SSL Self-Signed Certificate

#!/usr/bin/env bash
# check_self_signed.sh
# Determine whether a remote TLS service presents an unrecognized self-signed chain.
# Output: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN, 3=usage/runtime error

set -u

HOST="${1:-}"
PORT="${2:-}"
SNI="${3:-${1:-}}"

if [[ -z "$HOST" || -z "$PORT" ]]; then
  echo "Usage: $0 <host> <port> [servername]"
  exit 3
fi

if ! command -v openssl >/dev/null 2>&1; then
  echo "UNKNOWN - openssl not found"
  exit 2
fi

# Find a likely CA bundle/path for verification.
CAFILE=""
CAPATH=""
for f in \
  /etc/ssl/certs/ca-certificates.crt \
  /etc/pki/tls/certs/ca-bundle.crt \
  /etc/ssl/ca-bundle.pem \
  /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem \
  /private/etc/ssl/cert.pem
  do
  if [[ -r "$f" ]]; then
    CAFILE="$f"
    break
  fi
done
if [[ -d /etc/ssl/certs ]]; then
  CAPATH="/etc/ssl/certs"
fi

TMPDIR="$(mktemp -d 2>/dev/null || mktemp -d -t selfsignedcheck)"
trap 'rm -rf "$TMPDIR"' EXIT
RAW="$TMPDIR/s_client.txt"
CHAIN="$TMPDIR/chain.pem"
LEAF="$TMPDIR/leaf.pem"
ROOTCAND="$TMPDIR/root_candidate.pem"

# Capture the presented chain. Timeout via openssl is not reliable everywhere; rely on shell redirection only.
if ! echo | openssl s_client -connect "${HOST}:${PORT}" -servername "$SNI" -showcerts 2>&1 > "$RAW"; then
  :
fi

# Some openssl builds send most output to stderr, so re-run and capture combined output.
( echo | openssl s_client -connect "${HOST}:${PORT}" -servername "$SNI" -showcerts ) > "$RAW" 2>&1

awk '
  /-----BEGIN CERTIFICATE-----/ {in_cert=1}
  in_cert {print}
  /-----END CERTIFICATE-----/ {in_cert=0; print "__CERT_END__"}
' "$RAW" | sed '/^__CERT_END__$/d' > "$CHAIN"

if ! grep -q 'BEGIN CERTIFICATE' "$CHAIN"; then
  echo "UNKNOWN - could not retrieve certificate chain from ${HOST}:${PORT}"
  exit 2
fi

awk '
  /-----BEGIN CERTIFICATE-----/ {cert++}
  cert==1 {print}
  /-----END CERTIFICATE-----/ && cert==1 {exit}
' "$CHAIN" > "$LEAF"

awk '
  /-----BEGIN CERTIFICATE-----/ {buf=$0 ORS; in_cert=1; next}
  in_cert {buf=buf $0 ORS}
  /-----END CERTIFICATE-----/ {last=buf; in_cert=0}
  END {printf "%s", last}
' "$CHAIN" > "$ROOTCAND"

leaf_subject="$(openssl x509 -in "$LEAF" -noout -subject 2>/dev/null | sed 's/^subject=//')"
leaf_issuer="$(openssl x509 -in "$LEAF" -noout -issuer 2>/dev/null | sed 's/^issuer=//')"
root_subject="$(openssl x509 -in "$ROOTCAND" -noout -subject 2>/dev/null | sed 's/^subject=//')"
root_issuer="$(openssl x509 -in "$ROOTCAND" -noout -issuer 2>/dev/null | sed 's/^issuer=//')"

# If the leaf is self-issued, this is almost certainly vulnerable unless locally trusted.
leaf_self_signed=0
if [[ -n "$leaf_subject" && "$leaf_subject" == "$leaf_issuer" ]]; then
  leaf_self_signed=1
fi

root_self_signed=0
if [[ -n "$root_subject" && "$root_subject" == "$root_issuer" ]]; then
  root_self_signed=1
fi

# Verify against local trust if we can.
verify_output=""
verify_rc=2
if [[ -n "$CAFILE" ]]; then
  if [[ -n "$CAPATH" ]]; then
    verify_output="$(openssl verify -CAfile "$CAFILE" -CApath "$CAPATH" "$LEAF" 2>&1)"
    verify_rc=$?
  else
    verify_output="$(openssl verify -CAfile "$CAFILE" "$LEAF" 2>&1)"
    verify_rc=$?
  fi
elif [[ -n "$CAPATH" ]]; then
  verify_output="$(openssl verify -CApath "$CAPATH" "$LEAF" 2>&1)"
  verify_rc=$?
fi

if [[ $verify_rc -eq 0 ]]; then
  echo "PATCHED - certificate validates to a locally trusted CA"
  exit 0
fi

# Parse common openssl failure text for self-signed conditions.
if echo "$verify_output" | grep -Eqi 'self[- ]signed certificate|self[- ]signed certificate in certificate chain'; then
  echo "VULNERABLE - untrusted self-signed certificate detected"
  exit 1
fi

if [[ $leaf_self_signed -eq 1 ]]; then
  echo "VULNERABLE - leaf certificate is self-signed and not locally trusted"
  exit 1
fi

if [[ $root_self_signed -eq 1 && $verify_rc -ne 0 ]]; then
  echo "VULNERABLE - chain terminates in a self-signed root that is not locally trusted"
  exit 1
fi

# Tenable notes plugin 57582 does not cover every unknown-CA case.
echo "UNKNOWN - certificate is untrusted, but not clearly self-signed from the presented chain"
exit 2