OAuth 2.0 et autorisation JWT en Swift : guide pas à pas pour débutants

Introduction à OAuth 2.0 et JWT en Swift

Les applications mobiles et de bureau modernes se passent rarement d'authentification. Deux protocoles clés — OAuth 2.0 et JWT (JSON Web Token) — sont devenus le standard de facto pour le transfert sécurisé de données entre le client et le serveur. Dans cet article, nous allons voir comment implémenter l'autorisation OAuth 2.0 et JWT en Swift pour les plateformes iOS et macOS. Vous apprendrez à configurer le flux d'obtention des jetons, à les stocker dans le Keychain et à les renouveler automatiquement à leur expiration.

Cet article est destiné aux développeurs débutants qui connaissent déjà les bases de Swift et SwiftUI. Nous utiliserons URLSession pour les requêtes réseau et Keychain pour le stockage sécurisé des données. Le code est écrit en Swift 5.9 et compatible avec iOS 15+ / macOS 12+.

Que sont OAuth 2.0 et JWT ?

Avant d'écrire du code, comprenons la théorie.

OAuth 2.0

OAuth 2.0 est un protocole d'autorisation qui permet à une application d'obtenir un accès limité aux ressources d'un utilisateur sans transmettre son identifiant et son mot de passe. À la place, des jetons d'accès sont utilisés. Les principaux acteurs sont :

\n
• Resource Owner — l'utilisateur.
\n
• Client — votre application.
\n
• Authorization Server — le serveur qui délivre les jetons.
\n
• Resource Server — l'API qui fournit les données.
\n

Le flux le plus populaire pour les applications mobiles est Authorization Code Flow with PKCE (Proof Key for Code Exchange). Il est sécurisé même sans client secret, difficile à stocker dans une application.

JWT (JSON Web Token)

JWT est un format de jeton compact et autonome qui contient des données JSON. Il se compose de trois parties séparées par des points :

\n
• Header — le type de jeton et l'algorithme de signature.
\n
• Payload — les données utiles (claims), comme l'ID utilisateur, le rôle, la date d'expiration.
\n
• Signature — la signature pour vérifier l'intégrité.
\n

JWT est souvent utilisé comme access token dans OAuth 2.0. Il permet au serveur de vérifier l'authenticité d'une requête sans accéder à la base de données.

Implémentation pratique en Swift

Nous allons créer une classe simple AuthService qui gérera l'authentification. Pour l'exemple, nous utiliserons le serveur https://api.example.com.

Étape 1 : Obtention des jetons via OAuth 2.0

Commençons par implémenter une méthode pour obtenir les jetons à partir du code d'autorisation. Supposons que nous avons déjà obtenu authorizationCode via une vue web (par exemple, ASWebAuthenticationSession).

import Foundation\n\nfinal class AuthService {\n    static let shared = AuthService()\n    private let baseURL = "https://api.example.com"\n    private let clientID = "your_client_id"\n    private let redirectURI = "yourapp://callback"\n    \n    // MARK: - Obtention des jetons\n    func exchangeCodeForTokens(code: String, codeVerifier: String) async throws -> TokenResponse {\n        let url = URL(string: "\\(baseURL)/oauth/token")!\n        var request = URLRequest(url: url)\n        request.httpMethod = "POST"\n        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")\n        \n        let body = [\n            "grant_type": "authorization_code",\n            "code": code,\n            "redirect_uri": redirectURI,\n            "client_id": clientID,\n            "code_verifier": codeVerifier\n        ]\n        .map { "\\($0.key)=\\($0.value.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? "")" }\n        .joined(separator: "&")\n        .data(using: .utf8)\n        \n        request.httpBody = body\n        \n        let (data, response) = try await URLSession.shared.data(for: request)\n        \n        guard let httpResponse = response as? HTTPURLResponse,