JSON-verkkotunnukset ovat helppokäyttöisiä ja viankorjauksia, mutta ne tarjoavat myös vaikuttavan tietoturvalisäyksen.

Rikkinäinen todennus on edelleen jatkuva haavoittuvuus nykyaikaisissa verkkosovelluksissa – se sijoittuu edelleen OWASP: n 10 suurimman API-tietoturvariskin joukkoon.

Tämän haavoittuvuuden vaikutukset voivat olla vakavia. Ne voivat myöntää luvattoman pääsyn arkaluonteisiin tietoihin ja vaarantaa järjestelmän eheyden. Jotta voit varmistaa tehokkaasti suojatun pääsyn sovelluksiin ja niiden resursseihin, on erittäin tärkeää, että käytät vankkoja todennusmekanismeja.

Ota selvää, kuinka voit toteuttaa käyttäjän todennuksen Flaskissa käyttämällä JSON Web Tokens (JWT), suosittu ja tehokas merkkipohjainen menetelmä.

Token-pohjainen todennus JSON-verkkotunnuksilla

Token-pohjainen todennus käyttää salattua merkkijonoa järjestelmän tai resurssin käytön vahvistamiseen ja valtuutukseen. Voit toteuttaa tämäntyyppisen todennuksen useilla eri menetelmillä, mukaan lukien istuntotunnisteet, API-avaimet ja JSON-verkkotunnukset.

instagram viewer

Erityisesti JWT: t tarjoavat turvallisen ja kompaktin tavan siirtää tarvittavat käyttäjien tunnistetiedot asiakaspuolen sovellusten ja palvelimien välillä.

JWT koostuu kolmesta pääkomponentista: otsikosta, hyötykuormasta ja allekirjoituksesta. Otsikko sisältää tunnuksen metatiedot, mukaan lukien tunnuksen koodaamiseen käytetyn hajautusalgoritmin.

Hyötykuorma sisältää todelliset käyttäjätiedot, kuten käyttäjätunnukset ja käyttöoikeudet. Lopuksi allekirjoitus varmistaa tunnuksen voimassaolon tarkistamalla sen sisällön salaisella avaimella.

JWT: iden avulla voit todentaa käyttäjiä ja tallentaa istuntotiedot itse tunnukseen.

Luo pulloprojekti ja MongoDB-tietokanta

Aloita luomalla uusi projektihakemisto terminaalilla:

mkdir-pullo-projekti
cd-pullo-projekti

Seuraavaksi asenna virtualenv, luodaksesi paikallisen virtuaalisen kehitysympäristön Flask-projektillesi.

virtualenv venv

Aktivoi lopuksi virtuaaliympäristö.

# Unix tai MacOS: 
lähde venv/bin/activate
# Windows: 
.\venv\Scripts\activate

Löydät tämän projektin koodin tästä GitHub-arkisto.

Asenna tarvittavat paketit

Luo uusi projektikansiosi juurihakemistoon vaatimukset.txt tiedosto ja lisää nämä riippuvuudet projektille:

pullo
pyjwt
python-dotenv
pymongo
bcrypt

Suorita lopuksi alla oleva komento pakettien asentamiseksi. Varmista, että sinulla on pip (paketinhallinta) asennettu; jos ei, asenna se Windows-, Mac- tai Linux-järjestelmääsi.

pip install -r vaatimukset.txt

Luo MongoDB-tietokanta

Mene eteenpäin ja luo MongoDB-tietokanta. Sinä pystyt määritä paikallinen MongoDB-tietokanta, vaihtoehtoisesti, luo klusteri MongoDB Atlasissa, pilvipohjaisessa MongoDB-palvelussa.

Kun olet luonut tietokannan, kopioi yhteyden URI, luo a .env tiedosto projektisi juurihakemistoon ja lisää se seuraavasti:

MONGO_URI=""

Lopuksi määritä tietokantayhteys Flask-sovelluksesta. Luoda uusi utils/db.py tiedosto projektisi juurihakemistossa tällä koodilla:

alkaen pymongo tuonti MongoClient
defconnect_to_mongodb(mongo_uri):
 asiakas = MongoClient (mongo_uri)
 db = client.get_database("käyttäjät")
palata db

Tämä toiminto muodostaa yhteyden MongoDB-tietokantaan mukana toimitetun yhteyden URI: n avulla. Sitten se luo uuden käyttäjiä kokoelma, jos sitä ei ole olemassa, ja palauttaa vastaavan tietokantailmentymän.

Luo Flask-verkkopalvelin

Kun tietokanta on määritetty, siirry eteenpäin ja luo app.py tiedosto projektikansion juurihakemistoon ja lisää seuraava koodi luodaksesi Flask-sovelluksen esiintymän.

alkaen pullo tuonti Pullo
alkaen routes.user_auth tuonti register_routes
alkaen utils.db tuonti connect_to_mongodb
tuonti os
alkaen dotenv tuonti load_dotenv
app = Kolvi (__name__)
load_dotenv()


mongo_uri = os.getenv("MONGO_URI")
db = connect_to_mongodb (mongo_uri)


register_routes (sovellus, db)
jos __nimi__ == '__main__':
 app.run (debug=Totta)

Luo Authentication API -päätepisteet

Käyttäjien todennuksen toteuttamiseksi Flask-sovelluksessa on ratkaisevan tärkeää määrittää tarvittavat API-päätepisteet, jotka käsittelevät todentamiseen liittyviä toimintoja.

Määritä kuitenkin ensin malli käyttäjien tiedoille. Luo uusi model/user_model.py tiedosto juurihakemistoon ja lisää seuraava koodi.

alkaen pymongo.collection tuonti Kokoelma
alkaen bson.objectid tuonti ObjectId
luokkaaKäyttäjä:
def__sen sisällä__(itse, kokoelma: Kokoelma, käyttäjätunnus: str, salasana: str):
 self.collection = kokoelma
 self.username = käyttäjänimi
 self.password = salasana
defTallentaa(itse):
 user_data = {
'käyttäjänimi': itse.käyttäjänimi,
'Salasana': itse.salasana
 }
 tulos = self.collection.insert_one (user_data)
palata str (tulos.lisätty_tunnus)


 @staticmethod
deffind_by_id(kokoelma: Kokoelma, user_id: str):
palata collection.find_one({'_id': ObjectId (user_id)})
 @staticmethod
deffind_by_username(kokoelma: Kokoelma, käyttäjätunnus: str):
palata collection.find_one({'käyttäjänimi': käyttäjätunnus})

Yllä oleva koodi määrittää a Käyttäjä luokka, joka toimii tietomallina ja määrittää useita menetelmiä vuorovaikutukseen MongoDB-kokoelman kanssa käyttäjiin liittyvien toimintojen suorittamiseksi.

  1. The Tallentaa menetelmä tallentaa uuden käyttäjädokumentin annetulla käyttäjätunnuksella ja salasanalla MongoDB-kokoelmaan ja palauttaa lisätyn asiakirjan tunnuksen.
  2. The find_by_id ja find_by_username menetelmät hakevat käyttäjädokumentteja kokoelmasta annetun käyttäjätunnuksen tai käyttäjätunnuksen perusteella.

Määritä todennusreitit

  1. Aloitetaan määrittämällä rekisteröintireitti. Tämä reitti lisää uusia käyttäjätietoja MongoDB-käyttäjien kokoelmaan. Luo juurihakemistoon uusi routes/user_auth.py tiedosto ja seuraava koodi.
    tuonti jwt
    alkaen toiminnalliset työkalut tuonti kääreitä
    alkaen pullo tuonti jsonify, request, make_response
    alkaen mallit.käyttäjämalli tuonti Käyttäjä
    tuonti bcrypt
    tuonti os
    defregister_routes(sovellus, db):
     kokoelma = db.käyttäjät
     app.config['SALAINEN AVAIN'] = os.urandom(24)
    

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

     käyttäjätunnus = request.json.get('käyttäjänimi')
     salasana = request.json.get('Salasana')

     olemassa oleva_käyttäjä = User.find_by_username (kokoelma, käyttäjänimi)
    jos olemassa oleva käyttäjä:
    palata jsonify({'viesti': 'Käyttäjätunnus on jo olemassa!'})

     hashed_password = bcrypt.hashpw (salasana.encode("utf-8"), bcrypt.gensalt())
     new_user = Käyttäjä (kokoelma, käyttäjätunnus, hashed_password.decode("utf-8"))
     käyttäjätunnus = uusi_käyttäjä.tallenna()
    palata jsonify({'viesti': 'Käyttäjä rekisteröity onnistuneesti!', 'käyttäjätunnus': käyttäjätunnus})
  2. Toteuta sisäänkirjautumistoiminto todennusprosessin hoitamiseksi ja käyttäjän tunnistetietojen tarkistamiseksi. Lisää rekisteröitymisreitin alle seuraava koodi.
     @app.route('/api/login', method=['POST'])
    defKirjaudu sisään():
     käyttäjätunnus = request.json.get('käyttäjänimi')
     salasana = request.json.get('Salasana')
     user = User.find_by_username (kokoelma, käyttäjänimi)
    jos käyttäjä:
    jos bcrypt.checkpw (salasana.encode("utf-8"), käyttäjä['Salasana'].encode("utf-8")):
     token = jwt.encode({'käyttäjätunnus': str (käyttäjä['_id'])}, app.config['SALAINEN AVAIN'], algoritmi="HS256")

     vastaus = make_response (jsonify({'viesti': 'Kirjautuminen onnistui!'}))
     vastaus.set_cookie("tunnus", tunnus)
    palata vastaus
    palata jsonify({'viesti': 'Väärä käyttäjänimi tai salasana'})
    Kirjautumisen päätepiste tekee kaksi asiaa: se tarkistaa toimitetut käyttäjätiedot ja onnistuneen todennuksen jälkeen luo yksilöllisen JWT: n tälle käyttäjälle. Se asettaa tämän tunnuksen evästeeksi vastauksessa sekä JSON-hyötykuorman, joka osoittaa onnistuneen kirjautumisen. Jos tunnistetiedot ovat virheellisiä, se palauttaa JSON-vastauksen.
  3. Määritä koristelutoiminto, joka vahvistaa myöhempien API-pyyntöjen mukana välitetyt JSON-verkkotunnukset (JWT). Lisää alla oleva koodi sisään register_routes toimintokoodilohko.
    deftoken_required(f):
     @wraps (f)
    defkoristeltu(*args, **kwargs):
     token = request.cookies.get("tunnus")
    josei tunnus:
    palata jsonify({'viesti': "Token puuttuu!"}), 401
    

    yrittää:
     data = jwt.decode (tunnus, app.config['SALAINEN AVAIN'], algoritmit=["HS256"])
     current_user = User.find_by_id (kokoelma, data['käyttäjätunnus'])
    paitsi jwt. Expired SignatureError:
    palata jsonify({'viesti': "Token on vanhentunut!"}), 401
    paitsi jwt. InvalidTokenError:
    palata jsonify({'viesti': "Virheellinen tunnus!"}), 401
    

    palata f (nykyinen_käyttäjä, *args, **kwargs)
    palata koristeltu
    Tämä koristelutoiminto varmistaa kelvollisen JWT-tunnuksen läsnäolon myöhemmissä API-pyynnöissä. Se tarkistaa, puuttuuko tunnus, onko se vanhentunut tai kelvollinen, ja palauttaa asianmukaisen JSON-vastauksen, jos se on.
  4. Luo lopuksi suojattu reitti.
     @app.route('/api/users', method=['GET'])
     @token_required
    defget_users(nykyinen käyttäjä):
     käyttäjät = lista (collection.find({}, {'_id': 0}))
    palata jsonify (käyttäjät)

Tämä päätepiste käsittelee logiikkaa käyttäjätietojen hakemiseksi tietokannasta, mutta se edellyttää, että asiakas lähettää pyynnöt, että se sisältää kelvollisen tunnuksen tietojen käyttämiseksi.

Suorita lopuksi alla oleva komento käynnistääksesi kehityspalvelimen.

pullon juoksu

Voit testata rekisteröinnin, kirjautumisen ja suojatun käyttäjien päätepisteen käyttämällä Postmania tai mitä tahansa muuta API-asiakasta. Lähetä pyynnöt osoitteeseen http://localhost: 5000/api/ja tarkkaile vastauksia varmistaaksesi näiden API-päätepisteiden toimivuuden.

Onko Token-todennus idioottivarma turvatoimenpide?

JSON-verkkotunnukset tarjoavat vankan ja tehokkaan tavan todentaa verkkosovelluksesi käyttäjät. On kuitenkin tärkeää ymmärtää, että token-todennus ei ole idioottivarma; se on vain yksi pala suuremmasta turvallisuuspalapelistä.

Yhdistä token-todennus muihin turvallisuuden parhaisiin käytäntöihin. Muista seurata jatkuvasti ja ottaa käyttöön johdonmukaisia ​​suojauskäytäntöjä; parannat huomattavasti Flask-sovellustesi yleistä turvallisuutta.