feat: auth fail-closed, regles par defaut idempotentes et conteneur non root (tt-2026-11-061)

This commit is contained in:
gemini-ops committed 2026-11-17 13:09:53 +01:00
1 parent b51a8bba69
commit 6aef9e83e7
11 files changed
+424 -95

No files matched your search

+38 -35
View File
@@ -5,15 +5,36 @@ from typing import Dict, Any, Optional
from fastapi import Request, HTTPException, Security
from fastapi.security import APIKeyHeader
import jwt
from app.config import CF_ACCESS_CERTS_URL, CF_ACCESS_AUD, CF_TEST_SECRET
from app.config import ENV, CF_ACCESS_CERTS_URL, CF_ACCESS_AUD, CF_TEST_SECRET
cf_access_header = APIKeyHeader(name="Cf-Access-Jwt-Assertion", auto_error=False)
def verify_cf_access_jwt(request: Request) -> Dict[str, Any]:
"""
Vérifie la présence et la validité du jeton Cloudflare Access.
Rejette toute requête sans jeton ou avec un jeton invalide (HTTP 401).
Vérifie la présence et la validité de la signature du jeton Cloudflare Access.
Fail-closed : aucun décodage sans vérification de signature n'est autorisé.
- Si l'environnement n'est pas configuré avec les clés nécessaires : HTTP 503.
- Le mode CF_TEST_SECRET n'existe que si ENV='test'.
- Toute absence de jeton, jeton forgé (alg none ou fausse signature) ou invalide : HTTP 401.
"""
is_test_env = (ENV == "test")
# 1. Contrôle préalable de la configuration (Fail-closed)
# Sans clés de vérification, le service répond 503 sur les routes API
if is_test_env and CF_TEST_SECRET:
# Configuration valide pour le mode test
pass
elif CF_ACCESS_CERTS_URL and CF_ACCESS_AUD:
# Configuration valide pour la production (JWKS Cloudflare Access)
pass
else:
# Clés obligatoires manquantes : refus immédiat de servir les routes /api
raise HTTPException(
status_code=503,
detail="Authentification Cloudflare Access non configurée : CF_ACCESS_CERTS_URL et CF_ACCESS_AUD obligatoires"
)
# 2. Présence obligatoire du jeton Cloudflare Access
token = request.headers.get("Cf-Access-Jwt-Assertion")
if not token or not token.strip():
raise HTTPException(
@@ -23,25 +44,25 @@ def verify_cf_access_jwt(request: Request) -> Dict[str, Any]:
token = token.strip()
# 1. Mode test avec secret HMAC (utilisé dans les tests unitaires et d'intégration)
if CF_TEST_SECRET:
# 3. Mode test avec secret HMAC (strictement restreint à ENV=test)
if is_test_env and CF_TEST_SECRET:
try:
payload = jwt.decode(
token,
CF_TEST_SECRET,
algorithms=["HS256"],
audience=CF_ACCESS_AUD if CF_ACCESS_AUD else None,
options={"verify_aud": bool(CF_ACCESS_AUD)}
options={"verify_aud": bool(CF_ACCESS_AUD), "verify_signature": True}
)
return payload
except jwt.PyJWTError as e:
raise HTTPException(
status_code=401,
detail=f"Jeton Cloudflare Access invalide : {str(e)}"
detail=f"Jeton Cloudflare Access invalide ou signature non vérifiée : {str(e)}"
)
# 2. Mode production avec JWKS Cloudflare Access si configuré
if CF_ACCESS_CERTS_URL:
# 4. Mode production avec vérification de signature JWKS Cloudflare Access
if CF_ACCESS_CERTS_URL and CF_ACCESS_AUD:
try:
jwks_client = jwt.PyJWKClient(CF_ACCESS_CERTS_URL)
signing_key = jwks_client.get_signing_key_from_jwt(token)
@@ -49,36 +70,18 @@ def verify_cf_access_jwt(request: Request) -> Dict[str, Any]:
token,
signing_key.key,
algorithms=["RS256"],
audience=CF_ACCESS_AUD if CF_ACCESS_AUD else None,
options={"verify_aud": bool(CF_ACCESS_AUD)}
audience=CF_ACCESS_AUD,
options={"verify_aud": True, "verify_signature": True}
)
return payload
except Exception as e:
raise HTTPException(
status_code=401,
detail=f"Jeton Cloudflare Access non vérifié par JWKS : {str(e)}"
detail=f"Jeton Cloudflare Access invalide ou signature non vérifiée : {str(e)}"
)
# 3. Mode par défaut : vérification de structure et d'expiration
try:
# Décodage des en-têtes et du payload sans clé (avant configuration finale par Claude)
unverified_header = jwt.get_unverified_header(token)
if not unverified_header:
raise ValueError("En-tête JWT manquant")
payload = jwt.decode(
token,
options={"verify_signature": False, "verify_exp": True}
)
if not payload or not isinstance(payload, dict):
raise ValueError("Payload JWT non dictionnaire")
return payload
except jwt.ExpiredSignatureError:
raise HTTPException(
status_code=401,
detail="Jeton Cloudflare Access expiré"
)
except Exception as e:
raise HTTPException(
status_code=401,
detail=f"Jeton Cloudflare Access malformé : {str(e)}"
)
# Si aucun mode n'a pu valider la signature (sécurité absolue)
raise HTTPException(
status_code=401,
detail="Jeton Cloudflare Access rejeté : signature non vérifiée"
)
+77 -31
View File
@@ -1,5 +1,7 @@
import re
import json
from typing import Optional, Dict, Any, List, Tuple
from app.config import get_tunis_now_iso
from app.db import (
list_regles,
get_regle,
@@ -21,7 +23,6 @@ def extract_keywords(text: Optional[str]) -> str:
"""Extrait les mots significatifs d'un objet de mail."""
if not text:
return ""
# Nettoyage des préfixes et caractères spéciaux
clean = re.sub(r"^(?:re|fwd|tr)\s*:\s*", "", text, flags=re.IGNORECASE)
words = re.findall(r"\b[\w\u00C0-\u017F-]{3,}\b", clean, flags=re.UNICODE)
meaningful = [w for w in words if w.lower() not in STOPWORDS]
@@ -35,7 +36,7 @@ def match_mail_to_rules(mail: Dict[str, Any], rules: List[Dict[str, Any]]) -> st
mail_exp = (mail.get("expediteur") or mail.get("from") or "").lower()
mail_obj = (mail.get("objet") or mail.get("subject") or "").lower()
mail_snip = (mail.get("apercu") or mail.get("snippet") or "").lower()
mail_tags = [t.lower() for t in (mail.get("etiquettes") or mail.get("tags") or [])]
mail_tags = [t.strip().lower() for t in (mail.get("etiquettes") or mail.get("tags") or [])]
for rule in rules:
if rule.get("statut") != "active":
@@ -51,12 +52,11 @@ def match_mail_to_rules(mail: Dict[str, Any], rules: List[Dict[str, Any]]) -> st
if rule_exp and rule_exp in mail_exp:
return rule["categorie"]
# 3. Correspondance sur les mots-clés
# 3. Correspondance sur les mots-clés (avec frontières de mots pour éviter les faux-positifs)
rule_mot = (rule.get("mot_cle") or "").strip().lower()
if rule_mot:
# Vérifier si l'un des mots-clés de la règle est présent
mot_parts = rule_mot.split()
if any(p in mail_obj or p in mail_snip for p in mot_parts):
pattern = rf"\b{re.escape(rule_mot)}\b"
if re.search(pattern, mail_obj, re.IGNORECASE) or re.search(pattern, mail_snip, re.IGNORECASE):
return rule["categorie"]
return "À classer"
@@ -78,12 +78,16 @@ def classify_mail(mail: Dict[str, Any], db_path: Optional[str] = None) -> Dict[s
rules = list_regles(statut="active", db_path=db_path)
categorie = match_mail_to_rules(mail, rules)
tags = mail.get("etiquettes") or mail.get("tags") or []
tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags)
return save_classement_regle(
message_id=mid,
categorie=categorie,
expediteur=mail.get("expediteur") or mail.get("from") or "",
objet=mail.get("objet") or mail.get("subject") or "",
date_mail=mail.get("date") or "",
etiquettes=tags_json,
db_path=db_path
)
@@ -104,6 +108,9 @@ def manual_classify_and_propose(
obj = (mail_info.get("objet") if mail_info else None) or (existing.get("objet") if existing else "")
date_m = (mail_info.get("date") if mail_info else None) or (existing.get("date_mail") if existing else "")
tags = (mail_info.get("etiquettes") if mail_info else None) or (existing.get("etiquettes") if existing else "[]")
tags_json = json.dumps(tags) if isinstance(tags, list) else str(tags)
classement = save_classement_manuel(
message_id=message_id,
categorie=new_category,
@@ -111,6 +118,7 @@ def manual_classify_and_propose(
expediteur=exp,
objet=obj,
date_mail=date_m,
etiquettes=tags_json,
db_path=db_path
)
@@ -128,6 +136,68 @@ def manual_classify_and_propose(
return classement, proposed_rule
def reclassify_all_non_manual(db_path: Optional[str] = None, date_prefix: Optional[str] = None) -> int:
"""
Réévalue et reclasse tous les emails non-manuels enregistrés en base.
RÈGLE ABSOLUE : Les classements manuels ne sont jamais touchés.
"""
active_rules = list_regles(statut="active", db_path=db_path)
all_classements = list_classements(date_prefix=date_prefix, db_path=db_path)
reclassified_count = 0
for c in all_classements:
if c.get("source") == "manuel":
continue
raw_tags = c.get("etiquettes") or "[]"
try:
tags = json.loads(raw_tags) if isinstance(raw_tags, str) else raw_tags
except Exception:
tags = []
mail_repr = {
"message_id": c["message_id"],
"expediteur": c.get("expediteur", ""),
"objet": c.get("objet", ""),
"apercu": "",
"etiquettes": tags if isinstance(tags, list) else []
}
new_cat = match_mail_to_rules(mail_repr, active_rules)
if new_cat != c.get("categorie"):
save_classement_regle(
message_id=c["message_id"],
categorie=new_cat,
expediteur=c.get("expediteur", ""),
objet=c.get("objet", ""),
date_mail=c.get("date_mail", ""),
etiquettes=raw_tags if isinstance(raw_tags, str) else json.dumps(raw_tags),
db_path=db_path
)
reclassified_count += 1
return reclassified_count
def reclassify_today_mails(mirror_client: Optional[Any] = None, db_path: Optional[str] = None, target_date: Optional[str] = None) -> int:
"""
Reclasse les mails du jour : interroge le miroir pour synchroniser les étiquettes et applique
les règles actives, sans jamais écraser un classement manuel.
"""
t_date = target_date or get_tunis_now_iso()[:10]
total_processed = 0
if mirror_client:
try:
mails = mirror_client.get_mails_for_day(t_date, max_items=50)
for m in mails:
classify_mail(m, db_path=db_path)
total_processed += 1
except Exception:
pass
# Reclassement de sécurité sur les données déjà en base
reclassify_all_non_manual(db_path=db_path, date_prefix=t_date)
return total_processed
def confirm_and_apply_rule(regle_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]:
"""
Confirme une règle proposée (statut='active') et applique les règles actives
@@ -138,29 +208,5 @@ def confirm_and_apply_rule(regle_id: int, db_path: Optional[str] = None) -> Opti
if not rule:
return None
# Réévaluation des emails non manuels en base
active_rules = list_regles(statut="active", db_path=db_path)
all_classements = list_classements(db_path=db_path)
for c in all_classements:
if c.get("source") == "manuel":
continue
mail_repr = {
"message_id": c["message_id"],
"expediteur": c.get("expediteur", ""),
"objet": c.get("objet", ""),
"apercu": "",
"etiquettes": []
}
new_cat = match_mail_to_rules(mail_repr, active_rules)
if new_cat != c.get("categorie"):
save_classement_regle(
message_id=c["message_id"],
categorie=new_cat,
expediteur=c.get("expediteur", ""),
objet=c.get("objet", ""),
date_mail=c.get("date_mail", ""),
db_path=db_path
)
reclassify_all_non_manual(db_path=db_path)
return rule
+23
View File
@@ -2,6 +2,8 @@ import os
from datetime import datetime
from zoneinfo import ZoneInfo
ENV = os.getenv("ENV", "production")
DATA_DIR = os.getenv("DATA_DIR", os.path.join(os.path.dirname(os.path.dirname(__file__)), "data"))
DB_PATH = os.getenv("DB_PATH", os.path.join(DATA_DIR, "courrier.db"))
MIRROR_TOKEN_PATH = os.getenv("MIRROR_TOKEN_PATH", os.path.join(os.path.dirname(os.path.dirname(__file__)), "secrets", "mirror.token"))
@@ -20,6 +22,27 @@ DEFAULT_CATEGORIES = [
"À classer"
]
DEFAULT_RULES = [
# 1. Étiquettes du miroir O365
{"categorie": "Sans objet", "etiquette_miroir": "sans_objet", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Tunis", "etiquette_miroir": "tunis", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Tunis", "etiquette_miroir": "courses", "expediteur": None, "mot_cle": None, "statut": "active"},
# 2. Catégories spécifiques et mots-clés évidents
{"categorie": "Sans objet", "etiquette_miroir": None, "expediteur": None, "mot_cle": "sans objet", "statut": "active"},
{"categorie": "Tunis", "etiquette_miroir": None, "expediteur": None, "mot_cle": "tunis", "statut": "active"},
{"categorie": "Tunis", "etiquette_miroir": None, "expediteur": None, "mot_cle": "courses", "statut": "active"},
{"categorie": "Demande FB", "etiquette_miroir": "demande fb", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Demande FB", "etiquette_miroir": "demande_fb", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Demande FB", "etiquette_miroir": None, "expediteur": None, "mot_cle": "demande fb", "statut": "active"},
{"categorie": "Demande FB", "etiquette_miroir": None, "expediteur": None, "mot_cle": "facebook", "statut": "active"},
{"categorie": "CI", "etiquette_miroir": "ci", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "CI", "etiquette_miroir": None, "expediteur": None, "mot_cle": "ci", "statut": "active"},
{"categorie": "Câbles", "etiquette_miroir": "câbles", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Câbles", "etiquette_miroir": "cables", "expediteur": None, "mot_cle": None, "statut": "active"},
{"categorie": "Câbles", "etiquette_miroir": None, "expediteur": None, "mot_cle": "câbles", "statut": "active"},
{"categorie": "Câbles", "etiquette_miroir": None, "expediteur": None, "mot_cle": "cables", "statut": "active"},
]
def get_tunis_now_iso() -> str:
"""Retourne l'horodatage actuel en fuseau Africa/Tunis avec offset +01:00."""
return datetime.now(ZoneInfo("Africa/Tunis")).strftime("%Y-%m-%dT%H:%M:%S+01:00")
+58 -19
View File
@@ -1,7 +1,8 @@
import os
import json
import sqlite3
from typing import Optional, List, Dict, Any
from app.config import DB_PATH, DEFAULT_CATEGORIES, get_tunis_now_iso
from app.config import DB_PATH, DEFAULT_CATEGORIES, DEFAULT_RULES, get_tunis_now_iso
def get_connection(db_path: Optional[str] = None) -> sqlite3.Connection:
path = db_path or DB_PATH
@@ -45,18 +46,50 @@ def init_db(db_path: Optional[str] = None) -> None:
traite INTEGER NOT NULL DEFAULT 0,
expediteur TEXT,
objet TEXT,
date_mail TEXT
date_mail TEXT,
etiquettes TEXT DEFAULT '[]'
);
""")
# Initialisation des catégories par défaut si vide
cursor = conn.execute("SELECT COUNT(*) as cnt FROM categories")
if cursor.fetchone()["cnt"] == 0:
now = get_tunis_now_iso()
for cat in DEFAULT_CATEGORIES:
# Migration douce si la table classements existait sans la colonne etiquettes
cols = [r["name"] for r in conn.execute("PRAGMA table_info(classements)").fetchall()]
if "etiquettes" not in cols:
conn.execute("ALTER TABLE classements ADD COLUMN etiquettes TEXT DEFAULT '[]'")
now = get_tunis_now_iso()
# Initialisation idempotente des catégories par défaut
for cat in DEFAULT_CATEGORIES:
conn.execute(
"INSERT OR IGNORE INTO categories (name, created_at) VALUES (?, ?)",
(cat, now)
)
# Initialisation idempotente des règles de départ
for rule in DEFAULT_RULES:
cat = rule["categorie"]
eti = rule.get("etiquette_miroir")
exp = rule.get("expediteur")
mot = rule.get("mot_cle")
sta = rule.get("statut", "active")
cursor = conn.execute(
"""
SELECT COUNT(*) as cnt FROM regles
WHERE categorie = ?
AND (etiquette_miroir IS ? OR etiquette_miroir = ?)
AND (expediteur IS ? OR expediteur = ?)
AND (mot_cle IS ? OR mot_cle = ?)
""",
(cat, eti, eti, exp, exp, mot, mot)
)
if cursor.fetchone()["cnt"] == 0:
conn.execute(
"INSERT OR IGNORE INTO categories (name, created_at) VALUES (?, ?)",
(cat, now)
"""
INSERT INTO regles (categorie, etiquette_miroir, expediteur, mot_cle, statut, created_at)
VALUES (?, ?, ?, ?, ?, ?)
""",
(cat, eti, exp, mot, sta, now)
)
finally:
conn.close()
@@ -223,7 +256,7 @@ def get_classement(message_id: str, db_path: Optional[str] = None) -> Optional[D
conn = get_connection(db_path)
try:
row = conn.execute(
"SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail FROM classements WHERE message_id = ?",
"SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE message_id = ?",
(message_id,)
).fetchone()
if not row:
@@ -242,7 +275,7 @@ def list_classements(
) -> List[Dict[str, Any]]:
conn = get_connection(db_path)
try:
query = "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail FROM classements WHERE 1=1"
query = "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE 1=1"
params: list = []
if date_prefix:
query += " AND (date_mail LIKE ? OR horodatage LIKE ?)"
@@ -270,6 +303,7 @@ def save_classement_regle(
expediteur: str = "",
objet: str = "",
date_mail: str = "",
etiquettes: Optional[str] = None,
db_path: Optional[str] = None
) -> Dict[str, Any]:
"""
@@ -288,22 +322,24 @@ def save_classement_regle(
exp = expediteur or (existing["expediteur"] if existing else "")
obj = objet or (existing["objet"] if existing else "")
d_mail = date_mail or (existing["date_mail"] if existing else "")
etiq = etiquettes or (existing.get("etiquettes") if existing else "[]")
with conn:
conn.execute(
"""
INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail)
VALUES (?, ?, 'regle', ?, ?, ?, ?, ?)
INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes)
VALUES (?, ?, 'regle', ?, ?, ?, ?, ?, ?)
ON CONFLICT(message_id) DO UPDATE SET
categorie = excluded.categorie,
source = 'regle',
horodatage = excluded.horodatage,
expediteur = excluded.expediteur,
objet = excluded.objet,
date_mail = excluded.date_mail
date_mail = excluded.date_mail,
etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END
WHERE classements.source != 'manuel'
""",
(message_id, categorie, now, 1 if traite else 0, exp, obj, d_mail)
(message_id, categorie, now, 1 if traite else 0, exp, obj, d_mail, etiq)
)
return get_classement(message_id, db_path)
finally:
@@ -316,6 +352,7 @@ def save_classement_manuel(
expediteur: Optional[str] = None,
objet: Optional[str] = None,
date_mail: Optional[str] = None,
etiquettes: Optional[str] = None,
db_path: Optional[str] = None
) -> Dict[str, Any]:
"""
@@ -329,12 +366,13 @@ def save_classement_manuel(
exp = expediteur if expediteur is not None else (existing["expediteur"] if existing else "")
obj = objet if objet is not None else (existing["objet"] if existing else "")
d_mail = date_mail if date_mail is not None else (existing["date_mail"] if existing else "")
etiq = etiquettes if etiquettes is not None else (existing.get("etiquettes") if existing else "[]")
with conn:
conn.execute(
"""
INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail)
VALUES (?, ?, 'manuel', ?, ?, ?, ?, ?)
INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes)
VALUES (?, ?, 'manuel', ?, ?, ?, ?, ?, ?)
ON CONFLICT(message_id) DO UPDATE SET
categorie = excluded.categorie,
source = 'manuel',
@@ -342,9 +380,10 @@ def save_classement_manuel(
traite = excluded.traite,
expediteur = CASE WHEN excluded.expediteur != '' THEN excluded.expediteur ELSE classements.expediteur END,
objet = CASE WHEN excluded.objet != '' THEN excluded.objet ELSE classements.objet END,
date_mail = CASE WHEN excluded.date_mail != '' THEN excluded.date_mail ELSE classements.date_mail END
date_mail = CASE WHEN excluded.date_mail != '' THEN excluded.date_mail ELSE classements.date_mail END,
etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END
""",
(message_id, categorie, now, is_traite, exp, obj, d_mail)
(message_id, categorie, now, is_traite, exp, obj, d_mail, etiq)
)
return get_classement(message_id, db_path)
finally:
+8 -2
View File
@@ -22,7 +22,8 @@ from app.db import (
from app.classifier import (
classify_mail,
manual_classify_and_propose,
confirm_and_apply_rule
confirm_and_apply_rule,
reclassify_today_mails
)
from app.mirror_client import MirrorClient
from app.auth import verify_cf_access_jwt
@@ -59,8 +60,13 @@ class TraiteRequest(BaseModel):
# --- Lifespan ---
@asynccontextmanager
async def lifespan(app: FastAPI):
# Démarrage : initialisation de la base SQLite
# Démarrage : initialisation de la base SQLite et des règles par défaut
init_db()
# Reclassement des mails du jour après ajout des règles de départ
try:
reclassify_today_mails(mirror_client=mirror_client)
except Exception:
pass
yield
app = FastAPI(