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

Introduction à OAuth 2.0 et JWT en C++

Les applications web et API modernes fonctionnent rarement sans systèmes d'autorisation. Les deux standards les plus populaires — OAuth 2.0 et JWT (JSON Web Token) — sont devenus la base de la sécurité pour des millions de services. Dans cet article, nous allons voir comment implémenter une autorisation OAuth 2.0 de base avec des jetons JWT en langage C++. Vous apprendrez comment ces protocoles fonctionnent et verrez des exemples de code prêts à l'emploi que vous pouvez adapter à votre projet.

Cet article est destiné aux développeurs débutants qui connaissent déjà les bases du C++ (classes, fonctions, travail réseau) et souhaitent ajouter une autorisation sécurisée à leurs applications. Nous n'utiliserons pas de bibliothèques tierces pour le serveur HTTP — tous les exemples seront en C++ pur avec un minimum de dépendances.

Qu'est-ce qu'OAuth 2.0 et pourquoi en a-t-on besoin ?

OAuth 2.0 est un protocole d'autorisation qui permet aux applications d'obtenir un accès limité aux ressources d'un utilisateur sans transmettre son mot de passe. Imaginez que vous souhaitiez donner à une application l'accès à vos photos sur un serveur. Au lieu de saisir votre identifiant et mot de passe, vous passez par un serveur d'autorisation qui délivre un jeton temporaire. L'application utilise ce jeton pour accéder aux ressources.

Les rôles principaux dans OAuth 2.0 :

\n
• Propriétaire de la ressource — l'utilisateur, propriétaire des données.
\n
• Client — l'application qui demande l'accès.
\n
• Serveur d'autorisation — le serveur qui délivre les jetons après authentification.
\n
• Serveur de ressources — le serveur stockant les données protégées (par exemple, une API).
\n

En C++, nous implémenterons une version simplifiée du serveur d'autorisation et du serveur de ressources, en utilisant JWT comme jeton d'accès.

JWT : structure et principe de fonctionnement

JWT (JSON Web Token) est un moyen compact et autonome de transmettre des informations entre les parties sous la forme d'un objet JSON. Le jeton se compose de trois parties séparées par des points :

en-tête.charge.signature

L'en-tête contient le type de jeton et l'algorithme de signature (généralement HMAC SHA256 ou RSA). La charge utile est la charge utile : identifiant utilisateur, durée de vie du jeton, rôles, etc. La signature vérifie l'intégrité des données.

Exemple de création d'un JWT en C++ sans bibliothèques (simplifié) :

#include <iostream>\n#include <sstream>\n#include <vector>\n#include <openssl/sha.h>\n#include <openssl/hmac.h>\n\nstd::string base64_encode(const std::string &input) {\n    // Implémentation simplifiée de Base64 (pour l'exemple)\n    static const char* lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\n    std::string result;\n    // ... code de codage ...\n    return result;\n}\n\nstd::string create_jwt(const std::string &payload, const std::string &secret) {\n    std::string header = R"({"alg":"HS256","typ":"JWT"})";\n    std::string header_b64 = base64_encode(header);\n    std::string payload_b64 = base64_encode(payload);\n    std::string data = header_b64 + "." + payload_b64;\n    \n    unsigned char* sig = HMAC(EVP_sha256(), secret.c_str(), secret.length(), \n                              (unsigned char*)data.c_str(), data.length(), NULL, NULL);\n    std::string sig_b64 = base64_encode(std::string((char*)sig, 32));\n    \n    return data + "." + sig_b64;\n}\n\nint main() {\n    std::string payload = R"({"user_id":123,"role":"admin","exp":1700000000})";\n    std::string token = create_jwt(payload, "my_secret_key");\n    std::cout << "JWT: " << token << std::endl;\n    return 0;\n}

Ce code crée un JWT avec un en-tête HS256 et une charge utile. Dans des projets réels, utilisez des bibliothèques éprouvées comme jwt-cpp ou libjwt, mais pour comprendre l'essentiel, une telle approche convient également.