Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Login e sicurezza6. Login e rotte protettep. 175

Login e rotte protette, se qualcosa va storto

Gli errori del login e del controllore, e quelli che non fanno rumore

Gli errori che vedrai di più in questo capitolo. Per ognuno: cosa leggi, cosa vuol dire, cosa fai.

Ricorda come si legge un traceback: dal basso. L'ultima riga dice cosa, la riga con i ^^^ dice quale pezzo, la riga File … line … dice dove. Tutto il resto è nel capitolo Leggere un traceback. Con un server acceso, il traceback è nel terminale del server, non in quello di curl: al client arriva solo Internal Server Error.

Il codice

LeggiVuol direCosa fai
AttributeError: 'NoneType' object has no attribute 'credentials' (nel terminale del server, e 500 Internal Server Error per il client)Nel controllore usi header.credentials, ma header è None: la richiesta non aveva il bigliettoPrima di leggerlo: if header is None: e 401 «Manca il biglietto»
KeyError: None (o KeyError: 'fantasma')Nel controllore cerchi l'utente con le quadre: utenti[username]. Con un biglietto che non vale username è None, e None non è una chiaveutenti.get(username), e poi if utente is None: con il 401
{"detail":"Not authenticated"}, con un header www-authenticate: BearerIl controllore è un HTTPBearer() senza auto_error=False: risponde lui, con il suo messaggioUsa il controllore di sicurezza.py: HTTPBearer(auto_error=False). Il 401 con il tuo messaggio lo scrive utente_corrente
{"detail":[{"type":"missing","loc":["body"],"msg":"Field required","input":null}]} su una rotta che è un GETIl parametro utente: UtenteSalvato non ha = Depends(utente_corrente): per FastAPI è un corpo da leggere dalla richiestautente: UtenteSalvato = Depends(utente_corrente)
{"detail":[{"type":"missing","loc":["body","password"],"msg":"Field required",…}]} al loginNel corpo del login manca un campo (qui password)loc dice dove, msg dice cosa. Il corpo vuole tutti e due: username e password
{"detail":[{"type":"model_attributes_type","loc":["body"],"msg":"Input should be a valid dictionary or object to extract fields from",…}]} al loginIl corpo non è JSON: è arrivato come testo semplice, per esempio username=lucia&password=…In Postman: Body → raw → JSON. In curl: -H "Content-Type: application/json" e il corpo con le virgolette doppie
/login risponde 401 con la password giustaQuasi sempre: uno spazio o una maiuscola in più nello username, o la password di un altro utente. Il messaggio è uguale per tutti i guai, appostaControlla username e password, lettera per lettera, con la tabella degli utenti del README
assert 501 == 200 (o 201, o 401)C'è ancora la riga «da fare»: raise HTTPException(status_code=501, …)Al posto di quella riga, il tuo codice
RuntimeError: Manca SECRET_KEY: crea il file .env (README, «Una volta sola») accendendo il serverManca il file .env nella cartella principale: senza chiave non si firma nessun bigliettoIl comando della chiave, nel README: python3 -c "import secrets; print('SECRET_KEY=' + secrets.token_hex(32))" > .env. I test no: usano una chiave loro
Address already in useC'è già un server acceso, in un altro terminaleCtrl+C di là, oppure fastapi dev … --port 8001

La richiesta

LeggiVuol direCosa fai
{"detail":"Manca il biglietto"}, ma il biglietto lo stai mandandoNon è arrivato un header Authorization: Bearer … fatto bene: manca la parola Bearer, o lo spazio, o l'header ha un altro nomecurl: -H "Authorization: Bearer $BIGLIETTO". Postman: Authorization → Bearer Token, non una riga a mano
{"detail":"Biglietto non valido"} appena fatto il loginIl biglietto è stato letto, ma non vale. Quasi sempre: sono passati 30 minuti; oppure in /docs hai incollato Bearer eyJ… nel lucchetto (la parola la aggiunge da sola); oppure hai incollato le virgoletteRifai il login e incolla solo il valore di access_token, senza virgolette e senza Bearer
{"detail":"Biglietto non valido"} con un biglietto fresco, dopo aver salvato un filefastapi dev ricarica il programma a ogni salvataggio, e il dizionario utenti torna com'era: la persona registrata a mano non c'è più. Il biglietto vale, ma l'utente noRegistrala di nuovo e rifai il login. Vedi sotto: «Il server riparte, il dizionario torna»
{"detail":"Biglietto non valido"} dopo aver cambiato il .envLa chiave è nuova: i biglietti fatti con la vecchia hanno una firma che non torna piùRifai il login con il server riavviato
{{biglietto}} resta rosso in PostmanLa variabile non c'è: lo script del login non è partito, o non ha salvato nienteScripts → Post-response: pm.collectionVariables.set("biglietto", pm.response.json().access_token);. Poi rifai il login, e controlla di averla scritta nella collezione
Could not send request o ECONNREFUSED in PostmanPostman non raggiunge il server: spento, oppure l'indirizzo è sbagliato. O stai usando Postman nel browser, che non vede il tuo computerControlla che fastapi dev sia acceso, e che baseUrl sia http://127.0.0.1:8000. Usa l'app desktop
/me risponde 401 in Postman, ma il login ha funzionatoLa richiesta di /me non manda il biglietto: l'Auth Type della richiesta non è Bearer Token, oppure il biglietto è scadutoImposta Bearer Token con {{biglietto}}. Scaduto: rifai il login
403 al posto di 401 (o 404 al posto di 401)Hai confuso le domande. 401: non so chi sei. 403: so chi sei, ma qui non entri. 404: quello che chiedi non c'èUn biglietto che manca o non vale è sempre 401. Il 403 comincia nel capitolo sui permessiin arrivo

Il server riparte, il dizionario torna

Il caso più strano di questo capitolo, e vero: tutto funziona, poi salvi un file e la tua persona sparisce. Con la storia accesa (fastapi dev storia/main.py), questo è quello che succede:

Terminale
curl -s -X POST http://127.0.0.1:8000/personale -H "Content-Type: application/json" -d '{"username": "bruno", "nome": "Bruno Gatti", "password": "linea-verde-33"}'
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer $BIGLIETTO"
touch storia/main.py    # come salvare il file
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer $BIGLIETTO"
curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "bruno", "password": "linea-verde-33"}'
{"username":"bruno","nome":"Bruno Gatti"}
{"username":"bruno","nome":"Bruno Gatti"}
{"detail":"Biglietto non valido"}
{"detail":"Username o password sbagliati"}

La prima risposta è la registrazione, la seconda è /me con il biglietto di Bruno ($BIGLIETTO, preso con un login subito dopo la registrazione). Nel terminale del server compare WatchFiles detected changes … Reloading: il programma è ripartito, e utenti è tornato com'era scritto nel codice, cioè vuoto. Il biglietto di Bruno vale ancora (la chiave è sempre la stessa), ma Bruno non c'è più: è proprio il quinto 401 della teoria. Con un database i dati resterebbero; con un dizionario, no: si registra di nuovo.

Gli errori che non danno errori

I più difficili sono quelli senza traceback: il programma gira, le richieste vanno, il test (se c'è) resta verde. Qui sono tutti buchi di sicurezza, e si vedono solo con un test che li cerca.

Il nome al posto dello username. crea_biglietto(utente.nome): il login risponde 200, ma nel biglietto c'è «Lucia Ferri», e il controllore non la trova. Ogni richiesta dopo è un 401.

Chi sei, preso dal posto sbagliato. Uno username letto dal corpo, dall'indirizzo o da un parametro (?username=lucia): sembra comodo, e permette a chiunque di essere chiunque. L'utente è sempre quello del biglietto.

Due messaggi per due guai al login. «Username non trovato» e «Password sbagliata»: funziona, ma dice a un estraneo chi lavora alla Linea Menta.

Il biglietto letto, non controllato. jwt.decode(…, options={"verify_signature": False}): si legge lo username e tutto funziona. Ma un biglietto cambiato a mano passa, uno scaduto passa, uno firmato con un'altra chiave passa. Per leggere il biglietto si usa leggi_biglietto.

L'impronta nella risposta. -> UtenteSalvato dove serve -> Utente: lo stampo della risposta è il solo filtro. Nessun errore: lo vedi solo leggendo la risposta.

Il 404 dove serve il 401. Se una rotta cerca la cosa (/porte/binario-9/apri) prima di chiedersi chi sei, a chi non ha un biglietto dice «Porta non trovata»: gli racconta cosa esiste. Prima il 401, poi il 404.

Per trovarli, nell'ordine: un test che prova la rotta con un biglietto di un'altra persona, con un biglietto cambiato, con nessun biglietto. E il debugger, se la risposta è strana: un breakpoint dentro utente_corrente, e in WATCH header, username, utente. Come si fa: Il debugger con FastAPI e i test.

Se il problema non è il codice

pytest: command not found, No module named 'pwdlib' (o 'jwt', 'dotenv'), il pannello Testing vuoto, No module named 'login': non è il tuo codice, è l'ambiente. Ha una pagina sua nel Pronto soccorso: pytest non parte, o non trova niente. Le cure brevi per Postman e il login (Could not send request, {{biglietto}}, il 422 del corpo) sono nel Pronto soccorso.