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