Ho creato un certificato SSL autofirmato per il CN localhost. Firefox accetta questo certificato dopo essersi inizialmente lamentato, come previsto. Chrome e IE, tuttavia, si rifiutano di accettarlo, anche dopo aver aggiunto il certificato all'archivio certificati di sistema in Trusted Roots. Anche se il certificato è elencato come installato correttamente quando faccio clic su "Visualizza informazioni sul certificato" nel popup HTTPS di Chrome, insiste sul fatto che il certificato non può essere considerato attendibile.

Che cosa dovrei fare per far accettare a Chrome il certificato e smettere di lamentarmi?

2020-05-22 : Con solo 6 comandi shell , puoi farlo.

Si prega di non modificare le impostazioni di sicurezza del browser.

Con il codice seguente, è possibile (1) diventare la propria CA, (2) quindi firmare il certificato SSL come CA. (3) Quindi importare il certificato CA (non il certificato SSL, che va sul server) in Chrome / Chromium. (Sì, funziona anche su 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

Per ricapitolare:

1. Diventa una CA.
2. Firma il tuo certificato usando la tua chiave CA.
3. Importa myCA.pemcome autorità nelle impostazioni di Chrome (Impostazioni> Gestisci certificati> Autorità> Importa)
4. Usa il .crtfile nel tuo server

Passaggi aggiuntivi (almeno per Mac):

1. Importa il certificato CA in "File> Importa file", quindi trovalo nell'elenco, fai clic con il pulsante destro del mouse, espandi "> Affidabilità" e seleziona "Sempre"
2. Aggiungi extendedKeyUsage=serverAuth,clientAuthqui sotto basicConstraints=CA:FALSEe assicurati di impostare "CommonName" sullo stesso di $NAMEquando richiede l'installazione

Puoi controllare il tuo lavoro

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

Per localhostsolo:

Basta incollarlo nel tuo Chrome:

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

Dovresti vedere il testo evidenziato che dice: Consenti certificati non validi per le risorse caricate da localhost

Fare clic Enable.

Questo ha funzionato per me:

1. Utilizzando Chrome, accedi a una pagina sul tuo server tramite HTTPS e continua oltre la pagina di avviso rossa (supponendo che non l'abbia già fatto).
2. Apri Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
3. Fai clic sulla Authoritiesscheda e scorri verso il basso per trovare il certificato sotto il Nome dell'organizzazione che hai assegnato al certificato.
4. Selezionalo, fai clic su Modifica ( NOTA : nelle versioni recenti di Chrome, il pulsante è ora "Avanzato" anziché "Modifica"), seleziona tutte le caselle e fai clic su OK. Potrebbe essere necessario riavviare Chrome.

Ora dovresti ottenere il bel lucchetto verde sulle tue pagine.

EDIT: ho provato di nuovo su una nuova macchina e il certificato non è apparso nella finestra Gestisci certificati semplicemente continuando dalla pagina rossa del certificato non attendibile. Ho dovuto fare quanto segue:

1. Nella pagina con il certificato non attendibile ( https://barrato in rosso), fai clic sul lucchetto> Informazioni sul certificato. NOTA: nelle versioni più recenti di Chrome, devi aprire Developer Tools > Securitye selezionare View certificate.
2. Clicca il Details tab > Export. Scegli PKCS #7, single certificatecome formato file.
3. Quindi segui le mie istruzioni originali per accedere alla pagina Gestisci certificati. Fare clic su Authorities tab > Importe selezionare il file in cui è stato esportato il certificato e assicurarsi di scegliere PKCS #7, single certificate come tipo di file .
4. Se richiesto negozio di certificazione, selezionare Autorità di certificazione radice attendibili
5. Seleziona tutte le caselle e fai clic su OK. Riavvia Chrome.

AGGIORNAMENTO PER CHROME 58+ (RILASCIATO 19-04-2017)

A partire da Chrome 58, la possibilità di identificare l'host utilizzando solo è commonName stata rimossa . I certificati devono ora utilizzare subjectAltNameper identificare i loro host. Vedi ulteriori discussioni qui e bug tracker qui . In passato, subjectAltNameveniva utilizzato solo per certificati multi-host, quindi alcuni strumenti CA interni non li includevano.

Se i tuoi certificati autofirmati hanno funzionato bene in passato ma improvvisamente hanno iniziato a generare errori in Chrome 58, ecco perché.

Quindi, qualunque sia il metodo che stai usando per generare il tuo certificato autofirmato (o certificato firmato da una CA autofirmata), assicurati che il certificato del server contenga un subjectAltNamecon le voci appropriate DNSe / o IPentry /, anche se è solo per un singolo host .

Per openssl, ciò significa che la tua configurazione OpenSSL ( /etc/ssl/openssl.cnfsu Ubuntu) dovrebbe avere qualcosa di simile al seguente per un singolo host:

[v3_ca]   # and/or [v3_req], if you are generating a CSR
subjectAltName = DNS:example.com

o per più host:

[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

Nel visualizzatore di certificati Chrome (che è stato spostato nella scheda "Sicurezza" in F12) dovresti vederlo elencato Extensionscome Certificate Subject Alternative Name:

Su Mac, puoi utilizzare l'utilità Accesso portachiavi per aggiungere il certificato autofirmato al portachiavi di sistema, quindi Chrome lo accetterà. Ho trovato le istruzioni dettagliate qui:

Google Chrome, Mac OS X e certificati SSL autofirmati

Fondamentalmente:

1. fai doppio clic sull'icona del lucchetto con una X e trascina l'icona del certificato sul desktop,
2. aprire questo file (terminando con un'estensione .cer); questo apre l'applicazione portachiavi che ti consente di approvare il certificato.

Fai clic in un punto qualsiasi della pagina e digita un BYPASS_SEQUENCE

" thisisunsafe" è un BYPASS_SEQUENCE per Chrome versione 65

" badidea" Chrome versione 62-64.

" danger" funzionava nelle versioni precedenti di Chrome

Non è necessario cercare un campo di input, basta inserirlo. Sembra strano ma funziona.

L'ho provato su Mac High Sierra.

Per ricontrollare se lo hanno cambiato di nuovo, vai all'ultimo codice sorgente di cromo

Per cercare BYPASS_SEQUENCE, al momento sembra che:

var BYPASS_SEQUENCE = window.atob('dGhpc2lzdW5zYWZl');

Ora lo hanno mimetizzato, ma per vedere il vero BYPASS_SEQUENCE puoi eseguire la seguente riga in una console del browser.

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

Linux

Se stai usando Linux, puoi anche seguire queste pagine wiki ufficiali:

• Configurazione dei certificati SSL su Linux.
• NSS DB condiviso e LINUX
• How to DB condiviso NSS

Fondamentalmente:

• fai clic sull'icona del lucchetto con una X,
• scegli Informazioni sul certificato
• vai alla scheda Dettagli
• Fai clic su Esporta ... (salva come file)

Ora, il comando seguente aggiungerà il certificato (dove YOUR_FILE è il file esportato):

certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n YOUR_FILE -i YOUR_FILE

Per elencare tutti i certificati, eseguire il comando seguente:

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

Se il problema persiste, potresti essere interessato da questo errore: Problema 55050: errore Ubuntu SSL 8179

PS Assicurati anche di averlo libnss3-tools, prima di poter usare i comandi sopra.

Se non lo hai, ti preghiamo di installarlo da:

sudo apt-get install libnss3-tools # on Ubuntu
sudo yum install nss-tools # on Fedora, Red Hat, etc.

Come bonus, puoi usare i seguenti script utili:

$ 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'

Uso:

add_cert.sh [FILE]
list_cert.sh
download_cert.sh [DOMAIN]

Risoluzione dei problemi

• Esegui Chrome con il --auto-ssl-client-authparametro

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

Sul Mac, puoi creare un certificato che è completamente attendibile da Chrome e Safari a livello di sistema procedendo come segue:

    # 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

Quanto sopra utilizza i seguenti script e un file di supporto v3.extper evitare errori mancanti del nome alternativo del soggetto

Se si desidera creare un nuovo certificato autofirmato completamente attendibile utilizzando la propria autorità di root, è possibile farlo utilizzando questi script.

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%%

Un altro passo: come rendere affidabili i certificati autofirmati in Chrome / Safari

Per consentire la piena fiducia dei certificati autofirmati in Chrome e Safari, devi importare una nuova autorità di certificazione sul tuo Mac. Per fare ciò, seguire queste istruzioni o le istruzioni più dettagliate su questo processo generale sul sito Web mitmproxy :

Puoi farlo in 2 modi, dalla riga di comando, usando questo comando che ti chiederà la password:

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

o usando l' Keychain Accessapp:

1. Apri Accesso portachiavi
2. Scegli "Sistema" nell'elenco "Portachiavi"
3. Scegli "Certificati" nell'elenco "Categoria"
4. Scegli "File | Importa elementi ..."
5. Cerca il file creato sopra, "rootCA.pem", selezionalo e fai clic su "Apri"
6. Seleziona il certificato appena importato nell'elenco "Certificati".
7. Fai clic sul pulsante "i" o fai clic con il pulsante destro del mouse sul certificato e scegli "Ottieni informazioni"
8. Espandi l'opzione "Affidabilità"
9. Modifica "Quando si utilizza questo certificato" in "Sempre attendibile"
10. Chiudi la finestra di dialogo e ti verrà richiesta la password.
11. Chiudi e riapri tutte le schede che utilizzano il tuo dominio di destinazione e verrà caricato in modo sicuro!

e come bonus, se hai bisogno che i clienti Java credano nei certificati, puoi farlo importando i certificati nel keystore java. Nota che questo rimuoverà il certificato dal keystore se esiste già, poiché deve aggiornarlo nel caso in cui le cose cambino. Ovviamente lo fa solo per i certificati importati.

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

AGGIORNAMENTO 11/2017: questa risposta probabilmente non funzionerà per la maggior parte delle versioni più recenti di Chrome.

AGGIORNAMENTO 02/2016: istruzioni migliori per gli utenti Mac sono disponibili qui .

1. Sul sito che desideri aggiungere, fai clic con il pulsante destro del mouse sull'icona del lucchetto rosso nella barra degli indirizzi:

   2. Fai clic sulla scheda denominata Connessione , quindi fai clic su Informazioni sul certificato

   3. Fare clic sulla Dettagli scheda, il fare clic sul pulsante Copia su file ... . Si aprirà l'Esportazione guidata certificati, fare clic su Avanti per accedere alla schermata Esporta formato file .

   4. Scegliere X.509 binario codificato DER (.CER) , fare clic su Avanti

   5. Fai clic su Sfoglia ... e salva il file sul tuo computer. Dagli un nome descrittivo. Fai clic su Avanti , quindi fai clic su Fine .

   6. Apri le impostazioni di Chrome, scorri verso il basso e fai clic su Mostra impostazioni avanzate ...

   7. In HTTPS / SSL , fai clic su Gestisci certificati ...

   8. Fare clic sulla certificazione Autorità di fonti attendibili scheda, quindi fare clic sul Importa ... pulsante. Questo apre la procedura guidata per l'importazione dei certificati. Fare clic su Avanti per accedere alla schermata File da importare .

   9. Fai clic su Sfoglia ... e seleziona il file del certificato salvato in precedenza, quindi fai clic su Avanti .

   10. Selezionare Posiziona tutti i certificati nel seguente negozio . Il negozio selezionato dovrebbe essere Autorità di certificazione radice affidabili . In caso contrario, fai clic su Sfoglia ... e selezionalo. Fai clic su Avanti e Fine

   11. Fai clic su Sì nell'avviso di sicurezza.

   12. Riavvia Chrome.

Se sei su un Mac e non vedi la scheda di esportazione o come ottenere il certificato ha funzionato per me:

1. Fai clic sul lucchetto prima di https: //
2. Vai alla scheda "Connessione"

3. Fai clic su "Informazioni sul certificato"

   Ora dovresti vedere questo:

4. Trascina quella piccola icona del certificato sul desktop (o ovunque).

5. Fai doppio clic sul file .cer che è stato scaricato, questo dovrebbe importarlo nel tuo portachiavi e aprire Accesso portachiavi al tuo elenco di certificati.

   In alcuni casi, questo è sufficiente e ora puoi aggiornare la pagina.

   Altrimenti:

6. Fare doppio clic sul certificato appena aggiunto.
7. Sotto il menu a discesa Trust, modifica l'opzione "Quando usi questo certificato" in "Always Trust"

Ora ricarica la pagina in questione e dovrebbe essere risolto il problema! Spero che sia di aiuto.

Modifica da Wolph

Per renderlo un po 'più semplice, puoi usare il seguente script ( sorgente ):

1. Salva il seguente script come 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. Rendi eseguibile lo script (dalla shell):

   chmod +x whitelist_ssl_certificate.ssh

3. Esegui lo script per il dominio desiderato (semplicemente copia / incolla tutte le opere URL):

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

AGGIORNATO 23/2020 aprile

Consigliato dal team Chromium

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

Soluzione rapida super facile

Esiste una frase di esclusione segreta che può essere digitata nella pagina di errore per consentire a Chrome di procedere nonostante l'errore di sicurezza: thisisunsafe (nelle versioni precedenti di Chrome, digitare badidea e, ancora prima, pericolo ). DO NOT USE questo a meno che capire esattamente perché ne hai bisogno!

Fonte:

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

(NOTA che si window.atob('dGhpc2lzdW5zYWZl')risolve in thisisunsafe)

L'ultima versione della fonte è @ https://chromium.googlesource.com/chromium/src/+/refs/heads/master/components/security_interstitials/core/browser/resources/interstitial_large.js e ilwindow.atob funzione può essere eseguita in una console JS.

Per informazioni sul perché il team di Chrome ha cambiato la frase di bypass (la prima volta):

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

Se tutto il resto fallisce (soluzione n. 1)

Per una tantum una tantum se l'opzione "Procedi comunque" non è disponibile, né la frase bypass funziona, questo trucco funziona bene:

1. Consenti errori certificati localhostda abilitando questo flag (nota che Chrome ha bisogno di un riavvio dopo aver modificato il valore del flag):

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

   (e risposta di voto https://stackoverflow.com/a/31900210/430128 di @Chris)

2. Se il sito a cui si desidera connettersi è localhost, il gioco è fatto. Altrimenti, imposta un tunnel TCP per ascoltare localmente sulla porta 8090 e collegarti broken-remote-site.comsulla porta 443, assicurati di aver socatinstallato ed eseguito qualcosa del genere in una finestra del terminale:

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

3. Vai su https: // localhost: 8090 nel tuo browser.

Se tutto il resto fallisce (soluzione n. 2)

Simile a "Se tutto il resto fallisce (soluzione n. 1)", qui configuriamo un proxy per il nostro servizio locale usando ngrok . Poiché è possibile accedere ai tunnel http di ngrok tramite TLS (nel qual caso viene terminato da ngrok con un certificato valido) o tramite un endpoint non TLS, il browser non lamenterà certificati non validi.

Scarica e installa ngrok e poi esponilo tramite ngrok.io:

ngrok http https://localhost

ngrok si avvierà e ti fornirà un nome host a cui puoi connetterti e tutte le richieste verranno ricondotte al tuo computer locale.

Per un ambiente di test

È possibile utilizzare --ignore-certificate-errorscome parametro della riga di comando all'avvio di Chrome (lavorando sulla versione 28.0.1500.52 su Ubuntu).

Questo farà sì che ignori gli errori e si colleghi senza preavviso. Se hai già una versione di Chrome in esecuzione, dovrai chiuderla prima di riavviare dalla riga di comando o si aprirà una nuova finestra ma ignorerà i parametri.

Configuro Intellij per avviare Chrome in questo modo quando si esegue il debug, poiché i server di test non hanno mai certificati validi.

Non consiglierei la normale navigazione in questo modo, poiché i controlli dei certificati sono un'importante funzione di sicurezza, ma questo potrebbe essere utile per alcuni.

Come qualcuno ha notato, è necessario riavviare TUTTO Chrome, non solo le finestre del browser. Il modo più veloce per farlo è aprire una scheda per ...

chrome://restart

WINDOWS JUN / 2017 Windows Server 2012

Ho seguito la risposta di @Brad Parks. Su Windows è necessario importare rootCA.pem nell'archivio delle autorità di certificazione radice attendibili.

Ho fatto i seguenti passi:

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

Dove v3.ext è:

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

Quindi, nel mio caso, ho un'app Web ospitata autonomamente, quindi devo associare il certificato con indirizzo IP e porta, il certificato dovrebbe essere nel MIO negozio con le informazioni sulla chiave privata, quindi ho esportato in formato pfx.

openssl pkcs12 -export -out device.pfx -inkey device.key -in device.crt

Con la console mmc (File / Aggiungi o rimuovi snap-in / Certificati / Aggiungi / Account computert / LocalComputer / OK) Ho importato il file pfx nell'archivio personale.

Successivamente ho usato questo comando per associare il certificato (è possibile utilizzare anche lo strumento HttpConfig):

netsh http add sslcert ipport=0.0.0.0:12345 certhash=b02de34cfe609bf14efd5c2b9be72a6cb6d6fe54 appid={BAD76723-BF4D-497F-A8FE-F0E28D3052F4}

certhash = Certificato Thumprint

appid = GUID (a scelta)

Innanzitutto ho provato a importare il certificato "device.crt" su Autorità di certificazione radice attendibili in diversi modi ma sto ancora ottenendo lo stesso errore:

Ma mi sono reso conto che avrei dovuto importare il certificato dell'autorità di root e non il certificato per il dominio. Quindi ho usato la console mmc (File / Aggiungi o Rimuovi snap-in / Certificati / Aggiungi / Account computert / LocalComputer / OK) Ho importato rootCA.pem nell'archivio delle autorità di certificazione radice affidabili.

Riavvia Chrome e voilà funziona.

Con localhost:

O con indirizzo IP:

L'unica cosa che non sono riuscito a ottenere è che ha un codice obsoleto (quadrato rosso nell'immagine). L'aiuto è apprezzato su questo punto.

Con makecert non è possibile aggiungere informazioni SAN. Con New-SelfSignedCertificate (Powershell) è possibile aggiungere informazioni SAN, funziona anche.

1. Aggiungere il certificato CA nell'archivio CA radice attendibile.

2. Vai su Chrome e abilita questo flag!

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

Alla fine, usa semplicemente il dominio * .me o qualsiasi dominio valido come * .com e * .net e gestiscili nel file host. Per i miei sviluppatori locali, utilizzo * .me o * .com con un file host gestito come segue:

3. Aggiungi all'host. C: / windows / system32 / drivers / etc / hosts

   127.0.0.1 nextwebapp.me

Nota: se il browser è già aperto durante questa operazione, l'errore continuerà a essere visualizzato. Quindi, per favore chiudi il browser e ricomincia. Meglio ancora, vai in incognito o inizia una nuova sessione per un effetto immediato.

Sei sicuro che l'indirizzo del sito venga offerto come lo stesso del certificato? Ho avuto gli stessi problemi con Chrome e un certificato autofirmato, ma alla fine ho scoperto che era incredibilmente pignolo sulla convalida del nome di dominio sul certificato (come dovrebbe essere).

Chrome non ha il proprio negozio di certificati e utilizza quello di Windows. Tuttavia, Chrome non offre alcun modo per importare certificati nel negozio, quindi è necessario aggiungerli tramite IE.

Installazione dei certificati in Google Chrome

Installazione dei certificati in Internet Explorer

Dai un'occhiata anche a questo per un paio di approcci diversi alla creazione di certificati autofirmati (suppongo che stai usando IIS come non hai menzionato).

Come creare un certificato autofirmato in IIS 7

Ho seguito il processo di utilizzo di ciò che bjnord ha suggerito: Google Chrome, Mac OS X e certificati SSL autofirmati

Ciò che viene mostrato nel blog non ha funzionato.

Tuttavia, uno dei commenti al blog era l'oro:

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

Dovrai seguire il blog su come ottenere il file cert, dopodiché puoi usare il comando sopra e dovresti andare bene.

La GUI per la gestione dei certificati SSL su Chromium su Linux NON ha funzionato correttamente per me. Tuttavia, i loro documenti hanno dato la risposta giusta. Il trucco era eseguire il comando seguente che importa il certificato SSL autofirmato. Basta aggiornare il nome del <certificate-nickname>ecertificate-filename.cer , quindi riavviare chromium / chrome.

Dai documenti:

Su Linux, Chromium utilizza il DB condiviso NSS. Se il gestore integrato non funziona per te, puoi configurare i certificati con gli strumenti da riga di comando NSS.

Ottieni gli strumenti

• 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"(È necessario avviare tutti i comandi seguenti con il nssprefisso, ad esempio nsscertutil.) Opensuse:sudo zypper install mozilla-nss-tools

Per fidarci di un certificato server autofirmato, dovremmo usare

certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n <certificate-nickname> -i certificate-filename.cer

Elencare tutti i certificati

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

I TRUSTARGS sono tre stringhe di zero o più caratteri alfabetici, separate da virgole. Definiscono come il certificato deve essere considerato attendibile per SSL, e-mail e firma degli oggetti e sono spiegati nei documenti del certutil o nel post sul blog di Meena sui flag di fiducia.

Aggiungi un certificato personale e una chiave privata per l'autenticazione client SSL Utilizzare il comando:

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

per importare un certificato personale e una chiave privata memorizzati in un file PKCS # 12. I TRUSTARGS del certificato personale saranno impostati su "u, u, u".

Elimina un certificato certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>

Estratto da: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md

Filippo Valsorda ha scritto uno strumento multipiattaforma mkcert, per farlo per molti negozi di fiducia. Presumo che l'abbia scritto per lo stesso motivo per cui ci sono così tante risposte a questa domanda: è una seccatura fare la cosa "giusta" per i certificati SubjectAltName firmati da una CA radice attendibile.

mkcert è incluso nei principali sistemi di gestione dei pacchetti per Windows, macOS e diverse versioni di Linux.

mkcert

mkcertè uno strumento semplice per la creazione di certificati di sviluppo attendibili localmente. Non richiede alcuna configurazione.

$ 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" ✅

Quando fai clic sull'icona del lucchetto barrato accanto all'URL, otterrai una casella simile a questa:

Dopo aver fatto clic sul collegamento Informazioni sul certificato , verrà visualizzata la seguente finestra di dialogo:

Indica quale archivio certificati è quello corretto, è l' archivio delle autorità di certificazione radice attendibili .

Puoi utilizzare uno dei metodi indicati nelle altre risposte per aggiungere il certificato a quel negozio o utilizzare:

certutil -addstore -user "ROOT" cert.pem

• ROOT è il nome interno dell'archivio certificati menzionato in precedenza.
• cert.pem è il nome del certificato autofirmato.

Questo ha funzionato per me. Vedi: http://www.robpeck.com/2010/10/google-chrome-mac-os-x-and-self-signed-ssl-certificates/#.Vcy8_ZNVhBc

Nella barra degli indirizzi, fai clic sul lucchetto con la X. Verrà visualizzata una piccola schermata informativa. Fai clic sul pulsante "Informazioni sul certificato".

Fare clic e trascinare l'immagine sul desktop. Sembra un piccolo certificato.

Fare doppio clic su di esso. Questo farà apparire l'utilità Accesso Portachiavi. Inserisci la tua password per sbloccarla.

Assicurati di aggiungere il certificato al portachiavi di sistema, non al portachiavi di accesso. Fai clic su "Fidati sempre", anche se questo non sembra fare nulla.

Dopo che è stato aggiunto, fare doppio clic su di esso. Potrebbe essere necessario eseguire nuovamente l'autenticazione.

Espandi la sezione "Fiducia".

"Quando si utilizza questo certificato", impostare su "Sempre attendibile"

Ho provato di tutto e cosa l'ha fatto funzionare: durante l'importazione, selezionare la categoria corretta, vale a dire Autorità di certificazione radice attendibili :

(mi dispiace è tedesco, ma basta seguire l'immagine)

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
)

Questo post è già invaso da risposte, ma ho creato uno script bash basato su alcune delle altre risposte per facilitare la generazione di un certificato TLS autofirmato valido in Chrome (testato in Chrome 65.x). Spero sia utile agli altri.

script bash autofirmato-tls

Dopo aver installato ( e considerato attendibile ) il certificato, non dimenticare di riavviare Chrome ( chrome://restart)

Un altro strumento che vale la pena provare è il cfssltoolkit di CloudFlare :

cfssl

Per creare un certificato autofirmato in Windows di cui crede v58 e successive, avvia Powershell con privilegi elevati e digita:

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!!

Una volta fatto ciò, il certificato verrà salvato nei certificati del computer locale in Personal \ Certificates nell'archivio .

Si desidera copiare questo certificato nell'archivio Autorità di certificazione radice accreditate \ Certificati .

Un modo per farlo: fai clic sul pulsante Start di Windows e digita certlm.msc. Quindi trascina e rilascia il certificato appena creato nell'archivio Autorità di certificazione radice accreditate \ Certificati per lo screenshot seguente.

Correzione localhost SSL / HTTPS su mac / osx:

1. Fare clic sul lucchetto rosso con la croce nella barra degli indirizzi quando si tenta di aprire l'ambiente localhost https. Si aprirà una finestra con alcune informazioni sul certificato.

2. Fai clic sulla finestra delle informazioni "Dettagli"

3. Gli strumenti di sviluppo di Chrome si aprono nella scheda "Sicurezza". Fai clic su Visualizza certificato . L'immagine del certificato

4. Aggiungilo al tuo portachiavi 'Sistema' (non al tuo portachiavi 'login' che è selezionato per impostazione predefinita).

5. Apri il tuo portachiavi (di nuovo) e trova il certificato. Cliccaci sopra e assicurati di "fidarti" di tutto.

6. Riavvia Chrome e dovrebbe funzionare.

Stavo riscontrando lo stesso problema: avevo installato il certificato nell'archivio Trusted Root Authorities di Windows e Chrome continuava a rifiutare il certificato con l'errore ERR_CERT_COMMON_NAME_INVALID. Si noti che quando il certificato non è installato correttamente nel negozio, l'errore èERR_CERT_AUTHORITY_INVALID .

Come suggerito dal nome dell'errore, da questo commento e da questa domanda , il problema risiedeva nel nome di dominio dichiarato nel certificato. Quando mi è stato richiesto il "Nome comune" durante la generazione del certificato, ho dovuto inserire il nome di dominio che stavo usando per accedere al sito ( localhostnel mio caso). Ho riavviato Chrome utilizzando chrome://restarted è stato finalmente felice con questo nuovo certificato.

A partire da Chrome 58+ ho iniziato a ricevere un errore di certificato su macOS a causa della SAN mancante. Ecco come ottenere nuovamente il blocco verde sulla barra degli indirizzi.

1. Genera un nuovo certificato con il seguente comando:

   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. Importa il server.crtnel tuo KeyChain, quindi fai doppio clic sul certificato, espandi il Trust e seleziona Always Trust

Aggiorna la pagina https://domain.dev in Google Chrome, quindi il lucchetto verde è tornato.

Per Chrome su MacOS, se hai preparato un certificato:

• Esci da Chrome ( cmd+ Q).
• Avvia l'app Accesso Portachiavi e apri la categoria "Certificati".
• Trascina il file del certificato nella finestra Accesso portachiavi e digita la password per il file del certificato.
• Fare doppio clic sul certificato e aprire l'elenco "Affidabilità".
  • Nella riga "Quando si utilizza questo certificato", selezionare "Sempre attendibile".
  • Chiudi questa roba e digita la tua password.
• Avvia Chrome e svuota tutte le cache.
• Controlla che sia tutto a posto.

Consentire a localhost non sicuro di funzionare correttamente tramite questo metodo chrome: // flags / # allow-insecure-localhost

Solo che è necessario creare il nome host di sviluppo su xxx.localhost.