So ignorieren Sie die Zertifikatsprüfung bei ssl

Ich versuche einen Weg zu finden, die Zertifikatsprüfung zu ignorieren, wenn eine HTTP-Ressource angefordert wird. Bisher habe ich einen hilfreichen Artikel im Internet gefunden.

Aber ich habe immer noch ein Problem. Bitte überprüfen Sie meinen Code. Ich verstehe einfach nicht, was der Code ServicePointManager.ServerCertificateValidationCallbackbedeutet.

Wann wird diese Delegatmethode aufgerufen? Und noch eine Frage, an welcher Stelle soll ich diesen Code schreiben? Vor ServicePointManager.ServerCertificateValidationCallbackoder vor der Ausführung Stream stream = request.GetRequestStream()?

public HttpWebRequest GetRequest()
{
    CookieContainer cookieContainer = new CookieContainer();

    // Create a request to the server
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_remoteUrl);

    #region Set request parameters

    request.Method = _context.Request.HttpMethod;
    request.UserAgent = _context.Request.UserAgent;
    request.KeepAlive = true;
    request.CookieContainer = cookieContainer;
    request.PreAuthenticate = true;
    request.AllowAutoRedirect = false;

    #endregion

    // For POST, write the post data extracted from the incoming request
    if (request.Method == "POST")
    {
        Stream clientStream = _context.Request.InputStream;
        request.ContentType = _context.Request.ContentType;
        request.ContentLength = clientStream.Length;

        ServicePointManager.ServerCertificateValidationCallback = delegate(
            Object obj, X509Certificate certificate, X509Chain chain, 
            SslPolicyErrors errors)
            {
                return (true);
            };

            Stream stream = request.GetRequestStream();

            ....
        }

        ....

        return request;
    }
}   

Da es nur einen globalen ServicePointManager gibt , führt das Festlegen von ServicePointManager.ServerCertificateValidationCallback dazu, dass alle nachfolgenden Anforderungen diese Richtlinie erben. Da es sich um eine globale "Einstellung" handelt, ist es vorzuziehen , sie in der Application_Start- Methode in Global.asax festzulegen .

Durch Festlegen des Rückrufs wird das Standardverhalten überschrieben, und Sie können selbst eine benutzerdefinierte Validierungsroutine erstellen.

Für alle, die diese Lösung auf Anfrage anwenden möchten, ist dies eine Option und verwendet einen Lambda-Ausdruck. Der gleiche Lambda-Ausdruck kann auch auf den von blak3r erwähnten globalen Filter angewendet werden. Diese Methode scheint .NET 4.5 zu erfordern.

String url = "https://www.stackoverflow.com";
HttpWebRequest request = HttpWebRequest.CreateHttp(url);
request.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;

In .NET 4.0 kann der Lambda-Ausdruck als solcher auf den globalen Filter angewendet werden

ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;

Das hat bei mir funktioniert:

System.Net.ServicePointManager.ServerCertificateValidationCallback +=
delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate,
                        System.Security.Cryptography.X509Certificates.X509Chain chain,
                        System.Net.Security.SslPolicyErrors sslPolicyErrors)
    {
        return true; // **** Always accept
    };

Ausschnitt von hier: http://www.west-wind.com/weblog/posts/2011/Feb/11/HttpWebRequest-and-Ignoring-SSL-Certificate-Errors

Es gibt auch die kurze Delegatenlösung:

ServicePointManager.ServerCertificateValidationCallback = delegate { return true; }; 

Es wurde erwähnt, dass vor .NET 4.5 die Eigenschaft für die Anforderung des Zugriffs ServicePointManagernicht verfügbar war.

Hier ist der .NET 4.0-Code, mit dem Sie ServicePointpro Anfrage auf den zugreifen können . Sie erhalten keinen Zugriff auf den Rückruf pro Anforderung, sollten jedoch weitere Informationen zum Problem erhalten. Greifen Sie einfach auf die Eigenschaften zu scvPoint.Certificate(oder ClientCertificatewenn Sie dies bevorzugen).

WebRequest request = WebRequest.Create(uri);

// oddity: these two .Address values are not necessarily the same!
//  The service point appears to be related to the .Host, not the Uri itself.
//  So, check the .Host vlaues before fussing in the debugger.
//
ServicePoint svcPoint = ServicePointManager.FindServicePoint(uri);
if (null != svcPoint)
{
    if (!request.RequestUri.Host.Equals(svcPoint.Address.Host, StringComparison.OrdinalIgnoreCase))
    {
        Debug.WriteLine(".Address              == " + request.RequestUri.ToString());
        Debug.WriteLine(".ServicePoint.Address == " + svcPoint.Address.ToString());
    }
    Debug.WriteLine(".IssuerName           == " + svcPoint.Certificate.GetIssuerName());
}

Nur im Übrigen ist dies die am wenigsten ausführliche Methode, um alle Zertifikatsüberprüfungen in einer bestimmten App zu deaktivieren, von denen ich weiß:

ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => true;

Anstatt ServicePointManager einen Rückruf hinzuzufügen, der die Zertifikatsüberprüfung global überschreibt, können Sie den Rückruf für eine lokale Instanz von HttpClient festlegen. Dieser Ansatz sollte nur Aufrufe betreffen, die mit dieser Instanz von HttpClient getätigt wurden.

Hier ist ein Beispielcode, der zeigt, wie das Ignorieren von Zertifikatüberprüfungsfehlern für bestimmte Server in einem Web-API-Controller implementiert werden kann.

using System.Net.Http;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

public class MyController : ApiController
{

    // use this HttpClient instance when making calls that need cert errors suppressed
    private static readonly HttpClient httpClient;

    static MyController()
    {
        // create a separate handler for use in this controller
        var handler = new HttpClientHandler();

        // add a custom certificate validation callback to the handler
        handler.ServerCertificateCustomValidationCallback = ((sender, cert, chain, errors) => ValidateCert(sender, cert, chain, errors));

        // create an HttpClient that will use the handler
        httpClient = new HttpClient(handler);
    }

    protected static ValidateCert(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors errors)
    {

        // set a list of servers for which cert validation errors will be ignored
        var overrideCerts = new string[]
        {
            "myproblemserver",
            "someotherserver",
            "localhost"
        };

        // if the server is in the override list, then ignore any validation errors
        var serverName = cert.Subject.ToLower();
        if (overrideCerts.Any(overrideName => serverName.Contains(overrideName))) return true;

        // otherwise use the standard validation results
        return errors == SslPolicyErrors.None;
    }

}

Basierend auf Adams Antwort und Robs Kommentar habe ich Folgendes verwendet:

ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => certificate.Issuer == "CN=localhost";

was das "Ignorieren" etwas filtert. Natürlich können bei Bedarf weitere Emittenten hinzugefügt werden. Dies wurde in .NET 2.0 getestet, da wir älteren Code unterstützen müssen.

CA5386: Tools zur Analyse von Sicherheitslücken machen Sie auf diese Codes aufmerksam.

Richtiger Code:

ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) =>
{
   return (sslPolicyErrors & SslPolicyErrors.RemoteCertificateNotAvailable) != SslPolicyErrors.RemoteCertificateNotAvailable;
};

Für .net Kern

using (var handler = new HttpClientHandler())
{ 
    // allow the bad certificate
    handler.ServerCertificateCustomValidationCallback = (request, cert, chain, errors) => true;
    using (var httpClient = new HttpClient(handler))
    {
        await httpClient.PostAsync("the_url", null);
    }
}

Ausdrücklich ausgedrückt ...

ServicePointManager.ServerCertificateValidationCallback += new System.Net.Security.RemoteCertificateValidationCallback(CertCheck);

private static bool CertCheck(object sender, X509Certificate cert,
X509Chain chain, System.Net.Security.SslPolicyErrors error)
{
    return true;
}

Zusätzlich zu den Antworten von Sani und blak3r habe ich dem Startcode für meine Anwendung Folgendes hinzugefügt, jedoch in VB:

'** Overriding the certificate validation check.
Net.ServicePointManager.ServerCertificateValidationCallback = Function(sender, certificate, chain, sslPolicyErrors) True

Scheint den Trick zu machen.

Tipp: Mit dieser Methode können Sie auch Zertifikate verfolgen, die bald ablaufen. Dies kann Ihren Speck retten, wenn Sie ein Zertifikat entdecken, das bald abläuft, und es rechtzeitig reparieren lassen. Gut auch für Drittunternehmen - für uns ist dies DHL / FedEx. DHL hat gerade ein Zertifikat ablaufen lassen, das uns 3 Tage vor Thanksgiving vermasselt. Zum Glück bin ich da, um das Problem zu beheben ... diesmal!

    private static DateTime? _nextCertWarning;
    private static bool ValidateRemoteCertificate(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors error)
    {
        if (error == SslPolicyErrors.None)
        {
            var cert2 = cert as X509Certificate2;
            if (cert2 != null)
            { 
                // If cert expires within 2 days send an alert every 2 hours
                if (cert2.NotAfter.AddDays(-2) < DateTime.Now)
                {
                    if (_nextCertWarning == null || _nextCertWarning < DateTime.Now)
                    {
                        _nextCertWarning = DateTime.Now.AddHours(2);

                        ProwlUtil.StepReached("CERT EXPIRING WITHIN 2 DAYS " + cert, cert.GetCertHashString());   // this is my own function
                    }
                }
            }

            return true;
        }
        else
        {
            switch (cert.GetCertHashString())
            {
                // Machine certs - SELF SIGNED
                case "066CF9CAD814DE2097D367F22D3A7E398B87C4D6":    

                    return true;

                default:
                    ProwlUtil.StepReached("UNTRUSTED CERT " + cert, cert.GetCertHashString());
                    return false;
            }
        }
    }

Mehrere Antworten oben funktionieren. Ich wollte einen Ansatz, bei dem ich nicht ständig Codeänderungen vornehmen musste und meinen Code nicht unsicher machte. Daher habe ich eine Whitelist erstellt. Die Whitelist kann in jedem Datenspeicher verwaltet werden. Ich habe die Konfigurationsdatei verwendet, da es sich um eine sehr kleine Liste handelt.

Mein Code ist unten.

ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, error) => {
    return error == System.Net.Security.SslPolicyErrors.None || certificateWhitelist.Contains(cert.GetCertHashString());
};

Unity C # -Version dieser Lösung:

void Awake()
{
    System.Net.ServicePointManager.ServerCertificateValidationCallback += ValidateCertification;
}

void OnDestroy()
{
    ServerCertificateValidationCallback = null;
}

public static bool ValidateCertification(object sender, X509Certificate certificate, X509Chain chain, System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
    return true;
}