merge: correctifs securite SecretBytes (wipe silencieux, fromHex permissif)

Author: gitubpatrice

lib/src/security/secret_bytes.dart

@@ -42,13 +42,24 @@ abstract final class SecretBytes {
   /// de portée d'une clé pour limiter la fenêtre où elle est en clair en RAM.
   ///
   /// Sémantique identique à un `bytes.fillRange(0, bytes.length, 0)`.
-  static void wipe(Uint8List bytes) {
+  ///
+  /// **Retourne `true` si l'effacement a réellement eu lieu, `false` si le
+  /// buffer était non modifiable.** Avant, l'échec était avalé en silence :
+  /// un appelant écrivant `SecretBytes.wipe(finalKey)` croyait le matériel de
+  /// clé zéroïsé alors qu'une `UnmodifiableUint8ListView` — retournée par
+  /// certaines implémentations FFI de `cryptography_flutter` — laissait la clé
+  /// intacte en RAM jusqu'au GC. Le résultat doit être vérifié partout où
+  /// l'effacement fait partie du modèle de menace ; quand il vaut `false`, la
+  /// seule parade est de ne pas conserver de référence au buffer.
+  @pragma('vm:prefer-inline')
+  static bool wipe(Uint8List bytes) {
     try {
       bytes.fillRange(0, bytes.length, 0);
+      return true;
     } catch (_) {
-      // Buffer non-modifiable (UnmodifiableUint8ListView retourné par
-      // certaines impls FFI de `cryptography_flutter`). Best-effort : on ne
-      // peut pas effacer une vue read-only — la mémoire sera libérée par GC.
+      // Buffer non-modifiable : on ne peut pas effacer une vue read-only —
+      // la mémoire sera libérée par GC, à une date non déterministe.
+      return false;
     }
   }
 
@@ -93,12 +104,39 @@ abstract final class SecretBytes {
     }
     final out = Uint8List(hex.length ~/ 2);
     for (var i = 0; i < out.length; i++) {
-      final byte = int.parse(hex.substring(i * 2, i * 2 + 2), radix: 16);
-      out[i] = byte;
+      // `int.parse(..., radix: 16)` accepte un SIGNE et des espaces de tête :
+      // "+a" rendait 10, " a" rendait 10, et "-a" rendait -10 — silencieusement
+      // tronqué à l'octet 246 par `Uint8List`. La documentation promet pourtant
+      // une FormatException sur entrée invalide. On valide donc chaque demi-
+      // octet nous-mêmes avant de parser.
+      final hi = _hexDigit(hex.codeUnitAt(i * 2));
+      final lo = _hexDigit(hex.codeUnitAt(i * 2 + 1));
+      if (hi < 0 || lo < 0) {
+        throw FormatException('invalid hex byte', hex, i * 2);
+      }
+      out[i] = (hi << 4) | lo;
     }
     return out;
   }
 
+  /// Valeur d'un chiffre hexadécimal, ou -1 si le code unité n'en est pas un.
+  /// Accepte `0-9`, `a-f`, `A-F` et RIEN d'autre — pas de signe, pas d'espace.
+  static int _hexDigit(int codeUnit) {
+    // 0-9
+    if (codeUnit >= 0x30 && codeUnit <= 0x39) {
+      return codeUnit - 0x30;
+    }
+    // a-f
+    if (codeUnit >= 0x61 && codeUnit <= 0x66) {
+      return codeUnit - 0x61 + 10;
+    }
+    // A-F
+    if (codeUnit >= 0x41 && codeUnit <= 0x46) {
+      return codeUnit - 0x41 + 10;
+    }
+    return -1;
+  }
+
   /// Comparaison en temps constant de deux strings hex (sortie SHA-256, etc.).
   /// Lance [ArgumentError] si tailles différentes — contrairement à
   /// [constantTimeEq] sur bytes (qui retourne `false`), ici on sait que les

test/secret_bytes_test.dart

@@ -0,0 +1,84 @@
+import 'dart:typed_data';
+
+import 'package:files_tech_core/files_tech_core.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('SecretBytes.fromHex — rejet des entrées non hexadécimales', () {
+    // Régression : `int.parse(..., radix: 16)` accepte un signe de tête et des
+    // espaces. `fromHex('-a')` rendait donc l'octet 246 (troncature deux
+    // compléments par Uint8List) au lieu de lever, alors que la doc promet une
+    // FormatException. Ces cas verrouillent le contrat.
+    for (final bad in const ['+a', '-a', ' a', 'a ', '+0', '-0', 'g0', '0g']) {
+      test('rejette "$bad"', () {
+        expect(() => SecretBytes.fromHex(bad), throwsFormatException);
+      });
+    }
+
+    test('rejette une longueur impaire', () {
+      expect(() => SecretBytes.fromHex('abc'), throwsFormatException);
+    });
+
+    test('accepte le hex valide, casses mélangées', () {
+      expect(SecretBytes.fromHex('00ffAb'), [0x00, 0xff, 0xab]);
+    });
+
+    test('chaîne vide → buffer vide', () {
+      expect(SecretBytes.fromHex(''), isEmpty);
+    });
+
+    test('round-trip toHex ∘ fromHex est l\'identité', () {
+      final src = Uint8List.fromList([0, 1, 15, 16, 127, 128, 254, 255]);
+      expect(SecretBytes.fromHex(SecretBytes.toHex(src)), src);
+    });
+  });
+
+  group('SecretBytes.wipe — signale l\'échec au lieu de l\'avaler', () {
+    test('buffer modifiable : zéroïse et retourne true', () {
+      final b = Uint8List.fromList([1, 2, 3, 4]);
+      expect(SecretBytes.wipe(b), isTrue);
+      expect(b, everyElement(0));
+    });
+
+    test('vue non modifiable : retourne false sans lever', () {
+      // C'est le cas que certaines impls FFI de `cryptography_flutter`
+      // produisent. Avant, l'échec était silencieux : l'appelant croyait le
+      // matériel de clé effacé alors qu'il restait intact en RAM.
+      final ro = Uint8List.fromList([1, 2, 3, 4]).asUnmodifiableView();
+      expect(SecretBytes.wipe(ro), isFalse);
+      expect(ro, [1, 2, 3, 4]);
+    });
+
+    test('buffer vide : succès trivial', () {
+      expect(SecretBytes.wipe(Uint8List(0)), isTrue);
+    });
+  });
+
+  group('SecretBytes.constantTimeEq', () {
+    test('longueurs différentes → false', () {
+      expect(SecretBytes.constantTimeEq([1, 2], [1, 2, 3]), isFalse);
+    });
+
+    test('contenu identique → true', () {
+      expect(SecretBytes.constantTimeEq([1, 2, 3], [1, 2, 3]), isTrue);
+    });
+
+    test('un seul bit différent → false', () {
+      expect(SecretBytes.constantTimeEq([1, 2, 3], [1, 2, 2]), isFalse);
+    });
+  });
+
+  group('SecretBytes.randomBytes', () {
+    test('longueur négative → ArgumentError', () {
+      expect(() => SecretBytes.randomBytes(-1), throwsArgumentError);
+    });
+
+    test('n == 0 → buffer vide', () {
+      expect(SecretBytes.randomBytes(0), isEmpty);
+    });
+
+    test('deux tirages de 32 octets diffèrent', () {
+      expect(SecretBytes.randomBytes(32), isNot(SecretBytes.randomBytes(32)));
+    });
+  });
+}