Remove excess gost3410.Mode

diff --git a/README b/README
index eda3d24da360df2c8963cb9c463aa57d4829ccc2..3767c50200170548ba728f589773fd0e8d8a3fe5 100644 (file)
--- a/README
+++ b/README
@@ -46,13 +46,13 @@ Example 34.10-2012-256 keypair generation, signing and verifying:
         _, err := hasher.Write(data)
         dgst := hasher.Sum(nil)
         curve := gost3410.CurveIdtc26gost34102012256paramSetB()
-        prvRaw := make([]byte, int(gost3410.Mode2001))
+        prvRaw := make([]byte, int(32))
         _, err = io.ReadFull(rand.Reader, prvRaw)
-        prv, err := gost3410.NewPrivateKey(curve, gost3410.Mode2001, prvRaw)
+        prv, err := gost3410.NewPrivateKey(curve, prvRaw)
         pub, err := prv.PublicKey()
         pubRaw := pub.Raw()
         sign, err := prv.Sign(rand.Reader, dgst, nil)
-        pub, err = gost3410.NewPublicKey(curve, gost3410.Mode2001, pubRaw)
+        pub, err = gost3410.NewPublicKey(curve, pubRaw)
         isValid, err := pub.VerifyDigest(dgst, sign)
         if !isValid { panic("signature is invalid") }
     }

diff --git a/VERSION b/VERSION
index f77856a6f1af5be6984fa25aaa2e17616e1030ab..0062ac971805f7b700058db4bb0f5c5b771dda76 100644 (file)
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-4.3.1
+5.0.0

diff --git a/gost3410/2001_test.go b/gost3410/2001_test.go
index e330d4e5fc9ad4e2fb5083062399a027f31fe89c..c5d827144553ba206d8e00b7360b20ce03bfbb86 100644 (file)
--- a/gost3410/2001_test.go
+++ b/gost3410/2001_test.go
@@ -59,7 +59,7 @@ func TestRFCVectors(t *testing.T) {
        }
 
        c := CurveIdGostR34102001TestParamSet()
-       prv, err := NewPrivateKey(c, Mode2001, priv)
+       prv, err := NewPrivateKey(c, priv)
        if err != nil {
                t.FailNow()
        }
@@ -90,11 +90,7 @@ func TestRFCVectors(t *testing.T) {
 func TestRandom2001(t *testing.T) {
        c := CurveIdGostR34102001TestParamSet()
        f := func(data [31]byte, digest [32]byte) bool {
-               prv, err := NewPrivateKey(
-                       c,
-                       Mode2001,
-                       append([]byte{0xde}, data[:]...),
-               )
+               prv, err := NewPrivateKey(c, append([]byte{0xde}, data[:]...))
                if err != nil {
                        return false
                }
@@ -103,7 +99,7 @@ func TestRandom2001(t *testing.T) {
                        return false
                }
                pubRaw := pub.Raw()
-               pub, err = NewPublicKey(c, Mode2001, pubRaw)
+               pub, err = NewPublicKey(c, pubRaw)
                if err != nil {
                        return false
                }
@@ -124,7 +120,7 @@ func TestRandom2001(t *testing.T) {
 
 func BenchmarkSign2001(b *testing.B) {
        c := CurveIdGostR34102001TestParamSet()
-       prv, err := GenPrivateKey(c, Mode2001, rand.Reader)
+       prv, err := GenPrivateKey(c, rand.Reader)
        if err != nil {
                b.FailNow()
        }
@@ -138,7 +134,7 @@ func BenchmarkSign2001(b *testing.B) {
 
 func BenchmarkVerify2001(b *testing.B) {
        c := CurveIdGostR34102001TestParamSet()
-       prv, err := GenPrivateKey(c, Mode2001, rand.Reader)
+       prv, err := GenPrivateKey(c, rand.Reader)
        if err != nil {
                b.FailNow()
        }
@@ -160,9 +156,9 @@ func BenchmarkVerify2001(b *testing.B) {
 
 func TestPrvEqualsTo1(t *testing.T) {
        c := CurveIdGostR34102001TestParamSet()
-       prvRaw := make([]byte, int(Mode2001))
+       prvRaw := make([]byte, 32)
        prvRaw[len(prvRaw)-1] = 1
-       prv, err := NewPrivateKey(c, Mode2001, prvRaw)
+       prv, err := NewPrivateKey(c, prvRaw)
        if err != nil {
                t.FailNow()
        }

diff --git a/gost3410/2012_test.go b/gost3410/2012_test.go
index 592418491fc6deadf1d746467427fb8fe0553f0d..fa868f28378d8bc192d5189d3dedf8f4e9ba34aa 100644 (file)
--- a/gost3410/2012_test.go
+++ b/gost3410/2012_test.go
@@ -57,7 +57,7 @@ func TestStdVector1(t *testing.T) {
                0x92, 0x80, 0x14, 0xF6, 0xC5, 0xBF, 0x9C, 0x40,
        }
        reverse(prvRaw)
-       prv, err := NewPrivateKey(CurveIdGostR34102001TestParamSet(), Mode2001, prvRaw)
+       prv, err := NewPrivateKey(CurveIdGostR34102001TestParamSet(), prvRaw)
        if err != nil {
                t.FailNow()
        }
@@ -182,7 +182,7 @@ func TestStdVector2(t *testing.T) {
                0x2A, 0x98, 0x53, 0xBD, 0xE7, 0x3E, 0x5B, 0x4A,
        }
        reverse(prvRaw)
-       prv, err := NewPrivateKey(c, Mode2012, prvRaw)
+       prv, err := NewPrivateKey(c, prvRaw)
        if err != nil {
                t.FailNow()
        }
@@ -328,7 +328,7 @@ func TestGCL3Vectors(t *testing.T) {
        if err != nil {
                t.FailNow()
        }
-       prv, err := NewPrivateKey(c, Mode2012, priv)
+       prv, err := NewPrivateKey(c, priv)
        if err != nil {
                t.FailNow()
        }
@@ -359,11 +359,7 @@ func TestGCL3Vectors(t *testing.T) {
 func TestRandom2012(t *testing.T) {
        c := CurveIdtc26gost341012512paramSetA()
        f := func(prvRaw [64 - 1]byte, digest [64]byte) bool {
-               prv, err := NewPrivateKey(
-                       c,
-                       Mode2012,
-                       append([]byte{0xde}, prvRaw[:]...),
-               )
+               prv, err := NewPrivateKey(c, append([]byte{0xde}, prvRaw[:]...))
                if err != nil {
                        return false
                }
@@ -372,7 +368,7 @@ func TestRandom2012(t *testing.T) {
                        return false
                }
                pubRaw := pub.Raw()
-               pub, err = NewPublicKey(c, Mode2012, pubRaw)
+               pub, err = NewPublicKey(c, pubRaw)
                if err != nil {
                        return false
                }
@@ -582,7 +578,7 @@ func TestUVXYConversion(t *testing.T) {
 
 func BenchmarkSign2012(b *testing.B) {
        c := CurveIdtc26gost341012512paramSetA()
-       prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
+       prv, err := GenPrivateKey(c, rand.Reader)
        if err != nil {
                b.FailNow()
        }
@@ -596,7 +592,7 @@ func BenchmarkSign2012(b *testing.B) {
 
 func BenchmarkVerify2012(b *testing.B) {
        c := CurveIdtc26gost341012512paramSetA()
-       prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
+       prv, err := GenPrivateKey(c, rand.Reader)
        if err != nil {
                b.FailNow()
        }

diff --git a/gost3410/curve.go b/gost3410/curve.go
index a3685ce047e7be3b7c11ea58f649c09761255d46..e1214d712127533f2205ef655afe41872a0dca92 100644 (file)
--- a/gost3410/curve.go
+++ b/gost3410/curve.go
@@ -96,6 +96,10 @@ func NewCurve(p, q, a, b, x, y, e, d, co *big.Int) (*Curve, error) {
        return &c, nil
 }
 
+func (c *Curve) PointSize() int {
+       return PointSize(c.P)
+}
+
 func (c *Curve) pos(v *big.Int) {
        if v.Cmp(zero) < 0 {
                v.Add(v, c.P)

diff --git a/gost3410/params.go b/gost3410/params.go
index ebbb9afe6d4f87ec0ebd849a398987ef8e2222a9..6e7111458ff9f80df89eb7f45d532e82d0e50769 100644 (file)
--- a/gost3410/params.go
+++ b/gost3410/params.go
@@ -15,12 +15,7 @@
 
 package gost3410
 
-type Mode int
-
 var (
-       Mode2001 Mode = Mode(32)
-       Mode2012 Mode = Mode(64)
-
        CurveGostR34102001ParamSetcc func() *Curve = func() *Curve {
                curve, err := NewCurve(
                        bytes2big([]byte{

diff --git a/gost3410/private.go b/gost3410/private.go
index 645881bfd5c1944814637e5387899932a095a542..689a9612d7ba3d2ad1f5fe5620ee046876aac6e7 100644 (file)
--- a/gost3410/private.go
+++ b/gost3410/private.go
@@ -24,16 +24,16 @@ import (
 )
 
 type PrivateKey struct {
-       C    *Curve
-       Mode Mode
-       Key  *big.Int
+       C   *Curve
+       Key *big.Int
 }
 
-func NewPrivateKey(curve *Curve, mode Mode, raw []byte) (*PrivateKey, error) {
-       if len(raw) != int(mode) {
-               return nil, fmt.Errorf("gogost/gost3410: len(key) != %d", mode)
+func NewPrivateKey(curve *Curve, raw []byte) (*PrivateKey, error) {
+       pointSize := curve.PointSize()
+       if len(raw) != pointSize {
+               return nil, fmt.Errorf("gogost/gost3410: len(key) != %d", pointSize)
        }
-       key := make([]byte, int(mode))
+       key := make([]byte, pointSize)
        for i := 0; i < len(key); i++ {
                key[i] = raw[len(raw)-i-1]
        }
@@ -41,19 +41,19 @@ func NewPrivateKey(curve *Curve, mode Mode, raw []byte) (*PrivateKey, error) {
        if k.Cmp(zero) == 0 {
                return nil, errors.New("gogost/gost3410: zero private key")
        }
-       return &PrivateKey{curve, mode, k}, nil
+       return &PrivateKey{curve, k}, nil
 }
 
-func GenPrivateKey(curve *Curve, mode Mode, rand io.Reader) (*PrivateKey, error) {
-       raw := make([]byte, int(mode))
+func GenPrivateKey(curve *Curve, rand io.Reader) (*PrivateKey, error) {
+       raw := make([]byte, curve.PointSize())
        if _, err := io.ReadFull(rand, raw); err != nil {
                return nil, err
        }
-       return NewPrivateKey(curve, mode, raw)
+       return NewPrivateKey(curve, raw)
 }
 
 func (prv *PrivateKey) Raw() []byte {
-       raw := pad(prv.Key.Bytes(), int(prv.Mode))
+       raw := pad(prv.Key.Bytes(), prv.C.PointSize())
        reverse(raw)
        return raw
 }
@@ -63,7 +63,7 @@ func (prv *PrivateKey) PublicKey() (*PublicKey, error) {
        if err != nil {
                return nil, err
        }
-       return &PublicKey{prv.C, prv.Mode, x, y}, nil
+       return &PublicKey{prv.C, x, y}, nil
 }
 
 func (prv *PrivateKey) SignDigest(digest []byte, rand io.Reader) ([]byte, error) {
@@ -72,7 +72,7 @@ func (prv *PrivateKey) SignDigest(digest []byte, rand io.Reader) ([]byte, error)
        if e.Cmp(zero) == 0 {
                e = big.NewInt(1)
        }
-       kRaw := make([]byte, int(prv.Mode))
+       kRaw := make([]byte, prv.C.PointSize())
        var err error
        var k *big.Int
        var r *big.Int
@@ -102,9 +102,10 @@ Retry:
        if s.Cmp(zero) == 0 {
                goto Retry
        }
+       pointSize := prv.C.PointSize()
        return append(
-               pad(s.Bytes(), int(prv.Mode)),
-               pad(r.Bytes(), int(prv.Mode))...,
+               pad(s.Bytes(), pointSize),
+               pad(r.Bytes(), pointSize)...,
        ), nil
 }
 

diff --git a/gost3410/private_test.go b/gost3410/private_test.go
index f20d325c1b604287a76bb20e09504b6539f7e6e4..a9b051cfe6d9129cfb9fc33c916543e5e2e93726 100644 (file)
--- a/gost3410/private_test.go
+++ b/gost3410/private_test.go
@@ -22,9 +22,9 @@ import (
 )
 
 func TestSignerInterface(t *testing.T) {
-       prvRaw := make([]byte, int(Mode2001))
+       prvRaw := make([]byte, 32)
        rand.Read(prvRaw)
-       prv, err := NewPrivateKey(CurveIdGostR34102001TestParamSet(), Mode2001, prvRaw)
+       prv, err := NewPrivateKey(CurveIdGostR34102001TestParamSet(), prvRaw)
        if err != nil {
                t.FailNow()
        }

diff --git a/gost3410/public.go b/gost3410/public.go
index 675431cf816f72bc4448c5916ef1fe3fb564ad9c..e2e3814e381e9dd8db2caf0408a67bd79fb65d86 100644 (file)
--- a/gost3410/public.go
+++ b/gost3410/public.go
@@ -21,14 +21,14 @@ import (
 )
 
 type PublicKey struct {
-       C    *Curve
-       Mode Mode
-       X    *big.Int
-       Y    *big.Int
+       C *Curve
+       X *big.Int
+       Y *big.Int
 }
 
-func NewPublicKey(curve *Curve, mode Mode, raw []byte) (*PublicKey, error) {
-       key := make([]byte, 2*int(mode))
+func NewPublicKey(curve *Curve, raw []byte) (*PublicKey, error) {
+       pointSize := curve.PointSize()
+       key := make([]byte, 2*pointSize)
        if len(raw) != len(key) {
                return nil, fmt.Errorf("gogost/gost3410: len(key) != %d", len(key))
        }
@@ -37,27 +37,28 @@ func NewPublicKey(curve *Curve, mode Mode, raw []byte) (*PublicKey, error) {
        }
        return &PublicKey{
                curve,
-               mode,
-               bytes2big(key[int(mode) : 2*int(mode)]),
-               bytes2big(key[:int(mode)]),
+               bytes2big(key[pointSize : 2*pointSize]),
+               bytes2big(key[:pointSize]),
        }, nil
 }
 
 func (pub *PublicKey) Raw() []byte {
+       pointSize := pub.C.PointSize()
        raw := append(
-               pad(pub.Y.Bytes(), int(pub.Mode)),
-               pad(pub.X.Bytes(), int(pub.Mode))...,
+               pad(pub.Y.Bytes(), pointSize),
+               pad(pub.X.Bytes(), pointSize)...,
        )
        reverse(raw)
        return raw
 }
 
 func (pub *PublicKey) VerifyDigest(digest, signature []byte) (bool, error) {
-       if len(signature) != 2*int(pub.Mode) {
-               return false, fmt.Errorf("gogost/gost3410: len(signature) != %d", 2*int(pub.Mode))
+       pointSize := pub.C.PointSize()
+       if len(signature) != 2*pointSize {
+               return false, fmt.Errorf("gogost/gost3410: len(signature) != %d", 2*pointSize)
        }
-       s := bytes2big(signature[:pub.Mode])
-       r := bytes2big(signature[pub.Mode:])
+       s := bytes2big(signature[:pointSize])
+       r := bytes2big(signature[pointSize:])
        if r.Cmp(zero) <= 0 ||
                r.Cmp(pub.C.Q) >= 0 ||
                s.Cmp(zero) <= 0 ||

diff --git a/gost3410/utils.go b/gost3410/utils.go
index 2f22d3bcee751705edad8954c17c4315d2fcd7e7..b903915e674116fab459fa691060bd04c909b9f7 100644 (file)
--- a/gost3410/utils.go
+++ b/gost3410/utils.go
@@ -32,3 +32,10 @@ func reverse(d []byte) {
 func pad(d []byte, size int) []byte {
        return append(make([]byte, size-len(d)), d...)
 }
+
+func PointSize(p *big.Int) int {
+       if p.BitLen() > 256 {
+               return 64
+       }
+       return 32
+}

diff --git a/gost3410/vko.go b/gost3410/vko.go
index e373e4a6c2a63ef290fd77ec0652f436d1a68f28..fdf3a2f5cb191312f678297696745d75964049f6 100644 (file)
--- a/gost3410/vko.go
+++ b/gost3410/vko.go
@@ -31,6 +31,6 @@ func (prv *PrivateKey) KEK(pub *PublicKey, ukm *big.Int) ([]byte, error) {
                        return nil, err
                }
        }
-       pk := PublicKey{prv.C, prv.Mode, keyX, keyY}
+       pk := PublicKey{prv.C, keyX, keyY}
        return pk.Raw(), nil
 }

diff --git a/gost3410/vko2001.go b/gost3410/vko2001.go
index c9aeada21a90a36f782a49497aaa8c4af347a813..8559ed2a9c2dc807302a22d0b02fedea1c8b68be 100644 (file)
--- a/gost3410/vko2001.go
+++ b/gost3410/vko2001.go
@@ -26,8 +26,8 @@ import (
 // RFC 4357 VKO GOST R 34.10-2001 key agreement function.
 // UKM is user keying material, also called VKO-factor.
 func (prv *PrivateKey) KEK2001(pub *PublicKey, ukm *big.Int) ([]byte, error) {
-       if prv.Mode != Mode2001 {
-               return nil, errors.New("gogost/gost3410: KEK2001 can not be used in Mode2012")
+       if prv.C.PointSize() != 32 {
+               return nil, errors.New("gogost/gost3410: KEK2001 is only for 256-bit curves")
        }
        key, err := prv.KEK(pub, ukm)
        if err != nil {

diff --git a/gost3410/vko2001_test.go b/gost3410/vko2001_test.go
index 41fa4a4c3d473e2115afd3e73af45c8c402b99cb..3f807338cca2432c141e69f049a2b232c384dfc5 100644 (file)
--- a/gost3410/vko2001_test.go
+++ b/gost3410/vko2001_test.go
@@ -29,8 +29,8 @@ func TestVKO2001(t *testing.T) {
        prvRaw1, _ := hex.DecodeString("1df129e43dab345b68f6a852f4162dc69f36b2f84717d08755cc5c44150bf928")
        prvRaw2, _ := hex.DecodeString("5b9356c6474f913f1e83885ea0edd5df1a43fd9d799d219093241157ac9ed473")
        kek, _ := hex.DecodeString("ee4618a0dbb10cb31777b4b86a53d9e7ef6cb3e400101410f0c0f2af46c494a6")
-       prv1, _ := NewPrivateKey(c, Mode2001, prvRaw1)
-       prv2, _ := NewPrivateKey(c, Mode2001, prvRaw2)
+       prv1, _ := NewPrivateKey(c, prvRaw1)
+       prv2, _ := NewPrivateKey(c, prvRaw2)
        pub1, _ := prv1.PublicKey()
        pub2, _ := prv2.PublicKey()
        kek1, _ := prv1.KEK2001(pub2, ukm)
@@ -46,11 +46,11 @@ func TestVKO2001(t *testing.T) {
 func TestRandomVKO2001(t *testing.T) {
        c := CurveIdGostR34102001TestParamSet()
        f := func(prvRaw1 [32]byte, prvRaw2 [32]byte, ukmRaw [8]byte) bool {
-               prv1, err := NewPrivateKey(c, Mode2001, prvRaw1[:])
+               prv1, err := NewPrivateKey(c, prvRaw1[:])
                if err != nil {
                        return false
                }
-               prv2, err := NewPrivateKey(c, Mode2001, prvRaw2[:])
+               prv2, err := NewPrivateKey(c, prvRaw2[:])
                if err != nil {
                        return false
                }

diff --git a/gost3410/vko2012_test.go b/gost3410/vko2012_test.go
index 3d23b95abb1e3a36bc66ddc8623f6b6ace689d9f..33aabd963eb9c394d12532a01154ef2f0a565d15 100644 (file)
--- a/gost3410/vko2012_test.go
+++ b/gost3410/vko2012_test.go
@@ -30,11 +30,11 @@ func TestVKO2012256(t *testing.T) {
        pubRawA, _ := hex.DecodeString("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")
        prvRawB, _ := hex.DecodeString("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")
        pubRawB, _ := hex.DecodeString("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")
-       pubA, _ := NewPublicKey(c, Mode2012, pubRawA)
-       pubB, _ := NewPublicKey(c, Mode2012, pubRawB)
+       pubA, _ := NewPublicKey(c, pubRawA)
+       pubB, _ := NewPublicKey(c, pubRawB)
        kek, _ := hex.DecodeString("c9a9a77320e2cc559ed72dce6f47e2192ccea95fa648670582c054c0ef36c221")
-       prvA, _ := NewPrivateKey(c, Mode2012, prvRawA)
-       prvB, _ := NewPrivateKey(c, Mode2012, prvRawB)
+       prvA, _ := NewPrivateKey(c, prvRawA)
+       prvB, _ := NewPrivateKey(c, prvRawB)
        kekA, _ := prvA.KEK2012256(pubB, ukm)
        kekB, _ := prvB.KEK2012256(pubA, ukm)
        if bytes.Compare(kekA, kekB) != 0 {
@@ -48,11 +48,11 @@ func TestVKO2012256(t *testing.T) {
 func TestRandomVKO2012256(t *testing.T) {
        c := CurveIdtc26gost341012512paramSetA()
        f := func(prvRaw1 [64]byte, prvRaw2 [64]byte, ukmRaw [8]byte) bool {
-               prv1, err := NewPrivateKey(c, Mode2012, prvRaw1[:])
+               prv1, err := NewPrivateKey(c, prvRaw1[:])
                if err != nil {
                        return false
                }
-               prv2, err := NewPrivateKey(c, Mode2012, prvRaw2[:])
+               prv2, err := NewPrivateKey(c, prvRaw2[:])
                if err != nil {
                        return false
                }
@@ -76,11 +76,11 @@ func TestVKO2012512(t *testing.T) {
        pubRawA, _ := hex.DecodeString("aab0eda4abff21208d18799fb9a8556654ba783070eba10cb9abb253ec56dcf5d3ccba6192e464e6e5bcb6dea137792f2431f6c897eb1b3c0cc14327b1adc0a7914613a3074e363aedb204d38d3563971bd8758e878c9db11403721b48002d38461f92472d40ea92f9958c0ffa4c93756401b97f89fdbe0b5e46e4a4631cdb5a")
        prvRawB, _ := hex.DecodeString("48c859f7b6f11585887cc05ec6ef1390cfea739b1a18c0d4662293ef63b79e3b8014070b44918590b4b996acfea4edfbbbcccc8c06edd8bf5bda92a51392d0db")
        pubRawB, _ := hex.DecodeString("192fe183b9713a077253c72c8735de2ea42a3dbc66ea317838b65fa32523cd5efca974eda7c863f4954d1147f1f2b25c395fce1c129175e876d132e94ed5a65104883b414c9b592ec4dc84826f07d0b6d9006dda176ce48c391e3f97d102e03bb598bf132a228a45f7201aba08fc524a2d77e43a362ab022ad4028f75bde3b79")
-       pubA, _ := NewPublicKey(c, Mode2012, pubRawA)
-       pubB, _ := NewPublicKey(c, Mode2012, pubRawB)
+       pubA, _ := NewPublicKey(c, pubRawA)
+       pubB, _ := NewPublicKey(c, pubRawB)
        kek, _ := hex.DecodeString("79f002a96940ce7bde3259a52e015297adaad84597a0d205b50e3e1719f97bfa7ee1d2661fa9979a5aa235b558a7e6d9f88f982dd63fc35a8ec0dd5e242d3bdf")
-       prvA, _ := NewPrivateKey(c, Mode2012, prvRawA)
-       prvB, _ := NewPrivateKey(c, Mode2012, prvRawB)
+       prvA, _ := NewPrivateKey(c, prvRawA)
+       prvB, _ := NewPrivateKey(c, prvRawB)
        kekA, _ := prvA.KEK2012512(pubB, ukm)
        kekB, _ := prvB.KEK2012512(pubA, ukm)
        if bytes.Compare(kekA, kekB) != 0 {
@@ -94,11 +94,11 @@ func TestVKO2012512(t *testing.T) {
 func TestRandomVKO2012512(t *testing.T) {
        c := CurveIdtc26gost341012512paramSetA()
        f := func(prvRaw1 [64]byte, prvRaw2 [64]byte, ukmRaw [8]byte) bool {
-               prv1, err := NewPrivateKey(c, Mode2012, prvRaw1[:])
+               prv1, err := NewPrivateKey(c, prvRaw1[:])
                if err != nil {
                        return false
                }
-               prv2, err := NewPrivateKey(c, Mode2012, prvRaw2[:])
+               prv2, err := NewPrivateKey(c, prvRaw2[:])
                if err != nil {
                        return false
                }

diff --git a/install.texi b/install.texi
index 75c0f99d745b5fc77009d8385f4042826319046d..729510d85a4ee169a73f24999f909afc07445b80 100644 (file)
--- a/install.texi
+++ b/install.texi
@@ -1,7 +1,7 @@
 @node Download
 @unnumbered Download
 
-@set VERSION 4.3.1
+@set VERSION 5.0.0
 
 Preferable way is to download tarball with the signature from
 website and, for example, run tests with benchmarks:

diff --git a/news.texi b/news.texi
index 68ee9069696f0b2c91c050b77cbd6a44af5eebf0..350ac077bda2980fb57b4a7f908304e1ce19d5fb 100644 (file)
--- a/news.texi
+++ b/news.texi
@@ -3,6 +3,12 @@
 
 @table @strong
 
+@anchor{Release 5.0.0}
+@item 5.0.0
+    Backward incompatible remove of excess misleading @code{gost3410.Mode}
+    from all related functions. Point/key sizes are determined by
+    looking at curve's parameters size.
+
 @anchor{Release 4.3.0}
 @item 4.3.0
     @strong{Fixed} nasty bug with Edwards curves using in 34.10-VKO

diff --git a/www.texi b/www.texi
index 94bf7161663b9b54c0e3c9a84448f5cfeea687a0..83de587790a2ab8d2c22d48ae372a84b7eab62ea 100644 (file)
--- a/www.texi
+++ b/www.texi
@@ -74,13 +74,13 @@ func main() {
     _, err := hasher.Write(data)
     dgst := hasher.Sum(nil)
     curve := gost3410.CurveIdtc26gost34102012256paramSetB()
-    prvRaw := make([]byte, int(gost3410.Mode2001))
+    prvRaw := make([]byte, 32)
     _, err = io.ReadFull(rand.Reader, prvRaw)
-    prv, err := gost3410.NewPrivateKey(curve, gost3410.Mode2001, prvRaw)
+    prv, err := gost3410.NewPrivateKey(curve, prvRaw)
     pub, err := prv.PublicKey()
     pubRaw := pub.Raw()
     sign, err := prv.Sign(rand.Reader, dgst, nil)
-    pub, err = gost3410.NewPublicKey(curve, gost3410.Mode2001, pubRaw)
+    pub, err = gost3410.NewPublicKey(curve, pubRaw)
     isValid, err := pub.VerifyDigest(dgst, sign)
     if !isValid { panic("signature is invalid") }
 }