Job search
Software Supply Chain Portfolio: Verify a Signed Build and Its Provenance
Build a local signed-artifact portfolio with inspected provenance, actual tamper rejections, and an independent builder-policy intake decision.
A software supply chain portfolio should make a release decision inspectable: which bytes were built, which key signed them, what the provenance claims, and why the verifier accepted or rejected the package. A successful signature check answers one part of that decision. It does not establish that the signer is an approved producer or that the build environment was secure.
This guide actually built and verified two original text artifacts locally on October 23, 2026. It uses disposable RSA keys, detached signatures, and a small authored provenance-policy checker. It did not use a cloud account, CI push, keyless identity, public transparency log, or third-party package. The examples demonstrate local verification mechanics, with explicit trust assumptions.

Use LandOffer’s recently posted jobs to identify build-security or artifact-verification responsibilities worth demonstrating. Choose an owned artifact and a rejection rule you can reproduce without giving a reviewer credentials.
Separate the signature, provenance, and trust decision
The artifact is the output file. Its signature lets a verifier check those bytes against a particular public key. Provenance describes the claimed build inputs and process. A consumer policy decides which signer, builder, and inputs are acceptable. Record the cryptographic result separately from the consumer’s acceptance decision. A reviewer can then see whether rejection came from altered bytes, an unacceptable key, or authenticated claims outside the allowed policy.
Sigstore’s verification documentation illustrates keyless verification with certificate identity and OIDC issuer expectations, as well as public-key and attestation verification. Those documented routes supply useful context. This exercise does not run Cosign, obtain a Fulcio certificate, authenticate an OIDC identity, or submit anything to Rekor. It must not be described as a Sigstore keyless implementation.
Instead, the existing local OpenSSL executable reports version 4.0.3. We used its documented RSA/SHA-256 signing and verification operations, called from Python’s standard library. The OpenSSL command reference describes signing with a private key and verifying with a public key; it also distinguishes signature handling from associated signer-identification formats. No additional tool was installed for this demonstration.
The trusted-key fingerprint and expected fields live in a separate local policy file. In this authored lab, the same author created that policy and the signing keys. In a real consumer system, trust configuration would need an authenticated, controlled distribution process. Accepting whichever key arrives beside a download would not establish producer identity.
Worked asset one: a signed build with a traceable input record
Packet A starts with an original UTF-8 source file containing “release note alpha.” The tiny build.py script strips surrounding whitespace, converts the text to uppercase, and appends one newline. The resulting artifact.txt contains “RELEASE NOTE ALPHA” followed by that newline.
The script was run twice against this input, and the output bytes matched. This is a repeated deterministic transformation of one owned file, not evidence of a hermetic compiler build or reproducibility across operating systems and toolchains.
Packet A includes the source, recipe, output, public key, two detached signatures, provenance JSON, policy, and run receipt. Its output SHA-256 begins f79c49f041e2; the full digest is preserved in the signed statement and verification evidence. The setup script generated private keys in a temporary directory and asserted that those files no longer existed after that directory was removed. Public keys and signatures remain for repeat verification; this local file check is not proof that no copy could ever have existed. The saved command record includes exit codes and the actual tool version.
The authored statement uses the in-toto statement type and the SLSA provenance predicate identifier. The current SLSA build-provenance specification distinguishes the subject output from the build definition and run details. Our record includes:
- Subject:
artifact.txt, with its actual SHA-256 digest. - Build type: a private teaching identifier,
urn:landoffer:demo:uppercase-utf8:v1, whose meaning is documented with the recipe. - External parameters: exactly one declared input name,
source.txt. - Resolved inputs: digests for this source file and the authored recipe.
- Builder: the synthetic local release-builder label used by the demonstration policy.
- Run metadata: an invocation identifier and recorded start and finish timestamps.
These are not claims of a fully inventoried build environment. The Python runtime, operating system, and all transitive dependencies are not represented as a complete dependency graph. The checker is not a full SLSA schema validator or a standard attestation-envelope implementation.
The JSON and artifact have separate detached signatures over their exact bytes. This is not a DSSE envelope or a Cosign bundle, and interoperability with those formats was not tested. Reformatting the JSON changes its signed bytes and requires a new signature; the verifier does not silently canonicalize it.
Verify expected fields after checking the signed bytes
The checker first performs actual OpenSSL verification for both signatures and compares the supplied public key’s hash with the configured pin. If those checks fail, it rejects the packet before using provenance fields for acceptance.
For authenticated JSON, it checks the statement and predicate identifiers, the single subject name, the artifact digest, the expected builder label, build type, exact external parameters, and resolved-input list. It also compares the local source and recipe bytes with the policy’s recorded digests. These are finite rules for this authored package, not an ecosystem-wide verifier.
The SLSA verification guidance connects provenance verification to configured trust and expected values. Its distinction between signature verification and matching builder/build expectations motivates the exercise. We do not assign a SLSA Build level to this local signing process or infer one from a builder label.
The completed rejection record for Packet A is:
| Test | Actual observation | Local decision |
|---|---|---|
| Intact artifact and provenance | Both signatures valid; configured fields match | Accept within the toy policy |
| Modified artifact bytes | Artifact signature fails | Reject |
| Different public key | Key pin mismatches; signature verification fails | Reject |
| Modified provenance without re-signing | Provenance signature fails | Reject before trusting its fields |
| Re-signed provenance with an incorrect subject digest | Signature valid; artifact digest comparison fails | Reject |
| Re-signed provenance with an extra external parameter | Signature valid; exact parameter expectation fails | Reject |
The last two cases show why a consumer needs field expectations after signature verification. A reviewer can see a correct cryptographic result and a justified rejection in the same record, rather than treating every signed statement as acceptable. Possession of the demonstration key lets the author sign an incorrect digest or an unexpected parameter. The consumer’s additional checks still reject those packets. A signature alone would miss that policy failure.
From the supplied demo directory, rerun the retained checks with:
python3 regression.py > replay.json
The result records each OpenSSL exit code, expected acceptance, observed acceptance, and field comparison. Across both assets, the seven cases produced one acceptance and six rejections, all matching their declared expectations. Two fresh verifier processes produced identical saved output in the observed environment. The private keys are unnecessary to repeat verification; generating new keys and signatures would produce a different package.
Worked asset two: a valid signature with an unacceptable builder
The independent intake case uses Packet B, a separate input containing “museum intake beta,” a separate uppercase artifact, and a separate provenance invocation. Its source and artifact digests differ from Packet A’s. The recipe and local demonstration signing key are shared; it is not a copy of Packet A’s result labeled as another project.
Both packets were built on the same local machine. For this intake test, Packet B deliberately records the synthetic experimental-builder label, while its consumer policy expects the release-builder label. These are authored policy labels, not independently authenticated identities of two actual build platforms. The test does not establish isolation between environments or permission for the same signer to represent a production builder.
The completed intake record is INTAKE-B — hold despite intact signatures:
Received material: the original second text artifact, detached artifact signature, signed provenance JSON, source, recipe, and the separate consumer-policy file for Packet B. Its pin, expected builder, input digests, and parameters are recorded explicitly; they were authored locally, not supplied by an independently trusted release organization. No executable third-party package was downloaded or installed.
Cryptographic result: artifact signature valid under the pinned public key; provenance signature valid under that key. The signer is the same demonstration key used for Packet A. Its actual identity beyond this local exercise is not established.
Content binding: subject name, artifact digest, local source digest, and recipe digest all match. The build type and external parameters also match the expected values. These checks rule out the specific byte and field discrepancies they test; they do not certify the truth of every provenance claim.
Failed expectation: the authenticated builder label differs from the permitted release-builder label. The local decision is rejection. Renaming the label after receipt or weakening the expected policy would erase the very boundary the intake test is meant to demonstrate.
Reviewer disposition: preserve the original packet and record the mismatch. In a real authorized process, ask the designated release owner to explain the builder authorization and provide an acceptable build through the approved route. That is a proposed next action; no person was contacted, no new build was requested, and no exception was approved here.
Unresolved trust: both signer and builder claims remain under the lab author’s control. This is an executed consumer-policy example, not proof of a compromised builder, malicious artifact, or legitimate production release. The packet’s correct signatures do not resolve those questions.

Explain the assurance the demonstration leaves open
The private key’s removal limits what remains in this review package; it does not prove that the key was hardware-protected, never copied, or inaccessible during the build. There is no isolated signing service, independent provenance generator, trusted timestamp authority, certificate chain, revocation service, or transparency-log inclusion proof.
The recorded invocation times are local observations, not externally verified time. The public-key pin is deliberately preconfigured for the lab. If an attacker could replace both the packet and its trusted policy, these checks would not supply an independent trust anchor. Protecting policy and key distribution belongs in a separate design and test plan.
The small checker also assumes the authored JSON shape. Malformed input, parser ambiguities, resource limits, duplicate keys, general schema compatibility, and arbitrary hostile packages were not comprehensively tested. Its finite mutation suite is not a general-purpose package-security gate. It should remain a teaching verifier, not be copied into production as a complete release policy.
No test here establishes that the program is free of vulnerabilities. Provenance and signature checks address origin and integrity expectations under stated trust assumptions. Code quality, dependency risk, licensing, and runtime behavior would require their own permitted reviews. A valid package signature does not make its contents harmless.
Give the reviewer a bounded engineering story
Keep the recipe, source, signed files, public key, policy, verification code, and rejection results together. Show the repeat command near the outcome. A reviewer should be able to identify which checks are cryptographic, which compare authenticated fields, and which rely on a trust decision the exercise merely assumes.
This topic differs from documenting a cloud deployment or a successful CI run. There is no hosting architecture, customer workload, uptime, or deployment claim here. The engineering contribution is the traceable build record and consumer decision, including deliberately rejected material.
A supported portfolio description is: “Built two original local text artifacts, signed artifact and provenance bytes with disposable RSA keys, and implemented a finite verification policy that rejected altered bytes, an incorrect key, inconsistent provenance, unexpected parameters, and a disallowed builder label.” It does not imply Sigstore keyless integration, a verified CI identity, or SLSA-level assurance.
Use LandOffer’s current listings to identify relevant responsibilities, then select the actual files and refusal decisions that explain your work. LandOffer does not verify these signatures, authorize builders, or certify the project. Keep the limitations alongside the passing case, so the project remains reviewable without becoming a larger security claim.
Download the worked example files
Download the curated educational companion. Read PUBLICATION-README.md after extraction for the public file layout, replay commands and requirements. The finite offline verifier was rerun from the extracted archive using an existing OpenSSL command. The earlier local report and commands describe the original evidence environment; use the companion README for the portable layout. No whole evidence directory, credentials or compiler binaries are included.


