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

   1 // GoGOST -- Pure Go GOST cryptographic functions library
   2 // Copyright (C) 2015-2016 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, DigestSize2001, 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                         DigestSize2001,
 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, DigestSize2001, 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, DigestSize2001, 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, DigestSize2001, 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 }