Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Google propose une mise à jour de Chrome pour atténuer la possibilité d'exploiter
La vulnérabilité cryptographique critique découverte par la NSA dans Windows

Le , par Stéphane le calme

22PARTAGES

9  0 
C'est durant son traditionnel Patch Tuesday que Microsoft a corrigé un bogue potentiellement dangereux qui permettrait à un attaquant d'usurper un certificat en faisant croire qu'il provient d'une source fiable. C'est la National Security Agency qui a signalé à Microsoft la vulnérabilité qui affecte Windows 10, Windows Server 2016, Windows Server 2019 et Windows Server version 1803, d’après un rapport de l’organisme gouvernemental.

« La NSA a découvert une vulnérabilité critique (CVE-2020-0601) affectant les fonctionnalités cryptographiques de Microsoft Windows. La vulnérabilité de validation de certificat permet à un attaquant de miner la façon dont Windows vérifie la confiance cryptographique et peut permettre l'exécution de code à distance. La vulnérabilité affecte Windows 10 et Windows Server 2016/2019 ainsi que les applications qui dépendent de Windows pour les fonctionnalités de confiance », lit-on dans le rapport du ministère de la Défense.

La faille affectait le chiffrement des signatures numériques utilisées pour authentifier le contenu, y compris les logiciels ou les fichiers. Si elle était exploitée, cette faille pourrait permettre aux criminels d'envoyer du contenu malveillant avec de fausses signatures qui le font paraître sûr.

Le spécialiste en cybersécurité Brian Krebs a rapporté que la vulnérabilité en question réside dans un composant Windows connu sous le nom de crypt32.dll, un module Windows qui, selon Microsoft, gère « les fonctions de certificat et de messagerie cryptographique dans le CryptoAPI ». Le CryptoAPI de Microsoft fournit des services qui permettent aux développeurs de sécuriser les applications Windows à l'aide de la cryptographie, et comprend des fonctionnalités de chiffrement et de déchiffrement des données à l'aide de certificats numériques.

Google entre dans la danse avec Chrome

Cette fois-ci, Google a publié une mise à jour de Chrome, Chrome 79.0.3945.130, qui détectera désormais les certificats qui tentent d'exploiter la vulnérabilité CryptoAPI Windows CVE-2020-0601 découverte par la NSA. Cette vulnérabilité permet aux attaquants de créer des certificats TLS et de signature de code qui usurpent l'identité d'autres entreprises pour effectuer des attaques de type man-in-the-middle ou créer des sites de phishing.

Étant donné que les PoC exploitant la vulnérabilité CVE-2020-0601 ont déjà été publiés, l'éditeur estime que ce n'est qu'une question de temps pour que les attaquants commencent à créer facilement des certificats usurpés.

Chrome 79.0.3945.130 vient donc vérifier davantage l'intégrité du certificat d'un site Web avant d'autoriser un visiteur à accéder au site. Le code de la double vérification de signature sur les chaînes vérifiées a été rajouté par Ryan Sleevi de Google.


Voici l'ancien code :

Code C++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    } 
  } 
  return false; 
} 
// Saves some information about the certificate chain |chain_context| in 
// |*verify_result|. The caller MUST initialize |*verify_result| before 
// calling this function. 
void GetCertChainInfo(PCCERT_CHAIN_CONTEXT chain_context, 
                      CertVerifyResult* verify_result) { 
  if (chain_context->cChain == 0) 
  
    return; 
  
  PCERT_SIMPLE_CHAIN first_chain = chain_context->rgpChain[0]; 
  DWORD num_elements = first_chain->cElement; 
  PCERT_CHAIN_ELEMENT* element = first_chain->rgpElement; 
  PCCERT_CONTEXT verified_cert = nullptr; 
  std::vector<PCCERT_CONTEXT> verified_chain; 
  
  bool has_root_ca = num_elements > 1 && 
      !(chain_context->TrustStatus.dwErrorStatus & 
          CERT_TRUST_IS_PARTIAL_CHAIN); 
  // Each chain starts with the end entity certificate (i = 0) and ends with 
  // either the root CA certificate or the last available intermediate. If a 
  // root CA certificate is present, do not inspect the signature algorithm of 
  // the root CA certificate because the signature on the trust anchor is not 
  // important. 
  if (has_root_ca) {

Et voici le nouveau

Code C++ : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
    } 
  } 
  return false; 
} 
// Saves some information about the certificate chain |chain_context| in 
// |*verify_result|. The caller MUST initialize |*verify_result| before 
// calling this function. 
void GetCertChainInfo(PCCERT_CHAIN_CONTEXT chain_context, 
                      CertVerifyResult* verify_result) { 
  if (chain_context->cChain == 0 || chain_context->rgpChain[0]->cElement == 0) { 
  
    verify_result->cert_status |= CERT_STATUS_INVALID; 
    return; 
  
  } 
  PCERT_SIMPLE_CHAIN first_chain = chain_context->rgpChain[0]; 
  DWORD num_elements = first_chain->cElement; 
  PCERT_CHAIN_ELEMENT* element = first_chain->rgpElement; 
  PCCERT_CONTEXT verified_cert = nullptr; 
  std::vector<PCCERT_CONTEXT> verified_chain; 
  
  // Recheck signatures in the event junk data was provided. 
  
  for (DWORD i = 0; i < num_elements - 1; ++i) { 
  
    PCCERT_CONTEXT issuer = element[i + 1]->pCertContext; 
  
  
    // If Issuer isn't ECC, skip this certificate. 
  
    if (strcmp(issuer->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 
  
               szOID_ECC_PUBLIC_KEY)) { 
  
      continue; 
  
    } 
  
  
    PCCERT_CONTEXT cert = element[i]->pCertContext; 
  
    if (!CryptVerifyCertificateSignatureEx( 
  
            NULL, X509_ASN_ENCODING, CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT, 
  
            const_cast<PCERT_CONTEXT>(cert), CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT, 
  
            const_cast<PCERT_CONTEXT>(issuer), 0, NULL)) { 
  
      verify_result->cert_status |= CERT_STATUS_INVALID; 
  
      break; 
  
    } 
  
  } 
  
  bool has_root_ca = num_elements > 1 && 
     !(chain_context->TrustStatus.dwErrorStatus & 
          CERT_TRUST_IS_PARTIAL_CHAIN); 
  // Each chain starts with the end entity certificate (i = 0) and ends with 
  // either the root CA certificate or the last available intermediate. If a 
  // root CA certificate is present, do not inspect the signature algorithm of 
  // the root CA certificate because the signature on the trust anchor is not 
  // important. 
  if (has_root_ca) {

Pour montrer les nouvelles protections à l'œuvre, en utilisant le site de test CVE-2020-0601 de Kudelski Security, nous pouvons voir la vulnérabilité exploitée sur un PC Windows 10 non patché utilisant une ancienne version de Google Chrome.


Sur la même machine Windows 10 non corrigée utilisant Google Chrome 79.0.3945.130, lorsque vous visitez à nouveau le site, le navigateur avertit désormais que les attaquants pourraient essayer de voler vos informations.


Sleevi a reconnu que cette mesure de contrôle n'est pas parfaite, mais qu'elle est suffisante pour le moment tandis que les utilisateurs déploient les mises à jour de sécurité de leurs systèmes d'exploitation et que Google passe à de meilleurs vérificateurs : « Ce n'est pas parfait, mais ce contrôle de sécurité est suffisant, le temps pour nous de passer à un autre vérificateur ou de renforcer le blocage des modules 3P, même pour CAPI ».

Sources : Google, Kudelski Security

Et vous ?

Sur quel système d'exploitation êtes-vous ?
Quel navigateur utilisez-vous ?
Allez-vous faire la mise à jour ?

Voir aussi :

Google prévoit de déprécier et bloquer la chaîne User-Agent sur Chrome pour la remplacer par une alternative, qui fournira moins d'informations aux serveurs
Google se donne deux ans pour éliminer de son navigateur Chrome les cookies tiers, en accord avec sa vision d'un Web « plus privé »
La version 80 de Google Chrome bloquera automatiquement les demandes de notifications ennuyeuses, fini les popups indésirables
L'extension Chrome Shitcoin Wallet, qui propose aux utilisateurs de gérer leur portefeuille Ethereum, surprise en train d'injecter du code JavaScript pour voler les mots de passe et clés privées

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de SQLpro
Rédacteur https://www.developpez.com
Le 17/01/2020 à 17:10
Microsoft l'a corrigé AVANT google !
A lire : https://securite.developpez.com/actu...osoft-Windows/
Datée du 15

La correction Google est datée du 17 !

Consternant de lire des bêtises pareilles… Vivement la Loi sur les "fake news" !

A +
2  0 
Avatar de Fleur en plastique
Membre averti https://www.developpez.com
Le 17/01/2020 à 12:41
Merci à Google de réparer les failles de Microsoft.

Il est temps que les vraies entreprises prennent le relai de celles qui codent avec les pieds.
1  5