Varför din AI-kodningsassistent är en säkerhetshål (och hur du täpper till det)

Förra veckan slog det mig: min AI-assistent har kört kommandon på min dator i månader. Den har nått mina AWS-uppgifter, SSH-nycklar och privata GitHub-repo. Det läskiga? Jag tänkte aldrig på risken. Verktyget var ju så smidigt, och inget hade krashat än.

Det är exakt den tanken som raderar produktionsdatabaser.

Bekvämligheten lurar dig in i farozonen

Sanningen är brutal: dagens AI-kodningsverktyg får samma åtkomst som en senior devops på första dagen. Vi skulle aldrig ge en ny konsult fri SSH till alla servrar. Men en LLM? Den får det utan diskussion.

Felet ligger inte i ondska. Det är slarv. De är så bra på att hjälpa till att vi glömmer vad de kan ställa till med. Ett enda prompt-injektionsangrepp i en repo, eller ett oskyldigt kommando, och dina credentials är på väg till en angripare. Du märker inget.

Positivt nog har verktyg som Claude Code starka säkerhetsfunktioner. De flesta aktiverar dem aldrig.

Riskerna med standardinställningarna

Många AI-agenter kör i "auto"-läge som standard. De exekverar kommandon utan att fråga, om det inte är blockerat. Effektivt? Ja. Farligt? Kolla vad det innebär:

Tom deny-lista plus auto-läge ger fri tillgång till:

• curl mot valfria servrar
• wget för nedladdningar
• ssh till externa maskiner
• nc för nätverksanslutningar
• Alla .env-filer i projektet
• ~/.aws/credentials, ~/.ssh-mappar, ~/.gnupg
• Direkta pushes till repos

Allt sker tyst. Inga varningar. Borta.

Bygg en tredelad säkerhetsvägg

Du behöver finmaskig kontroll. Inte allt ska godkännas, men kritiska grejer ja. Så här gör du:

Lag 1: Hård blockering

Börja med deny-lista för credentials och farliga nätverkskommandon:

{
  "deny": [
    "Read(~/.ssh/**)",
    "Read(~/.aws/**)",
    "Read(~/.gnupg/**)",
    "Read(~/.azure/**)",
    "Read(~/.kube/**)",
    "Read(~/.npmrc)",
    "Read(~/.git-credentials)",
    "Read(*.env)",
    "Read(.env.*)",
    "Bash(curl *)",
    "Bash(wget *)",
    "Bash(nc *)",
    "Bash(ssh *)"
  ]
}

Det här är din brandvägg. Inget slinker igenom, oavsett vad AI:n försöker.

Lag 2: Godkänn-punkt

"ask"-lista för reversibla men riskabla actions:

{
  "ask": [
    "Bash(git push *)",
    "Bash(git commit *)",
    "Bash(git merge *)",
    "Bash(git reset *)",
    "Bash(npm publish *)",
    "Bash(docker push *)"
  ]
}

AI:n kan behöva det här – pusha kod, publicera paket – men du granskar först. Smidigt utan panik.

Lag 3: Grön zon

Tillåt säkra kommandon fritt:

{
  "allow": [
    "Bash(npm run *)",
    "Bash(git status *)",
    "Bash(git diff *)",
    "Bash(git log *)",
    "Bash(ls *)",
    "Read(src/**)",
    "Read(tests/**)"
  ]
}

Inga stopp här. De ändrar inget farligt eller är ofarliga.

Välj rätt standardläge

Efter listorna: välj default för resten. Tre val:

1. auto – Oförhindrat kör fritt. Snabbt, men deny-listan måste vara vattentät.

2. acceptEdits – Läser och föreslår ändringar fritt, frågar för bash utanför allow. Balanserat.

3. ask – Frågar för allt riskabelt. Säkrast, men långsammast.

acceptEdits passar de flesta team. Produktivitet med medvetna val.

Ett färdigt exempel för prod

Så här ser en robust konfig ut:

{
  "permissions": {
    "deny": [
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)",
      "Read(~/.gnupg/**)",
      "Read(~/.azure/**)",
      "Read(~/.kube/**)",
      "Read(~/.npmrc)",
      "Read(~/.git-credentials)",
      "Read(~/.config/gh/**)",
      "Read(*.env)",
      "Read(.env.*)",
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(nc *)",
      "Bash(ssh *)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(git commit *)",
      "Bash(npm publish *)",
      "Bash(docker push *)"
    ],
    "allow": [
      "Bash(npm run *)",
      "Bash(npm install *)",
      "Bash(npm test *)",
      "Bash(git status *)",
      "Bash(git diff *)",
      "Bash(git log *)"
    ],
    "defaultMode": "acceptEdits"
  }
}

AI:n fixar test, lint och kodgranskning. Men stjäl inte nycklar, pushar inte utan OK eller ringer hem.

Två lägen för olika jobb

Jag kör två aliases:

# Standard: balanserad säkerhet
alias cc="claude --permission-mode auto"

# Debug: full frihet (använd sällan)
alias ccd="claude --permission-mode dangerously-skip-permissions"

cc för vardagen. ccd bara vid kriser, medvetet risk.

Problemet drabbar alla verktyg

Inte bara Claude Code. Alla AI med shell-execution – GitHub Copilot, Devin, Cursor, ChatGPT – har samma svaghet. Convenience vs säkerhet.

Claude sticker ut med fina kontroller. Andra tvingar dig till allt eller inget.

Vad det betyder för ditt team

I team-miljö blir det akut. Lita inte på att devs fixar själva.

Gör så här:

• Kräv deny-listor i shared config
• Blockera credential-filer på filsystemet
• Använd temporära tokens istället för eviga nycklar
• Nätverksregler mot dataläckage
• Utbilda om produktivitet vs risk

Slutsatsen

AI-kodningshjälpare är grymma. Men gratis? Nej. Kontrollerna finns – använd dem.

Börja nu. 15 minuter: deny för credentials, ask för deploy, smart default. Då kör AI:n effektivt – och säkert.

" Inget har hänt än" är ingen strategi.