Skip to main content

Cosign

@dataverket/cosignv2026.10.28.1· AGPL-3.0-only· 2d agoBEHAVIORSWORKFLOWSSKILLSACCEPTED WARNINGS
01README

Container images signed and verified with cosign, https://github.com/sigstore/cosign, signed with a key, with or without a transparency log, verified against that key or keyless against the identity in a Sigstore certificate. One model type, @dataverket/cosign/signer, one signing identity. sign signs images named by digest with annotations, verify checks them against the public key, or keyless against a certificate identity and its OIDC issuer, and records what it found, verified or not, so a workflow can assert; attest attaches a predicate file as an attestation of a type and verifyAttestation checks those; signBlob and verifyBlob do the same for a file, with a Sigstore bundle beside it; describe records cosign's version and the public key in effect with its fingerprint; generateKeyPair makes a key pair and records it with the private key as a sensitive field, in the vault. The private key is a PEM from a vault expression, a KMS or HSM reference, or a key file: a PEM reaches cosign through its environment, never a file or an argument, and never appears in a record, a log or an error. Tags are refused: what is signed is a digest. With tlog false, the default, signatures go to the registry only, through a signing config with no transparency log that the model generates per run; with tlog true they are recorded in Rekor and a log entry is required to verify. A signing config or trusted root of your own, for private Sigstore infrastructure, replaces that. Two workflows: @dataverket/cosign-sign signs digests with a key from a vault and verifies them; @dataverket/cosign-verify gates on a public key, read-only. A skill, cosign, says which to run for what, and how to put a key in the vault. Written against cosign 3.1.4.

02Behaviors1
@dataverket/cosign/signerv2026.10.28.1signer.ts

Global Arguments

ArgumentTypeDescription
key?stringThe private key: a PEM, written as a vault expression; a KMS or HSM reference (awskms://, gcpkms://, azurekms://, hashivault://, k8s://, pkcs11:); or a key file, absolute or relative to the repository root. Empty for a signer that only verifies
password?stringThe key's passphrase, written as a vault expression; empty for an unencrypted key
publicKey?stringThe public key verify checks against: a PEM, or a file absolute or relative to the repository root; derived from key when empty
certificateIdentity?stringFor keyless verification: the exact identity the signing certificate must name, such as a GitHub workflow URL; verify, verifyAttestation and verifyBlob then check the certificate and its log entry instead of a public key. Needs oidcIssuer and tlog true
certificateIdentityRegexp?stringFor keyless verification: a regular expression the certificate's identity must match, instead of certificateIdentity
oidcIssuer?stringFor keyless verification: the OIDC issuer that vouched for the identity, such as https://token.actions.githubusercontent.com; required with an identity
tlog?booleanRecord every signature in a transparency log and require a log entry when verifying; false signs through a signing config with no log service and verifies ignoring the log. Keyless verification requires true
signingConfig?stringA Sigstore signing config file for sign and attest, relative to the repository root, such as one naming a private Rekor or TSA; replaces what tlog chooses
trustedRoot?stringA Sigstore trusted root file for sign, attest and verify, relative to the repository root, for private infrastructure
insecureRegistry?booleanAllow a registry whose certificate does not verify
httpRegistry?booleanAllow a registry served over plain HTTP
cosignBinary?string
fn describe()
Record cosign's version, how the key was given, the public key in effect and the log and config choices
fn generateKeyPair()
Generate a key pair, encrypted with password when one is set, and record it with the private key as a sensitive field
fn sign(annotations?: array, recursive?: boolean, upload?: boolean)
Sign every image named by digest with the key, with annotations, and record each signature
ArgumentTypeDescription
annotations?arrayAnnotations carried by every signature, key=value
recursive?booleanFor an image index, also sign every image in it
upload?booleanPush the signature to the registry; false signs and discards, a rehearsal
fn verify(annotations?: array)
Verify every image named by digest against the public key, or keyless against the certificate identity, and record what was found; an image that does not verify is recorded, not a failure
ArgumentTypeDescription
annotations?arrayAnnotations a signature must carry to count, key=value
fn attest(predicate: string, type?: string, upload?: boolean)
Attach the predicate file as an attestation of the given type to every image named by digest, signed with the key, and record each
ArgumentTypeDescription
predicatestringThe predicate file, absolute or relative to the repository root
type?stringThe predicate type: slsaprovenance, slsaprovenance02, slsaprovenance1, link, spdx, spdxjson, cyclonedx, vuln, openvex, custom, or a URI
upload?booleanPush the attestation to the registry
fn verifyAttestation(type?: string)
Verify the attestations of the given type on every image named by digest against the public key, or keyless against the certificate identity, and record what was found
ArgumentTypeDescription
type?stringThe predicate type an attestation must have to count
fn signBlob(path: string, bundle?: string)
Sign one file with the key and write a Sigstore bundle beside it; record the file's sha256 and the bundle
ArgumentTypeDescription
pathstringThe file to sign, absolute or relative to the repository root
bundle?stringWhere the Sigstore bundle is written, absolute or relative to the repository root; <path>.sigstore.json when empty
fn verifyBlob(path: string, bundle?: string)
Verify one file against its Sigstore bundle with the public key, or keyless against the certificate identity, and record the outcome; a file that does not verify is recorded, not a failure
ArgumentTypeDescription
pathstringThe file to verify, absolute or relative to the repository root
bundle?stringIts Sigstore bundle, absolute or relative to the repository root; <path>.sigstore.json when empty

Resources

signer(infinite)— The signer as cosign sees it: version, how the key was given, the public key, how it verifies, log and config choices
keypair(infinite)— One generated key pair; the private key is sensitive and lives in the vault, and is always an encrypted PEM, with password as its passphrase, empty or not
signature(infinite)— One image signed: its reference, digest and annotations
verification(infinite)— One image verified, or not: the signatures found and cosign's reason when none counted
attestation(infinite)— One attestation attached: its type and predicate
attestationVerification(infinite)— One image's attestations of a type verified, or not, with their predicate types
blobSignature(infinite)— One file signed: its sha256 and the Sigstore bundle written beside it
blobVerification(infinite)— One file verified against its bundle, or not, with cosign's reason
03Workflows2
@dataverket/cosign-sign77ec3bcb-f4a4-4297-acfc-659615aca7ff

Sign images named by digest with a private key held in a vault, then verify every one of them against that key's public half and fail unless all verify. The key and its passphrase are named by vault and key, never passed as values, because workflow inputs are recorded in cleartext in the run history; the key reaches cosign through its environment, never a file or an argument. With tlog false, the default, signatures go to the registry only, through a signing config with no transparency log, and

sign
1.signatures— One cosign sign per image; one signature record each.
verify
1.verifications— One cosign verify per image against the key's public half; one verification record each.
2.every-image-verified— This run recorded one verification per image, every one verified.
@dataverket/cosign-verify92c2dc73-8d7f-4d0a-8b5f-f339820df6b0

Verify images named by digest against a public key and fail unless every one carries a signature that checks out, with the required annotations when any are given. Read-only: nothing is pushed anywhere. The public key is a PEM or a file in the repository, nothing secret. With tlog false, the default, the transparency log is ignored; with tlog true a log entry is required. Made to gate a deploy: run it on the digests a manifest pins before anything applies them. Its model is created on first use

verify
1.verifications— One cosign verify per image; one verification record each, verified or not.
2.every-image-verified— This run recorded one verification per image, every one verified.
04Skills1
cosign1 file
05Stats
A
100 / 100
Downloads
0
Archive size
40.5 KB
  • Has README or module doc2/2earned
  • README has a code example1/1earned
  • README is substantive1/1earned
  • Most symbols documented1/1earned
  • No slow types (deprecated)1/1earned
  • Dependencies pass trust audit2/2earned
  • Docs keep secrets in a vault1/1earned
  • Has description1/1earned
  • Platform support declared (or universal)2/2earned
  • License2/2earned
  • Verified public repository2/2earned

07Platforms
08Labels