Désactiver le secours SSL et utiliser uniquement TLS pour les connexions sortantes dans .NET? (Atténuation des caniches)

J'essaie d'atténuer notre vulnérabilité à l' attaque de secours Poodle SSL 3.0 . Nos administrateurs ont déjà commencé à désactiver SSL au profit de TLS pour les connexions entrantes vers nos serveurs. Et nous avons également conseillé à notre équipe de désactiver SSL dans leurs navigateurs Web. Je regarde maintenant notre base de code .NET, qui initie des connexions HTTPS avec divers services via System.Net.HttpWebRequest . Je pense que ces connexions pourraient être vulnérables à une attaque MITM si elles permettent le retour de TLS vers SSL. Voici ce que j'ai déterminé jusqu'à présent. Quelqu'un pourrait-il vérifier cela pour vérifier que j'ai raison? Cette vulnérabilité est toute nouvelle, je n'ai donc pas encore vu de conseils de Microsoft sur la façon de l'atténuer dans .NET:

1. Les protocoles autorisés pour la classe System.Net.Security.SslStream, qui sous-tendent la communication sécurisée dans .NET, sont définis globalement pour chaque AppDomain via la propriété System.Net.ServicePointManager.SecurityProtocol .

2. La valeur par défaut de cette propriété dans .NET 4.5 est Ssl3 | Tls(bien que je ne trouve pas de documentation pour le sauvegarder.) SecurityProtocolType est une énumération avec l'attribut Flags, donc c'est un OU au niveau du bit de ces deux valeurs. Vous pouvez vérifier cela dans votre environnement avec cette ligne de code:

   Console.WriteLine (System.Net.ServicePointManager.SecurityProtocol.ToString ());

3. Cela devrait être remplacé par juste Tls, ou peut Tls12- être , avant de lancer des connexions dans votre application:

   System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls;

4. Important: Étant donné que la propriété prend en charge plusieurs indicateurs au niveau du bit, je suppose que SslStream ne se repliera pas automatiquement vers d'autres protocoles non spécifiés pendant la négociation. Sinon, quel serait l'intérêt de supporter plusieurs drapeaux?

Mise à jour sur TLS 1.0 vs 1.1 / 1.2:

Selon l'expert en sécurité de Google, Adam Langley, TLS 1.0 s'est avéré plus tard vulnérable à POODLE s'il n'était pas implémenté correctement , vous devriez donc envisager de passer exclusivement à TLS 1.2.

Mise à jour pour .NET Framework 4.7 et supérieur:

Comme évoqué par le professeur Von Lemongargle ci-dessous, à partir de la version 4.7 du .NET Framework, il n'est pas nécessaire d'utiliser ce hack car le paramètre par défaut permettra au système d'exploitation de choisir la version de protocole TLS la plus sécurisée. Consultez les bonnes pratiques TLS (Transport Layer Security) avec le .NET Framework pour plus d'informations.

Nous faisons la même chose. Pour prendre en charge uniquement TLS 1.2 et aucun protocole SSL, vous pouvez le faire:

System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

SecurityProtocolType.Tls est uniquement TLS 1.0, pas toutes les versions TLS.

En complément: si vous voulez vérifier que votre site n'autorise pas les connexions SSL, vous pouvez le faire ici (je ne pense pas que cela sera affecté par le paramètre ci-dessus, nous avons dû modifier le registre pour forcer IIS à utiliser TLS pour les connexions entrantes): https://www.ssllabs.com/ssltest/index.html

Pour désactiver SSL 2.0 et 3.0 dans IIS, consultez cette page: https://www.sslshopper.com/article-how-to-disable-ssl-2.0-in-iis-7.html

La réponse de @Eddie Loeffen semble être la réponse la plus populaire à cette question, mais elle a de mauvais effets à long terme. Si vous consultez la page de documentation de System.Net.ServicePointManager.SecurityProtocol ici, la section des remarques implique que la phase de négociation devrait simplement résoudre ce problème (et forcer le protocole est une mauvaise pratique car à l'avenir, TLS 1.2 sera également compromis). Cependant, nous ne chercherions pas cette réponse si c'était le cas.

En recherchant, il semble que le protocole de négociation ALPN est nécessaire pour atteindre TLS1.2 dans la phase de négociation. Nous avons pris cela comme point de départ et avons essayé des versions plus récentes du framework .Net pour voir où commence le support. Nous avons constaté que .Net 4.5.2 ne prend pas en charge la négociation vers TLS 1.2, contrairement à .Net 4.6.

Donc, même si forcer TLS1.2 fera le travail maintenant, je vous recommande de mettre à niveau vers .Net 4.6 à la place. Puisqu'il s'agit d'un problème PCI DSS pour juin 2016, la fenêtre est courte, mais le nouveau cadre est une meilleure réponse.

MISE À JOUR: En travaillant à partir des commentaires, j'ai construit ceci:

ServicePointManager.SecurityProtocol = 0;    
foreach (SecurityProtocolType protocol in SecurityProtocolType.GetValues(typeof(SecurityProtocolType)))
    {
        switch (protocol)
        {
            case SecurityProtocolType.Ssl3:
            case SecurityProtocolType.Tls:
            case SecurityProtocolType.Tls11:
                break;
            default:
                ServicePointManager.SecurityProtocol |= protocol;
            break;
        }
    }

Afin de valider le concept, j'ai associé SSL3 et TLS1.2 et exécuté le code ciblant un serveur qui ne prend en charge que TLS 1.0 et TLS 1.2 (1.1 est désactivé). Avec les protocoles or'd, il semble bien se connecter. Si je passe à SSL3 et TLS 1.1, cela n'a pas pu se connecter. Ma validation utilise HttpWebRequest de System.Net et appelle simplement GetResponse (). Par exemple, j'ai essayé ceci et j'ai échoué:

        HttpWebRequest request = WebRequest.Create("https://www.contoso.com/my/web/resource") as HttpWebRequest;
        ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls11;
        request.GetResponse();

pendant que cela fonctionnait:

        HttpWebRequest request = WebRequest.Create("https://www.contoso.com/my/web/resource") as HttpWebRequest;
        ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls12;
        request.GetResponse();

Cela présente un avantage par rapport au forçage de TLS 1.2 en ce que, si le framework .Net est mis à niveau afin qu'il y ait plus d'entrées dans Enum, elles seront prises en charge par le code tel quel. Il a un inconvénient par rapport à l'utilisation de .Net 4.6 en ce que 4.6 utilise ALPN et devrait prendre en charge de nouveaux protocoles si aucune restriction n'est spécifiée.

Edit 29/04/2019 - Microsoft a publié cet article en octobre dernier. Il a un assez bon résumé de leur recommandation sur la façon dont cela devrait être fait dans les différentes versions du framework .net.

@watson

Sur les formulaires Windows, il est disponible, en haut de la classe mis

  static void Main(string[] args)
    {
        ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
       //other stuff here
    }

puisque Windows est à thread unique, c'est tout ce dont vous avez besoin, dans le cas où il s'agit d'un service, vous devez le placer juste au-dessus de l'appel au service (car il est impossible de dire sur quel thread vous serez).

using System.Security.Principal 

est également nécessaire.

Si vous êtes curieux de savoir quels protocoles .NET prend en charge, vous pouvez essayer HttpClient sur https://www.howsmyssl.com/

// set proxy if you need to
// WebRequest.DefaultWebProxy = new WebProxy("http://localhost:3128");

File.WriteAllText("howsmyssl-httpclient.html", new HttpClient().GetStringAsync("https://www.howsmyssl.com").Result);

// alternative using WebClient for older framework versions
// new WebClient().DownloadFile("https://www.howsmyssl.com/", "howsmyssl-webclient.html");

Le résultat est accablant:

Votre client utilise TLS 1.0, qui est très ancien, peut-être sensible à l'attaque BEAST, et ne dispose pas des meilleures suites de chiffrement disponibles. Les ajouts tels que AES-GCM et SHA256 pour remplacer MD5-SHA-1 ne sont pas disponibles pour un client TLS 1.0 ainsi que pour de nombreuses suites de chiffrement plus modernes.

Comme Eddie l'explique ci-dessus, vous pouvez activer manuellement de meilleurs protocoles:

System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11; 

Je ne sais pas pourquoi il utilise de mauvais protocoles prêts à l'emploi. Cela semble un mauvais choix de configuration, ce qui équivaut à un bogue de sécurité majeur (je parie que beaucoup d'applications ne changent pas la valeur par défaut). Comment pouvons-nous le signaler?

J'ai dû lancer l'équivalent entier pour contourner le fait que j'utilise toujours .NET 4.0

System.Net.ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
/* Note the property type  
   [System.Flags]
   public enum SecurityProtocolType
   {
     Ssl3 = 48,
     Tls = 192,
     Tls11 = 768,
     Tls12 = 3072,
   } 
*/

J'ai trouvé que la solution la plus simple consiste à ajouter deux entrées de registre comme suit (exécutez ceci dans une invite de commande avec des privilèges d'administrateur):

reg add HKLM\SOFTWARE\Microsoft\.NETFramework\v4.0.30319 /v SchUseStrongCrypto /t REG_DWORD /d 1 /reg:32

reg add HKLM\SOFTWARE\Microsoft\.NETFramework\v4.0.30319 /v SchUseStrongCrypto /t REG_DWORD /d 1 /reg:64

Ces entrées semblent affecter la façon dont le .NET CLR choisit un protocole lors de l'établissement d'une connexion sécurisée en tant que client.

Il y a plus d'informations sur cette entrée de registre ici:

https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2015/2960358#suggested-actions

Non seulement c'est plus simple, mais en supposant que cela fonctionne pour votre cas, beaucoup plus robuste qu'une solution basée sur du code, qui oblige les développeurs à suivre le protocole et le développement et à mettre à jour tout leur code pertinent. Espérons que des modifications d'environnement similaires peuvent être apportées pour TLS 1.3 et au-delà, tant que .NET reste suffisamment stupide pour ne pas choisir automatiquement le protocole le plus élevé disponible.

REMARQUE : même si, selon l'article ci-dessus, cela est uniquement censé désactiver RC4, et on ne penserait pas que cela changerait si le client .NET est autorisé à utiliser TLS1.2 + ou non, pour une raison quelconque, il l'a effet.

REMARQUE : Comme indiqué par @Jordan Rieger dans les commentaires, ce n'est pas une solution pour POODLE, car il ne désactive pas les anciens protocoles a - il permet simplement au client de travailler avec des protocoles plus récents, par exemple lorsqu'un serveur patché a désactivé l'ancien protocoles. Cependant, avec une attaque MITM, il est évident qu'un serveur compromis offrira au client un protocole plus ancien, que le client utilisera alors avec plaisir.

TODO : Essayez de désactiver l'utilisation côté client de TLS1.0 et TLS1.1 avec ces entrées de registre, mais je ne sais pas si les bibliothèques clientes .NET http respectent ces paramètres ou non:

https://docs.microsoft.com/en-us/windows-server/security/tls/tls-registry-settings#tls-10

https://docs.microsoft.com/en-us/windows-server/security/tls/tls-registry-settings#tls-11