Sådan fjerner du "skjult kode" fra ChatGPT og andre LLM'er

Efterhånden som store sprogmodeller (LLM'er) i stigende grad genererer fungerende kode og integreres i udviklingspipelines og agentstacks, er der en stigende risiko for, at skjulte or ondsindet Instruktioner – uanset om de er indlejret i modeloutput, injiceret via websider eller tredjeparts plugins eller introduceret under modeltræning – kan forårsage usikker adfærd, når den pågældende kode udføres.

Ifølge brugerrapporter, der cirkulerer i udviklerfællesskaber, oplevede en softwareudvikler katastrofalt datatab – ca. 800 GB filer blev slettet, Herunder hele CursorAI-applikationen selv — efter at have udført kode genereret med hjælp fra Gemini 3 mens man arbejder inde i CursorAI IDEEfterhånden som udviklere i stigende grad bruger LLM'er til kodegenerering, bliver konsekvenserne af ureviewede eller usikre scripts mere alvorlige.

Derfor er det ret vigtigt at vide, hvordan man opdager og fjerner farlige koder genereret af LLM.

Hvad er "skjult kode" i forbindelse med ChatGPT og LLM'er?

Hvad mener folk med "skjult kode"?

"Skjult kode" er en paraplybetegnelse, som udviklere bruger til at beskrive alle indlejrede instruktioner eller eksekverbart indhold i teksten (eller filerne), som en LLM indtager eller udsender, herunder:

Instruktioner i promptstil indlejret i brugerindhold (f.eks. "Ignorer tidligere instruktioner..." skjult i en PDF).
Usynlige tegn eller mellemrum med nul bredde, der bruges til at skjule tokens eller bryde tokeniseringsantagelser.
Kodede nyttelaster (base64, URL-kodet, steganografiske indlejringer i billeder eller dokumenter).
Skjult HTML/JS eller scriptblokke inkluderet i formateret indhold, der kan fortolkes af downstream-renderere.
Metadata eller annoteringer (filkommentarer, skjulte lag i PDF-filer), der instruerer hentningssystemer eller modellen.
Implicitte adfærdsmønstre som følge af genereret kode, der bruger farlige API'er (f.eks. eval, exec, subprocesseller netværks-/systemkald) — selv når hensigten ikke er eksplicit ondsindet.
Prompt-injicerede instruktioner der får modellen til at generere kode, der indeholder skjulte kommandoer eller bagdørslignende logik, fordi en angriber har konstrueret prompten eller konteksten.

Disse angrebsvektorer kaldes ofte hurtig indsprøjtning or indirekte hurtig injektion når målet er at ændre modeladfærd. Sikkerhedsmiljøet behandler nu prompt injection som en central LLM-sårbarhed, og OWASP har formaliseret den som en LLM-risikokategori.

Hvordan adskiller dette sig fra almindelig malware eller XSS?

Forskellen er semantiske lag: Prompt injektion er rettet mod modellens instruktionsfølgende adfærd snarere end værtens OS eller browserens renderingmotor. Når det er sagt, er skjult HTML eller script, der ender med at køre i en webrenderer, stadig et eksekverbart angreb (XSS-lignende); både semantiske og eksekveringslag skal forsvares. Brancheledere og forskere har kaldt prompt injektion en "grænsesikkerhedsudfordring" og fortsætter med at offentliggøre afbødningsstrategier.

Hvorfor kan LLM producere skjult eller farlig kode?

Modeladfærd, træningsdata og instruktionskontekst

LLM'er er trænet til at producere plausible fortsættelser givet kontekst og instruktioner. Hvis konteksten indeholder modstridende signaler, eller hvis en bruger beder modellen om kode, der udfører kraftfulde handlinger, kan modellen udskrive kode, der inkluderer subtil eller aktiv adfærd.

LLM'er producerer plausibel, men usikker kode

LLM'er er optimeret til flydende og brugbarhed, ikke til sikkerhed i tilfælde af destruktive bivirkninger. De vil med glæde generere en kortfattet tekst. rm -rf /path/to/dir or shutil.rmtree() ringe, når de bliver bedt om at "rydde op" – og fordi deres svar ofte er formuleret med selvtillid, kan brugerne kopiere og køre uden tilstrækkelig granskning. Dette problem med "selvsikre hallucinationer" er grunden til, at tilsyneladende uskadelige anmodninger bliver farlige.

Automatisering af obfuskationsarbejdsgange

Trusselsaktører automatiserer nu kodeforvirring ved at kæde LLM-kald sammen: én model genererer en nyttelast, en anden omarbejder den for at undgå signaturdetektion osv. Trusselsrapporter fra branchen og leverandøranalyser i 2025 dokumenterer denne "AI-assisterede forvirring" som en ny teknik.

Hvordan kan man finde skjult kode i modeloutput?

Hurtig triage-tjekliste

Scan efter usynlig/usædvanlig Unicode (sammenkoblinger med nul bredde, mellemrum med nul bredde, byteordensmærker, ikke-ASCII-homoglyffer).
Kør statisk analyse / AST-parsing at identificere brugen af kraftfulde API'er (eval, exec, subprocess, os.system, reflekterende opkald).
Søg efter kodede nyttelast (base64, hex-blobs, gentagne lange strenge eller komprimeret indhold).
Tjek for forvirringsmønstre (strengsammenkædning, der konstruerer API-navne, tegnberegning, chr() kæder).
Brug semantisk analyse for at bekræfte, om koden rent faktisk udfører I/O, netværk eller filsystemmutation.

Statisk mønsterdetektion (hurtig, første linje)

Sprogbevidst parsing og linting. Parser omgående genereret output til kodeblokke vs. prosa. Kør formateringsprogrammer og linters (Black/Prettier, pylint, eslint). Lint-regler bør markere brugen af eval, exec, rm -rf, rå underproceskald eller shell-pipes, der konstruerer kommandoer dynamisk.
Token- og strengmønsterscannere. Søg efter tokens og mønstre med høj risiko: sudo, absolutte stier som /home/, C:\, rm -rf, shutil.rmtree, subprocess.Popen, indlejrede base64-blobs, lange strenge, der ikke kan fortolkes, og nørder, der skifter fortolkerkontekst.
Hemmelig scanning og oprindelseskontrol. Registrer hardcodede legitimationsoplysninger, URL'er, der peger på upålidelige registre, eller kode, der dynamisk henter pakker fra vilkårlige kilder.

Statisk analyse fanger mange åbenlyse problemer hurtigt og er billig at køre som en del af en CI-gate.

Semantisk og kontekstuel detektion (dyberegående)

Intentionsanalyse. Brug en sekundær model eller en regelmotor til at klassificere den genererede kodes hensigt: er den "læs", "skriv", "slet", "netværk", "installer"? Alt, der kategoriseres som slet/skriv, bør udløse eskalering.
Dataflowanalyse. Analysér koden for at opdage, om uvaliderede eller brugerangivne stier kan nå destruktive API'er. Hvis f.eks. en variabel, der er afledt af et LLM-output eller en fjernfil, senere sammenkædes til en shell-kommando, skal den markeres.
Provenienskorrelation. Hold en fuldstændig oversigt over samtalen, systemprompten og kontekstsiderne. Hvis mistænkelige output korrelerer med et bestemt eksternt dokument eller plugin-kald, kan det indikere promptindsprøjtning eller en forurenet kontekst.

Dynamisk og adfærdsmæssig detektion (mest pålidelig)

Sandkasseudførelse med overvågning. Udfør genereret kode i et stramt begrænset, kortvarigt miljø uden netværk, uden værtsmonteringer og syscall-filtrering (seccomp). Overvåg filsystemaktivitet, forsøg på netværkskald, procesudvikling og usædvanlig I/O.
Kanariefugletestning. Før du kører på rigtige data, skal du køre koden mod syntetiske mapper, der indeholder sentinel-filer; overvåg for sletninger eller overskrivninger.
Adfærdsmæssige heuristikker. Se efter løkker, der gennemløber overordnede mapper, rekursive operationer uden dybdetjek eller omdøbningsmønstre, der kan skade mange filer (f.eks. gentagne gange at skrive det samme filnavn).
Dynamisk analyse er den eneste måde at detektere nyttelast, der er tilsløret, forsinket eller kun udløses under kørsel.

Hvordan skal man fjerne eller neutralisere skjult kode, før man udfører LLM-output?

Defensiv fjernelse vs. ændring af semantik

Der er to mål med at "fjerne skjult kode":

desinficering — fjern indhold, der tydeligvis ikke er koderelateret eller mistænkeligt (usynlig Unicode, tegn med nul bredde, tilføjede base64-nyttelaster). Dette bør ikke ændre den tilsigtede, godartede logik.
Neutralisering — for alt, der udfører eller kalder eksterne tjenester, skal disse kald deaktiveres eller gøres til no-operationer, indtil de er verificeret.

Foretrækker altid neutralisering + gennemgang over blind sletning: vilkårlig fjernelse af dele af kode kan forårsage ødelagt eller uventet adfærd. Erstat i stedet mistænkelige konstruktioner med eksplicitte, loggede stubs, der fejler sikkert (genererer undtagelser eller returnerer sikre standardværdier).

Trin 1 — Behandl genereret kode som upålidelige data

Udfør aldrig kode direkte fra ChatGPT (eller nogen LLM) uden at sende den gennem en pipeline til fjernelse og hærdning. Denne pipeline bør håndhæves af en politik og automatiseres i CI/CD.

Trin 2 — Udpak og kanoniser kode

Normaliser tekst og fjern tegn med nulbreddeFjern tegn som U+200B, U+200C, U+200D, U+FEFF og andre kodepunkter med nulbredde/formatering. Log, hvad der blev fjernet til revision. Dette trin fjerner mange "skjulte" kodninger, der bruges til visuel stealth.
Fjern al ikke-kodekontekstFjern narrative, skjulte kommentarer og eventuelle HTML/Markdown-wrappers. Konverter kode til kanonisk form ved hjælp af sprogformateringer (Black, Prettier), så obfuskerede mellemrum eller kontroltegn normaliseres.
Afvis eller sæt kode i karantæne med disse konstruktionerdynamisk eval, rå underproceskald (os.system, subprocess.Popen), indlejrede base64-blobs afkodet til udførelse eller indlejret #! direktiver, der forsøger at ændre tolkens kontekst. Normaliser tekst og fjern tegn med nulbredde
Fjern tegn som U+200B, U+200C, U+200D, U+FEFF og andre kodepunkter med nulbredde/formatering. Log, hvad der blev fjernet til revision. Dette trin fjerner mange "skjulte" kodninger, der bruges til visuel stealth.

Trin 3 — Parse ind i AST og erstat risikable noder

Når koden er parset ind i en AST, skal du finde noder, der kalder dynamisk udførelse (f.eks. exec), eller som programmatisk bygger funktionsnavne. Erstat dem med sikre stubber, der genererer en kontrolleret undtagelse, der angiver "usikker dynamisk adfærd blokeret". Generer en renset kopi af den AST-baserede kildekode til gennemgang. Kør sikkerhedsmønsterkontroller (brugerdefinerede semgrep-regler til dit miljø). Hvor der findes matches, skal de markeres og neutraliseres.

Trin 4 — Statisk hærdning og omskrivning

Automatiseret omskrivning: send koden gennem en automatiseret desinfektionsmiddel, der erstatter farlige opkald med sikre indpakninger — f.eks. erstat os.system() / subprocess med en godkendt sandbox-eksekutor, der håndhæver timeouts og netværksblokeringer.
Kapabilitetsgating: Rediger eller fjern API-nøgler, tokens eller kald til privilegerede slutpunkter; erstat dem med mock-adaptere til lokal testning. Forhindr utilsigtet inkludering af hemmeligheder eller URL'er.
Omskrivning af afhængigheder: blokdynamik pip / npm installationer oprettet af koden. Kræver, at afhængigheder deklareres og godkendes via din registreringsdatabase.

Trin 5 — Kør i en aggressiv sandkasse

Kortvarige containere / mikroVM'erUdfør koden i en container/VM, der ikke har noget netværk, ingen adgang til værtslegitimationsoplysninger og begrænset adgang til filsystemet. Teknologier som gVisor, Firecracker eller dedikerede, kortvarige udførelsestjenester er passende. Hvis kode skal have adgang til I/O, skal du bruge en proxy, der håndhæver politikken.
Systemkaldsfiltre og seccomp: begrænser hvilke syscalls der er tilladt. Filskrivninger uden for en midlertidig mappe bør blokeres.
Ressource-/tidsgrænser: sæt CPU/hukommelse/tidsgrænser, så selv logiske bomber ikke kan køre i det uendelige.

Sandbox-eksekvering plus overvågning afslører ofte nyttelast, som statiske kontroller overser. Branchevejledning og nylige hvidbøger anbefaler sandboxing som en central afhjælpningsforanstaltning.

Hvilke automatiserede værktøjer og regler bør være i din pipeline?

Anbefalede værktøjskædekomponenter

Unicode sanitetsmodul (brugerdefinerede eller eksisterende biblioteker). Skal logge normaliserede tegn.
Parser + AST-analysator for hvert målsprog (Python ast, typed-ast, JavaScript-parsere, Java-parsere).
Statiske analysatorer / SASTBandit (Python), Semgrep (flersproget, kan tilpasses), ESLint med sikkerheds-plugins.
Entropi og dekoderheuristikker: detekter base64/hex/gzip og send rute til inspektion.
Sandkasse-kørselstidminimal container med streng seccomp/AppArmor-profil eller sprogniveaufortolker med deaktiverede syscalls.
Politikhåndhæveren komponent, der bestemmer tilladte moduler, tilladte slutpunkter og sikre API-wrappers.
Revisionsspor: uforanderlige logfiler, der registrerer originalt output, renset output, diffs og beslutninger.

Eksempel på semgrep-mønstre (konceptuelle)

Brug korte, konservative regler, der markerer brugen af farlige funktioner. For eksempel:

Flag eval, exec, Function konstruktør (JS), dynamisk import eller strengbyggede API-navne.
Markér netværksopkald uden for tilladelseslisten (f.eks. requests.get til ukendte værter).
Flag skriver til følsomme stier (/etc, systemmapper) eller oprettelse af processer.

(Behold disse som konfigurationselementer pr. organisation, og stram dem op over tid.)

Hvad er praktiske desinficeringsuddrag (sikre eksempler)?

Nedenfor er ufarlige, defensive eksempler, som du kan tilpasse. De er desinficering og detektion snippets — ikke udnyttelsesinstruktioner.

Eksempel: fjern tegn med nulbredde (Python, defensiv)

import re
ZERO_WIDTH_RE = re.compile(r'')
def strip_zero_width(s: str) -> str:
    cleaned = ZERO_WIDTH_RE.sub('', s)
    return cleaned

Dette fjerner tegn, som angribere ofte bruger til at skjule kode i ellers synlig tekst. Log altid det, der blev fjernet, og behandl fjernelsen som en del af revisionssporet.

Eksempel: parse og inspicere AST (Python, konceptuel)

import ast

def has_dynamic_exec(source: str) -> bool:
    tree = ast.parse(source)
    for node in ast.walk(tree):
        if isinstance(node, ast.Call):
            if getattr(node.func, 'id', '') in ('eval', 'exec',):
                return True
        if isinstance(node, ast.Attribute):
            if getattr(node, 'attr', '') in ('popen', 'system'):
                return True
    return False

If has_dynamic_exec returnerer True, kør ikke koden; erstat i stedet den dynamiske node med en sikker stub og kræv gennemgang.

Bemærk: Disse eksempler er af defensiv karakter. Fjern ikke logføring, revision eller menneskelig gennemgang fra din pipeline.

Afsluttende tanker: Behandl altid LLM-output som upålidelig kode

LM'er er effektive produktivitetsværktøjer – de kan producere elegant kode, accelerere udkast og automatisere rutinearbejde. Men hvor de møder udførelse, ændres sikkerhedsreglerne: Modeloutput skal behandles som upålidelige artefakterKombinationen af hurtige injektioner, bagdørsforskning og afsløringer af sårbarheder i den virkelige verden i løbet af de sidste 18-30 måneder understreger tydeligt: risikooverfladen er vokset og vil fortsætte med at udvikle sig.

Praktiske forsvar, der kombinerer parsing, statisk analyse, sandbox-baseret dynamisk testning, governance og kontinuerlig red-teaming, vil stoppe de fleste angreb. Men teams skal også investere i organisatoriske kontroller: færrest rettigheder, proveniens og en kultur, der antager, at LLM-output skal verificeres. Branchen er i gang med at udvikle værktøjer og frameworks for at gøre disse mønstre nemmere; i mellemtiden reducerer implementeringen af ovenstående tjekliste risikoen for, at en skjult nyttelast forsvinder.

Udviklere kan få adgang til den nyeste LLM API, f.eks. Claude Sonnet 4.5 API og Gemini 3 Pro Preview osv. via CometAPI, den nyeste modelversion opdateres altid med den officielle hjemmeside. For at begynde, udforsk modellens muligheder i Legeplads og konsulter API guide for detaljerede instruktioner. Før du får adgang, skal du sørge for at være logget ind på CometAPI og have fået API-nøglen. CometAPI tilbyde en pris, der er langt lavere end den officielle pris, for at hjælpe dig med at integrere.

Klar til at gå? → Tilmeld dig CometAPI i dag !

Hvis du vil vide flere tips, guider og nyheder om AI, følg os på VK, X og Discord!