fix endian issue

Author: Mike Lodder

go/pkg/oberon/proof.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/coinbase/kryptology/pkg/core/curves"
+	"github.com/coinbase/kryptology/pkg/core/curves/native"
 	"github.com/coinbase/kryptology/pkg/core/curves/native/bls12381"
 	"io"
 )
@@ -159,8 +160,10 @@ func (p Proof) MarshalBinary() ([]byte, error) {
 	copy(tmp[:48], p.Proof.ToAffineCompressed())
 	copy(tmp[48:96], p.UTick.ToAffineCompressed())
 	copy(tmp[96:192], p.Commitment.ToAffineCompressed())
-	copy(tmp[192:224], p.Challenge.Bytes())
-	copy(tmp[224:], p.Schnorr.Bytes())
+	t := p.Challenge.Value.Bytes()
+	copy(tmp[192:224], t[:])
+	t = p.Schnorr.Value.Bytes()
+	copy(tmp[224:], t[:])
 	return tmp[:], nil
 }
 
@@ -181,11 +184,16 @@ func (p *Proof) UnmarshalBinary(in []byte) error {
 	if err != nil {
 		return err
 	}
-	challenge, err := curve.NewScalar().SetBytes(in[192:224])
+	var t [native.FieldBytes]byte
+	copy(t[:], in[192:224])
+	challenge, _ := curve.NewScalar().(*curves.ScalarBls12381)
+	_, err = challenge.Value.SetBytes(&t)
 	if err != nil {
 		return err
 	}
-	schnorr, err := curve.NewScalar().SetBytes(in[224:])
+	copy(t[:], in[224:])
+	schnorr, _ := curve.NewScalar().(*curves.ScalarBls12381)
+	_, err = schnorr.Value.SetBytes(&t)
 	if err != nil {
 		return err
 	}
@@ -202,20 +210,22 @@ func (p *Proof) UnmarshalBinary(in []byte) error {
 		p.Proof = Proof
 		p.UTick = UTick
 		p.Commitment = Commitment
-		p.Challenge, _ = challenge.(*curves.ScalarBls12381)
-		p.Schnorr, _ = schnorr.(*curves.ScalarBls12381)
+		p.Challenge = challenge
+		p.Schnorr = schnorr
 		return nil
 	}
 	return fmt.Errorf("invalid proof")
 }
 
 func (p Proof) MarshalText() ([]byte, error) {
+	c := p.Challenge.Value.Bytes()
+	s := p.Schnorr.Value.Bytes()
 	tmp := map[string][]byte{
 		"proof":      p.Proof.ToAffineCompressed(),
 		"u_tick":     p.UTick.ToAffineCompressed(),
 		"commitment": p.Commitment.ToAffineCompressed(),
-		"challenge":  p.Challenge.Bytes(),
-		"schnorr":    p.Schnorr.Bytes(),
+		"challenge":  c[:],
+		"schnorr":    s[:],
 	}
 	return json.Marshal(&tmp)
 }
@@ -260,18 +270,28 @@ func (p *Proof) UnmarshalText(in []byte) error {
 		return fmt.Errorf("missing expected mak key 'commitment'")
 	}
 	if challengeBytes, ok := tmp["challenge"]; ok {
-		chal, err := curve.NewScalar().SetBytes(challengeBytes)
+		if len(challengeBytes) != native.FieldBytes {
+			return fmt.Errorf("invalid byte sequence for 'challenge'")
+		}
+		var t [native.FieldBytes]byte
+		copy(t[:], challengeBytes)
+		challenge, _ = curve.NewScalar().(*curves.ScalarBls12381)
+		_, err = challenge.Value.SetBytes(&t)
 		if err != nil {
 			return err
 		}
-		challenge, _ = chal.(*curves.ScalarBls12381)
 	}
 	if schnorrBytes, ok := tmp["schnorr"]; ok {
-		sch, err := curve.NewScalar().SetBytes(schnorrBytes)
+		if len(schnorrBytes) != native.FieldBytes {
+			return fmt.Errorf("invalid byte sequence for 'schnorr'")
+		}
+		var t [native.FieldBytes]byte
+		copy(t[:], schnorrBytes)
+		schnorr, _ = curve.NewScalar().(*curves.ScalarBls12381)
+		_, err = schnorr.Value.SetBytes(&t)
 		if err != nil {
 			return err
 		}
-		schnorr, _ = sch.(*curves.ScalarBls12381)
 	}
 
 	goodProof := isValidPointG1(proof)

go/pkg/oberon/secret_key.go

@@ -87,10 +87,11 @@ func (s *SecretKey) Sign(id []byte) (*Token, error) {
 }
 
 func (s SecretKey) MarshalBinary() ([]byte, error) {
+	w, x, y := s.W.Value.Bytes(), s.X.Value.Bytes(), s.Y.Value.Bytes()
 	var tmp [96]byte
-	copy(tmp[:32], s.W.Bytes())
-	copy(tmp[32:64], s.X.Bytes())
-	copy(tmp[64:96], s.Y.Bytes())
+	copy(tmp[:32], w[:])
+	copy(tmp[32:64], x[:])
+	copy(tmp[64:96], y[:])
 	return tmp[:], nil
 }
 
@@ -128,10 +129,11 @@ func (s *SecretKey) UnmarshalBinary(in []byte) error {
 }
 
 func (s SecretKey) MarshalText() ([]byte, error) {
+	w, x, y := s.W.Value.Bytes(), s.X.Value.Bytes(), s.Y.Value.Bytes()
 	tmp := map[string][]byte{
-		"w": s.W.Bytes(),
-		"x": s.X.Bytes(),
-		"y": s.Y.Bytes(),
+		"w": w[:],
+		"x": x[:],
+		"y": y[:],
 	}
 	return json.Marshal(&tmp)
 }

go/pkg/oberon/secret_key_test.go

@@ -59,6 +59,6 @@ func TestHashSecretKey(t *testing.T) {
 	require.NoError(t, err)
 	out, err := sk.MarshalBinary()
 	require.NoError(t, err)
-	expBytes := []byte{6, 129, 143, 106, 175, 152, 144, 81, 239, 218, 36, 33, 224, 247, 166, 82, 231, 107, 54, 34, 63, 0, 42, 216, 230, 25, 194, 104, 39, 52, 134, 132, 86, 100, 67, 124, 53, 144, 206, 125, 91, 24, 39, 39, 207, 81, 87, 32, 72, 141, 111, 179, 210, 81, 177, 208, 135, 247, 119, 255, 97, 119, 192, 122, 37, 67, 118, 118, 48, 31, 164, 95, 215, 216, 235, 243, 165, 81, 54, 235, 56, 136, 107, 174, 131, 82, 7, 0, 211, 145, 6, 83, 14, 135, 124, 107}
+	expBytes := []byte{132, 134, 52, 39, 104, 194, 25, 230, 216, 42, 0, 63, 34, 54, 107, 231, 82, 166, 247, 224, 33, 36, 218, 239, 81, 144, 152, 175, 106, 143, 129, 6, 122, 192, 119, 97, 255, 119, 247, 135, 208, 177, 81, 210, 179, 111, 141, 72, 32, 87, 81, 207, 39, 39, 24, 91, 125, 206, 144, 53, 124, 67, 100, 86, 107, 124, 135, 14, 83, 6, 145, 211, 0, 7, 82, 131, 174, 107, 136, 56, 235, 54, 81, 165, 243, 235, 216, 215, 95, 164, 31, 48, 118, 118, 67, 37}
 	require.Equal(t, 0, bytes.Compare(out, expBytes))
 }