Attestations play a big function in SLSA and it’s important that customers of artifacts know the place to search out the attestations for these artifacts.
Attestations might be colocated within the repository that hosts the artifact. That is how Squirrel plans to retailer attestations for packages. They even need to add assist to the Squirrel CLI (e.g. acorn get-attestations foo@1.2.3).
Acme actually likes this method as a result of the attestations are all the time out there and it doesn’t introduce any new dependencies.
Rekor
In the meantime, Oppy plans to retailer attestations in Rekor. They like having the ability to direct customers to an current public occasion without having to keep up any new infrastructure themselves, and the in-depth protection the transparency log gives towards tampering with the attestations.
Although the latency of querying attestations from Rekor is probably going too excessive for doing verification at time of use, Oppy isn’t too involved since they anticipate customers to question Rekor at set up time.
Hybrid
A hybrid mannequin can also be out there the place the writer shops the attestations in Rekor in addition to co-located with the artifact within the repo—together with Rekor’s inclusion proof. This gives confidence the info was added to Rekor whereas offering the advantages of co-locating attestations within the repository.
‘Coverage’ refers back to the guidelines used to find out if an artifact needs to be allowed for a use case.Insurance policies typically use the bundle title as a proxy for figuring out the use case. An instance being, if you wish to discover the coverage to use you would lookup the coverage utilizing the bundle title of the artifact you’re evaluating.
Coverage specifics might fluctuate primarily based on ease of use, availability of information, danger tolerance and extra. Full verification wants extra from insurance policies than delegated verification does.
Default insurance policies permit admission choices with out the necessity to create particular insurance policies for every bundle. A default coverage is a manner of claiming “something that doesn’t have a extra particular coverage should adjust to this coverage”.
Squirrel plans to ultimately implement a default coverage of “any bundle with no extra particular coverage will likely be accepted so long as it meets SLSA 3”, however they acknowledge that the majority packages don’t assist this but. Till they obtain important mass they’ll have a default SLSA 0 coverage (all artifacts are accepted).
Whereas Oppy is leaving verification to their customers, they’ll counsel a default coverage of “any bundle constructed by ‘https://oppy.instance/slsa/builder/v1’”.
Squirrel additionally plans to permit customers to create insurance policies for particular packages. For instance, this coverage requires that bundle ‘foo’ will need to have been constructed by GitHub Actions, from github.com/foo/acorn-foo, and be SLSA 4.
Squirrel may even permit packages to create SLSA 0 insurance policies in the event that they’re not utilizing SLSA compliant infrastructure.
Coverage add-ons
Coverage analysis might do extra than simply consider the SLSA necessities. The identical insurance policies that verify SLSA necessities are effectively positioned to verify different properties which might be essential to organizations like “was static evaluation carried out”, “are there any recognized CVEs on this artifact”, “was integration testing profitable”, and so on…
Acme is absolutely all for a few of these coverage add-ons. They’d prefer to keep away from the embarrassing state of affairs of publishing a brand new container picture with recognized CVEs. They’re unsure tips on how to implement it but however they’ll be looking out for instruments that may assist them accomplish that.
Delegated insurance policies
When utilizing delegated verification there’s a lot much less that truly must be checked and they are often hard-coded instantly in tooling. A minimal delegated verification coverage is likely to be “permit if trusted-party verified this artifact (recognized by digest) as <bundle title>”. This may be tightened additional by including necessities on the artifact & its dependencies SLSA ranges (information which is out there within the VSA). For instance, “permit if trusted-party verified this artifact as <bundle title> at SLSA 3 and it doesn’t have any dependencies lower than SLSA 2”.
When utilizing particular, non-default, insurance policies verifiers have to know the place to search out the coverage they should consider.
Squirrel plans to retailer particular insurance policies as a property of the bundle within the repository. This makes them very straightforward for customers and their tooling to search out. It additionally permits the maintainer of the bundle to simply set the coverage (they have already got write permissions!).
A possible draw back is that the write permissions are the identical as for the bundle itself. An attacker that compromises the developer’s credentials might additionally change the coverage. This is probably not as dangerous because it appears. Insurance policies are human-readable so anybody paying consideration would discover that bundle foo’s coverage now says that it may be constructed from github.com/not-foo/acorn-foo. Squirrel plans to inform events (together with the maintainer!) when the coverage adjustments, doubtlessly letting them “sound the alarm” if something nefarious occurs.
The same method is taken in quite a lot of contact-change workflows. For instance, once you change your tackle along with your financial institution, the financial institution will ship you an e-mail (and a letter to the outdated tackle) letting you realize the tackle has been modified. This sort of notification would alert the maintainer to a possible compromise.
Squirrel would additionally think about requiring a second individual to assessment any coverage adjustments for packages with over 10,000 customers.
Public canonical Git repo
An alternative choice is likely to be to only create a canonical git repo (e.g. github.com/slsa-framework/slsa-acorn-policies) and let folks publish proposed insurance policies there. This has the benefit of utilizing a separate ACL management mechanism from the bundle repository itself, however the disadvantages of being tough to make sure the writer of the coverage is definitely allowed to set the coverage for that bundle and never scaling effectively because the repo grows.
The method outlined in coverage auto era might assist right here. Automation within the repo might simply take a look at the final N releases of the bundle and decide if the proposed coverage matches what’s truly been printed. Proactive adjustments to the coverage (like deciding to modify from GitHub Actions to CircleCI) could be more durable to coordinate nevertheless.
Org particular repo
Acme plans to determine their very own org particular repo for coverage storage. This provides them a single place to retailer all their insurance policies, no matter ecosystem sort, and lets them present extra particular insurance policies for packages offered by upstream repos. Since Oppy doesn’t have any plans to offer package-specific insurance policies this offers Acme a spot to retailer their very own insurance policies for Oppy packages (in the event that they ever get round to it).
Organizations also can use their coverage repo to vet any upstream adjustments to coverage and doubtlessly add further checks (e.g. “doesn’t have any recognized vulnerabilities”).
Acme needs to make use of delegated verification and that depends on having trusted verifiers to make choices for downstream customers. Who’re these trusted verifiers?
A public repo is in an important place to behave as a trusted verifier for his or her customers. Customers already belief these repos and so they might already be doing verification on import.
Squirrel plans to utilize this by making VSAs out there for every artifact printed, publicizing their verifier ID (i.e. ‘https://squirrel.instance/slsa-verifier’) and the general public key used to signal the VSAs. They even plan to construct VSA verification instantly into the Squirrel tooling, in order that customers can get SLSA safety by default.
Org-wide verifier
Whereas Acme is completely satisfied to make use of Squirrel’s verifier (and the verification constructed into the tooling) they nonetheless want their very own verifier to allow them to publish VSAs to Acme prospects. So Acme plans to face up their very own verification service and publish their verifier ID (i.e. ‘https://acme.instance/private-verifier’) and signing key. Acme prospects can then confirm the software program they get from Acme.
Sooner or later Acme might require all software program used all through the corporate to be verified with this verifier (as a substitute of counting on public verifiers). They’d do the verification and generate VSAs every time artifacts are imported into their non-public Artifactory occasion. They might then configure this ID/key pair to be used all through Acme and be assured that any software program used has been verified in line with Acme coverage. That’s not Acme’s highest precedence for the time being, however they like having this selection open to them.
When utilizing delegated verification this might be the simplest case. Squirrel can simply construct the important thing they used for delegated verification instantly into the Squirrel tooling. Acme also can pretty simply configure the usage of their keys by means of the corporate utilizing current configuration management mechanisms.
When utilizing full verification this may be more durable. If there are a number of builders that might be accepted the keys that signal the attestations should be distributed to everybody that may use that builder. For Squirrel this could be actually tough since they plan to permit bundle maintainers to make use of no matter builder they need. How these keys get configured could be tough only for Squirrel, and rather more tough if downstream Squirrel customers wished to do full verification of the Squirrel packages.
The state of affairs is simpler, nevertheless, for Oppy. That’s as a result of Oppy plans to solely settle for artifacts constructed by their autobuilder community. Oppy can configure this community to make use of a single (or small set) of keys after which publish these keys (and the SLSA stage Oppy believes it meets) for downstream customers.
Squirrel plans to resolve the issue of which keys they settle for by leveraging Fulcio. Squirrel will construct assist for Fulcio root keys into their verifier after which specific which Fulcio topic is allowed to signal attestations within the particular coverage of every bundle. E.g. “Squirrel bundle ‘foo’ will need to have been constructed & signed by ‘spiffe://foobar.com/foo-builder, from github.com/foo/acorn-foo, and be SLSA 4”.
The Replace Framework (TUF)
The above strategies might be additional enhanced with TUF to permit the safe upkeep of keys. TUF metadata might embody all of the SLSA keys, the construct companies and different entities they’re legitimate for, and the SLSA ranges they’re certified at. Oppy is contemplating utilizing TUF to let verifiers securely fetch and replace keys utilized by the Autobuilder community. Oppy would use a TUF delegation to point that these keys ought to solely be used for the builder id ‘https://oppy.instance/slsa/builder/v1’. Squirrel may do one thing much like permit for updating the Fulcio key in its tooling.
Acme needs to file and confirm the dependencies that go into its container into the SLSA provenance. Acme would favor that this performance had been simply built-in their construct service, however that characteristic isn’t out there but. As a substitute they’ll have to do one thing themselves. They’ve just a few choices at their disposal:
Since Oppy doesn’t construct SLSA into it’s tooling Acme will create wrapper scripts for dependency import/set up that file and confirm (utilizing cosign) dependencies as they’re put in. Acme will replace their construct scripts to exchange all cases of Oppy bundle set up with the wrapper script after which use the recorded outcomes to assist populate the supplies part of the provenance.
A draw back is that this method, if run within the construct itself, will not be assured to be full and can’t meet the “non-falsifiable” requirement (for the reason that outcomes reported by the wrapper might be falsified by the construct course of), relegating this method to SLSA 2. Nonetheless, it permits Acme to make progress SLSA-fying their builds and gives a place to begin for attaining increased SLSA ranges.
Constructed into ecosystem tooling
Since Squirrel does construct verification into their tooling, Acme can simply use acorn set up to confirm the dependencies and file what was put in. Acme can use this data to populate the Squirrel packages put in within the supplies part of the provenance and it could actually embody the attestations of these dependencies within the in-toto bundle for his or her container picture.
As with device wrappers, if this technique is used within the construct itself it can not meet “non-falsifiable” requirement.
Proxied verification
Acme thought of making a proxy for his or her current builder to proxy outbound connections. This proxy might confirm all the pieces fetched and use its logs to populate the provenance. Since this proxy is trusted it will be simpler to satisfy “non-falsifiable” requirement. Sadly it’s additionally loads of work for Acme in order that they’re going to defer this concept for now.
Within the first two components of this collection, we’ve lined the fundamentals of getting began with SLSA and the main points of coverage and provenance storage, coverage verification, and key dealing with. In our subsequent submit we’ll cowl how Squirrel, Oppy, and Acme put this all collectively to guard a heterogeneous provide chain.
