Chiffrement de bout en bout

# L'ÉTABLISSEMENT génère sa paire de clés (la privée reste chez vous) :
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:4096 -out private.pem
openssl pkey -in private.pem -pubout
# → coller le bloc BEGIN PUBLIC KEY dans l'admin ApiBorne (page Connectivité)

# Avec l'implémentation de référence : npm run keys:generate
# (stocke la privée dans les réglages de la démo, affiche la publique)

POST /api/apiborneIntegrationService/v1/patients/identify
X-Kiosk-Auth-Key: <clé partagée>
X-Kiosk-Device-Id: <id du device>
X-Kiosk-Encryption: v1
X-Kiosk-Encryption-Key: <sessionKey AES-256 wrappée RSA-OAEP-SHA256, base64>
Content-Type: application/json

{ "encrypted": { "v": 1, "iv": "<base64, 12 octets>", "data": "<base64, ciphertext+tag>" } }

// Déchiffrer une requête (node:crypto) — extrait de l'implémentation de référence
import crypto from "node:crypto";

function unwrapSessionKey(wrappedKeyBase64, privateKeys /* rotation : la + récente d'abord */) {
  const wrapped = Buffer.from(wrappedKeyBase64, "base64");
  for (const key of privateKeys) {
    try {
      const sessionKey = crypto.privateDecrypt(
        { key, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING, oaepHash: "sha256" },
        wrapped,
      );
      if (sessionKey.length === 32) return sessionKey;
    } catch { /* mauvaise clé (rotation) → essayer la suivante */ }
  }
  throw new Error("DECRYPTION_FAILED");
}

function decryptEnvelope(sessionKey, { iv, data }) {
  const payload = Buffer.from(data, "base64");
  const ciphertext = payload.subarray(0, payload.length - 16);
  const authTag = payload.subarray(payload.length - 16); // tag GCM concaténé (WebCrypto)
  const decipher = crypto.createDecipheriv("aes-256-gcm", sessionKey, Buffer.from(iv, "base64"));
  decipher.setAuthTag(authTag);
  return JSON.parse(Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8"));
}

// Chiffrer la réponse 2xx : MÊME sessionKey, IV NEUF (jamais celui de la requête)
function sealResponse(sessionKey, payload) {
  const iv = crypto.randomBytes(12);
  const cipher = crypto.createCipheriv("aes-256-gcm", sessionKey, iv);
  const ciphertext = Buffer.concat([cipher.update(JSON.stringify(payload), "utf8"), cipher.final()]);
  return {
    encrypted: {
      v: 1,
      iv: iv.toString("base64"),
      data: Buffer.concat([ciphertext, cipher.getAuthTag()]).toString("base64"),
    },
  };
}
// + header de réponse : X-Kiosk-Encryption: v1

// Ce que fait la borne (WebCrypto natif) — pour comprendre le format
const sessionKeyRaw = crypto.getRandomValues(new Uint8Array(32));
const wrapped = await crypto.subtle.encrypt(
  { name: "RSA-OAEP" },                                  // hash SHA-256 fixé à l'import de la clé
  publicKey,                                             // importKey('spki', der, { name: 'RSA-OAEP', hash: 'SHA-256' }, …)
  sessionKeyRaw,
);
const iv = crypto.getRandomValues(new Uint8Array(12));
const ciphertext = await crypto.subtle.encrypt(          // tag de 128 bits CONCATÉNÉ à la fin
  { name: "AES-GCM", iv },
  sessionKey,
  new TextEncoder().encode(JSON.stringify(body)),
);

# L'oracle de test de l'implémentation de référence : chiffre → appelle → déchiffre
node scripts/encrypted-curl.mjs POST /patients/identify '{"criteria":{"lastName":"MARTIN"}}' \
  --url https://votre-serveur.example.com/api/apiborneIntegrationService/v1 \
  --public-key votre-cle-publique.pem

# Votre implémentation doit refuser un tag corrompu :
node scripts/encrypted-curl.mjs POST /patients/identify '{"criteria":{"lastName":"MARTIN"}}' --corrupt-tag
# → attendu : 400 { "error": { "code": "DECRYPTION_FAILED", … } }