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