Stateful Embedded Fuzzing with Peripheral-Accurate SystemC Virtual Prototypes
Dit paper introduceert een nieuw raamwerk dat AFL++ integreert met stateful SystemC-TLM virtuele prototypes om realistische, pre-silicon fuzzing van ingebouwde software mogelijk te maken, waarbij perifeer gedrag nauwkeurig wordt gesimuleerd om valse positieven te elimineren zonder in te leveren op code-coverage of uitvoeringsprestaties.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Stel je voor dat je een nieuwe, zeer complexe auto gaat bouwen. Voordat je de eerste echte motor start, wil je zeker weten dat de software die de remmen, de lichten en de radio aanstuurt, niet crasht als er iets misgaat.
In het verleden hebben ingenieurs dit handmatig getest, maar tegenwoordig is de software zo ingewikkeld dat dit onmogelijk is. Daarom gebruiken ze een techniek genaamd "Fuzzing".
Wat is Fuzzing? (De "Goochelende Test")
Stel je voor dat je een duizendpoot bent die duizenden keer per seconde willekeurige knoppen indrukt op je nieuwe auto. Je probeert elke mogelijke combinatie: "Rem en gas tegelijk", "Radio op volume 100 en lichten uit", enzovoort. Het doel is om te zien of de auto in paniek raakt, vastloopt of iets kapot maakt.
Dit werkt geweldig voor software op je laptop. Maar bij ingebouwde systemen (zoals in een auto, drone of robot) is het lastiger. Die systemen praten met "periferieën": sensoren, schermen, radio's. Als je een simpele test doet, zegt de computer: "Ik heb een signaal van de rem gekregen", maar in de echte wereld is dat signaal misschien een logische reactie op een andere gebeurtenis.
Het Probleem: De "Lege" Simulatie
Tot nu toe gebruikten onderzoekers twee soorten methoden:
- De Snelle, maar Onrealistische Methode: Ze simuleerden de software in een omgeving waar de sensoren en motoren niet echt bestonden. Het was alsof je de auto testte in een virtuele wereld zonder wegen. Het ging supersnel, maar de computer dacht dat alles normaal was, terwijl in werkelijkheid de remmen vastzaten. Dit leidde tot veel vals alarm (de computer dacht dat er een fout was, terwijl het alleen maar een rare simulatie was).
- De Realistische, maar Trage Methode: Ze bouwden een complete digitale kopie van de auto, inclusief alle sensoren. Dit was heel realistisch, maar om dit te testen, moesten ze de software zelf aanpassen (instrumenteren). Dat is lastig als je de software niet mag wijzigen (bijvoorbeeld bij gesloten broncode van een leverancier).
De Oplossing: De "Digitale Tweeling" met een Telefoontje
De auteurs van dit paper hebben een slimme nieuwe manier bedacht. Ze hebben een Stateful (staat-bewust) systeem gebouwd.
Stel je voor dat je een digitale tweeling van je auto hebt in een computer. Deze digitale auto is gemaakt met een technologie genaamd SystemC. Het is alsof je een perfecte, virtuele werkplaats hebt.
Hun innovatie zit in de "Injectors" (de injectoren).
- Hoe het werkt: In plaats van dat de software zelf moet zeggen "Ik heb een signaal nodig", sturen deze injectoren automatisch willekeurige signalen naar de digitale sensoren en motoren, precies op het moment dat de software daar op wacht.
- De Analogie: Stel je voor dat je een acteur (de software) hebt die een toneelstuk speelt. De oude methoden gaven de acteur een script met willekeurige teksten. De nieuwe methode heeft een regisseur (de injector) die op het toneel staat en plotseling een deur openstoot of een lamp laat knipperen. De acteur reageert daarop op een natuurlijke manier, omdat de deur en de lamp echt "bestaan" in hun digitale wereld.
Waarom is dit zo goed?
- Geen Vals Alarm: Omdat de digitale sensoren echt reageren (bijvoorbeeld: een sensor zegt "ik heb 5 graden", en de software moet daar logisch op reageren), ontstaan er geen rare situaties die alleen bestaan in de simulatie. Als de software crasht, is het een échte fout.
- Geen Aanpassingen: Ze hoeven de software van de fabrikant niet aan te passen. Ze sturen gewoon signalen naar de digitale hardware.
- Vindt Echte Fouten: Ze hebben dit getest op drones en robots. Ze vonden fouten zoals:
- Een drone die vastliep omdat een sensor een verkeerd getal gaf.
- Een robot die vastliep omdat hij probeerde te delen door nul (een klassieke programmeerfout) toen een signaal verkeerd werd geïnterpreteerd.
De Korte Samenvatting
Vroeger testten we ingebouwde software alsof we een auto testten in een droomwereld: snel, maar niet echt.
Nu hebben we een perfecte digitale werkplaats gebouwd waar we de software kunnen laten "rijden" met echte, virtuele sensoren en motoren.
Het is misschien iets trager dan de droomwereld (ongeveer 2x trager), maar het resultaat is veel betrouwbaarder. Je vindt de echte gaten in de software voordat de eerste echte auto de fabriek uitrijdt, zonder dat je de software zelf hoeft te wijzigen. Het is als het vinden van een lek in een boot voordat je de oceaan opgaat, in plaats van hopen dat het water niet te diep is.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.