gost341194/pbkdf2_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 gost341194
  17
  18 import (
  19         "bytes"
  20         "hash"
  21         "testing"
  22
  23         "go.cypherpunks.ru/gogost/v4/gost28147"
  24         "golang.org/x/crypto/pbkdf2"
  25 )
  26
  27 func PBKDF2Hash() hash.Hash {
  28         return New(&gost28147.SboxIdGostR341194CryptoProParamSet)
  29 }
  30
  31 // Test vectors for PBKDF2 taken from
  32 // http://tc26.ru/methods/containers_v1/Addition_to_PKCS5_v1_0.pdf test vectors
  33 func TestPBKDF2Vectors(t *testing.T) {
  34         t.Run("1", func(t *testing.T) {
  35                 if bytes.Compare(pbkdf2.Key(
  36                         []byte("password"),
  37                         []byte("salt"),
  38                         1,
  39                         32,
  40                         PBKDF2Hash,
  41                 ), []byte{
  42                         0x73, 0x14, 0xe7, 0xc0, 0x4f, 0xb2, 0xe6, 0x62,
  43                         0xc5, 0x43, 0x67, 0x42, 0x53, 0xf6, 0x8b, 0xd0,
  44                         0xb7, 0x34, 0x45, 0xd0, 0x7f, 0x24, 0x1b, 0xed,
  45                         0x87, 0x28, 0x82, 0xda, 0x21, 0x66, 0x2d, 0x58,
  46                 }) != 0 {
  47                         t.FailNow()
  48                 }
  49         })
  50
  51         t.Run("2", func(t *testing.T) {
  52                 if bytes.Compare(pbkdf2.Key(
  53                         []byte("password"),
  54                         []byte("salt"),
  55                         2,
  56                         32,
  57                         PBKDF2Hash,
  58                 ), []byte{
  59                         0x99, 0x0d, 0xfa, 0x2b, 0xd9, 0x65, 0x63, 0x9b,
  60                         0xa4, 0x8b, 0x07, 0xb7, 0x92, 0x77, 0x5d, 0xf7,
  61                         0x9f, 0x2d, 0xb3, 0x4f, 0xef, 0x25, 0xf2, 0x74,
  62                         0x37, 0x88, 0x72, 0xfe, 0xd7, 0xed, 0x1b, 0xb3,
  63                 }) != 0 {
  64                         t.FailNow()
  65                 }
  66         })
  67
  68         t.Run("4096", func(t *testing.T) {
  69                 if bytes.Compare(pbkdf2.Key(
  70                         []byte("password"),
  71                         []byte("salt"),
  72                         4096,
  73                         32,
  74                         PBKDF2Hash,
  75                 ), []byte{
  76                         0x1f, 0x18, 0x29, 0xa9, 0x4b, 0xdf, 0xf5, 0xbe,
  77                         0x10, 0xd0, 0xae, 0xb3, 0x6a, 0xf4, 0x98, 0xe7,
  78                         0xa9, 0x74, 0x67, 0xf3, 0xb3, 0x11, 0x16, 0xa5,
  79                         0xa7, 0xc1, 0xaf, 0xff, 0x9d, 0xea, 0xda, 0xfe,
  80                 }) != 0 {
  81                         t.FailNow()
  82                 }
  83         })
  84
  85         /*
  86                 t.Run("16777216", func(t *testing.T) {
  87                         if bytes.Compare(pbkdf2.Key(
  88                                 []byte("password"),
  89                                 []byte("salt"),
  90                                 16777216,
  91                                 32,
  92                                 PBKDF2Hash,
  93                         ), []byte{
  94                                 0xa5, 0x7a, 0xe5, 0xa6, 0x08, 0x83, 0x96, 0xd1,
  95                                 0x20, 0x85, 0x0c, 0x5c, 0x09, 0xde, 0x0a, 0x52,
  96                                 0x51, 0x00, 0x93, 0x8a, 0x59, 0xb1, 0xb5, 0xc3,
  97                                 0xf7, 0x81, 0x09, 0x10, 0xd0, 0x5f, 0xcd, 0x97,
  98                         }) != 0 {
  99                                 t.FailNow()
 100                         }
 101                 })
 102         */
 103
 104         t.Run("many", func(t *testing.T) {
 105                 if bytes.Compare(pbkdf2.Key(
 106                         []byte("passwordPASSWORDpassword"),
 107                         []byte("saltSALTsaltSALTsaltSALTsaltSALTsalt"),
 108                         4096,
 109                         40,
 110                         PBKDF2Hash,
 111                 ), []byte{
 112                         0x78, 0x83, 0x58, 0xc6, 0x9c, 0xb2, 0xdb, 0xe2,
 113                         0x51, 0xa7, 0xbb, 0x17, 0xd5, 0xf4, 0x24, 0x1f,
 114                         0x26, 0x5a, 0x79, 0x2a, 0x35, 0xbe, 0xcd, 0xe8,
 115                         0xd5, 0x6f, 0x32, 0x6b, 0x49, 0xc8, 0x50, 0x47,
 116                         0xb7, 0x63, 0x8a, 0xcb, 0x47, 0x64, 0xb1, 0xfd,
 117                 }) != 0 {
 118                         t.FailNow()
 119                 }
 120         })
 121
 122         t.Run("zero byte", func(t *testing.T) {
 123                 if bytes.Compare(pbkdf2.Key(
 124                         []byte("pass\x00word"),
 125                         []byte("sa\x00lt"),
 126                         4096,
 127                         20,
 128                         PBKDF2Hash,
 129                 ), []byte{
 130                         0x43, 0xe0, 0x6c, 0x55, 0x90, 0xb0, 0x8c, 0x02,
 131                         0x25, 0x24, 0x23, 0x73, 0x12, 0x7e, 0xdf, 0x9c,
 132                         0x8e, 0x9c, 0x32, 0x91,
 133                 }) != 0 {
 134                         t.FailNow()
 135                 }
 136         })
 137 }