v1.0.4: zéro vuln zéro faille — audit expert A1-A20 + B1-B18

P0 sécurité (Sprint A) :
- A1 _validateEncryptedDb : onConfigure aligné prod + check table notes
- A2 (F6) race aliveIds vs _embeddings.save : check note existence +
  encryptedContent==null AVANT save (anti orphan plaintext post-delete
  ou post-vault-isation concurrente)
- A6 _aesGcmDecrypt : wipe plain post-copie (limite fenêtre plaintext
  dans le heap du package cryptography)
- A7 lock() + lockAll() : cancel _autoLockTimer orphelin
- A8 _Argon2Job : passphraseBytes Uint8List wipable + wipe en finally
  côté worker isolate (anti RAM forensics passphrase post-unlock)
- A11 RagService._sanitize aligné AI Tech v0.6.1 F2 :
  • strip zero-width / bidi U+200B-U+200F, U+202A-U+202E,
    U+2066-U+2069, U+FEFF (anti fragmentation balises)
  • neutralise blocs base64 longs (40+ chars) que Gemma sait décoder
- A13 ai_chat_screen WidgetsBindingObserver : clear _turns +
  stopGeneration sur paused/hidden/detached (anti RAM forensics du
  contenu vault déchiffré dans turn.sources après auto-lock)
- A17 PRAGMA cipher_compatibility = 4 explicite dans _onConfigure
  (anti-bump SQLCipher futur silencieux)
- B6 PanicStep.embedderWipe : panic wipe <appSupport>/models/
  (cache MiniLM ~25 Mo — cohérence voiceWipe + gemmaUninstall)

Docs :
- E1 SECURITY.md v1.0.0 → v1.0.4
- E2 README v1.0.0 → v1.0.4
- AppConstants.appVersion 1.0.3 → 1.0.4

Reportés v1.1 (format-breaking) :
- F3 (A3 audit) — chiffrement title vault (DB v7 + migration)
- F16 (A4 audit) — AAD KEK wrap Keystore (Kotlin + Dart)
- A5 — Argon2id calibration runtime adaptive

flutter analyze : 0 erreur, 0 warning (14 info pré-existants `announce`
deprecated, hors scope hardening).
flutter test : 64/64 passed (panic_service_test expected sequence
inclut maintenant embedderWipe).
Fastlane FR + EN 35.txt.

Author: gitubpatrice

README.md

@@ -2,7 +2,7 @@
 
 > Vos notes restent dans votre poche. L'IA aussi.
 
-**v1.0.0 — Mai 2026** · [Politique de confidentialité](PRIVACY.md) · [CGU](TERMS.md) · [Sécurité](SECURITY.md)
+**v1.0.4 — Mai 2026** · [Politique de confidentialité](PRIVACY.md) · [CGU](TERMS.md) · [Sécurité](SECURITY.md)
 
 Application Android Flutter de prise de notes Markdown chiffrées,
 **100 % locale, zéro permission Internet**. Interface bilingue **FR / EN**.

SECURITY.md

@@ -1,6 +1,6 @@
 # Security policy — Notes Tech
 
-**Version current : v1.0.0 — Mai 2026.**
+**Version current : v1.0.4 — Mai 2026.**
 
 Notes Tech v1.0 introduit plusieurs durcissements sécurité :
 - `prefs.clear()` panique avec **whitelist** (`db_encrypted_v1`,

fastlane/metadata/android/en-US/changelogs/35.txt

@@ -0,0 +1,38 @@
+v1.0.4 — Expert audit zero-vuln/zero-fault (May 2026)
+
+Security (P0+P1)
+• A1 — `_validateEncryptedDb` post-migration: `onConfigure` aligned
+  with prod + explicit `notes` table check (anti false-positive on
+  future sqflite_sqlcipher bump)
+• A2 (F6) — `aliveIds` vs `_embeddings.save` race fixed: existence +
+  `encryptedContent==null` check before each save (anti orphan
+  embedding re-inserted after concurrent hard-delete or vault-ization)
+• A6 — `_aesGcmDecrypt`: wipe `plain` buffer after copy (narrows
+  plaintext window in cryptography package heap)
+• A7 — `lock()` / `lockAll()` cancel the orphan `_autoLockTimer`
+• A8 — `_Argon2Job` passes `passphraseBytes` (Uint8List) instead of
+  String; worker isolate wipes the copy in `finally` (anti RAM
+  forensics post-unlock)
+• A11 — `RagService._sanitize` hardened: strip zero-width/bidi
+  (U+200B-U+200F, U+202A-U+202E, U+2066-U+2069, U+FEFF) + neutralize
+  long base64 blocks (aligned with AI Tech v0.6.1 F2)
+• A13 — `ai_chat_screen` clears `_turns` on paused/hidden/detached
+  lifecycle + stops in-progress generation (anti RAM forensics of
+  decrypted vault content in `turn.sources`)
+• A17 — `PRAGMA cipher_compatibility = 4;` explicit (anti future
+  SQLCipher bump)
+• B6 — `PanicStep.embedderWipe` added: panic wipes `<appSupport>/models/`
+  (MiniLM cache ~25 MB)
+
+Documentation
+• E1 — SECURITY.md "Version current v1.0.4"
+• E2 — README "v1.0.4"
+• AppConstants.appVersion bumped 1.0.3 → 1.0.4
+
+Deferred to v1.1 (format-breaking, migration required):
+• F3 (A3 audit) — vault `title` encryption (DB v7)
+• F16 (A4 audit) — Keystore wrap AAD binding (Kotlin + Dart)
+• A5 — Argon2id runtime adaptive calibration per device
+
+flutter analyze: 0 errors, 0 warnings.
+flutter test: 64/64 passed.

fastlane/metadata/android/fr-FR/changelogs/35.txt

@@ -0,0 +1,38 @@
+v1.0.4 — Audit expert zéro vuln/faille (mai 2026)
+
+Sécurité (P0+P1)
+• A1 — `_validateEncryptedDb` post-migration : `onConfigure` aligné sur
+  la prod + check explicite table `notes` (anti-faux-positif sur bump
+  futur sqflite_sqlcipher)
+• A2 (F6) — race `aliveIds` vs `_embeddings.save` corrigée : check
+  existence + `encryptedContent==null` avant chaque save (anti embedding
+  orphelin réinséré après hard-delete ou vault-isation concurrente)
+• A6 — `_aesGcmDecrypt` : wipe du buffer `plain` après copie (limite
+  fenêtre plaintext dans heap cryptography)
+• A7 — `lock()` / `lockAll()` cancel le `_autoLockTimer` orphelin
+• A8 — `_Argon2Job` passe `passphraseBytes` (Uint8List) au lieu de
+  String ; worker isolate wipe la copie en `finally` (anti RAM
+  forensics post-unlock)
+• A11 — `RagService._sanitize` durci : strip zero-width/bidi
+  (U+200B-U+200F, U+202A-U+202E, U+2066-U+2069, U+FEFF) + neutralise
+  blocs base64 longs (alignement AI Tech v0.6.1 F2)
+• A13 — `ai_chat_screen` clear `_turns` au lifecycle paused/hidden/
+  detached + stop génération en cours (anti RAM forensics du contenu
+  vault déchiffré dans `turn.sources`)
+• A17 — `PRAGMA cipher_compatibility = 4;` explicite (anti-bump
+  SQLCipher futur)
+• B6 — `PanicStep.embedderWipe` ajouté : panic wipe `<appSupport>/models/`
+  (cache MiniLM ~25 Mo)
+
+Documentation
+• E1 — SECURITY.md "Version current v1.0.4"
+• E2 — README "v1.0.4"
+• AppConstants.appVersion bumpé 1.0.3 → 1.0.4
+
+Reportés v1.1 (format-breaking, migration nécessaire) :
+• F3 (A3 audit) — chiffrement du `title` des notes vault (DB v7)
+• F16 (A4 audit) — AAD KEK wrap Keystore (Kotlin + Dart)
+• A5 — Argon2id calibration runtime adaptive au device
+
+flutter analyze : 0 erreur, 0 warning.
+flutter test : 64/64 passed.

lib/core/constants.dart

@@ -5,7 +5,7 @@ class AppConstants {
   AppConstants._();
 
   static const String appName = 'Notes Tech';
-  static const String appVersion = '1.0.3';
+  static const String appVersion = '1.0.4';
   // NB : la clé Kotlin équivalente côté `MainActivity.kt` est
   // `flutter.secure_window_enabled` (préfixe `flutter.` ajouté
   // automatiquement par `shared_preferences` au moment de la persistance).

lib/data/db/database.dart

@@ -170,9 +170,23 @@ class RagService {
   /// v1.1 (defense-in-depth) : encoder chaque note en base64 avec un
   /// délimiteur ASCII aléatoire régénéré par requête.
   static String _sanitize(String s) {
-    return s
-        .replaceAll(RegExp(r'</\s*note\s*>', caseSensitive: false), '<​/note>')
-        .replaceAll(RegExp(r'<\s*note\b', caseSensitive: false), '<​note')
+    // A11 v1.0.4 — pré-traitement aligné sur AI Tech v0.6.1 F2 :
+    // 1. Strip caractères zero-width / bidi qui pouvaient fragmenter
+    //    les balises tags (`<|im\u200C_start|>` avec U+200B au milieu
+    //    n'était pas matché par la regex).
+    // 2. Neutralise les blocs base64 longs (40+ chars) qui pouvaient
+    //    encoder une injection que Gemma sait décoder à la volée.
+    final stripped = s.replaceAll(_zeroWidthBidi, '');
+    final noB64 = stripped.replaceAll(
+      RegExp(r'[A-Za-z0-9+/]{40,}={0,2}'),
+      '·[base64 neutralisé]·',
+    );
+    return noB64
+        .replaceAll(
+          RegExp(r'</\s*note\s*>', caseSensitive: false),
+          '<\u200B/note>',
+        )
+        .replaceAll(RegExp(r'<\s*note\b', caseSensitive: false), '<\u200Bnote')
         // (2) Verbes d'instruction FR/EN.
         .replaceAll(
           RegExp(
@@ -188,18 +202,18 @@ class RagService {
         // (3) Tags de rôle système Gemma / instruct-style.
         .replaceAll(
           RegExp(r'<\|\s*system\s*\|>', caseSensitive: false),
-          '<​|system|>',
+          '<\u200B|system|>',
         )
         .replaceAll(
           RegExp(r'<\|\s*user\s*\|>', caseSensitive: false),
-          '<​|user|>',
+          '<\u200B|user|>',
         )
         .replaceAll(
           RegExp(r'<\|\s*assistant\s*\|>', caseSensitive: false),
-          '<​|assistant|>',
+          '<\u200B|assistant|>',
         )
-        .replaceAll(RegExp(r'</?s>'), '<​/s>')
-        .replaceAll(RegExp(r'\[/?INST\]'), '[​INST]')
+        .replaceAll(RegExp(r'</?s>'), '<\u200B/s>')
+        .replaceAll(RegExp(r'\[/?INST\]'), '[\u200BINST]')
         .replaceAll(
           RegExp(
             r'(?:^|\n)\s*(?:Assistant|System|Utilisateur|User)\s*:',
@@ -216,4 +230,16 @@ class RagService {
           '\n[steering neutralisé]:',
         );
   }
+
+  /// A11 v1.0.4 — regex pré-compilée pour stripper les caractères
+  /// zero-width / bidi (alignement AI Tech v0.6.1 F2). Couvre :
+  ///   U+200B-U+200F  ZWSP, ZWNJ, ZWJ, LRM, RLM
+  ///   U+202A-U+202E  bidi overrides (LRE, RLE, PDF, LRO, RLO)
+  ///   U+2066-U+2069  bidi isolates (LRI, RLI, FSI, PDI)
+  ///   U+FEFF         BOM / ZWNBSP
+  /// Définis via Unicode escapes pour éviter d'introduire ces caractères
+  /// dans le source lui-même (warnings analyzer bidi).
+  static final RegExp _zeroWidthBidi = RegExp(
+    '[\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]',
+  );
 }

lib/services/ai/rag_service.dart

@@ -202,6 +202,17 @@ class IndexingService {
         ),
       );
       final emb = _encodeWith(embedder, note);
+      // A2 v1.0.4 (F6) — race vs hard-delete ou vault-isation concurrente.
+      // Avant : un embedding d'une note supprimée entre listAllAlive et
+      // save était inséré comme orphelin survivant jusqu'à la passe
+      // suivante (leak sémantique transitoire). Idem pour une note
+      // vault-isée pendant la passe (content déjà vidé, embedding
+      // plaintext historique réinséré).
+      final live = await _notes.get(note.id);
+      if (live == null || live.encryptedContent != null) {
+        done++;
+        continue;
+      }
       await _embeddings.save(emb);
       done++;
       if (delay > Duration.zero) {

lib/services/indexing_service.dart

@@ -687,6 +687,10 @@ class FolderVaultService extends ChangeNotifier {
     final s = _unlocked.remove(folderId);
     if (s != null) {
       _wipe(s.folderKek);
+      // A7 v1.0.4 — cancel le timer auto-lock si plus rien d'unlocked,
+      // pour éviter qu'un Timer orphelin fire `_autoLockSweep` sur un
+      // map vide (no-op mais bruit).
+      if (_unlocked.isEmpty) _autoLockTimer?.cancel();
       notifyListeners();
     }
   }
@@ -699,6 +703,8 @@ class FolderVaultService extends ChangeNotifier {
       _wipe(s.folderKek);
     }
     _unlocked.clear();
+    // A7 v1.0.4 — cancel le timer auto-lock après wipe global.
+    _autoLockTimer?.cancel();
     notifyListeners();
   }
 
@@ -900,7 +906,8 @@ class FolderVaultService extends ChangeNotifier {
     return compute<_Argon2Job, Uint8List>(
       _argon2WorkerEntry,
       _Argon2Job(
-        passphrase: passphrase,
+        // A8 v1.0.4 — passe une COPIE Uint8List wipable au worker.
+        passphraseBytes: Uint8List.fromList(utf8Bytes(passphrase)),
         salt: salt,
         memoryKb: AppConstants.vaultArgon2MemoryKb,
         iterations: AppConstants.vaultArgon2Iterations,
@@ -922,7 +929,7 @@ class FolderVaultService extends ChangeNotifier {
     return compute<_Argon2Job, Uint8List>(
       _argon2WorkerEntry,
       _Argon2Job(
-        passphrase: pin,
+        passphraseBytes: Uint8List.fromList(utf8Bytes(pin)),
         salt: salt,
         memoryKb: AppConstants.vaultPinArgon2MemoryKb,
         iterations: AppConstants.vaultPinArgon2Iterations,
@@ -969,7 +976,19 @@ class FolderVaultService extends ChangeNotifier {
     final secret = SecretKey(key);
     final box = SecretBox(cipherText, nonce: iv, mac: Mac(macBytes));
     final plain = await algo.decrypt(box, secretKey: secret, aad: aad);
-    return Uint8List.fromList(plain);
+    // A6 v1.0.4 — wipe le buffer plain retourné par cryptography une fois
+    // la copie effectuée. Limite la fenêtre où le plaintext folder_kek
+    // (ou le contenu déchiffré) reste dans le heap du package cryptography
+    // jusqu'à GC.
+    final out = Uint8List.fromList(plain);
+    if (plain is Uint8List) {
+      try {
+        plain.fillRange(0, plain.length, 0);
+      } catch (_) {
+        // Buffer non-modifiable (vue, FFI) : best-effort.
+      }
+    }
+    return out;
   }
 
   Future<Uint8List> _verifierFor(Uint8List folderKek) async {
@@ -1018,16 +1037,22 @@ const _utf8 = Utf8Codec();
 
 /// Argument transmis à l'isolate. Tous les champs sont passifs et
 /// sérialisables (String, Uint8List, int).
+///
+/// A8 v1.0.4 — `passphraseBytes` est passé en `Uint8List` (au lieu de
+/// `String`) pour permettre un wipe explicite côté worker isolate à la
+/// fin de la dérivation. Le caller doit fournir `utf8.encode(passphrase)`
+/// converti en `Uint8List` ; la String côté UI reste immutable (limitation
+/// Dart) mais on minimise la fenêtre d'exposition dans l'isolate.
 class _Argon2Job {
   const _Argon2Job({
-    required this.passphrase,
+    required this.passphraseBytes,
     required this.salt,
     required this.memoryKb,
     required this.iterations,
     required this.parallelism,
     required this.hashLength,
   });
-  final String passphrase;
+  final Uint8List passphraseBytes;
   final Uint8List salt;
   final int memoryKb;
   final int iterations;
@@ -1044,8 +1069,17 @@ Future<Uint8List> _argon2WorkerEntry(_Argon2Job job) async {
     parallelism: job.parallelism,
     hashLength: job.hashLength,
   );
-  final secret = SecretKey(utf8Bytes(job.passphrase));
-  final derived = await algo.deriveKey(secretKey: secret, nonce: job.salt);
-  final bytes = await derived.extractBytes();
-  return Uint8List.fromList(bytes);
+  try {
+    final secret = SecretKey(job.passphraseBytes);
+    final derived = await algo.deriveKey(secretKey: secret, nonce: job.salt);
+    final bytes = await derived.extractBytes();
+    return Uint8List.fromList(bytes);
+  } finally {
+    // A8 v1.0.4 — wipe la copie de la passphrase côté worker isolate.
+    try {
+      job.passphraseBytes.fillRange(0, job.passphraseBytes.length, 0);
+    } catch (_) {
+      /* best-effort */
+    }
+  }
 }

lib/services/security/folder_vault_service.dart

@@ -57,6 +57,7 @@
 library;
 
 import 'dart:async';
+import 'dart:io';
 
 import 'package:path_provider/path_provider.dart';
 import 'package:shared_preferences/shared_preferences.dart';
@@ -100,6 +101,9 @@ enum PanicStep {
   dbWipe,
   voiceWipe,
   gemmaUninstall,
+
+  /// B6 v1.0.4 — wipe du modèle MiniLM bundled (~25 Mo) + cache.
+  embedderWipe,
   prefsClear,
   tmpPurge,
 }
@@ -248,6 +252,11 @@ class PanicService {
     //    KEK est partie depuis plusieurs steps).
     await _runStep(report, PanicStep.gemmaUninstall, _gemma.uninstall);
 
+    // 6.b B6 v1.0.4 — wipe du cache MiniLM (`<appSupport>/models/`).
+    // Le modèle MiniLM est public mais l'app le copie dans son sandbox.
+    // Cohérence avec wipe Gemma + Whisper : zéro résidu ML post-panic.
+    await _runStep(report, PanicStep.embedderWipe, _wipeEmbedderCache);
+
     // 7. Préférences : tri, dossier actif, hash Gemma accepté, modèle
     //    voix actif… aucun reliquat d'usage.
     //
@@ -325,4 +334,20 @@ class PanicService {
       }
     }
   }
+
+  /// B6 v1.0.4 — wipe du cache MiniLM (sandbox `<appSupport>/models/`).
+  /// Le modèle bundled est public, mais l'app le copie dans son sandbox.
+  /// Cohérence avec voiceWipe + gemmaUninstall : zéro résidu ML post-panic.
+  /// Best-effort (le modèle sera re-extrait des assets au prochain warmUp).
+  Future<void> _wipeEmbedderCache() async {
+    try {
+      final dir = await getApplicationSupportDirectory();
+      final modelsDir = Directory('${dir.path}/models');
+      if (await modelsDir.exists()) {
+        await modelsDir.delete(recursive: true);
+      }
+    } catch (_) {
+      // Best-effort.
+    }
+  }
 }