CMDB>> ethereum-dasm>> 返回
项目作者： tintinweb

项目描述 ：
An ethereum evm bytecode disassembler and static/dynamic analysis tool
高级语言： Python
项目地址: git://github.com/tintinweb/ethereum-dasm.git
创建时间： 2016-07-13T22:17:51Z
项目社区：https://github.com/tintinweb/ethereum-dasm
开源协议：GNU General Public License v2.0
下载


ethereum-dasm

ethereum evm bytecode disassembler with static- and dynamic-analysis and function signature lookup

[https://github.com/ethereum/] [https://www.ethereum.org/]

windows

disassembles evm bytecode

asciicast

decompile a contract to pseudocode

asciicast

install

pip

  1. #> pip3 install "ethereum-dasm[mythril,abidecoder]"
  2. #> python3 -m ethereum_dasm --help # verify installation

code

  1. #> pip3 install -r requirements*.txt
  2. #> python3 setup.py install
  1. #> python3 -m ethereum_dasm -a 0x44919b8026f38d70437a8eb3be47b06ab1c3e4bf  # jusst to verify installation

usage

  1. Usage: ethereum_dasm.py [options]
  3.        example: ethereum_dasm.py [-L -F -v] <file_or_bytecode>
  4.                 ethereum_dasm.py [-L -F -v] # read from stdin
  5.                 ethereum_dasm.py [-L -F -a <address>] # fetch contract code from infura.io
  8. Options:
  9.   -h, --help            show this help message and exit
  10.   -v VERBOSITY, --verbosity=VERBOSITY
  11.                         available loglevels:
  12.                         critical,fatal,error,warning,warn,info,debug,notset
  13.                         [default: critical]
  14.   -L, --listing         disables table mode, outputs assembly only
  15.   -F, --no-online-lookup
  16.                         disable online function signature lookup
  17.   -a ADDRESS, --address=ADDRESS
  18.                         fetch contract bytecode from address
  19.   -C, --no-color        disable color mode (requires pip install colorama)
  20.   -A, --guess-abi       guess the ABI for that contract
  21.   -D, --no-dynamic-analysis
  22.                         disable dynamic analysis / symolic execution
  23.   -S, --no-static-analysis
  24.                         disable static analysis
  25.   -s, --simplify        simplify disassembly to human readable code
  26.   -x, --simplify-show-asm
  27.                         simplify: show or hide asm annotations in simplified
  28.                         code
  29.   -y, --simplify-show-unreachable
  30.                         simplify: show or hide annotations for unreachable
  31.                         instructions in simplified code
  32.   -n NETWORK, --network=NETWORK
  33.                         network for address lookup (default: mainnet, ropsten,
  34.                         rinkeby, kovan
  1. #> echo "0x12345678" | python3 -m ethereum_dasm
  2. #> python3 -m ethereum_dasm 0x12345678
  3. #> python3 -m ethereum_dasm ether_contract.evm
  4. #> python3 -m ethereum_dasm -a <contract address>
  5. #> python3 -m ethereum_dasm -a <contract address>  -A
  6. #> python3 -m ethereum_dasm -a <contract address>  --simplify [--simplify-show-asm, --simplify-show-unreachable]

features

  • disassemble evm bytecode
  • decompile evm bytecode to pseudocode
  • provide the path to the ethereum vm bytecode or the bytecode as an argument to evmdasm. Tries to read from stdin by default.
  • returns !=0 on errors
  • various output modes (-L to switch from table to listing mode)
  • color-mode
  • invalid opcodes are prefixed with UNKNOWN_
  • gas consumption for instruction
  • return value and arguments for instruction
  • basic jump/xref analysis
  • basicblocking
  • online function signature and method name lookup, operand annotations
  • payable modifier detection
  • dynamic analysis based on symbolic execution (depends on mythril)
  • ABI.json download (from etherchain.org)
  • ABI.json reconstruction from static analysis of the evm bytecode
  • main interface Contract().

examples

abi online lookup or reconstruction
#>python3 -m ethereum_dasm -a 0x44919b8026f38d70437a8eb3be47b06ab1c3e4bf -A

  1. # [....]
  2. [{'stateMutability': 'nonpayable', 'constant': False, 'type': 'function', 'name': 'enter', 'signature': '0x124c32a1', 'outputs': [{'type': 'bool', 'name': ''}], 'inputs': [{'type': 'bytes32', 'name': '_passcode'
  3. }, {'type': 'bytes8', 'name': '_gateKey'}], 'payable': False}, {'stateMutability': 'pure', 'constant': True, 'type': 'function', 'name': 'maxEntrants', 'signature': '0x60643652', 'outputs': [{'type': 'uint8', 'n
  4. ame': ''}], 'inputs': [], 'payable': False}, {'stateMutability': 'view', 'constant': True, 'type': 'function', 'name': 'totalEntrants', 'signature': '0x694463a2', 'outputs': [{'type': 'uint8', 'name': ''}], 'inp
  5. uts': [], 'payable': False}, {'stateMutability': 'nonpayable', 'constant': False, 'type': 'function', 'name': 'assignAll', 'signature': '0x90ae631d', 'outputs': [{'type': 'bool', 'name': ''}], 'inputs': [], 'pay
  6. able': False}, {'inputs': [], 'stateMutability': 'nonpayable', 'payable': False, 'type': 'constructor'}]

abi reconstruction from dasm if abi is not available
#> python3 -m ethereum_dasm -a 0x8f8bed23a644f3bbb4e227e28704c050e67c35be -A

  1. [{'signature': '0x95d89b41', 'outputs': [], 'stateMutability': None, 'name': 'symbol', 'constant': None, 'inputs': [], 'payable': True, 'type': 'function', 'address': 598}, {'signature': '0x095ea7b3', 'outputs':
  2.  [], 'stateMutability': None, 'name': 'approve', 'constant': None, 'inputs': ['bytes32', '<bytes??>'], 'payable': True, 'type': 'function', 'address': 328}, {'signature': '0x313ce567', 'outputs': [], 'stateMutab
  3. ility': None, 'name': 'decimals', 'constant': None, 'inputs': [], 'payable': True, 'type': 'function', 'address': 486}, {'signature': '0xdd62ed3e', 'outputs': [], 'stateMutability': None, 'name': 'allowance', 'c
  4. onstant': None, 'inputs': ['bytes32', '<bytes??>'], 'payable': True, 'type': 'function', 'address': 691}, {'signature': '0x66188463', 'outputs': [], 'stateMutability': None, 'name': 'decreaseApproval', 'constant
  5. ': None, 'inputs': ['bytes32', '<bytes??>'], 'payable': True, 'type': 'function', 'address': 529}, {'signature': '0x23b872dd', 'outputs': [], 'stateMutability': None, 'name': 'transferFrom', 'constant': None, 'i
  6. nputs': ['bytes32', 'bytes32', '<bytes??>'], 'payable': True, 'type': 'function', 'address': 423}, {'signature': '0x2ff2e9dc', 'outputs': [], 'stateMutability': None, 'name': 'INITIAL_SUPPLY', 'constant': None,
  7. 'inputs': [], 'payable': True, 'type': 'function', 'address': 465}, {'signature': '0x06fdde03', 'outputs': [], 'stateMutability': None, 'name': 'name', 'constant': None, 'inputs': [], 'payable': True, 'type': 'f
  8. unction', 'address': 190}, {'signature': '0x18160ddd', 'outputs': [], 'stateMutability': None, 'name': 'totalSupply', 'constant': None, 'inputs': [], 'payable': True, 'type': 'function', 'address': 384}, {'signa
  9. ture': '0x70a08231', 'outputs': [], 'stateMutability': None, 'name': 'balanceOf', 'constant': None, 'inputs': ['<bytes??>'], 'payable': True, 'type': 'function', 'address': 565}, {'signature': '0xa9059cbb', 'out
  10. puts': [], 'stateMutability': None, 'name': 'transfer', 'constant': None, 'inputs': [{'type': 'address', 'name': 'arg0'}, {'type': 'uint256', 'name': 'arg1'}], 'payable': True, 'type': 'function', 'address': 619
  11. }, {'signature': '0xd73dd623', 'outputs': [], 'stateMutability': None, 'name': 'increaseApproval', 'constant': None, 'inputs': ['bytes32', '<bytes??>'], 'payable': True, 'type': 'function', 'address': 655}]

detailed listing

python3 -m ethereum_dasm -a 0x44919b8026f38d70437a8eb3be47b06ab1c3e4bf -A --no-color

  1.   Inst   addr  hex    gas | mnemonic        operand                                               xrefs        description                                                           retval           args
  2. ------------------------------------------------------------------------------------------------  -----------  --------------------------------------------------------------------  ---------------  --------------------
  3. :loc_0x0
  4.      0 [   0 0x0000 ]   3 | PUSH1           0x60                                                               # Place 1 byte item on stack.                                         item
  5.      1 [   2 0x0002 ]   3 | PUSH1           0x40                                                               # Place 1 byte item on stack.                                         item
  6.      2 [   4 0x0004 ]   3 | MSTORE                                                                             # Save word to memory.                                                                 value, offset
  7.      3 [   5 0x0005 ]   3 | PUSH1           0x04                                                               # Place 1 byte item on stack.                                         item
  8.      4 [   7 0x0007 ]   2 | CALLDATASIZE                                                                       # Get size of input data in current environment.                      msg.data.length
  9.      5 [   8 0x0008 ]   3 | LT                                                                                 # Lesser-than comparison                                              flag             a, b
  10.      6 [   9 0x0009 ]   3 | PUSH2           0x0048                                                             # Place 2-byte item on stack.                                         item
  11.      7 [  12 0x000c ]  10 | JUMPI           @0x48                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  12.      8 [  13 0x000d ]   3 | PUSH4           0xffffffff                                                         # Place 4-byte item on stack.                                         item
  13.      9 [  18 0x0012 ]   3 | PUSH1           0xe0                                                               # Place 1 byte item on stack.                                         item
  14.     10 [  20 0x0014 ]   3 | PUSH1           0x02                                                               # Place 1 byte item on stack.                                         item
  15.     11 [  22 0x0016 ]  10 | EXP                                                                                # Exponential operation.                                              result           base, exponent
  16.     12 [  23 0x0017 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  17.     13 [  25 0x0019 ]   3 | CALLDATALOAD                                                                       # Get input data of current environment.                              msg.data         unknown
  18.     14 [  26 0x001a ]   5 | DIV                                                                                # Integer division operation.                                         result           a, b
  19.     15 [  27 0x001b ]   3 | AND                                                                                # Bitwise AND operation.                                              result           a, b
  20.     16 [  28 0x001c ]   3 | PUSH4           0x124c32a1  --> 'function enter(bytes32,bytes8)'                   # Place 4-byte item on stack.                                         item
  21.     17 [  33 0x0021 ]   3 | DUP2                                                                               # Duplicate 2nd stack item.
  22.     18 [  34 0x0022 ]   3 | EQ                                                                                 # Equality  comparison                                                flag             a, b
  23.     19 [  35 0x0023 ]   3 | PUSH2           0x004d                                                             # Place 2-byte item on stack.                                         item
  24.     20 [  38 0x0026 ]  10 | JUMPI           @0x4d                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  25.     21 [  39 0x0027 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  26.     22 [  40 0x0028 ]   3 | PUSH4           0x60643652  --> 'function maxEntrants()'                           # Place 4-byte item on stack.                                         item
  27.     23 [  45 0x002d ]   3 | EQ                                                                                 # Equality  comparison                                                flag             a, b
  28.     24 [  46 0x002e ]   3 | PUSH2           0x0095                                                             # Place 2-byte item on stack.                                         item
  29.     25 [  49 0x0031 ]  10 | JUMPI           @0x95                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  30.     26 [  50 0x0032 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  31.     27 [  51 0x0033 ]   3 | PUSH4           0x694463a2  --> 'function totalEntrants()'                         # Place 4-byte item on stack.                                         item
  32.     28 [  56 0x0038 ]   3 | EQ                                                                                 # Equality  comparison                                                flag             a, b
  33.     29 [  57 0x0039 ]   3 | PUSH2           0x00be                                                             # Place 2-byte item on stack.                                         item
  34.     30 [  60 0x003c ]  10 | JUMPI           @0xbe                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  35.     31 [  61 0x003d ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  36.     32 [  62 0x003e ]   3 | PUSH4           0x90ae631d  --> 'function assignAll()'                             # Place 4-byte item on stack.                                         item
  37.     33 [  67 0x0043 ]   3 | EQ                                                                                 # Equality  comparison                                                flag             a, b
  38.     34 [  68 0x0044 ]   3 | PUSH2           0x00d1                                                             # Place 2-byte item on stack.                                         item
  39.     35 [  71 0x0047 ]  10 | JUMPI           @0xd1                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  41. :loc_0x48
  42.     36 [  72 0x0048 ]   1 | JUMPDEST                                                              JUMPI@0xc    # Mark a valid destination for jumps.
  43.     37 [  73 0x0049 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  44.     38 [  75 0x004b ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  45.     39 [  76 0x004c ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  46. :loc_0x4d
  47.   /*******************************************************************
  48.     function enter(bytes32,bytes8)
  49.     payable: False
  50.     inputs: (2) ['bytes32', '<bytes??>']
  51.     potential signatures: ['enter(bytes32,bytes8)']
  52.   *******************************************************************/
  53.     40 [  77 0x004d ]   1 | JUMPDEST                                                              JUMPI@0x26   # Mark a valid destination for jumps.
  54.     41 [  78 0x004e ]   2 | CALLVALUE                                                                          # Get deposited value by the instruction/transaction responsible for  msg.value
  55.                                                                                                                  this execution.
  56.     42 [  79 0x004f ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  57.     43 [  80 0x0050 ]   3 | PUSH2           0x0058                                                             # Place 2-byte item on stack.                                         item
  58.     44 [  83 0x0053 ]  10 | JUMPI           @0x58                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  59.     45 [  84 0x0054 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  60.     46 [  86 0x0056 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  61.     47 [  87 0x0057 ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  62. :loc_0x58
  63.     48 [  88 0x0058 ]   1 | JUMPDEST                                                              JUMPI@0x53   # Mark a valid destination for jumps.
  64.     49 [  89 0x0059 ]   3 | PUSH2           0x0081                                                             # Place 2-byte item on stack.                                         item
  65.     50 [  92 0x005c ]   3 | PUSH1           0x04                                                               # Place 1 byte item on stack.                                         item
  66.     51 [  94 0x005e ]   3 | CALLDATALOAD                                                                       # Get input data of current environment.                              msg.data         unknown
  67.     52 [  95 0x005f ]   3 | PUSH24          0xffffffffffffffffffffffffffffffffffffffffffffffff                 # Place 24-byte item on stack.                                        item
  68.     53 [ 120 0x0078 ]   3 | NOT                                                                                # Bitwise NOT operation.                                              result           a, b
  69.     54 [ 121 0x0079 ]   3 | PUSH1           0x24                                                               # Place 1 byte item on stack.                                         item
  70.     55 [ 123 0x007b ]   3 | CALLDATALOAD                                                                       # Get input data of current environment.                              msg.data         unknown
  71.     56 [ 124 0x007c ]   3 | AND                                                                                # Bitwise AND operation.                                              result           a, b
  72.     57 [ 125 0x007d ]   3 | PUSH2           0x00e4                                                             # Place 2-byte item on stack.                                         item
  73.     58 [ 128 0x0080 ]   8 | JUMP            @0xe4                                                              # Alter the program counter.                                                           evm.pc
  75. :loc_0x81
  76.     59 [ 129 0x0081 ]   1 | JUMPDEST                                                                           # Mark a valid destination for jumps.
  77.     60 [ 130 0x0082 ]   3 | PUSH1           0x40                                                               # Place 1 byte item on stack.                                         item
  78.     61 [ 132 0x0084 ]   3 | MLOAD                                                                              # Load word from memory.                                                               offset
  79.     62 [ 133 0x0085 ]   3 | SWAP1                                                                              # Exchange 1st and 2nd stack items.
  80.     63 [ 134 0x0086 ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  81.     64 [ 135 0x0087 ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  82.     65 [ 136 0x0088 ]   3 | DUP2                                                                               # Duplicate 2nd stack item.
  83.     66 [ 137 0x0089 ]   3 | MSTORE                                                                             # Save word to memory.                                                                 value, offset
  84.     67 [ 138 0x008a ]   3 | PUSH1           0x20                                                               # Place 1 byte item on stack.                                         item
  85.     68 [ 140 0x008c ]   3 | ADD                                                                                # Addition operation.                                                 result           a, b
  86.     69 [ 141 0x008d ]   3 | PUSH1           0x40                                                               # Place 1 byte item on stack.                                         item
  87.     70 [ 143 0x008f ]   3 | MLOAD                                                                              # Load word from memory.                                                               offset
  88.     71 [ 144 0x0090 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  89.     72 [ 145 0x0091 ]   3 | SWAP2                                                                              # Exchange 1st and 3rd stack items.
  90.     73 [ 146 0x0092 ]   3 | SUB                                                                                # Subtraction operation.                                              result           a, b
  91.     74 [ 147 0x0093 ]   3 | SWAP1                                                                              # Exchange 1st and 2nd stack items.
  92.     75 [ 148 0x0094 ]   0 | RETURN                                                                             # Halt execution returning output data.                                                offset, size
  94. :loc_0x95
  95.   /*******************************************************************
  96.     function maxEntrants()
  97.     payable: False
  98.     inputs: (0) []
  99.     potential signatures: ['maxEntrants()']
  100.   *******************************************************************/
  101.     76 [ 149 0x0095 ]   1 | JUMPDEST                                                              JUMPI@0x31   # Mark a valid destination for jumps.
  102.     77 [ 150 0x0096 ]   2 | CALLVALUE                                                                          # Get deposited value by the instruction/transaction responsible for  msg.value
  103.                                                                                                                  this execution.
  104.     78 [ 151 0x0097 ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  105.     79 [ 152 0x0098 ]   3 | PUSH2           0x00a0                                                             # Place 2-byte item on stack.                                         item
  106.     80 [ 155 0x009b ]  10 | JUMPI           @0xa0                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  107.     81 [ 156 0x009c ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  108.     82 [ 158 0x009e ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  109.     83 [ 159 0x009f ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  110. :loc_0xa0
  111.     84 [ 160 0x00a0 ]   1 | JUMPDEST                                                              JUMPI@0x9b   # Mark a valid destination for jumps.
  112.     85 [ 161 0x00a1 ]   3 | PUSH2           0x00a8                                                             # Place 2-byte item on stack.                                         item
  113.     86 [ 164 0x00a4 ]   3 | PUSH2           0x0314                                                             # Place 2-byte item on stack.                                         item
  114.     87 [ 167 0x00a7 ]   8 | JUMP            @0x314                                                             # Alter the program counter.                                                           evm.pc
  116. :loc_0xa8
  117.     88 [ 168 0x00a8 ]   1 | JUMPDEST                                                                           # Mark a valid destination for jumps.
  118.     89 [ 169 0x00a9 ]   3 | PUSH1           0x40                                                               # Place 1 byte item on stack.                                         item
  119.     90 [ 171 0x00ab ]   3 | MLOAD                                                                              # Load word from memory.                                                               offset
  120.     91 [ 172 0x00ac ]   3 | PUSH1           0xff                                                               # Place 1 byte item on stack.                                         item
  121.     92 [ 174 0x00ae ]   3 | SWAP1                                                                              # Exchange 1st and 2nd stack items.
  122.     93 [ 175 0x00af ]   3 | SWAP2                                                                              # Exchange 1st and 3rd stack items.
  123.     94 [ 176 0x00b0 ]   3 | AND                                                                                # Bitwise AND operation.                                              result           a, b
  124.     95 [ 177 0x00b1 ]   3 | DUP2                                                                               # Duplicate 2nd stack item.
  125.     96 [ 178 0x00b2 ]   3 | MSTORE                                                                             # Save word to memory.                                                                 value, offset
  126.     97 [ 179 0x00b3 ]   3 | PUSH1           0x20                                                               # Place 1 byte item on stack.                                         item
  127.     98 [ 181 0x00b5 ]   3 | ADD                                                                                # Addition operation.                                                 result           a, b
  128.     99 [ 182 0x00b6 ]   3 | PUSH1           0x40                                                               # Place 1 byte item on stack.                                         item
  129.    100 [ 184 0x00b8 ]   3 | MLOAD                                                                              # Load word from memory.                                                               offset
  130.    101 [ 185 0x00b9 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  131.    102 [ 186 0x00ba ]   3 | SWAP2                                                                              # Exchange 1st and 3rd stack items.
  132.    103 [ 187 0x00bb ]   3 | SUB                                                                                # Subtraction operation.                                              result           a, b
  133.    104 [ 188 0x00bc ]   3 | SWAP1                                                                              # Exchange 1st and 2nd stack items.
  134.    105 [ 189 0x00bd ]   0 | RETURN                                                                             # Halt execution returning output data.                                                offset, size
  136. :loc_0xbe
  137.   /*******************************************************************
  138.     function totalEntrants()
  139.     payable: False
  140.     inputs: (0) []
  141.     potential signatures: ['totalEntrants()']
  142.   *******************************************************************/
  143.    106 [ 190 0x00be ]   1 | JUMPDEST                                                              JUMPI@0x3c   # Mark a valid destination for jumps.
  144.    107 [ 191 0x00bf ]   2 | CALLVALUE                                                                          # Get deposited value by the instruction/transaction responsible for  msg.value
  145.                                                                                                                  this execution.
  146.    108 [ 192 0x00c0 ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  147.    109 [ 193 0x00c1 ]   3 | PUSH2           0x00c9                                                             # Place 2-byte item on stack.                                         item
  148.    110 [ 196 0x00c4 ]  10 | JUMPI           @0xc9                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  149.    111 [ 197 0x00c5 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  150.    112 [ 199 0x00c7 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  151.    113 [ 200 0x00c8 ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  152. :loc_0xc9
  153.    114 [ 201 0x00c9 ]   1 | JUMPDEST                                                              JUMPI@0xc4   # Mark a valid destination for jumps.
  154.    115 [ 202 0x00ca ]   3 | PUSH2           0x00a8                                                             # Place 2-byte item on stack.                                         item
  155.    116 [ 205 0x00cd ]   3 | PUSH2           0x031a                                                             # Place 2-byte item on stack.                                         item
  156.    117 [ 208 0x00d0 ]   8 | JUMP            @0x31a                                                             # Alter the program counter.                                                           evm.pc
  158. :loc_0xd1
  159.   /*******************************************************************
  160.     function assignAll()
  161.     payable: False
  162.     inputs: (0) []
  163.     potential signatures: ['assignAll()']
  164.   *******************************************************************/
  165.    118 [ 209 0x00d1 ]   1 | JUMPDEST                                                              JUMPI@0x47   # Mark a valid destination for jumps.
  166.    119 [ 210 0x00d2 ]   2 | CALLVALUE                                                                          # Get deposited value by the instruction/transaction responsible for  msg.value
  167.                                                                                                                  this execution.
  168.    120 [ 211 0x00d3 ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  169.    121 [ 212 0x00d4 ]   3 | PUSH2           0x00dc                                                             # Place 2-byte item on stack.                                         item
  170.    122 [ 215 0x00d7 ]  10 | JUMPI           @0xdc                                                              # Conditionally alter the program counter.                                             evm.pc, condition
  171.    123 [ 216 0x00d8 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  172.    124 [ 218 0x00da ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  173.    125 [ 219 0x00db ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  174. :loc_0xdc
  175.    126 [ 220 0x00dc ]   1 | JUMPDEST                                                              JUMPI@0xd7   # Mark a valid destination for jumps.
  176.    127 [ 221 0x00dd ]   3 | PUSH2           0x0081                                                             # Place 2-byte item on stack.                                         item
  177.    128 [ 224 0x00e0 ]   3 | PUSH2           0x0320                                                             # Place 2-byte item on stack.                                         item
  178.    129 [ 227 0x00e3 ]   8 | JUMP            @0x320                                                             # Alter the program counter.                                                           evm.pc
  180. :loc_0xe4
  181.    130 [ 228 0x00e4 ]   1 | JUMPDEST                                                              JUMP@0x80    # Mark a valid destination for jumps.
  182.    131 [ 229 0x00e5 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  183.    132 [ 231 0x00e7 ]   2 | ORIGIN                                                                             # Get execution origination address.                                  tx.origin
  184.    133 [ 232 0x00e8 ]   3 | PUSH1           0x01                                                               # Place 1 byte item on stack.                                         item
  185.    134 [ 234 0x00ea ]   3 | PUSH1           0xa0                                                               # Place 1 byte item on stack.                                         item
  186.    135 [ 236 0x00ec ]   3 | PUSH1           0x02                                                               # Place 1 byte item on stack.                                         item
  187.    136 [ 238 0x00ee ]  10 | EXP                                                                                # Exponential operation.                                              result           base, exponent
  188.    137 [ 239 0x00ef ]   3 | SUB                                                                                # Subtraction operation.                                              result           a, b
  189.    138 [ 240 0x00f0 ]   3 | AND                                                                                # Bitwise AND operation.                                              result           a, b
  190.    139 [ 241 0x00f1 ]   2 | CALLER                                                                             # Get caller address.This is the address of the account that is       msg.sender
  191.                                                                                                                  directly responsible for this execution.
  192.    140 [ 242 0x00f2 ]   3 | PUSH1           0x01                                                               # Place 1 byte item on stack.                                         item
  193.    141 [ 244 0x00f4 ]   3 | PUSH1           0xa0                                                               # Place 1 byte item on stack.                                         item
  194.    142 [ 246 0x00f6 ]   3 | PUSH1           0x02                                                               # Place 1 byte item on stack.                                         item
  195.    143 [ 248 0x00f8 ]  10 | EXP                                                                                # Exponential operation.                                              result           base, exponent
  196.    144 [ 249 0x00f9 ]   3 | SUB                                                                                # Subtraction operation.                                              result           a, b
  197.    145 [ 250 0x00fa ]   3 | AND                                                                                # Bitwise AND operation.                                              result           a, b
  198.    146 [ 251 0x00fb ]   3 | EQ                                                                                 # Equality  comparison                                                flag             a, b
  199.    147 [ 252 0x00fc ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  200.    148 [ 253 0x00fd ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  201.    149 [ 254 0x00fe ]   3 | ISZERO                                                                             # Simple not operator                                                 flag             a
  202.    150 [ 255 0x00ff ]   3 | PUSH2           0x0107                                                             # Place 2-byte item on stack.                                         item
  203.    151 [ 258 0x0102 ]  10 | JUMPI           @0x107                                                             # Conditionally alter the program counter.                                             evm.pc, condition
  204.    152 [ 259 0x0103 ]   3 | PUSH1           0x00                                                               # Place 1 byte item on stack.                                         item
  205.    153 [ 261 0x0105 ]   3 | DUP1                                                                               # Duplicate 1st stack item.
  206.    154 [ 262 0x0106 ]   0 | REVERT                                                                             # throw an error                                                                       offset, size
  208. [...]
  210. :loc_0x5d5
  211.    954 [1493 0x05d5 ]   1 | JUMPDEST                                                              JUMPI@0x5c9  # Mark a valid destination for jumps.
  212.    955 [1494 0x05d6 ]   2 | POP                                                                                # Remove item from stack.                                                              #dummy
  213.    956 [1495 0x05d7 ]   3 | SWAP1                                                                              # Exchange 1st and 2nd stack items.
  214.    957 [1496 0x05d8 ]   8 | JUMP                                                                               # Alter the program counter.                                                           evm.pc
  215.    958 [1497 0x05d9 ]   0 | STOP                                                                               # Halts execution.
  216.    959 [1498 0x05da ] 750 | LOG1            0x65                                                               # Append log record with one topic.                                                    start, size, topic1
  217.    960 [1500 0x05dc ]   3 | PUSH3           0x7a7a72                                                           # Place 3-byte item on stack.                                         item
  218.    961 [1504 0x05e0 ]   2 | ADDRESS                                                                            # Get address of currently executing account.                         this.address
  219.    962 [1505 0x05e1 ]   2 | PC                                                                                 # Get the value of the program counter prior to the increment.        evm.pc
  220.    963 [1506 0x05e2 ]  30 | SHA3                                                                               # Compute Keccak-256 hash.                                            flag             offset, size
  221.    964 [1507 0x05e3 ]  -1 | UNKNOWN_0xf                                                                        # Invalid opcode
  222.    965 [1508 0x05e4 ]   3 | SWAP4                                                                              # Exchange 1st and 5th stack items.
  223.    966 [1509 0x05e5 ]   3 | SWAP14                                                                             # Exchange 1st and 15th stack items.
  224.    967 [1510 0x05e6 ]   2 | CALLDATASIZE                                                                       # Get size of input data in current environment.                      msg.data.length
  225.    968 [1511 0x05e7 ]  -1 | UNKNOWN_0xe1                                                                       # Invalid opcode
  226.    969 [1512 0x05e8 ]  -1 | UNKNOWN_0xcb                                                                       # Invalid opcode
  227.    970 [1513 0x05e9 ]   3 | PUSH22          0xc68ec825da862dc7082ea12aea89eb3783b2e0423cd2                     # Place 22-byte item on stack.                                        item
  228.    971 [1536 0x0600 ]  30 | SHA3                                                                               # Compute Keccak-256 hash.                                            flag             offset, size
  229.    972 [1537 0x0601 ]  -1 | UNKNOWN_0x28                                                                       # Invalid opcode
  230.    973 [1538 0x0602 ]   3 | PUSH16          0x0029                                                             # Place 16-byte item on stack.                                        item
  231. ==============================
  232. reconstructed ABI:
  233. [{'name': 'enter', 'stateMutability': 'nonpayable', 'signature': '0x124c32a1', 'payable': False, 'inputs': [{'name': '_passcode', 'type': 'bytes32'}, {'name': '_gateKey', 'type': 'bytes8'}], 'constant': False, 'type': 'function', 'outputs': [{'name': '', 'type': 'bool'}]}, {'name': 'maxEntrants', 'stateMutability': 'pure', 'signature': '0x60643652', 'payable': False, 'inputs': [], 'constant': True, 'type': 'function', 'outputs': [{'name': '', 'type': 'uint8'}]}, {'name': 'totalEntrants', 'stateMutability': 'view', 'signature': '0x694463a2', 'payable': False, 'inputs': [], 'constant': True, 'type': 'function', 'outputs': [{'name': '', 'type': 'uint8'}]}, {'name': 'assignAll', 'stateMutability': 'nonpayable', 'signature': '0x90ae631d', 'payable': False, 'inputs': [], 'constant': False, 'type': 'function', 'outputs': [{'name': '', 'type': 'bool'}]}, {'stateMutability': 'nonpayable', 'type': 'constructor', 'payable': False, 'inputs': []}]

decompile to pseudocode

python3 -m ethereum_dasm -a 0x44919b8026f38d70437a8eb3be47b06ab1c3e4bf --simplify #[--simplify-show-asm, --simplify-show-unreachable]

  2. ======================[simplified]
  4. :init
  5.         memory[0x40] = 0x60
  6.         if (Not(ULE(0x4, 1_calldatasize))) goto LOC_0x48
  7.         if (And(If(1_calldatasize <= 0x3, 0x0, 1_calldata[0x3]) == 0xa1,
  8.                 If(1_calldatasize <= 0x2, 0x0, 1_calldata[0x2]) == 0x32,
  9.                 If(1_calldatasize <= 0x1, 0x0, 1_calldata[0x1]) == 0x4c,
  10.                 If(1_calldatasize <= 0x0, 0x0, 1_calldata[0x0]) == 0x12)) goto function_enter (LOC_0x4d)
  11.         if (And(If(1_calldatasize <= 0x3, 0x0, 1_calldata[0x3]) == 0x52,
  12.                 If(1_calldatasize <= 0x2, 0x0, 1_calldata[0x2]) == 0x36,
  13.                 If(1_calldatasize <= 0x1, 0x0, 1_calldata[0x1]) == 0x64,
  14.                 If(1_calldatasize <= 0x0, 0x0, 1_calldata[0x0]) == 0x60)) goto function_maxEntrants (LOC_0x95)
  15.         if (And(If(1_calldatasize <= 0x3, 0x0, 1_calldata[0x3]) == 0xa2,
  16.                 If(1_calldatasize <= 0x2, 0x0, 1_calldata[0x2]) == 0x63,
  17.                 If(1_calldatasize <= 0x1, 0x0, 1_calldata[0x1]) == 0x44,
  18.                 If(1_calldatasize <= 0x0, 0x0, 1_calldata[0x0]) == 0x69)) goto function_totalEntrants (LOC_0xbe)
  19.         if (And(If(1_calldatasize <= 0x3, 0x0, 1_calldata[0x3]) == 0x1d,
  20.                 If(1_calldatasize <= 0x2, 0x0, 1_calldata[0x2]) == 0x63,
  21.                 If(1_calldatasize <= 0x1, 0x0, 1_calldata[0x1]) == 0xae,
  22.                 If(1_calldatasize <= 0x0, 0x0, 1_calldata[0x0]) == 0x90)) goto function_assignAll (LOC_0xd1)
  24. :LOC_0x48 
  25.         REVERT(offset=0x0, size=0x0)
  26.         /******* <<terminates execution>> *******/
  28. :function_enter (LOC_0x4d) 
  29.   /*******************************************************************
  30.     function enter(bytes32,bytes8)
  31.     payable: False
  32.     inputs: (2) ['bytes32', '<bytes??>']
  33.     potential signatures: ['enter(bytes32,bytes8)']
  34.   *******************************************************************/
  36.         if (call_value1 == 0x0) goto LOC_0x58
  37.         REVERT(offset=0x0, size=0x0)
  38.         /******* <<terminates execution>> *******/
  40. :LOC_0x58 
  41.         goto LOC_0xe4
  43. :LOC_0x81 
  45. :function_maxEntrants (LOC_0x95) 
  46.   /*******************************************************************
  47.     function maxEntrants()
  48.     payable: False
  49.     inputs: (0) []
  50.     potential signatures: ['maxEntrants()']
  51.   *******************************************************************/
  53.         if (call_value1 == 0x0) goto LOC_0xa0
  54.         REVERT(offset=0x0, size=0x0)
  55.         /******* <<terminates execution>> *******/
  57. :LOC_0xa0 
  58.         goto LOC_0x314
  60. :LOC_0xa8 
  61.         memory[0x60] = 0xfa
  62.         RETURN(offset=0x60, size=0x20)
  63.         /******* <<terminates execution>> *******/
  65. :function_totalEntrants (LOC_0xbe) 
  66.   /*******************************************************************
  67.     function totalEntrants()
  68.     payable: False
  69.     inputs: (0) []
  70.     potential signatures: ['totalEntrants()']
  71.   *******************************************************************/
  73.         if (call_value1 == 0x0) goto LOC_0xc9
  74.         REVERT(offset=0x0, size=0x0)
  75.         /******* <<terminates execution>> *******/
  77. :LOC_0xc9 
  78.         goto LOC_0x31a
  80. :function_assignAll (LOC_0xd1) 
  81.   /*******************************************************************
  82.     function assignAll()
  83.     payable: False
  84.     inputs: (0) []
  85.     potential signatures: ['assignAll()']
  86.   *******************************************************************/
  88.         if (call_value1 == 0x0) goto LOC_0xdc
  89.         REVERT(offset=0x0, size=0x0)
  90.         /******* <<terminates execution>> *******/
  92. :LOC_0xdc 
  93.         goto LOC_0x320
  95. :LOC_0xe4 
  96.         if (Not(Extract(159, 0, origin1) ==
  97.                 0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef)) goto LOC_0x107
  98.         REVERT(offset=0x0, size=0x0)
  99.         /******* <<terminates execution>> *******/
  101. :LOC_0x107 
  102.         if (True) goto LOC_0x114
  104. :LOC_0x114 
  105.         if (bvurem_i(1_gas, 0x1fff) == 0x0) goto LOC_0x11f
  106.         REVERT(offset=0x0, size=0x0)
  107.         /******* <<terminates execution>> *******/
  109. :LOC_0x11f 
  110.         if (And(If(1_calldatasize <= 0x29, 0x0, 1_calldata[0x29]) == 0x0,
  111.                 If(1_calldatasize <= 0x28, 0x0, 1_calldata[0x28]) == 0x0)) goto LOC_0x154
  112.         REVERT(offset=0x0, size=0x0)
  113.         /******* <<terminates execution>> *******/
  115. :LOC_0x154 
  116.         if (Not(And(If(1_calldatasize <= 0x27, 0x0, 1_calldata[0x27]) ==
  117.                     0x0,
  118.                     If(1_calldatasize <= 0x26, 0x0, 1_calldata[0x26]) ==
  119.                     0x0,
  120.                     If(1_calldatasize <= 0x25, 0x0, 1_calldata[0x25]) ==
  121.                     0x0,
  122.                     If(1_calldatasize <= 0x24, 0x0, 1_calldata[0x24]) ==
  123.                     0x0))) goto LOC_0x18f
  124.         REVERT(offset=0x0, size=0x0)
  125.         /******* <<terminates execution>> *******/
  127. :LOC_0x18f 
  128.         if (And(Extract(7, 0, origin1) ==
  129.                 If(1_calldatasize <= 0x2b, 0x0, 1_calldata[0x2b]),
  130.                 Extract(15, 8, origin1) ==
  131.                 If(1_calldatasize <= 0x2a, 0x0, 1_calldata[0x2a]),
  132.                 If(1_calldatasize <= 0x29, 0x0, 1_calldata[0x29]) == 0x0,
  133.                 If(1_calldatasize <= 0x28, 0x0, 1_calldata[0x28]) == 0x0)) goto LOC_0x1c0
  134.         REVERT(offset=0x0, size=0x0)
  135.         /******* <<terminates execution>> *******/
  137. :LOC_0x1c0 
  138.         if (True) goto LOC_0x1d1
  140. :LOC_0x1d1 
  141.         memory[0x0] = 0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef
  142.         memory[0x20] = 0x3
  143.         if (True) goto LOC_0x1f7
  145. :LOC_0x1f7 
  146.         memory[0x0] = Concat(0x0, Extract(159, 0, origin1))
  147.         memory[0x20] = 0x3
  148.         if (True) goto LOC_0x21d
  150. :LOC_0x21d 
  151.         memory[0x60] = Concat(If(1_calldatasize <= 0x4, 0x0, 1_calldata[0x4]),
  152.                    If(1_calldatasize <= 0x5, 0x0, 1_calldata[0x5]),
  153.                    If(1_calldatasize <= 0x6, 0x0, 1_calldata[0x6]),
  154.                    If(1_calldatasize <= 0x7, 0x0, 1_calldata[0x7]),
  155.                    If(1_calldatasize <= 0x8, 0x0, 1_calldata[0x8]),
  156.                    If(1_calldatasize <= 0x9, 0x0, 1_calldata[0x9]),
  157.                    If(1_calldatasize <= 0xa, 0x0, 1_calldata[0xa]),
  158.                    If(1_calldatasize <= 0xb, 0x0, 1_calldata[0xb]),
  159.                    If(1_calldatasize <= 0xc, 0x0, 1_calldata[0xc]),
  160.                    If(1_calldatasize <= 0xd, 0x0, 1_calldata[0xd]),
  161.                    If(1_calldatasize <= 0xe, 0x0, 1_calldata[0xe]),
  162.                    If(1_calldatasize <= 0xf, 0x0, 1_calldata[0xf]),
  163.                    If(1_calldatasize <= 0x10, 0x0, 1_calldata[0x10]),
  164.                    If(1_calldatasize <= 0x11, 0x0, 1_calldata[0x11]),
  165.                    If(1_calldatasize <= 0x12, 0x0, 1_calldata[0x12]),
  166.                    If(1_calldatasize <= 0x13, 0x0, 1_calldata[0x13]),
  167.                    If(1_calldatasize <= 0x14, 0x0, 1_calldata[0x14]),
  168.                    If(1_calldatasize <= 0x15, 0x0, 1_calldata[0x15]),
  169.                    If(1_calldatasize <= 0x16, 0x0, 1_calldata[0x16]),
  170.                    If(1_calldatasize <= 0x17, 0x0, 1_calldata[0x17]),
  171.                    If(1_calldatasize <= 0x18, 0x0, 1_calldata[0x18]),
  172.                    If(1_calldatasize <= 0x19, 0x0, 1_calldata[0x19]),
  173.                    If(1_calldatasize <= 0x1a, 0x0, 1_calldata[0x1a]),
  174.                    If(1_calldatasize <= 0x1b, 0x0, 1_calldata[0x1b]),
  175.                    If(1_calldatasize <= 0x1c, 0x0, 1_calldata[0x1c]),
  176.                    If(1_calldatasize <= 0x1d, 0x0, 1_calldata[0x1d]),
  177.                    If(1_calldatasize <= 0x1e, 0x0, 1_calldata[0x1e]),
  178.                    If(1_calldatasize <= 0x1f, 0x0, 1_calldata[0x1f]),
  179.                    If(1_calldatasize <= 0x20, 0x0, 1_calldata[0x20]),
  180.                    If(1_calldatasize <= 0x21, 0x0, 1_calldata[0x21]),
  181.                    If(1_calldatasize <= 0x22, 0x0, 1_calldata[0x22]),
  182.                    If(1_calldatasize <= 0x23, 0x0, 1_calldata[0x23]))
  183.         memory[0x0] = KECCAC[If(1_calldatasize_<=_0x4,_0x0,_1_calldata[0x4])]
  184.         memory[0x20] = 0x4
  185.         if (False) goto LOC_0x257
  186.         REVERT(offset=0x0, size=0x0)
  187.         /******* <<terminates execution>> *******/
  189. :LOC_0x257 
  191. :LOC_0x275 
  193. :LOC_0x2d6 
  195. :LOC_0x314 
  197. :LOC_0x317 
  198.         goto LOC_0xa8
  200. :LOC_0x31a 
  201.         goto LOC_0xa8
  203. :LOC_0x320 
  204.         if (False) goto LOC_0x338
  205.         REVERT(offset=0x0, size=0x0)
  206.         /******* <<terminates execution>> *******/
  208. :LOC_0x338 
  210. :LOC_0x347 
  212. :LOC_0x3a8 
  214. :LOC_0x3b9 
  216. :LOC_0x3d8 
  218. :LOC_0x3e0 
  220. :LOC_0x3f5 
  222. :LOC_0x459 
  224. :LOC_0x46a 
  226. :LOC_0x4de 
  228. :LOC_0x541 
  230. :LOC_0x552 
  232. :LOC_0x556 
  234. :LOC_0x55e 
  236. :LOC_0x588 
  238. :LOC_0x592 
  240. :LOC_0x5b6 
  242. :LOC_0x5bb 
  244. :LOC_0x5c1 
  246. :LOC_0x5d5