Tankeledare
AI hittar sårbarheter i rasande fart. Att åtgärda dem är en helt annan sak.

Viktiga punkterAI upptäcker nu zero-days snabbare än försvarare kan lappa dem.
Visa mer
- AI upptäcker nu zero-days snabbare än försvarare kan lappa dem.
- Över hälften av AI-genererade patchar misslyckades med att åtgärda sårbarheten eller introducerade nya.
- Att enbart förlita sig på offentliggjorda CVE:er lämnar försvarare att reagera på angriparnas tidslinjer.
Cybersäkerheten står inför ett nytt problem, och ironiskt nog beror det på att vi kan hitta problem snabbare än någonsin.
Avancerade AI-modeller blir allt bättre på att upptäcka och utnyttja sårbarheter i programvara. Det innebär att brister som hade kunnat förbli dolda i åratal nu upptäcks i en takt som hade varit nästan omöjlig att föreställa sig för bara några månader sedan.
Utmaningen är att branschen blir mycket bättre på att hitta sårbarheter än på att åtgärda dem. Titta på den senaste forskningen från Anthropic. Zhipu AI:s GLM-5.3-modell med öppna vikter lyckades ta fram fungerande, heltäckande exploateringar i 50 av 410 försök i jämförelsetestet ExploitBench, medan Claude Mythos Preview lyckades i 56 försök.
Skillnaden är ytterst liten mellan en avancerad modell med begränsad åtkomst och en vars vikter är öppet tillgängliga. Förmågor som tidigare krävde högt specialiserade säkerhetsforskare blir nu tillgängliga för en mycket bredare publik. Samtidigt har programvaran vi alla använder inte plötsligt blivit mindre sårbar. Vi har gått in i en era där det faktiskt kan gå snabbare att hitta en nolldagssårbarhet än att åtgärda den.
De senaste PHP2Shell-sårbarheterna är ett tydligt exempel. Enligt forskning från Wiz, Calif och OpenAI:s Codex-säkerhetsteam hjälpte avancerad AI en enskild forskare att upptäcka kritiska brister i PHP-motorn på ungefär en vecka. Sårbarheterna påverkade en körmiljö som ligger till grund för en betydande del av webben, däribland applikationer byggda med WordPress, Drupal och Joomla.
För säkerhetsteam väcker det en akut fråga: Vad händer när angripare kan hitta sårbarheter snabbare än försvarare kan åtgärda dem?
Handboken för sårbarhetshantering är inte gjord för det här
I åratal har sårbarhetshanteringen följt ett välbekant mönster. En sårbarhet upptäcks, någon rapporterar den, ett CVE-nummer tilldelas, en programfix blir tillgänglig, skannrar flaggar sårbarheten, säkerhetsteam bedömer risken, prioriterar åtgärden och installerar den. Processen är inte perfekt, men hela säkerhetsekosystemet har byggts kring den.
Det verkliga problemet är dock att processen till stor del bygger på att man känner till sårbarheten från början. Traditionella skannrar är utmärkta på att tala om vilka kända sårbarheter som finns i din miljö, men hur är det med dem som inte har offentliggjorts? De som saknar ett CVE-nummer, en säkerhetsvarning eller en programfix?
Offentliggörandet av PHP2Shell visar hur utsatta vi blir med den här modellen. De två kritiska sårbarheterna, CVE-2026-109618 och CVE-2026-109619, fick båda betyget CVSS 9,2 och gällde minnessäkerhetsbrister i själva PHP. Forskare demonstrerade fjärrkörning av kod och åtkomst till minnesinnehåll i brett använda applikationer, däribland WordPress, Drupal och Joomla. Även applikationer med i övrigt säker kod kunde vara sårbara eftersom svagheten fanns i den underliggande körmiljön.
Tidslinjen var lika avslöjande. Efter en tidig offentlig varning skyndade PHP:s säkerhetsteam på sin utgivningsplan. När programfixarna blev tillgängliga hade de första angreppsförsöken redan börjat observeras.
Och PHP var inte det enda problemet den dagen. Ett separat angrepp mot programvarans leveranskedja komprometterade LiteLLM version 1.107.0, en populär öppen källkod-gateway för stora språkmodeller. Angriparna bäddade in en informationsstjälarprogramvara och en fjärråtkomsttrojan i det publicerade Python-paketet, medan projektets källkodsförråd förblev rent. Ett team som bara granskade källkoden skulle helt ha missat den skadliga nyttolasten.
Händelserna visar hur sårbarheter kan finnas djupt inne i betrodda programvarukomponenter i åratal, samtidigt som skadlig kod också kan ta sig in via beroenden som organisationer regelbundet installerar. Ingetdera behöver ha sitt ursprung i applikationens egen kod.
Det visar också hur din skanner kan ge dig grönt besked trots att allvarliga sårbarheter fortfarande finns i den programvara som dina applikationer är beroende av. Fram till nyligen krävdes omfattande forskarkompetens och resurser för att upptäcka dolda brister i stor skala, men avancerad AI förändrar förutsättningarna.
Att hitta felet är den enkla delen. Vad händer sedan?
Det råder stor entusiasm kring AI:s förmåga att upptäcka nolldagssårbarheter. Det är befogat, eftersom utvecklingen är enastående, men jag tycker att det talas för mycket om hur många sårbarheter AI kan hitta och alldeles för lite om vad som händer sedan.
Att hitta en sårbarhet gör dig inte säkrare. Först måste du bekräfta att den är verklig, eftersom AI-genererade fynd inte automatiskt är giltiga och en övertygande exploatering inte alltid går att återskapa. Därefter måste du ta reda på vilka versioner som berörs, om sårbarheten faktiskt går att utnyttja och vilken risk den medför.
Sedan måste du åtgärda den, och det är då det blir särskilt intressant. Forskning från 1Password granskade 6 080 AI-genererade programfixar och fann att 53,9 % inte åtgärdade den ursprungliga sårbarheten, introducerade en ny säkerhetsbrist eller gjorde både och.
I den studien hade mer än hälften av de genererade säkerhetskorrigeringarna egna säkerhetsbrister. Resultaten speglar förstås specifika testförhållanden. Men de visar något som alla erfarna ingenjörer vet: det är två helt olika saker att skriva kod som ser ut att lösa problemet och att bevisa att den faktiskt gör det.
Och även när säkerhetskorrigeringen är korrekt är arbetet inte klart. Kommer den att försämra befintlig funktionalitet? Fungerar den med den äldre versionen av biblioteket som programmet är beroende av? Går den att driftsätta utan att tvinga fram en uppgradering som skapar ett dussin andra problem?
Vad händer när den ska införas i hundratals program, team och miljöer? En säkerhetskorrigering som fungerar i en testmiljö men aldrig når produktion skyddar ingen. Det här är den stora klyfta som jag tycker att säkerhetsbranschen måste ta itu med.
Vi ökar takten i upptäckten av sårbarheter i rasande fart, samtidigt som mycket av arbetet med att omvandla upptäckterna till ett faktiskt skydd fortfarande går plågsamt långsamt. Och den klyftan håller på att bli en säkerhetsrisk i sig.
Så hur överbryggar vi egentligen klyftan?
Jag tror inte att lösningen är att säga åt redan överbelastade säkerhetsteam att arbeta hårdare eller hantera fler larm. Vi måste tänka om kring hur effektiv sårbarhetshantering ser ut när upptäckten av brister inte längre är den största flaskhalsen.
Här är de fyra områden jag skulle börja med.
1. Se inte CVE-databasen som hela bilden
CVE:er och sårbarhetsskannrar är nödvändiga, men de dokumenterar vad vi känner till – inte allt som faktiskt finns. Säkerhetsteam måste börja se bortom offentligt redovisade sårbarheter och kombinera traditionell skanning med proaktiv forskning, kodanalys, hotunderrättelser och en tydlig förståelse av vilka programvarukomponenter organisationerna är beroende av.
Resurser som CISA:s katalog över kända aktivt utnyttjade sårbarheter är värdefulla när det gäller att prioritera kända hot, men de kan inte berätta om sårbarheter som ännu inte har offentliggjorts. PHP2Shell visade att allvarliga sårbarheter kan finnas i grundläggande programvara i åratal innan de upptäcks. När avancerad AI kan hitta sådana brister på några dagar innebär ett ensidigt förlitande på publicerade säkerhetsbulletiner att försvarare alltid kommer att reagera på någon annans tidtabell.
2. Förstå att fler fynd ≠ bättre säkerhet
AI kan generera enorma mängder möjliga fynd, men det betyder inte att varje fynd motiverar att ett ingenjörsteam släpper allt för att undersöka det.
Det verkliga värdet ligger i att veta vilka sårbarheter som är verkliga, går att utnyttja och är relevanta för er miljö. Går problemet att återskapa? Vilka versioner berörs? Finns det en realistisk angreppsväg? Vilken är den faktiska verksamhetspåverkan?
Utan den kontexten riskerar organisationer att prioritera sårbarheter enbart utifrån allvarlighetsgrader och samtidigt förbise hur angripare faktiskt skulle kunna nå känsliga system och autentiseringsuppgifter.
3. Gör säkerhetskorrigeringen driftsättningsbar, inte bara tekniskt korrekt
Det här är en av de mest underskattade utmaningarna när sårbarheter ska åtgärdas. Företag verkar inte i perfekta miljöer där alla beroenden kan uppgraderas till den senaste versionen över en natt. De har äldre program, sammankopplade system, kompatibilitetskrav och programvaruversioner som de inte bara kan byta ut.
En säkerhetskorrigering som kräver att en organisation bygger om halva sin infrastruktur är därför inte särskilt användbar. Vi behöver bättre sätt att bakåtportera säkerhetskorrigeringar, bevara kompatibiliteten, minska onödiga angreppsytor och leverera uppdateringar med de verktyg och arbetsflöden som teamen redan använder.
NIST:s vägledning för hantering av säkerhetsuppdateringar i företag betonar vikten av att identifiera, prioritera, installera och verifiera uppdateringar. Utmaningen nu är att göra hela processen tillräckligt snabb för att hålla jämna steg med AI-driven upptäckt, eftersom världens bästa säkerhetskorrigering är värdelös om ingen kan driftsätta den.
4. Mät hur snabbt ni faktiskt får skydd
Om AI upptäcker en kritisk sårbarhet i dag, hur lång tid tar det då att validera den, ta fram en fungerande säkerhetskorrigering, testa den och få ut den i produktion?
Hanteringen av PHP2Shell ger ett användbart riktmärke. På Echo levererade vi korrigerade PHP-paket så snart korrigeringarna från uppströmsprojektet blev tillgängliga, och samma eftermiddag byggde vi om avbildningar för de PHP-versioner som stöds.
Säkerhetsteam bör mäta hela åtgärdscykeln, från upptäckt och validering till utveckling av säkerhetskorrigeringar, kompatibilitetstestning och driftsättning. De bör veta hur snabbt de kan bygga om berörd programvara, om de kan identifiera alla program som använder ett sårbart beroende och hur mycket manuellt arbete som krävs för att få skydd på plats.
I takt med att den mest avancerade AI:n gör det snabbare och enklare att upptäcka sårbarheter kommer tidsfönstret mellan upptäckt och potentiellt utnyttjande att fortsätta krympa. Vi kan inte utgå från att traditionella processer för offentliggörande och säkerhetsuppdateringar kommer att hålla jämna steg. Nästa era inom sårbarhetshantering kommer att präglas av vilka som kan omvandla upptäckterna till tillförlitliga korrigeringar som går att driftsätta innan angriparna får möjlighet att agera.












