Data-integriteit · Per meting

Elke meting wordt cryptografisch verzegeld zodra die binnenkomt.

De meeste systemen ondertekenen het rapport. FahCel ondertekent elke meting en koppelt ze aan elkaar. Manipulatie van welke waarde dan ook, waar ook in de historie, wordt zo wiskundig aantoonbaar.

Hashalgoritme
SHA-256 FIPS 180-4 · 21 CFR Part 11 §11.10(e)
Hashes per meting
Twee data_hash · record_hash
Verificatie
Deterministisch offline, herhaalbaar, opensource
Beginpunt
prev_hash = '0' één beginpunt per levensduur van het apparaat
Vóór je volgende inspectie

De cryptografie doet het werk. Jij bent er klaar voor.

Verzegeling gebeurt bij ontvangst, dus het bewijs bestaat al voordat iemand erom vraagt. Voor een QA-manager verandert dat drie bekende haastklussen in zaken die gewoon klaarstaan.

Auditklaar pakket met één klik

Exporteer een ondertekende pdf met tijdstempel, de volledige meethistorie en het verificatieresultaat, ingericht voor toetsing aan de registraties waarop je al wordt beoordeeld.

EU GDP · 21 CFR Part 11 §11.10(e)

Afwijkingsmeldingen in realtime

Zodra een meting een grenswaarde overschrijdt, krijgt het team een melding. De registratie is dan al verzegeld in de keten, niet achteraf gereconstrueerd.

Verzegeld bij ontvangst · niet bij rapportage

Verificatie die de auditor kan herhalen

Overhandig de dataset en de open verificatietool. Een inspecteur kan de keten zelf offline opnieuw berekenen en tot hetzelfde resultaat komen.

Deterministisch · offline · opensource
Bewijsregister · Live

Wijzig een meting. Zie hoe de keten breekt.

Selecteer een meting en wijzig de temperatuur. Elke volgende record_hash wordt opnieuw berekend en vergeleken. De eerste gebroken schakel wordt gemarkeerd en alles erna geldt als onbetrouwbaar.
Apparaat FC-L421 · Vriezer 3 · Batch L2604-B Keten geverifieerd beginpunt: 0 · metingen: 6
✓
6 van 6 metingen geverifieerd. Elke data_hash klopt met de inhoud; elke record_hash verwijst naar zijn voorganger.
controletijd · 0.4 ms
Het principe

Twee hashes per meting. Eén verzegelt de data, één de historie.

Eén hash toont of een meting is bewerkt, maar niet of er een is verwijderd, verplaatst of stilzwijgend toegevoegd. Twee hashes, één over de inhoud en één over de inhoud plus de vorige record_hash, maken elke vorm van manipulatie zichtbaar.

Laag 1 · Integriteit van de inhoud

data_hash

SHA-256(deterministicJSON(// meetvelden — bedrijfseigen
  { ████████ ┄ ████████ ┄ ████,
    ███████ ┄ ██████ ┄ █████ ┄ ████████,
    ████████ ┄ █████████ ┄ ███████,
    ██████████ ┄ ███████████ }

))

Een vingerafdruk van de inhoud van de meting, onafhankelijk van de plek in de keten. De exacte velden en canonisatieregel zijn bedrijfseigen, maar deterministisch: dezelfde meting levert altijd dezelfde hash op, op elk systeem, voor altijd.

Doel. Manipulatie in de meetdata afzonderlijk herkennen. Verandert een veld, al is het één decimaal of seconde, dan verandert de data_hash.
Laag 2 · Integriteit van de historie

record_hash

SHA-256(deterministicJSON({
  ...business_fields,
  prev_hash // record_hash van de vorige meting
}))

De ketenschakel. Elke record_hash bevat de record_hash van de vorige meting. Zo vormen de hashes een eenrichtingsafhankelijkheid. De eerste meting gebruikt prev_hash = '0'.

Doel. Wijzig een meting en elke volgende record_hash verandert. De keten laat zien waar de manipulatie begon.
Ketenstructuur

Elke meting is afhankelijk van alle voorgaande metingen.

Een gekoppelde lijst waarin elke schakel onafhankelijk te verifiëren is. Als meting #3 wordt gewijzigd, mislukken de controles voor #4 tot en met #N: hun opgeslagen record_hash komt niet meer overeen met de herberekende hash.

Meting #001 · Beginpunt
-20.4 °C
prev_hash0
data_hasha17b…39fc
record_hashc4f0…91ae
prev_hash
Meting #002
-20.3 °C
prev_hashc4f0…91ae
data_hash7d22…8e01
record_hashe8a3…1c77
prev_hash
Meting #003
-20.6 °C
prev_hashe8a3…1c77
data_hashb91c…4a20
record_hash2f6d…d8b3
prev_hash
Meting #004
-20.5 °C
prev_hash2f6d…d8b3
data_hash03fe…6a15
record_hash91ba…47ec
Verificatie

verifyChain() — deterministisch, herhaalbaar, offline.

De verificatietool is deterministisch en identiek aan de code die de keten verzegelt. Dezelfde metingen geven altijd hetzelfde oordeel. Klanten en auditors draaien de volledige versie offline op elke geëxporteerde dataset. De kernregel voor verzegeling blijft bedrijfseigen.

// hashChain.js
export function verifyChain(readings) {
  const sorted = [...readings].sort(
    (a, b) => a.device_timestamp - b.device_timestamp
  );

  let prev_hash = sorted[0].prev_hash; // anchor ('0' at genesis)
  let firstTampered = null;

  for (const r of sorted) {
    core sealing — proprietary, redacted
    const data_hash   = sha256(canon(██████████));
    const record_hash = sha256(canon({ ████████ ┄ ████,
      prev_hash, ████████████ }));

    if (data_hash   !== r.data_hash ||
        prev_hash   !== r.prev_hash ||
        record_hash !== r.record_hash) {
      firstTampered ??= r.seq;         // remember first failure
    }
    prev_hash = r.record_hash;         // walk forward regardless
  }

  return {
    valid: firstTampered === null,
    first_tampered_at: firstTampered,
    total: sorted.length,
  };
}
1

Sorteer op apparaattijdstempel

De verificatietool doorloopt metingen in device_timestamp -volgorde, niet op ontvangstvolgorde. Een later ontvangen maar eerder vastgelegde meting komt op de juiste plek in de keten.

2

Bereken beide hashes opnieuw

Voor elke meting berekent de verificatietool data_hash en record_hash opnieuw vanuit de opgeslagen velden met dezelfde canonisatieregels. De opgeslagen waarden worden niet vertrouwd, maar opnieuw berekend en vergeleken.

3

Vind de eerste gebroken schakel

De eerste afwijking in een van de hashes wordt gemarkeerd. Elke volgende meting wordt verdacht: ook als de eigen hashes geldig lijken, is de integriteit van de keten al verloren.

4

Geef een verifieerbaar oordeel

valid, first_tampered_at, en het totale aantal gecontroleerde metingen. Dezelfde waarden staan in je audit-pdf. De inspecteur ziet dus precies wat je QA-team zag en kan het zelf herhalen.

Veelgestelde vragen

Wat auditors en QA-managers vragen voordat ze de keten vertrouwen.

Waarom heeft elke temperatuurmeting twee hashes nodig?

Eén hash herkent een bewerkte meting, maar geen verwijderde, verplaatste of stilzwijgend toegevoegde meting. FahCel slaat er twee op: een data_hash over de inhoud van de meting en een record_hash over die inhoud plus de vorige record_hash. Samen maken ze elke vorm van manipulatie zichtbaar, niet alleen wijzigingen in velden.

Wat is een record_hash in een koelketenlogboek?

De record_hash is de ketenschakel: de SHA-256 van de canonieke meetinhoud gecombineerd met de vorige record_hash. Zo vormen de hashes een eenrichtingsafhankelijkheid. De eerste meting in een zending gebruikt prev_hash = '0'. Wijzig een meting en elke record_hash erna verandert.

Hoe controleer je of een temperatuurketen ongewijzigd is?

Voer verifyChain() uit op de geëxporteerde metingen. Het berekent elke data_hash vanuit de inhoud en elke record_hash vanuit de inhoud plus de voorganger opnieuw en vergelijkt ze met de opgeslagen waarden. De controle is deterministisch, herhaalbaar en werkt offline. Een auditor kan het resultaat dus reproduceren zonder FahCel te hoeven vertrouwen.

Wat gebeurt er als iemand een eerdere temperatuurmeting wijzigt?

Vanaf die meting mislukt de verificatie. Als meting #3 wordt gewijzigd, falen #4 tot en met #N omdat hun opgeslagen record_hash niet meer overeenkomt met de herberekende hash. De eerste gebroken schakel wordt gemarkeerd en alles erna geldt als onbetrouwbaar. Je ziet dus waar de manipulatie begon, niet alleen dat die plaatsvond.

Op welke normen sluit de hashketen aan?

Het hashen gebruikt SHA-256 volgens FIPS 180-4. Het controlespoor dat manipulatie zichtbaar maakt is ontworpen op basis van 21 CFR Part 11 §11.10(e). Die bepaling vereist veilige, computergegenereerde controlesporen met tijdstempels die eerdere informatie niet verbergen. Het ondersteunt ook de registratie-eisen van EU GDP.

Zie de keten standhouden — of breken. Live.

In een QA-demo van 20 minuten verzegelen we temperatuurmetingen bij ontvangst, voeren we verifyChain uit en wijzigen we één meting. Je ziet precies waar de keten dat detecteert. Geen slides, maar het echte systeem en de echte hashes.

// verifieer via de API van je eigen datalogger
$ fahcel verify readings.csv
→ 14.208 metingen gecontroleerd
→ beginpunt: prev_hash = '0'
→ keten: geverifieerd ✓

// wijzig één meting en voer opnieuw uit
$ fahcel verify readings_edited.csv
→ integriteitsschending bij meting 8.341
→ keten: GEBROKEN ✗