mcs/class/corlib/Test/System.Security.Cryptography/HMACSHA512Test.cs

   1 //
   2 // HMACSHA512Test.cs - NUnit Test Cases for HMACSHA512
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 // Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.Security.Cryptography;
  15 using System.Text;
  16
  17 namespace MonoTests.System.Security.Cryptography {
  18
  19         public class HS512 : HMACSHA512 {
  20
  21                 public int BlockSize {
  22                         get { return base.BlockSizeValue; }
  23                         set { base.BlockSizeValue = value; }
  24                 }
  25         }
  26
  27         public class SelectableHmacSha512: HMAC {
  28
  29                 // Legacy parameter explanation:
  30                 // http://blogs.msdn.com/shawnfa/archive/2007/01/31/please-do-not-use-the-net-2-0-hmacsha512-and-hmacsha384-classes.aspx
  31
  32                 public SelectableHmacSha512 (byte[] key, bool legacy)
  33                 {
  34                         HashName = "SHA512";
  35                         HashSizeValue = 512;
  36                         BlockSizeValue = legacy ? 64 : 128;
  37                         Key = key;
  38                 }
  39         }
  40
  41         // References:
  42         // a.   Identifiers and Test Vectors for HMAC-SHA-224, HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512
  43         //      http://www.ietf.org/rfc/rfc4231.txt
  44
  45         [TestFixture]
  46         public class HMACSHA512Test : KeyedHashAlgorithmTest {
  47
  48                 protected HMACSHA512 algo;
  49
  50                 [SetUp]
  51                 public override void SetUp ()
  52                 {
  53                         algo = new HMACSHA512 ();
  54                         algo.Key = new byte [8];
  55                         hash = algo;
  56                 }
  57
  58                 // the hash algorithm only exists as a managed implementation
  59                 public override bool ManagedHashImplementation {
  60                         get { return true; }
  61                 }
  62
  63                 [Test]
  64                 public void Constructors ()
  65                 {
  66                         algo = new HMACSHA512 ();
  67                         Assert.IsNotNull (algo, "HMACSHA512 ()");
  68
  69                         byte[] key = new byte [8];
  70                         algo = new HMACSHA512 (key);
  71                         Assert.IsNotNull (algo, "HMACSHA512 (key)");
  72                 }
  73
  74                 [Test]
  75                 [ExpectedException (typeof (NullReferenceException))]
  76                 public void Constructor_Null ()
  77                 {
  78                         new HMACSHA512 (null);
  79                 }
  80
  81                 [Test]
  82                 public void Invariants ()
  83                 {
  84                         algo = new HMACSHA512 ();
  85                         Assert.IsTrue (algo.CanReuseTransform, "HMACSHA512.CanReuseTransform");
  86                         Assert.IsTrue (algo.CanTransformMultipleBlocks, "HMACSHA512.CanTransformMultipleBlocks");
  87                         Assert.AreEqual ("SHA512", algo.HashName, "HMACSHA512.HashName");
  88                         Assert.AreEqual (512, algo.HashSize, "HMACSHA512.HashSize");
  89                         Assert.AreEqual (1, algo.InputBlockSize, "HMACSHA512.InputBlockSize");
  90                         Assert.AreEqual (1, algo.OutputBlockSize, "HMACSHA512.OutputBlockSize");
  91                         Assert.AreEqual ("System.Security.Cryptography.HMACSHA512", algo.ToString (), "HMACSHA512.ToString()");
  92                 }
  93
  94                 // some test case truncate the result
  95                 private void Compare (byte[] expected, byte[] actual, string msg)
  96                 {
  97                         if (expected.Length == actual.Length) {
  98                                 Assert.AreEqual (expected, actual, msg);
  99                         } else {
 100                                 byte[] data = new byte [expected.Length];
 101                                 Array.Copy (actual, data, data.Length);
 102                                 Assert.AreEqual (expected, data, msg);
 103                         }
 104                 }
 105
 106                 public void Check (string testName, HMAC algo, byte[] data, byte[] result)
 107                 {
 108                         CheckA (testName, algo, data, result);
 109                         CheckB (testName, algo, data, result);
 110                         CheckC (testName, algo, data, result);
 111                         CheckD (testName, algo, data, result);
 112                         CheckE (testName, algo, data, result);
 113                 }
 114
 115                 public void CheckA (string testName, HMAC algo, byte[] data, byte[] result)
 116                 {
 117                         byte[] hmac = algo.ComputeHash (data);
 118                         Compare (result, hmac, testName + "a1");
 119                         Compare (result, algo.Hash, testName + "a2");
 120                 }
 121
 122                 public void CheckB (string testName, HMAC algo, byte[] data, byte[] result)
 123                 {
 124                         byte[] hmac = algo.ComputeHash (data, 0, data.Length);
 125                         Compare (result, hmac, testName + "b1");
 126                         Compare (result, algo.Hash, testName + "b2");
 127                 }
 128
 129                 public void CheckC (string testName, HMAC algo, byte[] data, byte[] result)
 130                 {
 131                         using (MemoryStream ms = new MemoryStream (data)) {
 132                                 byte[] hmac = algo.ComputeHash (ms);
 133                                 Compare (result, hmac, testName + "c1");
 134                                 Compare (result, algo.Hash, testName + "c2");
 135                         }
 136                 }
 137
 138                 public void CheckD (string testName, HMAC algo, byte[] data, byte[] result)
 139                 {
 140                         algo.TransformFinalBlock (data, 0, data.Length);
 141                         Compare (result, algo.Hash, testName + "d");
 142                         algo.Initialize ();
 143                 }
 144
 145                 public void CheckE (string testName, HMAC algo, byte[] data, byte[] result)
 146                 {
 147                         byte[] copy = new byte[data.Length];
 148                         for (int i = 0; i < data.Length - 1; i++)
 149                                 algo.TransformBlock (data, i, 1, copy, i);
 150                         algo.TransformFinalBlock (data, data.Length - 1, 1);
 151                         Compare (result, algo.Hash, testName + "e");
 152                         algo.Initialize ();
 153                 }
 154
 155                 [Test]
 156                 public void RFC4231_TC1_Normal ()
 157                 {
 158                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 159                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 160                         byte[] digest = { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, 0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
 161                                 0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78, 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
 162                                 0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02, 0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
 163                                 0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70, 0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54 };
 164                         HMAC hmac = new SelectableHmacSha512 (key, false);
 165                         Check ("HMACSHA512-N-RFC4231-TC1", hmac, data, digest);
 166                 }
 167
 168                 [Test]
 169                 // Test with a key shorter than the length of the HMAC output.
 170                 public void RFC4231_TC2_Normal ()
 171                 {
 172                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 173                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 174                         byte[] digest = { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2, 0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
 175                                 0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6, 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
 176                                 0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a, 0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
 177                                 0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b, 0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37 };
 178                         HMAC hmac = new SelectableHmacSha512 (key, false);
 179                         Check ("HMACSHA512-N-RFC4231-TC2", hmac, data, digest);
 180                 }
 181
 182                 [Test]
 183                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 184                 public void RFC4231_TC3_Normal ()
 185                 {
 186                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 187                         byte[] data = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 188                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 189                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 190                                 0xdd, 0xdd };
 191                         byte[] digest = { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84, 0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
 192                                 0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36, 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
 193                                 0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8, 0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
 194                                 0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26, 0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb };
 195                         HMAC hmac = new SelectableHmacSha512 (key, false);
 196                         Check ("HMACSHA512-N-RFC4231-TC3", hmac, data, digest);
 197                 }
 198
 199                 [Test]
 200                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 201                 public void RFC4231_TC4_Normal ()
 202                 {
 203                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 204                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 205                         byte[] data = { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 206                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 207                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 208                                 0xcd, 0xcd };
 209                         byte[] digest = { 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69, 0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
 210                                 0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d, 0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
 211                                 0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4, 0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
 212                                 0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d, 0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd };
 213                         HMAC hmac = new SelectableHmacSha512 (key, false);
 214                         Check ("HMACSHA512-N-RFC4231-TC4", hmac, data, digest);
 215                 }
 216
 217                 [Test]
 218                 // Test with a truncation of output to 128 bits.
 219                 public void RFC4231_TC5_Normal ()
 220                 {
 221                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 222                                 0x0c, 0x0c, 0x0c, 0x0c };
 223                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 224                         byte[] digest = { 0x41, 0x5f, 0xad, 0x62, 0x71, 0x58, 0x0a, 0x53, 0x1d, 0x41, 0x79, 0xbc, 0x89, 0x1d, 0x87, 0xa6 };
 225                         HMAC hmac = new SelectableHmacSha512 (key, false);
 226                         Check ("HMACSHA512-N-RFC4231-TC5", hmac, data, digest);
 227                 }
 228
 229                 [Test]
 230                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 231                 public void RFC4231_TC6_Normal ()
 232                 {
 233                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 234                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 235                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 236                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 237                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 238                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 239                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 240                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 241                                 0xaa, 0xaa, 0xaa };
 242                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 243                         byte[] digest = { 0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb, 0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
 244                                 0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1, 0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
 245                                 0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98, 0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
 246                                 0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec, 0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98 };
 247                         HMAC hmac = new SelectableHmacSha512 (key, false);
 248                         Check ("HMACSHA512-N-RFC4231-TC6", hmac, data, digest);
 249                 }
 250
 251                 [Test]
 252                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 253                 public void RFC4231_TC7_Normal ()
 254                 {
 255                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 256                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 257                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 258                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 259                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 260                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 261                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 262                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 263                                 0xaa, 0xaa, 0xaa };
 264                         byte[] data = Encoding.Default.GetBytes ("This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.");
 265                         byte[] digest = { 0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba, 0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
 266                                 0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86, 0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
 267                                 0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1, 0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
 268                                 0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60, 0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58 };
 269                         HMAC hmac = new SelectableHmacSha512 (key, false);
 270                         Check ("HMACSHA512-N-RFC4231-TC7", hmac, data, digest);
 271                 }
 272
 273                 [Test]
 274                 public void RFC4231_TC1_Legacy ()
 275                 {
 276                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 277                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 278                         byte[] digest = { 0x96, 0x56, 0x97, 0x5E, 0xE5, 0xDE, 0x55, 0xE7, 0x5F, 0x29, 0x76, 0xEC, 0xCE, 0x9A, 0x04, 0x50,
 279                                 0x10, 0x60, 0xB9, 0xDC, 0x22, 0xA6, 0xED, 0xA2, 0xEA, 0xEF, 0x63, 0x89, 0x66, 0x28, 0x01, 0x82,
 280                                 0x47, 0x7F, 0xE0, 0x9F, 0x08, 0x0B, 0x2B, 0xF5, 0x64, 0x64, 0x9C, 0xAD, 0x42, 0xAF, 0x86, 0x07,
 281                                 0xA2, 0xBD, 0x8D, 0x02, 0x97, 0x9D, 0xF3, 0xA9, 0x80, 0xF1, 0x5E, 0x23, 0x26, 0xA0, 0xA2, 0x2A };
 282                         HMAC hmac = new SelectableHmacSha512 (key, true);
 283                         Check ("HMACSHA512-L-RFC4231-TC1", hmac, data, digest);
 284                 }
 285
 286                 [Test]
 287                 // Test with a key shorter than the length of the HMAC output.
 288                 public void RFC4231_TC2_Legacy ()
 289                 {
 290                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 291                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 292                         byte[] digest = { 0xD2, 0x76, 0x6E, 0xCA, 0x33, 0xFE, 0x85, 0x2B, 0xD6, 0x29, 0x25, 0x3F, 0xE0, 0x1C, 0x63, 0x51,
 293                                 0x9E, 0xB2, 0x45, 0x9B, 0xDB, 0x0A, 0xF2, 0x54, 0xBD, 0x43, 0x41, 0x74, 0x0B, 0x4D, 0x0E, 0xA7,
 294                                 0x23, 0xC6, 0xA2, 0xA4, 0xDF, 0xC3, 0x42, 0x52, 0x89, 0x1C, 0x14, 0xF2, 0x65, 0x80, 0x55, 0x23,
 295                                 0x7A, 0xA3, 0xF6, 0x49, 0x62, 0xD4, 0xD4, 0xDE, 0x21, 0x70, 0xAE, 0x18, 0xFD, 0x91, 0x60, 0xAA };
 296                         HMAC hmac = new SelectableHmacSha512 (key, true);
 297                         Check ("HMACSHA512-L-RFC4231-TC2", hmac, data, digest);
 298                 }
 299
 300                 [Test]
 301                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 302                 public void RFC4231_TC3_Legacy ()
 303                 {
 304                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 305                         byte[] data = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 306                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 307                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 308                                 0xdd, 0xdd };
 309                         byte[] digest = { 0x57, 0xD1, 0xE0, 0xB1, 0x1E, 0xE0, 0x8D, 0xF8, 0x9E, 0x3C, 0xDC, 0xD4, 0xB7, 0xD3, 0xA9, 0x2C,
 310                                 0x42, 0x30, 0x75, 0x24, 0xDB, 0x89, 0xD0, 0xC3, 0x1A, 0xCA, 0xBD, 0x41, 0x58, 0xF5, 0x19, 0xAA,
 311                                 0xC2, 0x2E, 0x0C, 0xA5, 0xBF, 0x05, 0x37, 0xF1, 0x0B, 0xD8, 0x3B, 0xDE, 0x43, 0x07, 0xD6, 0x4D,
 312                                 0xE1, 0x91, 0xA2, 0xCF, 0x12, 0x01, 0x8F, 0x49, 0x95, 0x1C, 0xF5, 0x99, 0xFF, 0x8A, 0xD1, 0x68 };
 313                         HMAC hmac = new SelectableHmacSha512 (key, true);
 314                         Check ("HMACSHA512-L-RFC4231-TC3", hmac, data, digest);
 315                 }
 316
 317                 [Test]
 318                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 319                 public void RFC4231_TC4_Legacy ()
 320                 {
 321                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 322                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 323                         byte[] data = { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 324                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 325                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 326                                 0xcd, 0xcd };
 327                         byte[] digest = { 0xF9, 0x82, 0x79, 0x3A, 0x2E, 0x24, 0xF6, 0xEB, 0x82, 0xF5, 0x2D, 0x10, 0x85, 0x2C, 0x13, 0x50,
 328                                 0x69, 0xA5, 0x81, 0x99, 0xF8, 0x1C, 0x2E, 0x09, 0x4F, 0xED, 0x96, 0x4E, 0x59, 0xD5, 0x57, 0xE4,
 329                                 0xE1, 0x02, 0x9A, 0x62, 0x9A, 0xF3, 0x45, 0x8C, 0xA8, 0xEE, 0x8A, 0xB4, 0x39, 0x99, 0x32, 0xE8,
 330                                 0xC7, 0x94, 0x4B, 0x37, 0xB5, 0x5E, 0x3C, 0xE8, 0xF5, 0x6D, 0x31, 0xA5, 0x25, 0x11, 0x97, 0xFB };
 331                         HMAC hmac = new SelectableHmacSha512 (key, true);
 332                         Check ("HMACSHA512-L-RFC4231-TC4", hmac, data, digest);
 333                 }
 334
 335                 [Test]
 336                 // Test with a truncation of output to 128 bits.
 337                 public void RFC4231_TC5_Legacy ()
 338                 {
 339                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 340                                 0x0c, 0x0c, 0x0c, 0x0c };
 341                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 342                         byte[] digest = { 0xBC, 0x59, 0x5A, 0x3F, 0x08, 0x9B, 0x2C, 0x5E, 0x25, 0x9B, 0x94, 0xAD, 0x7C, 0x48, 0xBA, 0xF3 };
 343                         HMAC hmac = new SelectableHmacSha512 (key, true);
 344                         Check ("HMACSHA512-L-RFC4231-TC5", hmac, data, digest);
 345                 }
 346
 347                 [Test]
 348                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 349                 public void RFC4231_TC6_Legacy ()
 350                 {
 351                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 352                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 353                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 354                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 355                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 356                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 357                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 358                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 359                                 0xaa, 0xaa, 0xaa };
 360                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 361                         byte[] digest = { 0x6A, 0x2D, 0x1C, 0x4B, 0x7B, 0x7A, 0x88, 0x15, 0xBA, 0xC4, 0xEB, 0x5D, 0x41, 0xB6, 0x6F, 0x7F,
 362                                 0x55, 0x5D, 0x4A, 0xDF, 0x00, 0xD2, 0x83, 0x3F, 0xDF, 0xCD, 0x2B, 0x55, 0xF4, 0xC5, 0x3D, 0xCA,
 363                                 0xEB, 0x11, 0x86, 0xEE, 0xB6, 0x46, 0x67, 0xB2, 0x54, 0x48, 0x42, 0x94, 0x41, 0x83, 0x57, 0x8E,
 364                                 0x47, 0xCB, 0x73, 0x32, 0x32, 0x0B, 0x35, 0x4F, 0xC0, 0xD5, 0x19, 0xFF, 0x4E, 0x5D, 0x90, 0xAD };
 365                         HMAC hmac = new SelectableHmacSha512 (key, true);
 366                         Check ("HMACSHA512-L-RFC4231-TC6", hmac, data, digest);
 367                 }
 368
 369                 [Test]
 370                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 371                 public void RFC4231_TC7_Legacy ()
 372                 {
 373                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 374                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 375                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 376                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 377                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 378                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 379                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 380                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 381                                 0xaa, 0xaa, 0xaa };
 382                         byte[] data = Encoding.Default.GetBytes ("This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.");
 383                         byte[] digest = { 0x18, 0xDC, 0x82, 0xB6, 0x9D, 0x9A, 0xF8, 0xA5, 0x28, 0x46, 0x8C, 0x38, 0x3A, 0x99, 0xAB, 0x2E,
 384                                 0xD4, 0x11, 0x14, 0xA6, 0xBB, 0x24, 0x00, 0x61, 0x13, 0xAA, 0xD2, 0x44, 0x00, 0x5F, 0xA9, 0xC3,
 385                                 0xAC, 0xBE, 0x53, 0x77, 0xB9, 0x3B, 0x4C, 0x5D, 0x17, 0x16, 0x8C, 0xAA, 0x85, 0x77, 0x52, 0x72,
 386                                 0xFF, 0xF4, 0x5A, 0xFC, 0x68, 0xF8, 0x90, 0x27, 0x2F, 0x2E, 0x12, 0x9D, 0x81, 0xB6, 0x48, 0x49 };
 387                         HMAC hmac = new SelectableHmacSha512 (key, true);
 388                         Check ("HMACSHA512-L-RFC4231-TC7", hmac, data, digest);
 389                 }
 390
 391                 [Test]
 392                 public void Bug6510a ()
 393                 {
 394                         byte[] key = Encoding.UTF8.GetBytes ("CA61A777DC1041B2FDCC354820F7F83CE0530C0E019A29BF576F175D314A6D891B35F");
 395                         byte[] data = Encoding.UTF8.GetBytes ("123456789");
 396                         byte[] digest = { 147, 50, 79, 211, 70, 90, 205, 252, 100, 25, 50, 209, 254, 157,
 397                                 154, 12, 132, 205, 113, 59, 97, 216, 252, 94, 43, 126, 207, 140, 137, 60, 227,
 398                                 82, 82, 240, 9, 15, 166, 167, 110, 85, 217, 245, 250, 169, 189, 138, 55, 197,
 399                                 146, 192, 96, 20, 249, 95, 130, 163, 147, 82, 71, 244, 139, 76, 45, 75 };
 400                         HMAC hmac = new SelectableHmacSha512 (key, false);
 401                         Check ("HMACSHA512-BUG-6510", hmac, data, digest);
 402                 }
 403
 404                 [Test]
 405                 public void Bug6510b ()
 406                 {
 407                         byte[] key = Encoding.UTF8.GetBytes ("CA61A777DC1041B2FDCC354820F7F83CE0530C0E019A29BF576F175D314A6D891");
 408                         byte[] data = Encoding.UTF8.GetBytes ("123456789");
 409                         byte[] digest = { 254, 159, 56, 218, 66, 110, 74, 135, 209, 81, 166, 150, 241, 194,
 410                                 171, 228, 143, 228, 16, 198, 171, 53, 40, 211, 229, 160, 158, 2, 102, 99, 11,
 411                                 49, 70, 53, 70, 32, 32, 219, 119, 14, 2, 149, 197, 220, 166, 38, 128, 25, 255,
 412                                 227, 25, 20, 229, 54, 217, 57, 143, 224, 251, 1, 202, 24, 245, 133 };
 413                         HMAC hmac = new SelectableHmacSha512 (key, false);
 414                         Check ("HMACSHA512-BUG-6510", hmac, data, digest);
 415                 }
 416         }
 417 }