Most organisations load model weights from a hub, a bucket or a registry with nothing more than a file name and a hope that the bytes are the ones the producer intended. Model signing closes that gap by binding every file in a model directory to a cryptographic signature and to an identity that a verifier can pin. This guide is the operational companion to the AI Model Provenance and Watermarking Guide: it explains how the OpenSSF model signing project (the sigstore/model-transparency library and the model_signing CLI) works, which signing identity to choose, where to put signing and verification gates in an ML pipeline, how the CoSAI Artifact Integrity Maturity Model (AIMM) frames how far to go, and what signing does not protect against. It is written for ML platform engineers, MLOps teams and security architects who own model intake and deployment.
Key takeaways
- Signing proves integrity and origin, not safety. A signed model can still be poisoned, backdoored or unsafe to deserialise; signing tells you who produced it and that nobody changed it since.
- Verification without a pinned identity is theatre. A verifier must check the signature against the expected identity and OIDC issuer, or the expected public key or certificate chain, for that specific model.
- The signing identity is a non-human identity. In CI it is the workload identity of the training or release pipeline, and it needs the same scoping, ownership and monitoring as any other machine credential.
- Every transformation needs a new signature. Fine-tuning, quantisation, merging, conversion to another format and distillation all produce a new artefact that must be signed by whoever produced it.
- Start at AIMM Level 1 everywhere, then add provenance where risk demands it. Hash, sign and verify at release boundaries first; signed lineage and policy-evaluated attestations come next.
What OpenSSF model signing is
The OpenSSF AI/ML working group released model signing v1.0 on 4 April 2025 as the first stable release of a library and CLI for signing and verifying machine learning models of any format and size. The project lives at sigstore/model-transparency and ships on PyPI as the model-signing package; when checked on 27 October 2026 PyPI listed version 1.1.1 (10 October 2025), Python 3.9 or later, with a "3 - Alpha" development status classifier despite the stable v1.0 announcement, so pin versions and test upgrades.
- What is signed: the tool hashes a model directory and produces a manifest, a list of every file (or file shard) path with its digest. The signature covers that manifest, so adding, removing or changing any file breaks verification.
- Format: the output is a Sigstore bundle (protobuf serialised as JSON) containing a DSSE envelope. The envelope holds an in-toto statement listing paths and digests, with the predicate type
https://model_signing/signature/v1.0. See the in-toto Attestations Guide. - One format, several trust models: the same hashing scheme and bundle format are used whether you sign with Sigstore keyless signing, a self-signed or organisational certificate, or a plain key pair, so verifiers do not need different tooling per producer.
- Exclusions: git-related paths are ignored by default; the
digestsubcommand follows the same ignore rules, which lets you compute the manifest without signing to compare against a known-good copy.
The Google announcement that accompanied v1.0 recommends signing during training and verifying before each use: when a model is uploaded to a hub, when it is selected for deployment, and when it is used as input to another training run. It also states the main assumption: signing at training time is only as trustworthy as the training infrastructure that holds the signing identity.
Choosing a signing identity
| Method | CLI form | What the verifier pins | Best fit | Main risk |
|---|---|---|---|---|
| Sigstore keyless (default) | model_signing sign <model_dir> | Identity (email, or CI workflow identity) plus OIDC issuer | Open models, public releases, CI pipelines with OIDC (for example GitHub Actions) | Signing identity details are recorded in a public transparency log; overly broad identity patterns in verification policy |
| Private key | model_signing sign key <model_dir> --private-key key.priv | Public key | Air-gapped or internal pipelines without OIDC | Long-lived key theft, no built-in revocation or transparency |
| Certificate (organisational PKI) | model_signing sign certificate ... | Certificate chain to your CA | Enterprises with an internal code-signing CA and HSMs | CA and certificate lifecycle overhead; revocation must be checked by your verifier design |
| PKCS #11 hardware key | model_signing sign pkcs11-key ... (install model-signing[pkcs11], RFC 7512 URI) | Public key or certificate | High-value internal models where the key must stay in an HSM or token | HSM availability in build agents; key access policy |
Sigstore keyless signing works by having the Fulcio certificate authority issue a short-lived certificate bound to an OpenID Connect identity, with the private key discarded after one use, and by recording the artefact digest, signature and certificate in the Rekor append-only transparency log. That removes key rotation from the producer and lets identity owners monitor the log for unexpected signatures. Treat the log as public: do not sign confidential internal models with a personal email identity on the public Sigstore instance if the existence of the model, or who built it, is itself sensitive. See the Sigstore Guide and the Code Signing Security Guide.
Decision guidance
- Publishing models externally: use Sigstore keyless signing from the release pipeline's workload identity, never from a developer's laptop, and publish the exact identity and issuer consumers should pin.
- Internal-only models in a regulated firm: use certificates from your internal CA with keys in an HSM (PKCS #11), so revocation, audit and key custody follow existing code-signing controls.
- Small teams: keyless signing in CI is the least operational burden; key pairs look simpler but leave you owning key storage, rotation and compromise response.
- Consuming third-party models: verify the producer's signature if one exists; if none exists, compute a digest at intake, re-sign the approved copy with your own intake identity and only ever deploy from your registry.
Where to sign and verify in the ML pipeline
| Stage | Action | Gate |
|---|---|---|
| Training or fine-tuning job completes | Pipeline signs the output directory with its workload identity | Job fails if signing fails; signature stored next to the model |
| Upload to hub or internal registry | Registry or upload job verifies against the expected identity for that project | Reject unsigned or mismatched uploads |
| Intake of an external model | Verify the producer signature if present; scan the artefact; re-sign the approved copy with the intake identity | Only intake-signed copies are deployable |
| Quantisation, conversion, merging | Verify the input, then sign the new output with the transformation pipeline's identity | Lineage record links input digest to output digest |
| Deployment | Serving platform or init container runs model_signing verify before loading weights | Pod or endpoint does not start on failure |
| Use as input to another training run | Verify base model and datasets before training starts | Training job refuses unverified inputs |
A Sigstore verification names the identity and the issuer explicitly, for example model_signing verify <model_dir> --signature model.sig --identity "$identity" --identity-provider "$oidc_provider"; key-based verification uses model_signing verify key <model_dir> --signature model.sig --public-key key.pub. Keep the expected identity per model in a policy file under change control, not typed into each pipeline.
How to implement
- Inventory model sources: list every place models enter the estate (public hubs, vendor deliveries, internal training, notebooks) and every place they are loaded. See the Model Supply Chain Guide.
- Stand up a single registry of record: production may only load models from it.
- Sign internal training outputs: add the sign step to one training pipeline, store the bundle beside the weights, and publish the expected identity.
- Verify in audit mode: run verification at deployment for [4 weeks] and log failures without blocking. Expect failures from manual uploads, notebooks and re-saved files; fix the process, not the policy.
- Enforce at the registry and at deployment: block unsigned or mismatched artefacts, starting with internet-facing and agent-backing models.
- Extend to transformations and intake: sign quantised and converted variants; re-sign approved external models at intake.
- Roll back safely: keep a documented break-glass path (a named approver can deploy a previously verified digest) rather than switching enforcement off globally.
The CoSAI Artifact Integrity Maturity Model
The Coalition for Secure AI (CoSAI), which operates under OASIS Open, published the Artifact Integrity Maturity Model on 5 October 2026 through its Workstream 1 (Software Supply Chain Security for AI Systems). It builds on CoSAI's earlier paper "Signing ML Artifacts: Building towards tamper-proof ML metadata records" and adapts SLSA, in-toto and SBOM patterns to AI artefacts that are trained, fine-tuned and transformed across organisations. See the CoSAI Frameworks and Workstreams Guide.
| AIMM level | What it adds | OpenSSF model signing role |
|---|---|---|
| Level 1: Basic Artifact Integrity | Producers hash and sign artefacts at a release boundary; consumers verify hash and signature before use. A single point in time, no record of how the artefact was produced. | Directly provides this level |
| Level 2: Provenance and Lineage | Signed provenance claims and verifiable links between artefacts and the transformations that produced them, such as fine-tuning, quantisation or distillation | Signs each artefact; lineage records and build provenance come from your pipeline. See the SLSA and Build Provenance Guide |
| Level 3: Structured Attestations for Policy Automation | Structured attestations about model, data, process and infrastructure properties that a policy engine can evaluate for admission. CoSAI notes fully automated enforcement is still aspirational | One input among several attestations |
Choose the level per use case: Level 1 for every model in production, Level 2 for models you fine-tune or that back agents with tool access, Level 3 where a regulator or customer asks for machine-checkable evidence of how a model was built.
What signing does not cover
- Unsafe serialisation: a correctly signed pickle-based checkpoint still executes code when loaded (MITRE ATLAS AML.T0011.000 Unsafe AI Artifacts). Prefer formats such as safetensors and scan artefacts at intake.
- Poisoned training: if the data or the training environment was compromised, the pipeline signs the poisoned result faithfully. See the OWASP LLM Top 10 LLM04 Data and Model Poisoning Guide.
- Compromised signer: a stolen CI identity or private key produces valid signatures. Monitor the transparency log or your signing service for signatures you did not expect.
- Runtime threats: prompt injection, jailbreaks and data leakage are separate risks that signing does not address.
- Datasets and metadata: OpenSSF lists datasets and other ML artefacts as future work, so model cards and evaluation results are not yet tamper-evident through this tool alone.
Where identity fits
The signing identity is the root of trust for every model it signs. In CI it is a workload identity (an OIDC token from the pipeline), in a PKI model it is a certificate and private key, and in a hub it is often a write-scoped API token that can replace the files being signed. Scope release identities to one repository and one workflow, separate training identities from release identities, keep hub write tokens fine-grained and short-lived, and assign an owner to each. See the CI/CD Pipeline Identity Security Guide and the Hugging Face Security Guide.
Detection and measurement
- Log: every sign and verify event with model name, digest, identity, issuer and result; deployment admission decisions; registry uploads without signatures.
- Alert on: verification failures in enforce mode, signatures from an unexpected identity in the transparency log or signing service, and model loads from paths outside the registry.
| Metric | Target |
|---|---|
| Production models with a valid signature verified at load | 100% of internet-facing and agent-backing models |
| Verification policies pinned to a specific identity and issuer (not wildcards) | 100% |
| Transformed variants (quantised, converted) with their own signature and lineage link | Rising quarter on quarter |
| External models deployed without intake verification or re-signing | Zero |
| Mean time to revoke a compromised signing identity and re-sign affected models | Measured in exercises, target [24 hours] |
Framework mapping
| Framework | Reference | How model signing supports it |
|---|---|---|
| NIST SP 800-53 Rev. 5 | SI-7 Software, Firmware, and Information Integrity; CM-14 Signed Components; SR-4 Provenance; SR-11 Component Authenticity; SR-3 Supply Chain Controls and Processes; SA-10 Developer Configuration Management | Integrity verification before load, signed artefacts, provenance records |
| NIST CSF 2.0 | GV.SC-07, PR.PS-02, PR.DS-01 | Supplier risk for model producers; software maintained with integrity; data at rest integrity |
| MITRE ATLAS | AML.T0010.003 AI Supply Chain Compromise: Model; AML.T0115.001 Publish Poisoned AI Artifacts: Models; AML.T0018 Manipulate AI Model | Detects tampering between producer and consumer |
| ISO/IEC 27001:2022 Annex A | A.5.21 Managing information security in the ICT supply chain | Supplier and artefact integrity controls |
| CIS Controls v8.1 | Control 16 Application Software Security | Secure handling of third-party components |
| OWASP Top 10 for LLM Applications 2025 | LLM03:2025 Supply Chain | Integrity of third-party models |
Common failure patterns
- Verifying "any valid signature": accepting any Sigstore identity means an attacker can sign a malicious model with their own account and pass.
- Signing from laptops: developer-signed releases tie trust to a personal identity that leaves with the person and is easy to phish.
- Write tokens as the weak link: in the Hugging Face API tokens exposure, Lasso Security reported 655 of 1,681 valid exposed tokens had write permission, enough to replace models others download. Signing with pinned verification turns a silent swap into a failed load.
- Signing once at intake, then transforming: a quantised or converted copy that is never re-signed is unverifiable, so teams quietly bypass the gate.
- Treating signed as safe: skipping deserialisation scanning and evaluation because the artefact is signed.
- Audit mode forever: verification logs failures that nobody reviews and enforcement never starts.
Practitioner checklist
- Production loads models only from a registry of record, and every model there has a signature bundle.
- Training and release pipelines sign with a scoped workload identity, never a personal one.
- Verification policies pin identity and issuer, or key or certificate chain, per model, under change control.
- Deployment verifies before loading weights and fails closed, with a named break-glass approver.
- Every quantised, converted or fine-tuned variant is re-signed and linked to its input digest.
- External models are verified or digested at intake, scanned, and re-signed by the intake identity.
- Hub write tokens are fine-grained, short-lived and owned; their use is monitored.
- Signing events are monitored for unexpected identities, and a signer-compromise runbook exists.
- The AIMM target level is recorded per use case and reviewed annually.
Standards and references
- OpenSSF and Sigstore: model-transparency (model signing) project
- OpenSSF: Launch of Model Signing v1.0
- CoSAI: Artifact Integrity Maturity Model (AIMM)
- Sigstore: Overview of Fulcio and Rekor
- NIST: SP 800-53 Rev. 5
- MITRE ATLAS: AI Supply Chain Compromise
- Google: Taming the Wild West of ML, Practical Model Signing with Sigstore
- PyPI: model-signing package
Related NHI Mgmt Group resources: AI Model Provenance and Watermarking Guide · Sigstore Guide · AI Supply Chain and AI-BOM Guide · Model Supply Chain Guide