intermesh 0.3.0__py3-none-any.whl

intermesh/crypto.py

@@ -0,0 +1,150 @@
+import base64
+import json
+import os
+
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+
+def generate_keypair():
+    """Génère une paire de clés RSA-2048."""
+    return rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+
+def get_public_key_pem(private_key) -> str:
+    """Exporte la clé publique au format PEM."""
+    return private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo
+    ).decode("utf-8")
+
+
+def get_private_key_pem(private_key) -> str:
+    """Exporte la clé privée au format PEM."""
+    return private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption()
+    ).decode("utf-8")
+
+
+def load_public_key(pem_string: str):
+    """Charge une clé publique depuis un PEM."""
+    return serialization.load_pem_public_key(pem_string.encode("utf-8"))
+
+
+def load_private_key(pem_string: str):
+    """Charge une clé privée depuis un PEM."""
+    return serialization.load_pem_private_key(pem_string.encode("utf-8"), password=None)
+
+
+def encrypt_for(recipient_public_key_pem: str, plaintext: str) -> str:
+    """Chiffrement hybride RSA-OAEP + AES-256-GCM."""
+    plaintext_bytes = plaintext.encode("utf-8")
+    aes_key = AESGCM.generate_key(bit_length=256)
+    nonce = os.urandom(12)
+    aesgcm = AESGCM(aes_key)
+    ciphertext = aesgcm.encrypt(nonce, plaintext_bytes, None)
+    pub_key = load_public_key(recipient_public_key_pem)
+    encrypted_aes_key = pub_key.encrypt(
+        aes_key,
+        padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None)
+    )
+    envelope = {
+        "ek": base64.b64encode(encrypted_aes_key).decode(),
+        "n": base64.b64encode(nonce).decode(),
+        "ct": base64.b64encode(ciphertext).decode()
+    }
+    return base64.b64encode(json.dumps(envelope).encode()).decode()
+
+
+def decrypt_with(private_key, encrypted_b64: str) -> str:
+    """Déchiffrement hybride RSA-OAEP + AES-256-GCM."""
+    envelope = json.loads(base64.b64decode(encrypted_b64))
+    aes_key = private_key.decrypt(
+        base64.b64decode(envelope["ek"]),
+        padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None)
+    )
+    aesgcm = AESGCM(aes_key)
+    return aesgcm.decrypt(base64.b64decode(envelope["n"]), base64.b64decode(envelope["ct"]), None).decode("utf-8")
+
+
+# --- CHIFFREMENT AU REPOS PAR PASSPHRASE (PBKDF2 + AES-256-GCM) ---
+
+PBKDF2_ITERATIONS = 100_000
+
+
+def _derive_key(passphrase: str, salt: bytes) -> bytes:
+    """Dérive une clé AES-256 depuis une passphrase, via PBKDF2-HMAC-SHA256."""
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=PBKDF2_ITERATIONS,
+    )
+    return kdf.derive(passphrase.encode("utf-8"))
+
+
+def encrypt_blob(plaintext: str, passphrase: str) -> dict:
+    """
+    Chiffre un texte quelconque avec une passphrase.
+
+    Retourne un dict JSON-sérialisable (`salt`/`nonce`/`ciphertext` en
+    base64) : le sel est stocké en clair, il n'est pas secret — il empêche
+    seulement de pré-calculer une table pour toutes les passphrases.
+    """
+    salt = os.urandom(16)
+    nonce = os.urandom(12)
+    ciphertext = AESGCM(_derive_key(passphrase, salt)).encrypt(
+        nonce, plaintext.encode("utf-8"), None
+    )
+    return {
+        "salt": base64.b64encode(salt).decode("utf-8"),
+        "nonce": base64.b64encode(nonce).decode("utf-8"),
+        "ciphertext": base64.b64encode(ciphertext).decode("utf-8"),
+    }
+
+
+def decrypt_blob(blob: dict, passphrase: str) -> str:
+    """
+    Déchiffre un blob produit par `encrypt_blob`.
+
+    Raises:
+        cryptography.exceptions.InvalidTag: passphrase incorrecte, ou
+            contenu altéré — AES-GCM ne distingue pas les deux cas, et
+            c'est voulu : les deux signifient « ne fais pas confiance ».
+    """
+    key = _derive_key(passphrase, base64.b64decode(blob["salt"]))
+    return AESGCM(key).decrypt(
+        base64.b64decode(blob["nonce"]),
+        base64.b64decode(blob["ciphertext"]),
+        None,
+    ).decode("utf-8")
+
+
+# --- COFFRE-FORT DE CLÉS LOCAL CHIFFRÉ (LOCAL KEY VAULT) ---
+
+def save_encrypted_vault(file_path: str, private_key_pem: str, passphrase: str):
+    """
+    Chiffre et sauvegarde la clé privée sur le disque avec PBKDF2 (100 000 itérations) + AES-256-GCM.
+    """
+    vault_data = encrypt_blob(private_key_pem, passphrase)
+    vault_data["version"] = "nexus_vault_v1"
+
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as f:
+        json.dump(vault_data, f, indent=2)
+
+    # Restreindre les permissions du fichier sous Linux (600 = lecture/écriture propriétaire seul)
+    os.chmod(file_path, 0o600)
+
+
+def load_encrypted_vault(file_path: str, passphrase: str) -> str:
+    """
+    Déchiffre et charge la clé privée depuis le coffre-fort local.
+    """
+    with open(file_path, "r", encoding="utf-8") as f:
+        vault_data = json.load(f)
+    return decrypt_blob(vault_data, passphrase)

intermesh/egress.py

@@ -0,0 +1,180 @@
+"""
+Filtrage de sortie : ce qu'une organisation accepte de laisser franchir
+sa frontière.
+
+L'isolement multi-tenant, le pairage explicite et la signature Ed25519
+répondent à « qui parle à qui ». Ils ne disent rien de « ce qui sort » :
+une fois le lien de fédération établi, un agent peut transmettre à un
+partenaire n'importe quel contenu auquel il a accès. C'est le manque que
+ce module comble.
+
+Deux points d'application, parce qu'ils ne voient pas la même chose :
+
+  * L'agent émetteur (SDK), avant chiffrement. C'est le seul endroit où le
+    contenu est en clair sur le chemin nominal, donc le seul filtre qui
+    morde réellement quand le chiffrement E2E est actif.
+  * Le Hub, au moment de relayer vers un pair. Il ne voit que ce qui n'est
+    pas chiffré, mais il applique la politique même à un agent qui ne
+    l'aurait pas fait — un agent est du code, pas une autorité.
+
+Ni l'un ni l'autre ne protège d'un agent interne malveillant qui
+chiffrerait lui-même avant l'envoi. Le filtre d'egress traite la fuite
+par négligence, pas l'exfiltration délibérée.
+
+Politique vide par défaut : rien n'est filtré tant que rien n'est déclaré.
+Caviarder en silence serait pire que ne pas filtrer.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+REDACT = "redact"
+DROP = "drop"
+BLOCK = "block"
+ACTIONS = (REDACT, DROP, BLOCK)
+
+DEFAULT_REPLACEMENT = "[REDACTED]"
+ANY_ORG = "*"
+
+
+class EgressBlocked(PermissionError):
+    """Le contenu contient quelque chose qui ne doit pas franchir la frontière."""
+
+    def __init__(self, rule_name: str, target_org: str):
+        self.rule_name = rule_name
+        self.target_org = target_org
+        super().__init__(
+            f"EGRESS_BLOCKED: la règle '{rule_name}' interdit d'envoyer ce contenu "
+            f"à l'organisation '{target_org}'."
+        )
+
+
+@dataclass
+class EgressRule:
+    """Une règle de sortie.
+
+    `action` :
+      - `redact` : remplace les portions de texte correspondant à `pattern`.
+      - `drop`   : supprime toute clé nommée `field` (à n'importe quelle
+                   profondeur), quelle que soit sa valeur.
+      - `block`  : refuse l'envoi entier si `pattern` apparaît.
+
+    `to_orgs` restreint la règle à certaines organisations destinataires ;
+    `["*"]` l'applique à toute sortie hors de l'organisation.
+    """
+
+    name: str
+    action: str
+    pattern: str | None = None
+    field_name: str | None = None
+    replacement: str = DEFAULT_REPLACEMENT
+    to_orgs: list[str] = field(default_factory=lambda: [ANY_ORG])
+
+    def __post_init__(self):
+        if self.action not in ACTIONS:
+            raise ValueError(f"action inconnue : {self.action!r} (attendu {ACTIONS})")
+        if self.action in (REDACT, BLOCK) and not self.pattern:
+            raise ValueError(f"règle '{self.name}' : action {self.action} exige un `pattern`")
+        if self.action == DROP and not self.field_name:
+            raise ValueError(f"règle '{self.name}' : action drop exige un `field`")
+        self._compiled = re.compile(self.pattern, re.IGNORECASE) if self.pattern else None
+
+    def applies_to(self, target_org: str) -> bool:
+        return ANY_ORG in self.to_orgs or target_org in self.to_orgs
+
+    @classmethod
+    def from_dict(cls, raw: dict) -> "EgressRule":
+        return cls(
+            name=raw["name"],
+            action=raw["action"],
+            pattern=raw.get("pattern"),
+            field_name=raw.get("field"),
+            replacement=raw.get("replacement", DEFAULT_REPLACEMENT),
+            to_orgs=raw.get("to_orgs", [ANY_ORG]),
+        )
+
+
+@dataclass
+class EgressPolicy:
+    name: str = "empty"
+    rules: list[EgressRule] = field(default_factory=list)
+
+    def rules_for(self, target_org: str) -> list[EgressRule]:
+        return [r for r in self.rules if r.applies_to(target_org)]
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.rules
+
+    @classmethod
+    def from_dict(cls, raw: dict) -> "EgressPolicy":
+        return cls(
+            name=raw.get("name", "unnamed"),
+            rules=[EgressRule.from_dict(r) for r in raw.get("rules", [])],
+        )
+
+    @classmethod
+    def load(cls, path: str | Path) -> "EgressPolicy":
+        return cls.from_dict(json.loads(Path(path).read_text(encoding="utf-8")))
+
+
+def apply_egress(payload: Any, target_org: str, policy: EgressPolicy | None
+                 ) -> tuple[Any, list[str]]:
+    """Applique la politique de sortie à `payload`.
+
+    Retourne le contenu filtré et la liste des noms de règles déclenchées —
+    des *noms*, jamais les valeurs retirées : un journal d'audit ne doit pas
+    devenir l'endroit où fuit ce qu'on vient de caviarder.
+
+    Raises:
+        EgressBlocked: si une règle `block` correspond.
+    """
+    if policy is None or policy.is_empty:
+        return payload, []
+
+    rules = policy.rules_for(target_org)
+    if not rules:
+        return payload, []
+
+    triggered: list[str] = []
+
+    def visit(node: Any) -> Any:
+        if isinstance(node, dict):
+            out = {}
+            for key, value in node.items():
+                dropped = False
+                for rule in rules:
+                    if rule.action == DROP and key.lower() == rule.field_name.lower():
+                        if rule.name not in triggered:
+                            triggered.append(rule.name)
+                        dropped = True
+                        break
+                if not dropped:
+                    out[key] = visit(value)
+            return out
+
+        if isinstance(node, list):
+            return [visit(item) for item in node]
+
+        if isinstance(node, str):
+            text = node
+            for rule in rules:
+                if rule.action == BLOCK and rule._compiled.search(text):
+                    raise EgressBlocked(rule.name, target_org)
+            for rule in rules:
+                if rule.action == REDACT:
+                    replaced, count = rule._compiled.subn(rule.replacement, text)
+                    if count:
+                        text = replaced
+                        if rule.name not in triggered:
+                            triggered.append(rule.name)
+            return text
+
+        return node
+
+    return visit(payload), triggered

intermesh/escrow.py

@@ -0,0 +1,208 @@
+"""
+InterMesh Escrow — séquestre inter-organisations pour les tâches payantes.
+
+Portée volontairement limitée : ceci est le PROTOCOLE (états, règles,
+traçabilité), pas une passerelle de paiement. Le `SimulatedLedger` tient des
+soldes en mémoire, alimentés uniquement par `grant()` (un robinet de test/démo,
+jamais une vraie source de fonds). Brancher un vrai mouvement d'argent (Stripe
+Connect, stablecoins...) suppose de remplacer `SimulatedLedger` par un backend
+qui parle à un processeur de paiement réel, en respectant la même interface
+(`debit`/`credit`/`balance`) — volontairement pas fourni ici.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+
+class EscrowError(Exception):
+    """Séquestre impossible ou opération invalide sur un séquestre existant."""
+
+
+class InsufficientFundsError(EscrowError):
+    """Solde insuffisant pour couvrir le montant demandé."""
+
+
+class EscrowStatus(str, Enum):
+    HELD = "held"
+    RELEASED = "released"
+    REFUNDED = "refunded"
+
+
+@dataclass
+class EscrowHold:
+    hold_id: str
+    task_id: str
+    payer_org: str
+    payee_org: str
+    amount: float
+    currency: str
+    status: EscrowStatus
+    auto_release: bool
+    created_at: float
+    resolved_at: Optional[float] = None
+    metadata: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "hold_id": self.hold_id,
+            "task_id": self.task_id,
+            "payer_org": self.payer_org,
+            "payee_org": self.payee_org,
+            "amount": self.amount,
+            "currency": self.currency,
+            "status": self.status.value,
+            "auto_release": self.auto_release,
+            "created_at": self.created_at,
+            "resolved_at": self.resolved_at,
+            "metadata": self.metadata,
+        }
+
+
+class SimulatedLedger:
+    """
+    Soldes en mémoire, par (organisation, devise).
+
+    `grant()` est le seul moyen de créer des fonds : un robinet explicite de
+    démonstration/test, jamais une source de vérité financière. Aucune
+    écriture ici ne représente un mouvement d'argent réel.
+    """
+
+    def __init__(self):
+        self._balances: Dict[Tuple[str, str], float] = {}
+
+    def balance(self, org_id: str, currency: str = "USD") -> float:
+        return self._balances.get((org_id, currency), 0.0)
+
+    def grant(self, org_id: str, amount: float, currency: str = "USD") -> float:
+        if amount <= 0:
+            raise EscrowError("Le montant crédité doit être positif.")
+        key = (org_id, currency)
+        self._balances[key] = self._balances.get(key, 0.0) + amount
+        return self._balances[key]
+
+    def debit(self, org_id: str, amount: float, currency: str = "USD") -> bool:
+        """Retourne False sans rien modifier si le solde est insuffisant."""
+        key = (org_id, currency)
+        current = self._balances.get(key, 0.0)
+        if current < amount:
+            return False
+        self._balances[key] = current - amount
+        return True
+
+    def credit(self, org_id: str, amount: float, currency: str = "USD") -> float:
+        key = (org_id, currency)
+        self._balances[key] = self._balances.get(key, 0.0) + amount
+        return self._balances[key]
+
+    def export_state(self) -> List[dict]:
+        """Soldes sérialisables — le tuple (org, devise) ne survit pas à JSON."""
+        return [
+            {"org_id": org, "currency": currency, "amount": amount}
+            for (org, currency), amount in sorted(self._balances.items())
+        ]
+
+    def import_state(self, rows: List[dict]) -> None:
+        """Remplace intégralement les soldes."""
+        self._balances = {
+            (r["org_id"], r["currency"]): float(r["amount"]) for r in rows
+        }
+
+
+class EscrowManager:
+    """Un séquestre par tâche : créé à la soumission, résolu à l'issue de la tâche."""
+
+    def __init__(self, ledger: Optional[SimulatedLedger] = None):
+        self.ledger = ledger or SimulatedLedger()
+        self._holds: Dict[str, EscrowHold] = {}  # task_id -> EscrowHold
+
+    def create_hold(
+        self,
+        task_id: str,
+        payer_org: str,
+        payee_org: str,
+        amount: float,
+        currency: str = "USD",
+        auto_release: bool = True,
+        metadata: Optional[dict] = None,
+    ) -> EscrowHold:
+        if not task_id:
+            raise EscrowError("task_id requis pour créer un séquestre.")
+        if amount <= 0:
+            raise EscrowError("Le montant séquestré doit être positif.")
+        if task_id in self._holds:
+            raise EscrowError(f"Un séquestre existe déjà pour la tâche '{task_id}'.")
+
+        if not self.ledger.debit(payer_org, amount, currency):
+            balance = self.ledger.balance(payer_org, currency)
+            raise InsufficientFundsError(
+                f"ESCROW_INSUFFICIENT_FUNDS: '{payer_org}' a {balance:.2f} {currency}, "
+                f"{amount:.2f} {currency} requis."
+            )
+
+        hold = EscrowHold(
+            hold_id=str(uuid.uuid4()), task_id=task_id, payer_org=payer_org, payee_org=payee_org,
+            amount=amount, currency=currency, status=EscrowStatus.HELD, auto_release=auto_release,
+            created_at=time.time(), metadata=metadata or {},
+        )
+        self._holds[task_id] = hold
+        return hold
+
+    def get(self, task_id: str) -> Optional[EscrowHold]:
+        return self._holds.get(task_id)
+
+    def list_holds(self, org_id: Optional[str] = None) -> List[EscrowHold]:
+        holds = list(self._holds.values())
+        if org_id:
+            holds = [h for h in holds if org_id in (h.payer_org, h.payee_org)]
+        return holds
+
+    def release(self, task_id: str) -> EscrowHold:
+        """Débloque les fonds vers le bénéficiaire (tâche livrée avec succès)."""
+        hold = self._require_held(task_id)
+        self.ledger.credit(hold.payee_org, hold.amount, hold.currency)
+        hold.status = EscrowStatus.RELEASED
+        hold.resolved_at = time.time()
+        return hold
+
+    def refund(self, task_id: str) -> EscrowHold:
+        """Rend les fonds au payeur (tâche échouée, annulée, ou litige tranché en sa faveur)."""
+        hold = self._require_held(task_id)
+        self.ledger.credit(hold.payer_org, hold.amount, hold.currency)
+        hold.status = EscrowStatus.REFUNDED
+        hold.resolved_at = time.time()
+        return hold
+
+    def export_state(self) -> dict:
+        """Séquestres et soldes, pour un instantané du Hub."""
+        return {
+            "ledger": self.ledger.export_state(),
+            "holds": [h.to_dict() for h in self._holds.values()],
+        }
+
+    def import_state(self, state: dict) -> None:
+        """Remplace intégralement séquestres et soldes."""
+        self.ledger.import_state(state.get("ledger") or [])
+        self._holds = {}
+        for raw in state.get("holds") or []:
+            hold = EscrowHold(
+                hold_id=raw["hold_id"], task_id=raw["task_id"],
+                payer_org=raw["payer_org"], payee_org=raw["payee_org"],
+                amount=float(raw["amount"]), currency=raw["currency"],
+                status=EscrowStatus(raw["status"]), auto_release=bool(raw["auto_release"]),
+                created_at=float(raw["created_at"]), resolved_at=raw.get("resolved_at"),
+                metadata=raw.get("metadata") or {},
+            )
+            self._holds[hold.task_id] = hold
+
+    def _require_held(self, task_id: str) -> EscrowHold:
+        hold = self._holds.get(task_id)
+        if hold is None:
+            raise EscrowError(f"Aucun séquestre pour la tâche '{task_id}'.")
+        if hold.status != EscrowStatus.HELD:
+            raise EscrowError(f"Séquestre déjà résolu ({hold.status.value}).")
+        return hold