8591bff45f
* WIP New Policy class * WIP pubsub * Update Signal tests * EVM support - Wip * EVM support - dependencies fixed * EVM support - fix decree merge * fix decode instrucion event * Fix small bugs in evm opcodes (too many arguments + wrong LOG name) (#380) Fix wrong call parameters + typo * Fix Create/Call * Fix depth * Default fixed point in arithmetic simplifier * small fixes from github comments * Fix event decode_instruction signature * wip wip * Auto tests for evm * New EVM tests * Ran 9556 FAILED (failures=166, errors=8, skipped=62) * Fix some arithmetic instructions * Ran 9556 FAILED (failures=136, errors=8, skipped=62) * More instructions - Optimizing symbolic memory * Added gas to opcodes description - FIX DELEGATECALL POPS * Add wip wallet example * The tests * Solidity constructors need argument after bytecode * Simple integer overflow working * Good merge * Good good merge * WIP manticore refactor * Fix default old-style initial state * context now working * Fix context serialization * Fix test models. Can not set a state constraints * typo * A few typos (constraints setter) and use of public properties in internal methods * Fix init wallet example * State __init__ needs to initialize platform constraints * Internal methods use internal properties * Better attack modeling * Better example layout * Storage backup on CALL is now faster .. and correct * Add LOG support * Minimal SE test * Added examples * Send ether bugfix * EVM: Fix wrong balance destination on CALL + decrease caller balance on CREATE * New balance management * Trying to maintain known hashes * Known hash concretization policy * CALLDATA max size bugfix * Minimal SE example * Remove evm tests * add -> enqueue * @m.init * Fix workspace url * Some test skipped * Ad Fixme to platform specific stuff in State * add -> enqueue * Enqueue created state * Fix m.init Use a messy hack to adhere to the spec (callback func receive 1 state argument) * Add _coverage_file ivar to Manticore * Fix symbolic files * remove extra enqueue * Fixing __main__ * comments * Fix visitors oddity * setup merged * remove duplicates and add pysha3 * Remove EVMTests import * Refactor platform specific code out of ManticoreOutput (#505) * Initial moving work * Clean * Make linux.generate_workspace_files work * Fix * clean * Add test * Test workspace for platform files * Skip EVM cpu pretty print * Remove bad import * Fix coverage.py for testing * Clean comment * Comment hack * Print evm cpu * pretty print evm world instead of platform * delet old scripts/examples * delet old tests * Remove z3 install script * Array.max_size can be None, include check for that * Rm unused _symbolic_files add_symbolic_files was moved to linux, so this is not needed * Rm unused args * Import evm * Rm dup function * Rm stray prints * Add docs for new classmethod apis * minimal * minimal example * fix minimal * Fair symbolic SHA3 handling * Simple mapping example * coverage example * fix tests * fix minimal * Some eko fixes * New SETH * integer_overflow refactored * Fixing the examples * init_bytecode -> init ' * Concrete reentrancy exampole * concrete reentrancy selfdestruct * Update minimal.py * It's a new Minimal * Integer overflow example * New minimal * minimal fix * Examples last minute fixes * Remove debug print * add plugin.py * Fixing event subscription * remove temp params * Remove param * Update uncovered will_exec callback prototype * Clean up debug output * Automatically generated intruction tests * Uninplemented instruction test removed * Unused concretization policy removed * Fixes enabling default bplugins * solc from PATH * Removed unused import * Logger name updated
2688 lines
111 KiB
Python
2688 lines
111 KiB
Python
|
|
import struct
|
|
import unittest
|
|
import json
|
|
from manticore.platforms import evm
|
|
from manticore.core import state
|
|
from manticore.core.smtlib import Operators, ConstraintSet
|
|
import os
|
|
|
|
|
|
class EVMTest_SHA3(unittest.TestCase):
|
|
_multiprocess_can_split_ = True
|
|
maxDiff=None
|
|
def _execute(self, new_vm):
|
|
last_returned = None
|
|
last_exception = None
|
|
try:
|
|
new_vm.execute()
|
|
except evm.Stop, e:
|
|
last_exception = "STOP"
|
|
except evm.NotEnoughGas:
|
|
last_exception = "OOG"
|
|
except evm.StackUnderflow:
|
|
last_exception = "INSUFICIENT STACK"
|
|
except evm.InvalidOpcode:
|
|
last_exception = "INVALID"
|
|
except evm.SelfDestruct:
|
|
last_exception = "SUICIDED"
|
|
except evm.Return as e:
|
|
last_exception = "RETURN"
|
|
last_returned = e.data
|
|
except evm.Revert:
|
|
last_exception = "REVERT"
|
|
|
|
return last_exception, last_returned
|
|
|
|
def test_SHA3_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=' '
|
|
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, 'OOG')
|
|
|
|
def test_SHA3_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=' '
|
|
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(0)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_3(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=' '
|
|
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(1)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_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=' '
|
|
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(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_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=' '
|
|
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(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_6(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=' '
|
|
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(16)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_7(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=' '
|
|
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(32)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_8(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=' '
|
|
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(48)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_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=' '
|
|
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(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_11(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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_15(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=' '
|
|
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)
|
|
new_vm._push(16)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_16(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=' '
|
|
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)
|
|
new_vm._push(32)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_17(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=' '
|
|
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)
|
|
new_vm._push(48)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_18(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=' '
|
|
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)
|
|
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, [89477152217924674838424037953991966239322087453347756267410168184682657981552L])
|
|
|
|
def test_SHA3_19(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=' '
|
|
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)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_20(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=' '
|
|
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)
|
|
new_vm._push(0)
|
|
new_vm.memory.write(0, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
|
|
|
|
def test_SHA3_21(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=' '
|
|
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)
|
|
new_vm._push(1)
|
|
new_vm.memory.write(1, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
|
|
|
|
def test_SHA3_22(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=' '
|
|
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)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_23(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=' '
|
|
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)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_24(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=' '
|
|
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)
|
|
new_vm._push(16)
|
|
new_vm.memory.write(16, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
|
|
|
|
def test_SHA3_25(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=' '
|
|
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)
|
|
new_vm._push(32)
|
|
new_vm.memory.write(32, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
|
|
|
|
def test_SHA3_26(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=' '
|
|
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)
|
|
new_vm._push(48)
|
|
new_vm.memory.write(48, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [38468488817986530247887777414678086216360049057372179296543030553902011157846L])
|
|
|
|
def test_SHA3_27(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=' '
|
|
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)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_28(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=' '
|
|
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)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_29(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=' '
|
|
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)
|
|
new_vm._push(0)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_30(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=' '
|
|
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)
|
|
new_vm._push(1)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_31(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=' '
|
|
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)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_32(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=' '
|
|
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)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_33(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=' '
|
|
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)
|
|
new_vm._push(16)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_34(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=' '
|
|
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)
|
|
new_vm._push(32)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_35(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=' '
|
|
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)
|
|
new_vm._push(48)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_36(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=' '
|
|
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)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_37(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=' '
|
|
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)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_38(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=' '
|
|
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)
|
|
new_vm._push(0)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_39(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=' '
|
|
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)
|
|
new_vm._push(1)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_40(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=' '
|
|
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)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_41(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=' '
|
|
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)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_42(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=' '
|
|
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)
|
|
new_vm._push(16)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_43(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=' '
|
|
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)
|
|
new_vm._push(32)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_44(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=' '
|
|
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)
|
|
new_vm._push(48)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_45(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=' '
|
|
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)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_46(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=' '
|
|
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(16)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_47(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=' '
|
|
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(16)
|
|
new_vm._push(0)
|
|
new_vm.memory.write(0, [88])
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
|
|
|
|
def test_SHA3_48(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=' '
|
|
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(16)
|
|
new_vm._push(1)
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
new_vm.memory.write(16, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
|
|
|
|
def test_SHA3_49(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=' '
|
|
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(16)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_50(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=' '
|
|
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(16)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_51(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=' '
|
|
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(16)
|
|
new_vm._push(16)
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
|
|
|
|
def test_SHA3_52(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=' '
|
|
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(16)
|
|
new_vm._push(32)
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
|
|
|
|
def test_SHA3_53(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=' '
|
|
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(16)
|
|
new_vm._push(48)
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [4734955612022241403446959571200475901047349850262219251209420455990604867461L])
|
|
|
|
def test_SHA3_54(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=' '
|
|
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(16)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_55(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=' '
|
|
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(32)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_56(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=' '
|
|
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(32)
|
|
new_vm._push(0)
|
|
new_vm.memory.write(0, [88])
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
|
|
|
|
def test_SHA3_57(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=' '
|
|
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(32)
|
|
new_vm._push(1)
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
new_vm.memory.write(32, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
|
|
|
|
def test_SHA3_58(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=' '
|
|
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(32)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_59(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=' '
|
|
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(32)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_60(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=' '
|
|
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(32)
|
|
new_vm._push(16)
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
|
|
|
|
def test_SHA3_61(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=' '
|
|
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(32)
|
|
new_vm._push(32)
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
|
|
|
|
def test_SHA3_62(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=' '
|
|
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(32)
|
|
new_vm._push(48)
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
new_vm.memory.write(64, [88])
|
|
new_vm.memory.write(65, [88])
|
|
new_vm.memory.write(66, [88])
|
|
new_vm.memory.write(67, [88])
|
|
new_vm.memory.write(68, [88])
|
|
new_vm.memory.write(69, [88])
|
|
new_vm.memory.write(70, [88])
|
|
new_vm.memory.write(71, [88])
|
|
new_vm.memory.write(72, [88])
|
|
new_vm.memory.write(73, [88])
|
|
new_vm.memory.write(74, [88])
|
|
new_vm.memory.write(75, [88])
|
|
new_vm.memory.write(76, [88])
|
|
new_vm.memory.write(77, [88])
|
|
new_vm.memory.write(78, [88])
|
|
new_vm.memory.write(79, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [55858784234176438416533633276923373318937222299816437706613930531814037745581L])
|
|
|
|
def test_SHA3_63(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=' '
|
|
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(32)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_64(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=' '
|
|
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(48)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_65(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=' '
|
|
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(48)
|
|
new_vm._push(0)
|
|
new_vm.memory.write(0, [88])
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
|
|
|
|
def test_SHA3_66(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=' '
|
|
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(48)
|
|
new_vm._push(1)
|
|
new_vm.memory.write(1, [88])
|
|
new_vm.memory.write(2, [88])
|
|
new_vm.memory.write(3, [88])
|
|
new_vm.memory.write(4, [88])
|
|
new_vm.memory.write(5, [88])
|
|
new_vm.memory.write(6, [88])
|
|
new_vm.memory.write(7, [88])
|
|
new_vm.memory.write(8, [88])
|
|
new_vm.memory.write(9, [88])
|
|
new_vm.memory.write(10, [88])
|
|
new_vm.memory.write(11, [88])
|
|
new_vm.memory.write(12, [88])
|
|
new_vm.memory.write(13, [88])
|
|
new_vm.memory.write(14, [88])
|
|
new_vm.memory.write(15, [88])
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
new_vm.memory.write(48, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
|
|
|
|
def test_SHA3_67(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=' '
|
|
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(48)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_68(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=' '
|
|
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(48)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_69(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=' '
|
|
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(48)
|
|
new_vm._push(16)
|
|
new_vm.memory.write(16, [88])
|
|
new_vm.memory.write(17, [88])
|
|
new_vm.memory.write(18, [88])
|
|
new_vm.memory.write(19, [88])
|
|
new_vm.memory.write(20, [88])
|
|
new_vm.memory.write(21, [88])
|
|
new_vm.memory.write(22, [88])
|
|
new_vm.memory.write(23, [88])
|
|
new_vm.memory.write(24, [88])
|
|
new_vm.memory.write(25, [88])
|
|
new_vm.memory.write(26, [88])
|
|
new_vm.memory.write(27, [88])
|
|
new_vm.memory.write(28, [88])
|
|
new_vm.memory.write(29, [88])
|
|
new_vm.memory.write(30, [88])
|
|
new_vm.memory.write(31, [88])
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
|
|
|
|
def test_SHA3_70(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=' '
|
|
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(48)
|
|
new_vm._push(32)
|
|
new_vm.memory.write(32, [88])
|
|
new_vm.memory.write(33, [88])
|
|
new_vm.memory.write(34, [88])
|
|
new_vm.memory.write(35, [88])
|
|
new_vm.memory.write(36, [88])
|
|
new_vm.memory.write(37, [88])
|
|
new_vm.memory.write(38, [88])
|
|
new_vm.memory.write(39, [88])
|
|
new_vm.memory.write(40, [88])
|
|
new_vm.memory.write(41, [88])
|
|
new_vm.memory.write(42, [88])
|
|
new_vm.memory.write(43, [88])
|
|
new_vm.memory.write(44, [88])
|
|
new_vm.memory.write(45, [88])
|
|
new_vm.memory.write(46, [88])
|
|
new_vm.memory.write(47, [88])
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
new_vm.memory.write(64, [88])
|
|
new_vm.memory.write(65, [88])
|
|
new_vm.memory.write(66, [88])
|
|
new_vm.memory.write(67, [88])
|
|
new_vm.memory.write(68, [88])
|
|
new_vm.memory.write(69, [88])
|
|
new_vm.memory.write(70, [88])
|
|
new_vm.memory.write(71, [88])
|
|
new_vm.memory.write(72, [88])
|
|
new_vm.memory.write(73, [88])
|
|
new_vm.memory.write(74, [88])
|
|
new_vm.memory.write(75, [88])
|
|
new_vm.memory.write(76, [88])
|
|
new_vm.memory.write(77, [88])
|
|
new_vm.memory.write(78, [88])
|
|
new_vm.memory.write(79, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
|
|
|
|
def test_SHA3_71(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=' '
|
|
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(48)
|
|
new_vm._push(48)
|
|
new_vm.memory.write(48, [88])
|
|
new_vm.memory.write(49, [88])
|
|
new_vm.memory.write(50, [88])
|
|
new_vm.memory.write(51, [88])
|
|
new_vm.memory.write(52, [88])
|
|
new_vm.memory.write(53, [88])
|
|
new_vm.memory.write(54, [88])
|
|
new_vm.memory.write(55, [88])
|
|
new_vm.memory.write(56, [88])
|
|
new_vm.memory.write(57, [88])
|
|
new_vm.memory.write(58, [88])
|
|
new_vm.memory.write(59, [88])
|
|
new_vm.memory.write(60, [88])
|
|
new_vm.memory.write(61, [88])
|
|
new_vm.memory.write(62, [88])
|
|
new_vm.memory.write(63, [88])
|
|
new_vm.memory.write(64, [88])
|
|
new_vm.memory.write(65, [88])
|
|
new_vm.memory.write(66, [88])
|
|
new_vm.memory.write(67, [88])
|
|
new_vm.memory.write(68, [88])
|
|
new_vm.memory.write(69, [88])
|
|
new_vm.memory.write(70, [88])
|
|
new_vm.memory.write(71, [88])
|
|
new_vm.memory.write(72, [88])
|
|
new_vm.memory.write(73, [88])
|
|
new_vm.memory.write(74, [88])
|
|
new_vm.memory.write(75, [88])
|
|
new_vm.memory.write(76, [88])
|
|
new_vm.memory.write(77, [88])
|
|
new_vm.memory.write(78, [88])
|
|
new_vm.memory.write(79, [88])
|
|
new_vm.memory.write(80, [88])
|
|
new_vm.memory.write(81, [88])
|
|
new_vm.memory.write(82, [88])
|
|
new_vm.memory.write(83, [88])
|
|
new_vm.memory.write(84, [88])
|
|
new_vm.memory.write(85, [88])
|
|
new_vm.memory.write(86, [88])
|
|
new_vm.memory.write(87, [88])
|
|
new_vm.memory.write(88, [88])
|
|
new_vm.memory.write(89, [88])
|
|
new_vm.memory.write(90, [88])
|
|
new_vm.memory.write(91, [88])
|
|
new_vm.memory.write(92, [88])
|
|
new_vm.memory.write(93, [88])
|
|
new_vm.memory.write(94, [88])
|
|
new_vm.memory.write(95, [88])
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, None)
|
|
self.assertEqual(new_vm.pc, 1)
|
|
self.assertEqual(new_vm.stack, [87315138422451183025224871972802370450373932520512056513148796263698858401046L])
|
|
|
|
def test_SHA3_72(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=' '
|
|
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(48)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_73(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=' '
|
|
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)
|
|
new_vm._push(115792089237316195423570985008687907853269984665640564039457584007913129639935L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_74(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=' '
|
|
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)
|
|
new_vm._push(0)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_75(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=' '
|
|
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)
|
|
new_vm._push(1)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_76(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=' '
|
|
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)
|
|
new_vm._push(57896044618658097711785492504343953926634992332820282019728792003956564819952L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_77(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=' '
|
|
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)
|
|
new_vm._push(3618502788666131106986593281521497120414687020801267626233049500247285301263L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_78(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=' '
|
|
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)
|
|
new_vm._push(16)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_79(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=' '
|
|
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)
|
|
new_vm._push(32)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_80(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=' '
|
|
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)
|
|
new_vm._push(48)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
def test_SHA3_81(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=' '
|
|
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)
|
|
new_vm._push(6089590155545428825848686802984512581899718912L)
|
|
last_exception, last_returned = self._execute(new_vm)
|
|
self.assertEqual(last_exception, 'OOG')
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|