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