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                         AsymmetricAlgorithm dsa = DSA.Create ();
 268                         dsa.FromXmlString (dsaKeyPairString);
 269                         AssertEquals ("DSA-KeyPair", dsaPrivBlob, CryptoConvert.ToCapiKeyBlob (dsa, true));
 270                         AssertEquals ("DSA-PublicKey", BitConverter.ToString (dsaPubBlob), BitConverter.ToString (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                 /* DSA key tests */
 334                 static byte[] dsaPrivBlob = { 7, 2, 0, 0, 0, 34, 0, 0, 68, 83,
 335                         83, 50, 0, 4, 0, 0, 69, 144, 99, 249,
 336                         41, 174, 97, 185, 66, 236, 179, 197, 182, 101,
 337                         146, 165, 47, 36, 234, 199, 170, 99, 97, 8,
 338                         224, 141, 189, 97, 86, 96, 240, 53, 69, 135,
 339                         123, 169, 165, 64, 50, 51, 144, 131, 158, 151,
 340                         218, 224, 159, 194, 166, 107, 132, 201, 148, 74,
 341                         38, 62, 231, 221, 157, 216, 239, 66, 248, 68,
 342                         26, 23, 123, 253, 157, 123, 65, 199, 109, 138,
 343                         231, 217, 247, 170, 81, 51, 43, 252, 66, 210,
 344                         75, 127, 68, 147, 141, 213, 174, 251, 109, 152,
 345                         244, 113, 14, 194, 198, 222, 69, 157, 146, 154,
 346                         224, 158, 46, 181, 204, 251, 10, 124, 153, 26,
 347                         239, 105, 199, 53, 43, 51, 255, 118, 213, 58,
 348                         111, 212, 166, 235, 29, 143, 53, 193, 210, 7,
 349                         78, 198, 7, 3, 219, 0, 57, 81, 179, 46,
 350                         58, 180, 61, 222, 145, 109, 165, 23, 119, 162,
 351                         91, 55, 48, 230, 133, 54, 103, 58, 139, 99,
 352                         146, 149, 90, 197, 167, 60, 164, 35, 90, 168,
 353                         150, 138, 107, 17, 219, 191, 163, 4, 98, 13,
 354                         109, 98, 122, 178, 247, 46, 73, 124, 53, 228,
 355                         137, 21, 20, 45, 214, 217, 202, 51, 87, 45,
 356                         78, 190, 19, 209, 249, 13, 31, 88, 52, 108,
 357                         196, 110, 54, 19, 252, 189, 80, 216, 191, 222,
 358                         192, 10, 112, 231, 67, 104, 154, 205, 1, 172,
 359                         194, 226, 187, 60, 252, 104, 176, 27, 87, 244,
 360                         217, 166, 140, 245, 97, 187, 64, 188, 103, 129,
 361                         194, 56, 206, 61, 169, 66, 171, 49, 234, 206,
 362                         29, 141, 249, 110, 171, 127, 135, 23, 20, 58,
 363                         156, 16, 252, 185, 148, 20, 202, 87, 124, 160,
 364                         65, 169, 243, 32, 164, 19, 59, 58, 188, 109,
 365                         43, 1, 150, 0, 0, 0, 203, 217, 189, 181,
 366                         208, 230, 19, 165, 199, 206, 44, 204, 209, 156,
 367                         80, 26, 199, 66, 198, 13 };
 368
 369                 static byte[] dsaPubBlob = { 6, 2, 0, 0, 0, 34, 0, 0, 68, 83,
 370                         83, 49, 0, 4, 0, 0, 69, 144, 99, 249,
 371                         41, 174, 97, 185, 66, 236, 179, 197, 182, 101,
 372                         146, 165, 47, 36, 234, 199, 170, 99, 97, 8,
 373                         224, 141, 189, 97, 86, 96, 240, 53, 69, 135,
 374                         123, 169, 165, 64, 50, 51, 144, 131, 158, 151,
 375                         218, 224, 159, 194, 166, 107, 132, 201, 148, 74,
 376                         38, 62, 231, 221, 157, 216, 239, 66, 248, 68,
 377                         26, 23, 123, 253, 157, 123, 65, 199, 109, 138,
 378                         231, 217, 247, 170, 81, 51, 43, 252, 66, 210,
 379                         75, 127, 68, 147, 141, 213, 174, 251, 109, 152,
 380                         244, 113, 14, 194, 198, 222, 69, 157, 146, 154,
 381                         224, 158, 46, 181, 204, 251, 10, 124, 153, 26,
 382                         239, 105, 199, 53, 43, 51, 255, 118, 213, 58,
 383                         111, 212, 166, 235, 29, 143, 53, 193, 210, 7,
 384                         78, 198, 7, 3, 219, 0, 57, 81, 179, 46,
 385                         58, 180, 61, 222, 145, 109, 165, 23, 119, 162,
 386                         91, 55, 48, 230, 133, 54, 103, 58, 139, 99,
 387                         146, 149, 90, 197, 167, 60, 164, 35, 90, 168,
 388                         150, 138, 107, 17, 219, 191, 163, 4, 98, 13,
 389                         109, 98, 122, 178, 247, 46, 73, 124, 53, 228,
 390                         137, 21, 20, 45, 214, 217, 202, 51, 87, 45,
 391                         78, 190, 19, 209, 249, 13, 31, 88, 52, 108,
 392                         196, 110, 54, 19, 252, 189, 80, 216, 191, 222,
 393                         192, 10, 112, 231, 67, 104, 154, 205, 1, 172,
 394                         194, 226, 187, 60, 252, 104, 176, 27, 87, 244,
 395                         217, 166, 140, 245, 97, 187, 64, 188, 103, 129,
 396                         194, 56, 206, 61, 169, 66, 171, 49, 234, 206,
 397                         29, 141, 249, 110, 171, 127, 135, 23, 20, 58,
 398                         156, 16, 185, 163, 1, 154, 216, 44, 43, 101,
 399                         67, 65, 35, 30, 70, 97, 44, 194, 46, 9,
 400                         182, 125, 162, 93, 231, 223, 50, 55, 14, 218,
 401                         93, 6, 176, 10, 195, 91, 83, 98, 73, 65,
 402                         88, 250, 7, 120, 0, 155, 35, 138, 54, 37,
 403                         80, 125, 44, 51, 25, 29, 198, 18, 107, 84,
 404                         60, 27, 227, 218, 32, 74, 62, 76, 222, 6,
 405                         76, 129, 254, 197, 53, 189, 4, 243, 203, 94,
 406                         73, 190, 102, 196, 88, 170, 17, 199, 119, 180,
 407                         205, 151, 184, 12, 168, 236, 81, 117, 49, 223,
 408                         204, 69, 50, 246, 230, 124, 57, 208, 75, 5,
 409                         178, 58, 7, 193, 224, 103, 60, 233, 2, 242,
 410                         82, 53, 252, 157, 202, 146, 231, 255, 250, 38,
 411                         150, 0, 0, 0, 203, 217, 189, 181, 208, 230,
 412                         19, 165, 199, 206, 44, 204, 209, 156, 80, 26,
 413                         199, 66, 198, 13 };
 414
 415                 static string dsaKeyPairString = "<DSAKeyValue><P>66bUbzrVdv8zKzXHae8amXwK+8y1Lp7gmpKdRd7Gwg5x9Jht+67VjZNEf0vSQvwrM1Gq99nnim3HQXud/XsXGkT4Qu/Ynd3nPiZKlMmEa6bCn+Dal56DkDMyQKWpe4dFNfBgVmG9jeAIYWOqx+okL6WSZbbFs+xCuWGuKfljkEU=</P><Q>3j20Oi6zUTkA2wMHxk4H0sE1jx0=</Q><G>EJw6FBeHf6tu+Y0dzuoxq0KpPc44woFnvEC7YfWMptn0VxuwaPw8u+LCrAHNmmhD53AKwN6/2FC9/BM2bsRsNFgfDfnRE75OLVczytnWLRQVieQ1fEku97J6Ym0NYgSjv9sRa4qWqFojpDynxVqVkmOLOmc2heYwN1uidxelbZE=</G><Y>Jvr/55LKnfw1UvIC6Txn4MEHOrIFS9A5fOb2MkXM3zF1UeyoDLiXzbR3xxGqWMRmvkley/MEvTXF/oFMBt5MPkog2uMbPFRrEsYdGTMsfVAlNoojmwB4B/pYQUliU1vDCrAGXdoONzLf512ifbYJLsIsYUYeI0FDZSss2JoBo7k=</Y><Seed>DcZCxxpQnNHMLM7HpRPm0LW92cs=</Seed><PgenCounter>lg==</PgenCounter><X>ASttvDo7E6Qg86lBoHxXyhSUufw=</X></DSAKeyValue>";
 416                 static string dsaPubKeyString =  "<DSAKeyValue><P>66bUbzrVdv8zKzXHae8amXwK+8y1Lp7gmpKdRd7Gwg5x9Jht+67VjZNEf0vSQvwrM1Gq99nnim3HQXud/XsXGkT4Qu/Ynd3nPiZKlMmEa6bCn+Dal56DkDMyQKWpe4dFNfBgVmG9jeAIYWOqx+okL6WSZbbFs+xCuWGuKfljkEU=</P><Q>3j20Oi6zUTkA2wMHxk4H0sE1jx0=</Q><G>EJw6FBeHf6tu+Y0dzuoxq0KpPc44woFnvEC7YfWMptn0VxuwaPw8u+LCrAHNmmhD53AKwN6/2FC9/BM2bsRsNFgfDfnRE75OLVczytnWLRQVieQ1fEku97J6Ym0NYgSjv9sRa4qWqFojpDynxVqVkmOLOmc2heYwN1uidxelbZE=</G><Y>Jvr/55LKnfw1UvIC6Txn4MEHOrIFS9A5fOb2MkXM3zF1UeyoDLiXzbR3xxGqWMRmvkley/MEvTXF/oFMBt5MPkog2uMbPFRrEsYdGTMsfVAlNoojmwB4B/pYQUliU1vDCrAGXdoONzLf512ifbYJLsIsYUYeI0FDZSss2JoBo7k=</Y><Seed>DcZCxxpQnNHMLM7HpRPm0LW92cs=</Seed><PgenCounter>lg==</PgenCounter></DSAKeyValue>";
 417
 418                 [Test]
 419                 public void FromCapiKeyBlobDSA ()
 420                 {
 421                         DSA dsa = CryptoConvert.FromCapiKeyBlobDSA (dsaPrivBlob);
 422                         AssertEquals ("KeyPair", dsaKeyPairString, dsa.ToXmlString (true));
 423                         AssertEquals ("PublicKey", dsaPubKeyString, dsa.ToXmlString (false));
 424                 }
 425
 426                 [Test]
 427                 [ExpectedException (typeof (ArgumentNullException))]
 428                 public void FromCapiKeyBlobDSA_Null ()
 429                 {
 430                         DSA dsa = CryptoConvert.FromCapiKeyBlobDSA (null);
 431                 }
 432
 433                 [Test]
 434                 [ExpectedException (typeof (ArgumentException))]
 435                 public void FromCapiKeyBlobDSA_InvalidOffset ()
 436                 {
 437                         DSA dsa = CryptoConvert.FromCapiKeyBlobDSA (new byte [0], 0);
 438                 }
 439
 440                 [Test]
 441                 [ExpectedException (typeof (CryptographicException))]
 442                 public void FromCapiKeyBlobDSA_UnknownBlob ()
 443                 {
 444                         byte[] blob = new byte [334];
 445                         DSA dsa = CryptoConvert.FromCapiKeyBlobDSA (blob, 0);
 446                 }
 447
 448                 [Test]
 449                 public void FromCapiPrivateKeyBlobDSA ()
 450                 {
 451                         DSA dsa = CryptoConvert.FromCapiPrivateKeyBlobDSA (dsaPrivBlob, 0);
 452                         AssertEquals ("KeyPair", dsaKeyPairString, dsa.ToXmlString (true));
 453                 }
 454
 455                 [Test]
 456                 [ExpectedException (typeof (ArgumentNullException))]
 457                 public void FromCapiPrivateKeyBlobDSA_Null ()
 458                 {
 459                         DSA dsa = CryptoConvert.FromCapiPrivateKeyBlobDSA (null);
 460                 }
 461
 462                 [Test]
 463                 [ExpectedException (typeof (ArgumentException))]
 464                 public void FromCapiPrivateKeyBlobDSA_InvalidOffset ()
 465                 {
 466                         DSA dsa = CryptoConvert.FromCapiPrivateKeyBlobDSA (new byte[0], 0);
 467                 }
 468
 469                 [Test]
 470                 [ExpectedException (typeof (CryptographicException))]
 471                 public void FromCapiPrivateKeyBlobDSA_Invalid ()
 472                 {
 473                         byte[] blob = new byte[334];
 474                         DSA dsa = CryptoConvert.FromCapiPrivateKeyBlobDSA (blob, 0);
 475                 }
 476
 477                 [Test]
 478                 public void FromCapiPublicKeyBlobDSA ()
 479                 {
 480                         DSA dsa = CryptoConvert.FromCapiPublicKeyBlobDSA (dsaPubBlob, 0);
 481                         AssertEquals ("PublicKey", dsaPubKeyString, dsa.ToXmlString (false));
 482                 }
 483
 484                 [Test]
 485                 [ExpectedException (typeof (ArgumentNullException))]
 486                 public void FromCapiPublicKeyBlobDSA_Null ()
 487                 {
 488                         DSA dsa = CryptoConvert.FromCapiPublicKeyBlobDSA (null);
 489                 }
 490
 491                 [Test]
 492                 [ExpectedException (typeof (ArgumentException))]
 493                 public void FromCapiPublicKeyBlobDSA_InvalidOffset ()
 494                 {
 495                         DSA dsa = CryptoConvert.FromCapiPublicKeyBlobDSA (new byte[0], 0);
 496                 }
 497
 498                 [Test]
 499                 [ExpectedException (typeof (CryptographicException))]
 500                 public void FromCapiPublicKeyBlobDSA_Invalid ()
 501                 {
 502                         byte[] blob = new byte[400];
 503                         DSA dsa = CryptoConvert.FromCapiPublicKeyBlobDSA (blob, 0);
 504                 }
 505
 506                 [Test]
 507                 public void ToCapiKeyBlob_DSA ()
 508                 {
 509                         DSA dsa = DSA.Create ();
 510                         dsa.FromXmlString (dsaKeyPairString);
 511                         byte[] keypair = CryptoConvert.ToCapiKeyBlob (dsa, true);
 512                         AssertEquals ("KeyPair", dsaPrivBlob, keypair);
 513
 514                         byte[] pubkey = CryptoConvert.ToCapiKeyBlob (dsa, false);
 515                         AssertEquals ("PublicKey", BitConverter.ToString (dsaPubBlob), BitConverter.ToString (pubkey));
 516                 }
 517
 518                 [Test]
 519                 [ExpectedException (typeof (ArgumentNullException))]
 520                 public void ToCapiKeyBlob_DSANull ()
 521                 {
 522                         DSA dsa = null;
 523                         CryptoConvert.ToCapiKeyBlob (dsa, false);
 524                 }
 525
 526                 [Test]
 527                 public void ToCapiPrivateKeyBlob_DSA ()
 528                 {
 529                         DSA dsa = DSA.Create ();
 530                         dsa.FromXmlString (dsaKeyPairString);
 531                         byte[] keypair = CryptoConvert.ToCapiPrivateKeyBlob (dsa);
 532                         AssertEquals ("KeyPair", dsaPrivBlob, keypair);
 533                 }
 534
 535                 [Test]
 536                 [ExpectedException (typeof (CryptographicException))]
 537                 public void ToCapiPrivateKeyBlob_PublicKeyOnly_DSA ()
 538                 {
 539                         DSA dsa = DSA.Create ();
 540                         dsa.FromXmlString (dsaPubKeyString);
 541                         byte[] pubkey = CryptoConvert.ToCapiPrivateKeyBlob (dsa);
 542                 }
 543
 544                 [Test]
 545                 public void ToCapiPublicKeyBlob_DSA ()
 546                 {
 547                         DSA dsa = DSA.Create ();
 548                         // full keypair
 549                         dsa.FromXmlString (dsaKeyPairString);
 550                         byte[] pubkey = CryptoConvert.ToCapiPublicKeyBlob (dsa);
 551                         AssertEquals ("PublicKey-1", BitConverter.ToString (dsaPubBlob), BitConverter.ToString (pubkey));
 552
 553                         // public key only
 554                         dsa.FromXmlString (dsaPubKeyString);
 555                         pubkey = CryptoConvert.ToCapiPublicKeyBlob (dsa);
 556                         AssertEquals ("PublicKey-2", BitConverter.ToString (dsaPubBlob), BitConverter.ToString (pubkey));
 557                 }
 558
 559                 [Test]
 560                 public void FromHex ()
 561                 {
 562                         AssertNull ("FromHex(null)", CryptoConvert.FromHex (null));
 563                         string result = BitConverter.ToString (CryptoConvert.FromHex ("0123456789aBcDeF"));
 564                         AssertEquals ("0123456789abcdef", "01-23-45-67-89-AB-CD-EF", result);
 565                 }
 566
 567                 [Test]
 568                 [ExpectedException (typeof (ArgumentException))]
 569                 public void FromHex_NonHexChars ()
 570                 {
 571                         CryptoConvert.FromHex ("abcdefgh");
 572                 }
 573
 574                 [Test]
 575                 [ExpectedException (typeof (ArgumentException))]
 576                 public void FromHex_NonMultipleOf2 ()
 577                 {
 578                         CryptoConvert.FromHex ("abc");
 579                 }
 580
 581                 [Test]
 582                 public void ToHex ()
 583                 {
 584                         AssertNull ("FromHex(null)", CryptoConvert.FromHex (null));
 585                         byte[] data = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 586                         AssertEquals ("0123456789abcdef", "0123456789ABCDEF", CryptoConvert.ToHex (data));
 587                 }
 588
 589                 [Test]
 590                 public void NUnitKey_Broken ()
 591                 {
 592                         // for some strange reason nunit.snk hasn't the same
 593                         // size as other strongname. I wonder how it was
 594                         // generated ?
 595                         RSA rsa = CryptoConvert.FromCapiKeyBlob (strongNameNUnit, 0);
 596                         // note the bad D parameters !!!
 597                         // this only works because CRT is being used
 598                         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));
 599                         AssertEquals ("PublicKey", "<RSAKeyValue><Modulus>rB8h0TaMs8fWA+5WMdcjOjejCZwhYwuFHUZPS0cC9TOG6FJtvlHPpZLQAg0xfLr2SivPRol1Xw9SqhuaYQNJA7sAaOb8Rvgmx93XbmcNotY9ob4TGaesk+M8VsdexsIJ3WlyLbmRlf0EjT52nboyauEL3UC85zkMjW1LNb8LSs8=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>", rsa.ToXmlString (false));
 600                 }
 601         }
 602 }