Zero-Knowledge Principles Skill¶

// ✅ CORRECT - Client-side encryption
// Dans l'app React Native/Expo
import { encryptDocument } from './crypto';

const plaintext = documentContent;
const k_doc = deriveDocumentKey(k_vault_user, doc_id);
const { ciphertext, iv, tag } = await encryptDocument(plaintext, k_doc);

// Envoi au serveur : ciphertext uniquement
await api.uploadDocument({ ciphertext, iv, tag, hash: sha3_256(plaintext) });

// ❌ INTERDIT - Server-side encryption
// Dans le backend NestJS
async encryptDocument(plaintext: Buffer, key: Buffer) {
  // Le serveur NE DOIT JAMAIS voir le plaintext
}

// ❌ INTERDIT
POST /api/auth/login
{
  "email": "user@example.com",
  "password": "plaintextPassword",
  "masterKey": "base64EncodedKey"  // ← JAMAIS
}

// ✅ CORRECT
POST /api/auth/login
{
  "email": "user@example.com",
  "passwordHash": "argon2id$..."  // Seulement hash pour auth
}

// ✅ CORRECT - Client calcule le hash
import { sha3_256 } from '@noble/hashes/sha3';

const plaintext = documentContent;
const hash = sha3_256(plaintext);  // Hash AVANT chiffrement

const { ciphertext } = await encryptDocument(plaintext, k_doc);

await api.uploadDocument({
  ciphertext,
  hash: bytesToHex(hash)  // Hash transmis pour preuve
});

// ❌ INTERDIT - Backend
logger.info(`Received document: ${plaintext}`);
logger.debug(`Content: ${data.toString()}`);
console.log(documentContent);

// ✅ CORRECT - Backend
logger.info(`Received encrypted document`, {
  doc_id: document.id,
  size: ciphertext.length,
  hash: hash.substring(0, 8) + '...'  // Seulement préfixe
});

// ✅ CORRECT - Key envelope
const k_doc = deriveDocumentKey(k_vault_user, doc_id);

// Chiffrement de K_doc avec K_vault_user
const k_envelope = await encryptKey(k_doc, k_vault_user);

await api.storeKeyEnvelope({
  doc_id,
  k_envelope: bytesToBase64(k_envelope)  // Clé chiffrée OK
});

// ✅ CORRECT - Client-side hashing
const passwordHash = await argon2.hash(password, salt);

// Envoi d'un challenge-response ou hash dérivé
const authToken = await deriveAuthToken(passwordHash, challenge);

await api.login({ email, authToken });

// CLIENT (App)
const plaintext = documentContent;

// 1. Hash probatoire (AVANT chiffrement)
const hash = sha3_256(plaintext);

// 2. Dérivation clé document
const k_doc = deriveDocumentKey(k_vault_user, doc_id);

// 3. Chiffrement
const { ciphertext, iv, tag } = await encryptDocument(plaintext, k_doc);

// 4. Envoi au serveur (seulement données chiffrées)
await api.uploadDocument({
  doc_id,
  ciphertext: bytesToBase64(ciphertext),
  iv: bytesToBase64(iv),
  tag: bytesToBase64(tag),
  hash: bytesToHex(hash),
  file_name: "encrypted.bin"  // Nom chiffré aussi si sensible
});

// BACKEND (API)
async uploadDocument(dto: UploadDocumentDto) {
  // Le backend NE PEUT PAS déchiffrer
  // Il stocke seulement les données chiffrées

  await this.documentsRepository.save({
    doc_id: dto.doc_id,
    ciphertext: dto.ciphertext,  // Opaque
    iv: dto.iv,
    tag: dto.tag,
    hash: dto.hash,  // Hash pour vérification future
    created_at: new Date()
  });

  // ❌ NE JAMAIS FAIRE
  // const plaintext = this.decrypt(dto.ciphertext, key);
}

// BACKEND (API)
async downloadDocument(doc_id: string) {
  const doc = await this.documentsRepository.findOne({ doc_id });

  // Retourne les données chiffrées telles quelles
  return {
    ciphertext: doc.ciphertext,  // Toujours chiffré
    iv: doc.iv,
    tag: doc.tag,
    hash: doc.hash
  };
}

// CLIENT (App)
const { ciphertext, iv, tag, hash } = await api.downloadDocument(doc_id);

// Dérivation clé
const k_doc = deriveDocumentKey(k_vault_user, doc_id);

// Déchiffrement côté client
const plaintext = await decryptDocument(
  base64ToBytes(ciphertext),
  k_doc,
  base64ToBytes(iv),
  base64ToBytes(tag)
);

// Vérification intégrité
const computedHash = sha3_256(plaintext);
if (bytesToHex(computedHash) !== hash) {
  throw new Error('Document integrity check failed');
}

// CLIENT A (Propriétaire)
const re_key_A_to_B = generateReEncryptionKey(
  privateKey_A,
  publicKey_B
);

await api.grantAccess({
  doc_id,
  recipient_id: user_B_id,
  re_key: bytesToBase64(re_key_A_to_B)  // Clé de re-encryption
});

// BACKEND (API + CloudHSM)
async reEncrypt(doc_id: string, recipient_id: string) {
  const doc = await this.documentsRepository.findOne({ doc_id });
  const reKey = await this.accessRepository.getReKey(doc_id, recipient_id);

  // Re-encryption dans le HSM (zero-knowledge preserved)
  const ciphertext_B = await this.hsmService.proxyReEncrypt(
    doc.ciphertext,
    reKey
  );

  return { ciphertext: ciphertext_B };  // Chiffré pour B
}

// ❌ BLOQUANT
async analyzeDocument(plaintext: string) {
  const sentiment = await this.nlpService.analyze(plaintext);
  // Le serveur ne doit JAMAIS avoir le plaintext
}

// ❌ BLOQUANT
POST /api/documents/upload
{
  "ciphertext": "...",
  "masterKey": "base64Key"  // JAMAIS
}

// ❌ BLOQUANT
async getDocumentPreview(doc_id: string) {
  const doc = await this.repo.findOne(doc_id);
  const plaintext = this.cryptoService.decrypt(doc.ciphertext, this.serverKey);
  return plaintext.substring(0, 100);
}

// ❌ BLOQUANT
logger.info(`Document content: ${plaintext}`);
logger.debug(`User data: ${JSON.stringify(data)}`);