Eu criei um certificado SSL autoassinado para o CN do host local. O Firefox aceita esse certificado depois de reclamar inicialmente, como esperado. O Chrome e o IE, no entanto, se recusam a aceitá-lo, mesmo após adicionar o certificado ao armazenamento de certificados do sistema em Raízes Confiáveis. Embora o certificado esteja listado como instalado corretamente quando clico em "Exibir informações do certificado" no pop-up HTTPS do Chrome, ele ainda insiste que o certificado não é confiável.

O que devo fazer para que o Chrome aceite o certificado e pare de reclamar?

22-05 2020 : Com apenas 6 comandos de shell , você pode fazer isso.

Por favor , não altere as configurações de segurança do navegador.

Com o código a seguir, você pode (1) se tornar sua própria CA, (2) e assinar seu certificado SSL como uma CA. (3) Importe o certificado da CA (não o certificado SSL, que entra no seu servidor) para o Chrome / Chromium. (Sim, isso funciona mesmo no 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

Para recapitular:

1. Torne-se uma CA
2. Assine seu certificado usando sua chave CA
3. Importar myCA.pemcomo uma autoridade nas configurações do Chrome (Configurações> Gerenciar certificados> Autoridades> Importar)
4. Use o .crtarquivo no seu servidor

Etapas extras (para Mac, pelo menos):

1. Importe o certificado da CA em "Arquivo> Importar arquivo" e encontre-o na lista, clique com o botão direito do mouse, expanda "> Confiança" e selecione "Sempre"
2. Adicione extendedKeyUsage=serverAuth,clientAuthabaixo basicConstraints=CA:FALSEe certifique-se de definir o "CommonName" como o mesmo que $NAMEquando estiver solicitando a instalação

Você pode conferir seu trabalho

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

Por localhostapenas:

Basta colar no seu chrome:

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

Você deverá ver o texto destacado dizendo: Permitir certificados inválidos para recursos carregados do host local

Clique em Enable.

Isso funcionou para mim:

1. Usando o Chrome, acesse uma página em seu servidor via HTTPS e continue além da página de aviso vermelha (supondo que você ainda não tenha feito isso).
2. Abra Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
3. Clique na Authoritiesguia e role para baixo para encontrar seu certificado sob o Nome da organização que você forneceu ao certificado.
4. Selecione-o, clique em Editar ( NOTA : nas versões recentes do Chrome, o botão agora é "Avançado" em vez de "Editar"), marque todas as caixas e clique em OK. Pode ser necessário reiniciar o Chrome.

Você deve obter o belo cadeado verde em suas páginas agora.

EDIT: Tentei novamente em uma nova máquina e o certificado não apareceu na janela Gerenciar certificados apenas continuando na página vermelha do certificado não confiável. Eu tive que fazer o seguinte:

1. Na página com o certificado não confiável ( https://riscado em vermelho), clique no cadeado> Informações do certificado. NOTA: nas versões mais recentes do chrome, é necessário abrir Developer Tools > Securitye selecionar View certificate.
2. Clique no Details tab > Export. Escolha PKCS #7, single certificatecomo formato de arquivo.
3. Siga as instruções originais para acessar a página Gerenciar certificados. Clique no Authorities tab > Importe escolha o arquivo para o qual você exportou o certificado e escolha PKCS #7, single certificate o tipo de arquivo .
4. Se o armazenamento de certificação for solicitado, escolha Autoridades de certificado raiz confiáveis
5. Marque todas as caixas e clique em OK. Reinicie o Chrome.

ATUALIZAÇÃO PARA CHROME 58+ (LANÇADO 19/04/2017)

No Chrome 58, a capacidade de identificar o host usando apenas commonName foi removida . Agora, os certificados devem ser usados subjectAltNamepara identificar seus hosts. Veja mais discussões aqui e rastreador de erros aqui . No passado, subjectAltNameera usado apenas para certificados de vários hosts, portanto algumas ferramentas internas da CA não os incluíam.

Se seus certificados autoassinados funcionaram bem no passado, mas de repente começaram a gerar erros no Chrome 58, é por isso.

Portanto, qualquer que seja o método que você esteja usando para gerar seu certificado autoassinado (ou certificado assinado por uma CA autoassinada), verifique se o certificado do servidor contém um subjectAltNamecom as devidas DNSe / ou IPentradas / entradas, mesmo que seja apenas para um único host .

Para o openssl, isso significa que sua configuração do OpenSSL ( /etc/ssl/openssl.cnfno Ubuntu) deve ter algo semelhante ao seguinte para um único host:

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

ou para vários 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

No visualizador de cert do Chrome (que se mudou para a aba "Segurança" sob F12), você deve vê-lo listado em Extensionscomo Certificate Subject Alternative Name:

No Mac, você pode usar o utilitário Keychain Access para adicionar o certificado autoassinado ao chaveiro do sistema, e o Chrome o aceitará. Encontrei as instruções passo a passo aqui:

Google Chrome, Mac OS X e certificados SSL autoassinados

Basicamente:

1. clique duas vezes no ícone de cadeado com um X e arraste e solte o ícone de certificado na área de trabalho,
2. abra este arquivo (terminando com uma extensão .cer); isso abre o aplicativo de chaveiro que permite aprovar o certificado.

Clique em qualquer lugar da página e digite um BYPASS_SEQUENCE

" thisisunsafe" é um BYPASS_SEQUENCE para Chrome versão 65

" badidea" Versão Chrome 62 - 64.

" danger" costumava funcionar em versões anteriores do Chrome

Você não precisa procurar pelo campo de entrada, basta digitá-lo. Parece estranho, mas está funcionando.

Eu tentei no Mac High Sierra.

Para verificar novamente se eles foram alterados novamente, vá para o código-fonte mais recente do cromo

Para procurar por BYPASS_SEQUENCE, no momento, é assim:

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

Agora eles estão camuflados, mas para ver o BYPASS_SEQUENCE real, você pode executar a seguinte linha em um console do navegador.

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

Linux

Se você estiver usando Linux, também poderá seguir estas páginas wiki oficiais:

• Configurando certificados SSL no Linux.
• DB e LINUX compartilhados do NSS
• How do NSS DB compartilhado

Basicamente:

• clique no ícone de cadeado com um X,
• escolha informações do certificado
• vá para a guia Detalhes
• Clique em Exportar ... (salvar como um arquivo)

Agora, o seguinte comando adicionará o certificado (onde YOUR_FILE é seu arquivo exportado):

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

Para listar todos os seus certificados, execute o seguinte comando:

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

Se ainda assim não funcionar, você pode ser afetado por este bug: Problema 55050: Erro SSL do Ubuntu 8179

PS Por favor, verifique também se você possui libnss3-tools , antes de poder usar os comandos acima.

Se você não possui, instale-o:

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

Como bônus, você pode usar os seguintes scripts úteis:

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

Solução de problemas

• Execute o Chrome com o --auto-ssl-client-authparâmetro

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

No Mac, você pode criar um certificado totalmente confiável para o Chrome e o Safari no nível do sistema, fazendo o seguinte:

    # 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

O exemplo acima usa os seguintes scripts e um arquivo de suporte v3.extpara evitar erros ausentes no nome do assunto alternativo

Se você deseja criar um novo certificado autoassinado totalmente confiável usando sua própria autoridade root, você pode fazê-lo usando esses scripts.

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

Mais uma etapa - Como tornar os certificados autoassinados totalmente confiáveis ​​no Chrome / Safari

Para permitir que os certificados autoassinados sejam TOTALMENTE confiáveis ​​no Chrome e Safari, você precisa importar uma nova autoridade de certificação para o seu Mac. Para fazer isso, siga estas instruções ou as instruções mais detalhadas sobre esse processo geral no site mitmproxy :

Você pode fazer isso de duas maneiras, na linha de comando, usando este comando que solicitará sua senha:

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

ou usando o Keychain Accessaplicativo:

1. Acesso ao chaveiro aberto
2. Escolha "Sistema" na lista "Chaveiros"
3. Escolha "Certificados" na lista "Categoria"
4. Escolha "Arquivo | Importar itens ..."
5. Navegue até o arquivo criado acima, "rootCA.pem", selecione-o e clique em "Abrir"
6. Selecione seu certificado recém-importado na lista "Certificados".
7. Clique no botão "i" ou clique com o botão direito do mouse no seu certificado e escolha "Obter informações"
8. Expanda a opção "Confiar"
9. Altere "Ao usar este certificado" para "Sempre confie"
10. Feche a caixa de diálogo e sua senha será solicitada.
11. Feche e reabra todas as guias que estão usando seu domínio de destino e ele será carregado com segurança!

e como bônus, se você precisar que os clientes java confiem nos certificados, poderá fazê-lo importando seus certificados para o keystore java. Observe que isso removerá o certificado do keystore, se ele já existir, pois será necessário atualizá-lo caso as coisas mudem. Obviamente, isso é feito apenas para os certificados sendo importados.

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

ATUALIZAÇÃO 11/2017: Essa resposta provavelmente não funcionará para a maioria das versões mais recentes do Chrome.

ATUALIZAÇÃO 02/2016: Melhores instruções para usuários de Mac podem ser encontradas aqui .

1. No site que você deseja adicionar, clique com o botão direito do mouse no ícone de cadeado vermelho na barra de endereço:

   2. Clique na guia Conexão e , em seguida, clique em Informações do certificado

   3. Clique no Detalhes guia, o clique no botão Copiar para Arquivo ... . Isso abrirá o Assistente para Exportação de Certificados, clique em Avançar para acessar a tela Formato do arquivo de exportação .

   4. Escolha X.509 binário codificado por DER (.CER) , clique em Avançar

   5. Clique em Procurar ... e salve o arquivo no seu computador. Dê um nome descritivo. Clique em Avançar e clique em Concluir .

   6. Abra as configurações do Chrome, role para a parte inferior e clique em Mostrar configurações avançadas ...

   7. Em HTTPS / SSL , clique em Gerenciar certificados ...

   8. Clique na Certificação Autoridades Raiz Confiáveis guia, em seguida, clique no Import ... botão. Isso abre o Assistente para importação de certificados. Clique em Avançar para acessar a tela Arquivo a ser importado .

   9. Clique em Procurar ... e selecione o arquivo de certificado que você salvou anteriormente e clique em Avançar .

   10. Selecione Colocar todos os certificados na seguinte loja . O armazenamento selecionado deve ser Autoridades de Certificação Raiz Confiáveis . Caso contrário, clique em Procurar ... e selecione-o. Clique em Avançar e em Concluir

   11. Clique em Sim no aviso de segurança.

   12. Reinicie o Chrome.

Se você estiver em um Mac e não estiver vendo a guia de exportação ou como obter o certificado, isso funcionou para mim:

1. Clique no cadeado antes do https: //
2. Vá para a guia "Conexão"

3. Clique em "Informações do certificado"

   Agora você deve ver isso:

4. Arraste esse pequeno ícone de certificado na área de trabalho (ou em qualquer lugar).

5. Clique duas vezes no arquivo .cer que foi baixado. Isso deve importá-lo para o seu chaveiro e abrir o Acesso ao chaveiro à sua lista de certificados.

   Em alguns casos, isso é suficiente e agora você pode atualizar a página.

   De outra forma:

6. Clique duas vezes no certificado recém-adicionado.
7. Na lista suspensa Confiança, altere a opção "Ao usar este certificado" para "Confiar sempre"

Agora recarregue a página em questão e ela deverá ser resolvida! Espero que isto ajude.

Editar a partir de Wolph

Para facilitar um pouco, você pode usar o seguinte script ( fonte ):

1. Salve o seguinte script como 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. Torne o script executável (a partir do shell):

   chmod +x whitelist_ssl_certificate.ssh

3. Execute o script para o domínio que você deseja (simplesmente copie / cole os trabalhos completos do URL):

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

ATUALIZADO 23 de abril de 2020

Recomendado pela equipe Chromium

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

Solução rápida e super fácil

Existe uma frase secreta de desvio que pode ser digitada na página de erro para que o Chrome continue apesar do erro de segurança: thisisunsafe (em versões anteriores do Chrome, digite badidea e, ainda mais, perigo ). DO NOT USE isto a menos que você entenda exatamente porque você precisa dele!

Fonte:

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

(NOTA que window.atob('dGhpc2lzdW5zYWZl')resolve parathisisunsafe )

A versão mais recente da fonte é @ https://chromium.googlesource.com/chromium/src/+/refs/heads/master/components/security_interstitials/core/browser/resources/interstitial_large.js e owindow.atob função pode ser executada em um console JS.

Para saber como a equipe do Chrome alterou a frase de desvio (a primeira vez):

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

Se tudo mais falhar (Solução 1)

Para pontuais rápidos, se a opção "Prosseguir de qualquer maneira" não estiver disponível, nem a frase de desvio estiver funcionando, esse hack funcionará bem:

1. Para permitir erros de certificado localhost, ative esse sinalizador (observe que o Chrome precisa ser reiniciado após alterar o valor do sinalizador):

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

   (e resposta à votação https://stackoverflow.com/a/31900210/430128 por @Chris)

2. Se o site ao qual você deseja se conectar for localhost, você está pronto. Caso contrário, configure um túnel TCP para escutar na porta 8090 localmente e conecte-se à broken-remote-site.comporta 443, verifique se você socatinstalou e execute algo parecido com isto em uma janela de terminal:

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

3. Vá para https: // localhost: 8090 no seu navegador.

Se tudo mais falhar (Solução 2)

Semelhante a "Se tudo mais falhar (Solução 1)", aqui configuramos um proxy para o nosso serviço local usando o ngrok . Como você pode acessar os túneis ngrok http via TLS (nesse caso, é encerrado pelo ngrok com um certificado válido) ou por um nó de extremidade não TLS, o navegador não se queixará de certificados inválidos.

Baixe e instale o ngrok e exponha-o através de ngrok.io:

ngrok http https://localhost

O ngrok será iniciado e fornecerá um nome de host ao qual você pode se conectar, e todos os pedidos serão encaminhados para a sua máquina local.

Para um ambiente de teste

Você pode usar --ignore-certificate-errorscomo um parâmetro de linha de comando ao iniciar o chrome (Trabalhando na versão 28.0.1500.52 no Ubuntu).

Isso fará com que ele ignore os erros e se conecte sem aviso. Se você já possui uma versão do chrome em execução, será necessário fechá-la antes de reiniciar a partir da linha de comando ou abrirá uma nova janela, mas ignore os parâmetros.

Eu configuro o Intellij para iniciar o chrome dessa maneira ao fazer a depuração, pois os servidores de teste nunca possuem certificados válidos.

Eu não recomendaria uma navegação normal como essa, pois as verificações de certificado são um importante recurso de segurança, mas isso pode ser útil para alguns.

Como alguém observou, você precisa reiniciar TODO o Chrome, não apenas as janelas do navegador. A maneira mais rápida de fazer isso é abrir uma guia para ...

chrome://restart

WINDOWS JUN / 2017 Windows Server 2012

Eu segui a resposta de @Brad Parks. No Windows, você deve importar o rootCA.pem no repositório de autoridades de certificados raiz confiáveis.

Eu fiz os seguintes passos:

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

Onde 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

Então, no meu caso, eu tenho um aplicativo Web auto-hospedado, por isso preciso vincular o certificado ao endereço IP e à porta, o certificado deve estar em MINHA loja com informações de chave privada, então eu exportei para o formato pfx.

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

Com o console mmc (Arquivo / Adicionar ou Remover Snap-ins / Certificados / Adicionar / Conta Computert / LocalComputer / OK), importei o arquivo pfx no Personal store.

Mais tarde, usei este comando para ligar o certificado (você também pode usar a ferramenta HttpConfig):

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

certhash = Certificado Thumprint

appid = GUID (sua escolha)

Primeiro, tentei importar o certificado "device.crt" nas autoridades de certificados raiz confiáveis ​​de maneiras diferentes, mas ainda estou recebendo o mesmo erro:

Mas percebi que deveria importar certificado de autoridade root e não certificado para domínio. Portanto, usei o console mmc (Arquivo / Adicionar ou remover snap-ins / Certificados / Adicionar / conta de computador / LocalComputer / OK). Importei o rootCA.pem no armazenamento de autoridades de certificados raiz confiáveis.

Reinicie o Chrome e pronto, ele funciona.

Com localhost:

Ou com endereço IP:

A única coisa que não consegui é que ela tenha uma cifra obsoleta (quadrado vermelho na foto). A ajuda é apreciada neste ponto.

Com o makecert, não é possível adicionar informações da SAN. Com o New-SelfSignedCertificate (Powershell), você pode adicionar informações da SAN, mas também funciona.

1. Adicione o certificado da CA no CA Store raiz confiável.

2. Acesse o chrome e ative esta sinalização!

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

Por fim, basta usar o domínio * .me ou qualquer domínio válido como * .com e * .net e mantê-los no arquivo host. Para meus desenvolvedores locais, uso * .me ou * .com com um arquivo host mantido da seguinte maneira:

3. Adicionar ao host. C: / windows / system32 / drivers / etc / hosts

   127.0.0.1 nextwebapp.me

Nota: Se o navegador já estiver aberto ao fazer isso, o erro continuará sendo exibido. Portanto, feche o navegador e comece novamente. Melhor ainda, entre no modo anônimo ou inicie uma nova sessão para efeito imediato.

Tem certeza de que o endereço em que o site está sendo exibido é o mesmo que o certificado? Eu tive os mesmos problemas com o Chrome e um certificado autoassinado, mas no final, achei incrivelmente exigente a validação do nome de domínio no certificado (como deveria ser).

O Chrome não possui sua própria loja de certificados e usa a própria janela. No entanto, o Chrome não oferece nenhuma maneira de importar certificados para a loja, portanto você deve adicioná-los via IE.

Instalando certificados no Google Chrome

Instalando certificados no Internet Explorer

Veja também algumas abordagens diferentes para criar certificados autoassinados (presumo que você esteja usando o IIS como não mencionou).

Como criar um certificado autoassinado no IIS 7

Eu segui o processo de usar o que o bjnord sugeriu: Google Chrome, Mac OS X e certificados SSL autoassinados

O que é mostrado no blog não funcionou.

No entanto, um dos comentários ao blog foi de ouro:

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

Você precisará seguir o blog sobre como obter o arquivo cert; depois disso, você pode usar o comando acima e deve estar pronto.

A GUI para gerenciar certificados SSL no Chromium no Linux NÃO funcionou corretamente para mim. No entanto, seus documentos deram a resposta certa. O truque era executar o comando abaixo que importa o certificado SSL autoassinado. Atualize o nome do <certificate-nickname>e certificate-filename.cer, em seguida, reinicie o chromium / chrome.

Dos documentos:

No Linux, o Chromium usa o NSS Shared DB. Se o gerenciador interno não funcionar, você poderá configurar os certificados com as ferramentas de linha de comando do NSS.

Obtenha as ferramentas

• 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"(Você precisa iniciar todos os comandos abaixo com o nssprefixo, por exemplo nsscertutil,.) Opensuse:sudo zypper install mozilla-nss-tools

Para confiar em um certificado de servidor autoassinado, devemos usar

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

Listar todos os certificados

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

Os TRUSTARGS são três cadeias de zero ou mais caracteres alfabéticos, separados por vírgulas. Eles definem como o certificado deve ser confiável para SSL, email e assinatura de objeto e são explicados nos documentos certutil ou na postagem do blog de Meena nos sinalizadores de confiança.

Adicionar um certificado pessoal e uma chave privada para autenticação do cliente SSL Use o comando:

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

para importar um certificado pessoal e uma chave privada armazenados em um arquivo PKCS # 12. Os TRUSTARGS do certificado pessoal serão definidos como "u, u, u".

Excluir um certificado certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>

Trecho de: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md

Filippo Valsorda escreveu uma ferramenta multiplataforma mkcert, para fazer isso em muitas lojas de confiança. Presumo que ele tenha escrito pelo mesmo motivo que há tantas respostas para essa pergunta: é difícil fazer a coisa "certa" para os certificados SubjectAltName assinados por uma CA raiz confiável.

mkcert está incluído nos principais sistemas de gerenciamento de pacotes para Windows, macOS e vários tipos de Linux.

mkcert

mkcerté uma ferramenta simples para criar certificados de desenvolvimento confiáveis ​​localmente. Não requer configuração.

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

Ao clicar no ícone de cadeado riscado ao lado do URL, você verá uma caixa assim:

Depois de clicar no link Informações do certificado , você verá a seguinte caixa de diálogo:

Ele informa qual armazenamento de certificados é o correto, é o armazenamento de Autoridades de Certificação Raiz Confiáveis .

Você pode usar um dos métodos descritos nas outras respostas para adicionar o certificado a esse armazenamento ou usar:

certutil -addstore -user "ROOT" cert.pem

• ROOT é o nome interno do armazenamento de certificados mencionado anteriormente.
• cert.pem é o nome do seu certificado autoassinado.

Isso funcionou para mim. Consulte: http://www.robpeck.com/2010/10/google-chrome-mac-os-x-and-self-signed-ssl-certificates/#.Vcy8_ZNVhBc

Na barra de endereço, clique no pequeno cadeado com o X. Isso exibirá uma pequena tela de informações. Clique no botão que diz "Informações do certificado".

Clique e arraste a imagem para a área de trabalho. Parece um pequeno certificado.

Clique duas vezes nele. Isso exibirá o utilitário Keychain Access. Digite sua senha para desbloqueá-la.

Certifique-se de adicionar o certificado ao chaveiro do sistema, não ao chaveiro de login. Clique em "Sempre confie", mesmo que isso pareça não fazer nada.

Depois de adicionado, clique duas vezes nele. Talvez você precise se autenticar novamente.

Expanda a seção "Confiança".

"Ao usar este certificado", defina como "Sempre confie"

Tentei de tudo e o que fez funcionar: Ao importar, selecione a categoria correta, a saber, Autoridades de Certificação Raiz Confiáveis :

(desculpe, é alemão, mas siga a imagem)

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
)

Esta postagem já está repleta de respostas, mas eu criei um script bash com base em algumas das outras respostas para facilitar a geração de um certificado TLS autoassinado válido no Chrome (Testado em Chrome 65.x). Espero que seja útil para os outros.

script bash autoassinado

Depois de instalar ( e confiar ) no certificado, não se esqueça de reiniciar o Chrome ( chrome://restart)

Outra ferramenta que vale a pena conferir é o cfsslkit de ferramentas do CloudFlare :

cfssl

Para criar um certificado autoassinado no Windows em que o Chrome v58 e versões posteriores confiarão, inicie o Powershell com privilégios elevados e digite:

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

Depois que você fizer isso, o certificado será salvo nos certificados do Computador Local, em Personal \ Certificates repositório .

Você deseja copiar este certificado no armazenamento Autoridades de Certificação Raiz Confiáveis ​​\ Certificados .

Uma maneira de fazer isso: clique no botão Iniciar do Windows e digite certlm.msc. Em seguida, arraste e solte o certificado recém-criado no armazenamento Autoridades de Certificação Raiz Confiáveis ​​\ Certificados , conforme a captura de tela abaixo.

Correção de host local SSL / HTTPS no mac / osx:

1. Clique no cadeado vermelho com a cruz na barra de endereço ao tentar abrir seu ambiente https localhost. Irá abrir uma janela com algumas informações sobre o certificado.

2. Clique na janela de informações "Detalhes"

3. As ferramentas do desenvolvedor do Chrome são abertas na guia "Segurança". Clique em Exibir certificado . A imagem do certificado

4. Adicione-o ao seu chaveiro 'Sistema' (não ao seu chaveiro de 'login', que é selecionado por padrão).

5. Abra seu chaveiro (novamente) e encontre o certificado. Clique nele e certifique-se de "Confiar" em todos.

6. Reinicie o chrome e ele deve funcionar.

Eu estava com o mesmo problema: havia instalado o certificado no armazenamento de autoridades raiz confiáveis ​​do Windows e o Chrome ainda recusou o certificado, com o erro ERR_CERT_COMMON_NAME_INVALID. Observe que quando o certificado não está instalado corretamente na loja, o erro éERR_CERT_AUTHORITY_INVALID .

Como sugerido pelo nome do erro, esse comentário e essa pergunta , o problema estava no nome de domínio declarado no certificado. Quando solicitado o "Nome comum" ao gerar o certificado, tive que inserir o nome de domínio que estava usando para acessar o site ( localhostno meu caso). Reiniciei o Chrome usando chrome://restarte finalmente fiquei feliz com este novo certificado.

A partir do Chrome 58+, comecei a receber um erro de certificado no macOS devido à falta da SAN. Aqui está como obter o bloqueio verde na barra de endereço novamente.

1. Gere um novo certificado com o seguinte 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. Importe o server.crtpara o seu KeyChain, clique duas vezes no certificado, expanda Confiança e selecione Confiar sempre

Atualize a página https://domain.dev no Google Chrome, para que a trava verde volte.

Para o Chrome no MacOS, se você preparou um certificado:

• Saia do Chrome ( cmd+ Q).
• Inicie o aplicativo Keychain Access e abra a categoria "Certificates".
• Arraste seu arquivo de certificado para a janela Acesso ao chaveiro e digite a senha do arquivo de certificado.
• Clique duas vezes no seu certificado e desdobre a lista "Confiar".
  • Na linha "Ao usar este certificado", escolha "Confiar sempre".
  • Feche esse material e digite sua senha.
• Inicie o Chrome e limpe todos os caches.
• Verifique se está tudo bem.

Permitir que localhost inseguro funcione bem por meio deste método chrome: // flags / # allow-insecure-localhost

Só que você precisa criar o nome do host de desenvolvimento para xxx.localhost.