What it does. 'Implements Sigstore-based software signing and verification using Cosign Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).

Install

• npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill implementing-sigstore-for-software-signing, or copy the skill folder into ~/.claude/skills/implementing-sigstore-for-software-signing/.
• Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/implementing-sigstore-for-software-signing/SKILL.md

SKILL.md (verbatim)

name: implementing-sigstore-for-software-signing
description: 'Implements Sigstore-based software signing and verification using Cosign
  keyless signing, Rekor transparency log verification, and Fulcio certificate authority
  integration to establish cryptographic provenance for container images, binaries,
  and software artifacts, including OIDC-based identity binding and CI/CD pipeline
  integration. Use when setting up keyless container/artifact signing, verifying
  signatures against the Rekor transparency log, or deploying Sigstore in a supply-chain
  security workflow.

  '
domain: cybersecurity
subdomain: supply-chain-security
tags:
- sigstore
- cosign
- rekor
- fulcio
- software-signing
- supply-chain
- keyless-signing
- OIDC
- transparency-log
version: 1.0.0
author: mukul975
license: Apache-2.0
nist_csf:
- GV.SC-01
- GV.SC-03
- GV.SC-06
- GV.SC-07
mitre_attack:
- T1078
- T1190
- T1059
- T1610
- T1611
mitre_f3:
  version: '1.1'
  tactics:
  - resource-development
  - initial-access
  - stealth
  techniques:
  - id: T1195
    name: Supply Chain Compromise
    tactic: initial-access
    source: attack
  - id: T1608
    name: Stage Capabilities
    tactic: resource-development
    source: attack
  - id: T1608.006
    name: 'Stage Capabilities: SEO Poisoning'
    tactic: resource-development
    source: attack
  - id: T1586
    name: Compromise Accounts
    tactic: resource-development
    source: attack
  - id: T1070
    name: Indicator Removal
    tactic: stealth
    source: attack

Implementing Sigstore for Software Signing

When to Use

• Signing container images and software artifacts without managing long-lived cryptographic keys
• Establishing verifiable provenance for build outputs in CI/CD pipelines using OIDC identity binding
• Querying the Rekor transparency log to audit when and by whom an artifact was signed
• Verifying that container images pulled from registries were signed by authorized identities and issuers
• Integrating Sigstore verification into Kubernetes admission controllers to enforce signed-image policies

Do not use for signing artifacts that require air-gapped or offline signing workflows where OIDC authentication is unavailable, for environments that cannot reach the public Sigstore infrastructure (Fulcio, Rekor) and have no private instance deployed, or as a replacement for traditional PGP/GPG signing where regulatory compliance mandates specific key management procedures.

Prerequisites

• Cosign CLI v2.4+ installed (go install github.com/sigstore/cosign/v2/cmd/cosign@latest or binary release)
• Access to an OIDC identity provider supported by Fulcio (Google, GitHub, Microsoft, or a custom OIDC issuer)
• Container registry credentials (for signing container images) with push access to store signature objects
• Python 3.9+ with sigstore, requests, and cryptography packages for the automation agent
• Network access to fulcio.sigstore.dev, rekor.sigstore.dev, and tuf-repo-cdn.sigstore.dev (or private Sigstore instance URLs)

Workflow

Step 1: Install and Configure Cosign

Install Cosign and verify it can reach the Sigstore infrastructure:

• Install from binary release: Download the appropriate binary from the Cosign GitHub releases page and verify its checksum. On Linux: curl -LO https://github.com/sigstore/cosign/releases/latest/download/cosign-linux-amd64 && chmod +x cosign-linux-amd64 && sudo mv cosign-linux-amd64 /usr/local/bin/cosign
• Verify installation: Run cosign version to confirm the version and check connectivity to Sigstore services with cosign initialize which fetches the TUF root of trust
• Configure custom infrastructure (optional): If running a private Sigstore stack, set --fulcio-url, --rekor-url, and --oidc-issuer flags or use environment variables COSIGN_REKOR_URL and COSIGN_FULCIO_URL

Step 2: Keyless Signing with Cosign and Fulcio

Perform identity-based signing where Fulcio issues a short-lived certificate bound to your OIDC identity:

• Sign a container image: Run cosign sign <IMAGE_DIGEST> which triggers an OIDC authentication flow. Cosign generates an ephemeral key pair, obtains a short-lived certificate from Fulcio binding the public key to the OIDC identity, signs the image digest, and records the signing event in Rekor. The private key is destroyed immediately after signing.
• Sign a blob (file): Run cosign sign-blob <file> --bundle artifact.sigstore.json to sign arbitrary files. The bundle contains the signature, certificate, timestamp, and Rekor inclusion proof.
• Non-interactive signing in CI: Set SIGSTORE_ID_TOKEN environment variable with a valid OIDC token (e.g., from GitHub Actions OIDC or GCP workload identity) to skip the browser-based authentication flow:

  export SIGSTORE_ID_TOKEN=$(curl -sH "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
    "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=sigstore" | jq -r '.value')
  cosign sign $IMAGE_DIGEST
  

• Supported OIDC providers: Google (https://accounts.google.com), GitHub (https://github.com/login/oauth), Microsoft (https://login.microsoftonline.com), GitLab (https://gitlab.com), and custom providers registered with a private Fulcio instance

Step 3: Verify Signed Artifacts

Verify that artifacts were signed by expected identities from expected OIDC issuers:

• Verify a container image: Run cosign verify <IMAGE_URI> --certificate-identity=name@example.com --certificate-oidc-issuer=https://accounts.google.com to confirm the image was signed by the specified identity. Cosign validates the certificate chain, checks the Rekor inclusion proof, and verifies the signature matches the current image digest.
• Verify a signed blob: Run cosign verify-blob <file> --bundle artifact.sigstore.json --certificate-identity=name@example.com --certificate-oidc-issuer=https://accounts.google.com
• Regex matching for CI identities: Use --certificate-identity-regexp to match CI workflow identities:

  cosign verify $IMAGE --certificate-identity-regexp="https://github.com/myorg/myrepo/.*" \
    --certificate-oidc-issuer=https://token.actions.githubusercontent.com
  

• Verification failure modes: Cosign returns a non-zero exit code on failure. Common failures include certificate identity mismatch, expired certificates without a valid Rekor timestamp, missing Rekor entry, and image digest mismatch (image was modified after signing).

Step 4: Query the Rekor Transparency Log

Search and verify entries in the Rekor transparency log to audit signing events:

• Search by email identity: Use rekor-cli search --email user@example.com to find all signing events for an identity
• Search by artifact hash: Use rekor-cli search --sha sha256:<hash> to find signing events for a specific artifact
• Retrieve and verify an entry: Use rekor-cli get --uuid <entry_uuid> to retrieve full entry details including the certificate, signature, and artifact hash
• Verify log inclusion: Use rekor-cli verify --entry-uuid <uuid> to verify the entry's inclusion proof against the signed tree head, confirming the entry exists in the append-only log and has not been tampered with
• REST API queries: Query https://rekor.sigstore.dev/api/v1/index/retrieve with POST body {"hash": "sha256:<hash>"} to retrieve entry UUIDs, then fetch full entries from /api/v1/log/entries/<uuid>
• Monitor for consistency: Use the rekor-monitor tool or Omniwitness to continuously verify the log remains append-only and entries are never mutated or removed

Step 5: Integrate into CI/CD Pipelines

Embed signing and verification into build and deployment pipelines:

• GitHub Actions: Use sigstore/cosign-installer action to install Cosign, then sign images using the GitHub OIDC token as the identity. The signing identity will be the workflow URL (e.g., https://github.com/org/repo/.github/workflows/build.yml@refs/heads/main).
• Kubernetes admission enforcement: Deploy Sigstore Policy Controller or Kyverno with Cosign verification policies to reject unsigned or incorrectly signed images at admission time
• Supply chain metadata: Use cosign attest to attach in-toto attestations (SLSA provenance, SBOM, vulnerability scan results) to images, signed with the same keyless flow, enabling consumers to verify both the artifact and its build metadata

Key Concepts

Tools & Systems

• Cosign: CLI tool for signing containers and blobs, verifying signatures, and attaching attestations using Sigstore keyless signing or traditional key-based signing
• Fulcio: Free root certificate authority for code signing certificates issued based on OIDC identity verification with a validity period of approximately 10 minutes
• Rekor: Transparency log server providing tamper-evident storage of signing metadata, searchable by identity, artifact hash, or public key
• Sigstore Policy Controller: Kubernetes admission webhook that enforces image signing policies by verifying Cosign signatures and attestations before allowing pod creation
• rekor-cli: Command-line client for querying, uploading, and verifying entries in the Rekor transparency log

Common Scenarios

Scenario: Securing a Container Image Build Pipeline with Keyless Signing

Context: A DevOps team builds container images in GitHub Actions and deploys to a Kubernetes cluster. They need to ensure only images built by their CI pipeline can be deployed, preventing supply chain attacks from compromised registries or unauthorized pushes.

Approach:

1. Add sigstore/cosign-installer@v3 to the GitHub Actions workflow and enable OIDC token permissions with id-token: write
2. After building and pushing the image, sign it with cosign sign $IMAGE_DIGEST using the GitHub Actions OIDC identity automatically
3. Deploy Sigstore Policy Controller to the Kubernetes cluster with a ClusterImagePolicy requiring signatures from --certificate-identity-regexp=https://github.com/myorg/myrepo/.* and --certificate-oidc-issuer=https://token.actions.githubusercontent.com
4. Verify the signing entry appears in Rekor by querying with the image digest hash to confirm the transparency log recorded the event
5. Test the admission controller by attempting to deploy an unsigned image and confirming it is rejected with a policy violation error

Pitfalls:

• Signing the image tag instead of the digest (cosign sign myimage:latest vs cosign sign myimage@sha256:abc...) means verification breaks when the tag is updated to point to a different digest
• Not pinning the --certificate-oidc-issuer during verification allows signatures from any OIDC provider to pass, defeating the purpose of identity binding
• Forgetting to set id-token: write permission in GitHub Actions results in OIDC token retrieval failure and signing errors
• Using --certificate-identity-regexp=.* in production verification policies effectively disables identity verification

Output Format

## Sigstore Signing Verification Report

**Artifact**: ghcr.io/myorg/myapp@sha256:a1b2c3d4...
**Verification Status**: PASSED

**Certificate Details**:
  Subject: https://github.com/myorg/myapp/.github/workflows/build.yml@refs/heads/main
  Issuer: https://token.actions.githubusercontent.com
  Valid From: 2026-03-19T10:00:00Z
  Valid To: 2026-03-19T10:10:00Z

**Rekor Entry**:
  UUID: 24296fb24b8ad77a8d52...
  Log Index: 89234567
  Integrated Time: 2026-03-19T10:00:05Z
  Inclusion Proof: VERIFIED (tree size: 92000000, root hash: e4f5a6...)

**Policy Check**: Image signed by authorized CI workflow identity

Other files in this skill

• LICENSE
• references/api-reference.md
• scripts/agent.py

references/api-reference.md (verbatim)

API Reference: Sigstore Software Signing Agent

Overview

Automates Sigstore-based software signing and verification using Cosign keyless signing, Rekor transparency log queries, and Fulcio certificate authority integration. Wraps the Cosign CLI and Rekor REST API to sign artifacts, verify signatures against expected OIDC identities, search the transparency log, and audit signing events end-to-end.

Dependencies

CLI Usage

# Check cosign installation and Rekor connectivity
python agent.py check

# Sign a file blob (triggers OIDC auth flow)
python agent.py sign-blob myfile.tar.gz --bundle myfile.sigstore.json

# Verify a signed blob
python agent.py verify-blob myfile.tar.gz --bundle myfile.sigstore.json \
  --cert-identity user@example.com \
  --cert-oidc-issuer https://accounts.google.com

# Sign a container image (use digest, not tag)
python agent.py sign-container registry.io/myimage@sha256:abc123...

# Verify a container image
python agent.py verify-container registry.io/myimage@sha256:abc123... \
  --cert-identity user@example.com \
  --cert-oidc-issuer https://accounts.google.com

# Search Rekor by artifact hash
python agent.py search-rekor --hash <sha256-hash>

# Search Rekor by signer email
python agent.py search-rekor --email user@example.com

# Search Rekor by file (computes hash automatically)
python agent.py search-rekor --file myfile.tar.gz

# Retrieve a specific Rekor entry
python agent.py get-rekor-entry <uuid>

# Get Rekor transparency log state
python agent.py log-info

# Full audit of a signing event
python agent.py audit --file myfile.tar.gz \
  --cert-identity user@example.com \
  --cert-oidc-issuer https://accounts.google.com

# All commands support custom output path
python agent.py sign-blob myfile.tar.gz --output custom_report.json

Arguments

Key Functions

sign_blob_keyless(filepath, bundle_path)

Signs a file using Cosign keyless signing. Triggers OIDC authentication, obtains a Fulcio certificate, records the event in Rekor, and outputs a sigstore bundle containing the signature, certificate, and inclusion proof.

verify_blob_keyless(filepath, bundle_path, cert_identity, cert_oidc_issuer)

Verifies a signed blob against the expected certificate identity and OIDC issuer. Validates the certificate chain, Rekor inclusion proof, and signature integrity.

sign_container_keyless(image_uri)

Signs a container image by digest using keyless signing. The signature is stored as an OCI artifact attached to the image in the registry.

verify_container_keyless(image_uri, cert_identity, cert_oidc_issuer)

Verifies container image signatures and returns parsed verification details including all matching signatures.

search_rekor_by_hash(artifact_hash, rekor_url)

Queries the Rekor REST API POST /api/v1/index/retrieve with a SHA-256 hash to find all log entries for an artifact.

search_rekor_by_email(email, rekor_url)

Queries Rekor for all signing events associated with an email identity.

get_rekor_entry(uuid, rekor_url)

Retrieves a specific Rekor log entry by UUID from GET /api/v1/log/entries/<uuid>, parsing log index, integrated time, inclusion proof presence, and signed entry timestamp.

get_rekor_log_info(rekor_url)

Retrieves the current Rekor log state from GET /api/v1/log, including tree size, root hash, and signed tree head.

audit_signing_event(filepath, image_uri, cert_identity, cert_oidc_issuer, rekor_url)

Performs a comprehensive audit combining artifact hash computation, Rekor log search, entry detail retrieval, inclusion proof verification, and signature verification into a single pass/fail report.

Rekor REST API Endpoints Used

Common OIDC Issuers

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.