public void CspNoChangesPermitted() { try { CspParameters cp = new CspParameters(-8, "Provider", "Container"); cp.KeyNumber = 0; cp.Flags = CspProviderFlags.UseMachineKeyStore; KeyPairPersistence kpp = new KeyPairPersistence(cp); CspParameters copy = kpp.Parameters; copy.Flags = CspProviderFlags.UseDefaultKeyContainer; copy.KeyContainerName = "NewContainerName"; copy.KeyNumber = 1; copy.ProviderName = "NewProviderName"; copy.ProviderType = -9; Assert.IsTrue(cp.Flags != copy.Flags, "Flags"); Assert.IsTrue(cp.KeyContainerName != copy.KeyContainerName, "KeyContainerName"); Assert.IsTrue(cp.KeyNumber != copy.KeyNumber, "KeyNumber"); Assert.IsTrue(cp.ProviderName != copy.ProviderName, "ProviderName"); Assert.IsTrue(cp.ProviderType != copy.ProviderType, "ProviderType"); } catch (UnauthorizedAccessException) { Assert.Ignore("Access denied to key containers files."); } }
internal X509Certificate CertificateFromData(byte[] data) { X509Certificate cert = new X509Certificate(data); #if !NET_2_1 // If privateKey it's available, load it too.. CspParameters cspParams = new CspParameters(); cspParams.KeyContainerName = CryptoConvert.ToHex(cert.Hash); if (_storePath.StartsWith(X509StoreManager.LocalMachinePath)) { cspParams.Flags = CspProviderFlags.UseMachineKeyStore; } KeyPairPersistence kpp = new KeyPairPersistence(cspParams); if (!kpp.Load()) { return(cert); } if (cert.RSA != null) { cert.RSA = new RSACryptoServiceProvider(cspParams); } else if (cert.DSA != null) { cert.DSA = new DSACryptoServiceProvider(cspParams); } #endif return(cert); }
public void CspFlagsDefaultMachine() { try { CspParameters cp = new CspParameters(-7, "Provider", "Container"); cp.Flags = CspProviderFlags.UseDefaultKeyContainer | CspProviderFlags.UseMachineKeyStore; KeyPairPersistence kpp = new KeyPairPersistence(cp, "<keypair/>"); kpp.Save(); Assert.IsTrue(File.Exists(kpp.Filename), "Save-Exists"); KeyPairPersistence kpp2 = new KeyPairPersistence(cp); Assert.IsTrue(kpp2.Load(), "Load"); Compare(kpp, kpp2); kpp.Remove(); Assert.IsFalse(File.Exists(kpp.Filename), "Remove-!Exists"); } catch (CryptographicException ce) { // not everyone can write to the machine store if (!(ce.InnerException is UnauthorizedAccessException)) { throw; } Assert.Ignore("Access denied to key containers files."); } catch (UnauthorizedAccessException) { Assert.Ignore("Access denied to key containers files."); } }
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 }
static void DisplayCertificate(X509Certificate x509, bool machine, bool verbose) { Console.WriteLine("{0}X.509 v{1} Certificate", (x509.IsSelfSigned ? "Self-signed " : String.Empty), x509.Version); Console.WriteLine(" Serial Number: {0}", CryptoConvert.ToHex(x509.SerialNumber)); Console.WriteLine(" Issuer Name: {0}", x509.IssuerName); Console.WriteLine(" Subject Name: {0}", x509.SubjectName); Console.WriteLine(" Valid From: {0}", x509.ValidFrom); Console.WriteLine(" Valid Until: {0}", x509.ValidUntil); Console.WriteLine(" Unique Hash: {0}", CryptoConvert.ToHex(x509.Hash)); if (verbose) { Console.WriteLine(" Key Algorithm: {0}", x509.KeyAlgorithm); Console.WriteLine(" Algorithm Parameters: {0}", (x509.KeyAlgorithmParameters == null) ? "None" : CryptoConvert.ToHex(x509.KeyAlgorithmParameters)); Console.WriteLine(" Public Key: {0}", CryptoConvert.ToHex(x509.PublicKey)); Console.WriteLine(" Signature Algorithm: {0}", x509.SignatureAlgorithm); Console.WriteLine(" Algorithm Parameters: {0}", (x509.SignatureAlgorithmParameters == null) ? "None" : CryptoConvert.ToHex(x509.SignatureAlgorithmParameters)); Console.WriteLine(" Signature: {0}", CryptoConvert.ToHex(x509.Signature)); RSACryptoServiceProvider rsaCsp = x509.RSA as RSACryptoServiceProvider; RSAManaged rsaManaged = x509.RSA as RSAManaged; Console.WriteLine(" Private Key: {0}", ((rsaCsp != null && !rsaCsp.PublicOnly) || (rsaManaged != null && !rsaManaged.PublicOnly))); CspParameters cspParams = new CspParameters(); cspParams.KeyContainerName = CryptoConvert.ToHex(x509.Hash); cspParams.Flags = machine ? CspProviderFlags.UseMachineKeyStore : 0; KeyPairPersistence kpp = new KeyPairPersistence(cspParams); Console.WriteLine(" KeyPair Key: {0}", kpp.Load()); } Console.WriteLine(); }
private X509Certificate LoadCertificate(string filename) { byte[] data = Load(filename); X509Certificate cert = new X509Certificate(data); #if !NET_2_1 // If privateKey it's available, load it too.. CspParameters cspParams = new CspParameters(); cspParams.KeyContainerName = CryptoConvert.ToHex(cert.Hash); cspParams.Flags = CspProviderFlags.UseMachineKeyStore; KeyPairPersistence kpp = new KeyPairPersistence(cspParams); if (!kpp.Load()) { return(cert); } if (cert.RSA != null) { cert.RSA = new RSACryptoServiceProvider(cspParams); } else if (cert.DSA != null) { cert.DSA = new DSACryptoServiceProvider(cspParams); } #endif return(cert); }
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); }
void Common(CspParameters parameters) { store = new KeyPairPersistence(parameters); store.Load(); if (store.KeyValue != null) { persisted = true; this.FromXmlString(store.KeyValue); } }
private void Compare(KeyPairPersistence saved, KeyPairPersistence loaded) { // Note: there is an additional Environement.NewLine // at the end of the loaded string - that's why we do // not use AssertEquals (for strings) Assert.IsTrue(loaded.Filename.StartsWith(saved.Filename), "Filename"); Assert.IsTrue(loaded.KeyValue.StartsWith(saved.KeyValue), "KeyValue"); Assert.IsTrue(loaded.Parameters.KeyContainerName.StartsWith(saved.Parameters.KeyContainerName), "Parameters.KeyContainerName"); Assert.AreEqual(saved.Parameters.KeyNumber, loaded.Parameters.KeyNumber, "Parameters.KeyNumber"); Assert.IsTrue(loaded.Parameters.ProviderName.StartsWith(saved.Parameters.ProviderName), "Parameters.ProviderName"); Assert.AreEqual(saved.Parameters.ProviderType, loaded.Parameters.ProviderType, "Parameters.ProviderType"); }
public void Save() { var csp = new CspParameters(1); if (machineStore) { csp.Flags |= CspProviderFlags.UseMachineKeyStore; } csp.ProviderName = String.Empty; csp.KeyContainerName = ContainerName; var kpp = new KeyPairPersistence(csp, KeyValue); kpp.Save(); }
void Common(CspParameters p) { 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; FromXmlString(store.KeyValue); } }
public void CspTypeProvider() { try { CspParameters cp = new CspParameters(-2, "Provider"); KeyPairPersistence kpp = new KeyPairPersistence(cp, "<keypair/>"); kpp.Save(); Assert.IsTrue(File.Exists(kpp.Filename), "Save-Exists"); // we didn't supply a name so we can't load it back kpp.Remove(); Assert.IsFalse(File.Exists(kpp.Filename), "Remove-!Exists"); } catch (UnauthorizedAccessException) { Assert.Ignore("Access denied to key containers files."); } }
public void CspTypeProviderContainer() { try { CspParameters cp = new CspParameters(-3, "Provider", "Container"); KeyPairPersistence kpp = new KeyPairPersistence(cp, "<keypair/>"); kpp.Save(); Assert.IsTrue(File.Exists(kpp.Filename), "Save-Exists"); KeyPairPersistence kpp2 = new KeyPairPersistence(cp); Assert.IsTrue(kpp2.Load(), "Load"); Compare(kpp, kpp2); kpp.Remove(); Assert.IsFalse(File.Exists(kpp.Filename), "Remove-!Exists"); } catch (UnauthorizedAccessException) { Assert.Ignore("Access denied to key containers files."); } }
public static void RemoveFromDisk(string containerName, bool machineStore) { var csp = new CspParameters(); if (machineStore) { csp.Flags |= CspProviderFlags.UseMachineKeyStore; } csp.ProviderName = String.Empty; csp.KeyContainerName = containerName; var kpp = new KeyPairPersistence(csp, String.Empty); if (!File.Exists(kpp.Filename)) { return; } File.Delete(kpp.Filename); }
public void ImportCspBlob(byte[] keyBlob) { if (keyBlob == null) { throw new ArgumentNullException("keyBlob"); } RSA rsa = CryptoConvert.FromCapiKeyBlob(keyBlob); if (rsa is RSACryptoServiceProvider) { // default (if no change are present in machine.config) RSAParameters rsap = rsa.ExportParameters(!(rsa as RSACryptoServiceProvider).PublicOnly); ImportParameters(rsap); } else { // we can't know from RSA if the private key is available try { // so we try it... RSAParameters rsap = rsa.ExportParameters(true); ImportParameters(rsap); } catch { // and fall back RSAParameters rsap = rsa.ExportParameters(false); ImportParameters(rsap); } } var p = new CspParameters(PROV_RSA_FULL); p.KeyNumber = keyBlob[5] == 0x24 ? AT_SIGNATURE : AT_KEYEXCHANGE; if (useMachineKeyStore) { p.Flags |= CspProviderFlags.UseMachineKeyStore; } store = new KeyPairPersistence(p); }
private X509Certificate LoadCertificate(string filename) { byte[] data = Load(filename); X509Certificate cert = new X509Certificate(data); #if !MOBILE // If privateKey it's available, load it too.. CspParameters cspParams = new CspParameters(); cspParams.KeyContainerName = CryptoConvert.ToHex(cert.Hash); if (_storePath.StartsWith(X509StoreManager.LocalMachinePath) || _storePath.StartsWith(X509StoreManager.NewLocalMachinePath)) { cspParams.Flags = CspProviderFlags.UseMachineKeyStore; } KeyPairPersistence kpp = new KeyPairPersistence(cspParams); try { if (!kpp.Load()) { return(cert); } } catch { return(cert); } if (cert.RSA != null) { cert.RSA = new RSACryptoServiceProvider(cspParams); } else if (cert.DSA != null) { cert.DSA = new DSACryptoServiceProvider(cspParams); } #endif return(cert); }
public void Constructor_Null() { KeyPairPersistence kpp = new KeyPairPersistence(null); }