Comment mettre en œuvre 2FA en Python

Hacking éthique

Apprenez à améliorer la sécurité avec Python en mettant en œuvre l’authentification à deux facteurs (2FA) en utilisant des algorithmes TOTP et HOTP. Ce guide complet couvre tout, de la génération d’OPP avec pyotp à l’intégration avec des applications authentificateur.

Introduction

Dans ce tutoriel, vous apprendrez comment implémenter 2FA (Authentication à deux facteurs) en utilisant le très capable de Python. 2FA est un mécanisme de sécurité qui exige des utilisateurs qu’ils fournissent deux facteurs d’authentification différents pour vérifier leur identité. Cela ajoute une couche de sécurité supplémentaire au-delà de la combinaison traditionnelle de nom d’utilisateur et de mot de passe.

Pour garantir un accès sécurisé à un système, vous pouvez être authentifié en utilisant trois facteurs majeurs:

  1. Quelque chose que vous savez, comme un mot de passe ou un PIN.
  2. Quelque chose que vous avez, comme un jeton physique, une carte à puce ou un appareil mobile.
  3. Quelque chose que vous êtes, comme la biométrie (empreinte digitale, scanner de la rétine, etc.).

Donc, l’utilisation de deux de ces trois facteurs est 2FA. Et oui, l’utilisation de tous les trois assure plus de sécurité. L’utilisation des trois est connue sous le nom de MFA (Multi-Factor Authentication).

Table des matières:

Démarrage

Dans ce tutoriel, vous apprendrez comment ajouter des OTP en tant que couche de sécurité supplémentaire à n’importe quelle authentification qu’un système peut utiliser. Pour y parvenir en Python, nous utiliserons le pyotp bibliothèque. Nous utiliserons également le qrcode bibliothèque pour générer des codes QR pour nos clés OTP.

Commençons par installer ces paquets :

$ pip install pyotp qrcode

pyotp est une bibliothèque Python qui prend en charge la génération et la validation des OTP (mots de passe à temps unique) basées sur les algorithmes TOTP (mot de passe à temps unique basé sur le temps) et HOTP (HMAC-based One-Time Password).

TOTP génère des mots de passe à usage unique basés sur l’heure actuelle, tandis que HOTP les génère sur la base d’une valeur de compteur. TOTP est plus sûr car il annule un OTP une fois que son temps (typiquement 30 secondes) est passé. En outre, le HOTP est vulnérable aux attaques par force brute en raison de son caractère statique. Nous verrons comment mettre en œuvre les deux.

Alors que le tutoriel s’appuie sur le pyotp Bibliothèque pour générer des OTP basés sur des algorithmes TOTP et HOTP, il est important de reconnaître que dans l’écosystème plus large de l’authentification à deux facteurs, les OTP délivrés par SMS ou par courrier électronique suivent principalement le modèle TOTP en raison de leurs caractéristiques d’expiration. Cependant, les architectures système peuvent varier, et certaines peuvent implémenter un mécanisme de type HOTP, en particulier pour les OTP basés sur le courrier électronique, où la séquence ou l’événement, plutôt que le temps strictement, dicte la validité de l’OTP.

TOTP (mot de passe à usage unique basé sur le temps)

En commençant par TOTP, ouvrir un nouveau fichier et le nommer de manière significative, comme totp.py, et inclure le code suivant:

import pyotp

#Générez une clé aléatoire. Vous pouvez également définir une variable, par exemple key = "CodingFleet"
key = pyotp.random_base32()
#Créez des OTP basés sur le temps à partir de la clé.
totp = pyotp.TOTP(key)
#Imprimer la clé actuelle.
print(totp.now())
#Entrez OTP pour vérification
input_code = input("Enter your OTP:")
#
print(totp.verify(input_code))

Dans ce code très basique, qui est destiné à vous montrer comment fonctionne TOTP, nous générons essentiellement un OTP avec un OTP key et l’exhiber. Après 30 secondes, le key devient inutile. N’hésitez pas à essayer :

$ python totp.py

C’est mon résultat après avoir pénétré dans le délai imparti. Si j’y avais entré après 30 secondes, j’aurais obtenu False comme ma production.

HOTP (mot de passe à temps basé sur le HMAC)

En s’en allant avec HOTP, ouvrez un nouveau fichier Python et nommez-le hotp.py:

import pyotp

#Définissez la clé. Une variable cette fois.
key = 'Muhammad'
#Créer un OTP basé sur HMAC
hotp = pyotp.HOTP(key)
#Imprimer les résultats
print(hotp.at(0))
print(hotp.at(1))
print(hotp.at(2))
print(hotp.at(3))
#Régler le compteur
counter = 0
for otp in range(4):
   print(hotp.verify(input("Enter Code: "), counter))
   counter += 1

Dans ce code, nous générons et vérifions des mots de passe à usage unique (HOTP) basés sur HMAC avec un prédéfini key, incrémenter le compteur pour chaque OTP généré et inviter l’utilisateur à entrer dans l’OTP pour vérification. Remarquez également que maintenant notre key n’a pas été générée au hasard; elle a été définie. Tu peux aller dans les deux sens.

La principale différence est qu’avec le HOTP, tant que le key est la même chose, vous obtiendrez le même OTP – Il n’est pas basé sur le temps. Donc, il n’y a pas de prix pour deviner que vous devez utiliser un mot de passe fort et secret. Examinons-le :

$ python hotp.py

Lors des essais, entrez séquentiellement dans tous les OTP. Remarquez que j’ai eu False lorsque j’ai entré un mauvais OTP.

Intégration avec les applications Authenticator

Maintenant que nous savons ce que sont les OTP, et comment les utiliser en Python, construisons un script simple qui s’intègre à Google Authenticator – Nous pourrons voir nos OTP en utilisant Google Authenticator. Cependant, n’hésitez pas à tester avec n’importe quel Authenticator qui vous permet de numériser un code QR.

Nous allons écrire deux programmes. La première générera notre key et QR code pour nous, tandis que l’autre fera la vérification.

Donc pour le premier, nommez-le de manière significative comme otp_qrcode_and_key.py et insérer le code suivant:

Cela signifie que pour vérifier ma connexion à mon compte CodingFleet, j’ai besoin d’entrer dans ce OTP.

Maintenant, pour le programme de vérification, ouvrez un autre fichier et nommez-le otp_verification.py:

#Programme 2 : Vérifier le code TOTP avec Google Authenticator
import pyotp

def simulate_authentication(key):
   #Simulez le processus d'authentification avec un code TOTP.
   totp = pyotp.TOTP(key)
   print("Enter the code from your Google Authenticator app to complete authentication.")
   user_input = input("Enter Code: ")
   if totp.verify(user_input):
       print("Authentication successful!")
   else:
       print("Authentication failed. Please try again with the right key.")

#Code principal
#La clé doit être la même que celle générée et utilisée pour créer le code QR dans le programme 1
user_key = open("2fa.txt").read()  # Lecture de la clé à partir du fichier généré dans le programme 1 (otp_qrcode_and_key.py)
simulate_authentication(user_key)

Ce code simule le processus d’authentification à l’aide de la clé TOTP (générée dans le programme 1). Il invite l’utilisateur à entrer un code à partir de son application Google Authenticator, vérifie son exactitude et affiche le résultat de l’authentification. Nous lisons le fichier 2fa.txt généré dans le premier programme, exécutons-le:

$ python otp_verification.py

Remarquez que j’ai essayé d’utiliser la clé dans l’image de l’application Authenticator ci-dessus, qui a échoué. C’est parce que cette clé avait déjà expiré (Après 30 secondes). J’en ai donc essayé un autre, qui était encore dans sa période de validité, et ça a marché.

Conclusion

Le mécanisme OTP (un mot de passe à temps), lorsqu’il est intégré à Google Authenticator (ou à toute application d’authentification), fonctionne sur le principe de TOTP. Même après un temps important, les OTP générés par l’application d’authentification restent en synchronisme avec le code (ou potentiellement, votre serveur) parce que le serveur et l’application utilisent la même clé secrète et le temps actuel que les entrées pour générer des OTP. L’algorithme TOTP génère de nouveaux codes à des intervalles fixes (généralement toutes les 30 secondes), en veillant à ce que le code de l’application de l’utilisateur corresponde au code attendu du serveur dans le même délai. Cette méthode maintient la synchronisation entre le serveur et l’application, assurant une méthode d’authentification sûre et dynamique qui est difficile à compromettre.

Voilà, vous l’avez. C’est ainsi que vous pouvez garantir 2FA en utilisant OTP dans vos applications.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *