self-signed certificate in certificate chain: die Root-CA ist dem Client unbekannt

Welche Fehlermeldung zeigt eine unbekannte Root-CA?

Ein Dienst mit dem Zertifikat einer internen oder privaten CA ist erreichbar, aber ein Client bricht die Prüfung ab. Der Wortlaut hängt davon ab, ob der Server die Root mitsendet.

Sendet der Server die Root mit?

openssl s_client:  Verify return code: 19 (self-signed certificate in certificate chain)
Node:              SELF_SIGNED_CERT_IN_CHAIN - self-signed certificate in certificate chain
curl (macOS):      curl: (60) SSL certificate problem: self signed certificate in certificate chain
Python (LibreSSL): [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self signed certificate in certificate chain

LibreSSL (curl und System-Python unter macOS) und OpenSSL bis 1.1.1 schreiben self signed ohne Bindestrich, OpenSSL ab 3.0 mit.

Und wenn er sie nicht mitsendet?

Das ist der Normalfall:

openssl s_client:  Verify return code: 20 (unable to get local issuer certificate)
Node:              UNABLE_TO_GET_ISSUER_CERT_LOCALLY - unable to get local issuer certificate
curl:              curl: (60) SSL certificate problem: unable to get local issuer certificate
Python:            [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate

Was melden Browser und Java?

Chromium und Firefox melden in beiden Fällen (gemessen mit Chromium 151 und Firefox 153):

Chromium:          net::ERR_CERT_AUTHORITY_INVALID
Firefox:           SEC_ERROR_UNKNOWN_ISSUER

Java meldet ebenfalls in beiden Fällen (Quelltext von OpenJDK):

PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

Fehlt wirklich nur die Root?

Das setzt voraus, dass der Server alle Zwischenzertifikate sendet. Fehlt stattdessen ein Zwischenzertifikat, hilft wenn nginx die Zertifikatskette unvollständig sendet; beide Fälle trennt der Abschnitt „Wie finde ich heraus, ob nur die Root fehlt?“.

Hilft es, die Root auf dem Server mitzusenden?

Wer unable to get local issuer certificate liest, schließt auf eine kaputte Kette und hängt die Root an die Datei an, die der Server ausliefert. Das ändert die Meldung, nicht das Ergebnis. Gemessen mit einer Wegwerf-CA: dieselbe Kette scheitert ohne Root mit Fehler 20 und mit angehängter Root mit Fehler 19.

Messung und Randfälle: Fehlernummer je Client

Gemessen wurde gegen openssl, curl, Python und Node. openssl nennt die Nummer, Python nur im Attribut verify_code der Ausnahme (die Meldung trägt sie nicht), curl und Node den zugehörigen Text.

Warum kennt der Client die Root nicht?

Ein Client prüft, ob sich vom Server-Zertifikat eine Signaturkette bis zu einem Zertifikat ziehen lässt, dem er vertraut, dem Trust Anchor. Leaf und Zwischenzertifikate liefert der Server mit, den Anker nicht: ein selbstsigniertes Zertifikat bestätigt nur sich selbst, ob man ihm vertraut, entscheidet der Client. Die Roots öffentlicher CAs sind vorinstalliert, die der eigenen CA nicht.

Welchen Speicher liest welcher Client?

  • Java liest die Datei cacerts der Installation.
  • Node nutzt je nach Bauart den mitgelieferten Mozilla-Bestand oder den Standardspeicher von OpenSSL (Node-Dokumentation: zur Bauzeit wählbar); node --help zeigt es an der Zeile mit (default).
  • Python-requests nutzt das Paket certifi und nicht den Speicher des Systems (requests-Dokumentation).
Messung und Randfälle: Node-Bauarten

Gemessen: das offizielle Binary v26.9.0 --use-bundled-ca, Homebrew --use-openssl-ca.

Wie finde ich heraus, ob nur die Root fehlt?

Die gesendete Kette lässt sich ohne Browser abfragen:

openssl s_client -showcerts -connect server.example.intern:443 -servername server.example.intern </dev/null

Unter Certificate chain steht jedes gesendete Zertifikat mit Subject (s:) und Issuer (i:), am Ende Verify return code. So liest man sie:

  • 19, der letzte Eintrag hat gleiches s: und i:: der Server sendet die Root, der Client kennt sie nicht.
  • 20 bei mindestens zwei Einträgen: der Aussteller des letzten Eintrags fehlt im Client, i: dort nennt ihn. Entweder ist es die Root oder ein weiteres Zwischenzertifikat, das der Server nicht sendet (dann hilft wenn nginx die Zertifikatskette unvollständig sendet); die Gegenprobe trennt beide.
  • 21 (unable to verify the first certificate) bei genau einem Eintrag: nur das Leaf kommt an. Entweder fehlt ein Zwischenzertifikat, oder die Root hat das Leaf direkt signiert (einstufige PKI). Beide enden bei 21; die Gegenprobe trennt sie.

Wie sieht die Gegenprobe aus?

Für die Gegenprobe wird die Root als Datei besorgt und als root.pem abgelegt. Die Datei kommt vom CA-Betreiber im PEM-Format (Text, beginnt mit -----BEGIN CERTIFICATE-----). Die Gegenprobe gibt dem Client nur diese Datei:

openssl s_client -connect server.example.intern:443 -servername server.example.intern -CAfile root.pem </dev/null 2>&1 | grep 'Verify return code'

root.pem enthält nur die geprüfte Root, und -CApath bleibt weg.

Messung und Randfälle: warum kein -CApath

Ein fehlendes Zwischenzertifikat in einem zusätzlich angegebenen Verzeichnis füllt die Lücke still, und die Gegenprobe meldet 0 (ok), obwohl der Server unvollständig sendet (gemessen mit OpenSSL 3.6.4). Mit -CAfile allein zieht openssl kein weiteres Verzeichnis heran.

Bei Verify return code: 0 (ok) trägt der Server die Kette korrekt, und es fehlt allein das Vertrauen im Client. Bleibt der Code bei 20 oder 21, fehlt auf dem Server noch ein Zwischenzertifikat (dazu wenn nginx die Zertifikatskette unvollständig sendet), oder root.pem ist nicht die Root dieser Kette.

Wie behebe ich es?

Erstens: Wie prüfe ich die Root?

Einen Trust Anchor (hier die Datei root.pem aus der Gegenprobe) nimmt man nur nach Prüfung auf, denn er gilt für alles, was die CA signiert: den Fingerabdruck vergleicht man auf einem zweiten Weg mit dem Wert des Betreibers:

openssl x509 -in root.pem -noout -subject -fingerprint -sha256

Zweitens: Wo trage ich die Root ein?

Die Root kommt dorthin, wo der fehlschlagende Client sucht. Im Systemspeicher unter Debian und Ubuntu (die Endung .crt ist Pflicht):

sudo cp root.pem /usr/local/share/ca-certificates/firmen-root.crt
sudo update-ca-certificates

Unter RHEL und Verwandten:

sudo cp root.pem /etc/pki/ca-trust/source/anchors/firmen-root.pem
sudo update-ca-trust extract

Unter macOS:

sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain root.pem

Wie geht das unter Windows?

root.cer ist die Root in der binären DER-Form, deren Textfassung root.pem ist. Welche Kodierung certutil -addstore annimmt, nennt die Microsoft-Dokumentation nicht (Stand 1. Mai 2025), gemessen ist es hier nicht; DER ist die Wahl ohne Textumschlag.

Umgewandelt wird vorher mit openssl auf dem Rechner, auf dem die Root geprüft wurde. Der Fingerabdruck muss dem aus dem ersten Schritt gleichen:

openssl x509 -in root.pem -outform DER -out root.cer
openssl x509 -inform DER -in root.cer -noout -fingerprint -sha256

Dann root.cer auf den Windows-Rechner kopieren und dort als Administrator:

certutil -addstore -f Root root.cer

Und bei curl, Node und Python?

Nicht jeder Client liest den Systemspeicher (für requests, Java und Node siehe „Welchen Speicher liest welcher Client?“). curl und Python-ssl lesen den Standardspeicher ihrer TLS-Bibliothek, bei Python mit OpenSSL unter macOS die Datei /private/etc/ssl/cert.pem (gemessen: 128 Zertifikate; ob der macOS-Schritt oben sie ändert, ist nicht gemessen). Diese Clients bekommen die Root einzeln:

curl --cacert root.pem https://server.example.intern/
CURL_CA_BUNDLE=/pfad/root.pem curl https://server.example.intern/
NODE_EXTRA_CA_CERTS=/pfad/root.pem node app.js

Python, mit requests alternativ über die Umgebungsvariable REQUESTS_CA_BUNDLE:

ctx = ssl.create_default_context(cafile="/pfad/root.pem")
requests.get(url, verify="/pfad/root.pem")

--cacert, cafile und verify= ersetzen den Standardspeicher, NODE_EXTRA_CA_CERTS ergänzt ihn (curl- und Node-Dokumentation).

Messung und Randfälle: Wirkung der Root auf die Clients

Gemessen: mit der Root verschwinden alle Fehler (HTTP 200).

Nach cafile=root.pem scheitert eine öffentliche Website bei Python mit OpenSSL mit Fehler 20, mit NODE_EXTRA_CA_CERTS antwortet sie.

System-curl (SecureTransport) und System-Python unter macOS akzeptieren sie auch mit nur der Wegwerf-Root.

Und bei Java?

Java braucht einen Truststore, der die Root enthält:

keytool -importcert -alias firmen-root -file root.pem -keystore truststore.p12 -storetype PKCS12
java -Djavax.net.ssl.trustStore=truststore.p12 -Djavax.net.ssl.trustStorePassword=... -jar app.jar

Die Eigenschaft javax.net.ssl.trustStore ersetzt den Standard-Truststore (JSSE-Referenz), öffentliche CAs müssen dann ebenfalls in die Datei. Alternativ trägt keytool -importcert -cacerts ... die Root in die cacerts der Installation ein.

Drittens: Darf ich die Prüfung abschalten?

Nein. curl -k, verify=False und NODE_TLS_REJECT_UNAUTHORIZED=0 lassen den Fehler verschwinden, weil sie die Prüfung abschalten; die Verbindung steht jedem Mittelsmann offen. Die Root vom Server mitsenden zu lassen hilft nicht (siehe oben).

Wann hilft das PKI-Toolkit?

Ist unklar, welche Datei eines CA-Bündels die Root ist, hilft unser PKI-Toolkit. Das Werkzeug:

  • liest die Dateien im Browser ohne Upload,
  • prüft die Signatur jedes Eintrags gegen seinen Aussteller bei RSA (PKCS#1 und PSS) und ECDSA (P-256, P-384, P-521), bei Ed25519 nur, wenn der Browser es unterstützt, und weist andere Verfahren als nicht geprüft aus,
  • kennzeichnet das selbstsignierte Zertifikat am Kettenende als „selbstsigniert (Root)“,
  • gibt fullchain.pem wahlweise mit oder ohne Root aus.

Welche Roots ein Client kennt, weiß es nicht; ob die Root dort fehlt, zeigt allein der Befehl aus „Wie finde ich heraus, ob nur die Root fehlt?“.

Lassen Sie uns sprechen

Kostenlose Erstberatung - kein Verkaufsgespräch, sondern ehrliche Einschätzung.

Beratungsgespräch anfragen →