Come costruire un sistema di verifica OTP usando Python

Anche se la tua password viene rubata, i sistemi di verifica OTP rappresentano un fattore cruciale per la sicurezza. Elimina la necessità di ricordare le password, funge da ulteriore livello di sicurezza e riduce i rischi di phishing.

Impara a creare un sistema di verifica OTP utilizzando Python che ti invia una OTP al tuo numero di cellulare valido solo per due minuti e il tuo account viene bloccato se inserisci l'OTP sbagliato tre volte in a riga.

Installa Tkinter, Twilio e moduli casuali

Tkinter te lo permette creare applicazioni desktop. Offre una varietà di widget come pulsanti, etichette e caselle di testo che semplificano lo sviluppo di applicazioni.

Il modulo Twilio ti aiuta a integrare funzionalità di comunicazione come SMS, MMS, telefonate e verifiche direttamente nella tua applicazione. Ha un'infrastruttura basata su cloud insieme a funzionalità straordinarie come il provisioning del numero, i modelli di messaggio e la registrazione delle chiamate.

Per installare i moduli Twilio e Tkinter, eseguire il seguente comando nel terminale:

pip install twilio tk

Il modulo Random è un modulo Python integrato utilizzato per generare numeri pseudo-casuali. Con questo, puoi generare numeri casuali, scegliere elementi casuali da un elenco, mescolare il contenuto di un elenco e altro ancora. Puoi usarlo per costruire una simulazione del tiro di dado, un mescolatore di elenchi o un generatore di password casuali.

Genera l'API Twilio e ottieni un numero di telefono

Per utilizzare Twilio e inviare richieste OTP al tuo telefono cellulare, sono necessarie le credenziali di autenticazione insieme a un numero di telefono Twilio. Per realizzare questo:

1. Registrati per un account Twilio e visita il Consolle Twilio.
2. Scorri verso il basso e fai clic sul Ottieni il numero di telefono pulsante. Copia il numero di telefono generato.
3. Scorri verso il basso fino a Informazioni sull'account sezione. Copia il Codice identificativo dell'account e il Token di autenticazione.

Costruire la struttura dell'applicazione

Puoi trovare l'intero codice sorgente per creare un sistema di verifica OTP usando Python in questo Deposito GitHub.

Importa i moduli necessari e imposta le credenziali di autenticazione. Inizializza il client Twilio per l'autenticazione e diventa il punto di ingresso per le chiamate API. Impostare il tempo di scadenza su due minuti.

Definisci una classe, Verifica OTP, e inizializzare il costruttore per impostare i valori predefiniti delle variabili insieme all'inizializzazione della finestra principale e all'impostazione del titolo e delle dimensioni dell'applicazione.

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

Definisci tre etichette per richiedere un numero di cellulare e una OTP e per visualizzare un timer dopo che il programma ha inviato una OTP. Imposta l'elemento genitore, il testo che dovrebbe visualizzare e gli stili di carattere che dovrebbe possedere. Allo stesso modo, crea due widget di immissione per ottenere l'input dall'utente. Imposta il suo elemento genitore, la sua larghezza e i suoi stili di carattere.

Crea tre pulsanti per inviare OTP, inviare nuovamente OTP e verificare OTP. Imposta il suo elemento genitore, il testo che dovrebbe visualizzare, il comando che dovrebbe eseguire quando si fa clic e i suoi stili di carattere. Organizza questi elementi utilizzando il file pacchetto metodo.

 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()

Creazione della funzionalità dell'applicazione

Definire un metodo, start_timer() che corre timer_conto alla rovescia in un thread separato.

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

Definire un metodo, timer_conto alla rovescia(). Registra l'ora di inizio ed esegui un ciclo infinito che prende l'ora corrente e calcola il tempo trascorso e quello rimanente. Se stop_timer è vero, termina il ciclo. Se il tempo rimanente è minore o uguale a zero, visualizza una finestra di messaggio di errore indicante che l'OTP è scaduto.

Attiva il pulsante Reinvia OTP, imposta OTP su nessuno e termina. Altrimenti, calcola i minuti e i secondi rimanenti, visualizzali sull'etichetta del timer e dormi per un secondo.

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)

Definire un metodo, invia_otp(). Se bloccato è vero, visualizza il messaggio appropriato. Altrimenti, estrai il numero di telefono, convalidalo e genera un OTP casuale. Passa il cellulare che hai ricevuto in precedenza e utilizza il client per inviare l'OTP al tuo numero di telefono. Visualizza una finestra di messaggio, avvia il timer, disabilita i pulsanti e cancella completamente la voce.

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) 

Definire un metodo, rispedisci_otp(). Se bloccato, visualizza il messaggio appropriato. Altrimenti, ottenere il numero di telefono, convalidarlo, rigenerare una OTP casuale, inviare nuovamente l'OTP, visualizzare la finestra di messaggio, avviare il timer e disabilitare il pulsante Reinvia 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)

Definire un metodo, verifica_otp(). Ottieni l'OTP e controlla se l'utente non ha inserito nulla. Se l'OTP memorizzato è Nessuno, chiedi all'utente di generare prima l'OTP. Se l'OTP immesso dall'utente corrisponde a quello memorizzato, visualizzare il messaggio di verifica OTP riuscita, arrestare il timer e uscire dal programma. Altrimenti, controlla se ci sono tentativi sbagliati. Se i tentativi sbagliati superano i tre, blocca l'account.

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

Definire un metodo, lock_account(). Imposta lo stato bloccato su true e visualizza l'etichetta come Account bloccato. Disabilita tutte le etichette, voci e pulsanti. Arresta il timer esistente e avviane uno nuovo per dieci minuti.

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)

Definire un metodo inizio_conto alla rovescia(). Se il tempo rimanente è minore o uguale a zero, reimpostare l'account. In caso contrario, mostra che il programma ha bloccato l'account e riprova nel tempo rimanente utilizzando una richiamata.

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)

Definire una funzione, ripristina_account(). Ripristina lo stato di tutti i widget e le variabili come prima.

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

Crea la finestra radice, un'istanza della classe, ed esegui l'applicazione Tkinter.

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

Esempio di output della verifica tramite OTP

Durante l'esecuzione del programma di verifica OTP, viene visualizzata una finestra che ti chiede di inserire il tuo numero di cellulare. Inseriscilo insieme al prefisso del tuo paese e premi il Invia OTP pulsante. Ricevi un messaggio che il programma ha inviato correttamente l'OTP e il pulsante si disattiva per due minuti. Controlla il tuo telefono per OTP e inseriscilo prima che scada.

Quando si immette l'OTP corretto prima che scada il tempo, si riceve un messaggio che indica che il programma ha verificato l'OTP con successo e il programma si chiude. Nel caso in cui non l'avessi inserito in tempo, riceverai una finestra di messaggio che dice che l'OTP è scaduto. Puoi cliccare sul Invia nuovamente OTP pulsante per generare una nuova OTP e inviarla al telefono.

Se inserisci l'OTP sbagliato, il programma visualizza una finestra di messaggio che dice OTP non corrisponde.

Se inserisci tre volte l'OTP sbagliato, tutti i campi vengono disabilitati e l'account viene bloccato per dieci minuti.

Utilizzo di Twilio con Python

Utilizzando Twilio, puoi creare un sistema di notifica SMS per vari eventi. Puoi usarlo con i dispositivi IoT per attivare SMS quando qualcosa scende al di sopra o al di sotto di una certa soglia o quando rilevi un intruso. Puoi creare sistemi di accesso sicuri con autenticazione a due fattori, creare un chatbot di WhatsApp e un sistema di promemoria degli appuntamenti.

Oltre a questo, puoi usarlo per la verifica del numero di telefono, campagne di marketing, invio di sondaggi e raccolta di feedback. Durante la creazione di qualsiasi applicazione, tieni sempre presente i prezzi dell'API Twilio per evitare costi imprevisti.