Technische Samenvatting: Het benutten van Code Slicing voor LLM-gebaseerde Detectie van Malafide NPM-pakketten

Probleemstelling

Het npm-ecosysteem wordt steeds vaker het doelwit van geavanceerde aanvallen op de software supply chain, die gebruikmaken van obfuscatie en complexe logica om detectie te omzeilen. Hoewel Large Language Models (LLM's) een superieur semantisch begrip bieden voor code-analyse vergeleken met traditionele regelgebaseerde of machine learning-methoden, worden ze geconfronteerd met aanzienlijke praktische beperkingen. Specifiek zijn de contextvensters van standaard LLM's (doorgaans 4K–16K tokens) vaak onvoldoende om volledige npm-pakketten te analyseren, die miljoenen tokens kunnen bevatten. Naïeve benaderingen, zoals het opsplitsen van code in vaste token-chunks, fragmenteren de semantische context en verslechteren de detectie nauwkeurigheid. Bovendien brengt volledige pakketanalyse prohibitieve inferentiekosten en latentie met zich mee, wat real-time registratiebewaking onhaalbaar maakt.

Methodologie

Het paper stelt een LLM-gebaseerd framework voor dat code-slicing technieken integreert om beveiligingsrelevante datastromen te isoleren van benigne boilerplate voordat de code naar een LLM wordt gevoerd. De methodologie bestaat uit drie primaire fasen:

1. Extractie van Gevoelige Code (Slicing):
   De auteurs passen taint-gebaseerde slicing aan voor het npm-ecosysteem met behulp van het Joern framework om Code Property Graphs (CPG's) te genereren. Ze introduceren een gecureerde, JavaScript-specifieke inventaris van gevoelige API's, gecategoriseerd in drie rollen:

   • Sources: Onbetrouwbare gegevensinputs (bijv. process.env, os.userInfo).
   • Sinks: Kritieke executiepunten (bijv. child_process.exec, eval, Buffer.from(..., 'base64')).
   • Dual: API's die zowel als source als sink fungeren (bijv. bestandsoperaties, netwerkcommunicatie).

   Twee slicing-strategieën worden geïmplementeerd en vergeleken:

   • Statische Slicing: Gebruikt Control Flow Graph (CFG) backward reachability om brede controledependenties vast te leggen.
   • Taint-gebaseerde Slicing: Volgt data-flow paden van onbetrouwbare sources naar kritieke sinks met behulp van Data Dependence Graphs (DDG's) en CPG's. Deze aanpak richt zich specifiek op beveiligingsrelevante flows en filtert incidentele API-aanroepen eruit.

   Een strikte tijdslimiet van drie minuten per pakket wordt afgedwongen om schaalbaarheid te garanderen. Pakketten die lege slices opleveren (vaak door dynamische codegeneratie of obfuscatie) worden uitgesloten van de statische analyse-pipeline.

2. LLM-gebaseerde Scoring:
   De geëxtraheerde slices worden gevoed aan DeepSeek-Coder-6.7B, gekozen vanwege het sterke begrip van code, een contextvenster van 16K tokens en het vermogen om strikt parseerbare JSON-outputs te produceren. Het model wordt geprompt met een statische analyse-persona om elke slice te beoordelen op kwaadaardige intentie, waarbij een JSON-object wordt geretourneerd met een betrouwbaarheidsscore, een obfuscatie-flag en een beveiligingsrisicoscore ($S \in [0, 1]$).

3. Aggregatie:
   Om de uiteindelijke pakket-niveau classificatie te bepalen, wordt een conservatieve aggregatiestrategie gehanteerd. De maximale kwaadaardigheidsscore over alle slices van een pakket wordt gebruikt als indicator. Een pakket wordt geclassificeerd als malafide als de score een drempelwaarde $\tau = 0.8$ overschrijdt.

Belangrijkste Bijdragen

Het paper levert drie specifieke bijdragen:

1. Adaptatie van Slicing-strategieën: De auteurs passen en evalueren twee code-slicing strategieën (statische CFG-gebaseerde en taint-gebaseerde) specifiek voor het npm-ecosysteem, gebruikmakend van Joern en een aangepaste JavaScript-specifieke API-taxonomie.
2. Kwantificering van Context Reductie: De studie kwantificeert de reductie in contextgrootte en het behoud van beveiligingsrelevante informatie. Taint-gebaseerde slicing reduceert het gemiddelde aantal input-tokens met 99,75% en de mediaan met 93,7%, terwijl kritieke kwaadaardige gedragingen behouden blijven.
3. Prestatie-evaluatie: Het framework wordt geëvalueerd op een dataset van meer dan 7.000 pakketten (gefilterd tot 2.537 die geschikt zijn voor statische analyse). De resultaten tonen aan dat semantisch gerichte inputrepresentaties de LLM-gebaseerde detectieprestaties aanzienlijk verbeteren ten opzichte van naïeve token-splitting en statische CFG-only slicing.

Resultaten

Geëvalueerd op een subset van 2.537 pakketten met DeepSeek-Coder-6.7B, bereikte de Taint-gebaseerde Slicing aanpak de volgende prestatie-indicatoren:

• Nauwkeurigheid (Accuracy): 87,04%
• Precisie (Precision): 96,23%
• Recall: 72,90%
• F1 Score: 83,32%

Deze resultaten presteerden beter dan zowel de Naïeve Token Splitting baseline (75,41% nauwkeurigheid, 67,80% F1) als de Statische CFG-only Slicing aanpak (75,65% nauwkeurigheid, 74,21% F1).

Wat betreft informatiebehoud behield Taint-gebaseerde slicing 73,7% van de gevoelige API-features in malafide pakketten, terwijl ongeveer 90% van de benigne code-segmenten werd weggefilterd. In tegenstelling hiertoe behield statische slicing slechts 73,4% van de malafide features, maar hield het aanzienlijk meer benigne ruis vast (15,9% van de gevoelige features in benigne pakketten versus 9,4% voor taint-gebaseerde slicing).

Betekenis en Beperkingen

Het paper stelt dat deze aanpak een effectieve en computationeel praktische verdediging biedt tegen evoluerende supply-chain dreigingen door LLM's in staat te stellen zich te concentreren op hoog-densiteit semantische signalen in plaats van het verwerken van enorme hoeveelheden irrelevante code. De significante reductie in het aantal tokens (van een gemiddelde van ~162k naar ~403) maakt real-time of bijna real-time analyse haalbaar op standaard hardware (twee RTX 3080 GPU's).

De auteurs erkennen echter expliciet enkele beperkingen:

• Survival Bias: De gerapporteerde nauwkeurigheid is alleen van toepassing op pakketten die niet-lege slices opleverden. Ongeveer 44% van de malafide pakketten in de dataset produceerde lege slices, voornamelijk door dynamische codegeneratie (bijv. eval, Function()) of obfuscatie die statische data-flow analyse doorbreekt.
• Afhankelijkheid van Predefiniëerde API's: Het framework vertrouwt op een gecureerde lijst van gevoelige API's. Het kan falen in het detecteren van nieuwe aanvalsvectoren die gebruikmaken van voorheen onbekende Node.js primitieven of indirecte call chains die niet in de inventaris aanwezig zijn.
• Obfuscatie: De huidige statische aanpak kan niet omgaan met zwaar geobfusceerde pakketten zonder een deobfusatie-preprocessing stap.

De auteurs concluderen dat hoewel de methode de detectieprestaties aanzienlijk verbetert ten opzichte van baselines, toekomstig werk deobfusatie, integratie van dynamische analyse en de uitbreiding van de API-inventaris moet adresseren om meer geavanceerde evasie-technieken aan te kunnen.