Assurer la sécurité des échanges d’informations entre une application et un serveur est un défi majeur.
Sans une identification sécurisée, les données sensibles risquent d’être exposées, compromettant la sécurité des utilisateurs.
Cet article propose d’explorer l’utilisation des tokens JWT pour authentifier et autoriser les utilisateurs efficacement.
Apprenez à construire des applications Android avec une architecture moderne et performante!
Introduction à l'authentification JWT
Lorsque vous développez une application qui interagit avec un serveur via des méthodes HTTP comme GET et POST, il est crucial d’assurer la sécurité des échanges d’informations. Le principal défi réside dans l’identification sécurisée de l’utilisateur et l’accès aux ressources de manière contrôlée. C’est ici qu’intervient l’utilisation des tokens JWT, un mécanisme largement utilisé pour authentifier et autoriser les utilisateurs.
JWT : Comprendre JSON Web Token
Un JWT est une chaîne de caractères qui permet au serveur de vérifier l’identité de l’utilisateur et de contrôler l’accès aux ressources. Ce token est crypté et contient des informations (claims) sur l’utilisateur et ses permissions.
Sécurisation des échanges avec JWT
1. Préparation du Token
Avant de pouvoir utiliser un JWT, certaines préparations sont nécessaires tant du côté client que du côté serveur :
- Côté serveur :Le serveur prépare les informations (claims) qui seront encapsulées dans le token. Ces informations peuvent inclure l’identité de l’utilisateur, les ressources auxquelles il a accès, etc.
- Côté client :Le client doit être capable de recevoir et stocker le token pour le renvoyer lors des requêtes ultérieures.
2. Génération du Token
La génération du token se fait côté serveur :
- Le serveur reçoit une requête POST du client avec les informations d’authentification.
- À partir de ces informations, le serveur génère un token unique.
- Ce token est ensuite envoyé au client, qui le conserve pour les futures requêtes.
3. Vérification du Token
À chaque requête, le client envoie le token au serveur :
- Le serveur déchiffre le token et vérifie les informations encapsulées.
- Il contrôle également la validité temporelle du token (expiration).
- Si le token est valide, l’accès aux ressources est accordé ; sinon, une erreur d’authentification est renvoyée.
4. Gestion des Échecs d’Authentification
Le serveur peut rejeter un token pour plusieurs raisons :
- Le token a expiré.
- Le token est invalide ou a été falsifié.
- Les informations encapsulées ne correspondent pas aux attentes du serveur.
Étape | Résumé |
|---|---|
Préparation du Token | Le serveur prépare les informations (claims) pour le token et le client le reçoit et le stocke. |
Génération du Token | Le serveur reçoit les informations d’authentification, génère un token unique et l’envoie au client. |
Vérification du Token | À chaque requête, le client envoie le token au serveur, qui le vérifie pour sa validité et son expiration. |
Gestion des Échecs d’Authentification | Le serveur rejette les tokens expirés, invalides, ou avec des informations incorrectes. |
Projet : Implémentation des tokens JWT
Création du Projet
Commencez par créer un nouveau projet. Assurez-vous d’inclure les bibliothèques nécessaires pour la gestion des tokens JWT, notamment pour l’authentification.
Organisation du Code
Créez des classes séparées pour les différentes responsabilités :
- Verbe.kt :Pour la gestion des verbes.
- JwtConfig.kt :Pour la configuration et la gestion des tokens JWT.
- VerbeRouting.kt :Pour la gestion des routes HTTP.
Définition de la Classe Verbe
Dans cet exemple, nous utilisons une classe Verbe pour représenter des objets stockés en base de données. Cette classe comprend :
- Un identifiant unique (ID).
- L’infinitif du verbe.
- Une liste des formes conjuguées (par exemple, les temps du verbe).
data class Verbe(val id : Int, val infinitif : String, val temps : List<String>)
Configuration du JWT
Une classe JwtConfig (sous forme de singleton) est utilisée pour définir les paramètres du token :
- Secret :Clé secrète pour le chiffrement du token, connue seulement du serveur.
- Issuer :Nom du serveur émettant le token.
- Timeout :Durée de validité du token (par exemple, 10 heures).
- Algorithme :Algorithme utilisé pour le chiffrement.
object JwtConfig {
private
const val secret = "secret_key" // Doit être sécurisé
private const val issuer = "server_name" private const val validityInMs =
36_000_00 * 10 // 10 heures
private val algorithm = Algorithm.HMAC256(secret) private val verifier
: JWTVerifier =
JWT.require(algorithm).withIssuer(issuer).build() fun generateToken(
verbe : Verbe)
: String = JWT.create()
.withSubject("Authentication")
.withIssuer(issuer)
.withClaim("id", verbe.id)
.withArrayClaim("temps", verbe.temps.toTypedArray())
.withExpiresAt(
Date(System.currentTimeMillis() + validityInMs))
.sign(algorithm) fun validateToken(token : String)
: DecodedJWT = verifier.verify(token)
}
Le token généré est une chaîne de caractères que le client utilisera pour ses requêtes.
Génération du Token
Voici un exemple de code pour générer un token :
- Claims :Ajoutez des informations comme l’ID de l’utilisateur, ses permissions, etc.
- Expiration :Définissez la durée de validité du token.
- Signature :Utilisez l’algorithme défini pour signer le token.
fun Route.verbeRouting() {
val verbeStorage = mutableListOf<Verbe>()
// Route GET all - avec vérification JWT
authenticate("jwt-auth") {
get("/verbes") {
if (verbeStorage.isNotEmpty()) {
call.respond(verbeStorage)
} else {
call.respondText("Pas de verbes disponibles",
status = HttpStatusCode.OK)
}
}
}
// Route GET avec ID - avec vérification JWT
authenticate("jwt-auth") {
get("/verbes/{id}") {
val id = call.parameters["id"] ?.toIntOrNull() if (id == null) {
call.respondText("ID manquant ou invalide",
status = HttpStatusCode.BadRequest) return @get
}
val verbe = verbeStorage.getOrNull(id) if (verbe != null) {
call.respond(verbe)
}
else {
call.respondText("Pas de verbe avec cet ID",
status = HttpStatusCode.NotFound)
}
}
}
// Route POST - Génération de JWT lors de l'enregistrement d'un verbe
post("/verbes"){
val verbe = call.receive<Verbe>() verbeStorage.add(verbe) val token =
JwtConfig.generateToken(verbe)
call.respondText("Verbe enregistré avec token: $token",
status = HttpStatusCode.Created)}
// Route DELETE - avec vérification JWT
authenticate("jwt-auth") {
delete ("/verbes/{id}") {
val id = call.parameters["id"] ?.toIntOrNull() if (id == null) {
call.respondText("ID manquant ou invalide",
status = HttpStatusCode.BadRequest) return @ delete
}
if (verbeStorage.removeAtOrNull(id) != null) {
call.respondText("Verbe supprimé", status = HttpStatusCode.OK)
} else {
call.respondText("Pas de verbe avec cet ID",
status = HttpStatusCode.NotFound)
}
}
}
}
Vérification et Utilisation du Token
Lors de chaque requête client, le serveur :
- Déchiffre le token.
- Vérifie les claims et l’expiration.
- Valide ou invalide l’accès en fonction des résultats.
Implémentation des Routes
Dans l’application, les routes peuvent être protégées par l’authentification JWT :
- Route protégée :L’accès nécessite un token valide.
- Route optionnelle :L’accès peut se faire avec ou sans token.
fun Application.module() {
install(Authentication) {
jwt("jwt-auth") {
verifier(JwtConfig.verifier) validate {
credential->if (credential.payload.getClaim("id").asInt() != null) {
JWTPrincipal(credential.payload)
}
else null
}
}
}
routing { verbeRouting() }
}
Conclusion sur la sécurité JWT
L’intégration d’une authentification JWT dans une application permet de sécuriser les échanges entre le client et le serveur de manière efficace. Le serveur contrôle l’accès aux ressources en fonction des informations encapsulées dans le token, tout en s’assurant que l’identité de l’utilisateur est bien vérifiée. Cette approche est couramment utilisée pour des applications nécessitant un haut niveau de sécurité.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Qu'est-ce qu'un JWT et à quoi sert-il ?
Comment fonctionne la génération d'un token JWT ?
Comment le serveur vérifie-t-il un token JWT ?
Quelles sont les étapes pour sécuriser une application avec JWT ?
Comment intégrer JWT dans un projet de développement ?
Conclusion
L’intégration de JWT dans vos applications renforce la sécurité des échanges. Comment envisagez-vous d’améliorer vos pratiques d’authentification avec JWT ?
