From 65708b733365a64efde8e285481571fa00a983f5 Mon Sep 17 00:00:00 2001 From: Asra Ali Date: Wed, 15 Feb 2023 14:37:58 -0600 Subject: [PATCH] test: add docker based spport and start adding tests Signed-off-by: Asra Ali --- cli/slsa-verifier/main_regression_test.go | 154 +++++++++++++++++- .../main/workflow_dispatch.main.default | 4 + ...flow_dispatch.main.default.intoto.sigstore | 1 + verifiers/internal/gha/builder.go | 5 +- verifiers/internal/gha/provenance.go | 8 +- .../gha/slsaprovenance/v1.0/provenance.go | 9 +- 6 files changed, 170 insertions(+), 11 deletions(-) create mode 100644 cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default create mode 100644 cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default.intoto.sigstore diff --git a/cli/slsa-verifier/main_regression_test.go b/cli/slsa-verifier/main_regression_test.go index b7d1162fb..7632b2483 100644 --- a/cli/slsa-verifier/main_regression_test.go +++ b/cli/slsa-verifier/main_regression_test.go @@ -8,6 +8,7 @@ import ( "errors" "fmt" "io/ioutil" + "os" "path" "path/filepath" "strings" @@ -38,9 +39,12 @@ func pString(s string) *string { const TEST_DIR = "./testdata" var ( - GHA_ARTIFACT_PATH_BUILDERS = []string{"gha_go", "gha_generic"} - GHA_ARTIFACT_IMAGE_BUILDERS = []string{"gha_generic_container"} - GCB_ARTIFACT_IMAGE_BUILDERS = []string{"gcb_container"} + GHA_ARTIFACT_PATH_BUILDERS = []string{"gha_go", "gha_generic"} + // TODO(https://github.com/slsa-framework/slsa-verifier/issues/485): Merge this with + // GHA_ARTIFACT_PATH_BUILDERS. + GHA_ARTIFACT_DOCKER_BUILDERS = []string{"gha_docker-based"} + GHA_ARTIFACT_IMAGE_BUILDERS = []string{"gha_generic_container"} + GCB_ARTIFACT_IMAGE_BUILDERS = []string{"gcb_container"} ) func getBuildersAndVersions(t *testing.T, @@ -1231,3 +1235,147 @@ func Test_runVerifyGCBArtifactImage(t *testing.T) { }) } } + +// TODO(https://github.com/slsa-framework/slsa-verifier/issues/485): Version the test-cases +// when a version for the builder is released. +func Test_runVerifyGHADockerBased(t *testing.T) { + // We cannot use t.Setenv due to parallelized tests. + os.Setenv("SLSA_VERIFIER_EXPERIMENTAL", "1") + + t.Parallel() + + builder := "https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml" + tests := []struct { + name string + artifacts []string + source string + pbranch *string + ptag *string + pversiontag *string + pBuilderID *string + inputs map[string]string + err error + }{ + { + name: "valid main branch default", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + }, + { + name: "valid main branch default - invalid builderID", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/not-trusted.yml"), + err: serrors.ErrorUntrustedReusableWorkflow, + }, + { + name: "valid main branch set", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + pbranch: pString("main"), + }, + + { + name: "wrong branch master", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pbranch: pString("master"), + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + err: serrors.ErrorMismatchBranch, + }, + { + name: "wrong source append A", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-packageA", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + err: serrors.ErrorMismatchSource, + }, + { + name: "wrong source prepend A", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "Agithub.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + err: serrors.ErrorMismatchSource, + }, + { + name: "wrong source middle A", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/Aslsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + err: serrors.ErrorMismatchSource, + }, + { + name: "tag no match empty tag workflow_dispatch", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + ptag: pString("v1.2.3"), + err: serrors.ErrorMismatchTag, + }, + { + name: "versioned tag no match empty tag workflow_dispatch", + artifacts: []string{"workflow_dispatch.main.default"}, + source: "github.com/slsa-framework/example-package", + pBuilderID: pString("https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml"), + pversiontag: pString("v1"), + err: serrors.ErrorInvalidSemver, + }, + } + for _, tt := range tests { + tt := tt // Re-initializing variable so it is not changed while executing the closure below + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + checkVersions := getBuildersAndVersions(t, "", nil, GHA_ARTIFACT_DOCKER_BUILDERS) + + for _, v := range checkVersions { + testPath := filepath.Clean(filepath.Join(TEST_DIR, v, tt.artifacts[0])) + provenancePath := fmt.Sprintf("%s.intoto.sigstore", testPath) + + artifacts := make([]string, len(tt.artifacts)) + for i, artifact := range tt.artifacts { + artifacts[i] = filepath.Clean(filepath.Join(TEST_DIR, v, artifact)) + } + + // For each test, we run 2 sub-tests: + // 1. With the the full builderID including the semver in short form. + // 2. With the the full builderID including the semver in long form. + // 3. With only the name of the builder. + // 4. With no builder ID. + sv := path.Base(v) + builderIDs := []*string{ + pString(builder + "@" + sv), + pString(builder + "@refs/tags/" + sv), + pString(builder), + nil, + } + + // If builder ID is set, use it. + if tt.pBuilderID != nil { + builderIDs = []*string{tt.pBuilderID} + } + + for _, bid := range builderIDs { + cmd := verify.VerifyArtifactCommand{ + ProvenancePath: provenancePath, + SourceURI: tt.source, + SourceBranch: tt.pbranch, + BuilderID: bid, + SourceTag: tt.ptag, + SourceVersionTag: tt.pversiontag, + BuildWorkflowInputs: tt.inputs, + } + + // The outBuilderID is the actual builder ID from the provenance. + // This is always long form for the GHA builders. + _, err := cmd.Exec(context.Background(), artifacts) + if !errCmp(err, tt.err) { + t.Errorf("%v: %v", v, cmp.Diff(err, tt.err, cmpopts.EquateErrors())) + } + } + } + }) + } +} diff --git a/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default b/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default new file mode 100644 index 000000000..e4997faad --- /dev/null +++ b/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default @@ -0,0 +1,4 @@ +# Simple command for generating a file. +command = ["cp", ".github/configs-docker/config.toml", "config.toml"] +# Path to the file generated by the command above. +artifact_path = "config.toml" \ No newline at end of file diff --git a/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default.intoto.sigstore b/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default.intoto.sigstore new file mode 100644 index 000000000..1684c3f90 --- /dev/null +++ b/cli/slsa-verifier/testdata/gha_docker-based/main/workflow_dispatch.main.default.intoto.sigstore @@ -0,0 +1 @@ +{"mediaType":"application/vnd.dev.sigstore.bundle+json;version=0.1","verificationMaterial":{"x509CertificateChain":{"certificates":[{"rawBytes":"MIIEGDCCA52gAwIBAgIUCWYYB00jkc17bO6w0zT5xXq+dFAwCgYIKoZIzj0EAwMwNzEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MR4wHAYDVQQDExVzaWdzdG9yZS1pbnRlcm1lZGlhdGUwHhcNMjMwMjE1MTkyMzQ3WhcNMjMwMjE1MTkzMzQ3WjAAMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEx8lrDBT2vkXlGh3C5uRL7iICjn6H+GvOpAOU62WY3noxmTfLpxLVt9p9IOQqQbxZUKmkPiNZG678qrNzVolk06OCArwwggK4MA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDAzAdBgNVHQ4EFgQUCVhAiPdNj3YJds8kDQKqXJN0/4IwHwYDVR0jBBgwFoAU39Ppz1YkEZb5qNjpKFWixi4YZD8wgYYGA1UdEQEB/wR8MHqGeGh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1ld29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvYnVpbGRlcl9kb2NrZXItYmFzZWRfc2xzYTMueW1sQHJlZnMvaGVhZHMvbWFpbjA5BgorBgEEAYO/MAEBBCtodHRwczovL3Rva2VuLmFjdGlvbnMuZ2l0aHVidXNlcmNvbnRlbnQuY29tMB8GCisGAQQBg78wAQIEEXdvcmtmbG93X2Rpc3BhdGNoMDYGCisGAQQBg78wAQMEKDJkMDQ5ODIwMWEwN2FjMzRjOGNmMTI2MTY5NWE0YTU0NzE5ZDYyNDQwWQYKKwYBBAGDvzABBARLLmdpdGh1Yi93b3JrZmxvd3MvZTJlLmRvY2tlci1iYXNlZC53b3JrZmxvd19kaXNwYXRjaC5tYWluLmRlZmF1bHQuc2xzYTMueW1sMCwGCisGAQQBg78wAQUEHnNsc2EtZnJhbWV3b3JrL2V4YW1wbGUtcGFja2FnZTAdBgorBgEEAYO/MAEGBA9yZWZzL2hlYWRzL21haW4wgYsGCisGAQQB1nkCBAIEfQR7AHkAdwDdPTBqxscRMmMZHhyZZzcCokpeuN48rf+HinKALynujgAAAYZWiG93AAAEAwBIMEYCIQDQqeoEL5drqu8X0RsNCPH5umCTIkvYo4zhpjCYaBOKfAIhAPrmWh7LGpIFjT0+0V4RaSV5rumZOfWnET+sA/C6PvbQMAoGCCqGSM49BAMDA2kAMGYCMQDYSGRL9P2ddAF2yYfWpvqwOxlZ65xnB9qStBjDc4LWknQI4gbUwGINc0Y78GHEHVQCMQDYiUWP8c4VyqUHMtId97sBJsQqFL3SItCFQ17P2D3IJJ3xOJfUfGyGwIm+xhLTJiY="},{"rawBytes":"MIICGjCCAaGgAwIBAgIUALnViVfnU0brJasmRkHrn/UnfaQwCgYIKoZIzj0EAwMwKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTAeFw0yMjA0MTMyMDA2MTVaFw0zMTEwMDUxMzU2NThaMDcxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEeMBwGA1UEAxMVc2lnc3RvcmUtaW50ZXJtZWRpYXRlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE8RVS/ysH+NOvuDZyPIZtilgUF9NlarYpAd9HP1vBBH1U5CV77LSS7s0ZiH4nE7Hv7ptS6LvvR/STk798LVgMzLlJ4HeIfF3tHSaexLcYpSASr1kS0N/RgBJz/9jWCiXno3sweTAOBgNVHQ8BAf8EBAMCAQYwEwYDVR0lBAwwCgYIKwYBBQUHAwMwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU39Ppz1YkEZb5qNjpKFWixi4YZD8wHwYDVR0jBBgwFoAUWMAeX5FFpWapesyQoZMi0CrFxfowCgYIKoZIzj0EAwMDZwAwZAIwPCsQK4DYiZYDPIaDi5HFKnfxXx6ASSVmERfsynYBiX2X6SJRnZU84/9DZdnFvvxmAjBOt6QpBlc4J/0DxvkTCqpclvziL6BCCPnjdlIB3Pu3BxsPmygUY7Ii2zbdCdliiow="},{"rawBytes":"MIIB9zCCAXygAwIBAgIUALZNAPFdxHPwjeDloDwyYChAO/4wCgYIKoZIzj0EAwMwKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTAeFw0yMTEwMDcxMzU2NTlaFw0zMTEwMDUxMzU2NThaMCoxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjERMA8GA1UEAxMIc2lnc3RvcmUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAT7XeFT4rb3PQGwS4IajtLk3/OlnpgangaBclYpsYBr5i+4ynB07ceb3LP0OIOZdxexX69c5iVuyJRQ+Hz05yi+UF3uBWAlHpiS5sh0+H2GHE7SXrk1EC5m1Tr19L9gg92jYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRYwB5fkUWlZql6zJChkyLQKsXF+jAfBgNVHSMEGDAWgBRYwB5fkUWlZql6zJChkyLQKsXF+jAKBggqhkjOPQQDAwNpADBmAjEAj1nHeXZp+13NWBNa+EDsDP8G1WWg1tCMWP/WHPqpaVo0jhsweNFZgSs0eE7wYI4qAjEA2WB9ot98sIkoF3vZYdd3/VtWB5b9TNMea7Ix/stJ5TfcLLeABLE4BNJOsQ4vnBHJ"}]},"tlogEntries":[{"logIndex":"13419795","logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="},"kindVersion":{"kind":"intoto","version":"0.0.2"},"integratedTime":"1676489027","inclusionPromise":{"signedEntryTimestamp":"MEYCIQDez3v1XaIzk72GNAXRsmcPFWom2ZXmc25SF4u7ooLzIwIhALMz8n93pxGOYxUGDelyAzS6uNUJ2Ro6V7TlUFc8dYkk"},"canonicalizedBody":"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"}]},"dsseEnvelope":{"payload":"{"_type":"https://in-toto.io/Statement/v0.1","subject":[{"name":"config.toml","digest":{"sha256":"5d672b0dbb696a3289632bf241cc4bb08dbb32c3e9559ea7e9f96b0490209891"}}],"predicateType":"https://slsa.dev/provenance/v1.0?draft","predicate":{"buildDefinition":{"buildType":"https://slsa.dev/container-based-build/v0.1?draft","externalParameters":{"source":{"uri":"git+https://github.com/slsa-framework/example-package@refs/heads/main","digest":{"sha1":"2d0498201a07ac34c8cf1261695a4a54719d6244"}},"builderImage":{"uri":"bash@sha256:9e2ba52487d945504d250de186cb4fe2e3ba023ed2921dd6ac8b97ed43e76af9","digest":{"sha256":"9e2ba52487d945504d250de186cb4fe2e3ba023ed2921dd6ac8b97ed43e76af9"}},"configPath":".github/configs-docker/config.toml","buildConfig":{"ArtifactPath":"config.toml","Command":["cp",".github/configs-docker/config.toml","config.toml"]}},"resolvedDependencies":[{"uri":"git+https://github.com/slsa-framework/slsa-github-generator@refs/heads/main","digest":{"sha256":"8ce39a56163ad1a5f0531018beda42a4ac349b2af702701d55641ca9dd4425fc"}}],"systemParameters":{"GITHUB_EVENT_NAME":"workflow_dispatch","GITHUB_JOB":"provenance","GITHUB_REF":"refs/heads/main","GITHUB_REF_TYPE":"branch","GITHUB_REPOSITORY":"slsa-framework/example-package","GITHUB_RUN_ATTEMPT":"1","GITHUB_RUN_ID":4187381382,"GITHUB_RUN_NUMBER":20,"GITHUB_SHA":"2d0498201a07ac34c8cf1261695a4a54719d6244","GITHUB_WORKFLOW":".github/workflows/e2e.docker-based.workflow_dispatch.main.default.slsa3.yml","GITHUB_WORKFLOW_REF":"slsa-framework/example-package/.github/workflows/e2e.docker-based.workflow_dispatch.main.default.slsa3.yml@refs/heads/main","GITHUB_WORKFLOW_SHA":"2d0498201a07ac34c8cf1261695a4a54719d6244","IMAGE_OS":"ubuntu22","IMAGE_VERSION":"20230206.1","RUNNER_ARCH":"X64","RUNNER_NAME":"Hosted Agent","RUNNER_OS":"Linux","GITHUB_ACTOR_ID":"5194569","GITHUB_REPOSITORY_ID":"486325809","GITHUB_REPOSITORY_OWNER_ID":"80431187","GITHUB_EVENT_PAYLOAD":{"inputs":null,"organization":{"avatar_url":"https://avatars.githubusercontent.com/u/80431187?v=4","description":"Supply-chain Levels for Software Artifacts","events_url":"https://api.github.com/orgs/slsa-framework/events","hooks_url":"https://api.github.com/orgs/slsa-framework/hooks","id":80431187,"issues_url":"https://api.github.com/orgs/slsa-framework/issues","login":"slsa-framework","members_url":"https://api.github.com/orgs/slsa-framework/members{/member}","node_id":"MDEyOk9yZ2FuaXphdGlvbjgwNDMxMTg3","public_members_url":"https://api.github.com/orgs/slsa-framework/public_members{/member}","repos_url":"https://api.github.com/orgs/slsa-framework/repos","url":"https://api.github.com/orgs/slsa-framework"},"ref":"refs/heads/main","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/slsa-framework/example-package/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/slsa-framework/example-package/assignees{/user}","blobs_url":"https://api.github.com/repos/slsa-framework/example-package/git/blobs{/sha}","branches_url":"https://api.github.com/repos/slsa-framework/example-package/branches{/branch}","clone_url":"https://github.com/slsa-framework/example-package.git","collaborators_url":"https://api.github.com/repos/slsa-framework/example-package/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/slsa-framework/example-package/comments{/number}","commits_url":"https://api.github.com/repos/slsa-framework/example-package/commits{/sha}","compare_url":"https://api.github.com/repos/slsa-framework/example-package/compare/{base}...{head}","contents_url":"https://api.github.com/repos/slsa-framework/example-package/contents/{+path}","contributors_url":"https://api.github.com/repos/slsa-framework/example-package/contributors","created_at":"2022-04-27T19:30:43Z","default_branch":"main","deployments_url":"https://api.github.com/repos/slsa-framework/example-package/deployments","description":null,"disabled":false,"downloads_url":"https://api.github.com/repos/slsa-framework/example-package/downloads","events_url":"https://api.github.com/repos/slsa-framework/example-package/events","fork":false,"forks":10,"forks_count":10,"forks_url":"https://api.github.com/repos/slsa-framework/example-package/forks","full_name":"slsa-framework/example-package","git_commits_url":"https://api.github.com/repos/slsa-framework/example-package/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/slsa-framework/example-package/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/slsa-framework/example-package/git/tags{/sha}","git_url":"git://github.com/slsa-framework/example-package.git","has_discussions":false,"has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":true,"homepage":null,"hooks_url":"https://api.github.com/repos/slsa-framework/example-package/hooks","html_url":"https://github.com/slsa-framework/example-package","id":486325809,"is_template":false,"issue_comment_url":"https://api.github.com/repos/slsa-framework/example-package/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/slsa-framework/example-package/issues/events{/number}","issues_url":"https://api.github.com/repos/slsa-framework/example-package/issues{/number}","keys_url":"https://api.github.com/repos/slsa-framework/example-package/keys{/key_id}","labels_url":"https://api.github.com/repos/slsa-framework/example-package/labels{/name}","language":"Starlark","languages_url":"https://api.github.com/repos/slsa-framework/example-package/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"},"merges_url":"https://api.github.com/repos/slsa-framework/example-package/merges","milestones_url":"https://api.github.com/repos/slsa-framework/example-package/milestones{/number}","mirror_url":null,"name":"example-package","node_id":"R_kgDOHPy-MQ","notifications_url":"https://api.github.com/repos/slsa-framework/example-package/notifications{?since,all,participating}","open_issues":19,"open_issues_count":19,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/80431187?v=4","events_url":"https://api.github.com/users/slsa-framework/events{/privacy}","followers_url":"https://api.github.com/users/slsa-framework/followers","following_url":"https://api.github.com/users/slsa-framework/following{/other_user}","gists_url":"https://api.github.com/users/slsa-framework/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/slsa-framework","id":80431187,"login":"slsa-framework","node_id":"MDEyOk9yZ2FuaXphdGlvbjgwNDMxMTg3","organizations_url":"https://api.github.com/users/slsa-framework/orgs","received_events_url":"https://api.github.com/users/slsa-framework/received_events","repos_url":"https://api.github.com/users/slsa-framework/repos","site_admin":false,"starred_url":"https://api.github.com/users/slsa-framework/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/slsa-framework/subscriptions","type":"Organization","url":"https://api.github.com/users/slsa-framework"},"private":false,"pulls_url":"https://api.github.com/repos/slsa-framework/example-package/pulls{/number}","pushed_at":"2023-02-15T07:11:50Z","releases_url":"https://api.github.com/repos/slsa-framework/example-package/releases{/id}","size":4400,"ssh_url":"git@github.com:slsa-framework/example-package.git","stargazers_count":6,"stargazers_url":"https://api.github.com/repos/slsa-framework/example-package/stargazers","statuses_url":"https://api.github.com/repos/slsa-framework/example-package/statuses/{sha}","subscribers_url":"https://api.github.com/repos/slsa-framework/example-package/subscribers","subscription_url":"https://api.github.com/repos/slsa-framework/example-package/subscription","svn_url":"https://github.com/slsa-framework/example-package","tags_url":"https://api.github.com/repos/slsa-framework/example-package/tags","teams_url":"https://api.github.com/repos/slsa-framework/example-package/teams","topics":[],"trees_url":"https://api.github.com/repos/slsa-framework/example-package/git/trees{/sha}","updated_at":"2023-01-31T19:47:25Z","url":"https://api.github.com/repos/slsa-framework/example-package","visibility":"public","watchers":6,"watchers_count":6,"web_commit_signoff_required":true},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/5194569?v=4","events_url":"https://api.github.com/users/asraa/events{/privacy}","followers_url":"https://api.github.com/users/asraa/followers","following_url":"https://api.github.com/users/asraa/following{/other_user}","gists_url":"https://api.github.com/users/asraa/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/asraa","id":5194569,"login":"asraa","node_id":"MDQ6VXNlcjUxOTQ1Njk=","organizations_url":"https://api.github.com/users/asraa/orgs","received_events_url":"https://api.github.com/users/asraa/received_events","repos_url":"https://api.github.com/users/asraa/repos","site_admin":false,"starred_url":"https://api.github.com/users/asraa/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/asraa/subscriptions","type":"User","url":"https://api.github.com/users/asraa"},"workflow":".github/workflows/e2e.docker-based.workflow_dispatch.main.default.slsa3.yml"}}},"runDetails":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/builder_docker-based_slsa3.yml@refs/heads/main"},"metadata":{"invocationId":"https://github.com/slsa-framework/example-package/actions/runs/4187381382/attempts/1"}}}}","payloadType":"application/vnd.in-toto+json","signatures":[{"sig":"MEYCIQDPcCNR1c7eLr+Ogh/37huI6LRCQTeH0vDHNJegvP2cbwIhAKBjcwYoMszKtqQmZSC7lWGARLP9kfaGHIlVZIS5qvpc","keyid":""}]}} \ No newline at end of file diff --git a/verifiers/internal/gha/builder.go b/verifiers/internal/gha/builder.go index f39005827..423fc0e8e 100644 --- a/verifiers/internal/gha/builder.go +++ b/verifiers/internal/gha/builder.go @@ -23,8 +23,9 @@ var ( ) var defaultArtifactTrustedReusableWorkflows = map[string]bool{ - trustedBuilderRepository + "/.github/workflows/generator_generic_slsa3.yml": true, - trustedBuilderRepository + "/.github/workflows/builder_go_slsa3.yml": true, + trustedBuilderRepository + "/.github/workflows/generator_generic_slsa3.yml": true, + trustedBuilderRepository + "/.github/workflows/builder_go_slsa3.yml": true, + trustedBuilderRepository + "/.github/workflows/builder_docker-based_slsa3.yml": true, } var defaultContainerTrustedReusableWorkflows = map[string]bool{ diff --git a/verifiers/internal/gha/provenance.go b/verifiers/internal/gha/provenance.go index 7480dc2c5..7aa8c4389 100644 --- a/verifiers/internal/gha/provenance.go +++ b/verifiers/internal/gha/provenance.go @@ -85,7 +85,7 @@ func verifySourceURI(prov slsaprovenance.Provenance, expectedSourceURI string) e if err != nil { return err } - configURI, err := sourceFromURI(fullConfigURI, false) + configURI, err := sourceFromURI(fullConfigURI) if err != nil { return err } @@ -99,7 +99,7 @@ func verifySourceURI(prov slsaprovenance.Provenance, expectedSourceURI string) e if err != nil { return err } - materialURI, err := sourceFromURI(materialSourceURI, false) + materialURI, err := sourceFromURI(materialSourceURI) if err != nil { return err } @@ -119,13 +119,13 @@ func verifySourceURI(prov slsaprovenance.Provenance, expectedSourceURI string) e return nil } -func sourceFromURI(uri string, allowNotTag bool) (string, error) { +func sourceFromURI(uri string) (string, error) { if uri == "" { return "", fmt.Errorf("%w: empty uri", serrors.ErrorMalformedURI) } r := strings.SplitN(uri, "@", 2) - if len(r) < 2 && !allowNotTag { + if len(r) < 2 { return "", fmt.Errorf("%w: %s", serrors.ErrorMalformedURI, uri) } diff --git a/verifiers/internal/gha/slsaprovenance/v1.0/provenance.go b/verifiers/internal/gha/slsaprovenance/v1.0/provenance.go index 95c76877f..4eeef96f1 100644 --- a/verifiers/internal/gha/slsaprovenance/v1.0/provenance.go +++ b/verifiers/internal/gha/slsaprovenance/v1.0/provenance.go @@ -1,6 +1,7 @@ package v1 import ( + "encoding/json" "fmt" intoto "github.com/in-toto/in-toto-golang/in_toto" @@ -44,8 +45,12 @@ func (prov *ProvenanceV1) SourceURI() (string, error) { if !ok { return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "external parameters source") } - sourceRef, ok := source.(slsa1.ArtifactReference) - if !ok { + sourceBytes, err := json.Marshal(source) + if err != nil { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err) + } + var sourceRef slsa1.ArtifactReference + if err := json.Unmarshal(sourceBytes, &sourceRef); err != nil { return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "external parameters source type") } return sourceRef.URI, nil