Use SafeMath for arithmetic operations

contracts/attacks/CoinFlipAttack.sol

@@ -1,14 +1,17 @@
 pragma solidity ^0.4.18;
 
 import '../levels/CoinFlip.sol';
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
 
 contract CoinFlipAttack {
+
+  using SafeMath for uint256;
   uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
 
   function attack(address _victim) public returns (bool) {
     CoinFlip coinflip = CoinFlip(_victim);
-    uint256 blockValue = uint256(block.blockhash(block.number-1));
-    uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
+    uint256 blockValue = uint256(block.blockhash(block.number.sub(1)));
+    uint256 coinFlip = uint256(uint256(blockValue).div(FACTOR));
     bool side = coinFlip == 1 ? true : false;
     coinflip.flip(side);
     return side;

contracts/levels/CoinFlip.sol

@@ -1,6 +1,10 @@
 pragma solidity ^0.4.18;
 
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
+
 contract CoinFlip {
+
+  using SafeMath for uint256;
   uint256 public consecutiveWins;
   uint256 lastHash;
   uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
@@ -10,14 +14,14 @@ contract CoinFlip {
   }
 
   function flip(bool _guess) public returns (bool) {
-    uint256 blockValue = uint256(block.blockhash(block.number-1));
+    uint256 blockValue = uint256(block.blockhash(block.number.sub(1)));
 
     if (lastHash == blockValue) {
       revert();
     }
 
     lastHash = blockValue;
-    uint256 coinFlip = blockValue / FACTOR;
+    uint256 coinFlip = blockValue.div(FACTOR);
     bool side = coinFlip == 1 ? true : false;
 
     if (side == _guess) {

contracts/levels/Denial.sol

@@ -1,7 +1,10 @@
 pragma solidity ^0.4.24;
 
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
+
 contract Denial {
 
+    using SafeMath for uint256;
     address public partner; // withdrawal partner - pay the gas, split the withdraw
     address public constant owner = 0xA9E;
     uint timeLastWithdrawn;
@@ -13,14 +16,14 @@ contract Denial {
 
     // withdraw 1% to recipient and 1% to owner
     function withdraw() public {
-        uint amountToSend = address(this).balance/100;
+        uint amountToSend = address(this).balance.div(100);
         // perform a call without checking return
         // The recipient can revert, the owner will still get their share
         partner.call.value(amountToSend)();
         owner.transfer(amountToSend);
         // keep track of last withdrawal time
         timeLastWithdrawn = now;
-        withdrawPartnerBalances[partner] += amountToSend;
+        withdrawPartnerBalances[partner] = withdrawPartnerBalances[partner].add(amountToSend);
     }
 
     // allow deposit of funds

contracts/levels/Fallback.sol

@@ -1,9 +1,11 @@
 pragma solidity ^0.4.18;
 
 import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
 
 contract Fallback is Ownable {
-
+
+  using SafeMath for uint256;
   mapping(address => uint) public contributions;
 
   function Fallback() public {
@@ -12,7 +14,7 @@ contract Fallback is Ownable {
 
   function contribute() public payable {
     require(msg.value < 0.001 ether);
-    contributions[msg.sender] += msg.value;
+    contributions[msg.sender] = contributions[msg.sender].add(msg.value);
     if(contributions[msg.sender] > contributions[owner]) {
       owner = msg.sender;
     }

contracts/levels/Fallout.sol

@@ -1,9 +1,11 @@
 pragma solidity ^0.4.18;
 
 import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
 
 contract Fallout is Ownable {
-
+
+  using SafeMath for uint256;
   mapping (address => uint) allocations;
 
   /* constructor */
@@ -13,7 +15,7 @@ contract Fallout is Ownable {
   }
 
   function allocate() public payable {
-    allocations[msg.sender] += msg.value;
+    allocations[msg.sender] = allocations[msg.sender].add(msg.value);
   }
 
   function sendAllocation(address allocator) public {

contracts/levels/NaughtCoin.sol

@@ -3,12 +3,13 @@ pragma solidity ^0.4.18;
 import 'zeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
 
  contract NaughtCoin is StandardToken {
-
+
+  using SafeMath for uint256;
   string public constant name = 'NaughtCoin';
   string public constant symbol = '0x0';
   uint public constant decimals = 18;
   uint public timeLock = now + 10 years;
-  uint public INITIAL_SUPPLY = 1000000 * (10 ** decimals);
+  uint public INITIAL_SUPPLY = (10 ** decimals).mul(1000000);
   address public player;
 
   function NaughtCoin(address _player) public {

contracts/levels/Recovery.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.4.23;
 
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
+
 contract Recovery {
 
   //generate tokens
@@ -11,6 +13,7 @@ contract Recovery {
 
 contract SimpleToken {
 
+  using SafeMath for uint256;
   // public variables
   string public name;
   mapping (address => uint) public balances;
@@ -23,13 +26,13 @@ contract SimpleToken {
 
   // collect ether in return for tokens
   function() public payable {
-    balances[msg.sender] = msg.value*10;
+    balances[msg.sender] = msg.value.mul(10);
   }
 
   // allow transfers of tokens
   function transfer(address _to, uint _amount) public { 
     require(balances[msg.sender] >= _amount);
-    balances[msg.sender] -= _amount;
+    balances[msg.sender] = balances[msg.sender].sub(_amount);
     balances[_to] = _amount;
   }
 

contracts/levels/RecoverySimpleToken.sol

@@ -2,9 +2,11 @@
 pragma solidity ^0.4.23;
 
 import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
 
 contract RecoverySimpleToken {
 
+  using SafeMath for uint256;
   // public variables
   string public name;
   mapping (address => uint) public balances;
@@ -17,13 +19,13 @@ contract RecoverySimpleToken {
 
   // collect ether in return for tokens
   function () public payable {
-    balances[msg.sender] += msg.value*10;
+    balances[msg.sender] = balances[msg.sender].add(msg.value.mul(10));
   }
 
   // allow transfers of tokens
   function transfer(address _to, uint _amount) public { 
     require(balances[msg.sender] >= _amount);
-    balances[msg.sender] -= _amount;
+    balances[msg.sender] = balances[msg.sender].sub(_amount);
     balances[_to] = _amount;
   }
 

contracts/levels/Reentrance.sol

@@ -1,11 +1,14 @@
 pragma solidity ^0.4.18;
 
-contract Reentrance {
+import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
 
+contract Reentrance {
+
+  using SafeMath for uint256;
   mapping(address => uint) public balances;
 
   function donate(address _to) public payable {
-    balances[_to] += msg.value;
+    balances[_to] = balances[_to].add(msg.value);
   }
 
   function balanceOf(address _who) public view returns (uint balance) {