update
This commit is contained in:
PTA
672
app/Models/CompteModel.php
Normal file
672
app/Models/CompteModel.php
Normal file
@@ -0,0 +1,672 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace App\Models;
|
||||
|
||||
use App\Core\Access;
|
||||
use DomainException;
|
||||
|
||||
/**
|
||||
* Comptes d'accès et jetons (V7.11).
|
||||
*
|
||||
* PRINCIPE : chaque utilisateur — agent, responsable de lieu, Service Enfance,
|
||||
* DSI — reçoit un jeton unique tiré au sort par le serveur. Il n'y a AUCUN mot
|
||||
* de passe dans PTA : rien à choisir, rien à renouveler, rien à ressaisir sur
|
||||
* un post-it.
|
||||
*
|
||||
* Le jeton n'est stocké NULLE PART en clair. La base garde son empreinte
|
||||
* SHA-256 et ses onze premiers caractères, qui servent uniquement à reconnaître
|
||||
* une ligne dans la liste de la page DSI. Conséquence directe, à assumer dans
|
||||
* l'interface : un jeton n'est affiché QU'UNE FOIS, au moment où il est produit.
|
||||
* Perdu, il ne se retrouve pas — il se régénère, ce qui invalide le précédent.
|
||||
*
|
||||
* Pourquoi SHA-256 sans sel, alors qu'on hache d'ordinaire les secrets avec
|
||||
* password_hash() : un jeton PTA est tiré sur 120 bits d'entropie par le
|
||||
* serveur, il n'est pas devinable par dictionnaire comme le serait un mot de
|
||||
* passe choisi par un humain. Le durcissement lent de password_hash() n'apporte
|
||||
* donc rien ici, alors qu'il interdirait de retrouver le compte en une seule
|
||||
* lecture d'index — il faudrait comparer le jeton présenté à CHAQUE compte.
|
||||
*/
|
||||
final class CompteModel extends BaseModel
|
||||
{
|
||||
/**
|
||||
* Alphabet des jetons : chiffres et majuscules, MOINS I, O, 0 et 1.
|
||||
* Les jetons sont recopiés à la main depuis un courriel ou un papier : les
|
||||
* caractères qu'on confond à la lecture en sont exclus.
|
||||
*/
|
||||
private const ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
|
||||
|
||||
/** 4 groupes de 6 caractères = 24 tirages sur 32 valeurs, soit 120 bits. */
|
||||
private const GROUPES = 4;
|
||||
private const TAILLE_GROUPE = 6;
|
||||
|
||||
/**
|
||||
* Longueur minimale d'un mot de passe. La longueur prime sur la complexité :
|
||||
* imposer une majuscule et un chiffre produit « Motdepasse1 », pas un secret.
|
||||
*/
|
||||
public const MOT_DE_PASSE_MINIMUM = 12;
|
||||
|
||||
/**
|
||||
* Longueur maximale, imposée par bcrypt : password_hash() ne considère que
|
||||
* les 72 PREMIERS OCTETS et ignore le reste EN SILENCE. Refuser au-delà vaut
|
||||
* mieux que laisser croire qu'une phrase de 90 caractères protège mieux
|
||||
* qu'un préfixe de 72.
|
||||
*/
|
||||
public const MOT_DE_PASSE_MAXIMUM = 72;
|
||||
|
||||
/**
|
||||
* Empreinte du jeton d'installation posé par la migration V7.11.
|
||||
* Sert uniquement à afficher l'alerte « ce jeton est public, régénérez-le »
|
||||
* tant que le compte DSI initial n'a pas été renouvelé.
|
||||
*/
|
||||
public const EMPREINTE_INSTALLATION = '7f61ffc8efed4ed46d581a98286115ad03bb0122ffc70db3398584348aca431d';
|
||||
|
||||
/**
|
||||
* Vérifie un jeton présenté à la connexion.
|
||||
*
|
||||
* La vue ne renvoie le compte que s'il est actif ET que l'identité derrière
|
||||
* lui l'est aussi : un agent désactivé ne peut plus entrer, même avec un
|
||||
* jeton techniquement valide.
|
||||
*
|
||||
* @return array<string, mixed>|null Le compte, ou null si le jeton est
|
||||
* inconnu, révoqué ou porté par une
|
||||
* identité inactive.
|
||||
*/
|
||||
public function authentifier(string $jeton): ?array
|
||||
{
|
||||
$jeton = self::normaliser($jeton);
|
||||
if ($jeton === '') {
|
||||
return null;
|
||||
}
|
||||
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT * FROM v_acces_compte
|
||||
WHERE jeton_empreinte = :empreinte AND actif = 1 AND identite_active = 1
|
||||
LIMIT 1'
|
||||
);
|
||||
$stmt->execute(['empreinte' => self::empreinte($jeton)]);
|
||||
|
||||
return $stmt->fetch() ?: null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Relit un compte par son identifiant, pour la SECONDE étape de connexion.
|
||||
*
|
||||
* Les mêmes conditions qu'à l'authentification par jeton s'appliquent — actif
|
||||
* et identité active : entre la saisie du jeton et celle du mot de passe, la
|
||||
* DSI a pu révoquer le compte. La ligne est renvoyée brute, avec son hachage,
|
||||
* là où trouver() la met en forme pour l'API et le retire.
|
||||
*
|
||||
* @return array<string, mixed>|null
|
||||
*/
|
||||
public function trouverPourAuthentification(int $compteId): ?array
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT * FROM v_acces_compte
|
||||
WHERE id_compte = :id AND actif = 1 AND identite_active = 1
|
||||
LIMIT 1'
|
||||
);
|
||||
$stmt->execute(['id' => $compteId]);
|
||||
|
||||
return $stmt->fetch() ?: null;
|
||||
}
|
||||
|
||||
/** Horodate une connexion réussie et incrémente son compteur. */
|
||||
public function enregistrerConnexion(int $compteId): void
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'UPDATE compte_acces
|
||||
SET date_derniere_connexion = NOW(),
|
||||
nombre_connexions = nombre_connexions + 1
|
||||
WHERE id_compte = :id'
|
||||
);
|
||||
$stmt->execute(['id' => $compteId]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Liste des comptes pour la page DSI.
|
||||
*
|
||||
* @param array<string, mixed> $filtres role, actif (0|1), q (texte libre).
|
||||
*
|
||||
* @return array<int, array<string, mixed>>
|
||||
*/
|
||||
public function lister(array $filtres = []): array
|
||||
{
|
||||
$conditions = [];
|
||||
$params = [];
|
||||
|
||||
$role = (string) ($filtres['role'] ?? '');
|
||||
if ($role !== '') {
|
||||
$conditions[] = 'role = :role';
|
||||
$params['role'] = $role;
|
||||
}
|
||||
|
||||
if (isset($filtres['actif']) && $filtres['actif'] !== '') {
|
||||
$conditions[] = 'actif = :actif';
|
||||
$params['actif'] = (int) $filtres['actif'];
|
||||
}
|
||||
|
||||
$recherche = trim((string) ($filtres['q'] ?? ''));
|
||||
if ($recherche !== '') {
|
||||
$conditions[] = '(identite_libelle LIKE :q OR libelle LIKE :q OR matricule LIKE :q OR jeton_prefixe LIKE :q)';
|
||||
$params['q'] = '%' . $recherche . '%';
|
||||
}
|
||||
|
||||
$where = $conditions === [] ? '' : ' WHERE ' . implode(' AND ', $conditions);
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT id_compte, role, libelle, identite_libelle, identite_active, id_agent, id_structure,
|
||||
matricule, structure_nom, jeton_prefixe, jeton_empreinte, actif, commentaire,
|
||||
date_creation, date_rotation, date_derniere_connexion, nombre_connexions,
|
||||
mot_de_passe_requis, mot_de_passe_defini, date_mot_de_passe
|
||||
FROM v_acces_compte' . $where . '
|
||||
ORDER BY FIELD(role, \'DSI\', \'SERVICE_ENFANCE\', \'RESPONSABLE_STRUCTURE\', \'AGENT\'), identite_libelle'
|
||||
);
|
||||
$stmt->execute($params);
|
||||
|
||||
return array_map(
|
||||
fn (array $ligne): array => $this->presenter($ligne),
|
||||
$stmt->fetchAll()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Un compte par son identifiant.
|
||||
*
|
||||
* @return array<string, mixed>|null
|
||||
*/
|
||||
public function trouver(int $compteId): ?array
|
||||
{
|
||||
$stmt = $this->pdo->prepare('SELECT * FROM v_acces_compte WHERE id_compte = :id LIMIT 1');
|
||||
$stmt->execute(['id' => $compteId]);
|
||||
$compte = $stmt->fetch();
|
||||
|
||||
return $compte === false ? null : $this->presenter($compte);
|
||||
}
|
||||
|
||||
/**
|
||||
* Identités actives encore dépourvues de compte.
|
||||
*
|
||||
* @return array<int, array<string, mixed>>
|
||||
*/
|
||||
public function manquants(): array
|
||||
{
|
||||
$stmt = $this->pdo->query(
|
||||
'SELECT role, id_agent, id_structure, libelle FROM v_acces_compte_manquant ORDER BY role, libelle'
|
||||
);
|
||||
|
||||
return $stmt->fetchAll();
|
||||
}
|
||||
|
||||
/**
|
||||
* Crée un compte et retourne le jeton EN CLAIR — unique occasion de le lire.
|
||||
*
|
||||
* @return array{compte: array<string, mixed>, jeton: string}
|
||||
*
|
||||
* @throws DomainException Si le rôle, l'identité ou l'unicité ne conviennent pas.
|
||||
*/
|
||||
public function creer(
|
||||
string $role,
|
||||
?int $agentId,
|
||||
?int $structureId,
|
||||
string $libelle,
|
||||
?string $commentaire = null
|
||||
): array {
|
||||
$role = strtoupper(trim($role));
|
||||
$libelle = trim($libelle);
|
||||
|
||||
if (!in_array($role, [Access::ROLE_AGENT, Access::ROLE_RESPONSABLE, Access::ROLE_SERVICE, Access::ROLE_DSI], true)) {
|
||||
throw new DomainException('Rôle inconnu.');
|
||||
}
|
||||
|
||||
// Un compte AGENT ou RESPONSABLE_STRUCTURE tire son périmètre de son
|
||||
// identité : sans identité, la session n'aurait aucun lieu ni aucun
|
||||
// agent à borner. Les deux autres rôles n'ont pas de périmètre à borner.
|
||||
if ($role === Access::ROLE_AGENT) {
|
||||
$structureId = null;
|
||||
if ($agentId === null) {
|
||||
throw new DomainException('Choisissez l’agent titulaire du jeton.');
|
||||
}
|
||||
$libelle = $this->libelleAgent($agentId);
|
||||
} elseif ($role === Access::ROLE_RESPONSABLE) {
|
||||
$agentId = null;
|
||||
if ($structureId === null) {
|
||||
throw new DomainException('Choisissez le lieu d’affectation titulaire du jeton.');
|
||||
}
|
||||
$libelle = $this->libelleStructure($structureId);
|
||||
} else {
|
||||
$agentId = null;
|
||||
$structureId = null;
|
||||
if ($libelle === '') {
|
||||
throw new DomainException('Indiquez le nom du titulaire du jeton.');
|
||||
}
|
||||
}
|
||||
|
||||
$jeton = self::genererJeton();
|
||||
$stmt = $this->pdo->prepare(
|
||||
'INSERT INTO compte_acces (role, libelle, id_agent, id_structure, jeton_empreinte, jeton_prefixe, commentaire)
|
||||
VALUES (:role, :libelle, :id_agent, :id_structure, :empreinte, :prefixe, :commentaire)'
|
||||
);
|
||||
|
||||
try {
|
||||
$stmt->execute([
|
||||
'role' => $role,
|
||||
'libelle' => mb_substr($libelle, 0, 180),
|
||||
'id_agent' => $agentId,
|
||||
'id_structure' => $structureId,
|
||||
'empreinte' => self::empreinte($jeton),
|
||||
'prefixe' => self::prefixe($jeton),
|
||||
'commentaire' => $commentaire !== null && trim($commentaire) !== ''
|
||||
? mb_substr(trim($commentaire), 0, 255)
|
||||
: null,
|
||||
]);
|
||||
} catch (\PDOException $e) {
|
||||
// 23000 = violation de contrainte : les index uniques sur id_agent et
|
||||
// id_structure garantissent un seul compte par identité.
|
||||
if ($e->getCode() === '23000') {
|
||||
throw new DomainException('Cette identité possède déjà un compte d’accès.');
|
||||
}
|
||||
throw $e;
|
||||
}
|
||||
|
||||
$compte = $this->trouver((int) $this->pdo->lastInsertId());
|
||||
|
||||
return ['compte' => $compte ?? [], 'jeton' => $jeton];
|
||||
}
|
||||
|
||||
/**
|
||||
* Régénère le jeton d'un compte : l'ancien cesse immédiatement de
|
||||
* fonctionner, y compris pour les sessions ouvertes — Access relit le compte
|
||||
* à chaque requête, mais c'est l'empreinte qui a changé, pas le compte.
|
||||
*
|
||||
* @return string Le nouveau jeton, en clair, à transmettre au titulaire.
|
||||
*
|
||||
* @throws DomainException Si le compte n'existe pas.
|
||||
*/
|
||||
public function regenererJeton(int $compteId): string
|
||||
{
|
||||
if ($this->trouver($compteId) === null) {
|
||||
throw new DomainException('Compte introuvable.');
|
||||
}
|
||||
|
||||
$jeton = self::genererJeton();
|
||||
$stmt = $this->pdo->prepare(
|
||||
'UPDATE compte_acces
|
||||
SET jeton_empreinte = :empreinte,
|
||||
jeton_prefixe = :prefixe,
|
||||
date_rotation = NOW()
|
||||
WHERE id_compte = :id'
|
||||
);
|
||||
$stmt->execute([
|
||||
'empreinte' => self::empreinte($jeton),
|
||||
'prefixe' => self::prefixe($jeton),
|
||||
'id' => $compteId,
|
||||
]);
|
||||
|
||||
return $jeton;
|
||||
}
|
||||
|
||||
/**
|
||||
* Active ou désactive un compte.
|
||||
*
|
||||
* @throws DomainException Si l'opération laisserait l'application sans
|
||||
* aucune DSI en état de se connecter.
|
||||
*/
|
||||
public function definirActif(int $compteId, bool $actif): void
|
||||
{
|
||||
$compte = $this->trouver($compteId);
|
||||
if ($compte === null) {
|
||||
throw new DomainException('Compte introuvable.');
|
||||
}
|
||||
|
||||
if (!$actif) {
|
||||
$this->assurerDerniereDsi($compte);
|
||||
}
|
||||
|
||||
$stmt = $this->pdo->prepare('UPDATE compte_acces SET actif = :actif WHERE id_compte = :id');
|
||||
$stmt->execute(['actif' => $actif ? 1 : 0, 'id' => $compteId]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Supprime définitivement un compte. Les traces qu'il a laissées dans le
|
||||
* journal SURVIVENT : la clé étrangère est en ON DELETE SET NULL et le
|
||||
* libellé de l'acteur y est figé.
|
||||
*
|
||||
* @throws DomainException Si c'est le dernier accès DSI actif.
|
||||
*/
|
||||
public function supprimer(int $compteId): void
|
||||
{
|
||||
$compte = $this->trouver($compteId);
|
||||
if ($compte === null) {
|
||||
throw new DomainException('Compte introuvable.');
|
||||
}
|
||||
|
||||
$this->assurerDerniereDsi($compte);
|
||||
|
||||
$stmt = $this->pdo->prepare('DELETE FROM compte_acces WHERE id_compte = :id');
|
||||
$stmt->execute(['id' => $compteId]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Génère en une passe un jeton pour chaque agent et chaque lieu actif qui
|
||||
* n'en a pas. C'est l'outil de MISE EN SERVICE : sans lui, il faudrait créer
|
||||
* les comptes un par un avant que quiconque puisse se connecter.
|
||||
*
|
||||
* @return array<int, array{role: string, libelle: string, jeton: string, id_compte: int}>
|
||||
* Les jetons produits, en clair. Cette liste est la seule occasion
|
||||
* de les lire : elle doit être distribuée puis refermée.
|
||||
*/
|
||||
public function genererManquants(): array
|
||||
{
|
||||
$produits = [];
|
||||
|
||||
foreach ($this->manquants() as $identite) {
|
||||
$role = (string) $identite['role'];
|
||||
$agentId = $identite['id_agent'] !== null ? (int) $identite['id_agent'] : null;
|
||||
$structureId = $identite['id_structure'] !== null ? (int) $identite['id_structure'] : null;
|
||||
|
||||
$resultat = $this->creer($role, $agentId, $structureId, (string) $identite['libelle']);
|
||||
$produits[] = [
|
||||
'id_compte' => (int) ($resultat['compte']['id_compte'] ?? 0),
|
||||
'role' => $role,
|
||||
'libelle' => (string) ($resultat['compte']['identite_libelle'] ?? $identite['libelle']),
|
||||
'jeton' => $resultat['jeton'],
|
||||
];
|
||||
}
|
||||
|
||||
return $produits;
|
||||
}
|
||||
|
||||
/** Nombre de comptes DSI actifs, hors compte $exclu. */
|
||||
public function compterDsiActives(?int $exclu = null): int
|
||||
{
|
||||
// Zéro plutôt que NULL : PDO tourne sans émulation de requêtes préparées,
|
||||
// un même paramètre nommé ne peut donc pas être répété dans la requête,
|
||||
// et aucun compte ne porte l'identifiant 0.
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT COUNT(*) FROM v_acces_compte
|
||||
WHERE role = :role AND actif = 1 AND identite_active = 1
|
||||
AND id_compte <> :exclu'
|
||||
);
|
||||
$stmt->execute(['role' => Access::ROLE_DSI, 'exclu' => $exclu ?? 0]);
|
||||
|
||||
return (int) $stmt->fetchColumn();
|
||||
}
|
||||
|
||||
/**
|
||||
* Vrai tant qu'un compte actif porte encore le jeton d'installation, dont
|
||||
* l'empreinte est écrite en clair dans la migration versionnée — donc
|
||||
* publique. L'interface DSI s'en sert pour alerter en rouge.
|
||||
*
|
||||
* La question est posée à la base plutôt qu'à la liste affichée : un filtre
|
||||
* de recherche ne doit pas faire disparaître l'alerte.
|
||||
*/
|
||||
public function installationEnCours(): bool
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT 1 FROM compte_acces
|
||||
WHERE jeton_empreinte = :empreinte AND actif = 1
|
||||
LIMIT 1'
|
||||
);
|
||||
$stmt->execute(['empreinte' => self::EMPREINTE_INSTALLATION]);
|
||||
|
||||
return $stmt->fetchColumn() !== false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ce compte réclame-t-il un mot de passe en plus de son jeton ?
|
||||
*
|
||||
* La règle vit dans la vue (`mot_de_passe_requis`), pas ici : la liste des
|
||||
* rôles concernés se modifie en SQL, comme le reste des droits depuis la
|
||||
* V7.8.
|
||||
*
|
||||
* @param array<string, mixed> $compte Ligne de v_acces_compte.
|
||||
*/
|
||||
public static function exigeMotDePasse(array $compte): bool
|
||||
{
|
||||
return (int) ($compte['mot_de_passe_requis'] ?? 0) === 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Le titulaire a-t-il déjà choisi son mot de passe ?
|
||||
* Faux à la création du compte comme après une réinitialisation par la DSI :
|
||||
* la connexion suivante impose alors d'en définir un.
|
||||
*
|
||||
* @param array<string, mixed> $compte Ligne de v_acces_compte.
|
||||
*/
|
||||
public static function motDePasseDefini(array $compte): bool
|
||||
{
|
||||
return (int) ($compte['mot_de_passe_defini'] ?? 0) === 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie le mot de passe présenté, et remet l'empreinte à niveau si PHP a
|
||||
* changé d'algorithme par défaut depuis sa création.
|
||||
*
|
||||
* @param array<string, mixed> $compte Ligne de v_acces_compte, avec son hachage.
|
||||
*/
|
||||
public function verifierMotDePasse(array $compte, string $motDePasse): bool
|
||||
{
|
||||
$hash = (string) ($compte['mot_de_passe_hash'] ?? '');
|
||||
if ($hash === '' || !password_verify($motDePasse, $hash)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (password_needs_rehash($hash, PASSWORD_DEFAULT)) {
|
||||
$this->enregistrerHash((int) $compte['id_compte'], password_hash($motDePasse, PASSWORD_DEFAULT));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enregistre le mot de passe choisi par le titulaire.
|
||||
*
|
||||
* @throws DomainException Si la politique n'est pas respectée.
|
||||
*/
|
||||
public function definirMotDePasse(int $compteId, string $motDePasse, string $confirmation): void
|
||||
{
|
||||
if ($motDePasse !== $confirmation) {
|
||||
throw new DomainException('Les deux mots de passe saisis ne sont pas identiques.');
|
||||
}
|
||||
|
||||
$this->assurerPolitique($motDePasse);
|
||||
$this->enregistrerHash($compteId, password_hash($motDePasse, PASSWORD_DEFAULT));
|
||||
}
|
||||
|
||||
/**
|
||||
* Efface le mot de passe d'un compte : la DSI ne le remplace pas, elle le
|
||||
* RETIRE. Le titulaire en choisira un nouveau à sa prochaine connexion, avec
|
||||
* son jeton — la DSI ne connaît donc jamais le mot de passe de personne.
|
||||
*
|
||||
* @throws DomainException Si le compte n'existe pas ou n'a pas de mot de passe.
|
||||
*/
|
||||
public function reinitialiserMotDePasse(int $compteId): array
|
||||
{
|
||||
$compte = $this->trouver($compteId);
|
||||
if ($compte === null) {
|
||||
throw new DomainException('Compte introuvable.');
|
||||
}
|
||||
if (!$compte['mot_de_passe_requis']) {
|
||||
throw new DomainException('Ce type de compte n’utilise pas de mot de passe.');
|
||||
}
|
||||
|
||||
$stmt = $this->pdo->prepare(
|
||||
'UPDATE compte_acces SET mot_de_passe_hash = NULL, date_mot_de_passe = NULL WHERE id_compte = :id'
|
||||
);
|
||||
$stmt->execute(['id' => $compteId]);
|
||||
|
||||
return $compte;
|
||||
}
|
||||
|
||||
/**
|
||||
* Politique de mot de passe : la longueur, et rien d'autre.
|
||||
*
|
||||
* @throws DomainException Si le mot de passe est trop court, trop long ou
|
||||
* trop proche du jeton.
|
||||
*/
|
||||
private function assurerPolitique(string $motDePasse): void
|
||||
{
|
||||
// Mesure en OCTETS et non en caractères : c'est la limite de bcrypt, et
|
||||
// un accent compte pour deux.
|
||||
$longueur = strlen($motDePasse);
|
||||
|
||||
if ($longueur < self::MOT_DE_PASSE_MINIMUM) {
|
||||
throw new DomainException(sprintf(
|
||||
'Le mot de passe doit contenir au moins %d caractères.',
|
||||
self::MOT_DE_PASSE_MINIMUM
|
||||
));
|
||||
}
|
||||
if ($longueur > self::MOT_DE_PASSE_MAXIMUM) {
|
||||
throw new DomainException(sprintf(
|
||||
'Le mot de passe ne peut pas dépasser %d caractères.',
|
||||
self::MOT_DE_PASSE_MAXIMUM
|
||||
));
|
||||
}
|
||||
if (str_starts_with(self::normaliser($motDePasse), 'PTA-')) {
|
||||
// Recopier son jeton dans le champ mot de passe ramènerait les deux
|
||||
// facteurs à un seul secret.
|
||||
throw new DomainException('Le mot de passe ne peut pas être votre jeton d’accès.');
|
||||
}
|
||||
}
|
||||
|
||||
/** Écrit une empreinte de mot de passe et horodate le changement. */
|
||||
private function enregistrerHash(int $compteId, string $hash): void
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'UPDATE compte_acces
|
||||
SET mot_de_passe_hash = :hash, date_mot_de_passe = NOW()
|
||||
WHERE id_compte = :id'
|
||||
);
|
||||
$stmt->execute(['hash' => $hash, 'id' => $compteId]);
|
||||
}
|
||||
|
||||
/** Un jeton en clair, prêt à être transmis : « PTA-XXXXXX-XXXXXX-… ». */
|
||||
public static function genererJeton(): string
|
||||
{
|
||||
$groupes = [];
|
||||
for ($groupe = 0; $groupe < self::GROUPES; $groupe++) {
|
||||
$caracteres = '';
|
||||
for ($index = 0; $index < self::TAILLE_GROUPE; $index++) {
|
||||
// random_int() et non rand() : le tirage doit être imprévisible.
|
||||
$caracteres .= self::ALPHABET[random_int(0, strlen(self::ALPHABET) - 1)];
|
||||
}
|
||||
$groupes[] = $caracteres;
|
||||
}
|
||||
|
||||
return 'PTA-' . implode('-', $groupes);
|
||||
}
|
||||
|
||||
/** Empreinte stockée en base. */
|
||||
public static function empreinte(string $jeton): string
|
||||
{
|
||||
return hash('sha256', self::normaliser($jeton));
|
||||
}
|
||||
|
||||
/**
|
||||
* Nettoie un jeton saisi à la main : espaces, casse et espaces insécables
|
||||
* collés par un copier-coller depuis un courriel.
|
||||
*/
|
||||
public static function normaliser(string $jeton): string
|
||||
{
|
||||
$jeton = str_replace(["\u{00A0}", ' ', "\t", "\r", "\n"], '', $jeton);
|
||||
|
||||
return strtoupper(trim($jeton));
|
||||
}
|
||||
|
||||
/** Début du jeton, conservé en base pour l'identifier sans le révéler. */
|
||||
private static function prefixe(string $jeton): string
|
||||
{
|
||||
return mb_substr(self::normaliser($jeton), 0, 11);
|
||||
}
|
||||
|
||||
/**
|
||||
* Met en forme une ligne de v_acces_compte pour l'API : types corrects,
|
||||
* empreinte remplacée par le seul drapeau qui intéresse l'interface.
|
||||
*
|
||||
* @param array<string, mixed> $ligne
|
||||
*
|
||||
* @return array<string, mixed>
|
||||
*/
|
||||
private function presenter(array $ligne): array
|
||||
{
|
||||
return [
|
||||
'id_compte' => (int) $ligne['id_compte'],
|
||||
'role' => (string) $ligne['role'],
|
||||
'libelle' => (string) $ligne['libelle'],
|
||||
'identite_libelle' => (string) ($ligne['identite_libelle'] ?? $ligne['libelle']),
|
||||
'identite_active' => (int) ($ligne['identite_active'] ?? 1) === 1,
|
||||
'id_agent' => $ligne['id_agent'] !== null ? (int) $ligne['id_agent'] : null,
|
||||
'id_structure' => $ligne['id_structure'] !== null ? (int) $ligne['id_structure'] : null,
|
||||
'matricule' => $ligne['matricule'] ?? null,
|
||||
'structure_nom' => $ligne['structure_nom'] ?? null,
|
||||
'jeton_prefixe' => (string) $ligne['jeton_prefixe'],
|
||||
// Le jeton d'installation est public : l'interface doit pouvoir
|
||||
// crier tant qu'il n'a pas été remplacé.
|
||||
'jeton_installation' => (string) $ligne['jeton_empreinte'] === self::EMPREINTE_INSTALLATION,
|
||||
'actif' => (int) $ligne['actif'] === 1,
|
||||
// Le hachage ne sort jamais du serveur : l'interface n'a besoin que
|
||||
// de savoir si un mot de passe est exigé et s'il a été choisi.
|
||||
'mot_de_passe_requis' => (int) ($ligne['mot_de_passe_requis'] ?? 0) === 1,
|
||||
'mot_de_passe_defini' => (int) ($ligne['mot_de_passe_defini'] ?? 0) === 1,
|
||||
'date_mot_de_passe' => $ligne['date_mot_de_passe'] ?? null,
|
||||
'commentaire' => $ligne['commentaire'] ?? null,
|
||||
'date_creation' => $ligne['date_creation'],
|
||||
'date_rotation' => $ligne['date_rotation'],
|
||||
'date_derniere_connexion' => $ligne['date_derniere_connexion'],
|
||||
'nombre_connexions' => (int) $ligne['nombre_connexions'],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Interdit de se couper soi-même la branche : le dernier accès DSI actif ne
|
||||
* peut être ni désactivé ni supprimé. Sans ce garde-fou, il faudrait rejouer
|
||||
* la migration pour récupérer la main.
|
||||
*
|
||||
* @param array<string, mixed> $compte
|
||||
*/
|
||||
private function assurerDerniereDsi(array $compte): void
|
||||
{
|
||||
if ((string) $compte['role'] !== Access::ROLE_DSI || !$compte['actif']) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($this->compterDsiActives((int) $compte['id_compte']) === 0) {
|
||||
throw new DomainException(
|
||||
'Ce compte est le dernier accès DSI actif : créez-en un autre avant de le retirer.'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/** Libellé d'un agent actif, ou refus si l'agent n'existe pas ou est inactif. */
|
||||
private function libelleAgent(int $agentId): string
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT CONCAT(prenom, \' \', nom) FROM v_acces_identite_agent WHERE id_agent = :id LIMIT 1'
|
||||
);
|
||||
$stmt->execute(['id' => $agentId]);
|
||||
$libelle = $stmt->fetchColumn();
|
||||
|
||||
if ($libelle === false) {
|
||||
throw new DomainException('Agent introuvable ou inactif.');
|
||||
}
|
||||
|
||||
return (string) $libelle;
|
||||
}
|
||||
|
||||
/** Libellé d'un lieu actif, ou refus si le lieu n'existe pas ou est fermé. */
|
||||
private function libelleStructure(int $structureId): string
|
||||
{
|
||||
$stmt = $this->pdo->prepare(
|
||||
'SELECT nom FROM v_acces_identite_structure WHERE id_structure = :id LIMIT 1'
|
||||
);
|
||||
$stmt->execute(['id' => $structureId]);
|
||||
$libelle = $stmt->fetchColumn();
|
||||
|
||||
if ($libelle === false) {
|
||||
throw new DomainException('Lieu d’affectation introuvable ou inactif.');
|
||||
}
|
||||
|
||||
return (string) $libelle;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user