Hogyan lehet kikerülni az intelligens szerződéseket a visszatérő támadások csapdájából?

Olvasási idő: 6 jegyzőkönyv

Ha közelebbről megvizsgáljuk a legnagyobb kriptohackeket és az eltévedt szemet gyönyörködtető figurákat, akkor a kódolási hibákból mélyen gyökereztek volna.

A biztonsági rések egyik ilyen gyakori előfordulása a Reentrancy támadás. A helytelenül kezelt visszatérés miatti pusztító hatás azonban nem hangzik olyan egyszerűnek, mint maga a támadás.

Annak ellenére, hogy ismerős és jól ismert probléma, a Reentrancy hiba megjelenése az intelligens szerződésekben mindig elkerülhetetlen. 

Milyen gyakran használták ki a hackerek a Reentrancy sebezhetőségét az elmúlt években? Hogyan működik? Hogyan akadályozhatjuk meg, hogy az intelligens szerződések pénzvesztést okozzanak a Reentrancy hibák miatt? Ezekre a kérdésekre keresse a választ ebben a blogban.

Tehát rövid időn belül ecseteljük az emlékezet legnagyobb visszatérési támadásait. 

Néhány a leghírhedtebb valós idejű Reentrancy Hackek közül 

Azok a visszatérési támadások, amelyek a projektekre a legpusztítóbb hatást váltották ki, a kettő, vagy akár mindkettő egyikét okozták. 

• Teljesen ürítse ki az Ethert az intelligens szerződésekből
• Hackerek belopják magukat az intelligens szerződés kódjába

Most megfigyelhetjük a Reentrancy támadások néhány esetét és azok hatását. 

június 2016: DAO támadás – 3.54 millió vagy 150 millió dollár éter

2020. április: Uniswap/Lendf.Me hack – 25 millió dollár

Május 2021: A BurgerSwap hack – 7.2 millió dollár

augusztus 2021.: CREAM FINANCE hack – 18.8 millió dollár

2022. március: Ola Finance – 3.6 millió dollár

2022. július: OMNI protokoll – 1.43 millió dollár

Kristálytiszta, hogy a Reentrancy támadások soha nem mentek ki a divatból. A következő részekben nyerjünk mély betekintést ebbe. 

A Reentrancy támadás áttekintése

Mint a „Reentrancy” névből, ami azt jelenti, hogy „újra és újra belépni kell”. A visszatérő támadás két szerződést foglal magában: az áldozati szerződést és a támadó szerződést. 

A támadószerződés kihasználja az áldozati szerződés visszatérési sebezhetőségét. Ennek eléréséhez visszavonás funkciót használ. 

A támadó szerződés meghívja a visszavonási funkciót, hogy az áldozati szerződésből származó pénzeszközöket ismételten lehívja, mielőtt az áldozati szerződés egyenlege frissülne. Az áldozati szerződés ellenőrzi az egyenleget, pénzt küld és frissíti az egyenleget. 

De a pénzeszközök elküldésének és a szerződésben szereplő egyenleg frissítésének időkeretén belül a támadó szerződés folyamatosan felszólítja a pénzeszközök visszavonását. Ennek eredményeként az egyenleg nem frissül az áldozati szerződésben mindaddig, amíg a támadó szerződés el nem üríti az összes pénzt.

A reentancy kihasználásának súlyossága és költsége riasztja a teljesítmény rendkívüli szükségességét intelligens szerződés auditok hogy kizárja az ilyen hibák figyelmen kívül hagyásának lehetőségét. 

A Reentrancy Attack szemléltető képe

Az alábbi, egyszerűsített ábrán értelmezzük a visszatérő támadás fogalmát. 

Íme két szerződés: A sebezhető szerződés és a Hacker szerződés

A hackerszerződés felszólít a sebezhető szerződéstől való elállásra. A hívás fogadásakor a sebezhető szerződés ellenőrzi a hacker szerződésben szereplő pénzeszközöket, majd átutalja a pénzt a hackernek. 

A hacker megkapja a pénzeszközöket, és végrehajtja a tartalék funkciót, amely újra behívja a sebezhető szerződést még azelőtt, hogy az egyenleg frissülne a sérülékeny szerződésben. Így ugyanazt a műveletet megismételve a hacker teljesen kivonja a pénzt a sebezhető szerződésből. 

A támadó által használt tartalék funkció jellemzői 

• Külsőleg hívhatók. Azaz nem hívhatók a szerződésen belülről, amiket írnak
• Névtelen függvény
• A tartalék függvény nem tartalmaz tetszőleges logikát
• A tartalék akkor aktiválódik, amikor az ETH elküldésre kerül a hozzá tartozó intelligens szerződéshez, és nincs deklarálva a Receive() függvény.

A visszatérő támadás elemzése technikai nézetből 

Vegyünk egy szerződésmintát, és értsük meg, hogyan történik a visszatérési támadás.

Rosszindulatú szerződés

contract Attack {
    DepositFunds public depositFunds;

    constructor(address _depositFundsAddress) {
        depositFunds = DepositFunds(_depositFundsAddress);
    }

    // Fallback is called when DepositFunds sends Ether to this contract.
    fallback() external payable {
        if (address(depositFunds).balance >= 1 ether) {
            depositFunds.withdraw();
        }
    }

    function attack() external payable {
        require(msg.value >= 1 ether);
        depositFunds.deposit{value: 1 ether}();
        depositFunds.withdraw();
    }


}

Ez a támadó szerződés, amelyben a támadó letétbe helyezi a 2ETH-t. A támadó meghívja a visszavonási függvényt a sebezhető szerződésben. Amint a pénz megérkezik a sebezhető szerződésből, a tartalék funkció aktiválódik. 

A tartalék ezután végrehajtja a visszavonási funkciót, és kiüríti az alapot a sérülékeny szerződésből. Ez a ciklus addig tart, amíg az alapok teljesen ki nem merülnek a sebezhető szerződésből.

Sebezhető szerződés

contract DepositFunds {
    mapping(address => uint) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw() public {
        uint bal = balances[msg.sender];
        require(bal > 0);

        (bool sent, ) = msg.sender.call{value: bal}("");
        require(sent, "Failed to send Ether");

        balances[msg.sender] = 0;
    }


}

A sebezhető szerződés 30 ETH. Itt a visszavonás() függvény elküldi a kért összeget a támadónak. Mivel az egyenleg nem frissül, a tokenek ismételten átkerülnek a támadóhoz. 

A visszatérő támadások típusai

• Egyfunkciós visszatérés 

function withdraw() external {
   uint256 amount = balances[msg.sender];
   require(msg.sender.call.value(amount)());
   balances[msg.sender] = 0;
}

Az msg.sender.call.value(amount)() átutalja az összeget, amely után a támadó szerződéses tartalék függvénye ismét meghívja a visszavonás() függvényt, mielőtt a balances[msg.sender] = 0 frissülne.

• Keresztfunkciós visszatérés

function transfer(address to, uint amount) external {
   if (balances[msg.sender] >= amount) {
       balances[to] += amount;
       balances[msg.sender] -= amount;
   }
}
function withdraw() external {
   uint256 amount = balances[msg.sender];
   require(msg.sender.call.value(amount)());
   balances[msg.sender] = 0;
}

A keresztfunkciók közötti visszatérést sokkal bonyolultabb azonosítani. A különbség itt az, hogy a tartalék függvény az átvitelt hívja, ellentétben az egyfunkciós reentrancy-val, ahol a visszavonást hívja.

Megelőzés a visszatérő támadásokkal szemben

Ellenőrzések-hatások-kölcsönhatások minta: Az ellenőrzések-hatások-kölcsönhatások minta segít a funkciók strukturálásában. 

A programot úgy kell kódolni, hogy először ellenőrizze a feltételeket. Az ellenőrzések átesése után fel kell oldani a szerződések állapotára gyakorolt ​​hatásokat, ezt követően hívhatók meg a külső funkciók. 

function withdraw() external {
   uint256 amount = balances[msg.sender];
   balances[msg.sender] = 0;
   require(msg.sender.call.value(amount)());
}

Az itt átírt kód az ellenőrzések-hatások-kölcsönhatások mintát követi. Itt az egyenleg nullázódik, mielőtt külső hívást kezdeményezne. 

Módosító használata

A függvényre alkalmazott noReentrant módosító biztosítja, hogy ne legyenek reentrant hívások. 

contract ReEntrancyGuard {
    bool internal locked;

    modifier noReentrant() {
        require(!locked, "No re-entrancy");
        locked = true;
        _;
        locked = false;
    }
}

A végén

A leghatékonyabb lépés az intelligens szerződések auditálása egy vezető biztonsági cégtől, például a QuillAuditstól, ahol az auditorok szorosan figyelemmel kísérik a kód szerkezetét, és ellenőrzik a tartalék funkció működését. A vizsgált minták alapján javaslatokat tesznek a kód átstrukturálására, ha úgy tűnik, hogy van ilyen sebezhető viselkedések. 

A pénzeszközök biztonsága közvetlenül azelőtt biztosított, hogy bármilyen veszteség áldozatává válna. 

GYIK

Mi az a visszatérő támadás?

Újbóli belépési támadás akkor történik, amikor a sebezhető szerződés egyik funkciója nem megbízható szerződést hív meg. A megbízhatatlan szerződés a támadó szerződése lesz, amely rekurzív hívásokat intéz a sebezhető szerződéshez, amíg az alap teljesen el nem fogy. 

Mi az a visszatérő?

Az újbóli belépés azt jelenti, hogy megszakítjuk a kód végrehajtását, és újraindítjuk a folyamatot, amit újrabevitelnek is neveznek.

Mi az a visszatérő őr?

A Reentrancy Guard egy módosítót használ, amely megakadályozza a függvény ismételt meghívását. Olvassa el a fenti blogot, hogy megtalálja a visszalépési őr példáját.

Melyek az intelligens szerződések elleni támadások?

Az intelligens szerződések számos sebezhetőségnek vannak kitéve, mint például az újrabelépés, az időbélyeg-függőség, az aritmetikai túlcsordulás, a DoS támadások stb. Ezért az auditálás elengedhetetlen annak biztosítására, hogy ne legyenek olyan hibák, amelyek összeomlanak a szerződés logikájában.

69 Nézetek