# --- pickle : JAMAIS deserialiser des donnees non fiables ---
import pickle

# pickle.loads() peut executer du code arbitraire via __reduce__ !
class Exploit:
    def __reduce__(self):
        import os
        return (os.system, ("echo 'code arbitraire execute !'",))

# donnees_malveillantes = pickle.dumps(Exploit())
# pickle.loads(donnees_malveillantes)     # NE JAMAIS FAIRE CECI sur une source non fiable

# Regle absolue : pickle uniquement pour des donnees INTERNES et fiables (cache local, IPC controle)
# Pour des donnees externes (API, upload utilisateur), utiliser JSON
import json
donnees_utilisateur = '{"nom": "Alice", "age": 30}'
donnees_safe = json.loads(donnees_utilisateur)     # pas d'execution de code possible

# --- eval() / exec() : dangers similaires ---
# eval(input())     # NE JAMAIS FAIRE : execute n'importe quelle expression Python
# Si une evaluation dynamique est vraiment necessaire, restreindre drastiquement :
import ast

def evaluer_expression_mathematique_safe(expression: str):
    # ast.literal_eval n'evalue QUE des litteraux (pas d'appels de fonction, pas d'attributs)
    return ast.literal_eval(expression)

print(evaluer_expression_mathematique_safe("[1, 2, {'a': 3}]"))    # OK, structure litterale
try:
    evaluer_expression_mathematique_safe("__import__('os').system('ls')")
except (ValueError, SyntaxError) as e:
    print("Refuse : tentative d'injection de code")

# --- YAML : yaml.load() non securise est aussi dangereux que pickle ---
# import yaml
# yaml.load(source, Loader=yaml.FullLoader)    # dangereux avec certains loaders
# yaml.safe_load(source)                          # a utiliser systematiquement

# --- Injection SQL : toujours parametrer les requetes ---
import sqlite3

connexion = sqlite3.connect(":memory:")
curseur = connexion.cursor()
curseur.execute("CREATE TABLE utilisateurs (id INTEGER, nom TEXT)")

nom_utilisateur = "Alice'; DROP TABLE utilisateurs; --"    # tentative d'injection

# MAUVAIS : concatenation directe -> vulnerable a l'injection SQL
# curseur.execute(f"SELECT * FROM utilisateurs WHERE nom = '{nom_utilisateur}'")

# BON : requete parametree, le driver echappe correctement les valeurs
curseur.execute("SELECT * FROM utilisateurs WHERE nom = ?", (nom_utilisateur,))

# --- Gestion des secrets : jamais en dur dans le code source ---
import os

# MAUVAIS
# API_KEY = "sk-1234567890abcdef"

# BON : variables d'environnement (chargees depuis un .env NON commite, ou un secret manager)
API_KEY = os.environ.get("API_KEY")
if API_KEY is None:
    raise RuntimeError("API_KEY manquante dans l'environnement")

# python-dotenv pour le developpement local (fichier .env dans .gitignore)
# from dotenv import load_dotenv
# load_dotenv()

# --- Comparaisons securisees pour les secrets (eviter les timing attacks) ---
import hmac

def verifier_token(token_recu: str, token_attendu: str) -> bool:
    # comparer avec == expose une timing attack (le temps de comparaison fuit de l'info)
    # hmac.compare_digest() effectue une comparaison en temps constant
    return hmac.compare_digest(token_recu, token_attendu)

# --- Hachage de mots de passe : jamais de hachage simple (md5/sha256 seuls) ---
# Utiliser un algorithme concu pour les mots de passe (lent, sale, resistant au bruteforce)
import hashlib
import secrets

def hacher_mot_de_passe(mot_de_passe: str) -> tuple[str, str]:
    sel = secrets.token_hex(16)                 # sel aleatoire cryptographiquement sur
    hache = hashlib.pbkdf2_hmac(
        "sha256", mot_de_passe.encode(), sel.encode(), iterations=200_000
    )
    return sel, hache.hex()

# En production, preferer une librairie dediee : argon2-cffi ou bcrypt
# from argon2 import PasswordHasher
# ph = PasswordHasher()
# hache = ph.hash("mot_de_passe_utilisateur")
# ph.verify(hache, "mot_de_passe_utilisateur")

# --- Generer des valeurs aleatoires cryptographiquement sures ---
# MAUVAIS pour de la securite : random n'est PAS cryptographiquement sur
import random
token_faible = random.randint(100000, 999999)      # predictible par un attaquant determine

# BON : le module secrets est concu pour la cryptographie
token_fort = secrets.token_urlsafe(32)