golang.org/x/crypto v0.20.0

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 pkg:golang/golang.org/x/crypto@v0.20.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/crypto@v0.20.0

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:5bec013138709c9521b951ebfdacf6f20325e6781731dce97f88be8c24a1ab54","contract":["hkdf.Extract derives pseudorandom key matching hash size from secret and salt","hkdf.Extract with nil salt defaults to zeros and derives deterministic pseudorandom key","hkdf.Expand expands pseudorandom key and info context into derived key bytes","hkdf.New derives key bytes identical to sequential Extract and Expand calls","hkdf.New produces different key streams for different info context strings","hkdf.Expand returns error when reading beyond 255 times hash size limit"],"goal":"verify pkg:golang/golang.org/x/crypto@v0.20.0","kind":"HOW","packages":["pkg:golang/golang.org/x/crypto@v0.20.0"],"schemaVersion":1},"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/golang.org/x/crypto@v0.20.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/crypto@v0.20.0","verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require golang.org/x/crypto v0.20.0

golang.org/x/crypto v0.20.0 h1:jmAMJJZXr5KiCw05dfYK9QnqaqKLYXijU23lsEdcQqg=
golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ=

package main

import (
	"crypto/sha256"
	"fmt"
	"io"
	"log"

	"golang.org/x/crypto/hkdf"
)

func main() {
	secret := []byte("master-secret-key-32-bytes-long!")
	salt := []byte("arbitrary-salt-value")
	info := []byte("sample-app-encryption-key-v1")

	// 1. Derive key directly using hkdf.New
	kdfReader := hkdf.New(sha256.New, secret, salt, info)
	derivedKey := make([]byte, 32)
	if _, err := io.ReadFull(kdfReader, derivedKey); err != nil {
		log.Fatalf("hkdf.New failed: %v", err)
	}
	fmt.Printf("Derived key (32 bytes): %x\n", derivedKey)

	// 2. Derive key in two stages: Extract then Expand
	prk := hkdf.Extract(sha256.New, secret, salt)
	fmt.Printf("PRK (32 bytes): %x\n", prk)

	expandedReader := hkdf.Expand(sha256.New, prk, info)
	expandedKey := make([]byte, 32)
	if _, err := io.ReadFull(expandedReader, expandedKey); err != nil {
		log.Fatalf("hkdf.Expand failed: %v", err)
	}
	fmt.Printf("Expanded key (32 bytes): %x\n", expandedKey)

	fmt.Println("HKDF key derivation successful.")
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/golang.org/x/crypto@v0.20.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/crypto@v0.20.0"
  ]
}

package main

import (
	"bytes"
	"crypto/sha256"
	"fmt"
	"io"
	"os"

	"golang.org/x/crypto/hkdf"
)

func main() {
	secret := []byte("input-keying-material-super-secret")
	salt := []byte("application-salt-12345")
	info := []byte("contract-test-context-info")

	// 1. hkdf.Extract derives pseudorandom key matching hash size from secret and salt
	prk := hkdf.Extract(sha256.New, secret, salt)
	if len(prk) != sha256.Size {
		fmt.Fprintf(os.Stderr, "Extract PRK length mismatch: got %d, want %d\n", len(prk), sha256.Size)
		os.Exit(1)
	}
	prkRepeat := hkdf.Extract(sha256.New, secret, salt)
	if !bytes.Equal(prk, prkRepeat) {
		fmt.Fprintf(os.Stderr, "Extract is not deterministic for same inputs\n")
		os.Exit(1)
	}

	// 2. hkdf.Extract with nil salt defaults to zeros and derives deterministic pseudorandom key
	prkNilSalt := hkdf.Extract(sha256.New, secret, nil)
	if len(prkNilSalt) != sha256.Size {
		fmt.Fprintf(os.Stderr, "Extract with nil salt length mismatch: got %d, want %d\n", len(prkNilSalt), sha256.Size)
		os.Exit(1)
	}
	if bytes.Equal(prk, prkNilSalt) {
		fmt.Fprintf(os.Stderr, "Extract with nil salt should differ from Extract with explicit salt\n")
		os.Exit(1)
	}

	// 3. hkdf.Expand expands pseudorandom key and info context into derived key bytes
	expanded := make([]byte, 48)
	expandReader := hkdf.Expand(sha256.New, prk, info)
	n, err := io.ReadFull(expandReader, expanded)
	if err != nil || n != 48 {
		fmt.Fprintf(os.Stderr, "Expand ReadFull failed: err=%v, read=%d\n", err, n)
		os.Exit(1)
	}

	// 4. hkdf.New derives key bytes identical to sequential Extract and Expand calls
	newReader := hkdf.New(sha256.New, secret, salt, info)
	newKey := make([]byte, 48)
	n, err = io.ReadFull(newReader, newKey)
	if err != nil || n != 48 {
		fmt.Fprintf(os.Stderr, "New ReadFull failed: err=%v, read=%d\n", err, n)
		os.Exit(1)
	}
	if !bytes.Equal(expanded, newKey) {
		fmt.Fprintf(os.Stderr, "New output does not match Extract+Expand output: %x vs %x\n", newKey, expanded)
		os.Exit(1)
	}

	// 5. hkdf.New produces different key streams for different info context strings
	otherInfoReader := hkdf.New(sha256.New, secret, salt, []byte("different-context-info"))
	otherKey := make([]byte, 48)
	if _, err := io.ReadFull(otherInfoReader, otherKey); err != nil {
		fmt.Fprintf(os.Stderr, "New with different info failed: %v\n", err)
		os.Exit(1)
	}
	if bytes.Equal(newKey, otherKey) {
		fmt.Fprintf(os.Stderr, "New should produce different outputs for different info\n")
		os.Exit(1)
	}

	// 6. hkdf.Expand returns error when reading beyond 255 times hash size limit
	limitReader := hkdf.Expand(sha256.New, prk, info)
	chunk := make([]byte, sha256.Size)
	for i := 0; i < 255; i++ {
		if _, err := io.ReadFull(limitReader, chunk); err != nil {
			fmt.Fprintf(os.Stderr, "Expand chunk %d read failed: %v\n", i, err)
			os.Exit(1)
		}
	}
	buf := make([]byte, 1)
	if _, err := limitReader.Read(buf); err == nil {
		fmt.Fprintf(os.Stderr, "Expand should return error when reading beyond 255*hash.Size bytes\n")
		os.Exit(1)
	}

	fmt.Println("All HKDF contract assertions passed.")
}