new protocol v1

Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>

Author: adecaro

token/core/common/validator.go

@@ -69,7 +69,7 @@ type Validator[P driver.PublicParameters, T driver.Input, TA driver.TransferActi
 
 	// MinProtocolVersion specifies the minimum protocol version required for token requests.
 	// If set to 0, no minimum version is enforced (accepts all versions).
-	// If set to a specific version (e.g., driver.ProtocolV2), only requests with that version
+	// If set to a specific version (e.g., driver.ProtocolV1), only requests with that version
 	// or higher will be accepted, rejecting older protocol versions.
 	MinProtocolVersion uint32
 }

token/core/common/validator_version_test.go

@@ -35,12 +35,6 @@ func TestMinProtocolVersionEnforcement(t *testing.T) {
 			requestVersion:     driver.ProtocolV1,
 			shouldFail:         false,
 		},
-		{
-			name:               "No minimum version set - accepts V2",
-			minProtocolVersion: 0,
-			requestVersion:     driver.ProtocolV2,
-			shouldFail:         false,
-		},
 		{
 			name:               "Minimum V1 - rejects version 0",
 			minProtocolVersion: driver.ProtocolV1,
@@ -54,32 +48,6 @@ func TestMinProtocolVersionEnforcement(t *testing.T) {
 			requestVersion:     driver.ProtocolV1,
 			shouldFail:         false,
 		},
-		{
-			name:               "Minimum V1 - accepts V2",
-			minProtocolVersion: driver.ProtocolV1,
-			requestVersion:     driver.ProtocolV2,
-			shouldFail:         false,
-		},
-		{
-			name:               "Minimum V2 - rejects version 0",
-			minProtocolVersion: driver.ProtocolV2,
-			requestVersion:     0,
-			shouldFail:         true,
-			expectedError:      "invalid token request: protocol version cannot be 0",
-		},
-		{
-			name:               "Minimum V2 - rejects V1",
-			minProtocolVersion: driver.ProtocolV2,
-			requestVersion:     driver.ProtocolV1,
-			shouldFail:         true,
-			expectedError:      "token request protocol version [1] is below minimum required version [2]",
-		},
-		{
-			name:               "Minimum V2 - accepts V2",
-			minProtocolVersion: driver.ProtocolV2,
-			requestVersion:     driver.ProtocolV2,
-			shouldFail:         false,
-		},
 	}
 
 	for _, tt := range tests {
@@ -115,13 +83,8 @@ func TestMinProtocolVersionLogic(t *testing.T) {
 	}{
 		{"V0 always invalid", 0, 0, false, "version 0 is invalid"},
 		{"No min, V1 request", 0, driver.ProtocolV1, true, ""},
-		{"No min, V2 request", 0, driver.ProtocolV2, true, ""},
 		{"Min V1, V0 request", driver.ProtocolV1, 0, false, "version 0 is invalid"},
 		{"Min V1, V1 request", driver.ProtocolV1, driver.ProtocolV1, true, ""},
-		{"Min V1, V2 request", driver.ProtocolV1, driver.ProtocolV2, true, ""},
-		{"Min V2, V0 request", driver.ProtocolV2, 0, false, "version 0 is invalid"},
-		{"Min V2, V1 request", driver.ProtocolV2, driver.ProtocolV1, false, "below minimum"},
-		{"Min V2, V2 request", driver.ProtocolV2, driver.ProtocolV2, true, ""},
 	}
 
 	for _, tt := range tests {
@@ -143,3 +106,4 @@ func TestMinProtocolVersionLogic(t *testing.T) {
 		})
 	}
 }
+

token/core/zkatdlog/nogh/v1/validator/regression/regression_test.go

@@ -69,6 +69,20 @@ func TestRegression(t *testing.T) {
 	}
 }
 
+// TestRegressionWithMinProtocolVersionV2 verifies that when the validator is configured
+// with MinProtocolVersion set to V2, all V1 token requests (from testdata) are rejected
+// with the expected error message about protocol version being below minimum.
+func TestRegressionWithMinProtocolVersionV2(t *testing.T) {
+	t.Skip()
+	t.Parallel()
+	// Test with one representative sample from each testdata directory
+	for _, root := range []string{"testdata", "testdata2", "testdata3"} {
+		for _, variant := range []string{"32-BLS12_381_BBS_GURVY", "64-BLS12_381_BBS_GURVY", "32-BN254", "64-BN254"} {
+			testRegressionWithMinVersionParallel(t, filepath.Join(root, variant), "transfers_i1_o1")
+		}
+	}
+}
+
 func testRegressionParallel(t *testing.T, rootDir, subFolder string) {
 	t.Helper()
 	t.Run(fmt.Sprintf("%s-%s", rootDir, subFolder), func(t *testing.T) {
@@ -137,19 +151,6 @@ func (*fakeLedger) GetState(_ tk.ID) ([]byte, error) {
 	panic("ciao")
 }
 
-// TestRegressionWithMinProtocolVersionV2 verifies that when the validator is configured
-// with MinProtocolVersion set to V2, all V1 token requests (from testdata) are rejected
-// with the expected error message about protocol version being below minimum.
-func TestRegressionWithMinProtocolVersionV2(t *testing.T) {
-	t.Parallel()
-	// Test with one representative sample from each testdata directory
-	for _, root := range []string{"testdata", "testdata2", "testdata3"} {
-		for _, variant := range []string{"32-BLS12_381_BBS_GURVY", "64-BLS12_381_BBS_GURVY", "32-BN254", "64-BN254"} {
-			testRegressionWithMinVersionParallel(t, filepath.Join(root, variant), "transfers_i1_o1")
-		}
-	}
-}
-
 func testRegressionWithMinVersionParallel(t *testing.T, rootDir, subFolder string) {
 	t.Helper()
 	t.Run(fmt.Sprintf("%s-%s-MinV2", rootDir, subFolder), func(t *testing.T) {
@@ -168,8 +169,8 @@ func testRegressionWithMinVersion(t *testing.T, rootDir, subFolder string) {
 	ppRaw, err := base64.StdEncoding.DecodeString(string(paramsData))
 	require.NoError(t, err)
 
-	// Create validator with MinProtocolVersion set to V2
-	_, tokenValidator, err := validatorWithMinVersion(ppRaw, driver.ProtocolV2)
+	// Create validator with MinProtocolVersion set to V1
+	_, tokenValidator, err := validatorWithMinVersion(ppRaw, driver.ProtocolV1)
 	require.NoError(t, err)
 
 	var tokenData struct {

token/driver/asn1_fast.go

@@ -170,3 +170,4 @@ func appendLength(buf []byte, length int) []byte {
 
 	return append(buf, 0x84, lengthBytes[0], lengthBytes[1], lengthBytes[2], lengthBytes[3])
 }
+

token/driver/asn1_fast_bench_test.go

@@ -259,30 +259,7 @@ func BenchmarkStdMarshalSignatureMessageV2_Large(b *testing.B) {
 	}
 }
 
-// BenchmarkMarshalToMessageToSignV2_Complete benchmarks the complete V2 marshalling flow
-func BenchmarkMarshalToMessageToSignV2_Complete(b *testing.B) {
-	tr := &TokenRequest{
-		Issues: [][]byte{
-			make([]byte, 500),
-			make([]byte, 800),
-		},
-		Transfers: [][]byte{
-			make([]byte, 600),
-		},
-	}
-	anchor := []byte("test-anchor-data")
-
-	b.ResetTimer()
-	b.ReportAllocs()
-	for range b.N {
-		_, err := tr.marshalToMessageToSignV2(anchor)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-// BenchmarkMarshalToMessageToSignV1_Complete benchmarks the V1 marshalling flow for comparison
+// BenchmarkMarshalToMessageToSignV1_Complete benchmarks the complete V1 marshalling flow
 func BenchmarkMarshalToMessageToSignV1_Complete(b *testing.B) {
 	tr := &TokenRequest{
 		Issues: [][]byte{
@@ -350,3 +327,4 @@ func BenchmarkManySmallItems_Std(b *testing.B) {
 		}
 	}
 }
+

token/driver/asn1_fast_test.go

@@ -255,16 +255,16 @@ func TestAppendLength(t *testing.T) {
 	}
 }
 
-// TestMarshalToMessageToSignV2_UsesFastMarshaller verifies that V2 uses the fast marshaller
-func TestMarshalToMessageToSignV2_UsesFastMarshaller(t *testing.T) {
+// TestMarshalToMessageToSignV1_UsesFastMarshaller verifies that V1 uses the fast marshaller
+func TestMarshalToMessageToSignV1_UsesFastMarshaller(t *testing.T) {
 	tr := &TokenRequest{
 		Issues:    [][]byte{[]byte("issue1"), []byte("issue2")},
 		Transfers: [][]byte{[]byte("transfer1")},
 	}
 	anchor := []byte("test-anchor")
 
-	// Get V2 output (should use fast marshaller)
-	v2Result, err := tr.marshalToMessageToSignV2(anchor)
+	// Get V1 output (should use fast marshaller)
+	v1Result, err := tr.marshalToMessageToSignV1(anchor)
 	require.NoError(t, err)
 
 	// Manually construct expected output using standard ASN.1
@@ -288,8 +288,8 @@ func TestMarshalToMessageToSignV2_UsesFastMarshaller(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	// V2 should produce identical output
-	assert.Equal(t, expectedResult, v2Result, "V2 should produce ASN.1-compatible output")
+	// V1 should produce identical output
+	assert.Equal(t, expectedResult, v1Result, "V1 should produce ASN.1-compatible output")
 }
 
 // TestFastMarshalRoundTrip verifies that fast-marshalled data can be unmarshalled correctly
@@ -357,3 +357,4 @@ func TestFastMarshalDeterministic(t *testing.T) {
 	assert.True(t, bytes.Equal(result1, result2))
 	assert.True(t, bytes.Equal(result2, result3))
 }
+

token/driver/request.go

@@ -7,8 +7,6 @@ SPDX-License-Identifier: Apache-2.0
 package driver
 
 import (
-	"encoding/asn1"
-
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/proto"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/protos-go/utils"
@@ -20,8 +18,10 @@ import (
 )
 
 const (
+	// ProtocolV1 demarks the V1 version of the protocol
+	// This version uses a secure structured format with explicit Request and Anchor fields,
+	// providing robust boundary separation and preventing collision attacks.
 	ProtocolV1 = 1
-	ProtocolV2 = 2
 
 	// MaxAnchorSize defines the maximum allowed size for anchor parameter in bytes.
 	// This limit prevents potential DoS attacks through excessive memory allocation.
@@ -166,10 +166,9 @@ type TokenRequest struct {
 	Transfers  [][]byte
 	Signatures []*RequestSignature
 	// Version specifies the protocol version for this token request.
-	// Defaults to ProtocolV2 for new requests.
-	// Set to ProtocolV1 when deserializing legacy requests for backward compatibility.
+	// Defaults to ProtocolV1 (structured format) for new requests.
 	// The asn1 tag with "-" means this field is never included in ASN.1 marshaling,
-	// ensuring backward compatibility with V1 signature verification.
+	// ensuring consistent signature verification.
 	Version uint32
 }
 
@@ -202,10 +201,10 @@ func (r *TokenRequest) ToProtos() (*request.TokenRequest, error) {
 		return nil, errors.Wrap(err, "failed converting request signatures")
 	}
 
-	// Use stored version, defaulting to V2 for new requests
+	// Use stored version, defaulting to V1 (structured format) for new requests
 	version := r.Version
 	if version == 0 {
-		version = uint32(ProtocolV2)
+		version = uint32(ProtocolV1)
 	}
 
 	return &request.TokenRequest{
@@ -216,9 +215,9 @@ func (r *TokenRequest) ToProtos() (*request.TokenRequest, error) {
 }
 
 func (r *TokenRequest) FromProtos(tr *request.TokenRequest) error {
-	// Validate version
-	if tr.Version != uint32(ProtocolV1) && tr.Version != uint32(ProtocolV2) {
-		return errors.Wrapf(ErrUnsupportedVersion, "expected [%d] or [%d], got [%d]", ProtocolV1, ProtocolV2, tr.Version)
+	// Validate version - only ProtocolV1 (structured format) is supported
+	if tr.Version != uint32(ProtocolV1) {
+		return errors.Wrapf(ErrUnsupportedVersion, "expected [%d], got [%d]", ProtocolV1, tr.Version)
 	}
 
 	// Store the version from the protobuf
@@ -270,96 +269,48 @@ func (r *TokenRequest) FromProtos(tr *request.TokenRequest) error {
 }
 
 // MarshalToMessageToSign creates a canonical byte representation of the TokenRequest
-// for signature generation. The behavior depends on the protocol version:
-//
-// ProtocolV1: Uses simple concatenation (ASN.1-encoded request + anchor).
-// This method is maintained for backward compatibility but has known security
-// limitations regarding potential hash collisions.
+// for signature generation using the structured ASN.1 format.
 //
-// ProtocolV2: Uses structured ASN.1 format with separate Request and Anchor fields,
-// providing robust boundary separation and preventing collision attacks.
+// The ProtocolV1 format uses a secure structured ASN.1 format with separate Request
+// and Anchor fields, providing robust boundary separation and preventing collision attacks.
 //
 // Parameters:
 //   - anchor: A unique identifier (e.g., transaction ID) that binds this signature
-//     to a specific context. For V2, must be non-empty and within size limits.
+//     to a specific context. Must be non-empty and within size limits.
 //
 // Security considerations:
 //   - The anchor MUST be unique per transaction to prevent signature reuse
 //   - Signatures are not included in the marshaled data to avoid circular dependencies
-//   - V1 uses concatenation which requires careful anchor selection
-//   - V2 uses structured format which provides stronger security guarantees
+//   - Structured format provides strong security guarantees against collision attacks
 //
 // Returns the message bytes to be signed, or an error if marshaling fails.
 func (r *TokenRequest) MarshalToMessageToSign(anchor []byte) ([]byte, error) {
-	// Dispatch based on protocol version
-	switch r.getVersion() {
-	case ProtocolV1:
-		return r.marshalToMessageToSignV1(anchor)
-	case ProtocolV2:
-		return r.marshalToMessageToSignV2(anchor)
-	default:
-		return nil, errors.Errorf("unsupported protocol version [%d]", r.getVersion())
-	}
+	return r.marshalToMessageToSignV1(anchor)
 }
 
 // getVersion returns the protocol version of this TokenRequest.
-// Returns the stored version, defaulting to V2 for new requests.
+// Returns the stored version, defaulting to V1 (structured format) for new requests.
 func (r *TokenRequest) getVersion() int {
 	if r.Version == 0 {
-		// Default to V2 for new requests
-		return ProtocolV2
+		// Default to V1 (structured format) for new requests
+		return ProtocolV1
 	}
 
 	return int(r.Version)
 }
 
-// marshalToMessageToSignV1 implements the V1 protocol signature message construction.
-// This method maintains the original behavior for backward compatibility with existing
-// test data and deployed systems.
-//
-// WARNING: This implementation has known security limitations:
-//   - Simple concatenation without delimiter allows potential boundary ambiguity
-//   - Different (request, anchor) pairs could theoretically produce identical messages
-//
-// This method is preserved unchanged to ensure regression tests pass.
-func (r *TokenRequest) marshalToMessageToSignV1(anchor []byte) ([]byte, error) {
-	// Use a struct that matches the original TokenRequest structure (4 fields).
-	// Even though only Issues and Transfers are populated, ASN.1 encodes all fields,
-	// including empty Signatures and AuditorSignatures as empty sequences.
-	// This ensures identical ASN.1 encoding for backward compatibility with V1 signatures.
-	type tokenRequestV1 struct {
-		Issues            [][]byte
-		Transfers         [][]byte
-		Signatures        [][]byte
-		AuditorSignatures []*AuditorSignature
-	}
-
-	bytes, err := asn1.Marshal(tokenRequestV1{
-		Issues:    r.Issues,
-		Transfers: r.Transfers,
-	})
-	if err != nil {
-		return nil, errors.Wrapf(err, "audit of tx [%s] failed: error marshal token request for signature", string(anchor))
-	}
-
-	return append(bytes, anchor...), nil
-}
-
-// marshalToMessageToSignV2 implements the V2 protocol signature message construction
+// marshalToMessageToSignV1 implements the V1 protocol signature message construction
 // using a secure structured ASN.1 format that prevents hash collision vulnerabilities.
 //
-// Security improvements over V1:
+// Security features:
 //   - Structured ASN.1 format with explicit Request and Anchor fields
 //   - Clear boundary separation prevents collision attacks
 //   - Input validation ensures anchor meets security requirements
 //   - Hex-encoded error messages prevent sensitive data exposure
 //
-// This method should be used for all new token requests to benefit from
-// enhanced security properties.
-//
 // This implementation uses an optimized fast marshaller that avoids reflection overhead
 // while maintaining full ASN.1 compatibility.
-func (r *TokenRequest) marshalToMessageToSignV2(anchor []byte) ([]byte, error) {
+func (r *TokenRequest) marshalToMessageToSignV1(anchor []byte) ([]byte, error) {
 	// Input validation with typed errors
 	if len(anchor) == 0 {
 		return nil, ErrAnchorEmpty