// Initialize all of the default certificates and protocols public SslServer() { // Initialize the Socket serverSocketType = SocketType.Stream; serverProtocolType = ProtocolType.Tcp; if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3) { cert = new X509Certificate(CertificatesAndCAs.emuCert, "NetMF"); ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caEmuCert) }; } else { // Initialize the SslStream cert = new X509Certificate(CertificatesAndCAs.newCert); ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caCert) }; } verify = SslVerification.NoVerification; sslProtocols = new SslProtocols[] { SslProtocols.Default }; // Create a TCP/IP (IPv4) socket and listen for incoming connections. serverSocket = new Socket(AddressFamily.InterNetwork, serverSocketType, serverProtocolType); serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false); serverSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); serverEp = (IPEndPoint)serverSocket.LocalEndPoint; Debug.Print("Listening for a client to connect..."); serverSocket.Listen(1); }
// The GitHub SSL certificate is corrupt, or something? Who cares. public static bool Validator( object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors ) { return true; }
public void CanCreateAndDispose() { using (var cert = new X509Certificate()) { cert.PrintRefCount(); } }
public virtual bool IsSignedBy(X509Certificate potentialIssuer) { try { x509crl.Verify(potentialIssuer.GetPublicKey()); return true; } catch (InvalidKeyException) { return false; } /*catch (CrlException) { return false; }*/ catch (NoSuchAlgorithmException) { return false; } /*catch (NoSuchProviderException e) { throw new RuntimeException(e); }*/ catch (SignatureException) { return false; } }
public static bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { if (sslPolicyErrors == SslPolicyErrors.None) { return true; } byte[] receivedCertificateHash = certificate.GetCertHash(); //If length differs, obviously different hash. if (receivedCertificateHash.Length != hardCodedServerCertificateHash.Length) { return false; } //Check that each byte is the same for (int i = 0; i < hardCodedServerCertificateHash.Length; i++) { if (receivedCertificateHash[i] != hardCodedServerCertificateHash[i]) { return false; } } //Equality of the certificates confirmed. return true; }
public TcpTransport(string host,int port, X509Certificate clientCertificate, bool loggingEnabled = false) { EPP_REGISTRY_COM = host; PORT = port; this.loggingEnabled = loggingEnabled; this.clientCertificate = clientCertificate; }
public void CanAddExtensions() { X509V3ExtensionList extList = new X509V3ExtensionList(); extList.Add(new X509V3ExtensionValue("subjectKeyIdentifier", false, "hash")); extList.Add(new X509V3ExtensionValue("authorityKeyIdentifier", false, "keyid:always,issuer:always")); extList.Add(new X509V3ExtensionValue("basicConstraints", true, "critical,CA:true")); extList.Add(new X509V3ExtensionValue("keyUsage", false, "cRLSign,keyCertSign")); DateTime start = DateTime.Now; DateTime end = start + TimeSpan.FromMinutes(10); CryptoKey key = new CryptoKey(new DSA(true)); using (X509Certificate cert = new X509Certificate(101, "CN=Root", "CN=Root", key, start, end)) { foreach (X509V3ExtensionValue extValue in extList) { using (X509Extension ext = new X509Extension(cert, cert, extValue.Name, extValue.IsCritical, extValue.Value)) { cert.AddExtension(ext); } } foreach (X509Extension ext in cert.Extensions) { Console.WriteLine(ext); } Assert.AreEqual(extList.Count, cert.Extensions.Count); } }
public bool PosTest1() { bool retVal = true; X509Certificate cer; TestLibrary.TestFramework.BeginScenario("PosTest1: Valid certificate"); try { cer = new X509Certificate(c_VALIDPATH); if (null == cer) { TestLibrary.TestFramework.LogError("-01", "Failed to load " + c_VALIDPATH); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("000", "Unexpected exception: " + e); retVal = false; } return retVal; }
public SslStreamServer( Stream stream, bool ownStream, X509Certificate serverCertificate, bool clientCertificateRequired, X509Chain caCerts, SslProtocols enabledSslProtocols, SslStrength sslStrength, bool checkCertificateRevocation, RemoteCertificateValidationHandler remote_callback) : base(stream, ownStream) { this.checkCertificateRevocationStatus = checkCertificateRevocation; this.remoteCertificateSelectionCallback = remote_callback; // Initialize the SslContext object InitializeServerContext(serverCertificate, clientCertificateRequired, caCerts, enabledSslProtocols, sslStrength, checkCertificateRevocation); ssl = new Ssl(sslContext); // Initialze the read/write bio read_bio = BIO.MemoryBuffer(false); write_bio = BIO.MemoryBuffer(false); // Set the read/write bio's into the the Ssl object ssl.SetBIO(read_bio, write_bio); read_bio.SetClose(BIO.CloseOption.Close); write_bio.SetClose(BIO.CloseOption.Close); // Set the Ssl object into server mode ssl.SetAcceptState(); }
public ServerContext( SslServerStream stream, SecurityProtocolType securityProtocolType, X509Certificate serverCertificate, bool clientCertificateRequired) : base(securityProtocolType) { this.sslStream = stream; this.clientCertificateRequired = clientCertificateRequired; // Convert the System.Security cert to a Mono Cert MonoX509.X509Certificate cert = new MonoX509.X509Certificate(serverCertificate.GetRawCertData()); // Add server certificate to the certificate collection this.ServerSettings.Certificates = new MonoX509.X509CertificateCollection(); this.ServerSettings.Certificates.Add(cert); this.ServerSettings.UpdateCertificateRSA(); // Add requested certificate types this.ServerSettings.CertificateTypes = new ClientCertificateType[1]; this.ServerSettings.CertificateTypes[0] = ClientCertificateType.RSA; // Add certificate authorities MonoX509.X509CertificateCollection trusted = MonoX509.X509StoreManager.TrustedRootCertificates; string[] list = new string [trusted.Count]; int i = 0; foreach (MonoX509.X509Certificate root in trusted) { list [i++] = root.IssuerName; } this.ServerSettings.DistinguisedNames = list; }
public static ICollection GetSubjectAlternativeNames( X509Certificate cert) { Asn1OctetString extVal = cert.GetExtensionValue(X509Extensions.SubjectAlternativeName); return GetAlternativeName(extVal); }
private static Asn1Sequence FromCertificate( X509Certificate certificate) { try { GeneralName genName = new GeneralName( PrincipalUtilities.GetIssuerX509Principal(certificate)); if (certificate.Version == 3) { Asn1OctetString ext = certificate.GetExtensionValue(X509Extensions.SubjectKeyIdentifier); if (ext != null) { Asn1OctetString str = (Asn1OctetString) X509ExtensionUtilities.FromExtensionValue(ext); return (Asn1Sequence) new AuthorityKeyIdentifier( str.GetOctets(), new GeneralNames(genName), certificate.SerialNumber).ToAsn1Object(); } } SubjectPublicKeyInfo info = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo( certificate.GetPublicKey()); return (Asn1Sequence) new AuthorityKeyIdentifier( info, new GeneralNames(genName), certificate.SerialNumber).ToAsn1Object(); } catch (Exception e) { throw new CertificateParsingException("Exception extracting certificate details", e); } }
public ServerContext( SslServerStream stream, SecurityProtocolType securityProtocolType, X509Certificate serverCertificate, bool clientCertificateRequired) : base(securityProtocolType) { this.sslStream = stream; this.clientCertificateRequired = clientCertificateRequired; // Convert the System.Security cert to a Mono Cert MonoX509.X509Certificate cert = new MonoX509.X509Certificate(serverCertificate.GetRawCertData()); // Add server certificate to the certificate collection this.ServerSettings.Certificates = new MonoX509.X509CertificateCollection(); this.ServerSettings.Certificates.Add(cert); this.ServerSettings.UpdateCertificateRSA(); // Add requested certificate types this.ServerSettings.CertificateTypes = new ClientCertificateType[1]; this.ServerSettings.CertificateTypes[0] = ClientCertificateType.RSA; // Add certificate authorities this.ServerSettings.DistinguisedNames = new string[0]; }
public AppleTlsContext( MobileAuthenticatedStream parent, MonoTlsSettings settings, AppleTlsProvider provider, bool serverMode, string targetHost, SSA.SslProtocols enabledProtocols, X509Certificate serverCertificate, X509CertificateCollection clientCertificates, bool askForClientCert) { this.parent = parent; this.settings = settings; this.provider = provider; this.serverMode = serverMode; this.targetHost = targetHost; this.enabledProtocols = enabledProtocols; this.serverCertificate = serverCertificate; this.clientCertificates = clientCertificates; this.askForClientCert = askForClientCert; handle = GCHandle.Alloc (this); connectionId = GCHandle.ToIntPtr (handle); readFunc = NativeReadCallback; writeFunc = NativeWriteCallback; // a bit higher than the default maximum fragment size readBuffer = new byte [16384]; writeBuffer = new byte [16384]; certificateValidator = CertificateValidationHelper.GetDefaultValidator (settings, provider); if (IsServer) { if (serverCertificate == null) throw new ArgumentNullException ("serverCertificate"); } }
public static void X509Certificate2CollectionConstructors() { using (X509Certificate2 c1 = new X509Certificate2()) using (X509Certificate2 c2 = new X509Certificate2()) using (X509Certificate2 c3 = new X509Certificate2()) { X509Certificate2Collection cc = new X509Certificate2Collection(new X509Certificate2[] { c1, c2, c3 }); Assert.Equal(3, cc.Count); Assert.Same(c1, cc[0]); Assert.Same(c2, cc[1]); Assert.Same(c3, cc[2]); X509Certificate2Collection cc2 = new X509Certificate2Collection(cc); Assert.Equal(3, cc2.Count); Assert.Same(c1, cc2[0]); Assert.Same(c2, cc2[1]); Assert.Same(c3, cc2[2]); Assert.Throws<ArgumentNullException>(() => new X509Certificate2Collection(new X509Certificate2[] { c1, c2, null, c3 })); using (X509Certificate c4 = new X509Certificate()) { X509Certificate2Collection collection = new X509Certificate2Collection { c1, c2, c3 }; ((IList)collection).Add(c4); // Add non-X509Certificate2 object Assert.Throws<InvalidCastException>(() => new X509Certificate2Collection(collection)); } } }
//Encryption internal WebSocketClient(Socket s,X509Certificate cert) { this.Socket = s; var ns = new NetworkStream(s,false); var ss = new SslStream(ns, false); ss.AuthenticateAsServer(cert,false,SslProtocols.Tls12,false); this.stream = ss; }
public bool NegTest1(string fileName) { return NegTest(1, "Import(String)", fileName, delegate(string fName) { X509Certificate cer; cer = new X509Certificate(); cer.Import(fName); return false; } ); }
public bool NegTest2(string fileName) { return NegTest(2, "Import(String,String,X509KeyStorageFlags)", fileName, delegate(string fName) { X509Certificate cer; cer = new X509Certificate(); cer.Import(fName, "", X509KeyStorageFlags.DefaultKeySet); return false; } ); }
public bool NegTest3(string fileName) { return NegTest(3, "Import(byte[])", fileName, delegate(string fName) { X509Certificate cer; cer = new X509Certificate(); cer.Import(BytesFromFile(fName)); return false; } ); }
/// <summary> /// Calls X509V3_EXT_conf_nid() /// </summary> /// <param name="issuer"></param> /// <param name="subject"></param> /// <param name="name"></param> /// <param name="critical"></param> /// <param name="value"></param> public X509Extension(X509Certificate issuer, X509Certificate subject, string name, bool critical, string value) : base(IntPtr.Zero, true) { using (var ctx = new X509V3Context(issuer, subject, null)) { ptr = Native.ExpectNonNull(Native.X509V3_EXT_conf_nid(IntPtr.Zero, ctx.Handle, Native.TextToNID(name), value)); } }
public void CanLoadFromPEM() { using (BIO bio = new BIO(LoadString(Resources.CaCrt))) { using (X509Certificate cert = new X509Certificate(bio)) { TestCert(cert, "CN=Root", "CN=Root", 1234); } } }
public bool CheckValidationResult( ServicePoint srvPoint , X509Certificate certificate , WebRequest request , int certificateProblem) { //Return True to force the certificate to be accepted. return true; }
public TcpTransport(string host, int port, X509Certificate clientCertificate, bool loggingEnabled = false, int readTimeout = Timeout.Infinite, int writeTimeout = Timeout.Infinite) { EPP_REGISTRY_COM = host; PORT = port; READ_TIMEOUT = readTimeout; WRITE_TIMEOUT = writeTimeout; this.loggingEnabled = loggingEnabled; this.clientCertificate = clientCertificate; }
private static void VerifyImportNotSupported(X509Certificate c) { Assert.Throws<PlatformNotSupportedException>(() => c.Import(Array.Empty<byte>())); Assert.Throws<PlatformNotSupportedException>(() => c.Import(string.Empty)); Assert.Throws<PlatformNotSupportedException>(() => c.Import(Array.Empty<byte>(), string.Empty, X509KeyStorageFlags.DefaultKeySet)); Assert.Throws<PlatformNotSupportedException>(() => c.Import(Array.Empty<byte>(), new SecureString(), X509KeyStorageFlags.DefaultKeySet)); Assert.Throws<PlatformNotSupportedException>(() => c.Import(string.Empty, string.Empty, X509KeyStorageFlags.DefaultKeySet)); Assert.Throws<PlatformNotSupportedException>(() => c.Import(string.Empty, new SecureString(), X509KeyStorageFlags.DefaultKeySet)); }
static AsymmetricAlgorithm PrivateKeySelection (X509Certificate certificate, string targetHost) { Console.WriteLine ("PrivateKeySelection"); Console.WriteLine ("\tHost: {0}", targetHost); Console.WriteLine (certificate.ToString (true)); Console.WriteLine ("\tPrivateKeySelection ({0})", p12.Keys.Count); Console.WriteLine (); return (AsymmetricAlgorithm) p12.Keys [0]; }
static bool CertificateValidation (X509Certificate certificate, int[] certificateErrors) { Console.WriteLine ("CertificateValidation"); Console.WriteLine (certificate.ToString (true)); Console.WriteLine ("\tError(s)"); foreach (int error in certificateErrors) Console.WriteLine ("\t\t#{0}", error); Console.WriteLine (); return true; }
public static void X509CertEmptyToString() { using (var c = new X509Certificate()) { string expectedResult = "System.Security.Cryptography.X509Certificates.X509Certificate"; Assert.Equal(expectedResult, c.ToString()); Assert.Equal(expectedResult, c.ToString(false)); Assert.Equal(expectedResult, c.ToString(true)); } }
public void CanLoadFromPEM() { using(BIO bio = BIO.File(Paths.CaCrt, "r")) { using(X509Certificate cert = new X509Certificate(bio)) { TestCert(cert, "CN=Root", "CN=Root", 1234); } } }
public virtual IAsyncResult BeginAuthenticateAsServer(X509Certificate serverCertificate, AsyncCallback asyncCallback, object asyncState) { return(BeginAuthenticateAsServer(serverCertificate, false, SslProtocols.Tls, false, asyncCallback, asyncState)); }
public virtual void AuthenticateAsServer(X509Certificate serverCertificate) { AuthenticateAsServer(serverCertificate, false, SslProtocols.Tls, false); }
public virtual void AuthenticateAsServer(X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation) { EndAuthenticateAsServer(BeginAuthenticateAsServer( serverCertificate, clientCertificateRequired, enabledSslProtocols, checkCertificateRevocation, null, null)); }
//url为请求的网址,param参数为需要查询的条件(服务端接收的参数,没有则为null) //返回该次请求的响应 public static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) { //直接确认,否则打不开 return(true); }
public static bool IgnoreCertificateValidationFailureForTestingOnly(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); }
protected X509Certificate ContextLocalCertificateSelect(object sender, string targetHost, X509CertificateCollection localCertificates, X509Certificate remoteCertificate, string[] acceptableIssuers) { if (Tracer.IsDebugEnabled) { string subjects = "{"; string issuers = "{"; string acceptedIssuers = "{"; foreach (X509Certificate cert in localCertificates) { subjects += cert.Subject + ", "; issuers += cert.Issuer + ", "; } subjects += "}"; issuers += "}"; for (int i = 0; i < acceptableIssuers.Length; i++) { acceptedIssuers += acceptableIssuers[i] + ", "; } Tracer.DebugFormat("Local Certificate Selection.\n" + "Sender {0}, Target Host {1}, Remote Cert Subject {2}, Remote Cert Issuer {3}" + "\nlocal Cert Subjects {4}, " + "\nlocal Cert Issuers {5}", sender.ToString(), targetHost, remoteCertificate?.Subject, remoteCertificate?.Issuer, subjects, issuers); } X509Certificate localCertificate = null; if (ClientCertificateSelectCallback != null) { try { if (Tracer.IsDebugEnabled) { Tracer.DebugFormat("Calling application callback for Local certificate selection."); } localCertificate = ClientCertificateSelectCallback(sender, targetHost, localCertificates, remoteCertificate, acceptableIssuers); } catch (Exception ex) { Tracer.InfoFormat("Caught Exception from application callback for local certificate selction. Exception : {0}", ex); throw ex; } } else if (localCertificates.Count >= 1) { // when there is only one certificate select that certificate. localCertificate = localCertificates[0]; if (!String.IsNullOrWhiteSpace(this.ClientCertSubject)) { // should the application identify a specific certificate to use search for that certificate. localCertificate = null; foreach (X509Certificate cert in localCertificates) { if (String.Compare(cert.Subject, this.ClientCertSubject, true) == 0) { localCertificate = cert; break; } } } } if (localCertificate == null) { Tracer.InfoFormat("Could not select Local Certificate for target host {0}", targetHost); } else if (Tracer.IsDebugEnabled) { Tracer.DebugFormat("Selected Local Certificate {0}", localCertificate.ToString()); } return(localCertificate); }
private void TestCert(X509Certificate cert, string subject, string issuer, int serial) { Assert.AreEqual(subject, cert.Subject.ToString()); Assert.AreEqual(issuer, cert.Issuer.ToString()); Assert.AreEqual(serial, cert.SerialNumber); }
/* * AsymmetricAlgorithm GetPrivateKey (X509Certificate cert, string targetHost) * { * // FIXME: what can I do for non-X509Certificate2 ? * X509Certificate2 cert2 = cert as X509Certificate2; * return cert2 != null ? cert2.PrivateKey : null; * } */ X509Certificate OnCertificateSelection(X509CertificateCollection clientCerts, X509Certificate serverCert, string targetHost, X509CertificateCollection serverRequestedCerts) { string [] acceptableIssuers = new string [serverRequestedCerts != null ? serverRequestedCerts.Count : 0]; for (int i = 0; i < acceptableIssuers.Length; i++) { acceptableIssuers [i] = serverRequestedCerts [i].GetIssuerName(); } return(selection_callback(this, targetHost, clientCerts, serverCert, acceptableIssuers)); }
public static bool ValidateServerCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); }
public void UntrustedSelfSignedCertificate() { String host = "-----BEGIN CERTIFICATE-----\n" + "MIIEcDCCAligAwIBAgIEAP+quzANBgkqhkiG9w0BAQUFADA2MQswCQYDVQQGEwJE\n" + "RTELMAkGA1UECAwCQlcxDTALBgNVBAoMBFNZU1MxCzAJBgNVBAMMAkNBMB4XDTE0\n" + "MDQxMDA3Mzg0MFoXDTE1MDQxMDA3Mzg0MFowQTELMAkGA1UEBhMCREUxCzAJBgNV\n" + "BAgMAkJXMQ0wCwYDVQQKDARTWVNTMRYwFAYDVQQDDA13d3cuZ29vZ2xlLmNoMIIB\n" + "IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8P4nPfLKOXtl+uOOUF7YO+mH\n" + "ee9hYHuDLusgyDpLEQAqnBHtBi6RCP5XmArpunNfTF8yls5QdyjKogJ6nXafzlGa\n" + "If1fe6iI/OMp9oUBdqJh2mU9OfZm5he9sLobunrVWqlm5fIbSRZkhZe5o8Dutcsa\n" + "p74TClaHbXTcsVbw6/aScXibj5ARIK71JgtPFUNp1QanF78GmXUu2MOROaz2duUF\n" + "LxzJJCxnNElNkt663LUjtgfbcEgKQDZ0k0uNchAyDHDIkNr6FmilgBmt1LI0sjdH\n" + "llY6Z/r8waH9ztTqlf78jG1AhmUSTbBNtYU92rqdRqPa21WBbhaEhNtFg8EZywID\n" + "AQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVy\n" + "YXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQU48hgd+eZiIeWwiDJ3XPIb6PI+0gw\n" + "HwYDVR0jBBgwFoAUWc4WPc0maSLX2fTyx9YLvqqPs8YwDQYJKoZIhvcNAQEFBQAD\n" + "ggIBAA8T4LM8FKvRQh+/UWmKkMFFMVcSav2UYYHwbDQ1G+38lKT9G1pddslA450H\n" + "XkaOZnRIb31+bgIK/WRt16sowt/wxK34p0kphKS7ubszF6SQI/rUF7Z/44MBnyng\n" + "CsJhO+hu9vk7qTBSx7wL5MI9lsmalzwmQhEnNBKyYxxwBKRpZzlns6bX/nysfIPd\n" + "lJ28Q01VfuFI4LZn6XoCgP3a5KMbvkFCcoQ0BWaJZUJXj8Taunn52+4yd02CojXJ\n" + "6jnM8asmeZLME7k4BZrYGzmEZWqEWlArltpo315/lEdgPvmmIsSMn3N3wi8IJnlj\n" + "1LRzDy3HF2m8Kk/3HPYorUKItEFdZ2yBHJd8SvrsoahoyqLN3rPkQ6TXFg5GD6XF\n" + "76GUMSbr92sjKtWI4fta5CZi2iRnQEhiuAW9mvmsr9/g9fHAvNbs8QjLfYxdG8KW\n" + "oLQIuTllXuQRiWJ6X33ea4seNDpD53I7rhZNhDxkns7YdEy9IsJjHJganVBY+/3f\n" + "15bn34p3g3mQlsnLA2WMX2ZyLrVWaEt82iIZKAFzHjO38fANno6IXh0HP1xy6uQd\n" + "37SZV2h0nUlJYw483RIUcJghkEBkKnIJInb6wGKXSpEZE2ObDJV0cH9vJflygh+G\n" + "P6IvpzJ9dGNO8yNuyxvxcG7C+yDjgWjXkHqBYDS8lY9rM0yk\n" + "-----END CERTIFICATE-----\n"; String ca = "-----BEGIN CERTIFICATE-----\n" + "MIIFPzCCAyegAwIBAgIJAODkvo4frTJPMA0GCSqGSIb3DQEBBQUAMDYxCzAJBgNV\n" + "BAYTAkRFMQswCQYDVQQIDAJCVzENMAsGA1UECgwEU1lTUzELMAkGA1UEAwwCQ0Ew\n" + "HhcNMTQwNDEwMDczODI2WhcNMjQwNDA5MDczODI2WjA2MQswCQYDVQQGEwJERTEL\n" + "MAkGA1UECAwCQlcxDTALBgNVBAoMBFNZU1MxCzAJBgNVBAMMAkNBMIICIjANBgkq\n" + "hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxYEqG0gr2sxp1KJtj8VKmv802cdfXvIv\n" + "3M10eB4weWtbRim/g8NcZUzPac5R672JxdQTpGERVl4y+6fxjjc9NsxuXBBoMOam\n" + "ihINUsZzhxQatQ0Vos9WHX9rVdVQXLnVDrfn//thx8pLCzN777q8xDYwuyNeiUzG\n" + "KVtlQV7ltbMTCL0jLRWiKe/pX27qDx0j+VipgohVZc6UHTFgbsWIn/x9tcCYaGPU\n" + "IORUDYKLxURgUxikGipGxEaLa4zyOoniH9LqAVKZ0mXGV2OKYQqppb60zPm/N5Ke\n" + "9R2fjBYdY8QAkkRDe6ZfEy9/+8dJTheVIxfQ2IAh4CKmgRCutlhD99n9xtUzXfJU\n" + "X8E7+t2SKgdkC3uQvLWdABO5cLqw+JC8kn1alz9mQDuhjq/63iJ9kFa3mv6/GCPd\n" + "oyQ5Ey+vqKwyWP/2Y42HF5Kj8eCiLV71Jf7Njifnnn6N7DgjHeJJPfLCBxmxFuiO\n" + "aB4P9fLvoUpLkCIE3bYVCXiHKc6NrZ7Bx/5QVA8471KDH9YngFF7DpbnqwYVdRys\n" + "kqMEupb2kUf0W0ObjLHAAUFMcPUdY081QFrVi9m78B2wAbW3ynguzrFBK4lmj6L3\n" + "5rQipe5lEVFUbDnMYLONz55kLROGyw8H4EhgRuGCPwpiJtWYq3Tyc7smEy8Y9JcS\n" + "iuskbUOgTgECAwEAAaNQME4wHQYDVR0OBBYEFFnOFj3NJmki19n08sfWC76qj7PG\n" + "MB8GA1UdIwQYMBaAFFnOFj3NJmki19n08sfWC76qj7PGMAwGA1UdEwQFMAMBAf8w\n" + "DQYJKoZIhvcNAQEFBQADggIBAC+mnC3rSJnDkKhMuL88DG0tErvHEUwL+qrgoeNN\n" + "1rOdXxv2hsVFfRMG9ieVvyMd9aHVvSgbWf43o0NHCX347eFWRq7n6A9QFNvcx4lD\n" + "DFgt8eptIgRAChbRg4QV0+GdsKeBSlOL/Y03zXwxvrCEpKBrluBYz8NZ4LTDtO6Q\n" + "g//+q0lnd49Gk1+PENzKKLVk2OzyQFh70o7pkm16KlpmQLnhvtkQJQPsOBVizk7v\n" + "hKtdUnn/fJytniJ5F4dZykH5GV4owILTRpjiuqO0BEOAznjvFDiMnzKif/jxX6XR\n" + "PMyqlWTk9VS23i1ghcU223+oeDiSNj8lbla8lHFcI8ztsvY469206pfCrK51FanL\n" + "dB/G7zd9P3zQRinwfaG9/9eL4nDsvPMVqotFiyrHhJJOAeZNQtRDB+e8c+334coS\n" + "Y6GQpdmCPQeL1grxH5g5VypkITPgq+aPmgHv6jk5cHdFhHy25tOwpdrk1ppN3ln4\n" + "GG2QjTbVnOEH01+ySZpB4eMaqF2wME0LQYuZo4OYz5Dfu565ft3E81TWqsaOxXyQ\n" + "kLHLnzzlATLh7F30aUV254MJTLwf4TL2/p4DJklo9t47iS1ckYAwtFYwgbDIziGZ\n" + "hJYa6ulLyko8z7MPf8OSOipYKOW/gXfV1XxMYh+k5qwaKLK4BsoXuwiB/kMVJtTJ\n" + "ndIN\n" + "-----END CERTIFICATE-----\n"; CertificateFactory certFactory = CertificateFactory.getInstance("X.509"); InputStream his = new ByteArrayInputStream(Encoding.ASCII.GetBytes(host)); X509Certificate hostCert = (X509Certificate)certFactory.generateCertificate(his); InputStream cais = new ByteArrayInputStream(Encoding.ASCII.GetBytes(ca)); X509Certificate caCert = (X509Certificate)certFactory.generateCertificate(cais); const string hostName = "www.google.ch"; List certs = new ArrayList(); certs.add(hostCert); certs.add(caCert); try { //no exception registered yet new SystemCertificateStore().isTrusted(hostName, certs); Assert.Fail(); } catch (EntryPointNotFoundException exception) { Console.WriteLine("TEST"); } //register exception PreferencesFactory.get() .setProperty(hostName + ".certificate.accept", SystemCertificateStore.ConvertCertificate(hostCert).Thumbprint); Assert.IsTrue(new SystemCertificateStore().isTrusted(hostName, certs)); }
public bool CheckValidationResult(ServicePoint srvPoint, X509Certificate certificate, WebRequest request, int certificateProblem) { return(true); }
protected bool ContextServerCertificateValidation(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { if (Tracer.IsDebugEnabled) { string name = null; if (certificate is X509Certificate2) { X509Certificate2 cert = certificate as X509Certificate2; name = cert.SubjectName.Name; } Tracer.DebugFormat("Cert DN {0}; Cert Subject {1}; Cert Issuer {2}; SSLPolicyErrors [{3}]", name, certificate?.Subject ?? "null", certificate?.Issuer ?? "null", sslPolicyErrors.ToString()); try { X509VerificationFlags verFlags = chain.ChainPolicy.VerificationFlags; X509RevocationMode revMode = chain.ChainPolicy.RevocationMode; X509RevocationFlag revFlags = chain.ChainPolicy.RevocationFlag; StringBuilder sb = new StringBuilder(); sb.Append("ChainStatus={"); int size = sb.Length; foreach (X509ChainStatus status in chain.ChainStatus) { X509ChainStatusFlags csflags = status.Status; sb.AppendFormat("Info={0}; flags=0x{1:X}; flagNames=[{2}]", status.StatusInformation, csflags, csflags.ToString()); sb.Append(", "); } if (size != sb.Length) { sb.Remove(sb.Length - 2, 2); } sb.Append("}"); Tracer.DebugFormat("X.509 Cert Chain, Verification Flags {0:X} {1}, Revocation Mode {2}, Revocation Flags {3}, Status {4} ", verFlags, verFlags.ToString(), revMode.ToString(), revFlags.ToString(), sb.ToString()); } catch (Exception ex) { Tracer.ErrorFormat("Error displaying Remote Cert fields. Cause: {0}", ex); } } bool?valid = null; if (ServerCertificateValidateCallback != null) { try { if (Tracer.IsDebugEnabled) { Tracer.DebugFormat("Calling application callback for Remote Certificate Validation."); } valid = ServerCertificateValidateCallback(sender, certificate, chain, sslPolicyErrors); } catch (Exception ex) { Tracer.InfoFormat("Caught Exception from application callback for Remote Certificate Validation. Exception : {0}", ex); throw ex; } } else { if ((sslPolicyErrors & SslPolicyErrors.RemoteCertificateNameMismatch) == SslPolicyErrors.RemoteCertificateNameMismatch && !String.IsNullOrWhiteSpace(this.ServerName)) { if (certificate.Subject.IndexOf(string.Format("CN={0}", this.ServerName), StringComparison.InvariantCultureIgnoreCase) > -1) { sslPolicyErrors &= ~(SslPolicyErrors.RemoteCertificateNameMismatch); } } if (sslPolicyErrors == SslPolicyErrors.None) { valid = true; } else { Tracer.WarnFormat("SSL certificate {0} validation error : {1}", certificate.Subject, sslPolicyErrors.ToString()); valid = this.AcceptInvalidBrokerCert; } } return(valid ?? this.AcceptInvalidBrokerCert); }
private static bool CertValidator(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); }
static void Ssl(string host, bool machine, bool verbose) { if (verbose) { Console.WriteLine("Importing certificates from '{0}' into the {1} stores.", host, machine ? "machine" : "user"); } int n = 0; X509CertificateCollection coll = GetCertificatesFromSslSession(host); if (coll != null) { X509Store store = null; // start by the end (root) so we can stop adding them anytime afterward for (int i = coll.Count - 1; i >= 0; i--) { X509Certificate x509 = coll [i]; bool selfsign = false; bool failed = false; try { selfsign = x509.IsSelfSigned; } catch { // sadly it's hard to interpret old certificates with MD2 // without manually changing the machine.config file failed = true; } if (selfsign) { // this is a root store = GetStoreFromName(X509Stores.Names.TrustedRoot, machine); } else if (i == 0) { // server certificate isn't (generally) an intermediate CA store = GetStoreFromName(X509Stores.Names.OtherPeople, machine); } else { // all other certificates should be intermediate CA store = GetStoreFromName(X509Stores.Names.IntermediateCA, machine); } Console.WriteLine("{0}{1}X.509 Certificate v{2}", Environment.NewLine, selfsign ? "Self-signed " : String.Empty, x509.Version); Console.WriteLine(" Issued from: {0}", x509.IssuerName); Console.WriteLine(" Issued to: {0}", x509.SubjectName); Console.WriteLine(" Valid from: {0}", x509.ValidFrom); Console.WriteLine(" Valid until: {0}", x509.ValidUntil); if (!x509.IsCurrent) { Console.WriteLine(" *** WARNING: Certificate isn't current ***"); } if ((i > 0) && !selfsign) { X509Certificate signer = coll [i - 1]; bool signed = false; try { if (signer.RSA != null) { signed = x509.VerifySignature(signer.RSA); } else if (signer.DSA != null) { signed = x509.VerifySignature(signer.DSA); } else { Console.WriteLine(" *** WARNING: Couldn't not find who signed this certificate ***"); signed = true; // skip next warning } if (!signed) { Console.WriteLine(" *** WARNING: Certificate signature is INVALID ***"); } } catch { failed = true; } } if (failed) { Console.WriteLine(" *** ERROR: Couldn't decode certificate properly ***"); Console.WriteLine(" *** try 'man certmgr' for additional help or report to bugzilla.novell.com ***"); break; } if (store.Certificates.Contains(x509)) { Console.WriteLine("This certificate is already in the {0} store.", store.Name); } else { Console.Write("Import this certificate into the {0} store ?", store.Name); string answer = Console.ReadLine().ToUpper(); if ((answer == "YES") || (answer == "Y")) { store.Import(x509); n++; } else { if (verbose) { Console.WriteLine("Certificate not imported into store {0}.", store.Name); } break; } } } } Console.WriteLine(); if (n == 0) { Console.WriteLine("No certificate were added to the stores."); } else { Console.WriteLine("{0} certificate{1} added to the stores.", n, (n == 1) ? String.Empty : "s"); } }
public virtual Task AuthenticateAsServerAsync(X509Certificate serverCertificate) { return(Task.Factory.FromAsync(BeginAuthenticateAsServer, EndAuthenticateAsServer, serverCertificate, null)); }
private bool AcceptAllCertifications(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); }
private static X509Certificate LocalCertificateSelectionCallback(object sender, string targetHost, X509CertificateCollection localCertificates, X509Certificate remoteCertificate, string[] acceptableIssuers) { return(GetCertificate()); }
public static bool MyRemoteCertificateValidationCallback(System.Object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { bool isOk = true; // If there are errors in the certificate chain, // look at each error to determine the cause. if (sslPolicyErrors != SslPolicyErrors.None) { for (int i = 0; i < chain.ChainStatus.Length; i++) { if (chain.ChainStatus[i].Status == X509ChainStatusFlags.RevocationStatusUnknown) { continue; } chain.ChainPolicy.RevocationFlag = X509RevocationFlag.EntireChain; chain.ChainPolicy.RevocationMode = X509RevocationMode.Online; chain.ChainPolicy.UrlRetrievalTimeout = new TimeSpan(0, 1, 0); chain.ChainPolicy.VerificationFlags = X509VerificationFlags.AllFlags; bool chainIsValid = chain.Build((X509Certificate2)certificate); if (!chainIsValid) { isOk = false; break; } } } return isOk; }
public PackageDigitalSignature Countersign(X509Certificate certificate, IEnumerable <Uri> signatures) { throw new NotImplementedException(); }
static X509CertificateCollection LoadCertificates(string filename, string password, bool verbose) { X509Certificate x509 = null; X509CertificateCollection coll = new X509CertificateCollection(); switch (Path.GetExtension(filename).ToUpper()) { case ".P7B": case ".SPC": SoftwarePublisherCertificate spc = SoftwarePublisherCertificate.CreateFromFile(filename); coll.AddRange(spc.Certificates); spc = null; break; case ".CER": case ".CRT": using (FileStream fs = File.OpenRead(filename)) { byte[] data = new byte [fs.Length]; fs.Read(data, 0, data.Length); if (data [0] != 0x30) { // maybe it's ASCII PEM base64 encoded ? data = PEM("CERTIFICATE", data); } if (data != null) { x509 = new X509Certificate(data); } } if (x509 != null) { coll.Add(x509); } break; case ".P12": case ".PFX": PKCS12 p12 = password == null?PKCS12.LoadFromFile(filename) : PKCS12.LoadFromFile(filename, password); X509CertificateCollection tmp = new X509CertificateCollection(p12.Certificates); for (int i = 0; i != p12.Keys.Count; i++) { X509Certificate cert = p12.Certificates[i]; RSACryptoServiceProvider pk = p12.Keys[i] as RSACryptoServiceProvider; if (pk == null || pk.PublicOnly) { continue; } if (verbose) { Console.WriteLine("Found key for certificate: {0}", cert.SubjectName); } tmp[0].RSA = pk; } coll.AddRange(tmp); p12 = null; break; default: Console.WriteLine("Unknown file extension: {0}", Path.GetExtension(filename)); break; } return(coll); }
public PackageDigitalSignature Sign(IEnumerable <Uri> parts, X509Certificate certificate) { throw new NotImplementedException(); }
public PackageDigitalSignature Sign(IEnumerable <Uri> parts, X509Certificate certificate, IEnumerable <PackageRelationshipSelector> relationshipSelectors, string signatureId) { throw new NotImplementedException(); }
public void CanGetAndSetProperties() { var serial = 101; var subject = new X509Name("CN=localhost"); var issuer = new X509Name("CN=Root"); var start = DateTime.Now; var end = start + TimeSpan.FromMinutes(10); var key = new CryptoKey(new DSA(true)); var bits = key.Bits; X509Name saveIssuer = null; X509Name saveSubject = null; CryptoKey savePublicKey = null; CryptoKey savePrivateKey = null; using (var cert = new X509Certificate()) { cert.Subject = subject; cert.Issuer = issuer; cert.SerialNumber = serial; cert.NotBefore = start; cert.NotAfter = end; cert.PublicKey = key; cert.PrivateKey = key; Assert.AreEqual(subject, cert.Subject); Assert.AreEqual(issuer, cert.Issuer); Assert.AreEqual(serial, cert.SerialNumber); Assert.AreEqual(key, cert.PublicKey); Assert.AreEqual(key, cert.PrivateKey); // If the original key gets disposed before the internal private key, // make sure that memory is correctly managed key.Dispose(); // If the internal private key has already been disposed, this will blowup Assert.AreEqual(bits, cert.PublicKey.Bits); Assert.AreEqual(bits, cert.PrivateKey.Bits); // We compare short date/time strings here because the wrapper can't handle milliseconds Assert.AreEqual(start.ToShortDateString(), cert.NotBefore.ToShortDateString()); Assert.AreEqual(start.ToShortTimeString(), cert.NotBefore.ToShortTimeString()); saveSubject = cert.Subject; saveIssuer = cert.Issuer; savePublicKey = cert.PublicKey; savePrivateKey = cert.PrivateKey; } // make sure that a property torn-off from the cert is still valid using (subject) using (saveSubject) { Assert.AreEqual(subject, saveSubject); } using (issuer) using (saveIssuer) { Assert.AreEqual(issuer, saveIssuer); } using (savePublicKey) { Assert.AreEqual(bits, savePublicKey.Bits); } using (savePrivateKey) { Assert.AreEqual(bits, savePrivateKey.Bits); } }
private static bool AllwaysGoodCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors policyErrors) { return(true); }
private bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) { return(true); }
private static bool RemoteCertificateValidate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors error) { return(true); }
public SchannelCred(X509Certificate certificate, SchProtocols protocols) : this(CurrentVersion, certificate, SchannelCred.Flags.Zero, protocols) { }
private static bool TrustCertificate(object sender, X509Certificate x509Certificate, X509Chain x509Chain, SslPolicyErrors sslPolicyErrors) { return(true); }
private static bool Validator(object in_sender, X509Certificate in_certificate, X509Chain in_chain, SslPolicyErrors in_sslPolicyErrors) { return(true); }
/// <summary> /// Creates a new <see cref="HttpListener"/> instance with default factories. /// </summary> /// <param name="address">Address that the listener should accept connections on.</param> /// <param name="port">Port that listener should accept connections on.</param> /// <param name="certificate">Certificate to use</param> /// <returns>Created HTTP listener.</returns> public static HttpListener Create(IPAddress address, int port, X509Certificate certificate) { //RequestParserFactory requestFactory = new RequestParserFactory(); //HttpContextFactory factory = new HttpContextFactory(NullLogWriter.Instance, 16384, requestFactory); return(new SecureHttpListener(address, port, certificate)); }
public static void TestImportNotSupported_X509Certificate() { using (var c = new X509Certificate()) { VerifyImportNotSupported(c); } }
public static bool Validator( object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors policyErrors ) { // Just accept and move on... return true; }