From a646635b4c586230fbcabf16347057b6e93ad289 Mon Sep 17 00:00:00 2001 From: Johan LEROY Date: Wed, 23 Sep 2026 09:19:29 +0200 Subject: [PATCH] =?UTF-8?q?test:=20partage=20un=20jeu=20de=20d=C3=A9monstr?= =?UTF-8?q?ation=20et=20des=20comptes=20de=20test?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit db/seeds/ était vide, et chaque outil de test semait ses données à la main : un site et deux relevés dans dast.yml, rien pour le reste. - db/seeds/demo.sql : trois sites, 72 heures de relevés relatives à now(), une prévision par site, quatorze alertes de tous types et sévérités, un rapport de dérive par site. Rejouable. - scripts/comptes-test.sh : administrateur par la CLI, lecteur et opérateur activés, et un compte laissé sur son mot de passe temporaire ; identifiants écrits en JSON (mode 600). Fonctionne en natif ou contre la stack Compose (BASE_URL, APP_CLI). - scripts/dast-token.sh s'appuie désormais dessus ; dast.yml sème demo.sql. --- .github/workflows/dast.yml | 27 +++------- db/seeds/demo.sql | 101 ++++++++++++++++++++++++++++++++++++ scripts/comptes-test.sh | 103 +++++++++++++++++++++++++++++++++++++ scripts/dast-token.sh | 78 +++++----------------------- 4 files changed, 224 insertions(+), 85 deletions(-) create mode 100644 db/seeds/demo.sql create mode 100755 scripts/comptes-test.sh diff --git a/.github/workflows/dast.yml b/.github/workflows/dast.yml index 6208e2e..38a5ded 100644 --- a/.github/workflows/dast.yml +++ b/.github/workflows/dast.yml @@ -1,9 +1,9 @@ name: DAST # Scan dynamique OWASP ZAP de l'API (issue #41). Il attaque une API qui tourne : le job démarre -# la base et le backend sur le runner, sème un site et quelques relevés (sans ça le scan ne -# frappe que des gestionnaires d'erreur), crée un compte `lecteur` jetable -# (scripts/dast-token.sh), puis lance ZAP sur le contrat OpenAPI avec le jeton de ce compte. +# la base et le backend sur le runner, sème le jeu de démonstration (sans ça le scan ne frappe que +# des gestionnaires d'erreur), crée des comptes jetables (scripts/dast-token.sh), puis lance ZAP +# sur le contrat OpenAPI avec le jeton du `lecteur`. # # Non bloquant pour l'instant sur les alertes (`continue-on-error` sur la seule étape du scan) : # le volume d'un premier passage trié est inconnu. Deux étapes suivantes, elles, bloquent si le @@ -24,6 +24,8 @@ on: paths: - ".github/workflows/dast.yml" - "scripts/dast-token.sh" + - "scripts/comptes-test.sh" + - "db/seeds/**" permissions: contents: read @@ -108,22 +110,9 @@ jobs: working-directory: apps/backend # Sans données, `GET /sites` rend `[]`, chaque `/{site_id}` rend 404 et le scan actif ne - # frappe que des gestionnaires d'erreur plutôt que la logique métier. `db/seeds/` est vide - # (pas encore d'outillage de jeu de données pour la CI) : un site et deux relevés à la main, - # juste assez pour que les routes de lecture aient quelque chose à rendre. - - name: Insère un site et des relevés minimaux pour le scan - run: | - psql -h localhost -p 5433 -U enervision -d enervision_dast <<'SQL' - INSERT INTO site (site_id, site_name, site_type, location, capacity_kw, status) - VALUES ('dast-site', 'Site du scan DAST', 'bureau', 'CI', 50, 'actif') - ON CONFLICT (site_id) DO NOTHING; - - INSERT INTO reading (site_id, timestamp, source, consumption_kw, consumption_kwh, is_working_hours, data_quality, raw_data) - VALUES - ('dast-site', now() - interval '2 hours', 'api_current', 12.5, 12.5, true, 'good', '{}'), - ('dast-site', now() - interval '1 hour', 'api_current', 13.0, 13.0, true, 'good', '{}') - ON CONFLICT DO NOTHING; - SQL + # frappe que des gestionnaires d'erreur plutôt que la logique métier. + - name: Sème le jeu de démonstration + run: psql -h localhost -p 5433 -U enervision -d enervision_dast -v ON_ERROR_STOP=1 -f db/seeds/demo.sql - name: Démarre l'API run: | diff --git a/db/seeds/demo.sql b/db/seeds/demo.sql new file mode 100644 index 0000000..d3d66d8 --- /dev/null +++ b/db/seeds/demo.sql @@ -0,0 +1,101 @@ +-- Contrainte : jeu de démonstration pour une base JETABLE (CI, e2e, charge, DAST) - demo.sql. +-- Rejouable : identifiants fixes et `ON CONFLICT DO NOTHING`, ou `NOT EXISTS` là où aucune +-- contrainte d'unicité ne protège la table. +-- Pourquoi : les horodatages suivent `now()`. La fenêtre par défaut de `GET /readings` couvre les +-- 24 dernières heures, et un jeu figé dans le passé laisserait le tableau de bord vide. +-- Piège : `demo-ecole` finit sur une lecture `partial` sans humidité, pour que la supervision des +-- capteurs montre un site dégradé ; au-delà de dix alertes, le fil affiche « Afficher plus ». + +BEGIN; + +INSERT INTO site (site_id, site_name, site_type, location, capacity_kw, status) +VALUES + ('demo-siege', 'Siège Part-Dieu', 'office', 'Lyon', 450, 'actif'), + ('demo-usine', 'Usine de Vénissieux', 'factory', 'Vénissieux', 900, 'actif'), + ('demo-ecole', 'Groupe scolaire Gratte-Ciel', 'school', 'Villeurbanne', 250, 'maintenance') +ON CONFLICT (site_id) DO NOTHING; + +WITH profil (site_id, base_kw, amplitude_kw) AS ( + VALUES ('demo-siege', 180.0, 120.0), ('demo-usine', 520.0, 260.0), ('demo-ecole', 70.0, 60.0) +), +heures AS ( + SELECT date_trunc('hour', now()) - make_interval(hours => n) AS horodatage, n + FROM generate_series(0, 71) AS n +), +lectures AS ( + SELECT + p.site_id, + h.horodatage, + h.n, + round((p.base_kw + p.amplitude_kw * greatest(0, sin(pi() * (extract(hour FROM h.horodatage) - 6) / 14)))::numeric, 2)::double precision AS kw, + extract(isodow FROM h.horodatage) < 6 AND extract(hour FROM h.horodatage) BETWEEN 8 AND 18 AS ouvre + FROM profil AS p + CROSS JOIN heures AS h +) +INSERT INTO reading ( + site_id, timestamp, source, consumption_kw, consumption_kwh, consumption_euros, + voltage_v, current_a, power_factor, temperature_celsius, humidity_percent, + is_working_hours, data_quality, null_reasons, raw_data +) +SELECT + site_id, + horodatage, + 'api_current', + kw, + kw, + round((kw * 0.19)::numeric, 2), + 230.0, + round((kw * 1000 / (230.0 * 3 * 0.95))::numeric, 1)::double precision, + 0.95, + 19.5 + 3 * sin(pi() * extract(hour FROM horodatage) / 12), + CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN NULL ELSE 45.0 END, + ouvre, + CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN 'partial' ELSE 'good' END, + CASE WHEN site_id = 'demo-ecole' AND n = 0 THEN ARRAY['humidity_sensor_failure'] END, + '{}'::jsonb +FROM lectures +ON CONFLICT DO NOTHING; + +INSERT INTO prediction (site_id, target_at, target_metric, period_minutes, predicted_value, model_reference, status) +SELECT s.site_id, date_trunc('hour', now()) + interval '1 hour', 'consumption_kwh', 60, s.valeur, 'demo-seed', 'available' +FROM (VALUES ('demo-siege', 214.0), ('demo-usine', 610.5), ('demo-ecole', 88.2)) AS s (site_id, valeur) +WHERE NOT EXISTS ( + SELECT 1 FROM prediction AS p + WHERE p.site_id = s.site_id + AND p.model_reference = 'demo-seed' + AND p.target_at = date_trunc('hour', now()) + interval '1 hour' +); + +INSERT INTO alert (source_alert_id, site_id, source, timestamp, type, severity, message, value, threshold, metric, raw_data) +SELECT a.id, a.site_id, 'enervision', now() - make_interval(hours => a.age_h), a.type, a.severite, a.message, a.valeur, a.seuil, a.metrique, '{}'::jsonb +FROM ( + VALUES + ('demo-01', 'demo-siege', 1, 'spike', 'high', 'Pic de consommation à 312 kW', 312.0, 250.0, 'consumption_kw'), + ('demo-02', 'demo-siege', 3, 'threshold', 'medium', 'Seuil de 80 % de la capacité franchi', 372.0, 360.0, 'consumption_kw'), + ('demo-03', 'demo-siege', 6, 'anomaly', 'low', 'Consommation nocturne inhabituelle', 205.0, NULL, 'consumption_kw'), + ('demo-04', 'demo-siege', 9, 'sensor', 'medium', 'Capteur de température muet', NULL, NULL, 'temperature_celsius'), + ('demo-05', 'demo-siege', 20, 'outage', 'critical', 'Coupure de courant de 2 heures', 0.0, NULL, 'consumption_kw'), + ('demo-06', 'demo-usine', 2, 'spike', 'critical', 'Pic de consommation à 1 020 kW', 1020.0, 850.0, 'consumption_kw'), + ('demo-07', 'demo-usine', 4, 'threshold', 'high', 'Seuil de 90 % de la capacité franchi', 830.0, 810.0, 'consumption_kw'), + ('demo-08', 'demo-usine', 8, 'anomaly', 'medium', 'Facteur de puissance dégradé', 0.71, 0.85, 'power_factor'), + ('demo-09', 'demo-usine', 14, 'outage', 'high', 'Perte de mesure sur la ligne principale', NULL, NULL, 'consumption_kw'), + ('demo-10', 'demo-usine', 30, 'sensor', 'low', 'Capteur électrique intermittent', NULL, NULL, 'voltage_v'), + ('demo-11', 'demo-ecole', 1, 'sensor', 'high', 'Capteur d''humidité muet', NULL, NULL, 'humidity_percent'), + ('demo-12', 'demo-ecole', 5, 'anomaly', 'low', 'Chauffage actif hors des heures d''ouverture', 96.0, NULL, 'consumption_kw'), + ('demo-13', 'demo-ecole', 12, 'threshold', 'medium', 'Seuil de 60 % de la capacité franchi', 158.0, 150.0, 'consumption_kw'), + ('demo-14', 'demo-ecole', 40, 'spike', 'medium', 'Pic de consommation à 190 kW', 190.0, 160.0, 'consumption_kw') +) AS a (id, site_id, age_h, type, severite, message, valeur, seuil, metrique) +ON CONFLICT DO NOTHING; + +INSERT INTO drift_report (window_start, window_end, n_observations, mae, mape, bias, reference_mae, coverage_ratio, insufficient_data_ratio, model_references, status, reason, site_id) +SELECT date_trunc('day', now()) - interval '7 days', date_trunc('day', now()), d.n, d.mae, d.mape, d.biais, 11.0, 0.98, 0.0, ARRAY['demo-seed'], d.statut, d.raison, d.site_id +FROM ( + VALUES + ('demo-siege', 168, 9.4, 0.052, -1.2, 'stable', NULL), + ('demo-usine', 168, 31.8, 0.061, 14.5, 'derive', 'MAE supérieure à 1,5 fois la référence'), + ('demo-ecole', 120, 6.1, 0.083, 0.4, 'stable', NULL), + (NULL, 456, 16.9, 0.064, 5.1, 'stable', NULL) +) AS d (site_id, n, mae, mape, biais, statut, raison) +ON CONFLICT DO NOTHING; + +COMMIT; diff --git a/scripts/comptes-test.sh b/scripts/comptes-test.sh new file mode 100755 index 0000000..793b8e0 --- /dev/null +++ b/scripts/comptes-test.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# Contrainte : réservé à une base JETABLE (CI, e2e, charge sur le poste) - comptes-test.sh. Crée +# un administrateur par la CLI, puis un lecteur, un opérateur et un compte laissé sur son mot de +# passe temporaire, et écrit leurs identifiants en JSON dans $COMPTES_FICHIER. +# Piège : un compte neuf est en `must_change_password`, que toute route gardée refuse. Seul +# `premiere_connexion` garde ce statut : c'est le parcours du premier login de l'e2e. +# Piège : `create-admin` refuse un second administrateur actif. Sur une base qui en a déjà un +# (recette, poste peuplé), créer les comptes depuis l'interface d'administration. +# +# BASE_URL vise l'API (http://localhost:8000 par défaut, ou le proxy en https). APP_CLI lance la +# CLI du backend : depuis apps/backend par défaut, ou `docker compose ... exec -T backend python +# -m app.cli` contre la stack conteneurisée. + +set -euo pipefail +# Sans lui, une erreur dans `$(...)` ne s'arrête pas : la substitution rendrait un mot de passe vide. +shopt -s inherit_errexit + +BASE_URL="${BASE_URL:-http://localhost:8000}" +API="$BASE_URL/api/v1" +COMPTES_FICHIER="${COMPTES_FICHIER:?COMPTES_FICHIER=chemin du fichier JSON requis}" +read -ra CLI <<<"${APP_CLI:-uv run --frozen --no-sync --no-build python -m app.cli}" +SUFFIXE="$(openssl rand -hex 4)" + +CURL=(curl -fsS) +[[ "$BASE_URL" == https://* ]] && CURL+=(--insecure) + +# Classes exigées par le validateur : majuscule, minuscule, chiffre, caractère spécial. +nouveau_mot_de_passe() { echo "Test-$(openssl rand -hex 12)-Aa1!"; } + +journal() { echo "comptes-test: $*" >&2; } + +connexion() { + local email="$1" mot_de_passe="$2" + "${CURL[@]}" -X POST "$API/auth/login" -H 'Content-Type: application/json' \ + -d "$(jq -n --arg e "$email" --arg p "$mot_de_passe" '{email:$e, password:$p}')" \ + | jq -r '.access_token' +} + +# `/auth/password` rend un nouveau jeton d'accès : pas de reconnexion, donc pas de second hachage +# Argon2id ni de requête de plus dans la zone `auth` de nginx (30 par minute). +changer_mot_de_passe() { + local jeton="$1" ancien="$2" nouveau="$3" + "${CURL[@]}" -X POST "$API/auth/password" \ + -H "Authorization: Bearer $jeton" -H 'Content-Type: application/json' \ + -d "$(jq -n --arg a "$ancien" --arg n "$nouveau" '{current_password:$a, new_password:$n}')" \ + | jq -r '.access_token' +} + +creer_compte() { + local jeton_admin="$1" email="$2" role="$3" reponse temporaire + reponse="$("${CURL[@]}" -X POST "$API/users" -H "Authorization: Bearer $jeton_admin" \ + -H 'Content-Type: application/json' \ + -d "$(jq -n --arg e "$email" --arg r "$role" '{email:$e, role:$r}')")" + temporaire="$(jq -r '.temporary_password // empty' <<<"$reponse")" + [[ -n "$temporaire" ]] || { journal "mot de passe temporaire absent de la réponse : $reponse"; exit 1; } + echo "$temporaire" +} + +# Rend le mot de passe définitif d'un compte créé par `creer_compte`. +activer_compte() { + local email="$1" temporaire="$2" definitif jeton + definitif="$(nouveau_mot_de_passe)" + jeton="$(connexion "$email" "$temporaire")" + changer_mot_de_passe "$jeton" "$temporaire" "$definitif" >/dev/null + echo "$definitif" +} + +EMAIL_ADMIN="test-admin-$SUFFIXE@enervision.fr" +journal "création de l'administrateur $EMAIL_ADMIN" +if ! SORTIE="$("${CLI[@]}" create-admin --email "$EMAIL_ADMIN" --generate)"; then + journal "la création de l'administrateur a échoué : $SORTIE" + exit 1 +fi +MDP_TEMPORAIRE_ADMIN="$(sed -n 's/^Mot de passe généré, il ne sera plus affiché : //p' <<<"$SORTIE" | tr -d '\r')" +[[ -n "$MDP_TEMPORAIRE_ADMIN" ]] || { journal "mot de passe introuvable dans la sortie : $SORTIE"; exit 1; } + +MDP_ADMIN="$(nouveau_mot_de_passe)" +JETON_ADMIN="$(connexion "$EMAIL_ADMIN" "$MDP_TEMPORAIRE_ADMIN")" +JETON_ADMIN="$(changer_mot_de_passe "$JETON_ADMIN" "$MDP_TEMPORAIRE_ADMIN" "$MDP_ADMIN")" + +EMAIL_LECTEUR="test-lecteur-$SUFFIXE@enervision.fr" +EMAIL_OPERATEUR="test-operateur-$SUFFIXE@enervision.fr" +EMAIL_PREMIERE="test-premiere-connexion-$SUFFIXE@enervision.fr" +journal "création du lecteur, de l'opérateur et du compte de première connexion" +TEMPORAIRE_LECTEUR="$(creer_compte "$JETON_ADMIN" "$EMAIL_LECTEUR" lecteur)" +MDP_LECTEUR="$(activer_compte "$EMAIL_LECTEUR" "$TEMPORAIRE_LECTEUR")" +TEMPORAIRE_OPERATEUR="$(creer_compte "$JETON_ADMIN" "$EMAIL_OPERATEUR" operateur)" +MDP_OPERATEUR="$(activer_compte "$EMAIL_OPERATEUR" "$TEMPORAIRE_OPERATEUR")" +MDP_PREMIERE="$(creer_compte "$JETON_ADMIN" "$EMAIL_PREMIERE" lecteur)" + +umask 077 +jq -n \ + --arg ae "$EMAIL_ADMIN" --arg ap "$MDP_ADMIN" \ + --arg le "$EMAIL_LECTEUR" --arg lp "$MDP_LECTEUR" \ + --arg oe "$EMAIL_OPERATEUR" --arg op "$MDP_OPERATEUR" \ + --arg pe "$EMAIL_PREMIERE" --arg pp "$MDP_PREMIERE" \ + '{ + admin: {email: $ae, password: $ap}, + lecteur: {email: $le, password: $lp}, + operateur: {email: $oe, password: $op}, + premiere_connexion: {email: $pe, password: $pp} + }' >"$COMPTES_FICHIER" +journal "identifiants écrits dans $COMPTES_FICHIER" diff --git a/scripts/dast-token.sh b/scripts/dast-token.sh index 2bbbdfb..aa94fd4 100755 --- a/scripts/dast-token.sh +++ b/scripts/dast-token.sh @@ -1,78 +1,24 @@ #!/usr/bin/env bash -# Prépare le scan DAST : crée un compte `lecteur` sur une API déjà démarrée, lui fait passer le -# changement de mot de passe obligatoire, et écrit son jeton d'accès sur la sortie standard. -# -# Piège : un compte neuf est en `must_change_password`, et toute route gardée le refuse tant que -# le mot de passe n'a pas été changé. Sans cette étape, ZAP ne verrait que 403 sur les routes -# gardées et le scan ne testerait rien de l'API authentifiée. -# +# Contrainte : prépare le scan DAST sur une base JETABLE - dast-token.sh. Crée les comptes de +# test (scripts/comptes-test.sh, mêmes variables) et écrit sur la sortie standard le seul jeton +# d'accès du `lecteur`. # Contrainte : le compte du scan est `lecteur`, jamais `admin`. Un scan actif avec un jeton admin # frapperait POST /users ou la réinitialisation de mots de passe pour de bon. -# -# L'administrateur n'existe que pour créer ce compte (l'API n'a pas d'inscription publique). -# À lancer depuis apps/backend, dans un environnement où DATABASE_URL et APP_SECRET_KEY visent -# une base JETABLE : le script y crée deux comptes. set -euo pipefail +shopt -s inherit_errexit +ICI="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" BASE_URL="${BASE_URL:-http://localhost:8000}" -API="$BASE_URL/api/v1" -SUFFIXE="$(openssl rand -hex 4)" -EMAIL_ADMIN="dast-admin-$SUFFIXE@enervision.fr" -EMAIL_LECTEUR="dast-lecteur-$SUFFIXE@enervision.fr" +COMPTES="$(mktemp)" +trap 'rm -f "$COMPTES"' EXIT -# Classes exigées par le validateur : majuscule, minuscule, chiffre, caractère spécial. -nouveau_mot_de_passe() { echo "Dast-$(openssl rand -hex 12)-Aa1!"; } +COMPTES_FICHIER="$COMPTES" BASE_URL="$BASE_URL" "$ICI/comptes-test.sh" -# Tout ce qui n'est pas la sortie finale part sur stderr : la sortie standard ne porte que le jeton. -journal() { echo "dast-token: $*" >&2; } +JETON="$(curl -fsS -X POST "$BASE_URL/api/v1/auth/login" -H 'Content-Type: application/json' \ + -d "$(jq '.lecteur | {email, password}' "$COMPTES")" | jq -r '.access_token')" -connexion() { - local email="$1" mot_de_passe="$2" - curl -fsS -X POST "$API/auth/login" -H 'Content-Type: application/json' \ - -d "$(jq -n --arg e "$email" --arg p "$mot_de_passe" '{email:$e, password:$p}')" \ - | jq -r '.access_token' -} +CODE="$(curl -sS -o /dev/null -w '%{http_code}' "$BASE_URL/api/v1/sites" -H "Authorization: Bearer $JETON")" +[[ "$CODE" == "200" ]] || { echo "dast-token: GET /sites répond $CODE avec le jeton du lecteur, attendu 200" >&2; exit 1; } -# Rend le nouveau jeton d'accès : `/auth/password` en émet un (avec l'`iat` de la session en -# cours, cf. le piège documenté dans `app/api/deps.py`), pas seulement une confirmation. S'y fier -# évite une reconnexion, donc un second hachage Argon2id (19456 Kio) et un aller-retour de -# refresh-token superflus sur le chemin critique de la CI. -changer_mot_de_passe() { - local jeton="$1" ancien="$2" nouveau="$3" - curl -fsS -X POST "$API/auth/password" \ - -H "Authorization: Bearer $jeton" -H 'Content-Type: application/json' \ - -d "$(jq -n --arg a "$ancien" --arg n "$nouveau" '{current_password:$a, new_password:$n}')" \ - | jq -r '.access_token' -} - -journal "création de l'administrateur $EMAIL_ADMIN" -if ! SORTIE="$(uv run --frozen --no-sync --no-build python -m app.cli create-admin --email "$EMAIL_ADMIN" --generate)"; then - journal "la création de l'administrateur a échoué :" - journal "$SORTIE" - exit 1 -fi -MDP_ADMIN="$(sed -n 's/^Mot de passe généré, il ne sera plus affiché : //p' <<<"$SORTIE")" -[[ -n "$MDP_ADMIN" ]] || { journal "mot de passe administrateur introuvable dans la sortie :"; journal "$SORTIE"; exit 1; } - -JETON="$(connexion "$EMAIL_ADMIN" "$MDP_ADMIN")" -NOUVEAU_ADMIN="$(nouveau_mot_de_passe)" -JETON="$(changer_mot_de_passe "$JETON" "$MDP_ADMIN" "$NOUVEAU_ADMIN")" - -journal "création du lecteur $EMAIL_LECTEUR" -REPONSE="$(curl -fsS -X POST "$API/users" -H "Authorization: Bearer $JETON" \ - -H 'Content-Type: application/json' \ - -d "$(jq -n --arg e "$EMAIL_LECTEUR" '{email:$e, role:"lecteur"}')")" -MDP_TEMPORAIRE="$(jq -r '.temporary_password // empty' <<<"$REPONSE")" -[[ -n "$MDP_TEMPORAIRE" ]] || { journal "mot de passe temporaire introuvable dans la réponse de POST /users :"; journal "$REPONSE"; exit 1; } - -JETON="$(connexion "$EMAIL_LECTEUR" "$MDP_TEMPORAIRE")" -NOUVEAU_LECTEUR="$(nouveau_mot_de_passe)" -JETON="$(changer_mot_de_passe "$JETON" "$MDP_TEMPORAIRE" "$NOUVEAU_LECTEUR")" - -# Vérifie que le jeton ouvre bien une route gardée avant de le rendre. -CODE="$(curl -sS -o /dev/null -w '%{http_code}' "$API/sites" -H "Authorization: Bearer $JETON")" -[[ "$CODE" == "200" ]] || { journal "GET /sites répond $CODE avec le jeton du lecteur, attendu 200"; exit 1; } - -journal "jeton du lecteur prêt" echo "$JETON"