diff --git a/verifiers/internal/gha/provenance.go b/verifiers/internal/gha/provenance.go index b3fcc03..8233fc7 100644 --- a/verifiers/internal/gha/provenance.go +++ b/verifiers/internal/gha/provenance.go @@ -3,7 +3,6 @@ package gha import ( "context" "crypto/x509" - "encoding/base64" "encoding/json" "fmt" "os" @@ -11,7 +10,6 @@ import ( "golang.org/x/mod/semver" - intoto "github.com/in-toto/in-toto-golang/in_toto" dsselib "github.com/secure-systems-lab/go-securesystemslib/dsse" "github.com/sigstore/rekor/pkg/generated/client" "github.com/sigstore/rekor/pkg/generated/models" @@ -19,6 +17,10 @@ import ( "github.com/slsa-framework/slsa-github-generator/signing/envelope" serrors "github.com/slsa-framework/slsa-verifier/v2/errors" "github.com/slsa-framework/slsa-verifier/v2/options" + "github.com/slsa-framework/slsa-verifier/v2/verifiers/internal/gha/slsaprovenance" + + // Load provenance types. + _ "github.com/slsa-framework/slsa-verifier/v2/verifiers/internal/gha/slsaprovenance/v0.2" ) // SignedAttestation contains a signed DSSE envelope @@ -38,29 +40,17 @@ func EnvelopeFromBytes(payload []byte) (env *dsselib.Envelope, err error) { return } -func provenanceFromEnv(env *dsselib.Envelope) (prov *intoto.ProvenanceStatement, err error) { - if env.PayloadType != "application/vnd.in-toto+json" { - return nil, fmt.Errorf("%w: expected payload type 'application/vnd.in-toto+json', got '%s'", - serrors.ErrorInvalidDssePayload, env.PayloadType) - } - pyld, err := base64.StdEncoding.DecodeString(env.Payload) - if err != nil { - return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err.Error()) - } - prov = &intoto.ProvenanceStatement{} - if err := json.Unmarshal(pyld, prov); err != nil { - return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err.Error()) - } - return -} - // Verify Builder ID in provenance statement. // This function does an exact comparison, and expects certBuilderID to be the full // `name@refs/tags/`. -func verifyBuilderIDExactMatch(prov *intoto.ProvenanceStatement, certBuilderID string) error { - if certBuilderID != prov.Predicate.Builder.ID { +func verifyBuilderIDExactMatch(prov slsaprovenance.Provenance, certBuilderID string) error { + builderID, err := prov.BuilderID() + if err != nil { + return err + } + if certBuilderID != builderID { return fmt.Errorf("%w: expected '%s' in builder.id, got '%s'", serrors.ErrorMismatchBuilderID, - certBuilderID, prov.Predicate.Builder.ID) + certBuilderID, builderID) } return nil @@ -80,7 +70,7 @@ func asURI(s string) string { } // Verify source URI in provenance statement. -func verifySourceURI(prov *intoto.ProvenanceStatement, expectedSourceURI string) error { +func verifySourceURI(prov slsaprovenance.Provenance, expectedSourceURI string) error { source := asURI(expectedSourceURI) // We expect github.com URIs only. @@ -90,34 +80,39 @@ func verifySourceURI(prov *intoto.ProvenanceStatement, expectedSourceURI string) } // Verify source from ConfigSource field. - configURI, err := sourceFromURI(prov.Predicate.Invocation.ConfigSource.URI, false) + fullConfigURI, err := prov.ConfigURI() + if err != nil { + return err + } + configURI, err := sourceFromURI(fullConfigURI, false) if err != nil { return err } if configURI != source { return fmt.Errorf("%w: expected source '%s' in configSource.uri, got '%s'", serrors.ErrorMismatchSource, - source, prov.Predicate.Invocation.ConfigSource.URI) + source, fullConfigURI) } // Verify source from material section. - if len(prov.Predicate.Materials) == 0 { - return fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "no material") + materialSourceURI, err := prov.SourceURI() + if err != nil { + return err } - materialURI, err := sourceFromURI(prov.Predicate.Materials[0].URI, false) + materialURI, err := sourceFromURI(materialSourceURI, false) if err != nil { return err } if materialURI != source { return fmt.Errorf("%w: expected source '%s' in material section, got '%s'", serrors.ErrorMismatchSource, - source, prov.Predicate.Materials[0].URI) + source, materialSourceURI) } // Last, verify that both fields match. // We use the full URI to match on the tag as well. - if prov.Predicate.Invocation.ConfigSource.URI != prov.Predicate.Materials[0].URI { + if fullConfigURI != materialSourceURI { return fmt.Errorf("%w: material and config URIs do not match: '%s' != '%s'", serrors.ErrorInvalidDssePayload, - prov.Predicate.Invocation.ConfigSource.URI, prov.Predicate.Materials[0].URI) + fullConfigURI, materialSourceURI) } return nil @@ -141,12 +136,13 @@ func sourceFromURI(uri string, allowNotTag bool) (string, error) { } // Verify SHA256 Subject Digest from the provenance statement. -func verifySha256Digest(prov *intoto.ProvenanceStatement, expectedHash string) error { - if len(prov.Subject) == 0 { - return fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "no subjects") +func verifySha256Digest(prov slsaprovenance.Provenance, expectedHash string) error { + subjects, err := prov.Subjects() + if err != nil { + return err } - for _, subject := range prov.Subject { + for _, subject := range subjects { digestSet := subject.Digest hash, exists := digestSet["sha256"] if !exists { @@ -185,16 +181,12 @@ func VerifyProvenanceSignature(ctx context.Context, trustedRoot *TrustedRoot, fmt.Fprintf(os.Stderr, "No certificate provided, trying Redis search index to find entries by subject digest\n") // Verify the provenance and return the signing certificate. - signedAttestation, err := SearchValidSignedAttestation(ctx, artifactHash, provenance, rClient, trustedRoot) - if err != nil { - return nil, err - } - - return signedAttestation, nil + return SearchValidSignedAttestation(ctx, artifactHash, + provenance, rClient, trustedRoot) } func VerifyProvenance(env *dsselib.Envelope, provenanceOpts *options.ProvenanceOpts) error { - prov, err := provenanceFromEnv(env) + prov, err := slsaprovenance.ProvenanceFromEnvelope(env) if err != nil { return err } @@ -247,14 +239,9 @@ func VerifyProvenance(env *dsselib.Envelope, provenanceOpts *options.ProvenanceO return nil } -func VerifyWorkflowInputs(prov *intoto.ProvenanceStatement, inputs map[string]string) error { - environment, ok := prov.Predicate.Invocation.Environment.(map[string]interface{}) - if !ok { - return fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type") - } - +func VerifyWorkflowInputs(prov slsaprovenance.Provenance, inputs map[string]string) error { // Verify it's a workflow_dispatch trigger. - triggerName, err := getAsString(environment, "github_event_name") + triggerName, err := prov.GetStringFromEnvironment("github_event_name") if err != nil { return err } @@ -264,21 +251,11 @@ func VerifyWorkflowInputs(prov *intoto.ProvenanceStatement, inputs map[string]st } // Assume no nested level. - payload, err := getEventPayload(environment) + pyldInputs, err := prov.GetInputs() if err != nil { return err } - payloadInputs, err := getAsAny(payload, "inputs") - if err != nil { - return fmt.Errorf("%w: error retrieving 'inputs': %v", serrors.ErrorInvalidDssePayload, err) - } - - pyldInputs, ok := payloadInputs.(map[string]interface{}) - if !ok { - return fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type inputs") - } - // Verify all inputs. for k, v := range inputs { value, err := getAsString(pyldInputs, k) @@ -295,7 +272,7 @@ func VerifyWorkflowInputs(prov *intoto.ProvenanceStatement, inputs map[string]st return nil } -func VerifyBranch(prov *intoto.ProvenanceStatement, expectedBranch string) error { +func VerifyBranch(prov slsaprovenance.Provenance, expectedBranch string) error { branch, err := getBranch(prov) if err != nil { return err @@ -309,7 +286,7 @@ func VerifyBranch(prov *intoto.ProvenanceStatement, expectedBranch string) error return nil } -func VerifyTag(prov *intoto.ProvenanceStatement, expectedTag string) error { +func VerifyTag(prov slsaprovenance.Provenance, expectedTag string) error { tag, err := getTag(prov) if err != nil { return err @@ -323,7 +300,7 @@ func VerifyTag(prov *intoto.ProvenanceStatement, expectedTag string) error { return nil } -func VerifyVersionedTag(prov *intoto.ProvenanceStatement, expectedTag string) error { +func VerifyVersionedTag(prov slsaprovenance.Provenance, expectedTag string) error { // Validate and canonicalize the provenance tag. if !semver.IsValid(expectedTag) { return fmt.Errorf("%s: %w", expectedTag, serrors.ErrorInvalidSemver) @@ -402,8 +379,17 @@ func extractFromVersion(v string, i int) (string, error) { return parts[i], nil } -func getAsString(environment map[string]interface{}, field string) (string, error) { - value, ok := environment[field] +func getAsAny(payload map[string]any, field string) (any, error) { + value, ok := payload[field] + if !ok { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, + fmt.Sprintf("payload type for %s", field)) + } + return value, nil +} + +func getAsString(pyld map[string]interface{}, field string) (string, error) { + value, ok := pyld[field] if !ok { return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, fmt.Sprintf("environment type for %s", field)) @@ -416,19 +402,10 @@ func getAsString(environment map[string]interface{}, field string) (string, erro return i, nil } -func getAsAny(environment map[string]any, field string) (any, error) { - value, ok := environment[field] - if !ok { - return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, - fmt.Sprintf("environment type for %s", field)) - } - return value, nil -} - -func getEventPayload(environment map[string]interface{}) (map[string]interface{}, error) { - eventPayload, ok := environment["github_event_payload"] - if !ok { - return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type event payload") +func getEventPayload(prov slsaprovenance.Provenance) (map[string]interface{}, error) { + eventPayload, err := prov.GetAnyFromEnvironment("github_event_payload") + if err != nil { + return nil, err } payload, ok := eventPayload.(map[string]interface{}) @@ -439,8 +416,8 @@ func getEventPayload(environment map[string]interface{}) (map[string]interface{} return payload, nil } -func getBaseRef(environment map[string]interface{}) (string, error) { - baseRef, err := getAsString(environment, "github_base_ref") +func getBaseRef(prov slsaprovenance.Provenance) (string, error) { + baseRef, err := prov.GetStringFromEnvironment("github_base_ref") if err != nil { return "", err } @@ -453,7 +430,7 @@ func getBaseRef(environment map[string]interface{}) (string, error) { // Look at the event payload instead. // We don't do that for all triggers because the payload // is event-specific; and only the `push` event seems to have a `base_ref`. - eventName, err := getAsString(environment, "github_event_name") + eventName, err := prov.GetStringFromEnvironment("github_event_name") if err != nil { return "", err } @@ -462,7 +439,7 @@ func getBaseRef(environment map[string]interface{}) (string, error) { return "", nil } - payload, err := getEventPayload(environment) + payload, err := getEventPayload(prov) if err != nil { return "", err } @@ -481,8 +458,8 @@ func getBaseRef(environment map[string]interface{}) (string, error) { return v, nil } -func getTargetCommittish(environment map[string]interface{}) (string, error) { - eventName, err := getAsString(environment, "github_event_name") +func getTargetCommittish(prov slsaprovenance.Provenance) (string, error) { + eventName, err := prov.GetStringFromEnvironment("github_event_name") if err != nil { return "", err } @@ -491,7 +468,7 @@ func getTargetCommittish(environment map[string]interface{}) (string, error) { return "", nil } - payload, err := getEventPayload(environment) + payload, err := getEventPayload(prov) if err != nil { return "", err } @@ -515,25 +492,20 @@ func getTargetCommittish(environment map[string]interface{}) (string, error) { return "refs/heads/" + branch, nil } -func getBranchForTag(environment map[string]interface{}) (string, error) { +func getBranchForTag(prov slsaprovenance.Provenance) (string, error) { // First try the base_ref. - branch, err := getBaseRef(environment) + branch, err := getBaseRef(prov) if branch != "" || err != nil { return branch, err } // Second try the target comittish. - return getTargetCommittish(environment) + return getTargetCommittish(prov) } // Get tag from the provenance invocation parameters. -func getTag(prov *intoto.ProvenanceStatement) (string, error) { - environment, ok := prov.Predicate.Invocation.Environment.(map[string]interface{}) - if !ok { - return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type") - } - - refType, err := getAsString(environment, "github_ref_type") +func getTag(prov slsaprovenance.Provenance) (string, error) { + refType, err := prov.GetStringFromEnvironment("github_ref_type") if err != nil { return "", err } @@ -542,7 +514,7 @@ func getTag(prov *intoto.ProvenanceStatement) (string, error) { case "branch": return "", nil case "tag": - return getAsString(environment, "github_ref") + return prov.GetStringFromEnvironment("github_ref") default: return "", fmt.Errorf("%w: %s %s", serrors.ErrorInvalidDssePayload, "unknown ref type", refType) @@ -550,22 +522,17 @@ func getTag(prov *intoto.ProvenanceStatement) (string, error) { } // Get branch from the provenance invocation parameters. -func getBranch(prov *intoto.ProvenanceStatement) (string, error) { - environment, ok := prov.Predicate.Invocation.Environment.(map[string]interface{}) - if !ok { - return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type") - } - - refType, err := getAsString(environment, "github_ref_type") +func getBranch(prov slsaprovenance.Provenance) (string, error) { + refType, err := prov.GetStringFromEnvironment("github_ref_type") if err != nil { return "", err } switch refType { case "branch": - return getAsString(environment, "github_ref") + return prov.GetStringFromEnvironment("github_ref") case "tag": - return getBranchForTag(environment) + return getBranchForTag(prov) default: return "", fmt.Errorf("%w: %s %s", serrors.ErrorInvalidDssePayload, "unknown ref type", refType) diff --git a/verifiers/internal/gha/provenance_test.go b/verifiers/internal/gha/provenance_test.go index 680da5b..e785529 100644 --- a/verifiers/internal/gha/provenance_test.go +++ b/verifiers/internal/gha/provenance_test.go @@ -11,14 +11,16 @@ import ( slsa02 "github.com/in-toto/in-toto-golang/in_toto/slsa_provenance/v0.2" serrors "github.com/slsa-framework/slsa-verifier/v2/errors" + "github.com/slsa-framework/slsa-verifier/v2/verifiers/internal/gha/slsaprovenance" + v02 "github.com/slsa-framework/slsa-verifier/v2/verifiers/internal/gha/slsaprovenance/v0.2" ) -func provenanceFromBytes(payload []byte) (*intoto.ProvenanceStatement, error) { +func provenanceFromBytes(payload []byte) (slsaprovenance.Provenance, error) { env, err := EnvelopeFromBytes(payload) if err != nil { return nil, err } - return provenanceFromEnv(env) + return slsaprovenance.ProvenanceFromEnvelope(env) } func Test_VerifySha256Subject(t *testing.T) { @@ -347,7 +349,11 @@ func Test_verifySourceURI(t *testing.T) { t.Run(tt.name, func(t *testing.T) { t.Parallel() - err := verifySourceURI(tt.prov, tt.sourceURI) + prov := &v02.ProvenanceV02{ + ProvenanceStatement: tt.prov, + } + + err := verifySourceURI(prov, tt.sourceURI) if !errCmp(err, tt.expected) { t.Errorf(cmp.Diff(err, tt.expected)) } @@ -434,7 +440,11 @@ func Test_verifyBuilderIDExactMatch(t *testing.T) { t.Run(tt.name, func(t *testing.T) { t.Parallel() - err := verifyBuilderIDExactMatch(tt.prov, tt.id) + prov := &v02.ProvenanceV02{ + ProvenanceStatement: tt.prov, + } + + err := verifyBuilderIDExactMatch(prov, tt.id) if !errCmp(err, tt.expected) { t.Errorf(cmp.Diff(err, tt.expected)) } @@ -564,7 +574,7 @@ func Test_VerifyWorkflowInputs(t *testing.T) { "some_bool": "true", "some_integer": "123", }, - expected: serrors.ErrorInvalidDssePayload, + expected: serrors.ErrorMismatchWorkflowInputs, }, } for _, tt := range tests { diff --git a/verifiers/internal/gha/slsaprovenance/slsaprovenance.go b/verifiers/internal/gha/slsaprovenance/slsaprovenance.go new file mode 100644 index 0000000..953a13e --- /dev/null +++ b/verifiers/internal/gha/slsaprovenance/slsaprovenance.go @@ -0,0 +1,73 @@ +package slsaprovenance + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "sync" + + intoto "github.com/in-toto/in-toto-golang/in_toto" + dsselib "github.com/secure-systems-lab/go-securesystemslib/dsse" + serrors "github.com/slsa-framework/slsa-verifier/v2/errors" +) + +type Provenance interface { + // BuilderID returns the builder id in the predicate. + BuilderID() (string, error) + + // SourceURI is the full URI (including tag) of the source material. + SourceURI() (string, error) + + // ConfigURI is the full URI (including tag) of the configuration material. + ConfigURI() (string, error) + + // Subject is the list of intoto subjects in the provenance. + Subjects() ([]intoto.Subject, error) + + // GetStringFromEnvironment retrieves a string parameter from the environment + // attested to in the provenance. + GetStringFromEnvironment(name string) (string, error) + + // GetAnyFromEnvironment retrieves an object parameter from the environment + // attested to in the provenance. + GetAnyFromEnvironment(name string) (interface{}, error) + + // GetInputs retrieves the inputs from the provenance. Only succeeds for event + // relevant event types (workflow_inputs). + GetInputs() (map[string]interface{}, error) +} + +// ProvenanceMap stores the different provenance version types. +var ProvenanceMap sync.Map + +// Provenance interface that each type may implement. +func ProvenanceFromEnvelope(env *dsselib.Envelope) (Provenance, error) { + if env.PayloadType != "application/vnd.in-toto+json" { + return nil, fmt.Errorf("%w: expected payload type 'application/vnd.in-toto+json', got '%s'", + serrors.ErrorInvalidDssePayload, env.PayloadType) + } + pyld, err := base64.StdEncoding.DecodeString(env.Payload) + if err != nil { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err.Error()) + } + + // Get the predicateType, a required field. + pred := struct { + PredicateType string `json:"predicateType"` + }{} + if err := json.Unmarshal(pyld, &pred); err != nil { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err.Error()) + } + + // Load the appropriate structure and unmarshal. + ptype, ok := ProvenanceMap.Load(pred.PredicateType) + if !ok { + return nil, fmt.Errorf("%w: %s %s", serrors.ErrorInvalidDssePayload, "unexpected predicate type ", pred.PredicateType) + } + prov := ptype.(func() Provenance)() + + if err := json.Unmarshal(pyld, prov); err != nil { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, err.Error()) + } + return prov, nil +} diff --git a/verifiers/internal/gha/slsaprovenance/v0.2/provenance.go b/verifiers/internal/gha/slsaprovenance/v0.2/provenance.go new file mode 100644 index 0000000..ced6e32 --- /dev/null +++ b/verifiers/internal/gha/slsaprovenance/v0.2/provenance.go @@ -0,0 +1,103 @@ +package v02 + +import ( + "fmt" + + intoto "github.com/in-toto/in-toto-golang/in_toto" + serrors "github.com/slsa-framework/slsa-verifier/v2/errors" + "github.com/slsa-framework/slsa-verifier/v2/verifiers/internal/gha/slsaprovenance" +) + +// TODO(asraa): Use a static mapping. +// +//nolint:gochecknoinits +func init() { + slsaprovenance.ProvenanceMap.Store( + "https://slsa.dev/provenance/v0.2", + New) +} + +type ProvenanceV02 struct { + *intoto.ProvenanceStatement +} + +// This returns a new, empty instance of the v0.2 provenance. +func New() slsaprovenance.Provenance { + return &ProvenanceV02{} +} + +func (prov *ProvenanceV02) BuilderID() (string, error) { + return prov.Predicate.Builder.ID, nil +} + +func (prov *ProvenanceV02) SourceURI() (string, error) { + if len(prov.Predicate.Materials) == 0 { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "no material") + } + return prov.Predicate.Materials[0].URI, nil +} + +func (prov *ProvenanceV02) ConfigURI() (string, error) { + return prov.Predicate.Invocation.ConfigSource.URI, nil +} + +func (prov *ProvenanceV02) Subjects() ([]intoto.Subject, error) { + subj := prov.Subject + if len(subj) == 0 { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "no subjects") + } + return subj, nil +} + +func (prov *ProvenanceV02) GetStringFromEnvironment(name string) (string, error) { + environment, ok := prov.Predicate.Invocation.Environment.(map[string]interface{}) + if !ok { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type") + } + val, ok := environment[name] + if !ok { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, + fmt.Sprintf("environment type for %s", name)) + } + i, ok := val.(string) + if !ok { + return "", fmt.Errorf("%w: %s '%s'", serrors.ErrorInvalidDssePayload, "environment type string", name) + } + return i, nil +} + +func (prov *ProvenanceV02) GetAnyFromEnvironment(name string) (interface{}, error) { + environment, ok := prov.Predicate.Invocation.Environment.(map[string]interface{}) + if !ok { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type") + } + val, ok := environment[name] + if !ok { + return "", fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, + fmt.Sprintf("environment type for %s", name)) + } + return val, nil +} + +func (prov *ProvenanceV02) GetInputs() (map[string]interface{}, error) { + eventPayload, err := prov.GetAnyFromEnvironment("github_event_payload") + if err != nil { + return nil, err + } + + payload, ok := eventPayload.(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type payload") + } + + payloadInputs, ok := payload["inputs"] + if !ok { + return nil, fmt.Errorf("%w: error retrieving 'inputs': %v", serrors.ErrorInvalidDssePayload, err) + } + + pyldInputs, ok := payloadInputs.(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("%w: %s", serrors.ErrorInvalidDssePayload, "parameters type inputs") + } + return pyldInputs, nil +} diff --git a/verifiers/internal/gha/testdata/dsse-workflow-inputs-wrong-trigger.intoto.jsonl b/verifiers/internal/gha/testdata/dsse-workflow-inputs-wrong-trigger.intoto.jsonl index 30034ff..9d6749d 100644 --- a/verifiers/internal/gha/testdata/dsse-workflow-inputs-wrong-trigger.intoto.jsonl +++ b/verifiers/internal/gha/testdata/dsse-workflow-inputs-wrong-trigger.intoto.jsonl @@ -1 +1 @@ -{"payloadType":"application/vnd.in-toto+json","payload":"{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"artifact1","digest":{"sha256":"482ce8c8f7e867da3a3c05a9aee637703e17470ed1cf882a9e5b405e8f82619d"}},{"name":"artifact2","digest":{"sha256":"89cfc6954e88b2f92a7c2879d9eb085c42f3c7065d012a5066f450dbe59b2c00"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v1.2.0"},"buildType":"https://github.com/slsa-framework/slsa-github-generator@v1","invocation":{"configSource":{"uri":"git+https://github.com/laurentsimon/slsa-on-github-test@refs/heads/main","digest":{"sha1":"466c113ed3d5ac7568174d4b6ad6bb6a80e153b2"},"entryPoint":".github/workflows/slsa-generic.yml"},"parameters":{"event_inputs":{"release_version":"v1.2.3","some_bool":"true","some_integer":"123"}},"environment":{"github_actor":"laurentsimon","github_actor_id":"64505099","github_base_ref":"","github_event_name":"workflow_dispatch","github_event_payload":{"inputs":{"release_version":"v1.2.3","some_bool":"true","some_integer":"123"},"ref":"refs/heads/main","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/assignees{/user}","blobs_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/git/blobs{/sha}","branches_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/branches{/branch}","clone_url":"https://github.com/laurentsimon/slsa-on-github-test.git","collaborators_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/comments{/number}","commits_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/commits{/sha}","compare_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/compare/{base}...{head}","contents_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/contents/{+path}","contributors_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/contributors","created_at":"2022-02-05T01:10:46Z","default_branch":"main","deployments_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/deployments","description":"Test for SLSA","disabled":false,"downloads_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/downloads","events_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/events","fork":false,"forks":1,"forks_count":1,"forks_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/forks","full_name":"laurentsimon/slsa-on-github-test","git_commits_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/git/tags{/sha}","git_url":"git://github.com/laurentsimon/slsa-on-github-test.git","has_downloads":true,"has_issues":true,"has_pages":false,"has_projects":true,"has_wiki":true,"homepage":null,"hooks_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/hooks","html_url":"https://github.com/laurentsimon/slsa-on-github-test","id":455743396,"is_template":false,"issue_comment_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/issues/events{/number}","issues_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/issues{/number}","keys_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/keys{/key_id}","labels_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/labels{/name}","language":"Shell","languages_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/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/laurentsimon/slsa-on-github-test/merges","milestones_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/milestones{/number}","mirror_url":null,"name":"slsa-on-github-test","node_id":"R_kgDOGyoXpA","notifications_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/notifications{?since,all,participating}","open_issues":24,"open_issues_count":24,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/64505099?v=4","events_url":"https://api.github.com/users/laurentsimon/events{/privacy}","followers_url":"https://api.github.com/users/laurentsimon/followers","following_url":"https://api.github.com/users/laurentsimon/following{/other_user}","gists_url":"https://api.github.com/users/laurentsimon/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/laurentsimon","id":64505099,"login":"laurentsimon","node_id":"MDQ6VXNlcjY0NTA1MDk5","organizations_url":"https://api.github.com/users/laurentsimon/orgs","received_events_url":"https://api.github.com/users/laurentsimon/received_events","repos_url":"https://api.github.com/users/laurentsimon/repos","site_admin":false,"starred_url":"https://api.github.com/users/laurentsimon/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/laurentsimon/subscriptions","type":"User","url":"https://api.github.com/users/laurentsimon"},"private":false,"pulls_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/pulls{/number}","pushed_at":"2022-08-15T17:02:08Z","releases_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/releases{/id}","size":666,"ssh_url":"git@github.com:laurentsimon/slsa-on-github-test.git","stargazers_count":1,"stargazers_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/stargazers","statuses_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/statuses/{sha}","subscribers_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/subscribers","subscription_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/subscription","svn_url":"https://github.com/laurentsimon/slsa-on-github-test","tags_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/tags","teams_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/teams","topics":[],"trees_url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test/git/trees{/sha}","updated_at":"2022-06-13T20:29:33Z","url":"https://api.github.com/repos/laurentsimon/slsa-on-github-test","visibility":"public","watchers":1,"watchers_count":1,"web_commit_signoff_required":false},"sender":{"avatar_url":"https://avatars.githubusercontent.com/u/64505099?v=4","events_url":"https://api.github.com/users/laurentsimon/events{/privacy}","followers_url":"https://api.github.com/users/laurentsimon/followers","following_url":"https://api.github.com/users/laurentsimon/following{/other_user}","gists_url":"https://api.github.com/users/laurentsimon/gists{/gist_id}","gravatar_id":"","html_url":"https://github.com/laurentsimon","id":64505099,"login":"laurentsimon","node_id":"MDQ6VXNlcjY0NTA1MDk5","organizations_url":"https://api.github.com/users/laurentsimon/orgs","received_events_url":"https://api.github.com/users/laurentsimon/received_events","repos_url":"https://api.github.com/users/laurentsimon/repos","site_admin":false,"starred_url":"https://api.github.com/users/laurentsimon/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/laurentsimon/subscriptions","type":"User","url":"https://api.github.com/users/laurentsimon"},"workflow":".github/workflows/slsa-generic.yml"},"github_head_ref":"","github_ref":"refs/heads/main","github_ref_type":"branch","github_repository_id":"455743396","github_repository_owner":"laurentsimon","github_repository_owner_id":"64505099","github_run_attempt":"1","github_run_id":"2862171003","github_run_number":"8","github_sha1":"466c113ed3d5ac7568174d4b6ad6bb6a80e153b2"}},"metadata":{"buildInvocationID":"2862171003-1","completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/laurentsimon/slsa-on-github-test@refs/heads/main","digest":{"sha1":"466c113ed3d5ac7568174d4b6ad6bb6a80e153b2"}}]}}","signatures":[{"keyid":"","sig":"MEUCIHBtbLeV5WMsyLpPrZcxFU1wuEYHFUrJnzizsg17dL4hAiEAkoTLa49Vrf/g5mSaWY6Oab99YNvqByNgR773ikJXQ5I=","cert":"-----BEGIN CERTIFICATE-----\nMIIDVDCCAtqgAwIBAgITLCk1E2/wH2/mCjCYAovMeTTHnDAKBggqhkjOPQQDAzAq\nMRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxETAPBgNVBAMTCHNpZ3N0b3JlMB4XDTIy\nMDgxNTE3MDQxMloXDTIyMDgxNTE3MTQxMVowADBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCw6VO5lksfxcjt+4cEbgBnLuPB2wDgj3I9UQZh45xW4KRYKM7/oSLfD\nP8QGLfgNkv3ZDwBZUDLbBk0hNoMq0bejggIHMIICAzAOBgNVHQ8BAf8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwMwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUyxfq\nz2Pr2VR+K9FdiLbOSxqIYgQwHwYDVR0jBBgwFoAUWMAeX5FFpWapesyQoZMi0CrF\nxfowgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92MS4yLjAwHwYKKwYB\nBAGDvzABAgQRd29ya2Zsb3dfZGlzcGF0Y2gwLgYKKwYBBAGDvzABBQQgbGF1cmVu\ndHNpbW9uL3Nsc2Etb24tZ2l0aHViLXRlc3QwJAYKKwYBBAGDvzABBAQWU0xTQSBn\nZW5lcmljIGdlbmVyYXRvcjAdBgorBgEEAYO/MAEGBA9yZWZzL2hlYWRzL21haW4w\nOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJj\nb250ZW50LmNvbTA2BgorBgEEAYO/MAEDBCg0NjZjMTEzZWQzZDVhYzc1NjgxNzRk\nNGI2YWQ2YmI2YTgwZTE1M2IyMAoGCCqGSM49BAMDA2gAMGUCMQCx4+iMpFBvnFV9\nX6goGjQfdgliPcNa4cdd2K0nmrn79cOpslyzcJLAlL/qSYsGlocCMC/P/gL2B16i\nMp6YQZUiSMwzUohrr7V3nJsMPcLgETGyiZoR3UijZG74FobZ/+3pCw==\n-----END CERTIFICATE-----\n"}]}","signatures":[{"keyid":"","sig":"MEUCIHBtbLeV5WMsyLpPrZcxFU1wuEYHFUrJnzizsg17dL4hAiEAkoTLa49Vrf/g5mSaWY6Oab99YNvqByNgR773ikJXQ5I=","cert":"-----BEGIN CERTIFICATE-----\nMIIDVDCCAtqgAwIBAgITLCk1E2/wH2/mCjCYAovMeTTHnDAKBggqhkjOPQQDAzAq\nMRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxETAPBgNVBAMTCHNpZ3N0b3JlMB4XDTIy\nMDgxNTE3MDQxMloXDTIyMDgxNTE3MTQxMVowADBZMBMGByqGSM49AgEGCCqGSM49\nAwEHA0IABCw6VO5lksfxcjt+4cEbgBnLuPB2wDgj3I9UQZh45xW4KRYKM7/oSLfD\nP8QGLfgNkv3ZDwBZUDLbBk0hNoMq0bejggIHMIICAzAOBgNVHQ8BAf8EBAMCB4Aw\nEwYDVR0lBAwwCgYIKwYBBQUHAwMwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUyxfq\nz2Pr2VR+K9FdiLbOSxqIYgQwHwYDVR0jBBgwFoAUWMAeX5FFpWapesyQoZMi0CrF\nxfowgYQGA1UdEQEB/wR6MHiGdmh0dHBzOi8vZ2l0aHViLmNvbS9zbHNhLWZyYW1l\nd29yay9zbHNhLWdpdGh1Yi1nZW5lcmF0b3IvLmdpdGh1Yi93b3JrZmxvd3MvZ2Vu\nZXJhdG9yX2dlbmVyaWNfc2xzYTMueW1sQHJlZnMvdGFncy92MS4yLjAwHwYKKwYB\nBAGDvzABAgQRd29ya2Zsb3dfZGlzcGF0Y2gwLgYKKwYBBAGDvzABBQQgbGF1cmVu\ndHNpbW9uL3Nsc2Etb24tZ2l0aHViLXRlc3QwJAYKKwYBBAGDvzABBAQWU0xTQSBn\nZW5lcmljIGdlbmVyYXRvcjAdBgorBgEEAYO/MAEGBA9yZWZzL2hlYWRzL21haW4w\nOQYKKwYBBAGDvzABAQQraHR0cHM6Ly90b2tlbi5hY3Rpb25zLmdpdGh1YnVzZXJj\nb250ZW50LmNvbTA2BgorBgEEAYO/MAEDBCg0NjZjMTEzZWQzZDVhYzc1NjgxNzRk\nNGI2YWQ2YmI2YTgwZTE1M2IyMAoGCCqGSM49BAMDA2gAMGUCMQCx4+iMpFBvnFV9\nX6goGjQfdgliPcNa4cdd2K0nmrn79cOpslyzcJLAlL/qSYsGlocCMC/P/gL2B16i\nMp6YQZUiSMwzUohrr7V3nJsMPcLgETGyiZoR3UijZG74FobZ/+3pCw==\n-----END CERTIFICATE-----\n"}]} \ No newline at end of file +{"payloadType":"application/vnd.in-toto+json","payload":"{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://slsa.dev/provenance/v0.2","subject":[{"name":"binary-linux-amd64","digest":{"sha256":"6db937f07c14d309d403e561e2b402972e2a6edb32f4526e1b6b9ba855fd8574"}}],"predicate":{"builder":{"id":"https://github.com/slsa-framework/slsa-github-generator-go/.github/workflows/slsa3_builder.yml@refs/heads/main"},"buildType":"https://github.com/slsa-framework/slsa-github-generator-go@v1","invocation":{"configSource":{"uri":"git+https://github.com/asraa/slsa-on-github-test@refs/tags/v1","digest":{"sha1":"a5f48fdb433884a3b43cbfc65218ffe4559f0b17"},"entryPoint":"Test SLSA"},"parameters":{},"environment":{"arch":"X64","github_actor":"asraa","github_base_ref":"","github_event_name":"push","github_event_payload":{"after":"a5f48fdb433884a3b43cbfc65218ffe4559f0b17","base_ref":"refs/heads/main","before":"0000000000000000000000000000000000000000","commits":[],"compare":"https://github.com/asraa/slsa-on-github-test/compare/v1","created":true,"deleted":false,"forced":false,"head_commit":{"author":{"email":"asraa@google.com","name":"Asra Ali","username":"asraa"},"committer":{"email":"asraa@google.com","name":"Asra Ali","username":"asraa"},"distinct":true,"id":"a5f48fdb433884a3b43cbfc65218ffe4559f0b17","message":"update\n\nSigned-off-by: Asra Ali \u003casraa@google.com\u003e","timestamp":"2022-05-03T14:27:35-05:00","tree_id":"2d3a7894c930afd6bf0e367c968ecba42f74481f","url":"https://github.com/asraa/slsa-on-github-test/commit/a5f48fdb433884a3b43cbfc65218ffe4559f0b17"},"pusher":{"email":"asraa@google.com","name":"asraa"},"ref":"refs/tags/v1","repository":{"allow_forking":true,"archive_url":"https://api.github.com/repos/asraa/slsa-on-github-test/{archive_format}{/ref}","archived":false,"assignees_url":"https://api.github.com/repos/asraa/slsa-on-github-test/assignees{/user}","blobs_url":"https://api.github.com/repos/asraa/slsa-on-github-test/git/blobs{/sha}","branches_url":"https://api.github.com/repos/asraa/slsa-on-github-test/branches{/branch}","clone_url":"https://github.com/asraa/slsa-on-github-test.git","collaborators_url":"https://api.github.com/repos/asraa/slsa-on-github-test/collaborators{/collaborator}","comments_url":"https://api.github.com/repos/asraa/slsa-on-github-test/comments{/number}","commits_url":"https://api.github.com/repos/asraa/slsa-on-github-test/commits{/sha}","compare_url":"https://api.github.com/repos/asraa/slsa-on-github-test/compare/{base}...{head}","contents_url":"https://api.github.com/repos/asraa/slsa-on-github-test/contents/{+path}","contributors_url":"https://api.github.com/repos/asraa/slsa-on-github-test/contributors","created_at":1644939229,"default_branch":"main","deployments_url":"https://api.github.com/repos/asraa/slsa-on-github-test/deployments","description":"Test for SLSA","disabled":false,"downloads_url":"https://api.github.com/repos/asraa/slsa-on-github-test/downloads","events_url":"https://api.github.com/repos/asraa/slsa-on-github-test/events","fork":true,"forks":0,"forks_count":0,"forks_url":"https://api.github.com/repos/asraa/slsa-on-github-test/forks","full_name":"asraa/slsa-on-github-test","git_commits_url":"https://api.github.com/repos/asraa/slsa-on-github-test/git/commits{/sha}","git_refs_url":"https://api.github.com/repos/asraa/slsa-on-github-test/git/refs{/sha}","git_tags_url":"https://api.github.com/repos/asraa/slsa-on-github-test/git/tags{/sha}","git_url":"git://github.com/asraa/slsa-on-github-test.git","has_downloads":true,"has_issues":false,"has_pages":false,"has_projects":true,"has_wiki":true,"homepage":null,"hooks_url":"https://api.github.com/repos/asraa/slsa-on-github-test/hooks","html_url":"https://github.com/asraa/slsa-on-github-test","id":459639150,"is_template":false,"issue_comment_url":"https://api.github.com/repos/asraa/slsa-on-github-test/issues/comments{/number}","issue_events_url":"https://api.github.com/repos/asraa/slsa-on-github-test/issues/events{/number}","issues_url":"https://api.github.com/repos/asraa/slsa-on-github-test/issues{/number}","keys_url":"https://api.github.com/repos/asraa/slsa-on-github-test/keys{/key_id}","labels_url":"https://api.github.com/repos/asraa/slsa-on-github-test/labels{/name}","language":"Go","languages_url":"https://api.github.com/repos/asraa/slsa-on-github-test/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/asraa/slsa-on-github-test/merges","milestones_url":"https://api.github.com/repos/asraa/slsa-on-github-test/milestones{/number}","mirror_url":null,"name":"slsa-on-github-test","node_id":"R_kgDOG2WJbg","notifications_url":"https://api.github.com/repos/asraa/slsa-on-github-test/notifications{?since,all,participating}","open_issues":0,"open_issues_count":0,"owner":{"avatar_url":"https://avatars.githubusercontent.com/u/5194569?v=4","email":"asraa@google.com","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","name":"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"},"private":false,"pulls_url":"https://api.github.com/repos/asraa/slsa-on-github-test/pulls{/number}","pushed_at":1651606341,"releases_url":"https://api.github.com/repos/asraa/slsa-on-github-test/releases{/id}","size":1215,"ssh_url":"git@github.com:asraa/slsa-on-github-test.git","stargazers":0,"stargazers_count":0,"stargazers_url":"https://api.github.com/repos/asraa/slsa-on-github-test/stargazers","statuses_url":"https://api.github.com/repos/asraa/slsa-on-github-test/statuses/{sha}","subscribers_url":"https://api.github.com/repos/asraa/slsa-on-github-test/subscribers","subscription_url":"https://api.github.com/repos/asraa/slsa-on-github-test/subscription","svn_url":"https://github.com/asraa/slsa-on-github-test","tags_url":"https://api.github.com/repos/asraa/slsa-on-github-test/tags","teams_url":"https://api.github.com/repos/asraa/slsa-on-github-test/teams","topics":[],"trees_url":"https://api.github.com/repos/asraa/slsa-on-github-test/git/trees{/sha}","updated_at":"2022-02-15T15:36:41Z","url":"https://github.com/asraa/slsa-on-github-test","visibility":"public","watchers":0,"watchers_count":0},"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"}},"github_head_ref":"","github_ref":"refs/tags/v1","github_ref_type":"tag","github_run_attempt":"1","github_run_id":"2265933835","github_run_number":"3","github_sha1":"a5f48fdb433884a3b43cbfc65218ffe4559f0b17","os":"ubuntu20"}},"buildConfig":{"version":1,"steps":[{"command":["/opt/hostedtoolcache/go/1.17.9/x64/bin/go","build","-mod=vendor","-trimpath","-tags=netgo","-o","binary-linux-amd64"],"env":["GOOS=linux","GOARCH=amd64","GO111MODULE=on","CGO_ENABLED=0"]}]},"metadata":{"completeness":{"parameters":true,"environment":false,"materials":false},"reproducible":false},"materials":[{"uri":"git+https://github.com/asraa/slsa-on-github-test@refs/tags/v1","digest":{"sha1":"a5f48fdb433884a3b43cbfc65218ffe4559f0b17"}},{"uri":"https://github.com/actions/virtual-environments/releases/tag/ubuntu20/20220425.1"}]}}","signatures":[{"keyid":"","sig":"MEUCIQDOJ6RZ0bdsfNebunBpm/t3iGvoB9QzxdgTqczV3UwvSAIgGNV8KjAOxlT5r4uFFd05b3aGPKRE/mgmMsfI3CPsTw4="}]} \ No newline at end of file