fix(auth): refactor DPoP nonce manager to use atomic.Pointer and fix empty nonce validation

Replace sync.RWMutex with atomic.Pointer[nonceState] for lock-free reads on
the hot path (getCurrentNonce, validateNonce), keeping sync.Mutex only to
serialize writes. Also guards validateNonce against empty-string nonce matching
the initial zero-value previousNonce.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Signed-off-by: Dave Mihalcik <dmihalcik@virtru.com>

Author: dmihalcik-virtru

service/internal/auth/authn.go

@@ -18,6 +18,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"connectrpc.com/connect"
@@ -108,72 +109,72 @@ type Authentication struct {
 }
 
 // dpopNonceManager manages server-issued DPoP nonces per RFC 9449 §8
-type dpopNonceManager struct {
-	mu            sync.RWMutex
+type nonceState struct {
 	currentNonce  string
 	previousNonce string
-	expiration    time.Duration
-	lastRotation  time.Time
-	requireNonce  bool
+	rotatedAt     time.Time
+}
+
+type dpopNonceManager struct {
+	state        atomic.Pointer[nonceState]
+	mu           sync.Mutex // serializes rotation only
+	expiration   time.Duration
+	requireNonce bool
 }
 
 func newDPoPNonceManager(requireNonce bool, expiration time.Duration) *dpopNonceManager {
 	nm := &dpopNonceManager{
 		requireNonce: requireNonce,
 		expiration:   expiration,
 	}
+	nm.state.Store(&nonceState{})
 	if requireNonce {
 		nm.rotate()
 	}
 	return nm
 }
 
-func (nm *dpopNonceManager) rotate() {
-	nm.mu.Lock()
-	defer nm.mu.Unlock()
-
-	nm.previousNonce = nm.currentNonce
+func (nm *dpopNonceManager) storeRotated(s *nonceState) {
 	nonce := make([]byte, dpopNonceBytes)
 	if _, err := rand.Read(nonce); err != nil {
 		panic(fmt.Sprintf("failed to generate nonce: %v", err))
 	}
-	nm.currentNonce = hex.EncodeToString(nonce)
-	nm.lastRotation = time.Now()
+	nm.state.Store(&nonceState{
+		previousNonce: s.currentNonce,
+		currentNonce:  hex.EncodeToString(nonce),
+		rotatedAt:     time.Now(),
+	})
+}
+
+func (nm *dpopNonceManager) rotate() {
+	nm.mu.Lock()
+	defer nm.mu.Unlock()
+	nm.storeRotated(nm.state.Load())
 }
 
 func (nm *dpopNonceManager) getCurrentNonce() string {
-	nm.mu.RLock()
-	if time.Since(nm.lastRotation) <= nm.expiration {
-		defer nm.mu.RUnlock()
-		return nm.currentNonce
+	s := nm.state.Load()
+	if time.Since(s.rotatedAt) <= nm.expiration {
+		return s.currentNonce
 	}
-	nm.mu.RUnlock()
 
 	nm.mu.Lock()
 	defer nm.mu.Unlock()
-	// Double-check after acquiring the write lock to prevent concurrent double-rotation.
-	if time.Since(nm.lastRotation) > nm.expiration {
-		nm.previousNonce = nm.currentNonce
-		nonce := make([]byte, dpopNonceBytes)
-		if _, err := rand.Read(nonce); err != nil {
-			panic(fmt.Sprintf("failed to generate nonce: %v", err))
-		}
-		nm.currentNonce = hex.EncodeToString(nonce)
-		nm.lastRotation = time.Now()
+	// Double-check after acquiring the lock to prevent concurrent double-rotation.
+	s = nm.state.Load()
+	if time.Since(s.rotatedAt) > nm.expiration {
+		nm.storeRotated(s)
+		s = nm.state.Load()
 	}
-
-	return nm.currentNonce
+	return s.currentNonce
 }
 
 func (nm *dpopNonceManager) validateNonce(nonce string) bool {
 	if !nm.requireNonce {
 		return true
 	}
-
-	nm.mu.RLock()
-	defer nm.mu.RUnlock()
-
-	return nonce == nm.currentNonce || nonce == nm.previousNonce
+	s := nm.state.Load()
+	return nonce != "" && (nonce == s.currentNonce || nonce == s.previousNonce)
 }
 
 // Creates new authN which is used to verify tokens for a set of given issuers

service/internal/auth/dpop_nonce_test.go

@@ -59,6 +59,11 @@ func TestDPoPNonceManager(t *testing.T) {
 		assert.False(t, nm.validateNonce(currentNonce), "nonce older than previous should not validate")
 	})
 
+	t.Run("empty nonce rejected when required", func(t *testing.T) {
+		nm := newDPoPNonceManager(true, 5*time.Minute)
+		assert.False(t, nm.validateNonce(""), "empty nonce must not match initial empty previousNonce")
+	})
+
 	t.Run("disabled nonces", func(t *testing.T) {
 		nm := newDPoPNonceManager(false, 5*time.Minute)
 		assert.True(t, nm.validateNonce("any-random-nonce"))