Solidityでセキュアなコードを書く 第3回

はじめに

今回の内容

ゴール

ターゲット

前提知識

典型的な攻撃

競合状態

リエントラント

// セキュアでないコード
mapping (address => uint) private userBalances;

function withdrawBalance() public {
    uint amountToWithdraw = userBalances[msg.sender];
    if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
    userBalances[msg.sender] = 0;
}

mapping (address => uint) private userBalances;

function withdrawBalance() public {
    uint amountToWithdraw = userBalances[msg.sender];
    userBalances[msg.sender] = 0;
    if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
}

　Cross-function競合状態

// セキュアでないコード
mapping (address => uint) private userBalances;

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

function withdrawBalance() public {
    uint amountToWithdraw = userBalances[msg.sender];
    if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
    userBalances[msg.sender] = 0;
}


　競合状態解決の落とし穴

// セキュアでないコード
mapping (address => uint) private userBalances;
mapping (address => bool) private claimedBonus;
mapping (address => uint) private rewardsForA;

function withdraw(address recipient) public {
    uint amountToWithdraw = userBalances[recipient];
    rewardsForA[recipient] = 0;
    if (!(recipient.call.value(amountToWithdraw)())) { throw; }
}

function getFirstWithdrawalBonus(address recipient) public {
    if (claimedBonus[recipient]) { throw; }

    rewardsForA[recipient] += 100;
    withdraw(recipient);
    claimedBonus[recipient] = true;
}

mapping (address => uint) private userBalances;
mapping (address => bool) private claimedBonus;
mapping (address => uint) private rewardsForA;

function untrustedWithdraw(address recipient) public {
    uint amountToWithdraw = userBalances[recipient];
    rewardsForA[recipient] = 0;
    if (!(recipient.call.value(amountToWithdraw)())) { throw; }
}

function untrustedGetFirstWithdrawalBonus(address recipient) public {
    if (claimedBonus[recipient]) { throw; } 

    claimedBonus[recipient] = true;
    rewardsForA[recipient] += 100;
    untrustedWithdraw(recipient);
}

// 注: これは基本的な例です。ミューテックスは実質的な競合状態や共有状態があるときに特に有効です。
mapping (address => uint) private balances;
bool private lockBalances;

function deposit() payable public returns (bool) {
    if (!lockBalances) {
        lockBalances = true;
        balances[msg.sender] += msg.value;
        lockBalances = false;
        return true;
    }
    throw;
}

function withdraw(uint amount) payable public returns (bool) {
    if (!lockBalances && amount > 0 && balances[msg.sender] >= amount) {
        lockBalances = true;

        if (msg.sender.call(amount)()) { // call(amount)は通常セキュアでありませんが、ミューテックスで危険性を取り除いています
          balances[msg.sender] -= amount;
        }

        lockBalances = false;
        return true;
    }
    throw;
}

// セキュアでないコード
contract StateHolder {
    uint private n;
    address private lockHolder;

    function getLock() {
        if (lockHolder != 0) { throw; }
        lockHolder = msg.sender;
    }

    function releaseLock() {
        lockHolder = 0;
    }

    function set(uint newState) {
        if (msg.sender != lockHolder) { throw; }
        n = newState;
    }
}

TOD/Front Running

タイムスタンプ依存

uint someVariable = now + 1;

if (now % 2 == 0) { // now はマイナーによって操作されることがあります。
}

if ((someVariable - 100) % 2 == 0) { // someValue はマイナーによって操作されることがあります。
}

整数のオーバーフローとアンダーフロー

mapping (address => uint256) public balanceOf;

// セキュアでないコード
function transfer(address _to, uint256 _value) {
    /* 送信者の残高があるかをチェック */
    if (balanceOf[msg.sender] < _value)
        throw;
    /* 残高を移動 */
    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value;
}

// セキュアなコード
function transfer(address _to, uint256 _value) {
    /* 送信者の残高があるかを確認し、受信者の残高がオーバーフローしないかをチェック*/
    if (balanceOf[msg.sender] < _value || balanceOf[_to] + _value < balanceOf[_to])
        throw;

    /* 残高を移動 */
    balanceOf[msg.sender] -= _value;
    balanceOf[_to] += _value;
}

予期しない throwでのDoS攻撃

// セキュアでないコード
contract Auction {
    address currentLeader;
    uint highestBid;

    function bid() payable {
        if (msg.value <= highestBid) { throw; }

        if (!currentLeader.send(highestBid)) { throw; } // old leader に返金を試み、失敗したらthrowする

        currentLeader = msg.sender;
        highestBid = msg.value;
    }
}


address[] private refundAddresses;
mapping (address => uint) public refunds;

// だめな例
function refundAll() public {
    for(uint x; x < refundAddresses.length; x++) { // 参加しているアドレス数に基づく任意の長さのイテレーション
        if(refundAddresses[x].send(refunds[refundAddresses[x]])) {
            throw; // 一つのアドレスへの送金が失敗するとすべての送金処理がロールバックされます
        }
    }
}


GasLimitでのDoS攻撃

struct Payee {
    address addr;
    uint256 value;
}
Payee payees[];
uint256 nextPayeeIndex;

function payOut() {
    uint256 i = nextPayeeIndex;
    while (i < payees.length && msg.gas > 200000) {
      payees[i].addr.send(payees[i].value);
      i++;
    }
    nextPayeeIndex = i;
}


コールスタックの深さを利用した攻撃

引用URL：

免責事項

ブロックチェーン学習に最適の書籍の紹介

会社紹介