JWT da zero: a cosa serve, come proteggerlo e implementarlo con l’IA

import {SignJWT,jwtVerify} from 'jose';
const issuer='https://auth.example.test', audience='billing-api';
function checkKey(key){if(!(key instanceof Uint8Array)||key.length<32)throw new Error('Use at least 32 random bytes');}
export async function issue(subject,tenant,key){
 checkKey(key);
 if(!subject||!tenant)throw new Error('Missing identity');
 return new SignJWT({tenant}).setProtectedHeader({alg:'HS256',typ:'nf-access+jwt'})
  .setSubject(subject).setIssuer(issuer).setAudience(audience)
  .setIssuedAt().setExpirationTime('5m').sign(key);
}
export async function verify(token,key){
 checkKey(key);
 const {payload}=await jwtVerify(token,key,{
  algorithms:['HS256'],typ:'nf-access+jwt',issuer,audience,
  requiredClaims:['exp','iat','sub','tenant'],maxTokenAge:'5m',clockTolerance:0,
 });
 const now=Math.floor(Date.now()/1000);
 if(typeof payload.sub!=='string'||!payload.sub||typeof payload.tenant!=='string'||!payload.tenant||
  !Number.isInteger(payload.exp)||!Number.isInteger(payload.iat)||payload.iat>now||
  payload.exp<=payload.iat||payload.exp-payload.iat>300)throw new Error('Invalid access profile');
 return payload;
}
export function canReadInvoice(actor,invoice){
 return !!actor?.sub&&!!actor?.tenant&&actor.tenant===invoice?.tenant&&actor.sub===invoice?.owner;
}

"""Local HS256 access-token profile. Caller authenticates before issue()."""
import secrets, time, jwt
ISSUER, AUDIENCE = 'https://auth.example.test', 'billing-api'
def check_key(key):
 if not isinstance(key, bytes) or len(key)<32: raise ValueError('Use 32 random bytes')
def issue(subject,tenant,key):
 check_key(key)
 if not subject or not tenant: raise ValueError('Missing identity')
 now=int(time.time())
 return jwt.encode({'sub':subject,'tenant':tenant,'iss':ISSUER,'aud':AUDIENCE,
  'iat':now,'exp':now+300},key,algorithm='HS256',headers={'typ':'nf-access+jwt'})
def verify(token,key):
 check_key(key)
 data=jwt.decode_complete(token,key,algorithms=['HS256'],issuer=ISSUER,audience=AUDIENCE,
  options={'require':['exp','iat','sub','tenant','iss','aud']})
 p=data['payload']; now=int(time.time())
 if (data['header'].get('typ')!='nf-access+jwt' or not isinstance(p['sub'],str)
  or not p['sub'] or not isinstance(p['tenant'],str) or not p['tenant']
  or type(p['iat']) is not int or type(p['exp']) is not int
  or p['iat']>now or not 0<p['exp']-p['iat']<=300): raise ValueError('Invalid access profile')
 return p
def can_read_invoice(actor,invoice):
 return bool(actor.get('sub') and actor.get('tenant') and actor['sub']==invoice.get('owner') and actor['tenant']==invoice.get('tenant'))
if __name__=='__main__':
 key=secrets.token_bytes(32);actor=verify(issue('user-7','acme',key),key)
 print({'authenticated':True,'subject':actor['sub'],'sameTenantInvoice':can_read_invoice(actor,{'owner':'user-7','tenant':'acme'})})

<?php
// Local HS256 profile. Issue tokens only after trusted server authentication.
require __DIR__.'/vendor/autoload.php';
use Firebase\JWT\JWT;
use Firebase\JWT\Key;
function checkKey(string $key): void {
 if(strlen($key)<32) throw new RuntimeException('Use 32 random bytes');
}
function issue(string $subject,string $tenant,string $key): string {
 checkKey($key);
 if($subject===''||$tenant==='') throw new RuntimeException('Missing identity');
 $now=time();
 return JWT::encode(['sub'=>$subject,'tenant'=>$tenant,'iss'=>'https://auth.example.test',
  'aud'=>'billing-api','iat'=>$now,'exp'=>$now+300],$key,'HS256',null,['typ'=>'nf-access+jwt']);
}
function verify(string $token,string $key): object {
 checkKey($key); $headers=new stdClass();
 $p=JWT::decode($token,new Key($key,'HS256'),$headers); $now=time();
 if(($headers->typ??null)!=='nf-access+jwt'||($p->iss??null)!=='https://auth.example.test'
  ||($p->aud??null)!=='billing-api'||!is_string($p->sub??null)||$p->sub===''
  ||!is_string($p->tenant??null)||$p->tenant===''
  ||!is_int($p->iat??null)||!is_int($p->exp??null)||$p->iat>$now||$p->exp<=$now
  ||$p->exp<=$p->iat||$p->exp-$p->iat>300) throw new RuntimeException('Invalid access profile');
 return $p;
}
function canReadInvoice(object $actor,object $invoice): bool {
 return !empty($actor->sub)&&!empty($actor->tenant)&&$actor->sub===($invoice->owner??null)&&$actor->tenant===($invoice->tenant??null);
}
if(realpath($_SERVER['SCRIPT_FILENAME']??'')===__FILE__){
 $key=random_bytes(32);$actor=verify(issue('user-7','acme',$key),$key);
 echo json_encode(['authenticated'=>true,'subject'=>$actor->sub,'sameTenantInvoice'=>canReadInvoice($actor,(object)['owner'=>'user-7','tenant'=>'acme'])]).PHP_EOL;
}

# Choose ONE language; extract the ZIP into a new folder first.
# JavaScript / Node.js 22+
npm ci
npm test

# Python 3.9+ (macOS/Linux; Windows: .venv\Scripts\activate)
python3 -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements.txt
python -m unittest test_python.py
python jwt_example.py

# PHP 8.1+ and Composer
composer install --no-plugins --no-scripts
php test_php.php
php jwt_example.php

Act as a senior application engineer. First inspect the existing authentication
framework and explain whether an opaque server session or a JWT is appropriate.
Do not replace a working authentication system just to introduce JWTs.
If JWT access tokens are justified, implement the provided local access profile:
pinned HS256, at least 32 random key bytes, issuer https://auth.example.test,
audience billing-api, typ nf-access+jwt, non-empty sub and tenant, required
integer iat and exp, maximum lifetime 300 seconds and no future issued-at.
Use jose, PyJWT or PHP-JWT according to the actual project language.
Issue tokens only after trusted authentication. Enforce object ownership and
tenant membership in server authorization on every relevant request.
Never derive a signing key, accepted algorithm or tenant from request JSON.
Propose browser storage, CSRF protection, logout/revocation and key rotation
for this application before coding. Do not log tokens or secrets.
Add negative tests for bad signatures, expiration, missing claims, wrong issuer,
audience and token type, another tenant and a non-owner. Report real test output.
Stop before deployment.

Requirement: reject a token intended for another API.
Evidence: verify() supplies audience="billing-api".
Negative test: a correctly signed token with aud="other-api" is rejected.
Remaining gap: verify the real HTTP middleware invokes verify() on every route.
This example is an expected review format, not a certification.

Review this local JWT implementation independently. Produce a table with:
requirement, exact code location, positive test, negative test and remaining gap.
Explain the difference between decoding, signature verification and authorization.
Check key entropy, algorithm pinning, required claims, issuer/audience/type,
short lifetime, server-derived identity, browser storage and token revocation.
Report confirmed defects separately from unverified integration assumptions.
Use only synthetic tokens. Never ask me to paste production credentials.