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