LLM4PQC - Accurate and Efficient Synthesis of PQC Cores by Feedback-Driven LLMs

Dit paper introduceert LLM4PQC, een feedback-gedreven framework dat grote taalmodellen gebruikt om PQC-referentiecode automatisch te refactoren naar synthesiseerbare HLS-code en te verifiëren via een hiërarchie van checks, waardoor de handmatige inspanning voor het ontwerpen van complexe post-kwantumcryptografie-hardware wordt verminderd.

De kern

Stel je voor dat je een heel complexe, handgeschreven receptenboek hebt voor het bakken van een taart die niemand eerder heeft gemaakt. Dit recept is perfect voor een professionele chef-kok (de software-ontwikkelaar), maar als je het rechtstreeks aan een robot in een fabriek wilt geven (de hardware-chip), werkt het niet. De robot begrijpt termen als "een beetje van dit" of "bak tot het goed ruikt" niet; hij heeft exacte grammaten en seconden nodig.

Dit is precies het probleem dat LLM4PQC oplost.

Hier is een uitleg in simpele taal, met een paar creatieve vergelijkingen:

1. Het Probleem: De "Vertaal- en Bouwkwestie"

Vroeger waren onze digitale sloten (zoals RSA) veilig. Maar nu komen er supercomputers (kwantumcomputers) die die sloten kunnen kraken. De oplossing? Nieuwe, onbreekbare sloten genaamd PQC (Post-Quantum Cryptography).

Deze nieuwe sloten zijn bedacht door wiskundigen en programmeurs. Ze hebben het werkcode geschreven in een taal die computers begrijpen (C-code), maar die code is gemaakt voor software (zoals op je laptop).

• Het probleem: Als je die code wilt gebruiken in een fysieke chip (hardware), moet je hem volledig herschrijven. Dat is als proberen een recept voor een taart om te zetten in instructies voor een 3D-printer. Je moet elke stap exact definiëren, geen "een beetje" meer zeggen, en alles statisch maken.
• De huidige manier: Mensen doen dit handmatig. Ze kijken naar de code, denken na, herschrijven het, testen het, zien dat het fout gaat, en beginnen opnieuw. Dit duurt jaren en is extreem duur.

2. De Oplossing: LLM4PQC (De Slimme Architect)

De auteurs van dit paper hebben een nieuw systeem bedacht, LLM4PQC. Dit is een systeem dat een Kunstmatige Intelligentie (AI) gebruikt, maar dan op een heel slimme manier.

Stel je voor dat je een zeer intelligente, maar soms wat slordige architect (de AI) hebt die een huis moet bouwen.

• De oude manier: Je gaf de architect het recept en zei: "Bouw dit." Hij probeerde het, maar viel in de put omdat hij een brug over een kloof moest bouwen zonder brugmaterialen.
• De nieuwe manier (LLM4PQC):
  1. De Voorbereiding (Preprocessing): Eerst helpt een assistent de architect om het recept te "ontsmakken". We halen de lastige dingen eruit (zoals "wacht tot het warm is" of "gebruik een willekeurig aantal eieren") en vervangen ze door vaste getallen.
  2. De Bouw (HLS): De architect probeert nu het huis te bouwen.
  3. De Feedback-lus (Het Magische Deel): Dit is het belangrijkste. Zodra de architect een fout maakt (bijvoorbeeld: "Ik heb geen hout voor deze muur"), krijgt hij direct een melding van de bouwvakkers (de software-tools).
  4. Het Herhalen: De AI leest de melding, denkt: "Ah, ik dacht dat ik hout kon gebruiken, maar hier moet ik steen gebruiken," en past het plan direct aan.
  5. De Controle: Voordat het huis echt wordt gebouwd, wordt er een virtuele test gedaan. Werkt de deur? Zitten de ramen op de juiste plek? Pas als alles perfect is, wordt het plan naar de fabriek gestuurd.

3. Wat hebben ze gedaan?

Ze hebben dit systeem getest op de nieuwste, moeilijkste cryptografische algoritmen (Kyber, Dilithium, Falcon).

• Het resultaat: Het systeem kon deze complexe code automatisch omzetten in werkende hardware-instructies.
• De prestatie: De chips die ze maakten waren soms zelfs kleiner en zuiniger dan chips die door menselijke experts handmatig waren ontworpen.
• De prijs: Soms waren ze iets langzamer (de taart werd iets langer gebakken), maar dat is een klein prijsje voor het enorme voordeel dat je niet jarenlang hoeft te wachten op een ontwerp.

4. Waarom is dit belangrijk?

Vroeger duurde het jaren om een nieuwe beveiligingschip te maken. Met LLM4PQC kan dit proces worden versneld tot weken of zelfs dagen.

• Het is alsof we zijn overgestapt van het handmatig kopiëren van een boek naar het gebruik van een printer die zichzelf corrigeert als er een letter verkeerd staat.
• Het maakt het mogelijk om onze digitale wereld snel veilig te maken tegen de dreiging van toekomstige kwantumcomputers.

Kort samengevat:
LLM4PQC is een slimme, zelf-corrigerende vertaler. Hij neemt een rommelig, menselijk recept voor digitale beveiliging, maakt er een strak, machine-leesbaar plan van, en bouwt er een fysieke chip van die beter presteert dan veel handgemaakte versies. Het is de sleutel om onze toekomstige digitale sloten snel en goedkoop te kunnen produceren.

Technische samenvatting

Titel: LLM4PQC: Accurate en Efficiënte Synthese van PQC-kernen door Feedback-gedreven LLM's

1. Het Probleem

De overgang naar post-kwantumcryptografie (PQC) vereist efficiënte hardware-implementaties om kwantumbedreigingen voor RSA en ECC te mitigeren. Hoewel de National Institute of Standards and Technology (NIST) referentie-implementaties in C heeft gestandaardiseerd (zoals Kyber, Dilithium en Falcon), zijn deze niet direct geschikt voor hardware-synthese.

De huidige workflow voor het converteren van deze C-code naar High-Level Synthesis (HLS) en vervolgens naar Register Transfer Level (RTL) code stuit op ernstige knelpunten:

• Manuele Refactoring: Het converteren van portable, software-georiënteerde C-code naar synthesizable HLS-C vereist uitgebreide manuele aanpassingen.
• Synthese-Belemmeringen: Referentiecode bevat constructies die onverenigbaar zijn met HLS-tools, zoals:
  • Calls naar math.h (bijv. sin, cos, sqrt).
  • Floating-point rekenkunde (vaak nodig voor nauwkeurigheid in PQC, maar moeilijk te synthetiseren).
  • Runtime-initialisatie van constante tabellen (bijv. twiddle-factoren).
  • Dynamische geheugenallocatie (malloc) en complexe datastructuren (structs, pointers).
• Schaalbaarheid: Het handmatig optimaliseren van complexe primitieven zoals de Number Theoretic Transform (NTT) en Gaussian samplers is tijdrovend en vereist diepgaande expertise.

2. Methodologie: Het LLM4PQC Framework

LLM4PQC is een feedback-gedreven framework dat Large Language Models (LLM's) gebruikt om PQC-referentiecode automatisch te transformeren naar synthesizable HLS-C code. Het proces verloopt in vier fasen (zie Figuur 1 in het paper):

Fase 1: Extractie van PQC-subroutines
In plaats van de volledige referentie-implementatie te converteren, identificeert het systeem (met behulp van een LLM) de prestatie-kritieke kernfuncties (zoals NTT, FFT, Samplers). Het LLM extrahert deze functies met minimale afhankelijkheden en genereert automatisch een verificatie-infrastructuur met Known Answer Tests (KATs) om functionele gelijkwaardigheid te garanderen.

Fase 2: HLS Preprocessing (Automatische Refactoring)
Voordat de code naar de HLS-tool gaat, ondergaat deze een voorbewerking om "synthese-blokkers" te verwijderen:

• Static Memory Mapping: Dynamische allocaties (malloc) worden geautomatiseerd omgezet naar statische arrays.
• Initialisatieverwijdering: Runtime-routines die constante tabellen berekenen, worden vervangen door compile-time constante arrays (ROM-achtige tabellen).
• Datastructuur-expansie: Complexe structs worden ontbonden in primitieve variabelen om de mapping naar hardware-interfaces te vergemakkelijken.
• Feedback-lus: Als de geresulteerd code niet compileert of faalt in tests, worden de foutmeldingen teruggekoppeld naar het LLM voor iteratieve correctie.

Fase 3: HLS-C Generatie en Design-Space Exploration (DSE)
De gepreprocesseerde code wordt ingevoerd in een geïntegreerde toolflow (C2HLSC en Catapult).

• Het LLM genereert HLS-compatibele C-code.
• Iteratieve optimalisatie: Op basis van feedback van de synthesise-tool (oppervlaktegebruik, latentie) introduceert het LLM HLS-pragmas (zoals loop-unrolling en pipelining) om de prestaties te optimaliseren.
• De output wordt continu gevalideerd tegen de originele C-referentie via KAT-tests.

Fase 4: Synthese en Verificatie
De gegenereerde code wordt gesynthetiseerd naar RTL voor ASIC (Nangate 45nm) en FPGA (Xilinx Artix-7, XCZU7EV) doelen. Automatisch gegenereerde testbenches verifiëren het gedrag van het RTL tegen de C-model outputs.

3. Belangrijkste Bijdragen

1. LLM-gedreven Preprocessing: Een geautomatiseerde pipeline die C-code transformeert om specifieke HLS-vereisten te voldoen (statisch geheugen, verwijdering van runtime-initialisatie, expansie van datastructuren).
2. Gestructureerde Feedback-workflow: Een end-to-end cyclus die LLM-transformaties koppelt aan tool-gedreven feedback (compilatiefouten, simulatieresultaten, PPA-metrics) voor iteratieve verbetering.
3. Empirische Validatie: Een uitgebreide case study op drie NIST-standaarden (Kyber, Dilithium, Falcon) en hun kernprimitieven (NTT, FFT, Sampler), wat de haalbaarheid van volledig geautomatiseerde PQC-hardwareontwikkeling aantoont.

4. Resultaten

De auteurs hebben LLM4PQC getest op vijf benchmarks: Kyber-NTT, Dilithium-NTT, Falcon-NTT, Falcon-Sampler en Falcon-FFT.

• Succesratio: De framework bereikte een 100% succesratio voor Kyber-NTT, Dilithium-NTT en Falcon-FFT. Falcon-NTT en Falcon-Sampler hadden lagere successratios (respectievelijk 70% en 40%), voornamelijk door de complexiteit van floating-point operaties en data-afhankelijke loops in de sampler.
• Efficiëntie (ASIC): De gegenereerde ontwerpen waren uitzonderlijk compact. Bijvoorbeeld, Kyber-NTT gebruikte gemiddeld slechts 2.957 µm², wat aanzienlijk lager is dan veel handmatig ontworpen referenties.
• Vergelijking met Bestaand Werk (FPGA):
  • LLM4PQC presteerde beter in termen van resource-gebruik (LUTs en Flip-Flops) dan handmatig ontworpen baselines en eerdere LLM-gestuurde pogingen.
  • Latentie: De latency was hoger dan bij handmatig geoptimaliseerde ontwerpen. Dit komt doordat het LLM zonder expliciete instructie vaak voor compacte, sequentiële structuren kiest in plaats van agressieve parallelisatie.
  • Voorbeeld Falcon-Sampler: LLM4PQC bereikte een latency van 0,39 µs, wat beter is dan de 0,73 µs van een vergelijkbare eerdere LLM-studie ([18]).
• Automatisering: Het framework reduceerde de manuele inspanning aanzienlijk en versnelde de design-space exploration (DSE) ten opzichte van traditionele flows.

5. Betekenis en Conclusie

LLM4PQC demonstreert dat Large Language Models, wanneer ze worden ingezet binnen een gestructureerde, feedback-gedreven workflow, een krachtig instrument kunnen zijn voor het automatiseren van complexe hardwareontwerpen voor cryptografie.

• Paradigmaverschuiving: Het paper toont aan dat de barrière tussen software-referentiecode en hardware-implementatie overbrugd kan worden zonder volledige handmatige herschrijving.
• Trade-off: Er is een duidelijke trade-off tussen productiviteit/oppervlakte-efficiëntie (waarbij LLM4PQC excelleert) en latentie (waarbij handmatige optimalisatie nog steeds de voorkeur heeft).
• Toekomstperspectief: De auteurs suggereren dat toekomstige werken zich moeten richten op het verfijnen van de LLM's met specifieke HLS-datasets, het gebruik van Retrieval-Augmented Generation (RAG) voor bewezen ontwerppatronen, en het integreren van voorspellende modellen voor PPA (Power, Performance, Area) om de synthese-tijd te verkorten.

Kortom, LLM4PQC biedt een robuust pad naar het sneller en efficiënter ontwikkelen van PQC-hardwareversnellers, wat cruciaal is voor de bredere adoptie van post-kwantumcryptografie.