gost3410/2001_test.go

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