refactor the trusted params on the verifer.

algorand · id-ms · May 10, 2022 · Feb 16, 2022 · Mar 10, 2022 · Mar 13, 2022
commit a3507ada1c643c9dfc7e7a5d7bf027c92a4c817e
diff --git a/compactcert/builder.go b/compactcert/builder.go
@@ -64,15 +64,15 @@ func (ccw *Worker) builderForRound(rnd basics.Round) (builder, error) {
 	}
 	ccw.Message = msg
 
-	p, err := ledger.CompactCertParams(msg, votersHdr, hdr)
+	p, err := ledger.CompactCertParams(votersHdr, hdr)
 	if err != nil {
 		return builder{}, err
 	}
 
 	var res builder
 	res.votersHdr = votersHdr
 	res.voters = voters
-	res.Builder, err = compactcert.MkBuilder(p, voters.Participants, voters.Tree)
+	res.Builder, err = compactcert.MkBuilder(p, msg.IntoStateProofMessageHash(), uint64(hdr.Round), voters.Participants, voters.Tree)
 	if err != nil {
 		return builder{}, err
 	}

diff --git a/compactcert/worker_test.go b/compactcert/worker_test.go
@@ -295,9 +295,7 @@ func TestWorkerAllSigs(t *testing.T) {
 			require.False(t, overflowed)
 
 			ccparams := compactcert.Params{
-				Data:           tx.Txn.CertMsg.IntoStateProofMessageHash(),
 				ProvenWeight:   provenWeight,
-				Round:          tx.Txn.CertIntervalLatestRound,
 				StrengthTarget: proto.CompactCertStrengthTarget,
 			}
 
@@ -307,7 +305,7 @@ func TestWorkerAllSigs(t *testing.T) {
 			verif, err := compactcert.MkVerifier(ccparams, voters.Tree.Root())
 			require.NoError(t, err)
 
-			err = verif.Verify(&tx.Txn.Cert)
+			err = verif.Verify(uint64(tx.Txn.CertIntervalLatestRound), tx.Txn.CertMsg.IntoStateProofMessageHash(), &tx.Txn.Cert)
 			require.NoError(t, err)
 			break
 		}
@@ -361,9 +359,7 @@ func TestWorkerPartialSigs(t *testing.T) {
 	require.False(t, overflowed)
 
 	ccparams := compactcert.Params{
-		Data:           msg.IntoStateProofMessageHash(),
 		ProvenWeight:   provenWeight,
-		Round:          tx.Txn.CertIntervalLatestRound,
 		StrengthTarget: proto.CompactCertStrengthTarget,
 	}
 
@@ -372,7 +368,7 @@ func TestWorkerPartialSigs(t *testing.T) {
 
 	verif, err := compactcert.MkVerifier(ccparams, voters.Tree.Root())
 	require.NoError(t, err)
-	err = verif.Verify(&tx.Txn.Cert)
+	err = verif.Verify(uint64(tx.Txn.CertIntervalLatestRound), msg.IntoStateProofMessageHash(), &tx.Txn.Cert)
 	require.NoError(t, err)
 }
 

diff --git a/config/consensus.go b/config/consensus.go
@@ -382,8 +382,7 @@ type ConsensusParams struct {
 	// The threshold is computed as CompactCertWeightThreshold/(1<<32).
 	CompactCertWeightThreshold uint32
 
-	// CompactCertStrengthTarget is the security parameter for the compact
-	// certificate scheme.
+	// CompactCertStrengthTarget represents either k+q (for pre-quantum security) or k+2q (for post-quantum security)
 	CompactCertStrengthTarget uint64
 
 	// EnableAssetCloseAmount adds an extra field to the ApplyData. The field contains the amount of the remaining

diff --git a/crypto/compactcert/builder.go b/crypto/compactcert/builder.go
@@ -41,6 +41,8 @@ type sigslot struct {
 // a compact certificate for that message.
 type Builder struct {
 	Params
+	data           StateProofMessageHash
+	round          uint64
 	sigs           []sigslot // Indexed by pos in participants
 	sigsHasValidL  bool      // The L values in sigs are consistent with weights
 	signedWeight   uint64    // Total weight of signatures so far
@@ -57,16 +59,17 @@ type Builder struct {
 // to be signed, as well as other security parameters, are specified in
 // param.  The participants that will sign the message are in part and
 // parttree.
-func MkBuilder(param Params, part []basics.Participant, parttree *merklearray.Tree) (*Builder, error) {
+func MkBuilder(param Params, data StateProofMessageHash, round uint64, part []basics.Participant, parttree *merklearray.Tree) (*Builder, error) {
 	npart := len(part)
 	lnProvenWt, err := lnIntApproximation(param.ProvenWeight)
 	if err != nil {
 		return nil, err
 	}
 
 	b := &Builder{
-		Params: param,
-
+		Params:         param,
+		data:           data,
+		round:          round,
 		sigs:           make([]sigslot, npart),
 		sigsHasValidL:  false,
 		signedWeight:   0,
@@ -104,9 +107,9 @@ func (b *Builder) IsValid(pos uint64, sig merklesignature.Signature, verifySig b
 			return err
 		}
 
-		cpy := make([]byte, len(b.Params.Data))
-		copy(cpy, b.Params.Data[:]) // TODO: onmce cfalcon is fixed can remove this copy.
-		if err := p.PK.VerifyBytes(uint64(b.Round), cpy, sig); err != nil {
+		cpy := make([]byte, len(b.data))
+		copy(cpy, b.data[:]) // TODO: onmce cfalcon is fixed can remove this copy.
+		if err := p.PK.VerifyBytes(b.round, cpy, sig); err != nil {
 			return err
 		}
 	}
@@ -213,7 +216,7 @@ func (b *Builder) Build() (*Cert, error) {
 		lnProvenWeight: b.lnProvenWeight,
 		sigCommitment:  c.SigCommit,
 		signedWeight:   c.SignedWeight,
-		data:           b.Params.Data,
+		data:           b.data,
 	}
 
 	coinHash := makeCoinGenerator(&choice)

diff --git a/crypto/compactcert/builder_test.go b/crypto/compactcert/builder_test.go
@@ -75,8 +75,7 @@ func generateTestSigner(firstValid uint64, lastValid uint64, interval uint64, a
 	return signer
 }
 
-func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.GenericDigest, uint64) {
-	currentRound := basics.Round(compactCertRoundsForTests)
+func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.GenericDigest, uint64, StateProofMessageHash) {
 	// Doing a full test of 1M accounts takes too much CPU time in CI.
 	doLargeTest := false
 
@@ -91,10 +90,9 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 
 	npart := npartHi + npartLo
 
+	data := testMessage("hello world").IntoStateProofMessageHash()
 	param := Params{
-		Data:           testMessage("hello world").IntoStateProofMessageHash(),
 		ProvenWeight:   uint64(totalWeight / 2),
-		Round:          currentRound,
 		StrengthTarget: compactCertStrengthTarget,
 	}
 
@@ -105,8 +103,8 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartHi, key.GetVerifier())...)
 	parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartLo, key.GetVerifier())...)
 
-	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.Data[:])
+	signerInRound := key.GetSigner(compactCertRoundsForTests)
+	sig, err := signerInRound.SignBytes(data[:])
 	a.NoError(err, "failed to create keys")
 
 	for i := 0; i < npart; i++ {
@@ -116,7 +114,7 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	partcom, err := merklearray.BuildVectorCommitmentTree(basics.ParticipantsArray(parts), crypto.HashFactory{HashType: HashType})
 	a.NoError(err)
 
-	b, err := MkBuilder(param, parts, partcom)
+	b, err := MkBuilder(param, data, compactCertRoundsForTests, parts, partcom)
 	a.NoError(err)
 
 	for i := 0; i < npart; i++ {
@@ -128,15 +126,15 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	cert, err := b.Build()
 	a.NoError(err)
 
-	return cert, param, partcom.Root(), uint64(npart)
+	return cert, param, partcom.Root(), uint64(npart), data
 }
 
 func TestBuildVerify(t *testing.T) {
 	partitiontest.PartitionTest(t)
 
 	a := require.New(t)
 
-	cert, param, partCom, _ := generateCertForTesting(a)
+	cert, param, partCom, _, data := generateCertForTesting(a)
 
 	var someReveal Reveal
 	for _, rev := range cert.Reveals {
@@ -159,11 +157,11 @@ func TestBuildVerify(t *testing.T) {
 	verif, err := MkVerifier(param, partCom)
 	a.NoError(err)
 
-	err = verif.Verify(cert)
+	err = verif.Verify(compactCertRoundsForTests, data, cert)
 	a.NoError(err, "failed to verify the compact cert")
 }
 
-func generateRandomParticipant(a *require.Assertions, testname string) basics.Participant {
+func generateRandomParticipant(a *require.Assertions) basics.Participant {
 	key := generateTestSigner(0, 8, 1, a)
 
 	p := basics.Participant{
@@ -205,10 +203,10 @@ func TestParticipationCommitmentBinaryFormat(t *testing.T) {
 	a := require.New(t)
 
 	var parts []basics.Participant
-	parts = append(parts, generateRandomParticipant(a, t.Name()))
-	parts = append(parts, generateRandomParticipant(a, t.Name()))
-	parts = append(parts, generateRandomParticipant(a, t.Name()))
-	parts = append(parts, generateRandomParticipant(a, t.Name()))
+	parts = append(parts, generateRandomParticipant(a))
+	parts = append(parts, generateRandomParticipant(a))
+	parts = append(parts, generateRandomParticipant(a))
+	parts = append(parts, generateRandomParticipant(a))
 
 	partcom, err := merklearray.BuildVectorCommitmentTree(basics.ParticipantsArray(parts), crypto.HashFactory{HashType: HashType})
 	a.NoError(err)
@@ -234,14 +232,12 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 
 	a := require.New(t)
 
-	currentRound := basics.Round(compactCertRoundsForTests)
 	totalWeight := 10000000
 	numPart := 4
 
+	data := testMessage("test!").IntoStateProofMessageHash()
 	param := Params{
-		Data:           testMessage("test!").IntoStateProofMessageHash(),
 		ProvenWeight:   uint64(totalWeight / (2 * numPart)),
-		Round:          currentRound,
 		StrengthTarget: compactCertStrengthTarget,
 	}
 
@@ -257,7 +253,7 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 		}
 		parts = append(parts, part)
 
-		sig, err := key.GetSigner(uint64(currentRound)).SignBytes(param.Data[:])
+		sig, err := key.GetSigner(compactCertRoundsForTests).SignBytes(data[:])
 		require.NoError(t, err, "failed to create keys")
 		sigs = append(sigs, sig)
 
@@ -266,7 +262,7 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 	partcom, err := merklearray.BuildVectorCommitmentTree(basics.ParticipantsArray(parts), crypto.HashFactory{HashType: HashType})
 	a.NoError(err)
 
-	b, err := MkBuilder(param, parts, partcom)
+	b, err := MkBuilder(param, data, compactCertRoundsForTests, parts, partcom)
 	a.NoError(err)
 
 	for i := 0; i < numPart; i++ {
@@ -432,16 +428,14 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 
 	// setting up a builder
 	a := require.New(t)
-	currentRound := basics.Round(compactCertRoundsForTests)
 
 	totalWeight := 10000000
 	npartHi := 1
 	npartLo := 9
 
+	data := testMessage("hello world").IntoStateProofMessageHash()
 	param := Params{
-		Data:           testMessage("hello world").IntoStateProofMessageHash(),
 		ProvenWeight:   uint64(totalWeight / 2),
-		Round:          currentRound,
 		StrengthTarget: compactCertStrengthTarget,
 	}
 
@@ -453,12 +447,12 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 	partcom, err := merklearray.BuildVectorCommitmentTree(basics.ParticipantsArray(parts), crypto.HashFactory{HashType: HashType})
 	a.NoError(err)
 
-	builder, err := MkBuilder(param, parts, partcom)
+	builder, err := MkBuilder(param, data, compactCertRoundsForTests, parts, partcom)
 	a.NoError(err)
 
 	// actual test:
-	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.Data[:])
+	signerInRound := key.GetSigner(compactCertRoundsForTests)
+	sig, err := signerInRound.SignBytes(data[:])
 	require.NoError(t, err, "failed to create keys")
 	// Corrupting the version of the signature:
 	sig.Signature[1]++
@@ -492,8 +486,9 @@ func TestBuilderWithZeroProvenWeight(t *testing.T) {
 	a := require.New(t)
 
 	p := Params{ProvenWeight: 0}
+	data := testMessage("hello world").IntoStateProofMessageHash()
 
-	_, err := MkBuilder(p, nil, nil)
+	_, err := MkBuilder(p, data, compactCertRoundsForTests, nil, nil)
 	a.ErrorIs(err, ErrIllegalInputForLnApprox)
 
 }
@@ -502,13 +497,11 @@ func BenchmarkBuildVerify(b *testing.B) {
 	totalWeight := 1000000
 	npart := 1000
 
-	currentRound := basics.Round(compactCertRoundsForTests)
 	a := require.New(b)
 
+	data := testMessage("hello world").IntoStateProofMessageHash()
 	param := Params{
-		Data:           testMessage("hello world").IntoStateProofMessageHash(),
 		ProvenWeight:   uint64(totalWeight / 2),
-		Round:          compactCertRoundsForTests,
 		StrengthTarget: compactCertStrengthTarget,
 	}
 
@@ -522,8 +515,8 @@ func BenchmarkBuildVerify(b *testing.B) {
 			Weight: uint64(totalWeight / npart),
 		}
 
-		signerInRound := signer.GetSigner(uint64(currentRound))
-		sig, err := signerInRound.SignBytes(param.Data[:])
+		signerInRound := signer.GetSigner(compactCertRoundsForTests)
+		sig, err := signerInRound.SignBytes(data[:])
 		require.NoError(b, err, "failed to create keys")
 
 		partkeys = append(partkeys, signer)
@@ -539,7 +532,7 @@ func BenchmarkBuildVerify(b *testing.B) {
 
 	b.Run("AddBuild", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
-			builder, err := MkBuilder(param, parts, partcom)
+			builder, err := MkBuilder(param, data, compactCertRoundsForTests, parts, partcom)
 			if err != nil {
 				b.Error(err)
 			}
@@ -560,7 +553,7 @@ func BenchmarkBuildVerify(b *testing.B) {
 	b.Run("Verify", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			verif, _ := MkVerifier(param, partcom.Root())
-			if err = verif.Verify(cert); err != nil {
+			if err = verif.Verify(compactCertRoundsForTests, data, cert); err != nil {
 				b.Error(err)
 			}
 		}

diff --git a/crypto/compactcert/coinGenerator.go b/crypto/compactcert/coinGenerator.go
@@ -72,7 +72,7 @@ func makeCoinGenerator(choice *coinChoiceSeed) coinGenerator {
 	rep := crypto.HashRep(choice)
 	shk := sha3.NewShake256()
 	shk.Write(rep)
-	
+
 	threshold, signedWt := prepareRejectionSamplingValues(choice.signedWeight)
 	return coinGenerator{shkContext: shk, signedWeight: signedWt, threshold: threshold}
 

diff --git a/crypto/compactcert/committableSignatureSlot.go b/crypto/compactcert/committableSignatureSlot.go
@@ -78,7 +78,7 @@ func (cs *committableSignatureSlot) ToBeHashed() (protocol.HashID, []byte) {
 	}
 	binaryLValue := make([]byte, 8)
 	binary.LittleEndian.PutUint64(binaryLValue, cs.sigCommit.L)
-	
+
 	sigSlotByteRepresentation := make([]byte, 0, len(binaryLValue)+len(cs.serializedSignature))
 	sigSlotByteRepresentation = append(sigSlotByteRepresentation, binaryLValue...)
 	sigSlotByteRepresentation = append(sigSlotByteRepresentation, cs.serializedSignature...)

diff --git a/crypto/compactcert/structs.go b/crypto/compactcert/structs.go
@@ -31,9 +31,7 @@ const StateProofMessageHashType = crypto.Sha256
 
 // Params defines common parameters for the verifier and builder.
 type Params struct {
-	Data           StateProofMessageHash
-	ProvenWeight   uint64       // Weight proven by the certificate
-	Round          basics.Round // The round for which the ephemeral key is committed to
+	ProvenWeight   uint64 // Weight proven by the certificate
 	StrengthTarget uint64
 }
 
@@ -64,12 +62,11 @@ type Reveal struct {
 type Cert struct {
 	_struct struct{} `codec:",omitempty,omitemptyarray"`
 
-	SigCommit    crypto.GenericDigest `codec:"c"`
-	SignedWeight uint64               `codec:"w"`
-	SigProofs    merklearray.Proof    `codec:"S"`
-	PartProofs   merklearray.Proof    `codec:"P"`
-	// CR salt version - chagne the falcon to byte or change this to int
-	MerkleSignatureSaltVersion int32 `codec:"v"`
+	SigCommit                  crypto.GenericDigest `codec:"c"`
+	SignedWeight               uint64               `codec:"w"`
+	SigProofs                  merklearray.Proof    `codec:"S"`
+	PartProofs                 merklearray.Proof    `codec:"P"`
+	MerkleSignatureSaltVersion int32                `codec:"v"`
 	// Reveals is a sparse map from the position being revealed
 	// to the corresponding elements from the sigs and participants
 	// arrays.