fixed hash representation for coinhash

algorand · id-ms · May 10, 2022 · Feb 16, 2022 · Mar 10, 2022 · Mar 13, 2022
commit 2f275f3b3bdee077ca47b3dc9193e285fb32b191
diff --git a/crypto/compactcert/builder.go b/crypto/compactcert/builder.go
@@ -206,14 +206,14 @@ func (b *Builder) Build() (*Cert, error) {
 	revealsSequence := make([]uint64, nr)
 
 	choice := coinChoiceSeed{
-		MsgHash:                 b.StateProofMessageHash,
-		LnProvenWeightThreshold: b.lnProvenWeightThreshold,
-		SignedWeight:            c.SignedWeight,
-		Sigcom:                  c.SigCommit,
-		Partcom:                 b.parttree.Root(),
+		msgHash:                 b.StateProofMessageHash,
+		lnProvenWeightThreshold: b.lnProvenWeightThreshold,
+		signedWeight:            c.SignedWeight,
+		sigCommitment:           c.SigCommit,
+		partCommitment:          b.parttree.Root(),
 	}
 
-	coinHash := makeCoinGenerator(choice)
+	coinHash := makeCoinGenerator(&choice)
 
 	for j := uint64(0); j < nr; j++ {
 		coin := coinHash.getNextCoin()

diff --git a/crypto/compactcert/coinGenerator.go b/crypto/compactcert/coinGenerator.go
@@ -28,19 +28,32 @@ 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 {
-	_struct struct{} `codec:",omitempty,omitemptyarray"`
-
-	MsgHash                 StateProofMessageHash `codec:"msghash"`
-	SignedWeight            uint64                `codec:"sigweight"`
-	LnProvenWeightThreshold uint64                `codec:"lnweight"`
-	Sigcom                  crypto.GenericDigest  `codec:"sigcom"`
-	Partcom                 crypto.GenericDigest  `codec:"partcom"`
+	msgHash                 StateProofMessageHash
+	signedWeight            uint64
+	lnProvenWeightThreshold uint64
+	sigCommitment           crypto.GenericDigest
+	partCommitment          crypto.GenericDigest
 }
 
-// ToBeHashed implements the crypto.Hashable interface.
-func (cc coinChoiceSeed) ToBeHashed() (protocol.HashID, []byte) {
-	// TODO should create a fixed length representation
-	return protocol.CompactCertCoin, protocol.Encode(&cc)
+// ToBeHashed returns a binary representation of the coinChoiceSeed structure.
+// Since this code is also implemented as a circuit in the stateproof SNARK prover we can't use
+// msgpack encoding since it may result in a variable length byte slice.
+// Alternatively, we serialize the fields in the structure in a specific format.
+func (cc *coinChoiceSeed) ToBeHashed() (protocol.HashID, []byte) {
+	signedWtAsBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(signedWtAsBytes, cc.signedWeight)
+
+	lnProvenWtAsBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(lnProvenWtAsBytes, cc.lnProvenWeightThreshold)
+
+	coinChoiceBytes := make([]byte, 0, len(cc.msgHash)+len(signedWtAsBytes)+len(lnProvenWtAsBytes)+len(cc.sigCommitment)+len(cc.partCommitment))
+	coinChoiceBytes = append(coinChoiceBytes, cc.msgHash[:]...)
+	coinChoiceBytes = append(coinChoiceBytes, signedWtAsBytes...)
+	coinChoiceBytes = append(coinChoiceBytes, lnProvenWtAsBytes...)
+	coinChoiceBytes = append(coinChoiceBytes, cc.sigCommitment...)
+	coinChoiceBytes = append(coinChoiceBytes, cc.partCommitment...)
+
+	return protocol.CompactCertCoin, coinChoiceBytes
 }
 
 // coinGenerator is used for extracting "randomized" 64 bits for coin flips
@@ -54,15 +67,15 @@ type coinGenerator struct {
 // it is used for squeezing 64 bits for coin flips.
 // the function inits the XOF function in the following manner
 // Shake(sumhash(coinChoiceSeed))
-//we extract 64 bits from shake for each coin flip and divide it by SignedWeight
-func makeCoinGenerator(choice coinChoiceSeed) coinGenerator {
+// 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)
 
 	shk := sha3.NewShake256()
 	shk.Write(hashedCoin)
 
-	threshold, singedWt := prepareRejectionSamplingValues(choice.SignedWeight)
+	threshold, singedWt := prepareRejectionSamplingValues(choice.signedWeight)
 	return coinGenerator{shkContext: shk, signedWeight: singedWt, threshold: threshold}
 
 }
@@ -84,23 +97,23 @@ func prepareRejectionSamplingValues(signedWeight uint64) (*big.Int, *big.Int) {
 	return threshold, singedWt
 }
 
-// getNextCoin returns the next 64bits integer which represents a number between [0,SignedWeight)
-func (ch *coinGenerator) getNextCoin() uint64 {
+// getNextCoin returns the next 64bits integer which represents a number between [0,signedWeight)
+func (cg *coinGenerator) getNextCoin() uint64 {
 	// take b bits from the XOF and generate an integer z.
 	// we accept the sample if z < threshold
 	// else, we reject the sample and repeat the process.
 	z := &big.Int{}
 	for true {
 		var shakeDigest [8]byte
-		ch.shkContext.Read(shakeDigest[:])
+		cg.shkContext.Read(shakeDigest[:])
 		randNumFromXof := binary.LittleEndian.Uint64(shakeDigest[:])
 
 		z.SetUint64(randNumFromXof)
-		if comp := z.Cmp(ch.threshold); comp == -1 {
+		if comp := z.Cmp(cg.threshold); comp == -1 {
 			break
 		}
 	}
 
-	z.Mod(z, ch.signedWeight)
+	z.Mod(z, cg.signedWeight)
 	return z.Uint64()
 }
diff --git a/crypto/compactcert/coinGenerator_test.go b/crypto/compactcert/coinGenerator_test.go
@@ -36,12 +36,12 @@ func TestHashCoin(t *testing.T) {
 	crypto.RandBytes(msgHash[:])
 
 	choice := coinChoiceSeed{
-		SignedWeight: uint64(len(slots)),
-		Sigcom:       sigcom,
-		Partcom:      partcom,
-		MsgHash:      msgHash,
+		signedWeight:   uint64(len(slots)),
+		sigCommitment:  sigcom,
+		partCommitment: partcom,
+		msgHash:        msgHash,
 	}
-	coinHash := makeCoinGenerator(choice)
+	coinHash := makeCoinGenerator(&choice)
 
 	for j := uint64(0); j < 1000; j++ {
 		coin := coinHash.getNextCoin()
@@ -72,12 +72,12 @@ func BenchmarkHashCoin(b *testing.B) {
 	crypto.RandBytes(msgHash[:])
 
 	choice := coinChoiceSeed{
-		SignedWeight: 1025,
-		Sigcom:       sigcom,
-		Partcom:      partcom,
-		MsgHash:      msgHash,
+		signedWeight:   1025,
+		sigCommitment:  sigcom,
+		partCommitment: partcom,
+		msgHash:        msgHash,
 	}
-	coinHash := makeCoinGenerator(choice)
+	coinHash := makeCoinGenerator(&choice)
 
 	for i := 0; i < b.N; i++ {
 		coinHash.getNextCoin()
@@ -94,13 +94,13 @@ func BenchmarkHashCoinGenerate(b *testing.B) {
 	crypto.RandBytes(msgHash[:])
 
 	choice := coinChoiceSeed{
-		SignedWeight: 1025,
-		Sigcom:       sigcom,
-		Partcom:      partcom,
-		MsgHash:      msgHash,
+		signedWeight:   1025,
+		sigCommitment:  sigcom,
+		partCommitment: partcom,
+		msgHash:        msgHash,
 	}
 
 	for i := 0; i < b.N; i++ {
-		makeCoinGenerator(choice)
+		makeCoinGenerator(&choice)
 	}
 }
diff --git a/crypto/compactcert/msgp_gen.go b/crypto/compactcert/msgp_gen.go