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
])
