Como fazer uma solicitação https com certificado inválido?

Digamos que eu queira ser https://golang.orgprogramaticamente. Atualmente, o golang.org (ssl) possui um certificado inválido emitido para o *.appspot.comSo quando executo isso:

package main

import (
    "log"
    "net/http"
)

func main() {
    _, err := http.Get("https://golang.org/")
    if err != nil {
        log.Fatal(err)
    }
}

Eu recebo (como eu esperava)

Get https://golang.org/: certificate is valid for *.appspot.com, *.*.appspot.com, appspot.com, not golang.org

Agora, eu mesmo quero confiar neste certificado (imagine um certificado auto-emitido onde eu possa validar impressões digitais etc.): como posso fazer uma solicitação e validar / confiar no certificado?

Eu provavelmente preciso usar o openssl para baixar o certificado, carregá-lo no meu arquivo e preencher tls.Configstruct!?

Nota de segurança: Desabilitar as verificações de segurança é perigoso e deve ser evitado

Você pode desativar as verificações de segurança globalmente para todas as solicitações do cliente padrão:

package main

import (
    "fmt"
    "net/http"
    "crypto/tls"
)

func main() {
    http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
    _, err := http.Get("https://golang.org/")
    if err != nil {
        fmt.Println(err)
    }
}

Você pode desativar a verificação de segurança para um cliente:

package main

import (
    "fmt"
    "net/http"
    "crypto/tls"
)

func main() {
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr}
    _, err := client.Get("https://golang.org/")
    if err != nil {
        fmt.Println(err)
    }
}

Aqui está uma maneira de fazê-lo sem perder as configurações padrão do DefaultTransporte sem precisar da solicitação falsa conforme o comentário do usuário.

defaultTransport := http.DefaultTransport.(*http.Transport)

// Create new Transport that ignores self-signed SSL
customTransport := &http.Transport{
  Proxy:                 defaultTransport.Proxy,
  DialContext:           defaultTransport.DialContext,
  MaxIdleConns:          defaultTransport.MaxIdleConns,
  IdleConnTimeout:       defaultTransport.IdleConnTimeout,
  ExpectContinueTimeout: defaultTransport.ExpectContinueTimeout,
  TLSHandshakeTimeout:   defaultTransport.TLSHandshakeTimeout,
  TLSClientConfig:       &tls.Config{InsecureSkipVerify: true},
}

ATUALIZAR

Maneira mais curta:

customTransport := &(*http.DefaultTransport.(*http.Transport)) // make shallow copy
customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

Maneira correta (a partir do Go 1.13) (fornecida pela resposta abaixo ):

customTransport := http.DefaultTransport.(*http.Transport).Clone()
customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

Aviso : Apenas para fins de teste / desenvolvimento. Qualquer outra coisa, proceda por sua conta e risco !!!

Todas essas respostas estão erradas! Não use InsecureSkipVerifypara lidar com uma CN que não corresponda ao nome do host. Os desenvolvedores do Go imprudentemente foram inflexíveis quanto a não desativar as verificações de nome de host (que têm usos legítimos - túneis, nats, certificados de cluster compartilhado etc.), além de terem algo parecido, mas na verdade ignoram completamente a verificação de certificado. Você precisa saber que o certificado é válido e assinado por um certificado confiável. Mas em cenários comuns, você sabe que o CN não corresponderá ao nome do host ao qual você se conectou. Para aqueles, definido ServerNameno tls.Config. Se tls.Config.ServerName== remoteServerCN, a verificação do certificado será bem-sucedida. Isso é o que você quer. InsecureSkipVerifysignifica que não há autenticação; e está maduro para um homem-no-meio; derrotando o propósito de usar TLS.

Há um uso legítimo para InsecureSkipVerify: use-o para conectar-se a um host e obter seu certificado e, em seguida, desconecte-o imediatamente. Se você configurou seu código para uso InsecureSkipVerify, geralmente é porque você não o definiu ServerNamecorretamente (ele precisará vir de um env var ou algo assim - não fique com dor de barriga com esse requisito ... faça-o corretamente).

Em particular, se você usa certificados de clientes e confia neles para autenticação, basicamente possui um login falso que na verdade não entra mais. Recuse o código que sim InsecureSkipVerify, ou você aprenderá o que há de errado com ele da maneira mais difícil!

A maneira correta de fazer isso se você deseja manter as configurações de transporte padrão é agora (a partir do Go 1.13):

customTransport := http.DefaultTransport.(*http.Transport).Clone()
customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
client = &http.Client{Transport: customTransport}

Transport.Clone faz uma cópia profunda do transporte. Dessa forma, você não precisa se preocupar em perder nenhum novo campo que seja adicionado à Transportestrutura ao longo do tempo.

Se você deseja usar as configurações padrão do pacote http, para não precisar criar um novo objeto de Transporte e Cliente, pode alterar para ignorar a verificação do certificado da seguinte maneira:

tr := http.DefaultTransport.(*http.Transport)
tr.TLSClientConfig.InsecureSkipVerify = true

Geralmente, o domínio DNS da URL DEVE corresponder ao Assunto do certificado do certificado.

Antigamente, isso poderia ser definido pelo domínio como cn do certificado ou tendo o domínio definido como um Nome alternativo do assunto.

O suporte ao cn foi descontinuado por um longo tempo (desde 2000, na RFC 2818 ) e o navegador Chrome nem olha mais para o cn, então hoje você precisa ter o domínio DNS do URL como um nome alternativo do assunto.

RFC 6125, que proíbe a verificação do cn se o SAN for DNS Domain estiver presente, mas não se o SAN for IP Address estiver presente. O RFC 6125 também repete que o cn está obsoleto, o que já foi mencionado na RFC 2818. E o Fórum do Navegador da Autoridade de Certificação, que, combinado com o RFC 6125, significa essencialmente que o cn nunca será verificado quanto ao nome de domínio DNS.