def check_shake_result(self, data_text, expected):
hex_in_before = pyqrllib.bin2hstr(pyqrllib.str2bin(data_text))
data_out = pyqrllib.shake128(32, pyqrllib.str2bin(data_text))
# This is just to keep as an example. Things could be compared without converting to hex
hex_in = pyqrllib.bin2hstr(pyqrllib.str2bin(data_text))
hex_out = pyqrllib.bin2hstr(data_out)
self.assertEqual(hex_in, hex_in_before)
self.assertEqual(hex_out, expected)
def check_sha_n_result(self, data_text, expected, count):
hex_in_before = pyqrllib.bin2hstr(pyqrllib.str2bin(data_text))
data_out = pyqrllib.sha2_256_n(pyqrllib.str2bin(data_text), count)
# This is just to keep as an example. Things could be compared without converting to hex
hex_in = pyqrllib.bin2hstr(pyqrllib.str2bin(data_text))
hex_out = pyqrllib.bin2hstr(data_out)
self.assertEqual(hex_in_before, hex_in)
self.assertEqual(expected, hex_out)
def generate_headerhash(self):
# FIXME: This is using strings... fix
data = "{0}{1}{2}{3}{4}{5}{6}{7}{8}".format(
self.stake_selector, self.epoch, self.block_reward,
self.fee_reward, self.timestamp, self.block_number,
self.prev_blockheaderhash, self.tx_merkle_root, self.reveal_hash)
return bytes(sha2_256(str2bin(data)))
def mining_hash(self):
representation = "{0}{1}{2}{3}{4}{5}{6}{7}".format(
self.PK, self.epoch, self.block_reward, self.fee_reward,
self.timestamp, self.block_number, self.prev_hash,
self.tx_merkle_root)
# Add the nonce placeholder (4 bytes) to the beginning of the Block representation.
return "00000000" + bin2hstr(bytes(sha2_256(str2bin(representation))))
def test_register(self):
mr = MessageReceipt()
msg_hash = str2bin("asdf")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
def test_register(self):
mr = MessageReceipt()
msg_hash = str2bin("asdf")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
def __init__(self, tree_height, seed=None, _xmssfast=None):
"""
:param
tree_height: height of the tree to generate. number of OTS keypairs=2**tree_height
:param seed:
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getHeight()
4
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
132
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSignatureSize()
2308
>>> from qrl.crypto.doctest_data import *; len(XMSS(4, xmss_test_seed1)._xmss.getSK()) == XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPK() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSK() ) == xmss_sk_expected1
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getRoot() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPKSeed() )
'51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getIndex()
0
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKSeed() )
'5f2eb95ccf6a0e3e7f472c32d234340c20b3fd379dc28b710affcc0cb2afa57b'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKPRF() )
'3aa40c0f99459afe7efe72eb9517ee8ded49ccd51dab72ebf6bc37d73240bb3a'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getAddress('Q')
'Q1d651431536359202ce7095757e3ed66f579a6eab488ac1331486f207c91604016b6a443'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed2)._xmss.getPK() ) # doctest: +SKIP
''
"""
self._type = 'XMSS'
if _xmssfast is not None:
self._xmss = _xmssfast
self._seed = self._xmss.getSeed()
else:
# TODO: This is the old code, probably it should be removed
if seed is None:
# FIXME: Improve seed generation
self._seed = getRandomSeed(48, '')
else:
if isinstance(seed, str):
self._seed = str2bin(seed)
else:
self._seed = seed
self._xmss = XmssFast(self._seed, tree_height)
self.addresses = [(0, self.get_address(), self.get_number_signatures())
]
def test_contains(self):
mr = MessageReceipt()
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
self.assertTrue(mr.contains(msg_hash, msg_type))
def test_contains(self):
mr = MessageReceipt()
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
mr.register(msg_type, msg_hash, msg_obj)
self.assertTrue(mr.contains(msg_hash, msg_type))
def _get_hashable_bytes(self):
"""
This method should return bytes that are to be hashed and represent the transaction
:return: hashable bytes
:rtype: bytes
"""
# FIXME: Avoid all intermediate conversions
tmptxhash = str2bin(bin2hstr(sha2_256(bytes(self.subtype))))
return bytes(tmptxhash)
def __init__(self, tree_height, seed=None, _xmssfast=None):
"""
:param
tree_height: height of the tree to generate. number of OTS keypairs=2**tree_height
:param seed:
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getHeight()
4
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
132
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSignatureSize()
2308
>>> from qrl.crypto.doctest_data import *; len(XMSS(4, xmss_test_seed1)._xmss.getSK()) == XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPK() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSK() ) == xmss_sk_expected1
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getRoot() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPKSeed() )
'51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getIndex()
0
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKSeed() )
'5f2eb95ccf6a0e3e7f472c32d234340c20b3fd379dc28b710affcc0cb2afa57b'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKPRF() )
'3aa40c0f99459afe7efe72eb9517ee8ded49ccd51dab72ebf6bc37d73240bb3a'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getAddress('Q')
'Q1d651431536359202ce7095757e3ed66f579a6eab488ac1331486f207c91604016b6a443'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed2)._xmss.getPK() ) # doctest: +SKIP
''
"""
self._type = 'XMSS'
if _xmssfast is not None:
self._xmss = _xmssfast
self._seed = self._xmss.getSeed()
else:
# TODO: This is the old code, probably it should be removed
if seed is None:
# FIXME: Improve seed generation
self._seed = getRandomSeed(48, '')
else:
if isinstance(seed, str):
self._seed = str2bin(seed)
else:
self._seed = seed
self._xmss = XmssFast(self._seed, tree_height)
self.addresses = [(0, self.get_address(), self.get_number_signatures())]
def mining_hash(self):
data = "{0}{1}{2}{3}{4}{5}{6}{7}".format(self.PK,
self.epoch,
self.block_reward,
self.fee_reward,
self.timestamp,
self.block_number,
self.prev_blockheaderhash,
self.tx_merkle_root)
return bytes(sha2_256(str2bin(data)))
def generate_headerhash(self):
# FIXME: This is using strings... fix
data = "{0}{1}{2}{3}{4}{5}{6}{7}{8}".format(self.PK,
self.epoch,
self.block_reward,
self.fee_reward,
self.timestamp,
self.block_number,
self.prev_blockheaderhash,
self.tx_merkle_root,
self.mining_nonce)
return bytes(sha2_256(str2bin(data)))
def create(self,
blocknumber,
xmss,
slave_public_key,
hashchain_terminator=None,
first_hash=None,
balance=None):
"""
:param blocknumber:
:type blocknumber:
:param xmss:
:type xmss:
:param slave_public_key:
:type slave_public_key:
:param hashchain_terminator:
:type hashchain_terminator:
:param first_hash:
:type first_hash:
:param balance:
:type balance:
:return:
:rtype:
>>> s = StakeTransaction()
>>> slave = XMSS(4)
>>> isinstance(s.create(0, XMSS(4), slave.pk(), None, slave.pk(), 10), StakeTransaction)
True
"""
if not balance:
logger.info('Invalid Balance %d', balance)
raise Exception
self.slave_public_key = slave_public_key
self.epoch = blocknumber // config.dev.blocks_per_epoch # in this block the epoch is..
self.first_hash = first_hash
self.balance = balance
if hashchain_terminator is None:
self.hash = hashchain_reveal(xmss.get_seed_private(),
epoch=self.epoch + 1)
else:
self.hash = hashchain_terminator
tmphash = ''.join([bin2hstr(b) for b in self.hash])
if self.first_hash is None:
self.first_hash = tuple()
self.txhash = str2bin(tmphash + bin2hstr(self.first_hash) +
bin2hstr(self.slave_public_key))
self._process_XMSS(xmss.get_address(), self.txhash,
xmss) # self.hash to be replaced with self.txhash
return self
def test_register_overflow(self):
mr = MessageReceipt()
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
config.dev.message_q_size = 4
for i in range(config.dev.message_q_size * 2):
msg_hash = str2bin(str(i))
mr.register(msg_type, msg_hash, msg_obj)
self.assertEqual(len(mr._hash_msg), config.dev.message_q_size)
def test_register_overflow(self):
mr = MessageReceipt()
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
config.dev.message_q_size = 4
for i in range(config.dev.message_q_size * 2):
msg_hash = str2bin(str(i))
mr.register(msg_type, msg_hash, msg_obj)
self.assertEqual(len(mr._hash_msg), config.dev.message_q_size)
def _get_hashable_bytes(self):
"""
This method should return bytes that are to be hashed and represent the transaction
:return: hashable bytes
:rtype: bytes
"""
# FIXME: Avoid all intermediate conversions
tmptxhash = bin2hstr(tuple(self.hash))
tmptxhash = str2bin(tmptxhash +
bin2hstr(self.slave_public_key) +
bin2hstr(sha2_256(bytes(self.activation_blocknumber))) +
bin2hstr(sha2_256(bytes(self.subtype)))) # FIXME: stringify in standardized way
# FIXME: the order in the dict may affect hash
return bytes(tmptxhash)
def test_add_contains_remove(self):
mr = MessageReceipt()
# FIXME: Hashes being are treated as strings
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
peer = '127.0.0.1'
mr.register(msg_type, msg_hash, msg_obj)
mr.add_peer(msg_hash, msg_type, peer)
self.assertTrue(mr.contains(msg_hash, msg_type))
self.assertFalse(mr.contains(b'hash_invalid', msg_type))
def test_add_contains_remove(self):
mr = MessageReceipt()
# FIXME: Hashes being are treated as strings
msg_hash = str2bin("hash_valid")
msg_obj = [1, 2, 3, 4]
msg_type = mr.allowed_types[0]
peer = '127.0.0.1'
mr.register(msg_type, msg_hash, msg_obj)
mr.add_peer(msg_hash, msg_type, peer)
self.assertTrue(mr.contains(msg_hash, msg_type))
self.assertFalse(mr.contains(b'hash_invalid', msg_type))
def test_sign_verify(self):
message = "This is a test"
message_bin = str2bin(message)
xmss_height = 10
seed = bytearray([i for i in range(48)])
xmss = XMSS(xmss_height, seed)
pk = xmss.pk()
xmss.set_index(1)
for i in range(10):
self.assertTrue(xmss.get_index() == i + 1)
signature = xmss.SIGN(message_bin)
self.assertTrue(XMSS.VERIFY(message_bin, signature, pk))
def test_sign_verify(self):
message = "This is a test"
message_bin = str2bin(message)
xmss_height = 10
seed = bytearray([i for i in range(48)])
xmss = XMSS(XmssFast(seed, xmss_height))
pk = xmss.pk
xmss.set_ots_index(1)
for i in range(10):
self.assertTrue(xmss.ots_index == i + 1)
signature = xmss.sign(message_bin)
self.assertTrue(XmssFast.verify(message_bin, signature, pk))
def test_sign_verify(self):
message = "This is a test"
message_bin = str2bin(message)
xmss_height = 10
seed = bytearray([i for i in range(48)])
xmss = XMSS(xmss_height, seed)
pk = xmss.pk()
xmss.set_index(1)
for i in range(10):
self.assertTrue(xmss.get_index() == i + 1)
signature = xmss.SIGN(message_bin)
self.assertTrue(XMSS.VERIFY(message_bin, signature, pk))
def create(blocknumber,
xmss,
slave_public_key,
hashchain_terminator=None,
first_hash=None,
balance=None):
"""
>>> s = StakeTransaction()
>>> slave = XMSS(4)
>>> isinstance(s.create(0, XMSS(4), slave.pk(), None, slave.pk(), 10), StakeTransaction)
True
"""
if not balance:
logger.info('Invalid Balance %d', balance)
raise Exception
transaction = StakeTransaction()
transaction.txfrom = xmss.get_address()
transaction.slave_public_key = slave_public_key
transaction.epoch = blocknumber // config.dev.blocks_per_epoch # in this block the epoch is..
transaction.balance = balance
transaction.first_hash = first_hash
if transaction.first_hash is None:
transaction.first_hash = tuple()
transaction.hash = hashchain_terminator
if hashchain_terminator is None:
transaction.hash = hashchain_reveal(xmss.get_seed_private(),
epoch=transaction.epoch + 1)
transaction.PK = xmss.pk()
transaction.ots_key = xmss.get_index()
tmppubhash = transaction._get_pubhash()
tmptxhash = ''.join([bin2hstr(b) for b in transaction.hash])
tmptxhash = str2bin(tmptxhash + bin2hstr(transaction.first_hash) +
bin2hstr(transaction.slave_public_key))
transaction.txhash = transaction._get_txhash(tmptxhash, tmppubhash)
return transaction
def get_message_hash(self):
"""
:return:
:rtype:
>>> s = StakeTransaction()
>>> seed = [i for i in range(48)]
>>> slave = XMSS(4, seed)
>>> t = s.create(0, XMSS(4, seed), slave.pk(), None, slave.pk(), 10)
>>> t.get_message_hash()
(190, 216, 197, 106, 146, 168, 148, 15, 12, 106, 8, 196, 43, 74, 14, 144, 215, 198, 251, 97, 148, 8, 182, 151, 10, 227, 212, 134, 25, 11, 228, 245)
"""
message = super(StakeTransaction, self).get_message_hash()
# message.write(self.epoch)
tmphash = ''.join([bin2hstr(b) for b in self.hash])
message.write(tmphash)
message.write(bin2hstr(self.first_hash))
messagestr = message.getvalue()
result = sha256(str2bin(messagestr))
return result
def test_getObject(self):
SOME_ODD_HASH = sha256(b'this should not be found')
SOME_ADDR1 = b'Q' + sha256(b'address1')
SOME_ADDR2 = b'Q' + sha256(b'address2')
db_state = Mock(spec=State)
p2p_factory = Mock(spec=P2PFactory)
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.tx_pool = Mock()
buffered_chain.tx_pool.transaction_pool = []
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertFalse(response.found)
# Find an address
db_state.get_address = MagicMock(return_value=AddressState.create(
address=SOME_ADDR1,
nonce=25,
balance=10,
pubhashes=[sha256(b'a'), sha256(b'b')],
tokens=dict()))
db_state.get_address_tx_hashes = MagicMock(
return_value=[sha256(b'0'), sha256(b'1')])
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ODD_HASH
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertFalse(response.found)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ADDR1
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.address_state)
self.assertEqual(SOME_ADDR1, response.address_state.address)
self.assertEqual(25, response.address_state.nonce)
self.assertEqual(10, response.address_state.balance)
self.assertEqual([sha256(b'a'), sha256(b'b')],
response.address_state.pubhashes)
self.assertEqual([sha256(b'0'), sha256(b'1')],
response.address_state.transaction_hashes)
# Find a transaction
db_state.address_used = MagicMock(return_value=False)
tx1 = TransferTransaction.create(addr_from=SOME_ADDR1,
addr_to=SOME_ADDR2,
amount=125,
fee=19,
xmss_pk=sha256(b'pk'),
xmss_ots_index=13)
buffered_chain.tx_pool.transaction_pool = [tx1]
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = tx1.txhash
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.transaction)
self.assertEqual(qrl_pb2.Transaction.TRANSFER,
response.transaction.type)
self.assertEqual(SOME_ADDR1, response.transaction.addr_from)
self.assertEqual(sha256(b'pk'), response.transaction.public_key)
self.assertEqual(tx1.txhash, response.transaction.transaction_hash)
self.assertEqual(13, response.transaction.ots_key)
self.assertEqual(b'', response.transaction.signature)
self.assertEqual(SOME_ADDR2, response.transaction.transfer.addr_to)
self.assertEqual(125, response.transaction.transfer.amount)
self.assertEqual(19, response.transaction.transfer.fee)
# Find a block
buffered_chain.get_block = MagicMock(return_value=Block.create(
staking_address=qrladdress('staking_addr'),
block_number=1,
reveal_hash=sha256(b'reveal'),
prevblock_headerhash=sha256(b'reveal'),
transactions=[],
duplicate_transactions=OrderedDict(),
vote=VoteMetadata(),
signing_xmss=get_alice_xmss(),
nonce=1))
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bytes(str2bin('1'))
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.block)
self.assertEqual(1, response.block.header.block_number)
def test_getObject(self):
SOME_ODD_HASH = sha256(b'this should not be found')
db_state = Mock(spec=State)
db_state.get_tx_metadata = MagicMock(return_value=None)
db_state.get_block = MagicMock(return_value=None)
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
# First try an empty request
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertFalse(response.found)
# Some odd address
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ODD_HASH
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertFalse(response.found)
# Find an address
bob_xmss = get_bob_xmss()
addr1_state = AddressState.create(address=bob_xmss.address,
nonce=25,
balance=10,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
addr1_state.transaction_hashes.append(sha256(b'0'))
addr1_state.transaction_hashes.append(sha256(b'1'))
db_state.get_address_state = MagicMock(return_value=addr1_state)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bob_xmss.address
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.address_state)
self.assertEqual(bob_xmss.address, response.address_state.address)
self.assertEqual(25, response.address_state.nonce)
self.assertEqual(10, response.address_state.balance)
self.assertEqual([sha256(b'0'), sha256(b'1')],
response.address_state.transaction_hashes)
# Find a transaction
alice_xmss = get_alice_xmss()
db_state.address_used = MagicMock(return_value=False)
tx1 = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[125],
fee=19,
xmss_pk=bob_xmss.pk,
master_addr=alice_xmss.address)
chain_manager.tx_pool.transaction_pool = [(0, TransactionInfo(tx1, 0))]
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = tx1.txhash
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.transaction)
self.assertEqual('transfer',
response.transaction.tx.WhichOneof('transactionType'))
self.assertEqual(alice_xmss.address,
response.transaction.tx.master_addr)
self.assertEqual(bob_xmss.pk, response.transaction.tx.public_key)
self.assertEqual(tx1.txhash, response.transaction.tx.transaction_hash)
self.assertEqual(b'', response.transaction.tx.signature)
self.assertEqual(bob_xmss.address,
response.transaction.tx.transfer.addrs_to[0])
self.assertEqual(125, response.transaction.tx.transfer.amounts[0])
self.assertEqual(19, response.transaction.tx.fee)
alice_xmss = get_alice_xmss()
# Find a block
db_state.get_block_by_number = MagicMock(
return_value=Block.create(block_number=1,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=[],
miner_address=alice_xmss.address))
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bytes(str2bin('1'))
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.block_extended)
self.assertEqual(1, response.block_extended.header.block_number)
def test_getObject(self):
SOME_ODD_HASH = sha256(b'this should not be found')
with set_qrl_dir('no_data'):
db_state = State()
p2p_factory = Mock(spec=P2PFactory)
p2p_factory.pow = Mock(spec=POW)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._pow = p2p_factory.pow
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
# First try an empty request
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertFalse(response.found)
# Some odd address
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = SOME_ODD_HASH
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertFalse(response.found)
# Find an address
bob_xmss = get_bob_xmss()
addr1_state = OptimizedAddressState.create(address=bob_xmss.address,
nonce=25,
balance=10,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
AddressState.put_address_state(db_state, addr1_state, None)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bob_xmss.address
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.address_state)
self.assertEqual(bob_xmss.address, response.address_state.address)
self.assertEqual(25, response.address_state.nonce)
self.assertEqual(10, response.address_state.balance)
# Find a transaction
alice_xmss = get_alice_xmss()
db_state.address_used = MagicMock(return_value=False)
tx1 = TransferTransaction.create(
addrs_to=[bob_xmss.address],
amounts=[125],
message_data=None,
fee=19,
xmss_pk=bob_xmss.pk,
master_addr=alice_xmss.address)
chain_manager.tx_pool.transaction_pool = [(0, TransactionInfo(tx1, 0))]
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = tx1.txhash
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.transaction)
self.assertEqual('transfer', response.transaction.tx.WhichOneof('transactionType'))
self.assertEqual(alice_xmss.address, response.transaction.tx.master_addr)
self.assertEqual(bob_xmss.pk, response.transaction.tx.public_key)
self.assertEqual(tx1.txhash, response.transaction.tx.transaction_hash)
self.assertEqual(b'', response.transaction.tx.signature)
self.assertEqual(bob_xmss.address, response.transaction.tx.transfer.addrs_to[0])
self.assertEqual(125, response.transaction.tx.transfer.amounts[0])
self.assertEqual(19, response.transaction.tx.fee)
alice_xmss = get_alice_xmss()
# Find a block
block = Block.create(dev_config=config.dev,
block_number=1,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=[],
miner_address=alice_xmss.address,
seed_height=0,
seed_hash=None)
Block.put_block(db_state, block, None)
Block.put_block_number_mapping(db_state,
block.block_number,
qrl_pb2.BlockNumberMapping(headerhash=block.headerhash),
None)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetObjectReq()
request.query = bytes(str2bin('1'))
response = service.GetObject(request=request, context=context)
context.set_code.assert_not_called()
self.assertTrue(response.found)
self.assertIsNotNone(response.block_extended)
self.assertEqual(1, response.block_extended.header.block_number)
def _generate_tx_merkle_root(transactions):
result = str2bin("".join(tx.hash for tx in transactions))
return bin2hstr(sha2_256(result))
def __init__(self, tree_height, seed=None):
"""
:param
tree_height: height of the tree to generate. number of OTS keypairs=2**tree_height
:param seed:
>>> from qrl.crypto.doctest_data import *; XMSS(4, mnemonic2bin(xmss_mnemonic_test1, wordlist)).get_address()
'Q572721d2221f1d43b18eecacb945221f1156f1e2f519b71e3def43d761e88f3af72feb52'
>>> from qrl.crypto.doctest_data import *; XMSS(4, mnemonic2bin(xmss_mnemonic_test2, wordlist)).get_address()
'Q578230464f0550df33f1bad86b725ce6e6c5e278c5d03a100fb93c1d282daec21b2422f2'
>>> from qrl.crypto.doctest_data import *; XMSS(4, mnemonic2bin(xmss_mnemonic_test2, wordlist)).get_address()
'Q578230464f0550df33f1bad86b725ce6e6c5e278c5d03a100fb93c1d282daec21b2422f2'
# NEW TESTS
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getHeight()
4
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
132
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getSignatureSize()
2308
>>> from qrl.crypto.doctest_data import *; len(XMSS(4, xmss_test_seed1)._xmss.getSK()) == XMSS(4, xmss_test_seed1)._xmss.getSecretKeySize()
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPK() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSK() ) == xmss_sk_expected1
True
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getRoot() )
'26b3bcc104d686ecfd9fdea7b1963384339121430fbe056cab7c3048ea3e4c4e'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getPKSeed() )
'51ec21420dd061739e4637fd74517a46f86f89e0fb83f2526fafafe356e564ff'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getIndex()
0
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKSeed() )
'5f2eb95ccf6a0e3e7f472c32d234340c20b3fd379dc28b710affcc0cb2afa57b'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed1)._xmss.getSKPRF() )
'3aa40c0f99459afe7efe72eb9517ee8ded49ccd51dab72ebf6bc37d73240bb3a'
>>> from qrl.crypto.doctest_data import *; XMSS(4, xmss_test_seed1)._xmss.getAddress('Q')
'Q1d651431536359202ce7095757e3ed66f579a6eab488ac1331486f207c91604016b6a443'
>>> from qrl.crypto.doctest_data import *; bin2hstr( XMSS(4, xmss_test_seed2)._xmss.getPK() ) # doctest: +SKIP
''
"""
self._number_signatures = 2**tree_height
self._type = 'XMSS'
# FIXME: Set index to appropiate value after restoring
self._index = 0
if seed is None:
# FIXME: Improve seed generation
self._seed = getRandomSeed(48, '')
else:
if isinstance(seed, str):
self._seed = str2bin(seed)
else:
self._seed = seed
# TODO: #####################
# FIXME Seed is fixed!!!!!!!!!!!!!!!!!!!!
self._xmss = XmssFast(self._seed, tree_height)
# TODO: Need to set an index
# data to allow signing of smaller xmss trees/different addresses derived from same SEED..
# position in wallet denoted by first number and address/tree by signatures
self.addresses = [(0, self.get_address(), self.get_number_signatures())
]
