mcs/class/System.Security/System.Security.Cryptography.Xml/EncryptedXml.cs

   1 //
   2 // EncryptedXml.cs - EncryptedXml implementation for XML Encryption
   3 //
   4 // Author:
   5 //      Tim Coleman (tim@timcoleman.com)
   6 //
   7 // Copyright (C) Tim Coleman, 2004
   8
   9 #if NET_1_2
  10
  11 using System.Collections;
  12 using System.IO;
  13 using System.Security.Cryptography;
  14 using System.Security.Policy;
  15 using System.Text;
  16 using System.Xml;
  17
  18 namespace System.Security.Cryptography.Xml {
  19         public class EncryptedXml {
  20
  21                 #region Fields
  22
  23                 public const string XmlEncAES128KeyWrapUrl      = XmlEncNamespaceUrl + "kw-aes128";
  24                 public const string XmlEncAES128Url             = XmlEncNamespaceUrl + "aes128-cbc";
  25                 public const string XmlEncAES192KeyWrapUrl      = XmlEncNamespaceUrl + "kw-aes192";
  26                 public const string XmlEncAES192Url             = XmlEncNamespaceUrl + "aes192-cbc";
  27                 public const string XmlEncAES256KeyWrapUrl      = XmlEncNamespaceUrl + "kw-aes256";
  28                 public const string XmlEncAES256Url             = XmlEncNamespaceUrl + "aes256-cbc";
  29                 public const string XmlEncDESUrl                = XmlEncNamespaceUrl + "des-cbc";
  30                 public const string XmlEncElementContentUrl     = XmlEncNamespaceUrl + "ElementContent";
  31                 public const string XmlEncElementUrl            = XmlEncNamespaceUrl + "element";
  32                 public const string XmlEncEncryptedKeyUrl       = XmlEncNamespaceUrl + "EncryptedKey";
  33                 public const string XmlEncNamespaceUrl          = "http://www.w3.org/2001/04/xmlenc#";
  34                 public const string XmlEncRSA1_5Url             = XmlEncNamespaceUrl + "rsa-1_5";
  35                 public const string XmlEncRSAOAEPUrl            = XmlEncNamespaceUrl + "rsa-oaep-mgf1p";
  36                 public const string XmlEncSHA256Url             = XmlEncNamespaceUrl + "sha256";
  37                 public const string XmlEncSHA512Url             = XmlEncNamespaceUrl + "sha512";
  38                 public const string XmlEncTripleDESKeyWrapUrl   = XmlEncNamespaceUrl + "kw-tripledes";
  39                 public const string XmlEncTripleDESUrl          = XmlEncNamespaceUrl + "tripledes-cbc";
  40
  41                 Evidence documentEvidence;
  42                 Encoding encoding = Encoding.UTF8;
  43                 Hashtable keyNameMapping = new Hashtable ();
  44                 CipherMode mode = CipherMode.CBC;
  45                 PaddingMode padding = PaddingMode.ISO10126;
  46                 string recipient;
  47                 XmlResolver resolver;
  48
  49                 #endregion // Fields
  50
  51                 #region Constructors
  52
  53                 [MonoTODO]
  54                 public EncryptedXml ()
  55                 {
  56                 }
  57
  58                 [MonoTODO]
  59                 public EncryptedXml (XmlDocument document)
  60                 {
  61                 }
  62
  63                 [MonoTODO]
  64                 public EncryptedXml (XmlDocument document, Evidence evidence)
  65                 {
  66                         DocumentEvidence = evidence;
  67                 }
  68
  69                 #endregion // Constructors
  70
  71                 #region Properties
  72
  73                 public Evidence DocumentEvidence {
  74                         get { return documentEvidence; }
  75                         set { documentEvidence = value; }
  76                 }
  77
  78                 public Encoding Encoding {
  79                         get { return encoding; }
  80                         set { encoding = value; }
  81                 }
  82
  83                 public CipherMode Mode {
  84                         get { return mode; }
  85                         set { mode = value; }
  86                 }
  87
  88                 public PaddingMode Padding {
  89                         get { return padding; }
  90                         set { padding = value; }
  91                 }
  92
  93                 public string Recipient {
  94                         get { return recipient; }
  95                         set { recipient = value; }
  96                 }
  97
  98                 public XmlResolver Resolver {
  99                         get { return resolver; }
 100                         set { resolver = value; }
 101                 }
 102
 103                 #endregion // Properties
 104
 105                 #region Methods
 106
 107                 public void AddKeyNameMapping (string keyName, object keyObject)
 108                 {
 109                         keyNameMapping [keyName] = keyObject;
 110                 }
 111
 112                 public void ClearKeyNameMappings ()
 113                 {
 114                         keyNameMapping.Clear ();
 115                 }
 116
 117                 public byte[] DecryptData (EncryptedData encryptedData, SymmetricAlgorithm symAlg)
 118                 {
 119                         return Transform (encryptedData.CipherData.CipherValue, symAlg.CreateDecryptor ());
 120                 }
 121
 122                 [MonoTODO]
 123                 public void DecryptDocument ()
 124                 {
 125                         throw new NotImplementedException ();
 126                 }
 127
 128                 [MonoTODO]
 129                 public virtual byte[] DecryptEncryptedKey (EncryptedKey encryptedKey)
 130                 {
 131                         throw new NotImplementedException ();
 132                 }
 133
 134                 [MonoTODO]
 135                 public static byte[] DecryptKey (byte[] keyData, SymmetricAlgorithm symAlg)
 136                 {
 137                         if (symAlg is TripleDES)
 138                                 return SymmetricKeyWrap.TripleDESKeyWrapDecrypt (symAlg.Key, keyData);
 139                         if (symAlg is Rijndael)
 140                                 return SymmetricKeyWrap.TripleDESKeyWrapDecrypt (symAlg.Key, keyData);
 141
 142                         throw new CryptographicException ("The specified cryptographic transform is not supported.");
 143                 }
 144
 145                 [MonoTODO]
 146                 public static byte[] DecryptKey (byte[] keyData, RSA rsa, bool fOAEP)
 147                 {
 148                         throw new NotImplementedException ();
 149                 }
 150
 151                 public byte[] EncryptData (XmlElement inputElement, SymmetricAlgorithm symAlg, bool content)
 152                 {
 153                         if (content)
 154                                 return Transform (Encoding.GetBytes (inputElement.InnerXml), symAlg.CreateEncryptor ());
 155                         else
 156                                 return Transform (Encoding.GetBytes (inputElement.OuterXml), symAlg.CreateEncryptor ());
 157                 }
 158
 159                 [MonoTODO ("Do we need to support more algorithms?")]
 160                 public static byte[] EncryptKey (byte[] keyData, SymmetricAlgorithm symAlg)
 161                 {
 162                         if (symAlg is TripleDES)
 163                                 return SymmetricKeyWrap.TripleDESKeyWrapEncrypt (symAlg.Key, keyData);
 164                         if (symAlg is Rijndael)
 165                                 return SymmetricKeyWrap.AESKeyWrapEncrypt (symAlg.Key, keyData);
 166
 167                         throw new CryptographicException ("The specified cryptographic transform is not supported.");
 168                 }
 169
 170                 [MonoTODO ("Not sure what this is for.")]
 171                 public static byte[] EncryptKey (byte[] keyData, RSA rsa, bool fOAEP)
 172                 {
 173                         throw new NotImplementedException ();
 174                 }
 175
 176                 private static SymmetricAlgorithm GetAlgorithm (string symAlgUri)
 177                 {
 178                         SymmetricAlgorithm symAlg = null;
 179
 180                         switch (symAlgUri) {
 181                         case XmlEncAES128Url:
 182                                 symAlg = SymmetricAlgorithm.Create ("Rijndael");
 183                                 symAlg.KeySize = 128;
 184                                 break;
 185                         case XmlEncAES192Url:
 186                                 symAlg = SymmetricAlgorithm.Create ("Rijndael");
 187                                 symAlg.KeySize = 192;
 188                                 break;
 189                         case XmlEncAES256Url:
 190                                 symAlg = SymmetricAlgorithm.Create ("Rijndael");
 191                                 symAlg.KeySize = 256;
 192                                 break;
 193                         case XmlEncDESUrl:
 194                                 symAlg = SymmetricAlgorithm.Create ("DES");
 195                                 break;
 196                         case XmlEncTripleDESUrl:
 197                                 symAlg = SymmetricAlgorithm.Create ("TripleDES");
 198                                 break;
 199                         default:
 200                                 throw new ArgumentException ("symAlgUri");
 201                         }
 202
 203                         return symAlg;
 204                 }
 205
 206                 [MonoTODO]
 207                 public virtual byte[] GetDecryptionIV (EncryptedData encryptedData, string symAlgUri)
 208                 {
 209                         SymmetricAlgorithm symAlg = GetAlgorithm (symAlgUri);
 210
 211                         throw new NotImplementedException ();
 212                 }
 213
 214                 [MonoTODO]
 215                 public virtual SymmetricAlgorithm GetDecryptionKey (EncryptedData encryptedData, string symAlgUri)
 216                 {
 217                         SymmetricAlgorithm symAlg = GetAlgorithm (symAlgUri);
 218
 219                         throw new NotImplementedException ();
 220                 }
 221
 222                 public virtual XmlElement GetIdElement (XmlDocument document, string idValue)
 223                 {
 224                         // this works only if there's a DTD or XSD available to define the ID
 225                         XmlElement xel = document.GetElementById (idValue);
 226                         if (xel == null) {
 227                                 // search an "undefined" ID
 228                                 xel = (XmlElement) document.SelectSingleNode ("//*[@Id='" + idValue + "']");
 229                         }
 230                         return xel;
 231                 }
 232
 233                 [MonoTODO]
 234                 public static void ReplaceElement (XmlElement inputElement, EncryptedData encryptedData, bool content)
 235                 {
 236                         throw new NotImplementedException ();
 237                 }
 238
 239                 private byte[] Transform (byte[] data, ICryptoTransform transform)
 240                 {
 241                         MemoryStream output = new MemoryStream ();
 242                         CryptoStream crypto = new CryptoStream (output, transform, CryptoStreamMode.Write);
 243                         crypto.Write (data, 0, data.Length);
 244                         crypto.Close ();
 245                         output.Close ();
 246
 247                         return output.ToArray ();
 248                 }
 249
 250                 #endregion // Methods
 251         }
 252 }
 253
 254 #endif