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(p, q, a, b, x, y)
 146         if err != nil {
 147                 t.FailNow()
 148         }
 149         prv, err := NewPrivateKey(c, Mode2012, priv)
 150         if err != nil {
 151                 t.FailNow()
 152         }
 153         pub, err := prv.PublicKey()
 154         if err != nil {
 155                 t.FailNow()
 156         }
 157         if bytes.Compare(pub.Raw()[:64], pubX) != 0 {
 158                 t.FailNow()
 159         }
 160         if bytes.Compare(pub.Raw()[64:], pubY) != 0 {
 161                 t.FailNow()
 162         }
 163         ourSign, err := prv.SignDigest(digest, rand.Reader)
 164         if err != nil {
 165                 t.FailNow()
 166         }
 167         valid, err := pub.VerifyDigest(digest, ourSign)
 168         if err != nil || !valid {
 169                 t.FailNow()
 170         }
 171         valid, err = pub.VerifyDigest(digest, signature)
 172         if err != nil || !valid {
 173                 t.FailNow()
 174         }
 175 }
 176
 177 func TestRandom2012(t *testing.T) {
 178         c := CurveIdtc26gost341012512paramSetA()
 179         f := func(prvRaw [64 - 1]byte, digest [64]byte) bool {
 180                 prv, err := NewPrivateKey(
 181                         c,
 182                         Mode2012,
 183                         append([]byte{0xde}, prvRaw[:]...),
 184                 )
 185                 if err != nil {
 186                         return false
 187                 }
 188                 pub, err := prv.PublicKey()
 189                 if err != nil {
 190                         return false
 191                 }
 192                 pubRaw := pub.Raw()
 193                 pub, err = NewPublicKey(c, Mode2012, pubRaw)
 194                 if err != nil {
 195                         return false
 196                 }
 197                 sign, err := prv.SignDigest(digest[:], rand.Reader)
 198                 if err != nil {
 199                         return false
 200                 }
 201                 valid, err := pub.VerifyDigest(digest[:], sign)
 202                 if err != nil {
 203                         return false
 204                 }
 205                 return valid
 206         }
 207         if err := quick.Check(f, nil); err != nil {
 208                 t.Error(err)
 209         }
 210 }
 211
 212 func BenchmarkSign2012(b *testing.B) {
 213         c := CurveIdtc26gost341012512paramSetA()
 214         prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
 215         if err != nil {
 216                 b.FailNow()
 217         }
 218         digest := make([]byte, 64)
 219         rand.Read(digest)
 220         b.ResetTimer()
 221         for i := 0; i < b.N; i++ {
 222                 prv.SignDigest(digest, rand.Reader)
 223         }
 224 }
 225
 226 func BenchmarkVerify2012(b *testing.B) {
 227         c := CurveIdtc26gost341012512paramSetA()
 228         prv, err := GenPrivateKey(c, Mode2012, rand.Reader)
 229         if err != nil {
 230                 b.FailNow()
 231         }
 232         digest := make([]byte, 64)
 233         rand.Read(digest)
 234         sign, err := prv.SignDigest(digest, rand.Reader)
 235         if err != nil {
 236                 b.FailNow()
 237         }
 238         pub, err := prv.PublicKey()
 239         if err != nil {
 240                 b.FailNow()
 241         }
 242         b.ResetTimer()
 243         for i := 0; i < b.N; i++ {
 244                 pub.VerifyDigest(digest, sign)
 245         }
 246 }