SSL Certificate Chain Contains RSA Keys Less Than 2048 bits

Tenable plugin 73459 fires when a remote TLS service presents at least one X.509 certificate in the served chain whose RSA modulus is under 2048 bits. That usually means a 1024-bit leaf or intermediate certificate on legacy web admin planes, embedded devices, old Java stacks, or private PKI chains. The plugin is configuration-driven, not product-specific, so there is no affected software version range; the affected population is any endpoint currently serving a weak-RSA certificate chain.

Tenable's MEDIUM label is defensible for compliance and interoperability, but it overstates near-term exploitability for most enterprise patch queues. In the real world, an attacker still needs either a cheap-to-factor key size like 512/768, or a much harder 1024-bit factoring effort plus a man-in-the-middle position, DNS/BGP control, or some other traffic-redirection foothold before this turns into impact. For the common 1024-bit case, this is more often a trust failure and modernization issue than a Monday-morning breach driver.

Why this verdict

• Attacker position required: meaningful abuse usually needs unauthenticated remote reachability plus a second-stage MITM/interception foothold, which compounds downward pressure versus the vendor baseline.
• Population narrowing: many hits are on internal-only or low-value appliance interfaces, not Internet-facing crown-jewel apps, so reachable exposure is smaller than the raw scan count suggests.
• Exploit friction: 1024-bit RSA is policy-weak, not commodity-broken. The technical finding is real, but the path from detection to attacker payoff is expensive and unreliable for routine criminal activity.

Why not higher?

There is no direct RCE, privilege escalation, or one-packet compromise here. Even after identifying the weak chain, an attacker still has to solve a hard practical problem: derive or otherwise obtain the private key and then control traffic flow or client trust well enough to impersonate the service.

Why not lower?

This is still not noise. Weak RSA in live TLS chains creates compliance exposure, future compatibility breakage, and a real impersonation risk on high-value or interceptable paths, especially on public-facing admin planes and legacy private PKI.

1. Inventory every weak-RSA endpoint — Pull the full set of hosts matching plugin 73459, then tag each by exposure: Internet-facing, internal user-facing, and admin-only. For a LOW verdict there is no SLA, so treat this as backlog hygiene; still, do the inventory in the next routine PKI review so you know which exceptions are on exposed edge systems.
2. Prioritize edge and admin plane certificates — Rotate public web, VPN, IdP, load balancer, and management-interface certs before low-value internal services because those are the few places where a MITM path is plausible. For LOW, there is no mitigation SLA and no remediation SLA; fold this into the next scheduled certificate maintenance window rather than preempting zero-day work.
3. Reissue with strong defaults — Standardize issuance templates on RSA 2048/3072 or ECDSA P-256/P-384, and remove legacy CSR scripts that still generate 1024-bit keys. For a LOW finding, do this during normal renewal or platform refresh unless the affected endpoint is public-facing authentication infrastructure.
4. Harden interception paths — Because this finding only matters when traffic can be redirected or spoofed, keep DNS protections, NAC, Wi-Fi security, HSTS, and segmentation healthy. That reduces the already-limited attack path while you clean up the cert debt in ordinary maintenance cycles.

Run this from an auditor workstation or jump host that can reach the target TLS service over the network. Invoke it as ./check_weak_rsa_chain.sh example.org 443; no root is required, but openssl must be installed and outbound connectivity to the target host:port is needed.

#!/usr/bin/env bash
# check_weak_rsa_chain.sh
# Exit codes:
#   0 = PATCHED
#   1 = VULNERABLE
#   2 = UNKNOWN

set -u

HOST="${1:-}"
PORT="${2:-443}"
TIMEOUT_BIN="$(command -v timeout || true)"
OPENSSL_BIN="$(command -v openssl || true)"

if [[ -z "$HOST" ]]; then
  echo "Usage: $0 <host> [port]"
  echo "UNKNOWN"
  exit 2
fi

if [[ -z "$OPENSSL_BIN" ]]; then
  echo "openssl not found"
  echo "UNKNOWN"
  exit 2
fi

TMPDIR="$(mktemp -d 2>/dev/null || mktemp -d -t weakrsa)"
CHAIN_FILE="$TMPDIR/chain.pem"
trap 'rm -rf "$TMPDIR"' EXIT

CONNECT_CMD=("$OPENSSL_BIN" s_client -connect "${HOST}:${PORT}" -servername "$HOST" -showcerts -verify 10)

if [[ -n "$TIMEOUT_BIN" ]]; then
  OUTPUT="$($TIMEOUT_BIN 15 "${CONNECT_CMD[@]}" 2>/dev/null)"
  RC=$?
else
  OUTPUT="$(${CONNECT_CMD[@]} 2>/dev/null)"
  RC=$?
fi

if [[ $RC -ne 0 || -z "$OUTPUT" ]]; then
  echo "Failed to connect or no TLS chain returned from ${HOST}:${PORT}"
  echo "UNKNOWN"
  exit 2
fi

printf '%s
' "$OUTPUT" | awk '/-----BEGIN CERTIFICATE-----/,/-----END CERTIFICATE-----/' > "$CHAIN_FILE"

if [[ ! -s "$CHAIN_FILE" ]]; then
  echo "No certificates extracted from TLS handshake"
  echo "UNKNOWN"
  exit 2
fi

awk 'BEGIN{n=0} /-----BEGIN CERTIFICATE-----/{n++} {print > ("'$TMPDIR'" "/cert_" n ".pem")}' "$CHAIN_FILE"

FOUND=0
CERTS=0
DETAILS=()

for cert in "$TMPDIR"/cert_*.pem; do
  [[ -f "$cert" ]] || continue
  CERTS=$((CERTS+1))

  PUBINFO="$($OPENSSL_BIN x509 -in "$cert" -noout -text 2>/dev/null)"
  SUBJECT="$($OPENSSL_BIN x509 -in "$cert" -noout -subject 2>/dev/null | sed 's/^subject=//')"

  if echo "$PUBINFO" | grep -q "Public Key Algorithm: rsaEncryption"; then
    BITS="$(echo "$PUBINFO" | sed -n 's/.*Public-Key: (\([0-9][0-9]*\) bit).*/\1/p' | head -n1)"
    if [[ -n "$BITS" ]]; then
      DETAILS+=("RSA ${BITS} bits :: ${SUBJECT}")
      if (( BITS < 2048 )); then
        FOUND=1
      fi
    else
      DETAILS+=("RSA unknown bits :: ${SUBJECT}")
    fi
  else
    ALG="$(echo "$PUBINFO" | sed -n 's/.*Public Key Algorithm: \(.*\)$/\1/p' | head -n1 | xargs)"
    DETAILS+=("${ALG:-non-RSA} :: ${SUBJECT}")
  fi
done

if (( CERTS == 0 )); then
  echo "No parsed certificates found"
  echo "UNKNOWN"
  exit 2
fi

printf '%s
' "${DETAILS[@]}"

if (( FOUND == 1 )); then
  echo "VULNERABLE"
  exit 1
else
  echo "PATCHED"
  exit 0
fi

Sources

1. Tenable Nessus Plugin 73459
2. CA/Browser Forum Baseline Requirements
3. NIST SP 800-131A Rev. 2
4. Microsoft Security Advisory 2661254
5. Apple TLS certificate trust requirements
6. Mozilla: Phasing out Certificates with 1024-bit RSA Keys
7. Another look at secure communication of Internet devices