Rebase after identitypreimage refactor

Author: konradkonrad

rolling-shutter/cmd/cryptocmd/jsontests.go

@@ -15,7 +15,7 @@ import (
 
 	"github.com/shutter-network/shutter/shlib/shcrypto"
 
-	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/epochid"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/identitypreimage"
 	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/testkeygen"
 )
 
@@ -181,11 +181,11 @@ const (
 )
 
 type encryptionTest struct {
-	Message      hexutil.Bytes              `json:"message"`
-	EonPublicKey *shcrypto.EonPublicKey     `json:"eon_public_key"`
-	EpochID      epochid.EpochID            `json:"epoch_id"`
-	Sigma        shcrypto.Block             `json:"sigma"`
-	Expected     *shcrypto.EncryptedMessage `json:"expected"`
+	Message      hexutil.Bytes                     `json:"message"`
+	EonPublicKey *shcrypto.EonPublicKey            `json:"eon_public_key"`
+	EpochID      identitypreimage.IdentityPreimage `json:"epoch_id"`
+	Sigma        shcrypto.Block                    `json:"sigma"`
+	Expected     *shcrypto.EncryptedMessage        `json:"expected"`
 }
 
 type decryptionTest struct {
@@ -195,10 +195,10 @@ type decryptionTest struct {
 }
 
 type verificationTest struct {
-	EpochSecretKey shcrypto.EpochSecretKey `json:"epoch_secret_key"`
-	EonPublicKey   shcrypto.EonPublicKey   `json:"eon_public_key"`
-	EpochID        epochid.EpochID         `json:"epoch_id"`
-	Expected       bool                    `json:"expected"`
+	EpochSecretKey shcrypto.EpochSecretKey           `json:"epoch_secret_key"`
+	EonPublicKey   shcrypto.EonPublicKey             `json:"eon_public_key"`
+	EpochID        identitypreimage.IdentityPreimage `json:"epoch_id"`
+	Expected       bool                              `json:"expected"`
 }
 
 func readTestcases(filename string) []error {
@@ -591,8 +591,8 @@ func testMarshalingRoundtrip(tc *testCase) error {
 	if !bytes.Equal(marshaled, roundtrip) {
 		println(len(marshaled))
 		println(len(roundtrip))
-		println("m:", string(marshaled))
-		println("u:", string(roundtrip))
+		println("before:", string(marshaled))
+		println("after:", string(roundtrip))
 		return errors.New("roundtrip marshaling failed")
 	}
 	return nil

rolling-shutter/medley/identitypreimage/identitypreimage.go

@@ -50,3 +50,13 @@ func (e IdentityPreimage) String() string {
 func Equal(a, b IdentityPreimage) bool {
 	return bytes.Equal(a.Bytes(), b.Bytes())
 }
+
+func (e IdentityPreimage) MarshalText() ([]byte, error) { //nolint:unparam
+	return []byte(e.Hex()), nil
+}
+
+func (e *IdentityPreimage) UnmarshalText(input []byte) error {
+	val, err := HexToIdentityPreimage(string(input))
+	*e = val.Bytes()
+	return err
+}

rolling-shutter/medley/testkeygen/testgenerator.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/shutter-network/shutter/shlib/shcrypto"
 
-	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/epochid"
+	"github.com/shutter-network/rolling-shutter/rolling-shutter/medley/identitypreimage"
 )
 
 // KeyGenerator is a helper tool to generate secret and public eon and epoch keys and key
@@ -28,15 +28,15 @@ func NewKeyGenerator(numKeypers uint64, threshold uint64) *KeyGenerator {
 
 // getEonIndex computes the index of the EON key to be used for the given epochID. We generate a new
 // eon key every eonInterval epochs.
-func (kg *KeyGenerator) getEonIndex(epochID epochid.EpochID) uint64 {
+func (kg *KeyGenerator) getEonIndex(epochID identitypreimage.IdentityPreimage) uint64 {
 	if kg.eonInterval == 0 {
 		return 0
 	}
 
 	return epochID.Big().Uint64() / kg.eonInterval
 }
 
-func (kg *KeyGenerator) EonKeysForEpoch(epochID epochid.EpochID) *EonKeys {
+func (kg *KeyGenerator) EonKeysForEpoch(epochID identitypreimage.IdentityPreimage) *EonKeys {
 	eonIndex := kg.getEonIndex(epochID)
 	res, ok := kg.eonKeyGen[eonIndex]
 	var err error
@@ -54,40 +54,37 @@ func (kg *KeyGenerator) EonKeysForEpoch(epochID epochid.EpochID) *EonKeys {
 	return res
 }
 
-func (kg *KeyGenerator) EonPublicKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EonPublicKeyShare {
+func (kg *KeyGenerator) EonPublicKeyShare(epochID identitypreimage.IdentityPreimage, keyperIndex uint64) *shcrypto.EonPublicKeyShare {
 	return kg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].eonPublicKeyShare
 }
 
-func (kg *KeyGenerator) EonPublicKey(epochID epochid.EpochID) *shcrypto.EonPublicKey {
+func (kg *KeyGenerator) EonPublicKey(epochID identitypreimage.IdentityPreimage) *shcrypto.EonPublicKey {
 	return kg.EonKeysForEpoch(epochID).publicKey
 }
 
-func (kg *KeyGenerator) EonSecretKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EonSecretKeyShare {
+func (kg *KeyGenerator) EonSecretKeyShare(epochID identitypreimage.IdentityPreimage, keyperIndex uint64) *shcrypto.EonSecretKeyShare {
 	return kg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].eonSecretKeyShare
 }
 
-func (kg *KeyGenerator) EpochSecretKeyShare(epochID epochid.EpochID, keyperIndex uint64) *shcrypto.EpochSecretKeyShare {
+func (kg *KeyGenerator) EpochSecretKeyShare(epochID identitypreimage.IdentityPreimage, keyperIndex uint64) *shcrypto.EpochSecretKeyShare {
 	return kg.EonKeysForEpoch(epochID).keyperShares[keyperIndex].ComputeEpochSecretKeyShare(epochID)
 }
 
-func (kg *KeyGenerator) EpochSecretKey(epochID epochid.EpochID) *shcrypto.EpochSecretKey {
+func (kg *KeyGenerator) EpochSecretKey(epochID identitypreimage.IdentityPreimage) *shcrypto.EpochSecretKey {
 	epochSecretKey, err := kg.EonKeysForEpoch(epochID).EpochSecretKey(epochID)
 	if err != nil {
 		panic(err)
 	}
 	return epochSecretKey
 }
 
-func (kg *KeyGenerator) RandomEpochID(epochbytes []byte) epochid.EpochID {
+func (kg *KeyGenerator) RandomEpochID(epochbytes []byte) identitypreimage.IdentityPreimage {
 	_, err := rand.Read(epochbytes)
 	if err != nil {
 		panic(err)
 	}
 
-	epochID, err := epochid.BytesToEpochID(epochbytes)
-	if err != nil {
-		panic(err)
-	}
+	epochID := identitypreimage.IdentityPreimage(epochbytes)
 	return epochID
 }