Hur man bygger ett OTP-verifieringssystem med Python

Även om ditt lösenord blir stulet, fungerar OTP-verifieringssystem som en avgörande faktor för säkerheten. Det eliminerar behovet av att komma ihåg lösenord, fungerar som ett extra lager av säkerhet och minskar riskerna för nätfiske.

Lär dig att bygga ett OTP-verifieringssystem med Python som skickar en OTP till ditt mobilnummer endast giltigt i två minuter och ditt konto blir låst om du anger fel OTP tre gånger i en rad.

Installera moduler Tkinter, Twilio och Random

Tkinter låter dig skapa skrivbordsapplikationer. Den erbjuder en mängd olika widgets som knappar, etiketter och textrutor som gör det lättare att utveckla applikationer.

Twilio-modulen hjälper dig att integrera kommunikationsfunktioner som SMS, MMS, telefonsamtal och verifiering direkt i din applikation. Den har en molnbaserad infrastruktur tillsammans med fantastiska funktioner som nummerupplåtelse, meddelandemallar och samtalsinspelning.

För att installera Twilio- och Tkinter-modulerna, kör följande kommando i terminalen:

pip install twilio tk

Random-modulen är en inbyggd Python-modul som används för att generera pseudoslumptal. Med detta kan du generera slumpmässiga tal, välja slumpmässiga element från en lista, blanda innehållet i en lista och mer. Du kan använda den för att bygga en tärningssimulering, en listblandare eller en slumpmässig lösenordsgenerator.

Generera Twilio API och skaffa ett telefonnummer

För att använda Twilio och skicka OTP-förfrågningar till din mobiltelefon behöver du autentiseringsuppgifter tillsammans med ett Twilio-telefonnummer. För att uppnå detta:

1. Registrera dig för ett Twilio-konto och besök Twilio konsol.
2. Scrolla ner och klicka på Få telefonnummer knapp. Kopiera det genererade telefonnumret.
3. Scrolla ner till Konto information sektion. Kopiera Konto SID och den Auth Token.

Bygga applikationens struktur

Du kan hitta hela källkoden för att bygga ett OTP-verifieringssystem med Python i detta GitHub-förråd.

Importera nödvändiga moduler och ställ in autentiseringsuppgifterna. Initiera Twilio-klienten för att autentisera och vara startpunkten för API-anrop. Ställ in utgångstiden till två minuter.

Definiera en klass, OTPVerifiering, och initiera konstruktorn för att ställa in standardvärdena för variabler tillsammans med att initiera rotfönstret och ställa in titeln och dimensionerna för programmet.

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

Definiera tre etiketter för att fråga efter ett mobilnummer och en OTP, och för att visa en timer efter att programmet skickat en OTP. Ställ in det överordnade elementet, texten det ska visa och typsnittet som det ska ha. Skapa på samma sätt två inmatningswidgetar för att få input från användaren. Ställ in dess överordnade element, dess bredd och dess teckensnittsstil.

Skapa tre knappar för att skicka OTP, skicka om OTP och Verifiera OTP. Ställ in dess överordnade element, texten den ska visa, kommandot den ska köra när den klickas och dess teckensnittsstilar. Organisera dessa element med hjälp av packa 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()

Bygga applikationens funktionalitet

Definiera en metod, start_timer() som springer timer_countdown i en separat tråd.

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

Definiera en metod, timer_countdown(). Spela in starttiden och kör en oändlig slinga som tar den aktuella tiden och beräknar förfluten och återstående tid. Om stop_timer är sant, avsluta slingan. Om den återstående tiden är mindre än eller lika med noll, visa en felmeddelanderuta som säger att OTP har gått ut.

Aktivera återsänd OTP-knappen, ställ in OTP till ingen och avsluta. I annat fall, beräkna återstående minuter och sekunder, visa det på timeretiketten och sov i en sekund.

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)

Definiera en metod, send_otp(). Om låst är sant, visa lämpligt meddelande. I annat fall, extrahera telefonnumret, validera det och generera en slumpmässig OTP. Passera mobiltelefonen du fick tidigare och använd klienten för att skicka OTP till ditt telefonnummer. Visa en meddelanderuta, starta timern, inaktivera knapparna och rensa posten helt.

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) 

Definiera en metod, återsänd_otp(). Om den är låst, visa lämpligt meddelande. Annars skaffar du telefonnumret, validerar det, genererar en slumpmässig OTP igen, skickar OTP igen, visar meddelanderutan, startar timern och inaktiverar knappen skicka OTP igen.

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)

Definiera en metod, verifiera_otp(). Skaffa OTP och kontrollera om användaren inte har angett något. Om den lagrade OTP är Ingen, be användaren att generera OTP först. Om den OTP som användaren angav matchar den lagrade, visa det framgångsrika OTP-verifieringsmeddelandet, stoppa timern och avsluta programmet. Kontrollera annars om det finns fel försök. Om fel försök överstiger tre, lås kontot.

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

Definiera en metod, lock_account(). Ställ in låst status på sant och visa etiketten som Kontot är låst. Inaktivera alla etiketter, poster och knappar. Stoppa den befintliga timern och starta en ny i tio minuter.

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)

Definiera en metod start_countdown(). Om den återstående tiden är mindre än eller lika med noll, återställ kontot. Annars, visa att programmet har låst kontot och försök igen under den återstående tiden med en återuppringning.

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)

Definiera en funktion, reset_account(). Återställ status för alla widgets och variabler som tidigare.

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

Skapa rotfönstret, en instans av klassen, och kör programmet Tkinter.

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

Exempel på utdata för verifiering med OTP

När du kör OTP-verifieringsprogrammet får du ett fönster som ber dig att ange ditt mobilnummer. Ange den tillsammans med din landskod och tryck på Skicka OTP knapp. Du får ett meddelande om att programmet har skickat OTP framgångsrikt och knappen avaktiveras i två minuter. Kontrollera din telefon för OTP och ange den innan den löper ut.

När du anger rätt OTP innan timern tar slut får du ett meddelande om att programmet har verifierat OTP framgångsrikt och programmet avslutas. Om du inte angav den i tid kommer du att få en meddelanderuta som säger att OTP har löpt ut. Du kan klicka på Skicka OTP igen för att generera en ny OTP och skicka den till din telefon.

Om du anger fel OTP visar programmet en meddelanderuta som säger OTP matchar inte.

Om du anger fel OTP tre gånger inaktiveras alla fält och kontot låses i tio minuter.

Använder Twilio med Python

Med hjälp av Twilio kan du bygga ett SMS-aviseringssystem för olika evenemang. Du kan använda den med IoT-enheter för att utlösa SMS när något faller över eller under en viss tröskel eller när du upptäcker en inkräktare. Du kan bygga säkra inloggningssystem med tvåfaktorsautentisering, bygga en WhatsApp chatbot och ett påminnelsesystem för möten.

Bortsett från detta kan du använda den för verifiering av telefonnummer, marknadsföringskampanjer, skicka enkäter och samla in feedback. När du bygger en applikation, var alltid uppmärksam på Twilio API-prissättning för att undvika oväntade kostnader.