Mod Int Migrates to compatible

Author: ValeriodeSa

compatible/compatible_mod/const_mod.go

@@ -25,3 +25,17 @@ type Mod struct {
 func (m *Mod) Nat() *bigmod.Nat {
 	return m.Nat()
 }
+
+func (z *Mod) SetString(s string, base int) (*Mod, bool) { panic("implement me") }
+
+func (z *Mod) SetUint64(v uint64) *Mod {
+	panic("implement me")
+}
+
+func (z *Mod) SetBytes(b []byte) (*Mod, error) {
+	modulus, err := bigmod.NewModulus(b)
+	if err != nil {
+		return nil, err
+	}
+	return &Mod{modulus}, nil
+}

compatible/compatible_mod/var_mod.go

@@ -6,10 +6,16 @@ import (
 	"math/big"
 )
 
-type Mod = big.Int
+type Mod struct {
+	*big.Int
+}
 
 func NewInt(x int64) *Mod {
-	return big.NewInt(x)
+	return &Mod{big.NewInt(x)}
+}
+
+func (m *Mod) SetBytes(b []byte) (*Mod, error) {
+	return &Mod{big.NewInt(0).SetBytes(b)}, nil
 }
 
 // func Add(x, y *Int, _ int) *Int { return big.Add(x, y) }

compatible/const_int.go

@@ -14,6 +14,10 @@ type Int struct {
 	Int *bigmod.Nat
 }
 
+func SetFromNat(x *bigmod.Nat) *Int {
+	return &Int{x}
+}
+
 func NewInt(x uint) *Int {
 	var z = bigmod.NewNat().SetUint(x)
 	//
@@ -98,6 +102,10 @@ func (z *Int) SetUint(v uint) *Int {
 	z.Int = bigmod.NewNat().SetUint(v)
 	return z
 }
+func (z *Int) SetUint64(v uint64) *Int {
+	z.Int = bigmod.NewNat().SetUint(uint(v))
+	return z
+}
 
 func (z *Int) zero() *Int {
 	z.Int.SetUint(0)

group.go

@@ -2,7 +2,7 @@ package kyber
 
 import (
 	"crypto/cipher"
-	"math/big"
+	"go.dedis.ch/kyber/v4/compatible/compatible_mod"
 )
 
 // ByteOrder denotes the endianness of the operation.
@@ -72,8 +72,8 @@ type Scalar interface {
 	ByteOrder() ByteOrder
 
 	// GroupOrder returns the order of the underlying group
-	// todo should this return a compatible.Int? Is the size of the groupOrder secret?
-	GroupOrder() *big.Int
+	// todo should this return a compatible_mod.Mod? Is the size of the groupOrder secret?
+	GroupOrder() *compatible_mod.Mod
 }
 
 // Point represents an element of a public-key cryptographic Group.

group/edwards25519/const.go

@@ -5,10 +5,11 @@ package edwards25519
 
 import (
 	"go.dedis.ch/kyber/v4/compatible"
+	"go.dedis.ch/kyber/v4/compatible/compatible_mod"
 )
 
 // prime modulus of underlying field = 2^255 - 19
-var prime, _ = new(compatible.Int).SetString("57896044618658097711785492504343953926634992332820282019728792003956564819949", 10)
+var prime, _ = new(compatible_mod.Mod).SetString("57896044618658097711785492504343953926634992332820282019728792003956564819949", 10)
 
 // prime order of base point = 2^252 + 27742317777372353535851937790883648493
 var primeOrder, _ = new(compatible.Int).SetString("7237005577332262213973186563042994240857116359379907606001950938285454250989", 10)
@@ -19,10 +20,10 @@ var primeOrder, _ = new(compatible.Int).SetString("72370055773322622139731865630
 var lMinus2, _ = new(compatible.Int).SetString("7237005577332262213973186563042994240857116359379907606001950938285454250987", 10)
 
 // cofactor of the curve, as a ModInt
-var cofactor = new(compatible.Int).SetInt64(8)
+var cofactor = new(compatible.Int).SetUint64(8)
 
 // order of the full group including the cofactor
-var fullOrder = new(compatible.Int).Mul(primeOrder, cofactor)
+var fullOrder = new(compatible.Int).Mul(primeOrder, cofactor, prime)
 
 // scalar versions of these, usable for multiplication
 var primeOrderScalar = newScalarInt(primeOrder)

group/edwards25519/constant_scalar.go

@@ -1,4 +1,4 @@
-//go:build constantTime
+//go:build constantTime && a
 
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

group/edwards25519/scalar.go

@@ -1,5 +1,3 @@
-//go:build !constantTime
-
 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
@@ -11,8 +9,8 @@ import (
 	"encoding/hex"
 	"errors"
 	"go.dedis.ch/kyber/v4/compatible"
+	"go.dedis.ch/kyber/v4/compatible/compatible_mod"
 	"io"
-	"math/big"
 
 	"go.dedis.ch/kyber/v4"
 	"go.dedis.ch/kyber/v4/group/internal/marshalling"
@@ -59,11 +57,19 @@ func (s *scalar) setInt(i *mod.Int) kyber.Scalar {
 
 // SetInt64 sets the scalar to a small integer value.
 func (s *scalar) SetInt64(v int64) kyber.Scalar {
-	return s.setInt(mod.NewInt64(v, primeOrder))
+	modulusPrimeOrder, err := new(compatible_mod.Mod).SetBytes(primeOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	return s.setInt(mod.NewInt64(v, modulusPrimeOrder))
 }
 
 func (s *scalar) toInt() *mod.Int {
-	return mod.NewIntBytes(s.v[:], primeOrder, defaultEndianess)
+	modulusPrimeOrder, err := new(compatible_mod.Mod).SetBytes(primeOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	return mod.NewIntBytes(s.v[:], modulusPrimeOrder, defaultEndianess)
 }
 
 // Set to the additive identity (0)
@@ -137,13 +143,21 @@ func (s *scalar) Inv(a kyber.Scalar) kyber.Scalar {
 
 // Set to a fresh random or pseudo-random scalar
 func (s *scalar) Pick(rand cipher.Stream) kyber.Scalar {
-	i := mod.NewInt(random.Int(primeOrder, rand), primeOrder)
+	modulusPrimeOrder, err := new(compatible_mod.Mod).SetBytes(primeOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	i := mod.NewInt(random.Int(primeOrder, rand), modulusPrimeOrder)
 	return s.setInt(i)
 }
 
 // SetBytes s to b, interpreted as a little endian integer.
 func (s *scalar) SetBytes(b []byte) kyber.Scalar {
-	return s.setInt(mod.NewIntBytes(b, primeOrder, defaultEndianess))
+	modulusPrimeOrder, err := new(compatible_mod.Mod).SetBytes(primeOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	return s.setInt(mod.NewIntBytes(b, modulusPrimeOrder, defaultEndianess))
 }
 
 // ByteOrder return the byte representation type (big or little endian)
@@ -152,8 +166,13 @@ func (s *scalar) ByteOrder() kyber.ByteOrder {
 }
 
 // GroupOrder returns the order of the underlying group
-func (s *scalar) GroupOrder() *big.Int {
-	return big.NewInt(0).SetBytes(primeOrder.Bytes())
+func (s *scalar) GroupOrder() *compatible_mod.Mod {
+
+	modulusPrimeOrder, err := new(compatible_mod.Mod).SetBytes(primeOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	return modulusPrimeOrder
 }
 
 // String returns the string representation of this scalar (fixed length of 32 bytes, little endian).
@@ -202,8 +221,13 @@ func (s *scalar) UnmarshalFrom(r io.Reader) (int, error) {
 }
 
 func newScalarInt(i *compatible.Int) *scalar {
+	modulusFullOrder, err := new(compatible_mod.Mod).SetBytes(fullOrder.Bytes())
+	if err != nil {
+		panic(err)
+	}
+
 	s := scalar{}
-	s.setInt(mod.NewInt(i, fullOrder))
+	s.setInt(mod.NewInt(i, modulusFullOrder))
 	return &s
 }
 

group/mod/constant_time_int.go

@@ -8,23 +8,20 @@ import (
 	"crypto/cipher"
 	"encoding/hex"
 	"errors"
-	"github.com/cronokirby/saferith"
+	"go.dedis.ch/kyber/v4"
 	"go.dedis.ch/kyber/v4/compatible"
 	"go.dedis.ch/kyber/v4/compatible/compatible_mod"
-	"io"
-	"math/big"
-
-	"go.dedis.ch/kyber/v4"
 	"go.dedis.ch/kyber/v4/group/internal/marshalling"
 	"go.dedis.ch/kyber/v4/util/random"
+	"io"
 )
 
 var Cap = 64
 var marshalScalarID = [8]byte{'m', 'o', 'd', '.', 'i', 'n', 't', ' '}
 
 // Int is a generic implementation of finite field arithmetic
 // on integer finite fields with a given constant modulus,
-// built using Go's built-in big.Int or with the saferith package,
+// built using Go's built-in big.Int or with the filosottile/bigmod package,
 // depending on whether the constantTime build tag is chosen.
 // Int satisfies the kyber.Scalar interface,
 // and hence serves as a basic implementation of kyber.Scalar,
@@ -66,17 +63,18 @@ func (i *Int) SetString(n, d string, base int) (*Int, bool) {
 	return i, true
 }
 
-// Jacobi computes the Jacobi symbol of (a/M), which indicates whether a is
-// zero (0), a positive square in M (1), or a non-square in M (-1).
-func (i *Int) Jacobi(as kyber.Scalar) kyber.Scalar {
-	ai := as.(*Int) //nolint:errcheck // Design pattern to emulate generics
-	i.M = ai.M
-	i.V.SetUint(uint(big.Jacobi(&ai.V, i.M)))
-	return i
-}
+// Not used in constant time
+//// Jacobi computes the Jacobi symbol of (a/M), which indicates whether a is
+//// zero (0), a positive square in M (1), or a non-square in M (-1).
+//func (i *Int) Jacobi(as kyber.Scalar) kyber.Scalar {
+//	ai := as.(*Int) //nolint:errcheck // Design pattern to emulate generics
+//	i.M = ai.M
+//	i.V.SetUint(uint(big.Jacobi(&ai.V, i.M)))
+//	return i
+//}
 
 // NewInt creaters a new Int with a given compatible.Int and a compatible.Int modulus.
-func NewInt(v *saferith.Nat, m *compatible_mod.Mod) *Int {
+func NewInt(v *compatible.Int, m *compatible_mod.Mod) *Int {
 	return new(Int).Init(v, m)
 }
 
@@ -182,13 +180,13 @@ func (i *Int) Clone() kyber.Scalar {
 
 // Zero set the Int to the value 0.  The modulus must already be initialized.
 func (i *Int) Zero() kyber.Scalar {
-	i.V.SetUint64(0)
+	i.V.SetUint(0)
 	return i
 }
 
 // One sets the Int to the value 1.  The modulus must already be initialized.
 func (i *Int) One() kyber.Scalar {
-	i.V.SetUint64(1)
+	i.V.SetUint(1)
 	return i
 }
 
@@ -295,28 +293,25 @@ func (i *Int) Exp(a kyber.Scalar, e *compatible.Int) kyber.Scalar {
 	return i
 }
 
-// Sqrt computes some square root of a mod M of one exists.
-// Assumes the modulus M is an odd prime.
-// Returns true on success, false if input a is not a square.
-func (i *Int) Sqrt(as kyber.Scalar) bool {
-	ai := as.(*Int) //nolint:errcheck // Design pattern to emulate generics
-	out := i.V.ModSqrt(ai.V, ai.M)
-	i.M = ai.M
-	return out != nil
-}
+//not used in constant time
+//// Sqrt computes some square root of a mod M of one exists.
+//// Assumes the modulus M is an odd prime.
+//// Returns true on success, false if input a is not a square.
+//func (i *Int) Sqrt(as kyber.Scalar) bool {
+//	ai := as.(*Int) //nolint:errcheck // Design pattern to emulate generics
+//	out := i.V.ModSqrt(ai.V, ai.M)
+//	i.M = ai.M
+//	return out != nil
+//}
 
 // Pick a [pseudo-]random integer, modulo M,
 // using bits from the given stream cipher.
 func (i *Int) Pick(rand cipher.Stream) kyber.Scalar {
-	moduleInt := &saferith.Int{}
-	moduleInt.SetNat(i.M.Nat())
-
-	compInt := &compatible.Int{
-		moduleInt,
-	}
+	moduleInt := i.M.Nat()
+	moduleCompatible := compatible.SetFromNat(moduleInt)
 
 	i.V.Set(
-		random.Int(compInt, rand),
+		random.Int(moduleCompatible, rand),
 	)
 	return i
 }
@@ -328,8 +323,8 @@ func (i *Int) ByteOrder() kyber.ByteOrder {
 
 // GroupOrder returns the order of the underlying group
 // todo change to compatible_mod.Mod
-func (i *Int) GroupOrder() *big.Int {
-	return big.NewInt(0).Set(i.M.Modulus)
+func (i *Int) GroupOrder() *compatible_mod.Mod {
+	return i.M
 }
 
 // MarshalSize returns the length in bytes of encoded integers with modulus M.