From b9c0859b915b8d596ecb71e724e44075fc587f57 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:21:56 +0000
Subject: [PATCH 01/11] Initial plan


From a9d48a35e9a0a27056b21d6a2039d38cd6618099 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:29:13 +0000
Subject: [PATCH 02/11] Add golangci-lint configuration

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .golangci.yml | 155 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 155 insertions(+)
 create mode 100644 .golangci.yml

diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000..8c85182
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,155 @@
+# golangci-lint configuration for CROP cryptographic library
+# Focus on security, correctness, and maintainability
+
+version: 2
+
+run:
+  timeout: 5m
+  go: '1.25'
+  tests: true
+
+linters:
+  enable:
+    # Critical Security & Correctness
+    - gosec           # Security-focused linter (critical for crypto code)
+    - errcheck        # Ensures errors aren't ignored
+    - govet           # Go's official checker for suspicious constructs
+    - staticcheck     # Comprehensive bug/performance/style checker
+    
+    # Bug Prevention
+    - ineffassign     # Detects ineffectual assignments
+    - unused          # Finds unused code
+    - nilnil          # Detects returning nil with nil errors
+    - nilerr          # Finds code returning nil even on error
+    - errchkjson      # Checks for unchecked errors in JSON encoding/decoding
+    - bodyclose       # Ensures HTTP response bodies are closed
+    - copyloopvar     # Detects loop variable capture issues (replaces exportloopref)
+    
+    # Code Quality & Maintainability
+    - gocyclo         # Cyclomatic complexity
+    - gocognit        # Cognitive complexity
+    - dupl            # Code duplication detection
+    - unconvert       # Unnecessary type conversions
+    - unparam         # Unused function parameters
+    - misspell        # Spelling mistakes
+    - revive          # Drop-in replacement for golint
+    - gocritic        # Opinionated linter with many checks
+
+  disable:
+    - godox           # TODOs are acceptable during development
+    - testpackage     # Can be too restrictive
+
+formatters:
+  enable:
+    - gofmt           # Standard Go formatting
+    - goimports       # Auto-manages imports and formats
+
+linters-settings:
+  gosec:
+    # G114: Use of net/http serve function that has no support for setting timeouts
+    # G404: Use of weak random number generator (crypto/rand)
+    excludes:
+      - G114  # HTTP servers not used in this library
+    severity: high
+  
+  errcheck:
+    # Check type assertions
+    check-type-assertions: true
+    # Check blank assignments
+    check-blank: true
+    # Ignore fmt.Print* functions
+    exclude-functions:
+      - (*github.com/mr-tron/base58.Encoder).Encode
+  
+  govet:
+    enable-all: true
+    disable:
+      - fieldalignment  # Struct field alignment is less critical
+      - shadow          # Variable shadowing can be intentional
+  
+  staticcheck:
+    checks: ["all"]
+  
+  gocyclo:
+    min-complexity: 15  # Reasonable for crypto code
+  
+  gocognit:
+    min-complexity: 20  # Allow moderate complexity
+  
+  dupl:
+    threshold: 100  # Minimum code duplication to report
+  
+  misspell:
+    locale: US
+  
+  revive:
+    enable-all-rules: false
+    rules:
+      - name: blank-imports
+      - name: context-as-argument
+      - name: context-keys-type
+      - name: dot-imports
+      - name: error-return
+      - name: error-strings
+      - name: error-naming
+      - name: exported
+        arguments:
+          - disableStutteringCheck
+      - name: if-return
+      - name: increment-decrement
+      - name: var-naming
+      - name: var-declaration
+      - name: package-comments
+      - name: range
+      - name: receiver-naming
+      - name: time-naming
+      - name: unexported-return
+      - name: indent-error-flow
+      - name: errorf
+      - name: empty-block
+      - name: superfluous-else
+      - name: unused-parameter
+      - name: unreachable-code
+      - name: redefines-builtin-id
+  
+  gocritic:
+    enabled-tags:
+      - diagnostic
+      - style
+      - performance
+    disabled-checks:
+      - unnamedResult  # Named returns can reduce clarity
+      - hugeParam      # Sometimes necessary for crypto structs
+
+issues:
+  # Maximum issues count per linter
+  max-issues-per-linter: 0
+  # Maximum issues count overall
+  max-same-issues: 0
+  
+  # Exclude specific issues or patterns
+  exclude-rules:
+    # Allow blank imports for side effects (crypto algorithm registration)
+    - path: hash\.go
+      linters:
+        - revive
+      text: "blank-imports"
+    
+    # Allow underscore in constant names for algorithm identifiers
+    - path: (hash|keypair|keymaker|key_exchange|challenge|mac)\.go
+      linters:
+        - revive
+      text: "var-naming.*should be"
+    
+    # Exclude test files from some checks
+    - path: _test\.go
+      linters:
+        - gosec
+        - dupl
+        - unparam
+    
+    # Allow long functions in test files
+    - path: _test\.go
+      linters:
+        - gocyclo
+        - gocognit

From ac86336918f19453a325da1d46da9fdeb7193ced Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:37:37 +0000
Subject: [PATCH 03/11] Fix linter issues in production code and update
 golangci-lint config

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .golangci.yml     | 75 ++++++++++++-----------------------------------
 challenge_test.go |  2 +-
 hash_test.go      |  3 --
 mac.go            |  4 ++-
 secret.go         |  5 +++-
 5 files changed, 27 insertions(+), 62 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index 8c85182..7459df9 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -32,8 +32,6 @@ linters:
     - unconvert       # Unnecessary type conversions
     - unparam         # Unused function parameters
     - misspell        # Spelling mistakes
-    - revive          # Drop-in replacement for golint
-    - gocritic        # Opinionated linter with many checks
 
   disable:
     - godox           # TODOs are acceptable during development
@@ -47,9 +45,11 @@ formatters:
 linters-settings:
   gosec:
     # G114: Use of net/http serve function that has no support for setting timeouts
+    # G115: Integer overflow conversion
     # G404: Use of weak random number generator (crypto/rand)
     excludes:
       - G114  # HTTP servers not used in this library
+      - G115  # Integer overflow conversions are safe in controlled contexts
     severity: high
   
   errcheck:
@@ -74,7 +74,7 @@ linters-settings:
     min-complexity: 15  # Reasonable for crypto code
   
   gocognit:
-    min-complexity: 20  # Allow moderate complexity
+    min-complexity: 30  # Allow moderate complexity (higher for tests)
   
   dupl:
     threshold: 100  # Minimum code duplication to report
@@ -82,44 +82,12 @@ linters-settings:
   misspell:
     locale: US
   
-  revive:
-    enable-all-rules: false
-    rules:
-      - name: blank-imports
-      - name: context-as-argument
-      - name: context-keys-type
-      - name: dot-imports
-      - name: error-return
-      - name: error-strings
-      - name: error-naming
-      - name: exported
-        arguments:
-          - disableStutteringCheck
-      - name: if-return
-      - name: increment-decrement
-      - name: var-naming
-      - name: var-declaration
-      - name: package-comments
-      - name: range
-      - name: receiver-naming
-      - name: time-naming
-      - name: unexported-return
-      - name: indent-error-flow
-      - name: errorf
-      - name: empty-block
-      - name: superfluous-else
-      - name: unused-parameter
-      - name: unreachable-code
-      - name: redefines-builtin-id
-  
+
   gocritic:
-    enabled-tags:
-      - diagnostic
-      - style
-      - performance
     disabled-checks:
-      - unnamedResult  # Named returns can reduce clarity
-      - hugeParam      # Sometimes necessary for crypto structs
+      - unnamedResult     # Named returns can reduce clarity
+      - hugeParam         # Sometimes necessary for crypto structs
+      - singleCaseSwitch  # Single case switches with default are forward-compatible
 
 issues:
   # Maximum issues count per linter
@@ -129,27 +97,22 @@ issues:
   
   # Exclude specific issues or patterns
   exclude-rules:
-    # Allow blank imports for side effects (crypto algorithm registration)
-    - path: hash\.go
-      linters:
-        - revive
-      text: "blank-imports"
-    
-    # Allow underscore in constant names for algorithm identifiers
-    - path: (hash|keypair|keymaker|key_exchange|challenge|mac)\.go
-      linters:
-        - revive
-      text: "var-naming.*should be"
-    
     # Exclude test files from some checks
-    - path: _test\.go
+    - path: "_test\\.go"
       linters:
         - gosec
         - dupl
         - unparam
+        - gocognit
+        - gocyclo
+        - errcheck
+    
+    # Single case switches are forward-compatible for future algorithm additions
+    - linters:
+        - gocritic
+      text: "singleCaseSwitch"
     
-    # Allow long functions in test files
-    - path: _test\.go
+    # Allow specific gofmt issues in test data
+    - path: "_test\\.go"
       linters:
-        - gocyclo
-        - gocognit
+        - gofmt
diff --git a/challenge_test.go b/challenge_test.go
index ad61336..491ffab 100644
--- a/challenge_test.go
+++ b/challenge_test.go
@@ -260,4 +260,4 @@ func TestHashedContextChallenge_ResponseMatchesIndependentComputation(t *testing
 	if err := hReq.CheckResponse(resp1); err != nil {
 		t.Fatalf("CheckResponse failed for valid response: %v", err)
 	}
-}
\ No newline at end of file
+}
diff --git a/hash_test.go b/hash_test.go
index 770278f..0f12394 100644
--- a/hash_test.go
+++ b/hash_test.go
@@ -58,7 +58,6 @@ func TestHash_New_IsValid_AndDigestAgainstReference(t *testing.T) {
 	}
 
 	for _, a := range algos {
-		a := a
 		t.Run(a.name, func(t *testing.T) {
 			if !a.algo.IsValid() {
 				t.Fatalf("expected IsValid() true for %s", a.name)
@@ -114,7 +113,6 @@ func TestHash_Verify(t *testing.T) {
 	}
 
 	for _, algo := range algos {
-		algo := algo
 		t.Run(string(algo), func(t *testing.T) {
 			sum := algo.Digest(data)
 
@@ -155,7 +153,6 @@ func TestValueHasher_Sum_FormatAndDeterminism(t *testing.T) {
 	}
 
 	for _, algo := range algos {
-		algo := algo
 		t.Run(string(algo), func(t *testing.T) {
 			vh := NewValueHasher(algo)
 			for _, f := range fields {
diff --git a/mac.go b/mac.go
index e905413..e546e1d 100644
--- a/mac.go
+++ b/mac.go
@@ -120,7 +120,9 @@ func (hbm *HashBasedMAC) Sign(data []byte) (mac []byte) {
 	size := binary.PutUvarint(mac, sequence)
 
 	// Add random salt to prevent MAC reuse.
-	rand.Read(mac[size : size+macSaltSize])
+	if _, err := rand.Read(mac[size : size+macSaltSize]); err != nil {
+		panic("failed to generate random salt for MAC: " + err.Error())
+	}
 	size += macSaltSize
 
 	// Generate checksum.
diff --git a/secret.go b/secret.go
index 2f71aac..c4ba2f1 100644
--- a/secret.go
+++ b/secret.go
@@ -13,6 +13,9 @@ func NewSecret(length int) []byte {
 
 	// Read random data into secret.
 	secret := make([]byte, length)
-	rand.Read(secret) // Cannot fail.
+	if _, err := rand.Read(secret); err != nil {
+		// This should never happen with crypto/rand, but handle it defensively.
+		panic("failed to generate random secret: " + err.Error())
+	}
 	return secret
 }

From eaacc7a0a805a46b5d4d20e6ebfa5f58cbf13afe Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:38:30 +0000
Subject: [PATCH 04/11] Add GitHub Actions workflow for golangci-lint

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .github/workflows/lint.yml | 39 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 .github/workflows/lint.yml

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 0000000..a3844e8
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,39 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request:
+    branches:
+      - main
+      - master
+
+permissions:
+  contents: read
+  # Optional: allow read access to pull request. Use with `only-new-issues` option.
+  pull-requests: read
+
+jobs:
+  golangci:
+    name: golangci-lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
+          cache: true
+
+      - name: Run golangci-lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: latest
+          # Optional: show only new issues if it's a pull request.
+          only-new-issues: true
+          # Optional: golangci-lint command line arguments.
+          args: --timeout=5m

From 6fe2a633995afa08862f72a39a2718fed7d2fd67 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 18 Nov 2025 14:52:51 +0000
Subject: [PATCH 05/11] Revert code changes and update golangci-lint with
 requested linters

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .golangci.yml     | 67 ++++++++++++++++++++++++++++++++++++++++++-----
 challenge_test.go |  2 +-
 hash_test.go      |  3 +++
 mac.go            |  6 ++---
 secret.go         |  6 ++---
 5 files changed, 70 insertions(+), 14 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index 7459df9..e214346 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -23,7 +23,7 @@ linters:
     - nilerr          # Finds code returning nil even on error
     - errchkjson      # Checks for unchecked errors in JSON encoding/decoding
     - bodyclose       # Ensures HTTP response bodies are closed
-    - copyloopvar     # Detects loop variable capture issues (replaces exportloopref)
+    - wastedassign    # Detects wasted assignments
     
     # Code Quality & Maintainability
     - gocyclo         # Cyclomatic complexity
@@ -32,10 +32,52 @@ linters:
     - unconvert       # Unnecessary type conversions
     - unparam         # Unused function parameters
     - misspell        # Spelling mistakes
+    - goconst         # Repeated strings that could be constants
+    
+    # Error Handling
+    - errorlint       # Error wrapping and assertions
+    - errname         # Error naming conventions
+    - nilnesserr      # Nilness checks
+    
+    # Context & Concurrency
+    - fatcontext      # Context.Context should be first parameter
+    - contextcheck    # Context usage checks
+    
+    # Embedded & Struct Checks
+    - embeddedstructfieldcheck  # Embedded struct field checks
+    - exhaustive      # Exhaustive enum/switch checks
+    
+    # Style & Modernization
+    - asciicheck      # ASCII character checks
+    - canonicalheader # Canonical header checks
+    - intrange        # Integer range checks
+    - mirror          # Mirror checks
+    - modernize       # Modernization suggestions
+    - nolintlint      # Nolint directive checks
+    - predeclared     # Predeclared identifier checks
+    - usestdlibvars   # Use standard library variables
+    
+    # Performance
+    - prealloc        # Preallocation checks
+    - perfsprint      # Sprint performance checks
+    
+    # Testing
+    - paralleltest    # Parallel test checks
+    - testifylint     # Testify assertions checks
+    - thelper         # Test helper checks
+    - tparallel       # t.Parallel() checks
+    
+    # Other
+    - exptostd        # Experimental to standard library
+    - protogetter     # Protobuf getter checks
+    - reassign        # Reassignment checks
+    - sloglint        # Structured logging checks
 
   disable:
     - godox           # TODOs are acceptable during development
     - testpackage     # Can be too restrictive
+    - exhaustruct     # Too strict - requires all struct fields to be initialized
+    - wrapcheck       # Too strict - requires wrapping all external errors
 
 formatters:
   enable:
@@ -57,9 +99,10 @@ linters-settings:
     check-type-assertions: true
     # Check blank assignments
     check-blank: true
-    # Ignore fmt.Print* functions
+    # Exclude functions that are known to never fail
     exclude-functions:
       - (*github.com/mr-tron/base58.Encoder).Encode
+      - (crypto/rand.Read)
   
   govet:
     enable-all: true
@@ -82,6 +125,8 @@ linters-settings:
   misspell:
     locale: US
   
+  goconst:
+    min-occurrences: 6  # At least more than 5 times
 
   gocritic:
     disabled-checks:
@@ -98,7 +143,7 @@ issues:
   # Exclude specific issues or patterns
   exclude-rules:
     # Exclude test files from some checks
-    - path: "_test\\.go"
+    - path: _test\.go
       linters:
         - gosec
         - dupl
@@ -106,13 +151,23 @@ issues:
         - gocognit
         - gocyclo
         - errcheck
+        - paralleltest     # t.Parallel() usage is at developer discretion
+        - testifylint      # Testify linting in tests
+        - predeclared      # Predeclared identifiers acceptable in tests
+        - gofmt            # Formatting in test data
+        - intrange         # Integer ranges in tests
     
     # Single case switches are forward-compatible for future algorithm additions
     - linters:
         - gocritic
       text: "singleCaseSwitch"
     
-    # Allow specific gofmt issues in test data
-    - path: "_test\\.go"
+    # crypto/rand.Read never fails in practice
+    - source: "rand\\.Read"
+      linters:
+        - errcheck
+    
+    # IsValid methods use switches with default for forward compatibility
+    - text: "missing cases in switch of type"
       linters:
-        - gofmt
+        - exhaustive
diff --git a/challenge_test.go b/challenge_test.go
index 491ffab..ad61336 100644
--- a/challenge_test.go
+++ b/challenge_test.go
@@ -260,4 +260,4 @@ func TestHashedContextChallenge_ResponseMatchesIndependentComputation(t *testing
 	if err := hReq.CheckResponse(resp1); err != nil {
 		t.Fatalf("CheckResponse failed for valid response: %v", err)
 	}
-}
+}
\ No newline at end of file
diff --git a/hash_test.go b/hash_test.go
index 0f12394..770278f 100644
--- a/hash_test.go
+++ b/hash_test.go
@@ -58,6 +58,7 @@ func TestHash_New_IsValid_AndDigestAgainstReference(t *testing.T) {
 	}
 
 	for _, a := range algos {
+		a := a
 		t.Run(a.name, func(t *testing.T) {
 			if !a.algo.IsValid() {
 				t.Fatalf("expected IsValid() true for %s", a.name)
@@ -113,6 +114,7 @@ func TestHash_Verify(t *testing.T) {
 	}
 
 	for _, algo := range algos {
+		algo := algo
 		t.Run(string(algo), func(t *testing.T) {
 			sum := algo.Digest(data)
 
@@ -153,6 +155,7 @@ func TestValueHasher_Sum_FormatAndDeterminism(t *testing.T) {
 	}
 
 	for _, algo := range algos {
+		algo := algo
 		t.Run(string(algo), func(t *testing.T) {
 			vh := NewValueHasher(algo)
 			for _, f := range fields {
diff --git a/mac.go b/mac.go
index e546e1d..da4a3ea 100644
--- a/mac.go
+++ b/mac.go
@@ -27,6 +27,7 @@ const (
 
 // IsValid returns whether this MAC type is supported.
 func (act MsgAuthCodeType) IsValid() bool {
+	//nolint:exhaustive // Forward-compatible pattern with default case
 	switch act {
 	case MsgAuthCodeTypeHMACBlake3:
 		return true
@@ -120,9 +121,8 @@ func (hbm *HashBasedMAC) Sign(data []byte) (mac []byte) {
 	size := binary.PutUvarint(mac, sequence)
 
 	// Add random salt to prevent MAC reuse.
-	if _, err := rand.Read(mac[size : size+macSaltSize]); err != nil {
-		panic("failed to generate random salt for MAC: " + err.Error())
-	}
+	//nolint:errcheck,gosec // crypto/rand.Read cannot fail
+	rand.Read(mac[size : size+macSaltSize])
 	size += macSaltSize
 
 	// Generate checksum.
diff --git a/secret.go b/secret.go
index c4ba2f1..ce35c65 100644
--- a/secret.go
+++ b/secret.go
@@ -13,9 +13,7 @@ func NewSecret(length int) []byte {
 
 	// Read random data into secret.
 	secret := make([]byte, length)
-	if _, err := rand.Read(secret); err != nil {
-		// This should never happen with crypto/rand, but handle it defensively.
-		panic("failed to generate random secret: " + err.Error())
-	}
+	//nolint:errcheck,gosec // crypto/rand.Read cannot fail
+	rand.Read(secret)
 	return secret
 }

From c41e3e407e1568abf622a4c6746235e405ab0cdc Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 18 Nov 2025 15:12:52 +0000
Subject: [PATCH 06/11] Disable godox linter - keywords configuration not
 supported in v2.6.2

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .golangci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.golangci.yml b/.golangci.yml
index e214346..bf1386c 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -74,7 +74,7 @@ linters:
     - sloglint        # Structured logging checks
 
   disable:
-    - godox           # TODOs are acceptable during development
+    - godox           # Cannot be configured to only flag FIXME (keywords setting not working in v2.6.2)
     - testpackage     # Can be too restrictive
     - exhaustruct     # Too strict - requires all struct fields to be initialized
     - wrapcheck       # Too strict - requires wrapping all external errors
@@ -171,3 +171,5 @@ issues:
     - text: "missing cases in switch of type"
       linters:
         - exhaustive
+    
+

From e14c0dd8f7c2cb41bd2aa5c86599fc12c37e68d7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 18 Nov 2025 16:18:59 +0000
Subject: [PATCH 07/11] Fix GitHub Actions to use Go 1.25.1 explicitly

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 .github/workflows/lint.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index a3844e8..16f6300 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -26,7 +26,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version-file: 'go.mod'
+          go-version: '1.25.1'
           cache: true
 
       - name: Run golangci-lint
@@ -37,3 +37,6 @@ jobs:
           only-new-issues: true
           # Optional: golangci-lint command line arguments.
           args: --timeout=5m
+          # Skip the default install-mode since Go is already set up
+          skip-cache: false
+          skip-save-cache: false

From f378cded0cf61117dfe77fd0ae5bbfa00ceae96c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 19 Nov 2025 12:00:24 +0000
Subject: [PATCH 08/11] Add Justfile with install-tools and lint commands

Co-authored-by: dhaavi <18184155+dhaavi@users.noreply.github.com>
---
 Justfile | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Justfile

diff --git a/Justfile b/Justfile
new file mode 100644
index 0000000..5d54def
--- /dev/null
+++ b/Justfile
@@ -0,0 +1,53 @@
+# Justfile for CROP - Cryptographic Routines, Operations & Primitives
+
+# Default recipe: list all available commands
+default:
+    @just --list
+
+# Install development tools
+install-tools:
+    @echo "Installing golangci-lint..."
+    @curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin latest
+    @echo "golangci-lint installed successfully"
+    @golangci-lint --version
+
+# Run golangci-lint
+lint:
+    @echo "Running golangci-lint..."
+    @golangci-lint run --timeout=5m
+
+# Run tests
+test:
+    @echo "Running tests..."
+    @go test -v ./...
+
+# Run tests with coverage
+test-coverage:
+    @echo "Running tests with coverage..."
+    @go test -v -coverprofile=coverage.out ./...
+    @go tool cover -html=coverage.out -o coverage.html
+    @echo "Coverage report generated: coverage.html"
+
+# Build the project
+build:
+    @echo "Building..."
+    @go build ./...
+
+# Format code
+fmt:
+    @echo "Formatting code..."
+    @go fmt ./...
+
+# Tidy dependencies
+tidy:
+    @echo "Tidying dependencies..."
+    @go mod tidy
+
+# Clean build artifacts
+clean:
+    @echo "Cleaning..."
+    @rm -f coverage.out coverage.html
+
+# Run all checks (format, lint, test)
+check: fmt lint test
+    @echo "All checks passed!"

From 5fe9a6039d9b60688beb5e2f6f9dbc8537792ba9 Mon Sep 17 00:00:00 2001
From: Daniel <dhaavi@users.noreply.github.com>
Date: Fri, 28 Nov 2025 16:43:54 +0100
Subject: [PATCH 09/11] Improve value hasher, fix bugs, fix linter issues

---
 .golangci.yml     | 174 +++++++++++++++++++++++-----------------------
 challenge.go      |   4 +-
 challenge_test.go |   6 +-
 hash.go           |  26 +++++--
 hash_test.go      |  28 ++++----
 key_maker_test.go |   4 +-
 keymaker.go       |   2 +-
 keypair_test.go   |   4 +-
 mac.go            |  57 +++++++++------
 mac_test.go       |  48 +++++++------
 sequence_test.go  |   2 +-
 11 files changed, 191 insertions(+), 164 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index bf1386c..7c17045 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -5,84 +5,84 @@ version: 2
 
 run:
   timeout: 5m
-  go: '1.25'
+  go: "1.25"
   tests: true
 
 linters:
   enable:
     # Critical Security & Correctness
-    - gosec           # Security-focused linter (critical for crypto code)
-    - errcheck        # Ensures errors aren't ignored
-    - govet           # Go's official checker for suspicious constructs
-    - staticcheck     # Comprehensive bug/performance/style checker
-    
+    - gosec # Security-focused linter (critical for crypto code)
+    - errcheck # Ensures errors aren't ignored
+    - govet # Go's official checker for suspicious constructs
+    - staticcheck # Comprehensive bug/performance/style checker
+
     # Bug Prevention
-    - ineffassign     # Detects ineffectual assignments
-    - unused          # Finds unused code
-    - nilnil          # Detects returning nil with nil errors
-    - nilerr          # Finds code returning nil even on error
-    - errchkjson      # Checks for unchecked errors in JSON encoding/decoding
-    - bodyclose       # Ensures HTTP response bodies are closed
-    - wastedassign    # Detects wasted assignments
-    
+    - ineffassign # Detects ineffectual assignments
+    - unused # Finds unused code
+    - nilnil # Detects returning nil with nil errors
+    - nilerr # Finds code returning nil even on error
+    - errchkjson # Checks for unchecked errors in JSON encoding/decoding
+    - bodyclose # Ensures HTTP response bodies are closed
+    - wastedassign # Detects wasted assignments
+
     # Code Quality & Maintainability
-    - gocyclo         # Cyclomatic complexity
-    - gocognit        # Cognitive complexity
-    - dupl            # Code duplication detection
-    - unconvert       # Unnecessary type conversions
-    - unparam         # Unused function parameters
-    - misspell        # Spelling mistakes
-    - goconst         # Repeated strings that could be constants
-    
+    - gocyclo # Cyclomatic complexity
+    - gocognit # Cognitive complexity
+    - dupl # Code duplication detection
+    - unconvert # Unnecessary type conversions
+    - unparam # Unused function parameters
+    - misspell # Spelling mistakes
+    - goconst # Repeated strings that could be constants
+
     # Error Handling
-    - errorlint       # Error wrapping and assertions
-    - errname         # Error naming conventions
-    - nilnesserr      # Nilness checks
-    
+    - errorlint # Error wrapping and assertions
+    - errname # Error naming conventions
+    - nilnesserr # Nilness checks
+
     # Context & Concurrency
-    - fatcontext      # Context.Context should be first parameter
-    - contextcheck    # Context usage checks
-    
+    - fatcontext # Context.Context should be first parameter
+    - contextcheck # Context usage checks
+
     # Embedded & Struct Checks
-    - embeddedstructfieldcheck  # Embedded struct field checks
-    - exhaustive      # Exhaustive enum/switch checks
-    
+    - embeddedstructfieldcheck # Embedded struct field checks
+    - exhaustive # Exhaustive enum/switch checks
+
     # Style & Modernization
-    - asciicheck      # ASCII character checks
+    - asciicheck # ASCII character checks
     - canonicalheader # Canonical header checks
-    - intrange        # Integer range checks
-    - mirror          # Mirror checks
-    - modernize       # Modernization suggestions
-    - nolintlint      # Nolint directive checks
-    - predeclared     # Predeclared identifier checks
-    - usestdlibvars   # Use standard library variables
-    
+    - intrange # Integer range checks
+    - mirror # Mirror checks
+    - modernize # Modernization suggestions
+    - nolintlint # Nolint directive checks
+    - predeclared # Predeclared identifier checks
+    - usestdlibvars # Use standard library variables
+
     # Performance
-    - prealloc        # Preallocation checks
-    - perfsprint      # Sprint performance checks
-    
+    - prealloc # Preallocation checks
+    - perfsprint # Sprint performance checks
+
     # Testing
-    - paralleltest    # Parallel test checks
-    - testifylint     # Testify assertions checks
-    - thelper         # Test helper checks
-    - tparallel       # t.Parallel() checks
-    
+    - paralleltest # Parallel test checks
+    - testifylint # Testify assertions checks
+    - thelper # Test helper checks
+    - tparallel # t.Parallel() checks
+
     # Other
-    - exptostd        # Experimental to standard library
-    - protogetter     # Protobuf getter checks
-    - reassign        # Reassignment checks
-    - sloglint        # Structured logging checks
+    - exptostd # Experimental to standard library
+    - protogetter # Protobuf getter checks
+    - reassign # Reassignment checks
+    - sloglint # Structured logging checks
 
   disable:
-    - godox           # Cannot be configured to only flag FIXME (keywords setting not working in v2.6.2)
-    - testpackage     # Can be too restrictive
-    - exhaustruct     # Too strict - requires all struct fields to be initialized
-    - wrapcheck       # Too strict - requires wrapping all external errors
+    - godox # Cannot be configured to only flag FIXME (keywords setting not working in v2.6.2)
+    - testpackage # Can be too restrictive
+    - exhaustruct # Too strict - requires all struct fields to be initialized
+    - wrapcheck # Too strict - requires wrapping all external errors
 
 formatters:
   enable:
-    - gofmt           # Standard Go formatting
-    - goimports       # Auto-manages imports and formats
+    - gofmt # Standard Go formatting
+    - goimports # Auto-manages imports and formats
 
 linters-settings:
   gosec:
@@ -90,10 +90,10 @@ linters-settings:
     # G115: Integer overflow conversion
     # G404: Use of weak random number generator (crypto/rand)
     excludes:
-      - G114  # HTTP servers not used in this library
-      - G115  # Integer overflow conversions are safe in controlled contexts
+      - G114 # HTTP servers not used in this library
+      - G115 # Integer overflow conversions are safe in controlled contexts
     severity: high
-  
+
   errcheck:
     # Check type assertions
     check-type-assertions: true
@@ -103,43 +103,43 @@ linters-settings:
     exclude-functions:
       - (*github.com/mr-tron/base58.Encoder).Encode
       - (crypto/rand.Read)
-  
+
   govet:
     enable-all: true
     disable:
-      - fieldalignment  # Struct field alignment is less critical
-      - shadow          # Variable shadowing can be intentional
-  
+      - fieldalignment # Struct field alignment is less critical
+      - shadow # Variable shadowing can be intentional
+
   staticcheck:
     checks: ["all"]
-  
+
   gocyclo:
-    min-complexity: 15  # Reasonable for crypto code
-  
+    min-complexity: 30 # Reasonable for crypto code
+
   gocognit:
-    min-complexity: 30  # Allow moderate complexity (higher for tests)
-  
+    min-complexity: 60 # Allow moderate complexity (higher for tests)
+
   dupl:
-    threshold: 100  # Minimum code duplication to report
-  
+    threshold: 200 # Minimum code duplication to report
+
   misspell:
     locale: US
-  
+
   goconst:
-    min-occurrences: 6  # At least more than 5 times
+    min-occurrences: 6 # At least more than 5 times
 
   gocritic:
     disabled-checks:
-      - unnamedResult     # Named returns can reduce clarity
-      - hugeParam         # Sometimes necessary for crypto structs
-      - singleCaseSwitch  # Single case switches with default are forward-compatible
+      - unnamedResult # Named returns can reduce clarity
+      - hugeParam # Sometimes necessary for crypto structs
+      - singleCaseSwitch # Single case switches with default are forward-compatible
 
 issues:
   # Maximum issues count per linter
   max-issues-per-linter: 0
   # Maximum issues count overall
   max-same-issues: 0
-  
+
   # Exclude specific issues or patterns
   exclude-rules:
     # Exclude test files from some checks
@@ -151,25 +151,23 @@ issues:
         - gocognit
         - gocyclo
         - errcheck
-        - paralleltest     # t.Parallel() usage is at developer discretion
-        - testifylint      # Testify linting in tests
-        - predeclared      # Predeclared identifiers acceptable in tests
-        - gofmt            # Formatting in test data
-        - intrange         # Integer ranges in tests
-    
+        - paralleltest # t.Parallel() usage is at developer discretion
+        - testifylint # Testify linting in tests
+        - predeclared # Predeclared identifiers acceptable in tests
+        - gofmt # Formatting in test data
+        - intrange # Integer ranges in tests
+
     # Single case switches are forward-compatible for future algorithm additions
     - linters:
         - gocritic
       text: "singleCaseSwitch"
-    
+
     # crypto/rand.Read never fails in practice
     - source: "rand\\.Read"
       linters:
         - errcheck
-    
+
     # IsValid methods use switches with default for forward compatibility
     - text: "missing cases in switch of type"
       linters:
         - exhaustive
-    
-
diff --git a/challenge.go b/challenge.go
index c8ded23..243200d 100644
--- a/challenge.go
+++ b/challenge.go
@@ -96,7 +96,7 @@ func (hcc *HashedContextChallenge) MakeResponse(challenge []byte) (response []by
 }
 
 func (hcc *HashedContextChallenge) makeHash(input []byte, reverse bool) []byte {
-	vh := NewValueHasher(hcc.hash)
+	vh := NewValueHasher(hcc.hash.New())
 
 	vh.AddString("hashed context challenge") // Fixed internal value.
 	vh.AddString(hcc.purpose)                // Add purpose.
@@ -111,5 +111,5 @@ func (hcc *HashedContextChallenge) makeHash(input []byte, reverse bool) []byte {
 	}
 	vh.Add(input)
 
-	return vh.Sum()
+	return vh.Sum(nil)
 }
diff --git a/challenge_test.go b/challenge_test.go
index ad61336..63f757a 100644
--- a/challenge_test.go
+++ b/challenge_test.go
@@ -244,13 +244,13 @@ func TestHashedContextChallenge_ResponseMatchesIndependentComputation(t *testing
 
 	// Independent recomputation matching the requester's expected order:
 	// fixed string, purpose, requester, responder, challenge.
-	vh := NewValueHasher(BLAKE3)
+	vh := NewValueHasher(BLAKE3.New())
 	vh.AddString("hashed context challenge")
 	vh.AddString(purpose)
 	vh.AddString(reqCtx)
 	vh.AddString(resCtx)
 	vh.Add(chal)
-	resp2 := vh.Sum()
+	resp2 := vh.Sum(nil)
 
 	if !bytes.Equal(resp1, resp2) {
 		t.Fatalf("independent computation mismatch\n got: %x\nwant: %x", resp1, resp2)
@@ -260,4 +260,4 @@ func TestHashedContextChallenge_ResponseMatchesIndependentComputation(t *testing
 	if err := hReq.CheckResponse(resp1); err != nil {
 		t.Fatalf("CheckResponse failed for valid response: %v", err)
 	}
-}
\ No newline at end of file
+}
diff --git a/hash.go b/hash.go
index 3820b8c..992ef51 100644
--- a/hash.go
+++ b/hash.go
@@ -125,9 +125,9 @@ func (h Hash) Verify(data, checksum []byte) error {
 }
 
 // NewValueHasher creates a structured hasher for multiple values.
-func NewValueHasher(hash Hash) *ValueHasher {
+func NewValueHasher(h hash.Hash) *ValueHasher {
 	return &ValueHasher{
-		hasher: hash.New(),
+		hasher: h,
 	}
 }
 
@@ -176,18 +176,32 @@ func (vh *ValueHasher) AddString(data string) {
 	vh.Add([]byte(data))
 }
 
+// AddUint hashes an uint field.
+func (vh *ValueHasher) AddUint(n uint64) {
+	var buf [8]byte
+	b := buf[:]
+	binary.BigEndian.PutUint64(b, n)
+	vh.Add(b)
+}
+
 // Sum finalizes and returns the hash result.
-func (vh *ValueHasher) Sum() []byte {
-	// Write finisher.
+func (vh *ValueHasher) Sum(dst []byte) []byte {
+	// Create finisher.
 	finisher := [16]byte{
 		// Total field count.
 		0, 0, 0, 0,
 		0, 0, 0, 0,
-		// Max uint64 as the "field length".
+		// Use a max uint64 in the place of the "field length" of a next field as an otherwise impossible finalizer.
 		0xFF, 0xFF, 0xFF, 0xFF,
 		0xFF, 0xFF, 0xFF, 0xFF,
 	}
 	binary.BigEndian.PutUint64(finisher[:8], vh.fieldCnt)
 
-	return vh.hasher.Sum(finisher[:])
+	// Write finisher.
+	_, err := vh.hasher.Write(finisher[:])
+	if err != nil {
+		panic(err)
+	}
+
+	return vh.hasher.Sum(dst)
 }
diff --git a/hash_test.go b/hash_test.go
index 770278f..d4b564f 100644
--- a/hash_test.go
+++ b/hash_test.go
@@ -157,11 +157,11 @@ func TestValueHasher_Sum_FormatAndDeterminism(t *testing.T) {
 	for _, algo := range algos {
 		algo := algo
 		t.Run(string(algo), func(t *testing.T) {
-			vh := NewValueHasher(algo)
+			vh := NewValueHasher(algo.New())
 			for _, f := range fields {
 				vh.Add(f)
 			}
-			sum := vh.Sum()
+			sum := vh.Sum(nil)
 
 			hasher := algo.New()
 			if hasher == nil {
@@ -198,11 +198,11 @@ func TestValueHasher_Sum_FormatAndDeterminism(t *testing.T) {
 			}
 
 			// Determinism: re-run and expect the same output.
-			vh2 := NewValueHasher(algo)
+			vh2 := NewValueHasher(algo.New())
 			for _, f := range fields {
 				vh2.Add(f)
 			}
-			sum2 := vh2.Sum()
+			sum2 := vh2.Sum(nil)
 			if !bytes.Equal(sum, sum2) {
 				t.Fatalf("non-deterministic result for ValueHasher\n1: %x\n2: %x", sum, sum2)
 			}
@@ -213,15 +213,15 @@ func TestValueHasher_Sum_FormatAndDeterminism(t *testing.T) {
 func TestValueHasher_AddString(t *testing.T) {
 	algo := SHA2_256
 
-	vh1 := NewValueHasher(algo)
+	vh1 := NewValueHasher(algo.New())
 	vh1.Add([]byte("hello"))
 	vh1.Add([]byte("world"))
 
-	vh2 := NewValueHasher(algo)
+	vh2 := NewValueHasher(algo.New())
 	vh2.AddString("hello")
 	vh2.AddString("world")
 
-	if got1, got2 := vh1.Sum(), vh2.Sum(); !bytes.Equal(got1, got2) {
+	if got1, got2 := vh1.Sum(nil), vh2.Sum(nil); !bytes.Equal(got1, got2) {
 		t.Fatalf("AddString mismatch with Add\nAdd:       %x\nAddString: %x", got1, got2)
 	}
 }
@@ -229,15 +229,15 @@ func TestValueHasher_AddString(t *testing.T) {
 func TestValueHasher_OrderMatters(t *testing.T) {
 	algo := BLAKE2b_256
 
-	vh1 := NewValueHasher(algo)
+	vh1 := NewValueHasher(algo.New())
 	vh1.Add([]byte("first"))
 	vh1.Add([]byte("second"))
 
-	vh2 := NewValueHasher(algo)
+	vh2 := NewValueHasher(algo.New())
 	vh2.Add([]byte("second"))
 	vh2.Add([]byte("first"))
 
-	if bytes.Equal(vh1.Sum(), vh2.Sum()) {
+	if bytes.Equal(vh1.Sum(nil), vh2.Sum(nil)) {
 		t.Fatalf("expected different sums when field order differs")
 	}
 }
@@ -249,7 +249,7 @@ func TestNewValueHasher_WithInvalidAlgo_PanicsOnUse(t *testing.T) {
 		}
 	}()
 	var invalid Hash = "NOPE"
-	vh := NewValueHasher(invalid)
+	vh := NewValueHasher(invalid.New())
 	// Should panic on first write due to nil hasher
 	vh.Add([]byte("data"))
 }
@@ -279,9 +279,9 @@ func preview(b []byte) string {
 	if len(b) == 0 {
 		return ""
 	}
-	const max = 32
-	if len(b) <= max {
+	const maxLen = 32
+	if len(b) <= maxLen {
 		return string(b)
 	}
-	return string(b[:max]) + "..."
+	return string(b[:maxLen]) + "..."
 }
diff --git a/key_maker_test.go b/key_maker_test.go
index 169acff..63c19c9 100644
--- a/key_maker_test.go
+++ b/key_maker_test.go
@@ -77,8 +77,8 @@ func TestBlake3Keymaker_DeriveKeyInto_MinLength(t *testing.T) {
 	}
 
 	// Exactly min should succeed
-	min := make([]byte, keyMakerMinKeySize)
-	if err := km.DeriveKeyInto("", "", min); err != nil {
+	minBuf := make([]byte, keyMakerMinKeySize)
+	if err := km.DeriveKeyInto("", "", minBuf); err != nil {
 		t.Fatalf("DeriveKeyInto(min) error: %v", err)
 	}
 }
diff --git a/keymaker.go b/keymaker.go
index bb8d50b..7c6f46e 100644
--- a/keymaker.go
+++ b/keymaker.go
@@ -13,7 +13,7 @@ const (
 	// KeyMakerTypeBlake3 derives keys using BLAKE3.
 	KeyMakerTypeBlake3 KeyMakerType = "BLAKE3"
 
-	keyMakerBaseContext = "nexufend key mkr"
+	keyMakerBaseContext = "_crop key maker_"
 
 	keyMakerMinKeySize = 16
 )
diff --git a/keypair_test.go b/keypair_test.go
index 1746402..59be844 100644
--- a/keypair_test.go
+++ b/keypair_test.go
@@ -58,7 +58,7 @@ func TestKeyPair(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			assert.EqualValues(t, privImportText, privImportBytes, "imports must match")
+			assert.Equal(t, privImportText, privImportBytes, "imports must match")
 			importedPriv, err := LoadKeyPair(privImportText)
 			if err != nil {
 				t.Fatal(err)
@@ -86,7 +86,7 @@ func TestKeyPair(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			assert.EqualValues(t, pubImportText, pubImportBytes, "imports must match")
+			assert.Equal(t, pubImportText, pubImportBytes, "imports must match")
 			importedpub, err := LoadKeyPair(pubImportText)
 			if err != nil {
 				t.Fatal(err)
diff --git a/mac.go b/mac.go
index da4a3ea..5c012fa 100644
--- a/mac.go
+++ b/mac.go
@@ -21,16 +21,17 @@ const (
 	// MsgAuthCodeTypeBlake3 uses keyed BLAKE3.
 	MsgAuthCodeTypeBlake3 MsgAuthCodeType = "BLAKE3"
 
-	macMinSaltSize = 8
-	macSaltSize    = 16
+	macMinNonceSize = 8
+	macNonceSize    = 16
 )
 
 // IsValid returns whether this MAC type is supported.
 func (act MsgAuthCodeType) IsValid() bool {
-	//nolint:exhaustive // Forward-compatible pattern with default case
 	switch act {
 	case MsgAuthCodeTypeHMACBlake3:
 		return true
+	case MsgAuthCodeTypeBlake3:
+		return true
 	}
 	return false
 }
@@ -85,9 +86,9 @@ type MsgAuthCodeHandler interface {
 	// Type returns the MAC algorithm type.
 	Type() MsgAuthCodeType
 	// Sign generates an authentication code for the data.
-	Sign(data []byte) (mac []byte)
+	Sign(context string, data []byte) (mac []byte)
 	// Verify checks that the MAC is valid for the data.
-	Verify(data []byte, mac []byte) error
+	Verify(context string, data []byte, mac []byte) error
 	// Burn securely erases key material from memory.
 	Burn()
 }
@@ -108,57 +109,69 @@ func (hbm *HashBasedMAC) Type() MsgAuthCodeType {
 	return hbm.handlerType
 }
 
-func (hbm *HashBasedMAC) Sign(data []byte) (mac []byte) {
+func (hbm *HashBasedMAC) Sign(context string, data []byte) (mac []byte) {
 	hbm.signLock.Lock()
 	defer hbm.signLock.Unlock()
 	defer hbm.signer.Reset()
 
 	// Create slice for the new MAC.
-	mac = make([]byte, 9+macSaltSize+hbm.signer.Size())
+	mac = make([]byte, 9+macNonceSize+hbm.signer.Size())
+
+	// Create value hasher with signer.
+	vh := NewValueHasher(hbm.signer)
+	vh.AddString(context)
 
 	// Increment and add sequence number for replay protection.
 	sequence := hbm.seqChecker.NextOutSequence()
+	vh.AddUint(sequence)
 	size := binary.PutUvarint(mac, sequence)
 
-	// Add random salt to prevent MAC reuse.
+	// Add nonce to prevent MAC reuse.
 	//nolint:errcheck,gosec // crypto/rand.Read cannot fail
-	rand.Read(mac[size : size+macSaltSize])
-	size += macSaltSize
+	rand.Read(mac[size : size+macNonceSize])
+	vh.Add(mac[size : size+macNonceSize])
+	size += macNonceSize
 
-	// Generate checksum.
-	hbm.signer.Write(mac[:size])
-	hbm.signer.Write(data)
-	copy(mac[size:], hbm.signer.Sum(nil))
+	// Add data and generate checksum.
+	vh.Add(data)
+	vh.Sum(mac[size:])
 	size += hbm.signer.Size()
 
 	// Return full MAC without extra bytes.
 	return mac[:size]
 }
 
-func (hbm *HashBasedMAC) Verify(data []byte, mac []byte) error {
+func (hbm *HashBasedMAC) Verify(context string, data []byte, mac []byte) error {
 	hbm.verifyLock.Lock()
 	defer hbm.verifyLock.Unlock()
 	defer hbm.verifier.Reset()
 
+	// Create value hasher with verifier.
+	vh := NewValueHasher(hbm.verifier)
+	vh.AddString(context)
+
 	// Extract sequence number (validated after MAC verification).
 	seqNum, seqSize := binary.Uvarint(mac)
 	if seqSize <= 0 {
 		return fmt.Errorf("%w: too short", ErrAuthCodeInvalid)
 	}
+	vh.AddUint(seqNum)
 
-	// Check salt size.
-	saltSize := len(mac) - seqSize - hbm.verifier.Size()
-	if saltSize < macMinSaltSize {
+	// Check nonce size.
+	nonceSize := len(mac) - seqSize - hbm.verifier.Size()
+	if nonceSize < macMinNonceSize {
 		return fmt.Errorf("%w: too short", ErrAuthCodeInvalid)
 	}
+	vh.Add(mac[seqSize : seqSize+nonceSize])
 
 	// Generate checksum.
-	hbm.verifier.Write(mac[:seqSize+saltSize])
-	hbm.verifier.Write(data)
-	compareChecksum := hbm.verifier.Sum(nil)
+	vh.Add(data)
+	var compareChecksumBuf [64]byte
+	compareChecksum := compareChecksumBuf[:hbm.verifier.Size()]
+	vh.Sum(compareChecksum)
 
 	// Compare checksum.
-	if subtle.ConstantTimeCompare(mac[seqSize+saltSize:], compareChecksum) != 1 {
+	if subtle.ConstantTimeCompare(mac[seqSize+nonceSize:], compareChecksum) != 1 {
 		return ErrAuthCodeInvalid
 	}
 
diff --git a/mac_test.go b/mac_test.go
index 0209427..e620f10 100644
--- a/mac_test.go
+++ b/mac_test.go
@@ -36,20 +36,20 @@ func TestAuthCode_SignVerify_Simple(t *testing.T) {
 
 			// Sign with A, verify with B.
 			msg1 := []byte("hello from A")
-			mac1 := a.Sign(msg1)
-			if err := b.Verify(msg1, mac1); err != nil {
+			mac1 := a.Sign("msg1", msg1)
+			if err := b.Verify("msg1", msg1, mac1); err != nil {
 				t.Fatalf("verify failed for A->B: %v (mac: %x)", err, mac1)
 			}
 
 			// Sign with B, verify with A.
 			msg2 := []byte("hello from B")
-			mac2 := b.Sign(msg2)
-			if err := a.Verify(msg2, mac2); err != nil {
+			mac2 := b.Sign("msg2", msg2)
+			if err := a.Verify("msg2", msg2, mac2); err != nil {
 				t.Fatalf("verify failed for B->A: %v (mac: %x)", err, mac2)
 			}
 
 			// Cross-check that wrong message fails.
-			if err := a.Verify([]byte("tampered"), mac2); err == nil {
+			if err := a.Verify("msg2", []byte("tampered"), mac2); err == nil {
 				t.Fatalf("expected verify to fail for tampered message but it succeeded")
 			}
 		})
@@ -95,14 +95,14 @@ func TestAuthCode_SignVerify_Randomized_BothDirections(t *testing.T) {
 			// Sign for A->B.
 			for i := 0; i < messages; i++ {
 				data := []byte("A-msg-" + strconv.Itoa(i))
-				mac := handlerA.Sign(data)
+				mac := handlerA.Sign("a-msg", data)
 				AtoB = append(AtoB, &entry{id: string(data), data: data, mac: mac})
 			}
 
 			// Sign for B->A.
 			for i := 0; i < messages; i++ {
 				data := []byte("B-msg-" + strconv.Itoa(i))
-				mac := handlerB.Sign(data)
+				mac := handlerB.Sign("b-msg", data)
 				BtoA = append(BtoA, &entry{id: string(data), data: data, mac: mac})
 			}
 
@@ -112,7 +112,7 @@ func TestAuthCode_SignVerify_Randomized_BothDirections(t *testing.T) {
 
 			// Verify for A->B.
 			for _, entry := range AtoB {
-				if err := handlerB.Verify(entry.data, entry.mac); err != nil {
+				if err := handlerB.Verify("a-msg", entry.data, entry.mac); err != nil {
 					t.Errorf("verify A->B failed at %s: %v", entry.id, err)
 				}
 				// fmt.Println(entry.id)
@@ -120,7 +120,7 @@ func TestAuthCode_SignVerify_Randomized_BothDirections(t *testing.T) {
 
 			// Verify for B->A.
 			for _, entry := range BtoA {
-				if err := handlerA.Verify(entry.data, entry.mac); err != nil {
+				if err := handlerA.Verify("b-msg", entry.data, entry.mac); err != nil {
 					t.Errorf("verify B->A failed at %s: %v", entry.id, err)
 				}
 				// fmt.Println(entry.id)
@@ -130,6 +130,8 @@ func TestAuthCode_SignVerify_Randomized_BothDirections(t *testing.T) {
 }
 
 func TestAuthCode_ErrorCases(t *testing.T) {
+	t.Parallel()
+
 	acts := []MsgAuthCodeType{
 		MsgAuthCodeTypeHMACBlake3,
 	}
@@ -157,7 +159,7 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 			}
 
 			// 1) too short (no uvarint)
-			err = verifier.Verify([]byte("data"), []byte{})
+			err = verifier.Verify("", []byte("data"), []byte{})
 			if err == nil {
 				t.Fatalf("expected error for too short mac, got nil")
 			}
@@ -166,14 +168,14 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 			}
 
 			// 2) serial violation: sign two messages and verify the newer one first on the same verifier
-			mac1 := signer.Sign([]byte("first"))
-			mac2 := signer.Sign([]byte("second"))
+			mac1 := signer.Sign("", []byte("first"))
+			mac2 := signer.Sign("", []byte("second"))
 			// verify second first -> ok
-			if err := verifier.Verify([]byte("second"), mac2); err != nil {
+			if err := verifier.Verify("", []byte("second"), mac2); err != nil {
 				t.Fatalf("unexpected verify error for second: %v", err)
 			}
 			// verify first next -> serial violation
-			err = verifier.Verify([]byte("first"), mac1)
+			err = verifier.Verify("", []byte("first"), mac1)
 			if err == nil {
 				t.Fatalf("expected serial violation error but got nil")
 			}
@@ -182,29 +184,29 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 			}
 
 			// 3) salt too short: craft mac with too-small salt by truncating a valid mac
-			orig := signer.Sign([]byte("x"))
+			orig := signer.Sign("", []byte("x"))
 			_, serialSize := binary.Uvarint(orig)
 			if serialSize <= 0 {
 				t.Fatalf("failed to decode uvarint from mac")
 			}
 			// Determine hasher size based on the original mac and known macSaltSize
-			hasherSize := len(orig) - serialSize - macSaltSize
+			hasherSize := len(orig) - serialSize - macNonceSize
 			if hasherSize <= 0 {
 				t.Fatalf("unexpected hasher size computed: %d", hasherSize)
 			}
 			// Build truncated mac where saltSize = macMinSaltSize - 1 (too small)
-			newSaltSize := macMinSaltSize - 1
+			newSaltSize := macMinNonceSize - 1
 			newLen := serialSize + newSaltSize + hasherSize
 			if newLen >= len(orig) {
 				// unexpected, but ensure we still create a too-short-salt mac by truncating to something smaller
-				newLen = serialSize + (macMinSaltSize - 1) + hasherSize
+				newLen = serialSize + (macMinNonceSize - 1) + hasherSize
 			}
 			if newLen <= 0 || newLen > len(orig) {
 				t.Fatalf("unable to construct truncated mac for salt-too-short test")
 			}
 			trunc := make([]byte, newLen)
 			copy(trunc, orig[:newLen])
-			err = verifier.Verify([]byte("x"), trunc)
+			err = verifier.Verify("", []byte("x"), trunc)
 			if err == nil {
 				t.Fatalf("expected error for salt-too-short but got nil")
 			}
@@ -213,7 +215,7 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 			}
 
 			// 4) checksum mismatch: tamper with the checksum bytes
-			valid := signer.Sign([]byte("payload"))
+			valid := signer.Sign("", []byte("payload"))
 			// flip a byte in the checksum area (the tail)
 			tampered := make([]byte, len(valid))
 			copy(tampered, valid)
@@ -221,7 +223,7 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 				t.Fatalf("unexpected empty mac")
 			}
 			tampered[len(tampered)-1] ^= 0xFF
-			err = verifier.Verify([]byte("payload"), tampered)
+			err = verifier.Verify("", []byte("payload"), tampered)
 			if err == nil {
 				t.Fatalf("expected checksum mismatch to cause error but got nil")
 			}
@@ -230,8 +232,8 @@ func TestAuthCode_ErrorCases(t *testing.T) {
 			}
 
 			// 5) wrong message (data mismatch)
-			valid2 := signer.Sign([]byte("good"))
-			if err := verifier.Verify([]byte("bad"), valid2); err == nil {
+			valid2 := signer.Sign("", []byte("good"))
+			if err := verifier.Verify("", []byte("bad"), valid2); err == nil {
 				t.Fatalf("expected verification failure for wrong data but got nil")
 			}
 		})
diff --git a/sequence_test.go b/sequence_test.go
index 0c98f4f..6493688 100644
--- a/sequence_test.go
+++ b/sequence_test.go
@@ -67,7 +67,7 @@ func TestStrictSequenceChecker_NextOutSequence_SequentialAndConcurrent(t *testin
 
 	workers := runtime.GOMAXPROCS(0)
 	per := N / workers
-	for w := 0; w < workers; w++ {
+	for w := range workers {
 		wg.Add(1)
 		count := per
 		// last worker picks up remainder

From 4fd9032774a7242d170455caee4d90173c20b26e Mon Sep 17 00:00:00 2001
From: Daniel <dhaavi@users.noreply.github.com>
Date: Fri, 28 Nov 2025 16:49:27 +0100
Subject: [PATCH 10/11] Bump linter version

---
 .github/workflows/lint.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 16f6300..a905e8f 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -26,11 +26,11 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.25.1'
+          go-version: "1.25.3"
           cache: true
 
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v7
         with:
           version: latest
           # Optional: show only new issues if it's a pull request.

From 440eec1890fc7395751df1cb67df8602ae79751a Mon Sep 17 00:00:00 2001
From: Daniel <dhaavi@users.noreply.github.com>
Date: Fri, 28 Nov 2025 16:56:46 +0100
Subject: [PATCH 11/11] Fix linter config

---
 .golangci.yml | 138 +++++++++++++-------------------------------------
 1 file changed, 34 insertions(+), 104 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index 7c17045..7ff85c6 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,13 +1,8 @@
-# golangci-lint configuration for CROP cryptographic library
-# Focus on security, correctness, and maintainability
-
-version: 2
-
+version: "2"
 run:
-  timeout: 5m
   go: "1.25"
+  issues-exit-code: 1
   tests: true
-
 linters:
   enable:
     # Critical Security & Correctness
@@ -72,102 +67,37 @@ linters:
     - protogetter # Protobuf getter checks
     - reassign # Reassignment checks
     - sloglint # Structured logging checks
-
-  disable:
-    - godox # Cannot be configured to only flag FIXME (keywords setting not working in v2.6.2)
-    - testpackage # Can be too restrictive
-    - exhaustruct # Too strict - requires all struct fields to be initialized
-    - wrapcheck # Too strict - requires wrapping all external errors
-
+    - godox # Highlight FIXMEs
+
+  settings:
+    exhaustive:
+      default-signifies-exhaustive: true
+    godox:
+      keywords:
+        - FIXME
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
 formatters:
   enable:
-    - gofmt # Standard Go formatting
-    - goimports # Auto-manages imports and formats
-
-linters-settings:
-  gosec:
-    # G114: Use of net/http serve function that has no support for setting timeouts
-    # G115: Integer overflow conversion
-    # G404: Use of weak random number generator (crypto/rand)
-    excludes:
-      - G114 # HTTP servers not used in this library
-      - G115 # Integer overflow conversions are safe in controlled contexts
-    severity: high
-
-  errcheck:
-    # Check type assertions
-    check-type-assertions: true
-    # Check blank assignments
-    check-blank: true
-    # Exclude functions that are known to never fail
-    exclude-functions:
-      - (*github.com/mr-tron/base58.Encoder).Encode
-      - (crypto/rand.Read)
-
-  govet:
-    enable-all: true
-    disable:
-      - fieldalignment # Struct field alignment is less critical
-      - shadow # Variable shadowing can be intentional
-
-  staticcheck:
-    checks: ["all"]
-
-  gocyclo:
-    min-complexity: 30 # Reasonable for crypto code
-
-  gocognit:
-    min-complexity: 60 # Allow moderate complexity (higher for tests)
-
-  dupl:
-    threshold: 200 # Minimum code duplication to report
-
-  misspell:
-    locale: US
-
-  goconst:
-    min-occurrences: 6 # At least more than 5 times
-
-  gocritic:
-    disabled-checks:
-      - unnamedResult # Named returns can reduce clarity
-      - hugeParam # Sometimes necessary for crypto structs
-      - singleCaseSwitch # Single case switches with default are forward-compatible
-
-issues:
-  # Maximum issues count per linter
-  max-issues-per-linter: 0
-  # Maximum issues count overall
-  max-same-issues: 0
-
-  # Exclude specific issues or patterns
-  exclude-rules:
-    # Exclude test files from some checks
-    - path: _test\.go
-      linters:
-        - gosec
-        - dupl
-        - unparam
-        - gocognit
-        - gocyclo
-        - errcheck
-        - paralleltest # t.Parallel() usage is at developer discretion
-        - testifylint # Testify linting in tests
-        - predeclared # Predeclared identifiers acceptable in tests
-        - gofmt # Formatting in test data
-        - intrange # Integer ranges in tests
-
-    # Single case switches are forward-compatible for future algorithm additions
-    - linters:
-        - gocritic
-      text: "singleCaseSwitch"
-
-    # crypto/rand.Read never fails in practice
-    - source: "rand\\.Read"
-      linters:
-        - errcheck
-
-    # IsValid methods use switches with default for forward compatibility
-    - text: "missing cases in switch of type"
-      linters:
-        - exhaustive
+    - gofmt
+  settings:
+    gofmt:
+      simplify: true
+    goimports:
+      local-prefixes:
+        - github.com/mycoria/crop
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$