src/cypherpunks.ru/gogost/gost3410/2001_test.go

   1 // GoGOST -- Pure Go GOST cryptographic functions library
   2 // Copyright (C) 2015-2019 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 package gost3410
  18
  19 import (
  20         "bytes"
  21         "crypto/rand"
  22         "testing"
  23         "testing/quick"
  24 )
  25
  26 func TestRFCVectors(t *testing.T) {
  27         priv := []byte{
  28                 0x28, 0x3b, 0xec, 0x91, 0x98, 0xce, 0x19, 0x1d,
  29                 0xee, 0x7e, 0x39, 0x49, 0x1f, 0x96, 0x60, 0x1b,
  30                 0xc1, 0x72, 0x9a, 0xd3, 0x9d, 0x35, 0xed, 0x10,
  31                 0xbe, 0xb9, 0x9b, 0x78, 0xde, 0x9a, 0x92, 0x7a,
  32         }
  33         pubX := []byte{
  34                 0x0b, 0xd8, 0x6f, 0xe5, 0xd8, 0xdb, 0x89, 0x66,
  35                 0x8f, 0x78, 0x9b, 0x4e, 0x1d, 0xba, 0x85, 0x85,
  36                 0xc5, 0x50, 0x8b, 0x45, 0xec, 0x5b, 0x59, 0xd8,
  37                 0x90, 0x6d, 0xdb, 0x70, 0xe2, 0x49, 0x2b, 0x7f,
  38         }
  39         pubY := []byte{
  40                 0xda, 0x77, 0xff, 0x87, 0x1a, 0x10, 0xfb, 0xdf,
  41                 0x27, 0x66, 0xd2, 0x93, 0xc5, 0xd1, 0x64, 0xaf,
  42                 0xbb, 0x3c, 0x7b, 0x97, 0x3a, 0x41, 0xc8, 0x85,
  43                 0xd1, 0x1d, 0x70, 0xd6, 0x89, 0xb4, 0xf1, 0x26,
  44         }
  45         digest := []byte{
  46                 0x2d, 0xfb, 0xc1, 0xb3, 0x72, 0xd8, 0x9a, 0x11,
  47                 0x88, 0xc0, 0x9c, 0x52, 0xe0, 0xee, 0xc6, 0x1f,
  48                 0xce, 0x52, 0x03, 0x2a, 0xb1, 0x02, 0x2e, 0x8e,
  49                 0x67, 0xec, 0xe6, 0x67, 0x2b, 0x04, 0x3e, 0xe5,
  50         }
  51         signature := []byte{
  52                 0x01, 0x45, 0x6c, 0x64, 0xba, 0x46, 0x42, 0xa1,
  53                 0x65, 0x3c, 0x23, 0x5a, 0x98, 0xa6, 0x02, 0x49,
  54                 0xbc, 0xd6, 0xd3, 0xf7, 0x46, 0xb6, 0x31, 0xdf,
  55                 0x92, 0x80, 0x14, 0xf6, 0xc5, 0xbf, 0x9c, 0x40,
  56                 0x41, 0xaa, 0x28, 0xd2, 0xf1, 0xab, 0x14, 0x82,
  57                 0x80, 0xcd, 0x9e, 0xd5, 0x6f, 0xed, 0xa4, 0x19,
  58                 0x74, 0x05, 0x35, 0x54, 0xa4, 0x27, 0x67, 0xb8,
  59                 0x3a, 0xd0, 0x43, 0xfd, 0x39, 0xdc, 0x04, 0x93,
  60         }
  61
  62         c, err := NewCurveFromParams(CurveParamsGostR34102001Test)
  63         if err != nil {
  64                 t.FailNow()
  65         }
  66         prv, err := NewPrivateKey(c, Mode2001, priv)
  67         if err != nil {
  68                 t.FailNow()
  69         }
  70         pub, err := prv.PublicKey()
  71         if err != nil {
  72                 t.FailNow()
  73         }
  74         if bytes.Compare(pub.Raw()[:32], pubX) != 0 {
  75                 t.FailNow()
  76         }
  77         if bytes.Compare(pub.Raw()[32:], pubY) != 0 {
  78                 t.FailNow()
  79         }
  80         ourSign, err := prv.SignDigest(digest, rand.Reader)
  81         if err != nil {
  82                 t.FailNow()
  83         }
  84         valid, err := pub.VerifyDigest(digest, ourSign)
  85         if err != nil || !valid {
  86                 t.FailNow()
  87         }
  88         valid, err = pub.VerifyDigest(digest, signature)
  89         if err != nil || !valid {
  90                 t.FailNow()
  91         }
  92 }
  93
  94 func TestRandom2001(t *testing.T) {
  95         c, _ := NewCurveFromParams(CurveParamsGostR34102001Test)
  96         f := func(data [31]byte, digest [32]byte) bool {
  97                 prv, err := NewPrivateKey(
  98                         c,
  99                         Mode2001,
 100                         append([]byte{0xde}, data[:]...),
 101                 )
 102                 if err != nil {
 103                         return false
 104                 }
 105                 pub, err := prv.PublicKey()
 106                 if err != nil {
 107                         return false
 108                 }
 109                 pubRaw := pub.Raw()
 110                 pub, err = NewPublicKey(c, Mode2001, pubRaw)
 111                 if err != nil {
 112                         return false
 113                 }
 114                 sign, err := prv.SignDigest(digest[:], rand.Reader)
 115                 if err != nil {
 116                         return false
 117                 }
 118                 valid, err := pub.VerifyDigest(digest[:], sign)
 119                 if err != nil {
 120                         return false
 121                 }
 122                 return valid
 123         }
 124         if err := quick.Check(f, nil); err != nil {
 125                 t.Error(err)
 126         }
 127 }
 128
 129 func BenchmarkSign2001(b *testing.B) {
 130         c, _ := NewCurveFromParams(CurveParamsGostR34102001Test)
 131         prv, err := GenPrivateKey(c, Mode2001, rand.Reader)
 132         if err != nil {
 133                 b.FailNow()
 134         }
 135         digest := make([]byte, 32)
 136         rand.Read(digest)
 137         b.ResetTimer()
 138         for i := 0; i < b.N; i++ {
 139                 prv.SignDigest(digest, rand.Reader)
 140         }
 141 }
 142
 143 func BenchmarkVerify2001(b *testing.B) {
 144         c, _ := NewCurveFromParams(CurveParamsGostR34102001Test)
 145         prv, err := GenPrivateKey(c, Mode2001, rand.Reader)
 146         if err != nil {
 147                 b.FailNow()
 148         }
 149         digest := make([]byte, 32)
 150         rand.Read(digest)
 151         sign, err := prv.SignDigest(digest, rand.Reader)
 152         if err != nil {
 153                 b.FailNow()
 154         }
 155         pub, err := prv.PublicKey()
 156         if err != nil {
 157                 b.FailNow()
 158         }
 159         b.ResetTimer()
 160         for i := 0; i < b.N; i++ {
 161                 pub.VerifyDigest(digest, sign)
 162         }
 163 }
 164
 165 func TestPrvEqualsTo1(t *testing.T) {
 166         c, _ := NewCurveFromParams(CurveParamsGostR34102001Test)
 167         prv, err := NewPrivateKey(c, Mode2001, []byte{0x01})
 168         if err != nil {
 169                 t.FailNow()
 170         }
 171         pub, err := prv.PublicKey()
 172         if err != nil {
 173                 t.FailNow()
 174         }
 175         digest := []byte{
 176                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 177                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 178                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 179                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
 180         }
 181         sign, err := prv.SignDigest(digest, rand.Reader)
 182         if err != nil {
 183                 t.FailNow()
 184         }
 185         valid, err := pub.VerifyDigest(digest, sign)
 186         if err != nil || !valid {
 187                 t.FailNow()
 188         }
 189 }