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