gost341194/hash_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, 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 gost341194
  17
  18 import (
  19         "bytes"
  20         "crypto/rand"
  21         "hash"
  22         "testing"
  23         "testing/quick"
  24
  25         "go.cypherpunks.ru/gogost/v4/gost28147"
  26 )
  27
  28 func TestHashInterface(t *testing.T) {
  29         h := New(SboxDefault)
  30         var _ hash.Hash = h
  31 }
  32
  33 func TestVectors(t *testing.T) {
  34         h := New(SboxDefault)
  35
  36         t.Run("empty", func(t *testing.T) {
  37                 if bytes.Compare(h.Sum(nil), []byte{
  38                         0xce, 0x85, 0xb9, 0x9c, 0xc4, 0x67, 0x52, 0xff,
  39                         0xfe, 0xe3, 0x5c, 0xab, 0x9a, 0x7b, 0x02, 0x78,
  40                         0xab, 0xb4, 0xc2, 0xd2, 0x05, 0x5c, 0xff, 0x68,
  41                         0x5a, 0xf4, 0x91, 0x2c, 0x49, 0x49, 0x0f, 0x8d,
  42                 }) != 0 {
  43                         t.FailNow()
  44                 }
  45         })
  46
  47         t.Run("a", func(t *testing.T) {
  48                 h.Reset()
  49                 h.Write([]byte("a"))
  50                 if bytes.Compare(h.Sum(nil), []byte{
  51                         0xd4, 0x2c, 0x53, 0x9e, 0x36, 0x7c, 0x66, 0xe9,
  52                         0xc8, 0x8a, 0x80, 0x1f, 0x66, 0x49, 0x34, 0x9c,
  53                         0x21, 0x87, 0x1b, 0x43, 0x44, 0xc6, 0xa5, 0x73,
  54                         0xf8, 0x49, 0xfd, 0xce, 0x62, 0xf3, 0x14, 0xdd,
  55                 }) != 0 {
  56                         t.FailNow()
  57                 }
  58         })
  59
  60         t.Run("abc", func(t *testing.T) {
  61                 h.Reset()
  62                 h.Write([]byte("abc"))
  63                 if bytes.Compare(h.Sum(nil), []byte{
  64                         0xf3, 0x13, 0x43, 0x48, 0xc4, 0x4f, 0xb1, 0xb2,
  65                         0xa2, 0x77, 0x72, 0x9e, 0x22, 0x85, 0xeb, 0xb5,
  66                         0xcb, 0x5e, 0x0f, 0x29, 0xc9, 0x75, 0xbc, 0x75,
  67                         0x3b, 0x70, 0x49, 0x7c, 0x06, 0xa4, 0xd5, 0x1d,
  68                 }) != 0 {
  69                         t.FailNow()
  70                 }
  71         })
  72
  73         t.Run("message digest", func(t *testing.T) {
  74                 h.Reset()
  75                 h.Write([]byte("message digest"))
  76                 if bytes.Compare(h.Sum(nil), []byte{
  77                         0xad, 0x44, 0x34, 0xec, 0xb1, 0x8f, 0x2c, 0x99,
  78                         0xb6, 0x0c, 0xbe, 0x59, 0xec, 0x3d, 0x24, 0x69,
  79                         0x58, 0x2b, 0x65, 0x27, 0x3f, 0x48, 0xde, 0x72,
  80                         0xdb, 0x2f, 0xde, 0x16, 0xa4, 0x88, 0x9a, 0x4d,
  81                 }) != 0 {
  82                         t.FailNow()
  83                 }
  84         })
  85
  86         t.Run("128U", func(t *testing.T) {
  87                 h.Reset()
  88                 for i := 0; i < 128; i++ {
  89                         h.Write([]byte("U"))
  90                 }
  91                 if bytes.Compare(h.Sum(nil), []byte{
  92                         0x53, 0xa3, 0xa3, 0xed, 0x25, 0x18, 0x0c, 0xef,
  93                         0x0c, 0x1d, 0x85, 0xa0, 0x74, 0x27, 0x3e, 0x55,
  94                         0x1c, 0x25, 0x66, 0x0a, 0x87, 0x06, 0x2a, 0x52,
  95                         0xd9, 0x26, 0xa9, 0xe8, 0xfe, 0x57, 0x33, 0xa4,
  96                 }) != 0 {
  97                         t.FailNow()
  98                 }
  99         })
 100
 101         t.Run("lazy dog", func(t *testing.T) {
 102                 h.Reset()
 103                 h.Write([]byte("The quick brown fox jumps over the lazy dog"))
 104                 if bytes.Compare(h.Sum(nil), []byte{
 105                         0x77, 0xb7, 0xfa, 0x41, 0x0c, 0x9a, 0xc5, 0x8a,
 106                         0x25, 0xf4, 0x9b, 0xca, 0x7d, 0x04, 0x68, 0xc9,
 107                         0x29, 0x65, 0x29, 0x31, 0x5e, 0xac, 0xa7, 0x6b,
 108                         0xd1, 0xa1, 0x0f, 0x37, 0x6d, 0x1f, 0x42, 0x94,
 109                 }) != 0 {
 110                         t.FailNow()
 111                 }
 112         })
 113
 114         t.Run("lazy cog", func(t *testing.T) {
 115                 h.Reset()
 116                 h.Write([]byte("The quick brown fox jumps over the lazy cog"))
 117                 if bytes.Compare(h.Sum(nil), []byte{
 118                         0xa3, 0xeb, 0xc4, 0xda, 0xaa, 0xb7, 0x8b, 0x0b,
 119                         0xe1, 0x31, 0xda, 0xb5, 0x73, 0x7a, 0x7f, 0x67,
 120                         0xe6, 0x02, 0x67, 0x0d, 0x54, 0x35, 0x21, 0x31,
 121                         0x91, 0x50, 0xd2, 0xe1, 0x4e, 0xee, 0xc4, 0x45,
 122                 }) != 0 {
 123                         t.FailNow()
 124                 }
 125         })
 126
 127         t.Run("32", func(t *testing.T) {
 128                 h.Reset()
 129                 h.Write([]byte("This is message, length=32 bytes"))
 130                 if bytes.Compare(h.Sum(nil), []byte{
 131                         0xb1, 0xc4, 0x66, 0xd3, 0x75, 0x19, 0xb8, 0x2e,
 132                         0x83, 0x19, 0x81, 0x9f, 0xf3, 0x25, 0x95, 0xe0,
 133                         0x47, 0xa2, 0x8c, 0xb6, 0xf8, 0x3e, 0xff, 0x1c,
 134                         0x69, 0x16, 0xa8, 0x15, 0xa6, 0x37, 0xff, 0xfa,
 135                 }) != 0 {
 136                         t.FailNow()
 137                 }
 138         })
 139
 140         t.Run("50", func(t *testing.T) {
 141                 h.Reset()
 142                 h.Write([]byte("Suppose the original message has length = 50 bytes"))
 143                 if bytes.Compare(h.Sum(nil), []byte{
 144                         0x47, 0x1a, 0xba, 0x57, 0xa6, 0x0a, 0x77, 0x0d,
 145                         0x3a, 0x76, 0x13, 0x06, 0x35, 0xc1, 0xfb, 0xea,
 146                         0x4e, 0xf1, 0x4d, 0xe5, 0x1f, 0x78, 0xb4, 0xae,
 147                         0x57, 0xdd, 0x89, 0x3b, 0x62, 0xf5, 0x52, 0x08,
 148                 }) != 0 {
 149                         t.FailNow()
 150                 }
 151         })
 152 }
 153
 154 func TestVectorsCryptoPro(t *testing.T) {
 155         h := New(&gost28147.SboxIdGostR341194CryptoProParamSet)
 156
 157         t.Run("empty", func(t *testing.T) {
 158                 if bytes.Compare(h.Sum(nil), []byte{
 159                         0x98, 0x1e, 0x5f, 0x3c, 0xa3, 0x0c, 0x84, 0x14,
 160                         0x87, 0x83, 0x0f, 0x84, 0xfb, 0x43, 0x3e, 0x13,
 161                         0xac, 0x11, 0x01, 0x56, 0x9b, 0x9c, 0x13, 0x58,
 162                         0x4a, 0xc4, 0x83, 0x23, 0x4c, 0xd6, 0x56, 0xc0,
 163                 }) != 0 {
 164                         t.FailNow()
 165                 }
 166         })
 167
 168         t.Run("a", func(t *testing.T) {
 169                 h.Reset()
 170                 h.Write([]byte("a"))
 171                 if bytes.Compare(h.Sum(nil), []byte{
 172                         0xe7, 0x4c, 0x52, 0xdd, 0x28, 0x21, 0x83, 0xbf,
 173                         0x37, 0xaf, 0x00, 0x79, 0xc9, 0xf7, 0x80, 0x55,
 174                         0x71, 0x5a, 0x10, 0x3f, 0x17, 0xe3, 0x13, 0x3c,
 175                         0xef, 0xf1, 0xaa, 0xcf, 0x2f, 0x40, 0x30, 0x11,
 176                 }) != 0 {
 177                         t.FailNow()
 178                 }
 179         })
 180
 181         t.Run("abc", func(t *testing.T) {
 182                 h.Reset()
 183                 h.Write([]byte("abc"))
 184                 if bytes.Compare(h.Sum(nil), []byte{
 185                         0xb2, 0x85, 0x05, 0x6d, 0xbf, 0x18, 0xd7, 0x39,
 186                         0x2d, 0x76, 0x77, 0x36, 0x95, 0x24, 0xdd, 0x14,
 187                         0x74, 0x74, 0x59, 0xed, 0x81, 0x43, 0x99, 0x7e,
 188                         0x16, 0x3b, 0x29, 0x86, 0xf9, 0x2f, 0xd4, 0x2c,
 189                 }) != 0 {
 190                         t.FailNow()
 191                 }
 192         })
 193
 194         t.Run("message digest", func(t *testing.T) {
 195                 h.Reset()
 196                 h.Write([]byte("message digest"))
 197                 if bytes.Compare(h.Sum(nil), []byte{
 198                         0xbc, 0x60, 0x41, 0xdd, 0x2a, 0xa4, 0x01, 0xeb,
 199                         0xfa, 0x6e, 0x98, 0x86, 0x73, 0x41, 0x74, 0xfe,
 200                         0xbd, 0xb4, 0x72, 0x9a, 0xa9, 0x72, 0xd6, 0x0f,
 201                         0x54, 0x9a, 0xc3, 0x9b, 0x29, 0x72, 0x1b, 0xa0,
 202                 }) != 0 {
 203                         t.FailNow()
 204                 }
 205         })
 206
 207         t.Run("lazy dog", func(t *testing.T) {
 208                 h.Reset()
 209                 h.Write([]byte("The quick brown fox jumps over the lazy dog"))
 210                 if bytes.Compare(h.Sum(nil), []byte{
 211                         0x90, 0x04, 0x29, 0x4a, 0x36, 0x1a, 0x50, 0x8c,
 212                         0x58, 0x6f, 0xe5, 0x3d, 0x1f, 0x1b, 0x02, 0x74,
 213                         0x67, 0x65, 0xe7, 0x1b, 0x76, 0x54, 0x72, 0x78,
 214                         0x6e, 0x47, 0x70, 0xd5, 0x65, 0x83, 0x0a, 0x76,
 215                 }) != 0 {
 216                         t.FailNow()
 217                 }
 218         })
 219
 220         t.Run("32", func(t *testing.T) {
 221                 h.Reset()
 222                 h.Write([]byte("This is message, length=32 bytes"))
 223                 if bytes.Compare(h.Sum(nil), []byte{
 224                         0x2c, 0xef, 0xc2, 0xf7, 0xb7, 0xbd, 0xc5, 0x14,
 225                         0xe1, 0x8e, 0xa5, 0x7f, 0xa7, 0x4f, 0xf3, 0x57,
 226                         0xe7, 0xfa, 0x17, 0xd6, 0x52, 0xc7, 0x5f, 0x69,
 227                         0xcb, 0x1b, 0xe7, 0x89, 0x3e, 0xde, 0x48, 0xeb,
 228                 }) != 0 {
 229                         t.FailNow()
 230                 }
 231         })
 232
 233         t.Run("50", func(t *testing.T) {
 234                 h.Reset()
 235                 h.Write([]byte("Suppose the original message has length = 50 bytes"))
 236                 if bytes.Compare(h.Sum(nil), []byte{
 237                         0xc3, 0x73, 0x0c, 0x5c, 0xbc, 0xca, 0xcf, 0x91,
 238                         0x5a, 0xc2, 0x92, 0x67, 0x6f, 0x21, 0xe8, 0xbd,
 239                         0x4e, 0xf7, 0x53, 0x31, 0xd9, 0x40, 0x5e, 0x5f,
 240                         0x1a, 0x61, 0xdc, 0x31, 0x30, 0xa6, 0x50, 0x11,
 241                 }) != 0 {
 242                         t.FailNow()
 243                 }
 244         })
 245
 246         t.Run("128U", func(t *testing.T) {
 247                 h.Reset()
 248                 for i := 0; i < 128; i++ {
 249                         h.Write([]byte{'U'})
 250                 }
 251                 if bytes.Compare(h.Sum(nil), []byte{
 252                         0x1c, 0x4a, 0xc7, 0x61, 0x46, 0x91, 0xbb, 0xf4,
 253                         0x27, 0xfa, 0x23, 0x16, 0x21, 0x6b, 0xe8, 0xf1,
 254                         0x0d, 0x92, 0xed, 0xfd, 0x37, 0xcd, 0x10, 0x27,
 255                         0x51, 0x4c, 0x10, 0x08, 0xf6, 0x49, 0xc4, 0xe8,
 256                 }) != 0 {
 257                         t.FailNow()
 258                 }
 259         })
 260 }
 261
 262 func TestRandom(t *testing.T) {
 263         h := New(SboxDefault)
 264         f := func(data []byte) bool {
 265                 h.Reset()
 266                 h.Write(data)
 267                 d1 := h.Sum(nil)
 268                 h.Reset()
 269                 for _, c := range data {
 270                         h.Write([]byte{c})
 271                 }
 272                 d2 := h.Sum(nil)
 273                 return bytes.Compare(d1, d2) == 0
 274         }
 275         if err := quick.Check(f, nil); err != nil {
 276                 t.Error(err)
 277         }
 278 }
 279
 280 func BenchmarkHash(b *testing.B) {
 281         h := New(SboxDefault)
 282         src := make([]byte, BlockSize+1)
 283         rand.Read(src)
 284         b.ResetTimer()
 285         for i := 0; i < b.N; i++ {
 286                 h.Write(src)
 287                 h.Sum(nil)
 288         }
 289 }