Join our Newsletter — 33% off our NHI Course
Home› Guides› Model Signing and OpenSSF Model Signing Guide
Guide Agent Controls & Monitoring

Model Signing and OpenSSF Model Signing Guide

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 13 November 2026 13 min read
On this page

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 digest subcommand 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

MethodCLI formWhat the verifier pinsBest fitMain risk
Sigstore keyless (default)model_signing sign <model_dir>Identity (email, or CI workflow identity) plus OIDC issuerOpen 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 keymodel_signing sign key <model_dir> --private-key key.privPublic keyAir-gapped or internal pipelines without OIDCLong-lived key theft, no built-in revocation or transparency
Certificate (organisational PKI)model_signing sign certificate ...Certificate chain to your CAEnterprises with an internal code-signing CA and HSMsCA and certificate lifecycle overhead; revocation must be checked by your verifier design
PKCS #11 hardware keymodel_signing sign pkcs11-key ... (install model-signing[pkcs11], RFC 7512 URI)Public key or certificateHigh-value internal models where the key must stay in an HSM or tokenHSM 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

StageActionGate
Training or fine-tuning job completesPipeline signs the output directory with its workload identityJob fails if signing fails; signature stored next to the model
Upload to hub or internal registryRegistry or upload job verifies against the expected identity for that projectReject unsigned or mismatched uploads
Intake of an external modelVerify the producer signature if present; scan the artefact; re-sign the approved copy with the intake identityOnly intake-signed copies are deployable
Quantisation, conversion, mergingVerify the input, then sign the new output with the transformation pipeline's identityLineage record links input digest to output digest
DeploymentServing platform or init container runs model_signing verify before loading weightsPod or endpoint does not start on failure
Use as input to another training runVerify base model and datasets before training startsTraining 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

  1. 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.
  2. Stand up a single registry of record: production may only load models from it.
  3. Sign internal training outputs: add the sign step to one training pipeline, store the bundle beside the weights, and publish the expected identity.
  4. 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.
  5. Enforce at the registry and at deployment: block unsigned or mismatched artefacts, starting with internet-facing and agent-backing models.
  6. Extend to transformations and intake: sign quantised and converted variants; re-sign approved external models at intake.
  7. 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 levelWhat it addsOpenSSF model signing role
Level 1: Basic Artifact IntegrityProducers 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 LineageSigned provenance claims and verifiable links between artefacts and the transformations that produced them, such as fine-tuning, quantisation or distillationSigns each artefact; lineage records and build provenance come from your pipeline. See the SLSA and Build Provenance Guide
Level 3: Structured Attestations for Policy AutomationStructured attestations about model, data, process and infrastructure properties that a policy engine can evaluate for admission. CoSAI notes fully automated enforcement is still aspirationalOne 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.
MetricTarget
Production models with a valid signature verified at load100% 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 linkRising quarter on quarter
External models deployed without intake verification or re-signingZero
Mean time to revoke a compromised signing identity and re-sign affected modelsMeasured in exercises, target [24 hours]

Framework mapping

FrameworkReferenceHow model signing supports it
NIST SP 800-53 Rev. 5SI-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 ManagementIntegrity verification before load, signed artefacts, provenance records
NIST CSF 2.0GV.SC-07, PR.PS-02, PR.DS-01Supplier risk for model producers; software maintained with integrity; data at rest integrity
MITRE ATLASAML.T0010.003 AI Supply Chain Compromise: Model; AML.T0115.001 Publish Poisoned AI Artifacts: Models; AML.T0018 Manipulate AI ModelDetects tampering between producer and consumer
ISO/IEC 27001:2022 Annex AA.5.21 Managing information security in the ICT supply chainSupplier and artefact integrity controls
CIS Controls v8.1Control 16 Application Software SecuritySecure handling of third-party components
OWASP Top 10 for LLM Applications 2025LLM03:2025 Supply ChainIntegrity 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

Related NHI Mgmt Group resources: AI Model Provenance and Watermarking Guide · Sigstore Guide · AI Supply Chain and AI-BOM Guide · Model Supply Chain Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 13 November 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.