README | 6 +++--- VERSION | 2 +- gost3410/2001_test.go | 18 +++++++----------- gost3410/2012_test.go | 18 +++++++----------- gost3410/curve.go | 4 ++++ gost3410/params.go | 5 ----- gost3410/private.go | 33 +++++++++++++++++---------------- gost3410/private_test.go | 4 ++-- gost3410/public.go | 31 ++++++++++++++++--------------- gost3410/utils.go | 7 +++++++ gost3410/vko.go | 2 +- gost3410/vko2001.go | 4 ++-- gost3410/vko2001_test.go | 8 ++++---- gost3410/vko2012_test.go | 24 ++++++++++++------------ install.texi | 2 +- news.texi | 6 ++++++ www.texi | 6 +++--- diff --git a/README b/README index 9229f578c9cffddb0505f81d613c0f81bad9db999abe2453e451ebfff585944b..e25df09c6bcf1e974e75c8f3f28f9648ccd4a907d1029b7beaf1040132d9f6ab 100644 --- a/README +++ b/README @@ -46,13 +46,13 @@ hasher := gost34112012256.New() _, 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 79bdee7087e7330e5d4bcc9c7d52577c2c8a42bbe8f9a21e9089ddc7e681dc57..66f2a752442fc764e44f203c55ad3ded2f621d3d55dbdc1f1ae3b57f325add6e 100644 --- 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 321cc0c2a6551fbbdfad5751b6f0163c50acceda4691fd097b94e1085b5eb76a..60667472551f72e58e368a2067dcadd34d2e142d87c3b516d7c9c1eff76c286e 100644 --- a/gost3410/2001_test.go +++ b/gost3410/2001_test.go @@ -59,7 +59,7 @@ 0x3a, 0xd0, 0x43, 0xfd, 0x39, 0xdc, 0x04, 0x93, } c := CurveIdGostR34102001TestParamSet() - prv, err := NewPrivateKey(c, Mode2001, priv) + prv, err := NewPrivateKey(c, priv) if err != nil { t.FailNow() } @@ -90,11 +90,7 @@ 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 @@ if err != nil { 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 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 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 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 109fa349a7156d924be54c3d159dceef406e6faecf46cd7c113cf17c206a07e0..ebd27de0c24d9893f37d2fde9c6a206971948f53d650885b4f112d05720e5cea 100644 --- a/gost3410/2012_test.go +++ b/gost3410/2012_test.go @@ -57,7 +57,7 @@ 0xBC, 0xD6, 0xD3, 0xF7, 0x46, 0xB6, 0x31, 0xDF, 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 @@ 0x6A, 0x6E, 0xEB, 0x1F, 0x56, 0x91, 0x9C, 0xB9, 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 @@ ) 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 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 @@ if err != nil { 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 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 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 bc010b432bf63d8d426a9c7a63b10034273b9bbeede2d82107e21e427ee5bb16..3947212e06f74699ff3444c7100599233be2a67fd6aacc5fde5c9ad9c1631a5e 100644 --- a/gost3410/curve.go +++ b/gost3410/curve.go @@ -96,6 +96,10 @@ } 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 3142c34785973c04623a2c950f328194165b107b8cddf3c61a8bfb78b2febba5..cf633458267c97f820375d51e4085c55030b563e60a336627b0e833e974575b3 100644 --- a/gost3410/params.go +++ b/gost3410/params.go @@ -15,12 +15,7 @@ // along with this program. If not, see . 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 c6bcc822128c5f8c85fb6fb642769015ab3a6ec81f2bfe14cf08da9b3e67ba5e..e9106b574c36e0c3c8a1861f747521cf79a593b19d6dc258cf430e88b0f1e171 100644 --- a/gost3410/private.go +++ b/gost3410/private.go @@ -24,16 +24,16 @@ "math/big" ) 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 @@ k := bytes2big(key) 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 @@ x, y, err := prv.C.Exp(prv.Key, prv.C.X, prv.C.Y) 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 @@ e.Mod(e, prv.C.Q) 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 @@ s.Mod(s, prv.C.Q) 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 7256bc425f0c0181561f1281b50147ed45f6a351582fd74cde40bd217771bf0b..a9764243d96d27a8e710e2ac0cf63ee9054d6c1b67f4c5359f71f9c37a89f265 100644 --- a/gost3410/private_test.go +++ b/gost3410/private_test.go @@ -22,9 +22,9 @@ "testing" ) 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 70efd878bbf5181629c3df979b34ce72e690dc43800488dfa10fb7bf5a98076e..08eee30f00767392dde50361462929f4d5a1e9effa37dc06c071370718870995 100644 --- a/gost3410/public.go +++ b/gost3410/public.go @@ -21,14 +21,14 @@ "math/big" ) 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 @@ key[i] = raw[len(raw)-i-1] } 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 6d84492e7c5fcc703af0cb4d45bcdc37c43cec4e6beb83b1ee3024f19bf54f7d..c28062ffca03624efc51dfd942427f80948f047b7c0ac5122e8fcc416aebca2a 100644 --- a/gost3410/utils.go +++ b/gost3410/utils.go @@ -32,3 +32,10 @@ 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 d06793e4d68938c73dc226eb52cc48a4148bb254d14bf1525341c8b79f2f6934..ea5571658220fe121d46618df189d6f21ce40affb40309adfda76f257e1dc054 100644 --- a/gost3410/vko.go +++ b/gost3410/vko.go @@ -31,6 +31,6 @@ if err != nil { 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 5ffe784e341a5b50246457b01dc6929900cb10d35457fcb0f9fe17f64269f226..44719af1d9b762444825d58b8db1777adb5969991a9337f9a843bca28fb0b251 100644 --- a/gost3410/vko2001.go +++ b/gost3410/vko2001.go @@ -26,8 +26,8 @@ // 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 98217d193f2b3ff50d1c7c99256cad3a64dc53be26a82b3e3a576abaf3281a0e..f8f8456c8ac16b2d29251630b343fb8577b925fbc5ef05a4e12d88044887a53a 100644 --- a/gost3410/vko2001_test.go +++ b/gost3410/vko2001_test.go @@ -29,8 +29,8 @@ ukm := NewUKM(ukmRaw) 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 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 90aa481fb99ffbc98467595efcef69709ca8e6686be56284f9e0be8e55c5417a..01f0f98288fc22363b9d15520835c64ba625caccb6ade65e8ebf4f3a28160dbc 100644 --- a/gost3410/vko2012_test.go +++ b/gost3410/vko2012_test.go @@ -30,11 +30,11 @@ prvRawA, _ := hex.DecodeString("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667") 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 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 @@ prvRawA, _ := hex.DecodeString("c990ecd972fce84ec4db022778f50fcac726f46708384b8d458304962d7147f8c2db41cef22c90b102f2968404f9b9be6d47c79692d81826b32b8daca43cb667") 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 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 147166155617151f0cb6bf493f4b9cebd6cf6a99e078cf196a9e9b0379a42adf..f1215f27a7d4617724e49783d04ec79119f2a2ec7c1c73ef20eba0a5e8b23c10 100644 --- 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 bf119451e415b33abc849a9462b6265de79c3656abc4dcc5616a822d0049a1e6..89b65b45993bf0ee72c8a2204c7c41feffece0b34844127e15eec24029c2221a 100644 --- a/news.texi +++ b/news.texi @@ -3,6 +3,12 @@ @unnumbered News @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 902f5b4fd3f68d14a8501dc71af5ef41fcb371669b0d5179d04efc8bf8820590..9125098797eabc6471133a418856fd589df727f178efa6257bf4377f5fe40fc5 100644 --- a/www.texi +++ b/www.texi @@ -74,13 +74,13 @@ hasher := gost34112012256.New() _, 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") } }