Source file src/crypto/hmac/hmac_test.go

Documentation: crypto/hmac

		 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  	// https://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 https://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 < 4; 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  			// Third and fourth iteration: make sure hmac works on
	 551  			// hashes without MarshalBinary/UnmarshalBinary
	 552  			if j == 1 {
	 553  				h = New(func() hash.Hash { return justHash{tt.hash()} }, tt.key)
	 554  			}
	 555  		}
	 556  	}
	 557  }
	 558  
	 559  func TestNonUniqueHash(t *testing.T) {
	 560  	sha := sha256.New()
	 561  	defer func() {
	 562  		err := recover()
	 563  		if err == nil {
	 564  			t.Error("expected panic when calling New with a non-unique hash generation function")
	 565  		}
	 566  	}()
	 567  	New(func() hash.Hash { return sha }, []byte("bytes"))
	 568  }
	 569  
	 570  // justHash implements just the hash.Hash methods and nothing else
	 571  type justHash struct {
	 572  	hash.Hash
	 573  }
	 574  
	 575  func TestEqual(t *testing.T) {
	 576  	a := []byte("test")
	 577  	b := []byte("test1")
	 578  	c := []byte("test2")
	 579  
	 580  	if !Equal(b, b) {
	 581  		t.Error("Equal failed with equal arguments")
	 582  	}
	 583  	if Equal(a, b) {
	 584  		t.Error("Equal accepted a prefix of the second argument")
	 585  	}
	 586  	if Equal(b, a) {
	 587  		t.Error("Equal accepted a prefix of the first argument")
	 588  	}
	 589  	if Equal(b, c) {
	 590  		t.Error("Equal accepted unequal slices")
	 591  	}
	 592  }
	 593  
	 594  func BenchmarkHMACSHA256_1K(b *testing.B) {
	 595  	key := make([]byte, 32)
	 596  	buf := make([]byte, 1024)
	 597  	h := New(sha256.New, key)
	 598  	b.SetBytes(int64(len(buf)))
	 599  	for i := 0; i < b.N; i++ {
	 600  		h.Write(buf)
	 601  		mac := h.Sum(nil)
	 602  		h.Reset()
	 603  		buf[0] = mac[0]
	 604  	}
	 605  }
	 606  
	 607  func BenchmarkHMACSHA256_32(b *testing.B) {
	 608  	key := make([]byte, 32)
	 609  	buf := make([]byte, 32)
	 610  	h := New(sha256.New, key)
	 611  	b.SetBytes(int64(len(buf)))
	 612  	for i := 0; i < b.N; i++ {
	 613  		h.Write(buf)
	 614  		mac := h.Sum(nil)
	 615  		h.Reset()
	 616  		buf[0] = mac[0]
	 617  	}
	 618  }
	 619  
	 620  func BenchmarkNewWriteSum(b *testing.B) {
	 621  	buf := make([]byte, 32)
	 622  	b.SetBytes(int64(len(buf)))
	 623  	for i := 0; i < b.N; i++ {
	 624  		h := New(sha256.New, make([]byte, 32))
	 625  		h.Write(buf)
	 626  		mac := h.Sum(nil)
	 627  		buf[0] = mac[0]
	 628  	}
	 629  }
	 630  

View as plain text