# Validering

## Vad det är

Validering är det steg där ett program ställer inkommande data mot de regler som de är tänkta att följa och avvisar dem som inte håller måttet, innan något lagras, körs eller skickas vidare. Steget har olika namn beroende på lager: indatavalidering för formulärfält och API-anrop, schemavalidering när reglerna är nedskrivna som ett JSON Schema eller en OpenAPI-beskrivning, och validering av uppmärkning när en webbsida kontrolleras mot grammatiken i HTML. Indata som klarar kontrollen kallas giltig.

OWASP delar upp arbetet i två frågor. Syntaxen gäller om ett värde har förväntad typ och form: är det här ett datum, är det ett heltal, går anropets body att tolka som JSON. Semantiken gäller om värdet är rimligt för den operation det ska användas i, så en hotellbokning behöver två giltiga datum och dessutom ett slutdatum som ligger efter startdatumet. Att omvandla strängen ”500” till ett heltal avgör den första frågan och säger ingenting om huruvida 500 nätter är en godtagbar vistelse.

Validering av uppmärkning är den äldsta offentliga formen av idén på webben. W3C:s Markup Validation Service beskriver validering som att kontrollera ett dokument mot den grammatik som det uppger sig använda, och jämför sin validator med lint för C. Dokumentationen är noga med vad det bevisar: en giltig sida är inte nödvändigtvis en bra sida, bara en som ett verktyg har funnit förenlig med en viss uppsättning regler. Samma försiktighet gäller alla andra sorter. Validering säger att data passar de regler du skrev, men inte att reglerna var de rätta.

Två närliggande begrepp blandas ofta ihop med den. Sanering ändrar indata för att göra dem godtagbara, genom att skala bort eller skriva om delar av dem, medan validering godtar eller avvisar dem som de är. Kodning och parametrisering gör data säkra för den plats dit de ska, en HTML-sida eller en databasfråga i SQL, och de behövs fortfarande efter att valideringen har gått igenom.

## Varför det spelar roll

Beslutet bakom validering är var ett system drar sin förtroendegräns och vad det kontrollerar där. Varje anrop från en webbläsare, varje meddelande från en kö, varje fil från en partner och varje ändring i konfigurationen från en kollega kommer med antaganden i bagaget. Att kontrollera dem vid kanten innebär att resten av koden kan lita på dem. Att hoppa över kontrollen innebär att varje funktion längre in måste försvara sig själv, och i praktiken gör de flesta inte det.

Det andra beslutet gäller hur reglerna skrivs. Kontroller som skrivs för hand, slutpunkt för slutpunkt, är billiga i början och glider isär när systemet växer, eftersom var och en är sin egen lilla kodsnutt. Regler som deklareras en gång, som typer eller som ett schema, kan upprätthållas av ett bibliotek och publiceras som dokumentation från samma källa, vilket minskar risken för att beskrivningen och beteendet glider isär. Priset är ett ramverk att lära sig och standardvärden att förstå, eftersom ett schema upprätthåller exakt det som står i det och ingenting av det som det lämnar osagt.

Striktheten är det sista valet. En tillåtelselista beskriver vad som är godtagbart och avvisar allt annat, vilket OWASP rekommenderar framför att försöka känna igen varje skadlig sträng. Att avvisa fält som ett schema inte känner till fångar stavfel och gamla klienter tidigt. Att avvisa hela anropet vid det första problemet, med ett tydligt felmeddelande, är säkrare än att fortsätta med data som bara delvis har kontrollerats.

## Så ser det ut i praktiken

Ett API började med validering av anrop som skrevs för hand för varje slutpunkt. Vid det dokumenterade implementeringsskedet gjorde flytten till Huma v2 kontrollerna till typer över 649 sökvägar och 760 operationer. Varje slutpunkt hade structar för indata och utdata, Huma genererade valideringen av anropen utifrån dem, och en OpenAPI-beskrivning kom ur samma typer. Två slutpunkter för WebSocket låg kvar på ren Fiber, där modellen med anrop och svar inte passade. En kontroll i CI jämförde de rutter som servern registrerade med dem som beskrivningen utlovade. Den dokumenterade överensstämmelsen mellan rutterna var 100 %; kontroller deklarerade i indatatyperna ersatte motsvarande handskrivna validering.

Konfiguration behöver samma behandling, och SSH-härdningen på företagets värd kör nu validering i tre steg vid varje konvergenskörning. Kandidatfilen syntaxkontrolleras innan den installeras, den sammansatta konfigurationen kontrolleras efter installationen, och sedan läses daemonens egna gällande inställningar tillbaka och 24 direktiv kontrolleras mot dem. Det tredje steget finns därför att en åtkomstrapport i september 2026 hittade två inställningar som automatiseringen hade skrivit vid varje konvergenskörning och som daemonen hade åsidosatt. Operativsystemets egna standardvärden lästes först, och för just de två inställningarna vinner den första förekomsten. Som sidan uttrycker det bevisar en sökning efter ett direktiv med grep bara att det skrevs.

Validering av uppmärkning ingick i det dokumenterade implementeringsskedet i augusti 2026: HTML-validering var en av kontrollerna i en kvalitetsgrind med 22 lintverktyg vid commit, utan varningsnivå. Varje diagnostik var ett fel och undertryckningar direkt i koden var förbjudna, så att en ogiltig sida inte kunde committas genom att felet markerades som godtagbart.

## Var det går fel

Servern litar på det som webbläsaren redan har kontrollerat. Ett formulär som vägrar ta emot en felaktig e-postadress i webbläsaren ser validerat ut, men anropet kan skickas helt utan formuläret. OWASP räknar kontroller enbart på klientsidan som en vanlig fallgrop: validera på servern, och behandla kontrollen i webbläsaren som en snabb ledtråd till den som skriver.

Ett schema godtar allt som det inte nämner. I JSON Schema gör en listad egenskap varken fältet obligatoriskt eller andra fält förbjudna, och under standardvokabulären i 2020-12 samlas nyckelordet `format` in som en annotering, med kontrollen av formatet avslagen som standard. Det här schemat ser strikt ut:

```json
{
    "type": "object",
    "properties": {
        "email": { "type": "string", "format": "email" }
    }
}
```

Det godtar `{}`, `{"email": "nope"}` och `{"emial": "a@example.com"}`. Lägg till `required` och `"additionalProperties": false`, och aktivera formatkontroll (format assertion) i validatorn, eller kontrollera formatet i koden. Huma avvisar för sin del okända fält i en body som standard, dokumenterar `readOnly` och `writeOnly` utan att upprätthålla dem och ignorerar okända query-parametrar om inget annat anges.

Kontrollen godkänner en version av data och programmet använder en annan. En validator som läser det råa anropet medan hanteraren läser en avkodad kopia, eller ett test som granskar filen på disken medan daemonen tillämpar en annan inställning, har kontrollerat något som systemet aldrig använder. OWASP råder dig att validera den representation som faktiskt kommer att användas. SSH-arbetet ovan är samma lärdom i konfigurationens form: bara daemonens återläsning visade vad som faktiskt gällde.

En spärrlista möter nästa variant. Att blockera kända farliga tecken avvisar legitim indata, t.ex. en apostrof i ett efternamn, och lämnar ändå databasfrågan osäker. Bestäm vad varje fält godtar och avvisa resten.

Giltig indata behandlas som säker indata. En sträng som klarade varje regel kan ändå bryta sönder en SQL-sats eller en sida när den klistras in i den. Validering begränsar vad som kommer in. Parametriserade databasfrågor och kodning av utdata skyddar platsen där det hamnar, och båda behövs.

## Läs mer
* OWASP Input Validation Cheat Sheet — syntax och semantik, tillåtelselistor, gränser för tolkning och vanliga fallgropar.
* W3C Markup Validator documentation — validatorns egen beskrivning av validering av uppmärkning, med hjälpsidor om vad giltighet bevisar och vad den inte bevisar.
* JSON Schema Validation, draft 2020-12 — nyckelorden för validering, bl.a. hur `format` beter sig som standard.
* Huma: Request Validation — validering som genereras från taggar på Go-structar, med inställningarna för strikta och lösa fält.
* OpenAPI Specification — formatet för API-beskrivningar, vars schemadefinitioner många validerare för API:er upprätthåller.

=> /sv/portfolio/migrated-the-api-to-huma-v2-at-100-parity/ gjorde flytten till Huma v2 kontrollerna till typer över 649 sökvägar och 760 operationer
=> /sv/portfolio/hardened-ssh-to-24-validated-directives/ SSH-härdningen på företagets värd kör nu validering i tre steg vid varje konvergenskörning
=> /sv/portfolio/built-a-22-linter-commit-gate/ HTML-validering var en av kontrollerna i en kvalitetsgrind med 22 lintverktyg
=> https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html OWASP Input Validation Cheat Sheet
=> https://validator.w3.org/docs/ W3C Markup Validator documentation
=> https://json-schema.org/draft/2020-12/json-schema-validation JSON Schema Validation, draft 2020-12
=> https://huma.rocks/features/request-validation/ Huma: Request Validation
=> https://spec.openapis.org/oas/latest.html OpenAPI Specification

=> https://engineer.company/sv/glossary/validation/ Den här sidan på webben
