deer

Author: Your

task_05_basic_security.py

@@ -2,86 +2,55 @@
 from werkzeug.security import generate_password_hash, check_password_hash
 from flask_httpauth import HTTPBasicAuth
 from flask_jwt_extended import (JWTManager, create_access_token, jwt_required, get_jwt_identity)
-import datetime
 
-# Initialiser l'application Flask
 app = Flask(__name__)
-
-# Configurer la clé secrète pour signer les tokens JWT
-app.config['JWT_SECRET_KEY'] = 'supersecretkey'  # Utilisez une clé secrète robuste en production
-jwt = JWTManager(app)
-
-# Initialiser l'authentification de base
+app.config["SECRET_KEY"] = "theoretically predictable"
 auth = HTTPBasicAuth()
+jwt = JWTManager(app)
 
-# Liste des utilisateurs avec mots de passe hashés et rôles
-users = {
-    "user1": {"username": "user1", "password": generate_password_hash("password"), "role": "user"},
-    "admin1": {"username": "admin1", "password": generate_password_hash("password"), "role": "admin"}
-}
+users = {"user1": {"username": "user1", "password": generate_password_hash("password"), "role": "user"},
+         "admin1": {"username": "admin1", "password": generate_password_hash("password"), "role": "admin"}}
 
-# Vérification du mot de passe avec Basic Auth
 @auth.verify_password
 def verify_password(username, password):
-    if username in users and check_password_hash(users[username]["password"], password):
-        return username  # Authentification réussie
-
-# Fonction pour créer un token JWT
-def create_jwt_token(username):
-    expiration = datetime.datetime.utcnow() + datetime.timedelta(hours=1)  # Le token expire après 1 heure
-    user_data = users[username]
-    payload = {
-        'sub': username,
-        'role': user_data["role"],  # Ajout du rôle dans le payload du JWT
-        'exp': expiration
-    }
-    token = create_access_token(identity=username, additional_claims={"role": user_data["role"]})  # Création du JWT
-    return token
-
-# Route pour accéder à une ressource protégée avec l'authentification de base
-@app.route('/basic-protected', methods=["GET"])
-@auth.login_required  # Protéger avec l'authentification de base
-def basic_protected():
-    return jsonify({"message": "Basic Auth: Access Granted"})
+    user = users.get(username)
+    if user and check_password_hash(user['password'], password):
+        return user
+    return None
 
-# Route publique (sans authentification)
-@app.route('/')
-def home():
-    return jsonify({"message": "Bienvenue sur l'API !"})
+@app.route('/basic-protected')
+@auth.login_required
+def basic_protected():
+    return "Basic Auth: Access Granted"
 
-# Route pour se connecter et obtenir un JWT
-@app.route('/login', methods=["POST"])
+@app.route('/login', methods=['POST'])
 def login():
-    username = request.json.get("username")
-    password = request.json.get("password")
-
-    # Vérification des identifiants
-    if username in users and check_password_hash(users[username]["password"], password):
-        token = create_jwt_token(username)  # Créer un token JWT
-        return jsonify({"access_token": token})  # Retourner le token JWT
-    else:
-        return jsonify({"message": "Identifiants invalides"}), 401
-
-# Route protégée par JWT
-@app.route('/jwt-protected', methods=["GET"])
-@jwt_required()  # Protéger avec un token JWT
+    data = request.get_json()
+    username = data.get('username')
+    password = data.get('password')
+    user = users.get(username)
+    if user and check_password_hash(user['password'], password):
+        access_token = create_access_token(identity={'username': username, 'role': user['role']})
+        return jsonify(access_token=access_token)
+
+    return jsonify({"error": "Invalid credentials"}), 401
+
+
+@app.route('/jwt-protected')
+@jwt_required()
 def jwt_protected():
-    return jsonify({"message": "JWT Auth: Access Granted"})
+    return "JWT Auth: Access Granted"
 
-# Route uniquement accessible aux administrateurs (Role-based Access Control)
-@app.route('/admin-only', methods=["GET"])
-@jwt_required()  # Protéger avec un token JWT
+@app.route('/admin-only')
+@jwt_required()
 def admin_only():
     current_user = get_jwt_identity()
-    user_role = current_user["role"]
 
-    # Vérifier si l'utilisateur a le rôle "admin"
-    if user_role != "admin":
-        return jsonify({"error": "Admin access required"}), 403  # Accès refusé si ce n'est pas un admin
+    if current_user['role'] != 'admin':
+        return jsonify({"error": "Admin access required"}), 403
 
-    return jsonify({"message": "Admin Access: Granted"})
+    return "Admin Access: Granted"
 
-# Gestion des erreurs liées au JWT
 @jwt.unauthorized_loader
 def handle_unauthorized_error(err):
     return jsonify({"error": "Missing or invalid token"}), 401
@@ -102,6 +71,4 @@ def handle_revoked_token_error(err):
 def handle_needs_fresh_token_error(err):
     return jsonify({"error": "Fresh token required"}), 401
 
-# Démarrer l'application Flask
-if __name__ == '__main__':
-    app.run(debug=True)
+app.run()