Comment vérifier les certificats SSL en utilisant la bibliothèque requests de Python

La bibliothèque requests de Python est largement utilisée pour interagir avec les API Web et effectuer des communications HTTP de manière simple. Cependant, pour assurer une communication sécurisée, il est important d’utiliser le chiffrement via le protocole SSL/TLS. La bibliothèque requests vérifie par défaut les certificats SSL, mais selon l’environnement, des erreurs peuvent survenir. Pour traiter correctement les erreurs de certificat et maintenir la sécurité des communications, il est essentiel de comprendre le mécanisme de vérification des certificats SSL et de le configurer correctement. Cet article explique de manière claire comment vérifier les certificats SSL avec la bibliothèque requests, ainsi que les solutions aux problèmes courants.

Concepts de base de la vérification des certificats SSL

Un certificat SSL (Secure Sockets Layer) chiffre les communications entre un serveur web et un client, empêchant ainsi l’écoute et la falsification des données par des tiers. Aujourd’hui, le standard TLS (Transport Layer Security) a remplacé SSL, mais le terme « certificat SSL » est toujours couramment utilisé.

Comment fonctionne un certificat SSL

Le certificat SSL est délivré par une autorité de certification (CA) et sert à prouver qu’un site web est digne de confiance. Lorsque les navigateurs ou les clients HTTP établissent une communication SSL/TLS, ils vérifient le certificat et s’assurent de ce qui suit :

1. Que l’émetteur du certificat est une CA digne de confiance
2. Que le nom de domaine cible correspond à celui du certificat
3. Que le certificat n’a pas expiré

L’importance de la vérification des certificats

La vérification des certificats SSL permet de prévenir les risques de sécurité suivants :

• Attaques par usurpation d’identité : Empêche un serveur falsifié de voler les données des utilisateurs.
• Attaques de type homme du milieu (MITM) : Réduit le risque d’écoute et de falsification des communications.

Vérifier correctement les certificats est essentiel pour assurer une communication sécurisée. La bibliothèque requests est conçue pour vérifier les certificats SSL par défaut.

Paramètres de base pour la vérification SSL avec la bibliothèque requests

La bibliothèque requests offre une fonctionnalité de vérification automatique des certificats SSL. Cela permet de garantir la sécurité des communications et de se connecter uniquement à des sites web de confiance.

Le rôle du paramètre `verify`

Dans la bibliothèque requests, le paramètre verify permet de contrôler la vérification des certificats SSL. Ce paramètre peut être configuré de deux manières :

1. True (par défaut) : Active la vérification des certificats
2. False : Désactive la vérification des certificats (non recommandé)

Le comportement par défaut est verify=True, ce qui signifie que la bibliothèque se réfère à une liste de CAs fiables pour vérifier le certificat.

Utilisation de base

Voici un exemple d’utilisation du paramètre verify.

import requests

# Vérifier le certificat SSL et envoyer une requête HTTPS
response = requests.get('https://example.com', verify=True)
print(response.status_code)

Comment désactiver la vérification des certificats

Si vous devez désactiver la vérification des certificats à des fins de test ou de débogage, vous pouvez configurer le paramètre comme suit :

import requests

# Envoyer une requête sans vérifier le certificat SSL (non recommandé)
response = requests.get('https://example.com', verify=False)
print(response.status_code)

Dans ce cas, Python affichera un avertissement. Il est également possible de supprimer cet avertissement, mais cette approche doit absolument être évitée en production.

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

# Supprimer l'avertissement
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

# Envoyer une requête sans vérifier le certificat SSL
response = requests.get('https://example.com', verify=False)
print(response.status_code)

Points à retenir

Désactiver la vérification des certificats augmente les risques de sécurité. Cela peut permettre des connexions à des sites malveillants ou exposer l’application à des attaques de type homme du milieu. Il est donc important de limiter l’utilisation de verify=False aux environnements de test ou à des situations particulières.

Désactivation de la vérification des certificats SSL et ses risques

Désactiver la vérification des certificats SSL peut parfois permettre d’éviter des erreurs de communication, mais cela entraîne de graves risques pour la sécurité. Dans la bibliothèque requests, en spécifiant verify=False, il est possible de contourner la vérification des certificats, mais son utilisation en production est fortement déconseillée.

Comment désactiver la vérification des certificats SSL

Pour désactiver la vérification des certificats, vous pouvez définir verify=False.

import requests

# Désactiver la vérification SSL
response = requests.get('https://example.com', verify=False)
print(response.text)

Cette configuration permet d’envoyer la requête sans vérifier la validité du certificat.

Risques de désactivation de la vérification des certificats

1. Vulnérabilité aux attaques de type homme du milieu (MITM)
   Désactiver la vérification permet de se connecter à des serveurs dont la fiabilité n’a pas été vérifiée. Cela expose les communications à des attaques où des attaquants peuvent intercepter et modifier les données.
2. Connexion à des serveurs usurpateurs
   Si un attaquant se fait passer pour un serveur légitime, la désactivation de la vérification permet à la connexion d’être établie malgré tout, ce qui peut entraîner des fuites d’informations sensibles.
3. Exploitation de vulnérabilités
   En ignorant le protocole SSL/TLS, on peut établir des connexions avec des serveurs vulnérables utilisant des méthodes de chiffrement obsolètes ou non sécurisées.

Les risques supplémentaires liés à l’ignorance des avertissements

Les avertissements générés par requests servent à sensibiliser aux risques de sécurité. Les supprimer avec urllib3.disable_warnings risque de faire passer sous silence des problèmes de sécurité.

# Désactiver les avertissements (non recommandé)
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

Recommandations

Au lieu de désactiver la vérification des certificats, il est préférable de résoudre le problème en suivant ces étapes :

• Installer un certificat CA digne de confiance : Assurez-vous que le certificat du serveur a été délivré correctement.
• Configurer un certificat personnalisé : Spécifiez un certificat CA particulier dans l’option verify (voir la section suivante).
• Configurer correctement le serveur : Vérifiez que le serveur utilise le bon certificat SSL.

La désactivation de la vérification des certificats doit se limiter à des fins de débogage ou de résolution de problèmes temporaires, et une connexion sécurisée doit toujours être privilégiée.

Vérification SSL avec un certificat personnalisé

Dans certains cas, vous devrez peut-être vous connecter à un serveur qui utilise un certificat SSL délivré par une autorité de certification (CA) personnalisée. Dans ces situations, vous pouvez spécifier un fichier de certificat personnalisé avec le paramètre verify pour effectuer la vérification du certificat.

Préparer un certificat CA personnalisé

Pour utiliser un certificat CA personnalisé, vous devez d’abord obtenir ce certificat (généralement au format .pem) et le sauvegarder localement. Par exemple, supposons que vous ayez un fichier de certificat appelé my_ca_cert.pem.

Utiliser un certificat personnalisé

Voici comment spécifier un certificat personnalisé dans le paramètre verify de requests :

import requests

# Utiliser un certificat CA personnalisé pour envoyer la requête
response = requests.get('https://example.com', verify='path/to/my_ca_cert.pem')
print(response.status_code)

Avec cette configuration, le certificat spécifié est utilisé pour vérifier le certificat du serveur.

Précautions concernant la chaîne de certificats

Si votre certificat CA personnalisé nécessite des certificats intermédiaires, assurez-vous que la chaîne de certificats est correctement configurée. Si vous incluez les certificats intermédiaires nécessaires dans le fichier my_ca_cert.pem, la vérification réussira plus facilement.

Exemple de vérification réussie avec un certificat personnalisé

Voici un exemple où la vérification réussit en utilisant un certificat personnalisé pour envoyer une requête HTTPS :

# Certificat valide
response = requests.get('https://securedomain.com', verify='my_ca_cert.pem')
if response.ok:
    print("Connexion réussie !")
else:
    print("Échec de la connexion. Code d'état :", response.status_code)

Solution en cas de non-reconnaissance du certificat personnalisé

1. Vérifiez le format du certificat
   Assurez-vous que le certificat est encodé en format PEM. Si le format est différent, vous pouvez le convertir à l’aide de OpenSSL.

   openssl x509 -in my_ca_cert.crt -out my_ca_cert.pem -outform PEM

2. Vérifiez le chemin du certificat
   Assurez-vous que le chemin du fichier est correct.
3. Intégrez la chaîne de certificats
   Si des certificats intermédiaires sont nécessaires, assurez-vous qu’ils sont inclus dans le certificat principal.

   cat intermediate_cert.pem >> my_ca_cert.pem

Utilisation des certificats système

Si vous utilisez fréquemment un certificat personnalisé, il peut être utile de l’ajouter au magasin de certificats CA par défaut du système. Cela vous permet de maintenir une connexion de confiance tout en simplifiant le code.

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

Recommandations

Lorsque vous utilisez des certificats personnalisés, veillez toujours à vérifier leur fiabilité. En utilisant des certificats correctement gérés, vous pouvez maintenir une communication sécurisée.

Résolution des erreurs de certificat

Lorsque vous utilisez la bibliothèque requests pour vérifier un certificat SSL, des erreurs de certificat peuvent survenir. Ces erreurs sont souvent dues à des problèmes avec le certificat lui-même ou l’environnement système. Nous allons expliquer ici les causes courantes des erreurs de certificat et comment les résoudre.

Erreurs courantes et leurs causes

1. Le certificat n’est pas reconnu (Certificate verify failed)
   Cette erreur se produit lorsque le certificat du serveur n’est pas signé par une autorité de certification (CA) ou lorsque le certificat CA est absent du magasin de confiance du système.
   Message d’exception :

   requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED]

2. Certificat expiré (Expired certificate)
   Cette erreur se produit lorsque le certificat du serveur a dépassé sa date d’expiration.
3. Nom de domaine du certificat incorrect (Hostname mismatch)
   Cette erreur se produit lorsque le nom de domaine du certificat (Common Name ou SAN) ne correspond pas au nom de domaine de l’URL demandée.
4. Chaîne de certificats incomplète (Incomplete certificate chain)
   Cette erreur se produit lorsque le serveur ne fournit pas tous les certificats intermédiaires nécessaires.

Solutions aux erreurs

1. Ajouter un certificat CA

Si l’erreur est due à un certificat non reconnu, vous pouvez fournir un certificat CA personnalisé et le spécifier dans le paramètre verify.

import requests

# Utiliser un certificat CA personnalisé
response = requests.get('https://example.com', verify='path/to/ca_cert.pem')
print(response.status_code)

2. Mettre à jour le magasin de certificats CA du système

Si le magasin de certificats du système est obsolète, des erreurs de certificat peuvent survenir. Vous pouvez mettre à jour le magasin de certificats en utilisant la commande suivante :

• 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. Vérifier le certificat du serveur

Si le certificat du serveur est expiré ou que le nom de domaine ne correspond pas, vous devrez contacter l’administrateur du serveur pour qu’il mette à jour ou corrige le certificat. Vous pouvez vérifier le certificat du serveur avec la commande openssl.

openssl s_client -connect example.com:443 -showcerts

4. Intégrer les certificats intermédiaires

Si des certificats intermédiaires manquent, vous devez construire et intégrer la chaîne de certificats.

cat intermediate_cert.pem >> server_cert.pem

5. Solution temporaire (non recommandée)

Si vous devez absolument contourner l’erreur de certificat, vous pouvez définir verify=False pour désactiver la vérification. Cependant, cela augmente les risques de sécurité et ne doit pas être utilisé en production.

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

Meilleures pratiques pour résoudre les erreurs

• Mettre régulièrement à jour le magasin de certificats CA du système.
• Vérifier que le certificat du serveur est correctement configuré.
• Utiliser un certificat CA personnalisé lorsque cela est nécessaire pour garantir une communication sécurisée.

Ces méthodes vous permettront de résoudre efficacement les erreurs liées aux certificats SSL et d’assurer une communication sécurisée.

Utilisation d’outils externes pour vérifier les certificats

Pour résoudre les problèmes liés aux certificats SSL, vous devez examiner les détails du certificat et identifier la cause du problème. Il est très efficace d’utiliser des outils externes pour inspecter les certificats, et non seulement la bibliothèque requests. Nous expliquerons ici les outils qui peuvent vous aider à vérifier les certificats et comment les utiliser.

Vérification des certificats avec OpenSSL

OpenSSL est un outil largement utilisé pour gérer les communications SSL/TLS et les certificats. Il est utile pour obtenir et vérifier le certificat d’un serveur.

Obtenir le certificat d’un serveur

Voici la commande pour obtenir le certificat d’un serveur spécifié et afficher ses détails.

openssl s_client -connect example.com:443 -showcerts

Exemple de sortie :

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

Vérification de la date d’expiration du certificat

Pour vérifier la date d’expiration d’un certificat, vous pouvez utiliser la commande suivante.

openssl x509 -in server_cert.pem -noout -dates

Exemple de sortie :

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

Vérification des certificats CA avec certifi

La bibliothèque requests de Python utilise par défaut la bibliothèque certifi pour gérer les certificats CA fiables. Avec certifi, vous pouvez vérifier la liste actuelle des certificats CA.

Installer certifi

Si certifi n’est pas installé, vous pouvez l’installer avec la commande suivante.

pip install certifi

Vérification du chemin du certificat avec certifi

Pour vérifier le chemin du certificat CA actuellement utilisé, exécutez le code suivant.

import certifi

# Afficher le chemin du certificat CA
print(certifi.where())

Exemple de sortie :

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

Vérification des certificats avec un navigateur

Vous pouvez également vérifier les certificats SSL directement dans un navigateur. Sur Chrome ou Firefox, suivez ces étapes :

1. Accédez au site web : Rendez-vous sur le site concerné (par exemple, https://example.com).
2. Afficher les informations sur le certificat :

• Chrome : Cliquez sur l’icône du cadenas dans la barre d’adresse, puis sélectionnez « Détails ».
• Firefox : Cliquez sur l’icône du cadenas et sélectionnez « Détails de la connexion ».

1. Vérifiez les détails du certificat : Vérifiez l’émetteur, le domaine cible, et la date d’expiration.

Points à vérifier lors de la validation

• Correspondance des noms de domaine : Vérifiez que le CN ou SAN du certificat correspond au domaine auquel vous accédez.
• Présence des certificats intermédiaires : Vérifiez que la chaîne de certificats est correcte et contient tous les certificats intermédiaires nécessaires.
• Date d’expiration : Assurez-vous que le certificat n’est pas expiré.

Choisir l’outil approprié

• Pour obtenir un certificat depuis le serveur : Utilisez OpenSSL.
• Pour vérifier la liste des CA de confiance de requests : Utilisez certifi.
• Pour examiner directement les informations sur le certificat : Utilisez un navigateur.

Ces outils vous permettront d’analyser efficacement les problèmes liés aux certificats SSL et de recueillir les informations importantes pour maintenir un environnement de communication sécurisé.

Exemples pratiques de vérification SSL avec requests

Dans cette section, nous présentons des exemples concrets de code pour vérifier un certificat SSL en utilisant la bibliothèque requests de Python. Nous couvrirons les méthodes de base ainsi que l’utilisation de certificats personnalisés.

Exemple de vérification SSL de base

La bibliothèque requests vérifie par défaut les certificats SSL. Voici un exemple de requête HTTPS avec la vérification du certificat activée.

import requests

# Requête HTTPS vérifiée
url = 'https://www.google.com'
response = requests.get(url)

print(f"Code d'état : {response.status_code}")
print(f"En-têtes de réponse : {response.headers}")

Si la vérification du certificat réussit, le code d’état HTTP et les en-têtes de réponse seront affichés.

Exemple d’erreur de vérification SSL

Si la vérification du certificat échoue, une exception requests.exceptions.SSLError sera levée. Voici un exemple d’erreur causée par un certificat auto-signé.

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

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

Dans cet exemple, l’erreur est causée par un certificat émis par une autorité de certification non fiable.

Exemple d’utilisation d’un certificat CA personnalisé

Voici un exemple d’utilisation d’un certificat CA personnalisé pour effectuer une vérification SSL.

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

# Utiliser un certificat personnalisé pour la vérification
response = requests.get(url, verify=ca_cert_path)

print(f"Code d'état : {response.status_code}")
print(f"Corps de la réponse : {response.text}")

Dans cet exemple, le chemin du certificat CA personnalisé est spécifié dans le paramètre verify, et le certificat du serveur est vérifié.

Exemple de désactivation de la vérification SSL (non recommandée)

Voici un exemple de désactivation de la vérification SSL pour envoyer une requête. Cette méthode n’est pas recommandée sauf pour les environnements de test.

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

# Désactiver la vérification SSL
response = requests.get(url, verify=False)

print(f"Code d'état : {response.status_code}")
print(f"Corps de la réponse : {response.text}")

Cette méthode désactive la vérification du certificat SSL, et Python générera un avertissement à ce sujet.

Activer les journaux détaillés pour la vérification SSL

Lors du débogage des problèmes de vérification SSL, activer les journaux détaillés peut fournir des informations utiles sur le processus de vérification.

import requests
import logging

# Activer les journaux
logging.basicConfig(level=logging.DEBUG)

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

print(f"Code d'état : {response.status_code}")

Les journaux afficheront des informations détaillées sur la poignée de connexion TLS et les certificats, ce qui peut aider à diagnostiquer des problèmes.

Exemple complet : Fonction traitant plusieurs cas

Voici un exemple de fonction générique qui gère la vérification SSL réussie ou échouée en fonction des paramètres fournis.

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"Erreur SSL : {e}"
    except Exception as e:
        return f"Autre erreur : {e}"

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

Cette fonction permet de configurer facilement la vérification SSL, d’utiliser un certificat personnalisé ou de désactiver la vérification selon les besoins.

Vérification des résultats d’exécution

Exécutez le code et vérifiez les points suivants :

• La communication a-t-elle réussi ?
• Le code d’état et le contenu de la réponse sont-ils corrects ?
• Les informations détaillées sont-elles obtenues en cas d’erreur ?

Ces exemples vous permettent de traiter différents scénarios de vérification SSL de manière efficace.

Cas d’utilisation avancés : Vérification SSL dans les communications API

Dans les communications API, il est particulièrement important de vérifier correctement les certificats SSL. Cela empêche les connexions à des serveurs non autorisés et garantit la sécurité des échanges de données. Voici un exemple d’utilisation de la vérification SSL dans les communications API.

Vérification SSL pour une API nécessitant une authentification

De nombreuses API nécessitent une authentification via un token ou une clé API. Voici comment activer la vérification SSL et envoyer une requête avec les en-têtes appropriés.

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

# Envoyer une requête HTTPS
response = requests.get(api_url, headers=headers)

if response.status_code == 200:
    print("Données récupérées avec succès :", response.json())
else:
    print(f"Erreur : {response.status_code}, Détails : {response.text}")

Dans cet exemple, la vérification SSL est effectuée pendant la communication API pour garantir une transmission sécurisée des données.

Communication API interne avec certificat personnalisé

Les systèmes internes ou les API privées peuvent utiliser des certificats CA personnalisés. Dans ce cas, vous devez spécifier un certificat CA personnalisé pour envoyer la requête.

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

# Spécifier un certificat personnalisé
response = requests.get(api_url, verify=ca_cert_path)

if response.status_code == 200:
    print("Communication API réussie :", response.json())
else:
    print(f"Erreur : {response.status_code}, Détails : {response.text}")

Test de communication avec vérification SSL désactivée

Dans un environnement de développement, il peut être nécessaire d’utiliser un certificat auto-signé. Vous pouvez désactiver la vérification SSL pour tester la communication. Cependant, cela doit être limité aux environnements de test uniquement.

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

# Désactiver la vérification SSL
response = requests.get(api_url, verify=False)

if response.status_code == 200:
    print("Test de communication réussi :", response.json())
else:
    print(f"Erreur : {response.status_code}, Détails : {response.text}")

Meilleures pratiques pour renforcer la sécurité

Pour effectuer correctement la vérification SSL dans les communications API, adoptez les meilleures pratiques suivantes.

1. Toujours activer la vérification SSL

Évitez d’utiliser verify=False en dehors des environnements de test. Cela vous aide à prévenir les connexions avec des serveurs non autorisés.

2. Vérifiez régulièrement la validité des certificats

Assurez-vous que les certificats utilisés ne sont pas expirés et surveillez leur date d’expiration.

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

3. Implémentez un traitement des erreurs approprié

En cas d’erreur SSL, implémentez un traitement des exceptions pour enregistrer des informations détaillées sur l’erreur.

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

4. Utilisez des certificats client pour l’authentification

Si l’API nécessite une authentification par certificat client, vous pouvez configurer les certificats nécessaires dans la requête.

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("Authentification client réussie :", response.json())
else:
    print(f"Erreur : {response.status_code}, Détails : {response.text}")

Résumé

• Configurer correctement la vérification SSL : Priorisez la sécurité en utilisant le paramètre verify pour garantir une communication sécurisée.
• Traiter les erreurs de manière rigoureuse : Enregistrez les journaux détaillés en cas d’échec de la communication pour faciliter l’identification et la résolution des problèmes.
• Utiliser des certificats personnalisés : Utilisez des certificats CA personnalisés ou des certificats client pour sécuriser les communications avec des API internes.

En appliquant ces pratiques, vous pouvez effectuer la vérification SSL dans les communications API de manière sécurisée et efficace.

Conclusion

Dans cet article, nous avons exploré l’utilisation de la bibliothèque requests de Python pour vérifier les certificats SSL. Les certificats SSL jouent un rôle essentiel pour garantir la sécurité des communications. Nous avons couvert les configurations de base, l’utilisation de certificats personnalisés, la résolution des erreurs et des exemples pratiques dans les communications API.

Pour maintenir une communication sécurisée, voici les points essentiels à retenir :

• Utilisez la configuration par défaut de la vérification des certificats SSL pour garantir une communication sécurisée.
• Spécifiez correctement les certificats CA personnalisés pour sécuriser les communications avec des API internes.
• Ne désactivez la vérification des certificats que pour les environnements de test et activez-la toujours en production.

En appliquant ces principes, vous pouvez garantir des communications HTTP plus sûres et fiables.