PD-41 — Plan d'implémentation¶

1. Découpage en composants¶

Architecture cible¶

src/modules/crypto/pre/
├── pre.module.ts                    # Module NestJS
├── pre.service.ts                   # Service principal (façade)
├── pre.config.ts                    # Configuration et validation
├── interfaces/
│   ├── pre.interface.ts             # Types PRE (ReKey, Capsule, CFrag)
│   ├── pre-artefacts.interface.ts   # Formats PRE-1.0 (annexe 11)
│   └── pre-errors.interface.ts      # Codes d'erreur normatifs
├── providers/
│   ├── umbral.provider.ts           # Wrapper Umbral (bibliothèque)
│   └── umbral-mock.provider.ts      # Mock pour tests unitaires
├── validators/
│   ├── artefact.validator.ts        # Validation des formats PRE-1.0
│   ├── context.validator.ts         # Validation contextId cohérence
│   └── size-limit.validator.ts      # Limites de taille (INV-07)
├── dto/
│   ├── generate-rekey.dto.ts        # DTO generateReKey()
│   ├── re-encrypt.dto.ts            # DTO reEncrypt()
│   └── validate.dto.ts              # DTO validate()
└── __tests__/
    ├── pre.service.spec.ts          # Tests unitaires
    ├── pre.integration.spec.ts      # Tests d'intégration
    └── fixtures/                    # Blocs JSON PRE-1.0 référence

Composants et responsabilités¶

2. Flux techniques¶

Flux N1 — Health/Readiness¶

Client                     PreService                UmbralProvider
  │                            │                           │
  │──── getHealth() ──────────>│                           │
  │                            │──── isReady() ───────────>│
  │                            │<──── { ready, version } ──│
  │<─── { serviceVersion,      │                           │
  │      umbralVersion,        │                           │
  │      status: ready|not } ──│                           │

Flux N2 — generateReKey()¶

Client                     PreService        Validators         UmbralProvider
  │                            │                 │                    │
  │── generateReKey(dto) ─────>│                 │                    │
  │                            │── validateDto ─>│                    │
  │                            │<─ ok/reject ────│                    │
  │                            │── checkSize ───>│                    │
  │                            │<─ ok/reject ────│                    │
  │                            │── generateKFrags ──────────────────>│
  │                            │<─ KFrag[] ──────────────────────────│
  │                            │── buildReKeyArtefact ───────────────│
  │                            │── auditLog (sans secrets) ──────────│
  │<── ReKey (PRE-1.0) ────────│                 │                    │

Flux N3 — reEncrypt()¶

Client                     PreService        Validators         UmbralProvider
  │                            │                 │                    │
  │── reEncrypt(dto) ─────────>│                 │                    │
  │                            │── validateArtefacts ─>│              │
  │                            │<─ ok/reject ──────────│              │
  │                            │── validateContextId ─>│              │
  │                            │<─ ok/reject ──────────│              │
  │                            │── checkSize ─────────>│              │
  │                            │<─ ok/reject ──────────│              │
  │                            │── reEncrypt(capsule, kfrag) ────────>│
  │                            │<─ CFrag ────────────────────────────│
  │                            │── buildCFragArtefact ───────────────│
  │                            │── auditLog (sans secrets) ──────────│
  │<── CFrag (PRE-1.0) ────────│                 │                    │

Flux N4 — validate()¶

Client                     PreService        Validators
  │                            │                 │
  │── validate(artefact) ─────>│                 │
  │                            │── validateFormat ──>│
  │                            │<─ errors[] ────────│
  │                            │── validateContext ─>│
  │                            │<─ errors[] ────────│
  │                            │── auditLog ────────│
  │<── { verdict, codes[] } ───│                 │

2b. Diagrammes Mermaid¶

Graphe de dépendances des composants¶

graph TD
    PreModule["PreModule<br/><i>Module NestJS</i>"]
    PreService["PreService<br/><i>Façade publique</i>"]
    PreConfig["PreConfig<br/><i>Configuration</i>"]
    UmbralProvider["UmbralProvider<br/><i>Wrapper Umbral</i>"]
    ArtefactValidator["ArtefactValidator<br/><i>Formats PRE-1.0</i>"]
    ContextValidator["ContextValidator<br/><i>Cohérence contextId</i>"]
    SizeLimitValidator["SizeLimitValidator<br/><i>Limites de taille</i>"]
    AuditLogger["AuditLogger<br/><i>Journalisation sécurisée</i>"]

    PreModule --> PreService
    PreModule --> PreConfig
    PreService --> UmbralProvider
    PreService --> ArtefactValidator
    PreService --> ContextValidator
    PreService --> SizeLimitValidator
    PreService --> AuditLogger
    PreService --> PreConfig
    SizeLimitValidator --> PreConfig
    ArtefactValidator -.->|"valide formats"| UmbralProvider

Séquence — generateReKey (Flux N2)¶

sequenceDiagram
    participant C as Client
    participant PS as PreService
    participant AV as ArtefactValidator
    participant SV as SizeLimitValidator
    participant UP as UmbralProvider
    participant AL as AuditLogger

    C->>PS: generateReKey(dto)
    PS->>AV: validateDto(dto)
    alt DTO invalide
        AV-->>PS: INVALID_PUBLIC_KEY / INVALID_PARAMETERS
        PS->>AL: logError(contextId, errorCode)
        PS-->>C: throw PreException
    end
    AV-->>PS: ok
    PS->>SV: checkSize(dto)
    alt Dépassement
        SV-->>PS: PAYLOAD_TOO_LARGE
        PS->>AL: logError(contextId, errorCode)
        PS-->>C: throw PreException
    end
    SV-->>PS: ok
    PS->>UP: generateKFrags(ownerPk, recipientPk, t, n)
    UP-->>PS: KFrag[]
    PS->>PS: buildReKeyArtefact(KFrag[], contextId)
    PS->>AL: logSuccess(contextId, artefactType)
    PS-->>C: ReKey (PRE-1.0)

Séquence — reEncrypt (Flux N3)¶

sequenceDiagram
    participant C as Client
    participant PS as PreService
    participant AV as ArtefactValidator
    participant CV as ContextValidator
    participant SV as SizeLimitValidator
    participant UP as UmbralProvider
    participant AL as AuditLogger

    C->>PS: reEncrypt(dto)
    PS->>AV: validateArtefacts(capsule, reKey)
    alt Artefact invalide
        AV-->>PS: INVALID_ARTEFACT / INVALID_FORMAT
        PS->>AL: logError(contextId, errorCode)
        PS-->>C: throw PreException
    end
    AV-->>PS: ok
    PS->>CV: validateContextId(capsule, reKey)
    alt contextId divergent
        CV-->>PS: INVALID_CONTEXT
        PS->>AL: logError(contextId, errorCode)
        PS-->>C: throw PreException
    end
    CV-->>PS: ok
    PS->>SV: checkSize(dto)
    SV-->>PS: ok
    PS->>UP: reEncrypt(capsule, kfrag)
    alt Erreur Umbral
        UP-->>PS: REKEY_MISMATCH / CRYPTO_FAILURE
        PS->>AL: logError(contextId, errorCode)
        PS-->>C: throw PreException
    end
    UP-->>PS: CFrag
    PS->>PS: buildCFragArtefact(CFrag, contextId)
    PS->>AL: logSuccess(contextId, artefactType)
    PS-->>C: CFrag (PRE-1.0)

3. Mapping invariants → mécanismes¶

4. Mapping critères d'acceptation → mécanismes¶

5. Mapping tests (TC-*) → mécanismes + observables¶

Note : TC-NEG-02 (Flood/DoS) est hors périmètre PRE (Spec H5, Tests §7). Le rate limiting relève de la couche applicative amont.

6. Gestion des erreurs¶

Table des codes d'erreur (normative)¶

Implémentation fail-closed¶

// Décorateur ou wrapper pour toutes les méthodes publiques
async executeWithFailClosed<T>(operation: () => Promise<T>): Promise<T> {
  try {
    return await operation();
  } catch (error) {
    // Log sans secrets (contextId, errorCode uniquement)
    this.auditLogger.logError({
      contextId: extractContextIdSafe(error),
      errorCode: mapToNormativeCode(error),
      timestamp: new Date().toISOString(),
    });
    // Toujours rejeter avec code normatif, jamais de résultat partiel
    throw new PreException(mapToNormativeCode(error));
  }
}

7. Impacts sécurité¶

Risques et mitigations¶

Journalisation sécurisée¶

Champs autorisés (liste blanche) : - contextId - issuerKeyId / recipientKeyId (identifiants, pas les clés) - formatVersion - artefactType - errorCode - timestamp

Champs interdits (liste noire normative) : - plaintext - payload - capsule (contenu complet) - kfrag / cfrag (contenu complet) - privateKey - Tout secret dérivé

Conformité¶

• eIDAS : traçabilité des opérations PRE sans exposition de secrets
• RGPD : pas de données personnelles dans les artefacts PRE (contextId opaque)
• PKCS#11 : non applicable (PRE est purement logiciel)

8. Hypothèses techniques¶

9. Points de vigilance (risques, dette, pièges)¶

Risques identifiés¶

1. Bibliothèque Umbral : Peu de bindings Node.js matures. Évaluer :
2. umbral-pre (Rust + NAPI)
3. pyumbral via child process

4. Implémentation TypeScript pure (risque sécurité)

5. Testabilité TC-ERR-06 : Impossible de provoquer déterministiquement une erreur Umbral interne. Couverture indirecte via mock.

6. Performance : Si volume élevé de reEncrypt(), considérer :

7. Connection pooling vers Umbral
8. Cache des validations
9. Batch processing

Dette technique acceptée¶

• Les seuils de taille (annexe B) sont informatifs ; valeurs exactes à définir lors de l'implémentation
• Le code NON_AUTHORIZED est hors périmètre PRE (géré par couche amont)

Pièges à éviter¶

1. Ne jamais logger les artefacts complets (capsule, kfrag, cfrag)
2. Ne jamais exposer de méthode decrypt() même en interne
3. Ne jamais accepter de champ privateKey dans les DTOs
4. Toujours valider le contextId AVANT toute opération cryptographique
5. Toujours retourner un code normatif (pas de message d'erreur libre)

10. Hors périmètre¶

• Chiffrement symétrique des documents (AES-GCM) — géré ailleurs
• PKI / Gestion des identités — hors périmètre PRE
• Politiques d'accès métier (qui peut partager quoi) — couche applicative
• Réseau décentralisé NuCypher (staking, nodes) — non utilisé
• Rate limiting / AuthN — couche infrastructure amont
• Révocation des ReKeys — à définir dans une US séparée
• Résistance quantique — hors périmètre actuel