src/crypto/hmac/hmac_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package hmac
   6
   7 import (
   8         "bytes"
   9         "crypto/md5"
  10         "crypto/sha1"
  11         "crypto/sha256"
  12         "crypto/sha512"
  13         "fmt"
  14         "hash"
  15         "testing"
  16 )
  17
  18 type hmacTest struct {
  19         hash      func() hash.Hash
  20         key       []byte
  21         in        []byte
  22         out       string
  23         size      int
  24         blocksize int
  25 }
  26
  27 var hmacTests = []hmacTest{
  28         // Tests from US FIPS 198
  29         // https://csrc.nist.gov/publications/fips/fips198/fips-198a.pdf
  30         {
  31                 sha1.New,
  32                 []byte{
  33                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  34                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  35                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  36                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  37                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  38                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  39                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  40                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  41                 },
  42                 []byte("Sample #1"),
  43                 "4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a",
  44                 sha1.Size,
  45                 sha1.BlockSize,
  46         },
  47         {
  48                 sha1.New,
  49                 []byte{
  50                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  51                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  52                         0x40, 0x41, 0x42, 0x43,
  53                 },
  54                 []byte("Sample #2"),
  55                 "0922d3405faa3d194f82a45830737d5cc6c75d24",
  56                 sha1.Size,
  57                 sha1.BlockSize,
  58         },
  59         {
  60                 sha1.New,
  61                 []byte{
  62                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
  63                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  64                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  65                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  66                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  67                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
  68                         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  69                         0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  70                         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  71                         0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  72                         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  73                         0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  74                         0xb0, 0xb1, 0xb2, 0xb3,
  75                 },
  76                 []byte("Sample #3"),
  77                 "bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa",
  78                 sha1.Size,
  79                 sha1.BlockSize,
  80         },
  81
  82         // Test from Plan 9.
  83         {
  84                 md5.New,
  85                 []byte("Jefe"),
  86                 []byte("what do ya want for nothing?"),
  87                 "750c783e6ab0b503eaa86e310a5db738",
  88                 md5.Size,
  89                 md5.BlockSize,
  90         },
  91
  92         // Tests from RFC 4231
  93         {
  94                 sha256.New,
  95                 []byte{
  96                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  97                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  98                         0x0b, 0x0b, 0x0b, 0x0b,
  99                 },
 100                 []byte("Hi There"),
 101                 "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
 102                 sha256.Size,
 103                 sha256.BlockSize,
 104         },
 105         {
 106                 sha256.New,
 107                 []byte("Jefe"),
 108                 []byte("what do ya want for nothing?"),
 109                 "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
 110                 sha256.Size,
 111                 sha256.BlockSize,
 112         },
 113         {
 114                 sha256.New,
 115                 []byte{
 116                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 117                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 118                         0xaa, 0xaa, 0xaa, 0xaa,
 119                 },
 120                 []byte{
 121                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 122                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 123                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 124                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 125                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 126                         0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 127                         0xdd, 0xdd,
 128                 },
 129                 "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
 130                 sha256.Size,
 131                 sha256.BlockSize,
 132         },
 133         {
 134                 sha256.New,
 135                 []byte{
 136                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 137                         0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 138                         0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
 139                         0x19,
 140                 },
 141                 []byte{
 142                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 143                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 144                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 145                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 146                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 147                         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 148                         0xcd, 0xcd,
 149                 },
 150                 "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
 151                 sha256.Size,
 152                 sha256.BlockSize,
 153         },
 154         {
 155                 sha256.New,
 156                 []byte{
 157                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 158                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 159                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 160                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 161                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 162                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 163                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 164                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 165                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 166                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 167                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 168                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 169                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 170                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 171                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 172                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 173                         0xaa, 0xaa, 0xaa,
 174                 },
 175                 []byte("Test Using Larger Than Block-Size Key - Hash Key First"),
 176                 "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
 177                 sha256.Size,
 178                 sha256.BlockSize,
 179         },
 180         {
 181                 sha256.New,
 182                 []byte{
 183                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 184                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 185                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 186                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 187                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 188                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 189                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 190                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 191                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 192                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 193                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 194                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 195                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 196                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 197                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 198                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 199                         0xaa, 0xaa, 0xaa,
 200                 },
 201                 []byte("This is a test using a larger than block-size key " +
 202                         "and a larger than block-size data. The key needs to " +
 203                         "be hashed before being used by the HMAC algorithm."),
 204                 "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
 205                 sha256.Size,
 206                 sha256.BlockSize,
 207         },
 208
 209         // Tests from https://csrc.nist.gov/groups/ST/toolkit/examples.html
 210         // (truncated tag tests are left out)
 211         {
 212                 sha1.New,
 213                 []byte{
 214                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 215                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 216                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 217                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 218                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 219                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 220                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 221                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 222                 },
 223                 []byte("Sample message for keylen=blocklen"),
 224                 "5fd596ee78d5553c8ff4e72d266dfd192366da29",
 225                 sha1.Size,
 226                 sha1.BlockSize,
 227         },
 228         {
 229                 sha1.New,
 230                 []byte{
 231                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 232                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 233                         0x10, 0x11, 0x12, 0x13,
 234                 },
 235                 []byte("Sample message for keylen<blocklen"),
 236                 "4c99ff0cb1b31bd33f8431dbaf4d17fcd356a807",
 237                 sha1.Size,
 238                 sha1.BlockSize,
 239         },
 240         {
 241                 sha1.New,
 242                 []byte{
 243                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 244                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 245                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 246                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 247                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 248                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 249                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 250                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 251                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 252                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 253                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 254                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 255                         0x60, 0x61, 0x62, 0x63,
 256                 },
 257                 []byte("Sample message for keylen=blocklen"),
 258                 "2d51b2f7750e410584662e38f133435f4c4fd42a",
 259                 sha1.Size,
 260                 sha1.BlockSize,
 261         },
 262         {
 263                 sha256.New224,
 264                 []byte{
 265                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 266                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 267                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 268                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 269                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 270                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 271                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 272                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 273                 },
 274                 []byte("Sample message for keylen=blocklen"),
 275                 "c7405e3ae058e8cd30b08b4140248581ed174cb34e1224bcc1efc81b",
 276                 sha256.Size224,
 277                 sha256.BlockSize,
 278         },
 279         {
 280                 sha256.New224,
 281                 []byte{
 282                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 283                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 284                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 285                         0x18, 0x19, 0x1a, 0x1b,
 286                 },
 287                 []byte("Sample message for keylen<blocklen"),
 288                 "e3d249a8cfb67ef8b7a169e9a0a599714a2cecba65999a51beb8fbbe",
 289                 sha256.Size224,
 290                 sha256.BlockSize,
 291         },
 292         {
 293                 sha256.New224,
 294                 []byte{
 295                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 296                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 297                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 298                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 299                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 300                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 301                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 302                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 303                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 304                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 305                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 306                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 307                         0x60, 0x61, 0x62, 0x63,
 308                 },
 309                 []byte("Sample message for keylen=blocklen"),
 310                 "91c52509e5af8531601ae6230099d90bef88aaefb961f4080abc014d",
 311                 sha256.Size224,
 312                 sha256.BlockSize,
 313         },
 314         {
 315                 sha256.New,
 316                 []byte{
 317                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 318                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 319                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 320                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 321                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 322                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 323                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 324                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 325                 },
 326                 []byte("Sample message for keylen=blocklen"),
 327                 "8bb9a1db9806f20df7f77b82138c7914d174d59e13dc4d0169c9057b133e1d62",
 328                 sha256.Size,
 329                 sha256.BlockSize,
 330         },
 331         {
 332                 sha256.New,
 333                 []byte{
 334                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 335                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 336                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 337                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 338                 },
 339                 []byte("Sample message for keylen<blocklen"),
 340                 "a28cf43130ee696a98f14a37678b56bcfcbdd9e5cf69717fecf5480f0ebdf790",
 341                 sha256.Size,
 342                 sha256.BlockSize,
 343         },
 344         {
 345                 sha256.New,
 346                 []byte{
 347                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 348                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 349                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 350                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 351                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 352                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 353                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 354                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 355                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 356                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 357                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 358                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 359                         0x60, 0x61, 0x62, 0x63,
 360                 },
 361                 []byte("Sample message for keylen=blocklen"),
 362                 "bdccb6c72ddeadb500ae768386cb38cc41c63dbb0878ddb9c7a38a431b78378d",
 363                 sha256.Size,
 364                 sha256.BlockSize,
 365         },
 366         {
 367                 sha512.New384,
 368                 []byte{
 369                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 370                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 371                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 372                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 373                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 374                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 375                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 376                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 377                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 378                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 379                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 380                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 381                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 382                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 383                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 384                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 385                 },
 386                 []byte("Sample message for keylen=blocklen"),
 387                 "63c5daa5e651847ca897c95814ab830bededc7d25e83eef9195cd45857a37f448947858f5af50cc2b1b730ddf29671a9",
 388                 sha512.Size384,
 389                 sha512.BlockSize,
 390         },
 391         {
 392                 sha512.New384,
 393                 []byte{
 394                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 395                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 396                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 397                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 398                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 399                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 400                 },
 401                 []byte("Sample message for keylen<blocklen"),
 402                 "6eb242bdbb582ca17bebfa481b1e23211464d2b7f8c20b9ff2201637b93646af5ae9ac316e98db45d9cae773675eeed0",
 403                 sha512.Size384,
 404                 sha512.BlockSize,
 405         },
 406         {
 407                 sha512.New384,
 408                 []byte{
 409                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 410                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 411                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 412                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 413                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 414                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 415                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 416                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 417                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 418                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 419                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 420                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 421                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 422                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 423                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 424                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 425                         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 426                         0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 427                         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 428                         0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 429                         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 430                         0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 431                         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
 432                         0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 433                         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 434                 },
 435                 []byte("Sample message for keylen=blocklen"),
 436                 "5b664436df69b0ca22551231a3f0a3d5b4f97991713cfa84bff4d0792eff96c27dccbbb6f79b65d548b40e8564cef594",
 437                 sha512.Size384,
 438                 sha512.BlockSize,
 439         },
 440         {
 441                 sha512.New,
 442                 []byte{
 443                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 444                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 445                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 446                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 447                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 448                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 449                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 450                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 451                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 452                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 453                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 454                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 455                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 456                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 457                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 458                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 459                 },
 460                 []byte("Sample message for keylen=blocklen"),
 461                 "fc25e240658ca785b7a811a8d3f7b4ca" +
 462                         "48cfa26a8a366bf2cd1f836b05fcb024bd36853081811d6c" +
 463                         "ea4216ebad79da1cfcb95ea4586b8a0ce356596a55fb1347",
 464                 sha512.Size,
 465                 sha512.BlockSize,
 466         },
 467         {
 468                 sha512.New,
 469                 []byte{
 470                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 471                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 472                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 473                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 474                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 475                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 476                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 477                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 478                 },
 479                 []byte("Sample message for keylen<blocklen"),
 480                 "fd44c18bda0bb0a6ce0e82b031bf2818" +
 481                         "f6539bd56ec00bdc10a8a2d730b3634de2545d639b0f2cf7" +
 482                         "10d0692c72a1896f1f211c2b922d1a96c392e07e7ea9fedc",
 483                 sha512.Size,
 484                 sha512.BlockSize,
 485         },
 486         {
 487                 sha512.New,
 488                 []byte{
 489                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 490                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 491                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 492                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 493                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 494                         0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 495                         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 496                         0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 497                         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 498                         0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
 499                         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 500                         0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
 501                         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 502                         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 503                         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 504                         0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 505                         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 506                         0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 507                         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 508                         0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 509                         0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 510                         0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
 511                         0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
 512                         0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 513                         0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 514                 },
 515                 []byte("Sample message for keylen=blocklen"),
 516                 "d93ec8d2de1ad2a9957cb9b83f14e76a" +
 517                         "d6b5e0cce285079a127d3b14bccb7aa7286d4ac0d4ce6421" +
 518                         "5f2bc9e6870b33d97438be4aaa20cda5c5a912b48b8e27f3",
 519                 sha512.Size,
 520                 sha512.BlockSize,
 521         },
 522         // HMAC without key is dumb but should probably not fail.
 523         {
 524                 sha1.New,
 525                 []byte{},
 526                 []byte("message"),
 527                 "d5d1ed05121417247616cfc8378f360a39da7cfa",
 528                 sha1.Size,
 529                 sha1.BlockSize,
 530         },
 531         {
 532                 sha256.New,
 533                 []byte{},
 534                 []byte("message"),
 535                 "eb08c1f56d5ddee07f7bdf80468083da06b64cf4fac64fe3a90883df5feacae4",
 536                 sha256.Size,
 537                 sha256.BlockSize,
 538         },
 539         {
 540                 sha512.New,
 541                 []byte{},
 542                 []byte("message"),
 543                 "08fce52f6395d59c2a3fb8abb281d74ad6f112b9a9c787bcea290d94dadbc82b2ca3e5e12bf2277c7fedbb0154d5493e41bb7459f63c8e39554ea3651b812492",
 544                 sha512.Size,
 545                 sha512.BlockSize,
 546         },
 547 }
 548
 549 func TestHMAC(t *testing.T) {
 550         for i, tt := range hmacTests {
 551                 h := New(tt.hash, tt.key)
 552                 if s := h.Size(); s != tt.size {
 553                         t.Errorf("Size: got %v, want %v", s, tt.size)
 554                 }
 555                 if b := h.BlockSize(); b != tt.blocksize {
 556                         t.Errorf("BlockSize: got %v, want %v", b, tt.blocksize)
 557                 }
 558                 for j := 0; j < 4; j++ {
 559                         n, err := h.Write(tt.in)
 560                         if n != len(tt.in) || err != nil {
 561                                 t.Errorf("test %d.%d: Write(%d) = %d, %v", i, j, len(tt.in), n, err)
 562                                 continue
 563                         }
 564
 565                         // Repetitive Sum() calls should return the same value
 566                         for k := 0; k < 2; k++ {
 567                                 sum := fmt.Sprintf("%x", h.Sum(nil))
 568                                 if sum != tt.out {
 569                                         t.Errorf("test %d.%d.%d: have %s want %s\n", i, j, k, sum, tt.out)
 570                                 }
 571                         }
 572
 573                         // Second iteration: make sure reset works.
 574                         h.Reset()
 575
 576                         // Third and fourth iteration: make sure hmac works on
 577                         // hashes without MarshalBinary/UnmarshalBinary
 578                         if j == 1 {
 579                                 h = New(func() hash.Hash { return justHash{tt.hash()} }, tt.key)
 580                         }
 581                 }
 582         }
 583 }
 584
 585 // justHash implements just the hash.Hash methods and nothing else
 586 type justHash struct {
 587         hash.Hash
 588 }
 589
 590 func TestEqual(t *testing.T) {
 591         a := []byte("test")
 592         b := []byte("test1")
 593         c := []byte("test2")
 594
 595         if !Equal(b, b) {
 596                 t.Error("Equal failed with equal arguments")
 597         }
 598         if Equal(a, b) {
 599                 t.Error("Equal accepted a prefix of the second argument")
 600         }
 601         if Equal(b, a) {
 602                 t.Error("Equal accepted a prefix of the first argument")
 603         }
 604         if Equal(b, c) {
 605                 t.Error("Equal accepted unequal slices")
 606         }
 607 }
 608
 609 func TestWriteAfterSum(t *testing.T) {
 610         h := New(sha1.New, nil)
 611         h.Write([]byte("hello"))
 612         sumHello := h.Sum(nil)
 613
 614         h = New(sha1.New, nil)
 615         h.Write([]byte("hello world"))
 616         sumHelloWorld := h.Sum(nil)
 617
 618         // Test that Sum has no effect on future Sum or Write operations.
 619         // This is a bit unusual as far as usage, but it's allowed
 620         // by the definition of Go hash.Hash, and some clients expect it to work.
 621         h = New(sha1.New, nil)
 622         h.Write([]byte("hello"))
 623         if sum := h.Sum(nil); !bytes.Equal(sum, sumHello) {
 624                 t.Fatalf("1st Sum after hello = %x, want %x", sum, sumHello)
 625         }
 626         if sum := h.Sum(nil); !bytes.Equal(sum, sumHello) {
 627                 t.Fatalf("2nd Sum after hello = %x, want %x", sum, sumHello)
 628         }
 629
 630         h.Write([]byte(" world"))
 631         if sum := h.Sum(nil); !bytes.Equal(sum, sumHelloWorld) {
 632                 t.Fatalf("1st Sum after hello world = %x, want %x", sum, sumHelloWorld)
 633         }
 634         if sum := h.Sum(nil); !bytes.Equal(sum, sumHelloWorld) {
 635                 t.Fatalf("2nd Sum after hello world = %x, want %x", sum, sumHelloWorld)
 636         }
 637
 638         h.Reset()
 639         h.Write([]byte("hello"))
 640         if sum := h.Sum(nil); !bytes.Equal(sum, sumHello) {
 641                 t.Fatalf("Sum after Reset + hello = %x, want %x", sum, sumHello)
 642         }
 643 }
 644
 645 func BenchmarkHMACSHA256_1K(b *testing.B) {
 646         key := make([]byte, 32)
 647         buf := make([]byte, 1024)
 648         h := New(sha256.New, key)
 649         b.SetBytes(int64(len(buf)))
 650         for i := 0; i < b.N; i++ {
 651                 h.Write(buf)
 652                 h.Reset()
 653                 mac := h.Sum(nil)
 654                 buf[0] = mac[0]
 655         }
 656 }
 657
 658 func BenchmarkHMACSHA256_32(b *testing.B) {
 659         key := make([]byte, 32)
 660         buf := make([]byte, 32)
 661         h := New(sha256.New, key)
 662         b.SetBytes(int64(len(buf)))
 663         for i := 0; i < b.N; i++ {
 664                 h.Write(buf)
 665                 h.Reset()
 666                 mac := h.Sum(nil)
 667                 buf[0] = mac[0]
 668         }
 669 }