Authentification sécurisée en Kotlin : guide pour développeur

Introduction : pourquoi l'authentification "maison" est-elle risquée ?

Imaginez : vous écrivez une application en Kotlin — que ce soit un client Android ou un backend avec Ktor/Spring Boot. Vous bricolez rapidement un formulaire de connexion, vous enregistrez le mot de passe dans SharedPreferences et vous vous réjouissez que tout fonctionne. Et une semaine plus tard, vous recevez un message : "Votre application a été piratée, des données ont fuité". Cela vous dit quelque chose ? Malheureusement, c'est un classique.

L'authentification sécurisée en Kotlin ne se limite pas à "vérifier le mot de passe". C'est tout un écosystème : hachage, tokens, protection contre la falsification de requêtes, stockage sécurisé des secrets. Dans cet article, nous allons voir comment éviter les erreurs typiques et construire un système de connexion fiable. C'est parti !

1. Hachage des mots de passe : bcrypt et ses amis

Première règle de sécurité : ne stockez jamais les mots de passe en clair. Même si vous utilisez HTTPS, la base de données peut être compromise. Votre tâche est de ne stocker que le hachage.

Pourquoi MD5 et SHA sont-ils mauvais ?

Ces algorithmes sont rapides. Et les hachages rapides sont un rêve pour les pirates : ils peuvent essayer des milliards de combinaisons par seconde. Utilisez plutôt bcrypt, scrypt ou Argon2. Ils sont délibérément lents et résistants aux attaques par GPU.

Exemple en Kotlin avec la bibliothèque jbcrypt :

import org.mindrot.jbcrypt.BCrypt\n\nfun hashPassword(password: String): String {\n    val salt = BCrypt.gensalt(12) // facteur de coût 12 — optimal\n    return BCrypt.hashpw(password, salt)\n}\n\nfun checkPassword(password: String, hashed: String): Boolean {\n    return BCrypt.checkpw(password, hashed)\n}

Important : le sel est généré automatiquement et intégré dans le hachage. Vous n'avez pas besoin de le stocker séparément.

2. JWT : authentification légère et sécurisée

JSON Web Token (JWT) est un standard pour transmettre des revendications (claims) entre les parties. En Kotlin, vous pouvez utiliser la bibliothèque java-jwt (Auth0) ou jsonwebtoken (jjwt).

Génération d'un JWT en Kotlin

import io.jsonwebtoken.Jwts\nimport io.jsonwebtoken.SignatureAlgorithm\nimport io.jsonwebtoken.security.Keys\nimport java.util.Date\n\nfun generateToken(userId: String, secretKey: String): String {\n    val key = Keys.hmacShaKeyFor(secretKey.toByteArray())\n    return Jwts.builder()\n        .setSubject(userId)\n        .setIssuedAt(Date())\n        .setExpiration(Date(System.currentTimeMillis() + 3600_000)) // 1 heure\n        .signWith(key, SignatureAlgorithm.HS256)\n        .compact()\n}

Validation du token

fun validateToken(token: String, secretKey: String): String? {\n    return try {\n        val key = Keys.hmacShaKeyFor(secretKey.toByteArray())\n        val claims = Jwts.parserBuilder()\n            .setSigningKey(key)\n            .build()\n            .parseClaimsJws(token)\n            .body\n        claims.subject // retourne l'userId\n    } catch (e: Exception) {\n        null // token invalide ou expiré\n    }\n}

Conseil : ne stockez pas la clé secrète dans le code. Utilisez des variables d'environnement ou Vault.

3. Stockage sécurisé des tokens sur Android

Si vous écrivez une application mobile en Kotlin, le token d'accès ne doit pas être stocké dans SharedPreferences — c'est un fichier ouvert qui peut être lu par d'autres applications ou par un attaquant ayant un accès root.

Utilisez EncryptedSharedPreferences (de AndroidX Security) ou Keystore :

import androidx.security.crypto.EncryptedSharedPreferences\nimport androidx.security.crypto.MasterKey\n\nfun saveToken(context: Context, token: String) {\n    val masterKey = MasterKey.Builder(context)\n        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)\n        .build()\n\n    val sharedPreferences = EncryptedSharedPreferences.create(\n        context,\n        "secure_prefs",\n        masterKey,\n