fix CRs

algorand · id-ms · May 10, 2022 · Feb 16, 2022 · Mar 10, 2022 · Mar 13, 2022
commit e7941801674596a2c9f88c4eeb073b48d906ccf3
diff --git a/compactcert/worker_test.go b/compactcert/worker_test.go
@@ -295,10 +295,10 @@ func TestWorkerAllSigs(t *testing.T) {
 			require.False(t, overflowed)
 
 			ccparams := compactcert.Params{
-				MessageHash:           tx.Txn.CertMsg.IntoStateProofMessageHash(),
-				ProvenWeightThreshold: provenWeight,
-				SigRound:              tx.Txn.CertIntervalLatestRound,
-				SecKQ:                 proto.CompactCertSecKQ,
+				Data:         tx.Txn.CertMsg.IntoStateProofMessageHash(),
+				ProvenWeight: provenWeight,
+				Round:        tx.Txn.CertIntervalLatestRound,
+				SecKQ:        proto.CompactCertSecKQ,
 			}
 
 			voters, err := s.CompactCertVoters(tx.Txn.CertIntervalLatestRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))
@@ -361,10 +361,10 @@ func TestWorkerPartialSigs(t *testing.T) {
 	require.False(t, overflowed)
 
 	ccparams := compactcert.Params{
-		MessageHash:           msg.IntoStateProofMessageHash(),
-		ProvenWeightThreshold: provenWeight,
-		SigRound:              basics.Round(tx.Txn.CertIntervalLatestRound),
-		SecKQ:                 proto.CompactCertSecKQ,
+		Data:         msg.IntoStateProofMessageHash(),
+		ProvenWeight: provenWeight,
+		Round:        tx.Txn.CertIntervalLatestRound,
+		SecKQ:        proto.CompactCertSecKQ,
 	}
 
 	voters, err := s.CompactCertVoters(tx.Txn.CertIntervalLatestRound - basics.Round(proto.CompactCertRounds) - basics.Round(proto.CompactCertVotersLookback))

diff --git a/crypto/compactcert/builder.go b/crypto/compactcert/builder.go
@@ -41,12 +41,12 @@ type sigslot struct {
 // a compact certificate for that message.
 type Builder struct {
 	Params
-	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
-	participants            []basics.Participant
-	parttree                *merklearray.Tree
-	lnProvenWeightThreshold 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
+	participants   []basics.Participant
+	parttree       *merklearray.Tree
+	lnProvenWeight uint64
 
 	// Cached cert, if Build() was called and no subsequent
 	// Add() calls were made.
@@ -59,20 +59,20 @@ type Builder struct {
 // parttree.
 func MkBuilder(param Params, part []basics.Participant, parttree *merklearray.Tree) (*Builder, error) {
 	npart := len(part)
-	lnProvenWt, err := lnIntApproximation(param.ProvenWeightThreshold, precisionBits)
+	lnProvenWt, err := lnIntApproximation(param.ProvenWeight, precisionBits)
 	if err != nil {
 		return nil, err
 	}
 
 	b := &Builder{
 		Params: param,
 
-		sigs:                    make([]sigslot, npart),
-		sigsHasValidL:           false,
-		signedWeight:            0,
-		participants:            part,
-		parttree:                parttree,
-		lnProvenWeightThreshold: lnProvenWt,
+		sigs:           make([]sigslot, npart),
+		sigsHasValidL:  false,
+		signedWeight:   0,
+		participants:   part,
+		parttree:       parttree,
+		lnProvenWeight: lnProvenWt,
 	}
 
 	return b, nil
@@ -104,9 +104,9 @@ func (b *Builder) IsValid(pos uint64, sig merklesignature.Signature, verifySig b
 			return err
 		}
 
-		cpy := make([]byte, len(b.Params.MessageHash))
-		copy(cpy, b.Params.MessageHash[:]) // TODO: onmce cfalcon is fixed can remove this copy.
-		if err := p.PK.VerifyBytes(uint64(b.SigRound), cpy, sig); err != nil {
+		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 {
 			return err
 		}
 	}
@@ -127,7 +127,7 @@ func (b *Builder) Add(pos uint64, sig merklesignature.Signature) {
 
 // Ready returns whether the certificate is ready to be built.
 func (b *Builder) Ready() bool {
-	return b.signedWeight > b.Params.ProvenWeightThreshold
+	return b.signedWeight > b.Params.ProvenWeight
 }
 
 // SignedWeight returns the total weight of signatures added so far.
@@ -175,8 +175,8 @@ func (b *Builder) Build() (*Cert, error) {
 		return b.cert, nil
 	}
 
-	if b.signedWeight <= b.Params.ProvenWeightThreshold {
-		return nil, fmt.Errorf("%w: %d <= %d", ErrSignedWeightLessThanProvenWeight, b.signedWeight, b.Params.ProvenWeightThreshold)
+	if b.signedWeight <= b.Params.ProvenWeight {
+		return nil, fmt.Errorf("%w: %d <= %d", ErrSignedWeightLessThanProvenWeight, b.signedWeight, b.Params.ProvenWeight)
 	}
 
 	// Commit to the sigs array
@@ -199,7 +199,7 @@ func (b *Builder) Build() (*Cert, error) {
 		MerkleSignatureVersion: merklesignature.SchemeVersion,
 	}
 
-	nr, err := numReveals(b.signedWeight, b.lnProvenWeightThreshold, b.SecKQ)
+	nr, err := numReveals(b.signedWeight, b.lnProvenWeight, b.SecKQ)
 	if err != nil {
 		return nil, err
 	}
@@ -209,11 +209,11 @@ func (b *Builder) Build() (*Cert, error) {
 	revealsSequence := make([]uint64, nr)
 
 	choice := coinChoiceSeed{
-		msgHash:                 b.Params.MessageHash,
-		lnProvenWeightThreshold: b.lnProvenWeightThreshold,
-		signedWeight:            c.SignedWeight,
-		sigCommitment:           c.SigCommit,
-		partCommitment:          b.parttree.Root(),
+		data:           b.Params.Data,
+		lnProvenWeight: b.lnProvenWeight,
+		signedWeight:   c.SignedWeight,
+		sigCommitment:  c.SigCommit,
+		partCommitment: b.parttree.Root(),
 	}
 
 	coinHash := makeCoinGenerator(&choice)

diff --git a/crypto/compactcert/builder_test.go b/crypto/compactcert/builder_test.go
@@ -80,8 +80,7 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	// Doing a full test of 1M accounts takes too much CPU time in CI.
 	doLargeTest := false
 
-	totalWeight := 10
-	000
+	totalWeight := 10000000
 	npartHi := 10
 	npartLo := 9990
 
@@ -93,10 +92,10 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	npart := npartHi + npartLo
 
 	param := Params{
-		MessageHash:           testMessage("hello world").IntoStateProofMessageHash(),
-		ProvenWeightThreshold: uint64(totalWeight / 2),
-		SigRound:              currentRound,
-		SecKQ:                 compactCertSecKQForTests,
+		Data:         testMessage("hello world").IntoStateProofMessageHash(),
+		ProvenWeight: uint64(totalWeight / 2),
+		Round:        currentRound,
+		SecKQ:        compactCertSecKQForTests,
 	}
 
 	// Share the key; we allow the same vote key to appear in multiple accounts..
@@ -107,7 +106,7 @@ func generateCertForTesting(a *require.Assertions) (*Cert, Params, crypto.Generi
 	parts = append(parts, createParticipantSliceWithWeight(totalWeight, npartLo, key.GetVerifier())...)
 
 	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.MessageHash[:])
+	sig, err := signerInRound.SignBytes(param.Data[:])
 	a.NoError(err, "failed to create keys")
 
 	for i := 0; i < npart; i++ {
@@ -240,10 +239,10 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 	numPart := 4
 
 	param := Params{
-		MessageHash:           testMessage("test!").IntoStateProofMessageHash(),
-		ProvenWeightThreshold: uint64(totalWeight / (2 * numPart)),
-		SigRound:              currentRound,
-		SecKQ:                 compactCertSecKQForTests,
+		Data:         testMessage("test!").IntoStateProofMessageHash(),
+		ProvenWeight: uint64(totalWeight / (2 * numPart)),
+		Round:        currentRound,
+		SecKQ:        compactCertSecKQForTests,
 	}
 
 	var parts []basics.Participant
@@ -258,7 +257,7 @@ func TestSignatureCommitmentBinaryFormat(t *testing.T) {
 		}
 		parts = append(parts, part)
 
-		sig, err := key.GetSigner(uint64(currentRound)).SignBytes(param.MessageHash[:])
+		sig, err := key.GetSigner(uint64(currentRound)).SignBytes(param.Data[:])
 		require.NoError(t, err, "failed to create keys")
 		sigs = append(sigs, sig)
 
@@ -440,10 +439,10 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 	npartLo := 9
 
 	param := Params{
-		MessageHash:           testMessage("hello world").IntoStateProofMessageHash(),
-		ProvenWeightThreshold: uint64(totalWeight / 2),
-		SigRound:              currentRound,
-		SecKQ:                 compactCertSecKQForTests,
+		Data:         testMessage("hello world").IntoStateProofMessageHash(),
+		ProvenWeight: uint64(totalWeight / 2),
+		Round:        currentRound,
+		SecKQ:        compactCertSecKQForTests,
 	}
 
 	key := generateTestSigner(0, uint64(compactCertRoundsForTests)*20+1, compactCertRoundsForTests, a)
@@ -459,7 +458,7 @@ func TestBuilder_AddRejectsInvalidSigVersion(t *testing.T) {
 
 	// actual test:
 	signerInRound := key.GetSigner(uint64(currentRound))
-	sig, err := signerInRound.SignBytes(param.MessageHash[:])
+	sig, err := signerInRound.SignBytes(param.Data[:])
 	require.NoError(t, err, "failed to create keys")
 	// Corrupting the version of the signature:
 	sig.Signature[1]++
@@ -492,7 +491,7 @@ func TestBuilderWithZeroProvenWeight(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	a := require.New(t)
 
-	p := Params{ProvenWeightThreshold: 0}
+	p := Params{ProvenWeight: 0}
 
 	_, err := MkBuilder(p, nil, nil)
 	a.ErrorIs(err, ErrIllegalInputForLnApprox)
@@ -507,10 +506,10 @@ func BenchmarkBuildVerify(b *testing.B) {
 	a := require.New(b)
 
 	param := Params{
-		MessageHash:           testMessage("hello world").IntoStateProofMessageHash(),
-		ProvenWeightThreshold: uint64(totalWeight / 2),
-		SigRound:              compactCertRoundsForTests,
-		SecKQ:                 compactCertSecKQForTests,
+		Data:         testMessage("hello world").IntoStateProofMessageHash(),
+		ProvenWeight: uint64(totalWeight / 2),
+		Round:        compactCertRoundsForTests,
+		SecKQ:        compactCertSecKQForTests,
 	}
 
 	var parts []basics.Participant
@@ -524,7 +523,7 @@ func BenchmarkBuildVerify(b *testing.B) {
 		}
 
 		signerInRound := signer.GetSigner(uint64(currentRound))
-		sig, err := signerInRound.SignBytes(param.MessageHash[:])
+		sig, err := signerInRound.SignBytes(param.Data[:])
 		require.NoError(b, err, "failed to create keys")
 
 		partkeys = append(partkeys, signer)

diff --git a/crypto/compactcert/coinGenerator.go b/crypto/compactcert/coinGenerator.go
@@ -28,11 +28,11 @@ import (
 // The coinChoiceSeed defines the randomness seed that will be given to an XOF function. This will be used  for choosing
 // the index of the coin to reveal as part of the compact certificate.
 type coinChoiceSeed struct {
-	msgHash                 StateProofMessageHash
-	signedWeight            uint64
-	lnProvenWeightThreshold uint64
-	sigCommitment           crypto.GenericDigest
-	partCommitment          crypto.GenericDigest
+	data           StateProofMessageHash
+	signedWeight   uint64
+	lnProvenWeight uint64
+	sigCommitment  crypto.GenericDigest
+	partCommitment crypto.GenericDigest
 }
 
 // ToBeHashed returns a binary representation of the coinChoiceSeed structure.
@@ -44,10 +44,10 @@ func (cc *coinChoiceSeed) ToBeHashed() (protocol.HashID, []byte) {
 	binary.LittleEndian.PutUint64(signedWtAsBytes, cc.signedWeight)
 
 	lnProvenWtAsBytes := make([]byte, 8)
-	binary.LittleEndian.PutUint64(lnProvenWtAsBytes, cc.lnProvenWeightThreshold)
+	binary.LittleEndian.PutUint64(lnProvenWtAsBytes, cc.lnProvenWeight)
 
-	coinChoiceBytes := make([]byte, 0, len(cc.msgHash)+len(signedWtAsBytes)+len(lnProvenWtAsBytes)+len(cc.sigCommitment)+len(cc.partCommitment))
-	coinChoiceBytes = append(coinChoiceBytes, cc.msgHash[:]...)
+	coinChoiceBytes := make([]byte, 0, len(cc.data)+len(signedWtAsBytes)+len(lnProvenWtAsBytes)+len(cc.sigCommitment)+len(cc.partCommitment))
+	coinChoiceBytes = append(coinChoiceBytes, cc.data[:]...)
 	coinChoiceBytes = append(coinChoiceBytes, signedWtAsBytes...)
 	coinChoiceBytes = append(coinChoiceBytes, lnProvenWtAsBytes...)
 	coinChoiceBytes = append(coinChoiceBytes, cc.sigCommitment...)
@@ -66,14 +66,12 @@ type coinGenerator struct {
 // makeCoinGenerator creates a new CoinHash context.
 // it is used for squeezing 64 bits for coin flips.
 // the function inits the XOF function in the following manner
-// Shake(sumhash(coinChoiceSeed))
+// Shake(coinChoiceSeed)
 // we extract 64 bits from shake for each coin flip and divide it by signedWeight
 func makeCoinGenerator(choice *coinChoiceSeed) coinGenerator {
-	hash := crypto.HashFactory{HashType: CoinHashType}.NewHash()
-	hashedCoin := crypto.GenericHashObj(hash, choice)
-
+	rep := crypto.HashRep(choice)
 	shk := sha3.NewShake256()
-	shk.Write(hashedCoin)
+	shk.Write(rep)
 
 	threshold, singedWt := prepareRejectionSamplingValues(choice.signedWeight)
 	return coinGenerator{shkContext: shk, signedWeight: singedWt, threshold: threshold}

diff --git a/crypto/compactcert/coinGenerator_test.go b/crypto/compactcert/coinGenerator_test.go
@@ -39,7 +39,7 @@ func TestHashCoin(t *testing.T) {
 		signedWeight:   uint64(len(slots)),
 		sigCommitment:  sigcom,
 		partCommitment: partcom,
-		msgHash:        msgHash,
+		data:           msgHash,
 	}
 	coinHash := makeCoinGenerator(&choice)
 
@@ -75,7 +75,7 @@ func BenchmarkHashCoin(b *testing.B) {
 		signedWeight:   1025,
 		sigCommitment:  sigcom,
 		partCommitment: partcom,
-		msgHash:        msgHash,
+		data:           msgHash,
 	}
 	coinHash := makeCoinGenerator(&choice)
 
@@ -97,7 +97,7 @@ func BenchmarkHashCoinGenerate(b *testing.B) {
 		signedWeight:   1025,
 		sigCommitment:  sigcom,
 		partCommitment: partcom,
-		msgHash:        msgHash,
+		data:           msgHash,
 	}
 
 	for i := 0; i < b.N; i++ {

diff --git a/crypto/compactcert/const.go b/crypto/compactcert/const.go
@@ -24,12 +24,12 @@ import (
 const (
 	HashType            = crypto.Sumhash
 	HashSize            = crypto.SumhashDigestSize
-	CoinHashType        = crypto.Sumhash
-	precisionBits       = uint64(1 << 16) // number of bits used for log approximation
-	ln2IntApproximation = uint64(45427)   // the value of the ln(2) with 16 bits of precision
+	precisionBits       = uint8(16)     // number of bits used for log approximation
+	ln2IntApproximation = uint64(45427) // the value of the ln(2) with 16 bits of precision
 )
 
 const (
 	// MaxReveals is a bound on allocation and on numReveals to limit log computation
+	// CR double-check
 	MaxReveals = 2048
 )
diff --git a/crypto/compactcert/structs.go b/crypto/compactcert/structs.go
@@ -31,10 +31,10 @@ const StateProofMessageHashType = crypto.Sha256
 
 // Params defines common parameters for the verifier and builder.
 type Params struct {
-	MessageHash           StateProofMessageHash
-	ProvenWeightThreshold uint64       // Weight threshold proven by the certificate
-	SigRound              basics.Round // The round for which the ephemeral key is committed to
-	SecKQ                 uint64       // Security parameter (k+q) from analysis document
+	Data         StateProofMessageHash
+	ProvenWeight uint64       // Weight proven by the certificate
+	Round        basics.Round // The round for which the ephemeral key is committed to
+	SecKQ        uint64       // Security parameter (k+q) from analysis document
 }
 
 // A sigslotCommit is a single slot in the sigs array that forms the certificate.
@@ -69,6 +69,7 @@ type Cert struct {
 	SigProofs    merklearray.Proof    `codec:"S"`
 	PartProofs   merklearray.Proof    `codec:"P"`
 
+	// CR salt version - chagne the falcon to uint8 or change this to int
 	MerkleSignatureVersion int32 `codec:"v"`
 
 	// Reveals is a sparse map from the position being revealed