public ElGamalManaged() { // create the key struct o_key_struct = new ElGamalKeyStruct(); // set all of the big integers to zero o_key_struct.P = new BigInteger(0); o_key_struct.G = new BigInteger(0); o_key_struct.Y = new BigInteger(0); o_key_struct.X = new BigInteger(0); // set the default key size value KeySizeValue = 1024; // set the range of legal keys LegalKeySizesValue = new KeySizes[] { new KeySizes(384, 1088, 8) }; }
private static int GetSecondMin(KeySizes[] keySizes) { int secondMin = int.MaxValue; int min = secondMin; foreach (var keySize in keySizes) { int localMin = keySize.MinSize; if (localMin < min) { secondMin = min; min = localMin; } else if (localMin < secondMin) { secondMin = localMin; } if (keySize.MaxSize != keySize.MinSize) { int secondLocal = localMin + keySize.SkipSize; if (secondLocal < secondMin) { secondMin = secondLocal; } } } return secondMin; }
public DSACryptoServiceProvider (int dwKeySize, CspParameters parameters) { LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (512, 1024, 64); // will throw an exception is key size isn't supported KeySize = dwKeySize; dsa = new DSAManaged (dwKeySize); dsa.KeyGenerated += new DSAManaged.KeyGeneratedEventHandler (OnKeyGenerated); persistKey = (parameters != null); if (parameters == null) { parameters = new CspParameters (PROV_DSS_DH); if (useMachineKeyStore) parameters.Flags |= CspProviderFlags.UseMachineKeyStore; store = new KeyPairPersistence (parameters); // no need to load - it cannot exists } else { store = new KeyPairPersistence (parameters); store.Load (); if (store.KeyValue != null) { persisted = true; this.FromXmlString (store.KeyValue); } } }
private static bool IsLegalSize(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; }
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 Null () { KeySizeValue = 128; BlockSizeValue = 128; FeedbackSizeValue = 128; LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (0, 1024, 8); LegalBlockSizesValue = new KeySizes [1]; LegalBlockSizesValue [0] = new KeySizes (0, 1024, 8); }
public TripleDES() { // from SymmetricAlgorithm KeySizeValue = 192; BlockSizeValue = 64; FeedbackSizeValue = 64; LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (128, 192, 64); LegalBlockSizesValue = new KeySizes [1]; LegalBlockSizesValue [0] = new KeySizes (64, 64, 0); }
private static int GetMin(KeySizes[] keySizes) { int min = int.MaxValue; foreach (var keySize in keySizes) { if (keySize.MinSize < min) { min = keySize.MinSize; } } return min; }
public static bool IsKeySizeValid(this KeySizes keySizes, int keySize) { if (keySizes.SkipSize == 0) { return(keySizes.MinSize == keySize || keySizes.MaxSize == keySize); } for (int minSize = keySizes.MinSize; minSize <= keySizes.MaxSize; minSize += keySizes.SkipSize) { if (keySize == minSize) { return(true); } } return(false); }
public static void LegalBlockSizes() { using (Aes aes = AesFactory.Create()) { KeySizes[] blockSizes = aes.LegalBlockSizes; Assert.NotNull(blockSizes); Assert.Equal(1, blockSizes.Length); KeySizes blockSizeLimits = blockSizes[0]; Assert.Equal(128, blockSizeLimits.MinSize); Assert.Equal(128, blockSizeLimits.MaxSize); Assert.Equal(0, blockSizeLimits.SkipSize); } }
/// <summary> /// Initializes a new instance of the RC4 class. /// </summary> internal RC4() { // Recommended length for use in the US is 128 bits. KeySizeValue = 128; // Usually, it is 256 bits. However, to increase safety, it is necessary to increase this value. BlockSizeValue = 256; // Response size cannot be larger than block size. FeedbackSizeValue = BlockSizeValue; // The algorithm has no max limit on the size of the S-box. Limitations only in performance and x86/x64 system. LegalBlockSizesValue = new KeySizes[] { new KeySizes(256, 256, 0) }; // The key length can be 8-2048 bits (1 - 256 bytes). LegalKeySizesValue = new KeySizes[] { new KeySizes(8, 2048, 0) }; // The CBC mode may also be considered a stream cipher with n-bit blocks playing the role of very large characters. ModeValue = CipherMode.CBC; PaddingValue = PaddingMode.None; }
public static void LegalKeySizes() { using (Aes aes = AesFactory.Create()) { KeySizes[] keySizes = aes.LegalKeySizes; Assert.NotNull(keySizes); Assert.Equal(1, keySizes.Length); KeySizes keySizeLimits = keySizes[0]; Assert.Equal(128, keySizeLimits.MinSize); Assert.Equal(256, keySizeLimits.MaxSize); Assert.Equal(64, keySizeLimits.SkipSize); } }
/// <summary> /// Try get legal nonce sizes. /// </summary> /// <param name="mode">Symmetric algorithm cipher mode.</param> /// <param name="padding">Symmetric algorithm padding mode.</param> /// <param name="nonceSizes">Legal nonce size bits.</param> /// <returns></returns> public bool TryGetNonceSizes(SymmetricCipherMode mode, SymmetricPaddingMode padding, out KeySizes[] nonceSizes) { switch (padding) { case SymmetricPaddingMode.NoPadding: break; default: nonceSizes = null; return(false); } switch (mode) { case SymmetricCipherMode.CCM: if (this.BlockSize == 128) { nonceSizes = new KeySizes[] { new KeySizes(56, 104, 8) }; return(true); } break; case SymmetricCipherMode.EAX: if (this.BlockSize == 64 || this.BlockSize == 128) { nonceSizes = new KeySizes[] { new KeySizes(8, 2147483640, 8) }; return(true); } break; case SymmetricCipherMode.GCM: if (this.BlockSize == 128) { nonceSizes = new KeySizes[] { new KeySizes(8, 2147483640, 8) }; return(true); } break; case SymmetricCipherMode.OCB: if (this.BlockSize == 128) { nonceSizes = new KeySizes[] { new KeySizes(0, 120, 8) }; return(true); } break; default: break; } nonceSizes = null; return(false); }
/// <summary> /// Try get legal mac sizes. /// </summary> /// <param name="mode">Symmetric algorithm cipher mode.</param> /// <param name="padding">Symmetric algorithm padding mode.</param> /// <param name="macSizes">Legal mac size bits.</param> /// <returns></returns> public bool TryGetMacSizes(SymmetricCipherMode mode, SymmetricPaddingMode padding, out KeySizes[] macSizes) { switch (padding) { case SymmetricPaddingMode.NoPadding: break; default: macSizes = null; return(false); } switch (mode) { case SymmetricCipherMode.CCM: if (this.BlockSize == 128) { macSizes = new KeySizes[] { new KeySizes(32, 128, 16) }; return(true); } break; case SymmetricCipherMode.EAX: if (this.BlockSize == 64 || this.BlockSize == 128) { macSizes = new KeySizes[] { new KeySizes(8, this.BlockSize, 8) }; return(true); } break; case SymmetricCipherMode.GCM: if (this.BlockSize == 128) { macSizes = new KeySizes[] { new KeySizes(32, 128, 8) }; return(true); } break; case SymmetricCipherMode.OCB: if (this.BlockSize == 128) { macSizes = new KeySizes[] { new KeySizes(64, 128, 8) }; return(true); } break; default: break; } macSizes = null; return(false); }
/// <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; }
public static void LegalKeySizes() { using (Aes aes = AesFactory.Create()) { KeySizes[] keySizes = aes.LegalKeySizes; Assert.NotNull(keySizes); Assert.Equal(1, keySizes.Length); KeySizes keySizeLimits = keySizes[0]; Assert.Equal(128, keySizeLimits.MinSize); Assert.Equal(256, keySizeLimits.MaxSize); // Browser's SubtleCrypto doesn't support AES-192 int expectedKeySkipSize = PlatformDetection.IsBrowser ? 128 : 64; Assert.Equal(expectedKeySkipSize, keySizeLimits.SkipSize); } }
public void LegalKeySizes(AsymmetricAlgorithm name, int minSize, int maxSize, int stepSize) { IAsymmetricKeyAlgorithmProvider provider = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(name); IReadOnlyList <KeySizes>? result = provider.LegalKeySizes; Assert.NotNull(result); Assert.NotEmpty(result); Action <int> attemptKeySize = size => { provider.CreateKeyPair(size).Dispose(); }; KeySizes range = result.Single(); Assert.Equal(minSize, range.MinSize); Assert.Equal(maxSize, range.MaxSize); Assert.Equal(stepSize, range.StepSize); }
// Initialise bi from XML element if element_name matches // Used by FromXmlString private bool CheckXmlElement(XmlReader reader, string element_name, string element_name_required, ref BigInteger bi_out) { if (element_name != element_name_required) { return(false); } string s = reader.ReadString(); byte[] b = Convert.FromBase64String(s); if (element_name == "Modulus") { KeySizeValue = b.Length * 8; LegalKeySizesValue[0] = new KeySizes(KeySizeValue, KeySizeValue, 0); } BigInteger bi = new BigInteger(b); bi_out = bi; return(true); }
public PaillierManaged() { // create the key struct o_key_struct = new PaillierKeyStruct(); // set all of the big integers to zero o_key_struct.N = new BigInteger(0); o_key_struct.G = new BigInteger(0); o_key_struct.Lambda = new BigInteger(0); o_key_struct.Miu = new BigInteger(0); // set the default key size value KeySizeValue = 1024; // set the default padding mode Padding = PaillierPaddingMode.LeadingZeros; // set the range of legal keys LegalKeySizesValue = new KeySizes[] { new KeySizes(384, 1088, 8) }; }
/// <summary> /// constructor /// </summary> public BlowfishAlgorithm() : base() { m_bf = null; m_bfc = null; // FIXME: are we supposed to create a default key and IV? IVValue = null; KeyValue = null; KeySizeValue = Blowfish.MAXKEYLENGTH * 8; LegalBlockSizesValue = new KeySizes[1]; LegalBlockSizesValue[0] = new KeySizes(BlockSize, BlockSize, 8); LegalKeySizesValue = new KeySizes[1]; LegalKeySizesValue[0] = new KeySizes(0, Blowfish.MAXKEYLENGTH * 8, 8); ModeValue = CipherMode.ECB; m_rng = null; }
public BlowfishAlgorithm() : base() { m_bf = null; m_bfc = null; IVValue = null; KeyValue = null; KeySizeValue = Blowfish.MAXKEYLENGTH * 8; LegalBlockSizesValue = new KeySizes[1]; LegalBlockSizesValue[0] = new KeySizes(BlockSize, BlockSize, 8); LegalKeySizesValue = new KeySizes[1]; LegalKeySizesValue[0] = new KeySizes(0, Blowfish.MAXKEYLENGTH * 8, 8); ModeValue = CipherMode.ECB; m_rng = null; }
private void UpdateLegalTagSizes(SafeBCryptAlgorithmHandle algorithm) { Debug.Assert(algorithm != null, "algorithm != null"); Debug.Assert(!algorithm.IsClosed && !algorithm.IsInvalid, "!algorithm.IsClosed && !algorithm.IsInvalid"); // Get the authentication tag length structure. BCryptNative.BCRYPT_KEY_LENGTHS_STRUCT tagLengths = BCryptNative.GetValueTypeProperty <SafeBCryptAlgorithmHandle, BCryptNative.BCRYPT_KEY_LENGTHS_STRUCT>( algorithm, BCryptNative.ObjectPropertyName.AuthTagLength); // BCrypt returns the tag sizes in bytes, convert them to bits for the LegalTagSizes property LegalTagSizesValue = new KeySizes[] { new KeySizes(tagLengths.dwMinLength * 8, tagLengths.dwMaxLength * 8, tagLengths.dwIncrement * 8) }; // By default, generate the maximum authentication tag length possible for this algorithm TagSize = tagLengths.dwMaxLength * 8; }
public ElGamalManaged() { // create the key struct o_key_struct = new ElGamalKeyStruct(); // set all of the big integers to zero o_key_struct.P = new BigInteger(0); o_key_struct.G = new BigInteger(0); o_key_struct.Y = new BigInteger(0); o_key_struct.X = new BigInteger(0); // set the default key size value KeySizeValue = 1024; // set the default padding mode Padding = ElGamalPaddingMode.Zeros; // set the range of legal keys LegalKeySizesValue = new KeySizes[] { new KeySizes(384, 1088, 8) }; }
// // 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; } }
private static bool IsLegalSize(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; }
// Display specified KeySize properties to the console. private static void ShowKeys(KeySizes[] keySizes, string objectName) { // Retrieve the first KeySizes in the array. KeySizes firstKeySize = keySizes[0]; // Retrieve the minimum key size in bits. int minKeySize = firstKeySize.MinSize; // Retrieve the maximum key size in bits. int maxKeySize = firstKeySize.MaxSize; // Retrieve the interval between valid key size in bits. int skipKeySize = firstKeySize.SkipSize; Console.Write("\n KeySizes retrieved from the "); Console.WriteLine(objectName + " object."); Console.WriteLine("Minimum key size bits: " + minKeySize); Console.WriteLine("Maximum key size bits: " + maxKeySize); Console.WriteLine("Interval between key size bits: " + skipKeySize); }
// // Summary: // Given a pointer to a CryptoHandle create a new instance of this class. // public InfoCardRSACryptoProvider(AsymmetricCryptoHandle cryptoHandle) : base() { m_cryptoHandle = (AsymmetricCryptoHandle)cryptoHandle.Duplicate(); try { m_params = (RpcAsymmetricCryptoParameters)m_cryptoHandle.Parameters; int keySize = m_params.keySize; LegalKeySizesValue = new KeySizes[1]; KeySizeValue = keySize; LegalKeySizesValue[0] = new KeySizes(keySize, keySize, 0); } catch { m_cryptoHandle.Dispose(); m_cryptoHandle = null; throw; } }
public Trivial() { // Desktop's SymmetricAlgorithm reads from the field overly aggressively, // but in Core it always reads from the property. By setting the field // we're still happy on Desktop tests, and we can validate the default // behavior of the LegalBlockSizes property. LegalBlockSizesValue = new KeySizes[] { new KeySizes(5 * 8, -99 * 8, 0 * 8), new KeySizes(13 * 8, 22 * 8, 6 * 8), new KeySizes(101 * 8, 104 * 8, 1 * 8), }; // Desktop's SymmetricAlgorithm reads from the property correctly, but // we'll set the field here, anyways, to validate the default behavior // of the LegalKeySizes property. LegalKeySizesValue = new KeySizes[] { new KeySizes(5 * 8, -99 * 8, 0 * 8), new KeySizes(13 * 8, 22 * 8, 6 * 8), new KeySizes(101 * 8, 104 * 8, 1 * 8), }; }
private static Byte[] Pad(Byte[] buf, KeySizes keySize) { var psize = buf.Length * 8; var size = 0; for (var i = keySize.MinSize; i <= keySize.MaxSize; i += keySize.SkipSize) { if (i >= psize) { size = i / 8; break; } // DES的SkipSize为0 if (keySize.SkipSize == 0) { break; } } // 所有key大小都不合适,取最大值,此时密码过长,需要截断 if (size == 0) { size = keySize.MaxSize / 8; } if (buf.Length == size) { return(buf); } var buf2 = new Byte[size]; buf2.Write(0, buf); return(buf2); }
/// <summary> /// Initializes a new instance of the RC4CryptoServiceProvider class. /// </summary> public RC4CryptoServiceProvider() { // Change the limits for the current implementation (5 - 256 bytes). LegalKeySizesValue = new KeySizes[] { new KeySizes(40, 2048, 0) }; }
private bool CompareKeySizes (KeySizes k1, KeySizes k2) { bool result = k1.MaxSize == k2.MaxSize; result = result && k1.MinSize == k2.MinSize; result = result && k1.SkipSize == k2.SkipSize; return result; }
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); store.Load (); if (store.KeyValue != null) { persisted = true; this.FromXmlString (store.KeyValue); } } }
public RijndaelLegalSizesBreaker() { LegalKeySizesValue[0] = new KeySizes(1, 1, 0); LegalBlockSizesValue[0] = new KeySizes(1, 1, 0); }
/// <summary> /// Try get legal sizes. /// </summary> /// <param name="mode">Symmetric algorithm cipher mode.</param> /// <param name="padding">Symmetric algorithm padding mode.</param> /// <param name="ivSizes">Legal iv size bits.</param> /// <returns></returns> public bool TryGetIVSizes(SymmetricCipherMode mode, SymmetricPaddingMode padding, out KeySizes[] ivSizes) { bool pad; switch (padding) { case SymmetricPaddingMode.NoPadding: pad = false; break; case SymmetricPaddingMode.PKCS7: case SymmetricPaddingMode.Zeros: case SymmetricPaddingMode.X923: case SymmetricPaddingMode.ISO10126: case SymmetricPaddingMode.ISO7816_4: case SymmetricPaddingMode.TBC: pad = true; break; default: ivSizes = null; return(false); } switch (mode) { case SymmetricCipherMode.CBC: ivSizes = new KeySizes[] { new KeySizes(this.BlockSize, this.BlockSize, 0) }; return(true); case SymmetricCipherMode.ECB: ivSizes = new KeySizes[] { new KeySizes(0, 0, 0) }; return(true); case SymmetricCipherMode.OFB: ivSizes = new KeySizes[] { new KeySizes(8, this.BlockSize, 8) }; return(true); case SymmetricCipherMode.CFB: ivSizes = new KeySizes[] { new KeySizes(8, this.BlockSize, 8) }; return(true); case SymmetricCipherMode.CTS: if (!pad) { ivSizes = new KeySizes[] { new KeySizes(this.BlockSize, this.BlockSize, 0) }; return(true); } break; case SymmetricCipherMode.CTR: { int min = Math.Max(this.BlockSize / 2, this.BlockSize - 64); ivSizes = new KeySizes[] { new KeySizes(min, this.BlockSize, 8) }; return(true); } case SymmetricCipherMode.CTS_ECB: if (!pad) { ivSizes = new KeySizes[] { new KeySizes(0, 0, 0) }; return(true); } break; case SymmetricCipherMode.GOFB: if (this.BlockSize == 64) { ivSizes = new KeySizes[] { new KeySizes(this.BlockSize, this.BlockSize, 0) }; return(true); } break; case SymmetricCipherMode.OpenPGPCFB: ivSizes = new KeySizes[] { new KeySizes(8, this.BlockSize, 8) }; return(true); case SymmetricCipherMode.SIC: if (this.BlockSize >= 128) { int min = Math.Max(this.BlockSize / 2, this.BlockSize - 64); ivSizes = new KeySizes[] { new KeySizes(min, this.BlockSize, 8) }; return(true); } break; case SymmetricCipherMode.CCM: if (!pad && this.BlockSize == 128) { ivSizes = new KeySizes[] { new KeySizes(56, 104, 8) }; return(true); } break; case SymmetricCipherMode.EAX: if (!pad && (this.BlockSize == 64 || this.BlockSize == 128)) { ivSizes = new KeySizes[] { new KeySizes(8, 2147483640, 8) }; return(true); } break; case SymmetricCipherMode.GCM: if (!pad && this.BlockSize == 128) { ivSizes = new KeySizes[] { new KeySizes(8, 2147483640, 8) }; return(true); } break; case SymmetricCipherMode.OCB: if (!pad && this.BlockSize == 128) { ivSizes = new KeySizes[] { new KeySizes(0, 120, 8) }; return(true); } break; default: break; } ivSizes = null; return(false); }
public static bool IsLegalSize(this int size, KeySizes legalSizes) { return(size.IsLegalSize(legalSizes, out _)); }
void Common (int dwKeySize, bool parameters) { // 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 = parameters; if (parameters) return; // no need to load - it cannot exists var p = new CspParameters (PROV_RSA_FULL); if (useMachineKeyStore) p.Flags |= CspProviderFlags.UseMachineKeyStore; store = new KeyPairPersistence (p); }
private static int GetMax(KeySizes[] keySizes) { int max = 0; foreach (var keySize in keySizes) { if (keySize.MaxSize > max) { max = keySize.MaxSize; } } return max; }
public RC2LegalSizesBreaker() { LegalKeySizesValue[0] = new KeySizes(1, 1, 0); LegalBlockSizesValue[0] = new KeySizes(1, 1, 0); }
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 (useMachineKeyStore) p.Flags |= CspProviderFlags.UseMachineKeyStore; 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 DSAManaged (int dwKeySize) { KeySizeValue = dwKeySize; LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (512, 1024, 64); }
public bool ValidKeySize(int bitLength) { return(KeySizes.IsLegalKeySize(LegalKeySizesValue, bitLength)); }
public RSAManaged (int keySize) { LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (384, 16384, 8); base.KeySize = keySize; }
// Check that a size value is in a size list. private void CheckSize(String msg, KeySizes[] sizes, int value) { foreach(KeySizes size in sizes) { if(value >= size.MinSize && value <= size.MaxSize && ((value - size.MinSize) % size.SkipSize) == 0) { return; } } Fail(msg); }
public CryptoRSA(KeySizes KeySize) { _RSACSP = new RSACryptoServiceProvider((int)KeySize); _Converter = new UTF8Encoding(); }
public Trivial() { LegalKeySizesValue = new KeySizes[] { new KeySizes(5*8, -99*8, 0*8), new KeySizes(13*8, 22*8, 6*8), new KeySizes(101*8, 104*8, 1*8), new KeySizes(101*8 + 1, 101*8 + 2, 1), }; }
void Common (int dwKeySize, bool parameters) { LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (512, 1024, 64); // will throw an exception is key size isn't supported KeySize = dwKeySize; dsa = new DSAManaged (dwKeySize); dsa.KeyGenerated += new DSAManaged.KeyGeneratedEventHandler (OnKeyGenerated); persistKey = parameters; if (parameters) return; var p = new CspParameters (PROV_DSS_DH); if (useMachineKeyStore) p.Flags |= CspProviderFlags.UseMachineKeyStore; store = new KeyPairPersistence (p); // no need to load - it cannot exists }
private void OnKeySizeChanged(object sender, EventArgs e) { KeySizes ksize = KeySizes.K256; Enum.TryParse<KeySizes>(((ComboBox)sender).Text, out ksize); _keySize = ksize; }
public Trivial() { // Desktop's SymmetricAlgorithm reads from the field overly aggressively, // but in Core it always reads from the property. By setting the field // we're still happy on Desktop tests, and we can validate the default // behavior of the LegalBlockSizes property. LegalBlockSizesValue = new KeySizes[] { new KeySizes(5*8, -99*8, 0*8), new KeySizes(13*8, 22*8, 6*8), new KeySizes(101*8, 104*8, 1*8), }; // Desktop's SymmetricAlgorithm reads from the property correctly, but // we'll set the field here, anyways, to validate the default behavior // of the LegalKeySizes property. LegalKeySizesValue = new KeySizes[] { new KeySizes(5*8, -99*8, 0*8), new KeySizes(13*8, 22*8, 6*8), new KeySizes(101*8, 104*8, 1*8), }; }
public TripleDESLegalSizesBreaker() { LegalKeySizesValue[0] = new KeySizes(1, 1, 0); LegalBlockSizesValue[0] = new KeySizes(1, 1, 0); }
public RSAManaged(int keySize) { LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes(384, 16384, 8); base.KeySize = keySize; }
public RSAManaged (int keySize) { KeySizeValue = keySize; LegalKeySizesValue = new KeySizes [1]; LegalKeySizesValue [0] = new KeySizes (192, 16384, 8);//duff 384 before now 192 }
private int GetKeySize(string KeyPath) { KeySizes keySize = KeyHeader.GetKeySize(KeyPath); if (this.Engine == Engines.DCS) { return(96); } if (keySize == KeySizes.K128) { return(16); } else if (keySize == KeySizes.K192) { return(24); } else if (keySize == KeySizes.K192) { return(24); } else if (keySize == KeySizes.K256) { return(32); } else if (keySize == KeySizes.K384) { return(48); } else if (keySize == KeySizes.K448) { return(56); } else if (keySize == KeySizes.K512) { return(64); } else if (keySize == KeySizes.K1024) { return(128); } else if (keySize == KeySizes.K1536) { return(192); } else if (keySize == KeySizes.K2560) { return(320); } else if (keySize == KeySizes.K3584) { return(448); } else if (keySize == KeySizes.K4608) { return(576); } else { return(32); } }
public TripleDESLegalSizesBreaker() { LegalKeySizesValue[0] = new KeySizes(1, 1, 0); LegalBlockSizesValue[0] = new KeySizes(1, 1, 0); }
public HostManaged() { // define the valid block and key sizes LegalKeySizesValue = new KeySizes[] { new KeySizes(256, 256, 0) }; LegalBlockSizesValue = new KeySizes[] { new KeySizes(64, 64, 0) }; }