public static bool IsLegalSize(this int size, KeySizes[] legalSizes, out bool validatedByZeroSkipSizeKeySizes)
{
validatedByZeroSkipSizeKeySizes = false;
for (int i = 0; i < legalSizes.Length; i++)
{
KeySizes currentSizes = legalSizes[i];
// If a cipher has only one valid key size, MinSize == MaxSize and SkipSize will be 0
if (currentSizes.SkipSize == 0)
{
if (currentSizes.MinSize == size)
{
// Signal that we were validated by a 0-skipsize KeySizes entry. Needed to preserve a very obscure
// piece of back-compat behavior.
validatedByZeroSkipSizeKeySizes = true;
return true;
}
}
else if (size >= currentSizes.MinSize && size <= currentSizes.MaxSize)
{
// If the number is in range, check to see if it's a legal increment above MinSize
int delta = size - currentSizes.MinSize;
// While it would be unusual to see KeySizes { 10, 20, 5 } and { 11, 14, 1 }, it could happen.
// So don't return false just because this one doesn't match.
if (delta % currentSizes.SkipSize == 0)
{
return true;
}
}
}
return false;
}
public static bool IsLegalSize(this int size, KeySizes[] legalSizes, out bool validatedByZeroSkipSizeKeySizes)
{
validatedByZeroSkipSizeKeySizes = false;
for (int i = 0; i < legalSizes.Length; i++)
{
// If a cipher has only one valid key size, MinSize == MaxSize and SkipSize will be 0
if (legalSizes[i].SkipSize == 0)
{
if (legalSizes[i].MinSize == size)
{
// Signal that we were validated by a 0-skipsize KeySizes entry. Needed to preserve a very obscure
// piece of back-compat behavior.
validatedByZeroSkipSizeKeySizes = true;
return true;
}
}
else
{
for (int j = legalSizes[i].MinSize; j <= legalSizes[i].MaxSize; j += legalSizes[i].SkipSize)
{
if (j == size)
return true;
}
}
}
return false;
}
public RijndaelManaged()
{
LegalBlockSizesValue = new KeySizes[] { new KeySizes(minSize: 128, maxSize: 128, skipSize: 0) };
// This class wraps Aes
_impl = Aes.Create();
}
public static bool IsLegalSize(this int size, KeySizes[] legalSizes)
{
for (int i = 0; i < legalSizes.Length; i++)
{
KeySizes currentSizes = legalSizes[i];
// If a cipher has only one valid key size, MinSize == MaxSize and SkipSize will be 0
if (currentSizes.SkipSize == 0)
{
if (currentSizes.MinSize == size)
return true;
}
else if (size >= currentSizes.MinSize && size <= currentSizes.MaxSize)
{
// If the number is in range, check to see if it's a legal increment above MinSize
int delta = size - currentSizes.MinSize;
// While it would be unusual to see KeySizes { 10, 20, 5 } and { 11, 14, 1 }, it could happen.
// So don't return false just because this one doesn't match.
if (delta % currentSizes.SkipSize == 0)
{
return true;
}
}
}
return false;
}
internal RijndaelImplementation()
{
LegalBlockSizesValue = new KeySizes[] { new KeySizes(minSize: 128, maxSize: 128, skipSize: 0) };
// This class wraps Aes
_impl = Aes.Create();
}
internal static bool IsLegalKeySize (KeySizes[] legalKeys, int size)
{
foreach (KeySizes legalKeySize in legalKeys) {
if (legalKeySize.IsLegal (size))
return true;
}
return false;
}
// Validate a key size and throw an exception if invalid.
internal static void Validate(KeySizes[] sizes, int value, String resource)
{
if(!Validate(sizes, value))
{
throw new CryptographicException
(_(resource), value.ToString());
}
}
/// <summary>
/// Creates a ModifiedRijndael which can be used with larger key sizes and a specified number of rounds.
/// </summary>
public ModifiedRijndael()
{
_numRounds = -1; //defined by keysize
PaddingValue = PaddingMode.PKCS7;
ModeValue = CipherMode.CBC;
KeySizeValue = 256;
FeedbackSizeValue = BlockSizeValue = 128;
LegalBlockSizesValue = new KeySizes[] { new KeySizes(128, 256, 64) };
LegalKeySizesValue = new KeySizes[] { new KeySizes(128, 4096, 64) };
}
// Constructor.
public TripleDES()
: base()
{
KeySizeValue = 192;
BlockSizeValue = 64;
FeedbackSizeValue = 64;
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue[0] = new KeySizes(64, 64, 64);
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue[0] = new KeySizes(128, 192, 64);
}
// Constructor.
public RC2()
: base()
{
KeySizeValue = 128;
BlockSizeValue = 64;
FeedbackSizeValue = 64;
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue[0] = new KeySizes(64, 64, 64);
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue[0] = new KeySizes(128, 128, 128);
}
// Constructor.
public Rijndael()
: base()
{
KeySizeValue = 128;
BlockSizeValue = 128;
FeedbackSizeValue = 128;
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue[0] = new KeySizes(128, 128, 128);
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue[0] = new KeySizes(128, 256, 64);
}
// Constructor.
public DES()
: base()
{
KeySizeValue = 64;
BlockSizeValue = 64;
FeedbackSizeValue = 64;
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue[0] = new KeySizes(64, 64, 64);
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue[0] = new KeySizes(64, 64, 64);
}
internal static void ShowLegalSize(KeySizes[] ks)
{
StringBuilder sTmp = new StringBuilder(128);
foreach (KeySizes item in ks)
{
sTmp.Append("Max:").AppendLine(item.MaxSize.ToString());
sTmp.Append("Skip:").AppendLine(item.SkipSize.ToString());
sTmp.Append("Min:").Append(item.MinSize.ToString());
System.Windows.Forms.MessageBox.Show(sTmp.ToString());
}
}
public static void Validate
(
this global::System.Net.Sockets.Socket socket
, KeySizes[] ks
, int i
, string s
)
{
throw new NotImplementedException("Silverlight Cryptography TODO!");
return;
}
protected DES ()
{
KeySizeValue = 64;
BlockSizeValue = 64;
FeedbackSizeValue = 8;
LegalKeySizesValue = new KeySizes[1];
LegalKeySizesValue[0] = new KeySizes(64, 64, 0);
LegalBlockSizesValue = new KeySizes[1];
LegalBlockSizesValue[0] = new KeySizes(64, 64, 0);
}
protected Aes ()
{
KeySizeValue = 256;
BlockSizeValue = 128;
FeedbackSizeValue = 128;
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes (128, 256, 64);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes (128, 128, 0);
}
public NullEncryption()
{
KeySizeValue = 0;
BlockSizeValue = 8;
FeedbackSizeValue = 0;
LegalKeySizesValue = new KeySizes[1];
LegalKeySizesValue[0] = new KeySizes(0, 0, 0);
LegalBlockSizesValue = new KeySizes[1];
LegalBlockSizesValue[0] = new KeySizes(8, 8, 0);
}
public Rijndael ()
#endif
{
KeySizeValue = 256;
BlockSizeValue = 128;
FeedbackSizeValue = 128;
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes (128, 256, 64);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes (128, 256, 64);
}
public DES ()
#endif
{
KeySizeValue = 64;
BlockSizeValue = 64;
FeedbackSizeValue = 8;
LegalKeySizesValue = new KeySizes[1];
LegalKeySizesValue[0] = new KeySizes(64, 64, 0);
LegalBlockSizesValue = new KeySizes[1];
LegalBlockSizesValue[0] = new KeySizes(64, 64, 0);
}
protected TripleDES ()
{
// from SymmetricAlgorithm
KeySizeValue = 192;
BlockSizeValue = 64;
FeedbackSizeValue = 8;
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes (128, 192, 64);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes (64, 64, 0);
}
protected RC2 ()
{
KeySizeValue = 128;
BlockSizeValue = 64;
FeedbackSizeValue = 8;
// The RFC allows keys of 1 to 128 bytes, but MS impl only supports
// 40 to 128 bits, sigh.
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes (40, 128, 8);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes (64, 64, 0);
}
protected Aes ()
{
KeySizeValue = 256;
BlockSizeValue = 128;
#if !NET_2_1
// Silverlight 2.0 only supports CBC mode (i.e. no feedback)
FeedbackSizeValue = 128;
#endif
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes (128, 256, 64);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes (128, 128, 0);
}
[System.Security.SecuritySafeCritical] // auto-generated
public DSACryptoServiceProvider(int dwKeySize, CspParameters parameters) {
if (dwKeySize < 0)
throw new ArgumentOutOfRangeException("dwKeySize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
Contract.EndContractBlock();
_parameters = Utils.SaveCspParameters(CspAlgorithmType.Dss, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
LegalKeySizesValue = new KeySizes[] { new KeySizes(512, 1024, 64) }; // per the DSS spec
_dwKeySize = dwKeySize;
_sha1 = new SHA1CryptoServiceProvider();
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer || Environment.GetCompatibilityFlag(CompatibilityFlag.EagerlyGenerateRandomAsymmKeys))
GetKeyPair();
}
public RC2()
#endif
{
KeySizeValue = 128;
BlockSizeValue = 64;
FeedbackSizeValue = 8;
// The RFC allows keys of 1 to 128 bytes, but MS impl only supports
// 40 to 128 bits, sigh.
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes(40, 128, 8);
LegalBlockSizesValue = new KeySizes [1];
LegalBlockSizesValue [0] = new KeySizes(64, 64, 0);
}
// Validate a key size value.
internal static bool Validate(KeySizes[] sizes, int value)
{
if(sizes == null)
{
return false;
}
foreach(KeySizes size in sizes)
{
if(value >= size.MinSize && value <= size.MaxSize &&
((value - size.MinSize) % size.SkipSize) == 0)
{
return true;
}
}
return false;
}
public Gost3410CryptoServiceProvider(CspParameters parameters)
{
_parameters = CapiHelper.SaveCspParameters(
CapiHelper.CspAlgorithmType.PROV_GOST_2001_DH,
parameters,
s_useMachineKeyStore,
out _randomKeyContainer);
_keySpec = _parameters.KeyNumber;
LegalKeySizesValue = new KeySizes[] { new KeySizes(GostConstants.GOST_3410EL_SIZE, GostConstants.GOST_3410EL_SIZE, 0) };
_gost3411 = Gost3411.Create();
if (!_randomKeyContainer)
{
GetKeyPair();
}
}
public Gost3410_2012_256CryptoServiceProvider(CspParameters parameters)
{
_parameters = CapiHelper.SaveCspParameters(
CapiHelper.CspAlgorithmType.Gost2012_256,
parameters,
s_useMachineKeyStore,
out _randomKeyContainer);
_keySpec = _parameters.KeyNumber;
LegalKeySizesValue = new KeySizes[] { new KeySizes(GostConstants.GOST3410_2012_256KEY_SIZE, GostConstants.GOST3410_2012_256KEY_SIZE, 0) };
_hashImpl = Gost3411_2012_256.Create();
if (!_randomKeyContainer)
{
GetKeyPair();
}
}
internal BCryptSymmetricAlgorithm(CngAlgorithm algorithm,
CngProvider algorithmProvider,
KeySizes[] legalBlockSizes,
KeySizes[] legalkeySizes)
{
Debug.Assert(algorithm != null, "algorithm != null");
Debug.Assert(algorithmProvider != null, "algorithmProvider != null");
Debug.Assert(legalBlockSizes != null, "legalBlockSizes != null");
Debug.Assert(legalkeySizes != null, "legalKeySizes != null");
m_algorithm = algorithm;
m_algorithmProvider = algorithmProvider;
LegalBlockSizesValue = legalBlockSizes;
LegalKeySizesValue = legalkeySizes;
}
private RSACryptoServiceProvider(int keySize, CspParameters parameters, bool useDefaultKeySize)
{
if (keySize < 0)
{
throw new ArgumentOutOfRangeException("dwKeySize", "ArgumentOutOfRange_NeedNonNegNum");
}
_parameters = CapiHelper.SaveCspParameters(CapiHelper.CspAlgorithmType.Rsa, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
_legalKeySizesValue = new KeySizes[] { new KeySizes(384, 16384, 8) };
_keySize = useDefaultKeySize ? 1024 : keySize;
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer)
{
GetKeyPair();
}
}
private RSACryptoServiceProvider(int keySize, CspParameters parameters, bool useDefaultKeySize)
{
if (keySize < 0)
{
throw new ArgumentOutOfRangeException("dwKeySize", "ArgumentOutOfRange_NeedNonNegNum");
}
_parameters = CapiHelper.SaveCspParameters(CapiHelper.CspAlgorithmType.Rsa, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
_legalKeySizesValue = new KeySizes[] { new KeySizes(384, 16384, 8) };
_keySize = useDefaultKeySize ? 1024 : keySize;
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer)
{
GetKeyPair();
}
}
/// <summary>Default constructor. Starts as an uninitialized ECB instance.</summary>
public BlowfishAlgorithm()
: base()
{
KeySizeValue = BlowfishECB.MAX_KEY_LENGTH << 3;
LegalBlockSizesValue = new KeySizes[1];
LegalBlockSizesValue[0] = new KeySizes(
BlockSize,
BlockSize,
BlowfishECB.BLOCK_SIZE);
LegalKeySizesValue = new KeySizes[1];
LegalKeySizesValue[0] = new KeySizes(
0,
BlowfishECB.MAX_KEY_LENGTH << 3,
8);
ModeValue = CipherMode.ECB;
}
[System.Security.SecuritySafeCritical] // auto-generated
public DSACryptoServiceProvider(int dwKeySize, CspParameters parameters)
{
if (dwKeySize < 0)
{
throw new ArgumentOutOfRangeException("dwKeySize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
Contract.EndContractBlock();
_parameters = Utils.SaveCspParameters(CspAlgorithmType.Dss, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
LegalKeySizesValue = new KeySizes[] { new KeySizes(512, 1024, 64) }; // per the DSS spec
_dwKeySize = dwKeySize;
_sha1 = new SHA1CryptoServiceProvider();
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer || Environment.GetCompatibilityFlag(CompatibilityFlag.EagerlyGenerateRandomAsymmKeys))
{
GetKeyPair();
}
}
/// <summary>
/// constructor
/// </summary>
public Blowfish()
{
mBlowfishBase = null;
mBlowfishBaseCbc = null;
// FIXME: are we supposed to create a default key and IV?
IVValue = null;
KeyValue = null;
KeySizeValue = BlowfishBase.MAXKEYLENGTH*8;
LegalBlockSizesValue = new KeySizes[1];
LegalBlockSizesValue[0] = new KeySizes(BlockSize, BlockSize, 8);
LegalKeySizesValue = new KeySizes[1];
LegalKeySizesValue[0] = new KeySizes(0, BlowfishBase.MAXKEYLENGTH*8, 8);
ModeValue = CipherMode.ECB;
m_rng = null;
}
private void Common(int dwKeySize, CspParameters p)
{
// Microsoft RSA CSP can do between 384 and 16384 bits keypair
LegalKeySizesValue = new KeySizes [1];
LegalKeySizesValue [0] = new KeySizes(384, 16384, 8);
base.KeySize = dwKeySize;
rsa = new RSAManaged(KeySize);
rsa.KeyGenerated += new RSAManaged.KeyGeneratedEventHandler(OnKeyGenerated);
persistKey = (p != null);
if (p == null)
{
p = new CspParameters(PROV_RSA_FULL);
#if NET_1_1
if (useMachineKeyStore)
{
p.Flags |= CspProviderFlags.UseMachineKeyStore;
}
#endif
store = new KeyPairPersistence(p);
// no need to load - it cannot exists
}
else
{
store = new KeyPairPersistence(p);
bool exists = store.Load();
bool required = (p.Flags & CspProviderFlags.UseExistingKey) != 0;
if (required && !exists)
{
throw new CryptographicException("Keyset does not exist");
}
if (store.KeyValue != null)
{
persisted = true;
this.FromXmlString(store.KeyValue);
}
}
}
public static bool IsLegalSize(this int size, KeySizes[] legalSizes)
{
for (int i = 0; i < legalSizes.Length; i++)
{
// If a cipher has only one valid key size, MinSize == MaxSize and SkipSize will be 0
if (legalSizes[i].SkipSize == 0)
{
if (legalSizes[i].MinSize == size)
return true;
}
else
{
for (int j = legalSizes[i].MinSize; j <= legalSizes[i].MaxSize; j += legalSizes[i].SkipSize)
{
if (j == size)
return true;
}
}
}
return false;
}
//
// Summary:
// Constructs an InfoCardSymmetricAlgorithm
//
// Parameters:
// cryptoHandle - A handle to the symmetric key to base the symmetric algorithm on.
//
public InfoCardSymmetricAlgorithm(SymmetricCryptoHandle cryptoHandle)
: base()
{
m_cryptoHandle = (SymmetricCryptoHandle)cryptoHandle.Duplicate();
try
{
m_parameters = (RpcSymmetricCryptoParameters)m_cryptoHandle.Parameters;
KeySizeValue = m_parameters.keySize;
BlockSizeValue = m_parameters.blockSize;
FeedbackSizeValue = m_parameters.feedbackSize;
LegalBlockSizesValue = new KeySizes[] { new KeySizes(BlockSizeValue, BlockSizeValue, 0) };
LegalKeySizesValue = new KeySizes[] { new KeySizes(KeySizeValue, KeySizeValue, 0) };
}
catch
{
m_cryptoHandle.Dispose();
throw;
}
}
// Validate "rgbKey" and "rgbIV" values for a call on
// "CreateDecryptor" or "CreateEncryptor".
internal void ValidateCreate(byte[] rgbKey, byte[] rgbIV)
{
if (rgbKey == null)
{
throw new ArgumentNullException("rgbKey");
}
KeySizes.Validate(LegalKeySizesValue, rgbKey.Length * 8,
"Crypto_InvalidKeySize");
if (rgbIV != null)
{
// Verify the size of the IV against the block size.
if ((rgbIV.Length * 8) != BlockSizeValue)
{
throw new CryptographicException
(_("Crypto_InvalidIVSize"),
rgbIV.Length.ToString());
}
}
else if (ModeValue != CipherMode.ECB)
{
// We must have an IV in every mode except ECB.
throw new ArgumentNullException("rgbIV");
}
}
[System.Security.SecurityCritical] // auto-generated
private RSACryptoServiceProvider(int dwKeySize, CspParameters parameters, bool useDefaultKeySize)
{
if (dwKeySize < 0)
{
throw new ArgumentOutOfRangeException("dwKeySize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
Contract.EndContractBlock();
_parameters = Utils.SaveCspParameters(CspAlgorithmType.Rsa, parameters, s_UseMachineKeyStore, ref _randomKeyContainer);
LegalKeySizesValue = new KeySizes[] { new KeySizes(384, 16384, 8) };
_dwKeySize = useDefaultKeySize ? 1024 : dwKeySize;
// If this is not a random container we generate, create it eagerly
// in the constructor so we can report any errors now.
if (!_randomKeyContainer
#if !FEATURE_CORECLR
|| Environment.GetCompatibilityFlag(CompatibilityFlag.EagerlyGenerateRandomAsymmKeys)
#endif //!FEATURE_CORECLR
)
{
GetKeyPair();
}
}
public static bool IsLegalSize(this int size, KeySizes legalSizes)
{
return(size.IsLegalSize(legalSizes, out _));
}
public bool ValidKeySize(int bitLength)
{
return(KeySizes.IsLegalKeySize(LegalKeySizesValue, bitLength));
}
private void SetLegalKeySizesValue()
{
// CNG does not support 128-bit keys.
LegalKeySizesValue = new KeySizes[] { new KeySizes(minSize: 3 * 64, maxSize: 3 * 64, skipSize: 0) };
}
internal RSACryptoServiceProvider(int dwKeySize, CspParameters parameters, bool useDefaultKeySize)
{
int hr;
//
// Save the CSP Parameters
//
if (parameters == null)
{
_parameters = new CspParameters(1, null, null, m_UseMachineKeyStore);
}
else
{
// Check the parameter options: specifying either a key container name or UseDefaultKeyContainer flag
// requires unmanaged code permission
if (((parameters.Flags & CspProviderFlags.UseDefaultKeyContainer) != 0) ||
((parameters.KeyContainerName != null) && (parameters.KeyContainerName.Length > 0)))
{
_UCpermission.Demand();
// If we specified a key container name for this key, then mark it persisted
if ((parameters.KeyContainerName != null) && (parameters.KeyContainerName.Length > 0))
{
// CAPI doesn't accept Container Names longer than 260 characters
if (parameters.KeyContainerName.Length > 260)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidKeyContainerName"));
}
_persistKeyInCSP = true;
}
}
_parameters = parameters;
}
//
// If no key spec has been specified, then set it to be
// AT_KEYEXCHANGE, if a CALG_* has been specified, then
// map that to AT_* value
if (_parameters.KeyNumber == -1)
{
_parameters.KeyNumber = AT_KEYEXCHANGE;
}
else if (_parameters.KeyNumber == CALG_RSA_KEYX)
{
_parameters.KeyNumber = AT_KEYEXCHANGE;
}
else if (_parameters.KeyNumber == CALG_RSA_SIGN)
{
_parameters.KeyNumber = AT_SIGNATURE;
}
// See if we have the Enhanced RSA provider on this machine
_hasEnhancedProvider = HasEnhancedProvider();
// Now determine legal key sizes. If AT_SIGNATURE, then 384 -- 16386. Otherwise, depends on
// whether the strong provider is present.
if (_parameters.KeyNumber == AT_SIGNATURE)
{
LegalKeySizesValue = new KeySizes[1] {
new KeySizes(384, 16384, 8)
};
}
else if (_hasEnhancedProvider)
{
// it is, we have the strong provider
LegalKeySizesValue = new KeySizes[1] {
new KeySizes(384, 16384, 8)
};
}
else
{
// nope, all we have is the base provider
LegalKeySizesValue = new KeySizes[1] {
new KeySizes(384, 512, 8)
};
// tone down the default key size
_defaultKeySize = 512;
}
// Set the key size; this will throw an exception if dwKeySize is invalid.
// Don't check if dwKeySize == 0, since that's the "default size", however
// *our* default should be 1024 if the CSP can handle it. So, if the
// key size was unspecified in a constructor to us, it'll be -1 here and
// change it to the default size. If the user really put in a 0 give him back
// the default for the CSP whatever it is.
if (useDefaultKeySize)
{
dwKeySize = _defaultKeySize;
}
if (dwKeySize != 0)
{
KeySize = dwKeySize;
}
_dwKeySize = dwKeySize;
//
// Create the CSP container for this set of keys
//
_hCSP = IntPtr.Zero;
_hKey = IntPtr.Zero;
hr = _CreateCSP(_parameters, ref _hCSP);
if (hr != 0)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CouldNotAcquire"));
}
if (_hCSP == IntPtr.Zero)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CouldNotAcquire"));
}
// If the key already exists, use it, else generate a new one
hr = _GetUserKey(_hCSP, _parameters.KeyNumber, ref _hKey);
if (hr != 0)
{
_hKey = _GenerateKey(_hCSP, _parameters.KeyNumber, dwKeySize << 16);
if (_hKey == IntPtr.Zero)
{
throw new CryptographicException(Environment.GetResourceString("Cryptography_CSP_CreateKey"));
}
// We just gen'd a new key pair, so we have both halves.
_containerContents = KeyContainerContents.PublicAndExportablePrivate;
}
else
{
// If the key already exists, make sure to persist it
_persistKeyInCSP = true;
// we have both halves, but we don't know if it's exportable or not
_containerContents = KeyContainerContents.Unknown;
}
_CSPHandleProtector = new __CSPHandleProtector(_hCSP, _persistKeyInCSP, _parameters);
_KeyHandleProtector = new __KeyHandleProtector(_hKey);
}
