Add new examples:

 - missing constructor
 - unprotected function
 - wrong interface
Add DAO and Paritity Wallet source code

missing_constructor/Missing.sol

@@ -0,0 +1,25 @@
+pragma solidity ^0.4.15;
+
+contract Missing{
+    address private owner;
+
+    modifier onlyowner {
+        require(msg.sender==owner);
+        _;
+    }
+
+    // The name of the constructor should be Missing
+    // Anyone can call the IamMissing once the contract is deployed
+    function IamMissing()
+        public 
+    {
+        owner = msg.sender;
+    }
+
+    function withdraw() 
+        public 
+        onlyowner
+    {
+       owner.transfer(this.balance);
+    }
+}

missing_constructor/README.md

@@ -0,0 +1,11 @@
+# Unprotected function
+
+## Principle:
+- Wrong constructor name
+
+## Attack
+Anyone can call the function that was suppose to be the constructor, and changes the related state variables.
+
+## Known exploit
+[Rubixi](https://etherscan.io/address/0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code)
+- See `Rubixi_source_code/Rubixi.sol`: `DynamicPyramid` instead of `Rubixi`

missing_constructor/Rubixi_source_code/Rubixi.sol

@@ -0,0 +1,154 @@
+// 0xe82719202e5965Cf5D9B6673B7503a3b92DE20be#code
+
+contract Rubixi {
+
+        //Declare variables for storage critical to contract
+        uint private balance = 0;
+        uint private collectedFees = 0;
+        uint private feePercent = 10;
+        uint private pyramidMultiplier = 300;
+        uint private payoutOrder = 0;
+
+        address private creator;
+
+        //Sets creator
+        function DynamicPyramid() {
+                creator = msg.sender;
+        }
+
+        modifier onlyowner {
+                if (msg.sender == creator) _
+        }
+
+        struct Participant {
+                address etherAddress;
+                uint payout;
+        }
+
+        Participant[] private participants;
+
+        //Fallback function
+        function() {
+                init();
+        }
+
+        //init function run on fallback
+        function init() private {
+                //Ensures only tx with value of 1 ether or greater are processed and added to pyramid
+                if (msg.value < 1 ether) {
+                        collectedFees += msg.value;
+                        return;
+                }
+
+                uint _fee = feePercent;
+                //50% fee rebate on any ether value of 50 or greater
+                if (msg.value >= 50 ether) _fee /= 2;
+
+                addPayout(_fee);
+        }
+
+        //Function called for valid tx to the contract 
+        function addPayout(uint _fee) private {
+                //Adds new address to participant array
+                participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100));
+
+                //These statements ensure a quicker payout system to later pyramid entrants, so the pyramid has a longer lifespan
+                if (participants.length == 10) pyramidMultiplier = 200;
+                else if (participants.length == 25) pyramidMultiplier = 150;
+
+                // collect fees and update contract balance
+                balance += (msg.value * (100 - _fee)) / 100;
+                collectedFees += (msg.value * _fee) / 100;
+
+                //Pays earlier participiants if balance sufficient
+                while (balance > participants[payoutOrder].payout) {
+                        uint payoutToSend = participants[payoutOrder].payout;
+                        participants[payoutOrder].etherAddress.send(payoutToSend);
+
+                        balance -= participants[payoutOrder].payout;
+                        payoutOrder += 1;
+                }
+        }
+
+        //Fee functions for creator
+        function collectAllFees() onlyowner {
+                if (collectedFees == 0) throw;
+
+                creator.send(collectedFees);
+                collectedFees = 0;
+        }
+
+        function collectFeesInEther(uint _amt) onlyowner {
+                _amt *= 1 ether;
+                if (_amt > collectedFees) collectAllFees();
+
+                if (collectedFees == 0) throw;
+
+                creator.send(_amt);
+                collectedFees -= _amt;
+        }
+
+        function collectPercentOfFees(uint _pcent) onlyowner {
+                if (collectedFees == 0 || _pcent > 100) throw;
+
+                uint feesToCollect = collectedFees / 100 * _pcent;
+                creator.send(feesToCollect);
+                collectedFees -= feesToCollect;
+        }
+
+        //Functions for changing variables related to the contract
+        function changeOwner(address _owner) onlyowner {
+                creator = _owner;
+        }
+
+        function changeMultiplier(uint _mult) onlyowner {
+                if (_mult > 300 || _mult < 120) throw;
+
+                pyramidMultiplier = _mult;
+        }
+
+        function changeFeePercentage(uint _fee) onlyowner {
+                if (_fee > 10) throw;
+
+                feePercent = _fee;
+        }
+
+        //Functions to provide information to end-user using JSON interface or other interfaces
+        function currentMultiplier() constant returns(uint multiplier, string info) {
+                multiplier = pyramidMultiplier;
+                info = 'This multiplier applies to you as soon as transaction is received, may be lowered to hasten payouts or increased if payouts are fast enough. Due to no float or decimals, multiplier is x100 for a fractional multiplier e.g. 250 is actually a 2.5x multiplier. Capped at 3x max and 1.2x min.';
+        }
+
+        function currentFeePercentage() constant returns(uint fee, string info) {
+                fee = feePercent;
+                info = 'Shown in % form. Fee is halved(50%) for amounts equal or greater than 50 ethers. (Fee may change, but is capped to a maximum of 10%)';
+        }
+
+        function currentPyramidBalanceApproximately() constant returns(uint pyramidBalance, string info) {
+                pyramidBalance = balance / 1 ether;
+                info = 'All balance values are measured in Ethers, note that due to no decimal placing, these values show up as integers only, within the contract itself you will get the exact decimal value you are supposed to';
+        }
+
+        function nextPayoutWhenPyramidBalanceTotalsApproximately() constant returns(uint balancePayout) {
+                balancePayout = participants[payoutOrder].payout / 1 ether;
+        }
+
+        function feesSeperateFromBalanceApproximately() constant returns(uint fees) {
+                fees = collectedFees / 1 ether;
+        }
+
+        function totalParticipants() constant returns(uint count) {
+                count = participants.length;
+        }
+
+        function numberOfParticipantsWaitingForPayout() constant returns(uint count) {
+                count = participants.length - payoutOrder;
+        }
+
+        function participantDetails(uint orderInPyramid) constant returns(address Address, uint Payout) {
+                if (orderInPyramid <= participants.length) {
+                        Address = participants[orderInPyramid].etherAddress;
+                        Payout = participants[orderInPyramid].payout / 1 ether;
+                }
+        }
+}

unprotected_function/README.md

@@ -0,0 +1,10 @@
+# Unprotected function
+
+## Principle:
+- Missing modifier on a sensitive function
+
+
+## Known exploit
+[Parity Wallet](https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7)
+- See `initWallet` in `WalletLibrary_source_code/WalletLibrary.sol`
+

unprotected_function/Unprotected.sol

@@ -0,0 +1,30 @@
+pragma solidity ^0.4.15;
+
+contract Unprotected{
+    address private owner;
+
+    modifier onlyowner {
+        require(msg.sender==owner);
+        _;
+    }
+
+    function Unprotected()
+        public 
+    {
+        owner = msg.sender;
+    }
+
+    // This function should be protected
+    function changeOwner(address _newOwner) 
+        public
+    {
+       owner = _newOwner;
+    }
+
+    function changeOwner_fixed(address _newOwner) 
+        public 
+        onlyowner
+    {
+       owner = _newOwner;
+    }
+}

wrong_interface/Alice.sol

@@ -0,0 +1,18 @@
+
+pragma solidity ^0.4.15;
+
+contract Alice { 
+    int public val;
+
+    function set(int new_val){
+        val = new_val;
+    }
+
+    function set_fixed(int new_val){
+        val = new_val;
+    }
+
+    function(){
+        val = 1;
+    }
+}

wrong_interface/Bob.sol

@@ -0,0 +1,17 @@
+
+pragma solidity ^0.4.15;
+
+contract Alice { 
+    function set(uint); 
+    function set_fixed(int); 
+}
+
+contract Bob { 
+    function set(Alice c){ 
+        c.set(42); 
+    }
+
+    function set_fixed(Alice c){ 
+        c.set_fixed(42); 
+    } 
+}

wrong_interface/README.md

@@ -0,0 +1,76 @@
+# Wrong interface
+
+## Principle:
+- Wrong contract interface
+
+## Detail
+The interface is wrongly define. `Alice.set(uint)` takes an `uint` in `Bob.sol` and `Alice.set(int)` in `Alice.sol`.
+The id of the method from bob will be wrong, as a result bob will call the fallback function of alice.
+
+## Running example
+First, get the bytecode and the abi of the contracts:
+```̀bash 
+$ solc --bin Alice.sol
+6060604052341561000f57600080fd5b5b6101158061001f6000396000f300606060405236156051576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680633c6bb436146067578063a5d5e46514608d578063e5c19b2d1460ad575b3415605b57600080fd5b5b60016000819055505b005b3415607157600080fd5b607760cd565b6040518082815260200191505060405180910390f35b3415609757600080fd5b60ab600480803590602001909190505060d3565b005b341560b757600080fd5b60cb600480803590602001909190505060de565b005b60005481565b806000819055505b50565b806000819055505b505600a165627a7a723058207d0ad6d1ce356adf9fa0284c9f887bb4b912204886b731c37c2ae5d16aef19a20029
+$ solc --abi Alice.sol
+[{"constant":true,"inputs":[],"name":"val","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"new_val","type":"int256"}],"name":"set_fixed","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"new_val","type":"int256"}],"name":"set","outputs":[],"payable":false,"type":"function"},{"payable":false,"type":"fallback"}]
+
+
+$ solc --bin Bob.sol
+6060604052341561000f57600080fd5b5b6101f58061001f6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632801617e1461004957806390b2290e14610082575b600080fd5b341561005457600080fd5b610080600480803573ffffffffffffffffffffffffffffffffffffffff169060200190919050506100bb565b005b341561008d57600080fd5b6100b9600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610142565b005b8073ffffffffffffffffffffffffffffffffffffffff166360fe47b1602a6040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b151561012a57600080fd5b6102c65a03f1151561013b57600080fd5b5050505b50565b8073ffffffffffffffffffffffffffffffffffffffff1663a5d5e465602a6040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15156101b157600080fd5b6102c65a03f115156101c257600080fd5b5050505b505600a165627a7a72305820f8c9dcade78d92097c18627223a8583507e9331ef1e5de02640ffc2e731111320029
+$ solc --abi Bob.sol
+[{"constant":false,"inputs":[{"name":"c","type":"address"}],"name":"set","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"c","type":"address"}],"name":"set_fixed","outputs":[],"payable":false,"type":"function"}]
+```
+
+The following commands were tested on a private blockchain
+
+```javascript
+$ get attach
+
+// this unlock the account for a limited amount of time
+// if you have an error:
+// Error: authentication needed: password or unlock
+// you can to call unlockAccount again
+personal.unlockAccount(eth.accounts[0], "apasswordtochange")
+
+var bytecodeAlice = '0x6060604052341561000f57600080fd5b5b6101158061001f6000396000f300606060405236156051576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680633c6bb436146067578063a5d5e46514608d578063e5c19b2d1460ad575b3415605b57600080fd5b5b60016000819055505b005b3415607157600080fd5b607760cd565b6040518082815260200191505060405180910390f35b3415609757600080fd5b60ab600480803590602001909190505060d3565b005b341560b757600080fd5b60cb600480803590602001909190505060de565b005b60005481565b806000819055505b50565b806000819055505b505600a165627a7a723058207d0ad6d1ce356adf9fa0284c9f887bb4b912204886b731c37c2ae5d16aef19a20029'
+var abiAlice = [{"constant":true,"inputs":[],"name":"val","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"new_val","type":"int256"}],"name":"set_fixed","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"new_val","type":"int256"}],"name":"set","outputs":[],"payable":false,"type":"function"},{"payable":false,"type":"fallback"}]
+
+var bytecodeBob = '0x6060604052341561000f57600080fd5b5b6101f58061001f6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632801617e1461004957806390b2290e14610082575b600080fd5b341561005457600080fd5b610080600480803573ffffffffffffffffffffffffffffffffffffffff169060200190919050506100bb565b005b341561008d57600080fd5b6100b9600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610142565b005b8073ffffffffffffffffffffffffffffffffffffffff166360fe47b1602a6040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b151561012a57600080fd5b6102c65a03f1151561013b57600080fd5b5050505b50565b8073ffffffffffffffffffffffffffffffffffffffff1663a5d5e465602a6040518263ffffffff167c010000000000000000000000000000000000000000000000000000000002815260040180828152602001915050600060405180830381600087803b15156101b157600080fd5b6102c65a03f115156101c257600080fd5b5050505b505600a165627a7a72305820f8c9dcade78d92097c18627223a8583507e9331ef1e5de02640ffc2e731111320029'
+var abiBob = [{"constant":false,"inputs":[{"name":"c","type":"address"}],"name":"set","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"c","type":"address"}],"name":"set_fixed","outputs":[],"payable":false,"type":"function"}]
+
+var contractAlice = eth.contract(abiAlice); 
+var txDeployAlice = {from:eth.coinbase, data: bytecodeAlice, gas: 1000000}; 
+var contractPartialInstanceAlice = contractAlice.new(txDeployAlice); 
+
+// Wait to mine the block containing the transaction
+
+var alice = contractAlice.at(contractPartialInstanceAlice.address);
+
+var contractBob = eth.contract(abiBob); 
+var txDeployBob = {from:eth.coinbase, data: bytecodeBob, gas: 1000000}; 
+var contractPartialInstanceBob = contractBob.new(txDeployBob); 
+
+// Wait to mine the block containing the transaction
+
+var bob = contractBob.at(contractPartialInstanceBob.address);
+
+// From now, wait for each transaction to be mined before calling
+// the others transactions
+
+// print the default value of val: 0
+alice.val() 
+
+// call bob.set, as the interface is wrong, it will call
+// the fallback function of alice
+bob.set(alice.address, {from: eth.accounts[0]} )
+// print val: 1
+alice.val()
+
+// call the fixed version of the interface
+bob.set_fixed(alice.address, {from: eth.accounts[0]} )
+// print val: 42
+alice.val()
+```
+
+