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