feat!: cut over to jwx v4 and ML-DSA on Go 1.27

Drop dual jwx v2/v3 support for a single NewJWSSigner/NewJWSVerifier
path on lestrrat-go/jwx/v4, raise the Go floor to 1.27, and add an
ML-DSA-65 foreign-JWS round-trip. Prepares httpsign v0.6.0.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: yaronf

.github/workflows/lint.yml

@@ -11,7 +11,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.24'
+          go-version: '1.27'
           cache: false
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9

.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.24'
+          go-version: '1.27'
           cache: false
       - name: Test
         run: go test ./...

CLAUDE.md

@@ -51,7 +51,7 @@ fields.go / digest.go      ← Component field abstraction + Content-Digest head
 
 ### JWX dual-version support
 
-The library supports both `lestrrat-go/jwx/v2` (kept for backward compatibility) and `lestrrat-go/jwx/v3` (recommended for new code). Use `NewJWSSignerV3` / `NewJWSVerifierV3` for new integrations.
+Optional foreign JWS uses `lestrrat-go/jwx/v4` via `NewJWSSigner` / `NewJWSVerifier` (including ML-DSA with `crypto/mldsa` on Go 1.27+). Requires Go 1.27+.
 
 ### Content-Digest
 

README.md

@@ -27,6 +27,8 @@ in the [API reference](https://pkg.go.dev/github.com/yaronf/httpsign).
 	_ = res.Body.Close()
 ```
 ### Notes and Missing Features
+* Requires **Go 1.27+**.
+* Optional foreign JWS (including **ML-DSA** via `crypto/mldsa`) uses [`lestrrat-go/jwx/v4`](https://github.com/lestrrat-go/jwx) through `NewJWSSigner` / `NewJWSVerifier`.
 * The `Accept-Signature` header is unimplemented.
 * In responses, when using the "wrapped handler" feature, the `Content-Type` header is only signed if set explicitly by the server. This is different, but arguably more secure, than the normal `net.http` behavior.
 * **Behind a TLS-terminating reverse proxy:** The `@scheme` derived component defaults to `req.TLS != nil`. Behind nginx, Envoy, AWS ALB, etc., `req.TLS` is nil, so `@scheme` becomes `"http"` even for HTTPS traffic. Use `SetSchemeFromRequest` on `SignConfig` and `VerifyConfig` to derive the scheme from `X-Forwarded-Proto` or similar headers.

crypto.go

@@ -13,13 +13,8 @@ import (
 	"crypto/subtle"
 	"fmt"
 
-	// JWX v2 - for backward compatibility (used by existing NewJWSSigner/NewJWSVerifier)
-	"github.com/lestrrat-go/jwx/v2/jwa"
-	"github.com/lestrrat-go/jwx/v2/jws"
-
-	// JWX v3 - for new V3 functions (used by NewJWSSignerV3/NewJWSVerifierV3)
-	jwav3 "github.com/lestrrat-go/jwx/v3/jwa"
-	jwsv3 "github.com/lestrrat-go/jwx/v3/jws"
+	"github.com/lestrrat-go/jwx/v4/jwa"
+	"github.com/lestrrat-go/jwx/v4/jws"
 )
 
 // Signer includes a cryptographic key (typically a private key) and configuration of what needs to be signed.
@@ -131,51 +126,20 @@ func NewEd25519SignerFromSeed(seed []byte, config *SignConfig, fields Fields) (*
 	return NewEd25519Signer(key, config, fields)
 }
 
-// NewJWSSigner creates a generic signer for JWS algorithms, using the go-jwx v2 package. The particular key type for each algorithm
-// is documented in that package.
-// Config may be nil for a default configuration.
-//
-// Note: This function uses jwx v2. For jwx v3 support, use NewJWSSignerV3 instead.
+// NewJWSSigner creates a generic signer for JWS algorithms via github.com/lestrrat-go/jwx/v4.
+// The particular key type for each algorithm is documented in that package (including
+// crypto/mldsa keys for ML-DSA on Go 1.27+). Config may be nil for a default configuration.
 func NewJWSSigner(alg jwa.SignatureAlgorithm, key interface{}, config *SignConfig, fields Fields) (*Signer, error) {
 	if key == nil {
 		return nil, fmt.Errorf("key must not be nil")
 	}
-	if alg == jwa.NoSignature {
-		return nil, fmt.Errorf("the NONE signing algorithm is expressly disallowed")
-	}
-	if config == nil {
-		config = NewSignConfig()
-	}
-	jwsSigner, err := jws.NewSigner(alg)
-	if err != nil {
-		return nil, err
-	}
-	return &Signer{
-		key:           key,
-		alg:           "",
-		config:        config,
-		fields:        fields,
-		foreignSigner: jwsSigner,
-	}, nil
-}
-
-// NewJWSSignerV3 creates a generic signer for JWS algorithms, using the go-jwx v3 package. The particular key type for each algorithm
-// is documented in that package.
-// Config may be nil for a default configuration.
-//
-// This function uses jwx v3 and is the recommended choice for new code using jwx v3.
-// It uses the recommended SignerFor() API which returns Signer2 interface.
-func NewJWSSignerV3(alg jwav3.SignatureAlgorithm, key interface{}, config *SignConfig, fields Fields) (*Signer, error) {
-	if key == nil {
-		return nil, fmt.Errorf("key must not be nil")
-	}
-	if alg == jwav3.NoSignature() {
+	if alg == jwa.NoSignature() {
 		return nil, fmt.Errorf("the NONE signing algorithm is expressly disallowed")
 	}
 	if config == nil {
 		config = NewSignConfig()
 	}
-	jwsSigner, err := jwsv3.SignerFor(alg)
+	jwsSigner, err := jws.SignerFor(alg)
 	if err != nil {
 		return nil, err
 	}
@@ -190,21 +154,11 @@ func NewJWSSignerV3(alg jwav3.SignatureAlgorithm, key interface{}, config *SignC
 
 func (s Signer) sign(buff []byte) ([]byte, error) {
 	if s.foreignSigner != nil {
-		// Try v2 signer first (jws.Signer interface: Sign(payload, key))
-		if signerV2, ok := s.foreignSigner.(jws.Signer); ok {
-			return signerV2.Sign(buff, s.key)
-		}
-
-		// Try v3 Signer2 interface (new recommended API: Sign(key, payload))
-		// Note: parameter order is SWAPPED compared to v2!
-		type Signer2 interface {
-			Sign(key interface{}, payload []byte) ([]byte, error)
-		}
-		if signerV3, ok := s.foreignSigner.(Signer2); ok {
-			return signerV3.Sign(s.key, buff) // Note: key first, payload second
+		signer, ok := s.foreignSigner.(jws.Signer)
+		if !ok {
+			return nil, fmt.Errorf("expected jws.Signer, got %T", s.foreignSigner)
 		}
-
-		return nil, fmt.Errorf("expected jws.Signer or Signer2 interface, got %T", s.foreignSigner)
+		return signer.Sign(s.key, buff)
 	}
 	switch s.alg {
 	case "hmac-sha256":
@@ -369,51 +323,21 @@ func NewEd25519Verifier(key ed25519.PublicKey, config *VerifyConfig, fields Fiel
 	}, nil
 }
 
-// NewJWSVerifier creates a generic verifier for JWS algorithms, using the go-jwx v2 package. The particular key type for each algorithm
-// is documented in that package. Set config to nil for a default configuration.
+// NewJWSVerifier creates a generic verifier for JWS algorithms via github.com/lestrrat-go/jwx/v4.
+// The particular key type for each algorithm is documented in that package (including
+// crypto/mldsa keys for ML-DSA on Go 1.27+). Set config to nil for a default configuration.
 // Fields is the list of required headers and fields, which may be empty (but this is typically insecure).
-//
-// Note: This function uses jwx v2. For jwx v3 support, use NewJWSVerifierV3 instead.
 func NewJWSVerifier(alg jwa.SignatureAlgorithm, key interface{}, config *VerifyConfig, fields Fields) (*Verifier, error) {
 	if key == nil {
 		return nil, fmt.Errorf("key must not be nil")
 	}
 	if config == nil {
 		config = NewVerifyConfig()
 	}
-	if alg == jwa.NoSignature {
+	if alg == jwa.NoSignature() {
 		return nil, fmt.Errorf("the NONE signing algorithm is expressly disallowed")
 	}
-	verifier, err := jws.NewVerifier(alg)
-	if err != nil {
-		return nil, err
-	}
-	return &Verifier{
-		key:             key,
-		alg:             "",
-		config:          config,
-		fields:          fields,
-		foreignVerifier: verifier,
-	}, nil
-}
-
-// NewJWSVerifierV3 creates a generic verifier for JWS algorithms, using the go-jwx v3 package. The particular key type for each algorithm
-// is documented in that package. Set config to nil for a default configuration.
-// Fields is the list of required headers and fields, which may be empty (but this is typically insecure).
-//
-// This function uses jwx v3 and is the recommended choice for new code using jwx v3.
-// It uses the recommended VerifierFor() API which returns Verifier2 interface.
-func NewJWSVerifierV3(alg jwav3.SignatureAlgorithm, key interface{}, config *VerifyConfig, fields Fields) (*Verifier, error) {
-	if key == nil {
-		return nil, fmt.Errorf("key must not be nil")
-	}
-	if config == nil {
-		config = NewVerifyConfig()
-	}
-	if alg == jwav3.NoSignature() {
-		return nil, fmt.Errorf("the NONE signing algorithm is expressly disallowed")
-	}
-	verifier, err := jwsv3.VerifierFor(alg)
+	verifier, err := jws.VerifierFor(alg)
 	if err != nil {
 		return nil, err
 	}
@@ -428,31 +352,16 @@ func NewJWSVerifierV3(alg jwav3.SignatureAlgorithm, key interface{}, config *Ver
 
 func (v Verifier) verify(buff []byte, sig []byte) (bool, error) {
 	if v.foreignVerifier != nil {
-		// Try v2 verifier first (jws.Verifier interface: Verify(payload, sig, key))
-		if verifierV2, ok := v.foreignVerifier.(jws.Verifier); ok {
-			err := verifierV2.Verify(buff, sig, v.key)
-			if err != nil {
-				// Return opaque error; underlying err discarded for consistency
-				return false, fmt.Errorf("signature verification failed")
-			}
-			return true, nil
-		}
-
-		// Try v3 Verifier2 interface (new recommended API: Verify(key, payload, sig))
-		// Note: parameter order is DIFFERENT compared to v2!
-		type Verifier2 interface {
-			Verify(key interface{}, payload, signature []byte) error
+		verifier, ok := v.foreignVerifier.(jws.Verifier)
+		if !ok {
+			return false, fmt.Errorf("expected jws.Verifier, got %T", v.foreignVerifier)
 		}
-		if verifierV3, ok := v.foreignVerifier.(Verifier2); ok {
-			err := verifierV3.Verify(v.key, buff, sig) // Note: key first, then payload, then signature
-			if err != nil {
-				// Return opaque error; underlying err discarded for consistency
-				return false, fmt.Errorf("signature verification failed")
-			}
-			return true, nil
+		err := verifier.Verify(v.key, buff, sig)
+		if err != nil {
+			// Return opaque error; underlying err discarded for consistency
+			return false, fmt.Errorf("signature verification failed")
 		}
-
-		return false, fmt.Errorf("expected jws.Verifier or Verifier2 interface, got %T", v.foreignVerifier)
+		return true, nil
 	}
 
 	switch v.alg {