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