golang.org/x/crypto v0.20.0: hkdf.New

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 hkdf.New in 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
Demonstrate these symbols/APIs:
  - hkdf.New

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:511ee3ed0750579ca3e5415826e4dc18a846140f4fcf35066dc5a8bd467b8322","contract":["hkdf.New returns an io.Reader that derives pseudorandom keys using SHA-256","hkdf.New is deterministic and returns identical bytes for identical secret, salt, and info inputs","hkdf.New with nil salt is equivalent to using a zero-filled salt matching hash size","hkdf.New produces different key streams for different info context strings","hkdf.New produces different key streams for different secret inputs","hkdf.New returns error when reading beyond 255 times hash size limit"],"goal":"verify hkdf.New in pkg:golang/golang.org/x/crypto@v0.20.0","kind":"HOW","packages":["pkg:golang/golang.org/x/crypto@v0.20.0"],"schemaVersion":1,"symbols":["hkdf.New"]},"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","symbols":["hkdf.New"],"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")

	// Derive key stream 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)
	fmt.Println("HKDF key derivation successful.")
}

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

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.New returns an io.Reader that derives pseudorandom keys using SHA-256
	reader := hkdf.New(sha256.New, secret, salt, info)
	derivedKey := make([]byte, 32)
	n, err := io.ReadFull(reader, derivedKey)
	if err != nil || n != 32 {
		fmt.Fprintf(os.Stderr, "hkdf.New ReadFull failed: err=%v, n=%d\n", err, n)
		os.Exit(1)
	}

	// 2. hkdf.New is deterministic and returns identical bytes for identical secret, salt, and info inputs
	reader2 := hkdf.New(sha256.New, secret, salt, info)
	derivedKey2 := make([]byte, 32)
	if _, err := io.ReadFull(reader2, derivedKey2); err != nil {
		fmt.Fprintf(os.Stderr, "hkdf.New second read failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(derivedKey, derivedKey2) {
		fmt.Fprintf(os.Stderr, "hkdf.New is not deterministic for identical inputs\n")
		os.Exit(1)
	}

	// 3. hkdf.New with nil salt is equivalent to using a zero-filled salt matching hash size
	zeroSalt := make([]byte, sha256.Size)
	readerNilSalt := hkdf.New(sha256.New, secret, nil, info)
	readerZeroSalt := hkdf.New(sha256.New, secret, zeroSalt, info)
	keyNilSalt := make([]byte, 32)
	keyZeroSalt := make([]byte, 32)
	if _, err := io.ReadFull(readerNilSalt, keyNilSalt); err != nil {
		fmt.Fprintf(os.Stderr, "hkdf.New with nil salt failed: %v\n", err)
		os.Exit(1)
	}
	if _, err := io.ReadFull(readerZeroSalt, keyZeroSalt); err != nil {
		fmt.Fprintf(os.Stderr, "hkdf.New with zero salt failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(keyNilSalt, keyZeroSalt) {
		fmt.Fprintf(os.Stderr, "hkdf.New with nil salt does not match zero-filled salt\n")
		os.Exit(1)
	}

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

	// 5. hkdf.New produces different key streams for different secret inputs
	readerDiffSecret := hkdf.New(sha256.New, []byte("different-secret-key-material"), salt, info)
	keyDiffSecret := make([]byte, 32)
	if _, err := io.ReadFull(readerDiffSecret, keyDiffSecret); err != nil {
		fmt.Fprintf(os.Stderr, "hkdf.New with different secret failed: %v\n", err)
		os.Exit(1)
	}
	if bytes.Equal(derivedKey, keyDiffSecret) {
		fmt.Fprintf(os.Stderr, "hkdf.New should produce different key streams for different secrets\n")
		os.Exit(1)
	}

	// 6. hkdf.New returns error when reading beyond 255 times hash size limit
	limitReader := hkdf.New(sha256.New, secret, salt, info)
	chunk := make([]byte, sha256.Size)
	for i := 0; i < 255; i++ {
		if _, err := io.ReadFull(limitReader, chunk); err != nil {
			fmt.Fprintf(os.Stderr, "hkdf.New 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, "hkdf.New should return error when reading beyond 255*hash.Size bytes\n")
		os.Exit(1)
	}

	fmt.Println("All hkdf.New contract assertions passed.")
}