src/cypherpunks.ru/gogost/gost3410/2012_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 TestGCL3Vectors(t *testing.T) {
  27         p := []byte{
  28                 0x45, 0x31, 0xAC, 0xD1, 0xFE, 0x00, 0x23, 0xC7,
  29                 0x55, 0x0D, 0x26, 0x7B, 0x6B, 0x2F, 0xEE, 0x80,
  30                 0x92, 0x2B, 0x14, 0xB2, 0xFF, 0xB9, 0x0F, 0x04,
  31                 0xD4, 0xEB, 0x7C, 0x09, 0xB5, 0xD2, 0xD1, 0x5D,
  32                 0xF1, 0xD8, 0x52, 0x74, 0x1A, 0xF4, 0x70, 0x4A,
  33                 0x04, 0x58, 0x04, 0x7E, 0x80, 0xE4, 0x54, 0x6D,
  34                 0x35, 0xB8, 0x33, 0x6F, 0xAC, 0x22, 0x4D, 0xD8,
  35                 0x16, 0x64, 0xBB, 0xF5, 0x28, 0xBE, 0x63, 0x73,
  36         }
  37         q := []byte{
  38                 0x45, 0x31, 0xAC, 0xD1, 0xFE, 0x00, 0x23, 0xC7,
  39                 0x55, 0x0D, 0x26, 0x7B, 0x6B, 0x2F, 0xEE, 0x80,
  40                 0x92, 0x2B, 0x14, 0xB2, 0xFF, 0xB9, 0x0F, 0x04,
  41                 0xD4, 0xEB, 0x7C, 0x09, 0xB5, 0xD2, 0xD1, 0x5D,
  42                 0xA8, 0x2F, 0x2D, 0x7E, 0xCB, 0x1D, 0xBA, 0xC7,
  43                 0x19, 0x90, 0x5C, 0x5E, 0xEC, 0xC4, 0x23, 0xF1,
  44                 0xD8, 0x6E, 0x25, 0xED, 0xBE, 0x23, 0xC5, 0x95,
  45                 0xD6, 0x44, 0xAA, 0xF1, 0x87, 0xE6, 0xE6, 0xDF,
  46         }
  47         a := []byte{
  48                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  49                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  50                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  51                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  52                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  53                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  54                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  55                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
  56         }
  57         b := []byte{
  58                 0x1C, 0xFF, 0x08, 0x06, 0xA3, 0x11, 0x16, 0xDA,
  59                 0x29, 0xD8, 0xCF, 0xA5, 0x4E, 0x57, 0xEB, 0x74,
  60                 0x8B, 0xC5, 0xF3, 0x77, 0xE4, 0x94, 0x00, 0xFD,
  61                 0xD7, 0x88, 0xB6, 0x49, 0xEC, 0xA1, 0xAC, 0x43,
  62                 0x61, 0x83, 0x40, 0x13, 0xB2, 0xAD, 0x73, 0x22,
  63                 0x48, 0x0A, 0x89, 0xCA, 0x58, 0xE0, 0xCF, 0x74,
  64                 0xBC, 0x9E, 0x54, 0x0C, 0x2A, 0xDD, 0x68, 0x97,
  65                 0xFA, 0xD0, 0xA3, 0x08, 0x4F, 0x30, 0x2A, 0xDC,
  66         }
  67         x := []byte{
  68                 0x24, 0xD1, 0x9C, 0xC6, 0x45, 0x72, 0xEE, 0x30,
  69                 0xF3, 0x96, 0xBF, 0x6E, 0xBB, 0xFD, 0x7A, 0x6C,
  70                 0x52, 0x13, 0xB3, 0xB3, 0xD7, 0x05, 0x7C, 0xC8,
  71                 0x25, 0xF9, 0x10, 0x93, 0xA6, 0x8C, 0xD7, 0x62,
  72                 0xFD, 0x60, 0x61, 0x12, 0x62, 0xCD, 0x83, 0x8D,
  73                 0xC6, 0xB6, 0x0A, 0xA7, 0xEE, 0xE8, 0x04, 0xE2,
  74                 0x8B, 0xC8, 0x49, 0x97, 0x7F, 0xAC, 0x33, 0xB4,
  75                 0xB5, 0x30, 0xF1, 0xB1, 0x20, 0x24, 0x8A, 0x9A,
  76         }
  77         y := []byte{
  78                 0x2B, 0xB3, 0x12, 0xA4, 0x3B, 0xD2, 0xCE, 0x6E,
  79                 0x0D, 0x02, 0x06, 0x13, 0xC8, 0x57, 0xAC, 0xDD,
  80                 0xCF, 0xBF, 0x06, 0x1E, 0x91, 0xE5, 0xF2, 0xC3,
  81                 0xF3, 0x24, 0x47, 0xC2, 0x59, 0xF3, 0x9B, 0x2C,
  82                 0x83, 0xAB, 0x15, 0x6D, 0x77, 0xF1, 0x49, 0x6B,
  83                 0xF7, 0xEB, 0x33, 0x51, 0xE1, 0xEE, 0x4E, 0x43,
  84                 0xDC, 0x1A, 0x18, 0xB9, 0x1B, 0x24, 0x64, 0x0B,
  85                 0x6D, 0xBB, 0x92, 0xCB, 0x1A, 0xDD, 0x37, 0x1E,
  86         }
  87         priv := []byte{
  88                 0xD4, 0x8D, 0xA1, 0x1F, 0x82, 0x67, 0x29, 0xC6,
  89                 0xDF, 0xAA, 0x18, 0xFD, 0x7B, 0x6B, 0x63, 0xA2,
  90                 0x14, 0x27, 0x7E, 0x82, 0xD2, 0xDA, 0x22, 0x33,
  91                 0x56, 0xA0, 0x00, 0x22, 0x3B, 0x12, 0xE8, 0x72,
  92                 0x20, 0x10, 0x8B, 0x50, 0x8E, 0x50, 0xE7, 0x0E,
  93                 0x70, 0x69, 0x46, 0x51, 0xE8, 0xA0, 0x91, 0x30,
  94                 0xC9, 0xD7, 0x56, 0x77, 0xD4, 0x36, 0x09, 0xA4,
  95                 0x1B, 0x24, 0xAE, 0xAD, 0x8A, 0x04, 0xA6, 0x0B,
  96         }
  97         pubX := []byte{
  98                 0xE1, 0xEF, 0x30, 0xD5, 0x2C, 0x61, 0x33, 0xDD,
  99                 0xD9, 0x9D, 0x1D, 0x5C, 0x41, 0x45, 0x5C, 0xF7,
 100                 0xDF, 0x4D, 0x8B, 0x4C, 0x92, 0x5B, 0xBC, 0x69,
 101                 0xAF, 0x14, 0x33, 0xD1, 0x56, 0x58, 0x51, 0x5A,
 102                 0xDD, 0x21, 0x46, 0x85, 0x0C, 0x32, 0x5C, 0x5B,
 103                 0x81, 0xC1, 0x33, 0xBE, 0x65, 0x5A, 0xA8, 0xC4,
 104                 0xD4, 0x40, 0xE7, 0xB9, 0x8A, 0x8D, 0x59, 0x48,
 105                 0x7B, 0x0C, 0x76, 0x96, 0xBC, 0xC5, 0x5D, 0x11,
 106         }
 107         pubY := []byte{
 108                 0xEC, 0xBE, 0x77, 0x36, 0xA9, 0xEC, 0x35, 0x7F,
 109                 0xF2, 0xFD, 0x39, 0x93, 0x1F, 0x4E, 0x11, 0x4C,
 110                 0xB8, 0xCD, 0xA3, 0x59, 0x27, 0x0A, 0xC7, 0xF0,
 111                 0xE7, 0xFF, 0x43, 0xD9, 0x41, 0x94, 0x19, 0xEA,
 112                 0x61, 0xFD, 0x2A, 0xB7, 0x7F, 0x5D, 0x9F, 0x63,
 113                 0x52, 0x3D, 0x3B, 0x50, 0xA0, 0x4F, 0x63, 0xE2,
 114                 0xA0, 0xCF, 0x51, 0xB7, 0xC1, 0x3A, 0xDC, 0x21,
 115                 0x56, 0x0F, 0x0B, 0xD4, 0x0C, 0xC9, 0xC7, 0x37,
 116         }
 117         digest := []byte{
 118                 0x37, 0x54, 0xF3, 0xCF, 0xAC, 0xC9, 0xE0, 0x61,
 119                 0x5C, 0x4F, 0x4A, 0x7C, 0x4D, 0x8D, 0xAB, 0x53,
 120                 0x1B, 0x09, 0xB6, 0xF9, 0xC1, 0x70, 0xC5, 0x33,
 121                 0xA7, 0x1D, 0x14, 0x70, 0x35, 0xB0, 0xC5, 0x91,
 122                 0x71, 0x84, 0xEE, 0x53, 0x65, 0x93, 0xF4, 0x41,
 123                 0x43, 0x39, 0x97, 0x6C, 0x64, 0x7C, 0x5D, 0x5A,
 124                 0x40, 0x7A, 0xDE, 0xDB, 0x1D, 0x56, 0x0C, 0x4F,
 125                 0xC6, 0x77, 0x7D, 0x29, 0x72, 0x07, 0x5B, 0x8C,
 126         }
 127         signature := []byte{
 128                 0x10, 0x81, 0xB3, 0x94, 0x69, 0x6F, 0xFE, 0x8E,
 129                 0x65, 0x85, 0xE7, 0xA9, 0x36, 0x2D, 0x26, 0xB6,
 130                 0x32, 0x5F, 0x56, 0x77, 0x8A, 0xAD, 0xBC, 0x08,
 131                 0x1C, 0x0B, 0xFB, 0xE9, 0x33, 0xD5, 0x2F, 0xF5,
 132                 0x82, 0x3C, 0xE2, 0x88, 0xE8, 0xC4, 0xF3, 0x62,
 133                 0x52, 0x60, 0x80, 0xDF, 0x7F, 0x70, 0xCE, 0x40,
 134                 0x6A, 0x6E, 0xEB, 0x1F, 0x56, 0x91, 0x9C, 0xB9,
 135                 0x2A, 0x98, 0x53, 0xBD, 0xE7, 0x3E, 0x5B, 0x4A,
 136                 0x2F, 0x86, 0xFA, 0x60, 0xA0, 0x81, 0x09, 0x1A,
 137                 0x23, 0xDD, 0x79, 0x5E, 0x1E, 0x3C, 0x68, 0x9E,
 138                 0xE5, 0x12, 0xA3, 0xC8, 0x2E, 0xE0, 0xDC, 0xC2,
 139                 0x64, 0x3C, 0x78, 0xEE, 0xA8, 0xFC, 0xAC, 0xD3,
 140                 0x54, 0x92, 0x55, 0x84, 0x86, 0xB2, 0x0F, 0x1C,
 141                 0x9E, 0xC1, 0x97, 0xC9, 0x06, 0x99, 0x85, 0x02,
 142                 0x60, 0xC9, 0x3B, 0xCB, 0xCD, 0x9C, 0x5C, 0x33,
 143                 0x17, 0xE1, 0x93, 0x44, 0xE1, 0x73, 0xAE, 0x36,
 144         }
 145         c, err := NewCurve(
 146                 bytes2big(p),
 147                 bytes2big(q),
 148                 bytes2big(a),
 149                 bytes2big(b),
 150                 bytes2big(x),
 151                 bytes2big(y),
 152         )
 153         if err != nil {
 154                 t.FailNow()
 155         }
 156         prv, err := NewPrivateKey(c, Mode2012, priv)
 157         if err != nil {
 158                 t.FailNow()
 159         }
 160         pub, err := prv.PublicKey()
 161         if err != nil {
 162                 t.FailNow()
 163         }
 164         if bytes.Compare(pub.Raw()[:64], pubX) != 0 {
 165                 t.FailNow()
 166         }
 167         if bytes.Compare(pub.Raw()[64:], pubY) != 0 {
 168                 t.FailNow()
 169         }
 170         ourSign, err := prv.SignDigest(digest, rand.Reader)
 171         if err != nil {
 172                 t.FailNow()
 173         }
 174         valid, err := pub.VerifyDigest(digest, ourSign)
 175         if err != nil || !valid {
 176                 t.FailNow()
 177         }
 178         valid, err = pub.VerifyDigest(digest, signature)
 179         if err != nil || !valid {
 180                 t.FailNow()
 181         }
 182 }
 183
 184 func TestRandom2012(t *testing.T) {
 185         c := CurveIdtc26gost341012512paramSetA()
 186         f := func(prvRaw [64 - 1]byte, digest [64]byte) bool {
 187                 prv, err := NewPrivateKey(
 188                         c,
 189                         Mode2012,
 190                         append([]byte{0xde}, prvRaw[:]...),
 191                 )
 192                 if err != nil {
 193                         return false
 194                 }
 195                 pub, err := prv.PublicKey()
 196                 if err != nil {
 197                         return false
 198                 }
 199                 pubRaw := pub.Raw()
 200                 pub, err = NewPublicKey(c, Mode2012, pubRaw)
 201                 if err != nil {
 202                         return false
 203                 }
 204                 sign, err := prv.SignDigest(digest[:], rand.Reader)
 205                 if err != nil {
 206                         return false
 207                 }
 208                 valid, err := pub.VerifyDigest(digest[:], sign)
 209                 if err != nil {
 210                         return false
 211                 }
 212                 return valid
 213         }
 214         if err := quick.Check(f, nil); err != nil {
 215                 t.Error(err)
 216         }
 217 }
 218
 219 func BenchmarkSign2012(b *testing.B) {
 220         c := CurveIdtc26gost341012512paramSetA()
 221         prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
 222         if err != nil {
 223                 b.FailNow()
 224         }
 225         digest := make([]byte, 64)
 226         rand.Read(digest)
 227         b.ResetTimer()
 228         for i := 0; i < b.N; i++ {
 229                 prv.SignDigest(digest, rand.Reader)
 230         }
 231 }
 232
 233 func BenchmarkVerify2012(b *testing.B) {
 234         c := CurveIdtc26gost341012512paramSetA()
 235         prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
 236         if err != nil {
 237                 b.FailNow()
 238         }
 239         digest := make([]byte, 64)
 240         rand.Read(digest)
 241         sign, err := prv.SignDigest(digest, rand.Reader)
 242         if err != nil {
 243                 b.FailNow()
 244         }
 245         pub, err := prv.PublicKey()
 246         if err != nil {
 247                 b.FailNow()
 248         }
 249         b.ResetTimer()
 250         for i := 0; i < b.N; i++ {
 251                 pub.VerifyDigest(digest, sign)
 252         }
 253 }