From 989398f3cf44ea99fb2d583df6eec7882b001c6f Mon Sep 17 00:00:00 2001 From: Daniel Allaire Date: Fri, 11 Sep 2026 10:21:19 -0400 Subject: [PATCH] expositions-etat : le certificat SERVI, pas celui du disque MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Renommer une exposition touche cinq choses. Quatre suivent au deploiement ; la cinquieme est celle que le navigateur regarde. serveur_nginx pose le vhost et laisse le SAN en arriere — c est client_pki qui reemet, et rien ne le reclame. Mesure deux fois le 2026-09-10. Le controle compare trois listes : les expositions du plan, les noms du certificat servi, et le code que rend le vhost. Dans les deux sens : un nom reste dans le SAN apres avoir quitte le plan continue d etre authentifie. Piege trouve en l ecrivant : client_pki met toujours le FQDN et le nom court de la machine dans le SAN. Les compter comme vestiges faisait crier le controle a chaque execution — et un controle qui crie toujours ne se lit plus. Deux formes de terminaison, une seule question : le locataire termine sur un edge, le site sur la machine elle-meme. Le porteur se derive de l une ou de l autre. Ce n est pas une preuve : rien de statique ne peut lire un certificat servi. Les quatre controles a la demande n etaient nommes nulle part comme famille ; ils ont maintenant leur section dans les runbooks. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01Crgis8CxCWkAGFA1ecBz3q --- CHANGELOG.md | 46 +++++++ Makefile | 9 ++ docs/audit/preuve-2026-09-11.md | 6 +- docs/audit/wiki-publie.yml | 2 +- docs/runbooks-exploitation.md | 44 +++++++ scripts/expositions_etat.py | 212 ++++++++++++++++++++++++++++++++ 6 files changed, 315 insertions(+), 4 deletions(-) create mode 100644 scripts/expositions_etat.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 9e5fb97..d709d89 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,51 @@ # CHANGELOG — Set-OPS +## 2026-09-11 (3) — `make expositions-etat` : le certificat SERVI, pas celui du disque + +Renommer une exposition touche cinq choses. Quatre suivent au deploiement ; la cinquieme, +non — et c'est celle que le navigateur regarde. + + serveur_powerdns la zone publie le nouveau nom OK + serveur_keycloak le client OIDC accepte le retour OK + le service il fabrique ses URL avec le bon nom OK (P67) + serveur_nginx le vhost repond sur le nouveau nom OK + client_pki le SAN du certificat porte le nom NON il faut le rejouer + +Mesure DEUX FOIS le 2026-09-10, sur `grafana -> observatoire` puis `icinga -> vigie`. Le +symptome est trompeur : le site repond, la page s'affiche, et c'est le NAVIGATEUR qui +refuse — avec une erreur de certificat que personne ne relie a un renommage fait la veille. + +### Il regarde dans les deux sens + +Un nom RESTE dans le SAN apres avoir quitte le plan est un nom que le certificat continue +d'authentifier. C'est exactement ce qu'avait laisse le premier renommage. + +Le piege de ce second sens, trouve en l'ecrivant : `client_pki` met TOUJOURS le FQDN et le +nom court de la machine dans le SAN. Les compter comme vestiges faisait crier le controle a +chaque execution — et un controle qui crie toujours ne se lit plus. + +### Deux formes de terminaison, une seule question + +Le locataire termine son TLS sur un edge ; `sans_exposition` y designe le porteur. Le SITE +n'a pas d'edge — `site-forge-01` ecoute lui-meme sur 443 — et la variable n'y existe donc +pas. Le porteur se derive alors de l'application : son `hote` dit quelle machine la sert. + + OPS-Chezlepro 6 expositions toutes servies, certificat conforme, rien en trop + SITE 5 expositions INJOIGNABLE depuis ce poste + +Le second resultat n'accuse pas le service, et le controle le dit : les zones du SITE ne +sont pas routees depuis le plan d'administration du locataire. Le mur est la frontiere. + +### Pourquoi pas une preuve + +`make prouver` est STATIQUE — il lit le depot, zero appel reseau, et c'est ce qui le rend +rejouable partout. Rien de statique ne peut lire un certificat SERVI : il faut ouvrir la +connexion. + +Les quatre controles a la demande n'etaient nommes nulle part comme famille — +`routes-fabric-etat` n'apparaissait dans aucune documentation. Ils ont maintenant leur +section (§8 des runbooks). Une garde que personne ne sait lancer ne sert a rien. + ## 2026-09-11 (2) — La piste d'audit sort de la machine auditee `auditd` tournait, onze regles etaient armees, et rien de tout cela ne servait a grand-chose. diff --git a/Makefile b/Makefile index 38e79a5..778f343 100644 --- a/Makefile +++ b/Makefile @@ -1079,6 +1079,15 @@ routes-fabric-etat: ansible-runtime ## Les hyperviseurs routent-ils toutes les z @# ne ressemblait pas a une route manquante — il ressemblait a un pare-feu. python3 scripts/routes_fabric_etat.py +.PHONY: expositions-etat +expositions-etat: ## Chaque exposition est-elle servie sous un certificat qui la porte ? — ne corrige rien + @# `serveur_nginx` POSE LE VHOST ET LAISSE LE SAN EN ARRIERE. Mesure deux fois le + @# 2026-09-10, sur `grafana -> observatoire` puis `icinga -> vigie` : la zone publiait + @# le nouveau nom, le vhost repondait, le client OIDC l'acceptait — et le certificat + @# servi portait encore l'ancien. C'est `client_pki` qui reemet, et rien ne le reclame. + @# Ajouter `--site` pour l'ecosysteme du SITE. + python3 scripts/expositions_etat.py $(if $(SITE),--site) + .PHONY: gabarit-etat gabarit-etat: ## Le gabarit porte-t-il ce que le SITE declare ? — ne corrige rien, regarde python3 scripts/gabarit_etat.py diff --git a/docs/audit/preuve-2026-09-11.md b/docs/audit/preuve-2026-09-11.md index 5b52a74..533ac3d 100644 --- a/docs/audit/preuve-2026-09-11.md +++ b/docs/audit/preuve-2026-09-11.md @@ -43,7 +43,7 @@ | P28 | Pools Proxmox : un par tenant, sans collision | AFF-110 | ✅ OK | CONFORME : 3 pool(s) Proxmox, 34 VM placee(s), aucun nom ni VMID en collision. | | P29 | Authentification : chaque role declare sa position | AFF-111 | ✅ OK | 33 role(s) serveur declares (interne-sans-auth 2, ldap-direct 2, sans-auth-humaine 22, socle-identite 2, web-sso 5) ; 2 lacune(s) nommee(s) : serveur_loki, serv | | P30 | SDN EVPN : zones, VNets et sous-reseaux derives | AFF-112 | ✅ OK | CONFORME : SDN EVPN, 3 zone(s), 15 VNet(s), 15 sous-reseau(x), aucune collision. | -| P31 | Documentation : tout ce que le depot FAIT est nomme | — | ✅ OK | 59 scripts expliques et atteignables, 116 cibles make documentees, 68 roles avec README. | +| P31 | Documentation : tout ce que le depot FAIT est nomme | — | ✅ OK | 60 scripts expliques et atteignables, 117 cibles make documentees, 68 roles avec README. | | P32 | Intrants exiges par les roles : tous fournis | — | ✅ OK | CONFORME : 38 exigence(s) de role, toutes satisfaites (137 cle(s) declaree(s) par l'instance). | | P33 | Aucune collision de port entre roles co-localises | — | ✅ OK | CONFORME : 34 revendication(s) de port, aucune collision entre roles co-localises (36 groupes). | | P34 | Chaque document declare son lecteur | — | ✅ OK | 44 document(s) declarent leur lecteur (37 genere(s) exempte(s)). | @@ -53,7 +53,7 @@ | P38 | Catalogue des services : la carte dit ce que le moteur fait | — | ✅ OK | Catalogue a jour : 41 role(s) serveur/client tous nommes, 41 groupe(s) cite(s) en table existent tous. | | P39 | Glossaire : tout mot employe est enseigne | — | ✅ OK | Glossaire complet : 81 terme(s) du jargon expliques, 15 lien(s) valides, 27 page(s) de wiki toutes atteignables. | | P40 | Parente : l'ecosysteme sait de quoi il descend | — | ✅ OK | Parente coherente : 4 depot(s), tous retrouves, tous porteurs d'un remote. | -| P41 | Resolution d'instance : une seule, partagee | — | ✅ OK | Resolution unique : 55 script(s) passent par `inventory_rules`, 3 exemption(s) nommee(s). | +| P41 | Resolution d'instance : une seule, partagee | — | ✅ OK | Resolution unique : 56 script(s) passent par `inventory_rules`, 3 exemption(s) nommee(s). | | P42 | L'edge porte les noms qu'il publie | — | ✅ OK | 4 edge(s) emettent un certificat portant les noms publies (OPS-Chezlepro-lab/principal, OPS-Chezlepro/principal, OPS-Technolibre/principal, OPS-Patient0/product | | P43 | Frontiere : le devis voit les machines du site | — | ✅ OK | Devis de la frontiere : 7 machine(s) du plan retrouvees, 155 regle(s) du site. | | P44 | Integrations : le serveur avant ses clients | — | ✅ OK | 5 integration(s) appliquent leur serveur avant leurs clients. | @@ -72,7 +72,7 @@ | P57 | Comptes en prose : les chiffres du depot sur lui-meme | — | ✅ OK | Les comptes ecrits en prose correspondent a la mesure (68 preuves, 68 roles, 41 groupes). | | P58 | Habilitations : chaque service dit a quel GROUPE, et par quoi | — | ✅ OK | 8 habilitation(s) declarees, toutes nommant un groupe, un mecanisme connu et une raison ; les `role-realm` sont projetees. | | P59 | Enumerations annoncees : le nombre correspond a ce qui suit | — | ✅ OK | 2 enumeration(s) annoncee(s) correspondent a ce qu'elles annoncent (formes non ambigues seulement). | -| P60 | Wiki publie : la forge sert ce que le depot dit | AFF-002 | ✅ OK | Le wiki publie correspond au depot : `wiki/` n'a pas bouge depuis `53e2f78` (publie le 2026-09-11). | +| P60 | Wiki publie : la forge sert ce que le depot dit | AFF-002 | ✅ OK | Le wiki publie correspond au depot : `wiki/` n'a pas bouge depuis `5f5af70` (publie le 2026-09-11). | | P61 | Schema du plan : il decrit tout ce que les plans contiennent | AFF-033 | ✅ OK | Le schema decrit 47 champ(s) sur 6 registres ; il couvre tout ce que les plans reels contiennent, et la FORME de chaque champ (scalaire / objet / table) corresp | | P62 | Schema du plan : il decrit tout ce que le MOTEUR accepte | AFF-033 | ✅ OK | Les 4 validateurs n'acceptent aucun champ que le schema ignore (applications:8, bases_donnees:4, domaines_publics:5, serveurs:3 champ(s) lus par validateur). | | P63 | cloud-init nait avec la VM et ne lui survit pas | — | ✅ OK | cloud-init est au gabarit (la premiere seconde), absent du socle (pas de va-et-vient), et retire par le durcissement — avec la garde qui verifie que le reseau s | diff --git a/docs/audit/wiki-publie.yml b/docs/audit/wiki-publie.yml index cc51b7b..ba74b64 100644 --- a/docs/audit/wiki-publie.yml +++ b/docs/audit/wiki-publie.yml @@ -1,5 +1,5 @@ --- # Ecrit par `make wiki-publier`, lu par la preuve P60. Ne pas editer a la main. remote: ssh://git@forge.genese.internal/genome/set-ops-public.wiki.git -source: 53e2f78 +source: 5f5af70 date: 2026-09-11 diff --git a/docs/runbooks-exploitation.md b/docs/runbooks-exploitation.md index 6a32e14..fc646df 100644 --- a/docs/runbooks-exploitation.md +++ b/docs/runbooks-exploitation.md @@ -282,3 +282,47 @@ connue et courte. Deux remèdes de fond existent, aucun n'est appliqué : *Une dépendance qu'on documente sans la mesurer reste une dépendance qu'on découvrira au mauvais moment.* + +## 8. Les contrôles à la demande — ce que `make prouver` ne peut pas voir + +`make prouver` est **statique** : il lit le dépôt, zéro appel réseau. C'est ce qui le rend +rejouable partout, par n'importe qui, et présentable comme pièce justificative. Le prix de +cette propriété : il ne peut rien dire de ce qui ne s'observe qu'en ouvrant une connexion. + +Quatre contrôles comblent ce creux. Aucun ne corrige quoi que ce soit — ils regardent, et +rendent `0` si tout concorde. + +| Contrôle | Ce qu'il compare | Le piège qu'il attrape | +| --- | --- | --- | +| `make expositions-etat` | Expositions du plan ↔ **SAN du certificat servi** ↔ code du vhost | Un renommage déployé partout **sauf** dans le certificat | +| `make gabarit-etat` | Gabarit déclaré ↔ VM modèle réelle | Le modèle a dérivé de ce que le plan promet | +| `make routes-fabric-etat` | Zones déclarées ↔ routes déclarées ↔ routes vivantes | Une route **vivante mais non déclarée** — elle part au redémarrage | +| `make frontiere-plan` | Registre des flux ↔ règles de la frontière | Une règle posée à la main, qu'aucune déclaration ne porte | + +Ajouter `SITE=1` à `expositions-etat` pour interroger l'écosystème du SITE plutôt que +l'instance montée. + +### Pourquoi `expositions-etat` existe + +Renommer une exposition touche cinq choses. Quatre suivent au déploiement ; la cinquième, +non : + +``` +serveur_powerdns la zone publie le nouveau nom ✓ +serveur_keycloak le client OIDC accepte le retour ✓ +le service il fabrique ses URL avec le bon nom ✓ (P67) +serveur_nginx le vhost répond sur le nouveau nom ✓ +client_pki le SAN du certificat porte le nom ✗ il faut le rejouer +``` + +Le symptôme est trompeur : le site répond, la page s'affiche, et c'est le **navigateur** +qui refuse — avec une erreur de certificat que personne ne relie à un renommage fait la +veille. Mesuré deux fois le 2026-09-10, sur `grafana → observatoire` puis `icinga → vigie`. + +Le contrôle regarde **dans les deux sens**. Un nom resté dans le SAN après avoir quitté le +plan est un nom que le certificat continue d'authentifier : c'est exactement ce qu'avait +laissé le premier renommage, jusqu'au passage de `client_pki`. + +> Un `INJOIGNABLE` ne condamne pas le service : il dit que **ce poste** n'a pas pu ouvrir +> la connexion. Les zones du SITE ne sont pas routées depuis le plan d'administration du +> locataire — le mur est la frontière, pas le vhost. diff --git a/scripts/expositions_etat.py b/scripts/expositions_etat.py new file mode 100644 index 0000000..2525cf7 --- /dev/null +++ b/scripts/expositions_etat.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Chaque exposition du plan est-elle VRAIMENT servie, et par le bon certificat ? +Ne corrige rien. + +POURQUOI CE CONTROLE EXISTE (2026-09-11). + +Renommer une exposition touche cinq choses, et une seule ne suit pas toute seule. Mesure +deux fois le 2026-09-10, sur `grafana -> observatoire` puis sur `icinga -> vigie` : + + serveur_powerdns la zone publie le nouveau nom ✓ au deploiement + serveur_keycloak le client OIDC accepte le retour ✓ au deploiement + le service il fabrique ses URL avec le bon nom ✓ (P67) + serveur_nginx le vhost repond sur le nouveau nom ✓ au deploiement + client_pki le SAN du certificat porte le nom ✗ PAS au deploiement + +`serveur_nginx` pose le vhost et laisse le SAN en arriere : c'est `client_pki` qui reemet, +et rien ne le reclame. Le symptome est trompeur — le site repond, la page s'affiche, et +c'est le NAVIGATEUR qui refuse, avec une erreur de certificat que personne ne relie a un +renommage fait la veille. + +CE QU'ON COMPARE, ET DANS LES DEUX SENS : + + 1. les expositions DECLAREES par `plan/applications.yml` (la verite) ; + 2. les noms PORTES par le certificat reellement SERVI (pas celui sur le disque) ; + 3. le code que le vhost REND pour ce nom. + +Le sens inverse compte autant : un nom qui reste dans le SAN apres avoir disparu du plan +est un nom que le certificat continue d'authentifier. C'est exactement ce qu'a laisse le +premier renommage, jusqu'au passage de `client_pki`. + +POURQUOI CE N'EST PAS UNE PREUVE DU HARNAIS. `make prouver` est STATIQUE : il lit le +depot, zero appel reseau, et c'est ce qui le rend rejouable partout. Rien de statique ne +peut lire un certificat SERVI — il faut ouvrir la connexion. C'est donc un controle a la +demande, comme `make gabarit-etat` et `make routes-fabric-etat`. + +Usage : + python3 scripts/expositions_etat.py # l'instance montee + python3 scripts/expositions_etat.py --site # l'ecosysteme du SITE +""" +from __future__ import annotations + +import re +import subprocess +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +RACINE = Path(__file__).resolve().parent.parent + +# LE PORT EST UNE CONVENTION, PAS UNE DERIVATION. Le champ `port:` du plan est celui que +# le service ECOUTE en local (Forgejo 3000), pas celui sous lequel il est EXPOSE. Toutes +# les expositions de Set-OPS sont servies en TLS sur 443 ; le jour ou ce ne sera plus vrai, +# c'est ici qu'il faudra le declarer. +PORT = 443 + + +def _san_servi(adresse: str, fqdn: str) -> tuple[list[str], str]: + """Les noms du certificat que le serveur PRESENTE pour ce SNI. ([], raison) si muet.""" + try: + poignee = subprocess.run( + ["openssl", "s_client", "-connect", f"{adresse}:{PORT}", + "-servername", fqdn, "-verify_quiet"], + stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=20) + except subprocess.TimeoutExpired: + return [], "silence (aucune reponse TLS)" + if "BEGIN CERTIFICATE" not in poignee.stdout: + premiere = (poignee.stderr or "").strip().splitlines() + return [], (premiere[0][:70] if premiere else "aucun certificat presente") + texte = subprocess.run( + ["openssl", "x509", "-noout", "-ext", "subjectAltName"], + input=poignee.stdout, capture_output=True, text=True, timeout=20).stdout + return sorted(set(re.findall(r"DNS:([^\s,]+)", texte))), "" + + +def _code_http(adresse: str, fqdn: str) -> str: + r = subprocess.run( + ["curl", "-sk", "-o", "/dev/null", "-w", "%{http_code}", "--max-time", "12", + "--resolve", f"{fqdn}:{PORT}:{adresse}", f"https://{fqdn}/"], + capture_output=True, text=True, timeout=25) + return (r.stdout or "000").strip() + + +def _expositions_et_porteurs(site: bool) -> tuple[dict[str, tuple[str, str]], str]: + """{fqdn expose: (adresse qui le sert, nom court du porteur)}. L'adresse vient de `sans_exposition`, pose par + le generateur sur l'hote dont les groupes contiennent l'edge de cette exposition — + la MEME derivation que celle qui alimente le certificat. Interroger une autre source + reviendrait a fabriquer une troisieme liste.""" + import yaml + if site: + # L'INVENTAIRE DU SITE EST DYNAMIQUE, PAS STATIQUE : il rend + # `{groupe: {hosts: [noms]}, _meta: {hostvars: {...}}}` — la forme qu'Ansible + # attend d'un script, et non l'arbre `all.children` d'un `hosts.yml`. + import site_inventaire + inv = site_inventaire.inventaire() + hotes = dict((inv.get("_meta") or {}).get("hostvars") or {}) + etiquette = "SITE" + else: + from inventory_rules import instance_courante + chemin = instance_courante().resolve() + fichier = next(iter(sorted((chemin / "inventories").glob("*/hosts.yml"))), None) + if not fichier: + return {}, "" + data = yaml.safe_load(fichier.read_text(encoding="utf-8")) or {} + enfants = (data.get("all") or {}).get("children") or {} + hotes = {} + for etat in ("hotes_actifs", "hotes_planifies"): + for nom, v in ((enfants.get(etat) or {}).get("hosts") or {}).items(): + hotes[nom] = v or {} + etiquette = chemin.name + + porteurs: dict[str, tuple[str, str]] = {} + for nom, v in hotes.items(): + adresse = str(v.get("ansible_host") or "") + for fqdn in (v.get("sans_exposition") or []): + if adresse: + porteurs[str(fqdn)] = (adresse, str(nom)) + if porteurs: + return porteurs, etiquette + + # PAS D'EDGE : LA MACHINE SERT SON PROPRE TLS (le cas du SITE). + # + # `sans_exposition` est pose sur l'hote dont les groupes contiennent l'EDGE de + # l'exposition. Le site n'en a aucun — `site-forge-01` ecoute lui-meme sur 443. Le + # porteur se derive alors de l'application : son `groupe` dit quel hote la sert. + # Deux formes de terminaison, une seule question posee. + import underlay as underlay_mod + apps = (underlay_mod.lire_plan_site("applications.yml") or {}).get("applications") or {} + hote_du_groupe: dict[str, tuple[str, str]] = {} + for nom, v in hotes.items(): + adresse = str(v.get("ansible_host") or "") + if adresse: + hote_du_groupe.setdefault(str(nom), (adresse, str(nom))) + for app in apps.values(): + if not isinstance(app, dict): + continue + cible = hote_du_groupe.get(str(app.get("hote") or "")) + if not cible: + continue + for fqdn in (app.get("expose") or []): + porteurs[str(fqdn)] = cible + return porteurs, etiquette + + +def main() -> int: + site = "--site" in sys.argv[1:] + porteurs, etiquette = _expositions_et_porteurs(site) + if not porteurs: + print("Aucune exposition derivee : rien a comparer. " + "(`make instancier` a-t-il tourne ?)") + return 0 + + print(f"{etiquette} : {len(porteurs)} exposition(s) declaree(s), " + f"servies sur le port {PORT}.\n") + + ecarts: list[str] = [] + # Un meme porteur sert souvent plusieurs noms : on ne lit son certificat qu'une fois + # par (adresse, sni) et on garde le SAN pour la comparaison inverse. + san_par_adresse: dict[str, list[str]] = {} + + noms_propres: dict[str, str] = {a: n for a, n in porteurs.values()} + for fqdn, (adresse, _porteur) in sorted(porteurs.items()): + san, raison = _san_servi(adresse, fqdn) + if not san: + print(f" {fqdn:<34} {adresse:<14} INJOIGNABLE — {raison}") + ecarts.append(f"{fqdn} : {raison} (depuis CE poste ; " + f"la frontiere peut etre le mur, pas le service)") + continue + san_par_adresse.setdefault(adresse, san) + code = _code_http(adresse, fqdn) + dans_le_san = fqdn in san + etat = "OK" if dans_le_san and code.startswith(("2", "3")) else "ECART" + print(f" {fqdn:<34} {adresse:<14} cert={'oui' if dans_le_san else 'NON'} " + f"http={code} {etat}") + if not dans_le_san: + ecarts.append(f"{fqdn} : le certificat SERVI ne porte pas ce nom — " + f"rejouer `client_pki` sur le porteur ; `serveur_nginx` " + f"seul ne reemet pas le SAN") + elif not code.startswith(("2", "3")): + ecarts.append(f"{fqdn} : le certificat porte le nom mais le vhost rend " + f"{code} — le nom est authentifie, rien ne le sert") + + # LE SENS INVERSE : un nom reste dans le SAN apres avoir quitte le plan. + declares = set(porteurs) + for adresse, san in sorted(san_par_adresse.items()): + propre = noms_propres.get(adresse, "") + for nom in san: + if nom in declares: + continue + # LE PORTEUR S'AUTHENTIFIE SOUS SON PROPRE NOM, et ce n'est pas un reste : + # `client_pki` met toujours le FQDN et le nom court de la machine dans le SAN. + # Les confondre avec un vestige de renommage ferait crier ce controle a chaque + # execution — un controle qui crie toujours ne se lit plus. + if propre and nom.split(".")[0] == propre: + continue + ecarts.append(f"{nom} : porte par le certificat de {adresse} alors " + f"qu'aucune application ne l'expose — reste d'un " + f"renommage, encore authentifie") + + print() + if ecarts: + print(f"ECART — {len(ecarts)} :") + for e in ecarts: + print(f" - {e}") + return 1 + print("Conforme : chaque exposition declaree est servie, sous un certificat qui la " + "porte, et le certificat ne porte rien d'autre.") + return 0 + + +if __name__ == "__main__": + sys.exit(main())