README

Module d'authentification JWT RS256 pour NilsFramework.
Tokens sécurisés avec clés RSA 4096 bits, sessions révocables en base de données.

📋 Table des matières

Installation
Générer les clés RSA
Configuration
Migration SQL
Intégration dans le routeur
Utilisation
Exceptions

Installation

composer require nilsframework/nils-auth

Générer les clés RSA

À faire une seule fois lors de l'installation :

php -r "
require 'vendor/autoload.php';
NilsAuth\AuthService::genererCles('keys');
"

Cela génère :

keys/
├── private.pem  ← chmod 600 (jamais committer)
└── public.pem   ← chmod 644

⚠️ Ajoutez keys/private.pem et keys/public.pem à votre .gitignore.

Configuration

Ajoutez dans Configuration/config.json :

{
    "auth": {
        "algorithm":           "RS256",
        "private_key_path":    "keys/private.pem",
        "public_key_path":     "keys/public.pem",
        "token_ttl":           3600,
        "refresh_token_ttl":   604800
    }
}

Clé	Description	Défaut
`algorithm`	Algorithme JWT	`RS256`
`private_key_path`	Chemin clé privée	`keys/private.pem`
`public_key_path`	Chemin clé publique	`keys/public.pem`
`token_ttl`	Durée du token (secondes)	`3600` (1h)
`refresh_token_ttl`	Durée du refresh token	`604800` (7j)

Migration SQL

mysql -u root -p ma_base < vendor/nilsframework/nils-auth/migrations/auth_tables.sql

Crée la table nils_sessions :

Colonne	Type	Description
`id`	BIGINT	Clé primaire
`utilisateur_id`	BIGINT	ID de l'utilisateur
`guard`	VARCHAR	Type : admin, utilisateur, tous
`token`	TEXT	Access token JWT
`refresh_token`	TEXT	Refresh token JWT
`expires_at`	DATETIME	Expiration du token
`refresh_expires_at`	DATETIME	Expiration du refresh
`ip`	VARCHAR	IP du client
`user_agent`	TEXT	User-Agent du client

Intégration dans le routeur

1. Dans core/Routeur.php — dans la méthode diriger(), avant l'injection des arguments :

// Lire l'attribut #[Auth] et vérifier le JWT
$refMethodAuth = new \ReflectionMethod($controller, $method);

foreach ($refMethodAuth->getAttributes() as $attr) {
    $instance = $attr->newInstance();

    if ($instance instanceof \NilsAuth\Auth) {
        $headers       = new \core\Headers($requete->headers);
        $requete->auth = \NilsAuth\AuthMiddleware::verifier($headers, $instance->guard);
        break;
    }
}

2. Dans core/ArgumentResolverRegistry.php — ajouter le resolver :

$this->resolvers = [
    new RequestResolver(),
    new BodyResolver(),
    new ParamsResolver(),
    new HeadersResolver(),
    new QueryResolver(),
    new \NilsAuth\AuthResolver(), // ← ajouter
];

Utilisation

Ouvrir une session

use NilsAuth\AuthService;

// Après vérification du mot de passe
$tokens = AuthService::ouvrirSession([
    'id'    => $user->id,
    'email' => $user->email,
    'role'  => $user->role,
    'guard' => 'admin', // ou 'utilisateur', 'tous'
]);

Response::json([
    'success'       => true,
    'token'         => $tokens['token'],
    'refresh_token' => $tokens['refresh_token'],
], 201);

Protéger une route

use core\Get;
use core\Post;
use NilsAuth\Auth;

class UserController
{
    // Tout token valide accepté
    #[Get('/profile'), Auth]
    public function profile(array $auth): void
    {
        $auth['id'];    // ID utilisateur
        $auth['email']; // Email
        $auth['role'];  // Rôle
        $auth['token']; // Token JWT brut
    }

    // Guard spécifique — admin uniquement
    #[Get('/admin/users'), Auth('admin')]
    public function adminUsers(array $auth): void
    {
        // Seuls les tokens avec guard='admin' sont acceptés
    }

    // Guard utilisateur
    #[Get('/mes-groupes'), Auth('utilisateur')]
    public function mesGroupes(array $auth): void
    {
        $groupes = Groupe::get(['utilisateur_id' => $auth['id']]);
        Response::succes(array_map(fn($g) => $g->toArray(), $groupes));
    }
}

Fermer une session

use NilsAuth\AuthService;
use NilsAuth\AuthMiddleware;

#[Post('/logout'), Auth]
public function logout(array $auth): void
{
    AuthService::fermerSession($auth['token']);
    Response::succes([], "Déconnexion réussie.");
}

Rafraîchir un token

use NilsAuth\AuthService;
use core\Body;

#[Post('/auth/refresh')]
public function refresh(Body $body): void
{
    $refreshToken = $body->getRefresh_token();

    if (!$refreshToken) {
        throw UnprocessableEntityException::unprocessableEntityException("Refresh token requis.");
    }

    $tokens = AuthService::rafraichirSession($refreshToken);

    Response::succes([
        'token'         => $tokens['token'],
        'refresh_token' => $tokens['refresh_token'],
    ], "Token rafraîchi.");
}

Requête avec le token

GET /profile HTTP/1.1
Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

Exceptions

Exception	Code	Déclenchée quand
`AuthException::tokenManquant()`	401	Header Authorization absent
`AuthException::tokenInvalide()`	401	Signature invalide ou token malformé
`AuthException::tokenExpire()`	401	Token expiré
`AuthException::tokenRevoque()`	401	Session révoquée en DB
`AuthException::guardIncompatible()`	403	Guard du token ≠ guard requis
`AuthException::cleIntrouvable()`	500	Fichier PEM introuvable

Toutes étendent HttpException — capturées automatiquement par GestionnaireErreurs.

Algorithme RS256

Propriété	Valeur
Algorithme	RSA-SHA256
Taille clé	4096 bits
Clé privée	Signature uniquement (serveur)
Clé publique	Vérification (peut être partagée)
Sécurité	Asymétrique — la clé publique ne peut pas signer

nilsframework / nils-auth

Maintainers

Package info

Statistics

Security