def test_REVERT_10(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) caller = origin = 0x111111111111111111111111111111111111100 address = 0x222222222222222222222222222222222222200 balance = 0 code = b"" world.create_account(address=address) world.create_account(address=caller) price = 0 value = 10000 bytecode = b"\xfd" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = {"coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0} gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(0) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, "REVERT") self.assertEqual(new_vm.stack, [])
def test_POP_9(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = 'P' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(6089590155545428825848686802984512581899718912) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [])
def test_BALANCE_1(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0xffffffffffffffffffffffffffffffffffffffff balance = 0 code = b'' storage = {} world.create_account( address=address, balance=balance, code=code, storage=storage) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode=b'1' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_GASLIMIT_1(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"E" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_BALANCE_4(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0xfffffffffffffffffffffffffffffffffffffff0 balance = 0 code = b'' storage = {} world.create_account( address=address, balance=balance, code=code, storage=storage) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode=b'1' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_BALANCE_5(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0xf balance = 0 code = b'' storage = {} world.create_account( address=address, balance=balance, code=code, storage=storage) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode=b'1' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_ADDRESS_1(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '0' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [12179180311090857651697373605969025163799437824])
def test_PUSH_12(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode='k' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 13) self.assertEqual(new_vm.stack, [0])
def test_CALLCODE_2(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode='\xf2' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935) new_vm._push(0) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, 'INSUFFICIENT STACK') self.assertEqual(new_vm.gas, 999960)
def test_EXTCODESIZE_2(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x3030303030303030303030303030303030303030 balance = None code = b'' storage = {} world.create_account( address=address, balance=balance, code=code, storage=storage) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode=b';' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(0) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_addmod(self): """ (declare-fun BV () (_ BitVec 256)) (declare-fun BV_2 () (_ BitVec 256)) (declare-fun BV_1 () (_ BitVec 256)) (declare-fun a_1 () (_ BitVec 256))(assert (= a_1 (bvmul BV BV_1))) (declare-fun a_2 () (_ BitVec 512))(assert (= a_2 ((_ zero_extend 256) BV))) (declare-fun a_3 () (_ BitVec 512))(assert (= a_3 ((_ zero_extend 256) BV_1))) (declare-fun a_4 () (_ BitVec 512))(assert (= a_4 (bvmul a_2 a_3))) (declare-fun a_5 () (_ BitVec 512))(assert (= a_5 ((_ zero_extend 256) BV_2))) (declare-fun a_6 () (_ BitVec 512))(assert (= a_6 (bvsmod a_4 a_5))) (declare-fun a_7 () (_ BitVec 256))(assert (= a_7 ((_ extract 255 0) a_6))) (declare-fun a_8 () (_ BitVec 256))(assert (= a_8 (bvsmod a_1 BV_2))) (declare-fun a_9 () Bool)(assert (= a_9 (= a_7 a_8))) (assert (not a_9)) (check-sat) """ from manticore.platforms import evm from manticore.core.smtlib import ConstraintSet, Z3Solver, Operators constraints = ConstraintSet() address = 0x41414141414141414141 data = b"" caller = 0x42424242424242424242 value = 0 bytecode = "" vm = evm.EVM(constraints, address, data, caller, value, bytecode) self.assertEqual(vm.ADDMOD(12323, 2343, 20), 6) self.assertEqual(vm.ADDMOD(12323, 2343, 0), 0) A, B, C = ( 0x780000002090309A004201626B1400041D318000000200008A0080089C042DA7, 0xF000000740403F7007C012807BED003BE2CE800000060000FFFFBFF7E4087033, 0x338000080FFFFF64AAAACFFCF7DBFA408000000000000270120000001E7C2ACF, ) self.assertEqual( vm.ADDMOD(A, B, C), 23067954172474524581131069693479689311231082562138745684554374357070230297856, ) a, b, c = ( constraints.new_bitvec(256), constraints.new_bitvec(256), constraints.new_bitvec(256), ) constraints.add(a == A) constraints.add(b == B) constraints.add(c == C) result = vm.ADDMOD(a, b, c) # 0x32ffffd700d073ae080133f517d922bd000000000007f1611e003fffc9239d00 self.assertEqual( Z3Solver.instance().get_all_values(constraints, result), [ 0x32FFFFD700D073AE080133F517D922BD000000000007F1611E003FFFC9239D00 ], )
def test_mulmod(self): """ (declare-fun BV () (_ BitVec 256)) (declare-fun BV_2 () (_ BitVec 256)) (declare-fun BV_1 () (_ BitVec 256)) (declare-fun a_1 () (_ BitVec 256))(assert (= a_1 (bvmul BV BV_1))) (declare-fun a_2 () (_ BitVec 512))(assert (= a_2 ((_ zero_extend 256) BV))) (declare-fun a_3 () (_ BitVec 512))(assert (= a_3 ((_ zero_extend 256) BV_1))) (declare-fun a_4 () (_ BitVec 512))(assert (= a_4 (bvmul a_2 a_3))) (declare-fun a_5 () (_ BitVec 512))(assert (= a_5 ((_ zero_extend 256) BV_2))) (declare-fun a_6 () (_ BitVec 512))(assert (= a_6 (bvsmod a_4 a_5))) (declare-fun a_7 () (_ BitVec 256))(assert (= a_7 ((_ extract 255 0) a_6))) (declare-fun a_8 () (_ BitVec 256))(assert (= a_8 (bvsmod a_1 BV_2))) (declare-fun a_9 () Bool)(assert (= a_9 (= a_7 a_8))) (assert (not a_9)) (check-sat) """ from manticore.platforms import evm from manticore.core.smtlib import ConstraintSet, Z3Solver, Operators constraints = ConstraintSet() address = 0x41414141414141414141 data = b"" caller = 0x42424242424242424242 value = 0 bytecode = "" vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=23000) self.assertEqual(vm.MULMOD(12323, 2343, 20), 9) self.assertEqual(vm.MULMOD(12323, 2343, 0), 0) A, B, C = ( 110427941548649020598956093796432407239217743554726184882600387580788736, 1048576, 4194319, ) self.assertEqual(vm.MULMOD(A, B, C), 2423129) a, b, c = ( constraints.new_bitvec(256), constraints.new_bitvec(256), constraints.new_bitvec(256), ) constraints.add(a == A) constraints.add(b == B) constraints.add(c == C) result = vm.MULMOD(a, b, c) # 0x8000000000000000000000000000000000000000000000000000000082000011 self.assertEqual( Z3Solver.instance().get_all_values(constraints, result), [2423129])
def test_CALLCODE_4(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '\xf2' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 57896044618658097711785492504343953926634992332820282019728792003956564819952L ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, 'INSUFICIENT STACK') self.assertEqual(new_vm.gas, 999960)
def test_CALLCODE_5(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '\xf2' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 3618502788666131106986593281521497120414687020801267626233049500247285301263L ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, 'INSUFICIENT STACK') self.assertEqual(new_vm.gas, 999960)
def test_SLOAD_5(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = { 3618502788666131106986593281521497120414687020801267626233049500247285301263: 0 } world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push( 3618502788666131106986593281521497120414687020801267626233049500247285301263 ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_SLOAD_1(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = { 115792089237316195423570985008687907853269984665640564039457584007913129639935: 0 } world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935 ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_SLOAD_4(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = { 57896044618658097711785492504343953926634992332820282019728792003956564819952: 0 } world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push( 57896044618658097711785492504343953926634992332820282019728792003956564819952 ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def _make(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address=0x222222222222222222222222222222222222200 caller=origin=0x111111111111111111111111111111111111100 price=0 value=10000 bytecode=b'\x05' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) return constraints, world, new_vm
def test_SLOAD_2(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = 'T' storage = {0: 15589350798196297794172638215640352209663280458410L} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = 'T' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push(0) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [15589350798196297794172638215640352209663280458410L])
def test_SLOAD_3(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = 'T' storage = {1: 17148285878015927573589902037204387430629608504251L} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = 'T' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push(1) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [17148285878015927573589902037204387430629608504251L])
def test_DUP_10(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '\x81' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935L ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [ 115792089237316195423570985008687907853269984665640564039457584007913129639935L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L, 115792089237316195423570985008687907853269984665640564039457584007913129639935L ])
def test_DUP_14(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"\x81" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935 ) new_vm._push( 3618502788666131106986593281521497120414687020801267626233049500247285301263 ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual( new_vm.stack, [ 115792089237316195423570985008687907853269984665640564039457584007913129639935, 3618502788666131106986593281521497120414687020801267626233049500247285301263, 115792089237316195423570985008687907853269984665640564039457584007913129639935, ], )
def test_DUP_13(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"\x81" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push( 115792089237316195423570985008687907853269984665640564039457584007913129639935 ) new_vm._push( 57896044618658097711785492504343953926634992332820282019728792003956564819952 ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual( new_vm.stack, [ 115792089237316195423570985008687907853269984665640564039457584007913129639935, 57896044618658097711785492504343953926634992332820282019728792003956564819952, 115792089237316195423570985008687907853269984665640564039457584007913129639935, ], )
def test_BALANCE_9(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x111111111111111111111111111111111111100 balance = 1048576 code = '' storage = {} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '1' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push(6089590155545428825848686802984512581899718912L) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [1048576])
def test_SLOAD_2(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = {0: 15589350798196297794172638215640352209663280458410} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(0) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [15589350798196297794172638215640352209663280458410])
def test_SLOAD_3(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = {1: 17148285878015927573589902037204387430629608504251} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(1) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [17148285878015927573589902037204387430629608504251])
def test_SLOAD_9(self): # Make the constraint store constraints = ConstraintSet() # make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 balance = None code = b"T" storage = {6089590155545428825848686802984512581899718912: 0} world.create_account(address=address, balance=balance, code=code, storage=storage) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = b"T" data = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" header = { "coinbase": 0, "timestamp": 0, "number": 0, "difficulty": 0, "gaslimit": 0 } gas = 1000000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, gas=gas, world=world) new_vm._push(6089590155545428825848686802984512581899718912) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [0])
def test_jmpdest_check(self): ''' This test that jumping to a JUMPDEST in the operand of a PUSH should be treated as an INVALID instruction. https://github.com/trailofbits/manticore/issues/1169 ''' constraints = ConstraintSet() world = evm.EVMWorld(constraints) world.create_account( address=0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6, balance=100000000000000000000000, code=EVMAsm.assemble('PUSH1 0x5b\nPUSH1 0x1\nJUMP')) address = 0xf572e5295c57f15886f9b263e2f6d2d6c7b5ec6 price = 0x5af3107a4000 data = '' caller = 0xcd1722f3947def4cf144679da39c4c32bdc35681 value = 1000000000000000000 bytecode = world.get_code(address) gas = 100000 new_vm = evm.EVM(constraints, address, data, caller, value, bytecode, world=world, gas=gas) result = None returndata = '' try: while True: new_vm.execute() except evm.EndTx as e: result = e.result if e.result in ('RETURN', 'REVERT'): returndata = e.data self.assertEqual(result, 'THROW') self.assertEqual(new_vm.gas, 99992)
def test_DUP_4(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '\x80' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push( 57896044618658097711785492504343953926634992332820282019728792003956564819952L ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [ 57896044618658097711785492504343953926634992332820282019728792003956564819952L, 57896044618658097711785492504343953926634992332820282019728792003956564819952L ])
def test_DUP_5(self): #Make the constraint store constraints = ConstraintSet() #make the ethereum world state world = evm.EVMWorld(constraints) address = 0x222222222222222222222222222222222222200 caller = origin = 0x111111111111111111111111111111111111100 price = 0 value = 10000 bytecode = '\x80' data = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' header = { 'coinbase': 0, 'timestamp': 0, 'number': 0, 'difficulty': 0, 'gaslimit': 0, } gas = 1000000 new_vm = evm.EVM(constraints, address, origin, price, data, caller, value, bytecode, header, gas=gas, global_storage=world.storage) new_vm._push( 3618502788666131106986593281521497120414687020801267626233049500247285301263L ) last_exception, last_returned = self._execute(new_vm) self.assertEqual(last_exception, None) self.assertEqual(new_vm.pc, 1) self.assertEqual(new_vm.stack, [ 3618502788666131106986593281521497120414687020801267626233049500247285301263L, 3618502788666131106986593281521497120414687020801267626233049500247285301263L ])