32.5.1. Konstans idejű feldolgozás

Sokan azt hiszik, a konstans idejű feldolgozás azt jelenti, hogy egy művelet mindig, mikroszekundumra pontosan ugyanannyi ideig tart. Ez egy veszélyes leegyszerűsítés, ami félrevezető biztonsági döntésekhez vezethet. A valóság ennél sokkal árnyaltabb és a támadások szempontjából kritikusabb.

A konstans idejű algoritmusok lényege nem az, hogy gyorsak vagy egy adott, fix ideig futnak. A lényeg az, hogy a végrehajtási idejük független a feldolgozott titkos adatoktól. Egy művelet futhat 10 milliszekundumig és futhat 10 másodpercig is; amíg ez az idő nem függ a bemeneti jelszó karaktereitől, a privát kulcs bitjeitől vagy bármilyen más szenzitív információtól, addig az időzítési csatornát bezártuk.

A konstans idő valódi jelentése

Az időzítésen alapuló támadások (Timing Attacks) azon a megfigyelésen alapulnak, hogy a feldolgozási idő korrelál a bemeneti adatokkal. Ha egy jelszó-ellenőrző függvény az első eltérő karakternél azonnal visszatér, a futási ideje elárulja, hány karakter volt helyes. A konstans idejű feldolgozás ezt a korrelációt szünteti meg.

Ahogy a diagram is mutatja, a sebezhető megvalósítás futási ideje kaotikusan változik a bemenet függvényében, értékes információt szivárogtatva. Ezzel szemben a védett, konstans idejű változat futási ideje nem mutat korrelációt a bemenettel, így a támadó nem tud következtetéseket levonni.

Hogyan érhető el a konstans idejű működés?

A modern processzorok és fordítóprogramok optimalizációi miatt a konstans idejű kód írása nem triviális. Két fő területre kell koncentrálni:

1. Adatfüggő elágazások elkerülése

A leggyakoribb hibaforrás az, amikor a program futása egy titkos értéktől függő feltétel alapján más úton folytatódik. A klasszikus példa a string-összehasonlítás.

Sebezhető megvalósítás:

// Python pszeudokód
def compare_passwords_vulnerable(a, b):
 # A hosszak eltérése már önmagában információt szivárogtat
 if len(a) != len(b):
 return False
 
 for i in range(len(a)):
 # Azonnali kilépés az első hibánál.
 # A futási idő elárulja, hol volt az első eltérés.
 if a[i] != b[i]:
 return False
 
 return True

Konstans idejű megvalósítás:

// Python pszeudokód
def compare_passwords_constant_time(a, b):
 # Először ellenőrizzük a hosszakat, de a ciklus ideje ettől még lehet konstans.
 if len(a) != len(b):
 // Fontos, hogy itt is egy "dummy" összehasonlítást végezzünk
 // a, hogy a visszatérésig eltelő idő ne legyen túl árulkodó.
 // Egy jobb megoldás fix hosszúságú hasheket hasonlít össze.
 b = a 
 
 result = 0
 for x, y in zip(a, b):
 # Bitwise XOR műveletet használunk. Az eredmény 0, ha a karakterek azonosak.
 # A `result` változóba "gyűjtjük" az eltéréseket.
 # A ciklus MINDIG végigfut, nem lép ki korábban.
 result |= ord(x) ^ ord(y)
 
 return result == 0

A második példában a ciklus mindenképpen végigmegy a teljes bemeneten. Nincs korai kilépés. A bitenkénti műveletek (XOR és OR) segítségével gyűjtjük az eltéréseket anélkül, hogy feltételes elágazást (`if`) használnánk a cikluson belül.

2. Adatfüggő memóriahozzáférés megszüntetése

A modern CPU-k gyorsítótárakat (cache) használnak a memóriahozzáférés gyorsítására. Ha egy program egy titkos érték által indexelt tömbelemet kér le (pl. `lookup_table[secret_byte]`), a hozzáférés ideje attól függ, hogy az adott memóriacím a gyorsítótárban van-e. Egy támadó, aki képes mérni ezeket a finom időkülönbségeket (cache-timing attack), visszafejtheti a titkos értéket.

Ennek kivédése bonyolult, gyakran alacsony szintű programozási technikákat vagy speciális CPU-utasításokat igényel, amelyek megakadályozzák a spekulatív végrehajtást vagy a cache-alapú optimalizációkat a kritikus kódrészleteken.

Relevancia az MI rendszerekben

Bár a konstans idejű programozás a kriptográfiából ered, az MI-alapú rendszerekben is kritikus lehet, különösen azokon a pontokon, ahol a rendszer szenzitív adatokkal dolgozik:

• Input validáció: Egy API-kulcs, token vagy jelszó ellenőrzése a modell meghívása előtt tipikusan sebezhető pont.
• Modell architektúra: Bizonyos modellek (pl. „early exit” mechanizmussal rendelkező transzformerek vagy döntési fák) végrehajtási ideje függhet a bemenet komplexitásától vagy tartalmától. Ez információt szivárogtathat a bemeneti adatról.
• Tokenizáció: Egyedi tokenizációs eljárások feldolgozási ideje is függhet a szöveg tartalmától, ami elméleti támadási felületet nyithat.