With source code

process.py

@@ -0,0 +1,40 @@
+import os
+import csv
+
+
+# Read all csv files in ./csv folder and save them in a list
+csv_files = []
+for file in os.listdir('./csv'):
+    if file.endswith('.csv'):
+        csv_files.append(file)
+
+# Save list of files to a list variable
+contracts_list = os.listdir('./contracts')
+
+# For each csv file, create a folder with the same name under ./result
+for file in csv_files:
+    file_name = file.split('.')[0]
+    folder_name = './result/' + file_name
+    if not os.path.exists(folder_name):
+        os.makedirs(folder_name)
+
+    # Read the first column and save into a list variable
+    csv_file = open('./csv/' + file, 'r')
+    reader = csv.reader(csv_file)
+    first_column = []
+    for row in reader:
+        first_column.append(row[0])
+    csv_file.close()
+
+    # For each item in the first column, copy the corresponding file from ./contracts to the folder
+    for item in first_column:
+        item_name = item.split('/')[-1]
+
+        # copy the file starting with item_name from ./contracts to the folder. Ignore case.
+        for contract_file in contracts_list:
+            if contract_file.lower().startswith(item_name.lower()):
+                os.system('cp ./contracts/' + contract_file + ' ' + folder_name)
+                break
+
+        else:
+            print('Error: ' + item_name + ' not found in ./contracts')

result/A.Bugs_in_implementation/allowAnyone/0x0156888f51d68f858ac88aba45df699e2af2e4cc_VRToken.sol

@@ -0,0 +1,136 @@
+pragma solidity ^0.4.18;
+
+
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
+
+contract Token {
+
+    /// total amount of tokens
+    uint256 public totalSupply;
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return The balance
+    function balanceOf(address _owner) constant public returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) public returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
+
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of tokens to be approved for transfer
+    /// @return Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) public returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+
+/*
+You should inherit from StandardToken or, for a token like you would want to
+deploy in something like Mist, see HumanStandardToken.sol.
+(This implements ONLY the standard functions and NOTHING else.
+If you deploy this, you won't have anything useful.)
+
+Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
+.*/
+
+contract StandardToken is Token {
+
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        // Prevent transfer to 0x0 address.
+        require(_to != 0x0);
+        // Check if the sender has enough
+        require(balances[msg.sender] >= _value);
+        // Check for overflows
+        require(balances[_to] + _value > balances[_to]);
+
+        uint previousBalances = balances[msg.sender] + balances[_to];
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+        Transfer(msg.sender, _to, _value);
+        // Asserts are used to use static analysis to find bugs in your code. They should never fail
+        assert(balances[msg.sender] + balances[_to] == previousBalances);
+
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        /// same as above
+        require(_to != 0x0);
+        require(balances[_from] >= _value);
+        require(balances[_to] + _value > balances[_to]);
+
+        uint previousBalances = balances[_from] + balances[_to];
+        balances[_from] -= _value;
+        balances[_to] += _value;
+        allowed[_from][msg.sender] -= _value;
+        Transfer(_from, _to, _value);
+        assert(balances[_from] + balances[_to] == previousBalances);
+
+        return true;
+    }
+
+    function balanceOf(address _owner) constant public returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) public returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
+      return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances; /// balance amount of tokens for address
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+contract VRToken is StandardToken {
+
+    function () payable public {
+        //if ether is sent to this address, send it back.
+        //throw;
+        require(false);
+    }
+
+    string public constant name = "VRToken";   
+    string public constant symbol = "VRT";
+    uint256 private constant _INITIAL_SUPPLY = 25*10**26;
+    uint8 public decimals = 18;         
+    uint256 public totalSupply;            
+
+    function VRToken(
+    ) public {
+        // init
+        balances[msg.sender] = _INITIAL_SUPPLY;
+        totalSupply = _INITIAL_SUPPLY;
+
+    }
+
+    /* Approves and then calls the receiving contract */
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+}

result/A.Bugs_in_implementation/allowAnyone/0x14d9779b6585f3a7d4f768383b3cb030705dad2e_BAI20.sol

@@ -0,0 +1,131 @@
+pragma solidity ^0.4.18;
+
+interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
+
+/*
+You should inherit from TokenBase. This implements ONLY the standard functions obeys ERC20,
+and NOTHING else. If you deploy this, you won't have anything useful.
+
+Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20
+.*/
+contract ERC20 {
+
+    /// total amount of tokens
+    uint256 public totalSupply;
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return The balance
+    function balanceOf(address _owner) constant public returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) public returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
+
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of tokens to be approved for transfer
+    /// @return Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) public returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}
+
+contract TokenBase is ERC20 {
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        // Prevent transfer to 0x0 address.
+        require(_to != 0x0);
+        // Check if the sender has enough
+        require(balances[msg.sender] >= _value);
+        // Check for overflows
+        require(balances[_to] + _value > balances[_to]);
+
+        uint previousBalances = balances[msg.sender] + balances[_to];
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+        Transfer(msg.sender, _to, _value);
+        // Asserts are used to use static analysis to find bugs in your code. They should never fail
+        assert(balances[msg.sender] + balances[_to] == previousBalances);
+
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        /// same as above
+        require(_to != 0x0);
+        require(balances[_from] >= _value);
+        require(balances[_to] + _value > balances[_to]);
+
+        uint previousBalances = balances[_from] + balances[_to];
+        balances[_from] -= _value;
+        balances[_to] += _value;
+        allowed[_from][msg.sender] -= _value;
+        Transfer(_from, _to, _value);
+        assert(balances[_from] + balances[_to] == previousBalances);
+
+        return true;
+    }
+
+    function balanceOf(address _owner) constant public returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) public returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        Approval(msg.sender, _spender, _value);
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
+      return allowed[_owner][_spender];
+    }
+
+    mapping (address => uint256) balances; /// balance amount of tokens for address
+    mapping (address => mapping (address => uint256)) allowed;
+}
+
+contract BAI20 is TokenBase {
+
+    function () payable public {
+        //if ether is sent to this address, send it back.
+        //throw;
+        require(false);
+    }
+
+    string public constant name = "BAI2.0";
+    string public constant symbol = "BAI";
+    uint256 private constant _INITIAL_SUPPLY = 21000000000;
+    uint8 public decimals = 18;
+    uint256 public totalSupply;
+    string public version = "BAI2.0";
+
+    function BAI20(
+    ) public {
+        // init
+        totalSupply = _INITIAL_SUPPLY * 10 ** 18;
+        balances[msg.sender] = totalSupply;
+    }
+
+    /* Approves and then calls the receiving contract */
+    function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
+        tokenRecipient spender = tokenRecipient(_spender);
+        if (approve(_spender, _value)) {
+            spender.receiveApproval(msg.sender, _value, this, _extraData);
+            return true;
+        }
+    }
+}