alpinux-portail/web/inc/keycloak.php
Cédrix 5682052423
Fiche d'un compte AlpID dans la console d'administration (#5)
web/admin/compte.php?id=<uuid> montre d'un coup d'œil ce qui explique un
compte « reconnu, mais sans aucun droit » : activé ou non, adresse vérifiée,
actions requises, OTP, groupes, rôles realm et client — directs et effectifs,
ceux hérités d'un groupe compris —, sessions ouvertes. Un encadré « En bref »
pointe les rôles de ROLES_SURVEILLES (par défaut messagerie-admin et
messagerie-mailperso sur le client messagerie). L'identifiant est validé comme
UUID ; dans la liste des membres, nom et identifiant mènent à la fiche.

Les erreurs de l'API d'administration ne sont plus muettes : _kc_attendre()
lève une exception qui, pour un 403, nomme le rôle manquant au compte de
service et l'endroit où l'attribuer. Pour un compte du realm master, ces
rôles sont ceux du client « <realm>-realm » (« master-realm » en production),
l'équivalent de realm-management. kc_list_users(), kc_list_groups() et
kc_group_members() ne renvoient plus [] en cas d'erreur ; les écrans membres,
groupes et services affichent le message. Services refuse d'enregistrer quand
les groupes n'ont pu être lus, plutôt que d'effacer les groupes requis.

La liste des membres ne fait plus un appel par compte pour ses groupes : elle
lit les membres de chaque groupe (kc_noms_groupes_par_compte()).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V2csyno8m71DJFKYM1vgzV
2026-10-31 08:55:27 +01:00

366 lines
16 KiB
PHP

<?php
require_once __DIR__ . '/config.php';
class KcUserExistsException extends RuntimeException {}
function _kc_admin_token(): string {
static $cache = null;
if ($cache && $cache['expires'] > time()) return $cache['token'];
$ch = curl_init(ALPID_BASE . '/realms/master/protocol/openid-connect/token');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query([
'grant_type' => 'client_credentials',
'client_id' => KC_SERVICE_CLIENT_ID,
'client_secret' => KC_SERVICE_CLIENT_SECRET,
]),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 10,
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$erreur = curl_error($ch);
curl_close($ch);
if ($status === 0) {
throw new RuntimeException("Keycloak injoignable pour obtenir le jeton du compte de service : $erreur", 0);
}
if ($status === 400 || $status === 401) {
throw new RuntimeException('Le compte de service « ' . KC_SERVICE_CLIENT_ID . ' » est refusé par Keycloak'
. " ($status) : vérifier KC_SERVICE_CLIENT_SECRET dans le .env, et que « Service accounts roles »"
. ' est coché sur ce client dans le realm master.', $status);
}
if ($status !== 200) {
throw new RuntimeException("Authentification Keycloak Admin échouée ($status)", $status);
}
$data = json_decode($body, true);
$cache = ['token' => $data['access_token'], 'expires' => time() + $data['expires_in'] - 10];
return $cache['token'];
}
function _kc_request(string $method, string $path, mixed $body = null): array {
$url = KC_ADMIN_BASE . $path;
$token = _kc_admin_token();
$headers = ["Authorization: Bearer $token", "Content-Type: application/json"];
$ch = curl_init($url);
curl_setopt_array($ch, [
CURLOPT_CUSTOMREQUEST => $method,
CURLOPT_HTTPHEADER => $headers,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 15,
CURLOPT_HEADER => true,
]);
if ($body !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
}
$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$erreur = curl_error($ch);
curl_close($ch);
$response = is_string($response) ? $response : '';
$resp_headers = substr($response, 0, $header_size);
$resp_body = substr($response, $header_size);
return ['status' => $status, 'headers' => $resp_headers, 'body' => $resp_body, 'erreur' => $erreur];
}
// ── Erreurs de l'API d'administration ─────────────────────────────────
// Le compte de service vit dans le realm master. Ses droits sur le realm
// administré sont les rôles du client « <realm>-realm » du realm master
// (« master-realm » quand on administre master lui-même) : c'est là que
// Keycloak range, pour un compte de master, l'équivalent des rôles
// realm-management (view-users, manage-users, view-events, view-clients…).
function kc_client_droits(): string {
return ALPID_REALM . '-realm';
}
// Vérifie la réponse d'un appel et la décode. En cas d'échec, lève une
// RuntimeException dont le message dit quoi faire — en nommant le rôle
// manquant pour un 403 — et dont le code est le statut HTTP.
function _kc_attendre(array $resp, string $geste, string $role, int ...$attendus): mixed {
$attendus = $attendus ?: [200];
$status = $resp['status'];
if (in_array($status, $attendus, true)) {
return $resp['body'] === '' ? null : json_decode($resp['body'], true);
}
$detail = json_decode($resp['body'], true);
$detail = is_array($detail) ? ($detail['errorMessage'] ?? $detail['error_description'] ?? $detail['error'] ?? '') : '';
$detail = is_string($detail) && $detail !== '' ? " Keycloak précise : « $detail »." : '';
$message = match (true) {
$status === 0 => "Keycloak injoignable ($geste) : " . ($resp['erreur'] ?? '') . '.',
$status === 401 => "Keycloak a refusé le jeton du compte de service (401) pour : $geste.",
$status === 403 => "Refus de Keycloak (403) pour : $geste. Il manque au compte de service « "
. KC_SERVICE_CLIENT_ID . " » le rôle « $role » du client « " . kc_client_droits()
. ' » (rôles realm-management du realm ' . ALPID_REALM . '), à attribuer dans le realm master :'
. ' Clients → ' . KC_SERVICE_CLIENT_ID . ' → Service accounts roles → Assign role.',
$status === 404 => "Introuvable dans Keycloak (404) : $geste.$detail",
$status === 409 => "Conflit signalé par Keycloak (409) : $geste.$detail",
default => "Erreur Keycloak ($status) pour : $geste.$detail",
};
throw new RuntimeException($message, $status);
}
function kc_est_uuid(string $id): bool {
return (bool)preg_match('/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i', $id);
}
function _kc_encode_username(string $lastname): string {
$name = strtolower(iconv('UTF-8', 'ASCII//TRANSLIT//IGNORE', $lastname));
$name = preg_replace('/[^a-z]/', '', $name);
$len = strlen($name);
if ($len <= 2) return $name;
return $name[0] . ($len - 2) . $name[$len - 1];
}
function kc_username_exists(string $username): bool {
$resp = _kc_request('GET', '/users?username=' . urlencode($username) . '&exact=true');
if ($resp['status'] !== 200) return false;
return count(json_decode($resp['body'], true) ?? []) > 0;
}
function kc_generate_username(string $lastname, string $firstname): string {
$fn = strtolower(preg_replace('/[^a-z]/i', '', iconv('UTF-8', 'ASCII//TRANSLIT//IGNORE', $firstname)));
$code = _kc_encode_username($lastname);
$base = $fn . '.' . $code;
if (!kc_username_exists($base)) return $base;
for ($i = 2; $i <= 99; $i++) {
$try = $base . $i;
if (!kc_username_exists($try)) return $try;
}
return $base . uniqid('', false);
}
function kc_create_user(string $username, string $email, string $first_name, string $last_name, string $password): string {
$resp = _kc_request('POST', '/users', [
'username' => $username,
'email' => $email,
'firstName' => $first_name,
'lastName' => $last_name,
'enabled' => true,
'emailVerified' => false,
'credentials' => [['type' => 'password', 'value' => $password, 'temporary' => false]],
]);
if ($resp['status'] === 409) {
$detail = json_decode($resp['body'], true)['errorMessage'] ?? '';
$msg = str_contains(strtolower($detail), 'email')
? 'Cet email est déjà associé à un compte existant.'
: 'Ce nom d\'utilisateur est déjà utilisé.';
throw new KcUserExistsException($msg);
}
if ($resp['status'] !== 201) {
throw new RuntimeException("Erreur création compte ({$resp['status']}) : {$resp['body']}");
}
// L'ID est dans le header Location
preg_match('#/users/([a-f0-9-]+)#', $resp['headers'], $m);
return $m[1] ?? '';
}
function kc_get_otp_credential(string $user_id): ?array {
$resp = _kc_request('GET', "/users/$user_id/credentials");
if ($resp['status'] !== 200) return null;
foreach (json_decode($resp['body'], true) ?? [] as $c) {
if ($c['type'] === 'otp') return $c;
}
return null;
}
function kc_delete_credential(string $user_id, string $credential_id): void {
$resp = _kc_request('DELETE', "/users/$user_id/credentials/$credential_id");
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur suppression credential ({$resp['status']})");
}
}
function kc_update_name(string $user_id, string $first_name, string $last_name): void {
$resp = _kc_request('PUT', "/users/$user_id", [
'firstName' => $first_name,
'lastName' => $last_name,
]);
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur mise à jour nom ({$resp['status']})");
}
}
function kc_update_email(string $user_id, string $email): void {
$resp = _kc_request('PUT', "/users/$user_id", [
'email' => $email,
'emailVerified' => false,
]);
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur mise à jour email ({$resp['status']})");
}
}
function kc_set_password(string $user_id, string $password): void {
$resp = _kc_request('PUT', "/users/$user_id/reset-password", [
'type' => 'password',
'value' => $password,
'temporary' => false,
]);
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur changement mot de passe ({$resp['status']})");
}
}
// Liste brute d'une page de comptes, sans les groupes. Lève une exception
// au lieu de renvoyer une liste vide : une liste vide doit vouloir dire
// « aucun compte », jamais « Keycloak a refusé ».
function kc_list_users(int $max = 200, int $first = 0, string $recherche = ''): array {
$params = ['first' => $first, 'max' => $max, 'briefRepresentation' => 'true'];
if ($recherche !== '') $params['search'] = $recherche;
$resp = _kc_request('GET', '/users?' . http_build_query($params));
return _kc_attendre($resp, 'lister les comptes', 'view-users') ?? [];
}
function kc_count_users(string $recherche = ''): int {
$query = $recherche !== '' ? '?' . http_build_query(['search' => $recherche]) : '';
$resp = _kc_request('GET', '/users/count' . $query);
return (int)_kc_attendre($resp, 'compter les comptes', 'view-users');
}
function kc_list_groups(): array {
$resp = _kc_request('GET', '/groups?max=200&briefRepresentation=false');
return _kc_attendre($resp, 'lister les groupes', 'view-users (ou query-groups)') ?? [];
}
// Groupes à plat, sous-groupes compris, chacun avec son chemin (« /a/b »).
// Keycloak 23+ ne renvoie plus les sous-groupes dans /groups : on les
// demande alors à /groups/{id}/children quand subGroupCount l'annonce.
function kc_list_groups_plat(): array {
$plat = [];
$parcourir = function (array $groupes) use (&$parcourir, &$plat): void {
foreach ($groupes as $g) {
$plat[] = ['id' => $g['id'], 'name' => $g['name'], 'path' => $g['path'] ?? '/' . $g['name']];
$enfants = $g['subGroups'] ?? [];
if (!$enfants && ($g['subGroupCount'] ?? 0) > 0) {
$resp = _kc_request('GET', "/groups/{$g['id']}/children?max=200");
$enfants = _kc_attendre($resp, 'lister les sous-groupes', 'view-users (ou query-groups)') ?? [];
}
$parcourir($enfants);
}
};
$parcourir(kc_list_groups());
return $plat;
}
function kc_create_group(string $name): void {
$resp = _kc_request('POST', '/groups', ['name' => $name]);
if ($resp['status'] === 409) throw new RuntimeException("Le groupe « $name » existe déjà.");
if ($resp['status'] !== 201) throw new RuntimeException("Erreur création groupe ({$resp['status']})");
}
function kc_delete_group(string $group_id): void {
$resp = _kc_request('DELETE', "/groups/$group_id");
if ($resp['status'] >= 300) throw new RuntimeException("Erreur suppression groupe ({$resp['status']})");
}
function kc_group_members(string $group_id, int $max = 200, int $first = 0): array {
$resp = _kc_request('GET', "/groups/$group_id/members?first=$first&max=$max&briefRepresentation=true");
return _kc_attendre($resp, 'lister les membres d\'un groupe', 'view-users') ?? [];
}
function _kc_group_id(string $group_name): string {
$resp = _kc_request('GET', '/groups?search=' . urlencode($group_name));
$groups = _kc_attendre($resp, "chercher le groupe « $group_name »", 'view-users (ou query-groups)') ?? [];
foreach ($groups as $g) {
if ($g['name'] === $group_name) return $g['id'];
}
throw new RuntimeException("Groupe « $group_name » introuvable dans Keycloak.");
}
function kc_add_to_group(string $user_id, string $group_name): void {
$group_id = _kc_group_id($group_name);
$resp = _kc_request('PUT', "/users/$user_id/groups/$group_id");
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur ajout groupe ({$resp['status']})");
}
}
function kc_remove_from_group(string $user_id, string $group_name): void {
$group_id = _kc_group_id($group_name);
$resp = _kc_request('DELETE', "/users/$user_id/groups/$group_id");
if ($resp['status'] >= 300) {
throw new RuntimeException("Erreur suppression groupe ({$resp['status']})");
}
}
// ── Lecture d'un compte (fiche de la console) ─────────────────────────
// Noms des groupes de chaque compte, construits en lisant les membres de
// chaque groupe : un appel par groupe (et par tranche de 200 membres), au
// lieu d'un appel par compte.
function kc_noms_groupes_par_compte(): array {
$par_compte = [];
foreach (kc_list_groups_plat() as $g) {
for ($first = 0; ; $first += 200) {
$membres = kc_group_members($g['id'], 200, $first);
foreach ($membres as $m) $par_compte[$m['id']][] = $g['name'];
if (count($membres) < 200) break;
}
}
return $par_compte;
}
function kc_get_user(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id");
return _kc_attendre($resp, 'lire le compte', 'view-users') ?? [];
}
function kc_user_groups(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id/groups?briefRepresentation=true");
return _kc_attendre($resp, 'lire les groupes du compte', 'view-users') ?? [];
}
function kc_user_credentials(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id/credentials");
return _kc_attendre($resp, 'lire les moyens d\'authentification du compte', 'view-users') ?? [];
}
// Rôles attribués directement au compte : realmMappings, et clientMappings
// indexé par clientId ({client, id, mappings: [...]}).
function kc_user_role_mappings(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id/role-mappings");
return _kc_attendre($resp, 'lire les rôles du compte', 'view-users') ?? [];
}
// Rôles realm effectifs : directs, hérités d'un groupe ou d'un rôle composite.
function kc_user_realm_roles_effectifs(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id/role-mappings/realm/composite?briefRepresentation=true");
return _kc_attendre($resp, 'lire les rôles realm effectifs du compte', 'view-users') ?? [];
}
// Identifiant interne (UUID) d'un client à partir de son clientId, ou null
// s'il n'existe pas dans le realm.
function kc_client_uuid(string $client_id): ?string {
static $cache = [];
if (array_key_exists($client_id, $cache)) return $cache[$client_id];
$resp = _kc_request('GET', '/clients?' . http_build_query(['clientId' => $client_id, 'search' => 'false']));
$clients = _kc_attendre($resp, "trouver le client « $client_id »", 'view-clients') ?? [];
foreach ($clients as $c) {
if (($c['clientId'] ?? '') === $client_id) return $cache[$client_id] = $c['id'];
}
return $cache[$client_id] = null;
}
// Rôles effectifs du compte sur un client : ce que le jeton d'accès porterait
// dans resource_access.<client>.roles (sous réserve de la portée du client).
function kc_user_client_roles_effectifs(string $user_id, string $client_uuid): array {
$resp = _kc_request('GET', "/users/$user_id/role-mappings/clients/$client_uuid/composite?briefRepresentation=true");
return _kc_attendre($resp, 'lire les rôles effectifs du compte sur un client', 'view-users') ?? [];
}
// Sessions SSO ouvertes (les sessions hors ligne n'y figurent pas).
function kc_user_sessions(string $user_id): array {
$resp = _kc_request('GET', "/users/$user_id/sessions");
return _kc_attendre($resp, 'lire les sessions du compte', 'view-users') ?? [];
}