golang.org/x/crypto v0.48.0: sha3.New256

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

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/crypto@v0.48.0
Demonstrate these symbols/APIs:
  - golang.org/x/crypto/sha3.New256

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:69514281bd496a19b3e77ac52e5719195f97a8a8f5085946a4e4e63470792018","contract":["sha3.New256 returns a hash.Hash with Size 32 bytes and BlockSize 136 bytes","sha3.New256 computes the correct SHA3-256 digest for empty input","sha3.New256 computes the correct SHA3-256 digest for standard test message","sha3.New256 produces identical digest when written in single write or incremental chunks","sha3.New256 Reset clears state and produces same digest as new instance","sha3.New256 Sum appends the 32-byte digest to existing slice buffer"],"goal":"verify golang.org/x/crypto/sha3.New256 in pkg:golang/golang.org/x/crypto@v0.48.0","kind":"HOW","packages":["pkg:golang/golang.org/x/crypto@v0.48.0"],"schemaVersion":1,"symbols":["golang.org/x/crypto/sha3.New256"]},"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.48.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/crypto@v0.48.0","symbols":["golang.org/x/crypto/sha3.New256"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require golang.org/x/crypto v0.48.0

require golang.org/x/sys v0.47.0 // indirect

golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=

package main

import (
	"encoding/hex"
	"fmt"
	"log"

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

func main() {
	msg := []byte("The quick brown fox jumps over the lazy dog")

	// Initialize SHA3-256 hasher
	hasher := sha3.New256()

	// Hash the input message
	if _, err := hasher.Write(msg); err != nil {
		log.Fatalf("failed to write data: %v", err)
	}

	// Compute final digest
	digest := hasher.Sum(nil)
	fmt.Printf("SHA3-256 digest: %s\n", hex.EncodeToString(digest))
	fmt.Printf("Digest size: %d bytes, rate block size: %d bytes\n", hasher.Size(), hasher.BlockSize())
}

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

package main

import (
	"bytes"
	"encoding/hex"
	"fmt"
	"os"

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

func main() {
	// 1. sha3.New256 returns a hash.Hash with Size 32 bytes and BlockSize 136 bytes
	h := sha3.New256()
	if h.Size() != 32 {
		fmt.Fprintf(os.Stderr, "assertion 1 failed: Size expected 32, got %d\n", h.Size())
		os.Exit(1)
	}
	if h.BlockSize() != 136 {
		fmt.Fprintf(os.Stderr, "assertion 1 failed: BlockSize expected 136, got %d\n", h.BlockSize())
		os.Exit(1)
	}

	// 2. sha3.New256 computes the correct SHA3-256 digest for empty input
	hEmpty := sha3.New256()
	emptyDigest := hEmpty.Sum(nil)
	expectedEmptyHex := "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"
	if hex.EncodeToString(emptyDigest) != expectedEmptyHex {
		fmt.Fprintf(os.Stderr, "assertion 2 failed: empty digest expected %s, got %s\n", expectedEmptyHex, hex.EncodeToString(emptyDigest))
		os.Exit(1)
	}

	// 3. sha3.New256 computes the correct SHA3-256 digest for standard test message
	hMsg := sha3.New256()
	msg := []byte("The quick brown fox jumps over the lazy dog")
	if n, err := hMsg.Write(msg); err != nil || n != len(msg) {
		fmt.Fprintf(os.Stderr, "assertion 3 failed: Write returned err %v, n %d\n", err, n)
		os.Exit(1)
	}
	msgDigest := hMsg.Sum(nil)
	expectedMsgHex := "69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04"
	if hex.EncodeToString(msgDigest) != expectedMsgHex {
		fmt.Fprintf(os.Stderr, "assertion 3 failed: msg digest expected %s, got %s\n", expectedMsgHex, hex.EncodeToString(msgDigest))
		os.Exit(1)
	}

	// 4. sha3.New256 produces identical digest when written in single write or incremental chunks
	hChunked := sha3.New256()
	chunks := [][]byte{
		[]byte("The quick brown "),
		[]byte("fox jumps over "),
		[]byte("the lazy dog"),
	}
	for _, chunk := range chunks {
		if _, err := hChunked.Write(chunk); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Write chunk err: %v\n", err)
			os.Exit(1)
		}
	}
	chunkedDigest := hChunked.Sum(nil)
	if !bytes.Equal(chunkedDigest, msgDigest) {
		fmt.Fprintf(os.Stderr, "assertion 4 failed: chunked digest != single write digest\n")
		os.Exit(1)
	}

	// 5. sha3.New256 Reset clears state and produces same digest as new instance
	hReset := sha3.New256()
	hReset.Write([]byte("some completely different intermediate state"))
	hReset.Reset()
	hReset.Write(msg)
	resetDigest := hReset.Sum(nil)
	if !bytes.Equal(resetDigest, msgDigest) {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: reset digest != original digest\n")
		os.Exit(1)
	}

	// 6. sha3.New256 Sum appends the 32-byte digest to existing slice buffer
	hSum := sha3.New256()
	hSum.Write(msg)
	prefix := []byte{0xDE, 0xAD, 0xBE, 0xEF}
	combined := hSum.Sum(prefix)
	if len(combined) != len(prefix)+32 {
		fmt.Fprintf(os.Stderr, "assertion 6 failed: length mismatch, expected %d, got %d\n", len(prefix)+32, len(combined))
		os.Exit(1)
	}
	if !bytes.Equal(combined[:len(prefix)], prefix) {
		fmt.Fprintf(os.Stderr, "assertion 6 failed: prefix not preserved\n")
		os.Exit(1)
	}
	if !bytes.Equal(combined[len(prefix):], msgDigest) {
		fmt.Fprintf(os.Stderr, "assertion 6 failed: appended digest does not match\n")
		os.Exit(1)
	}

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