Cum să construiți un sistem de verificare OTP folosind Python

Chiar dacă parola dvs. este furată, sistemele de verificare OTP servesc ca un factor crucial pentru securitate. Elimină nevoia de a reține parolele, servește ca un strat suplimentar de securitate și reduce riscurile de phishing.

Învățați să construiți un sistem de verificare OTP folosind Python care vă trimite un OTP la numărul dvs. de mobil, este valabil doar două minute și contul dvs. este blocat dacă introduceți OTP greșit de trei ori într-un rând.

Instalați modulele Tkinter, Twilio și Random

Tkinter vă permite creați aplicații desktop. Oferă o varietate de widget-uri, cum ar fi butoane, etichete și casete de text, care facilitează dezvoltarea aplicațiilor.

Modulul Twilio vă ajută să să integreze funcționalități de comunicare precum SMS-urile, MMS, apeluri telefonice și verificare direct în aplicația dvs. Are o infrastructură bazată pe cloud, împreună cu funcții uimitoare, cum ar fi furnizarea de numere, șabloane de mesaje și înregistrarea apelurilor.

Pentru a instala modulele Twilio și Tkinter, rulați următoarea comandă în terminal:

pip install twilio tk

Modulul Random este un modul Python încorporat folosit pentru generarea de numere pseudoaleatoare. Cu aceasta, puteți genera numere aleatorii, alege elemente aleatorii dintr-o listă, amestecați conținutul unei liste și multe altele. Îl puteți folosi pentru a construi o simulare de rulare a zarurilor, un amestecător de liste sau un generator de parole aleatorii.

Generați API-ul Twilio și obțineți un număr de telefon

Pentru a utiliza Twilio și a trimite cereri OTP pe telefonul dvs. mobil, aveți nevoie de acreditări de autentificare împreună cu un număr de telefon Twilio. Pentru a realiza acest lucru:

1. Înscrieți-vă pentru un cont Twilio și vizitați Consola Twilio.
2. Derulați în jos și faceți clic pe Obțineți numărul de telefon buton. Copiați numărul de telefon generat.
3. Derulați în jos la Informatii cont secțiune. Copiați SID contului si Jeton de autentificare.

Construirea structurii aplicației

Puteți găsi întregul cod sursă pentru construirea unui sistem de verificare OTP folosind Python în aceasta Depozitul GitHub.

Importați modulele necesare și setați acreditările de autentificare. Inițializați clientul Twilio pentru a se autentifica și a fi punctul de intrare pentru apelurile API. Setați timpul de expirare la două minute.

Definiți o clasă, Verificare OTP, și inițializați constructorul pentru a seta valorile implicite ale variabilelor împreună cu inițializarea ferestrei rădăcină și setarea titlului și dimensiunilor aplicației.

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

Definiți trei etichete pentru a solicita un număr de mobil și un OTP și pentru a afișa un cronometru după ce programul trimite un OTP. Setați elementul părinte, textul pe care ar trebui să-l afișeze și stilurile de font pe care ar trebui să le posede. În mod similar, creați două widget-uri de intrare pentru a obține informații de la utilizator. Setați elementul părinte, lățimea și stilurile de font.

Creați trei butoane pentru a trimite OTP, retrimite OTP și Verificați OTP. Setați elementul părinte, textul pe care ar trebui să-l afișeze, comanda pe care ar trebui să o execute atunci când faceți clic și stilurile de font. Organizați aceste elemente folosind ambalaj metodă.

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

Construirea funcționalității aplicației

Definiți o metodă, start_timer() care rulează timer_countdown într-un fir separat.

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

Definiți o metodă, timer_countdown(). Înregistrați ora de pornire și rulați o buclă infinită care ia timpul curent și calculează timpul scurs și timpul rămas. Dacă stop_timer este adevărat, terminați bucla. Dacă timpul rămas este mai mic sau egal cu zero, afișați o casetă de mesaj de eroare care spune că OTP a expirat.

Activați butonul de retrimitere OTP, setați OTP la niciunul și terminați. În caz contrar, calculați minutele și secundele rămase, afișați-le pe eticheta temporizatorului și dormiți o secundă.

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)

Definiți o metodă, send_otp(). Dacă încuiat este adevărat, afișați mesajul corespunzător. În caz contrar, extrageți numărul de telefon, validați-l și generați un OTP aleatoriu. Dați telefonul mobil pe care l-ați primit mai devreme și utilizați clientul pentru a trimite OTP-ul la numărul dvs. de telefon. Afișați o casetă de mesaj, porniți cronometrul, dezactivați butoanele și ștergeți complet intrarea.

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) 

Definiți o metodă, resend_otp(). Dacă este blocat, afișați mesajul corespunzător. În caz contrar, obțineți numărul de telefon, validați-l, regenerați un OTP aleatoriu, retrimiteți OTP-ul, afișați caseta de mesaj, porniți cronometrul și dezactivați butonul de retrimitere 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)

Definiți o metodă, verify_otp(). Obțineți OTP și verificați dacă utilizatorul nu a introdus nimic. Dacă OTP-ul stocat este Nici unul, cereți utilizatorului să genereze mai întâi OTP. Dacă OTP-ul introdus de utilizator se potrivește cu cel stocat, afișați mesajul de verificare OTP cu succes, opriți cronometrul și părăsiți programul. În caz contrar, verificați dacă există încercări greșite. Dacă încercările greșite depășesc trei, blocați contul.

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

Definiți o metodă, lock_account(). Setați starea blocată la adevărat și afișați eticheta ca Cont blocat. Dezactivați toate etichetele, intrările și butoanele. Opriți cronometrul existent și porniți unul nou timp de zece minute.

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)

Definiți o metodă start_countdown(). Dacă timpul rămas este mai mic sau egal cu zero, resetați contul. În caz contrar, afișați că programul a blocat contul și încercați din nou în timpul rămas folosind un apel invers.

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)

Definiți o funcție, reset_account(). Resetați starea tuturor widget-urilor și variabilelor ca înainte.

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ți fereastra rădăcină, o instanță a clasei și rulați aplicația Tkinter.

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

Exemplu de rezultat al verificării folosind OTP

La rularea programului de verificare OTP, veți primi o fereastră care vă cere să introduceți numărul dvs. de telefon mobil. Introduceți-l împreună cu codul de țară și apăsați butonul Trimiteți OTP buton. Primiți un mesaj că programul a trimis OTP-ul cu succes și butonul se dezactivează timp de două minute. Verificați telefonul pentru OTP și introduceți-l înainte de a expira.

La introducerea OTP-ului corect înainte de expirarea temporizatorului, veți primi un mesaj că programul a verificat OTP-ul cu succes și programul se închide. În cazul în care nu l-ați introdus la timp, veți primi o casetă de mesaj care spune că OTP a expirat. Puteți face clic pe Retrimiteți OTP butonul pentru a genera un nou OTP și a-l trimite pe telefon.

Dacă introduceți OTP greșit, programul afișează o casetă de mesaj care spune OTP nu se potrivește.

Dacă introduceți greșit OTP de trei ori, toate câmpurile sunt dezactivate și contul este blocat timp de zece minute.

Utilizarea Twilio cu Python

Folosind Twilio, puteți construi un sistem de notificare prin SMS pentru diverse evenimente. Îl poți folosi cu dispozitive IoT pentru a declanșa SMS-uri atunci când ceva scade peste sau sub un anumit prag sau când detectezi un intrus. Puteți construi sisteme de conectare securizate cu autentificare cu doi factori, puteți construi un chatbot WhatsApp și un sistem de memento pentru întâlniri.

În afară de aceasta, îl puteți folosi pentru verificarea numărului de telefon, campanii de marketing, trimiterea de sondaje și colectarea de feedback. Când construiți orice aplicație, fiți întotdeauna atenți la prețurile Twilio API pentru a evita costurile neașteptate.