Como construir um sistema de verificação OTP usando Python

Mesmo que sua senha seja roubada, os sistemas de verificação OTP servem como um fator crucial para a segurança. Ele elimina a necessidade de lembrar senhas, funciona como uma camada extra de segurança e reduz os riscos de phishing.

Aprenda a construir um sistema de verificação OTP usando Python que envia um OTP para o seu número de celular, é válido apenas por dois minutos e sua conta é bloqueada se você digitar o OTP errado três vezes em um linha.

Instale os módulos Tkinter, Twilio e Random

Tkinter permite que você criar aplicativos de área de trabalho. Ele oferece uma variedade de widgets como botões, rótulos e caixas de texto que facilitam o desenvolvimento de aplicativos.

O módulo Twilio ajuda você a integrar funcionalidades de comunicação como SMS, MMS, chamadas telefônicas e verificação diretamente em seu aplicativo. Possui uma infraestrutura baseada em nuvem, juntamente com recursos incríveis, como provisionamento de números, modelos de mensagens e gravação de chamadas.

Para instalar os módulos Twilio e Tkinter, execute o seguinte comando no terminal:

pip install twilio tk

O módulo Random é um módulo interno do Python usado para gerar números pseudo-aleatórios. Com isso, você pode gerar números aleatórios, escolher elementos aleatórios de uma lista, embaralhar o conteúdo de uma lista e muito mais. Você pode usá-lo para criar uma simulação de rolagem de dados, um embaralhador de lista ou um gerador de senha aleatória.

Gere a API do Twilio e obtenha um número de telefone

Para usar o Twilio e enviar solicitações de OTP para seu celular, você precisa de credenciais de autenticação junto com um número de telefone do Twilio. Para alcançar isto:

1. Inscreva-se para uma conta Twilio e visite o Console Twilio.
2. Role para baixo e clique no Obter número de telefone botão. Copie o número de telefone gerado.
3. Role para baixo até o Informações da Conta seção. Copie o SID da conta e a Token de Autenticação.

Construindo a estrutura do aplicativo

Você pode encontrar todo o código fonte para construir um Sistema de Verificação OTP usando Python neste Repositório GitHub.

Importe os módulos necessários e defina as credenciais de autenticação. Inicialize o cliente Twilio para autenticar e ser o ponto de entrada para chamadas de API. Defina o tempo de expiração para dois minutos.

Definir uma classe, Verificação OTP, e inicializar o construtor para definir os valores padrão das variáveis ​​junto com a inicialização da janela raiz e definir o título e as dimensões do aplicativo.

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 três rótulos para solicitar um número de celular e um OTP e exibir um cronômetro após o programa enviar um OTP. Defina o elemento pai, o texto que ele deve exibir e os estilos de fonte que ele deve possuir. Da mesma forma, crie dois widgets de entrada para obter entrada do usuário. Defina seu elemento pai, sua largura e seus estilos de fonte.

Crie três botões para enviar OTP, reenviar OTP e Verificar OTP. Defina seu elemento pai, o texto que deve exibir, o comando que deve executar quando clicado e seus estilos de fonte. Organize esses elementos usando o pacote 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()

Construindo a Funcionalidade do Aplicativo

Defina um método, start_timer() que corre cronômetro_contagem regressiva em um tópico separado.

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

Defina um método, timer_countdown(). Registre a hora inicial e execute um loop infinito que usa a hora atual e calcula o tempo decorrido e restante. Se stop_timer for verdadeiro, encerre o loop. Se o tempo restante for menor ou igual a zero, exiba uma caixa de mensagem de erro informando que o OTP expirou.

Ative o botão reenviar OTP, defina OTP como nenhum e finalize. Caso contrário, calcule os minutos e segundos restantes, exiba-os no rótulo do cronômetro e durma por um 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)

Defina um método, send_otp(). Se bloqueado for verdadeiro, exiba a mensagem apropriada. Caso contrário, extraia o número de telefone, valide-o e gere um OTP aleatório. Passe o celular que você adquiriu anteriormente e use o cliente para enviar o OTP para o seu número de telefone. Exiba uma caixa de mensagem, inicie o cronômetro, desative os botões e limpe a entrada completamente.

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) 

Defina um método, reenviar_otp(). Se bloqueado, exiba a mensagem apropriada. Caso contrário, obtenha o número de telefone, valide-o, gere novamente um OTP aleatório, reenvie o OTP, exiba a caixa de mensagem, inicie o cronômetro e desative o botão reenviar 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)

Defina um método, verifique_otp(). Obtenha o OTP e verifique se o usuário não digitou nada. Se o OTP armazenado for Nenhum, peça ao usuário para gerar o OTP primeiro. Se o OTP que o usuário inseriu corresponder ao armazenado, exiba a mensagem de verificação de OTP bem-sucedida, pare o cronômetro e saia do programa. Caso contrário, verifique se há tentativas erradas. Se as tentativas erradas excederem três, bloqueie a conta.

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.')

Defina um método, lock_account(). Defina o status bloqueado como verdadeiro e exiba o rótulo como Conta bloqueada. Desative todos os rótulos, entradas e botões. Pare o cronômetro existente e inicie um novo por dez 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 um método start_countdown(). Se o tempo restante for menor ou igual a zero, redefina a conta. Caso contrário, mostre que o programa bloqueou a conta e tente novamente no tempo restante usando um callback.

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)

Defina uma função, redefinir_conta(). Redefina o status de todos os widgets e variáveis ​​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

Crie a janela raiz, uma instância da classe e execute o aplicativo Tkinter.

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

Exemplo de Saída de Verificação Usando OTP

Ao executar o programa OTP Verification, você obtém uma janela solicitando que você insira seu número de celular. Digite-o junto com o código do seu país e clique no botão Enviar OTP botão. Você recebe uma mensagem de que o programa enviou o OTP com sucesso e o botão é desativado por dois minutos. Verifique se há OTP em seu telefone e insira-o antes que expire.

Ao inserir o OTP correto antes que o tempo se esgote, você recebe uma mensagem informando que o programa verificou o OTP com sucesso e o programa é encerrado. Caso você não tenha digitado a tempo, receberá uma caixa de mensagem informando que o OTP expirou. Você pode clicar no Reenviar OTP botão para gerar um novo OTP e enviá-lo para o seu telefone.

Se você digitar o OTP errado, o programa exibirá uma caixa de mensagem dizendo OTP não corresponde.

Se você inserir o OTP errado três vezes, todos os campos serão desativados e a conta será bloqueada por dez minutos.

Usando Twilio com Python

Usando o Twilio, você pode criar um sistema de notificação por SMS para vários eventos. Você pode usá-lo com dispositivos IoT para acionar o SMS quando algo ficar acima ou abaixo de um determinado limite ou quando você detectar um intruso. Você pode criar sistemas de login seguros com autenticação de dois fatores, criar um chatbot do WhatsApp e um sistema de lembrete de compromissos.

Além disso, você pode usá-lo para verificação de número de telefone, campanhas de marketing, envio de pesquisas e coleta de feedback. Ao criar qualquer aplicativo, esteja sempre atento aos preços da API Twilio para evitar custos inesperados.