La simulation de connexion est une étape cruciale en web scraping lorsqu'il s'agit d'accéder à des données protégées par une authentification. Cette technique consiste à reproduire le comportement d'un navigateur via des scripts, généralement en utilisant la bibliothèque requests de Python.

1. Mécanismes fondamentaux de l'authentification web

Pour simuler une connexion, le script envoie une requête POST vers le serveur d'authentification avec les identifiants requis. Une fois validé, le serveur renvoie des indicateurs de session, souvent sous forme de Cookies ou de Tokens (comme le format JWT). Ces éléments servent de preuve d'identité pour les requêtes ultérieures.

Il est essentiel de noter que ces identifiants ont souvent une durée de validité limitée et qu'ils ne sont pas nécessaires dans l'en-tête de la requête de connexion initiale, car ils résultent justement de cette étape.

2. Gestion des Cookies et des Sessions

2.1 Manipulation manuelle des Cookies

La méthode la plus basique consiste à extraire manuellement les cookies depuis les outils de développement du navigateur et à les injecter dans le script. Bien que simple pour des tests ponctuels, cette approche est peu robuste face à l'expiration des sessions.

import requests

# URL cible nécessitant une authentification
target_url = "https://api.exemple.com/user/profile"

# Définition des en-têtes avec le cookie récupéré manuellement
custom_headers = {
    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
    "Cookie": "session_id=abc123xyz789; security_token=987654321"
}

response = requests.get(url=target_url, headers=custom_headers)

if response.status_code == 200:
    with open("page_privee.html", "w", encoding="utf-8") as f:
        f.write(response.text)

2.2 Automatisation avec l'objet Session

Pour une gestion efficace et automatique, la classe requests.Session est recommandée. Elle permet de conserver les cookies envoyés par le serveur et de les réinjecter automatiquement dans les requêtes suivantes, simulant ainsi parfaitement la persistance d'une session de navigation.

import requests

# Initialisation d'une session persistante
client_session = requests.Session()

# Première requête pour charger les cookies de base ou un jeton CSRF
login_page_url = "https://service.exemple.com/login"
client_session.get(login_page_url)

# Les requêtes suivantes via client_session utiliseront les cookies stockés

3. Cas pratique : Connexion avec traitement de CAPTCHA

Dans un scénario réel, il est fréquent de rencontrer des protections supplémentaires comme des jetons CSRF ou des codes CAPTCHA. Voici une structure logique pour gérer ce type de flux :

import requests
from lxml import etree

# Paramètres de connexion
AUTH_URL = "http://site-exemple.org/login/"
AGENT_STRING = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"

http_session = requests.Session()
http_session.headers.update({"User-Agent": AGENT_STRING})

# 1. Récupération de la page de login pour extraire les paramètres cachés (CSRF)
initial_response = http_session.get(AUTH_URL)
html_parser = etree.HTML(initial_response.text)

# Extraction du lien de l'image CAPTCHA via XPath
captcha_path = html_parser.xpath('//img[@id="captcha_img"]/@src')[0]
captcha_full_url = "http://site-exemple.org" + captcha_path

# 2. Téléchargement de l'image de vérification
captcha_data = http_session.get(captcha_full_url).content
with open("verify.png", "wb") as img_file:
    img_file.write(captcha_data)

# 3. Résolution du CAPTCHA (via un service tiers ou OCR)
# résolu_code = solve_captcha("verify.png")
résolu_code = input("Veuillez entrer le code CAPTCHA : ")

# 4. Soumission du formulaire de connexion
payload = {
    "username": "mon_utilisateur",
    "password": "ma_cle_secrete",
    "captcha_field": résolu_code,
    "csrf_token": html_parser.xpath('//input[@name="csrf"]/@value')[0]
}

post_headers = {
    "Referer": AUTH_URL,
    "Origin": "http://site-exemple.org"
}

final_response = http_session.post(AUTH_URL, data=payload, headers=post_headers)

if "Tableau de bord" in final_response.text:
    print("Connexion réussie.")
else:
    print("Échec de l'authentification.")

Cette approche garantit que les cookies de session sont correctement synchronisés entre l'étape de visualisation du CAPTCHA et l'envoi du formulaire POST, ce qui est indispensable pour que le serveur valide la réponse.