github.com/slackhq/nebula v1.6.1: header.Encode

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/slackhq/nebula/header.Encode in pkg:golang/github.com/slackhq/nebula@v1.6.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/slackhq/nebula@v1.6.1
Demonstrate these symbols/APIs:
  - github.com/slackhq/nebula/header.Encode

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:6d03a77054b8002009f8b5b3edeefd8308e98ac02572e96e1fa02f95ca9e181a","contract":["header.Encode encodes version, type, subtype, remote index, and message counter into a 16-byte binary header slice","header.NewHeader successfully parses the binary buffer written by header.Encode to recover all header fields","header.H.Encode delegates to header.Encode to serialize a Header struct into 16 bytes","header.Encode explicitly zeroes reserved bytes in positions 2 and 3 of the header buffer"],"goal":"verify github.com/slackhq/nebula/header.Encode in pkg:golang/github.com/slackhq/nebula@v1.6.1","kind":"HOW","packages":["pkg:golang/github.com/slackhq/nebula@v1.6.1"],"schemaVersion":1,"symbols":["github.com/slackhq/nebula/header.Encode"]},"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/slackhq/nebula@v1.6.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/slackhq/nebula@v1.6.1","symbols":["github.com/slackhq/nebula/header.Encode"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/slackhq/nebula v1.6.1

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/slackhq/nebula v1.6.1 h1:/OCTR3abj0Sbf2nGoLUrdDXImrCv0ZVFpVPP5qa0DsM=
github.com/slackhq/nebula v1.6.1/go.mod h1:UmkqnXe4O53QwToSl/gG7sM4BroQwAB7dd4hUaT6MlI=
github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

package main

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

	"github.com/slackhq/nebula/header"
)

// EncodeMessageHeader encodes a Nebula message header with the given parameters.
func EncodeMessageHeader(remoteIndex uint32, messageCounter uint64) []byte {
	buf := make([]byte, header.Len)
	return header.Encode(buf, header.Version, header.Message, header.MessageNone, remoteIndex, messageCounter)
}

// EncodeHandshakeHeader encodes a Nebula handshake header using header.H struct.
func EncodeHandshakeHeader(remoteIndex uint32, messageCounter uint64) ([]byte, error) {
	h := &header.H{
		Version:        header.Version,
		Type:           header.Handshake,
		Subtype:        header.HandshakeIXPSK0,
		Reserved:       0,
		RemoteIndex:    remoteIndex,
		MessageCounter: messageCounter,
	}
	buf := make([]byte, header.Len)
	return h.Encode(buf)
}

func main() {
	// Encode a message header
	msgBuf := EncodeMessageHeader(1001, 42)
	fmt.Printf("Encoded Message Header (%d bytes): %s\n", len(msgBuf), hex.EncodeToString(msgBuf))

	parsedMsg, err := header.NewHeader(msgBuf)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to parse message header: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Parsed: %s\n", parsedMsg.String())

	// Encode a handshake header
	hsBuf, err := EncodeHandshakeHeader(2002, 1)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to encode handshake header: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Encoded Handshake Header (%d bytes): %s\n", len(hsBuf), hex.EncodeToString(hsBuf))

	parsedHs, err := header.NewHeader(hsBuf)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to parse handshake header: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Parsed: %s\n", parsedHs.String())
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/slackhq/nebula/header.Encode in pkg:golang/github.com/slackhq/nebula@v1.6.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/slackhq/nebula@v1.6.1"
  ],
  "symbols": [
    "github.com/slackhq/nebula/header.Encode"
  ]
}

package main

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

	"github.com/slackhq/nebula/header"
)

func main() {
	// Assertion 1: header.Encode encodes version, type, subtype, remote index, and message counter into a 16-byte binary header slice
	buf := make([]byte, header.Len)
	var version uint8 = 1
	msgType := header.Message
	subType := header.MessageRelay
	var remoteIndex uint32 = 0x12345678
	var counter uint64 = 0x0102030405060708

	encoded := header.Encode(buf, version, msgType, subType, remoteIndex, counter)
	if len(encoded) != header.Len {
		fmt.Fprintf(os.Stderr, "FAIL: expected encoded length %d, got %d\n", header.Len, len(encoded))
		os.Exit(1)
	}
	if encoded[0] != (version<<4 | byte(msgType&0x0f)) {
		fmt.Fprintf(os.Stderr, "FAIL: byte 0 mismatch: expected 0x%02x, got 0x%02x\n", version<<4|byte(msgType&0x0f), encoded[0])
		os.Exit(1)
	}
	if encoded[1] != byte(subType) {
		fmt.Fprintf(os.Stderr, "FAIL: byte 1 mismatch: expected 0x%02x, got 0x%02x\n", byte(subType), encoded[1])
		os.Exit(1)
	}
	if binary.BigEndian.Uint32(encoded[4:8]) != remoteIndex {
		fmt.Fprintf(os.Stderr, "FAIL: remote index mismatch: expected 0x%x, got 0x%x\n", remoteIndex, binary.BigEndian.Uint32(encoded[4:8]))
		os.Exit(1)
	}
	if binary.BigEndian.Uint64(encoded[8:16]) != counter {
		fmt.Fprintf(os.Stderr, "FAIL: message counter mismatch: expected 0x%x, got 0x%x\n", counter, binary.BigEndian.Uint64(encoded[8:16]))
		os.Exit(1)
	}

	// Assertion 2: header.NewHeader successfully parses the binary buffer written by header.Encode to recover all header fields
	parsed, err := header.NewHeader(encoded)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: header.NewHeader returned unexpected error: %v\n", err)
		os.Exit(1)
	}
	if parsed.Version != version {
		fmt.Fprintf(os.Stderr, "FAIL: parsed version mismatch: expected %d, got %d\n", version, parsed.Version)
		os.Exit(1)
	}
	if parsed.Type != msgType {
		fmt.Fprintf(os.Stderr, "FAIL: parsed type mismatch: expected %d, got %d\n", msgType, parsed.Type)
		os.Exit(1)
	}
	if parsed.Subtype != subType {
		fmt.Fprintf(os.Stderr, "FAIL: parsed subtype mismatch: expected %d, got %d\n", subType, parsed.Subtype)
		os.Exit(1)
	}
	if parsed.RemoteIndex != remoteIndex {
		fmt.Fprintf(os.Stderr, "FAIL: parsed remote index mismatch: expected 0x%x, got 0x%x\n", remoteIndex, parsed.RemoteIndex)
		os.Exit(1)
	}
	if parsed.MessageCounter != counter {
		fmt.Fprintf(os.Stderr, "FAIL: parsed message counter mismatch: expected 0x%x, got 0x%x\n", counter, parsed.MessageCounter)
		os.Exit(1)
	}

	// Assertion 3: header.H.Encode delegates to header.Encode to serialize a Header struct into 16 bytes
	hdrStruct := &header.H{
		Version:        version,
		Type:           msgType,
		Subtype:        subType,
		Reserved:       0,
		RemoteIndex:    remoteIndex,
		MessageCounter: counter,
	}
	structBuf := make([]byte, header.Len)
	structEncoded, err := hdrStruct.Encode(structBuf)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: hdrStruct.Encode returned error: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(structEncoded, encoded) {
		fmt.Fprintf(os.Stderr, "FAIL: hdrStruct.Encode output differs from header.Encode output\n")
		os.Exit(1)
	}

	// Assertion 4: header.Encode explicitly zeroes reserved bytes in positions 2 and 3 of the header buffer
	dirtyBuf := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
	zeroCleaned := header.Encode(dirtyBuf, version, msgType, subType, remoteIndex, counter)
	if zeroCleaned[2] != 0 || zeroCleaned[3] != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: reserved bytes not zeroed: [2]=%d, [3]=%d\n", zeroCleaned[2], zeroCleaned[3])
		os.Exit(1)
	}

	fmt.Println("PASS: github.com/slackhq/nebula/header.Encode contract verified")
}