github
/
monero
mirror of https://github.com/monero-project/monero
1
Fork 0
Code Releases Activity
monero/tests/functional_tests/k_anonymity.py

315 lines
13 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python3
# Copyright (c) 2023, The Monero Project
#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification, are
# permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this list of
# conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice, this list
# of conditions and the following disclaimer in the documentation and/or other
# materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors may be
# used to endorse or promote products derived from this software without specific
# prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from __future__ import print_function
import math
import random
"""
Test the k-anonymity daemon RPC features:
* txid fetching by prefix
"""
from framework.daemon import Daemon
from framework.wallet import Wallet
seeds = [
'velvet lymph giddy number token physics poetry unquoted nibs useful sabotage limits benches lifestyle eden nitrogen anvil fewest avoid batch vials washing fences goat unquoted',
'peeled mixture ionic radar utopia puddle buying illness nuns gadget river spout cavernous bounced paradise drunk looking cottage jump tequila melting went winter adjust spout',
'tadpoles shrugged ritual exquisite deepest rest people musical farming otherwise shelter fabrics altitude seventh request tidy ivory diet vapidly syllabus logic espionage oozed opened people',
'ocio charla pomelo humilde maduro geranio bruto moño admitir mil difícil diva lucir cuatro odisea riego bebida mueble cáncer puchero carbón poeta flor fruta fruta'
]
pub_addrs = [
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
'44Kbx4sJ7JDRDV5aAhLJzQCjDz2ViLRduE3ijDZu3osWKBjMGkV1XPk4pfDUMqt1Aiezvephdqm6YD19GKFD9ZcXVUTp6BW',
'45uQD4jzWwPazqr9QJx8CmFPN7a9RaEE8T4kULg6r8GzfcrcgKXshfYf8cezLWwmENHC9pDN2fGAUFmmdFxjeZSs3n671rz',
'48hKTTTMfuiW2gDkmsibERHCjTCpqyCCh57WcU4KBeqDSAw7dG7Ad1h7v8iJF4q59aDqBATg315MuZqVmkF89E3cLPrBWsi'
]
CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW = 60
CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE = 10
RESTRICTED_SPENT_KEY_IMAGES_COUNT = 5000
def make_hash32_loose_template(txid, nbits):
txid_bytes = list(bytes.fromhex(txid))
for i in reversed(range(32)):
mask_nbits = min(8, nbits)
mask = 256 - (1 << (8 - mask_nbits))
nbits -= mask_nbits
txid_bytes[i] &= mask
return bytes(txid_bytes).hex()
def txid_list_is_sorted_in_template_order(txids):
reversed_txid_bytes = [bytes(reversed(bytes.fromhex(txid))) for txid in txids]
return sorted(reversed_txid_bytes) == reversed_txid_bytes
def txid_matches_template(txid, template, nbits):
txid_bytes = bytes.fromhex(txid)
template_bytes = bytes.fromhex(template)
for i in reversed(range(32)):
mask_nbits = min(8, nbits)
mask = 256 - (1 << (8 - mask_nbits))
nbits -= mask_nbits
if 0 != ((txid_bytes[i] ^ template_bytes[i]) & mask):
return False
return True
class KAnonymityTest:
def run_test(self):
self.reset()
self.create_wallets()
# If each of the N wallets is making N-1 transfers the first round, each N wallets needs
# N-1 unlocked coinbase outputs
N = len(seeds)
self.mine_and_refresh(2 * N * (N - 1))
self.mine_and_refresh(CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW)
# Generate a bunch of transactions
NUM_ROUNDS = 10
intermediate_mining_period = int(math.ceil(CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE / N)) * N
for i in range(NUM_ROUNDS):
self.transfer_around()
self.mine_and_refresh(intermediate_mining_period)
print("Wallets created {} transactions in {} rounds".format(len(self.wallet_txids), NUM_ROUNDS))
self.test_all_chain_txids() # Also gathers miner_txids
self.test_get_txids_loose_chain_suite()
self.test_get_txids_loose_pool_suite()
self.test_bad_txid_templates()
def reset(self):
print('Resetting blockchain')
daemon = Daemon()
res = daemon.get_height()
daemon.pop_blocks(res.height - 1)
daemon.flush_txpool()
self.wallet_txids = set()
self.total_blocks_mined = 0
self.miner_txids = set()
self.pool_txids = set()
def create_wallets(self):
print('Creating wallets')
assert len(seeds) == len(pub_addrs)
self.wallet = [None] * len(seeds)
for i in range(len(seeds)):
self.wallet[i] = Wallet(idx = i)
# close the wallet if any, will throw if none is loaded
try: self.wallet[i].close_wallet()
except: pass
res = self.wallet[i].restore_deterministic_wallet(seed = seeds[i])
def mine_and_refresh(self, num_blocks):
print("Mining {} blocks".format(num_blocks))
daemon = Daemon()
res = daemon.get_info()
old_height = res.height
assert num_blocks % len(self.wallet) == 0
assert len(self.wallet) == len(pub_addrs)
for i in range(len(self.wallet)):
daemon.generateblocks(pub_addrs[i], num_blocks // len(self.wallet))
res = daemon.get_info()
new_height = res.height
assert new_height == old_height + num_blocks, "height {} -> {}".format(old_height, new_height)
for i in range(len(self.wallet)):
self.wallet[i].refresh()
res = self.wallet[i].get_height()
assert res.height == new_height, "{} vs {}".format(res.height, new_height)
self.wallet_txids.update(self.pool_txids)
self.pool_txids.clear()
self.total_blocks_mined += num_blocks
def transfer_around(self):
N = len(self.wallet)
assert N == len(pub_addrs)
print("Creating transfers b/t wallets")
num_successful_transfers = 0
fee_margin = 0.05 # 5%
for sender in range(N):
receivers = list((r for r in range(N) if r != sender))
random.shuffle(receivers)
assert len(receivers) == N - 1
for j, receiver in enumerate(receivers):
unlocked_balance = self.wallet[sender].get_balance().unlocked_balance
if 0 == unlocked_balance:
assert j != 0 # we want all wallets to start out with at least some funds
break
imperfect_starting_balance = unlocked_balance * (N - 1) / (N - 1 - j) * (1 - fee_margin)
transfer_amount = int(imperfect_starting_balance / (N - 1))
assert transfer_amount < unlocked_balance
dst = {'address': pub_addrs[receiver], 'amount': transfer_amount}
res = self.wallet[sender].transfer([dst], get_tx_metadata = True)
tx_hex = res.tx_metadata
self.pool_txids.add(res.tx_hash)
res = self.wallet[sender].relay_tx(tx_hex)
self.wallet[sender].refresh()
num_successful_transfers += 1
print("Transferred {} times".format(num_successful_transfers))
def test_all_chain_txids(self):
daemon = Daemon()
print("Grabbing all txids from the daemon and testing against known txids")
# If assert stmt below fails, this test case needs to be rewritten to chunk the requests;
# there are simply too many txids on-chain to gather at once
expected_total_num_txids = len(self.wallet_txids) + self.total_blocks_mined + 1 # +1 for genesis coinbase tx
assert expected_total_num_txids <= RESTRICTED_SPENT_KEY_IMAGES_COUNT
res = daemon.get_txids_loose('0' * 64, 0)
all_txids = res.txids
assert 'c88ce9783b4f11190d7b9c17a69c1c52200f9faaee8e98dd07e6811175177139' in all_txids # genesis coinbase tx
assert len(all_txids) == expected_total_num_txids, "{} {}".format(len(all_txids), expected_total_num_txids)
assert txid_list_is_sorted_in_template_order(all_txids)
for txid in self.wallet_txids:
assert txid in all_txids
self.miner_txids = set(all_txids) - self.wallet_txids
def test_get_txids_loose_success(self, txid, num_matching_bits):
daemon = Daemon()
txid_template = make_hash32_loose_template(txid, num_matching_bits)
res = daemon.get_txids_loose(txid_template, num_matching_bits)
assert 'txids' in res
txids = res.txids
first_pool_index = 0
while first_pool_index < len(txids):
if txids[first_pool_index] in self.pool_txids:
break
else:
first_pool_index += 1
chain_txids = txids[:first_pool_index]
pool_txids = txids[first_pool_index:]
assert txid_list_is_sorted_in_template_order(chain_txids)
assert txid_list_is_sorted_in_template_order(pool_txids)
# Assert we know where txids came from
for txid in chain_txids:
assert (txid in self.wallet_txids) or (txid in self.miner_txids)
for txid in pool_txids:
assert txid in self.pool_txids
# Assert that all known txids were matched as they should've been
for txid in self.wallet_txids:
assert txid_matches_template(txid, txid_template, num_matching_bits) == (txid in chain_txids)
for txid in self.miner_txids:
assert txid_matches_template(txid, txid_template, num_matching_bits) == (txid in chain_txids)
for txid in self.pool_txids:
assert txid_matches_template(txid, txid_template, num_matching_bits) == (txid in pool_txids)
def test_get_txids_loose_chain_suite(self):
daemon = Daemon()
print("Testing grabbing on-chain txids loosely with all different bit sizes")
# Assert pool empty
assert len(self.pool_txids) == 0
res = daemon.get_transaction_pool_hashes()
assert not 'tx_hashes' in res or len(res.tx_hashes) == 0
assert len(self.wallet_txids)
current_chain_txids = list(self.wallet_txids.union(self.miner_txids))
for nbits in range(0, 256):
random_txid = random.choice(current_chain_txids)
self.test_get_txids_loose_success(random_txid, nbits)
def test_get_txids_loose_pool_suite(self):
daemon = Daemon()
print("Testing grabbing pool txids loosely with all different bit sizes")
# Create transactions to pool
self.transfer_around()
# Assert pool not empty
assert len(self.pool_txids) != 0
res = daemon.get_transaction_pool_hashes()
assert 'tx_hashes' in res and set(res.tx_hashes) == self.pool_txids
current_pool_txids = list(self.pool_txids)
for nbits in range(0, 256):
random_txid = random.choice(current_pool_txids)
self.test_get_txids_loose_success(random_txid, nbits)
def test_bad_txid_templates(self):
daemon = Daemon()
print("Making sure the daemon catches bad txid templates")
test_cases = [
['q', 256],
['a', 128],
['69' * 32, 257],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 0],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 1],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 2],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 4],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 8],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 16],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 32],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 64],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 128],
['0abcdef1234567890abcdef1234567890abcdef1234567890abcdef123456789', 193],
['0000000000000000000000000000000000000000000000000000000000000080', 0],
['0000000000000000000000000000000000000000000000000000000000000007', 5],
['00000000000000000000000000000000000000000000000000000000000000f7', 5],
]
for txid_template, num_matching_bits in test_cases:
ok = False
try: res = daemon.get_txids_loose(txid_template, num_matching_bits)
except: ok = True
assert ok, 'bad template didnt error: {} {}'.format(txid_template, num_matching_bits)
if __name__ == '__main__':
KAnonymityTest().run_test()
View Git Blame Copy Permalink