github.com/smallstep/pkcs7 v0.0.0-20231024181729-3b98ecc1ca81: PKCS7

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify github.com/smallstep/pkcs7.PKCS7 in pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81
Demonstrate these symbols/APIs:
  - github.com/smallstep/pkcs7.PKCS7

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:cded09a12754cacc16eb97a811671896202689b4f5e1ab581414764928eaef37","contract":["Parse parses DER-encoded PKCS#7 SignedData payload into a PKCS7 instance and preserves content bytes","Verify verifies the signature of a signed PKCS7 payload against embedded signer certificates","VerifyWithChain validates signature trust against a root certificate pool and rejects untrusted pools","Decrypt recovers original plaintext from an EnvelopedData PKCS7 instance using private key and certificate","GetOnlySigner extracts the single leaf signer certificate from a valid SignedData PKCS7 instance","DegenerateCertificate creates a certificate-only PKCS7 structure readable via Parse"],"goal":"verify github.com/smallstep/pkcs7.PKCS7 in pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81","kind":"HOW","packages":["pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81"],"schemaVersion":1,"symbols":["github.com/smallstep/pkcs7.PKCS7"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81"],"schemaVersion":1,"subject":"pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81","symbols":["github.com/smallstep/pkcs7.PKCS7"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/smallstep/pkcs7 v0.2.3

github.com/smallstep/pkcs7 v0.2.3 h1:bhoQ3TeZmdoXTatcwxCbk+FMcdsyr0gYrrW2Xq2qr+s=
github.com/smallstep/pkcs7 v0.2.3/go.mod h1:7STkdKhZaZe4xNEXTtY4j1NGeST1gYM4GA40kC5iqr8=

package main

import (
	"bytes"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"fmt"
	"math/big"
	"time"

	"github.com/smallstep/pkcs7"
)

// generateKeyPairAndCert generates a self-signed certificate and private key for testing.
func generateKeyPairAndCert() (*x509.Certificate, *rsa.PrivateKey, error) {
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return nil, nil, fmt.Errorf("generate RSA private key: %w", err)
	}

	template := &x509.Certificate{
		SerialNumber: big.NewInt(100),
		Subject: pkix.Name{
			CommonName: "pkcs7.example.com",
		},
		NotBefore:             time.Now().Add(-1 * time.Hour),
		NotAfter:              time.Now().Add(24 * time.Hour),
		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning, x509.ExtKeyUsageEmailProtection},
		BasicConstraintsValid: true,
		IsCA:                  true,
	}

	der, err := x509.CreateCertificate(rand.Reader, template, template, &priv.PublicKey, priv)
	if err != nil {
		return nil, nil, fmt.Errorf("create certificate: %w", err)
	}

	cert, err := x509.ParseCertificate(der)
	if err != nil {
		return nil, nil, fmt.Errorf("parse certificate: %w", err)
	}

	return cert, priv, nil
}

func main() {
	cert, privKey, err := generateKeyPairAndCert()
	if err != nil {
		fmt.Printf("Initialization error: %v\n", err)
		return
	}

	message := []byte("PKCS#7 cryptographic message structure demonstration")

	// 1. Sign data and produce PKCS#7 SignedData DER
	signedData, err := pkcs7.NewSignedData(message)
	if err != nil {
		fmt.Printf("Failed to create SignedData: %v\n", err)
		return
	}

	if err := signedData.AddSigner(cert, privKey, pkcs7.SignerInfoConfig{}); err != nil {
		fmt.Printf("Failed to add signer: %v\n", err)
		return
	}

	signedDER, err := signedData.Finish()
	if err != nil {
		fmt.Printf("Failed to finish SignedData: %v\n", err)
		return
	}

	// 2. Parse PKCS#7 structure and verify signature
	p7Signed, err := pkcs7.Parse(signedDER)
	if err != nil {
		fmt.Printf("Failed to parse PKCS#7 signed DER: %v\n", err)
		return
	}

	if err := p7Signed.Verify(); err != nil {
		fmt.Printf("Signature verification failed: %v\n", err)
		return
	}

	signerCert := p7Signed.GetOnlySigner()
	if signerCert != nil {
		fmt.Printf("Verified signer: %s\n", signerCert.Subject.CommonName)
	}

	// 3. Encrypt payload to PKCS#7 EnvelopedData DER
	encryptedDER, err := pkcs7.Encrypt(message, []*x509.Certificate{cert})
	if err != nil {
		fmt.Printf("Failed to encrypt data: %v\n", err)
		return
	}

	// 4. Parse encrypted PKCS#7 structure and decrypt
	p7Encrypted, err := pkcs7.Parse(encryptedDER)
	if err != nil {
		fmt.Printf("Failed to parse PKCS#7 encrypted DER: %v\n", err)
		return
	}

	decryptedContent, err := p7Encrypted.Decrypt(cert, privKey)
	if err != nil {
		fmt.Printf("Decryption failed: %v\n", err)
		return
	}

	if bytes.Equal(decryptedContent, message) {
		fmt.Printf("Successfully decrypted payload: %s\n", string(decryptedContent))
	}
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/smallstep/pkcs7.PKCS7 in pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/smallstep/pkcs7@v0.0.0-20231024181729-3b98ecc1ca81"
  ],
  "symbols": [
    "github.com/smallstep/pkcs7.PKCS7"
  ]
}

package main

import (
	"bytes"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"fmt"
	"math/big"
	"os"
	"time"

	"github.com/smallstep/pkcs7"
)

func createTestCertificate(commonName string) (*x509.Certificate, *rsa.PrivateKey, error) {
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to generate RSA key: %w", err)
	}

	template := &x509.Certificate{
		SerialNumber: big.NewInt(1001),
		Subject: pkix.Name{
			CommonName: commonName,
		},
		NotBefore:             time.Now().Add(-1 * time.Hour),
		NotAfter:              time.Now().Add(24 * time.Hour),
		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning, x509.ExtKeyUsageEmailProtection},
		BasicConstraintsValid: true,
		IsCA:                  true,
	}

	derBytes, err := x509.CreateCertificate(rand.Reader, template, template, &priv.PublicKey, priv)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to create certificate: %w", err)
	}

	cert, err := x509.ParseCertificate(derBytes)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to parse certificate: %w", err)
	}

	return cert, priv, nil
}

func main() {
	cert, privKey, err := createTestCertificate("signer.example.com")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: failed to create test certificate: %v\n", err)
		os.Exit(1)
	}

	rawPayload := []byte("Verified PKCS#7 contract test payload 2026")

	// Assertion 1: Parse parses DER-encoded PKCS#7 SignedData payload into a PKCS7 instance and preserves content bytes
	var signedDER []byte
	{
		sd, err := pkcs7.NewSignedData(rawPayload)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: NewSignedData failed: %v\n", err)
			os.Exit(1)
		}

		if err := sd.AddSigner(cert, privKey, pkcs7.SignerInfoConfig{}); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: AddSigner failed: %v\n", err)
			os.Exit(1)
		}

		signedDER, err = sd.Finish()
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Finish failed: %v\n", err)
			os.Exit(1)
		}

		p7, err := pkcs7.Parse(signedDER)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Parse failed: %v\n", err)
			os.Exit(1)
		}

		if !bytes.Equal(p7.Content, rawPayload) {
			fmt.Fprintf(os.Stderr, "FAIL: parsed Content mismatch: got %q, want %q\n", p7.Content, rawPayload)
			os.Exit(1)
		}

		if len(p7.Certificates) == 0 {
			fmt.Fprintf(os.Stderr, "FAIL: expected certificates in parsed PKCS7\n")
			os.Exit(1)
		}
	}

	// Assertion 2: Verify verifies the signature of a signed PKCS7 payload against embedded signer certificates
	p7Signed, err := pkcs7.Parse(signedDER)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: Parse signedDER failed: %v\n", err)
		os.Exit(1)
	}

	if err := p7Signed.Verify(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: Verify signature failed: %v\n", err)
		os.Exit(1)
	}

	// Assertion 3: VerifyWithChain validates signature trust against a root certificate pool and rejects untrusted pools
	{
		trustedPool := x509.NewCertPool()
		trustedPool.AddCert(cert)

		if err := p7Signed.VerifyWithChain(trustedPool); err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: VerifyWithChain failed on trusted pool: %v\n", err)
			os.Exit(1)
		}

		emptyPool := x509.NewCertPool()
		if err := p7Signed.VerifyWithChain(emptyPool); err == nil {
			fmt.Fprintf(os.Stderr, "FAIL: VerifyWithChain should reject untrusted empty pool\n")
			os.Exit(1)
		}
	}

	// Assertion 4: Decrypt recovers original plaintext from an EnvelopedData PKCS7 instance using private key and certificate
	{
		secretData := []byte("top secret payload data")
		encDER, err := pkcs7.Encrypt(secretData, []*x509.Certificate{cert})
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Encrypt failed: %v\n", err)
			os.Exit(1)
		}

		p7Enc, err := pkcs7.Parse(encDER)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Parse encrypted DER failed: %v\n", err)
			os.Exit(1)
		}

		decrypted, err := p7Enc.Decrypt(cert, privKey)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Decrypt failed: %v\n", err)
			os.Exit(1)
		}

		if !bytes.Equal(decrypted, secretData) {
			fmt.Fprintf(os.Stderr, "FAIL: Decrypted content mismatch: got %q, want %q\n", decrypted, secretData)
			os.Exit(1)
		}
	}

	// Assertion 5: GetOnlySigner extracts the single leaf signer certificate from a valid SignedData PKCS7 instance
	{
		signer := p7Signed.GetOnlySigner()
		if signer == nil {
			fmt.Fprintf(os.Stderr, "FAIL: GetOnlySigner returned nil\n")
			os.Exit(1)
		}

		if signer.Subject.CommonName != "signer.example.com" {
			fmt.Fprintf(os.Stderr, "FAIL: Signer CommonName mismatch: got %s, want signer.example.com\n", signer.Subject.CommonName)
			os.Exit(1)
		}
	}

	// Assertion 6: DegenerateCertificate creates a certificate-only PKCS7 structure readable via Parse
	{
		degDER, err := pkcs7.DegenerateCertificate(cert.Raw)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: DegenerateCertificate failed: %v\n", err)
			os.Exit(1)
		}

		p7Deg, err := pkcs7.Parse(degDER)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Parse degenerate certificate failed: %v\n", err)
			os.Exit(1)
		}

		if len(p7Deg.Certificates) != 1 || p7Deg.Certificates[0].Subject.CommonName != "signer.example.com" {
			fmt.Fprintf(os.Stderr, "FAIL: Degenerate certificates mismatch\n")
			os.Exit(1)
		}
	}

	fmt.Println("PASS: smallstep/pkcs7.PKCS7 contract passed")
}