try to use proxy for gmx mail
This commit is contained in:
@@ -0,0 +1,534 @@
|
||||
"""
|
||||
imap_proxy_reader.py
|
||||
====================
|
||||
Lire des emails via IMAPClient en passant par un proxy SOCKS5/SOCKS4/HTTP.
|
||||
|
||||
Fonctionnement :
|
||||
- ProxyIMAP4_TLS : sous-classe de imaplib.IMAP4 qui ouvre la socket
|
||||
à travers un proxy SOCKS via PySocks.
|
||||
- ProxyIMAPClient : sous-classe de IMAPClient qui injecte ProxyIMAP4_TLS
|
||||
au lieu de la connexion directe habituelle.
|
||||
|
||||
Dépendances :
|
||||
pip install imapclient PySocks
|
||||
"""
|
||||
|
||||
import datetime
|
||||
import email
|
||||
import imaplib
|
||||
import io
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import ssl
|
||||
import socket
|
||||
from dataclasses import dataclass, field
|
||||
from email.message import Message
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
import socks
|
||||
from dotenv import load_dotenv
|
||||
from imapclient import IMAPClient
|
||||
|
||||
load_dotenv()
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Constantes
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
VALIDATION_URL_SUBJECT_FR = "Validation de votre demande de rendez-vous"
|
||||
VALIDATION_URL_SUBJECT_EN = "Please confirm your appointment request"
|
||||
VALIDATION_URL_REGEX = (
|
||||
r"https:\/\/rendezvousparis\.hermes\.com"
|
||||
r"\/client\/register\/[A-Z0-9]+\/validate\.code=[A-Z0-9]+"
|
||||
)
|
||||
|
||||
DATE_FORMAT = "%d-%b-%Y"
|
||||
|
||||
# Correspondance domaine → serveur IMAP (identique à mail_constants.py)
|
||||
IMAP_SERVER_MAP: List[Tuple[str, str]] = [
|
||||
("163.com", "imap.163.com"),
|
||||
("yahoo.com", "imap.mail.yahoo.com"),
|
||||
("firemail.de", "imap.firemail.de"),
|
||||
("gmail.com", "imap.gmail.com"),
|
||||
("sina.com", "imap.sina.com"),
|
||||
("hotmail.com", "outlook.office365.com"),
|
||||
("outlook.com", "outlook.office365.com"),
|
||||
("rambler.ru", "imap.rambler.ru"),
|
||||
("btvm.ne.jp", "imap.btvm.ne.jp"),
|
||||
("mars.dti.ne.jp", "imap.cm.dream.jp"),
|
||||
("aurora.dti.ne.jp", "imap.cm.dream.jp"),
|
||||
("naver.com", "imap.naver.com"),
|
||||
("onet.pl", "imap.poczta.onet.pl"),
|
||||
("gazeta.pl", "imap.gazeta.pl"),
|
||||
("tim.it", "imap.tim.it"),
|
||||
("alice.it", "in.alice.it"),
|
||||
("gmx.com", "imap.gmx.com"),
|
||||
("gmx.fr", "imap.gmx.com"),
|
||||
("gmx.us", "imap.gmx.com"),
|
||||
("gmx.ch", "imap.gmx.com"),
|
||||
("gmx.pt", "imap.gmx.com"),
|
||||
("gmx.sg", "imap.gmx.com"),
|
||||
("gmx.net", "imap.gmx.net"),
|
||||
("gmx.de", "imap.gmx.net"),
|
||||
("gmx.at", "imap.gmx.at"),
|
||||
("web.de", "imap.web.de"),
|
||||
("inbox.lv", "mail.inbox.lv"),
|
||||
("pissmail.com", "mail.pissmail.com"),
|
||||
("incel.email", "mail.pissmail.com"),
|
||||
("shitposting.expert","mail.pissmail.com"),
|
||||
("hatesje.ws", "mail.pissmail.com"),
|
||||
("child.pizza", "mail.pissmail.com"),
|
||||
("genocide.fun", "mail.pissmail.com"),
|
||||
("dmc.chat", "mail.pissmail.com"),
|
||||
("aol.com", "imap.aol.com"), # fallback AOL
|
||||
]
|
||||
|
||||
PROXY_TYPE_MAP = {
|
||||
"SOCKS5": socks.SOCKS5,
|
||||
"SOCKS4": socks.SOCKS4,
|
||||
"HTTP": socks.HTTP,
|
||||
}
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Modèles de données
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
@dataclass
|
||||
class ProxyConfig:
|
||||
"""Configuration du proxy."""
|
||||
host: str
|
||||
port: int
|
||||
proxy_type: str = "SOCKS5" # "SOCKS5" | "SOCKS4" | "HTTP"
|
||||
username: Optional[str] = None
|
||||
password: Optional[str] = None
|
||||
|
||||
@property
|
||||
def socks_type(self) -> int:
|
||||
t = self.proxy_type.upper()
|
||||
if t not in PROXY_TYPE_MAP:
|
||||
raise ValueError(f"proxy_type invalide : {self.proxy_type!r}. "
|
||||
f"Valeurs autorisées : {list(PROXY_TYPE_MAP)}")
|
||||
return PROXY_TYPE_MAP[t]
|
||||
|
||||
def __repr__(self) -> str:
|
||||
auth = f"{self.username}:***@" if self.username else ""
|
||||
return f"{self.proxy_type}://{auth}{self.host}:{self.port}"
|
||||
|
||||
|
||||
@dataclass
|
||||
class MailAccount:
|
||||
"""Compte email à lire."""
|
||||
login: str
|
||||
password: str
|
||||
|
||||
|
||||
@dataclass
|
||||
class MailResult:
|
||||
"""Résultat d'une lecture d'email."""
|
||||
account: str
|
||||
subject: str
|
||||
from_address: str
|
||||
to_address: str
|
||||
body: str
|
||||
validation_urls: List[str] = field(default_factory=list)
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Connexion IMAP via proxy (bas niveau)
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
class ProxyIMAP4_TLS(imaplib.IMAP4):
|
||||
"""
|
||||
Variante TLS de imaplib.IMAP4 qui route la connexion
|
||||
à travers un proxy SOCKS5/SOCKS4/HTTP grâce à PySocks.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
host: str,
|
||||
port: int,
|
||||
ssl_context: Optional[ssl.SSLContext],
|
||||
proxy: ProxyConfig,
|
||||
timeout: Optional[float] = None,
|
||||
):
|
||||
self._ssl_context = ssl_context
|
||||
self._proxy = proxy
|
||||
self._timeout = timeout
|
||||
# imaplib.IMAP4.__init__ appelle self.open()
|
||||
imaplib.IMAP4.__init__(self, host, port)
|
||||
self.file: io.BufferedReader
|
||||
|
||||
def open(self, host: str = "", port: int = 993, timeout: Optional[float] = None) -> None:
|
||||
self.host = host
|
||||
self.port = port
|
||||
effective_timeout = timeout if timeout is not None else self._timeout
|
||||
|
||||
# ── Créer la socket SOCKS ────────────────────────────
|
||||
sock = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
sock.set_proxy(
|
||||
proxy_type=self._proxy.socks_type,
|
||||
addr=self._proxy.host,
|
||||
port=self._proxy.port,
|
||||
username=self._proxy.username,
|
||||
password=self._proxy.password,
|
||||
)
|
||||
if effective_timeout:
|
||||
sock.settimeout(effective_timeout)
|
||||
sock.connect((host, port))
|
||||
|
||||
# ── Envelopper avec SSL/TLS ──────────────────────────
|
||||
ctx = self._ssl_context or ssl.create_default_context()
|
||||
self.sock = ctx.wrap_socket(sock, server_hostname=host)
|
||||
self.file = self.sock.makefile("rb")
|
||||
|
||||
# ── Méthodes requises par imaplib.IMAP4 ─────────────────
|
||||
def read(self, size: int) -> bytes:
|
||||
return self.file.read(size) # type: ignore[return-value]
|
||||
|
||||
def readline(self) -> bytes:
|
||||
return self.file.readline() # type: ignore[return-value]
|
||||
|
||||
def send(self, data) -> None:
|
||||
self.sock.sendall(data)
|
||||
|
||||
def shutdown(self) -> None:
|
||||
imaplib.IMAP4.shutdown(self)
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# IMAPClient avec proxy
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
class ProxyIMAPClient(IMAPClient):
|
||||
"""
|
||||
Sous-classe d'IMAPClient qui utilise un proxy SOCKS/HTTP.
|
||||
|
||||
Usage :
|
||||
proxy = ProxyConfig(host="127.0.0.1", port=1080, proxy_type="SOCKS5")
|
||||
client = ProxyIMAPClient("imap.gmail.com", proxy=proxy, use_uid=True)
|
||||
client.login("user@gmail.com", "password")
|
||||
"""
|
||||
|
||||
def __init__(self, host: str, proxy: ProxyConfig, **kwargs):
|
||||
self._proxy = proxy
|
||||
super().__init__(host, **kwargs)
|
||||
|
||||
def _create_IMAP4(self):
|
||||
"""Remplace la méthode d'IMAPClient pour injecter ProxyIMAP4_TLS."""
|
||||
if self.ssl:
|
||||
return ProxyIMAP4_TLS(
|
||||
host=self.host,
|
||||
port=self.port,
|
||||
ssl_context=self.ssl_context,
|
||||
proxy=self._proxy,
|
||||
timeout=getattr(self._timeout, "connect", None),
|
||||
)
|
||||
# Connexion non-SSL à travers le proxy (rare, mais supporté)
|
||||
# On monkey-patch juste la connexion TCP
|
||||
raise NotImplementedError(
|
||||
"Connexion IMAP non-SSL via proxy non implémentée. "
|
||||
"Utilisez ssl=True (port 993)."
|
||||
)
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Fonctions utilitaires
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
def get_imap_server(login: str) -> str:
|
||||
"""Retourne le serveur IMAP correspondant au domaine du login."""
|
||||
login_lower = login.lower()
|
||||
for domain, server in IMAP_SERVER_MAP:
|
||||
if domain in login_lower:
|
||||
return server
|
||||
return "imap.aol.com" # fallback
|
||||
|
||||
|
||||
def extract_body(email_message: Message) -> str:
|
||||
"""Extrait le corps HTML ou texte d'un email."""
|
||||
body = ""
|
||||
for part in email_message.walk():
|
||||
content_type = part.get_content_type()
|
||||
try:
|
||||
if content_type == "text/html":
|
||||
payload = part.get_payload(decode=True)
|
||||
if payload:
|
||||
body += payload.decode("utf-8", errors="ignore")
|
||||
elif content_type == "text/plain":
|
||||
payload = part.get_payload()
|
||||
if payload:
|
||||
body += str(payload)
|
||||
except Exception as exc:
|
||||
logger.warning("Erreur extraction body : %s", exc)
|
||||
return body
|
||||
|
||||
|
||||
def find_validation_urls(text: str) -> List[str]:
|
||||
"""Recherche toutes les URLs de validation Hermes dans un texte."""
|
||||
return re.findall(VALIDATION_URL_REGEX, text)
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Lecteur principal
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
class ProxyMailReader:
|
||||
"""
|
||||
Lit les emails d'un compte via IMAPClient en passant par un proxy.
|
||||
|
||||
Paramètres
|
||||
----------
|
||||
account : MailAccount
|
||||
Identifiants du compte email.
|
||||
proxy : ProxyConfig
|
||||
Configuration du proxy.
|
||||
timeout : float, optional
|
||||
Timeout de connexion en secondes (défaut : 30 s).
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
account: MailAccount,
|
||||
proxy: ProxyConfig,
|
||||
timeout: float = 30.0,
|
||||
):
|
||||
self.account = account
|
||||
self.proxy = proxy
|
||||
self.timeout = timeout
|
||||
|
||||
# ── Connexion ────────────────────────────────────────────
|
||||
|
||||
def _connect(self) -> ProxyIMAPClient:
|
||||
imap_server = get_imap_server(self.account.login)
|
||||
logger.info(
|
||||
"[%s] Connexion via %s → %s:993",
|
||||
self.account.login, self.proxy, imap_server,
|
||||
)
|
||||
client = ProxyIMAPClient(
|
||||
host=imap_server,
|
||||
proxy=self.proxy,
|
||||
use_uid=True,
|
||||
ssl=True,
|
||||
timeout=self.timeout,
|
||||
)
|
||||
client.login(self.account.login, self.account.password)
|
||||
logger.info("[%s] Connecté.", self.account.login)
|
||||
return client
|
||||
|
||||
# ── Lecture des dossiers ─────────────────────────────────
|
||||
|
||||
def _list_folders(self, client: ProxyIMAPClient) -> List[str]:
|
||||
return [info[-1] for info in client.list_folders()]
|
||||
|
||||
# ── Lecture des messages ─────────────────────────────────
|
||||
|
||||
def _read_folder(
|
||||
self,
|
||||
client: ProxyIMAPClient,
|
||||
folder: str,
|
||||
since: Optional[datetime.datetime] = None,
|
||||
) -> List[MailResult]:
|
||||
results: List[MailResult] = []
|
||||
since = since or datetime.datetime.today()
|
||||
|
||||
try:
|
||||
client.select_folder(folder, readonly=True)
|
||||
except Exception as exc:
|
||||
logger.warning("[%s] Impossible d'ouvrir '%s' : %s",
|
||||
self.account.login, folder, exc)
|
||||
return results
|
||||
|
||||
try:
|
||||
uids = client.search(["SINCE", since])
|
||||
except Exception as exc:
|
||||
logger.warning("[%s] Recherche échouée dans '%s' : %s",
|
||||
self.account.login, folder, exc)
|
||||
return results
|
||||
|
||||
if not uids:
|
||||
return results
|
||||
|
||||
logger.info("[%s] %d message(s) dans '%s'",
|
||||
self.account.login, len(uids), folder)
|
||||
|
||||
for uid, msg_data in client.fetch(uids, "RFC822").items():
|
||||
try:
|
||||
raw = msg_data.get(b"RFC822") or msg_data.get("RFC822")
|
||||
if raw is None:
|
||||
continue
|
||||
em = email.message_from_bytes(raw)
|
||||
|
||||
subject = em.get("Subject", "")
|
||||
from_addr = em.get("From", "")
|
||||
to_addr = em.get("To", self.account.login)
|
||||
|
||||
# Filtrer : on ne garde que les emails de validation Hermes
|
||||
is_validation = (
|
||||
VALIDATION_URL_SUBJECT_FR in subject
|
||||
or VALIDATION_URL_SUBJECT_EN in subject
|
||||
or "no-reply@hermes.com" in from_addr.lower()
|
||||
)
|
||||
if not is_validation:
|
||||
continue
|
||||
|
||||
body = extract_body(em)
|
||||
urls = find_validation_urls(body)
|
||||
|
||||
result = MailResult(
|
||||
account=self.account.login,
|
||||
subject=subject,
|
||||
from_address=from_addr,
|
||||
to_address=to_addr,
|
||||
body=body,
|
||||
validation_urls=urls,
|
||||
)
|
||||
results.append(result)
|
||||
logger.info(
|
||||
"[%s] Email de validation trouvé (uid=%s) — URLs : %s",
|
||||
self.account.login, uid, urls or "aucune",
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.warning(
|
||||
"[%s] Erreur traitement uid=%s : %s",
|
||||
self.account.login, uid, exc,
|
||||
)
|
||||
|
||||
return results
|
||||
|
||||
# ── Point d'entrée public ────────────────────────────────
|
||||
|
||||
def read(
|
||||
self,
|
||||
since: Optional[datetime.datetime] = None,
|
||||
skip_folders: Optional[List[str]] = None,
|
||||
) -> List[MailResult]:
|
||||
"""
|
||||
Se connecte au serveur IMAP via le proxy et retourne la liste
|
||||
des emails de validation trouvés depuis `since` (aujourd'hui par défaut).
|
||||
|
||||
Paramètres
|
||||
----------
|
||||
since : datetime, optional — date de début de recherche
|
||||
skip_folders : list[str], optional — dossiers à ignorer
|
||||
(défaut : ["Sent", "Drafts", "Trash", "Junk", "Spam"])
|
||||
"""
|
||||
if skip_folders is None:
|
||||
skip_folders = ["Sent", "Drafts", "Trash", "Junk", "Spam"]
|
||||
|
||||
all_results: List[MailResult] = []
|
||||
client = self._connect()
|
||||
|
||||
try:
|
||||
folders = self._list_folders(client)
|
||||
logger.info("[%s] Dossiers : %s", self.account.login, folders)
|
||||
|
||||
for folder in folders:
|
||||
if folder in skip_folders:
|
||||
logger.debug("[%s] Dossier ignoré : %s",
|
||||
self.account.login, folder)
|
||||
continue
|
||||
all_results.extend(self._read_folder(client, folder, since))
|
||||
finally:
|
||||
try:
|
||||
client.logout()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return all_results
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Lecture parallèle de plusieurs comptes
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
|
||||
def read_multiple_accounts(
|
||||
accounts: List[MailAccount],
|
||||
proxy: ProxyConfig,
|
||||
since: Optional[datetime.datetime] = None,
|
||||
max_workers: int = 10,
|
||||
timeout: float = 30.0,
|
||||
) -> List[MailResult]:
|
||||
"""
|
||||
Lit plusieurs comptes email en parallèle via le même proxy.
|
||||
|
||||
Retourne la liste consolidée de tous les MailResult trouvés.
|
||||
"""
|
||||
all_results: List[MailResult] = []
|
||||
|
||||
with ThreadPoolExecutor(max_workers=max_workers) as executor:
|
||||
future_map = {
|
||||
executor.submit(
|
||||
ProxyMailReader(acc, proxy, timeout).read, since
|
||||
): acc.login
|
||||
for acc in accounts
|
||||
}
|
||||
for future in as_completed(future_map):
|
||||
login = future_map[future]
|
||||
try:
|
||||
results = future.result()
|
||||
logger.info("[%s] %d email(s) de validation récupéré(s).",
|
||||
login, len(results))
|
||||
all_results.extend(results)
|
||||
except Exception as exc:
|
||||
logger.error("[%s] Erreur : %s", login, exc)
|
||||
|
||||
return all_results
|
||||
|
||||
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
# Point d'entrée — exemple d'utilisation
|
||||
# ──────────────────────────────────────────────────────────────
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)-8s %(message)s",
|
||||
datefmt="%H:%M:%S",
|
||||
)
|
||||
|
||||
# ── 1. Configurer le proxy ───────────────────────────────
|
||||
proxy = ProxyConfig(
|
||||
host=os.environ.get("GMX_PROXY_HOST", ""),
|
||||
port=int(os.environ.get("GMX_PROXY_PORT", "443")),
|
||||
proxy_type=os.environ.get("GMX_PROXY_TYPE", "SOCKS5"),
|
||||
username=os.environ.get("GMX_PROXY_USERNAME"),
|
||||
password=os.environ.get("GMX_PROXY_PASSWORD"),
|
||||
)
|
||||
|
||||
# ── 2. Définir les comptes à lire ────────────────────────
|
||||
accounts = [
|
||||
MailAccount(login="birgitnaya@gmx.net", password="XEeUF3Y1yaO"),
|
||||
# MailAccount(login="user@gmail.com", password="apppassword"),
|
||||
# MailAccount(login="user@outlook.com", password="password"),
|
||||
]
|
||||
|
||||
# ── 3. Lancer la lecture ─────────────────────────────────
|
||||
results = read_multiple_accounts(
|
||||
accounts=accounts,
|
||||
proxy=proxy,
|
||||
since=datetime.datetime.today(),
|
||||
max_workers=5,
|
||||
timeout=30.0,
|
||||
)
|
||||
|
||||
# ── 4. Afficher les résultats ────────────────────────────
|
||||
print(f"\n{'='*60}")
|
||||
print(f" {len(results)} email(s) de validation trouvé(s)")
|
||||
print(f"{'='*60}\n")
|
||||
|
||||
for r in results:
|
||||
print(f" Compte : {r.account}")
|
||||
print(f" De : {r.from_address}")
|
||||
print(f" Sujet : {r.subject}")
|
||||
print(f" URLs : {r.validation_urls or 'aucune'}")
|
||||
print(f" {'-'*56}")
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user