Webové tokeny JSON sa ľahko používajú a ladia, no zároveň ponúkajú pôsobivé zvýšenie bezpečnosti.

Nefunkčná autentifikácia je aj naďalej pretrvávajúcou zraniteľnosťou v moderných webových aplikáciách – stále patrí medzi 10 najlepších bezpečnostných rizík API OWASP.

Účinky tejto zraniteľnosti môžu byť vážne. Môžu poskytnúť neoprávnený prístup k citlivým údajom a ohroziť integritu systému. Ak chcete efektívne zabezpečiť bezpečný prístup k aplikáciám a ich zdrojom, je dôležité, aby ste používali robustné mechanizmy autentifikácie.

Zistite, ako môžete implementovať autentifikáciu používateľov vo Flasku pomocou JSON Web Tokens (JWT), populárnej a efektívnej metódy založenej na tokenoch.

Autentifikácia na základe tokenov pomocou webových tokenov JSON

Autentifikácia založená na tokenoch používa zašifrovaný reťazec znakov na overenie a autorizáciu prístupu k systému alebo prostriedku. Tento typ autentifikácie môžete implementovať pomocou rôznych metód vrátane tokenov relácie, kľúčov API a webových tokenov JSON.

instagram viewer

Najmä JWT ponúkajú bezpečný a kompaktný prístup na prenos požadovaných používateľských poverení medzi aplikáciami na strane klienta a servermi.

JWT pozostáva z troch hlavných komponentov: hlavičky, užitočného zaťaženia a podpisu. Hlavička obsahuje metadáta o tokene vrátane hašovacieho algoritmu použitého na kódovanie tokenu.

Užitočné zaťaženie obsahuje skutočné používateľské poverenia, ako napríklad ID používateľa a povolenia. Nakoniec podpis zaisťuje platnosť tokenu overením jeho obsahu pomocou tajného kľúča.

Pomocou JWT môžete autentifikovať používateľov a ukladať dáta relácie všetko v rámci samotného tokenu.

Nastavte projekt Flask a databázu MongoDB

Ak chcete začať, vytvorte nový adresár projektu pomocou terminálu:

mkdir flask-project
cd flask-projekt

Ďalej nainštalujte virtualenv, na vytvorenie lokálneho virtuálneho vývojového prostredia pre váš projekt Flask.

virtualenv venv

Nakoniec aktivujte virtuálne prostredie.

# Unix alebo MacOS: 
zdroj venv/bin/activate
# Windows: 
.\venv\Scripts\activate

Kód tohto projektu nájdete v tomto úložisko GitHub.

Nainštalujte požadované balíky

V koreňovom adresári priečinka projektu vytvorte nový request.txt súbor a pridajte tieto závislosti pre projekt:

banke
pyjwt
python-dotenv
pymongo
bcrypt

Nakoniec spustite príkaz uvedený nižšie a nainštalujte balíky. Uistite sa, že máte pip (správca balíkov) nainštalovaný; Ak nie, nainštalujte ho do systému Windows, Mac alebo Linux.

pip install -r requirements.txt

Vytvorte databázu MongoDB

Pokračujte a vytvorte databázu MongoDB. Môžeš nastaviť lokálnu databázu MongoDB, prípadne, vytvorte klaster na MongoDB Atlas, cloudovej službe MongoDB.

Po vytvorení databázy skopírujte URI pripojenia, vytvorte a .env súbor v koreňovom adresári vášho projektu a pridajte ho takto:

MONGO_URI=""

Nakoniec nakonfigurujte pripojenie k databáze z vašej aplikácie Flask. Vytvorte nový utils/db.py súbor v koreňovom adresári vášho projektu s týmto kódom:

od pymongo importovať MongoClient
defconnect_to_mongodb(mongo_uri):
 klient = MongoClient (mongo_uri)
 db = client.get_database("používatelia")
vrátiť db

Táto funkcia vytvorí pripojenie k databáze MongoDB pomocou poskytnutého identifikátora URI pripojenia. Potom vytvorí nový používateľov kolekciu, ak neexistuje, a vráti zodpovedajúcu inštanciu databázy.

Vytvorte webový server Flask

S nakonfigurovanou databázou pokračujte a vytvorte súbor app.py súbor v koreňovom adresári priečinka projektu a pridajte nasledujúci kód na vytvorenie inštancie aplikácie Flask.

od banke importovať Banka
od routes.user_auth importovať register_routes
od utils.db importovať connect_to_mongodb
importovať os
od dotenv importovať load_dotenv
app = Banka (__name__)
load_dotenv()


mongo_uri = os.getenv(„MONGO_URI“)
db = connect_to_mongodb (mongo_uri)


register_routes (aplikácia, db)
ak __meno__ == '__Hlavná__':
 app.run (ladenie=Pravda)

Vytvorte koncové body rozhrania Authentication API

Na implementáciu autentifikácie používateľa vo vašej aplikácii Flask je dôležité definovať potrebné koncové body API, ktoré spracovávajú operácie súvisiace s autentifikáciou.

Najprv však definujte model pre údaje používateľov. Ak to chcete urobiť, vytvorte nový model/user_model.py súbor v koreňovom adresári a pridajte nasledujúci kód.

od pymongo.kolekcia importovať Zbierka
od bson.objectid importovať ObjectId
triedaPoužívateľ:
def__init__(self, collection: Collection, username: str, password: str):
 seba.zber = zber
 self.username = používateľské meno
 self.password = heslo
defuložiť(ja):
 user_data = {
'používateľské meno': vlastné používateľské meno,
'heslo': vlastné.heslo
 }
 výsledok = self.collection.insert_one (user_data)
vrátiť str (result.inserted_id)


 @statická metóda
deffind_by_id(kolekcia: Collection, user_id: str):
vrátiť collection.find_one({'_id': ObjectId (user_id)})
 @statická metóda
deffind_by_username(kolekcia: Collection, užívateľské meno: str):
vrátiť collection.find_one({'používateľské meno': používateľské meno})

Vyššie uvedený kód špecifikuje a Používateľ trieda, ktorá slúži ako dátový model a definuje niekoľko metód na interakciu s kolekciou MongoDB na vykonávanie operácií súvisiacich s používateľom.

  1. The uložiť metóda uloží nový užívateľský dokument so zadaným užívateľským menom a heslom do kolekcie MongoDB a vráti ID vloženého dokumentu.
  2. The find_by_id a find_by_username metódy získavajú užívateľské dokumenty z kolekcie na základe poskytnutého užívateľského ID alebo užívateľského mena, resp.

Definujte Autentifikačné cesty

  1. Začnime definovaním trasy registrácie. Táto trasa pridá nové používateľské údaje do zbierky používateľov MongoDB. V koreňovom adresári vytvorte nový routes/user_auth.py súbor a nasledujúci kód.
    importovať jwt
    od functools importovať zábaly
    od banke importovať jsonify, request, make_response
    od models.user_model importovať Používateľ
    importovať bcrypt
    importovať os
    defregister_routes(aplikácia, db):
     kolekcia = db.users
     app.config[„SECRET_KEY“] = os.urandom(24)
    

     @app.route('/api/register', methods=['POST'])
    defRegistrovať():

     používateľské meno = request.json.get('používateľské meno')
     heslo = request.json.get('heslo')

     existujúci_používateľ = User.find_by_username (kolekcia, používateľské meno)
    ak existujúci_používateľ:
    vrátiť jsonify({'správa': 'Užívateľské meno už existuje!'})

     hashed_password = bcrypt.hashpw (password.encode('utf-8'), bcrypt.gensalt())
     new_user = Používateľ (kolekcia, používateľské meno, hashované_heslo.decode('utf-8'))
     user_id = new_user.save()
    vrátiť jsonify({'správa': 'Používateľ sa úspešne zaregistroval!', 'ID používateľa': ID používateľa})
  2. Implementujte funkciu prihlasovania, aby ste zvládli proces autentifikácie a overili poverenia používateľa. Pod registračnú cestu pridajte nasledujúci kód.
     @app.route('/api/login', methods=['POST'])
    defPrihlásiť sa():
     používateľské meno = request.json.get('používateľské meno')
     heslo = request.json.get('heslo')
     user = User.find_by_username (kolekcia, používateľské meno)
    ak užívateľ:
    ak bcrypt.checkpw (password.encode('utf-8'), používateľ['heslo'].encode('utf-8')):
     token = jwt.encode({'ID používateľa': str (používateľ['_id'])}, app.config[„SECRET_KEY“], algoritmus='HS256')

     odpoveď = make_response (jsonify({'správa': 'Prihlásenie úspešné!'}))
     response.set_cookie('token', token)
    vrátiť odpoveď
    vrátiť jsonify({'správa': 'Nesprávne užívateľské meno alebo heslo'})
    Prihlasovací koncový bod robí dve veci: overuje dodané poverenia používateľa a po úspešnej autentifikácii vygeneruje pre tohto používateľa jedinečný JWT. Nastaví tento token ako súbor cookie v odpovedi spolu s užitočným zaťažením JSON označujúcim úspešné prihlásenie. Ak sú poverenia neplatné, vráti odpoveď JSON, ktorá to oznámi.
  3. Definujte funkciu dekorátora, ktorá overuje webové tokeny JSON (JWT) odovzdané spolu s následnými požiadavkami rozhrania API. Pridajte kód uvedený nižšie v rámci register_routes blok funkčného kódu.
    deftoken_required(f):
     @wraps (f)
    defzdobené(*args, **kwargs):
     token = request.cookies.get('token')
    aknie token:
    vrátiť jsonify({'správa': 'Chýba token!'}), 401
    

    skúste:
     data = jwt.decode (token, app.config[„SECRET_KEY“], algoritmy=['HS256'])
     current_user = User.find_by_id (kolekcia, údaje['ID používateľa'])
    okrem jwt. ExpiredSignatureError:
    vrátiť jsonify({'správa': 'Platnosť tokenu vypršala!'}), 401
    okrem jwt. InvalidTokenError:
    vrátiť jsonify({'správa': 'Neplatný Token!'}), 401
    

    vrátiť f (aktuálny_používateľ, *args, **kwargs)
    vrátiť zdobené
    Táto funkcia dekorátora zabezpečuje prítomnosť platného tokenu JWT v nasledujúcich požiadavkách API. Skontroluje, či token chýba, jeho platnosť vypršala alebo je platný, a ak áno, vráti príslušnú odpoveď JSON.
  4. Nakoniec vytvorte chránenú trasu.
     @app.route('/api/users', methods=['GET'])
     @token_required
    defget_users(súčasný užívateľ):
     používatelia = zoznam (collection.find({}, {'_id': 0}))
    vrátiť jsonify (používatelia)

Tento koncový bod spracováva logiku pre získavanie používateľských údajov z databázy, ale vyžaduje, aby klient odosielajúci požiadavky zahrnul platný token na prístup k údajom.

Nakoniec spustite príkaz uvedený nižšie, čím spustíte vývojový server.

flask run

Na otestovanie registrácie, prihlásenia a koncového bodu chránených používateľov môžete použiť Postman alebo akéhokoľvek iného klienta API. Žiadosti posielajte na http://localhost: 5000/api/a sledujte odpovede, aby ste si overili funkčnosť týchto koncových bodov API.

Je autentifikácia tokenu spoľahlivým bezpečnostným opatrením?

Webové tokeny JSON poskytujú robustný a efektívny spôsob overovania používateľov pre vašu webovú aplikáciu. Je však dôležité pochopiť, že autentifikácia pomocou tokenu nie je spoľahlivá; je to len jeden kúsok väčšej bezpečnostnej skladačky.

Skombinujte overenie pomocou tokenov s ďalšími osvedčenými postupmi zabezpečenia. Nezabudnite neustále monitorovať a prijať konzistentné bezpečnostné postupy; výrazne zvýšite celkovú bezpečnosť vašich aplikácií Flask.