MENU
  1. Início
  2. Python
  3. Como verificar certificados SSL usando a biblioteca requests do Python

Como verificar certificados SSL usando a biblioteca requests do Python

Python

A biblioteca requests do Python é amplamente utilizada para interagir com APIs da web e realizar comunicações HTTP de forma simples. No entanto, para garantir uma comunicação segura, a criptografia via protocolo SSL/TLS é essencial. A biblioteca requests verifica os certificados SSL por padrão, mas em alguns ambientes, erros podem ocorrer. Para tratar corretamente os erros de certificados e manter a segurança da comunicação, é crucial entender como funciona a verificação de certificados SSL e configurá-la adequadamente. Este artigo explica de maneira clara como realizar a verificação de certificados SSL usando a biblioteca requests, bem como como resolver problemas comuns.

Índice

Conceitos básicos da verificação de certificados SSL


O certificado SSL (Secure Sockets Layer) é um mecanismo que criptografa a comunicação entre um servidor web e o cliente, impedindo que terceiros intercepte ou alterem os dados. Embora atualmente o padrão seja o TLS (Transport Layer Security), o termo “certificado SSL” ainda é amplamente utilizado.

Como funciona o certificado SSL


O certificado SSL é obtido pelo administrador do site a partir de uma autoridade certificadora (CA) e serve para comprovar que o site é confiável. Quando navegadores ou clientes HTTP realizam uma comunicação SSL/TLS, o certificado é verificado para garantir que o seguinte esteja correto:

  1. O emissor do certificado é uma autoridade certificadora confiável
  2. O nome de domínio especificado no certificado corresponde ao domínio solicitado
  3. O certificado não está expirado

Importância da verificação de certificados


A verificação do certificado SSL ajuda a prevenir os seguintes riscos de segurança:

  • Ataques de falsificação de identidade: Impede que servidores falsos roubem os dados dos usuários.
  • Ataques de intermediário (MITM): Reduz o risco de escuta e modificação dos dados de comunicação.

Realizar a verificação correta dos certificados é fundamental para garantir uma comunicação segura. A biblioteca requests também foi projetada para realizar a verificação dos certificados SSL por padrão.

Configuração básica de verificação SSL na biblioteca requests

A biblioteca requests possui uma funcionalidade automática de verificação de certificados SSL. Isso garante que apenas conexões com sites confiáveis sejam estabelecidas, assegurando a segurança da comunicação.

Função do parâmetro `verify`


Na biblioteca requests, o parâmetro verify é usado para controlar a verificação do certificado SSL. Este parâmetro pode ser configurado de duas maneiras:

  1. True (padrão): Ativa a verificação do certificado.
  2. False: Desativa a verificação do certificado (não recomendado).

O comportamento padrão é verify=True, que consulta uma lista de autoridades certificadoras confiáveis para realizar a verificação do certificado.

Uso básico


A seguir, um exemplo de como usar o parâmetro verify.

import requests

# Verificando o certificado SSL e enviando uma requisição HTTPS
response = requests.get('https://example.com', verify=True)
print(response.status_code)

Desativando a verificação do certificado


Para fins de teste ou depuração, é possível desativar a verificação do certificado configurando o parâmetro verify=False, como mostrado abaixo.

import requests

# Enviando a requisição sem verificar o certificado SSL (não recomendado)
response = requests.get('https://example.com', verify=False)
print(response.status_code)

Neste caso, o Python exibirá um aviso. É possível suprimir este aviso, mas isso deve ser evitado em ambientes de produção.

import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning

# Suprimindo o aviso
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# Enviando a requisição sem verificar o certificado SSL
response = requests.get('https://example.com', verify=False)
print(response.status_code)

Cuidados


Desativar a verificação do certificado aumenta os riscos de segurança. A conexão com sites maliciosos ou ataques de intermediário podem ocorrer, por isso o uso de verify=False deve ser restrito a ambientes de teste ou situações específicas.

Desabilitando a verificação do certificado SSL e seus riscos

Desabilitar a verificação do certificado SSL pode evitar erros de comunicação, mas implica em riscos graves de segurança. A biblioteca requests permite que você pule a verificação do certificado usando verify=False, mas o uso em ambientes de produção não é recomendado.

Como desativar a verificação do certificado


Para desativar a verificação do certificado, basta configurar verify=False.

import requests

# Desativando a verificação do certificado SSL
response = requests.get('https://example.com', verify=False)
print(response.text)

Essa configuração fará com que a requisição seja enviada sem verificar a validade do certificado.

Riscos de desabilitar a verificação do certificado

  1. Vulnerabilidade a ataques de intermediário (MITM)
    Desabilitar a verificação permite que conexões sejam feitas com servidores não confiáveis. Isso pode permitir que atacantes interceptem ou alterem os dados.
  2. Conexões com servidores falsificados
    Se um terceiro malicioso se passar por um servidor legítimo, a conexão será estabelecida sem a verificação do certificado, aumentando o risco de vazamento de informações importantes.
  3. Aumento da possibilidade de exploração de vulnerabilidades
    Ignorar os protocolos de segurança SSL/TLS pode permitir a comunicação com servidores que utilizam criptografias obsoletas ou vulneráveis.

Ignorar avisos e seus riscos adicionais


Os avisos emitidos pelo requests são projetados para alertar sobre os riscos. Suprimir esses avisos com urllib3.disable_warnings pode fazer com que problemas de segurança passem despercebidos.

# Suprimindo avisos não recomendados
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

Recomendações


Em vez de desabilitar a verificação do certificado, considere as seguintes abordagens para resolver o problema:

  • Instalar um certificado de uma CA confiável: Verifique se o certificado do servidor foi emitido corretamente.
  • Configurar certificados personalizados: Especifique um certificado de CA específico usando o parâmetro verify (explicado adiante).
  • Configuração adequada do servidor: Verifique se o servidor está usando o certificado SSL correto.

Desabilitar a verificação do certificado deve ser limitado a depuração ou resolução temporária de problemas. Sempre priorize conexões seguras.

Verificação de SSL com um certificado personalizado

Em alguns casos, pode ser necessário conectar-se a um servidor que utiliza um certificado SSL emitido por uma autoridade certificadora (CA) personalizada. Para essas situações, você pode especificar um arquivo de certificado personalizado usando o parâmetro verify da biblioteca requests.

Preparando o certificado CA personalizado


Para usar um certificado CA personalizado, primeiro obtenha o certificado (geralmente no formato .pem) e salve-o em seu ambiente local. Suponha que o arquivo do certificado seja my_ca_cert.pem.

Usando o certificado personalizado


Na biblioteca requests, você pode especificar o caminho para o arquivo do certificado no parâmetro verify, como mostrado abaixo:

import requests

# Usando um certificado CA personalizado para enviar a requisição
response = requests.get('https://example.com', verify='path/to/my_ca_cert.pem')
print(response.status_code)

Essa configuração fará com que a verificação do certificado seja feita utilizando o certificado de CA especificado.

Considerações sobre a cadeia de certificados


Se o certificado CA personalizado precisar de um certificado intermediário, certifique-se de que a cadeia de certificados esteja corretamente configurada. Incluir os certificados intermediários no my_ca_cert.pem facilitará a verificação.

Exemplo de sucesso na verificação


A seguir, um exemplo de sucesso ao usar um certificado personalizado para enviar uma requisição HTTPS.

# Quando o certificado está correto
response = requests.get('https://securedomain.com', verify='my_ca_cert.pem')
if response.ok:
    print("Conexão bem-sucedida!")
else:
    print("Falha na conexão. Código de status:", response.status_code)

O que fazer quando o certificado personalizado não for reconhecido

  1. Verifique o formato do certificado
    Certifique-se de que ele esteja codificado no formato PEM. Caso contrário, use o OpenSSL para convertê-lo.
   openssl x509 -in my_ca_cert.crt -out my_ca_cert.pem -outform PEM
  1. Verifique o caminho do certificado
    Certifique-se de que o caminho do arquivo esteja correto.
  2. Integre os certificados intermediários
    Se houver certificados intermediários necessários, adicione-os ao certificado principal.
   cat intermediate_cert.pem >> my_ca_cert.pem

Utilizando o certificado no sistema inteiro


Se você usar um certificado personalizado com frequência, considere adicioná-lo ao repositório de certificados confiáveis do sistema para facilitar o gerenciamento e manter o código mais limpo.

sudo cp my_ca_cert.pem /usr/local/share/ca-certificates/
sudo update-ca-certificates

Recomendações


Mesmo ao usar certificados personalizados, sempre verifique sua confiabilidade. Certificados bem gerenciados ajudam a manter a comunicação segura.

Resolvendo erros de certificado

Ao usar a biblioteca requests para verificar certificados SSL, erros podem ocorrer devido a problemas no certificado ou no ambiente do sistema. Aqui, vamos explicar as causas e as soluções para erros comuns relacionados aos certificados.

Erros comuns e suas causas

  1. Certificado não confiável (Certificate verify failed)
    Este erro ocorre quando o certificado do servidor não foi assinado por uma autoridade certificadora (CA) ou quando o certificado CA não está no repositório confiável do sistema.
   requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED]
  1. Certificado expirado (Expired certificate)
    Ocorre quando o certificado do servidor ultrapassou sua data de validade.
  2. Nome de domínio do certificado não corresponde (Hostname mismatch)
    Este erro ocorre quando o nome de domínio especificado no certificado não corresponde ao domínio da URL solicitada.
  3. Falta de certificados intermediários (Incomplete certificate chain)
    Esse erro ocorre quando o servidor não fornece os certificados intermediários necessários.

Soluções para erros

1. Adicionar certificado CA


Se o erro for causado por um certificado não confiável, forneça um certificado CA personalizado e especifique-o no parâmetro verify.

import requests

# Usando um certificado CA personalizado
response = requests.get('https://example.com', verify='path/to/ca_cert.pem')
print(response.status_code)

2. Atualizar repositório de certificados CA do sistema


Se o repositório de certificados do sistema estiver desatualizado, erros de certificado podem ocorrer. Atualize o repositório de certificados com os seguintes comandos:

  • Debian/Ubuntu
  sudo apt update
  sudo apt install --reinstall ca-certificates
  • macOS
  security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain path/to/ca_cert.pem

3. Verificar o certificado do servidor


Se o certificado do servidor estiver expirado ou com o nome de domínio incorreto, entre em contato com o administrador do servidor para que ele possa atualizar ou corrigir o certificado. Você pode verificar o certificado do servidor usando o comando openssl.

openssl s_client -connect example.com:443 -showcerts

4. Integrar certificados intermediários


Se estiver faltando um certificado intermediário, integre a cadeia de certificados corretamente.

cat intermediate_cert.pem >> server_cert.pem

5. Solução temporária (não recomendada)


Se for necessário evitar erros de certificado, é possível configurar verify=False, mas isso deve ser evitado em ambientes de produção devido ao aumento dos riscos de segurança.

response = requests.get('https://example.com', verify=False)

Melhores práticas para resolver erros

  • Atualize regularmente o repositório de certificados CA do sistema.
  • Verifique se o certificado do servidor está configurado corretamente.
  • Use certificados CA personalizados quando necessário para garantir comunicação segura.

Com essas práticas, você pode resolver eficazmente os erros relacionados aos certificados SSL e garantir uma comunicação segura.

Verificação do certificado usando ferramentas externas

Para resolver problemas relacionados a certificados SSL, é necessário examinar os detalhes do certificado e identificar a causa do problema. Utilizar ferramentas externas para investigar os certificados pode ser muito eficaz, além da biblioteca requests. A seguir, apresentamos algumas ferramentas úteis para verificar certificados e como usá-las.

Verificação de certificados com OpenSSL

O OpenSSL é uma ferramenta amplamente utilizada para gerenciar certificados SSL/TLS e realizar comunicações seguras. Ele pode ser usado para obter o certificado de um servidor e verificar problemas.

Obter certificado do servidor


Com o comando a seguir, você pode obter o certificado de um servidor específico e exibir seus detalhes.

openssl s_client -connect example.com:443 -showcerts

Exemplo de saída:

Certificate chain
 0 s:/CN=example.com
   i:/CN=Example CA
---
Server certificate
-----BEGIN CERTIFICATE-----
(certificate data)
-----END CERTIFICATE-----

Verificar validade do certificado

Use o comando abaixo para verificar a validade do certificado obtido.

openssl x509 -in server_cert.pem -noout -dates

Exemplo de saída:

notBefore=Nov  1 00:00:00 2023 GMT
notAfter=Oct 31 23:59:59 2024 GMT

Verificação de certificados CA com certifi

A biblioteca requests do Python usa o certifi para gerenciar uma lista confiável de certificados CA. Usar o certifi permite verificar os certificados CA atuais.

Instalar o certifi

Se o certifi não estiver instalado, você pode instalá-lo com o seguinte comando.

pip install certifi

Verificar o caminho do certificado com certifi

Para verificar o caminho do certificado CA atualmente usado, execute o código abaixo.

import certifi

# Exibir caminho do certificado CA
print(certifi.where())

Exemplo de saída:

/path/to/python/site-packages/certifi/cacert.pem

Verificação do certificado com o navegador

Você também pode usar o navegador para verificar o certificado SSL diretamente. No Chrome ou Firefox, siga as etapas abaixo:

    1. Acesse o site: Acesse o site de destino (exemplo: https://example.com).

    1. Exibir as informações do certificado:

    • Chrome: Clique no ícone de cadeado na barra de endereços e selecione “Informações detalhadas”.

    • Firefox: Clique no ícone de cadeado e selecione “Detalhes da conexão”.

    1. Verifique os detalhes do certificado: Verifique o emissor, domínio de destino e validade.

Pontos importantes na verificação

    • Correspondência do nome de domínio: Verifique se o CN ou SAN do certificado corresponde ao nome de domínio acessado.

    • Presença de certificados intermediários: Verifique se a cadeia de certificados está correta e se todos os certificados intermediários estão presentes.

    • Validade: Verifique se o certificado não expirou.

Critérios para escolher a ferramenta

    • Para obter o certificado diretamente do servidor: Use o OpenSSL.

    • Para verificar a lista confiável de CAs da biblioteca requests: Use o certifi.

    • Para visualizar intuitivamente as informações do certificado: Use o navegador.

Com essas ferramentas, você pode identificar problemas relacionados aos certificados SSL e obter informações essenciais para manter um ambiente de comunicação seguro.

Exemplo prático de código para verificação de SSL com requests

Agora, veremos exemplos práticos de como realizar a verificação do certificado SSL usando a biblioteca requests do Python. Desde o uso básico até exemplos de uso de certificados personalizados.

Exemplo básico de verificação de SSL

A biblioteca requests realiza a verificação do certificado SSL por padrão. A seguir, um exemplo de requisição HTTPS que verifica o certificado:

import requests

# Requisição HTTPS com verificação bem-sucedida
url = 'https://www.google.com'
response = requests.get(url)

print(f"Código de status: {response.status_code}")
print(f"Cabeçalhos da resposta: {response.headers}")

Este código exibe o código de status e os cabeçalhos da resposta se a verificação do certificado for bem-sucedida.

Exemplo de erro na verificação de SSL

Se a verificação do certificado falhar, será gerado o erro requests.exceptions.SSLError. A seguir, um exemplo de erro ao acessar um site com certificado autoassinado.

url = 'https://self-signed.badssl.com'

try:
    response = requests.get(url)
except requests.exceptions.SSLError as e:
    print(f"Erro de SSL: {e}")

Este código gera um erro devido ao certificado não confiável emitido por uma CA não reconhecida.

Usando um certificado personalizado

Exemplo de como usar um certificado CA personalizado para verificar o certificado do servidor.

url = 'https://example.com'
ca_cert_path = '/path/to/your/ca_cert.pem'

# Enviando a requisição com certificado personalizado
response = requests.get(url, verify=ca_cert_path)

print(f"Código de status: {response.status_code}")
print(f"Corpo da resposta: {response.text}")

Este código especifica o caminho para o certificado CA personalizado e verifica o certificado do servidor.

Exemplo de desabilitação da verificação de SSL (não recomendado)

Exemplo de como desabilitar a verificação do SSL e enviar uma requisição. Essa prática não é recomendada, exceto em ambientes de teste.

url = 'https://self-signed.badssl.com'

# Desabilitando a verificação do SSL
response = requests.get(url, verify=False)

print(f"Código de status: {response.status_code}")
print(f"Corpo da resposta: {response.text}")

Esse código envia a requisição sem verificar o certificado SSL. O Python gera um aviso sobre essa configuração.

Exemplo de ativação de logs detalhados da verificação de SSL

Para depurar problemas na verificação de certificados, você pode ativar logs detalhados, que fornecem informações úteis sobre o processo de verificação.

import requests
import logging

# Ativando logs detalhados
logging.basicConfig(level=logging.DEBUG)

url = 'https://www.google.com'
response = requests.get(url)

print(f"Código de status: {response.status_code}")

Os logs exibirão informações sobre o handshake TLS e os detalhes do certificado durante o processo de verificação.

Função genérica para lidar com múltiplos cenários

Exemplo de uma função genérica para lidar com sucessos e falhas na verificação de SSL.

def fetch_url(url, ca_cert=None, disable_ssl=False):
    try:
        if disable_ssl:
            response = requests.get(url, verify=False)
        elif ca_cert:
            response = requests.get(url, verify=ca_cert)
        else:
            response = requests.get(url)
        return response.text
    except requests.exceptions.SSLError as e:
        return f"Erro SSL: {e}"
    except Exception as e:
        return f"Outro erro: {e}"

# Exemplo de uso
print(fetch_url('https://example.com', ca_cert='/path/to/ca_cert.pem'))
print(fetch_url('https://self-signed.badssl.com', disable_ssl=True))

Essa função permite configurar o parâmetro verify de forma flexível, alternando entre verificação normal, uso de certificado personalizado e desativação da verificação.

Verificando os resultados da execução

Ao executar o código, verifique os seguintes pontos:

    • Se a comunicação for bem-sucedida.

    • Se o código de status e o conteúdo da resposta estiverem corretos.

    • Se as informações detalhadas sobre os erros forem registradas.

Esses exemplos permitem que você lide com diferentes cenários de verificação de SSL de forma prática.

Exemplo de verificação de SSL em comunicação com API

Na comunicação com APIs, a verificação de certificados SSL é particularmente importante. Certifique-se de usar as melhores práticas para garantir que os dados sejam transmitidos de maneira segura. A seguir, apresentamos exemplos de verificação de SSL em comunicações com APIs.

Verificação de SSL em APIs com autenticação

Many APIs require authentication via tokens or API keys. Here’s an example of how to send a request to an API with SSL verification enabled and the appropriate headers:

import requests

api_url = 'https://api.example.com/data'
api_key = 'your_api_key_here'

headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

# Send HTTPS request
response = requests.get(api_url, headers=headers)

if response.status_code == 200:
    print("Data fetched successfully:", response.json())
else:
    print(f"Error: {response.status_code}, Details: {response.text}")

This code ensures that the SSL certificate is verified during the API communication, maintaining a secure connection.

Internal API communication using custom certificates

For internal systems or private APIs, you may need to use a custom CA certificate. Here’s an example of how to send a request to an internal API with SSL verification using a custom certificate:

api_url = 'https://internal-api.example.com/data'
ca_cert_path = '/path/to/internal_ca_cert.pem'

# Specify the custom certificate
response = requests.get(api_url, verify=ca_cert_path)

if response.status_code == 200:
    print("Internal API communication successful:", response.json())
else:
    print(f"Error: {response.status_code}, Details: {response.text}")

Disabling SSL verification for test communication

In development environments, you may use self-signed certificates. In this case, you can disable SSL verification. However, this approach should only be used in test environments.

api_url = 'https://dev-api.example.com/data'

# Disabling SSL verification for the request
response = requests.get(api_url, verify=False)

if response.status_code == 200:
    print("Test communication successful:", response.json())
else:
    print(f"Error: {response.status_code}, Details: {response.text}")

Best practices for security improvement

Adopting the following best practices will help ensure that SSL verification is performed securely in API communications.

1.

Always enable SSL verification

Never use verify=False outside of test environments to prevent communication with untrusted servers.

2. Regularly check certificate validity

Monitor certificate expiration dates to ensure they don’t expire during operation.

openssl x509 -in /path/to/certificate.pem -noout -dates

3. Implement proper error handling

Implement error handling to log detailed error messages when SSL errors occur.

try:
    response = requests.get(api_url, verify=True)
    response.raise_for_status()
except requests.exceptions.SSLError as e:
    print(f"SSL error: {e}")
except requests.exceptions.RequestException as e:
    print(f"Communication error: {e}")

4. Utilize client certificates

For APIs requiring client authentication, configure client certificates.

api_url = 'https://secure-api.example.com/data'
client_cert = '/path/to/client_cert.pem'
client_key = '/path/to/client_key.pem'

response = requests.get(api_url, cert=(client_cert, client_key), verify=True)

if response.status_code == 200:
    print("Client authentication successful:", response.json())
else:
    print(f"Error: {response.status_code}, Details: {response.text}")

Summary

    • Proper SSL verification settings: Prioritize security by using the verify parameter to ensure safe communication.

    • Comprehensive error handling: Maintain detailed logs of communication failures to quickly identify and resolve issues.

    • Utilize custom certificates: Use custom CA certificates or client certificates for secure internal API communications.

By adopting these practices, you can implement SSL certificate verification safely and efficiently for API communication.

Conclusion

In this article, we covered how to verify SSL certificates using Python’s requests library. SSL certificates play a critical role in ensuring the security of communications. We discussed everything from basic settings to using custom certificates, troubleshooting errors, and applying SSL verification in API communication.

Here are the key takeaways for maintaining secure communication:

    • Use the default SSL verification settings to ensure secure communication.

    • Properly specify custom CA certificates for secure internal API communications.

    • Limit the use of verify=False to test environments and always enable verification in production.

By applying this knowledge, you will be able to maintain a secure and trustworthy HTTP communication environment.

Python
Biblioteca requests certificados CA comunicação API comunicação HTTPS Criptografia de Dados erros de certificado Python Segurança SSL/TLS verificação SSL
Índice