diff --git a/cmd/root.go b/cmd/root.go index f9e37b0..b858736 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -12,7 +12,7 @@ import ( ) var rootCmd = &cobra.Command{ - Use: "ite-10-verifier", + Use: "attestation-verifier", RunE: verify, } @@ -20,6 +20,7 @@ var ( layoutPath string attestationsDir string parametersPath string + withResolver bool ) func Execute() { @@ -53,6 +54,14 @@ func init() { "Path to JSON file containing key-value string pairs for parameter substitution in the layout", ) + rootCmd.Flags().BoolVarP( + &withResolver, + "with-rd-resolver", + "r", + false, + "Enable resource descriptor (RD) resolver needed for cross-attestation checks", + ) + rootCmd.MarkFlagRequired("layout") rootCmd.MarkFlagRequired("attestations-directory") } @@ -107,5 +116,5 @@ func verify(cmd *cobra.Command, args []string) error { } } - return verifier.Verify(layout, attestations, parameters) + return verifier.Verify(layout, attestations, parameters, withResolver) } diff --git a/layouts/rd-resolution.yml b/layouts/rd-resolution.yml new file mode 100644 index 0000000..87aef18 --- /dev/null +++ b/layouts/rd-resolution.yml @@ -0,0 +1,50 @@ +# Run Command: cd test-data-rd-resolver; attestation-verifier -a . --layout ../layouts/rd-resolution.yml -r + +expires: "2024-10-10T12:23:22Z" +functionaries: + 1f57509240de3e7921e29a896553e7cf912441e17fe8cbd675457c7ba45bcee6: + keyType: "rsa" + scheme: "rsassa-pss-sha256" + keyIDHashAlgorithms: + - "sha256" + - "sha512" + keyVal: + public: "-----BEGIN PUBLIC KEY-----\nMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA0o+jumXN3tE2Xqx1qKjC\ngzCCvAPoOlzQlg+7OLGHnJbQgDxOyhFYMNqJ6cztb26NettmEpPtLDSnM5fPvHuH\nPVoPctzLqE9MiXdD1C7RHbjeSaUBxJV6wSGdAGzNa+8oxxG1ex4H7KHOXD8Mo61o\nitzViEw8knQNDhKHA/JWMnnhX07J1wF+EBWHpBsquAxZMLwy9h4uSlJjbK6TVZS8\nzLEtChVHLqF71px3/rRLlx6gyvSfqsVUd86JDrZtC+MHiq72nnx6N7+4wmSFB6ZQ\naBJvEemP9f54KgSMPLH4fZ63noQKUj9dnOZ+N4f0SGRIIvhN03/LlVA9ifkJBQml\nLKbiNWGAk92+C6NEp2Tj7olNsQ1zOTLzC27CJSWlDq9hSiS7LuaZUy7Gb3acX6Zf\nGZkwYXpXQPp/vM66InJcr5/T1iW/XhtmCHiRd7T24R4qDvS+Xuqv9+pJtHemCUpz\nWhn7N5L7Hr/t0b0SIUNd1PZzD4+lKElcAt99vCVlKQmVAgMBAAE=\n-----END PUBLIC KEY-----" + keyID: "1f57509240de3e7921e29a896553e7cf912441e17fe8cbd675457c7ba45bcee6" + 452e628a9a052784761275fe2eed15d7c0c8c8599bf1977879f130a568af5d8c: + keyType: "ecdsa" + scheme: "ecdsa-sha2-nistp256" + keyIDHashAlgorithms: + - "sha256" + - "sha512" + keyVal: + public: "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEB0TVhLF/u/aDcn+3ncIW2lfOKFn4\niCY36NC3k/oPa8sJ8X25H//mhY8/6fNyUh4PzjIEyHPOcr8CAi8dWyuRFQ==\n-----END PUBLIC KEY-----" + keyID: "452e628a9a052784761275fe2eed15d7c0c8c8599bf1977879f130a568af5d8c" +steps: + - name: "build" + expectedMaterials: + - "ALLOW git+https://github.com/marcelamelara/private-data-objects@refs/heads/generate-swsc-build-metadata" + - "DISALLOW *" + expectedProducts: + - "CREATE pdo_client_wawaka" + - "DISALLOW *" + expectedPredicates: + - predicateType: "https://slsa.dev/provenance/v0.2" + expectedAttributes: + - rule: "predicate.builder.id == 'https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v1.7.0'" + - rule: "predicate.invocation.configSource.uri == 'git+https://github.com/marcelamelara/private-data-objects@refs/heads/generate-swsc-build-metadata'" + - rule: "predicate.invocation.configSource.digest.sha1 == '87b74378e8c9ccf335a27ffcdc16636990254e1e'" + functionaries: + - "452e628a9a052784761275fe2eed15d7c0c8c8599bf1977879f130a568af5d8c" + - name: "evidence-collection" + expectedMaterials: + - "MATCH pdo_client_wawaka WITH products FROM build" + - "DISALLOW *" + expectedPredicates: + - predicateType: "https://in-toto.io/attestation/scai/attribute-report/v0.2" + expectedAttributes: + - rule: "size(predicate.attributes) >= 2" + - rule: "predicate.attributes.exists(a, a.attribute == 'HasSBOM')" + - rule: "predicate.attributes.exists(a, a.attribute == 'HasSLSA' && get_attestation(a.evidence) == 'https://slsa.dev/provenance/v0.2')" + functionaries: + - "1f57509240de3e7921e29a896553e7cf912441e17fe8cbd675457c7ba45bcee6" diff --git a/test-data-rd-resolver/build.452e628a.json b/test-data-rd-resolver/build.452e628a.json new file mode 100644 index 0000000..5eaa780 --- /dev/null +++ b/test-data-rd-resolver/build.452e628a.json @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"pdo_client_wawaka","digest":{"sha256":"9fb7ef552298f8fbad84604d06100e760b7b8c4cb4d6c4b727865f1f285d06ac"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v1.7.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator/generic@v1","invocation":{"configSource":{"uri":"git+https://github.com/marcelamelara/private-data-objects@refs/heads/generate-swsc-build-metadata","digest":{"sha1":"87b74378e8c9ccf335a27ffcdc16636990254e1e"},"entryPoint":".github/workflows/ci-swsc.yaml"},"parameters":{},"environment":{"github_actor":"marcelamelara","github_actor_id":"93797898","github_base_ref":"","github_event_name":"push","github_event_payload":{"after":"87b74378e8c9ccf335a27ffcdc16636990254e1e","base_ref":null,"before":"89ea53b883573c6295d8ee63ed7aa1e0d14c78e1","commits":[{"author":{"email":"marcela.melara@intel.com","name":"Marcela Melara","username":"marcelamelara"},"committer":{"email":"marcela.melara@intel.com","name":"Marcela Melara","username":"marcelamelara"},"distinct":true,"id":"87b74378e8c9ccf335a27ffcdc16636990254e1e","message":"Merge swsc metadata workflows\n\nSigned-off-by: Marcela Melara \u003cmarcela.melara@intel.com\u003e","timestamp":"2023-08-23T16:55:20-07:00","tree_id":"34699a554210ff93fc860f70e4a183e664b3725e","url":"https://github.com/marcelamelara/private-data-objects/commit/87b74378e8c9ccf335a27ffcdc16636990254e1e"}],"compare":"https://github.com/marcelamelara/private-data-objects/compare/89ea53b88357...87b74378e8c9","created":false,"deleted":false,"forced":false,"head_commit":{"author":{"email":"marcela.melara@intel.com","name":"Marcela Melara","username":"marcelamelara"},"committer":{"email":"marcela.melara@intel.com","name":"Marcela Melara","username":"marcelamelara"},"distinct":true,"id":"87b74378e8c9ccf335a27ffcdc16636990254e1e","message":"Merge swsc metadata workflows\n\nSigned-off-by: Marcela Melara \u003cmarcela.melara@intel.com\u003e","timestamp":"2023-08-23T16:55:20-07:00","tree_id":"34699a554210ff93fc860f70e4a183e664b3725e","url":"https://github.com/marcelamelara/private-data-objects/commit/87b74378e8c9ccf335a27ffcdc16636990254e1e"},"pusher":{"email":"marcela.melara@intel.com","name":"marcelamelara"},"ref":"refs/heads/generate-swsc-build-metadata","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/marcelamelara/private-data-objects/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/marcelamelara/private-data-objects/assignees{/user}","blobs_url":"https://api.github.com/repos/marcelamelara/private-data-objects/git/blobs{/sha}","branches_url":"https://api.github.com/repos/marcelamelara/private-data-objects/branches{/branch}","clone_url":"https://github.com/marcelamelara/private-data-objects.git","collaborators_url":"https://api.github.com/repos/marcelamelara/private-data-objects/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/marcelamelara/private-data-objects/comments{/number}","commits_url":"https://api.github.com/repos/marcelamelara/private-data-objects/commits{/sha}","compare_url":"https://api.github.com/repos/marcelamelara/private-data-objects/compare/{base}...{head}","contents_url":"https://api.github.com/repos/marcelamelara/private-data-objects/contents/{+path}","contributors_url":"https://api.github.com/repos/marcelamelara/private-data-objects/contributors","created_at":1580158534,"default_branch":"main","deployments_url":"https://api.github.com/repos/marcelamelara/private-data-objects/deployments","description":"The Private Data Objects lab provides technology for confidentiality-preserving, off-chain smart contracts.","disabled":false,"downloads_url":"https://api.github.com/repos/marcelamelara/private-data-objects/downloads","events_url":"https://api.github.com/repos/marcelamelara/private-data-objects/events","fork":true,"forks":1,"forks_count":1,"forks_url":"https://api.github.com/repos/marcelamelara/private-data-objects/forks","full_name":"marcelamelara/private-data-objects","git_commits_url":"https://api.github.com/repos/marcelamelara/private-data-objects/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/marcelamelara/private-data-objects/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/marcelamelara/private-data-objects/git/tags{/sha}","git_url":"git://github.com/marcelamelara/private-data-objects.git","has_discussions":false,"has_downloads":true,"has_issues":false,"has_pages":false,"has_projects":true,"has_wiki":true,"homepage":null,"hooks_url":"https://api.github.com/repos/marcelamelara/private-data-objects/hooks","html_url":"https://github.com/marcelamelara/private-data-objects","id":236592908,"is_template":false,"issue_comment_url":"https://api.github.com/repos/marcelamelara/private-data-objects/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/marcelamelara/private-data-objects/issues/events{/number}","issues_url":"https://api.github.com/repos/marcelamelara/private-data-objects/issues{/number}","keys_url":"https://api.github.com/repos/marcelamelara/private-data-objects/keys{/key_id}","labels_url":"https://api.github.com/repos/marcelamelara/private-data-objects/labels{/name}","language":"C++","languages_url":"https://api.github.com/repos/marcelamelara/private-data-objects/languages","license":{"key":"apache-2.0","name":"Apache License 2.0","node_id":"MDc6TGljZW5zZTI=","spdx_id":"Apache-2.0","url":"https://api.github.com/licenses/apache-2.0"},"master_branch":"main","merges_url":"https://api.github.com/repos/marcelamelara/private-data-objects/merges","milestones_url":"https://api.github.com/repos/marcelamelara/private-data-objects/milestones{/number}","mirror_url":null,"name":"private-data-objects","node_id":"MDEwOlJlcG9zaXRvcnkyMzY1OTI5MDg=","notifications_url":"https://api.github.com/repos/marcelamelara/private-data-objects/notifications{?since,all,participating}","open_issues":0,"open_issues_count":0,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/93797898?v=4","email":"marcela.melara@intel.com","events_url":"https://api.github.com/users/marcelamelara/events{/privacy}","followers_url":"https://api.github.com/users/marcelamelara/followers","following_url":"https://api.github.com/users/marcelamelara/following{/other_user}","gists_url":"https://api.github.com/users/marcelamelara/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/marcelamelara","id":93797898,"login":"marcelamelara","name":"marcelamelara","node_id":"U_kgDOBZc-Cg","organizations_url":"https://api.github.com/users/marcelamelara/orgs","received_events_url":"https://api.github.com/users/marcelamelara/received_events","repos_url":"https://api.github.com/users/marcelamelara/repos","site_admin":false,"starred_url":"https://api.github.com/users/marcelamelara/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/marcelamelara/subscriptions","type":"User","url":"https://api.github.com/users/marcelamelara"},"private":false,"pulls_url":"https://api.github.com/repos/marcelamelara/private-data-objects/pulls{/number}","pushed_at":1692834923,"releases_url":"https://api.github.com/repos/marcelamelara/private-data-objects/releases{/id}","size":3436,"ssh_url":"git@github.com:marcelamelara/private-data-objects.git","stargazers":0,"stargazers_count":0,"stargazers_url":"https://api.github.com/repos/marcelamelara/private-data-objects/stargazers","statuses_url":"https://api.github.com/repos/marcelamelara/private-data-objects/statuses/{sha}","subscribers_url":"https://api.github.com/repos/marcelamelara/private-data-objects/subscribers","subscription_url":"https://api.github.com/repos/marcelamelara/private-data-objects/subscription","svn_url":"https://github.com/marcelamelara/private-data-objects","tags_url":"https://api.github.com/repos/marcelamelara/private-data-objects/tags","teams_url":"https://api.github.com/repos/marcelamelara/private-data-objects/teams","topics":[],"trees_url":"https://api.github.com/repos/marcelamelara/private-data-objects/git/trees{/sha}","updated_at":"2022-01-11T01:04:34Z","url":"https://github.com/marcelamelara/private-data-objects","visibility":"public","watchers":0,"watchers_count":0,"web_commit_signoff_required":false},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/93797898?v=4","events_url":"https://api.github.com/users/marcelamelara/events{/privacy}","followers_url":"https://api.github.com/users/marcelamelara/followers","following_url":"https://api.github.com/users/marcelamelara/following{/other_user}","gists_url":"https://api.github.com/users/marcelamelara/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/marcelamelara","id":93797898,"login":"marcelamelara","node_id":"U_kgDOBZc-Cg","organizations_url":"https://api.github.com/users/marcelamelara/orgs","received_events_url":"https://api.github.com/users/marcelamelara/received_events","repos_url":"https://api.github.com/users/marcelamelara/repos","site_admin":false,"starred_url":"https://api.github.com/users/marcelamelara/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/marcelamelara/subscriptions","type":"User","url":"https://api.github.com/users/marcelamelara"}},"github_head_ref":"","github_ref":"refs/heads/generate-swsc-build-metadata","github_ref_type":"branch","github_repository_id":"236592908","github_repository_owner":"marcelamelara","github_repository_owner_id":"93797898","github_run_attempt":"1","github_run_id":"5957672580","github_run_number":"10","github_sha1":"87b74378e8c9ccf335a27ffcdc16636990254e1e"}},"metadata":{"buildInvocationID":"5957672580-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/marcelamelara/private-data-objects@refs/heads/generate-swsc-build-metadata","digest":{"sha1":"87b74378e8c9ccf335a27ffcdc16636990254e1e"}}]}}","signatures":[{"keyid":"","sig":"MEUCIBtd37BUemlRGSAtupB5MUNpuoY3M8sjizO8vNoF/XRzAiEA6MbwPr+GkoQ7O/gAzGqMO3YVRfnOn2CSrme14Y/Vq7g=","cert":"-----BEGIN CERTIFICATE-----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\nwZPYsMpbWP4k8SXbi6NaBqwAAnAl3s+w3qbR/Nt2wtoPwA==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file diff --git a/test-data-rd-resolver/evidence-collection.1f575092.json b/test-data-rd-resolver/evidence-collection.1f575092.json new file mode 100644 index 0000000..e8b2cd2 --- /dev/null +++ b/test-data-rd-resolver/evidence-collection.1f575092.json @@ -0,0 +1 @@ +{"payloadType":"application/vnd.in-toto+json","payload":"eyJfdHlwZSI6Imh0dHBzOi8vaW4tdG90by5pby9TdGF0ZW1lbnQvdjEiLCJzdWJqZWN0IjpbeyJuYW1lIjoicGRvX2NsaWVudF93YXdha2EiLCJkaWdlc3QiOnsic2hhMjU2IjoiOWZiN2VmNTUyMjk4ZjhmYmFkODQ2MDRkMDYxMDBlNzYwYjdiOGM0Y2I0ZDZjNGI3Mjc4NjVmMWYyODVkMDZhYyJ9fV0sInByZWRpY2F0ZVR5cGUiOiJodHRwczovL2luLXRvdG8uaW8vYXR0ZXN0YXRpb24vc2NhaS9hdHRyaWJ1dGUtcmVwb3J0L3YwLjIiLCJwcmVkaWNhdGUiOnsiYXR0cmlidXRlcyI6W3siYXR0cmlidXRlIjoiSGFzU0JPTSIsImV2aWRlbmNlIjp7ImRpZ2VzdCI6eyJzaGEyNTYiOiJkOTVjMjAyZTBlNDAyMTQ0ZDYzNjM4MGU5ODJlYWZmNTRiZTU1OWI1NTU5OGZkMTgwNzFlOTZkNmYzYTdlYjAzIn0sImRvd25sb2FkTG9jYXRpb24iOiJodHRwczovL2dpdGh1Yi5jb20vbWFyY2VsYW1lbGFyYS9wcml2YXRlLWRhdGEtb2JqZWN0cy9zdWl0ZXMvMTU0MTc3MjYxNDIvYXJ0aWZhY3RzLzg4MDQwMzM5NSIsIm1lZGlhVHlwZSI6ImFwcGxpY2F0aW9uL3NwZHgranNvbiIsIm5hbWUiOiJwZG9fY2xpZW50X3dhd2FrYS5zcGR4Lmpzb24ifX0seyJhdHRyaWJ1dGUiOiJIYXNTTFNBIiwiZXZpZGVuY2UiOnsiZGlnZXN0Ijp7InNoYTI1NiI6Ijk0ZDE4NzE2ZWU0NDEyMTc1YzVkOWRhMWNlNTA5NDcxNTNlMDljNDc2MmY5MDQ0YWY2ZjJkNjgyOGIxMmZlNWIifSwiZG93bmxvYWRMb2NhdGlvbiI6Imh0dHBzOi8vZ2l0aHViLmNvbS9tYXJjZWxhbWVsYXJhL3ByaXZhdGUtZGF0YS1vYmplY3RzL3N1aXRlcy8xNTQxNzcyNjE0Mi9hcnRpZmFjdHMvODgwNDAzMzkyL3Bkb19jbGllbnRfd2F3YWthLnNsc2EuaW50b3RvLmpzb25sIiwibWVkaWFUeXBlIjoiYXBwbGljYXRpb24vdm5kLmluLXRvdG8rZHNzZSIsIm5hbWUiOiJidWlsZC40NTJlNjI4YS5qc29uIn19XX19","signatures":[{"keyid":"1f57509240de3e7921e29a896553e7cf912441e17fe8cbd675457c7ba45bcee6","sig":"W5terKjmGajjJLl1mXNgPzIamE0omBDUkXzmrAVZMI51FTvv2a4ixCRAMSvT8qxcs/ZvqMXxMGQV5RR2x1aF1JkBLSP9nY7mQLcl7GYJ6E+KltLMgO3Bw9b4vXDp/JZ1y8Dby+rUEt0umehFJYj0Yl8/ndhWVK6QNMzrCDghK8TdZ8N1+HhyxewOYdP2i+yrM0Ll0Q0DiXO4r5SPGgGTY6BWe5Sjc2HNrt+J6fJcnXpvfCBlTAuG0pGNDbIS9jtimsh+AKAlpdcgJUPGpL3baTRW/1liyzVmtJtIrTl1kDDm/rzKmFi/OaMS6Vwm4RkaEkXaLPYpzz6pBaCHm8JxNJVjijtoTrNyuhEyHuvZW3o/p9/TmW9O6kyDc8Sybk5S8iWca0N3sLAfIsQw4968PHo4p7jf/bWWPFhSag2nIz4fKdiLXSzaDvxKtuuMfa6BG15j45Nwqq6qcKf2ZssYP4sjyuzYcJe912HFPPo8ZasQmFBcuBMhpu7NHU6yP/19"}]} \ No newline at end of file diff --git a/verifier/resolver.go b/verifier/resolver.go new file mode 100644 index 0000000..6333c69 --- /dev/null +++ b/verifier/resolver.go @@ -0,0 +1,160 @@ +package verifier + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "os" + + "github.com/google/cel-go/cel" + "github.com/google/cel-go/common/types" + "github.com/google/cel-go/common/types/ref" + attestationv1 "github.com/in-toto/attestation/go/v1" + "github.com/secure-systems-lab/go-securesystemslib/dsse" + log "github.com/sirupsen/logrus" + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/types/known/structpb" +) + +func addResourceDescriptorResolver(env *cel.Env) (*cel.Env, error) { + return env.Extend( + cel.Types(&attestationv1.ResourceDescriptor{}), + cel.Variable("rd", cel.ObjectType("in_toto_attestation.v1.ResourceDescriptor")), + cel.Function("get_attestation", + cel.Overload("get_attestation_resourcedescriptor", + []*cel.Type{cel.ObjectType("google.protobuf.Struct")}, + cel.StringType, + cel.UnaryBinding(func(pbStruct ref.Val) ref.Val { + st, err := getDSSEStatementPayload(pbStruct.Value().(*structpb.Struct)) + if err != nil { + log.Infof("get_attestation failed: %s", err) + return types.String("") + } + + log.Infof("Got attestation. Returning to rule eval...") + + // FIXME: want to return any Statement field for rule eval + return types.String(st.GetPredicateType()) + }, // func + ), // Binding + ), // Overload + ), // Function + ) // Extend +} + +func pbStructToRD(s *structpb.Struct) (*attestationv1.ResourceDescriptor, error) { + structJSON, err := protojson.Marshal(s) + if err != nil { + return nil, err + } + + rd := &attestationv1.ResourceDescriptor{} + err = protojson.Unmarshal(structJSON, rd) + if err != nil { + return nil, err + } + + if err := rd.Validate(); err != nil { + return nil, fmt.Errorf("parsed invalid RD: %w", err) + } + + return rd, nil +} + +func resolveResourceDescriptor(s *structpb.Struct, expectedType string) (bytes, error) { + rd, err := pbStructToRD(s) + if err != nil { + log.Infof("Conversion from structpb.Struct failed: %s", err) + return nil, err + } + + // FIXME: don't assume the full filepath is described in the RD name field + name := rd.GetName() + + log.Infof("Resolving file resource '%s' of type '%s'...", name, rd.GetMediaType()) + + fileBytes, err := os.ReadFile(name) + if err != nil { + return nil, err + } + + // check that the opened file matches the expected attestation + if len(rd.GetDigest()) > 0 { + // FIXME: support other algorithms + if !matchDigest(rd.GetDigest()["sha256"], fileBytes) { + return nil, fmt.Errorf("opened file does not match expected attestation in resource descriptor") + } + + log.Info("File resource integrity verified.") + } + + if rd.GetMediaType() != expectedType { + return nil, fmt.Errorf("resolved rd mediaType does not match expected type") + } + + return fileBytes, nil +} + +// copied from https://github.com/in-toto/scai-demos/blob/main/scai-gen/cmd/check.go +func getDSSEStatementPayload(s *structpb.Struct) (*attestationv1.Statement, error) { + envBytes, err := resolveResourceDescriptor(s, "application/vnd.in-toto+dsse") + if err != nil { + return nil, fmt.Errorf("resolver failed: %w", err) + } + + // TODO: check envelope signature + + // now, let's get the Statement + envelope := &dsse.Envelope{} + if err := json.Unmarshal(envBytes, envelope); err != nil { + return nil, err + } + + stBytes, err := envelope.DecodeB64Payload() + if err != nil { + return nil, fmt.Errorf("failed to decode DSSE payload: %w", err) + } + + statement := &attestationv1.Statement{} + if err = protojson.Unmarshal(stBytes, statement); err != nil { + return nil, fmt.Errorf("failed to unmarshal Statement: %w", err) + } + + /* FIXME: add back in + Fails with current test data because of outdated SLSA Provenance generation. + if err = statement.Validate(); err != nil { + return nil, fmt.Errorf("invalid Statement: %w", err) + } + */ + + return statement, nil +} + +func getJsonData() { + mediaType, envBytes, err := resolveResourceDescriptor(s, "application/json") + if err != nil { + return nil, fmt.Errorf("resolver failed: %w", err) + } +} + +// copied from https://github.com/in-toto/scai-demos/blob/main/scai-gen/policy/checks.go +func matchDigest(hexDigest string, blob []byte) bool { + digest := genSHA256(blob) + + decoded, err := hex.DecodeString(hexDigest) + if err != nil { + log.Info("Problem decoding hex-encoded digest to match") + return false + } + + return bytes.Equal(decoded, digest) +} + +// copied from https://github.com/in-toto/scai-demos/blob/main/scai-gen/policy/checks.go +func genSHA256(bytes []byte) []byte { + h := sha256.New() + h.Write(bytes) + return h.Sum(nil) +} diff --git a/verifier/verifier.go b/verifier/verifier.go index 13bc4ba..63e21a7 100644 --- a/verifier/verifier.go +++ b/verifier/verifier.go @@ -17,7 +17,7 @@ import ( "google.golang.org/protobuf/encoding/protojson" ) -func Verify(layout *Layout, attestations map[string]*dsse.Envelope, parameters map[string]string) error { +func Verify(layout *Layout, attestations map[string]*dsse.Envelope, parameters map[string]string, withRDResolver bool) error { log.Info("Verifying layout expiry...") expiry, err := time.Parse(time.RFC3339, layout.Expires) if err != nil { @@ -83,6 +83,14 @@ func Verify(layout *Layout, attestations map[string]*dsse.Envelope, parameters m return err } + // Once stable merge with getCELEnv() + if withRDResolver { + if env, err = addResourceDescriptorResolver(env); err != nil { + return fmt.Errorf("failed to add RD resolver: %w", err) + } + log.Info("Enabled RD resolver.") + } + for _, step := range layout.Steps { stepStatements, ok := claims[step.Name] if !ok {