Skip to content
Skillpedia
Security35k · #5960

implementing-sigstore-for-software-signing

Has your agent implement software signing and verification using Sigstore to ensure provenance.

What it does

This tool helps ensure that the software you use is authentic and hasn't been tampered with. It creates a digital signature for the software using your online identity (like your Google or GitHub account), without you needing to manage complex passwords.

When to use it

  • ✓When publishing new software versions.
  • ✓To verify if downloaded software is the original.
  • ✓In automated systems that build and test software.

Example of what to ask your AI

“Sign this container image with my GitHub account.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-sigstore-for-software-signing/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-sigstore-for-software-signing/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It uses a tool called Cosign to create a digital signature. This signature is linked to your online identity (OIDC) and recorded in a public log (Rekor) so anyone can verify it.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill implementing-sigstore-for-software-signing

Or download just the file:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/implementing-sigstore-for-software-signing/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

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

…

FAQ

Do I need to create passwords or secret keys?

No, it uses your online identity (like Google or GitHub) to sign, a process called 'keyless'.

What is 'cryptographic provenance'?

It's a way to prove who created or signed a piece of software and ensure it hasn't been changed since.

What if I don't have internet access?

This method requires internet access to connect to Sigstore services (Fulcio, Rekor). It won't work for fully offline environments.

Details

Original description by the author

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, verifyin

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularity

GitHub stars
35k
Ranking position
#5960
License
Apache-2.0
Updated
8/31/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills