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 (128, algo.Key.Length, "HMACSHA384.Key.Length");
  93                         Assert.AreEqual ("System.Security.Cryptography.HMACSHA384", algo.ToString (), "HMACSHA384.ToString()");
  94                 }
  95
  96                 // some test case truncate the result
  97                 private void Compare (byte[] expected, byte[] actual, string msg)
  98                 {
  99                         if (expected.Length == actual.Length) {
 100                                 Assert.AreEqual (expected, actual, msg);
 101                         } else {
 102                                 byte[] data = new byte[expected.Length];
 103                                 Array.Copy (actual, data, data.Length);
 104                                 Assert.AreEqual (expected, data, msg);
 105                         }
 106                 }
 107
 108                 public void Check (string testName, HMAC algo, byte[] data, byte[] result)
 109                 {
 110                         CheckA (testName, algo, data, result);
 111                         CheckB (testName, algo, data, result);
 112                         CheckC (testName, algo, data, result);
 113                         CheckD (testName, algo, data, result);
 114                         CheckE (testName, algo, data, result);
 115                 }
 116
 117                 public void CheckA (string testName, HMAC algo, byte[] data, byte[] result)
 118                 {
 119                         byte[] hmac = algo.ComputeHash (data);
 120                         Compare (result, hmac, testName + "a1");
 121                         Compare (result, algo.Hash, testName + "a2");
 122                 }
 123
 124                 public void CheckB (string testName, HMAC algo, byte[] data, byte[] result)
 125                 {
 126                         byte[] hmac = algo.ComputeHash (data, 0, data.Length);
 127                         Compare (result, hmac, testName + "b1");
 128                         Compare (result, algo.Hash, testName + "b2");
 129                 }
 130
 131                 public void CheckC (string testName, HMAC algo, byte[] data, byte[] result)
 132                 {
 133                         using (MemoryStream ms = new MemoryStream (data)) {
 134                                 byte[] hmac = algo.ComputeHash (ms);
 135                                 Compare (result, hmac, testName + "c1");
 136                                 Compare (result, algo.Hash, testName + "c2");
 137                         }
 138                 }
 139
 140                 public void CheckD (string testName, HMAC algo, byte[] data, byte[] result)
 141                 {
 142                         algo.TransformFinalBlock (data, 0, data.Length);
 143                         Compare (result, algo.Hash, testName + "d");
 144                         algo.Initialize ();
 145                 }
 146
 147                 public void CheckE (string testName, HMAC algo, byte[] data, byte[] result)
 148                 {
 149                         byte[] copy = new byte[data.Length];
 150                         for (int i = 0; i < data.Length - 1; i++)
 151                                 algo.TransformBlock (data, i, 1, copy, i);
 152                         algo.TransformFinalBlock (data, data.Length - 1, 1);
 153                         Compare (result, algo.Hash, testName + "e");
 154                         algo.Initialize ();
 155                 }
 156
 157                 [Test]
 158                 public void RFC4231_TC1_Normal ()
 159                 {
 160                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 161                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 162                         byte[] digest = { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62, 0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
 163                                 0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6, 0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
 164                                 0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f, 0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 };
 165                         HMAC hmac = new SelectableHmacSha384 (key, false);
 166                         Check ("HMACSHA384-N-RFC4231-TC1", hmac, data, digest);
 167                 }
 168
 169                 [Test]
 170                 // Test with a key shorter than the length of the HMAC output.
 171                 public void RFC4231_TC2_Normal ()
 172                 {
 173                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 174                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 175                         byte[] digest = { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31, 0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
 176                                 0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47, 0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
 177                                 0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7, 0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 };
 178                         HMAC hmac = new SelectableHmacSha384 (key, false);
 179                         Check ("HMACSHA384-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 = { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a, 0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
 192                                 0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb, 0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
 193                                 0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9, 0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 };
 194                         HMAC hmac = new SelectableHmacSha384 (key, false);
 195                         Check ("HMACSHA384-N-RFC4231-TC3", hmac, data, digest);
 196                 }
 197
 198                 [Test]
 199                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 200                 public void RFC4231_TC4_Normal ()
 201                 {
 202                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 203                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 204                         byte[] data = { 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, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 207                                 0xcd, 0xcd };
 208                         byte[] digest = { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85, 0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
 209                                 0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c, 0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
 210                                 0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79, 0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb };
 211                         HMAC hmac = new SelectableHmacSha384 (key, false);
 212                         Check ("HMACSHA384-N-RFC4231-TC4", hmac, data, digest);
 213                 }
 214
 215                 [Test]
 216                 // Test with a truncation of output to 128 bits.
 217                 public void RFC4231_TC5_Normal ()
 218                 {
 219                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 220                                 0x0c, 0x0c, 0x0c, 0x0c };
 221                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 222                         byte[] digest = { 0x3a, 0xbf, 0x34, 0xc3, 0x50, 0x3b, 0x2a, 0x23, 0xa4, 0x6e, 0xfc, 0x61, 0x9b, 0xae, 0xf8, 0x97 };
 223                         HMAC hmac = new SelectableHmacSha384 (key, false);
 224                         Check ("HMACSHA384-N-RFC4231-TC5", hmac, data, digest);
 225                 }
 226
 227                 [Test]
 228                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 229                 public void RFC4231_TC6_Normal ()
 230                 {
 231                         byte[] key = { 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, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 239                                 0xaa, 0xaa, 0xaa };
 240                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 241                         byte[] digest = { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90, 0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
 242                                 0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f, 0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
 243                                 0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82, 0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 };
 244                         HMAC hmac = new SelectableHmacSha384 (key, false);
 245                         Check ("HMACSHA384-N-RFC4231-TC6", hmac, data, digest);
 246                 }
 247
 248                 [Test]
 249                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 250                 public void RFC4231_TC7_Normal ()
 251                 {
 252                         byte[] key = { 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, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 260                                 0xaa, 0xaa, 0xaa };
 261                         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.");
 262                         byte[] digest = { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d, 0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
 263                                 0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a, 0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
 264                                 0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d, 0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e };
 265                         HMAC hmac = new SelectableHmacSha384 (key, false);
 266                         Check ("HMACSHA384-N-RFC4231-TC7", hmac, data, digest);
 267                 }
 268
 269                 [Test]
 270                 public void RFC4231_TC1_Legacy ()
 271                 {
 272                         byte[] key = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 273                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 274                         byte[] digest = { 0x0A, 0x04, 0x6A, 0xAA, 0x02, 0x55, 0xE4, 0x32, 0x91, 0x22, 0x28, 0xF8, 0xCC, 0xDA, 0x43, 0x7C,
 275                                 0x8A, 0x83, 0x63, 0xFB, 0x16, 0x0A, 0xFB, 0x05, 0x70, 0xAB, 0x5B, 0x1F, 0xD5, 0xDD, 0xC2, 0x0E,
 276                                 0xB1, 0x88, 0x8B, 0x9E, 0xD4, 0xE5, 0xB6, 0xCB, 0x5B, 0xC0, 0x34, 0xCD, 0x9E, 0xF7, 0x0E, 0x40 };
 277                         HMAC hmac = new SelectableHmacSha384 (key, true);
 278                         Check ("HMACSHA384-L-RFC4231-TC1", hmac, data, digest);
 279                 }
 280
 281                 [Test]
 282                 // Test with a key shorter than the length of the HMAC output.
 283                 public void RFC4231_TC2_Legacy ()
 284                 {
 285                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 286                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 287                         byte[] digest = { 0xBB, 0x8A, 0xF7, 0xF5, 0x8A, 0xC9, 0xE8, 0x3A, 0x87, 0x2E, 0x51, 0x2F, 0x75, 0xD8, 0x74, 0xCC,
 288                                 0x45, 0xE3, 0xDD, 0x1C, 0xD4, 0x76, 0x54, 0x66, 0xCC, 0xEA, 0x19, 0x5B, 0xC3, 0x00, 0x2C, 0xCE,
 289                                 0x3C, 0x9F, 0x1B, 0xAF, 0x44, 0xF2, 0xD7, 0x28, 0x13, 0xA2, 0x4D, 0x11, 0x52, 0xE3, 0x66, 0x6F };
 290                         HMAC hmac = new SelectableHmacSha384 (key, true);
 291                         Check ("HMACSHA384-L-RFC4231-TC2", hmac, data, digest);
 292                 }
 293
 294                 [Test]
 295                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 296                 public void RFC4231_TC3_Legacy ()
 297                 {
 298                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 299                         byte[] data = { 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, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
 302                                 0xdd, 0xdd };
 303                         byte[] digest = { 0x43, 0xAA, 0x39, 0x69, 0x01, 0xAB, 0xF6, 0xFA, 0x3A, 0x5E, 0x85, 0x07, 0x4E, 0xA6, 0x5D, 0x61,
 304                                 0x91, 0xED, 0x86, 0x20, 0x6E, 0xE0, 0x40, 0x23, 0x97, 0x48, 0xE1, 0x35, 0xD5, 0xC6, 0xC1, 0x90,
 305                                 0x9F, 0x1A, 0x39, 0x68, 0xCD, 0x44, 0xA0, 0xB0, 0x48, 0xFE, 0x7C, 0x68, 0x65, 0x44, 0x18, 0x98 };
 306                         HMAC hmac = new SelectableHmacSha384 (key, true);
 307                         Check ("HMACSHA384-L-RFC4231-TC3", hmac, data, digest);
 308                 }
 309
 310                 [Test]
 311                 // Test with a combined length of key and data that is larger than 64 bytes (= block-size of SHA-224 and SHA-256).
 312                 public void RFC4231_TC4_Legacy ()
 313                 {
 314                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 315                                 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 316                         byte[] data = { 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, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
 319                                 0xcd, 0xcd };
 320                         byte[] digest = { 0x1F, 0x20, 0x77, 0xC5, 0xBA, 0x39, 0x38, 0x23, 0x86, 0x47, 0xD0, 0x72, 0x14, 0x32, 0xC5, 0x6A,
 321                                 0x34, 0xDA, 0x36, 0xDD, 0x77, 0x9A, 0xCA, 0xC4, 0xB2, 0xA2, 0xF9, 0xE3, 0x1A, 0xE5, 0xEE, 0x00,
 322                                 0x83, 0xAA, 0x3E, 0x18, 0xDF, 0xD8, 0xBB, 0x6E, 0xEB, 0x0A, 0xF7, 0x37, 0x84, 0x21, 0x8F, 0xB3 };
 323                         HMAC hmac = new SelectableHmacSha384 (key, true);
 324                         Check ("HMACSHA384-L-RFC4231-TC4", hmac, data, digest);
 325                 }
 326
 327                 [Test]
 328                 // Test with a truncation of output to 128 bits.
 329                 public void RFC4231_TC5_Legacy ()
 330                 {
 331                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 332                                 0x0c, 0x0c, 0x0c, 0x0c };
 333                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 334                         byte[] digest = { 0x2E, 0xF2, 0xA4, 0x13, 0xAB, 0x77, 0xBE, 0xCC, 0xF0, 0xB7, 0xD6, 0xAA, 0x6F, 0x60, 0x6B, 0x59 };
 335                         HMAC hmac = new SelectableHmacSha384 (key, true);
 336                         Check ("HMACSHA384-L-RFC4231-TC5", hmac, data, digest);
 337                 }
 338
 339                 [Test]
 340                 // Test with a key larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 341                 public void RFC4231_TC6_Legacy ()
 342                 {
 343                         byte[] key = { 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, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 351                                 0xaa, 0xaa, 0xaa };
 352                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 353                         byte[] digest = { 0xCA, 0xAA, 0x39, 0xF4, 0x53, 0xED, 0x62, 0x43, 0x06, 0x8C, 0x00, 0x95, 0xD8, 0xD3, 0xAC, 0x78,
 354                                 0x80, 0xE8, 0xA4, 0x38, 0x82, 0x90, 0xAC, 0xFA, 0xBA, 0xE9, 0xA1, 0xAC, 0x1C, 0x3F, 0xB3, 0x74,
 355                                 0x34, 0x1C, 0xD1, 0xD2, 0xBE, 0x6C, 0x99, 0x75, 0x2B, 0xDC, 0x98, 0x78, 0x45, 0xB7, 0x08, 0x5F };
 356                         HMAC hmac = new SelectableHmacSha384 (key, true);
 357                         Check ("HMACSHA384-L-RFC4231-TC6", hmac, data, digest);
 358                 }
 359
 360                 [Test]
 361                 // Test with a key and data that is larger than 128 bytes (= block-size of SHA-384 and SHA-512).
 362                 public void RFC4231_TC7_Legacy ()
 363                 {
 364                         byte[] key = { 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, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 372                                 0xaa, 0xaa, 0xaa };
 373                         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.");
 374                         byte[] digest = { 0x5C, 0xF0, 0x92, 0x18, 0x76, 0xCB, 0x51, 0x7E, 0x0E, 0x29, 0xE5, 0x01, 0xCB, 0x70, 0x67, 0x6B,
 375                                 0x63, 0xAE, 0x98, 0x61, 0xB9, 0x66, 0xC2, 0x37, 0xEE, 0x1C, 0x7B, 0x30, 0x84, 0xB1, 0xAA, 0x76,
 376                                 0xEE, 0x81, 0x7A, 0xEF, 0xB4, 0xF4, 0x65, 0x00, 0xCA, 0x67, 0x92, 0xF8, 0x7E, 0xAA, 0x83, 0xBD };
 377                         HMAC hmac = new SelectableHmacSha384 (key, true);
 378                         Check ("HMACSHA384-L-RFC4231-TC7", hmac, data, digest);
 379                 }
 380         }
 381 }
 382