Debian Codegraph @

manifest/schema1/manifest.go

raw
1 package schema1
2
3 import (
4 "encoding/json"
5 "fmt"
6
7 "github.com/docker/distribution"
8 "github.com/docker/distribution/manifest"
9 "github.com/docker/libtrust"
10 "github.com/opencontainers/go-digest"
11 )
12
13 const (
14 // MediaTypeManifest specifies the mediaType for the current version. Note
15 // that for schema version 1, the the media is optionally "application/json".
16 MediaTypeManifest = "application/vnd.docker.distribution.manifest.v1+json"
17 // MediaTypeSignedManifest specifies the mediatype for current SignedManifest version
18 MediaTypeSignedManifest = "application/vnd.docker.distribution.manifest.v1+prettyjws"
19 // MediaTypeManifestLayer specifies the media type for manifest layers
20 MediaTypeManifestLayer = "application/vnd.docker.container.image.rootfs.diff+x-gtar"
21 )
22
23 var (
24 // SchemaVersion provides a pre-initialized version structure for this
25 // packages version of the manifest.
26 SchemaVersion = manifest.Versioned{
27 SchemaVersion: 1,
28 }
29 )
30
31 func init() {
32 schema1Func := func(b []byte) (distribution.Manifest, distribution.Descriptor, error) {
33 sm := new(SignedManifest)
34 err := sm.UnmarshalJSON(b)
35 if err != nil {
36 return nil, distribution.Descriptor{}, err
37 }
38
39 desc := distribution.Descriptor{
40 Digest: digest.FromBytes(sm.Canonical),
41 Size: int64(len(sm.Canonical)),
42 MediaType: MediaTypeSignedManifest,
43 }
44 return sm, desc, err
45 }
46 err := distribution.RegisterManifestSchema(MediaTypeSignedManifest, schema1Func)
47 if err != nil {
48 panic(fmt.Sprintf("Unable to register manifest: %s", err))
49 }
50 err = distribution.RegisterManifestSchema("", schema1Func)
51 if err != nil {
52 panic(fmt.Sprintf("Unable to register manifest: %s", err))
53 }
54 err = distribution.RegisterManifestSchema("application/json", schema1Func)
55 if err != nil {
56 panic(fmt.Sprintf("Unable to register manifest: %s", err))
57 }
58 }
59
60 // FSLayer is a container struct for BlobSums defined in an image manifest
61 type FSLayer struct {
62 // BlobSum is the tarsum of the referenced filesystem image layer
63 BlobSum digest.Digest `json:"blobSum"`
64 }
65
66 // History stores unstructured v1 compatibility information
67 type History struct {
68 // V1Compatibility is the raw v1 compatibility information
69 V1Compatibility string `json:"v1Compatibility"`
70 }
71
72 // Manifest provides the base accessible fields for working with V2 image
73 // format in the registry.
74 type Manifest struct {
75 manifest.Versioned
76
77 // Name is the name of the image's repository
78 Name string `json:"name"`
79
80 // Tag is the tag of the image specified by this manifest
81 Tag string `json:"tag"`
82
83 // Architecture is the host architecture on which this image is intended to
84 // run
85 Architecture string `json:"architecture"`
86
87 // FSLayers is a list of filesystem layer blobSums contained in this image
88 FSLayers []FSLayer `json:"fsLayers"`
89
90 // History is a list of unstructured historical data for v1 compatibility
91 History []History `json:"history"`
92 }
93
94 // SignedManifest provides an envelope for a signed image manifest, including
95 // the format sensitive raw bytes.
96 type SignedManifest struct {
97 Manifest
98
99 // Canonical is the canonical byte representation of the ImageManifest,
100 // without any attached signatures. The manifest byte
101 // representation cannot change or it will have to be re-signed.
102 Canonical []byte `json:"-"`
103
104 // all contains the byte representation of the Manifest including signatures
105 // and is returned by Payload()
106 all []byte
107 }
108
109 // UnmarshalJSON populates a new SignedManifest struct from JSON data.
110 func (sm *SignedManifest) UnmarshalJSON(b []byte) error {
111 sm.all = make([]byte, len(b))
112 // store manifest and signatures in all
113 copy(sm.all, b)
114
115 jsig, err := libtrust.ParsePrettySignature(b, "signatures")
116 if err != nil {
117 return err
118 }
119
120 // Resolve the payload in the manifest.
121 bytes, err := jsig.Payload()
122 if err != nil {
123 return err
124 }
125
126 // sm.Canonical stores the canonical manifest JSON
127 sm.Canonical = make([]byte, len(bytes))
128 copy(sm.Canonical, bytes)
129
130 // Unmarshal canonical JSON into Manifest object
131 var manifest Manifest
132 if err := json.Unmarshal(sm.Canonical, &manifest); err != nil {
133 return err
134 }
135
136 sm.Manifest = manifest
137
138 return nil
139 }
140
141 // References returns the descriptors of this manifests references
142 func (sm SignedManifest) References() []distribution.Descriptor {
143 dependencies := make([]distribution.Descriptor, len(sm.FSLayers))
144 for i, fsLayer := range sm.FSLayers {
145 dependencies[i] = distribution.Descriptor{
146 MediaType: "application/vnd.docker.container.image.rootfs.diff+x-gtar",
147 Digest: fsLayer.BlobSum,
148 }
149 }
150
151 return dependencies
152
153 }
154
155 // MarshalJSON returns the contents of raw. If Raw is nil, marshals the inner
156 // contents. Applications requiring a marshaled signed manifest should simply
157 // use Raw directly, since the the content produced by json.Marshal will be
158 // compacted and will fail signature checks.
159 func (sm *SignedManifest) MarshalJSON() ([]byte, error) {
160 if len(sm.all) > 0 {
161 return sm.all, nil
162 }
163
164 // If the raw data is not available, just dump the inner content.
165 return json.Marshal(&sm.Manifest)
166 }
167
168 // Payload returns the signed content of the signed manifest.
169 func (sm SignedManifest) Payload() (string, []byte, error) {
170 return MediaTypeSignedManifest, sm.all, nil
171 }
172
173 // Signatures returns the signatures as provided by
174 // (*libtrust.JSONSignature).Signatures. The byte slices are opaque jws
175 // signatures.
176 func (sm *SignedManifest) Signatures() ([][]byte, error) {
177 jsig, err := libtrust.ParsePrettySignature(sm.all, "signatures")
178 if err != nil {
179 return nil, err
180 }
181
182 // Resolve the payload in the manifest.
183 return jsig.Signatures()
184 }