Kako zavarovati bliskovni API REST s spletnim žetonom JSON?

Naučimo se, kako zaščititi API REST s spletnimi žetoni JSON, da uporabnikom in tretjim aplikacijam prepreči zlorabo.


Z uporabo baze podatkov bomo zgradili storitev SQLite uporabnikom pa omogočite dostop do njega prek API-ja REST z uporabo HTTP metod, kot sta POST in PUT.

Poleg tega bomo spoznali, zakaj so spletni žetoni JSON primeren način za zaščito API-ja za počitek namesto prebave in osnovne avtentikacije. Preden nadaljujemo, razumemo pojem spletne žetone JSON, REST API in okvir Flask.

JSON Spletni tokeni

JSON spletni žeton, znan tudi kot JWT, je varen način prenosa naključnih žetonov med dvema strankama ali subjektoma. JSON je običajno sestavljen iz treh delov, kot sledi.

  • Obremenitev
  • Glava
  • Podpis

JSON uporablja dve vrsti strukturnih obrazcev pri prenosu podatkov ali informacij med dvema strankama.

  • Serizirano
  • Deserializirano

Serializiran obrazec se uporablja pri prenosu podatkov v omrežje prek vsake zahteve in odgovora, medtem ko se deserializiran obrazec uporablja pri branju in pisanju podatkov v spletni žeton.

V serializirani obliki so tri komponente.

  • Glava
  • Obremenitev
  • Podpis

Komponenta glave določa kriptografske podatke o žetonih. Na primer:

  • Ali je JWT podpisan ali nepodpisan?
  • Določite tehnike algoritma

Deserializirana oblika za razliko od serializirane oblike vsebuje dve komponenti.

  • Obremenitev
  • Glava

REST API

API (aplikacijski programski vmesnik) omogoča komunikacijo med dvema programoma za pridobivanje ali predložitev podatkov. Obstajata dve priljubljeni vrsti API-jev – spletni in sistemski API.

V tem članku si bomo ogledali le spletni API. Obstajata dve vrsti spletnega API-ja.

  • Zahteva – odzivni API: počitek, GraphQL, klic na daljavo postopkov (RPC)
  • Event-driven API: WebHooks, Web Sockets, HTTP Streaming

REST API spada pod kategorijo odziv na zahtevo. Za izvajanje operacij API uporablja metode HTTP, kot so GET, POST in PUT.

Klasičen primer je, ko uporabnik v spletno storitev pošlje metodo GET, da zahteva ali pridobi določen vir ali zbirko virov. Nato strežnik pošlje določen vir ali zbirko virov nazaj uporabniku, ki ga je zahteval.

Bučni okvir

Bučka je okvir, ki temelji na pythonu. To je mikro-okvir, ki ga uporabljajo razvijalci python-a za pripravo API-ja za počitek. Mikro okvir se imenuje zato, ker omogoča razvijalcem, da na primer dodajo pristnost po meri in kateri koli drug zaledni sistem na podlagi preferenc.

Začnimo z izvajanjem. Moja sistemska namestitev je naslednja.

  • Ubuntu kot OS
  • Python 2.7+
  • Poštar

Nastavite virtualno okolje s pomočjo virtualenv

Vzpostaviti moramo navidezno okolje, da zagotovimo, da nekateri paketi ne bodo v nasprotju s sistemskimi paketi. Uporabite virtualenv za vzpostavitev novega virtualnega okolja.

Če predpostavimo, da imate v sistemu na voljo ukaz pip, zaženite naslednji ukaz prek pipa za namestitev.

pip namestite virtualenv

Če na vašem računalniku nimate pipsa, sledite temu dokumentacijo namestiti pip v vaš sistem.

Nato ustvarimo imenik za shranjevanje ali ohranjanje našega virtualnega okolja. Za ustvarjanje imenika uporabite ukaz mkdir, prikazan spodaj

mkdir bučkaprojekt

S pomočjo naslednjega ukaza se spremenite v imenik bučke

cd bučkaprojekt

Znotraj imenika flaskproject uporabite orodje virtualenv za ustvarjanje virtualnega okolja, kot je prikazano spodaj:

virtualenv flaskapi

Ko uporabite orodje virtualenv za ustvarjanje virtualnega okolja, zaženite ukaz cd, da se spremenite v imenik flaskapi kot virtualno okolje, in ga aktivirajte s spodnjim ukazom.

izvorni koš / aktiviraj

Izvedite vsa opravila, povezana s tem projektom, v virtualnem okolju.

Namestite pakete s pomočjo pipa

Zdaj je čas, da namestite pakete, kot sta okvir bučke in PyJWT, ki jih bomo uporabili za izdelavo preostalih API-jev in drugih potrebnih paketov za naš projekt API.

Ustvarite datoteko zahteve.txt z naslednjimi paketi.

Bučka
Datum čas
uuid
Flask-SQLAlchemy
PyJWT

Namestite jih s pipo.

pip namestite -r zahteve.txt

Nastavite bazo podatkov

Namestimo SQLite.

apt-get namestite sqlite3

Ustvarite bazo podatkov z imenom knjižnica. Znotraj te baze bomo ustvarili dve tabeli, in sicer tabelo Uporabniki in Avtorji.

Tabela uporabnikov bo vsebovala registrirane uporabnike. Samo registrirani uporabniki imajo dostop do tabele Avtorji.

V tabeli avtorjev bodo shranjeni podatki avtorja ali podrobnosti, kot so ime avtorja, država rojstva in tako naprej, ki jih predložijo registrirani uporabniki.

Ustvarite bazo podatkov z naslednjim ukazom:

sqlite3 library.db

S spodnjim ukazom lahko preverite, ali ste uspešno ustvarili bazo podatkov:

.baze podatkov

Odprite nov terminal in izvedite naslednje v virtualnem okolju, ki smo ga ustvarili prej.

dotaknite se app.py

Naslednjo kodo prilepite v datoteko z imenom app.py

iz uvoza bučke, bučka, zahteva, jsonify, make_response
iz flashk_sqlalchemy uvoz SQLAlchemy
iz werkzeug.security uvoz create_password_hash, check_password_hash
uvoz uuid
uvoz jwt
uvozi datum
iz uvoznih ovojev iz funkcijskih funkcij

Prva vrstica v zgornji kodi uvaža pakete, kot sta zahteva in jsonify. Uporabili bomo zahtevo za spremljanje podatkov na ravni zahteve med zahtevo in uporabili jsonify za izpis odgovorov v JSON format.

V naslednji vrstici smo uvozili SQLAlchemy iz flask_sqlalchemy, da bi vključili funkcije SQLAlchemy v bučko.

Iz werkzeug.security smo uvozili generator_password_hash za ustvarjanje hash-ja gesla za uporabnike in check_password_hash za preverjanje uporabnikovega gesla pri primerjavi gesla, ki so ga poslali uporabniki z uporabniškimi gesli, shranjenimi v bazi podatkov.

Nazadnje smo uvozili uuid, znan tudi kot univerzalni unikatni identifikatorji za generiranje naključnih id številk za uporabnike.

Kljub temu v datoteki app.py izvedite nastavitve konfiguracije za API knjižnice s pomočjo spodnje kode v datoteki app.py.

Pod uvozno izjavo postavite naslednjo kodo.

app = bučka (__ ime__)

app.config [‘SECRET_KEY’] = ‘Th1s1ss3cr3t’
app.config [‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite: /////home/michael/geekdemos/geekapp/library.db’
app.config [‘SQLALCHEMY_TRACK_MODIFICATIONS’] = Res

db = SQLAlchemy (aplikacija)

Zdaj ustvarite dva modela za tabelo Uporabniki in avtorji, kot je prikazano spodaj. Kopirajte in prilepite kodo v datoteko app.py.

Spodaj postavite kodo pod to nastavitev baze podatkov db = SQLAlchemy (aplikacija)

Uporabniki razreda (db.Model):
id = db. stolpec (db.Integer, Primary_key = True)
public_id = db.Steber (db.Integer)
ime = db. stolpec (db.String (50))
geslo = db. stolpec (db.String (50))
admin = db. Column (db.Boolean)
Avtorji razreda (db.Model):
id = db. stolpec (db.Integer, Primary_key = True)
ime = db. stolpec (db.String (50), edinstveno = resnično, nično = napačno))
knjiga = db. stolpec (db.String (20), edinstven = True, nullable = napačno))
država = db. stolpec (db.String (50), izvlečna = napačna))
booker_prize = db.kolon (db.Boolean)

Ustvari tabele uporabnikov in avtorjev

Na terminalu vtipkajte naslednjo kodo v virtualno okolje, da ustvarite ali ustvarite tabele za tabele Uporabniki in avtorji, kot je prikazano spodaj

iz uvoza aplikacije db
db.create_all ()

Nato odprite datoteko app.py v virtualnem okolju in ustvarite drugo funkcijo.

Ta funkcija bo ustvarila žetone, da bi samo registriranim uporabnikom omogočila dostop in izvedbo nabora operacij API v tabeli Avtorji.

To kodo postavite pod model baze podatkov za tabelo Avtorji

def token_required (f):
@wraps (f)
def decorator (* args, ** kwargs):

token = noben

če je v zahtevnih glavah ‘x-access-žetoni’:
token = request.headers [‘x-dostop-žetone’]

če ne žeton:
return jsonify ({‘message’: ‘manjka veljaven žeton’})

poskusi:
data = jwt.decode (token, app.config [SECRET_KEY])
current_user = Users.query.filter_by (public_id = podatki [‘public_id’]). prvi ()
razen:
return jsonify ({‘message’: ‘žeton je neveljaven’})

vrne f (trenutni_user, * args, ** kwargs)
vrne dekorater

Ustvari poti za tabelo uporabnikov

Zdaj ustvarimo pot, da uporabnikom omogočimo registracijo za avtorje API preko uporabniškega imena in gesla, kot je prikazano spodaj.

Znova odprite datoteko app.py v virtualnem okolju in pod funkcijo token_required (f) prilepite naslednjo kodo

@ app.route (‘/ registriraj’, metode = [‘GET’, ‘POST’])
def signup_user ():
data = request.get_json ()

hashed_password = generator_password_hash (podatki [‘geslo’], metoda = ‘sha256’)

new_user = Uporabniki (public_id = str (uuid.uuid4 ()), ime = podatki [‘ime’], geslo = hashed_password, admin = napačno)
db.session.add (new_user)
db.session.commit ()

return jsonify ({‘message’: ‘uspešno registriran’})

V virtualnem okolju ustvarite drugo pot v datoteki app.py, da se registriranim uporabnikom omogočite prijavo.

Ko se uporabnik prijavi, se ustvari naključni žeton za dostop do API-ja knjižnice.

Spodaj prilepite kodo pod prejšnjo pot, ki smo jo ustvarili.

@ app.route (‘/ prijava’, metode = [‘GET’, ‘POST’])
def login_user ():

auth = zahteva.avtorizacija

če ni avtor ali ne auth.username ali ne auth.password:
vrne make_response (‘ni bilo mogoče preveriti’, 401, {‘WWW.Authentication’: ‘Osnovno področje: "potrebna prijava"’})

uporabnik = Users.query.filter_by (ime = auth.username) .first ()

če je check_password_hash (user.password, auth.password):
token = jwt.encode ({‘public_id’: user.public_id, ‘exp’: datetime.datetime.utcnow () + datetime.timedelta (minute = 30)}, app.config [‘SECRET_KEY’])
vrne jsonify ({‘token’: token.decode (‘UTF-8’)})

vrne make_response (‘ni bilo mogoče preveriti’, 401, {‘WWW.Authentication’: ‘Osnovno področje: "potrebna prijava"’})

Kljub temu v virtualnem okolju ustvarite drugo pot v datoteki app.py, da pridobite ali pridobite vse registrirane uporabnike.

Ta koda preveri vse registrirane uporabnike v tabeli Uporabnikov in vrne končni rezultat v obliki JSON.

Spodaj prilepite kodo pod pot prijave

@ app.route (‘/ uporabniki’, metode = [‘GET’])
def get_all_users ():

users = Users.query.all ()

rezultat = []

za uporabnika v uporabnikih:
user_data = {}
user_data [‘public_id’] = uporabnik.public_id
user_data [‘ime’] = uporabniško ime
user_data [‘geslo’] = user.password
user_data [‘admin’] = user.admin

rezultat.append (user_data)

vrne jsonify ({‘uporabniki’: rezultat})

Ustvari poti za tabelo avtorjev 

Ustvarimo poti za tabelo Avtorji, da uporabnikom omogočimo priklic vseh avtorjev v zbirki podatkov in brisanje avtorjev.

Samo uporabniki z veljavnimi žetoni lahko izvajajo te operacije API-ja.

Znotraj datoteke app.py ustvarite pot za registrirane uporabnike, da ustvarijo nove avtorje.

Prilepite to kodo pod pot, ki uporabniku omogoča pridobivanje vseh registriranih uporabnikov.

@ app.route (‘/ avtor’, metode = [‘POST’, ‘GET’])
@token_required
def create_author (trenutni_user):

data = request.get_json ()

new_authors = Avtorji (ime = podatki [‘ime’], država = podatki [‘država’], knjiga = podatki [‘knjiga’], booker_prize = Res, user_id = current_user.id)
db.session.add (new_authors)
db.session.commit ()

return jsonify ({‘message’: ‘ustvarjen nov avtor’})

Nato ustvarite drugo pot, da registriranemu uporabniku z veljavnim žetonom omogočite priklic vseh avtorjev v tabeli Avtorji, kot je prikazano spodaj.

Prilepite to kodo pod pot, ki uporabniku omogoča ustvarjanje novega avtorja.

@ app.route (‘/ avtorji’, metode = [‘POST’, ‘GET’])
@token_required
def get_authors (current_user):

avtorji = Authors.query.filter_by (user_id = current_user.id) .all ()

izhod = []
za avtorja v avtorjih:

avtor_data = {}
avtor_data [‘ime’] = ime avtorja
avtor_data [‘knjiga’] = avtor.book
avtor_data [‘država’] = avtor.country
avtor_data [‘booker_prize’] = avtor.booker_prize
output.append (avtor_data)

vrne jsonify ({‘list_of_authors’: output})

Na koncu še vedno znotraj datoteke app.py ustvarite pot do izbrisa določenega avtorja, kot je prikazano spodaj.

Prilepite to kodo pod pot, ki uporabniku omogoča pridobivanje seznama avtorjev.

@ app.route (‘/ avtorji /’, metode = [‘DELETE’])
@token_required
def delete_author (trenutni_user, avtor_id):
avtor = Avtor.query.filter_by (id = avtor_id, user_id = trenutni_user.id) .first ()
če ni avtor:
return jsonify ({‘message’: ‘avtor ne obstaja’})

db.session.delete (avtor)
db.session.commit ()

return jsonify ({‘message’: ‘Avtor izbrisan’})

če je __name__ == ‘__main__’:
app.run (odpravljanje napak = True)

Nato shranite in zaprite datoteko app.py v virtualnem okolju.

Testiranje API-ja knjižnice s Postmanom

V tem razdelku bomo uporabili orodje poštarjev za pošiljanje zahteve storitvam baz podatkov. Če na svojem stroju nimate poštarja, lahko ugotovite, kako ga naložite in namestite tukaj.

Poleg poštarja lahko uporabimo tudi druga orodja, kot so Curl pošiljati zahteve strežniku.

Odprite nov terminal in vnesite naslednje:

poštar

Z ukaznim poštarjem bo vaš spletni brskalnik prikazal spodnjo stran:

postman_signup

Lahko se odločite za registracijo in ustvarjanje brezplačnega računa, vendar bomo preskočili in dobili neposreden dostop do aplikacije, da preizkusimo API knjižnice, kot je prikazano spodaj:

Preizkusite knjižnico api

V tem razdelku bomo uporabniku omogočili registracijo za knjižnični API z zagotavljanjem uporabniškega imena in edinstvenega gesla v obliki JSON z uporabo metode POST s pomočjo spodnjih korakov:

  • Kliknite na jeziček Body
  • Nato izberite surovi gumb in izberite obliko JSON
  • vnesite uporabniško ime in geslo za registracijo, kot je prikazano na posnetku zaslona
  • Poleg gumba za pošiljanje vstavite naslednji URL http://127.0.0.1/register
  • Na koncu spremenite način POST in pritisnite gumb za pošiljanje.

se uporabnik registrira za api

Prikaže se naslednji izhod, kot je prikazano spodaj:

Zdaj smo uspešno registrirali uporabnika. Pojdimo naprej, da uporabniku, ki se je pravkar registriral, omogoči prijavo, da ustvari začasni naključni žeton, da dostopa do tabele Avtorji z naslednjimi koraki:

  •  Kliknite na zavihek avtorizacije.
  • V razdelku vrste izberite osnovno preverjanje pristnosti.
  • Nato izpolnite obrazec za uporabniško ime in geslo z uporabniškim imenom in geslom, s katerim ste se predhodno registrirali.
  • Na koncu pritisnite gumb za pošiljanje, da se prijavite in ustvarite naključni žeton.

Ko se uporabnik uspešno prijavi, se za uporabnika ustvari naključni žeton, kot je prikazano na posnetku zaslona.

Uporabili bomo ustvarjen naključni žeton za dostop do tabele Avtorji.

V tem razdelku bomo v tabelo Avtorji dodali podatke o avtorju po metodi POST z naslednjimi koraki:

  • Kliknite na zavihek glave
  • Na posnetku zaslona vključite naslednje glave HTTP

  • Nato kliknite na zavihek telo in vnesite podrobnosti novega avtorja
  • Nato pritisnite gumb za pošiljanje, če želite podrobnosti o avtorju dodati v avtorjevo tabelo

Podatke avtorjev lahko dobite tudi v tabeli Avtorji z naslednjim:

  • Prepričajte se, da je ustvarjen žeton v razdelku z glavo. če ga ni, ga morate napolniti s svojim žetonom.
  • Poleg gumba za pošiljanje vnesite ta URL http://127.0.0.1/authors
  • Nato spremenite način HTTP v GET in pritisnite gumb za pošiljanje, da dobite podrobnosti o avtorjih.

Na koncu lahko avtorja (avtorje) iz tabele Avtorji izbrišete po metodi DELETE z naslednjimi koraki:

  • Prepričajte se, da je vaš žeton še vedno v razdelku z glavo. Na zavihku glave lahko preverite, ali so potrebne informacije.
  • Poleg gumba za pošiljanje vnesite ta URL http://127.0.0.1/sam
  • Nato pritisnite gumb za pošiljanje, da izbrišete uporabnika, ki ste ga določili.

Celotno izvorno kodo najdete na Github.  Lahko ga klonirate in preverite na svojem stroju.

Oznake:

  • Python

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map