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

   1 //
   2 // HMACMD5Test.cs - NUnit Test Cases for HMACMD5
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 #if NET_2_0
  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         // References:
  21         // a.   IETF RFC2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
  22         //      http://www.ietf.org/rfc/rfc2202.txt
  23
  24         [TestFixture]
  25         public class HMACMD5Test : KeyedHashAlgorithmTest {
  26
  27                 protected HMACMD5 algo;
  28
  29                 [Test]
  30                 public void Constructors ()
  31                 {
  32                         algo = new HMACMD5 ();
  33                         AssertNotNull ("HMACMD5 ()", algo);
  34
  35                         byte[] key = new byte [8];
  36                         algo = new HMACMD5 (key);
  37                         AssertNotNull ("HMACMD5 (key)", algo);
  38
  39                         try {
  40                                 algo = new HMACMD5 (null);
  41                                 Fail ("HMACMD5 (null) - Expected NullReferenceException but got none");
  42                         }
  43                         catch (NullReferenceException) {
  44                                 // well ArgumentNullException would have been more appropriate
  45                         }
  46                         catch (Exception e) {
  47                                 Fail ("HMACMD5 (null) - Expected NullReferenceException but got: " + e.ToString ());
  48                         }
  49                 }
  50
  51                 [Test]
  52                 public void Invariants ()
  53                 {
  54                         algo = new HMACMD5 ();
  55                         AssertEquals ("HMACMD5.CanReuseTransform", true, algo.CanReuseTransform);
  56                         AssertEquals ("HMACMD5.CanTransformMultipleBlocks", true, algo.CanTransformMultipleBlocks);
  57                         AssertEquals ("HMACMD5.HashName", "MD5", algo.HashName);
  58                         AssertEquals ("HMACMD5.HashSize", 128, algo.HashSize);
  59                         AssertEquals ("HMACMD5.InputBlockSize", 1, algo.InputBlockSize);
  60                         AssertEquals ("HMACMD5.OutputBlockSize", 1, algo.OutputBlockSize);
  61                         AssertEquals ("HMACMD5.ToString()", "System.Security.Cryptography.HMACMD5", algo.ToString ());
  62                 }
  63
  64                 public void Check (string testName, byte[] key, byte[] data, byte[] result)
  65                 {
  66                         string classTestName = "HMACMD5-" + testName;
  67                         CheckA (testName, key, data, result);
  68                         CheckB (testName, key, data, result);
  69                         CheckC (testName, key, data, result);
  70                         CheckD (testName, key, data, result);
  71                         CheckE (testName, key, data, result);
  72                 }
  73
  74                 public void CheckA (string testName, byte[] key, byte[] data, byte[] result)
  75                 {
  76                         algo = new HMACMD5 ();
  77                         algo.Key = key;
  78                         byte[] hmac = algo.ComputeHash (data);
  79                         AssertEquals (testName + "a1", result, hmac);
  80                         AssertEquals (testName + "a2", result, algo.Hash);
  81                 }
  82
  83                 public void CheckB (string testName, byte[] key, byte[] data, byte[] result)
  84                 {
  85                         algo = new HMACMD5 ();
  86                         algo.Key = key;
  87                         byte[] hmac = algo.ComputeHash (data, 0, data.Length);
  88                         AssertEquals (testName + "b1", result, hmac);
  89                         AssertEquals (testName + "b2", result, algo.Hash);
  90                 }
  91
  92                 public void CheckC (string testName, byte[] key, byte[] data, byte[] result)
  93                 {
  94                         algo = new HMACMD5 ();
  95                         algo.Key = key;
  96                         MemoryStream ms = new MemoryStream (data);
  97                         byte[] hmac = algo.ComputeHash (ms);
  98                         AssertEquals (testName + "c1", result, hmac);
  99                         AssertEquals (testName + "c2", result, algo.Hash);
 100                 }
 101
 102                 public void CheckD (string testName, byte[] key, byte[] data, byte[] result)
 103                 {
 104                         algo = new HMACMD5 ();
 105                         algo.Key = key;
 106                         // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 107                         algo.TransformFinalBlock (data, 0, data.Length);
 108                         AssertEquals (testName + "d", result, algo.Hash);
 109                 }
 110
 111                 public void CheckE (string testName, byte[] key, byte[] data, byte[] result)
 112                 {
 113                         algo = new HMACMD5 ();
 114                         algo.Key = key;
 115                         byte[] copy = new byte [data.Length];
 116                         // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 117                         for (int i=0; i < data.Length - 1; i++)
 118                                 algo.TransformBlock (data, i, 1, copy, i);
 119                         algo.TransformFinalBlock (data, data.Length - 1, 1);
 120                         AssertEquals (testName + "e", result, algo.Hash);
 121                 }
 122
 123                 [Test]
 124                 public void RFC2202_TC1 ()
 125                 {
 126                         byte[] key =  { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 127                         byte[] data = Encoding.Default.GetBytes ("Hi There");
 128                         byte[] digest = { 0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c, 0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d };
 129                         Check ("RFC2202-TC1", key, data, digest);
 130                 }
 131
 132                 [Test]
 133                 public void RFC2202_TC2 ()
 134                 {
 135                         byte[] key = Encoding.Default.GetBytes ("Jefe");
 136                         byte[] data = Encoding.Default.GetBytes ("what do ya want for nothing?");
 137                         byte[] digest = { 0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03, 0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38 };
 138                         Check ("RFC2202-TC2", key, data, digest);
 139                 }
 140
 141                 [Test]
 142                 public void RFC2202_TC3 ()
 143                 {
 144                         byte[] key = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
 145                         byte[] data = new byte [50];
 146                         for (int i = 0; i < data.Length; i++)
 147                                 data[i] = 0xdd;
 148                         byte[] digest = { 0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88, 0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6 };
 149                         Check ("RFC2202-TC3", key, data, digest);
 150                 }
 151
 152                 [Test]
 153                 public void RFC2202_TC4 ()
 154                 {
 155                         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 };
 156                         byte[] data = new byte [50];
 157                         for (int i = 0; i < data.Length; i++)
 158                                 data[i] = 0xcd;
 159                         byte[] digest = { 0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea, 0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79 };
 160                         Check ("RFC2202-TC4", key, data, digest);
 161                 }
 162
 163                 [Test]
 164                 public void RFC2202_TC5 ()
 165                 {
 166                         byte[] key = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c };
 167                         byte[] data = Encoding.Default.GetBytes ("Test With Truncation");
 168                         byte[] digest = { 0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00, 0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c };
 169                         Check ("RFC2202-TC5", key, data, digest);
 170                 }
 171
 172                 [Test]
 173                 public void RFC2202_TC6 ()
 174                 {
 175                         byte[] key = new byte [80];
 176                         for (int i = 0; i < key.Length; i++)
 177                                 key[i] = 0xaa;
 178                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key - Hash Key First");
 179                         byte[] digest = { 0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f, 0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd };
 180                         Check ("RFC2202-TC6", key, data, digest);
 181                 }
 182
 183                 [Test]
 184                 public void RFC2202_TC7 ()
 185                 {
 186                         byte[] key = new byte [80];
 187                         for (int i = 0; i < key.Length; i++)
 188                                 key[i] = 0xaa;
 189                         byte[] data = Encoding.Default.GetBytes ("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
 190                         byte[] digest = { 0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee, 0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e };
 191                         Check ("RFC2202-TC7", key, data, digest);
 192                 }
 193         }
 194
 195 }
 196
 197 #endif