Le piège de la casse en majuscules/minuscules qu'on ignore tous

Tu déploies ton app web. Tout roule en dev. Le staging est nickel. Et là, en prod, ça plante sans raison. Pire : un chercheur en sécu trouve une faille imprévue.

Souvent, ce n'est pas un bug dans ton code. Ni une validation oubliée. C'est la gestion de la casse qui merde quelque part.

Pourquoi la casse vous embête plus que prévu

Tout le monde sait que les domain names ignorent la casse. example.com, Example.Com ou EXAMPLE.COM : même chose. Facile.

Mais et les autres cas ?

• Adresses email dans ton système d'auth ?
• Identifiants users en base de données ?
• Chemins de fichiers dans ton storage cloud ?
• Endpoints API que tu appelles ?
• Logique de validation SSL ?

Dès que tes outils traitent la casse différemment, tu ouvres une porte aux attaques.

Un scénario d'attaque concret

Ton app vérifie les users par email. Tu stockes tout en minuscules en base. Logique. Mais ton provider OAuth renvoie Jean.Dupont@gmail.com avec des majuscules. Ton code compare les chaînes sans uniformiser.

Un attaquant s'inscrit avec jean.dupont@gmail.com. Il se connecte. Puis teste Jean.Dupont@gmail.com. Si ta gestion de casse varie, il peut :

• Contourner les limites de taux (vu comme un autre user)
• Créer des comptes en double avec des droits supérieurs
• Échapper aux logs de sécu
• Accéder à des données interdites

Ça empire avec :

Les IDN (International Domain Names) : Les règles Unicode changent par langue. Le 'ı' turc sans point casse tout. Certains caractères n'ont pas de majuscule.

Stockage cloud : Chez AWS S3, les clés d'objets sont sensibles à la casse, pas les noms de buckets. Erreur = fuite de données ou escalade de privilèges.

DNS : Les queries DNS ignorent la casse, mais ton app peut valider mal. Certificats wildcard et CNAME deviennent des failles.

Comment sécuriser ton infra

1. Fixe des règles d'uniformisation

Définis la casse au niveau app, pas en base. Uniformise tout input user dès l'entrée.

# Bien : uniformise à la frontière
def uniformise_email(email):
    return email.lower().strip()

def auth_user(email):
    uni = uniformise_email(email)
    user = User.query.filter_by(email=uni).first()
    return user

2. Choisis des libs Unicode

Pour du contenu international, évite le bricolage. Prends des outils pros :

• Python : unicodedata
• JavaScript : String.localeCompare()
• Go : package strings avec Unicode

3. Teste sur tous les systèmes

Ton app n'est pas seule. Vérifie la casse avec :

• API de ton DNS provider
• Validateur de ton SSL issuer
• Providers OAuth tiers
• Service de stockage cloud
• Règles de ton CDN

Note le comportement de chacun. Assure la cohérence.

4. Valide strictement les inputs

Ne fais pas confiance aux systèmes externes. Uniformise à chaque intégration.

// Avant les appels API externes
const uniformise_api = (input, format = 'lowercase') => {
  const uni = format === 'lowercase' 
    ? String(input).toLowerCase() 
    : String(input);
  return uni.trim();
};

5. Trace les anomalies de casse

Alerte sur les variations suspectes :

def detecte_variance_casse(email):
    uni = email.lower()
    if email != uni:
        logger.warning(f"Variance casse : {email} vs {uni}")
        # Cherche des patterns d'attaque

6. Applique les best practices NameOcean

Pour tes domains et DNS chez NameOcean :

• Code toujours en minuscules pour les domain names
• Stocke les DNS records avec casse fixe
• Exploite nos API case-insensitive sans peur
• Documente ta stratégie casse dans ton infra as code

La morale de l'histoire

La sécu, ce n'est pas que mots de passe forts et HTTPS. C'est capter comment ton écosystème gère les données. Une incohérence sur la casse propage auth, storage et API.

Les devs malins la chopent tôt en :

1. Remettant en cause les idées reçues – Ne présume rien sur la normalisation
2. Testant les cas limites – Variations casse dans tes tests sécu
3. Documentant tout – Note précisément le comportement de chaque système
4. Uniformisant partout – Choisis une règle, impose-la

Tes futurs chercheurs sécu (ou hackers) te diront merci.