Spring til indhold

Artikel

10 sikkerhedsfejl, der går igen i AI-byggede apps

AI-værktøjer er gode til at bygge det, man kan se. Sikkerhed er det, man ikke kan se. Her er de ti fejl, der går igen – hvad de er, hvorfor de opstår, og hvordan I selv finder og retter dem.

Lovable, Bolt, v0, Replit, Cursor, Claude Code og GitHub Copilot har gjort det muligt at bygge en fungerende app på dage i stedet for måneder. Det er en reel gevinst, og den skal I ikke lade jer tale fra.

Men værktøjerne bliver bedømt på, om det virker i preview. En manglende adgangskontrol virker fint i preview. Det gør en åben database også. Sikkerhedsfejl er fravær af noget, og fravær kan ikke ses på en skærm – hverken af jer eller af den model, der skrev koden.

Fejlene herunder er ikke nye. Det er de samme, udviklere har lavet i håndskrevet kode i årevis. Forskellen er, at de nu opstår hurtigere og hos folk, der ikke har prøvet at blive ramt af dem før. For hver fejl gennemgår vi, hvad den er, hvorfor AI-værktøjer har det med at lave den, hvordan I tjekker jeres egen løsning, og hvordan den rettes.

Test kun det, I selv ejer. Alle tjek i artiklen er tænkt til jeres egen løsning. At afprøve dem på andres systemer uden aftale er ulovligt.

Adgangskontrol kun i brugerfladen

Administratorknappen er skjult for almindelige brugere, og siden /admin sender dem væk. Men det endpoint, som knappen kalder, tjekker ikke, hvem der spørger. Brugerfladen er et forslag til, hvordan løsningen skal bruges. Enhver kan springe den over og tale direkte med serveren.

Hvorfor det opstår

En besked som ”kun administratorer må kunne slette brugere” bliver løst dér, hvor resultatet kan ses: en betingelse omkring knappen eller en route guard i React. Kravet ser opfyldt ud, og ingen har bedt om en test, der kalder serveren udenom.

Sådan tjekker I

  • Log ind som almindelig bruger, og åbn fanen Network i browserens udviklerværktøjer. Find et kald, som kun en administrator burde kunne lave, vælg ”Copy as cURL”, og kør det med den almindelige brugers session – og helt uden login.
  • Bliver handlingen gennemført, eller får I data tilbage, er det et hul. Svaret skal være 401, 403 eller 404.
  • Gennemgå hvert endpoint, hver server action og hver edge function: Hvor står der, hvem brugeren er, og hvad vedkommende må?

Sådan retter I

Tjek på serveren, i hvert eneste kald: Hvem er brugeren, og må vedkommende det her? Afvis som udgangspunkt, og åbn kun for det, der skal være åbent.

app.delete('/api/users/:id', requireUser, async (req, res) => {
  // Rollen læses fra sessionen på serveren – aldrig fra requesten
  if (req.user.role !== 'admin') {
    return res.sendStatus(403);
  }
  await db.user.delete({ where: { id: req.params.id } });
  res.sendStatus(204);
});

Bruger I Next.js, så husk, at server actions er offentlige HTTP-endpoints, og at middleware alene ikke er nok: Tjek sessionen inde i hver action og hver route handler. At skjule knappen er stadig god brugervenlighed. Det er bare ikke sikkerhed.

Åben database: Supabase uden row-level security, Firebase med åbne regler

Med Supabase og Firebase taler browseren direkte med databasen. Den nøgle, browseren bruger – Supabases anon-nøgle (i nyere projekter en publishable key, sb_publishable_…) eller Firebase-konfigurationen – er offentlig med vilje. Det eneste, der står mellem en fremmed og jeres data, er reglerne: row-level security (RLS) i Supabase og security rules i Firebase.

Er RLS slået fra på en tabel i public-skemaet, kan alle med anon-nøglen læse og skrive hele tabellen gennem Supabases API. Og nøglen ligger i jeres JavaScript.

Hvorfor det opstår

En RLS-policy, der blokerer, giver ikke en fejl. Den giver en tom liste. Den hurtigste vej til, at ”det virker igen”, er at slå RLS fra eller skrive en policy med using (true). I Firebase er det test mode, der åbner alt i en periode – og når perioden udløber, bliver datoen flyttet. En tredje variant er regler, der kun kræver login: Kan alle oprette en konto, kan alle læse alt.

Sådan tjekker I

I Supabase viser Security Advisor i dashboardet tabeller uden RLS. I kan også spørge databasen selv:

-- Tabeller i public og om RLS er slået til
select tablename, rowsecurity
from pg_tables
where schemaname = 'public';

-- De policies, der findes
select tablename, policyname, cmd, roles, qual, with_check
from pg_policies
where schemaname = 'public';

Læs hver policy. true i kolonnen qual betyder ”alle rækker”. Prøv derefter udefra: Hent en tabel med anon-nøglen uden at være logget ind, og se, hvad der kommer tilbage.

curl 'https://DIT-PROJEKT.supabase.co/rest/v1/orders?select=*' \
  -H "apikey: DIN_ANON_NØGLE"

I Firebase åbner I fanen Rules og leder efter allow read, write: if true, efter regler med en dato og efter regler, der kun tjekker request.auth != null.

Sådan retter I

Slå RLS til på alle tabeller, og skriv en policy pr. handling, der binder rækken til brugeren:

alter table public.orders enable row level security;

create policy "Brugere læser egne ordrer"
on public.orders for select
to authenticated
using ( (select auth.uid()) = user_id );

create policy "Brugere opretter egne ordrer"
on public.orders for insert
to authenticated
with check ( (select auth.uid()) = user_id );

Det samme i Firestore:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /orders/{orderId} {
      allow read: if request.auth != null
                  && request.auth.uid == resource.data.userId;
      allow create: if request.auth != null
                    && request.auth.uid == request.resource.data.userId;
    }
  }
}

Tre ting bliver ofte glemt: Storage har sine egne regler, som skal skrives for sig. Skriv både using og with check på update-policies, så det er tydeligt, hvilke rækker der må ændres, og hvad de må ændres til. Og Supabases service_role-nøgle – i nyere projekter en secret key, sb_secret_… – går uden om RLS. Den hører kun hjemme på serveren.

API-nøgler i frontend

Alt, hvad der sendes til browseren, er offentligt. Det gælder også miljøvariabler: Variabler, der starter med NEXT_PUBLIC_ i Next.js eller VITE_ i Vite, bliver skrevet ind i JavaScript-filerne, når løsningen bygges. De er ikke hemmelige, uanset at de står i en .env-fil.

Nogle nøgler er lavet til at være offentlige: Supabases anon-nøgle eller publishable key (sb_publishable_…), Firebase-konfigurationen og Stripes publishable key (pk_…). Andre må aldrig forlade serveren: Stripes secret key (sk_…), Supabases service_role-nøgle eller secret key (sb_secret_…), nøgler til OpenAI, Anthropic og Google, SMTP-adgangskoder og databaseforbindelser.

Hvorfor det opstår

Kaldet til AI-modellen eller betalingsudbyderen bliver skrevet dér, hvor der bliver arbejdet: i komponenten. I browseren er variablen undefined, og den rettelse, der får fejlen til at forsvinde, er at sætte NEXT_PUBLIC_ foran. Nu virker det – og nøglen er offentlig.

Sådan tjekker I

  • Søg i koden efter NEXT_PUBLIC_ og VITE_, og tag stilling til hver enkelt variabel: Må alle i verden kende den?
  • Byg løsningen, og søg i de færdige filer efter kendte nøgleformater.
  • Åbn den kørende løsning, og kig i fanen Network: Går der kald direkte fra browseren til api.openai.com, api.anthropic.com eller lignende, ligger nøglen i browseren.
# Efter build: led efter hemmelige nøgler i det, browseren får
grep -rEn "sk_live_|sk_test_|sk-proj-|sk-ant-|sb_secret_|service_role" dist/ .next/static/

Et fund på service_role viser et variabelnavn, ikke selve nøglen: Den ældre service_role-nøgle er en lang JWT, der begynder med eyJ. Se efter, hvilken værdi variablen har fået, og om den er endt i de filer, browseren henter.

Sådan retter I

Flyt kaldet til serveren – en API-route, en server action eller en edge function – så browseren kalder jeres endpoint, og jeres endpoint kalder tjenesten. Dér kan I også tjekke, at brugeren er logget ind, og begrænse forbruget (se fejl 7).

Og udskift nøglen. En nøgle, der har ligget i et offentligt bundle, skal betragtes som lækket. At fjerne præfikset og bygge igen ændrer ikke på, hvem der allerede har set den.

Ubekræftede betalings-webhooks

Når en kunde har betalt, fortæller betalingsudbyderen det til jeres server med et HTTP-kald til en offentlig adresse: en webhook. Tjekker jeres endpoint ikke, at kaldet faktisk kommer fra udbyderen, kan hvem som helst sende beskeden ”ordren er betalt” – og få adgang eller varer uden at betale.

En beslægtet fejl er at give adgang på kvitteringssiden: Kunden lander på /success, og siden markerer ordren som betalt. Den adresse kan alle åbne.

Hvorfor det opstår

En handler, der læser JSON og opdaterer databasen, virker fint i test. Signaturtjekket kræver den rå, uændrede request body, og det kolliderer med, at de fleste frameworks automatisk parser JSON. Når verificeringen fejler af den grund, er den nemmeste ”rettelse” at fjerne den.

Sådan tjekker I

  • Find jeres webhook-route. Med Stripe skal I kunne finde stripe.webhooks.constructEvent og headeren Stripe-Signature.
  • Send et hjemmelavet kald uden signatur til endpointet i jeres testmiljø. Svaret skal være 400, og intet må ændre sig i databasen.
  • Åbn kvitteringssiden direkte uden at have betalt. Sker der noget?

Sådan retter I

app.post('/webhooks/stripe',
  express.raw({ type: 'application/json' }),   // rå body, ikke parset JSON
  async (req, res) => {
    let event;
    try {
      event = stripe.webhooks.constructEvent(
        req.body,
        req.headers['stripe-signature'],
        process.env.STRIPE_WEBHOOK_SECRET
      );
    } catch (err) {
      return res.sendStatus(400);
    }

    if (event.type === 'checkout.session.completed') {
      await markOrderPaid(event.data.object, event.id);   // idempotent
    }
    res.sendStatus(200);
  }
);

I Next.js’ App Router læser I den rå body med await request.text(). Gem event.id, så det samme event ikke bliver behandlet to gange – udbyderen sender det igen, hvis jeres svar udebliver. Tag beløb og produkt fra eventet eller fra udbyderens API, aldrig fra noget, browseren har sendt. Princippet er det samme hos MobilePay, QuickPay og alle andre, der sender webhooks.

Manglende inputvalidering: injection og XSS

Alt, hvad en bruger kan sende, kan en angriber også sende – bare formet til at gøre skade. Tre varianter går igen:

  • SQL injection: Input bliver sat direkte ind i en SQL-sætning og kan dermed ændre, hvad sætningen gør.
  • XSS (cross-site scripting): Tekst fra en bruger – eller fra en AI-model – bliver vist som HTML, så et indlejret script kører i andre brugeres browser med deres login.
  • Mass assignment: Hele request-objektet bliver sendt videre til databasen, så en bruger selv kan sætte felter som role eller is_paid.

Hvorfor det opstår

ORM’er og React beskytter som standard, så AI-skrevet kode er ofte i orden, så længe den holder sig på hovedvejen. Fejlene opstår, når den forlader den: en rå forespørgsel til søgning eller sortering, dangerouslySetInnerHTML for at vise formateret tekst, eller update(req.body), fordi det er kortest. Valideringen ligger desuden tit kun i formularen i browseren – og den kan springes over.

Sådan tjekker I

  • Søg efter dangerouslySetInnerHTML, v-html og innerHTML. Hvor kommer indholdet fra?
  • Søg efter rå forespørgsler: $queryRawUnsafe, .raw( og tekststrenge med SELECT, der indeholder ${…}.
  • Spørg for hvert endpoint: Hvad sker der, hvis jeg sender et felt, formularen ikke har?

Sådan retter I

// Forkert: input bliver en del af SQL-sætningen
await db.query(`SELECT * FROM products WHERE name LIKE '%${q}%'`);

// Rigtigt: input sendes som parameter
await db.query('SELECT * FROM products WHERE name LIKE $1', [`%${q}%`]);

Validér på serveren med et skema – Zod, Pydantic, Laravels validering eller tilsvarende – og lad skemaet være en positivliste: Kun de felter, der står i det, kommer videre. Skal I vise HTML fra brugere, så rens det først med et bibliotek som DOMPurify. En Content Security Policy er et godt ekstra lag, men ikke en erstatning.

Andres data via ID’er i URL’en (IDOR)

I er logget ind og åbner /api/invoices/1042. I retter tallet til 1043 og får en anden kundes faktura. Serveren tjekker, at I er logget ind, men ikke at fakturaen er jeres. Fejlen hedder IDOR – insecure direct object reference. Under navnet broken object level authorization står den øverst på OWASP’s liste over sikkerhedsrisici i API’er.

Hvorfor det opstår

”Hent fakturaen med dette ID” bliver implementeret bogstaveligt: findById(id). Der er et login-tjek foran, så det ser sikret ud. Og fejlen kan ikke opdages af én person med én testbruger, hvilket er sådan, de fleste prototyper bliver testet.

Sådan tjekker I

  • Opret to testbrugere, helst i hver sin organisation. Lad A oprette noget, log ind som B, og bed om A’s ID’er: læs, ret og slet.
  • Husk fil-downloads, eksporter og billeder. De bliver ofte glemt.
  • Lange, tilfældige ID’er (UUID’er) gør det sværere at gætte, men de er ikke adgangskontrol. ID’er lækker gennem links, logs og delte skærmbilleder.

Sådan retter I

Lad ejerskabet være en del af selve forespørgslen, så det ikke kan glemmes:

const invoice = await db.invoice.findFirst({
  where: {
    id: req.params.id,
    organizationId: req.user.organizationId,   // fra sessionen
  },
});
if (!invoice) return res.sendStatus(404);

Organisationens eller brugerens ID skal komme fra sessionen på serveren, aldrig fra requesten. I Supabase er det præcis det, row-level security gør (se fejl 2). Skriv gerne en automatisk test, der prøver at hente bruger A’s data som bruger B. Den fanger fejlen, næste gang et nyt endpoint bliver genereret.

Ingen rate limiting: login, API og dyre AI-kald

Uden en grænse for, hvor mange gange et endpoint må kaldes, kan et script gøre det tusindvis af gange. På login betyder det, at adgangskoder kan gættes i ro og mag. På ”glemt adgangskode” og SMS betyder det spam for jeres regning. Og på endpoints, der kalder en AI-model, betyder det en regning, der vokser for hvert kald, indtil nogen opdager det.

Hvorfor det opstår

Rate limiting er ikke en funktion, nogen beder om, og den kan ikke ses i preview. Den kræver desuden et fælles sted at tælle – typisk Redis – som en serverless-opsætning ikke har fra start. En tæller i hukommelsen, som AI-værktøjer nogle gange foreslår, virker ikke, når hver forespørgsel kan lande på en ny instans.

Sådan tjekker I

# 30 hurtige loginforsøg mod jeres eget testmiljø
for i in $(seq 1 30); do
  curl -s -o /dev/null -w "%{http_code}\n" -X POST https://test.jeres-app.dk/api/login \
    -H "Content-Type: application/json" \
    -d '{"email":"test@example.com","password":"forkert"}'
done

Ser I aldrig 429, er der ingen grænse. Tjek også: Kan jeres AI-endpoint kaldes uden login? Og har I sat en forbrugsgrænse hos AI-udbyderen?

Sådan retter I

  • Begræns login og nulstilling af adgangskode både pr. IP-adresse og pr. konto.
  • Kræv login på alle endpoints, der kalder en AI-model, og giv hver bruger en kvote.
  • Sæt loft over inputlængde og max_tokens, så ét kald ikke kan blive vilkårligt dyrt.
  • Sæt forbrugsgrænser og budgetalarmer hos udbyderne. Det er sikkerhedsnettet, når alt andet fejler.
  • Brug det, platformen har: rate limiting-regler i Cloudflare, Upstash Ratelimit på Vercel, throttle-middleware i Laravel. Supabase Auth har grænser på sine egne endpoints – men ikke på de funktioner, I selv skriver.

Hemmeligheder i git-historikken

En .env-fil med rigtige nøgler bliver committet én gang. Senere bliver den slettet, og alt ser pænt ud. Men git glemmer ikke: Filen ligger stadig i historikken, og alle med adgang til repositoryet kan hente den frem. Er repositoryet offentligt, bliver nøglerne typisk fundet af automatiske scannere kort efter.

Hvorfor det opstår

En AI-agent opretter .env med de værdier, den har fået, og kører git add ., før der findes en .gitignore. Eller den skriver nøglen direkte i en konfigurationsfil eller et testscript for at komme videre. Når nogen beder den rydde op, sletter den filen i et nyt commit – og det gamle commit lever videre.

Sådan tjekker I

# Har en .env-fil nogensinde været committet?
git log --all --oneline -- .env '.env.*' '*.env'

# Find commits, hvor en bestemt nøgletype er tilføjet eller fjernet
git log --all -p -S 'sk_live_'

# Scan hele historikken med gitleaks (ældre versioner: gitleaks detect)
gitleaks git -v

På GitHub kan I desuden slå secret scanning og push protection til, så nye nøgler bliver stoppet, før de lander i repositoryet.

Sådan retter I

  1. Udskift nøglen først. Opret en ny hos udbyderen, læg den ind i driftsmiljøet, og spær den gamle. Det er det eneste skridt, der faktisk lukker hullet.
  2. Ryd op bagefter. Historikken kan omskrives med git filter-repo, men det hjælper ikke på kloner, forks og kopier, der allerede findes. Derfor er rotation ikke valgfri.
  3. Forebyg. Læg .env* i .gitignore, behold en .env.example uden værdier, og gem de rigtige nøgler i hostingplatformens miljøvariabler.

Forældede eller opdigtede pakker

Her er der to problemer i ét. Det første er velkendt: pakker i gamle versioner med kendte sårbarheder. Det andet er nyt: En sprogmodel kan foreslå en pakke, der lyder rigtig, men ikke findes. Fordi de samme opdigtede navne går igen, kan en angriber registrere dem på forhånd med skadelig kode i. Det kaldes slopsquatting. Når pakken installeres, kan dens installationsscript køre med adgang til alt det, jeres maskine eller build-server har adgang til.

Hvorfor det opstår

En sprogmodel genererer det sandsynlige navn, ikke det verificerede. Dens viden stopper på et tidspunkt, så den foreslår de versioner, der var aktuelle dengang. Og når en agent selv kører npm install, er der ingen, der når at kigge på, hvad der bliver hentet.

Sådan tjekker I

npm audit          # kendte sårbarheder (pnpm audit, pip-audit, composer audit)
npm outdated       # hvor langt bagud er I?
  • Læs package.json igennem. Slå hver pakke, I ikke kender, op i registret: Hvor gammel er den, hvor mange bruger den, og peger den på et rigtigt repository?
  • Vær ekstra opmærksom på navne, der ligner kendte pakker med en lille afvigelse.
  • Tjek, at lockfilen (package-lock.json, pnpm-lock.yaml) er committet.

Sådan retter I

  • Commit lockfilen, og brug npm ci i build, så det er de samme versioner, der bliver installeret hver gang.
  • Slå Dependabot eller Renovate til, så opdateringer kommer løbende som små ændringer i stedet for ét stort spring.
  • Fjern pakker, der ikke bliver brugt. Hver afhængighed er kode, I stoler på uden at have læst den.
  • Behandl en ny afhængighed som en kodeændring, der skal godkendes. Skriv det ind i jeres projektregler, så AI-agenten spørger, før den installerer noget.

Fejlbeskeder og logs, der lækker data

Når noget går galt, fortæller løsningen for meget. En fejlside viser stack trace, SQL-sætning og filstier. Et API returnerer hele brugerobjektet fra databasen, inklusive felter, brugerfladen aldrig viser. Login svarer ”brugeren findes ikke”, så man kan teste, hvilke e-mailadresser der har en konto. Og loggen gemmer hele requests med adgangskoder, tokens og persondata – hos en tredjepart.

Hvorfor det opstår

Fejlsøgning med AI foregår ved at logge alt og sende fejlen tilbage til skærmen, så den kan kopieres ind i chatten. Det er effektivt under udvikling. Bagefter er der ingen, der beder om at få det fjernet. På samme måde er select * og ”returnér hele objektet” den korteste vej til noget, der virker.

Sådan tjekker I

  • Fremprovokér fejl i produktion: et ID, der ikke findes, ugyldig JSON, et alt for langt felt. Hvad står der i svaret?
  • Kig på API-svarene i fanen Network. Er der felter med, som siden ikke bruger – password_hash, tokens, interne noter?
  • Tjek, at debug er slået fra i produktion: APP_DEBUG=false i Laravel, DEBUG = False i Django.
  • Søg i jeres logs efter password, token og authorization.

Sådan retter I

app.use((err, req, res, next) => {
  const errorId = crypto.randomUUID();
  logger.error({ errorId, err, path: req.path, userId: req.user?.id });  // detaljer til jer
  res.status(500).json({ error: 'Der skete en fejl.', errorId });        // ikke til brugeren
});

Brugeren får en generel besked og et fejl-ID, I kan slå op. Detaljerne bliver på serveren. Vælg eksplicit, hvilke felter et API returnerer, i stedet for at sende hele rækken. Brug samme besked ved forkert e-mail og forkert adgangskode. Og husk, at logs med persondata også er persondata: Filtrér følsomme felter fra, og beslut, hvor længe loggen skal gemmes.


Hvor skal I starte?

Ikke alle ti haster lige meget. Vi prioriterer efter, hvor let fejlen er at udnytte, og hvor meget den kan koste. Det er også sådan, vi deler fundene op i et kodetjek.

Kritisk
Kan udnyttes udefra. Manglende adgangskontrol på serveren (1), åben database (2), nøgler i frontend (3), ubekræftede webhooks (4) og hemmeligheder i et offentligt repository (8). Luk dem i dag.
Vigtigt
Kan udnyttes af enhver med en konto. Andres data via ID’er (6), inputvalidering (5) og rate limiting (7). Det samme gælder hemmeligheder i historikken på et privat repository (8). Luk dem, før I inviterer flere brugere ind.
Løbende
Hører til den faste vedligeholdelse. Afhængigheder (9) og fejlbeskeder og logs (10). Sæt dem i system, så de ikke bliver glemt.

Ingen af fejlene betyder, at løsningen skal kasseres, eller at det var forkert at bygge den med AI. De betyder, at der mangler et gennemsyn af en, der har prøvet det før. Det meste kan rettes uden at røre ved det, brugerne ser.

Vil I vide, hvor I selv står? Tag testen ”Er jeres app klar til produktion?” – ti spørgsmål, der også dækker backup, test og drift. Eller få et gratis kodetjek, hvor en erfaren udvikler gennemgår jeres kode og sender et prioriteret overblik.

Gratis kodetjek

Vil I vide, hvor mange af de ti der gælder jer?

Send et link til jeres kode. En erfaren udvikler gennemgår den og sender et kort overblik: hvad der er kritisk, hvad der er vigtigt, og hvad der kan vente.

  • Gratis og uforpligtende
  • Jeres kode og data behandles fortroligt