Poodle Attack in Aspnet with Mutual Tls

The Poodle attack (CVE-2014-3566) exploits weaknesses in SSL 3.0, particularly the CBC padding oracle in block ciphers. In an ASP.NET application using Mutual TLS (mTLS), the presence of SSL 3.0 as a fallback or enabled protocol—even when client certificate authentication is enforced—can reintroduce the risk. mTLS ensures both client and server present certificates, but if the server or client-side stack still negotiates SSL 3.0, an attacker on the network can perform chosen-plaintext attacks to decrypt secure cookies or other sensitive data.

In ASP.NET, this risk surfaces when the application relies on legacy system defaults or insecure configuration on the server or on the client certificate validation path. Even with client certificates required, if the SslProtocols enumeration includes Ssl3, the protocol downgrade enables Poodle. For example, a server configured with SslProtocols.Tls | SslProtocols.Ssl3 remains vulnerable regardless of mTLS, because an attacker can force a renegotiation using SSL 3.0 and exploit the CBC padding mechanism to reveal plaintext session cookies.

Another vector involves insecure client certificate validation in ASP.NET. If the server does not properly validate the client certificate chain, an attacker could present a malicious certificate and still complete the handshake over SSL 3.0, bypassing intended access controls. This is a configuration issue: enabling mTLS is not sufficient if the protocol list allows SSL 3.0 or if certificate revocation checks are not enforced.

ASP.NET Core mitigates this by default when using modern templates, but legacy ASP.NET (Framework) applications may explicitly or implicitly enable SSL 3.0 via registry or code. Attackers probe for SSL 3.0 support during the TLS handshake, and if detected, they can launch Poodle to recover secure cookies or authentication tokens. Therefore, the combination of mTLS and SSL 3.0 availability turns a strong authentication mechanism into a channel for decryption when protocol configuration is not hardened.

Remediation focuses on disabling SSL 3.0, enforcing strong protocols, and ensuring proper client certificate validation. Below are concrete examples for ASP.NET Framework and ASP.NET Core.

ASP.NET Core (Program.cs / WebApplicationBuilder)

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ConfigureHttpsDefaults(httpsOptions =>
    {
        // Enforce TLS 1.2 or higher, explicitly exclude SSL 3.0
        httpsOptions.SslProtocols = System.Security.Authentication.SslProtocols.Tls12 | System.Security.Authentication.SslProtocols.Tls13;
        // Require client certificates for mTLS
        httpsOptions.ClientCertificateMode = ClientCertificateMode.RequireCertificate;
    });
});
// Optionally, validate client certificate in code for additional checks
builder.Services.AddAuthentication(CertificateAuthenticationDefaults.AuthenticationScheme)
    .AddCertificate(options =>
    {
        options.AllowedCertificateTypes = CertificateTypes.All;
        options.RevocationMode = X509RevocationMode.Online;
        options.ValidateCertificateUse = true;
    });
var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
app.Run();

ASP.NET Framework (Global.asax or Startup)

protected void Application_Start(object sender, EventArgs e)
{
    // Enforce TLS 1.2 and disable SSL 3.0
    System.ServiceModel.Security.TlsSecurityProtocolProvider.UseDefaultProtocols = false;
    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
    // Ensure client certificates are validated
    ServicePointManager.ServerCertificateValidationCallback +=
        (sender, certificate, chain, sslPolicyErrors) =>
        {
            // Implement strict validation: check chain, revocation, etc.
            if (sslPolicyErrors != SslPolicyErrors.None)
            {
                // Log and reject invalid certificates
                return false;
            }
            // Additional custom checks can be added here
            return true;
        };
}

These configurations ensure SSL 3.0 is not offered, mTLS is enforced with explicit certificate validation, and protocols are limited to those that do not support the CBC padding oracle exploited by Poodle. Always test the configuration using a scanner such as middleBrick to confirm SSL 3.0 is not detectable and that mTLS is correctly enforced.