Ich habe ein selbstsigniertes SSL-Zertifikat für den localhost CN erstellt. Firefox akzeptiert dieses Zertifikat, nachdem es sich erwartungsgemäß zunächst darüber beschwert hat. Chrome und IE lehnen es jedoch ab, es zu akzeptieren, selbst nachdem das Zertifikat dem Systemzertifikatsspeicher unter Vertrauenswürdige Wurzeln 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 dem Zertifikat nicht vertraut werden kann.

Was soll ich tun, damit Chrome das Zertifikat akzeptiert und sich nicht mehr darüber beschwert?

2020-05-22 : Mit nur 6 Shell-Befehlen können Sie dies erreichen.

Bitte ändern Sie nicht die Sicherheitseinstellungen Ihres Browsers.

Mit dem folgenden Code können Sie (1) Ihre eigene Zertifizierungsstelle werden, (2) dann Ihr SSL-Zertifikat als Zertifizierungsstelle signieren. (3) Importieren Sie anschließend das CA-Zertifikat (nicht das SSL-Zertifikat, das auf Ihren Server übertragen wird) in Chrome / Chromium. (Ja, das funktioniert sogar unter Linux.)

######################
# Become a Certificate Authority
######################

# Generate private key
openssl genrsa -des3 -out myCA.key 2048
# Generate root certificate
openssl req -x509 -new -nodes -key myCA.key -sha256 -days 825 -out myCA.pem

######################
# Create CA-signed certs
######################

NAME=mydomain.com # Use your own domain name
# Generate a private key
openssl genrsa -out $NAME.key 2048
# Create a certificate-signing request
openssl req -new -key $NAME.key -out $NAME.csr
# Create a config file for the extensions
>$NAME.ext cat <<-EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = $NAME # Be sure to include the domain name here because Common Name is not so commonly honoured by itself
DNS.2 = bar.$NAME # Optionally, add additional domains (I've added a subdomain here)
IP.1 = 192.168.0.13 # Optionally, add an IP address (if the connection which you have planned requires it)
EOF
# Create the signed certificate
openssl x509 -req -in $NAME.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial \
-out $NAME.crt -days 825 -sha256 -extfile $NAME.ext

Um es noch einmal zusammenzufassen:

1. Werden Sie CA
2. Signieren Sie Ihr Zertifikat mit Ihrem CA-Schlüssel
3. Import myCA.pemals Autorität in Ihren Chrome - Einstellungen (Settings> Zertifikate verwalten> Behörden> Import)
4. Verwenden Sie die .crtDatei auf Ihrem Server

Zusätzliche Schritte (zumindest für Mac):

1. Importieren Sie das CA-Zertifikat unter "Datei> Datei importieren", suchen Sie es dann auch in der Liste, klicken Sie mit der rechten Maustaste darauf, erweitern Sie "> Vertrauen" und wählen Sie "Immer".
2. Fügen Sie extendedKeyUsage=serverAuth,clientAuthunten hinzu basicConstraints=CA:FALSE, und stellen Sie sicher, dass Sie den "CommonName" auf den gleichen Wert einstellen, als $NAMEwenn Sie nach dem Setup fragen

Sie können Ihre Arbeit überprüfen

openssl verify -CAfile myCA.pem -verify_hostname bar.mydomain.com mydomain.com.crt

Für localhostnur:

Fügen Sie dies einfach in Ihr Chrom ein:

chrome://flags/#allow-insecure-localhost

Sie sollten einen hervorgehobenen Text sehen, der besagt: Zulassen ungültiger Zertifikate für Ressourcen, die von localhost geladen werden

Klicken Sie auf Enable.

Das hat bei mir funktioniert:

1. Klicken Sie mit Chrome über HTTPS auf eine Seite auf Ihrem Server und fahren Sie mit der roten Warnseite fort (vorausgesetzt, Sie haben dies noch nicht getan).
2. Öffne dich Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
3. Klicken Sie auf die AuthoritiesRegisterkarte und scrollen Sie nach unten, um Ihr Zertifikat unter dem Organisationsnamen zu finden, den Sie dem Zertifikat gegeben haben.
4. Wählen Sie es aus, klicken Sie auf Bearbeiten ( HINWEIS : In neueren Versionen von Chrome lautet die Schaltfläche jetzt "Erweitert" anstelle von "Bearbeiten"), aktivieren Sie alle Kontrollkästchen und klicken Sie auf "OK". Möglicherweise müssen Sie Chrome neu starten.

Sie sollten jetzt das schöne grüne Schloss auf Ihren Seiten erhalten.

BEARBEITEN: Ich habe dies auf einem neuen Computer erneut versucht und das Zertifikat wurde nicht im Fenster "Zertifikate verwalten" angezeigt, indem ich einfach von der roten Seite "Nicht vertrauenswürdiges Zertifikat" fortfuhr. Ich musste folgendes tun:

1. https://Klicken Sie auf der Seite mit dem nicht vertrauenswürdigen Zertifikat ( rot durchgestrichen) auf die Sperre> Zertifikatinformationen. HINWEIS: Bei neueren Chrome-Versionen müssen Sie öffnen Developer Tools > Securityund auswählen View certificate.
2. Klicken Sie auf die Details tab > Export. Wählen Sie PKCS #7, single certificateals Dateiformat.
3. Folgen Sie dann meinen ursprünglichen Anweisungen, um zur Seite Zertifikate verwalten zu gelangen. Klicken Sie auf Authorities tab > Importund wählen Sie die Datei aus, in die Sie das Zertifikat exportiert haben, und stellen Sie sicher, dass Sie PKCS #7, single certificate den Dateityp auswählen .
4. Wenn Sie zum Zertifizierungsspeicher aufgefordert werden, wählen Sie Vertrauenswürdige Stammzertifizierungsstellen
5. Aktivieren Sie alle Kontrollkästchen und klicken Sie auf OK. Starten Sie Chrome neu.

UPDATE FÜR CHROM 58+ (VERÖFFENTLICHT 19.04.2017)

Ab Chrome 58 wurde die Möglichkeit, den Host nur mit zu identifizieren, commonName entfernt . Zertifikate müssen jetzt verwendet werden subjectAltName, um ihre Hosts zu identifizieren. Weitere Diskussionen finden Sie hier und Bug Tracker hier . In der Vergangenheit subjectAltNamewurde es nur für Multi-Host-Zertifikate verwendet, sodass einige interne CA-Tools diese nicht enthalten.

Wenn Ihre selbstsignierten Zertifikate in der Vergangenheit einwandfrei funktionierten, aber plötzlich Fehler in Chrome 58 generierten, ist dies der Grund.

Unabhängig davon, mit welcher Methode Sie Ihr selbstsigniertes Zertifikat (oder das von einer selbstsignierten Zertifizierungsstelle signierte Zertifikat) generieren, stellen Sie sicher, dass das Serverzertifikat ein subjectAltNamemit dem richtigen DNSund / oder IPEintrag / Einträgen enthält, auch wenn es nur für einen einzelnen Host gilt .

Für openssl bedeutet dies, dass Ihre OpenSSL-Konfiguration ( /etc/ssl/openssl.cnfunter Ubuntu) für einen einzelnen Host 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 (die Registerkarte „Sicherheit“ unter F12 bewegt hat) sollten Sie es sehen unter aufgeführt Extensionsals Certificate Subject Alternative Name:

Auf dem Mac können Sie das Dienstprogramm "Schlüsselbundzugriff" verwenden, um das selbstsignierte Zertifikat zum Systemschlüsselbund hinzuzufügen. Chrome akzeptiert es dann. Ich habe die Schritt-für-Schritt-Anleitung hier gefunden:

Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate

Grundsätzlich:

1. Doppelklicken Sie auf das Schlosssymbol mit einem X und ziehen Sie das Zertifikatsymbol per Drag & Drop auf den Desktop.
2. Öffnen Sie diese Datei (endet mit der Erweiterung .cer). Dadurch wird die Schlüsselbundanwendung geöffnet, mit der Sie das Zertifikat genehmigen können.

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" funktionierte früher in früheren Versionen von Chrome

Sie müssen nicht nach einem Eingabefeld suchen, sondern geben es einfach ein. Es fühlt sich seltsam an, aber es funktioniert.

Ich habe es auf Mac High Sierra versucht.

Um zu überprüfen, ob sie es erneut geändert haben, gehen Sie zu Neuester 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 die folgende Zeile in einer Browserkonsole ausführen.

console.log(window.atob('dGhpc2lzdW5zYWZl'));

Linux

Wenn Sie Linux verwenden, können Sie auch diesen offiziellen Wiki-Seiten folgen:

• Konfigurieren von SSL-Zertifikaten unter Linux.
• NSS Shared DB und LINUX
• NSS Shared DB Howto

Grundsätzlich:

• Klicken Sie auf das Schlosssymbol mit einem X,
• Wählen Sie Zertifikatinformationen
• Gehen Sie zur Registerkarte Details
• Klicken Sie auf Exportieren ... (als Datei speichern)

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, sind Sie möglicherweise von diesem Fehler betroffen: Problem 55050: Ubuntu SSL-Fehler 8179

PS Bitte stellen Sie auch sicher, dass Sie haben libnss3-tools, 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]

Fehlerbehebung

• Führen Sie Chrome mit dem --auto-ssl-client-authParameter aus

  google-chrome --auto-ssl-client-auth

Auf dem Mac können Sie ein Zertifikat erstellen, dem Chrome und Safari auf Systemebene voll 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

In den obigen Abschnitten werden die folgenden Skripts und eine unterstützende Datei verwendet v3.ext, um zu vermeiden , dass beim alternativen Namen des Betreffs Fehler fehlen

Wenn Sie ein neues selbstsigniertes Zertifikat erstellen möchten, das mit Ihrer eigenen Root-Berechtigung vollständig vertrauenswürdig ist, können Sie dies mithilfe dieser Skripts tun.

create_root_cert_and_key.sh

    #!/usr/bin/env bash
    openssl genrsa -out rootCA.key 2048
    openssl req -x509 -new -nodes -key rootCA.key -sha256 -days 1024 -out rootCA.pem

create_certificate_for_domain.sh

    #!/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=825
    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"

v3.ext

    authorityKeyIdentifier=keyid,issuer
    basicConstraints=CA:FALSE
    keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
    subjectAltName = @alt_names

    [alt_names]
    DNS.1 = %%DOMAIN%%

Noch ein Schritt - So machen Sie die selbstsignierten Zertifikate in Chrome / Safari vollständig vertrauenswürdig

Damit die selbstsignierten Zertifikate in Chrome und Safari VOLLSTÄNDIG vertrauenswürdig sind, 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 mit diesem Befehl tun, der Sie zur Eingabe Ihres Kennworts auffordert:

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

oder mit der Keychain AccessApp:

1. Öffnen Sie den Schlüsselbundzugriff
2. Wählen Sie "System" in der Liste "Schlüsselanhänger"
3. Wählen Sie "Zertifikate" in der Liste "Kategorie"
4. Wählen Sie "Datei | Elemente importieren ..."
5. Navigieren Sie zu der oben erstellten Datei "rootCA.pem", wählen Sie sie aus und klicken Sie auf "Öffnen".
6. Wählen Sie Ihr neu importiertes Zertifikat in der Liste "Zertifikate" aus.
7. Klicken Sie auf die Schaltfläche "i" oder klicken Sie mit der rechten Maustaste auf Ihr Zertifikat und wählen Sie "Get Info".
8. Erweitern Sie die Option "Vertrauen"
9. Ändern Sie "Bei Verwendung dieses Zertifikats" in "Immer vertrauen".
10. Schließen Sie den Dialog und Sie werden aufgefordert, Ihr Passwort einzugeben.
11. Schließen Sie alle Registerkarten, die Ihre Zieldomäne verwenden, und öffnen Sie sie erneut. Sie werden dann sicher geladen!

Wenn Sie Java-Clients benötigen, um den Zertifikaten zu vertrauen, können Sie dies als Bonus tun, indem Sie Ihre Zertifikate in den Java-Keystore importieren. Beachten Sie, dass dadurch das Zertifikat aus dem Keystore entfernt wird, falls es bereits vorhanden ist, da es aktualisiert werden muss, falls sich etwas ändert. Dies gilt natürlich nur für die importierten Zertifikate.

import_certs_in_current_folder_into_java_keystore.sh

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

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 .

1. Klicken Sie auf der Site, die Sie hinzufügen möchten, mit der rechten Maustaste auf das rote Schlosssymbol in der Adressleiste:

   2. Klicken Sie auf die Registerkarte Verbindung und dann auf Zertifikatinformationen

   3. Klicken Sie auf die Details der Registerkarte, klicken Sie auf die die Schaltfläche In Datei kopieren ... . Dadurch wird der Zertifikatsexport-Assistent geöffnet. Klicken Sie auf Weiter , um zum Bildschirm Dateiformat exportieren zu gelangen .

   4. Wählen Sie DER-codiertes binäres X.509 (.CER) und klicken Sie auf Weiter

   5. 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 .

   6. Öffnen Sie die Chrome-Einstellungen, scrollen Sie nach unten und klicken Sie auf Erweiterte Einstellungen anzeigen ...

   7. Klicken Sie unter HTTPS / SSL auf Zertifikate verwalten ...

   8. 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 .

   9. Klicken Sie auf Durchsuchen ... und wählen Sie die zuvor gespeicherte Zertifikatdatei aus. Klicken Sie dann auf Weiter .

   10. Wählen Sie Alle Zertifikate in den folgenden Speicher legen . Das ausgewählte Geschäft sollte Trusted Root Certification Authorities sein . Wenn dies nicht der Fall ist, klicken Sie auf Durchsuchen ... und wählen Sie es aus. Klicken Sie auf Weiter und Fertig stellen

   11. Klicken Sie in der Sicherheitswarnung auf Ja .

   12. Starten Sie Chrome neu.

Wenn Sie auf einem Mac arbeiten und die Registerkarte "Exportieren" nicht sehen oder nicht wissen, wie Sie das Zertifikat erhalten, hat dies für mich funktioniert:

1. Klicken Sie auf das Schloss vor dem https: //
2. Gehen Sie zur Registerkarte "Verbindung"

3. Klicken Sie auf "Zertifikatinformationen".

   Jetzt sollten Sie Folgendes sehen:

4. Ziehen Sie das kleine Zertifikatsymbol auf Ihren Desktop (oder irgendwo anders).

5. Doppelklicken Sie auf die heruntergeladene CER-Datei. Dadurch sollte sie in Ihren Schlüsselbund importiert und der Schlüsselbundzugriff auf Ihre Zertifikatsliste geöffnet werden.

   In einigen Fällen reicht dies aus und Sie können die Seite jetzt aktualisieren.

   Andernfalls:

6. Doppelklicken Sie auf das neu hinzugefügte Zertifikat.
7. Ändern Sie in der Dropdown-Liste "Vertrauen" die Option "Bei Verwendung dieses Zertifikats" in "Immer vertrauen".

Laden Sie nun die betreffende Seite neu und das Problem sollte gelöst sein! Hoffe das hilft.

Bearbeiten von Wolph

Um dies ein wenig zu vereinfachen, können Sie das folgende Skript ( Quelle ) verwenden:

1. 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

2. Machen Sie das Skript ausführbar (aus der Shell):

   chmod +x whitelist_ssl_certificate.ssh

3. Führen Sie das Skript für die gewünschte Domain aus (kopieren / Einfügen der vollständigen URL funktioniert einfach):

   ./whitelist_ssl_certificate.ssh https://your_website/whatever

AKTUALISIERT 23. April 2020

Empfohlen vom Chromium-Team

https://www.chromium.org/Home/chromium-security/deprecating-powerful-features-on-insecure-origins#TOC-Testing-Powerful-Features

Schnelle super-einfache Lösung

Es gibt eine geheime Umgehungsphrase, die in die Fehlerseite eingegeben werden kann, damit Chrome trotz des Sicherheitsfehlers fortfährt : thisisunsafe (in früheren Versionen von Chrome geben Sie badidea und noch früher die Gefahr ein ). DO NOT USE THIS SOFERN SIE ERKENNEN genau , warum Sie es brauchen!

Quelle:

https://chromium.googlesource.com/chromium/src/+/d8fc089b62cd4f8d907acff6fb3f5ff58f168697%5E%21/

(HINWEIS, der window.atob('dGhpc2lzdW5zYWZl')in aufgelöst wird thisisunsafe)

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 window.atobFunktion kann in ausgeführt werden eine JS-Konsole.

Hintergrundinformationen dazu, warum das Chrome-Team die Umgehungsphrase (zum ersten Mal) geändert hat:

https://bugs.chromium.org/p/chromium/issues/detail?id=581189

Wenn alles andere fehlschlägt (Lösung 1)

Für schnelle Einzelstücke, wenn die Option "Trotzdem fortfahren" nicht verfügbar ist oder die Bypass-Phrase funktioniert, funktioniert dieser Hack gut:

1. Zulassen von Zertifikatfehlern localhostdurch 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)

2. Wenn die Site, zu der Sie eine Verbindung herstellen möchten, localhostfertig ist , sind Sie fertig. Andernfalls richten Sie einen TCP-Tunnel ein, um Port 8090 lokal abzuhören und eine Verbindung zu broken-remote-site.comPort 443 herzustellen. Stellen Sie sicher, dass Sie socatFolgendes in einem Terminalfenster installiert und ausgeführt haben:

   socat tcp-listen:8090,reuseaddr,fork tcp:broken-remote-site.com:443

3. Gehen Sie in Ihrem Browser zu https: // localhost: 8090 .

Wenn alles andere fehlschlägt (Lösung 2)

Ähnlich wie bei "Wenn alles andere fehlschlägt (Lösung 1)" konfigurieren wir hier einen Proxy für unseren lokalen Dienst mit ngrok . Da Sie entweder über TLS (in diesem Fall wird es von ngrok mit einem gültigen Zertifikat beendet) oder über einen Nicht-TLS-Endpunkt auf ngrok-http-Tunnel zugreifen können, beschwert sich der Browser nicht über ungültige Zertifikate.

Laden Sie ngrok herunter, installieren Sie es und stellen Sie es dann zur Verfügung über ngrok.io:

ngrok http https://localhost

ngrok wird gestartet und gibt Ihnen einen Hostnamen, mit dem Sie eine Verbindung herstellen können, und alle Anforderungen werden zurück auf Ihren lokalen Computer getunnelt.

Für eine Testumgebung

Sie können es --ignore-certificate-errorsals Befehlszeilenparameter verwenden, wenn Sie Chrome starten (Arbeiten an Version 28.0.1500.52 unter Ubuntu).

Dadurch werden die Fehler ignoriert und die Verbindung ohne Vorwarnung hergestellt. Wenn bereits eine Chrome-Version ausgeführt wird, müssen Sie diese vor dem Neustart über die Befehlszeile schließen. 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 über gültige Zertifikate verfügen.

Ich würde ein normales Surfen wie dieses nicht empfehlen, da Zertifikatprüfungen ein wichtiges Sicherheitsmerkmal sind, aber dies kann 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 der Antwort von @Brad Parks. Unter Windows sollten Sie rootCA.pem in den Trusted Root Certificates Authorities Store 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

Wo 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 zum privaten Schlüssel 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 / entfernen / Zertifikate / Konto hinzufügen / Computert / LocalComputer / OK) habe ich die pfx-Datei in den Personal Store 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 verschiedenen Arten in vertrauenswürdige Stammzertifizierungsstellen zu importieren, aber es wird immer noch der gleiche Fehler angezeigt:

Aber mir wurde klar, dass ich ein Zertifikat der Stammautorität importieren sollte, kein Zertifikat für die Domäne. Also habe ich die mmc-Konsole verwendet (Datei / Snap-Ins hinzufügen oder entfernen / Zertifikate / Konto hinzufügen / Computert / LocalComputer / OK). Ich habe rootCA.pem in den Trusted Root Certificates Authorities Store importiert.

Starten Sie Chrome neu und es funktioniert.

Mit localhost:

Oder mit IP-Adresse:

Das einzige, was ich nicht erreichen konnte, ist, dass es eine 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.

1. Fügen Sie das CA-Zertifikat im vertrauenswürdigen Stamm-CA-Speicher hinzu.

2. Gehe zu Chrome und aktiviere diese Flagge!

chrome://flags/#allow-insecure-localhost

Verwenden Sie zum Schluss einfach die * .me-Domain oder gültige Domains wie * .com und * .net und pflegen Sie diese in der Hostdatei. Für meine lokalen Entwickler verwende ich * .me oder * .com mit einer Hostdatei, die wie folgt verwaltet wird:

3. Zum Host hinzufügen. C: / windows / system32 / drivers / etc / hosts

   127.0.0.1 nextwebapp.me

Hinweis: Wenn der Browser dabei bereits geöffnet ist, wird der Fehler weiterhin angezeigt. Schließen Sie also bitte den Browser und starten Sie erneut. Besser noch, gehen Sie inkognito oder starten Sie eine neue Sitzung für sofortige Wirkung.

Sind Sie sicher, dass die Adresse, auf der die Site bereitgestellt wird, mit dem Zertifikat übereinstimmt? Ich hatte die gleichen Probleme mit Chrome und einem selbstsignierten Zertifikat, aber am Ende fand ich, dass die Validierung des Domainnamens auf dem Zertifikat (wie es sein sollte) unglaublich wählerisch war.

Chrome hat keinen eigenen Zertifikatspeicher und verwendet den eigenen von Windows. Chrome bietet jedoch keine Möglichkeit, Zertifikate in den Store zu importieren. Sie sollten sie stattdessen über den Internet Explorer hinzufügen.

Installieren von Zertifikaten in Google Chrome

Installieren von Zertifikaten in Internet Explorer

Schauen Sie sich auch einige verschiedene Ansätze zum Erstellen selbstsignierter Zertifikate an (ich gehe davon aus, dass Sie IIS verwenden, wie Sie nicht erwähnt haben).

So erstellen Sie ein selbstsigniertes Zertifikat in IIS 7

Ich habe den von bjnord vorgeschlagenen Prozess durchlaufen: Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate

Was im Blog gezeigt wird, hat nicht funktioniert.

Einer der Kommentare zum 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 zu erfahren, wie Sie die Zertifizierungsdatei erhalten. Danach können Sie den obigen Befehl verwenden und sollten bereit sein.

Die GUI zum Verwalten von SSL-Zertifikaten unter Chromium unter Linux funktionierte bei mir NICHT richtig. Ihre Dokumente gaben jedoch die richtige Antwort. Der Trick bestand darin, den folgenden Befehl auszuführen, der das selbstsignierte SSL-Zertifikat importiert. Aktualisieren Sie einfach den Namen des <certificate-nickname>und certificate-filename.cerund starten Sie Chrom / Chrom 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 nssPräfix starten , z nsscertutil. B. ) Öffnet: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

Listen Sie alle Zertifikate auf

certutil -d sql:$HOME/.pki/nssdb -L

Die TRUSTARGS sind drei Zeichenfolgen mit null oder mehr alphabetischen Zeichen, die durch Kommas getrennt sind. Sie definieren, wie dem Zertifikat für SSL-, E-Mail- und Objektsignaturen vertraut werden soll, und werden in den certutil-Dokumenten oder in Meenas Blogbeitrag zu Vertrauensflags erläutert.

Hinzufügen eines persönlichen Zertifikats und eines privaten Schlüssels für die SSL-Clientauthentifizierung Verwenden Sie den folgenden Befehl:

pk12util -d sql:$HOME/.pki/nssdb -i PKCS12_file.p12

Importieren eines persönlichen Zertifikats und eines privaten Schlüssels, die in einer PKCS # 12-Datei gespeichert sind. Die TRUSTARGS des persönlichen Zertifikats werden auf "u, u, u" gesetzt.

Löschen Sie ein Zertifikat certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>

Auszug aus: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md

Filippo Valsorda hat ein plattformübergreifendes Tool geschrieben, mkcertum dies für viele Trust Stores zu tun . Ich nehme an, er hat es aus dem gleichen Grund geschrieben, aus dem 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-Varianten enthalten.

mkcert

mkcertist ein einfaches Tool zum Erstellen lokal vertrauenswürdiger Entwicklungszertifikate. 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" ✅

Wenn Sie auf das kleine durchgestrichene Schlosssymbol neben der URL klicken, wird folgende Box angezeigt:

Nach dem Klicken auf die Link Zertifikatinformationen , wird der folgende Dialog angezeigt:

Hier erfahren Sie, welcher Zertifikatspeicher der richtige ist. Es handelt sich um den Speicher für vertrauenswürdige Stammzertifizierungsstellen .

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.

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. Dadurch 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 hinzufügen, nicht zum Anmeldeschlüsselbund. Klicken Sie auf "Immer vertrauen", obwohl dies anscheinend nichts bewirkt.

Doppelklicken Sie nach dem Hinzufügen darauf. Möglicherweise müssen Sie sich erneut authentifizieren.

Erweitern Sie den Abschnitt "Vertrauen".

"Wenn Sie dieses Zertifikat verwenden", setzen Sie es auf "Immer vertrauen".

Ich habe alles versucht und was hat es funktioniert: Wählen Sie beim Importieren die richtige Kategorie aus, nämlich Trusted Root Certificate Authorities :

(Entschuldigung, es ist deutsch, aber folge einfach dem Bild)

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
)

Dieser Beitrag ist bereits mit Antworten überflutet, aber ich habe ein Bash-Skript basierend auf einigen anderen Antworten erstellt, um das Generieren eines in Chrome gültigen selbstsignierten TLS-Zertifikats (getestet in Chrome 65.x) zu vereinfachen . Hoffe, es ist nützlich für andere.

selbstsigniertes-tls-Bash-Skript

Vergessen Sie nach der Installation ( und dem Vertrauen ) des Zertifikats nicht, Chrome ( chrome://restart) neu zu starten.

Ein weiteres Tool, das einen Besuch wert ist, ist das CloudFlare- cfsslToolkit:

cfssl

Starten Sie Powershell mit erhöhten Berechtigungen und geben Sie Folgendes ein, um in Windows ein selbstsigniertes Zertifikat zu erstellen, dem Chrome v58 und höher vertraut.

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 getan haben, wird das Zertifikat auf den lokalen Computerzertifikaten im Speicher Personal \ Certificates gespeichert.

Sie möchten dieses Zertifikat in den Speicher Trusted Root Certification Authorities \ Certificates kopieren .

Eine Möglichkeit, dies zu tun: Klicken Sie auf die Windows-Startschaltfläche und geben Sie ein certlm.msc. Ziehen Sie das neu erstellte Zertifikat dann per Drag & Drop in den Speicher für vertrauenswürdige Stammzertifizierungsstellen \ Zertifikate ( siehe Abbildung unten).

SSL / HTTPS localhost Fix auf dem Mac / OSX:

1. 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 einigen Informationen zum Zertifikat.

2. Klicken Sie auf das Informationsfenster "Details"

3. Die Chrome Developer Tools werden auf der Registerkarte "Sicherheit" geöffnet. Klicken Sie auf Zertifikat anzeigen . Das Zertifikatbild

4. Fügen Sie es Ihrem 'System'-Schlüsselbund hinzu (nicht Ihrem' Login'-Schlüsselbund, der standardmäßig ausgewählt ist).

5. Öffnen Sie Ihren Schlüsselbund (erneut) und suchen Sie das Zertifikat. Klicken Sie darauf und stellen Sie sicher, dass Sie allen "vertrauen".

6. Starten Sie Chrome neu und es sollte funktionieren.

Ich hatte das gleiche Problem: Ich hatte das Zertifikat im Windows Trusted Root Authorities Store installiert, und Chrome lehnte das Zertifikat mit dem Fehler weiterhin ab ERR_CERT_COMMON_NAME_INVALID. Beachten Sie, dass der Fehler auftritt, wenn das Zertifikat nicht ordnungsgemäß im Store installiert istERR_CERT_AUTHORITY_INVALID .

Wie der Name des Fehlers, dieser Kommentar und diese Frage andeuten , 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 Domainnamen eingeben, den ich für den Zugriff auf die Site verwendet habe ( localhostin meinem Fall). Ich habe Chrome mit neu gestartet chrome://restartund es war endlich zufrieden mit diesem neuen Zertifikat.

Ab Chrome 58+ wurde unter macOS ein Zertifikatfehler angezeigt, da das SAN fehlte. Hier erfahren Sie, wie Sie das grüne Schloss in der Adressleiste wieder aktivieren.

1. 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

2. Importieren Sie das server.crtin Ihre KeyChain, doppelklicken Sie dann in 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 verfügbar ist.

Wenn Sie für Chrome unter MacOS ein Zertifikat vorbereitet haben:

• Beenden Sie Chrome ( cmd+ Q).
• Starten Sie die Keychain Access-App und öffnen Sie die Kategorie "Zertifikate".
• Ziehen Sie Ihre Zertifikatdatei in das Fenster Schlüsselbundzugriff und geben Sie das Kennwort für die Zertifikatdatei ein.
• Doppelklicken Sie auf Ihr Zertifikat und öffnen Sie die Liste "Vertrauen".
  • Wählen Sie in Zeile "Bei Verwendung dieses Zertifikats" die Option "Immer vertrauen".
  • Schließen Sie dieses Zeug und geben Sie Ihr Passwort ein.
• Starten Sie Chrome und löschen Sie alle Caches.
• Überprüfen Sie, ob alles in Ordnung ist.

Das Erlauben von unsicherem localhost funktioniert einwandfrei über diese Methode chrome: // flags / # allow-unsicheres-localhost

Nur dass Sie Ihren Entwicklungshostnamen für xxx.localhost erstellen müssen.