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

   1 //
   2 // HMACMD5Test.cs - NUnit Test Cases for HMACMD5
   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 HM5 : HMACMD5 {
  21
  22                 public int BlockSize {
  23                         get { return base.BlockSizeValue; }
  24                         set { base.BlockSizeValue = value; }
  25                 }
  26         }
  27
  28         // References:
  29         // a.   IETF RFC2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
  30         //      http://www.ietf.org/rfc/rfc2202.txt
  31
  32         [TestFixture]
  33         public class HMACMD5Test : KeyedHashAlgorithmTest {
  34
  35                 protected HMACMD5 algo;
  36
  37                 [SetUp]
  38                 public override void SetUp ()
  39                 {
  40                         algo = new HMACMD5 ();
  41                         algo.Key = new byte [8];
  42                         hash = algo;
  43                 }
  44
  45                 [Test]
  46                 public void Constructors ()
  47                 {
  48                         algo = new HMACMD5 ();
  49                         Assert.IsNotNull (algo, "HMACMD5 ()");
  50
  51                         byte[] key = new byte [8];
  52                         algo = new HMACMD5 (key);
  53                         Assert.IsNotNull (algo, "HMACMD5 (key)");
  54                 }
  55
  56                 [Test]
  57                 [ExpectedException (typeof (NullReferenceException))]
  58                 public void Constructor_Null ()
  59                 {
  60                         new HMACMD5 (null);
  61                 }
  62
  63                 [Test]
  64                 public void Invariants ()
  65                 {
  66                         algo = new HMACMD5 ();
  67                         Assert.IsTrue (algo.CanReuseTransform, "HMACMD5.CanReuseTransform");
  68                         Assert.IsTrue (algo.CanTransformMultipleBlocks, "HMACMD5.CanTransformMultipleBlocks");
  69                         Assert.AreEqual ("MD5", algo.HashName, "HMACMD5.HashName");
  70                         Assert.AreEqual (128, algo.HashSize, "HMACMD5.HashSize");
  71                         Assert.AreEqual (1, algo.InputBlockSize, "HMACMD5.InputBlockSize");
  72                         Assert.AreEqual (1, algo.OutputBlockSize, "HMACMD5.OutputBlockSize");
  73                         Assert.AreEqual ("System.Security.Cryptography.HMACMD5", algo.ToString (), "HMACMD5.ToString()");
  74                 }
  75
  76                 [Test]
  77                 public void BlockSize ()
  78                 {
  79                         HM5 hmac = new HM5 ();
  80                         Assert.AreEqual (64, hmac.BlockSize, "BlockSizeValue");
  81                 }
  82
  83                 public void Check (string testName, byte[] key, byte[] data, byte[] result)
  84                 {
  85                         string classTestName = "HMACMD5-" + testName;
  86                         CheckA (testName, key, data, result);
  87                         CheckB (testName, key, data, result);
  88                         CheckC (testName, key, data, result);
  89                         CheckD (testName, key, data, result);
  90                         CheckE (testName, key, data, result);
  91                 }
  92
  93                 public void CheckA (string testName, byte[] key, byte[] data, byte[] result)
  94                 {
  95                         algo = new HMACMD5 ();
  96                         algo.Key = key;
  97                         byte[] hmac = algo.ComputeHash (data);
  98                         Assert.AreEqual (result, hmac, testName + "a1");
  99                         Assert.AreEqual (result, algo.Hash, testName + "a2");
 100                 }
 101
 102                 public void CheckB (string testName, byte[] key, byte[] data, byte[] result)
 103                 {
 104                         algo = new HMACMD5 ();
 105                         algo.Key = key;
 106                         byte[] hmac = algo.ComputeHash (data, 0, data.Length);
 107                         Assert.AreEqual (result, hmac, testName + "b1");
 108                         Assert.AreEqual (result, algo.Hash, testName + "b2");
 109                 }
 110
 111                 public void CheckC (string testName, byte[] key, byte[] data, byte[] result)
 112                 {
 113                         algo = new HMACMD5 ();
 114                         algo.Key = key;
 115                         MemoryStream ms = new MemoryStream (data);
 116                         byte[] hmac = algo.ComputeHash (ms);
 117                         Assert.AreEqual (result, hmac, testName + "c1");
 118                         Assert.AreEqual (result, algo.Hash, testName + "c2");
 119                 }
 120
 121                 public void CheckD (string testName, byte[] key, byte[] data, byte[] result)
 122                 {
 123                         algo = new HMACMD5 ();
 124                         algo.Key = key;
 125                         // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 126                         algo.TransformFinalBlock (data, 0, data.Length);
 127                         Assert.AreEqual (result, algo.Hash, testName + "d");
 128                 }
 129
 130                 public void CheckE (string testName, byte[] key, byte[] data, byte[] result)
 131                 {
 132                         algo = new HMACMD5 ();
 133                         algo.Key = key;
 134                         byte[] copy = new byte [data.Length];
 135                         // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 136                         for (int i=0; i < data.Length - 1; i++)
 137                                 algo.TransformBlock (data, i, 1, copy, i);
 138                         algo.TransformFinalBlock (data, data.Length - 1, 1);
 139                         Assert.AreEqual (result, algo.Hash, testName + "e");
 140                 }
 141
 142                 [Test]
 143                 public void RFC2202_TC1 ()
 144                 {
 145                         byte[] key =  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 146                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 147                         byte[] digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c, 0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d };
 148                         Check ("RFC2202-TC1", key, data, digest);
 149                 }
 150
 151                 [Test]
 152                 public void RFC2202_TC2 ()
 153                 {
 154                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 155                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 156                         byte[] digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03, 0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 };
 157                         Check ("RFC2202-TC2", key, data, digest);
 158                 }
 159
 160                 [Test]
 161                 public void RFC2202_TC3 ()
 162                 {
 163                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 164                         byte[] data = new byte [50];
 165                         for (int i = 0; i < data.Length; i++)
 166                                 data[i] = 0xdd;
 167                         byte[] digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88, 0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 };
 168                         Check ("RFC2202-TC3", key, data, digest);
 169                 }
 170
 171                 [Test]
 172                 public void RFC2202_TC4 ()
 173                 {
 174                         byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19 };
 175                         byte[] data = new byte [50];
 176                         for (int i = 0; i < data.Length; i++)
 177                                 data[i] = 0xcd;
 178                         byte[] digest = { 0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea, 0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79 };
 179                         Check ("RFC2202-TC4", key, data, digest);
 180                 }
 181
 182                 [Test]
 183                 public void RFC2202_TC5 ()
 184                 {
 185                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c };
 186                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 187                         byte[] digest = { 0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00, 0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c };
 188                         Check ("RFC2202-TC5", key, data, digest);
 189                 }
 190
 191                 [Test]
 192                 public void RFC2202_TC6 ()
 193                 {
 194                         byte[] key = new byte [80];
 195                         for (int i = 0; i < key.Length; i++)
 196                                 key[i] = 0xaa;
 197                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 198                         byte[] digest = { 0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f, 0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd };
 199                         Check ("RFC2202-TC6", key, data, digest);
 200                 }
 201
 202                 [Test]
 203                 public void RFC2202_TC7 ()
 204                 {
 205                         byte[] key = new byte [80];
 206                         for (int i = 0; i < key.Length; i++)
 207                                 key[i] = 0xaa;
 208                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
 209                         byte[] digest = { 0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee, 0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e };
 210                         Check ("RFC2202-TC7", key, data, digest);
 211                 }
 212
 213                 [Test]
 214                 public void Create_Incorrect ()
 215                 {
 216                         var x = HMACMD5.Create ();
 217                         Assert.AreEqual ("SHA1", x.HashName, "https://connect.microsoft.com/VisualStudio/feedback/details/838731/all-hmac-create-methods-return-an-instance-of-hmacmd5");
 218                 }
 219         }
 220 }
 221