Evaluating Large Language Models for Multilingual Vulnerability Detection at Dual Granularities

Deze studie toont aan dat GPT-4o, versterkt door instructietuning en few-shot prompting, aanzienlijk beter presteert dan bestaande modellen bij het detecteren van kwetsbaarheden in meerdere programmeertalen op zowel functie- als lijnniveau.

De kern

Hier is een uitleg van dit wetenschappelijke artikel, vertaald naar begrijpelijk Nederlands met behulp van alledaagse vergelijkingen.

De Hoofdverhaal: Op zoek naar de perfecte "Code-Inspecteur"

Stel je voor dat software een enorme stad is, gebouwd met verschillende soorten bouwstenen (programmeertalen zoals Python, Java, C++, etc.). In deze stad zijn er soms verborgen valkuilen of slechte constructies: kwetsbaarheden. Als hackers deze vinden, kunnen ze de stad binnendringen en schade aanrichten.

Vroeger hadden we automatische inspecteurs (de zogenaamde Pre-trained Language Models of PLMs). Deze inspecteurs waren slim, maar ze waren gespecialiseerd in één taal (meestal C/C++) en keken vaak alleen naar het hele gebouw (de functie) in plaats van naar de specifieke losse baksteen (de regel code) waar het probleem zat.

Nu zijn er nieuwe, super-slimme inspecteurs opgedoken: de Grote Taalmodellen (LLMs), zoals GPT-4o. Deze zijn getraind op bijna alle talen ter wereld en kunnen heel goed begrijpen wat er gebeurt. Maar de vraag was: Zijn deze nieuwe inspecteurs ook echt beter in het vinden van fouten in een stad met veel verschillende talen, en kunnen ze de fouten ook precies lokaliseren?

De auteurs van dit paper hebben een grote test uitgevoerd om dit te beantwoorden.

---

De Test: Een enorme zoektocht door 7 steden

De onderzoekers hebben een gigantische database gebruikt met 30.000 echte reparaties van softwarefouten. Ze hebben gekeken naar zeven verschillende programmeertalen (C, C++, C#, Go, Java, JavaScript en Python).

Ze hebben de inspecteurs op twee manieren getest:

1. Op het niveau van het hele gebouw (Functie-niveau): "Is er ergens in dit stukje code een gevaar?"
2. Op het niveau van de losse baksteen (Regel-niveau): "Welke exacte regel is het gevaarlijk?"

Ze hebben verschillende strategieën gebruikt om de inspecteurs te helpen:

• Zomaar vragen (Zero-shot): "Kijk hier, is dit gevaarlijk?"
• Voorbeelden geven (Few-shot): "Kijk naar deze drie voorbeelden van gevaarlijke code, en zoek dan de fout in dit nieuwe stukje."
• Opleiding geven (Instruction Tuning): De inspecteur eerst intensief trainen met duizenden voorbeelden en instructies, en dan pas de test laten doen.

---

De Resultaten: Wie wint er?

Hier zijn de belangrijkste bevindingen, vertaald naar simpele taal:

1. De oude inspecteurs (PLMs) zijn goed, maar niet perfect

De traditionele modellen (zoals CodeT5P) deden het redelijk goed. Ze waren als ervaren metselaars die veel gebouwen hadden gezien. Maar ze maakten vaak fouten: ze dachten soms dat een veilig gebouw gevaarlijk was (veel vals alarm) of misten soms de echte gevaarlijke plekken.

2. De nieuwe inspecteurs (LLMs) hebben een "opleiding" nodig

Als je de super-slimme modellen (zoals GPT-4o) gewoon vroeg om te kijken zonder training of voorbeelden, deden ze het vaak slecht. Het was alsof je een briljante architect vraagt om een bouwinspectie te doen zonder hem de regels van de bouwcode te laten zien. Ze raakten in de war.

Maar... zodra je ze opleiding gaf (Instruction Tuning) en ze voorbeelden liet zien (Few-shot), werden ze onverslaanbaar.

• De winnaar: GPT-4o met deze extra training was veruit de beste.
• Het vond niet alleen meer fouten dan de oude modellen, maar maakte ook veel minder vals alarm.
• Het was zelfs beter in het vinden van de exacte regel code die kapot was, iets waar de oude modellen vaak in faalden.

3. Groter is niet altijd beter

Je zou denken dat een nog groter model (met meer "hersenen") automatisch beter is. De onderzoekers hebben gekeken naar modellen met 70 miljard parameters versus kleinere versies.

• Conclusie: De grootte maakt niet alles uit. Een slimme instructie en goede training waren belangrijker dan alleen maar groter zijn. Soms waren de kleinere modellen zelfs beter, omdat ze minder "verward" raakten.

4. Redeneren helpt niet altijd

Er zijn nieuwe modellen die "redeneren" (ze denken stap voor stap na voordat ze antwoorden). Je zou denken dat dit perfect is voor complexe veiligheidsproblemen.

• Conclusie: Voor het vinden van softwarefouten hielp dit "redeneren" niet echt. Het duurde langer, maar leverde geen significant betere resultaten op. Soms was het zelfs net zo goed als een snelle, intuïtieve inspecteur.

5. Kosten: De dure API vs. de lokale computer

Het gebruik van de slimste modellen (zoals GPT-4o) via internet kost geld (per woord dat je stuurt). Het trainen van je eigen model op een eigen computer kost een keer een dure videokaart, maar daarna is het goedkoper.

• Voor grote bedrijven met eigen hardware kan het trainen van een eigen model goedkoper zijn.
• Voor kleinere teams of snelle tests is het gebruik van de slimme API (zoals GPT-4o) vaak de beste keuze vanwege de superieure prestaties.

---

De Grootste Les: Waarom is dit belangrijk?

Stel je voor dat je een beveiligingscontrole doet in een internationaal vliegveld waar mensen uit heel verschillende landen (verschillende programmeertalen) komen.

• De oude systemen waren als een controleur die alleen Duitse paspoorten goed kon lezen. Hij miste veel fouten bij andere talen.
• De nieuwe systemen (GPT-4o met training) zijn als een controleur die alle talen spreekt, de regels kent, en je precies kan vertellen welke regel in je paspoort niet klopt.

De conclusie van het paper:
We moeten stoppen met alleen te kijken naar één programmeertaal. De toekomst van softwareveiligheid ligt bij het gebruik van deze nieuwe, getrainde AI-modellen die in staat zijn om fouten te vinden in elke taal, op elk detailniveau. Ze zijn niet perfect, maar ze zijn een enorme stap vooruit in het veilig houden van onze digitale wereld.

Kortom: Geef de slimme AI een goede training en voorbeelden, en hij wordt de beste beveiligingsagent die we ooit hebben gehad.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Evaluating Large Language Models for Multilingual Vulnerability Detection at Dual Granularities" in het Nederlands.

Probleemstelling

Automatische kwetsbaarheidsdetectie (AVD) is cruciaal voor softwarebeveiliging, maar bestaande methoden hebben drie belangrijke beperkingen:

1. Taalbeperking: De meeste studies focussen uitsluitend op één programmeertaal (meestal C/C++), terwijl moderne softwaresystemen vaak polyglot zijn (meerdere talen zoals Python, Java, Go, etc.).
2. Granulariteit: Onderzoek concentreert zich voornamelijk op het detecteren van kwetsbaarheden op functieniveau (is de hele functie kwetsbaar?), wat vaak te onnauwkeurig is voor ontwikkelaars. Het lijnenniveau (welke specifieke regel code is kwetsbaar?) wordt in meertalige contexten nauwelijks onderzocht.
3. Generalisatie: Het is onduidelijk of Pre-trained Language Models (PLMs) en Large Language Models (LLMs) hun kennis van kwetsbaarheidssemantiek kunnen generaliseren over verschillende programmeertaalparadigma's, of dat ze slechts syntaxis memoriseren.

Methodologie

De auteurs voerden een empirische studie uit om de effectiviteit van state-of-the-art PLMs en LLMs te evalueren voor meertalige kwetsbaarheidsdetectie op twee granulariteiten: functieniveau en lijnenniveau.

• Dataset: Ze gebruikten de REEF-dataset, een uitgebreid corpus met 4.466 CVE's en 30.987 patches over zeven programmeertalen: C, C#, C++, Go, JavaScript, Java en Python. De dataset werd voorverwerkt met Tree-sitter om kwetsbare en niet-kwetsbare functies en lijnen te extraheren.
• Modellen:
  • PLMs: CodeBERT, CodeT5, CodeT5P, UniXCoder, LineVul en diverse OpenAI Text-Embedding-modellen.
  • LLMs: DeepSeek-Coder, Code Llama, Llama 3, GPT-3.5-Turbo en GPT-4o.
• Strategieën voor LLMs: De studie vergeleek verschillende leerstrategieën:
  • Zero-shot prompting: Directe instructie zonder voorbeelden.
  • Few-shot prompting: Instructie met een paar voorbeelden (geselecteerd via BM25).
  • Instruction Tuning: Supervised Fine-Tuning (SFT) met Low-Rank Adaptation (LoRA) op instructiegevulde datasets, gevolgd door prompting.
• Evaluatiemetrics: Voor het functieniveau (evenwichtige dataset) werd Accuracy als hoofdmeter gebruikt. Voor het lijnenniveau (zeer onevenwichtige dataset) werd de F1-score gebruikt, aangevuld met Precision, Recall, FPR, FNR, MCC en AUC.

Belangrijkste Bijdragen

1. Uitgebreide Evaluatie: De eerste systematische vergelijking van PLMs en LLMs voor meertalige kwetsbaarheidsdetectie over zeven talen en twee granulariteiten.
2. Strategie-Optimalisatie: Onderzoek naar de impact van instructie-tuning en few-shot prompting op de prestaties van LLMs.
3. Diepgaande Analyse: Een analyse van de orthogonaliteit (unieke detecties), prestaties op de Top-25 gevaarlijkste CWE's (Common Weakness Enumeration) en detectie op basis van CVSS-zwaarte.
4. Kosten- en Schaalanalyse: Een vergelijking van de implementatiekosten (TCO) en de impact van modelgrootte (bijv. 7B vs 70B parameters) en redeneervermogen (Reasoning vs. Non-reasoning LLMs).
5. Open Science: Publicatie van een replicatiepakket met data, code en analyse-details.

Resultaten

De resultaten tonen een duidelijke superioriteit van specifieke LLM-configuraties ten opzichte van traditionele PLMs:

• Beste Prestaties: GPT-4o, gecombineerd met instructie-tuning en few-shot prompting, presteerde significant beter dan alle andere modellen.
  • Functieniveau: Bereikte een Accuracy van 0.7196 (vergeleken met 0.6037 voor de beste PLM, CodeT5P).
  • Lijnenniveau: Bereikte een F1-score van 0.6641 (vergeleken met 0.4841 voor CodeT5P).
• Meertalige Generalisatie: GPT-4o toonde robuuste prestaties over alle zeven talen, met de hoogste scores voor Go (functieniveau) en JavaScript (lijnenniveau).
• Kritieke Kwetsbaarheden: GPT-4o met instructie-tuning detecteerde de Top-25 gevaarlijkste CWE's (zoals SQL Injection en Out-of-bounds Write) aanzienlijk beter dan PLMs en andere LLM-configuraties.
• Orthogonaliteit: GPT-4o (IT + Few-shot) vond unieke correcte detecties die door PLMs werden gemist, en had de minste unieke foutieve detecties.
• Modelgrootte en Redeneren:
  • Grotere modelgrootte (bijv. 70B vs 7B) garandeerde geen significante verbetering in prestaties voor deze taak.
  • Reasoning-LLMs (zoals DeepSeek-R1) presteerden slechts marginaal beter dan niet-reasoning modellen en waren niet significant beter dan random guessing op het functieniveau.
• Kosten: Hoewel LLMs via API's duurder zijn per training, zijn ze schaalbaarder. Voor lokale implementatie zijn PLMs (zoals CodeT5P) op consumenten-GPU's kosteneffectiever, maar LLMs bieden betere prestaties voor complexe lijnenniveau-taken.

Betekenis en Conclusie

De studie concludeert dat Large Language Models, specifiek wanneer ze worden verfijnd met instructie-tuning en few-shot prompting, een doorbraak vormen voor meertalige kwetsbaarheidsdetectie. Ze overtreffen bestaande PLMs niet alleen in algehele nauwkeurigheid, maar vooral in het vermogen om specifieke, gevaarlijke kwetsbaarheden op lijnenniveau te lokaliseren in diverse programmeertalen.

De bevindingen suggereren dat voor praktische softwarebeveiliging in heterogene omgevingen, de inzet van geoptimaliseerde LLMs (zoals GPT-4o) de voorkeur verdient boven traditionele modellen, ondanks de hogere operationele kosten. De studie biedt een blauwdruk voor toekomstig onderzoek naar het verbeteren van kwetsbaarheidsdetectie in real-world, meertalige softwareprojecten.