
Partager:
Benjamin Aronov est un défenseur des développeurs chez Vonage. C'est un bâtisseur de communauté qui a fait ses preuves, avec une formation en Ruby on Rails. Benjamin apprécie les plages de Tel Aviv, où il vit. Sa base à Tel Aviv lui permet de rencontrer et d'apprendre de certains des meilleurs fondateurs de startups du monde. En dehors de la technologie, Benjamin aime voyager à travers le monde à la recherche du parfait pain au chocolat.
Ajouter l'authentification à deux facteurs avec Django et Vonage
Dans la plupart des exemples d'authentification à deux facteurs, le deuxième facteur intervient au moment de la connexion. Cela permet de se prémunir contre le vol de mots de passe, mais offre une protection moindre contre un autre problème courant : un pirate qui dispose déjà d'un cookie de session valide.
Une fois qu'un utilisateur s'est connecté, un session Django peut rester valide pendant plusieurs jours, voire plusieurs semaines. Si quelqu’un met la main sur ce cookie, il n’aura pas besoin de repasser par votre processus de connexion. Du point de vue de l’application, il est déjà authentifié.
Django est un framework web Python de haut niveau qui favorise le développement rapide et une conception épurée et pragmatique. Il intègre nativement des fonctionnalités d'authentification, de gestion des sessions, un ORM et un système de validation des formulaires. Ce tutoriel aborde ces quatre aspects.
Pour certaines applications, le moment opportun pour introduire un deuxième facteur d'authentification n'est donc pas lors de la connexion, mais juste avant une action sensible. Voici quelques exemples d'actions sensibles pour lesquelles vous pourriez souhaiter introduire un facteur d'authentification supplémentaire : le transfert d'un billet, un virement bancaire, la rotation d'une clé API ou la modification d'un compte de paiement.
Ce modèle est généralement appelé « authentification renforcée ». L'utilisateur se connecte normalement et peut utiliser les parties à faible risque de l'application sans interruption. Lorsqu'il tente d'effectuer une opération plus sensible, l'application lui demande une étape de vérification supplémentaire.
Dans ce tutoriel, nous allons mettre en place ce processus d’authentification par étapes dans Django à l’aide de l’ Verify API. Une vérification réussie sera stockée dans la session en cours pendant cinq minutes et consommée après une action protégée. Nous traiterons également les principaux cas d'échec de l'API et testerons le flux complet sans envoyer de véritables messages.
En bref : consultez le guide de démarrage rapide sur le dépôt GitHub de la communauté Vonage.
The Setlist code entry page showing a masked destination number and a wide monospaced input containing the digits 9 1 4 8 9 7.
Contexte
Authentification renforcée vs authentification à deux facteurs (2FA) lors de la connexion
Connexion avec authentification à deux facteurs (2FA) protège l'accès au compte lui-même. Chaque nouvelle session nécessite le deuxième facteur d'authentification, que l'utilisateur ouvre une console de facturation ou consulte une page d'aide. Cette mesure est appropriée lorsque la majeure partie de l'application contient des données sensibles. Les applications bancaires et les systèmes administratifs en sont des exemples courants.
L'authentification renforcée adopte une approche différente. Les activités normales utilisent la session authentifiée existante, tandis que certaines actions spécifiques à haut risque nécessitent une vérification récente par un deuxième facteur. Cela peut s’avérer utile lorsqu’une petite partie seulement de l’application nécessite une protection renforcée. Cela permet également de limiter les contraintes supplémentaires à l’action qui les justifie.
De nombreux systèmes combinent ces deux approches. L'authentification à deux facteurs (2FA) lors de la connexion permet de protéger l'accès à l'Account, tandis que l'authentification renforcée ajoute une vérification supplémentaire avant certaines opérations particulièrement sensibles. Dans ce tutoriel, nous nous concentrerons sur cette dernière.
Ce que vous allez développer : une application Django de transfert de billets
L'application exemple s'appelle « Setlist ». Elle gère des billets de concert. Un utilisateur se connecte, consulte ses billets et peut en transférer un à un autre utilisateur. Le transfert de billet constitue l'opération sensible de cet exemple, car il consiste à retirer de l'Account un élément ayant une valeur de revente et ne peut pas être annulé par l'expéditeur.
Voici le déroulement complet du processus du point de vue de l'utilisateur :
Ada se connecte comme d'habitude et consulte ses billets — aucune vérification supplémentaire n'est nécessaire.
Clics Ada Transférer sur un billet. Comme il s’agit d’une action sécurisée, l’application la redirige vers le processus de vérification.
Si Ada a déjà enregistré un numéro de téléphone validé dans son dossier, Vonage envoie un code à ce numéro. Sinon, elle doit d'abord en saisir un.
Ada saisit le code à six chiffres. Vonage confirme qu'il est correct.
L'application enregistre la vérification, renouvelle la clé de session et finalise le transfert : le ticket apparaît désormais sur l'Account de Grace.
Si Ada tente de transférer un autre billet immédiatement après, elle doit procéder à une nouvelle vérification. Un même code ne permet pas d'autoriser plusieurs transferts.
La consultation des billets s'effectue via la session authentifiée habituelle. Pour en transférer un, un code de vérification est nécessaire. Le VerificationRequiredMixin système applique cette règle : en l’absence de vérification récente de la session, toute tentative d’accès à la page de transfert redirige directement vers le processus de vérification.
La partie réutilisable se trouve dans une application Django appelée stepup. Elle ne contient aucune logique spécifique aux tickets ; ce code pourra donc être réutilisé ultérieurement pour d'autres actions protégées.
The Setlist my-tickets page listing four concert tickets, each showing venue, date, seat, order reference, and a face value between $62 and $145, with a Transfer button.
Mise en place
Conditions préalables
Vous aurez besoin de.. :
Python 3.12 ou version ultérieure. L'exemple a été compilé avec Django 5.2.17 LTS et la version 4.8 du SDK Python de Vonage.
Un compte API Vonage.
Un téléphone capable de recevoir des SMS. Tant que votre compte est en période d'essai, vous ne pouvez envoyer des messages qu'aux numéros que vous avez ajoutés comme numéros de test. Ajoutez votre téléphone sous Vos numéros avant de tester le flux.
Configurer et exécuter l'application Django
Clonez le dépôt et créez un environnement virtuel :
git clone https://github.com/Vonage-Community/blog-django-2fa-vonage-verify.git
cd blog-django-2fa-vonage-verify
python -m venv .venv
source .venv/bin/activateInstaller les dépendances :
pip install -r requirements.txt
Copiez le fichier d'environnement d'exemple :
cp .env.example .envAjoutez ensuite vos identifiants Vonage :
VONAGE_API_KEY=your_api_key
VONAGE_API_SECRET=your_api_secret
VONAGE_BRAND_NAME=Setlist
STEP_UP_TTL_SECONDS=300
Ouvrez votre Page des paramètres de l'API pour accéder à votre clé et à votre secret API de Vonage, qui sont tous deux affichés comme indiqué dans la capture d'écran ci-dessous. La clé API se trouve en haut de la page, et pour accéder à votre secret API, veuillez vous référer à la sous-section "Secret du compte".
Remarque : si vous ne vous souvenez plus de votre secret API précédemment créé, cliquez sur "+ Créer un nouveau secret" et sauvegardez-le en toute sécurité.

Créez la base de données et importez les données de démonstration :
python manage.py migrate
python manage.py seed_demo
Démarrer Django :
python manage.py runserver
Ouvrir http://127.0.0.1:8000/ et connectez-vous en tant que ada avec le mot de passe setlist-demo. Il existe également un deuxième Account, grace, que nous utiliserons comme destinataire lors du transfert des billets.
Et voilà ! L'application est prête à être utilisée !
Ce que la Verify API de Vonage prend en charge pour vous
Avant d'aborder le code Django, il convient de distinguer les responsabilités de l'application de celles de Vonage Verify.
Si nous mettions en place nous-mêmes les codes de vérification, nous devrions les générer, les stocker, définir leur date d’expiration, appliquer des limites de tentatives, comparer les valeurs saisies en toute sécurité et déterminer la marche à suivre après un nombre excessif de tentatives infructueuses. Verify se charge de toutes ces étapes. L’application lance une vérification en envoyant un numéro de téléphone à l’API et en recevant en retour un identifiant de requête. Par la suite, elle soumet cet identifiant de requête accompagné du code saisi par l’utilisateur : Verify détermine si le code est valide et l’ensemble du cycle de vie de la requête est géré par Vonage.
Par conséquent, ce projet n'a pas besoin d'un tableau de codes, d'une colonne « date d'expiration » ni d'une tâche de nettoyage.
Verify prend également en charge la redirection vers un autre canal. Son processus consiste en une liste ordonnée de méthodes de livraison. Si le premier canal ne permet pas de mener à bien la vérification dans un délai de channel_timeout, Vonage peut passer au suivant. Un seul canal SMS suffit pour l'échantillon. Si vous souhaitez une solution de secours, vous pouvez en ajouter VoiceChannel(to=number) après celui-ci afin que la même vérification puisse se poursuivre par un appel téléphonique si le SMS n’arrive pas.
Mettre en place le processus d'authentification à plusieurs niveaux
Enregistrer le numéro de téléphone vérifié
Le modèle d'utilisateur par défaut de Django ne comporte pas de champ « numéro de téléphone ». Pour un nouveau projet, vous pouvez décider d'en ajouter un à un modèle d'utilisateur personnalisé. Dans une application existante, cependant, le remplacement du modèle d'utilisateur peut représenter une modification bien plus importante que la fonctionnalité d'authentification elle-même.
Dans cet exemple, le numéro de téléphone est géré selon un modèle « un-à-un » au sein de l’ stepup application :
# stepup/models.py
from django.conf import settings
from django.core.validators import RegexValidator
from django.db import models
# Vonage wants numbers in E.164 without the leading "+": country code followed by
# the subscriber number, digits only. Validating here means a typo fails in the form
# rather than as an HTTP 422 from the API.
e164 = RegexValidator(
regex=r"^[1-9]\d{6,14}$",
message="Enter your number in international format, digits only, e.g. 447700900000.",
)
class VerifiedPhone(models.Model):
user = models.OneToOneField(
settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
related_name="verified_phone",
)
number = models.CharField(max_length=15, validators=[e164])
confirmed_at = models.DateTimeField(
null=True,
blank=True,
help_text="Set the first time a code sent to this number is accepted.",
)Utilisez settings.AUTH_USER_MODEL ici plutôt que d’importer django.contrib.auth.models.User directement. L'importation directe User fonctionne tant que le projet conserve le modèle d'utilisateur par défaut de Django. L'utilisation de ce paramètre garantit que cette application continuera de fonctionner si le projet utilise à la place un modèle personnalisé.
La distinction entre number et confirmed_at est également utile. Un numéro saisi dans un formulaire n’est pas nécessairement encore un numéro vérifié. Dans cette application, un numéro non confirmé reste en session tant que la vérification est en cours. La base de données n’est mise à jour qu’une fois que l’utilisateur a validé le code qui lui a été envoyé à ce numéro.
Enregistrer la vérification dans la session Django
C'est au niveau de la session que l'état « step-up » doit être défini. Une première implémentation pourrait le définir après une vérification réussie :
request.session["verified"] = TrueLe problème, c’est que cette valeur resterait valide pendant toute la durée de la session, à moins qu’elle ne soit explicitement supprimée. Les sessions Django durent généralement bien plus longtemps que ne le devrait la vérification. La durée par défaut SESSION_COOKIE_AGE est de deux semaines.
Pour l'authentification renforcée, nous voulons savoir non seulement si une vérification a eu lieu, mais aussi à quel moment elle s'est produite. L'exemple stocke un horodatage :
# stepup/session.py
import time
from django.conf import settings
VERIFIED_AT_KEY = "stepup_verified_at"
REQUEST_ID_KEY = "stepup_request_id"
NUMBER_KEY = "stepup_number"
LAST_REQUEST_ID_KEY = "stepup_last_request_id"
def mark_verified(session, request_id=""):
"""Record that this session just passed a verification."""
session[VERIFIED_AT_KEY] = time.time()
session.pop(REQUEST_ID_KEY, None)
session.pop(NUMBER_KEY, None)
if request_id:
session[LAST_REQUEST_ID_KEY] = request_id
def is_verified(session):
"""True if this session verified recently enough to still count."""
verified_at = session.get(VERIFIED_AT_KEY)
if not verified_at:
return False
return (time.time() - verified_at) < settings.STEP_UP_TTL_SECONDS
La durée de vie (TTL) par défaut dans cet exemple est de cinq minutes. Cela laisse à l'utilisateur suffisamment de temps pour recevoir le message, saisir le code et mener à bien l'action protégée, sans pour autant transformer la vérification en une autorisation de longue durée.
Il est également important de conserver cet état au niveau de la session lorsque le même utilisateur est connecté sur plusieurs appareils. Si l'utilisateur s'authentifie sur son ordinateur portable, la session de son téléphone ne doit pas être automatiquement authentifiée. L'état au niveau de la session nous permet d'obtenir ce comportement sans avoir à mettre en place un suivi supplémentaire des appareils.
Valider le next Paramètre de redirection
Le processus de vérification doit rediriger l'utilisateur vers la page qu'il avait initialement demandée. Une méthode courante pour mettre cela en œuvre consiste à utiliser un next paramètre. Il est important de noter que next est une entrée contrôlée par l'utilisateur.
Ce n'est pas sûr :
return HttpResponseRedirect(request.POST["next"])
Un pirate pourrait créer une URL telle que :
https://setlist.example/verify/?next=https://evil.example/login
L'utilisateur se rendrait sur l'application authentique, suivrait son processus de vérification normal, puis serait redirigé vers un site contrôlé par un pirate.
Django fournit url_has_allowed_host_and_scheme() une solution pour ce cas :
from django.utils.http import url_has_allowed_host_and_scheme
def safe_next(request, fallback="/"):
candidate = request.POST.get("next") or request.GET.get("next")
if candidate and url_has_allowed_host_and_scheme(
url=candidate,
allowed_hosts={request.get_host()},
require_https=request.is_secure(),
):
return candidate
return fallback
Cette fonction conserve les redirections sur l'hôte actuel et intercepte également les formulaires, notamment les URL relatives au protocole, telles que //evil.example. Il s’agit du même type de vérification que le flux de connexion de Django nécessite pour son propre next .
Protéger les vues Django à l'aide d'un mixin de vérification
Ensuite, il nous faut un garde qui puisse être associé aux vues sensibles.
# stepup/mixins.py
from urllib.parse import urlencode
from django.contrib.auth.mixins import LoginRequiredMixin
from django.shortcuts import redirect
from django.urls import reverse
from . import session
class VerificationRequiredMixin(LoginRequiredMixin):
def dispatch(self, request, *args, **kwargs):
if request.user.is_authenticated and not session.is_verified(request.session):
query = urlencode({"next": request.get_full_path()})
return redirect(f"{reverse('stepup:start')}?{query}")
return super().dispatch(request, *args, **kwargs)Le mixin étend LoginRequiredMixin plutôt que de le remplacer. Dans Django, les les mixins permettent d'intégrer des comportements réutilisables dans des vues basées sur des classes : chaque mixin ajoute un élément de logique spécifique, et plusieurs mixins peuvent être combinés au sein d'une même vue. Cela permet ici de distinguer deux cas de figure : un utilisateur anonyme doit se connecter, tandis qu'un utilisateur authentifié n'ayant pas effectué de vérification renforcée récemment doit suivre le processus de vérification. Django sait déjà comment gérer le premier cas ; ce mixin ne fait donc qu’ajouter le second.
La protection d'une vue devient alors très simple :
# tickets/views.py
class TicketTransferView(VerificationRequiredMixin, View):
...
Les pages qui ne nécessitent pas d'authentification renforcée continuent d'utiliser LoginRequiredMixin. Dans Setlist, TicketListView et TicketDetailView restent des vues authentifiées classiques. L’utilisateur peut consulter ses billets sans avoir besoin d’un téléphone.
Intégrer la Verify API dans Django
Configurer le client Python de Vonage
Tout le code spécifique à Vonage est regroupé dans un seul module. Les vues Django appellent une petite interface sans avoir à se soucier du fonctionnement des requêtes, des erreurs ou des objets de réponse du SDK.
# stepup/client.py
import logging
from django.conf import settings
from pydantic import ValidationError
from vonage import Auth, Vonage
from vonage_http_client.errors import HttpRequestError
from vonage_verify import SmsChannel, VerifyRequest
logger = logging.getLogger(__name__)
_client = None
def get_client():
global _client
if _client is None:
_client = Vonage(
Auth(
api_key=settings.VONAGE_API_KEY,
api_secret=settings.VONAGE_API_SECRET,
)
)
return _client
Verify v2 prend en charge l'authentification JWT et l'authentification de base. La transmission d'une clé API et d'un secret sélectionne l'authentification de base, ce qui limite cet exemple à deux variables d'environnement. En production, l'ID d'application associé à une clé privée constitue la meilleure option par défaut ; cette configuration est également requise si vous souhaitez bénéficier de rappels d'état asynchrones.
Lancer une vérification
Le premier appel d'API lance la vérification :
def start_verification(number):
try:
# The SDK models are Pydantic, so a badly shaped number fails here rather
# than costing a round trip. It raises ValidationError, not HttpRequestError.
request = VerifyRequest(
brand=settings.VONAGE_BRAND_NAME,
code_length=6,
workflow=[SmsChannel(to=number)],
)
except ValidationError as err:
raise VerificationError(
"That number does not look right. Check the country code and try again.",
restart=True,
) from err
try:
response = get_client().verify.start_verification(request)
except HttpRequestError as err:
raise VerificationError(_start_message(err), restart=True) from err
return response.request_id
Il y a deux try blocs car la fonction présente deux points de défaillance différents. J'ai rencontré ce problème en testant le cas d'un numéro invalide. Les objets de requête du SDK Vonage v4 sont des des modèles Pydantic ; on peut donc écrire quelque chose comme :
SmsChannel(to="1")peut être déclenché pydantic.ValidationError pendant la construction de l'objet de requête. Aucune requête HTTP n'a encore été effectuée à ce stade, donc HttpRequestError ne la verra jamais. Le fait de séparer la validation du modèle et les erreurs HTTP dans des blocs distincts rend cette distinction explicite et empêche les données d’entrée mal formées de générer une réponse 500 inattendue.
Vérifier un code
La soumission du code demande moins d'efforts :
def check_code(request_id, code):
"""Submit a code for `request_id`. Returns None on success, raises otherwise."""
try:
get_client().verify.check_code(request_id=request_id, code=code)
except HttpRequestError as err:
message, restart = _check_message(err)
raise VerificationError(message, restart=restart) from errLe SDK déclenche une exception en cas d'échec des vérifications ; l'application n'a donc pas besoin de vérifier un indicateur de réussite distinct.
Gérer les erreurs de la Verify API de Vonage
La question principale pour l'interface utilisateur ne se limite pas à savoir quelle erreur HTTP s'est produite. Il faut déterminer si l'utilisateur peut continuer à travailler avec la requête de vérification en cours ou si celle-ci est terminée et s'il doit recommencer. La fonction d'aide renvoie à la fois un message et un indicateur de redémarrage :
def _check_message(err):
status = _status(err)
logger.warning("Verify check failed with HTTP %s: %s", status, err)
if status == 400:
return "That code is not right. Check the message and try again.", False
if status == 404:
return "That code has expired. Request a new one.", True
if status == 410:
# Verify enforces the attempt limit for us and retires the request.
return "Too many incorrect attempts. Request a new code.", True
if status == 429:
return "Too many attempts right now. Try again in a moment.", False
return "We could not check that code. Request a new one.", TrueUne False valeur indique que la demande de vérification existante est toujours valable. L'utilisateur reste sur le formulaire de saisie du code et peut réessayer. Une True signifie que l’application doit effacer son état « en attente » et ramener l’utilisateur au début du processus de vérification.
Le code d'état HTTP 410 est particulièrement utile, car Verify gère pour nous la limite du nombre de tentatives infructueuses. Nous n'avons donc pas besoin de gérer un compteur distinct dans Django.
Le lancement d'une vérification s'accompagne d'une cartographie des erreurs qui lui est propre. Par exemple :
if status in (401, 403):
# A credentials problem is ours, not the user's. Do not leak the detail.
return "We could not send a code just now. Please try again later."
Un code d'erreur 401 ou 403 indique un problème lié aux identifiants ou aux autorisations Vonage de l'application — consultez le référence des erreurs de l'API Vonage pour obtenir la liste complète des codes d'erreur. Les détails complets doivent figurer dans les journaux du serveur plutôt que dans le message affiché à l'utilisateur.
Le code d'erreur 409 est un autre cas qui mérite d'être traité. Il peut se produire lorsqu'une vérification est déjà en cours pour le même numéro, par exemple lorsqu'une personne envoie deux fois le formulaire d'inscription.
Créer les vues de validation dans Django
Le processus de navigation se déroule en deux étapes :
Lancer une vérification d'un numéro de téléphone.
Saisissez le code reçu sur ce téléphone.
La vue « Numéro de téléphone »
La première vue gère le numéro de téléphone et crée la requête « Verify ».
# stepup/views.py
class StartVerificationView(LoginRequiredMixin, View):
template_name = "stepup/start.html"
def post(self, request):
phone = _confirmed_phone(request.user)
form = None
if phone:
number = phone.number
else:
form = PhoneNumberForm(request.POST)
if not form.is_valid():
return render(request, self.template_name, self._context(request, phone, form))
number = form.cleaned_data["number"]
try:
request_id = client.start_verification(number)
except client.VerificationError as err:
messages.error(request, err.message)
return render(request, self.template_name, self._context(request, phone, form))
session.start_pending(request.session, request_id, number)
return redirect(_with_next(reverse("stepup:check"), session.safe_next(request)))La première branche comporte une contrainte de sécurité importante. Une fois que le numéro de téléphone d'un utilisateur a été validé, cette vue ne lui permet pas d'en fournir un autre. Sinon, un pirate disposant du mot de passe de l'utilisateur pourrait se connecter, saisir son propre numéro de téléphone et valider lui-même la deuxième étape de l'authentification. La modification d'un numéro déjà validé doit faire l'objet d'un processus distinct de gestion d'account, idéalement protégé par une vérification par rapport au numéro existant.
Pour un nouveau numéro, l'application n'enregistre pour l'instant rien non plus VerifiedPhone pour l'instant. La valeur soumise reste dans la session jusqu’à ce que le code envoyé à ce numéro ait été vérifié.
La vue « Saisie du code »
La deuxième vue vérifie le code :
class CheckCodeView(LoginRequiredMixin, View):
template_name = "stepup/check.html"
def post(self, request):
request_id = session.pending_request_id(request.session)
if not request_id:
messages.error(request, "That verification is no longer active. Request a new code.")
return redirect(_with_next(reverse("stepup:start"), session.safe_next(request)))
form = CodeForm(request.POST)
if not form.is_valid():
return render(request, self.template_name, self._context(request, form))
try:
client.check_code(request_id, form.cleaned_data["code"])
except client.VerificationError as err:
messages.error(request, err.message)
if err.restart:
session.clear(request.session)
return redirect(_with_next(reverse("stepup:start"), session.safe_next(request)))
return render(request, self.template_name, self._context(request, form))
number = session.pending_number(request.session)
redirect_to = session.safe_next(request)
# Rotate the session key on a successful second factor, the same way Django
# does on login. A session ID captured before the step-up is useless after it.
request.session.cycle_key()
_remember_number(request.user, number)
session.mark_verified(request.session, request_id)
return redirect(redirect_to)L’appel à cycle_key() mérite qu'on s'y attarde. Django renouvelle la clé de session lors de la connexion afin de se prémunir contre la fixation de session. Si un attaquant parvenait à établir un identifiant de session connu avant l'authentification, l'ancien identifiant deviendrait inutile une fois l'utilisateur connecté. Une vérification à deux facteurs réussie constitue une autre étape d'authentification ; c'est pourquoi l'exemple renouvelle également la clé de session à ce stade.
Points forts et pièges
Améliorer la saisie des codes à usage unique sur mobile
Le formulaire de vérification fournit également au navigateur quelques conseils utiles :
code = forms.CharField(
min_length=4,
max_length=10,
label="Verification code",
widget=forms.TextInput(
attrs={
"inputmode": "numeric", # Lets iOS and Android offer the code straight from the SMS.
"autocomplete": "one-time-code",
"autofocus": "autofocus",
}
),
)inputmode="numeric" encourage les navigateurs mobiles à afficher un clavier numérique. autocomplete="one-time-code" permet aux plateformes mobiles prises en charge de proposer le code SMS reçu directement depuis la notification. C'est un petit ajout qui élimine la partie la plus fastidieuse de l'étape de vérification.
Deux pièges à éviter avec Django
Lors de la création de l'exemple, deux problèmes sont apparus, liés à Django lui-même plutôt qu'à la Verify API. Aucun des deux n'est compliqué une fois que l'on comprend ce qui se passe, mais ils peuvent facilement passer inaperçus.
Normaliser le numéro de téléphone avant la validation du champ
On tape souvent les Numbers en les séparant par des espaces ou en les faisant précéder d'un signe « + » :
+44 7700 900000
C'est une entrée valable pour un formulaire, même si la valeur que nous envoyons finalement à Vonage ne doit contenir que des chiffres. Ma première idée a été de la normaliser dans clean_number(). Le problème, c’est que Django exécute les validateurs de champs avant la méthode clean_<field> . Cela signifie que l'expression régulière E.164 analyse la valeur d'origine, y compris les + et les espaces, et la rejette avec le message de validation (« Entrez votre numéro au format international, chiffres uniquement ») avant que clean_number() n’ait eu le temps de modifier quoi que ce soit.
La méthode d'un champ personnalisé to_python() s'exécute plus tôt :
# stepup/forms.py
# Everything people type around a phone number that is decoration, not digits.
DECORATION = re.compile(r"[\s()\-.]")
class PhoneNumberField(forms.CharField):
def to_python(self, value):
value = super().to_python(value)
if value in self.empty_values:
return value
return DECORATION.sub("", value).lstrip("+")Au moment où les validateurs s'exécutent, ils reçoivent la représentation normalisée.
Ne pas charger d'objets protégés dans dispatch()
La première version de la vue de transfert de billet chargeait le billet dans dispatch():
def dispatch(self, request, *args, **kwargs):
self.ticket = get_object_or_404(Ticket, pk=kwargs["pk"], owner=request.user.pk)
return super().dispatch(request, *args, **kwargs)Cela ne fonctionne pas correctement pour les requêtes anonymes. Pour un utilisateur anonyme, request.user.pk est None. La recherche de ticket échoue et renvoie un code 404 avant LoginRequiredMixin, ce qui permet également, via dispatch(), a la possibilité de rediriger l'utilisateur vers la page de connexion.
Une meilleure approche consiste à laisser les mixins d'accès se charger dispatch() et de charger l'objet ultérieurement :
@cached_property
def ticket(self):
return get_object_or_404(
Ticket.objects.select_related("event"),
pk=self.kwargs["pk"],
owner=self.request.user.pk,
)La vue peut alors utiliser self.ticket à partir de get() et post() une fois que l’authentification a déjà été vérifiée.
Effectuer la vérification après le transfert
Une vérification récente redirige l'utilisateur vers la page de transfert de ticket, mais il reste encore une décision à prendre en matière de politique de sécurité. Cette vérification doit-elle autoriser toutes les actions sensibles effectuées pendant la durée de validité (TTL) de cinq minutes, ou uniquement l'action que l'utilisateur avait initialement l'intention d'effectuer ?
Dans cet exemple, une vérification autorise un transfert. Le transfert lui-même s'effectue dans le cadre d'une transaction de base de données :
with transaction.atomic():
Transfer.objects.create(
ticket=self.ticket,
sender=request.user,
recipient=form.recipient,
verification_request_id=session.last_request_id(request.session),
)
self.ticket.owner = form.recipient
self.ticket.save(update_fields=["owner"])
# One verification, one transfer.
# Leaving the session verified would let a
# single code authorize every ticket in the account.
session.clear(request.session)Une fois le transfert effectué, l'état « step-up » est supprimé de la session. Si l'utilisateur souhaite transférer un autre billet, il devra recommencer le processus de vérification. Cette approche est plus stricte que de se fier uniquement au délai de validité (TTL) de cinq minutes, mais elle correspond à la politique que nous mettons en œuvre : le code a autorisé une seule opération à haut risque.
L' Transfer enregistrement stocke également l’identifiant de la demande Verify associé à l’action. Cela fournit à l’application une piste d’audit reliant le transfert à une demande Verify spécifique. Si le transfert fait l’objet d’une contestation ultérieure, l’enregistrement contient davantage d’éléments probants qu’une simple valeur booléenne indiquant que la session a été vérifiée à ce moment-là.
Authentication can help secure important actions for your users, like transferring tickets.
Tester sans envoyer de SMS
Le projet comporte 47 tests. Aucun d'entre eux n'accède au réseau, ne nécessite d'identifiants ni n'envoie de message.
Cela fonctionne car les exceptions HTTP de Vonage encapsulent un requests.Response. Un test peut en créer une manuellement et la transmettre à la même classe d'exception que celle que le SDK aurait levée :
# stepup/tests/support.py
from json import dumps
from requests import Response
from vonage_http_client.errors import HttpRequestError, NotFoundError, RateLimitedError
def http_error(status_code, title="error"):
"""Build the exception the Vonage SDK would raise for a given status code."""
response = Response()
response.status_code = status_code
response.url = "https://api.nexmo.com/v2/verify"
response._content = dumps({"title": title}).encode()
if status_code == 404:
return NotFoundError(response)
if status_code == 429:
return RateLimitedError(response)
return HttpRequestError(response)Intégrez cette http_error() factory dans start_verification() ou check_code() et chaque branche du mappage des erreurs devient un test de trois lignes : code erroné, requête expirée, trop de tentatives, limite de débit, requête simultanée et identifiants incorrects. Le référentiel contient également les tests qui vérifient les politiques de sécurité elles-mêmes, notamment le fait qu’un utilisateur confirmé ne puisse pas rediriger des codes vers un nouveau numéro.
Exécutez la suite complète à l'aide de la commande suivante :
python manage.py test Prochaines étapes
L' stepup application est volontairement légère et autonome. Pour réutiliser ce modèle ailleurs, ajoutez VerificationRequiredMixin aux vues nécessitant une authentification plus stricte. Cela peut concerner notamment la modification d’un mot de passe, l’ajout d’un moyen de paiement, la suppression d’un Account, la rotation d’une clé API ou la divulgation d’un secret.
Il est également utile d'inclure les lectures sensibles dans cet examen. L'affichage d'une clé API ou d'un identifiant de récupération peut avoir des conséquences tout aussi graves que leur modification.
Cet exemple omet délibérément certains éléments. Le premier concerne la récupération de compte. Tel qu’il est présenté, la perte de l’accès au numéro de téléphone validé entraîne également la perte de la possibilité de transférer des billets. Une application réelle nécessiterait généralement des codes de secours, un processus de récupération assisté par le service client ou un autre facteur de récupération.
La deuxième consiste à modifier le numéro de téléphone validé. Cela devrait faire l'objet d'un processus spécifique, normalement sécurisé par une vérification par rapport au numéro existant.
L'application doit également mettre en place ses propres limites de débit pour ses points de terminaison. Verify assure la protection du côté API du processus de vérification, mais cela n'empêche pas quelqu'un d'envoyer des requêtes à répétition vers votre point de terminaison Django.
Enfin, Verify prend en charge l'authentification silencieuse. L’authentification silencieuse permet de vérifier un numéro de téléphone via l’opérateur sans que l’utilisateur ait à saisir de code ; un SMS est disponible en solution de secours lorsque la vérification silencieuse n’est pas possible. Le déroulement global de l’application reste similaire, mais l’interaction avec l’utilisateur peut être plus fluide.
Le code source complet est disponible sur GitHub.
En résumé
Ce tutoriel a permis de créer de A à Z un flux d'authentification par étapes dans Django. Voici ce que couvre l'implémentation finale :
L'API Vonage Verify gère la génération, la transmission et l'expiration des codes, ainsi que les limites de tentatives et l'application de ces règles. L'application n'a qu'à lancer une demande de vérification, puis à vérifier le code fourni.
VerificationRequiredMixinpermet de protéger n'importe quelle vue basée sur une classe en une seule ligne de code. Elle s'enchaîne surLoginRequiredMixinde sorte que les utilisateurs anonymes soient redirigés vers la page de connexion, et que les utilisateurs authentifiés mais non vérifiés soient redirigés vers le processus de vérification.État lié à la session avec un TTL court limite la vérification à un seul appareil et à une fenêtre de cinq minutes. Pas de fuite entre appareils, pas d'autorisation de longue durée.
Une vérification, une action. Le fait d'utiliser l'état « step-up » après le transfert signifie qu'un seul code ne peut pas autoriser discrètement tous les billets de l'Account.
Redirections sécurisées, rotation des sessions et verrouillage des numéros de téléphone permettent de combler les failles de mise en œuvre les plus courantes : attaques par redirection ouverte, fixation de session et redirection des identifiants.
47 tests, aucun vrai SMS. La
http_error()factory permet de tester chaque branche d'erreur en injectant une fausse exception HTTP, ce qui garantit la rapidité de la suite de tests et évite d'avoir à saisir des identifiants.
Vous souhaitez en savoir plus, rester en contact ou partager ce que vous êtes en train de créer ?
Continuez à apprendre
Découvrez des cas d'utilisation et des parcours d'apprentissage structurés dans le Centre de formation Vonage
Regardez les tutoriels sur notre chaîne YouTube Vonage Developer
Restez connecté
Abonnez-vous à la newsletter des développeurs Vonage
Suivez-nous sur X pour rester informé
Retrouvez-nous sur LinkedIn
Aidez-nous à améliorer l'expérience des développeurs en remplissant notre formulaire de commentaires « Voice of the Developer »
Partager:
Benjamin Aronov est un défenseur des développeurs chez Vonage. C'est un bâtisseur de communauté qui a fait ses preuves, avec une formation en Ruby on Rails. Benjamin apprécie les plages de Tel Aviv, où il vit. Sa base à Tel Aviv lui permet de rencontrer et d'apprendre de certains des meilleurs fondateurs de startups du monde. En dehors de la technologie, Benjamin aime voyager à travers le monde à la recherche du parfait pain au chocolat.