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