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

   1 //
   2 // HMACSHA384Test.cs - NUnit Test Cases for HMACSHA384
   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
  12 using NUnit.Framework;
  13 using System;
  14 using System.IO;
  15 using System.Security.Cryptography;
  16 using System.Text;
  17
  18 namespace MonoTests.System.Security.Cryptography {
  19
  20         public class HS384 : HMACSHA384 {
  21
  22                 public int BlockSize {
  23                         get { return base.BlockSizeValue; }
  24                         set { base.BlockSizeValue = value; }
  25                 }
  26         }
  27
  28         public class SelectableHmacSha384: HMAC {
  29
  30                 // legacy parameter:
  31                 //      http://blogs.msdn.com/shawnfa/archive/2007/01/31/please-do-not-use-the-net-2-0-hmacsha512-and-hmacsha384-classes.aspx
  32
  33                 public SelectableHmacSha384 (byte[] key, bool legacy)
  34                 {
  35                         HashName = "SHA384";
  36                         HashSizeValue = 384;
  37                         BlockSizeValue = legacy ? 64 : 128;
  38                         Key = key;
  39                 }
  40         }
  41
  42         // References:
  43         // a.   Identifiers and Test Vectors for HMAC-SHA-224, HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512
  44         //      http://www.ietf.org/rfc/rfc4231.txt
  45
  46         [TestFixture]
  47         public class HMACSHA384Test : KeyedHashAlgorithmTest {
  48
  49                 protected HMACSHA384 algo;
  50
  51                 [SetUp]
  52                 public override void SetUp ()
  53                 {
  54                         algo = new HMACSHA384 ();
  55                         algo.Key = new byte [8];
  56                         hash = algo;
  57                 }
  58
  59                 // the hash algorithm only exists as a managed implementation
  60                 public override bool ManagedHashImplementation {
  61                         get { return true; }
  62                 }
  63
  64                 [Test]
  65                 public void Constructors ()
  66                 {
  67                         algo = new HMACSHA384 ();
  68                         Assert.IsNotNull (algo, "HMACSHA384 ()");
  69
  70                         byte[] key = new byte [8];
  71                         algo = new HMACSHA384 (key);
  72                         Assert.IsNotNull (algo, "HMACSHA384 (key)");
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (NullReferenceException))]
  77                 public void Constructor_Null ()
  78                 {
  79                         new HMACSHA384 (null);
  80                 }
  81
  82                 [Test]
  83                 public void Invariants ()
  84                 {
  85                         algo = new HMACSHA384 ();
  86                         Assert.IsTrue (algo.CanReuseTransform, "HMACSHA384.CanReuseTransform");
  87                         Assert.IsTrue (algo.CanTransformMultipleBlocks, "HMACSHA384.CanTransformMultipleBlocks");
  88                         Assert.AreEqual ("SHA384", algo.HashName, "HMACSHA384.HashName");
  89                         Assert.AreEqual (384, algo.HashSize, "HMACSHA384.HashSize");
  90                         Assert.AreEqual (1, algo.InputBlockSize, "HMACSHA384.InputBlockSize");
  91                         Assert.AreEqual (1, algo.OutputBlockSize, "HMACSHA384.OutputBlockSize");
  92                         Assert.AreEqual ("System.Security.Cryptography.HMACSHA384", algo.ToString (), "HMACSHA384.ToString()");
  93                 }
  94
  95                 // some test case truncate the result
  96                 private void Compare (byte[] expected, byte[] actual, string msg)
  97                 {
  98                         if (expected.Length == actual.Length) {
  99                                 Assert.AreEqual (expected, actual, msg);
 100                         } else {
 101                                 byte[] data = new byte[expected.Length];
 102                                 Array.Copy (actual, data, data.Length);
 103                                 Assert.AreEqual (expected, data, msg);
 104                         }
 105                 }
 106
 107                 public void Check (string testName, HMAC algo, byte[] data, byte[] result)
 108                 {
 109                         CheckA (testName, algo, data, result);
 110                         CheckB (testName, algo, data, result);
 111                         CheckC (testName, algo, data, result);
 112                         CheckD (testName, algo, data, result);
 113                         CheckE (testName, algo, data, result);
 114                 }
 115
 116                 public void CheckA (string testName, HMAC algo, byte[] data, byte[] result)
 117                 {
 118                         byte[] hmac = algo.ComputeHash (data);
 119                         Compare (result, hmac, testName + "a1");
 120                         Compare (result, algo.Hash, testName + "a2");
 121                 }
 122
 123                 public void CheckB (string testName, HMAC algo, byte[] data, byte[] result)
 124                 {
 125                         byte[] hmac = algo.ComputeHash (data, 0, data.Length);
 126                         Compare (result, hmac, testName + "b1");
 127                         Compare (result, algo.Hash, testName + "b2");
 128                 }
 129
 130                 public void CheckC (string testName, HMAC algo, byte[] data, byte[] result)
 131                 {
 132                         using (MemoryStream ms = new MemoryStream (data)) {
 133                                 byte[] hmac = algo.ComputeHash (ms);
 134                                 Compare (result, hmac, testName + "c1");
 135                                 Compare (result, algo.Hash, testName + "c2");
 136                         }
 137                 }
 138
 139                 public void CheckD (string testName, HMAC algo, byte[] data, byte[] result)
 140                 {
 141                         algo.TransformFinalBlock (data, 0, data.Length);
 142                         Compare (result, algo.Hash, testName + "d");
 143                         algo.Initialize ();
 144                 }
 145
 146                 public void CheckE (string testName, HMAC algo, byte[] data, byte[] result)
 147                 {
 148                         byte[] copy = new byte[data.Length];
 149                         for (int i = 0; i < data.Length - 1; i++)
 150                                 algo.TransformBlock (data, i, 1, copy, i);
 151                         algo.TransformFinalBlock (data, data.Length - 1, 1);
 152                         Compare (result, algo.Hash, testName + "e");
 153                         algo.Initialize ();
 154                 }
 155
 156                 [Test]
 157                 public void RFC4231_TC1_Normal ()
 158                 {
 159                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 160                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 161                         byte[] digest = { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62, 0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
 162                                 0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6, 0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
 163                                 0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f, 0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 };
 164                         HMAC hmac = new SelectableHmacSha384 (key, false);
 165                         Check ("HMACSHA384-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 = { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31, 0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
 175                                 0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47, 0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
 176                                 0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7, 0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 };
 177                         HMAC hmac = new SelectableHmacSha384 (key, false);
 178                         Check ("HMACSHA384-N-RFC4231-TC2", hmac, data, digest);
 179                 }
 180
 181                 [Test]
 182                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 183                 public void RFC4231_TC3_Normal ()
 184                 {
 185                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 186                         byte[] data = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 187                                 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 };
 190                         byte[] digest = { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a, 0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
 191                                 0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb, 0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
 192                                 0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9, 0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 };
 193                         HMAC hmac = new SelectableHmacSha384 (key, false);
 194                         Check ("HMACSHA384-N-RFC4231-TC3", hmac, data, digest);
 195                 }
 196
 197                 [Test]
 198                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 199                 public void RFC4231_TC4_Normal ()
 200                 {
 201                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 202                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 203                         byte[] data = { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 204                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 205                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 206                                 0xcd, 0xcd };
 207                         byte[] digest = { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85, 0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
 208                                 0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c, 0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
 209                                 0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79, 0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb };
 210                         HMAC hmac = new SelectableHmacSha384 (key, false);
 211                         Check ("HMACSHA384-N-RFC4231-TC4", hmac, data, digest);
 212                 }
 213
 214                 [Test]
 215                 // Test with a truncation of output to 128 bits.
 216                 public void RFC4231_TC5_Normal ()
 217                 {
 218                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 219                                 0x0c, 0x0c, 0x0c, 0x0c };
 220                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 221                         byte[] digest = { 0x3a, 0xbf, 0x34, 0xc3, 0x50, 0x3b, 0x2a, 0x23, 0xa4, 0x6e, 0xfc, 0x61, 0x9b, 0xae, 0xf8, 0x97 };
 222                         HMAC hmac = new SelectableHmacSha384 (key, false);
 223                         Check ("HMACSHA384-N-RFC4231-TC5", hmac, data, digest);
 224                 }
 225
 226                 [Test]
 227                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 228                 public void RFC4231_TC6_Normal ()
 229                 {
 230                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 231                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 232                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 233                                 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 };
 239                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 240                         byte[] digest = { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90, 0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
 241                                 0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f, 0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
 242                                 0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82, 0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 };
 243                         HMAC hmac = new SelectableHmacSha384 (key, false);
 244                         Check ("HMACSHA384-N-RFC4231-TC6", hmac, data, digest);
 245                 }
 246
 247                 [Test]
 248                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 249                 public void RFC4231_TC7_Normal ()
 250                 {
 251                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 252                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 253                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 254                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 255                                 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 };
 260                         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.");
 261                         byte[] digest = { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d, 0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
 262                                 0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a, 0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
 263                                 0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d, 0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e };
 264                         HMAC hmac = new SelectableHmacSha384 (key, false);
 265                         Check ("HMACSHA384-N-RFC4231-TC7", hmac, data, digest);
 266                 }
 267
 268                 [Test]
 269                 public void RFC4231_TC1_Legacy ()
 270                 {
 271                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 272                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 273                         byte[] digest = { 0x0A, 0x04, 0x6A, 0xAA, 0x02, 0x55, 0xE4, 0x32, 0x91, 0x22, 0x28, 0xF8, 0xCC, 0xDA, 0x43, 0x7C,
 274                                 0x8A, 0x83, 0x63, 0xFB, 0x16, 0x0A, 0xFB, 0x05, 0x70, 0xAB, 0x5B, 0x1F, 0xD5, 0xDD, 0xC2, 0x0E,
 275                                 0xB1, 0x88, 0x8B, 0x9E, 0xD4, 0xE5, 0xB6, 0xCB, 0x5B, 0xC0, 0x34, 0xCD, 0x9E, 0xF7, 0x0E, 0x40 };
 276                         HMAC hmac = new SelectableHmacSha384 (key, true);
 277                         Check ("HMACSHA384-L-RFC4231-TC1", hmac, data, digest);
 278                 }
 279
 280                 [Test]
 281                 // Test with a key shorter than the length of the HMAC output.
 282                 public void RFC4231_TC2_Legacy ()
 283                 {
 284                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 285                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 286                         byte[] digest = { 0xBB, 0x8A, 0xF7, 0xF5, 0x8A, 0xC9, 0xE8, 0x3A, 0x87, 0x2E, 0x51, 0x2F, 0x75, 0xD8, 0x74, 0xCC,
 287                                 0x45, 0xE3, 0xDD, 0x1C, 0xD4, 0x76, 0x54, 0x66, 0xCC, 0xEA, 0x19, 0x5B, 0xC3, 0x00, 0x2C, 0xCE,
 288                                 0x3C, 0x9F, 0x1B, 0xAF, 0x44, 0xF2, 0xD7, 0x28, 0x13, 0xA2, 0x4D, 0x11, 0x52, 0xE3, 0x66, 0x6F };
 289                         HMAC hmac = new SelectableHmacSha384 (key, true);
 290                         Check ("HMACSHA384-L-RFC4231-TC2", hmac, data, digest);
 291                 }
 292
 293                 [Test]
 294                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 295                 public void RFC4231_TC3_Legacy ()
 296                 {
 297                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 298                         byte[] data = { 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 299                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 300                                 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 301                                 0xdd, 0xdd };
 302                         byte[] digest = { 0x43, 0xAA, 0x39, 0x69, 0x01, 0xAB, 0xF6, 0xFA, 0x3A, 0x5E, 0x85, 0x07, 0x4E, 0xA6, 0x5D, 0x61,
 303                                 0x91, 0xED, 0x86, 0x20, 0x6E, 0xE0, 0x40, 0x23, 0x97, 0x48, 0xE1, 0x35, 0xD5, 0xC6, 0xC1, 0x90,
 304                                 0x9F, 0x1A, 0x39, 0x68, 0xCD, 0x44, 0xA0, 0xB0, 0x48, 0xFE, 0x7C, 0x68, 0x65, 0x44, 0x18, 0x98 };
 305                         HMAC hmac = new SelectableHmacSha384 (key, true);
 306                         Check ("HMACSHA384-L-RFC4231-TC3", hmac, data, digest);
 307                 }
 308
 309                 [Test]
 310                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 311                 public void RFC4231_TC4_Legacy ()
 312                 {
 313                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 314                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 315                         byte[] data = { 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 316                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 317                                 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 318                                 0xcd, 0xcd };
 319                         byte[] digest = { 0x1F, 0x20, 0x77, 0xC5, 0xBA, 0x39, 0x38, 0x23, 0x86, 0x47, 0xD0, 0x72, 0x14, 0x32, 0xC5, 0x6A,
 320                                 0x34, 0xDA, 0x36, 0xDD, 0x77, 0x9A, 0xCA, 0xC4, 0xB2, 0xA2, 0xF9, 0xE3, 0x1A, 0xE5, 0xEE, 0x00,
 321                                 0x83, 0xAA, 0x3E, 0x18, 0xDF, 0xD8, 0xBB, 0x6E, 0xEB, 0x0A, 0xF7, 0x37, 0x84, 0x21, 0x8F, 0xB3 };
 322                         HMAC hmac = new SelectableHmacSha384 (key, true);
 323                         Check ("HMACSHA384-L-RFC4231-TC4", hmac, data, digest);
 324                 }
 325
 326                 [Test]
 327                 // Test with a truncation of output to 128 bits.
 328                 public void RFC4231_TC5_Legacy ()
 329                 {
 330                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 331                                 0x0c, 0x0c, 0x0c, 0x0c };
 332                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 333                         byte[] digest = { 0x2E, 0xF2, 0xA4, 0x13, 0xAB, 0x77, 0xBE, 0xCC, 0xF0, 0xB7, 0xD6, 0xAA, 0x6F, 0x60, 0x6B, 0x59 };
 334                         HMAC hmac = new SelectableHmacSha384 (key, true);
 335                         Check ("HMACSHA384-L-RFC4231-TC5", hmac, data, digest);
 336                 }
 337
 338                 [Test]
 339                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 340                 public void RFC4231_TC6_Legacy ()
 341                 {
 342                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 343                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 344                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 345                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 346                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 347                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 348                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 349                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 350                                 0xaa, 0xaa, 0xaa };
 351                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 352                         byte[] digest = { 0xCA, 0xAA, 0x39, 0xF4, 0x53, 0xED, 0x62, 0x43, 0x06, 0x8C, 0x00, 0x95, 0xD8, 0xD3, 0xAC, 0x78,
 353                                 0x80, 0xE8, 0xA4, 0x38, 0x82, 0x90, 0xAC, 0xFA, 0xBA, 0xE9, 0xA1, 0xAC, 0x1C, 0x3F, 0xB3, 0x74,
 354                                 0x34, 0x1C, 0xD1, 0xD2, 0xBE, 0x6C, 0x99, 0x75, 0x2B, 0xDC, 0x98, 0x78, 0x45, 0xB7, 0x08, 0x5F };
 355                         HMAC hmac = new SelectableHmacSha384 (key, true);
 356                         Check ("HMACSHA384-L-RFC4231-TC6", hmac, data, digest);
 357                 }
 358
 359                 [Test]
 360                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 361                 public void RFC4231_TC7_Legacy ()
 362                 {
 363                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 364                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 365                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 366                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 367                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 368                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 369                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 370                                 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 371                                 0xaa, 0xaa, 0xaa };
 372                         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.");
 373                         byte[] digest = { 0x5C, 0xF0, 0x92, 0x18, 0x76, 0xCB, 0x51, 0x7E, 0x0E, 0x29, 0xE5, 0x01, 0xCB, 0x70, 0x67, 0x6B,
 374                                 0x63, 0xAE, 0x98, 0x61, 0xB9, 0x66, 0xC2, 0x37, 0xEE, 0x1C, 0x7B, 0x30, 0x84, 0xB1, 0xAA, 0x76,
 375                                 0xEE, 0x81, 0x7A, 0xEF, 0xB4, 0xF4, 0x65, 0x00, 0xCA, 0x67, 0x92, 0xF8, 0x7E, 0xAA, 0x83, 0xBD };
 376                         HMAC hmac = new SelectableHmacSha384 (key, true);
 377                         Check ("HMACSHA384-L-RFC4231-TC7", hmac, data, digest);
 378                 }
 379         }
 380 }
 381