test: move setup decoder tests to utils_test and cover both symmetrically (F-2026-18199)

Author: Aman035

universalClient/tss/dkls/sign_test.go

@@ -1,7 +1,6 @@
 package dkls
 
 import (
-	"bytes"
 	"strings"
 	"testing"
 
@@ -131,56 +130,3 @@ func TestSignSession_EndToEnd(t *testing.T) {
 		t.Errorf("expected 2 participants, got %d", len(result.Participants))
 	}
 }
-
-// DKLS signs the hash embedded in the setup blob, not the hash a follower
-// verified separately. SetupMessageHash exposes the embedded one so callers can
-// bind the two, which is what stops a coordinator presenting one hash for
-// verification and embedding another in the setup it distributes.
-func TestSetupMessageHash(t *testing.T) {
-	participantIDs := encodeParticipantIDs([]string{"party1", "party2"})
-	keyID := make([]byte, 32)
-
-	legitHash := make([]byte, 32)
-	copy(legitHash, "legitimate-outbound-hash-32bytes")
-	attackerHash := make([]byte, 32)
-	copy(attackerHash, "attacker-chosen-vault-call-digest")
-
-	t.Run("returns the hash embedded in the setup", func(t *testing.T) {
-		setup, err := session.DklsSignSetupMsgNew(keyID, nil, legitHash, participantIDs)
-		if err != nil {
-			t.Fatalf("failed to build sign setup: %v", err)
-		}
-		got, err := SetupMessageHash(setup)
-		if err != nil {
-			t.Fatalf("SetupMessageHash() error = %v", err)
-		}
-		if !bytes.Equal(got, legitHash) {
-			t.Errorf("SetupMessageHash() = %x, want %x", got, legitHash)
-		}
-	})
-
-	// The attack: a setup built over attackerHash must not report legitHash, so
-	// a caller comparing against its verified hash detects the substitution.
-	t.Run("substituted setup reports the attacker hash", func(t *testing.T) {
-		setup, err := session.DklsSignSetupMsgNew(keyID, nil, attackerHash, participantIDs)
-		if err != nil {
-			t.Fatalf("failed to build sign setup: %v", err)
-		}
-		got, err := SetupMessageHash(setup)
-		if err != nil {
-			t.Fatalf("SetupMessageHash() error = %v", err)
-		}
-		if bytes.Equal(got, legitHash) {
-			t.Fatal("substituted setup must not report the legitimate hash")
-		}
-		if !bytes.Equal(got, attackerHash) {
-			t.Errorf("SetupMessageHash() = %x, want %x", got, attackerHash)
-		}
-	})
-
-	t.Run("rejects empty setup", func(t *testing.T) {
-		if _, err := SetupMessageHash(nil); err == nil {
-			t.Error("SetupMessageHash(nil) should error")
-		}
-	})
-}

universalClient/tss/dkls/utils_test.go

@@ -1,8 +1,11 @@
 package dkls
 
 import (
+	"bytes"
 	"crypto/sha256"
 	"testing"
+
+	session "go-wrapper/go-dkls/sessions"
 )
 
 func TestDeriveKeyID(t *testing.T) {
@@ -58,3 +61,107 @@ func TestEncodeParticipantIDs(t *testing.T) {
 		})
 	}
 }
+
+// The setup blob is what DKLS actually runs on, so these decoders are what let a
+// follower bind it to the values it validated separately. Both must report what
+// the blob really contains, and must error rather than guess on a malformed one.
+
+func TestSetupMessageHash(t *testing.T) {
+	participantIDs := encodeParticipantIDs([]string{"party1", "party2"})
+	keyID := make([]byte, 32)
+
+	legitHash := make([]byte, 32)
+	copy(legitHash, "legitimate-outbound-hash-32bytes")
+	attackerHash := make([]byte, 32)
+	copy(attackerHash, "attacker-chosen-vault-call-digest")
+
+	t.Run("returns the hash embedded in the setup", func(t *testing.T) {
+		setup, err := session.DklsSignSetupMsgNew(keyID, nil, legitHash, participantIDs)
+		if err != nil {
+			t.Fatalf("failed to build sign setup: %v", err)
+		}
+		got, err := SetupMessageHash(setup)
+		if err != nil {
+			t.Fatalf("SetupMessageHash() error = %v", err)
+		}
+		if !bytes.Equal(got, legitHash) {
+			t.Errorf("SetupMessageHash() = %x, want %x", got, legitHash)
+		}
+	})
+
+	// A substituted setup must report the hash it really signs, which is what
+	// makes the mismatch detectable.
+	t.Run("substituted setup reports the attacker hash", func(t *testing.T) {
+		setup, err := session.DklsSignSetupMsgNew(keyID, nil, attackerHash, participantIDs)
+		if err != nil {
+			t.Fatalf("failed to build sign setup: %v", err)
+		}
+		got, err := SetupMessageHash(setup)
+		if err != nil {
+			t.Fatalf("SetupMessageHash() error = %v", err)
+		}
+		if bytes.Equal(got, legitHash) {
+			t.Fatal("substituted setup must not report the legitimate hash")
+		}
+		if !bytes.Equal(got, attackerHash) {
+			t.Errorf("SetupMessageHash() = %x, want %x", got, attackerHash)
+		}
+	})
+
+	t.Run("errors on empty and malformed setup", func(t *testing.T) {
+		if _, err := SetupMessageHash(nil); err == nil {
+			t.Error("SetupMessageHash(nil) should error")
+		}
+		if _, err := SetupMessageHash([]byte("not-a-dkls-setup")); err == nil {
+			t.Error("SetupMessageHash(malformed) should error")
+		}
+	})
+}
+
+func TestSetupParticipants(t *testing.T) {
+	t.Run("returns the participants in index order", func(t *testing.T) {
+		want := []string{"alice", "bob", "carol"}
+		setup, err := session.DklsKeygenSetupMsgNew(2, nil, encodeParticipantIDs(want))
+		if err != nil {
+			t.Fatalf("failed to build keygen setup: %v", err)
+		}
+		got, err := SetupParticipants(setup)
+		if err != nil {
+			t.Fatalf("SetupParticipants() error = %v", err)
+		}
+		if len(got) != len(want) {
+			t.Fatalf("SetupParticipants() = %v, want %v", got, want)
+		}
+		for i := range want {
+			if got[i] != want[i] {
+				t.Errorf("participant %d = %q, want %q", i, got[i], want[i])
+			}
+		}
+	})
+
+	// Enumeration terminates on the first empty name rather than an error, which
+	// is the contract this relies on to find the end of the list.
+	t.Run("terminates at the end of a two party list", func(t *testing.T) {
+		want := []string{"first", "second"}
+		setup, err := session.DklsKeygenSetupMsgNew(2, nil, encodeParticipantIDs(want))
+		if err != nil {
+			t.Fatalf("failed to build keygen setup: %v", err)
+		}
+		got, err := SetupParticipants(setup)
+		if err != nil {
+			t.Fatalf("SetupParticipants() error = %v", err)
+		}
+		if len(got) != 2 || got[0] != "first" || got[1] != "second" {
+			t.Errorf("SetupParticipants() = %v, want %v", got, want)
+		}
+	})
+
+	t.Run("errors on empty and malformed setup", func(t *testing.T) {
+		if _, err := SetupParticipants(nil); err == nil {
+			t.Error("SetupParticipants(nil) should error")
+		}
+		if _, err := SetupParticipants([]byte("not-a-dkls-setup")); err == nil {
+			t.Error("SetupParticipants(malformed) should error")
+		}
+	})
+}