ignora il certificato SSL non valido in .net core

Sto lavorando a un progetto che deve connettersi a un sito https. Ogni volta che mi connetto, il mio codice genera un'eccezione perché il certificato di quel sito proviene da un sito non attendibile. C'è un modo per aggirare il controllo dei certificati in .net core http?

Ho visto questo codice dalla versione precedente di .NET. Credo di aver solo bisogno di qualcosa del genere.

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

ServicePointManager.ServerCertificateValidationCallback non è supportato in .Net Core.

La situazione attuale è che sarà un nuovo metodo ServerCertificateCustomValidationCallback per il prossimo contratto 4.1. * System.Net.Http (HttpClient). Il team .NET Core sta finalizzando il contratto 4.1 ora. Puoi leggere questo argomento qui su GitHub

Puoi provare la versione pre-rilascio di System.Net.Http 4.1 utilizzando i sorgenti direttamente qui in CoreFx o sul feed MYGET: https://dotnet.myget.org/gallery/dotnet-core

Definizione WinHttpHandler.ServerCertificateCustomValidationCallback corrente su Github

Aggiornare:

Come accennato di seguito, non tutte le implementazioni supportano questa richiamata (ovvero piattaforme come iOS). In questo caso, come dicono i documenti , puoi impostare esplicitamente il validatore:

handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;

Funziona anche per .NET Core 2.2, 3.0 e 3.1

Vecchia risposta , con più controllo ma può lanciare PlatformNotSupportedException:

Puoi sovrascrivere il controllo del certificato SSL su una chiamata HTTP con la funzione di richiamata anonima come questa

using (var httpClientHandler = new HttpClientHandler())
{
   httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return true; };
   using (var client = new HttpClient(httpClientHandler))
   {
       // Make your request...
   }
}

Inoltre, suggerisco di utilizzare un pattern factory per HttpClientperché è un oggetto condiviso che potrebbe non essere eliminato immediatamente e quindi le connessioni rimarranno aperte .

Risolvo con questo:

Startup.cs

public void ConfigureServices(IServiceCollection services)
    {
        services.AddHttpClient("HttpClientWithSSLUntrusted").ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
        {
            ClientCertificateOptions = ClientCertificateOption.Manual,
            ServerCertificateCustomValidationCallback =
            (httpRequestMessage, cert, cetChain, policyErrors) =>
            {
                return true;
            }
        });

YourService.cs

public UserService(IHttpClientFactory clientFactory, IOptions<AppSettings> appSettings)
    {
        _appSettings = appSettings.Value;
        _clientFactory = clientFactory;
    }

var request = new HttpRequestMessage(...

var client = _clientFactory.CreateClient("HttpClientWithSSLUntrusted");

HttpResponseMessage response = await client.SendAsync(request);

Sono venuto qui alla ricerca di una risposta allo stesso problema, ma sto usando WCF per NET Core. Se sei sulla stessa barca, usa:

client.ClientCredentials.ServiceCertificate.SslCertificateAuthentication = 
    new X509ServiceCertificateAuthentication()
    {
        CertificateValidationMode = X509CertificateValidationMode.None,
        RevocationMode = X509RevocationMode.NoCheck
    };

In .NetCore, è possibile aggiungere il seguente frammento di codice al metodo di configurazione dei servizi, ho aggiunto un controllo per assicurarmi solo che il certificato SSL venga superato solo nell'ambiente di sviluppo

services.AddHttpClient("HttpClientName", client => {
// code to configure headers etc..
}).ConfigurePrimaryHttpMessageHandler(() => {
                  var handler = new HttpClientHandler();
                  if (hostingEnvironment.IsDevelopment())
                  {
                      handler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return true; };
                  }
                  return handler;
              });

Ho affrontato lo stesso problema lavorando con certificati autofirmati e autenticazione certificato client su .NET Core 2.2 e Docker Linux. Tutto ha funzionato bene sulla mia macchina Windows di sviluppo, ma in Docker ho ricevuto questo errore:

System.Security.Authentication.AuthenticationException: il certificato remoto non è valido in base alla procedura di convalida

Fortunatamente, il certificato è stato generato utilizzando una catena. Naturalmente, puoi sempre ignorare questa soluzione e utilizzare le soluzioni di cui sopra.

Quindi ecco la mia soluzione:

1. Ho salvato il certificato utilizzando Chrome sul mio computer in formato P7B .

2. Converti certificato in formato PEM utilizzando questo comando:
   openssl pkcs7 -inform DER -outform PEM -in <cert>.p7b -print_certs > ca_bundle.crt

3. Apri il file ca_bundle.crt ed elimina tutte le registrazioni del Soggetto, lasciando un file pulito. Esempio sotto:

    -----BEGIN CERTIFICATE-----
    _BASE64 DATA_
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    _BASE64 DATA_
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    _BASE64 DATA_
    -----END CERTIFICATE-----

4. Metti queste righe nel Dockerfile (nei passaggi finali):

    # Update system and install curl and ca-certificates
    RUN apt-get update && apt-get install -y curl && apt-get install -y ca-certificates
    # Copy your bundle file to the system trusted storage
    COPY ./ca_bundle.crt /usr/local/share/ca-certificates/ca_bundle.crt
    # During docker build, after this line you will get such output: 1 added, 0 removed; done.
    RUN update-ca-certificates

5. Nell'app:

    var address = new EndpointAddress("https://serviceUrl");                
    var binding = new BasicHttpsBinding
    {
        CloseTimeout = new TimeSpan(0, 1, 0),
        OpenTimeout = new TimeSpan(0, 1, 0),
        ReceiveTimeout = new TimeSpan(0, 1, 0),
        SendTimeout = new TimeSpan(0, 1, 0),
        MaxBufferPoolSize = 524288,
        MaxBufferSize = 65536,
        MaxReceivedMessageSize = 65536,
        TextEncoding = Encoding.UTF8,
        TransferMode = TransferMode.Buffered,
        UseDefaultWebProxy = true,
        AllowCookies = false,
        BypassProxyOnLocal = false,
        ReaderQuotas = XmlDictionaryReaderQuotas.Max,
        Security =
        {
            Mode = BasicHttpsSecurityMode.Transport,
            Transport = new HttpTransportSecurity
            {
                ClientCredentialType = HttpClientCredentialType.Certificate,
                ProxyCredentialType = HttpProxyCredentialType.None
            }
        }
    };
    var client = new MyWSClient(binding, address);
    client.ClientCredentials.ClientCertificate.Certificate = GetClientCertificate("clientCert.pfx", "passwordForClientCert");
    // Client certs must be installed
    client.ClientCredentials.ServiceCertificate.SslCertificateAuthentication = new X509ServiceCertificateAuthentication
    {
        CertificateValidationMode = X509CertificateValidationMode.ChainTrust,
        TrustedStoreLocation = StoreLocation.LocalMachine,
        RevocationMode = X509RevocationMode.NoCheck
    };

Metodo GetClientCertificate:

private static X509Certificate2 GetClientCertificate(string clientCertName, string password)
{
    //Create X509Certificate2 object from .pfx file
    byte[] rawData = null;
    using (var f = new FileStream(Path.Combine(AppContext.BaseDirectory, clientCertName), FileMode.Open, FileAccess.Read))
    {
        var size = (int)f.Length;
        var rawData = new byte[size];
        f.Read(rawData, 0, size);
        f.Close();
    }
    return new X509Certificate2(rawData, password);
}

In primo luogo, NON USARLO IN PRODUZIONE

Se stai usando il middleware AddHttpClient, questo sarà utile. Penso che sia necessario per lo sviluppo e non per la produzione. Fino a quando non crei un certificato valido puoi usare questo Func.

Func<HttpMessageHandler> configureHandler = () =>
        {
            var bypassCertValidation = Configuration.GetValue<bool>("BypassRemoteCertificateValidation");
            var handler = new HttpClientHandler();
            //!DO NOT DO IT IN PRODUCTION!! GO AND CREATE VALID CERTIFICATE!
            if (bypassCertValidation)
            {
                handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, x509Certificate2, x509Chain, sslPolicyErrors) =>
                {
                    return true;
                };
            }
            return handler;
        };

e applicalo come

services.AddHttpClient<IMyClient, MyClient>(x => { x.BaseAddress = new Uri("https://localhost:5005"); })
        .ConfigurePrimaryHttpMessageHandler(configureHandler);

Consentire tutti i certificati è molto potente ma potrebbe anche essere pericoloso. Se desideri consentire solo certificati validi più alcuni determinati certificati, potresti farlo in questo modo.

using (var httpClientHandler = new HttpClientHandler())
{
    httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, sslPolicyErrors) => {
        if (sslPolicyErrors == SslPolicyErrors.None)
        {
            return true;   //Is valid
        }

        if (cert.GetCertHashString() == "99E92D8447AEF30483B1D7527812C9B7B3A915A7")
        {
            return true;
        }
        return false;
    };
    using (var httpClient = new HttpClient(httpClientHandler))
    {
        var httpResponse = httpClient.GetAsync("https://example.com").Result;
    }
}

Fonte originale:

https://stackoverflow.com/a/44140506/3850405