Export judiciaire & valeur probante

planar produit des dossiers numriques valeur probante conformes la norme NF Z42-013, avec horodatage qualifi eIDAS et chane de custody cryptographique.

Vue d'ensemble

L'export judiciaire gnre un dossier ZIP autonome contenant l'intgralit des preuves d'une mission : photos, vidos bodycam, enregistrements audio, traces GPS, marqueurs et notes. Chaque lment est hash individuellement (SHA-256) et l'ensemble est certifi par un jeton d'horodatage RFC 3161.

Stratgie d'horodatage

L'horodatage suit un modle deux niveaux : hachage local continu pendant la mission, certification externe au moment de l'export.

Pendant la mission (hachage local)

Chaque fichier captur (photo, vido, audio, marqueur) reoit immdiatement un hash SHA-256 calcul localement sur l'appareil. Ce hash est stock avec les mtadonnes du fichier. Pour les enregistrements bodycam chiffrs, deux hashes sont conservs :

• hash_sha256_content : hash du contenu original (avant chiffrement), pour la vrification judiciaire
• hash_sha256 : hash du fichier stock (aprs chiffrement AES-256-GCM), pour l'intgrit du stockage

l'export (certification TSA)

Au moment de l'export judiciaire, un manifest est gnr listant tous les fichiers avec leurs hashes SHA-256. Le hash de ce manifest est soumis une autorit d'horodatage (TSA) qui retourne un jeton RFC 3161 sign. Ce jeton unique certifie cryptographiquement que l'ensemble du dossier existait la date indique.

Autorits d'horodatage (TSA)

Structure du dossier export

Le ZIP gnr est un dossier autonome et auto-vrifiable. Un tiers (magistrat, expert, avocat) peut vrifier l'intgrit de l'ensemble avec des outils standard (OpenSSL).

export_mission_<id>_<date>.zip
├── originaux/
│   ├── photos/
│   │   └── photo_<timestamp>_<hash8>.jpg
│   ├── videos/
│   │   └── video_<timestamp>_<hash8>.webm
│   ├── audio/
│   │   └── audio_<timestamp>_<hash8>.webm
│   └── donnees/
│       ├── markers.json
│       ├── tracks.gpx
│       ├── filatures.json
│       ├── notes.json
│       ├── evidence_chain.json      ← Hash chain incrémentale complète
│       ├── chain_anchors.json       ← Points d'ancrage Merkle
│       └── chain_verification.json  ← Rapport de vérification automatique
├── signatures/
│   ├── timestamp.tsr            ← Jeton RFC 3161 (binaire DER)
│   ├── timestamp_info.json      ← Mtadonnes lisibles du jeton
│   ├── tsa_certificate.der      ← Certificat du TSA (vrification indpendante)
│   ├── timestamp_audit.json     ← Journal d'audit horodatage
│   ├── manifest.sig             ← Signature Ed25519 du manifest
│   └── public_key.json          ← Cl publique Ed25519
├── manifest.json                ← Inventaire complet + hashes SHA-256
└── chain_of_custody.json        ← Chane de custody (capture → export)

Le manifest

Le manifest.json est le cur du dossier probatoire. Il contient l'inventaire exhaustif de tous les fichiers exports, chacun avec son hash SHA-256, sa taille, sa date de capture et ses mtadonnes (GPS, auteur, appareil). C'est le hash de ce manifest qui est soumis au TSA.

Chane de custody

Le fichier chain_of_custody.json trace chaque vnement li aux preuves, de la capture l'export. Pour chaque fichier, trois vnements sont enregistrs :

Hash chain incrémentale (anti-falsification)

En plus de la traçabilité capture → stockage → export, le dossier inclut une chaîne de hachage incrémentale qui enregistre en temps réel chaque action probatoire pendant la mission. Comparable à une blockchain privée, chaque entrée est liée cryptographiquement à la précédente par un HMAC-SHA256.

Vrification indpendante

Le dossier export est conu pour tre vrifiable par un tiers sans accs planar. Les outils standard OpenSSL suffisent.

Vrifier le jeton RFC 3161

# Vrifier que le timestamp correspond au manifest
openssl ts -verify \
  -in signatures/timestamp.tsr \
  -data manifest.json \
  -CAfile signatures/tsa_certificate.der

# Lire le contenu du jeton
openssl ts -reply -in signatures/timestamp.tsr -text

Vrifier l'intgrit des fichiers

# Calculer le hash SHA-256 d'un fichier et comparer au manifest
sha256sum originaux/photos/photo_20250206_a1b2c3d4.jpg

# Comparer avec la valeur dans manifest.json → files[].hash_sha256

Vrifier la signature Ed25519

# La cl publique est dans signatures/public_key.json
# La signature du manifest est dans signatures/manifest.sig
# Vrifiable avec tout outil supportant Ed25519 (libsodium, openssl 3.x)

Valeur lgale

Deux types d'export : judiciaire vs forensique

planar propose deux exports complémentaires pour répondre à des besoins différents dans le cadre d'une procédure.

Vérification forensique indépendante

Pour les procédures judiciaires, un expert forensique peut vérifier l'intégrité de la chaîne de preuves de manière totalement indépendante, sans accès à planar.

Exporter le bundle de vérification

Depuis Paramètres → Compte → Vérification forensique, cliquez sur « Exporter les données de vérification ». Le fichier JSON généré contient :

• La chaîne de preuves complète (entrées, ancres Merkle, tombstones)
• La clé maître cryptographique et les paramètres HKDF (bundle autoportant)
• Le rapport d'intégrité automatique
• Les clés publiques Ed25519 pour vérification des signatures per-entrée
• Les instructions de vérification étape par étape

Processus de vérification par l'expert

1. Lire la clé maître depuis le champ keyDerivation.masterKeyHex du bundle JSON.
2. Dériver la clé HMAC : HKDF-SHA256(ikm=masterKeyHex décodé en 32 octets, salt="evidence-chain-v1", info="hmac-key", 256 bits).
3. Vérifier chaque entrée : HMAC-SHA256(clé, contentHash|previousHash|sequence|timestamp) == entryHash.
4. Vérifier le chaînage : entry[n].previousHash == entry[n-1].entryHash (première : "GENESIS").
5. Vérifier les signatures Ed25519 per-entrée avec les clés publiques fournies dans signingPublicKeys.
6. Vérifier les horodatages RFC 3161 des ancres Merkle (si présents).

Questions fréquentes

Script de vérification (Python)

import hmac, json, sys

bundle = json.load(open(sys.argv[1]))

# Read master key directly from bundle (no PIN needed)
master_key_hex = bundle["keyDerivation"]["masterKeyHex"]
master_key = bytes.fromhex(master_key_hex)

# Derive HMAC chain key via HKDF
import hkdf  # pip install hkdf
chain_key = hkdf.hkdf_expand(
    hkdf.hkdf_extract(b"evidence-chain-v1", master_key),
    b"hmac-key", 32
)

# Verify each entry
entries = sorted(bundle["evidenceChain"]["entries"], key=lambda e: e["sequence"])
prev_hash = "GENESIS"
ok_count = 0
for e in entries:
    expected = hmac.new(chain_key,
        f'{e["contentHash"]}|{prev_hash}|{e["sequence"]}|{e["timestamp"]}'.encode(),
        "sha256").hexdigest()
    chain_ok = e["previousHash"] == prev_hash
    hmac_ok = expected == e["entryHash"]
    ok = chain_ok and hmac_ok
    if ok: ok_count += 1
    else: print(f'FAIL seq={e["sequence"]} chain={chain_ok} hmac={hmac_ok}')
    prev_hash = e["entryHash"]

print(f"\n{ok_count}/{len(entries)} entries verified OK")