JSON-i veebimärke on lihtne kasutada ja siluda, kuid need pakuvad ka muljetavaldavat turbetõusu.

Katkine autentimine on jätkuvalt tänapäevaste veebirakenduste püsiv haavatavus – see on endiselt OWASP 10 peamise API turberiski hulgas.

Selle haavatavuse tagajärjed võivad olla tõsised. Nad võivad anda volitamata juurdepääsu tundlikele andmetele ja ohustada süsteemi terviklikkust. Rakendustele ja nende ressurssidele turvalise juurdepääsu tagamiseks on ülioluline kasutada tugevaid autentimismehhanisme.

Siit saate teada, kuidas saate Flaskis kasutaja autentimist rakendada, kasutades populaarset ja tõhusat märgipõhist meetodit JSON Web Tokens (JWT).

Tokenipõhine autentimine JSON-i veebilubade abil

Tokenipõhine autentimine kasutab süsteemile või ressursile juurdepääsu kinnitamiseks ja autoriseerimiseks krüpteeritud märgijada. Seda tüüpi autentimist saate rakendada erinevate meetodite, sealhulgas seansilubade, API võtmete ja JSON-i veebilubade abil.

Eelkõige pakuvad JWT-d turvalist ja kompaktset lähenemisviisi vajalike kasutajate mandaatide edastamiseks kliendipoolsete rakenduste ja serverite vahel.

instagram viewer

JWT koosneb kolmest põhikomponendist: päisest, kasulikust koormusest ja allkirjast. Päis sisaldab märgi metaandmeid, sealhulgas märgi kodeerimiseks kasutatud räsimise algoritmi.

Kasulik koormus sisaldab tegelikke kasutaja mandaate, nagu kasutaja ID ja õigused. Lõpuks tagab allkiri märgi kehtivuse, kontrollides selle sisu salajase võtmega.

JWT-de abil saate kasutajaid autentida ja salvestada seansiandmeid kõik märgis endas.

Looge kolviprojekt ja MongoDB andmebaas

Alustamiseks looge terminali abil uus projektikataloog:

mkdir kolbi projekt
cd-kolvi projekt

Järgmisena installige virtualenv, et luua oma Flask projekti jaoks kohalik virtuaalne arenduskeskkond.

virtualenv venv

Lõpuks aktiveerige virtuaalne keskkond.

# Unix või MacOS: 
allikas venv/bin/activate
# Windows: 
.\venv\Scripts\activate

Selle projekti koodi leiate siit GitHubi hoidla.

Installige nõutavad paketid

Looge oma projektikausta juurkataloogis uus nõuded.txt faili ja lisage projekti jaoks järgmised sõltuvused:

kolb
pyjwt
python-dotenv
pümongo
bcrypt

Lõpuks käivitage pakettide installimiseks allolev käsk. Veenduge, et teil on pip (paketihaldur) paigaldatud; Kui ei, installige see oma Windowsi, Maci või Linuxi süsteemi.

pip install -r nõuded.txt

Looge MongoDB andmebaas

Jätkake ja looge MongoDB andmebaas. Sa saad looge kohalik MongoDB andmebaas, alternatiivselt looge klaster pilvepõhises MongoDB teenuses MongoDB Atlas.

Kui olete andmebaasi loonud, kopeerige ühenduse URI ja looge a .env faili oma projekti juurkataloogi ja lisage see järgmiselt:

MONGO_URI=""

Lõpuks konfigureerige andmebaasiühendus oma Flask rakenduses. Loo uus utils/db.py faili oma projekti juurkataloogis järgmise koodiga:

alates pümongo importida MongoClient
defconnect_to_mongodb(mongo_uri):
 klient = MongoClient (mongo_uri)
 db = client.get_database("kasutajad")
tagasi db

See funktsioon loob ühenduse MongoDB andmebaasiga, kasutades selleks ette nähtud ühenduse URI-d. Seejärel loob see uue kasutajad kollektsiooni, kui seda pole olemas, ja tagastab vastava andmebaasi eksemplari.

Looge Flask veebiserver

Kui andmebaas on konfigureeritud, jätkake ja looge app.py faili projekti kausta juurkataloogis ja lisage Flask rakenduse eksemplari loomiseks järgmine kood.

alates kolb importida Kolb
alates routes.user_auth importida register_routes
alates utils.db importida connect_to_mongodb
importida os
alates dotenv importida load_dotenv
rakendus = Kolb (__name__)
load_dotenv()


mongo_uri = os.getenv('MONGO_URI')
db = ühendu_mongodb-ga (mongo_uri)


register_routes (rakendus, db)
kui __nimi__ == '__peamine__':
 app.run (debug=Tõsi)

Looge autentimise API lõpp-punktid

Kasutaja autentimise rakendamiseks oma Flask rakenduses on ülioluline määratleda vajalikud API lõpp-punktid, mis käitlevad autentimisega seotud toiminguid.

Esmalt määrake siiski kasutajate andmete mudel. Selleks looge uus model/user_model.py faili juurkataloogis ja lisage järgmine kood.

alates pymongo.kollektsioon importida Kollektsioon
alates bson.objektid importida Objekti ID
klassKasutaja:
def__selles__(ise, kogu: kogu, kasutajanimi: str, parool: str):
 ise.kogu = kogumine
 self.username = kasutajanimi
 self.password = parool
defsalvestada(ise):
 kasutaja_andmed = {
'kasutajanimi': ise.kasutajanimi,
'parool': ise.parool
 }
 tulemus = self.collection.insert_one (kasutaja_andmed)
tagasi str (tulemus.sisestatud_id)


 @staticmethod
deffind_by_id(kogu: kogu, kasutaja_id: str):
tagasi collection.find_one({'_id': ObjectId (kasutaja_id)})
 @staticmethod
defleia_kasutajanime järgi(kogu: kollektsioon, kasutajanimi: str):
tagasi collection.find_one({'kasutajanimi': kasutajanimi})

Ülaltoodud kood täpsustab a Kasutaja klass, mis toimib andmemudelina ja määratleb mitu meetodit MongoDB koguga suhtlemiseks kasutajaga seotud toimingute tegemiseks.

  1. The salvestada meetod salvestab antud kasutajanime ja parooliga uue kasutajadokumendi MongoDB kogusse ning tagastab sisestatud dokumendi ID.
  2. The find_by_id ja leia_kasutajanime järgi meetodid toovad kogust kasutajadokumendid vastavalt antud kasutajatunnuse või kasutajanime alusel.

Määratlege autentimismarsruudid

  1. Alustame registreerimismarsruudi määratlemisega. See marsruut lisab MongoDB kasutajate kogusse uusi kasutajaandmeid. Loo juurkataloogis uus routes/user_auth.py fail ja järgmine kood.
    importida jwt
    alates funktsionaalsed tööriistad importida mähised
    alates kolb importida jsonify, request, make_response
    alates mudelid.kasutaja_mudel importida Kasutaja
    importida bcrypt
    importida os
    defregister_routes(rakendus, db):
     kollektsioon = db.kasutajad
     app.config['SECRET_KEY'] = os.urandom(24)
    

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

     kasutajanimi = request.json.get('kasutajanimi')
     parool = request.json.get('parool')

     Olemasolev_kasutaja = User.find_by_username (kogu, kasutajanimi)
    kui olemasolev_kasutaja:
    tagasi jsonify({'sõnum': 'Kasutajanimi on juba olemas!'})

     hashed_password = bcrypt.hashpw (password.encode("utf-8"), bcrypt.gensalt())
     new_user = Kasutaja (kogu, kasutajanimi, hashed_password.decode("utf-8"))
     kasutaja_id = uus_kasutaja.save()
    tagasi jsonify({'sõnum': 'Kasutaja registreerus edukalt!', 'kasutaja ID': kasutaja ID})
  2. Rakendage sisselogimisfunktsiooni autentimisprotsessi haldamiseks ja kasutaja mandaatide kontrollimiseks. Lisage registreerimismarsruudi alla järgmine kood.
     @app.route('/api/login', method=['POST'])
    defLogi sisse():
     kasutajanimi = request.json.get('kasutajanimi')
     parool = request.json.get('parool')
     user = User.find_by_username (kogu, kasutajanimi)
    kui kasutaja:
    kui bcrypt.checkpw (password.encode("utf-8"), kasutaja['parool'].encode("utf-8")):
     token = jwt.encode({'kasutaja ID': str (kasutaja['_id'])}, app.config['SECRET_KEY'], algoritm="HS256")

     vastus = make_response (jsonify({'sõnum': 'Sisselogimine õnnestus!'}))
     response.set_cookie('märk', märk)
    tagasi vastuseks
    tagasi jsonify({'sõnum': 'Vale kasutajanimi või parool'})
    Sisselogimise lõpp-punkt teeb kahte asja: see kontrollib esitatud kasutaja mandaate ja eduka autentimise korral genereerib selle kasutaja jaoks ainulaadse JWT. See määrab selle märgi vastuses küpsiseks koos JSON-i kasuliku koormusega, mis näitab edukat sisselogimist. Kui mandaadid on kehtetud, tagastab see selle näitamiseks JSON-vastuse.
  3. Määrake dekoreerimisfunktsioon, mis kontrollib koos järgnevate API taotlustega edastatud JSON-i veebimärke (JWT-d). Lisage allolev kood jaotisesse register_routes funktsiooni koodiplokk.
    deftoken_required(f):
     @wraps (f)
    defkaunistatud(*args, **kwargs):
     token = request.cookies.get('märk')
    kuimitte märk:
    tagasi jsonify({'sõnum': 'Token on puudu!'}), 401
    

    proovige:
     andmed = jwt.decode (token, app.config['SECRET_KEY'], algoritmid=["HS256"])
     current_user = User.find_by_id (kogu, andmed['kasutaja ID'])
    välja arvatud jwt. Aegunud allkirjaviga:
    tagasi jsonify({'sõnum': "Token on aegunud!"}), 401
    välja arvatud jwt. InvalidTokenError:
    tagasi jsonify({'sõnum': 'Vigane märk!'}), 401
    

    tagasi f (praegune_kasutaja, *args, **kwargs)
    tagasi kaunistatud
    See dekoreerimisfunktsioon tagab kehtiva JWT-märgi olemasolu järgmistes API päringutes. See kontrollib, kas luba puudub, on aegunud või kehtiv, ja tagastab asjakohase JSON-vastuse, kui see on nii.
  4. Lõpuks looge kaitstud marsruut.
     @app.route('/api/users', method=['GET'])
     @token_required
    defhanki_kasutajad(praegune_kasutaja):
     kasutajad = list (collection.find({}, {'_id': 0}))
    tagasi jsonify (kasutajad)

See lõpp-punkt tegeleb kasutajaandmete andmebaasist toomise loogikaga, kuid see nõuab, et päringuid saadav klient sisaldaks andmetele juurdepääsuks kehtivat luba.

Lõpuks käivitage arendusserveri käivitamiseks allolev käsk.

kolvi jooks

Registreerimise, sisselogimise ja kaitstud kasutajate lõpp-punkti testimiseks võite kasutada Postmani või mõnda muud API klienti. Taotlused saata aadressile http://localhost: 5000/api/ja jälgige vastuseid, et kontrollida nende API lõpp-punktide funktsionaalsust.

Kas märgi autentimine on lollikindel turvameede?

JSON-i veebimärgid pakuvad tugevat ja tõhusat viisi teie veebirakenduse kasutajate autentimiseks. Siiski on oluline mõista, et märgi autentimine ei ole lollikindel; see on vaid üks tükk suuremast turvapuslest.

Ühendage loa autentimine teiste turvalisuse parimate tavadega. Ärge unustage pidevalt jälgida ja järgige ühtseid turvatavasid; parandate oluliselt oma Flaski rakenduste üldist turvalisust.