Datasets:

nguyenminh871

/

multi_class_solidity_function_vulnerabilty

like 5

function bug_unchk_send16() payable public{ msg.sender.transfer(1 ether);}

buggy_38.sol

function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public { require(tx.origin == owner_txorigin2); _recipient.transfer(address(this).balance); }

buggy_30.sol

function transferFrom(address from, address to, uint256 value) public returns (bool) { _transfer(from, to, value); _approve(from, msg.sender, _allowed[from][msg.sender].sub(value)); return true; }

buggy_14.sol

function my_func_unchk23(address payable dst) public payable{ dst.send(msg.value); }

buggy_40.sol

function getcontractbalance() public view returns(uint) { return address(this).balance; }

buggy_50.sol

function cash_unchk22(uint roundIndex, uint subpotIndex, address payable winner_unchk22)public{ uint64 subpot_unchk22 = 10 ether; winner_unchk22.send(subpot_unchk22); //bug subpot_unchk22= 0; }

buggy_18.sol

function totalSupply() public view returns (uint256);

buggy_16.sol

function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;

buggy_48.sol

function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; }

buggy_11.sol

function transfer(address recipient, uint256 amount) external returns (bool);

buggy_30.sol

function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; }

buggy_27.sol

function bug_txorigin8(address owner_txorigin8) public{ require(tx.origin == owner_txorigin8); }

buggy_36.sol

constructor() public { address initialOwner = 0xac775cD446889ac167da466692449ece5439fc12; totalSupply = 180000000 * (10**uint256(decimals)); //initial token creation balances[initialOwner] = totalSupply; emit Transfer(address(0), initialOwner, balances[initialOwner]); }

buggy_32.sol

function symbol() public view returns (string memory) { return _symbol; }

buggy_23.sol

function Owned() { owner = msg.sender; }

0x84d9ec85c9c568eb332b7226a8f826d897e0a4a8.sol

function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external;

buggy_17.sol

function balanceOf(address account) external view returns(uint256);

buggy_21.sol

function symbol() public view returns(string memory) { return _symbol; }

buggy_27.sol

function totalSupply() external view returns (uint256);

buggy_23.sol

function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public { require(tx.origin == owner_txorigin10); _recipient.transfer(address(this).balance); }

buggy_11.sol

function transfer(address _to, uint _value) public returns (bool) { // <yes> <report> ARITHMETIC require(balances[msg.sender] - _value >= 0); // <yes> <report> ARITHMETIC balances[msg.sender] -= _value; balances[_to] += _value; return true; }

token.sol

function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) { require(source.length == 34, "length of source must be 34"); uint8 hashFunction = uint8(source[0]); uint8 digestSize = uint8(source[1]); bytes32 hash; assembly { hash := mload(add(source, 34)) } return (MultiHash({ hashFunction: hashFunction, digestSize: digestSize, hash: hash })); }

buggy_44.sol

function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public { require(balances_re_ent31[msg.sender] >= _weiToWithdraw); // limit the withdrawal require(msg.sender.send(_weiToWithdraw)); //bug balances_re_ent31[msg.sender] -= _weiToWithdraw; }

buggy_26.sol

function balanceOf(address _owner) view public returns (uint256) { return balances[_owner]; }

buggy_16.sol

function getInstanceRegistry() external view returns (address instanceRegistry);

buggy_44.sol

function newProposal( address destination, uint weiAmount, string memory transactionDescription, bytes memory transactionBytecode ) onlyTokenholders public returns (uint proposalID) { proposalID = proposals.length++; Proposal storage p = proposals[proposalID]; p.recipient = destination; p.signedByChairman = false; p.amount = weiAmount; p.description = transactionDescription; p.proposalHash = keccak256(abi.encodePacked(destination, weiAmount, transactionBytecode)); p.minExecutionDate = now + debatingPeriodInMinutes * 1 minutes; p.executed = false; p.proposalPassed = false; p.numberOfVotes = 0; emit ProposalAdded(proposalID, destination, weiAmount, transactionDescription); numProposals = proposalID+1; return proposalID; }

buggy_22.sol

function transfer(address to, uint256 value) public returns (bool success);

buggy_21.sol

function _burnFrom(address account, uint256 value) internal { _burn(account, value); _approve(account, msg.sender, _allowed[account][msg.sender].sub(value)); }

buggy_23.sol

function bug_unchk3(address payable addr) public {addr.send (42 ether); }

buggy_11.sol

function() external { revert(); }

buggy_32.sol

function setReward_TOD26() public payable { require (!claimed_TOD26); require(msg.sender == owner_TOD26); owner_TOD26.transfer(reward_TOD26); reward_TOD26 = msg.value; }

buggy_23.sol

function increaseLockTime_intou21(uint _secondsToIncrease) public { lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow }

buggy_5.sol

function joinFlexible() onlyOwner public{ require(msg.sender == owner, "only owner can use this method"); msg.sender.transfer(address(this).balance); }

buggy_19.sol

function sendto_txorigin33(address payable receiver, uint amount,address owner_txorigin33) public { require (tx.origin == owner_txorigin33); receiver.transfer(amount); }

buggy_19.sol

function bug_unchk_send32() payable public{ msg.sender.transfer(1 ether);}

buggy_32.sol

function transferOwnership(address _newOwner) public;

buggy_22.sol

function bug_txorigin40(address owner_txorigin40) public{ require(tx.origin == owner_txorigin40); }

buggy_18.sol

function increaseLockTime_intou37(uint _secondsToIncrease) public { lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow }

buggy_23.sol

function isMaster() public view returns (bool) { return msg.sender == _master; }

buggy_7.sol

function setReward_TOD36() public payable { require (!claimed_TOD36); require(msg.sender == owner_TOD36); owner_TOD36.transfer(reward_TOD36); reward_TOD36 = msg.value; }

buggy_39.sol

function claimReward_TOD36(uint256 submission) public { require (!claimed_TOD36); require(submission < 10); msg.sender.transfer(reward_TOD36); claimed_TOD36 = true; }

buggy_40.sol

function bug_intou35() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug }

buggy_24.sol

function bug_unchk3(address payable addr) public {addr.send (42 ether); }

buggy_38.sol

function transfer(address to, uint tokens) public returns(bool success);

buggy_18.sol

function buyTicket_re_ent9() public{ (bool success,) = lastPlayer_re_ent9.call.value(jackpot_re_ent9)(""); if (!success) revert(); lastPlayer_re_ent9 = msg.sender; jackpot_re_ent9 = address(this).balance; }

buggy_47.sol

function renounceOwnership() public;

buggy_22.sol

function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; }

buggy_35.sol

function bug_re_ent13() public{ require(not_called_re_ent13); (bool success,)=msg.sender.call.value(1 ether)(""); if( ! success ){ revert(); } not_called_re_ent13 = false; }

buggy_22.sol

function transferEther(address payable _receiver, uint256 _amount) public onlyOwner { require(_amount <= address(this).balance); emit TransferEther(address(this), _receiver, _amount); _receiver.transfer(_amount); }

buggy_16.sol

function my_func_unchk11(address payable dst) public payable{ dst.send(msg.value); }

buggy_22.sol

function play_tmstmp31(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp31 = msg.sender;}}

buggy_43.sol

function getReward_TOD39() payable public{ winner_TOD39.transfer(msg.value); }

buggy_44.sol

function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public { require (tx.origin == owner_txorigin1); receiver.transfer(amount); }

buggy_30.sol

function totalSupply() external view returns (uint256);

buggy_40.sol

function getReward_TOD23() payable public{ winner_TOD23.transfer(msg.value); }

buggy_29.sol

function transfer(address to, uint256 value) external returns (bool);

buggy_28.sol

function cash_unchk46(uint roundIndex, uint subpotIndex, address payable winner_unchk46) public{ uint64 subpot_unchk46 = 3 ether; winner_unchk46.send(subpot_unchk46); //bug subpot_unchk46= 0; }

buggy_4.sol

function bug_tmstmp13() view public returns (bool) { return block.timestamp >= 1546300800; }

buggy_6.sol

function mint(address _to, uint256 _amount) onlyOwner public returns (bool) { require(_totalSupply.add(_amount) <= cap); _totalSupply = _totalSupply.add(_amount); _balances[_to] = _balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; }

buggy_9.sol

function pause() public onlyPauser whenNotPaused { _paused = true; emit Paused(msg.sender); }

buggy_30.sol

function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; }

buggy_7.sol

function allowance(address owner, address spender) public view returns (uint256) { return _allowed[owner][spender]; }

buggy_14.sol

function callme_re_ent42() public{ require(counter_re_ent42<=5); if( ! (msg.sender.send(10 ether) ) ){ revert(); } counter_re_ent42 += 1; }

buggy_23.sol

function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue)); return true; }

buggy_34.sol

function bug_unchk_send10() payable public{ msg.sender.transfer(1 ether);}

buggy_12.sol

constructor( uint256 initialSupply, address[] memory defaultOperators ) ERC777("SKYBIT", "SKYBIT", defaultOperators) public { _mint(msg.sender, msg.sender, initialSupply, "", ""); }

buggy_30.sol

function getInstanceCreator(address instance) external view returns (address creator);

buggy_44.sol

function NewDanPanPercent(uint256 newDanPanpercent) external onlyOwner { emit DanPanPercentChanged(dpPercent, newDanPanpercent); dpPercent = newDanPanpercent; }

buggy_27.sol

contract TTC is Ownable, TokenERC20 { address winner_tmstmp19; function play_tmstmp19(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp19 = msg.sender;}} uint256 public sellPrice; address winner_tmstmp26; function play_tmstmp26(uint startTime) public { if (startTime + (5 * 1 days) == block.timestamp){ winner_tmstmp26 = msg.sender;}} uint256 public buyPrice; function bug_tmstmp20 () public payable { uint pastBlockTime_tmstmp20; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug pastBlockTime_tmstmp20 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } } mapping (address => bool) public frozenAccount; /* This generates a public event on the blockchain that will notify clients */ uint256 bugv_tmstmp4 = block.timestamp; event FrozenFunds(address target, bool frozen); /* Initializes contract with initial supply tokens to the creator of the contract */ constructor( uint256 initialSupply, string memory tokenName, string memory tokenSymbol ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {} function bug_tmstmp36 () public payable { uint pastBlockTime_tmstmp36; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp36); // only 1 transaction per block //bug pastBlockTime_tmstmp36 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } } /* Internal transfer, only can be called by this contract */ function _transfer(address _from, address _to, uint _value) internal { require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead require (balanceOf[_from] >= _value); // Check if the sender has enough require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows require(!frozenAccount[_from]); // Check if sender is frozen require(!frozenAccount[_to]); // Check if recipient is frozen balanceOf[_from] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient emit Transfer(_from, _to, _value); } address winner_tmstmp35; function play_tmstmp35(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp35 = msg.sender;}} /// @notice Create `mintedAmount` tokens and send it to `target` /// @param target Address to receive the tokens /// @param mintedAmount the amount of tokens it will receive function mintToken(address target, uint256 mintedAmount) onlyOwner public { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; emit Transfer(address(0), address(this), mintedAmount); emit Transfer(address(this), target, mintedAmount); } function bug_tmstmp40 () public payable { uint pastBlockTime_tmstmp40; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp40); // only 1 transaction per block //bug pastBlockTime_tmstmp40 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } } /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens /// @param target Address to be frozen /// @param freeze either to freeze it or not function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; emit FrozenFunds(target, freeze); } function bug_tmstmp33() view public returns (bool) { return block.timestamp >= 1546300800; } /// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth /// @param newSellPrice Price the users can sell to the contract /// @param newBuyPrice Price users can buy from the contract function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public { sellPrice = newSellPrice; buyPrice = newBuyPrice; } address winner_tmstmp27; function play_tmstmp27(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp27 = msg.sender;}} /// @notice Buy tokens from contract by sending ether function buy() payable public { uint amount = msg.value / buyPrice; // calculates the amount _transfer(address(this), msg.sender, amount); // makes the transfers } address winner_tmstmp31; function play_tmstmp31(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp31 = msg.sender;}} /// @notice Sell `amount` tokens to contract /// @param amount amount of tokens to be sold function sell(uint256 amount) public { address myAddress = address(this); require(myAddress.balance >= amount * sellPrice); // checks if the contract has enough ether to buy _transfer(msg.sender, address(this), amount); // makes the transfers msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks } function bug_tmstmp13() view public returns (bool) { return block.timestamp >= 1546300800; } }

buggy_5.sol

function callnotchecked_unchk25(address payable callee) public { callee.call.value(1 ether); }

buggy_30.sol

function bug_intou3() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug }

buggy_47.sol

function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public { require(tx.origin == owner_txorigin15); to.call.value(amount); }

buggy_18.sol

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; }

buggy_32.sol

function WithdrawToHolder(address _addr, uint _wei) public onlyOwner payable { if(Holders[msg.sender]>0) { if(Holders[_addr]>=_wei) { // <yes> <report> UNCHECKED_LL_CALLS _addr.call.value(_wei); Holders[_addr]-=_wei; } } }

0x39cfd754c85023648bf003bea2dd498c5612abfa.sol

function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; }

buggy_12.sol

function withdraw_balances_re_ent15 () public { if (msg.sender.send(balances_re_ent15[msg.sender ])) balances_re_ent15[msg.sender] = 0; }

buggy_30.sol

function bug_unchk_send15() payable public{ msg.sender.transfer(1 ether);}

buggy_24.sol

function setReward_TOD32() public payable { require (!claimed_TOD32); require(msg.sender == owner_TOD32); owner_TOD32.transfer(reward_TOD32); reward_TOD32 = msg.value; }

buggy_43.sol

function bug_txorigin20(address owner_txorigin20) public{ require(tx.origin == owner_txorigin20); }

buggy_36.sol

constructor (address _tokenAddress, address _relayer) public { relayer = _relayer; token = IERC20(_tokenAddress); }

buggy_31.sol

function burn(uint256 value) public { _burn(msg.sender, value); }

buggy_14.sol

function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public { require(balances_re_ent17[msg.sender] >= _weiToWithdraw); // limit the withdrawal (bool success,)=msg.sender.call.value(_weiToWithdraw)(""); require(success); //bug balances_re_ent17[msg.sender] -= _weiToWithdraw; }

buggy_44.sol

function bug_intou40(uint8 p_intou40) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou40; // overflow bug }

buggy_6.sol

function setPaused(bool value) external onlyContractOwner { paused = value; }

buggy_29.sol

function isActiveOperator(address caller) public view returns (bool ok) { return (isOperator(caller) && hasActiveOperator()); }

buggy_43.sol

function claimReward_TOD2(uint256 submission) public { require (!claimed_TOD2); require(submission < 10); msg.sender.transfer(reward_TOD2); claimed_TOD2 = true; }

buggy_48.sol

function bug_unchk_send22() payable public{ msg.sender.transfer(1 ether);}

buggy_12.sol

function play_TOD11(bytes32 guess) public{ if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) { winner_TOD11 = msg.sender; } }

buggy_27.sol

function callnotchecked_unchk25(address payable callee) public { callee.call.value(1 ether); }

buggy_28.sol

function bug_unchk_send3() payable public{ msg.sender.transfer(1 ether);}

buggy_12.sol

function initialize( address operator, bytes memory multihash, bytes memory metadata ) public initializeTemplate() { // set storage variables if (multihash.length != 0) { ProofHash._setProofHash(multihash); } // set operator if (operator != address(0)) { Operated._setOperator(operator); Operated._activateOperator(); } // set metadata if (metadata.length != 0) { EventMetadata._setMetadata(metadata); } // log initialization params emit Initialized(operator, multihash, metadata); }

buggy_43.sol

function transferFrom(address from, address to, uint tokens) public returns (bool success);

buggy_47.sol

function totalSupply() external view returns (uint256);

buggy_23.sol

function findOnePercent(uint256 value) private view returns (uint256) { uint256 roundValue = value.ceil(basePercent); uint256 onePercent = roundValue.mul(basePercent).div(10000); return onePercent; }

buggy_42.sol

function play_tmstmp39(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp39 = msg.sender;}}

buggy_35.sol

function increaseLockTime_intou9(uint _secondsToIncrease) public { lockTime_intou9[msg.sender] += _secondsToIncrease; //overflow }

buggy_19.sol

function () payable external{ revert(); }

buggy_26.sol

contract ERC20Interface { function totalSupply() public view returns (uint256); function callnotchecked_unchk1(address payable callee) public { callee.call.value(2 ether); } function balanceOf(address tokenOwner) public view returns (uint256 balance); function withdrawBal_unchk41 () public{ uint64 Balances_unchk41 = 0; msg.sender.send(Balances_unchk41);} function allowance(address tokenOwner, address spender) public view returns (uint256 remaining); function bug_unchk42() public{ uint receivers_unchk42; address payable addr_unchk42; if (!addr_unchk42.send(42 ether)) {receivers_unchk42 +=1;} else {revert();} } function transfer(address to, uint256 tokens) public returns (bool success); function unhandledsend_unchk2(address payable callee) public { callee.send(5 ether); } function approve(address spender, uint256 tokens) public returns (bool success); function bug_unchk43() public{ address payable addr_unchk43; if (!addr_unchk43.send (10 ether) || 1==1) {revert();} } function transferFrom(address from, address to, uint256 tokens) public returns (bool success); function my_func_uncheck48(address payable dst) public payable{ dst.call.value(msg.value)(""); } function UncheckedExternalCall_unchk40 () public { address payable addr_unchk40; if (! addr_unchk40.send (2 ether)) {// comment1; } else {//comment2; } } event Transfer(address indexed from, address indexed to, uint256 tokens); bool public payedOut_unchk33 = false; function withdrawLeftOver_unchk33() public { require(payedOut_unchk33); msg.sender.send(address(this).balance); } event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens); }

buggy_16.sol

function bug_tmstmp12 () public payable { uint pastBlockTime_tmstmp12; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug pastBlockTime_tmstmp12 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } }

buggy_27.sol

function setmanager(address payable newmngr) external onlyManager { require(newmngr.balance > 0); manager = newmngr; }

buggy_50.sol