動不動就出事，智能合約攻擊該怎麼辦？

最新 07-27

如果你在數字貨幣世界待過足夠時間，也許你聽說過1或2個智能合約攻擊時間，這些攻擊導致了幾千萬美元的盜竊損失。最著名的攻擊是DAO事件，這是數字貨幣世界最受期待的項目之一，同時也是智能合約的改革。雖然很多人聽說過這些攻擊，但是很少人知道到底發生了什麼，是怎麼發生的，以及如何避免這些錯誤。

智能合約是動態的，複雜的以及難以置信地強大。雖然他們的潛力是很難想像，但是也不可能一夜之間就成為了攻擊的對象。也就是說，對於往後的數字貨幣，我們可以從之前的錯誤中學到經驗，然後一起成長。雖然DAO是已經發生的事情，但是這對於開發者，投資者，以及社區成員對於智能合約攻擊來說，都是一個很好的例子。

今天，我想和大家聊聊從DAO事件中，我們學到的3件事。

當攻擊者通過對目標調用提款操作的時候，重入攻擊就會發生，就好像DAO事件一樣。當合約不能在發出資金之前更新狀態（用戶餘額），攻擊者就可以連續進行提取函數調用，來獲得合約中的資金。任何時候攻擊者獲得以太幣，他的合約都會自動地調用反饋函數，function ()，這就再次調用了提現合約。這時候，攻擊就會進入遞歸迴路，這時候這個合約中的資金就會轉入攻擊者。因為目標合約都在不停地調用攻擊者的函數，這個合約也不會更新攻擊者的餘額。當前的合約不會發現有任何問題，更清楚地說，合約函數中包含反饋函數，當合約收到以太幣和零數據的時候，合約函數就會自動執行。

1.攻擊者將以太幣存入目標函數

2.目標函數就會根據存入的以太幣而更新攻擊者的約

3.攻擊者請求拿回資金

4.資金就會退回

5.攻擊者的反饋函數生效，然後調用提現功能

6.智能合約的邏輯就會更新攻擊者的餘額，因為提現又被成功調用

7.資金髮送到攻擊者

8.第5-7步重複使用

9.一旦攻擊結束，攻擊者就會把資金從他們自己的合約發送到個人地址

重入攻擊的遞歸迴路

很不幸地是，一旦這個攻擊開始，無法停下。攻擊者的提現功能會被一次次地調用，直到合約中的燃料跑完，或者被害者的以太幣餘額被消耗光。

下面就是DAO合約的簡單版本，其中會包括一些介紹來為這些不熟悉代碼/ solidity語言更好地理解合約。

contract babyDAO { /* assign key/value pair so we can look up credit integers with an ETH address */ mapping (address => uint256) public credit; /* a function for funds to be added to the contract, sender will be credited amount sent */ function donate(address to) payable { credit[msg.sender] += msg.value; } /*show ether credited to address*/ function assignedCredit(address) returns (uint) { return credit[msg.sender]; } /*withdrawal ether from contract*/ function withdraw(uint amount) { if (credit[msg.sender] >= amount) { msg.sender.call.value(amount)(); credit[msg.sender] -= amount; } } }

import 『browser/babyDAO.sol』;

contract ThisIsAHodlUp { /* assign babyDAO contract as "dao" */ babyDAO public dao = babyDAO(0x2ae...); address owner; /*assign contract creator as owner*/ constructor(ThisIsAHodlUp) public { owner = msg.sender; }

/*fallback function, withdraws funds from babyDAO*/ function() public { dao.withdraw(dao.assignedCredit(this)); } /*send drained funds to attacker』s address*/ function drainFunds() payable public{ owner.transfer(address(this).balance); } }

需要注意地是，這個後退函數，function()，會調用DAO或者babyDAO{}的提現函數，來從合約中盜取資金。從另個方面來說，當攻擊者想要把所有偷竊來的資金賺到他們的地址，drainFunds()功能會被調用。

contract babyDAO{

....

function withdraw(uint amount) { if (credit[msg.sender] >= amount) { credit[msg.sender] -= amount; /* updates balance first */ msg.sender.send(amount)(); /* send funds properly */ } }

雖然DAO合約不會讓受害者掉入下溢攻擊，我們能夠通過現有的babyDAO contract{}來更好地理解這些攻擊為什麼會發生。

首先，我們需要理解什麼是256單位制。一個256單位制是由256個位元組組成。以太坊的虛擬機是使用256位元組來完成的。因為以太坊虛擬機受限於256位元組的大小，所以數字的範圍是0到4,294,967,295 (22??)。如果我們超過這個範圍，那麼數字就會重置到範圍的最底部（22?? + 1 = 0）。如果我們低於這個範圍，這個數字就會重置到這個範圍的頂端（0–1= 22??）。

當我們從零中減去大於零的數，就會發生下溢攻擊，導致一個新的22??數集。現在，如果攻擊者的餘額發生了下溢，那麼這部分餘額就會更新，從而導致整個資金被盜。

攻擊者通過發出1Wei到目標合約，來啟動攻擊。

合約認證發出資金的人

隨後調用1Wei的提現函數

合約會從發送者的賬戶扣除的1Wei，現在賬戶餘額又是零

因為目標合約將以太幣發給攻擊者，攻擊者的退回函數被處罰，所以提現函數又被調用。

提現1Wei的事件被記錄

攻擊者合約的餘額就會更新兩次，第一次是到零，第二次是到-1。

攻擊者的餘額回置到22??

攻擊者通過提現目標合約的所有資金，從而完成整個攻擊

/*donate 1 wei, withdraw 1 wei*/ function attack() { dao.donate.value(1)(this); dao.withdraw(1); } /*fallback function, results in 0–1 = 2**256 */ function() { if (performAttack) { performAttack = false; dao.withdraw(1); } } /*extract balance from smart contract*/ function getJackpot() { dao.withdraw(dao.balance); owner.send(this.balance); } }

為了防止受害人陷入下溢攻擊，最好的方法是看更新的狀態是否在位元組範圍內。我們可以添加參數來檢查我們的代碼，作為最後一層保護。函數withdraw()的首行代碼是為了檢查是否有足夠的資金，第二行是為了檢查超溢，第三個是檢查下溢。

contract babysDAO{ .... /*withdrawal ether from contract*/ function withdraw(uint amount) { if (credit[msg.sender] >= amount && credit[msg.sender] + amount >= credit[msg.sender] && credit[msg.sender] - amountre>

需要注意，就像我們之前討論，我們上面的代碼是在發出資金之前更新用戶的餘額。

最後要說的，就是跨函數競爭攻擊。就像在重放攻擊中所說，DAO合約不能正確的更新合約狀態，並且可以讓資金被盜竊。DAO問題和外部調用中的部分原因是跨函數競爭條件攻擊的潛在原因。雖然以太坊中所有的轉賬是線性發生(一個在另一個後面), 外部調用（另一個合約或者地址的調用）如果沒有被合理管理，就會成為災難的導火線。在現實世界中，他們是完全可以避免的。當兩個函數被調用並且分享同個狀態，跨函數競爭條件攻擊就會發生。這個合約就會想到，現在有兩個合約狀態存在，但是現實是只有一個真正的合約狀態存在。我們不能同時獲得X = 3和X = 4這兩種結果。讓我們用一個例子來說明這個內容。

contract crossFunctionRace{ mapping (address => uint) private userBalances;

/* uses userBalances to transfer funds */ function transfer(address to, uint amount) { if (userBalances[msg.sender] >= amount) { userBalances[to] += amount; userBalances[msg.sender] -= amount; } }

/* uses userBalances to withdraw funds */ function withdrawalBalance() public { uint amountToWithdraw = userBalances[msg.sender]; require(msg.sender.send(amountToWithdraw)()); userBalances[msg.sender] = 0; } }

上面的合約有2個功能 – 一個是可以轉移資金，另一個是提現資金。我們假設攻擊者調用了函數transfer()，然後同時使用外部調用函數withdrawalBalance()。userBalance[msg.sender]的狀態通過2個不同的方向被抽出。用戶的餘額還沒有被設為0，但是儘管資金已經被提取，攻擊者也能夠轉移資金。這樣情況下，合約可以讓攻擊者使用雙花，這也是區塊鏈技術想要解決的問題之一。

注意：如果有函數分享狀態，跨函數競爭條件攻擊就會在多個合約中發生。

-在調用外部函數之前，應該完成所有的內部工作

-避免發生外部調用

-在不可避免地時候，使用外部函數「不可信」

-在外部調用不可避免的情況下，使用互斥

根據下面的合約，我們可以看到一個例子1) 在完成外部調用之前，完成內部工作。2）將所有外部調用都設為「不可信」。我們的合約會讓資金髮送到一個地址，並且允許用戶一次性將資金存入合同。

contract crossFunctionRace{ mapping (address => uint) private userBalances; mapping (address => uint) private reward; mapping (address => bool) private claimedReward;

//makes external call, need to mark as untrusted function untrustedWithdraw(address recipient) public { uint amountWithdraw = userBalances[recipient]; reward[recipient] = 0; require(recipient.call.value(amountWithdraw)()); } //untrusted because withdraw is called, an external call function untrustedGetReward(address recipient) public {

//check that reward hasn』t already been claimed require(!claimedReward[recipient]); //internal work first (claimedReward and assigning reward) claimedReward = true; reward[recipient] += 100; untrustedWithdraw(recipient); } }

我們可以看出，這個合約的首個函數在發送資金到用戶的合約/地址的時候，就會發生外部調用。同樣地，獎勵函數在發送一次性獎勵的時候，也會使用提現函數，因為這也是不可信的。同樣重要地是，合約需要執行所有內部工作。就好像重入攻擊，函數untrustedGetReward()會在允許提現之前，讓用戶獲得一次性的獎勵，從而防止跨函數競爭條件攻擊。

在真實世界，智能合約不需要依賴於外部調用。事實上，外部調用在很多情況下，在工作環境中都幾乎不可能發生的。由於這個原因，使用互斥體來「鎖定」一些狀態，並且讓擁有者有能力去改變狀態，可以幫助防止這類災難。雖然互斥體非常有效，但是當用於多個合約的時候，都會變的很棘手。如果你使用互斥體來防止這類攻擊，你需要很仔細地確保沒有其他方法來鎖定，或者永遠不會釋放。如果使用互斥體的方法，在寫入智能合約的時候，你需要保證你完全理解潛在的危險。

contract mutexExample{ mapping (address => uint) private balances; bool private lockBalances; function deposit() payable public returns (bool) { /*check if lockBalances is unlocked before proceeding*/ require(!lockBalances);

/*lock, execute, unlock */ lockBalances = true; balances[msg.sender] += msg.value; lockBalances = false; return true; } function withdraw(uint amount) payable public returns (bool) {

/*check if lockBalances is unlocked before proceeding*/ require(!lockBalances && amount > 0 && balances[msg.sender] >= amount);

/*lock, execute, unlock*/ lockBalances = true; if (msg.sender.call(amount)()) { balances[msg.sender] -= amount; } lockBalances = false; return true; } }

以上，我們可以看到合約mutexExample()會有私人鎖定狀態，來實行deposit()函數功能和withdraw()函數。鎖定會防止用戶能夠在所有的初步調用完成之前，成功完成withdraw()調用，可以防止任何種類的跨函數競爭條件攻擊。

力量越大，責任越大。雖然區塊鏈和智能合約技術每天都在革新，但是風險依然很高。攻擊者從沒有放棄去尋找機會來攻擊這些合約。這取決於我們來保證，我們可以從之前項目的問題中學習經驗，來讓我們獲得成長。希望通過這篇文章，以及其他系列文章，你可以更明白智能合約攻擊。

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！