src/cypherpunks.ru/gogost/gost34112012256/hkdf_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 gost34112012256
  18
  19 import (
  20         "bytes"
  21         "testing"
  22
  23         "golang.org/x/crypto/hkdf"
  24 )
  25
  26 func TestHKDF(t *testing.T) {
  27         t.Run("1", func(t *testing.T) {
  28                 ikm := []byte{
  29                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  30                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  31                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  32                 }
  33                 salt := []byte{
  34                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  35                         0x08, 0x09, 0x0a, 0x0b, 0x0c,
  36                 }
  37                 prk := hkdf.Extract(New, ikm, salt)
  38                 if bytes.Compare(prk, []byte{
  39                         0x94, 0x7d, 0x3d, 0x99, 0x2e, 0xdc, 0x44, 0xe3,
  40                         0x7b, 0x32, 0x72, 0x40, 0xf1, 0x5e, 0x62, 0x91,
  41                         0x3c, 0x0b, 0x91, 0xcc, 0x3e, 0x21, 0x43, 0xff,
  42                         0xe7, 0x72, 0x43, 0x6e, 0xc6, 0x3c, 0x99, 0xed,
  43                 }) != 0 {
  44                         t.Fatal("PRK differs")
  45                 }
  46                 info := []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9}
  47                 okm := make([]byte, 42)
  48                 if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
  49                         t.Fatal("HKDF-Expand failed")
  50                 }
  51                 if bytes.Compare(okm, []byte{
  52                         0x35, 0xf8, 0xf8, 0x03, 0x7a, 0xad, 0xf7, 0xaf,
  53                         0x3e, 0x4f, 0xc7, 0xbc, 0x8b, 0x93, 0xa9, 0x27,
  54                         0xd6, 0x85, 0xd4, 0x2f, 0x66, 0x28, 0xf9, 0xe6,
  55                         0x23, 0xc8, 0x5e, 0x19, 0x70, 0x09, 0x69, 0x2e,
  56                         0xae, 0xb1, 0x0b, 0x25, 0x26, 0x71, 0x2a, 0x7b,
  57                         0x49, 0xb7,
  58                 }) != 0 {
  59                         t.Fatal("OKM differs")
  60                 }
  61         })
  62         t.Run("2", func(t *testing.T) {
  63                 ikm := []byte{
  64                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  65                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  66                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  67                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  68                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  69                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  70                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  71                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  72                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  73                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  74                 }
  75                 salt := []byte{
  76                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  77                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  78                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  79                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
  80                         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  81                         0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  82                         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  83                         0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  84                         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  85                         0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  86                 }
  87                 prk := hkdf.Extract(New, ikm, salt)
  88                 if bytes.Compare(prk, []byte{
  89                         0xa2, 0xff, 0xcd, 0x64, 0x44, 0x45, 0xef, 0x94,
  90                         0x7e, 0x7e, 0xc9, 0xa8, 0x26, 0x89, 0x3d, 0x9a,
  91                         0x91, 0xfc, 0xe2, 0x65, 0xb0, 0xc2, 0xa9, 0x59,
  92                         0x6c, 0x59, 0xe1, 0x41, 0x53, 0x1d, 0x90, 0x77,
  93                 }) != 0 {
  94                         t.Fatal("PRK differs")
  95                 }
  96                 info := []byte{
  97                         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
  98                         0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  99                         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 100                         0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 101                         0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 102                         0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 103                         0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 104                         0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 105                         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 106                         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
 107                 }
 108                 okm := make([]byte, 82)
 109                 if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
 110                         t.Fatal("HKDF-Expand failed")
 111                 }
 112                 if bytes.Compare(okm, []byte{
 113                         0x28, 0x8c, 0x27, 0xff, 0xda, 0xf6, 0x4b, 0xe8,
 114                         0x24, 0xde, 0x84, 0x93, 0x48, 0x9d, 0x03, 0x12,
 115                         0x28, 0x07, 0xe9, 0x24, 0xaa, 0x6a, 0x09, 0x27,
 116                         0x01, 0x16, 0x9d, 0x2f, 0x66, 0x38, 0xc9, 0xd5,
 117                         0xc2, 0xbf, 0x09, 0xdb, 0x9f, 0xbe, 0x0b, 0x32,
 118                         0x88, 0x59, 0x7b, 0x67, 0x1d, 0xaf, 0x17, 0xed,
 119                         0x3e, 0x7d, 0xa5, 0x89, 0xdf, 0x69, 0xcc, 0x1d,
 120                         0xdc, 0xd8, 0x26, 0x2c, 0x1c, 0x6b, 0xe1, 0x4b,
 121                         0xc0, 0xb8, 0x5c, 0x4c, 0x2b, 0x24, 0xb6, 0xd8,
 122                         0xb4, 0x38, 0x18, 0xa1, 0xa5, 0xb0, 0x67, 0x53,
 123                         0xaf, 0x72,
 124                 }) != 0 {
 125                         t.Fatal("OKM differs")
 126                 }
 127         })
 128         t.Run("3", func(t *testing.T) {
 129                 ikm := []byte{
 130                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 131                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 132                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 133                 }
 134                 salt := []byte{}
 135                 prk := hkdf.Extract(New, ikm, salt)
 136                 if bytes.Compare(prk, []byte{
 137                         0x1f, 0xfc, 0x6d, 0x2b, 0xf9, 0x59, 0x4d, 0xfd,
 138                         0xf7, 0x75, 0xc2, 0xc1, 0x8f, 0xa3, 0xae, 0xcc,
 139                         0x92, 0xb6, 0xf9, 0xbc, 0x5c, 0xff, 0x0e, 0x08,
 140                         0x6f, 0x34, 0x0f, 0xab, 0x33, 0x6d, 0x86, 0x5f,
 141                 }) != 0 {
 142                         t.Fatal("PRK differs")
 143                 }
 144                 info := []byte{}
 145                 okm := make([]byte, 42)
 146                 if _, err := hkdf.Expand(New, prk, info).Read(okm); err != nil {
 147                         t.Fatal("HKDF-Expand failed")
 148                 }
 149                 if bytes.Compare(okm, []byte{
 150                         0x6a, 0xad, 0xb1, 0xa6, 0x48, 0x96, 0x2f, 0x0d,
 151                         0x96, 0x19, 0xcc, 0xdb, 0xf9, 0xd9, 0x2d, 0xc3,
 152                         0x54, 0x79, 0x73, 0x73, 0x3b, 0xc4, 0x06, 0x1d,
 153                         0x9f, 0xa5, 0x3e, 0xa8, 0x2a, 0x17, 0x35, 0xd7,
 154                         0xf3, 0xa4, 0x84, 0x6c, 0x76, 0xf9, 0x94, 0xb5,
 155                         0xdd, 0x03,
 156                 }) != 0 {
 157                         t.Fatal("OKM differs")
 158                 }
 159         })
 160 }