viernes, mayo 26, 2023

Smart Contract Hacking Final Free Chapter - Hacking Games Via Bad Randomness Implementations On The Blockchain

This is our final free chapter in this smart contract hacking series, hopefully you enjoyed it, I am not sure what I am going to work on next, perhaps some malware analysis, reverse engineering or maybe some hacking in the cloud. 

We are currently in 4th quarter and slammed with work so I wouldn't expect any more posts or the full blockchain release till after that eases up.

If you have any questions or comments you can hit us up at: 

@ficti0n

http://cclabs.io 


Cryptographic Implementations and Predictable PRNGs

Within operations that require random values we generally need a form of randomness coupled with our algorithm. If we do not have sufficient randomness and large character sets, we would end up with cryptographic collisions or predictable values depending what we are doing. This Is often the case in video game operations and data security encryption schemes. For example, we do not want to create random values which are predictable and repeatable based on known values or controllable values. With controllable values an attacker could duplicate the value by reverse engineering how it was originally created and what that random seed is. Also, If the value is predictable within a game, we may be able to cheat the game by creating our own valid values that exploit the perceived randomness.

Now we are not going to deep dive into cracking cryptography or brute forcing hash values. First off it takes too much time and effort. Secondly because there are easier more efficient ways of tackling cryptographic issues. Lastly, we do not have time for rabbit holes in a week-long penetration test that require us to explore many other attack vectors. Wasting a whole week on cracking a single cryptographic issue would be a terrible and inefficient penetration test leaving the rest of the target vulnerable. This may be suitable for R&D or a CTF but not for a penetration test.  

What you need to understand is that certain functions often used as randomness on the blockchain is not suitable as a source of randomness. Additionally, understanding how things are implemented will get you much farther when it comes to cryptography then attacking it directly. You do not need to break NSA level encryption by attacking it directly. Instead you should concentrate on finding insecure implementations of these algorithms to get what you need.

Oracle padding attacks are a great example of this if you were in the hacking community back in the late 2000s. The padding attack relied on error messages based on padding within blocks to determine a way to decrypt them. This was a brilliant attack vector as you didn't need to understand deep cryptographic concepts to decrypt data blocks only how blocks work and how it was implemented.  With this knowledge you could leverage the flawed implementation to get the decrypted values.

On the blockchain there are a number of insecure functionality that developers like to use when implementing random values. Most of these are very bad ideas for reasons we will discuss below.  

For Example, the following non-exhaustive but often used list of values are not suitable for randomness within sensitive operations. Usage of these types of values for any sort of calculation is always suspect for closer review:

ü  Secret keys in private variables

ü  Block Timestamps

ü  Block Numbers

ü  Block Hash values

Why you ask? Well regardless of the data being set as private on the blockchain a private variable storage value is 100% readable on the blockchain. There are no secret values. These can be queried as you saw in the storage issues chapter. Also embedding hard coded values are certainly not private as they are in the source code which may be posted directly on the blockchain. Or could be reverse engineered out of the bytecode used to deploy the contract when the source code is not available. If you can get a hold of that value, then you can violate the security of that functionality.

Secondly do not rely on predictable values for randomness especially from block data sources. Block timestamps are controlled by miners which can aid in orchestrated attacks when used as a source of randomness. Also block numbers are easy to query and create predictable attacks when used in calculations, if internal functions are using a block number, they are all using the same PRNG. Finally, block hash values are terrible to use for randomness as only the last 256 block hash values on chain actually have a real value. Anything older than 256 is reduced to 0 meaning that every calculation will use the same value of 0. We will cover that in some of our examples.

This is not an exhaustive list but instead just a small portion of bad decisions for random values. There are plenty of other values which could be used within calculations as a random seed which are also predictable. It is always important to review the data used in these calculations when reviewing smart contract functionality. So, without the need of a PHD in cryptography you should easily discern that all of the above implementation examples are terrible for the inclusion of random data within cryptographic operations.

 

Simple BlockHash Example

Let's start out taking a look at a simple example of using a blockhash value with a blocknumber value. While a hash of a block might seem like a good idea as a random number there are numerous issues with it. Firstly, a blocknumber is a known value set by a miner that persists for a set length of time and can be queried and used in an attacker's similar algorithm to produce the same result and bypass controls. But there is also an underlying vulnerability to this approach when coupled with a blockchash which we will take a look at below.

Action Steps:

ü  Open up your terminal and launch ganache-cli

ü  Type out the code below into Remix

ü  Within the Deploy Environment section dropdown change the JavaScript VM to the web3 Provider option.

ü  Deploy the contract to ganache with the deploy button in Remix

 

 

1.    pragma solidity ^0.6.6;
2.   
3.    contract simpleVulnerableBlockHash {
4.           uint32 public block_number;
5.           bytes32 public myHash;
6.   
7.           function get_block_number() public  {   
8.                   block_number = uint32(block.number);
9.           }
10. 
11.  function set_hash() public{
12.                 myHash = bytes32(blockhash(block_number));
13.         }
14. 
15.  function wasteTime() public{
16.                 uint test = uint(block.number);
17.  }
18. }

 

The simple contract above is querying for the current block number in the get_block_number function on line 8 and storing it within a block_number variable created on line 4.  This is the current block number running on the blockchain.

Then we have a function on line 11 which takes the block number and uses it with the blockhash button to retrieve the blockhash and store it in the myHash variable.

 

BlockHash Vulnerability Walk and Talk:

 

Action Steps:

ü  Execute the get_block_number function

ü  Execute the set_hash function

ü  Check the block_number value

ü  Check the myHash value

ü  Execute the wasteTime function 256 times

ü  Execute the set_hash function

ü  Check your myHash Value

ü  What happened and what implications would this have on calculations your using this value with?

 

So, we have 2 variables of a block number and a block hash associated with that block number. What's the big deal. Well let's walk through this step by step and then play around with the remaining wasteTime function on line 15 to find out.

Starting out if we have the deployed contract and we execute the get_block_number function followed by the set_hash function we will get the following result when checking the block_number and myHash variables.

 


We see the blocknumber of 3 and then a hex value representing the block hash that starts with 0x995f. Now if we were to use this hash as a random value or within some algorithm to create a random value it might work depending what we were doing and the level of security required for the length of time we need it to be perceived as random for. It wouldn't be secure but maybe good enough for your operations.  However, a blockhash has a dark little secret a developer may not be aware of.  Block hashes in Ethereum have short term memory when it comes to blocks older than 256 from the current block.  

So, what happens when we calculate a block after a time lapse? Let's give that a try by executing the wasteTime button till we reach block 259.  Waste time sets a block value and discards it to enumerate blocks for us, it doesn't actually make any real changes. Normally blocks on the Ethereum network enumerate on their own every 30 seconds and we would simply just wait for 256 blocks, but we don't have traffic on our blockchain so we will enumerate it ourselves with wasteTime.

 


After we reach block 259 we execute the set_hash function again which will take block_number of 3 which is older than 256 blocks and get the hash. If you retrieve the myHash variable again after executing the set_hash function again it results in:

 


You will notice the myHash variable is now 0x000. because blocks older than 256 from the current block are not stored and result in a value of 0.  Having a predictable value of 0 in our random algorithm can very likely create a situation where it would be easy to recreate the random number to bypass or cheat functionality in the smart contract.


Video Walkthrough of Bad Randomness:




A classical terrible example is something similar to this.

1.  Function checkWinner() public payable { 
2.     If (blockhash(blockNumber) % 2 == 0) {
3.         Msg.sender.transfer(balance);
4.     }
5.  }

 

In the example above uses a blockhash function with a blockNumber variable within its calculation. The issue with this calculation is if that blockNumber variable is more than 256 blocks old it will return Zero and based on the calculation the user will win every single time.

All the attacker would need to do is play the game to create the blocknumber variable. Then the attacker would simply wait for 256 blocks to pass before checking if he has won the game. By doing this the attacker would guarantee a win. 

 

In order to see how this would work let's take a look at a simple game of chance that implements this concept.

Action Steps:

ü  Type out this code within remix

ü  Deploy the code using Ganache and Web3 options

ü  Try to locate the vulnerability within the code

ü  Try to exploit the vulnerability this code so that you are always the winner

1.  pragma solidity ^0.6.6;
2.   
3.  contract simpleVulnerableBlockHash {
4.      
5.      uint balance = 2 ether;
6.      mapping (address => uint) blockNumber;     
7.      bool public win; 
8.      
9.      constructor() public payable{
10.        require(msg.value >= 10 ether);
11.    }
12.    
13.    function get_block_number() internal  {   
14.        blockNumber[msg.sender] = uint(block.number);
15.    }
16.    
17.    function playGame() public payable {
18.        require (msg.value >= 1 ether);
19.        get_block_number();
20.    }
21.     
22.     
23.    function checkWinner() public payable { 
24.      if (uint(blockhash(blockNumber[msg.sender])) % 2 == 0) {
25.          win = true; 
26.             msg.sender.transfer(balance);
27.      }   else{
28.             win = false;
29.         }
30.    }
31.    
32.}

 After trying to exploit this vulnerability yourself review the following video which walks you through the code and how to exploit it.

Video Walkthrough of Attacking The Game:



 

Preventing Randomness Summary

The best way to prevent these issues is to avoid on chain predictable values or secret values as your seed to operations and calculations.  We can do this with trusted external Oracles.  Oracles are external data sources that your contract can use when it needs random values or trusted data.  There are projects that specifically solve this problem for example ChainLink which has networks of Oracle nodes that handle data queries and provide back trusted verified data including random numbers.  A simple example for using Chainlink for a random number is found at the following link:

https://docs.chain.link/docs/get-a-random-number

It is always a good idea to avoid on chain secret data or block related information when performing any sort of sensitive operation and instead utilize an Oracle.  

 

Bad Randomness References

https://docs.chain.link/docs/get-a-random-number

https://nvd.nist.gov/vuln/detail/CVE-2018-14715

More info


  1. Termux Hacking Tools 2019
  2. Hack Tools Online
  3. Hacking Tools Windows
  4. Tools For Hacker
  5. Hacker Tools Windows
  6. Hack Rom Tools
  7. Hack Tools Pc
  8. Hacking Apps
  9. Hack Tools Pc
  10. Hacker Tools Apk
  11. Bluetooth Hacking Tools Kali
  12. Pentest Recon Tools
  13. Hacker Search Tools
  14. Best Hacking Tools 2020
  15. Pentest Tools For Mac
  16. Hack Tools Online
  17. Hacking Tools And Software
  18. Hack Rom Tools
  19. Pentest Tools Online
  20. Pentest Tools For Windows
  21. What Is Hacking Tools
  22. Ethical Hacker Tools
  23. Pentest Tools
  24. Nsa Hacker Tools
  25. Hacking Tools Name
  26. Underground Hacker Sites
  27. Pentest Automation Tools
  28. Termux Hacking Tools 2019
  29. Hacking Tools For Windows 7
  30. New Hacker Tools
  31. Hack Tools Pc
  32. Pentest Tools
  33. Hack Tools For Ubuntu
  34. Hacking Tools Pc
  35. Hack Tools Github
  36. Hacking Tools For Windows 7
  37. Hack Tools 2019
  38. Kik Hack Tools
  39. Hack Rom Tools
  40. Pentest Tools For Ubuntu
  41. Pentest Tools Download
  42. Hack Tools For Mac
  43. Hak5 Tools
  44. Hack Tools Mac
  45. Pentest Tools Port Scanner
  46. Hacking Tools Download
  47. Hacking Tools Name
  48. Best Hacking Tools 2020
  49. Hack Tools
  50. Hacker Tools Github
  51. Pentest Tools For Mac
  52. Hacking Tools Windows 10
  53. Pentest Recon Tools
  54. Computer Hacker
  55. Pentest Tools Free
  56. Hacking Tools Kit
  57. Free Pentest Tools For Windows
  58. Hacker Tool Kit
  59. Github Hacking Tools
  60. How To Hack
  61. Hacking Tools Windows
  62. Pentest Tools For Mac
  63. Game Hacking
  64. Hacker Tools For Ios
  65. Hack Tools For Mac
  66. Hacker Tools Apk
  67. Hacking Tools Mac
  68. Pentest Tools Download
  69. Kik Hack Tools
  70. Hack Rom Tools
  71. Hack Tools Online
  72. Hacker Tools Linux
  73. Hacking Tools For Windows
  74. Pentest Tools Website Vulnerability
  75. Hacker Tools For Windows
  76. Hak5 Tools
  77. Hacking Tools Mac
  78. Bluetooth Hacking Tools Kali
  79. Pentest Recon Tools
  80. Hacking Tools For Pc
  81. Hacker Tools Github
  82. Hacking Tools And Software
  83. New Hacker Tools
  84. Pentest Box Tools Download
  85. Pentest Reporting Tools
  86. Hacking Tools For Games
  87. Pentest Tools Nmap
  88. Pentest Tools Tcp Port Scanner
  89. Nsa Hack Tools Download
  90. What Is Hacking Tools
  91. Hacker Tools Github
  92. Pentest Tools For Android
  93. Hacking Tools 2020
  94. Tools Used For Hacking
  95. Hacking Tools Windows
  96. Hacking Tools Github
  97. Hacker Tools Hardware
  98. Hacking Tools Mac
  99. Pentest Tools Subdomain
  100. Hacker Tools Apk
  101. What Are Hacking Tools
  102. Hacker Tools Apk
  103. Hacking App
  104. Hack Tools Mac
  105. Hacker Tools Apk Download
  106. Hacking Tools Name
  107. Hack Website Online Tool
  108. Pentest Tools Url Fuzzer
  109. Hack Tool Apk No Root
  110. Hack Rom Tools
  111. What Are Hacking Tools
  112. Hack Tools Download
  113. Hacker Tools Free
  114. Tools Used For Hacking
  115. Underground Hacker Sites
  116. Usb Pentest Tools
  117. Tools 4 Hack
  118. Pentest Tools Android
  119. Pentest Tools List
  120. Blackhat Hacker Tools
  121. Pentest Tools Kali Linux
  122. Ethical Hacker Tools
  123. Pentest Reporting Tools
  124. Hack Tools For Ubuntu
  125. Hacker Tools Github
  126. Hacking Tools And Software
  127. Hacker Tools List
  128. Hacking Tools Pc
  129. How To Hack

No hay comentarios: