Tankeledere
AI finder sårbarheder med rasende fart. At rette dem er en helt anden historie.

NøglepunkterAI opdager nu zero-days hurtigere, end forsvarere kan patche dem.
Vis mere
- AI opdager nu zero-days hurtigere, end forsvarere kan patche dem.
- Over halvdelen af AI-genererede patches formåede ikke at rette fejlen eller introducerede nye.
- At stole udelukkende på offentliggjorte CVE'er efterlader forsvarere med at reagere på angribernes tidslinjer.
Cybersikkerheden står over for et nyt problem, og ironisk nok skyldes det, at vi er blevet i stand til at finde problemer hurtigere end nogensinde før.
Frontiermodeller inden for AI er blevet særdeles gode til at opdage og udnytte sårbarheder i software. Det betyder, at fejl, som kunne have været skjult i årevis, nu bliver fundet i et tempo, der ville have været næsten umuligt at forestille sig for blot få måneder siden.
Udfordringen er imidlertid, at branchen er blevet langt bedre til at finde sårbarheder, end den er til at rette dem. Se på den seneste forskning fra Anthropic. Zhipu AI’s GLM-5.3 med åbne modelvægte udviklede med succes fungerende udnyttelser fra start til slut i 50 ud af 410 forsøg på benchmarken ExploitBench, mens Claude Mythos Preview klarede 56.
Forskellen mellem en begrænset frontiermodel og en model, hvis vægte er offentligt tilgængelige, er altså ekstremt lille. Egenskaber, der tidligere krævede højt specialiserede sikkerhedsforskere, bliver nu tilgængelige for en langt bredere målgruppe. Samtidig er den software, vi alle bruger, ikke pludselig blevet mindre sårbar. Vi er trådt ind i en tid, hvor det faktisk kan gå hurtigere at finde en zero-day-sårbarhed, end det tager at rette den.
De nylige PHP2Shell-sårbarheder er et godt eksempel. Ifølge forskning fra Wiz, Calif og OpenAI’s Codex Security-team hjalp frontier-AI en enkelt forsker med at finde kritiske fejl i PHP-motoren på omkring en uge. Sårbarhederne påvirkede en runtime, som ligger til grund for en betydelig del af internettet, herunder applikationer bygget på WordPress, Drupal og Joomla.
Det rejser et presserende spørgsmål for sikkerhedsteams: Hvad sker der, når angribere kan finde sårbarheder hurtigere, end forsvarerne kan rette dem?
Håndbogen for sårbarhedshåndtering var ikke lavet til dette
I årevis har sårbarhedshåndtering fulgt et velkendt forløb. En sårbarhed bliver opdaget, nogen indberetter den, der tildeles et CVE-id, en rettelse bliver tilgængelig, scannere markerer sårbarheden, sikkerhedsteams vurderer risikoen, prioriterer rettelsen og installerer den. Forløbet er ikke perfekt, men hele sikkerhedsøkosystemet er bygget op omkring det.
Det egentlige problem er imidlertid, at forløbet i høj grad afhænger af, at man overhovedet kender til sårbarheden. Traditionelle scannere er gode til at fortælle, hvilke kendte sårbarheder der findes i jeres miljø, men hvad med dem, der endnu ikke er blevet offentliggjort? Dem uden et CVE-id, en sikkerhedsmeddelelse eller en rettelse?
Afsløringen af PHP2Shell viser, hvor udsatte vi er med denne model. De to kritiske sårbarheder, CVE-2026-109618 og CVE-2026-109619, fik begge en CVSS-score på 9.2 og skyldtes fejl i hukommelsessikkerheden i selve PHP. Forskere demonstrerede fjernkørsel af kode og afsløring af hukommelsesindhold i udbredte applikationer, herunder WordPress, Drupal og Joomla. Selv applikationer med ellers sikker kode kunne være sårbare, fordi svagheden fandtes i den underliggende runtime.
Tidslinjen var lige så afslørende. Efter en tidlig offentlig advarsel fremskyndede PHP’s sikkerhedsteam sin udgivelsesplan. Da rettelserne blev tilgængelige, var man allerede begyndt at observere tidlige angrebsforsøg.
Og PHP var ikke det eneste problem den dag. Et separat angreb på softwareforsyningskæden kompromitterede LiteLLM version 1.107.0, en populær open source-gateway til store sprogmodeller. Angribere indlejrede en infotyv og en fjernadgangstrojaner i den offentliggjorte Python-pakke, mens projektets kildelager forblev rent. Et team, der kun gennemgik kildekoden, ville være gået glip af den ondsindede nyttelast.
Disse hændelser viser, hvordan sårbarheder kan gemme sig dybt i betroede softwarekomponenter i årevis, samtidig med at ondsindet kode også kan komme ind via de afhængigheder, som organisationer rutinemæssigt installerer. Ingen af delene behøver nødvendigvis at stamme fra applikationens egen kode.
Det viser også, hvordan jeres scanner kan melde alt i orden, selv om alvorlige sårbarheder stadig findes i den software, jeres applikationer er afhængige af. Indtil for nylig krævede det betydelig forskningsekspertise og mange ressourcer at finde skjulte fejl i stor skala, men frontier-AI er ved at ændre på det.
At finde fejlen er den lette del. Hvad så?
Der er stor begejstring for AI’s evne til at opdage zero-day-sårbarheder. Det er der god grund til, for fremskridtene er ekstraordinære. Men jeg synes, der er alt for meget hype om, hvor mange sårbarheder AI kan finde, og slet ikke nok opmærksomhed på, hvad der sker bagefter.
Det gør dig ikke mere sikker at finde en sårbarhed. Først skal du bevise, at den er reel, for AI-genererede fund er ikke automatisk gyldige, og en udnyttelse, der ser overbevisende ud, kan ikke altid reproduceres. Derefter skal du finde ud af, hvilke versioner der er berørt, om sårbarheden faktisk kan udnyttes, og hvilken risiko den medfører.
Derefter skal du rette sårbarheden, og det er her, det bliver særligt interessant. Forskning fra 1Password undersøgte 6,080 AI-genererede rettelser og fandt, at 53.9% ikke løste den oprindelige sårbarhed, indførte en ny sikkerhedsfejl eller gjorde begge dele.
I den undersøgelse havde mere end halvdelen af de genererede programrettelser deres egne sikkerhedsproblemer. Resultaterne afspejler naturligvis specifikke testforhold. Men de illustrerer noget, enhver erfaren ingeniør ved: Der er stor forskel på at skrive kode, der ligner en løsning, og at bevise, at den faktisk løser problemet.
Og selv når programrettelsen er korrekt, er arbejdet ikke færdigt. Vil den ødelægge eksisterende funktionalitet? Fungerer den med den ældre version af biblioteket, som din applikation afhænger af? Kan den implementeres uden at tvinge en opgradering igennem, som skaber et dusin andre problemer?
Hvad sker der, når den skal rulles ud på tværs af hundredvis af applikationer, teams og miljøer? En programrettelse, der fungerer i et testmiljø, men aldrig når frem til produktion, beskytter ingen. Det er den store kløft, jeg mener, at sikkerhedsbranchen er nødt til at tage fat på.
Vi fremskynder sårbarhedsopdagelse i et vanvittigt tempo, mens meget af det arbejde, der skal til for at omsætte opdagelserne til reel beskyttelse, stadig går smerteligt langsomt. Og den kløft er i sig selv ved at blive en sikkerhedsrisiko.
Hvordan lukker vi så faktisk kløften?
Jeg mener ikke, at løsningen er at bede allerede overbelastede sikkerhedsteams om at arbejde hårdere eller behandle flere advarsler. Vi er nødt til at gentænke, hvad effektiv sårbarhedshåndtering indebærer, når opdagelsen af fejl ikke længere er den største flaskehals.
Her er de fire områder, jeg ville begynde med.
1. Betragt ikke CVE-databasen som hele billedet
CVE’er og sårbarhedsscannere er afgørende, men de registrerer det, vi kender til – ikke alt det, der faktisk findes. Sikkerhedsteams skal begynde at se ud over offentligt offentliggjorte sårbarheder og kombinere traditionel scanning med proaktiv research, kodeanalyse, trusselsinformation og en klar forståelse af de softwarekomponenter, deres organisationer er afhængige af.
Ressourcer som CISA’s katalog over kendte, aktivt udnyttede sårbarheder er nyttige, når kendte trusler skal prioriteres, men de kan ikke fortælle om sårbarheder, som ingen endnu har offentliggjort. PHP2Shell viste, at alvorlige sårbarheder kan findes i grundlæggende software i årevis, før de bliver opdaget. Når avanceret AI kan afdække disse fejl på få dage, vil forsvarerne altid reagere på andres tidsplan, hvis de udelukkende baserer sig på offentliggjorte sikkerhedsbulletiner.
2. Forstå, at flere fund ≠ bedre sikkerhed
AI kan generere en enorm mængde potentielle fund, men det betyder ikke, at hvert fund fortjener, at et ingeniørteam lægger alt andet til side for at undersøge det.
Den reelle værdi ligger i at vide, hvilke sårbarheder der er reelle, kan udnyttes og er relevante for dit miljø. Kan du genskabe problemet? Hvilke versioner er berørt? Findes der en realistisk angrebsvej? Hvad er den faktiske forretningsmæssige konsekvens?
Uden den kontekst risikerer organisationer at prioritere sårbarheder alene ud fra alvorlighedsscorer, samtidig med at de overser, hvordan angribere rent faktisk kan få adgang til følsomme systemer og legitimationsoplysninger.
3. Sørg for, at løsningen kan implementeres – ikke kun er teknisk korrekt
Dette er en af de mest undervurderede udfordringer ved afhjælpning af sårbarheder. Virksomheder opererer ikke i perfekte miljøer, hvor alle afhængigheder kan opgraderes til den nyeste version fra den ene dag til den anden. De har ældre applikationer, sammenkoblede systemer, kompatibilitetskrav og softwareversioner, som de ikke bare kan udskifte.
En løsning, der kræver, at en organisation genopbygger halvdelen af sin infrastruktur, er derfor ikke særlig nyttig. Vi har brug for bedre metoder til at tilbageportere sikkerhedsrettelser, bevare kompatibiliteten, begrænse unødvendige angrebsflader og levere opdateringer gennem de værktøjer og arbejdsgange, som teams allerede bruger.
NIST’s vejledning i organisationers håndtering af programrettelser fremhæver vigtigheden af at identificere, prioritere, installere og verificere opdateringer. Udfordringen nu er at gøre hele processen hurtig nok til at følge med AI-drevet opdagelse, for selv verdens bedste programrettelse er ubrugelig, hvis ingen kan implementere den.
4. Mål, hvor hurtigt I rent faktisk bliver beskyttet
Hvis AI opdager en kritisk sårbarhed i dag, hvor lang tid tager det så at validere den, udvikle en fungerende programrettelse, teste den og få den i produktion?
Håndteringen af PHP2Shell giver et nyttigt sammenligningsgrundlag. Hos Echo leverede vi rettede PHP-pakker, så snart programrettelserne fra det oprindelige projekt blev tilgængelige, og genopbyggede samme eftermiddag opdaterede aftryk til de understøttede PHP-versioner.
Sikkerhedsteams bør måle hele forløbet fra opdagelse og validering til udvikling af programrettelser, kompatibilitetstest og implementering. De bør vide, hvor hurtigt de kan genopbygge berørt software, om de kan identificere alle applikationer, der bruger en sårbar afhængighed, og hvor meget manuel indgriben der kræves for at opnå beskyttelse.
Efterhånden som den mest avancerede AI gør det hurtigere og mere tilgængeligt at opdage sårbarheder, vil tidsrummet mellem opdagelse og potentiel udnyttelse fortsat blive mindre. Vi kan ikke gå ud fra, at de traditionelle processer for offentliggørelse og udbedring med sikkerhedsrettelser kan følge med. Den næste æra inden for håndtering af sårbarheder vil blive defineret af, hvem der kan omsætte disse opdagelser til pålidelige rettelser, der kan implementeres, inden angriberne får mulighed for at handle.












