Cómo construir un sistema de verificación OTP usando Python

Incluso si le roban su contraseña, los sistemas de verificación de OTP sirven como un factor crucial para la seguridad. Elimina la necesidad de recordar contraseñas, sirve como una capa adicional de seguridad y reduce los riesgos de phishing.

Aprende a construir un sistema de verificación de OTP usando Python que te envía una OTP a tu número de móvil, es solo es válido por dos minutos y su cuenta se bloquea si ingresa la OTP incorrecta tres veces en un fila.

Instalar módulos Tkinter, Twilio y Random

Tkinter te permite crear aplicaciones de escritorio. Ofrece una variedad de widgets como botones, etiquetas y cuadros de texto que facilitan el desarrollo de aplicaciones.

El módulo Twilio le ayuda a integrar funcionalidades de comunicación como SMS, MMS, llamadas telefónicas y verificación directamente en su aplicación. Tiene una infraestructura basada en la nube junto con características sorprendentes como el aprovisionamiento de números, plantillas de mensajes y grabación de llamadas.

Para instalar los módulos Twilio y Tkinter, ejecute el siguiente comando en la terminal:

pip install twilio tk

El módulo Random es un módulo integrado de Python que se utiliza para generar números pseudoaleatorios. Con esto, puede generar números aleatorios, elegir elementos aleatorios de una lista, mezclar el contenido de una lista y más. Puede usarlo para crear una simulación de tirada de dado, un barajador de listas o un generador de contraseñas aleatorias.

Genere la API de Twilio y obtenga un número de teléfono

Para usar Twilio y enviar solicitudes OTP a su teléfono móvil, necesita credenciales de autenticación junto con un número de teléfono de Twilio. Lograr esto:

1. Regístrese para obtener una cuenta de Twilio y visite el consola Twilio.
2. Desplácese hacia abajo y haga clic en el Obtener número de teléfono botón. Copie el número de teléfono generado.
3. Desplácese hacia abajo hasta el Informacion de cuenta sección. Copia el SID de la cuenta y el Token de autenticación.

Construcción de la estructura de la aplicación

Puede encontrar el código fuente completo para construir un sistema de verificación OTP usando Python en este repositorio GitHub.

Importe los módulos necesarios y establezca las credenciales de autenticación. Inicialice el cliente de Twilio para autenticarse y ser el punto de entrada para las llamadas a la API. Establezca el tiempo de caducidad en dos minutos.

Definir una clase, OTPVerificación, e inicialice el constructor para establecer los valores predeterminados de las variables junto con la inicialización de la ventana raíz y el establecimiento del título y las dimensiones de la aplicación.

import tkinter as tk
from tkinter import messagebox
from twilio.rest import Client
import random
import threading
import time
account_sid = "YOUR_ACCOUNT_SID"
auth_token = "YOUR_AUTH_TOKEN"
client = Client(account_sid, auth_token)
expiration_time = 120
classOTPVerification:
def__init__(self, master):
 self.master = master
 self.master.title('OTP Verification')
 self.master.geometry("600x275")
 self.otp = None
 self.timer_thread = None
 self.resend_timer = None
 self.wrong_attempts = 0
 self.locked = False
 self.stop_timer = False

Defina tres etiquetas para solicitar un número de teléfono móvil y una OTP, y para mostrar un temporizador después de que el programa envíe una OTP. Establezca el elemento principal, el texto que debe mostrar y los estilos de fuente que debe tener. Del mismo modo, cree dos widgets de entrada para obtener información del usuario. Establezca su elemento principal, su ancho y sus estilos de fuente.

Cree tres botones para enviar OTP, reenviar OTP y Verificar OTP. Establezca su elemento principal, el texto que debe mostrar, el comando que debe ejecutar al hacer clic y sus estilos de fuente. Organiza estos elementos usando el embalar método.

 self.label1 = tk.Label(self.master, 
 text='Enter your mobile number:',
 font=('Arial', 14))
 self.label1.pack()
 self.mobile_number_entry = tk.Entry(self.master, 
 width=20,
 font=('Arial', 14))
 self.mobile_number_entry.pack()
 self.send_otp_button = tk.Button(self.master, 
 text='Send OTP', 
 command=self.send_otp,
 font=('Arial', 14))
 self.send_otp_button.pack()
 self.timer_label = tk.Label(self.master, 
 text='', 
 font=('Arial', 12, 'bold'))
 self.timer_label.pack()
 self.resend_otp_button = tk.Button(self.master, 
 text='Resend OTP', 
 state=tk.DISABLED, 
 command=self.resend_otp,
 font=('Arial', 14))
 self.resend_otp_button.pack()
 self.label2 = tk.Label(self.master, 
 text='Enter OTP sent to your mobile:',
 font=('Arial', 14))
 self.label2.pack()
 self.otp_entry = tk.Entry(self.master, 
 width=20,
 font=('Arial', 14))
 self.otp_entry.pack()
 self.verify_otp_button = tk.Button(self.master, 
 text='Verify OTP', 
 command=self.verify_otp,
 font=('Arial', 14))
 self.verify_otp_button.pack()

Construyendo la Funcionalidad de la Aplicación

Definir un método, start_timer() que corre timer_countdown en un hilo aparte.

defstart_timer(self):
 self.timer_thread = threading.Thread(target=self.timer_countdown)
 self.timer_thread.start()

Definir un método, temporizador_cuenta atrás(). Registre la hora de inicio y ejecute un bucle infinito que tome la hora actual y calcule el tiempo transcurrido y restante. Si stop_timer es verdadero, termina el bucle. Si el tiempo restante es menor o igual a cero, muestra un cuadro de mensaje de error que dice que la OTP caducó.

Active el botón OTP de reenvío, establezca OTP en ninguno y finalice. De lo contrario, calcule los minutos y segundos restantes, muéstrelo en la etiqueta del temporizador y duerma durante un segundo.

deftimer_countdown(self):
 start_time = time.time()
whileTrue:
 current_time = time.time()
 elapsed_time = current_time - start_time
 remaining_time = expiration_time - elapsed_time
if self.stop_timer:
break
if remaining_time <= 0:
 messagebox.showerror('Error', 'OTP has expired.')
 self.resend_otp_button.config(state=tk.NORMAL)
 self.otp = None
break
 minutes = int(remaining_time // 60)
 seconds = int(remaining_time % 60)
 timer_label = f'Time Remaining: {minutes:02d}:{seconds:02d}'
 self.timer_label.config(text=timer_label)
 time.sleep(1)

Definir un método, enviar_otp(). Si bloqueado es verdadero, muestre el mensaje apropiado. De lo contrario, extraiga el número de teléfono, valídalo y genere una OTP aleatoria. Pase el teléfono móvil que recibió anteriormente y use el cliente para enviar la OTP a su número de teléfono. Muestre un cuadro de mensaje, inicie el temporizador, deshabilite los botones y borre la entrada por completo.

defsend_otp(self):
if self.locked:
 messagebox.showinfo('Account Locked', 'Your account is locked. Try again later.')
return
 mobile_number = self.mobile_number_entry.get()
ifnot mobile_number:
 messagebox.showerror('Error', 'Please enter your mobile number.')
return
 self.otp = random.randint(1000, 9999)
 message = client.messages.create(
 body=f'Your OTP is {self.otp}.',
 from_='TWILIO_MOBILE_NUMBER',
 to=mobile_number
 )
 messagebox.showinfo('OTP Sent', f'OTP has been sent to {mobile_number}.')
 self.start_timer()
 self.send_otp_button.config(state=tk.DISABLED) 
 self.resend_otp_button.config(state=tk.DISABLED) 
 self.otp_entry.delete(0, tk.END) 

Definir un método, reenviar_otp(). Si está bloqueado, muestra el mensaje correspondiente. De lo contrario, obtenga el número de teléfono, valídelo, regenere una OTP aleatoria, vuelva a enviar la OTP, muestre el cuadro de mensaje, inicie el temporizador y deshabilite el botón de reenvío de OTP.

defresend_otp(self):
if self.locked:
 messagebox.showinfo('Account Locked', 'Your account is locked. Try again later.')
return
 mobile_number = self.mobile_number_entry.get()
ifnot mobile_number:
 messagebox.showerror('Error', 'Please enter your mobile number.')
return
 self.otp = random.randint(1000, 9999)
 message = client.messages.create(
 body=f'Your OTP is {self.otp}.',
 from_='TWILIO_MOBILE_NUMBER',
 to=mobile_number
 )
 messagebox.showinfo('OTP Sent', f'New OTP has been sent to {mobile_number}.')
 self.start_timer()
 self.resend_otp_button.config(state=tk.DISABLED)

Definir un método, verificar_otp(). Obtenga la OTP y verifique si el usuario no ha ingresado nada. Si la OTP almacenada es Ninguno, solicite al usuario que primero genere la OTP. Si la OTP que ingresó el usuario coincide con la almacenada, muestre el mensaje de verificación de OTP exitosa, detenga el temporizador y salga del programa. De lo contrario, verifique si hay intentos incorrectos. Si los intentos erróneos superan los tres, bloquea la cuenta.

defverify_otp(self):
 user_otp = self.otp_entry.get()
ifnot user_otp:
 messagebox.showerror('Error', 'Please enter OTP.')
return
if self.otp isNone:
 messagebox.showerror('Error', 'Please generate OTP first.')
return
if int(user_otp) == self.otp:
 messagebox.showinfo('Success', 'OTP verified successfully.')
 self.stop_timer = True
 exit()
else:
 self.wrong_attempts += 1
if self.wrong_attempts == 3:
 self.lock_account()
else:
 messagebox.showerror('Error', 'OTP does not match.')

Definir un método, bloquear cuenta(). Establezca el estado bloqueado en verdadero y muestre la etiqueta como Cuenta bloqueada. Deshabilite todas las etiquetas, entradas y botones. Detenga el temporizador existente y comience uno nuevo durante diez minutos.

deflock_account(self):
 self.locked = True
 self.label1.config(text='Account Locked')
 self.mobile_number_entry.config(state=tk.DISABLED)
 self.send_otp_button.config(state=tk.DISABLED)
 self.timer_label.config(text='')
 self.resend_otp_button.config(state=tk.DISABLED)
 self.label2.config(text='')
 self.otp_entry.config(state=tk.DISABLED)
 self.verify_otp_button.config(state=tk.DISABLED)
 self.stop_timer = True
 countdown_time = 10 * 60
 self.start_countdown(countdown_time)

Definir un método start_countdown(). Si el tiempo restante es menor o igual a cero, reinicie la cuenta. De lo contrario, muestre que el programa ha bloqueado la cuenta e intente nuevamente en el tiempo restante mediante una devolución de llamada.

defstart_countdown(self, remaining_time):
if remaining_time <= 0:
 self.reset_account()
return
 minutes = int(remaining_time // 60)
 seconds = int(remaining_time % 60)
 timer_label = f'Account Locked. Try again in: {minutes:02d}:{seconds:02d}'
 self.timer_label.config(text=timer_label)
 self.master.after(1000, self.start_countdown, remaining_time - 1)

Definir una función, restablecer_cuenta(). Restablezca el estado de todos los widgets y variables como antes.

defreset_account(self):
 self.locked = False
 self.wrong_attempts = 0
 self.label1.config(text='Enter your mobile number:')
 self.mobile_number_entry.config(state=tk.NORMAL)
 self.send_otp_button.config(state=tk.NORMAL)
 self.timer_label.config(text='')
 self.resend_otp_button.config(state=tk.DISABLED)
 self.label2.config(text='Enter OTP sent to your mobile:')
 self.otp_entry.config(state=tk.NORMAL)
 self.verify_otp_button.config(state=tk.NORMAL)
 self.stop_timer = False

Cree la ventana raíz, una instancia de la clase y ejecute la aplicación Tkinter.

if __name__ == '__main__':
 root = tk.Tk()
 otp_verification = OTPVerification(root)
 root.mainloop()

Ejemplo de salida de verificación usando OTP

Al ejecutar el programa de verificación OTP, aparece una ventana que le pide que ingrese su número de teléfono móvil. Introdúcelo junto con el código de tu país y pulsa el botón Enviar OTP botón. Recibe un mensaje de que el programa ha enviado la OTP con éxito y el botón se desactiva durante dos minutos. Verifique su teléfono para OTP e ingréselo antes de que caduque.

Al ingresar la OTP correcta antes de que se agote el tiempo, recibe un mensaje de que el programa ha verificado la OTP con éxito y el programa sale. En caso de que no lo haya ingresado a tiempo, recibirá un cuadro de mensaje que indica que la OTP ha caducado. Puedes hacer click en el Reenviar OTP botón para generar una nueva OTP y enviarla a su teléfono.

Si ingresa la OTP incorrecta, el programa muestra un cuadro de mensaje que dice OTP no coincide.

Si ingresa la OTP incorrecta tres veces, todos los campos se deshabilitan y la cuenta se bloquea durante diez minutos.

Usar Twilio con Python

Con Twilio, puede crear un sistema de notificación por SMS para varios eventos. Puede usarlo con dispositivos IoT para activar SMS cuando algo cae por encima o por debajo de cierto umbral o cuando detecta un intruso. Puede crear sistemas de inicio de sesión seguros con autenticación de dos factores, crear un chatbot de WhatsApp y un sistema de recordatorio de citas.

Aparte de esto, puede usarlo para la verificación de números de teléfono, campañas de marketing, envío de encuestas y recopilación de comentarios. Al crear cualquier aplicación, tenga siempre en cuenta los precios de la API de Twilio para evitar costos inesperados.