Spletni žetoni JSON so enostavni za uporabo in odpravljanje napak, ponujajo pa tudi impresivno povečanje varnosti.

Prekinjena avtentikacija je še vedno stalna ranljivost v sodobnih spletnih aplikacijah – še vedno je visoko uvrščena med 10 največjih varnostnih tveganj za API OWASP.

Učinki te ranljivosti so lahko resni. Lahko omogočijo nepooblaščen dostop do občutljivih podatkov in ogrozijo celovitost sistema. Za učinkovito zagotavljanje varnega dostopa do aplikacij in njihovih virov je bistveno, da uporabljate robustne mehanizme za preverjanje pristnosti.

Ugotovite, kako lahko implementirate avtentikacijo uporabnikov v Flasku z uporabo spletnih žetonov JSON (JWT), priljubljene in učinkovite metode, ki temelji na žetonih.

Preverjanje pristnosti na podlagi žetonov z uporabo spletnih žetonov JSON

Preverjanje pristnosti na podlagi žetonov uporablja šifriran niz znakov za potrditev in avtorizacijo dostopa do sistema ali vira. To vrsto avtentikacije lahko implementirate z različnimi metodami, vključno z žetoni seje, ključi API in spletnimi žetoni JSON.

instagram viewer

Zlasti JWT-ji ponujajo varen in kompakten pristop za prenos zahtevanih uporabniških poverilnic med aplikacijami na strani odjemalca in strežniki.

JWT je sestavljen iz treh glavnih komponent: glave, koristnega tovora in podpisa. Glava vsebuje metapodatke o žetonu, vključno z algoritmom zgoščevanja, uporabljenim za kodiranje žetona.

Tovor vsebuje dejanske uporabniške poverilnice, kot so ID uporabnika in dovoljenja. Nazadnje, podpis zagotavlja veljavnost žetona s preverjanjem njegove vsebine s skrivnim ključem.

Z uporabo JWT-jev lahko overite uporabnike in shranite podatke o sejah v samem žetonu.

Nastavite projekt Flask in bazo podatkov MongoDB

Za začetek ustvarite nov projektni imenik s terminalom:

mkdir flask-project
cd flask-projekt

Nato namestite virtualenv, da ustvarite lokalno virtualno razvojno okolje za svoj projekt Flask.

virtualenv venv

Nazadnje aktivirajte virtualno okolje.

# Unix ali MacOS: 
vir venv/bin/activate
# Windows: 
.\venv\Skripti\aktivirati

Tukaj lahko najdete kodo tega projekta Repozitorij GitHub.

Namestite zahtevane pakete

V korenskem imeniku mape projekta ustvarite novo zahteve.txt in dodajte te odvisnosti za projekt:

bučko
pyjwt
python-dotenv
pymongo
bcrypt

Na koncu zaženite spodnji ukaz za namestitev paketov. Prepričajte se, da imate pip (upravitelj paketov) nameščen; če ne, namestite v sistem Windows, Mac ali Linux.

pip install -r requirements.txt

Ustvarite bazo podatkov MongoDB

Nadaljujte in ustvarite bazo podatkov MongoDB. Ti lahko nastavite lokalno bazo podatkov MongoDB, alternativno, ustvarite gručo na MongoDB Atlas, storitev MongoDB v oblaku.

Ko ustvarite bazo podatkov, kopirajte URI povezave, ustvarite a .env datoteko v korenskem imeniku vašega projekta in jo dodajte na naslednji način:

MONGO_URI=""

Končno konfigurirajte povezavo z bazo podatkov iz vaše aplikacije Flask. Ustvari novo utils/db.py datoteko v korenskem imeniku vašega projekta s to kodo:

od pymongo uvoz MongoClient
defpoveži se z_mongodb(mongo_uri):
 stranka = MongoClient (mongo_uri)
 db = client.get_database("uporabniki")
vrnitev db

Ta funkcija vzpostavi povezavo z bazo podatkov MongoDB z uporabo posredovanega URI povezave. Nato ustvari novo uporabniki zbirka, če ne obstaja, in vrne ustrezen primerek baze podatkov.

Ustvarite spletni strežnik Flask

Ko je zbirka podatkov konfigurirana, nadaljujte in ustvarite app.py datoteko v korenskem imeniku mape projekta in dodajte naslednjo kodo, da ustvarite primerek aplikacije Flask.

od bučko uvoz Bučka
od routes.user_auth uvoz register_routes
od utils.db uvoz poveži se z_mongodb
uvoz os
od dotenv uvoz load_dotenv
app = Flask (__ime__)
load_dotenv()


mongo_uri = os.getenv('MONGO_URI')
db = povezava_z_mongodb (mongo_uri)


register_routes (aplikacija, db)
če __ime__ == '__glavni__':
 app.run (debug=Prav)

Ustvarite končne točke API-ja za preverjanje pristnosti

Za implementacijo avtentikacije uporabnika v vaši aplikaciji Flask je ključnega pomena, da definirate potrebne končne točke API-ja, ki obravnavajo operacije, povezane z avtentikacijo.

Vendar najprej definirajte model za podatke uporabnikov. Če želite to narediti, ustvarite novo model/user_model.py datoteko v korenskem imeniku in dodajte naslednjo kodo.

od pymongo.zbirka uvoz Zbirka
od bson.objectid uvoz ObjectId
razredUporabnik:
def__v__(jaz, zbirka: zbirka, uporabniško ime: str, geslo: str):
 self.collection = zbirka
 self.username = uporabniško ime
 self.password = geslo
defshraniti(sebe):
 uporabniški_podatki = {
'uporabniško ime': samo.uporabniško ime,
'geslo': samo.geslo
 }
 rezultat = self.collection.insert_one (uporabniški_podatki)
vrnitev str (result.inserted_id)


 @statičnametoda
deffind_by_id(zbirka: zbirka, user_id: str):
vrnitev collection.find_one({'_id': ObjectId (user_id)})
 @statičnametoda
defnajdi_po_uporabniškem imenu(zbirka: Zbirka, uporabniško ime: str):
vrnitev collection.find_one({'uporabniško ime': uporabniško ime})

Zgornja koda določa a Uporabnik razred, ki služi kot podatkovni model in definira več metod za interakcijo z zbirko MongoDB za izvajanje operacij, povezanih z uporabnikom.

  1. The shraniti metoda shrani nov uporabniški dokument s podanim uporabniškim imenom in geslom v zbirko MongoDB in vrne ID vstavljenega dokumenta.
  2. The find_by_id in najdi_po_uporabniškem imenu metode pridobijo uporabniške dokumente iz zbirke na podlagi posredovanega uporabniškega ID-ja oziroma uporabniškega imena.

Določite poti avtentikacije

  1. Začnimo z določitvijo registracijske poti. Ta pot bo dodala nove uporabniške podatke v zbirko uporabnikov MongoDB. V korenskem imeniku ustvarite nov routes/user_auth.py datoteko in naslednjo kodo.
    uvoz jwt
    od functools uvoz obloge
    od bučko uvoz jsonify, request, make_response
    od modeli.uporabniški_model uvoz Uporabnik
    uvoz bcrypt
    uvoz os
    defregister_routes(aplikacija, db):
     zbirka = db.users
     app.config['SECRET_KEY'] = os.urandom(24)
    

     @app.route('/api/register', metode=['POST'])
    defregister():

     uporabniško ime = request.json.get('uporabniško ime')
     geslo = request.json.get('geslo')

     obstoječ_uporabnik = User.find_by_username (zbirka, uporabniško ime)
    če obstoječi_uporabnik:
    vrnitev jsonify({'sporočilo': 'Uporabniško ime že obstaja!'})

     hasshed_password = bcrypt.hashpw (password.encode('utf-8'), bcrypt.gensalt())
     new_user = Uporabnik (zbirka, uporabniško ime, hasshed_password.decode('utf-8'))
     user_id = new_user.save()
    vrnitev jsonify({'sporočilo': 'Uporabnik je uspešno registriran!', 'Uporabniško ime': Uporabniško ime})
  2. Implementirajte funkcijo prijave za upravljanje postopka preverjanja pristnosti in preverjanje uporabniških poverilnic. Pod potjo registracije dodajte naslednjo kodo.
     @app.route('/api/login', metode=['POST'])
    defVpiši se():
     uporabniško ime = request.json.get('uporabniško ime')
     geslo = request.json.get('geslo')
     uporabnik = User.find_by_username (zbirka, uporabniško ime)
    če uporabnik:
    če bcrypt.checkpw (password.encode('utf-8'), uporabnik['geslo'].encode('utf-8')):
     žeton = jwt.encode({'Uporabniško ime': str (uporabnik['_id'])}, app.config['SECRET_KEY'], algoritem='HS256')

     odziv = make_response (jsonify({'sporočilo': 'Prijava uspešna!'}))
     response.set_cookie('žeton', žeton)
    vrnitev odgovor
    vrnitev jsonify({'sporočilo': 'Napačno uporabniško ime ali geslo'})
    Končna točka za prijavo naredi dve stvari: preveri posredovane uporabniške poverilnice in po uspešni overitvi ustvari edinstven JWT za tega uporabnika. Ta žeton nastavi kot piškotek v odgovoru, skupaj s tovorom JSON, ki označuje uspešno prijavo. Če poverilnice niso veljavne, bo vrnil odgovor JSON, ki to nakazuje.
  3. Definirajte funkcijo okrasitve, ki preverja spletne žetone JSON (JWT), posredovane skupaj z nadaljnjimi zahtevami API-ja. Dodajte spodnjo kodo znotraj register_routes blok funkcijske kode.
    deftoken_required(f):
     @ovitki (f)
    defokrašena(*args, **kwargs):
     žeton = request.cookies.get('žeton')
    čene žeton:
    vrnitev jsonify({'sporočilo': 'Žeton manjka!'}), 401
    

    poskusi:
     podatki = jwt.decode (žeton, app.config['SECRET_KEY'], algoritmi=['HS256'])
     current_user = User.find_by_id (zbirka, podatki['Uporabniško ime'])
    razen jwt. ExpiredSignatureError:
    vrnitev jsonify({'sporočilo': 'Žeton je potekel!'}), 401
    razen jwt. InvalidTokenError:
    vrnitev jsonify({'sporočilo': 'Neveljaven žeton!'}), 401
    

    vrnitev f (trenutni_uporabnik, *args, **kwargs)
    vrnitev okrašena
    Ta funkcija dekoratorja zagotavlja prisotnost veljavnega žetona JWT v naslednjih zahtevah API-ja. Preveri, ali žeton manjka, je potekel ali je veljaven, in vrne ustrezen odgovor JSON, če je.
  4. Končno ustvarite zaščiteno pot.
     @app.route('/api/users', metode=['GET'])
     @token_required
    defget_users(Trenutni uporabnik):
     uporabniki = seznam (zbirka.find({}, {'_id': 0}))
    vrnitev jsonify (uporabniki)

Ta končna točka obravnava logiko za pridobivanje uporabniških podatkov iz baze podatkov, vendar zahteva, da odjemalec, ki pošilja zahteve, vključi veljaven žeton za dostop do podatkov.

Na koncu zaženite spodnji ukaz, da zavrtite razvojni strežnik.

bučka teči

Če želite preizkusiti registracijo, prijavo in končno točko zaščitenih uporabnikov, lahko uporabite Postman ali katerega koli drugega API odjemalca. Pošljite zahteve na http://localhost: 5000/api/in opazujte odzive, da preverite delovanje teh končnih točk API-ja.

Ali je avtentikacija žetonov varen varnostni ukrep?

Spletni žetoni JSON zagotavljajo robusten in učinkovit način preverjanja pristnosti uporabnikov za vašo spletno aplikacijo. Vendar je pomembno razumeti, da avtentikacija žetonov ni varna; je le del večje varnostne uganke.

Združite preverjanje pristnosti žetonov z drugimi najboljšimi varnostnimi praksami. Ne pozabite nenehno spremljati in sprejeti dosledne varnostne prakse; občutno boste izboljšali splošno varnost vaših aplikacij Flask.