Nouveau · l'app mobile, second appareil pour relire et signer chaque ordre
kantamaSe connecterCréer un espace

Export et résiliation

Exportez l'Activité de votre espace dans un fichier que vous pouvez vérifier vous-même, sans Kantama. Et si vous partez : comment résilier, ce que font vos agents, ce qui est gardé et pour combien de temps.

13 minutesMis à jour le 18 novembre 2026

Exporter l'Activité

Sur la page Activité, Exporter propose deux fichiers : un JSON vérifiable et un CSV lisible dans un tableur (une ligne par événement). L'export fait partie d'Équipe et d'Entreprise ; dans toutes les formules, il reste possible pendant les 30 jours qui suivent une résiliation.

kantama-activite-atelier-2026-11-16.json
{"format": "kantama/export-activite/v1", "genere_le": 1794…,
 "espace": {"slug": "atelier", "formule": "equipe", "retention_j": 30, "resilie_le": null},
 "journal": {"reprise": {"jusqua": 1824, "empreinte": "9f2c…"}, "tete": "…", "evenements": [
   {"seq": 1825, "type": "journal.reprise", "at": 1794…, "data": {…}, "precedente": "…", "empreinte": "…"}, …]},
 "agents": [{"id": "agt_…", "empreinte": "c41e9a075d2f7be0", "cle_publique": "<Ed25519, 32 octets>"}],
 "ordres": [{"id": "ord_…", "action": "core.deploy", "octets": "<octets exacts signés>",
   "approbations": [{"nom": "Awa", "credential_id": "…", "client_data_json": "…", "signature": "…"}],
   "recu": {"octets": "…", "signature": "…"}, "resultat": {"octets": "…", "signature": "…"},
   "lignes": [{"seq": 1, "etape": "build", "texte": "…"}]}]}
  • Journal : chaque événement avec son empreinte et celle du précédent, et le point de reprise si le début a été effacé.
  • Ordres : les octets exacts de chaque ordre, les signatures des passkeys, le reçu et le résultat signés par l'agent, octet pour octet, et le déroulé de l'exécution.
  • Agents : la clé publique de chaque agent, qui permet de vérifier ses signatures.

Vérifier un export hors ligne

Ce script, sans dépendance (Python 3.10 ou plus récent), refait tous les calculs sur votre machine : la chaîne du journal depuis son début ou son point de reprise, l'empreinte de chaque ordre, le défi signé par chaque passkey, et la signature Ed25519 de l'agent sur chaque reçu et chaque résultat.

verifier_export.py
"""Vérifie hors ligne un export de l'Activité Kantama (kantama/export-activite/v1) ou un rapport de conformité
(kantama/conformite/v1, en JSON ou dans sa page imprimable). Python 3.10+, sans dépendance, sans réseau.

    python verifier_export.py kantama-activite-mon-espace-2026-11-16.json
    python verifier_export.py kantama-conformite-mon-espace-2026-11-30-cnf_….html
"""
import base64, hashlib, json, re, sys

# Ed25519 (RFC 8032), vérification seulement.
P = 2**255 - 19
Q = 2**252 + 27742317777372353535851937790883648493
D = -121665 * pow(121666, P - 2, P) % P
RACINE = pow(2, (P - 1) // 4, P)


def _x(y, signe):
    if y >= P:
        return None
    x2 = (y * y - 1) * pow(D * y * y + 1, P - 2, P) % P
    if x2 == 0:
        return None if signe else 0
    x = pow(x2, (P + 3) // 8, P)
    if (x * x - x2) % P:
        x = x * RACINE % P
    if (x * x - x2) % P:
        return None
    return P - x if (x & 1) != signe else x


def _point(octets):
    y = int.from_bytes(octets, "little")
    x = _x(y & ((1 << 255) - 1), y >> 255)
    return None if x is None else (x, y & ((1 << 255) - 1), 1, x * (y & ((1 << 255) - 1)) % P)


def _plus(a, b):
    e, h = (a[1] - a[0]) * (b[1] - b[0]) % P, (a[1] + a[0]) * (b[1] + b[0]) % P
    c, d = 2 * a[3] * b[3] * D % P, 2 * a[2] * b[2] % P
    return ((h - e) * (d - c), (d + c) * (h + e), (d - c) * (d + c), (h - e) * (h + e))


def _fois(n, a):
    r = (0, 1, 1, 0)
    while n:
        if n & 1:
            r = _plus(r, a)
        a, n = _plus(a, a), n >> 1
    return r


GY = 4 * pow(5, P - 2, P) % P
G = (_x(GY, 0), GY, 1, _x(GY, 0) * GY % P)


def ed25519(cle, message, signature):
    if len(cle) != 32 or len(signature) != 64:
        return False
    a, r = _point(cle), _point(signature[:32])
    s = int.from_bytes(signature[32:], "little")
    if a is None or r is None or s >= Q:
        return False
    h = int.from_bytes(hashlib.sha512(signature[:32] + cle + message).digest(), "little") % Q
    g, d = _fois(s, G), _plus(r, _fois(h, a))
    return (g[0] * d[2] - d[0] * g[2]) % P == 0 and (g[1] * d[2] - d[1] * g[2]) % P == 0


def b64(texte):
    return base64.urlsafe_b64decode(texte + "=" * (-len(texte) % 4))


def canonique(objet):
    return json.dumps(objet, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()


def _chaine(evs, precedente, attendu):
    for e in evs:
        calcul = hashlib.sha256(precedente + b"\x00" + canonique({"seq": e["seq"], "type": e["type"], "at": e["at"], "data": e["data"]})).digest()
        if e["seq"] != attendu or bytes.fromhex(e["precedente"]) != precedente or calcul.hex() != e["empreinte"]:
            return [f"journal rompu à l'événement {e['seq']}"]
        precedente, attendu = calcul, attendu + 1
    return []


def _cles(agents, erreurs):
    cles = {}
    for a in agents:
        cle = b64(a["cle_publique"])
        if hashlib.sha256(cle).digest()[:8].hex() != a["empreinte"]:
            erreurs.append(f"agent {a['id']} : clé et empreinte différentes")
        cles[a["empreinte"]] = cle
    return cles


def _ordres(ordres, cles, recus_au_journal, debut_journal, erreurs, fin_journal=None):
    for o in ordres:
        octets = b64(o["octets"])
        if hashlib.sha256(octets).hexdigest() != o["octets_sha256"]:
            erreurs.append(f"ordre {o['id']} : octets modifiés")
            continue
        defi = hashlib.sha256(b"kantama/ordre/v1\x00" + octets).digest()
        for ap in o["approbations"]:
            client = json.loads(b64(ap["client_data_json"]))
            if client.get("type") != "webauthn.get" or b64(client.get("challenge", "")) != defi:
                erreurs.append(f"ordre {o['id']} : une signature de passkey ne porte pas sur ces octets")
        for nom, domaine in (("recu", b"kantama/recu/v1"), ("resultat", b"kantama/resultat/v1")):
            x = o.get(nom)
            if not x:
                continue
            brut, cle = b64(x["octets"]), cles.get(o["agent"])
            contenu = json.loads(brut)
            if cle is None or not ed25519(cle, domaine + b"\x00" + brut, b64(x["signature"])):
                erreurs.append(f"ordre {o['id']} : {nom} non signé par l'agent {o['agent']}")
            elif contenu.get("order_id") != o["id"] or contenu.get("order_sha256") != o["octets_sha256"] or contenu.get("agent") != o["agent"]:
                erreurs.append(f"ordre {o['id']} : {nom} d'un autre ordre")
            elif (nom == "recu" and recus_au_journal and hashlib.sha256(brut).hexdigest() not in recus_au_journal and o["cree_le"] >= debut_journal
                  and (fin_journal is None or contenu.get("at", 0) <= fin_journal)):
                erreurs.append(f"ordre {o['id']} : reçu absent du journal")


def verifier(export):
    erreurs = []
    if export.get("format") == "kantama/conformite/v1":
        return verifier_conformite(export)
    if export.get("format") != "kantama/export-activite/v1":
        return ["format inconnu"]
    # 1. Journal chaîné, depuis son début ou depuis le point de reprise qui l'ancre.
    evs = export["journal"]["evenements"]
    precedente, attendu = bytes(32), 1
    if evs and evs[0]["seq"] != 1:
        point = next((e["data"] for e in evs if e["type"] == "journal.reprise" and e["data"].get("jusqua") == evs[0]["seq"] - 1), None)
        if point is None:
            return [f"début du journal effacé sans point de reprise (premier événement : {evs[0]['seq']})"]
        precedente, attendu = bytes.fromhex(point["empreinte"]), point["jusqua"] + 1
    erreurs += _chaine(evs, precedente, attendu)
    recus_au_journal = {e["data"].get("recu_sha256") for e in evs if e["type"] == "ordre.recu_agent"}
    # 2. Agents : la clé publique correspond à l'empreinte affichée par l'agent.
    cles = _cles(export["agents"], erreurs)
    # 3. Ordres : octets exacts, défi signé par chaque passkey, reçu et résultat signés par l'agent.
    _ordres(export["ordres"], cles, recus_au_journal, evs[0]["at"] if evs else 0, erreurs)
    return erreurs


def _avis(cle, x, kind):
    """Octets d'un avis signé par l'agent (domaine kantama/avis/v1), ou None si la signature ne tient pas."""
    try:
        brut = b64(x["octets"])
        if cle is None or not ed25519(cle, b"kantama/avis/v1\x00" + brut, b64(x["signature"])):
            return None
        contenu = json.loads(brut)
    except ValueError:
        return None
    return contenu if isinstance(contenu, dict) and contenu.get("kind") in kind else None


def constats(r):
    """Les constats recalculés à partir des preuves jointes (mêmes règles que le central)."""
    ordres, membres = r["ordres"], [m for m in r["acces"]["membres"] if m["etat"] == "actif"]
    par = {}
    for o in ordres:
        par[o["statut"]] = par.get(o["statut"], 0) + 1
    essais, declarees = r["sauvegardes"]["essais"], r["sauvegardes"]["declarees"]
    reussis = {(e["agent"], e["nom"]) for e in essais if e["statut"] == "succeeded"}
    liste = r["derives"]["liste"]
    closes = lambda res: sum(1 for d in liste if d["etat"] == "close" and d.get("resolution") == res)  # noqa: E731
    sans = sorted(m["nom"] for m in membres if m["passkeys"] < 2)
    return {
        "ordres": {"total": len(ordres), "par_statut": dict(sorted(par.items()))},
        "preuves_agent": {"recus_signes": sum(1 for o in ordres if o.get("recu")), "resultats_signes": sum(1 for o in ordres if o.get("resultat"))},
        "membres_deux_passkeys": {"actifs": len(membres), "avec_deux_passkeys": len(membres) - len(sans), "moins_de_deux": sans},
        "restaurations": {"essais": len(essais), "reussis": sum(1 for e in essais if e["statut"] == "succeeded"),
                          "echoues": sum(1 for e in essais if e["statut"] != "succeeded"),
                          "declarees_sans_essai_reussi": sorted(f"{d['projet']} · {d['nom']}" for d in declarees if (d["agent"], d["nom"]) not in reussis)},
        "gels_politiques": {"ordres_gel": sum(1 for o in ordres if o["action"].startswith("core.freeze.") and o["statut"] == "succeeded"),
                            "ordres_politique": sum(1 for o in ordres if o["action"].startswith("core.policy.") and o["statut"] == "succeeded")},
        "derives": {"constatees": len(liste), "closes_par_ordre": closes("order"), "acceptees": closes("accepted"), "revenues": closes("observed"),
                    "ouvertes": sum(1 for d in liste if d["etat"] == "ouverte"), "pannes": sum(1 for d in liste if d["gravite"] == "outage")},
        **_constats_lot_l(r),
    }


def _constats_lot_l(r):
    """Revue des accès et ordres d'urgence (rapports de conformité générés depuis ce lot ; absents avant)."""
    sortie = {}
    if "revue_acces" in r:
        camp = r["revue_acces"]["campagnes"]
        closes = [x for x in camp if x["statut"] == "close"]
        sortie["revue_acces"] = {
            "campagnes": len(camp), "closes": len(closes),
            "elements_revus": sum(x["resume"].get("confirmes", 0) + x["resume"].get("retires", 0) for x in closes),
            "retires": sum(x["resume"].get("retires", 0) for x in closes),
            "non_revus_a_echeance": sum(x["resume"].get("non_revus_a_echeance", 0) for x in camp),
            "en_retard": sum(1 for x in camp if x["statut"] == "en_cours" and x.get("en_retard_le")),
        }
    if any(c["id"] == "acces_urgence" for c in r["constats"]):
        u = [o for o in r["ordres"] if o.get("octets") and isinstance(json.loads(b64(o["octets"])).get("emergency"), dict)]
        sortie["acces_urgence"] = {
            "ordres_urgence": len(u), "executes": sum(1 for o in u if o["statut"] == "succeeded"),
            "revus": sum(1 for o in u if o.get("urgence_revue")),
            "non_revus": sum(1 for o in u if not o.get("urgence_revue") and o["statut"] in ("succeeded", "failed", "refused", "expired", "abandoned")),
        }
    return sortie


def _revues(r, erreurs):
    """Chaque rapport de revue clos : son empreinte, et la passkey du gestionnaire qui l'a confirmé sur
    SHA-256("kantama/revue-acces/v1" ‖ 0x00 ‖ octets) (défi lu dans clientDataJSON, comme pour les ordres)."""
    for x in (r.get("revue_acces") or {}).get("campagnes", []):
        if x["statut"] != "close":
            continue
        octets = b64(x.get("rapport") or "")
        conf = x.get("confirmation") or {}
        if hashlib.sha256(octets).hexdigest() != x.get("rapport_sha256"):
            erreurs.append(f"revue des accès {x['id']} : rapport différent de son empreinte")
            continue
        rapport = json.loads(octets)
        if rapport.get("format") != "kantama/revue-acces/v1" or rapport.get("id") != x["id"] or rapport.get("resume") != x["resume"]:
            erreurs.append(f"revue des accès {x['id']} : rapport incohérent")
        try:
            client = json.loads(b64(conf.get("client_data_json", "")))
        except ValueError:
            client = {}
        defi = hashlib.sha256(b"kantama/revue-acces/v1\x00" + octets).digest()
        if client.get("type") != "webauthn.get" or b64(client.get("challenge", "")) != defi:
            erreurs.append(f"revue des accès {x['id']} : la passkey du gestionnaire n'a pas confirmé ce rapport")


def verifier_conformite(r):
    erreurs = []
    if hashlib.sha256(canonique({k: v for k, v in r.items() if k != "empreinte"})).hexdigest() != r.get("empreinte"):
        erreurs.append("rapport modifié : son empreinte ne correspond plus à son contenu")
    # 1. Segment du journal de la période, ancré sur l'événement qui le précède.
    j, evs = r["journal"], r["journal"]["evenements"]
    if evs:
        ancre = j.get("ancre") or {"seq": 0, "empreinte": "00" * 32}
        erreurs += _chaine(evs, bytes.fromhex(ancre["empreinte"]), ancre["seq"] + 1)
    par_seq = {e["seq"]: e for e in evs}
    recus_au_journal = {e["data"].get("recu_sha256") for e in evs if e["type"] == "ordre.recu_agent"}
    # 2. Agents, puis ordres (octets, passkeys, reçus et résultats signés).
    cles = _cles(r["agents"], erreurs)
    _ordres(r["ordres"], cles, recus_au_journal, evs[0]["at"] if evs else 0, erreurs, evs[-1]["at"] if evs else 0)
    resultats = {o["id"]: o.get("resultat") for o in r["ordres"]}
    # 3. Dérives : chaque avis signé par l'agent, au journal ; une dérive close l'est par un avis signé.
    for d in r["derives"]["liste"]:
        fin = None
        for x in d["avis"]:
            contenu = _avis(cles.get(d["agent"]), x, ("drift",))
            if contenu is None or contenu.get("agent") != d["agent"] or contenu.get("id") != d["cle"]:
                erreurs.append(f"dérive {d['id']} : avis non signé par l'agent {d['agent']}")
                continue
            sha = hashlib.sha256(b64(x["octets"])).hexdigest()
            ev = par_seq.get(x.get("journal_seq"))
            if x.get("journal_seq") is not None and (ev is None and evs and evs[0]["seq"] <= x["journal_seq"] <= evs[-1]["seq"] or ev and ev["data"].get("avis_sha256") != sha):
                erreurs.append(f"dérive {d['id']} : avis absent du journal")
            if contenu.get("status") == "resolved":
                fin = contenu
        if d["etat"] == "close" and (fin is None or fin.get("resolution") != d.get("resolution") or (fin.get("order_id") or None) != d.get("ordre_id")):
            erreurs.append(f"dérive {d['id']} : close sans avis de fin signé qui le dise")
    for x in r["derives"]["attestations"]:
        contenu = _avis(cles.get(x["agent"]), x, ("drift.state",))
        if contenu is None or contenu.get("agent") != x["agent"]:
            erreurs.append(f"attestation de l'agent {x['agent']} : non signée par lui")
    # 4. Essais de restauration : l'avis signé du planning, ou le résultat signé de l'ordre.
    for e in r["sauvegardes"]["essais"]:
        preuve = e.get("preuve") or (resultats.get(e.get("ordre_id")) if e.get("ordre_id") else None)
        if preuve is None:
            continue
        brut = b64(preuve["octets"])
        domaine = b"kantama/avis/v1" if e.get("preuve") else b"kantama/resultat/v1"
        cle = cles.get(e["agent"])
        if cle is None or not ed25519(cle, domaine + b"\x00" + brut, b64(preuve["signature"])) or hashlib.sha256(brut).hexdigest() != e["preuve_sha256"]:
            erreurs.append(f"essai de restauration {e['projet']} · {e['nom']} : preuve non signée par l'agent")
    # 4 bis. Revue des accès (lot L) : chaque rapport clos, confirmé par la passkey d'un gestionnaire.
    _revues(r, erreurs)
    # 5. Constats : recalculés à partir des preuves jointes.
    calcules = constats(r)
    for c in r["constats"]:
        if c["id"] in calcules and calcules[c["id"]] != c["valeur"]:
            erreurs.append(f"constat « {c['id']} » différent de ce que disent les preuves jointes")
    return erreurs


def lire(chemin):
    with open(chemin, encoding="utf-8") as f:
        texte = f.read()
    m = re.search(r"<script type='application/json' id='kantama-conformite'>(.*?)</script>", texte, re.S)
    return json.loads(m.group(1) if m else texte)


if __name__ == "__main__":
    document = lire(sys.argv[1])
    erreurs = verifier(document)
    j = document.get("journal", {})
    if document.get("format") == "kantama/conformite/v1":
        print(f"rapport {document.get('id')} · {len(j.get('evenements', []))} événements, {len(document.get('ordres', []))} ordres, "
              f"{len(document.get('derives', {}).get('liste', []))} dérive(s), {len(document.get('constats', []))} constats")
    else:
        print(f"{len(j.get('evenements', []))} événements, {len(document.get('ordres', []))} ordres, {len(document.get('agents', []))} agent(s)")
        if j.get("reprise"):
            print(f"point de reprise : événements 1 à {j['reprise']['jusqua']} effacés (rétention), empreinte {j['reprise']['empreinte'][:16]}…")
        print(f"tête de chaîne : {j.get('tete')}")
    for e in erreurs:
        print("ÉCHEC :", e)
    if erreurs:
        print(f"{len(erreurs)} problème(s).")
    elif document.get("format") == "kantama/conformite/v1":
        print("Rapport vérifié : journal intact, preuves signées par les agents et les passkeys, constats conformes aux preuves.")
    else:
        print("Export vérifié : chaîne intacte, reçus et résultats signés par les agents.")
    sys.exit(1 if erreurs else 0)
Terminal
python verifier_export.py kantama-activite-atelier-2026-11-16.json
# 214 événements, 31 ordres, 2 agent(s)
# tête de chaîne : 5be1…
# Export vérifié : chaîne intacte, reçus et résultats signés par les agents.

Notez la tête de chaîne : un export suivant doit contenir le même événement avec la même empreinte. Comparez aussi l'empreinte de chaque agent avec celle qu'il affiche sur son serveur. Les signatures des passkeys ne sont vérifiées ici que pour ce qu'elles signent (le défi de l'ordre) : c'est l'agent qui les vérifie, et son reçu signé en témoigne.

Le même script vérifie un rapport de conformité (Entreprise), en JSON ou dans sa page imprimable.

Résilier l'espace

Dans l'écran Formule, la zone Résilier l'espace est réservée au propriétaire et aux membres qui signent dans tous les environnements.

  1. Vous tapez l'adresse de l'espace.
  2. Votre passkey signe une fermeture (core.space.close) pour chaque agent. Elle reste chez Kantama, retenue, tant que vous n'avez pas confirmé.
  3. Vous confirmez avec votre passkey : l'espace passe en lecture seule et chaque fermeture part à son agent. Un agent hors ligne reçoit la sienne à sa reconnexion (elle reste valable 30 jours).

Un agent d'une version antérieure ne connaît pas la fermeture : la console le signale. Mettez-le à jour, ou arrêtez-le et retirez-le de vos serveurs : il accepterait encore des ordres signés par vos passkeys.

30 jours de lecture seule

  • Toute la console se consulte ; un bandeau rappelle jusqu'à quand. L'export de l'Activité est ouvert à toutes les formules.
  • Plus rien ne se prépare, ne se signe ni ne s'ajoute, sauf la fermeture d'un agent qui ne l'a pas encore reçue, et sa réouverture.
  • Les ordres qui attendaient une signature sont abandonnés. Rien n'est plus effacé pendant ces 30 jours : tout ce qui existait reste exportable.
  • L'abonnement s'arrête le jour de la résiliation, sans remboursement de la période en cours ; une facture qui restait à régler est annulée.

Rouvrir l'espace

Pendant les 30 jours, un gestionnaire peut rouvrir l'espace avec sa passkey. Il revient en Solo (l'abonnement arrêté ne reprend pas). Chaque agent déjà fermé se rouvre par un ordre signé, core.space.reopen, que la console prépare : sans lui, l'agent continue de tout refuser.

Après 30 jours

Les données de l'espace sont supprimées définitivement : Activité, projets, agents, membres, passkeys, alertes, erreurs, variables chiffrées. Seules restent les factures et leurs règlements, que la loi impose de conserver ; l'espace n'y figure plus que sous un nom anonyme. L'adresse de l'espace et les adresses e-mail des membres redeviennent libres. Sur vos serveurs, l'agent garde sa fermeture : désinstallez-le quand vous le souhaitez.

Cette page vous a-t-elle aidé ?Modifier cette page

Les propositions de modification de la documentation ne sont pas encore ouvertes au public.