Create a gist now

Instantly share code, notes, and snippets.

@withzombies /rattle.log Secret
Last active Mar 20, 2018

Embed
What would you like to do?
blackhat ethereum runtime bytecode rattle output
<SSA::Function _dispatch hash:0xffffffff ofs:0x0 blocks:[
<SSA::BasicBlock ofs:0x0 insns:[
MSTORE(#0x40, #0x60),
%0 = CALLDATASIZE(),
%1 = LT(%0, #0x4),
JUMPI(#0x62, %1),
]>,
<SSA::BasicBlock ofs:0xd insns:[
%2 = CALLDATALOAD(#0x0),
%3 = DIV(%2, #0x100000000000000000000000000000000000000000000000000000000),
%4 = AND(#0xFFFFFFFF, %3),
%5 = EQ(#0x41C0E1B5, %4),
METHODCALL(hash:0x41c0e1b5, %5),
]>,
<SSA::BasicBlock ofs:0x41 insns:[
%6 = EQ(#0xA840DDA9, %4),
METHODCALL(hash:0xa840dda9, %6),
]>,
<SSA::BasicBlock ofs:0x4c insns:[
%7 = EQ(#0xB69EF8A8, %4),
METHODCALL(hash:0xb69ef8a8, %7),
]>,
<SSA::BasicBlock ofs:0x57 insns:[
%8 = EQ(#0xF8626AF8, %4),
METHODCALL(hash:0xf8626af8, %8),
]>,
<SSA::BasicBlock ofs:0x62 insns:[
%9 = CALLVALUE(),
%a = SLOAD(#0x1),
%b = ADD(%a, %9),
SSTORE(#0x1, %b),
STOP(),
]>,
]>
<SSA::Function kill() hash:0x41c0e1b5 ofs:0x74 blocks:[
<SSA::BasicBlock ofs:0x74 insns:[
%0 = CALLVALUE(),
%1 = ISZERO(%0),
JUMPI(#0x7F, %1),
]>,
<SSA::BasicBlock ofs:0x7b insns:[
REVERT(#0x0, #0x0),
]>,
<SSA::BasicBlock ofs:0x7f insns:[
JUMP(#0x126),
]>,
<SSA::BasicBlock ofs:0x126 insns:[
%2 = SLOAD(#0x0),
%3 = EXP(#0x100, #0x0),
%4 = DIV(%2, %3),
%5 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %4),
%6 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %5),
%7 = CALLER(),
%8 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %7),
%9 = EQ(%8, %6),
%a = ISZERO(%9),
%b = ISZERO(%a),
JUMPI(#0x181, %b),
]>,
<SSA::BasicBlock ofs:0x17d insns:[
REVERT(#0x0, #0x0),
]>,
<SSA::BasicBlock ofs:0x181 insns:[
%c = SLOAD(#0x0),
%d = EXP(#0x100, #0x0),
%e = DIV(%c, %d),
%f = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %e),
%10 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %f),
SUICIDE(%10),
]>,
]>
<SSA::Function <unknown> hash:0xa840dda9 ofs:0x89 blocks:[
<SSA::BasicBlock ofs:0x89 insns:[
JUMP(#0x1BB),
]>,
<SSA::BasicBlock ofs:0x1bb insns:[
%0 = CALLVALUE(),
%1 = LT(%0, #0x8AC7230489E80000),
%2 = ISZERO(%1),
%3 = ISZERO(%2),
%4 = ISZERO(%3),
JUMPI(#0x1D4, %4),
]>,
<SSA::BasicBlock ofs:0x1d0 insns:[
REVERT(#0x0, #0x0),
]>,
<SSA::BasicBlock ofs:0x1d4 insns:[
%5 = CALLER(),
%6 = ADD(#0x0, #0x0),
%7 = EXP(#0x100, #0x0),
%8 = SLOAD(%6),
%9 = MUL(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %7),
%a = NOT(%9),
%b = AND(%a, %8),
%c = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %5),
%d = MUL(%c, %7),
%e = OR(%d, %b),
SSTORE(%6, %e),
%f = CALLVALUE(),
%10 = ADD(#0x1, #0x0),
SSTORE(%10, %f),
%11 = CALLVALUE(),
%12 = SLOAD(#0x1),
%13 = ADD(%12, %11),
SSTORE(#0x1, %13),
%14 = TIMESTAMP(),
MSTORE(#0x0, %14),
%15 = ADD(#0x20, #0x0),
MSTORE(%15, #0x2),
%16 = ADD(#0x20, %15),
%17 = SHA3(#0x0, %16),
%18 = ADD(#0x0, #0x0),
%19 = SLOAD(%18),
%1a = EXP(#0x100, #0x0),
%1b = DIV(%19, %1a),
%1c = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1b),
%1d = ADD(#0x0, %17),
%1e = EXP(#0x100, #0x0),
%1f = SLOAD(%1d),
%20 = MUL(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1e),
%21 = NOT(%20),
%22 = AND(%21, %1f),
%23 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %1c),
%24 = MUL(%23, %1e),
%25 = OR(%24, %22),
SSTORE(%1d, %25),
%26 = ADD(#0x0, #0x1),
%27 = SLOAD(%26),
%28 = ADD(#0x1, %17),
SSTORE(%28, %27),
%29 = SLOAD(#0x1),
%2a = MUL(#0x1, %29),
%2b = NOT(#0x0),
%2c = AND(%2b, %2a),
%2d = CALLVALUE(),
%2e = MUL(#0x1, %2d),
%2f = NOT(#0x0),
%30 = AND(%2f, %2e),
%31 = CALLER(),
%32 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %31),
%33 = MUL(#0x1, %32),
%34 = NOT(#0x0),
%35 = AND(%34, %33),
%36 = TIMESTAMP(),
%37 = MUL(#0x1, %36),
%38 = MLOAD(#0x40),
%39 = NOT(#0x0),
%3a = AND(%39, %37),
%3b = NOT(#0x0),
%3c = AND(%3b, %3a),
MSTORE(%38, %3c),
%3d = ADD(#0x20, %38),
%3e = MLOAD(#0x40),
%3f = SUB(%3d, %3e),
LOG3(%3e, %3f, %35, %30, %2c),
JUMP(#0x91),
]>,
<SSA::BasicBlock ofs:0x91 insns:[
STOP(),
]>,
]>
<SSA::Function balance() hash:0xb69ef8a8 ofs:0x93 blocks:[
<SSA::BasicBlock ofs:0x93 insns:[
%0 = CALLVALUE(),
%1 = ISZERO(%0),
JUMPI(#0x9E, %1),
]>,
<SSA::BasicBlock ofs:0x9a insns:[
REVERT(#0x0, #0x0),
]>,
<SSA::BasicBlock ofs:0x9e insns:[
JUMP(#0x30C),
]>,
<SSA::BasicBlock ofs:0x30c insns:[
%2 = SLOAD(#0x1),
JUMP(#0xA6),
]>,
<SSA::BasicBlock ofs:0xa6 insns:[
%3 = MLOAD(#0x40),
MSTORE(%3, %2),
%4 = ADD(#0x20, %3),
%5 = MLOAD(#0x40),
%6 = SUB(%4, %5),
RETURN(%5, %6),
]>,
]>
<SSA::Function <unknown> hash:0xf8626af8 ofs:0xbc blocks:[
<SSA::BasicBlock ofs:0xbc insns:[
%0 = CALLVALUE(),
%1 = ISZERO(%0),
JUMPI(#0xC7, %1),
]>,
<SSA::BasicBlock ofs:0xc3 insns:[
REVERT(#0x0, #0x0),
]>,
<SSA::BasicBlock ofs:0xc7 insns:[
%2 = CALLDATALOAD(#0x4),
%3 = ADD(#0x20, #0x4),
JUMP(#0x312),
]>,
<SSA::BasicBlock ofs:0x312 insns:[
MSTORE(#0x20, #0x2),
MSTORE(#0x0, %2),
%4 = SHA3(#0x0, #0x40),
%5 = ADD(#0x0, %4),
%6 = SLOAD(%5),
%7 = EXP(#0x100, #0x0),
%8 = DIV(%6, %7),
%9 = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %8),
%a = ADD(#0x1, %4),
%b = SLOAD(%a),
JUMP(#0xDD),
]>,
<SSA::BasicBlock ofs:0xdd insns:[
%c = MLOAD(#0x40),
%d = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %9),
%e = AND(#0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, %d),
MSTORE(%c, %e),
%f = ADD(#0x20, %c),
MSTORE(%f, %b),
%10 = ADD(#0x20, %f),
%11 = MLOAD(#0x40),
%12 = SUB(%10, %11),
RETURN(%11, %12),
]>,
]>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment