Härdning efter panelgranskningen: kedjad logg, förseglat avslut, härledd säkerhetsnivå

Fyra av granskningens fynd åtgärdade, i bevisvärdesordning.

HASHKEDJAN (ALVA-SPEC-070). Triggrar skyddar loggen mot applikationen,
inte mot den som äger databasen — det var granskningens allvarligaste
invändning mot ett system vars hela värde är bevisvärde. Varje händelse
bär nu en hash av sitt innehåll och föregående händelses hash, beräknad
av servern vid insättningen. All skrivning går genom en enda kedjande
funktion; en händelse vid sidan av kedjan är ett hål i beviset, så den
bekväma vägen förbi finns inte. Digest tas över den LAGRADE händelsen,
efter kryptering: verifieringen ska kunna räkna om den ur databasen för
all framtid, och krypto-shredding förstör nycklar, inte rader, så kedjan
överlever en radering. Radlås per ärende hindrar att två samtidiga
batchar forkar kedjan — en falsk larmande verifiering avfärdas snart som
trasig, och då är den värdelös.

Integrationstestet provar hotmodellen ordagrant: triggern släpps, en rad
ändras med full databasbehörighet, triggern återskapas. Verifieringen
pekar ut raden — inte bara att något är fel, utan vilken.

FÖRSEGLINGEN. Avslut skriver kedjans rot och en HMAC med en nyckel som
aldrig finns i databasen, i samma transaktion som avslutshändelsen. Den
som räknar om hela kedjan efter sin ändring stoppas av att förseglingen
inte går att räkna om utan nyckeln. Engångs: triggern vägrar ändra en
satt försegling. Svaret säger vad det bevisar och inte — innehållet är
oförändrat sedan mottagandet, ingenting om tiden före, ingenting om
sanningshalten. Den texten följer med in i varje rapport som citerar
svaret, för det är precis den skillnad en motpartsjurist annars hittar.

SIGNATUREN. Fältet hette signatur men var teknikerns egen text — det
inbjöd en jurist att tro något som inte gällde. Det skrivs nu ur
verifierad token som övriga härkomstfält och intygar exakt vad det kan
intyga: vem som var inloggad när avslutet togs emot.

SÄKERHETSNIVÅN (ALVA-SPEC-071). Var teknikerns fria val — ett
självskattat värde som ser ut som en mätning. Nu ett tak härlett ur
underlaget: hög kräver reproducerat symptom OCH spårbart mätvärde ur
mätdonsregistret; enbart observationer bär inte ens medel. Teknikern kan
sänka men aldrig höja — asymmetrin är poängen, ärlig osäkerhet är
information. Grinden spärrar påståenden över taket på alla tio språken,
och gränssnittet visar taket medan arbetet pågår i stället för att spara
beskedet till avslutsknappen. "Delvis reproducerat" bär inte hög: delvis
är ett annat ord för att felet inte är förstått.

Taket bet direkt i två av våra egna testfixturer som påstod hög utan
spårbart mätdon — vilket är regeln som fungerar, inte testet som är fel.
Genomgången avslöjade följdkravet: vid medel/låg kräver panelen att
teknikern anger vilka ytterligare kontroller som skulle stärka
bedömningen, och det fältet fylls nu i som en tekniker skulle.

Kvar ur granskningens lista, medvetet: extern förankring (RFC 3161),
klienthashat foto vid upptagning, gränsvärden som data, OIDC/SAML.

766 tester, 200 integrationskontroller mot riktig Postgres — inklusive
sabotage som databasägare — genomgång 4/4, portalspärr, typkontroll,
lint och artefaktmätning gröna. Utgåva 3.3, API-specen uppdaterad,
åtgärderna bokförda i panelrapportens bilaga A.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012EQg3rJsrQ1ZNTvkzmQAtt

felsokning/services/gemensam/kedja.mjs

@@ -0,0 +1,108 @@
+// ALVA-SPEC-070 · Hashkedjan.
+//
+// ---- Varför triggrar inte räcker ----------------------------------------
+//
+// Loggen är append-only, genomdrivet av databastriggrar. Panelgranskningen
+// (docs/PANELGRANSKNING-2026-08.md, datasäkerhetssätet) satte fingret på
+// gränsen för det skyddet: en trigger skyddar mot APPLIKATIONEN, inte mot
+// den som äger databasen. Den som har superuser släpper triggern, ändrar
+// raden och återskapar triggern, och ingenting syns.
+//
+// För ett system vars hela värde är bevisvärde är det fel viloläge. En
+// hashkedja flyttar skyddet från behörighet till matematik: varje händelse
+// bär en hash av sitt eget innehåll OCH föregående händelses hash. Den som
+// ändrar en rad i efterhand bryter varje efterföljande länk, och brottet
+// går att peka ut — inte bara konstatera.
+//
+// ---- Vad kedjan bevisar, och inte ---------------------------------------
+//
+// Kedjan bevisar att loggen inte ändrats SEDAN DEN SKREVS, i den ordning
+// den skrevs. Den bevisar inte att det som skrevs var sant — det är
+// grindens och evidensmodellens uppgift — och den bevisar ingenting om
+// tiden FÖRE serverns mottagande. Rapporten ska säga just det och inte
+// mer: "innehållet är oförändrat sedan mottagandet".
+//
+// Förseglingen vid avslut (HMAC över roten med en nyckel utanför
+// databasen) skyddar mot nästa angrepp i ordningen: den som äger databasen
+// och räknar OM hela kedjan efter sin ändring. Utan nyckeln kan en
+// omräknad kedja inte förseglas om, och en försegling som inte stämmer
+// mot roten är beviset.
+//
+// ---- Konstruktion --------------------------------------------------------
+//
+//   länk_n = SHA256(länk_{n-1} · id · tidpunkt · anvandare · digest)
+//
+// `digest` är innehållshashen av den kanoniska händelsen — samma
+// `klientdigest` som kollisionsprövningen redan använder, så kedjan och
+// dubblettskyddet kan aldrig ha olika uppfattning om vad en händelse
+// "är". Fälten skiljs med radbrytning: utan avskiljare vore
+// ("ab","c") och ("a","bc") samma länk.
+//
+// Första länken utgår från ärende-id:t i stället för en tom sträng, så
+// att två ärenden med identisk första händelse ändå får olika kedjor —
+// en kedja ska inte gå att lyfta från ett ärende till ett annat.
+
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+/** Kedjans startvärde för ett ärende. */
+export const grund = (arendeId) =>
+  createHash("sha256").update(`alva-kedja\n${arendeId}`).digest("hex");
+
+/** Nästa länk. Alla fält är strängar; digest är händelsens innehållshash. */
+export function lank(foregaende, { id, tidpunkt, anvandare, digest }) {
+  return createHash("sha256")
+    .update(`${foregaende}\n${id}\n${tidpunkt}\n${anvandare}\n${digest ?? ""}`)
+    .digest("hex");
+}
+
+/**
+ * Verifierar en hel kedja mot lagrade länkar.
+ *
+ * @param arendeId ärendet kedjan tillhör
+ * @param rader    [{id, tidpunkt, anvandare, digest, kedjehash}] i kedjeordning
+ * @returns {ok, rot, brott} — brott pekar ut FÖRSTA raden som inte
+ *          stämmer. Allt efter den är följdfel och räknas inte upp:
+ *          den som läser ska laga ett brott i taget, inte skrämmas av
+ *          hundra.
+ *
+ * Rader utan lagrad kedjehash (skrivna innan kolumnen fanns) bryter inte
+ * kedjan men märks som `okedjade` — tystnad hade låtit gammal data se
+ * starkare ut än den är, och det är precis den sortens övertro kedjan
+ * finns för att förhindra.
+ */
+export function verifiera(arendeId, rader) {
+  let h = grund(arendeId);
+  let okedjade = 0;
+  for (let i = 0; i < rader.length; i++) {
+    const rad = rader[i];
+    h = lank(h, rad);
+    if (rad.kedjehash == null) {
+      okedjade++;
+      continue;
+    }
+    if (rad.kedjehash !== h) {
+      return { ok: false, rot: null, okedjade, brott: { index: i, id: rad.id } };
+    }
+  }
+  return { ok: true, rot: rader.length > 0 ? h : grund(arendeId), okedjade };
+}
+
+/**
+ * Förseglar en kedjerot med en nyckel som hålls utanför databasen.
+ *
+ * HMAC, inte hash: poängen är att den som äger databasen inte kan räkna
+ * om förseglingen efter en ändring. Nyckeln är serverns, inte
+ * teknikerns — förseglingen intygar att PLATTFORMEN såg denna rot vid
+ * denna tid, ingenting om vem som tryckte på knappen. Det intyget står
+ * händelsens serverägda `anvandare`-fält för.
+ */
+export function forsegla(nyckel, arendeId, rot, tidpunkt) {
+  return createHmac("sha256", nyckel).update(`${arendeId}\n${rot}\n${tidpunkt}`).digest("hex");
+}
+
+/** Prövar en försegling. Konstanttid — en försegling är en hemlighet. */
+export function provaForsegling(nyckel, arendeId, rot, tidpunkt, forsegling) {
+  const ratt = Buffer.from(forsegla(nyckel, arendeId, rot, tidpunkt), "hex");
+  const given = Buffer.from(String(forsegling ?? ""), "hex");
+  return ratt.length === given.length && given.length > 0 && timingSafeEqual(ratt, given);
+}