mcs/class/corlib/System.Security.Cryptography/DSACryptoServiceProvider.cs

   1 //
   2 // System.Security.Cryptography.DSACryptoServiceProvider.cs
   3 //
   4 // Authors:
   5 //      Dan Lewis (dihlewis@yahoo.co.uk)
   6 //      Sebastien Pouliot <sebastien@ximian.com>
   7 //      Ben Maurer (bmaurer@users.sf.net)
   8 //
   9 // (C) 2002
  10 // Portions (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
  11 // Portions (C) 2003 Ben Maurer
  12 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System.IO;
  35 using System.Globalization;
  36 using System.Runtime.InteropServices;
  37
  38 using Mono.Security.Cryptography;
  39
  40 namespace System.Security.Cryptography {
  41
  42         [ComVisible (true)]
  43         public sealed class DSACryptoServiceProvider : DSA, ICspAsymmetricAlgorithm {
  44                 private const int PROV_DSS_DH = 13;             // from WinCrypt.h
  45
  46                 private KeyPairPersistence store;
  47                 private bool persistKey;
  48                 private bool persisted;
  49
  50                 private bool privateKeyExportable = true;
  51                 private bool m_disposed;
  52
  53                 private DSAManaged dsa;
  54
  55                 // MS implementation generates a keypair everytime a new DSA
  56                 // object is created (unless an existing key container is
  57                 // specified in the CspParameters).
  58                 // However we:
  59                 // (a) often use DSA to import an existing keypair.
  60                 // (b) take a LOT of time to generate the DSA group
  61                 // So we'll generate the keypair only when (and if) it's being
  62                 // used (or exported). This should save us a lot of time (at
  63                 // least in the unit tests).
  64
  65                 public DSACryptoServiceProvider ()
  66                         : this (1024)
  67                 {
  68                 }
  69
  70                 public DSACryptoServiceProvider (CspParameters parameters)
  71                         : this (1024, parameters)
  72                 {
  73                 }
  74
  75                 public DSACryptoServiceProvider (int dwKeySize)
  76                 {
  77                         Common (dwKeySize, false);
  78                 }
  79
  80                 public DSACryptoServiceProvider (int dwKeySize, CspParameters parameters)
  81                 {
  82                         bool has_parameters = parameters != null;
  83                         Common (dwKeySize, has_parameters);
  84                         if (has_parameters)
  85                                 Common (parameters);
  86                 }
  87
  88                 void Common (int dwKeySize, bool parameters)
  89                 {
  90                         LegalKeySizesValue = new KeySizes [1];
  91                         LegalKeySizesValue [0] = new KeySizes (512, 1024, 64);
  92
  93                         // will throw an exception is key size isn't supported
  94                         KeySize = dwKeySize;
  95                         dsa = new DSAManaged (dwKeySize);
  96                         dsa.KeyGenerated += new DSAManaged.KeyGeneratedEventHandler (OnKeyGenerated);
  97
  98                         persistKey = parameters;
  99                         if (parameters)
 100                                 return;
 101
 102                         var p = new CspParameters (PROV_DSS_DH);
 103                         if (useMachineKeyStore)
 104                                 p.Flags |= CspProviderFlags.UseMachineKeyStore;
 105                         store = new KeyPairPersistence (p);
 106                         // no need to load - it cannot exists
 107                 }
 108
 109                 void Common (CspParameters parameters)
 110                 {
 111                         store = new KeyPairPersistence (parameters);
 112                         store.Load ();
 113                         if (store.KeyValue != null) {
 114                                 persisted = true;
 115                                 this.FromXmlString (store.KeyValue);
 116                         }
 117                 }
 118
 119                 ~DSACryptoServiceProvider ()
 120                 {
 121                         Dispose (false);
 122                 }
 123
 124                 // DSA isn't used for key exchange
 125                 public override string KeyExchangeAlgorithm {
 126                         get { return null; }
 127                 }
 128
 129                 public override int KeySize {
 130                         get { return dsa.KeySize; }
 131                 }
 132
 133                 public bool PersistKeyInCsp {
 134                         get { return persistKey; }
 135                         set { persistKey = value; }
 136                 }
 137
 138                 [ComVisible (false)]
 139                 public bool PublicOnly {
 140                         get { return dsa.PublicOnly; }
 141                 }
 142
 143                 public override string SignatureAlgorithm {
 144                         get { return "http://www.w3.org/2000/09/xmldsig#dsa-sha1"; }
 145                 }
 146
 147                 private static bool useMachineKeyStore;
 148
 149                 public static bool UseMachineKeyStore {
 150                         get { return useMachineKeyStore; }
 151                         set { useMachineKeyStore = value; }
 152                 }
 153
 154                 public override DSAParameters ExportParameters (bool includePrivateParameters)
 155                 {
 156                         if ((includePrivateParameters) && (!privateKeyExportable)) {
 157                                 throw new CryptographicException (
 158                                         Locale.GetText ("Cannot export private key"));
 159                         }
 160
 161                         return dsa.ExportParameters (includePrivateParameters);
 162                 }
 163
 164                 public override void ImportParameters (DSAParameters parameters)
 165                 {
 166                         dsa.ImportParameters (parameters);
 167                 }
 168
 169                 public override byte[] CreateSignature (byte[] rgbHash)
 170                 {
 171                         return dsa.CreateSignature (rgbHash);
 172                 }
 173
 174                 public byte[] SignData (byte[] buffer)
 175                 {
 176                         // right now only SHA1 is supported by FIPS186-2
 177                         HashAlgorithm hash = SHA1.Create ();
 178                         byte[] toBeSigned = hash.ComputeHash (buffer);
 179                         return dsa.CreateSignature (toBeSigned);
 180                 }
 181
 182                 public byte[] SignData (byte[] buffer, int offset, int count)
 183                 {
 184                         // right now only SHA1 is supported by FIPS186-2
 185                         HashAlgorithm hash = SHA1.Create ();
 186                         byte[] toBeSigned = hash.ComputeHash (buffer, offset, count);
 187                         return dsa.CreateSignature (toBeSigned);
 188                 }
 189
 190                 public byte[] SignData (Stream inputStream)
 191                 {
 192                         // right now only SHA1 is supported by FIPS186-2
 193                         HashAlgorithm hash = SHA1.Create ();
 194                         byte[] toBeSigned = hash.ComputeHash (inputStream);
 195                         return dsa.CreateSignature (toBeSigned);
 196                 }
 197
 198                 public byte[] SignHash (byte[] rgbHash, string str)
 199                 {
 200                         // right now only SHA1 is supported by FIPS186-2
 201                         if (String.Compare (str, "SHA1", true, CultureInfo.InvariantCulture) != 0) {
 202                                 // not documented
 203                                 throw new CryptographicException (Locale.GetText ("Only SHA1 is supported."));
 204                         }
 205
 206                         return dsa.CreateSignature (rgbHash);
 207                 }
 208
 209                 public bool VerifyData (byte[] rgbData, byte[] rgbSignature)
 210                 {
 211                         // right now only SHA1 is supported by FIPS186-2
 212                         HashAlgorithm hash = SHA1.Create();
 213                         byte[] toBeVerified = hash.ComputeHash (rgbData);
 214                         return dsa.VerifySignature (toBeVerified, rgbSignature);
 215                 }
 216
 217                 // LAMESPEC: MD5 isn't allowed with DSA
 218                 public bool VerifyHash (byte[] rgbHash, string str, byte[] rgbSignature)
 219                 {
 220                         if (str == null)
 221                                 str = "SHA1"; // default value
 222                         if (String.Compare (str, "SHA1", true, CultureInfo.InvariantCulture) != 0) {
 223                                 throw new CryptographicException (Locale.GetText ("Only SHA1 is supported."));
 224                         }
 225
 226                         return dsa.VerifySignature (rgbHash, rgbSignature);
 227                 }
 228
 229                 public override bool VerifySignature (byte[] rgbHash, byte[] rgbSignature)
 230                 {
 231                         return dsa.VerifySignature (rgbHash, rgbSignature);
 232                 }
 233
 234                 protected override byte[] HashData (byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
 235                 {
 236                         if (hashAlgorithm != HashAlgorithmName.SHA1)
 237                         {
 238                                 throw new CryptographicException(Environment.GetResourceString("Cryptography_UnknownHashAlgorithm", hashAlgorithm.Name));
 239                         }
 240
 241                         var hash = HashAlgorithm.Create (hashAlgorithm.Name);
 242                         return hash.ComputeHash (data, offset, count);
 243                 }
 244
 245                 protected override byte[] HashData (System.IO.Stream data, HashAlgorithmName hashAlgorithm)
 246                 {
 247                         if (hashAlgorithm != HashAlgorithmName.SHA1)
 248                         {
 249                                 throw new CryptographicException(Environment.GetResourceString("Cryptography_UnknownHashAlgorithm", hashAlgorithm.Name));
 250                         }
 251
 252                         var hash = HashAlgorithm.Create (hashAlgorithm.Name);
 253                         return hash.ComputeHash (data);
 254                 }
 255
 256                 protected override void Dispose (bool disposing)
 257                 {
 258                         if (!m_disposed) {
 259                                 // the key is persisted and we do not want it persisted
 260                                 if ((persisted) && (!persistKey)) {
 261                                         store.Remove ();        // delete the container
 262                                 }
 263                                 if (dsa != null)
 264                                         dsa.Clear ();
 265                                 // call base class
 266                                 // no need as they all are abstract before us
 267                                 m_disposed = true;
 268                         }
 269                 }
 270
 271                 // private stuff
 272
 273                 private void OnKeyGenerated (object sender, EventArgs e)
 274                 {
 275                         // the key isn't persisted and we want it persisted
 276                         if ((persistKey) && (!persisted)) {
 277                                 // save the current keypair
 278                                 store.KeyValue = this.ToXmlString (!dsa.PublicOnly);
 279                                 store.Save ();
 280                                 persisted = true;
 281                         }
 282                 }
 283                 // ICspAsymmetricAlgorithm
 284
 285                 [MonoTODO ("call into KeyPairPersistence to get details")]
 286                 [ComVisible (false)]
 287                 public CspKeyContainerInfo CspKeyContainerInfo {
 288                         get { return null; }
 289                 }
 290
 291                 [ComVisible (false)]
 292                 public byte[] ExportCspBlob (bool includePrivateParameters)
 293                 {
 294                         byte[] blob = null;
 295                         if (includePrivateParameters)
 296                                 blob = CryptoConvert.ToCapiPrivateKeyBlob (this);
 297                         else
 298                                 blob = CryptoConvert.ToCapiPublicKeyBlob (this);
 299                         return blob;
 300                 }
 301
 302                 [ComVisible (false)]
 303                 public void ImportCspBlob (byte[] keyBlob)
 304                 {
 305                         if (keyBlob == null)
 306                                 throw new ArgumentNullException ("keyBlob");
 307                         DSA dsa = CryptoConvert.FromCapiKeyBlobDSA (keyBlob);
 308                         if (dsa is DSACryptoServiceProvider) {
 309                                 DSAParameters dsap = dsa.ExportParameters (!(dsa as DSACryptoServiceProvider).PublicOnly);
 310                                 ImportParameters (dsap);
 311                         } else {
 312                                 // we can't know from DSA if the private key is available
 313                                 try {
 314                                         // so we try it...
 315                                         DSAParameters dsap = dsa.ExportParameters (true);
 316                                         ImportParameters (dsap);
 317                                 }
 318                                 catch {
 319                                         // and fall back
 320                                         DSAParameters dsap = dsa.ExportParameters (false);
 321                                         ImportParameters (dsap);
 322                                 }
 323                         }
 324                 }
 325         }
 326 }