RSA Keys Below 2048 Bits: The Weak Link in an SSL Certificate Chain

A valid certificate can still be built on cryptography that is no longer considered strong enough.

Introduction

During a Network Vulnerability Assessment using Nessus, you may encounter a finding such as:

SSL Certificate Chain Contains RSA Keys Less Than 2048 bits

At first, this finding can be confusing.

The certificate may:

• Be trusted
• Have a valid expiry date
• Be issued by a legitimate Certificate Authority
• Use HTTPS successfully

So why does Nessus still report a vulnerability?

The answer is RSA key length.

A certificate chain can be perfectly valid from a trust perspective while still containing an RSA public key that is too small by modern security standards.

Let’s understand what this means, how it can be exploited, its impact, and how to fix it.

What is an SSL/TLS Certificate?

An SSL/TLS certificate is a digital identity used by a server during TLS communication.

For example:

Client
   │
   │ HTTPS Request
   ▼
Web Server
   │
   │ TLS Certificate
   ▼
Client verifies certificate

The certificate contains information such as:

• Subject / domain
• Issuer
• Validity period
• Public key
• Signature
• Cryptographic algorithms

The public key is particularly important for this vulnerability.

What is an RSA Key?

RSA is a public-key cryptographic algorithm commonly used in certificates and digital signatures.

RSA uses a pair of keys:

Public Key
    +
Private Key

The public key can be shared openly.

The private key must remain secret.

For example:

Certificate
     │
     └── RSA Public Key
             │
             ▼
       Used for authentication
       / cryptographic operations

The security of RSA depends heavily on the difficulty of mathematical problems involving very large numbers.

What Does “Less Than 2048 Bits” Mean?

RSA keys have a size measured in bits.

Examples:

512-bit RSA    ❌ Extremely weak
768-bit RSA    ❌ Weak
1024-bit RSA   ❌ Deprecated / insufficient
2048-bit RSA   ✅ Minimum commonly accepted baseline
3072-bit RSA   ✅ Stronger
4096-bit RSA   ✅ Stronger, with performance trade-offs

The key point is:

The larger the RSA key, the harder it is to perform the mathematical attacks needed to recover the private key.

A key below 2048 bits is considered insufficient for modern security requirements.

What is a Certificate Chain?

A certificate chain establishes trust between the server certificate and a trusted root Certificate Authority.

A simplified chain looks like:

Root CA
   │
   ▼
Intermediate CA
   │
   ▼
Server Certificate
   │
   ▼
example.com

Each certificate in the chain can contain its own public key.

For example:

Even though the server certificate itself uses a 2048-bit RSA key, an older certificate somewhere in the presented chain may use a smaller key.

That’s where this Nessus finding becomes relevant.

What Does the Nessus Finding Mean?

When Nessus reports:

SSL Certificate Chain Contains RSA Keys Less Than 2048 bits

it means that during certificate-chain inspection, it identified an RSA certificate key below the configured security threshold.

Conceptually:

Nessus
   │
   ▼
Connects to TLS Service
   │
   ▼
Retrieves Certificate Chain
   │
   ├── Server Certificate
   ├── Intermediate Certificate
   └── Other Chain Certificates
            │
            ▼
       Checks RSA Key Sizes
            │
            ▼
      RSA Key < 2048 bits
            │
            ▼
       Nessus Finding

This is a cryptographic configuration weakness, not proof that the server has already been compromised.

Why is a Small RSA Key Dangerous?

The fundamental problem is that smaller RSA keys provide a smaller security margin.

An attacker who obtains the relevant public key can attempt mathematical attacks against the RSA key.

The objective would ultimately be to recover the corresponding private key.

Conceptually:

RSA Public Key
      │
      ▼
Cryptanalysis / Factoring Attack
      │
      ▼
Private Key Recovery
      │
      ▼
Potential Cryptographic Compromise

The difficulty of this process depends heavily on the key size and cryptographic implementation.

A 2048-bit RSA key is substantially harder to attack than a 1024-bit RSA key.

Can an Attacker Immediately Break the Certificate?

No.

This is an important distinction for VAPT reporting.

Finding:

RSA key < 2048 bits

does not mean:

“The attacker can immediately decrypt HTTPS traffic.”

An attacker would need to perform a cryptographic attack against the weak RSA key, and the feasibility depends on the exact key size and circumstances.

Therefore, don’t exaggerate the impact.

A technically accurate statement would be:

The use of an RSA key smaller than 2048 bits reduces the cryptographic security margin and may expose the certificate chain to attacks that are more feasible against smaller RSA keys.

How Can It Be Exploited?

The exploitation depends on what the weak RSA key belongs to and how that key is used.

For example, consider an old 1024-bit RSA certificate.

An attacker obtains the public certificate:

Server
  │
  └── RSA Public Key
          │
          ▼
       Attacker

The attacker can attempt cryptanalysis against the public key.

Conceptually:

Public RSA Key
      │
      ▼
Mathematical Attack
      │
      ▼
Attempt to Recover Private Key
      │
      ▼
Private Key Compromise

If the private key were successfully recovered, the consequences could be serious depending on the certificate’s role and how it is used.

However, successful factoring of an RSA key is not a routine or instant operation, particularly for keys near the 2048-bit level.

Get EternalSec’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

This is why the finding should be described as a weak cryptographic configuration, rather than claiming guaranteed private-key recovery.

Why Does the Certificate Chain Matter?

This is the interesting part.

Imagine:

A developer might look only at the server certificate and say:

“Our certificate uses 2048-bit RSA, so we’re secure.”

But Nessus examines the certificate chain, not just the leaf certificate.

Therefore, an older intermediate certificate can still trigger the finding.

How to Verify It

You can inspect the certificate chain manually.

Using OpenSSL

openssl s_client -connect <TARGET>:443 -showcerts

This displays the certificates presented by the server.

You can then inspect individual certificates with:

openssl x509 -in certificate.pem -text -noout

Look for:

Public-Key: (1024 bit)

or:

Public-Key: (2048 bit)

For this finding, you’re looking for an RSA public key below the required threshold.

Using Nmap

You can also gather TLS certificate information using Nmap scripts:

nmap --script ssl-cert -p 443 <TARGET-IP>

For broader TLS configuration analysis:

nmap --script ssl-enum-ciphers -p 443 <TARGET-IP>

The second command is particularly useful when you want to determine whether the RSA key-length issue exists alongside other TLS weaknesses.

Example VAPT Scenario

Suppose Nessus reports:

SSL Certificate Chain Contains RSA Keys Less Than 2048 bits

You investigate the chain:

Now the vulnerability is clearly understood.

The issue isn’t necessarily the server certificate.

The issue is the 1024-bit RSA key in the certificate chain.

Impact

Technical Impact

Potential risks include:

• Reduced cryptographic security
• Increased feasibility of attacks against weak RSA keys
• Weakness in the certificate chain
• Potential private-key compromise if cryptanalysis succeeds
• Failure to meet modern cryptographic security requirements

Business Impact

Depending on where the weak certificate is used:

• Compliance violations
• Security policy violations
• Increased risk to encrypted services
• Potential loss of trust
• Increased exposure of sensitive communications if the cryptographic weakness is successfully exploited

The actual business impact depends on the affected certificate, service, key size, and usage.

Is This the Same as a Weak Cipher Suite?

No.

This is an important distinction.

Weak Cipher Suite

Deals with:

How TLS communication is encrypted

Example:

3DES
RC4
Weak CBC configurations

Weak RSA Key

Deals with:

The cryptographic key used by a certificate

Example:

RSA 1024-bit ❌
RSA 2048-bit ✅

So:

Weak Cipher Suite
        ≠
Weak RSA Certificate Key

They are different findings, although both can weaken TLS security.

Recommendation

The recommended remediation is to replace certificates containing RSA keys smaller than 2048 bits.

1. Identify the affected certificate

Determine whether the weak key belongs to:

• Server certificate
• Intermediate CA
• Other certificate in the presented chain

2. Replace weak RSA certificates

Use RSA keys of at least:

2048 bits

or consider stronger modern configurations where appropriate.

3. Replace outdated intermediate certificates

If the server certificate is already 2048-bit but an intermediate certificate is 1024-bit, obtain an appropriate replacement chain from the Certificate Authority.

4. Review the entire chain

Don’t only check:

Server Certificate

Check:

Server
   ↓
Intermediate
   ↓
Root / Trust Chain

5. Restart / reload the service

After replacing the certificate chain, reload the affected service so the new certificate configuration is actually presented.

6. Rescan

Finally:

Replace Weak Certificate
        ↓
Reload Service
        ↓
Verify Certificate Chain
        ↓
Nessus Rescan
        ↓
Finding Resolved