src/cypherpunks.ru/gogost/internal/gost34112012/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 gost34112012
  18
  19 import (
  20         "bytes"
  21         "crypto/rand"
  22         "encoding"
  23         "hash"
  24         "testing"
  25         "testing/quick"
  26 )
  27
  28 func TestHashInterface(t *testing.T) {
  29         h := New(64)
  30         var _ hash.Hash = h
  31         var _ encoding.BinaryMarshaler = h
  32         var _ encoding.BinaryUnmarshaler = h
  33 }
  34
  35 func TestVectors(t *testing.T) {
  36         h512 := New(64)
  37         h256 := New(32)
  38
  39         t.Run("1", func(t *testing.T) {
  40                 m := []byte{
  41                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  42                         0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
  43                         0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33,
  44                         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31,
  45                         0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  46                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  47                         0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
  48                         0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32,
  49                 }
  50                 h512.Write(m)
  51                 if bytes.Compare(h512.Sum(nil), []byte{
  52                         0x1b, 0x54, 0xd0, 0x1a, 0x4a, 0xf5, 0xb9, 0xd5,
  53                         0xcc, 0x3d, 0x86, 0xd6, 0x8d, 0x28, 0x54, 0x62,
  54                         0xb1, 0x9a, 0xbc, 0x24, 0x75, 0x22, 0x2f, 0x35,
  55                         0xc0, 0x85, 0x12, 0x2b, 0xe4, 0xba, 0x1f, 0xfa,
  56                         0x00, 0xad, 0x30, 0xf8, 0x76, 0x7b, 0x3a, 0x82,
  57                         0x38, 0x4c, 0x65, 0x74, 0xf0, 0x24, 0xc3, 0x11,
  58                         0xe2, 0xa4, 0x81, 0x33, 0x2b, 0x08, 0xef, 0x7f,
  59                         0x41, 0x79, 0x78, 0x91, 0xc1, 0x64, 0x6f, 0x48,
  60                 }) != 0 {
  61                         t.FailNow()
  62                 }
  63                 h256.Write(m)
  64                 if bytes.Compare(h256.Sum(nil), []byte{
  65                         0x9d, 0x15, 0x1e, 0xef, 0xd8, 0x59, 0x0b, 0x89,
  66                         0xda, 0xa6, 0xba, 0x6c, 0xb7, 0x4a, 0xf9, 0x27,
  67                         0x5d, 0xd0, 0x51, 0x02, 0x6b, 0xb1, 0x49, 0xa4,
  68                         0x52, 0xfd, 0x84, 0xe5, 0xe5, 0x7b, 0x55, 0x00,
  69                 }) != 0 {
  70                         t.FailNow()
  71                 }
  72         })
  73
  74         t.Run("Се ветри", func(t *testing.T) {
  75                 // It is CP1251-encoded "Се ветри, Стрибожи внуци, веютъ с моря
  76                 // стрелами на храбрыя плъкы Игоревы" string
  77                 h512.Reset()
  78                 h256.Reset()
  79                 m := []byte{
  80                         0xd1, 0xe5, 0x20, 0xe2, 0xe5, 0xf2, 0xf0, 0xe8,
  81                         0x2c, 0x20, 0xd1, 0xf2, 0xf0, 0xe8, 0xe1, 0xee,
  82                         0xe6, 0xe8, 0x20, 0xe2, 0xed, 0xf3, 0xf6, 0xe8,
  83                         0x2c, 0x20, 0xe2, 0xe5, 0xfe, 0xf2, 0xfa, 0x20,
  84                         0xf1, 0x20, 0xec, 0xee, 0xf0, 0xff, 0x20, 0xf1,
  85                         0xf2, 0xf0, 0xe5, 0xeb, 0xe0, 0xec, 0xe8, 0x20,
  86                         0xed, 0xe0, 0x20, 0xf5, 0xf0, 0xe0, 0xe1, 0xf0,
  87                         0xfb, 0xff, 0x20, 0xef, 0xeb, 0xfa, 0xea, 0xfb,
  88                         0x20, 0xc8, 0xe3, 0xee, 0xf0, 0xe5, 0xe2, 0xfb,
  89                 }
  90                 h512.Write(m)
  91                 if bytes.Compare(h512.Sum(nil), []byte{
  92                         0x1e, 0x88, 0xe6, 0x22, 0x26, 0xbf, 0xca, 0x6f,
  93                         0x99, 0x94, 0xf1, 0xf2, 0xd5, 0x15, 0x69, 0xe0,
  94                         0xda, 0xf8, 0x47, 0x5a, 0x3b, 0x0f, 0xe6, 0x1a,
  95                         0x53, 0x00, 0xee, 0xe4, 0x6d, 0x96, 0x13, 0x76,
  96                         0x03, 0x5f, 0xe8, 0x35, 0x49, 0xad, 0xa2, 0xb8,
  97                         0x62, 0x0f, 0xcd, 0x7c, 0x49, 0x6c, 0xe5, 0xb3,
  98                         0x3f, 0x0c, 0xb9, 0xdd, 0xdc, 0x2b, 0x64, 0x60,
  99                         0x14, 0x3b, 0x03, 0xda, 0xba, 0xc9, 0xfb, 0x28,
 100                 }) != 0 {
 101                         t.FailNow()
 102                 }
 103                 h256.Write(m)
 104                 if bytes.Compare(h256.Sum(nil), []byte{
 105                         0x9d, 0xd2, 0xfe, 0x4e, 0x90, 0x40, 0x9e, 0x5d,
 106                         0xa8, 0x7f, 0x53, 0x97, 0x6d, 0x74, 0x05, 0xb0,
 107                         0xc0, 0xca, 0xc6, 0x28, 0xfc, 0x66, 0x9a, 0x74,
 108                         0x1d, 0x50, 0x06, 0x3c, 0x55, 0x7e, 0x8f, 0x50,
 109                 }) != 0 {
 110                         t.FailNow()
 111                 }
 112         })
 113
 114         t.Run("https://habr.com/ru/post/450024/", func(t *testing.T) {
 115                 h256.Reset()
 116                 m := []byte{
 117                         0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1,
 118                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 119                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 120                         0x3e, 0x00, 0x03, 0x00, 0xfe, 0xff, 0x09, 0x00,
 121                         0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 122                         0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 123                         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 124                         0x00, 0x10, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
 125                         0x01, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff,
 126                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 127                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 128                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 129                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 130                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 131                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 132                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 133                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 134                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 135                 }
 136                 h256.Write(m)
 137                 if bytes.Compare(h256.Sum(nil), []byte{
 138                         0xc7, 0x66, 0x08, 0x55, 0x40, 0xca, 0xaa, 0x89,
 139                         0x53, 0xbf, 0xcf, 0x7a, 0x1b, 0xa2, 0x20, 0x61,
 140                         0x9c, 0xee, 0x50, 0xd6, 0x5d, 0xc2, 0x42, 0xf8,
 141                         0x2f, 0x23, 0xba, 0x4b, 0x18, 0x0b, 0x18, 0xe0,
 142                 }) != 0 {
 143                         t.FailNow()
 144                 }
 145         })
 146 }
 147
 148 func TestBlocksized(t *testing.T) {
 149         h := New(64)
 150         m := make([]byte, BlockSize)
 151         for i := 0; i < BlockSize; i++ {
 152                 m[i] = byte(i)
 153         }
 154         h.Write(m)
 155         if bytes.Compare(h.Sum(nil), []byte{
 156                 0x2a, 0xe5, 0x81, 0xf1, 0x8a, 0xe8, 0x5e, 0x35,
 157                 0x96, 0xc9, 0x36, 0xac, 0xbe, 0xf9, 0x10, 0xf2,
 158                 0xed, 0x70, 0xdc, 0xf9, 0x1e, 0xd5, 0xd2, 0x4b,
 159                 0x39, 0xa5, 0xaf, 0x65, 0x7b, 0xf8, 0x23, 0x2a,
 160                 0x30, 0x3d, 0x68, 0x60, 0x56, 0xc8, 0xc0, 0x0b,
 161                 0xf3, 0x0d, 0x42, 0xe1, 0x6c, 0xe2, 0x55, 0x42,
 162                 0x6f, 0xa8, 0xa1, 0x55, 0xdc, 0xb3, 0xeb, 0x82,
 163                 0x2d, 0x92, 0x58, 0x08, 0xf7, 0xc7, 0xe3, 0x45,
 164         }) != 0 {
 165                 t.FailNow()
 166         }
 167 }
 168
 169 func TestBehaviour(t *testing.T) {
 170         h := New(64)
 171         // Sum does not change the state
 172         hsh1 := h.Sum(nil)
 173         if bytes.Compare(h.Sum(nil), hsh1) != 0 {
 174                 t.FailNow()
 175         }
 176         // No data equals to no state changing
 177         h.Write([]byte{})
 178         if bytes.Compare(h.Sum(nil), hsh1) != 0 {
 179                 t.FailNow()
 180         }
 181         // Just to be sure
 182         h.Write([]byte{})
 183         if bytes.Compare(h.Sum(nil), hsh1) != 0 {
 184                 t.FailNow()
 185         }
 186 }
 187
 188 func TestRandom(t *testing.T) {
 189         h := New(64)
 190         f := func(data []byte) bool {
 191                 h.Reset()
 192                 h.Write(data)
 193                 d1 := h.Sum(nil)
 194                 h1Raw, err := h.MarshalBinary()
 195                 if err != nil {
 196                         return false
 197                 }
 198                 h.Reset()
 199                 for _, c := range data {
 200                         h.Write([]byte{c})
 201                 }
 202                 d2 := h.Sum(nil)
 203                 if bytes.Compare(d1, d2) != 0 {
 204                         return false
 205                 }
 206                 h2Raw, err := h.MarshalBinary()
 207                 if err != nil {
 208                         return false
 209                 }
 210                 if bytes.Compare(h1Raw, h2Raw) != 0 {
 211                         return false
 212                 }
 213                 hNew := New(64)
 214                 if err = hNew.UnmarshalBinary(h1Raw); err != nil {
 215                         return false
 216                 }
 217                 return bytes.Compare(hNew.Sum(nil), d1) == 0
 218         }
 219         if err := quick.Check(f, nil); err != nil {
 220                 t.Error(err)
 221         }
 222 }
 223
 224 func BenchmarkHash(b *testing.B) {
 225         h := New(64)
 226         src := make([]byte, BlockSize+1)
 227         rand.Read(src)
 228         b.ResetTimer()
 229         for i := 0; i < b.N; i++ {
 230                 h.Write(src)
 231                 h.Sum(nil)
 232         }
 233 }