Ich habe ein selbstsigniertes SSL-Zertifikat für den lokalen Host-CN erstellt. Firefox akzeptiert dieses Zertifikat, nachdem es sich wie erwartet beschwert hat. Chrome und IE lehnen die Annahme jedoch ab, selbst nachdem das Zertifikat dem Systemzertifikatsspeicher unter Trusted Roots hinzugefügt wurde. Obwohl das Zertifikat als korrekt installiert aufgeführt ist, wenn ich im HTTPS-Popup von Chrome auf "Zertifikatinformationen anzeigen" klicke, besteht es weiterhin darauf, dass das Zertifikat nicht als vertrauenswürdig eingestuft wird.
Was soll ich tun, damit Chrome das Zertifikat akzeptiert und sich nicht mehr darüber beschwert?
Nur für localhost
:
Fügen Sie dies einfach in Ihr Chrome ein:
chrome://flags/#allow-insecure-localhost
Der hervorgehobene Text sollte lauten: Ungültige Zertifikate für von localhost geladene Ressourcen zulassen
Klicken Sie auf Enable
.
Das hat bei mir funktioniert:
Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates
.Authorities
und scrollen Sie nach unten, um Ihr Zertifikat unter dem Organisationsnamen zu finden, den Sie dem Zertifikat gegeben haben.Sie sollten jetzt das schöne grüne Schloss auf Ihren Seiten haben.
EDIT: Ich habe es auf einem neuen Computer erneut versucht und das Zertifikat wurde nicht im Fenster Zertifikate verwalten angezeigt, nur indem ich von der roten Seite für nicht vertrauenswürdige Zertifikate aus fortfuhr. Ich musste Folgendes tun:
https://
ist rot durchgestrichen) auf das Schloss> Zertifikatinformationen. HINWEIS: Bei neueren Chrome-Versionen müssen Sie Developer Tools > Security
öffnen und View certificate
auswählen.Details tab > Export
. Wählen Sie PKCS #7, single certificate
als Dateiformat.Authorities tab > Import
und wählen Sie die Datei aus, in die Sie das Zertifikat exportiert haben. Stellen Sie sicher, dass Sie PKCS #7, single certificate
als Dateityp .UPDATE FÜR CHROME 58+ (RELEASED 2017-04-19)
Ab Chrome 58, Identifizierung des Hosts nur mit commonName
wird entfernt . Siehe weiter Diskussion hier und Bug-Tracker hier . In der Vergangenheit wurde subjectAltName
nur für Multi-Host-Zertifikate verwendet, sodass einige interne CA-Tools diese möglicherweise nicht enthalten.
Wenn Ihre selbstsignierten Zertifikate in der Vergangenheit gut funktioniert haben , aber plötzlich Fehler in Chrome 58 generiert haben, ist dies der Grund.
Unabhängig von der Methode, mit der Sie Ihr selbstsigniertes Zertifikat (oder ein von einer selbstsignierten Zertifizierungsstelle signiertes Zertifikat) erstellen, müssen Sie sicherstellen, dass das Zertifikat des Servers ein subjectAltName
mit dem richtigen DNS
und/oder IP
entry/entries, auch wenn es sich nur um einen einzelnen Host handelt .
Für openssl bedeutet dies, dass Ihre OpenSSL-Konfiguration (/etc/ssl/openssl.cnf
unter Ubuntu) für einen einzelnen Host ungefähr Folgendes haben sollte:
[v3_ca] # and/or [v3_req], if you are generating a CSR
subjectAltName = DNS:example.com
oder für mehrere Hosts:
[v3_ca] # and/or [v3_req], if you are generating a CSR
subjectAltName = DNS:example.com, DNS:Host1.example.com, DNS:*.Host2.example.com, IP:10.1.2.3
In Chrome Cert Viewer (der unter F12 auf den Tab "Sicherheit" verschoben wurde) sollte er unter Extensions
als Certificate Subject Alternative Name
aufgeführt sein:
Auf dem Mac können Sie das selbstsignierte Zertifikat mit dem Dienstprogramm für den Schlüsselbundzugriff zum Systemschlüsselbund hinzufügen, und Chrome akzeptiert es dann. Die Schritt-für-Schritt-Anleitung habe ich hier gefunden:
Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate
Grundsätzlich gilt:
Klicken Sie auf eine beliebige Stelle auf der Seite und geben Sie BYPASS_SEQUENCE ein
"thisisunsafe
" ist eine BYPASS_SEQUENCE für Chrome Version 65
"badidea
" Chrome Version 62 - 64.
"danger
" wurde in früheren Chrome-Versionen verwendet
Sie müssen nicht nach einem Eingabefeld suchen, sondern müssen es nur eingeben. Es fühlt sich seltsam an, aber es funktioniert.
Ich habe es auf dem Mac High Sierra ausprobiert.
Um zu überprüfen, ob sie es erneut geändert haben, gehen Sie zu Neueste Chrom Quellcode
Um nach BYPASS_SEQUENCE zu suchen, sieht es im Moment so aus:
var BYPASS_SEQUENCE = window.atob('dGhpc2lzdW5zYWZl');
Jetzt haben sie es getarnt, aber um die echte BYPASS_SEQUENCE zu sehen, können Sie folgende Zeile in einer Browser-Konsole ausführen.
console.log(window.atob('dGhpc2lzdW5zYWZl'));
UPDATE 11/2017: Diese Antwort funktioniert wahrscheinlich nicht für die meisten neueren Versionen von Chrome.
UPDATE 02/2016: Bessere Anweisungen für Mac-Benutzer finden Sie hier .
Klicken Sie auf der Site, die Sie hinzufügen möchten, mit der rechten Maustaste auf das rote Schlosssymbol in der Adressleiste:
Klicken Sie auf die Registerkarte Verbindung und dann auf Zertifikatinformationen .
Klicken Sie auf die Registerkarte Details und dann auf die Schaltfläche In Datei kopieren ... . Der Zertifikatsexport-Assistent wird geöffnet. Klicken Sie auf Weiter , um zum Bildschirm Export File Format zu gelangen.
Wählen Sie DER-codierte binäre X.509 (.CER) , klicken Sie auf Weiter
Klicken Sie auf Durchsuchen ... und speichern Sie die Datei auf Ihrem Computer. Nennen Sie es etwas Beschreibendes. Klicken Sie auf Weiter und dann auf Fertig stellen .
Öffnen Sie Chrome Einstellungen, scrollen Sie nach unten und klicken Sie auf Erweiterte Einstellungen anzeigen ...
Klicken Sie unter HTTPS/SSL auf Zertifikate verwalten ...
Klicken Sie auf die Registerkarte Vertrauenswürdige Stammzertifizierungsstellen und dann auf die Schaltfläche Importieren ... . Dies öffnet den Zertifikatimport-Assistenten. Klicken Sie auf Weiter , um zum Bildschirm Zu importierende Datei zu gelangen.
Klicken Sie auf Durchsuchen ... und wählen Sie die zuvor gespeicherte Zertifikatdatei aus. Klicken Sie dann auf Weiter .
Wählen Sie Alle Zertifikate in folgendem Speicher ablegen . Der ausgewählte Speicher sollte vertrauenswürdige Stammzertifizierungsstellen sein. Wenn nicht, klicken Sie auf Durchsuchen ... und wählen Sie es aus. Klicken Sie auf Weiter und Fertig stellen
Klicken Sie in der Sicherheitswarnung auf Ja .
Starten Sie Chrome neu.
Wenn Sie Linux verwenden, können Sie auch diesen offiziellen Wiki-Seiten folgen:
Grundsätzlich gilt:
Mit dem folgenden Befehl wird nun das Zertifikat hinzugefügt (wobei YOUR_FILE Ihre exportierte Datei ist):
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n YOUR_FILE -i YOUR_FILE
Führen Sie den folgenden Befehl aus, um alle Ihre Zertifikate aufzulisten:
certutil -d sql:$HOME/.pki/nssdb -L
Wenn es immer noch nicht funktioniert, könnten Sie von diesem Fehler betroffen sein: Problem 55050: Ubuntu SSL-Fehler 8179
P.S. Bitte stellen Sie auch sicher, dass Sie libnss3-tools
haben, bevor Sie die obigen Befehle verwenden können.
Wenn Sie nicht haben, installieren Sie es bitte durch:
Sudo apt-get install libnss3-tools # on Ubuntu
Sudo yum install nss-tools # on Fedora, Red Hat, etc.
Als Bonus können Sie die folgenden praktischen Skripte verwenden:
$ cat add_cert.sh
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n $1 -i $1
$ cat list_cert.sh
certutil -d sql:$HOME/.pki/nssdb -L # add '-h all' to see all built-in certs
$ cat download_cert.sh
echo QUIT | openssl s_client -connect $1:443 | sed -ne '/BEGIN CERT/,/END CERT/p'
Verwendungszweck:
add_cert.sh [FILE]
list_cert.sh
download_cert.sh [DOMAIN]
Führen Sie Chrome mit dem Parameter --auto-ssl-client-auth
aus
google-chrome --auto-ssl-client-auth
Auf dem Mac können Sie ein Zertifikat erstellen, dem Chrome und Safari auf Systemebene uneingeschränkt vertrauen, indem Sie folgende Schritte ausführen:
# create a root authority cert
./create_root_cert_and_key.sh
# create a wildcard cert for mysite.com
./create_certificate_for_domain.sh mysite.com
# or create a cert for www.mysite.com, no wildcards
./create_certificate_for_domain.sh www.mysite.com www.mysite.com
v3.ext
, um Fehler aufgrund fehlender alternativer Namen zu vermeidenWenn Sie ein neues selbstsigniertes Zertifikat erstellen möchten, das mit Ihrer eigenen Root-Berechtigung voll vertrauenswürdig ist, können Sie dies mit diesen Skripten tun.
#!/usr/bin/env bash
openssl genrsa -out rootCA.key 2048
openssl req -x509 -new -nodes -key rootCA.key -sha256 -days 1024 -out rootCA.pem
#!/usr/bin/env bash
if [ -z "$1" ]
then
echo "Please supply a subdomain to create a certificate for";
echo "e.g. www.mysite.com"
exit;
fi
if [ ! -f rootCA.pem ]; then
echo 'Please run "create_root_cert_and_key.sh" first, and try again!'
exit;
fi
if [ ! -f v3.ext ]; then
echo 'Please download the "v3.ext" file and try again!'
exit;
fi
# Create a new private key if one doesnt exist, or use the xeisting one if it does
if [ -f device.key ]; then
KEY_OPT="-key"
else
KEY_OPT="-keyout"
fi
DOMAIN=$1
COMMON_NAME=${2:-*.$1}
SUBJECT="/C=CA/ST=None/L=NB/O=None/CN=$COMMON_NAME"
NUM_OF_DAYS=999
openssl req -new -newkey rsa:2048 -sha256 -nodes $KEY_OPT device.key -subj "$SUBJECT" -out device.csr
cat v3.ext | sed s/%%DOMAIN%%/"$COMMON_NAME"/g > /tmp/__v3.ext
openssl x509 -req -in device.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out device.crt -days $NUM_OF_DAYS -sha256 -extfile /tmp/__v3.ext
# move output files to final filenames
mv device.csr "$DOMAIN.csr"
cp device.crt "$DOMAIN.crt"
# remove temp file
rm -f device.crt;
echo
echo "###########################################################################"
echo Done!
echo "###########################################################################"
echo "To use these files on your server, simply copy both $DOMAIN.csr and"
echo "device.key to your webserver, and use like so (if Apache, for example)"
echo
echo " SSLCertificateFile /path_to_your_files/$DOMAIN.crt"
echo " SSLCertificateKeyFile /path_to_your_files/device.key"
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = %%DOMAIN%%
Damit die selbstsignierten Zertifikate in Chrome und Safari VOLLSTÄNDIG als vertrauenswürdig eingestuft werden, müssen Sie eine neue Zertifizierungsstelle in Ihren Mac importieren. Befolgen Sie dazu diese Anweisungen oder die detaillierteren Anweisungen zu diesem allgemeinen Vorgang auf der mitmproxy-Website :
Sie können dies auf zwei Arten in der Befehlszeile tun, indem Sie diesen Befehl verwenden, der Sie zur Eingabe Ihres Passworts auffordert:
$ Sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain rootCA.pem
oder mit der Keychain Access
App:
und als Bonus können Sie, wenn Sie Java Clients benötigen, um den Zertifikaten zu vertrauen, Ihre Zertifikate in den Java Keystore importieren. Beachten Sie, dass das Zertifikat aus dem Keystore entfernt wird, wenn es bereits vorhanden ist, da es aktualisiert werden muss, falls sich etwas ändert. Dies gilt natürlich nur für die importierten Zertifikate.
KEYSTORE="$(/usr/libexec/Java_home)/jre/lib/security/cacerts";
function running_as_root()
{
if [ "$EUID" -ne 0 ]
then echo "NO"
exit
fi
echo "YES"
}
function import_certs_to_Java_keystore
{
for crt in *.crt; do
echo prepping $crt
keytool -delete -storepass changeit -alias alias__${crt} -keystore $KEYSTORE;
keytool -import -file $crt -storepass changeit -noprompt --alias alias__${crt} -keystore $KEYSTORE
echo
done
}
if [ "$(running_as_root)" == "YES" ]
then
import_certs_to_Java_keystore
else
echo "This script needs to be run as root!"
fi
Wenn Sie auf einem Mac sind und die Registerkarte "Export" nicht sehen oder wissen, wie Sie das Zertifikat erhalten, hat dies für mich funktioniert:
Klicken Sie auf "Zertifikatsinformationen".
Jetzt solltest du folgendes sehen:
Ziehen Sie das kleine Zertifikatssymbol auf Ihren Desktop (oder irgendwo).
Doppelklicken Sie auf die heruntergeladene CER-Datei. Dadurch sollte sie in Ihren Schlüsselbund importiert und der Schlüsselbund-Zugriff auf Ihre Zertifikatsliste geöffnet werden.
In einigen Fällen reicht dies aus und Sie können die Seite jetzt aktualisieren.
Andernfalls:
Laden Sie nun die betreffende Seite neu und es sollte das Problem behoben sein! Hoffe das hilft.
Um dies ein wenig zu vereinfachen, können Sie das folgende Skript verwenden ( source ):
Speichern Sie das folgende Skript als whitelist_ssl_certificate.ssh
:
#!/usr/bin/env bash -e
SERVERNAME=$(echo "$1" | sed -E -e 's/https?:\/\///' -e 's/\/.*//')
echo "$SERVERNAME"
if [[ "$SERVERNAME" =~ .*\..* ]]; then
echo "Adding certificate for $SERVERNAME"
echo -n | openssl s_client -connect $SERVERNAME:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | tee /tmp/$SERVERNAME.cert
Sudo security add-trusted-cert -d -r trustRoot -k "/Library/Keychains/System.keychain" /tmp/$SERVERNAME.cert
else
echo "Usage: $0 www.site.name"
echo "http:// and such will be stripped automatically"
fi
Machen Sie das Skript ausführbar (aus der Shell):
chmod +x whitelist_ssl_certificate.ssh
Führen Sie das Skript für die gewünschte Domain aus (Kopieren/Einfügen der vollständigen URL funktioniert):
./whitelist_ssl_certificate.ssh https://your_website/whatever
AKTUALISIERT Apr 3/2018
Es gibt eine geheime Umgehungsphrase, die in die Fehlerseite eingegeben werden kann, damit Chrome trotz des Sicherheitsfehlers fortgesetzt wird: thisisunsafe (in frühere Chrome-Versionen geben badidea und noch früher danger ein . DO NOT BENUTZEN SIE DIES, AUSSER SIE VERSTEHEN GENAU, WARUM SIE ES BENÖTIGEN!
Quelle:
https://chromium.googlesource.com/chromium/src/+/d8fc089b62cd4f8d907acff6fb3f5ff58f168697%5E%21/
(HINWEIS, dass window.atob('dGhpc2lzdW5zYWZl')
in thisisunsafe
aufgelöst wird.)
Die neueste Version der Quelle ist @ https://chromium.googlesource.com/chromium/src/+/refs/heads/master/components/security_interstitials/core/browser/resources/interstitial_large.js und die Funktion window.atob
kann in einer JS-Konsole ausgeführt werden.
Hintergrundinformationen dazu, warum das Chrome Team die Umgehungsphrase (zum ersten Mal) geändert hat:
https://bugs.chromium.org/p/chromium/issues/detail?id=581189
Für schnelle einmalige Aktionen, wenn die Option "Trotzdem fortfahren" nicht verfügbar ist oder die Umgehungsphrase nicht funktioniert, funktioniert dieser Hack gut:
Zulassen von Zertifikatfehlern von localhost
durch Aktivieren dieses Flags (Hinweis Chrome muss nach dem Ändern des Flag-Werts neu gestartet werden):
chrome://flags/#allow-insecure-localhost
(und Abstimmungsantwort https://stackoverflow.com/a/31900210/430128 von @Chris)
Wenn die Site, zu der Sie eine Verbindung herstellen möchten, localhost
ist, sind Sie fertig. Andernfalls richten Sie einen TCP Tunnel ein, um Port 8090 lokal abzuhören, und stellen Sie über Port 443 eine Verbindung zu broken-remote-site.com
her. Stellen Sie sicher, dass socat
installiert ist, und führen Sie in einem Terminalfenster Folgendes aus:
socat tcp-listen:8090,reuseaddr,fork tcp:broken-remote-site.com:443
Wechseln Sie in Ihrem Browser zu https: // localhost: 809 .
Für eine Testumgebung
Sie können --ignore-certificate-errors
als Befehlszeilenparameter verwenden, wenn Sie chrome starten (Arbeiten mit Version 28.0.1500.52 unter Ubuntu).
Dadurch werden die Fehler ignoriert und die Verbindung wird ohne Warnung hergestellt. Wenn bereits eine Version von chrome ausgeführt wird, müssen Sie diese schließen, bevor Sie sie über die Befehlszeile neu starten. Andernfalls wird ein neues Fenster geöffnet, die Parameter werden jedoch ignoriert.
Ich konfiguriere Intellij so, dass chrome beim Debuggen auf diese Weise gestartet wird, da die Testserver niemals gültige Zertifikate haben.
Normales Browsen wie dieses würde ich allerdings nicht empfehlen, da Zertifikatsüberprüfungen ein wichtiges Sicherheitsmerkmal sind, dies kann jedoch für einige hilfreich sein.
Wie jemand bemerkt hat, müssen Sie ALLES von Chrome neu starten, nicht nur die Browserfenster. Der schnellste Weg, dies zu tun, besteht darin, einen Tab zu öffnen, um ...
chrome://restart
WINDOWS JUN/2017 Windows Server 2012
Ich folgte @ Brad Parks Antwort. Unter Windows sollten Sie rootCA.pem in den Speicher für vertrauenswürdige Stammzertifizierungsstellen importieren.
Ich habe die folgenden Schritte ausgeführt:
openssl genrsa -out rootCA.key 4096
openssl req -x509 -new -nodes -key rootCA.key -newkey rsa:4096 -sha256 -days 1024 -out rootCA.pem
openssl req -new -newkey rsa:4096 -sha256 -nodes -keyout device.key -out device.csr
openssl x509 -req -in device.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out device.crt -days 2000 -sha256 -extfile v3.ext
Wobei v3.ext ist:
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = localhost
IP.1 = 192.168.0.2
IP.2 = 127.0.0.1
In meinem Fall habe ich dann eine selbst gehostete Web-App, daher muss ich das Zertifikat mit der IP-Adresse und dem Port binden. Das Zertifikat sollte sich in MEINEM Geschäft mit Informationen zu privaten Schlüsseln befinden, also habe ich es in das PFX-Format exportiert.
openssl pkcs12 -export -out device.pfx -inkey device.key -in device.crt
Mit der MMC-Konsole (Datei/Snap-Ins hinzufügen oder entfernen/Zertifikate/Konto hinzufügen/Computert/LocalComputer/OK) habe ich eine PFX-Datei in den persönlichen Speicher importiert.
Später habe ich diesen Befehl verwendet, um das Zertifikat zu binden (Sie können auch das Tool HttpConfig verwenden):
netsh http add sslcert ipport=0.0.0.0:12345 certhash=b02de34cfe609bf14efd5c2b9be72a6cb6d6fe54 appid={BAD76723-BF4D-497F-A8FE-F0E28D3052F4}
certhash = Zertifikat Thumprint
appid = GUID (Ihre Wahl)
Zuerst habe ich versucht, das Zertifikat "device.crt" auf verschiedene Arten in vertrauenswürdige Stammzertifizierungsstellen zu importieren, aber es wird immer noch derselbe Fehler angezeigt:
Aber ich erkannte, dass ich das Zertifikat der Root-Autorität importieren sollte, nicht das Zertifikat für die Domain. Also habe ich die mmc-Konsole verwendet (Datei/Snap-Ins hinzufügen oder entfernen/Zertifikate/Konto hinzufügen/Computert/Lokaler Computer/OK). Ich habe rootCA.pem in den Speicher für vertrauenswürdige Stammzertifizierungsstellen importiert.
Starten Sie Chrome neu und es funktioniert.
Mit localhost:
Oder mit IP-Adresse:
Das einzige, was ich nicht erreichen konnte, ist, dass es veraltete Chiffre hat (rotes Quadrat auf dem Bild). Hilfe wird in diesem Punkt geschätzt.
Mit makecert ist es nicht möglich, SAN Informationen hinzuzufügen. Mit New-SelfSignedCertificate (Powershell) können Sie SAN Informationen hinzufügen, es funktioniert auch.
Sind Sie sicher, dass die Adresse, an die die Site geliefert wird, mit der des Zertifikats übereinstimmt? Ich hatte die gleichen Probleme mit Chrome und einem selbstsignierten Zertifikat, aber am Ende stellte ich fest, dass die Validierung des Domainnamens auf dem Zertifikat (wie es sein sollte) unglaublich pingelig war.
Chrome hat keinen eigenen Zertifizierungsspeicher und verwendet den von Windows. Allerdings bietet Chrome keine Möglichkeit, Zertifikate in den Store zu importieren. Fügen Sie sie stattdessen über IE hinzu.
Installieren von Zertifikaten in Google Chrome
Installieren von Zertifikaten in Internet Explorer
Sehen Sie sich dies auch an, um einige verschiedene Ansätze zum Erstellen von selbstsignierten Zertifikaten zu finden (ich gehe davon aus, dass Sie IIS verwenden, wie Sie es noch nicht erwähnt haben).
Wenn Sie auf das kleine durchgestrichene Schlosssymbol neben der URL klicken, wird ein Feld angezeigt, das wie folgt aussieht:
Nachdem Sie auf den Link Certificate information geklickt haben, wird das folgende Dialogfeld angezeigt:
Hier erfahren Sie, welcher Zertifikatspeicher der richtige ist. Es handelt sich um den Speicher Trusted Root Certification Authorities.
Sie können entweder eine der in den anderen Antworten beschriebenen Methoden verwenden, um das Zertifikat zu diesem Speicher hinzuzufügen, oder Folgendes verwenden:
certutil -addstore -user "ROOT" cert.pem
ROOT
ist der interne Name des zuvor erwähnten Zertifikatspeichers.cert.pem
ist der Name Ihres selbstsignierten Zertifikats.Ich habe die folgenden Vorschläge von bjnord verwendet: Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate
Was im Blog gezeigt wird, hat nicht funktioniert.
Einer der Kommentare im Blog war jedoch Gold:
Sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain site.crt
Sie müssen dem Blog folgen, um die Zertifikatsdatei zu erhalten. Danach können Sie den obigen Befehl verwenden und sollten einsatzbereit sein.
Dieser Beitrag ist bereits mit Antworten überflutet, aber ich habe ein Bash-Skript erstellt, das auf einigen der anderen Antworten basiert, um das Ermöglichen von Erstellen Sie ein selbstsigniertes TLS-Zertifikat , das in Chrome gültig ist (getestet in Chrome 65.x
). Hoffe, es ist nützlich für andere.
Vergessen Sie nach der Installation ( und Vertrauenswürdigkeit nicht, Chrome (chrome://restart
)
Ein weiteres Tool, das es wert ist, überprüft zu werden, ist das cfssl
Toolkit von CloudFlare:
Ab Chrome 58+ erhalte ich auf macOS einen Zertifikatfehler, da ein SAN fehlt. Hier erfahren Sie, wie Sie die grüne Adressleiste wieder sperren können.
Generieren Sie ein neues Zertifikat mit dem folgenden Befehl:
openssl req \
-newkey rsa:2048 \
-x509 \
-nodes \
-keyout server.key \
-new \
-out server.crt \
-subj /CN=*.domain.dev \
-reqexts SAN \
-extensions SAN \
-config <(cat /System/Library/OpenSSL/openssl.cnf \
<(printf '[SAN]\nsubjectAltName=DNS:*.domain.dev')) \
-sha256 \
-days 720
Importieren Sie den server.crt
in Ihren Schlüsselbund, doppelklicken Sie dann auf das Zertifikat, erweitern Sie die Vertrauensstellung und wählen Sie Immer Vertrauen
Aktualisieren Sie die Seite https://domain.dev in Google Chrome, damit die grüne Sperre wieder angezeigt wird.
Die GUI zum Verwalten von SSL-Zertifikaten auf Chromium unter Linux funktionierte bei mir NICHT ordnungsgemäß. Ihre Dokumente gaben jedoch die richtige Antwort. Der Trick bestand darin, den folgenden Befehl auszuführen, mit dem das selbstsignierte SSL-Zertifikat importiert wird. Aktualisieren Sie einfach den Namen von <certificate-nickname>
und certificate-filename.cer
und starten Sie dann chrom/chrome neu.
Aus den Dokumenten:
Unter Linux verwendet Chromium die NSS Shared DB. Wenn der integrierte Manager für Sie nicht funktioniert, können Sie Zertifikate mit den NSS-Befehlszeilentools konfigurieren.
Holen Sie sich die Werkzeuge
Debian/Ubuntu:
Sudo apt-get install libnss3-tools
Fedora:
su -c "yum install nss-tools"
Gentoo:
su -c "echo 'dev-libs/nss utils' >> /etc/portage/package.use && emerge dev-libs/nss"
(Sie müssen alle folgenden Befehle mit dem Präfixnss
starten, z. B.nsscertutil
.) Opensuse:Sudo zypper install mozilla-nss-tools
Um einem selbstsignierten Serverzertifikat zu vertrauen, sollten wir verwenden.
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n <certificate-nickname> -i certificate-filename.cer
Alle Zertifikate auflisten
certutil -d sql:$HOME/.pki/nssdb -L
Die TRUSTARGS sind drei durch Kommas getrennte Zeichenfolgen mit null oder mehr Buchstaben. Sie definieren, wie dem Zertifikat für SSL, E-Mail und Objektsignierung vertraut werden soll, und werden in den certutil-Dokumenten oder in Meenas Blogbeitrag zu Vertrauensmarkierungen erläutert.
Fügen Sie ein persönliches Zertifikat und einen privaten Schlüssel für die SSL-Clientauthentifizierung hinzu. Verwenden Sie den folgenden Befehl:
pk12util -d sql:$HOME/.pki/nssdb -i PKCS12_file.p12
um ein persönliches Zertifikat und einen privaten Schlüssel zu importieren, die in einer PKCS # 12-Datei gespeichert sind. Die TRUSTARGS des persönlichen Zertifikats werden auf "u, u, u" gesetzt.
Zertifikat löschen
certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>
Auszug aus: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md =
Wenn unter Fedora und Ubuntu die Fehlermeldung example.com Not a Certification authority
angezeigt wird, wenn Sie das Zertifikat mithilfe der GUI zum Hinzufügen einer neuen Stammzertifizierungsstelle hinzufügen.
Versuchen Sie Folgendes mit einem aus Chrom exportierten Zertifikat, jedes Format funktioniert (base64 chain/singe, pkcs 7, der binary, etc). Dies hat bei mir funktioniert, als ALLE GUI-Methoden kläglich versagten.
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n <certificate nickname> \
-i <certificate filename>
Starten Sie Chrome neu, um die Änderungen anzuzeigen, und beenden Sie es gegebenenfalls im Hintergrund. Firefox wird sich immer noch beschweren.
Um es später zu löschen, gehen Sie zu Chrome -> Einstellungen -> Erweitert -> Zertifikate verwalten -> Server. Es wird schließlich dort angezeigt, wo es gelöscht werden kann.
Quelle, Warnung, sehr, sehr fleckig und teilweise veraltet: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md
Das Zulassen von unsicherem localhost funktioniert mit der folgenden Methode: chrome: // flags/# allow-insecure-localhost
Sie müssen lediglich Ihren Entwicklungshostnamen für xxx.localhost erstellen.
2017-06-27 neueste Methode:
openssl req \
-newkey rsa:2048 \
-x509 \
-nodes \
-keyout yoursite.key \
-new \
-out yoursite.crt \
-subj /CN=yoursite.dev \
-reqexts SAN \
-extensions SAN \
-config <(cat /System/Library/OpenSSL/openssl.cnf \
<(printf '[SAN]\nsubjectAltName=DNS:yoursite.dev')) \
-sha256 \
-days 3650
fügen Sie anschließend yoursite.crt und yoursite.key zu Ihrer Nginx-Konfiguration hinzu.
von: https://github.com/webpack/webpack-dev-server/issues/854
Es hat bei mir nicht funktioniert, als ich versuchte, das Zertifikat in den Browser zu importieren ... Öffnen Sie in chrome Developer Tools> Security und wählen Sie Zertifikat anzeigen. Klicken Sie auf die Registerkarte Details und exportieren Sie sie.
// LINUX
Sudo apt-get install libnss3-tools
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n [EXPORTED_FILE_PATH] -i [EXPORTED_FILE_PATH]
Führen Sie diesen Befehl aus und wenn Sie die Datei sehen, die Sie gerade importiert haben, können Sie loslegen!
certutil -d sql:$HOME/.pki/nssdb -L
// Windows
Start => run => certmgr.msc
Wählen Sie auf der linken Seite Vertrauenswürdige Stammzertifizierungsstellen => Persönlich aus. Klicken Sie auf die Registerkarte "Aktionen" => "Alle Aktionen/Importieren" und wählen Sie die zuvor exportierte Datei aus dem Browser aus
Vergiss nicht, Chrome neu zu starten !!!
VIEL GLÜCK! ;)
Ich habe dieses Problem für mich behoben, ohne die Einstellungen in Browsern mit korrekten SSL-Zertifizierungen zu ändern. Ich benutze einen Mac, daher ist ein Schlüsselbund-Update für meine SSL-Zertifizierungen erforderlich. Ich musste der SSL-Zertifizierung Betreff-ALT-Namen hinzufügen, damit chrome sie akzeptierte. Ab heute gilt dies für die Chrome -Versionsnummer: 62.0.3202.94
Mein Beispiel sind einfach zu verwendende Befehle und Konfigurationsdateien:
fügen Sie diese Dateien hinzu, und dieses Beispiel befindet sich in einem Stammverzeichnis
ssl.conf
[ req ]
default_bits = 4096
distinguished_name = req_distinguished_name
req_extensions = req_ext
[ req_distinguished_name ]
countryName = Country Name (2 letter code)
stateOrProvinceName = State or Province Name (full name)
localityName = Locality Name (eg, city)
organizationName = Organization Name (eg, company)
commonName = Common Name (e.g. server FQDN or YOUR name)
commonName_max = 64
[ req_ext ]
subjectAltName = @alt_names
[alt_names]
DNS.1 = localhost
Führen Sie den Befehl aus, um eine Zertifizierung zu erstellen:
openssl req -newkey rsa:4096 -nodes -keyout key.pem -x509 -days 3650 -out certificate.pem -extensions req_ext -config ssl.conf -subj '/CN=localhost/O=Stackflow/C=US/L=Los Angeles/OU=StackflowTech'
Nur für Macs zum Hinzufügen einer vertrauenswürdigen Zertifizierung (erforderlich):
Sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ./certificate.pem
Für Windows müssen Sie herausfinden, wie Sie unsere SSL-Zertifikate lokal unabhängig überprüfen können. Ich benutze kein Windows. Sorry Windows Jungs und Mädels.
Ich verwende einen node.js-Server mit express.js, für den nur mein Schlüssel und die Zertifizierung erforderlich sind.
app.js
const https = require('https');
const Express = require('express');
const fs = require('fs');
const app = new Express();
const server = https.createServer({
key: fs.readFileSync('./key.pem'),
cert: fs.readFileSync('./certificate.pem'),
}, app);
server.listen(3000);
Möglicherweise mache ich dies in Zukunft für andere Backend-Frames, sodass ich dieses Beispiel in Zukunft für andere aktualisieren kann. Aber das war mein Fix in Node.js für dieses Problem. Löschen Sie den Browser-Cache und führen Sie Ihre App unter https: // aus.
Hier ist ein Beispiel für die Ausführung von https: // localhost auf einem Node.js-Server für Mac-Benutzer:
https://github.com/laynefaler/Stack-Overflow-running-HTTPS-localhost
Viel Spaß beim Codieren!
Für Chrome unter MacOS, wenn Sie ein Zertifikat vorbereitet haben:
Ich musste den Launcher Chrome unter MacOSX optimieren und das folgende Skript hinzufügen. Gespeichert wie unten;
/ Programme/Google\Chrome.app/Contents/MacOS/Chrome.command
#!/bin/sh
RealBin="Google Chrome"
AppDir="$(dirname "$0")"
exec "$AppDir/$RealBin" --ignore-certificate-errors "[email protected]"
Wenn ich Chrome mit diesem Skript starte, funktionieren selbstsignierte Zertifikate problemlos. Aber durchsuchen Sie das Internet nicht mit dem Browser, der mit diesem Skript gestartet wurde Sie werden nicht vor ungültigen Zertifikaten gewarnt!
mkdir CA
openssl genrsa -aes256 -out CA/rootCA.key 4096
openssl req -x509 -new -nodes -key CA/rootCA.key -sha256 -days 1024 -out CA/rootCA.crt
openssl req -new -nodes -keyout example.com.key -out domain.csr -days 3650 -subj "/C=US/L=Some/O=Acme, Inc./CN=example.com"
openssl x509 -req -days 3650 -sha256 -in domain.csr -CA CA/rootCA.crt -CAkey CA/rootCA.key -CAcreateserial -out example.com.crt -extensions v3_ca -extfile <(
cat <<-EOF
[ v3_ca ]
subjectAltName = DNS:example.com
EOF
)
Das hat bei mir funktioniert. Siehe: http://www.robpeck.com/2010/10/google-chrome-mac-os-x-and-self-signed-ssl-certificates/#.Vcy8_ZNVhBc
Klicken Sie in der Adressleiste auf das kleine Schloss mit dem X. Daraufhin wird ein kleiner Informationsbildschirm angezeigt. Klicken Sie auf die Schaltfläche "Zertifikatinformationen".
Klicken Sie auf das Bild und ziehen Sie es auf Ihren Desktop. Es sieht aus wie ein kleines Zertifikat.
Doppelklicken Sie darauf. Dadurch wird das Dienstprogramm für den Schlüsselbundzugriff aufgerufen. Geben Sie Ihr Passwort ein, um es zu entsperren.
Stellen Sie sicher, dass Sie das Zertifikat zum Systemschlüsselbund und nicht zum Anmeldeschlüsselbund hinzufügen. Klicken Sie auf "Immer vertrauen", obwohl dies nichts zu bewirken scheint.
Nachdem es hinzugefügt wurde, doppelklicken Sie darauf. Möglicherweise müssen Sie sich erneut authentifizieren.
Erweitern Sie den Abschnitt "Trust".
"Bei Verwendung dieses Zertifikats" auf "Immer vertrauen" setzen
Dies ist etwas, das immer wieder auftaucht - insbesondere für Google Chrome unter Mac OS X Yosemite!
Zum Glück hat mir heute einer unserer Entwickler diesen Link gesendet, und die Methode funktioniert zuverlässig, während Sie weiterhin steuern können, für welche Sites Sie Zertifikate akzeptieren.
jersully Beiträge:
Wenn Sie sich nicht um interne Zertifikate kümmern möchten ...
- Geben Sie
chrome://flags/
in die Adressleiste ein.- Scrollen Sie zu "Entscheidungen speichern" oder suchen Sie nach "Entscheidungen speichern", um SSL-Fehler für eine bestimmte Zeitspanne durchzuarbeiten.
- Wählen Sie Remember für drei Monate.
Um in Windows ein selbstsigniertes Zertifikat zu erstellen, dem Chrome v58 und höher vertraut, starten Sie Powershell mit erhöhten Berechtigungen und geben Sie Folgendes ein:
New-SelfSignedCertificate -CertStoreLocation Cert:\LocalMachine\My -Subject "fruity.local" -DnsName "fruity.local", "*.fruity.local" -FriendlyName "FruityCert" -NotAfter (Get-Date).AddYears(10)
#notes:
# -subject "*.fruity.local" = Sets the string subject name to the wildcard *.fruity.local
# -DnsName "fruity.local", "*.fruity.local"
# ^ Sets the subject alternative name to fruity.local, *.fruity.local. (Required by Chrome v58 and later)
# -NotAfter (Get-Date).AddYears(10) = make the certificate last 10 years. Note: only works from Windows Server 2016 / Windows 10 onwards!!
Sobald Sie dies tun, wird das Zertifikat in den Zertifikaten des lokalen Computers unter Personal\Certificates gespeichert.
Sie möchten dieses Zertifikat in den Speicher Vertrauenswürdige Stammzertifizierungsstellen\Zertifikate kopieren.
Eine Möglichkeit, dies zu tun: Klicken Sie auf die Windows-Startschaltfläche und geben Sie certlm.msc
ein. Ziehen Sie das neu erstellte Zertifikat per Drag & Drop in den Speicher Vertrauenswürdige Stammzertifizierungsstellen\Zertifikate (siehe Abbildung unten).
Was soll ich tun, damit Chrome das Zertifikat akzeptiert und sich nicht mehr darüber beschwert?
Sie sollten eine PKI mit erstellen;
1) Selbstsignierte Stammzertifizierungsstelle.
2) Unter-/Zwischenzertifikat [unterzeichnet von der Stammzertifizierungsstelle].
3) normales Zertifikat/Endentitätszertifikat [entweder von der Stammzertifizierungsstelle oder der Unterzertifizierungsstelle signiert] (commonName oder subjectAltName (SAN) als localhost) (einschließlich https: // localhost / als URI in SAN).
4) Importieren/Installieren Sie diese Stammzertifizierungsstelle in Ihrem Windows-Betriebssystem (weil Sie den IE erwähnt haben. Google Chrome verwendet die gleichen Ressourcen, während Sie nach Zertifikatsketten suchen - https: // www.chromium.org/Home/chromium-security/root-ca-policy ) als vertrauenswürdige Stammzertifizierungsstellen.
5) Installieren Sie dieses Endentitätszertifikat als Webserverzertifikat, und diese Fehlermeldung wird nicht mehr angezeigt.
Hoffe das hilft.
Ich hatte Erfolg nach der Antwort von kellen mit dem Vital pdate von Toby J , musste aber diese Überarbeitung vornehmen:
Beim Erstellen des selbstsignierten Zertifikats musste das neue Feld subjectAltName
unter den Erweiterungen v3_ca
anstelle von v3_req
platziert werden. Ich habe /etc/ssl/openssl.conf
in eine temporäre Datei kopiert und dann unter subjectAltName = DNS:*.example.com
eine Zeile [ v3_ca ]
eingefügt. Übergeben Sie diese Datei dann an den Befehl cert creation
openssl req -x509 -nodes -newkey rsa:2048 \
-config /tmp/openssl-revised.cfg \
-keyout example.com.key -out example.com.crt
und folgte kellen's aktualisierten Schritten.
Fix für Chrome unter Windows.
Zunächst müssen Sie das Zertifikat exportieren.
Importieren
Für Entwicklungszwecke unter Windows können Sie
zu Chrome Shortcut-Flag --ignore-certificate-errors
hinzufügen
Es wird erwartet, dass Zertifikatfehler ignoriert werden und Sie auf ungültige Zertifikatwebsites zugreifen können.
Bessere detaillierte Anweisungen in https://support.opendns.com/entries/66657664 .
Es trat das gleiche Problem auf: Ich hatte das Zertifikat im Speicher für vertrauenswürdige Stammzertifizierungsstellen von Windows installiert und Chrome lehnte das Zertifikat weiterhin mit dem Fehler ERR_CERT_COMMON_NAME_INVALID
ab. Beachten Sie, dass der Fehler ERR_CERT_AUTHORITY_INVALID
lautet, wenn das Zertifikat nicht ordnungsgemäß im Speicher installiert ist.
Wie der Name des Fehlers, dieser Kommentar und diese Frage andeutet, lag das Problem im deklarierten Domänennamen im Zertifikat. Als ich beim Generieren des Zertifikats zur Eingabe des "Common Name" aufgefordert wurde, musste ich den Domain-Namen eingeben , mit dem ich auf die Site zugegriffen habe (localhost
in meinem Fall). Ich habe Chrome mit chrome://restart
neu gestartet und war schließlich mit diesem neuen Zertifikat zufrieden.
SSL/HTTPS localhost fix auf dem Mac/osx:
Klicken Sie auf das rote Schloss mit dem Kreuz in Ihrer Adressleiste, wenn Sie versuchen, Ihre https localhost-Umgebung zu öffnen. Es öffnet sich ein Fenster mit Informationen zum Zertifikat.
Klicken Sie auf "Details" Informationsfenster
Fügen Sie es Ihrem "System" -Schlüsselbund hinzu (nicht Ihrem "Login" -Schlüsselbund, der standardmäßig ausgewählt ist).
Öffnen Sie Ihren Schlüsselbund (erneut) und suchen Sie das Zertifikat. Klicken Sie darauf und stellen Sie sicher, dass Sie allen vertrauen.
Starten Sie chrome neu und es sollte funktionieren.
Filippo Valsorda hat das plattformübergreifende Tool mkcert
für lots von Trust Stores geschrieben. Ich nehme an, er hat es aus demselben Grund geschrieben, weil es so viele Antworten auf diese Frage gibt: Es ist mühsam, das "Richtige" für SubjectAltName-Zertifikate zu tun, die von einer vertrauenswürdigen Stammzertifizierungsstelle signiert wurden.
mkcert
ist in den wichtigsten Paketverwaltungssystemen für Windows, macOS und verschiedene Linux-Versionen enthalten.
mkcert
mkcert
ist ein einfaches Tool zum Erstellen von lokal vertrauenswürdigen Entwicklungszertifikaten. Es ist keine Konfiguration erforderlich.$ mkcert -install Created a new local CA at "/Users/filippo/Library/Application Support/mkcert" ???? The local CA is now installed in the system trust store! ⚡️ The local CA is now installed in the Firefox trust store (requires browser restart)! ???? $ mkcert example.com "*.example.com" example.test localhost 127.0.0.1 ::1 Using the local CA at "/Users/filippo/Library/Application Support/mkcert" ✨ Created a new certificate valid for the following names ???? - "example.com" - "*.example.com" - "example.test" - "localhost" - "127.0.0.1" - "::1" The certificate is at "./example.com+5.pem" and the key at "./example.com+5-key.pem" ✅
Meine Lösung und Erklärung:
Ich hatte ein selbstsigniertes Zertifikat, das mit dem Resource Kit-Tool IIS erstellt wurde SelfSSL.exe . In den Zertifikatslisten auf meinem lokalen Computer habe ich festgestellt, dass dieses selbstsignierte Zertifikat nur einen Zweck hat : Serverauthentifizierung . Daher habe ich für beide Zwecke ein neues selbstsigniertes Zertifikat erstellt: Serverauthentifizierung und Clientauthentifizierung . Und jetzt beschwert sich Chrome nicht mehr.
Dieser Artikel zeigt viele Möglichkeiten, um selbstsignierte Zertifikate zu generieren. Beachten Sie, dass Sie nicht bei allen Optionen den Zweck des Zertifikats angeben können. Ich habe die PowerShell-Methode verwendet:
$cert = New-SelfSignedCertificate -certstorelocation cert:\localmachine\my -dnsname company.co.nz
Hinweis: Wie in diesem Antwort von kellen Chrome angegeben, können Sie die Verwendungszwecke für Zertifikate festlegen. Allerdings kann IMO keinen neuen Verwendungszweck für ein Zertifikat hinzufügen, wenn das letzte Zertifikat nicht mit einem solchen erstellt wurde im Kopf.
Keine der obigen Antworten hat mir unter Windows 10 beim Testen vor Ort geholfen
https://localhost:<port>
.
Allerdings habe ich diese Seite gefunden, auf der eine andere Flagge angezeigt wird:
https://www.chromium.org/blink/serviceworker/service-worker-faq
Wenn Sie mit einem selbstsignierten Zertifikat auf https: // localhost testen möchten, gehen Sie wie folgt vor:
$ ./chrome --allow-insecure-localhost https: // localhost
Damit wurde die rote Warnung nicht beseitigt, aber ich konnte nur https-fähige Funktionen wie Servicemitarbeiter und Web-Push-Benachrichtigungen verwenden.
Hier ist eine Lösung, die nur Java 8 keytool.exe anstelle von openssl verwendet:
@echo off
set PWD=changeit
set DNSNAME=%COMPUTERNAME%
echo create ca key
keytool -genkeypair -alias ca -keystore test.jks -keyalg RSA -validity 3650 -ext bc:critical=ca:true -dname "CN=CA" -storepass:env PWD -keypass:env PWD
echo generate cert request for ca signing
keytool -certreq -keystore test.jks -storepass:env PWD -alias ca -file ca.csr -ext bc:critical=ca:true
echo generate signed cert
keytool -gencert -keystore test.jks -storepass:env PWD -alias ca -infile ca.csr -outfile ca.cer -validity 3650 -ext bc:critical=ca:true
echo CA created. Import ca.cer in windows and firefox' certificate store as "Trusted CA".
pause
echo create server cert key for %DNSNAME%
keytool -genkeypair -alias leaf -keystore test.jks -keyalg RSA -validity 3650 -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1 -dname "CN=Leaf" -storepass:env PWD -keypass:env PWD
echo generate cert request
keytool -certreq -keystore test.jks -storepass:env PWD -alias leaf -file leaf.csr -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1
echo generate signed cert
keytool -gencert -keystore test.jks -storepass:env PWD -alias ca -infile leaf.csr -outfile leaf.cer -validity 3650 -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1
rem see content
rem keytool -printcert -file leaf.cer -storepass:env PWD
echo install in orig keystore
keytool -importcert -keystore test.jks -storepass:env PWD -file leaf.cer -alias leaf
echo content of test.jks:
keytool -list -v -storepass:env PWD -keystore test.jks
pause
Sie können auch Pipes anstelle von Dateien verwenden, aber mit den Dateien können Sie die Zwischenergebnisse überprüfen, wenn etwas schief geht. SSL getestet mit IE11, Edge, FF54, Chrome60 unter Windows und Chrome60 unter Android.
Bitte ändern Sie das Standardkennwort, bevor Sie das Skript verwenden.