Merge pull request #24 from bytemare/add-scalar-setint

Add Scalar.SetInt()

internal/misc.go

@@ -35,6 +35,9 @@ var (
 
 	// ErrIdentity indicates that the identity point (or point at infinity) has been encountered.
 	ErrIdentity = errors.New("infinity/identity point")
+
+	// ErrBigIntConversion reports an error in converting to a *big.int.
+	ErrBigIntConversion = errors.New("conversion error")
 )
 
 // RandomBytes returns random bytes of length len (wrapper for crypto/rand).

internal/nist/scalar.go

@@ -191,6 +191,14 @@ func (s *Scalar) Set(scalar internal.Scalar) internal.Scalar {
 	return s
 }
 
+// SetInt sets s to i modulo the field order, and returns an error if one occurs.
+func (s *Scalar) SetInt(i *big.Int) error {
+	s.s.Set(i)
+	s.field.mod(&s.s)
+
+	return nil
+}
+
 // Copy returns a copy of the Scalar.
 func (s *Scalar) Copy() internal.Scalar {
 	cpy := newScalar(s.field)

internal/ristretto/scalar.go

@@ -11,6 +11,7 @@ package ristretto
 
 import (
 	"fmt"
+	"math/big"
 
 	"github.com/gtank/ristretto255"
 
@@ -191,6 +192,25 @@ func (s *Scalar) Set(scalar internal.Scalar) internal.Scalar {
 	return s
 }
 
+// SetInt sets s to i modulo the field order, and returns an error if one occurs.
+func (s *Scalar) SetInt(i *big.Int) error {
+	a := new(big.Int).Set(i)
+
+	order, ok := new(big.Int).SetString(orderPrime, 10)
+	if !ok {
+		return internal.ErrBigIntConversion
+	}
+
+	bytes := make([]byte, 32)
+	bytes = a.Mod(a, order).FillBytes(bytes)
+
+	for j, k := 0, len(bytes)-1; j < k; j, k = j+1, k-1 {
+		bytes[j], bytes[k] = bytes[k], bytes[j]
+	}
+
+	return s.Decode(bytes)
+}
+
 // Copy returns a copy of the receiver.
 func (s *Scalar) Copy() internal.Scalar {
 	return &Scalar{*ristretto255.NewScalar().Add(ristretto255.NewScalar(), &s.scalar)}

internal/scalar.go

@@ -9,7 +9,10 @@
 // Package internal defines simple and abstract APIs to group Elements and Scalars.
 package internal
 
-import "encoding"
+import (
+	"encoding"
+	"math/big"
+)
 
 // Scalar interface abstracts common operations on scalars in a prime-order Group.
 type Scalar interface {
@@ -50,6 +53,9 @@ type Scalar interface {
 	// Set sets the receiver to the value of the argument scalar, and returns the receiver.
 	Set(Scalar) Scalar
 
+	// SetInt sets s to i modulo the field order, and returns an error if one occurs.
+	SetInt(i *big.Int) error
+
 	// Copy returns a copy of the receiver.
 	Copy() Scalar
 

scalar.go

@@ -11,6 +11,7 @@ package crypto
 
 import (
 	"fmt"
+	"math/big"
 
 	"github.com/bytemare/crypto/internal"
 )
@@ -122,6 +123,15 @@ func (s *Scalar) Set(scalar *Scalar) *Scalar {
 	return s
 }
 
+// SetInt sets s to i modulo the field order, and returns an error if one occurs.
+func (s *Scalar) SetInt(i *big.Int) error {
+	if err := s.Scalar.SetInt(i); err != nil {
+		return fmt.Errorf("scalar: %w", err)
+	}
+
+	return nil
+}
+
 // Copy returns a copy of the receiver.
 func (s *Scalar) Copy() *Scalar {
 	return &Scalar{s.Scalar.Copy()}

tests/scalar_test.go

@@ -10,6 +10,7 @@ package group_test
 
 import (
 	"encoding/hex"
+	"math/big"
 	"testing"
 
 	"github.com/bytemare/crypto"
@@ -104,6 +105,43 @@ func TestScalarSet(t *testing.T) {
 	})
 }
 
+func TestScalarSetInt(t *testing.T) {
+	testAll(t, func(t2 *testing.T, group *testGroup) {
+		i := big.NewInt(0)
+
+		s := group.id.NewScalar()
+		if err := s.SetInt(i); err != nil {
+			t.Fatal(err)
+		}
+
+		if !s.IsZero() {
+			t.Fatal("expected 0")
+		}
+
+		i = big.NewInt(1)
+		if err := s.SetInt(i); err != nil {
+			t.Fatal(err)
+		}
+
+		if s.Equal(group.id.NewScalar().One()) != 1 {
+			t.Fatal("expected 1")
+		}
+
+		order, ok := new(big.Int).SetString(group.id.Order(), 10)
+		if !ok {
+			t.Fatal("conversion error")
+		}
+
+		if err := s.SetInt(order); err != nil {
+			t.Fatal(err)
+		}
+
+		if !s.IsZero() {
+			t.Fatal("expected 0")
+		}
+	})
+}
+
 func TestScalar_EncodedLength(t *testing.T) {
 	testAll(t, func(t2 *testing.T, group *testGroup) {
 		encodedScalar := group.id.NewScalar().Random().Encode()