What it means: The server certificate is signed by its own key, so no trusted CA vouches for it.
Free online tool — SSL certificate checker: instant results, no signup.
Runs a full TLS check: handshake, protocol versions, certificate chain, trust and expiry.
A self-signed certificate names itself as issuer and is signed with its own private key. Firefox first tries to build a chain to a trusted root; when no issuer exists and the certificate verifies as self-signed, it reports MOZILLA_PKIX_ERROR_SELF_SIGNED_CERT with the line "The certificate is not trusted because it is self-signed." A certificate signed by a private CA that you have not imported gives SEC_ERROR_UNKNOWN_ISSUER instead.
The connection is still encrypted, but nothing proves you reached the real server. Chromium's source puts it precisely: a self-signed certificate provides "no defense against active attackers (but foiling passive attackers)". This is a trust problem at the TLS layer, not DNS, not HTTP. The Chrome and Edge counterpart is NET::ERR_CERT_AUTHORITY_INVALID.
| Browser | What you see | Most common trigger |
|---|---|---|
| Firefox | "Warning: Potential Security Risk Ahead", MOZILLA_PKIX_ERROR_SELF_SIGNED_CERT | Router, NAS or appliance admin page; placeholder certificate on a web server |
| Chrome | "Your connection is not private", NET::ERR_CERT_AUTHORITY_INVALID | Same |
| Edge | "Your connection isn't private", same Chrome code | Same |
| Safari | "This Connection Is Not Private" | Same |
Where self-signed certificates come from: admin interfaces of routers, NAS boxes, printers and hypervisors; the Debian and Ubuntu placeholder pair /etc/ssl/certs/ssl-cert-snakeoil.pem used by Apache's default-ssl site; a certificate made with openssl req -x509 on a staging server that ended up in production; and a TLS terminator falling back to its built-in certificate after a failed upload.
Recent Chromium source also defines ERR_CERT_SELF_SIGNED_LOCAL_NETWORK for self-signed certificates on .local names and private (RFC 1918) IP addresses. On public hostnames Chrome reports ERR_CERT_AUTHORITY_INVALID.
A self-signed certificate on the origin is invisible to visitors while a CDN terminates TLS. Cloudflare's Full mode accepts it without validation; Full (strict) rejects it with error 526. The clean fix is a Cloudflare Origin CA certificate or a public certificate on the origin. Visitors see the self-signed certificate only when the record is DNS only or Cloudflare is paused.
The same applies to your own reverse proxy. nginx does not verify an HTTPS upstream unless told to, so a self-signed backend works but is unauthenticated. Verify it against your internal CA instead of switching checks off:
location / {
proxy_pass https://10.0.0.5:8443;
proxy_ssl_verify on;
proxy_ssl_trusted_certificate /etc/nginx/internal-ca.pem;
proxy_ssl_server_name on;
proxy_ssl_name app.internal;
}openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null \
| openssl x509 -noout -subject -issuer
# identical subject and issuer = self-signed; s_client also prints num=18:self-signed certificatesudo certbot --nginx -d example.com -d www.example.com, or point Apache's SSLCertificateFile and SSLCertificateKeyFile away from the snakeoil pair. Guide: free Let's Encrypt setup.mkcert -install # creates a local CA and trusts it
mkcert example.test localhost 127.0.0.1 ::1
# → ./example.test+3.pem and ./example.test+3-key.pemOn Linux, Firefox trust needs certutil (NSS tools) installed before mkcert -install. Never share the generated rootCA-key.pem.CA:TRUE, which openssl req -x509 adds by default in OpenSSL 3, Firefox then fails with MOZILLA_PKIX_ERROR_CA_CERT_USED_AS_END_ENTITY.On HSTS sites Firefox shows no exception button at all (HSTS errors). Clearing the cache does nothing, because certificates are not stored in the HTTP cache.
openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null | grep "Verify return code"
# → Verify return code: 0 (ok)
curl -sS -o /dev/null https://example.com/ && echo OK
# still self-signed: curl: (60) SSL certificate problem: self-signed certificateFor an outside view of the issuer and chain your server presents, run the enterno.io SSL checker.
SSL/TLS is the encryption protocol that protects data between the browser and server. Our tool analyzes the certificate, chain of trust, TLS version, and knownvulnerabilities.
Issuer, validity period, signature algorithm, covered domains (SAN), and validation type (DV/OV/EV).
Full chain verification: from leaf certificate through intermediates to root CA.
Protocol version (TLS 1.2/1.3), cipher suites, Perfect Forward Secrecy (PFS) support.
Set up a monitor — get Telegram and email alerts 30/14/7 days before expiration.
SSL certificate monitoring
TLS config audit
HTTPS as ranking factor
customer trust
www and subdomains.Strict-Transport-Security header forces browsers to always use HTTPS.SSL certificate monitoring, check history and alerts 30 days before expiry.
Sign up freeNo. Every visitor gets a full-page warning, and they cannot tell your certificate from an attacker's. Publicly trusted certificates from Let's Encrypt cost nothing and renew automatically.
Yes, if you are on your own network and the SHA-256 fingerprint matches the one the device reports. Firefox stores the exception, so you only do this once per certificate.
mkcert creates a local CA, adds it to the system and Firefox trust stores, and signs your certificates with it. A plain openssl self-signed certificate has no trusted issuer, so every browser on every machine warns.
If the certificate has the CA:TRUE basic constraint, Firefox treats it as a CA and refuses it as a server certificate, reporting MOZILLA_PKIX_ERROR_CA_CERT_USED_AS_END_ENTITY. Use a local CA that signs a separate server certificate instead.
Open Settings > Privacy & Security > Certificates > View Certificates > Servers and delete the entry. Clearing the cache does not remove it, because exceptions are stored separately from cached pages.
Free plan — 10 monitors, checks every 5 min, no card required. Upgrade for 1-minute interval and multi-region monitoring.