mcs/class/Mono.Security/Test/Mono.Security.Cryptography/CryptoConvertTest.cs

   1 //
   2 // CryptoConvertTest.cs - NUnit Test Cases for CryptoConvert
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2004 Novell (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Security.Cryptography;
  13 using Mono.Security.Cryptography;
  14
  15 namespace MonoTests.Mono.Security.Cryptography {
  16
  17         [TestFixture]
  18         public class CryptoConvertTest : Assertion {
  19
  20                 // because most crypto stuff works with byte[] buffers
  21                 static public void AssertEquals (string msg, byte[] array1, byte[] array2)
  22                 {
  23                         if ((array1 == null) && (array2 == null))
  24                                 return;
  25                         if (array1 == null)
  26                                 Fail (msg + " -> First array is NULL");
  27                         if (array2 == null)
  28                                 Fail (msg + " -> Second array is NULL");
  29
  30                         bool a = (array1.Length == array2.Length);
  31                         if (a) {
  32                                 for (int i = 0; i < array1.Length; i++) {
  33                                         if (array1 [i] != array2 [i]) {
  34                                                 a = false;
  35                                                 break;
  36                                         }
  37                                 }
  38                         }
  39                         msg += " -> Expected " + BitConverter.ToString (array1, 0);
  40                         msg += " is different than " + BitConverter.ToString (array2, 0);
  41                         Assert (msg, a);
  42                 }
  43
  44                 // strongname generated using "sn -k unit.snk"
  45                 static byte[] strongName = {
  46                         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32,
  47                         0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x7C, 0xEA, 0x4A,
  48                         0x28, 0x33, 0xD8, 0x3C, 0x86, 0x90, 0x86, 0x91, 0x11, 0xBB, 0x30, 0x0D,
  49                         0x3D, 0x69, 0x04, 0x4C, 0x48, 0xF5, 0x4F, 0xE7, 0x64, 0xA5, 0x82, 0x72,
  50                         0x5A, 0x92, 0xC4, 0x3D, 0xC5, 0x90, 0x93, 0x41, 0xC9, 0x1D, 0x34, 0x16,
  51                         0x72, 0x2B, 0x85, 0xC1, 0xF3, 0x99, 0x62, 0x07, 0x32, 0x98, 0xB7, 0xE4,
  52                         0xFA, 0x75, 0x81, 0x8D, 0x08, 0xB9, 0xFD, 0xDB, 0x00, 0x25, 0x30, 0xC4,
  53                         0x89, 0x13, 0xB6, 0x43, 0xE8, 0xCC, 0xBE, 0x03, 0x2E, 0x1A, 0x6A, 0x4D,
  54                         0x36, 0xB1, 0xEB, 0x49, 0x26, 0x6C, 0xAB, 0xC4, 0x29, 0xD7, 0x8F, 0x25,
  55                         0x11, 0xA4, 0x7C, 0x81, 0x61, 0x97, 0xCB, 0x44, 0x2D, 0x80, 0x49, 0x93,
  56                         0x48, 0xA7, 0xC9, 0xAB, 0xDB, 0xCF, 0xA3, 0x34, 0xCB, 0x6B, 0x86, 0xE0,
  57                         0x4D, 0x27, 0xFC, 0xA7, 0x4F, 0x36, 0xCA, 0x13, 0x42, 0xD3, 0x83, 0xC4,
  58                         0x06, 0x6E, 0x12, 0xE0, 0xA1, 0x3D, 0x9F, 0xA9, 0xEC, 0xD1, 0xC6, 0x08,
  59                         0x1B, 0x3D, 0xF5, 0xDB, 0x4C, 0xD4, 0xF0, 0x2C, 0xAA, 0xFC, 0xBA, 0x18,
  60                         0x6F, 0x48, 0x7E, 0xB9, 0x47, 0x68, 0x2E, 0xF6, 0x1E, 0x67, 0x1C, 0x7E,
  61                         0x0A, 0xCE, 0x10, 0x07, 0xC0, 0x0C, 0xAD, 0x5E, 0xC1, 0x53, 0x70, 0xD5,
  62                         0xE7, 0x25, 0xCA, 0x37, 0x5E, 0x49, 0x59, 0xD0, 0x67, 0x2A, 0xBE, 0x92,
  63                         0x36, 0x86, 0x8A, 0xBF, 0x3E, 0x17, 0x04, 0xFB, 0x1F, 0x46, 0xC8, 0x10,
  64                         0x5C, 0x93, 0x02, 0x43, 0x14, 0x96, 0x6A, 0xD9, 0x87, 0x17, 0x62, 0x7D,
  65                         0x3A, 0x45, 0xBE, 0x35, 0xDE, 0x75, 0x0B, 0x2A, 0xCE, 0x7D, 0xF3, 0x19,
  66                         0x85, 0x4B, 0x0D, 0x6F, 0x8D, 0x15, 0xA3, 0x60, 0x61, 0x28, 0x55, 0x46,
  67                         0xCE, 0x78, 0x31, 0x04, 0x18, 0x3C, 0x56, 0x4A, 0x3F, 0xA4, 0xC9, 0xB1,
  68                         0x41, 0xED, 0x22, 0x80, 0xA1, 0xB3, 0xE2, 0xC7, 0x1B, 0x62, 0x85, 0xE4,
  69                         0x81, 0x39, 0xCB, 0x1F, 0x95, 0xCC, 0x61, 0x61, 0xDF, 0xDE, 0xF3, 0x05,
  70                         0x68, 0xB9, 0x7D, 0x4F, 0xFF, 0xF3, 0xC0, 0x0A, 0x25, 0x62, 0xD9, 0x8A,
  71                         0x8A, 0x9E, 0x99, 0x0B, 0xFB, 0x85, 0x27, 0x8D, 0xF6, 0xD4, 0xE1, 0xB9,
  72                         0xDE, 0xB4, 0x16, 0xBD, 0xDF, 0x6A, 0x25, 0x9C, 0xAC, 0xCD, 0x91, 0xF7,
  73                         0xCB, 0xC1, 0x81, 0x22, 0x0D, 0xF4, 0x7E, 0xEC, 0x0C, 0x84, 0x13, 0x5A,
  74                         0x74, 0x59, 0x3F, 0x3E, 0x61, 0x00, 0xD6, 0xB5, 0x4A, 0xA1, 0x04, 0xB5,
  75                         0xA7, 0x1C, 0x29, 0xD0, 0xE1, 0x11, 0x19, 0xD7, 0x80, 0x5C, 0xEE, 0x08,
  76                         0x15, 0xEB, 0xC9, 0xA8, 0x98, 0xF5, 0xA0, 0xF0, 0x92, 0x2A, 0xB0, 0xD3,
  77                         0xC7, 0x8C, 0x8D, 0xBB, 0x88, 0x96, 0x4F, 0x18, 0xF0, 0x8A, 0xF9, 0x31,
  78                         0x9E, 0x44, 0x94, 0x75, 0x6F, 0x78, 0x04, 0x10, 0xEC, 0xF3, 0xB0, 0xCE,
  79                         0xA0, 0xBE, 0x7B, 0x25, 0xE1, 0xF7, 0x8A, 0xA8, 0xD4, 0x63, 0xC2, 0x65,
  80                         0x47, 0xCC, 0x5C, 0xED, 0x7D, 0x8B, 0x07, 0x4D, 0x76, 0x29, 0x53, 0xAC,
  81                         0x27, 0x8F, 0x5D, 0x78, 0x56, 0xFA, 0x99, 0x45, 0xA2, 0xCC, 0x65, 0xC4,
  82                         0x54, 0x13, 0x9F, 0x38, 0x41, 0x7A, 0x61, 0x0E, 0x0D, 0x34, 0xBC, 0x11,
  83                         0xAF, 0xE2, 0xF1, 0x8B, 0xFA, 0x2B, 0x54, 0x6C, 0xA3, 0x6C, 0x09, 0x1F,
  84                         0x0B, 0x43, 0x9B, 0x07, 0x95, 0x83, 0x3F, 0x97, 0x99, 0x89, 0xF5, 0x51,
  85                         0x41, 0xF6, 0x8E, 0x5D, 0xEF, 0x6D, 0x24, 0x71, 0x41, 0x7A, 0xAF, 0xBE,
  86                         0x81, 0x71, 0xAB, 0x76, 0x2F, 0x1A, 0x5A, 0xBA, 0xF3, 0xA6, 0x65, 0x7A,
  87                         0x80, 0x50, 0xCE, 0x23, 0xC3, 0xC7, 0x53, 0xB0, 0x7C, 0x97, 0x77, 0x27,
  88                         0x70, 0x98, 0xAE, 0xB5, 0x24, 0x66, 0xE1, 0x60, 0x39, 0x41, 0xDA, 0x54,
  89                         0x01, 0x64, 0xFB, 0x10, 0x33, 0xCE, 0x8B, 0xBE, 0x27, 0xD4, 0x21, 0x57,
  90                         0xCC, 0x0F, 0x1A, 0xC1, 0x3D, 0xF3, 0xCC, 0x39, 0xF0, 0x2F, 0xAE, 0xF1,
  91                         0xC0, 0xCD, 0x3B, 0x23, 0x87, 0x49, 0x7E, 0x40, 0x32, 0x6A, 0xD3, 0x96,
  92                         0x4A, 0xE5, 0x5E, 0x6E, 0x26, 0xFD, 0x8A, 0xCF, 0x7E, 0xFC, 0x37, 0xDE,
  93                         0x39, 0x0C, 0x53, 0x81, 0x75, 0x08, 0xAF, 0x6B, 0x39, 0x6C, 0xFB, 0xC9,
  94                         0x79, 0xC0, 0x9B, 0x5F, 0x34, 0x86, 0xB2, 0xDE, 0xC4, 0x19, 0x84, 0x5F,
  95                         0x0E, 0xED, 0x9B, 0xB8, 0xD3, 0x17, 0xDA, 0x78 };
  96
  97                 static string strongNameString = "<RSAKeyValue><Modulus>4BJuBsSD00ITyjZPp/wnTeCGa8s0o8/bq8mnSJNJgC1Ey5dhgXykESWP1ynEq2wmSeuxNk1qGi4DvszoQ7YTicQwJQDb/bkIjYF1+uS3mDIHYpnzwYUrchY0HclBk5DFPcSSWnKCpWTnT/VITARpPQ0wuxGRhpCGPNgzKErqfH8=</Modulus><Exponent>AQAB</Exponent><P>+wQXPr+KhjaSvipn0FlJXjfKJefVcFPBXq0MwAcQzgp+HGce9i5oR7l+SG8YuvyqLPDUTNv1PRsIxtHsqZ89oQ==</P><Q>5IViG8fis6GAIu1BscmkP0pWPBgEMXjORlUoYWCjFY1vDUuFGfN9zioLdd41vkU6fWIXh9lqlhRDApNcEMhGHw==</Q><DP>Pj9ZdFoThAzsfvQNIoHBy/eRzaycJWrfvRa03rnh1PaNJ4X7C5meiorZYiUKwPP/T325aAXz3t9hYcyVH8s5gQ==</DP><DQ>qIr34SV7vqDOsPPsEAR4b3WURJ4x+YrwGE+WiLuNjMfTsCqS8KD1mKjJ6xUI7lyA1xkR4dApHKe1BKFKtdYAYQ==</DQ><InverseQ>UfWJmZc/g5UHm0MLHwlso2xUK/qL8eKvEbw0DQ5hekE4nxNUxGXMokWZ+lZ4XY8nrFMpdk0Hi33tXMxHZcJj1A==</InverseQ><D>eNoX07ib7Q5fhBnE3rKGNF+bwHnJ+2w5a68IdYFTDDneN/x+z4r9Jm5e5UqW02oyQH5JhyM7zcDxri/wOczzPcEaD8xXIdQnvovOMxD7ZAFU2kE5YOFmJLWumHAnd5d8sFPHwyPOUIB6ZabzuloaL3arcYG+r3pBcSRt712O9kE=</D></RSAKeyValue>";
  98
  99                 // strongname public key extracted using "sn -p unit.snk unit.pub"
 100                 static byte[] strongNamePublicKey = {
 101                         0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
 102                         0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x31,
 103                         0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x7C, 0xEA, 0x4A,
 104                         0x28, 0x33, 0xD8, 0x3C, 0x86, 0x90, 0x86, 0x91, 0x11, 0xBB, 0x30, 0x0D,
 105                         0x3D, 0x69, 0x04, 0x4C, 0x48, 0xF5, 0x4F, 0xE7, 0x64, 0xA5, 0x82, 0x72,
 106                         0x5A, 0x92, 0xC4, 0x3D, 0xC5, 0x90, 0x93, 0x41, 0xC9, 0x1D, 0x34, 0x16,
 107                         0x72, 0x2B, 0x85, 0xC1, 0xF3, 0x99, 0x62, 0x07, 0x32, 0x98, 0xB7, 0xE4,
 108                         0xFA, 0x75, 0x81, 0x8D, 0x08, 0xB9, 0xFD, 0xDB, 0x00, 0x25, 0x30, 0xC4,
 109                         0x89, 0x13, 0xB6, 0x43, 0xE8, 0xCC, 0xBE, 0x03, 0x2E, 0x1A, 0x6A, 0x4D,
 110                         0x36, 0xB1, 0xEB, 0x49, 0x26, 0x6C, 0xAB, 0xC4, 0x29, 0xD7, 0x8F, 0x25,
 111                         0x11, 0xA4, 0x7C, 0x81, 0x61, 0x97, 0xCB, 0x44, 0x2D, 0x80, 0x49, 0x93,
 112                         0x48, 0xA7, 0xC9, 0xAB, 0xDB, 0xCF, 0xA3, 0x34, 0xCB, 0x6B, 0x86, 0xE0,
 113                         0x4D, 0x27, 0xFC, 0xA7, 0x4F, 0x36, 0xCA, 0x13, 0x42, 0xD3, 0x83, 0xC4,
 114                         0x06, 0x6E, 0x12, 0xE0 };
 115
 116                 static string strongNamePublicKeyString = "<RSAKeyValue><Modulus>4BJuBsSD00ITyjZPp/wnTeCGa8s0o8/bq8mnSJNJgC1Ey5dhgXykESWP1ynEq2wmSeuxNk1qGi4DvszoQ7YTicQwJQDb/bkIjYF1+uS3mDIHYpnzwYUrchY0HclBk5DFPcSSWnKCpWTnT/VITARpPQ0wuxGRhpCGPNgzKErqfH8=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
 117
 118                 static  byte[] strongNameNUnit = {
 119                         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32,
 120                         0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0xCF, 0x4A, 0x0B, 0xBF,
 121                         0x35, 0x4B, 0x6D, 0x8D, 0x0C, 0x39, 0xE7, 0xBC, 0x40, 0xDD, 0x0B, 0xE1,
 122                         0x6A, 0x32, 0xBA, 0x9D, 0x76, 0x3E, 0x8D, 0x04, 0xFD, 0x95, 0x91, 0xB9,
 123                         0x2D, 0x72, 0x69, 0xDD, 0x09, 0xC2, 0xC6, 0x5E, 0xC7, 0x56, 0x3C, 0xE3,
 124                         0x93, 0xAC, 0xA7, 0x19, 0x13, 0xBE, 0xA1, 0x3D, 0xD6, 0xA2, 0x0D, 0x67,
 125                         0x6E, 0xD7, 0xDD, 0xC7, 0x26, 0xF8, 0x46, 0xFC, 0xE6, 0x68, 0x00, 0xBB,
 126                         0x03, 0x49, 0x03, 0x61, 0x9A, 0x1B, 0xAA, 0x52, 0x0F, 0x5F, 0x75, 0x89,
 127                         0x46, 0xCF, 0x2B, 0x4A, 0xF6, 0xBA, 0x7C, 0x31, 0x0D, 0x02, 0xD0, 0x92,
 128                         0xA5, 0xCF, 0x51, 0xBE, 0x6D, 0x52, 0xE8, 0x86, 0x33, 0xF5, 0x02, 0x47,
 129                         0x4B, 0x4F, 0x46, 0x1D, 0x85, 0x0B, 0x63, 0x21, 0x9C, 0x09, 0xA3, 0x37,
 130                         0x3A, 0x23, 0xD7, 0x31, 0x56, 0xEE, 0x03, 0xD6, 0xC7, 0xB3, 0x8C, 0x36,
 131                         0xD1, 0x21, 0x1F, 0xAC, 0xCD, 0xA7, 0x7F, 0x90, 0x33, 0x0B, 0x49, 0x62,
 132                         0xA6, 0xAD, 0xD1, 0xF5, 0x65, 0xC2, 0x78, 0x94, 0x0F, 0xB5, 0xC4, 0x4C,
 133                         0x3A, 0xC3, 0x06, 0xD1, 0x6B, 0x7C, 0x87, 0x2B, 0x57, 0xE2, 0xBB, 0x5D,
 134                         0x10, 0x85, 0x6E, 0xD7, 0xFC, 0x2D, 0x5F, 0xF4, 0x8A, 0xEA, 0xA7, 0xD7,
 135                         0x39, 0x84, 0x22, 0x12, 0xCF, 0x6E, 0x13, 0xC6, 0x45, 0x3B, 0xDB, 0xFD,
 136                         0xCE, 0xBD, 0x2B, 0x5A, 0x18, 0x29, 0xDE, 0xD9, 0x0B, 0x69, 0xAC, 0x30,
 137                         0x7B, 0x19, 0x2C, 0x35, 0x38, 0xFE, 0x5A, 0x73, 0x72, 0x32, 0xA5, 0x47,
 138                         0x48, 0xEA, 0xD7, 0x05, 0x83, 0x93, 0x5A, 0xAC, 0x59, 0xDC, 0x08, 0xE2,
 139                         0x44, 0x67, 0xAA, 0x0E, 0xB1, 0xA0, 0x73, 0xAC, 0xFB, 0x62, 0x2C, 0x31,
 140                         0x15, 0xE7, 0x83, 0xB5, 0x3F, 0xCF, 0xA4, 0x4C, 0x23, 0x57, 0x3B, 0x61,
 141                         0x59, 0x23, 0x50, 0x0E, 0xE7, 0xAE, 0x8E, 0x69, 0x78, 0x41, 0x3F, 0xCA,
 142                         0x95, 0xAC, 0x41, 0x59, 0x71, 0x25, 0xDA, 0x58, 0x91, 0x04, 0x8B, 0xBA,
 143                         0xF9, 0x5B, 0xF1, 0x33, 0xD4, 0x4F, 0x43, 0x99, 0x10, 0x6A, 0x2A, 0x4D,
 144                         0x78, 0xE7, 0x21, 0xE9, 0x47, 0x65, 0x81, 0xE9, 0x74, 0xB2, 0x6F, 0xE5,
 145                         0xFA, 0xB9, 0xEC, 0x37, 0x5B, 0x1D, 0x21, 0x31, 0x92, 0x5C, 0xCF, 0xFF,
 146                         0xBC, 0x34, 0xA5, 0x44, 0x48, 0xF7, 0xE3, 0xF1, 0x28, 0xE1, 0xC6, 0x39,
 147                         0x8F, 0x00, 0xC9, 0x70, 0x4B, 0x06, 0x0B, 0x0C, 0x66, 0x1E, 0xCF, 0x54,
 148                         0xEA, 0xE2, 0xA8, 0xFC, 0xE4, 0xBA, 0x1C, 0xA0, 0xA9, 0x71, 0x16, 0x51,
 149                         0x97, 0xA8, 0xBC, 0x4A, 0x95, 0x42, 0x71, 0x9F, 0x01, 0x5B, 0xEC, 0x07,
 150                         0x69, 0x7E, 0xB1, 0xB6, 0x92, 0x3D, 0x55, 0xE1, 0x48, 0xA6, 0x8F, 0x47,
 151                         0x5A, 0xBF, 0x47, 0x00, 0xF8, 0x1E, 0x2F, 0xE4, 0x62, 0x9F, 0xDD, 0x2F,
 152                         0x33, 0x2F, 0x9B, 0xF1, 0x5C, 0x93, 0x3E, 0x83, 0x65, 0xEA, 0x12, 0x4E,
 153                         0x9E, 0xDA, 0x6F, 0x6A, 0x51, 0x03, 0x8C, 0x2F, 0x47, 0xEB, 0x5C, 0x5B,
 154                         0x40, 0xC2, 0xE8, 0x4D, 0xC5, 0xA3, 0xC4, 0x8D, 0x30, 0x9A, 0xD4, 0x8E,
 155                         0x7D, 0x4D, 0xA6, 0x89, 0x81, 0x72, 0x82, 0x47, 0x5F, 0xAA, 0x4B, 0xBB,
 156                         0xD5, 0x8C, 0x75, 0x78, 0x21, 0x0F, 0x4B, 0xAA, 0x2E, 0x12, 0xF9, 0xF5,
 157                         0x81, 0x88, 0x72, 0x22, 0xD7, 0x77, 0xB4, 0x5F, 0x85, 0x12, 0xE5, 0xC7,
 158                         0x31, 0x2F, 0x4E, 0x3C, 0x63, 0xE9, 0x47, 0x79, 0x3C, 0x21, 0x5B, 0xDD,
 159                         0xED, 0x1C, 0x6A, 0xFD, 0x87, 0x01, 0xD2, 0x34, 0x0C, 0xEC };
 160
 161                 [Test]
 162                 public void FromCapiKeyBlob ()
 163                 {
 164                         // keypair
 165                         RSA rsa = CryptoConvert.FromCapiKeyBlob (strongName, 0);
 166                         AssertEquals ("KeyPair", strongNameString, rsa.ToXmlString (true));
 167                         AssertEquals ("PublicKey-1", strongNamePublicKeyString, rsa.ToXmlString (false));
 168
 169                         // public key (direct)
 170                         rsa = CryptoConvert.FromCapiKeyBlob (strongNamePublicKey, 12);
 171                         AssertEquals ("PublicKey-2", strongNamePublicKeyString, rsa.ToXmlString (false));
 172
 173                         // public key (indirect - inside header)
 174                         rsa = CryptoConvert.FromCapiKeyBlob (strongNamePublicKey, 0);
 175                         AssertEquals ("PublicKey-3", strongNamePublicKeyString, rsa.ToXmlString (false));
 176                 }
 177
 178                 [Test]
 179                 [ExpectedException (typeof (ArgumentNullException))]
 180                 public void FromCapiKeyBlob_Null ()
 181                 {
 182                         RSA rsa = CryptoConvert.FromCapiKeyBlob (null);
 183                 }
 184
 185                 [Test]
 186                 [ExpectedException (typeof (ArgumentException))]
 187                 public void FromCapiKeyBlob_InvalidOffset ()
 188                 {
 189                         RSA rsa = CryptoConvert.FromCapiKeyBlob (new byte [0], 0);
 190                 }
 191
 192                 [Test]
 193                 [ExpectedException (typeof (CryptographicException))]
 194                 public void FromCapiKeyBlob_UnknownBlob ()
 195                 {
 196                         byte[] blob = new byte [160];
 197                         RSA rsa = CryptoConvert.FromCapiKeyBlob (blob, 12);
 198                 }
 199
 200                 [Test]
 201                 public void FromCapiPrivateKeyBlob ()
 202                 {
 203                         RSA rsa = CryptoConvert.FromCapiPrivateKeyBlob (strongName, 0);
 204                         AssertEquals ("KeyPair", strongNameString, rsa.ToXmlString (true));
 205                 }
 206
 207                 [Test]
 208                 [ExpectedException (typeof (ArgumentNullException))]
 209                 public void FromCapiPrivateKeyBlob_Null ()
 210                 {
 211                         RSA rsa = CryptoConvert.FromCapiPrivateKeyBlob (null);
 212                 }
 213
 214                 [Test]
 215                 [ExpectedException (typeof (ArgumentException))]
 216                 public void FromCapiPrivateKeyBlob_InvalidOffset ()
 217                 {
 218                         RSA rsa = CryptoConvert.FromCapiPrivateKeyBlob (new byte [0], 0);
 219                 }
 220
 221                 [Test]
 222                 [ExpectedException (typeof (CryptographicException))]
 223                 public void FromCapiPrivateKeyBlob_Invalid ()
 224                 {
 225                         RSA rsa = CryptoConvert.FromCapiPrivateKeyBlob (strongNamePublicKey, 12);
 226                 }
 227
 228                 [Test]
 229                 public void FromCapiPublicKeyBlob ()
 230                 {
 231                         RSA rsa = CryptoConvert.FromCapiPublicKeyBlob (strongNamePublicKey, 12);
 232                         AssertEquals ("PublicKey", strongNamePublicKeyString, rsa.ToXmlString (false));
 233                 }
 234
 235                 [Test]
 236                 [ExpectedException (typeof (ArgumentNullException))]
 237                 public void FromCapiPublicKeyBlob_Null ()
 238                 {
 239                         RSA rsa = CryptoConvert.FromCapiPublicKeyBlob (null);
 240                 }
 241
 242                 [Test]
 243                 [ExpectedException (typeof (ArgumentException))]
 244                 public void FromCapiPublicKeyBlob_InvalidOffset ()
 245                 {
 246                         RSA rsa = CryptoConvert.FromCapiPublicKeyBlob (new byte [0], 0);
 247                 }
 248
 249                 [Test]
 250                 [ExpectedException (typeof (CryptographicException))]
 251                 public void FromCapiPublicKeyBlob_Invalid ()
 252                 {
 253                         RSA rsa = CryptoConvert.FromCapiPublicKeyBlob (strongName, 0);
 254                 }
 255
 256                 [Test]
 257                 public void ToCapiKeyBlob_AsymmetricAlgorithm ()
 258                 {
 259                         AsymmetricAlgorithm rsa = RSA.Create ();
 260                         rsa.FromXmlString (strongNameString);
 261                         byte[] keypair = CryptoConvert.ToCapiKeyBlob (rsa, true);
 262                         AssertEquals ("RSA-KeyPair", strongName, keypair);
 263
 264                         byte[] publicKey = CryptoConvert.ToCapiKeyBlob (rsa, false);
 265                         AssertEquals ("RSA-PublicKey", BitConverter.ToString (strongNamePublicKey, 12), BitConverter.ToString (publicKey));
 266
 267                         // TODO dsa (not implemented yet)
 268                         AsymmetricAlgorithm dsa = DSA.Create ();
 269                         AssertNull ("DSA-KeyPair", CryptoConvert.ToCapiKeyBlob (dsa, true));
 270                         AssertNull ("DSA-PublicKey", CryptoConvert.ToCapiKeyBlob (dsa, false));
 271                 }
 272
 273                 [Test]
 274                 public void ToCapiKeyBlob_RSA ()
 275                 {
 276                         RSA rsa = RSA.Create ();
 277                         rsa.FromXmlString (strongNameString);
 278                         byte[] keypair = CryptoConvert.ToCapiKeyBlob (rsa, true);
 279                         AssertEquals ("KeyPair", strongName, keypair);
 280
 281                         byte[] publicKey = CryptoConvert.ToCapiKeyBlob (rsa, false);
 282                         AssertEquals ("PublicKey", BitConverter.ToString (strongNamePublicKey, 12), BitConverter.ToString (publicKey));
 283                 }
 284
 285                 [Test]
 286                 [ExpectedException (typeof (ArgumentNullException))]
 287                 public void ToCapiKeyBlob_AsymmetricNull ()
 288                 {
 289                         AsymmetricAlgorithm aa = null;
 290                         CryptoConvert.ToCapiKeyBlob (aa, false);
 291                 }
 292
 293                 [Test]
 294                 [ExpectedException (typeof (ArgumentNullException))]
 295                 public void ToCapiKeyBlob_RSANull ()
 296                 {
 297                         RSA rsa = null;
 298                         CryptoConvert.ToCapiKeyBlob (rsa, false);
 299                 }
 300
 301                 [Test]
 302                 public void ToCapiPrivateKeyBlob ()
 303                 {
 304                         RSA rsa = RSA.Create ();
 305                         rsa.FromXmlString (strongNameString);
 306                         byte[] keypair = CryptoConvert.ToCapiPrivateKeyBlob (rsa);
 307                         AssertEquals ("KeyPair", strongName, keypair);
 308                 }
 309
 310                 [Test]
 311                 [ExpectedException (typeof (CryptographicException))]
 312                 public void ToCapiPrivateKeyBlob_PublicKeyOnly ()
 313                 {
 314                         RSA rsa = RSA.Create ();
 315                         rsa.FromXmlString (strongNamePublicKeyString);
 316                         byte[] publicKey = CryptoConvert.ToCapiPrivateKeyBlob (rsa);
 317                 }
 318
 319                 [Test]
 320                 public void ToCapiPublicKeyBlob ()
 321                 {
 322                         RSA rsa = RSA.Create ();
 323                         // full keypair
 324                         rsa.FromXmlString (strongNameString);
 325                         byte[] publicKey = CryptoConvert.ToCapiPublicKeyBlob (rsa);
 326                         AssertEquals ("PublicKey-1", BitConverter.ToString (strongNamePublicKey, 12), BitConverter.ToString (publicKey));
 327                         // public key only
 328                         rsa.FromXmlString (strongNamePublicKeyString);
 329                         publicKey = CryptoConvert.ToCapiPublicKeyBlob (rsa);
 330                         AssertEquals ("PublicKey-2", BitConverter.ToString (strongNamePublicKey, 12), BitConverter.ToString (publicKey));
 331                 }
 332
 333                 [Test]
 334                 public void FromHex ()
 335                 {
 336                         AssertNull ("FromHex(null)", CryptoConvert.FromHex (null));
 337                         string result = BitConverter.ToString (CryptoConvert.FromHex ("0123456789aBcDeF"));
 338                         AssertEquals ("0123456789abcdef", "01-23-45-67-89-AB-CD-EF", result);
 339                 }
 340
 341                 [Test]
 342                 [ExpectedException (typeof (ArgumentException))]
 343                 public void FromHex_NonHexChars ()
 344                 {
 345                         CryptoConvert.FromHex ("abcdefgh");
 346                 }
 347
 348                 [Test]
 349                 [ExpectedException (typeof (ArgumentException))]
 350                 public void FromHex_NonMultipleOf2 ()
 351                 {
 352                         CryptoConvert.FromHex ("abc");
 353                 }
 354
 355                 [Test]
 356                 public void ToHex ()
 357                 {
 358                         AssertNull ("FromHex(null)", CryptoConvert.FromHex (null));
 359                         byte[] data = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 360                         AssertEquals ("0123456789abcdef", "0123456789ABCDEF", CryptoConvert.ToHex (data));
 361                 }
 362
 363                 [Test]
 364                 public void NUnitKey_Broken ()
 365                 {
 366                         // for some strange reason nunit.snk hasn't the same
 367                         // size as other strongname. I wonder how it was
 368                         // generated ?
 369                         RSA rsa = CryptoConvert.FromCapiKeyBlob (strongNameNUnit, 0);
 370                         // note the bad D parameters !!!
 371                         // this only works because CRT is being used
 372                         AssertEquals ("KeyPair", "<RSAKeyValue><Modulus>rB8h0TaMs8fWA+5WMdcjOjejCZwhYwuFHUZPS0cC9TOG6FJtvlHPpZLQAg0xfLr2SivPRol1Xw9SqhuaYQNJA7sAaOb8Rvgmx93XbmcNotY9ob4TGaesk+M8VsdexsIJ3WlyLbmRlf0EjT52nboyauEL3UC85zkMjW1LNb8LSs8=</Modulus><Exponent>AQAB</Exponent><P>2d4pGForvc792ztFxhNuzxIihDnXp+qK9F8t/NduhRBdu+JXK4d8a9EGwzpMxLUPlHjCZfXRraZiSQszkH+nzQ==</P><Q>yj9BeGmOrucOUCNZYTtXI0ykzz+1g+cVMSxi+6xzoLEOqmdE4gjcWaxak4MF1+pIR6UycnNa/jg1LBl7MKxpCw==</Q><DP>cMkAjznG4Sjx4/dIRKU0vP/PXJIxIR1bN+y5+uVvsnTpgWVH6SHneE0qahCZQ0/UM/Fb+bqLBJFY2iVxWUGslQ==</DP><DQ>gz6TXPGbLzMv3Z9i5C8e+ABHv1pHj6ZI4VU9kraxfmkH7FsBn3FClUq8qJdRFnGpoBy65Pyo4upUzx5mDAsGSw==</DQ><InverseQ>x+UShV+0d9cicoiB9fkSLqpLDyF4dYzVu0uqX0eCcoGJpk19jtSaMI3Eo8VN6MJAW1zrRy+MA1Fqb9qeThLqZQ==</InverseQ><D>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</D></RSAKeyValue>", rsa.ToXmlString (true));
 373                         AssertEquals ("PublicKey", "<RSAKeyValue><Modulus>rB8h0TaMs8fWA+5WMdcjOjejCZwhYwuFHUZPS0cC9TOG6FJtvlHPpZLQAg0xfLr2SivPRol1Xw9SqhuaYQNJA7sAaOb8Rvgmx93XbmcNotY9ob4TGaesk+M8VsdexsIJ3WlyLbmRlf0EjT52nboyauEL3UC85zkMjW1LNb8LSs8=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>", rsa.ToXmlString (false));
 374                 }
 375         }
 376 }