def main(): data = [] tree = MerkleTree(data, hashfunc) for i in ascii_lowercase: tree.append(i) beautify(tree) print("Original verify_leaf_inclusion") original_proof = tree.get_proof('a') print(tree.verify_leaf_inclusion('a', original_proof)) print("Proof to lists/ Lists to proof verify_leaf_inclusion") root = tree._root proof_hashs, proof_types = proof_to_lists(original_proof) remade_proof = lists_to_proof(proof_hashs, proof_types) print( merklelib.verify_leaf_inclusion('a', remade_proof, hashfunc, utils.to_hex(root.hash))) print("Proof to string test") string_proof = proof_to_string(original_proof) print(type(string_proof) == type("hello")) print("Proof to string/ String to proof verify_leaf_inclusion") new_proof = string_to_proof(string_proof) print( merklelib.verify_leaf_inclusion('a', remade_proof, hashfunc, utils.to_hex(root.hash)))
def system_summary(): """ Summarises the system this function is run on. Includes system, cpu, gpu and module details :return: A dictionary of system details """ merkletree = MerkleTree() system_info = {} uname = platform.uname() system_info["system"] = { "system": uname.system, "release": uname.release, "machine": uname.machine, "processor": uname.processor, } cpu_freq = psutil.cpu_freq() system_info["cpu"] = { "cores_phys": psutil.cpu_count(logical=False), "cores_logic": psutil.cpu_count(logical=True), "max_frequency": cpu_freq.max, "min_frequency": cpu_freq.min, } sys_mem = psutil.virtual_memory() system_info["memory"] = {"total": sys_mem.total} gpus = GPUtil.getGPUs() system_info["gpu"] = {} for gpu in gpus: system_info["gpu"][gpu.id] = { "name": gpu.name, "memory": gpu.memoryTotal } system_info["modules"] = find_loaded_modules() merkletree.append(list(system_info.items())) system_info["signature"] = merkletree.merkle_root return system_info
def system_summary(): """ Summarises the system this function is run on. Includes system, cpu, gpu and module details :return: A dictionary of system details """ merkletree = MerkleTree() system_info = {} uname = platform.uname() system_info['system'] = { 'system': uname.system, 'release': uname.release, 'machine': uname.machine, 'processor': uname.processor } cpu_freq = psutil.cpu_freq() system_info['cpu'] = { 'cores_phys': psutil.cpu_count(logical=False), 'cores_logic': psutil.cpu_count(logical=True), 'max_frequency': cpu_freq.max, 'min_frequency': cpu_freq.min } sys_mem = psutil.virtual_memory() system_info['memory'] = {'total': sys_mem.total} gpus = GPUtil.getGPUs() system_info['gpu'] = {} for gpu in gpus: system_info['gpu'][gpu.id] = { 'name': gpu.name, 'memory': gpu.memoryTotal } system_info['modules'] = find_loaded_modules() merkletree.append([system_info[item] for item in system_info]) system_info['signature'] = merkletree.merkle_root return system_info
def recompute_command(command, fout): """ Recomputes a given command, tracing the methods logged on the way. These methods are loaded in a MerkleTree and returns its root. :param command: The executed python command (string) :param fout: The name of the file to store the trace :return: A merkleroot of the trace file. """ np.random.seed(42) # Random number control random.seed(42) sys.stdout = open(fout, 'w') tracer = trace.Trace(trace=1, count=0) tracer.run(command) sys.stdout.close() sys.stdout = sys.__stdout__ log = open(fout, 'r') mtree = MerkleTree(log.readlines()) mtree.append(system_summary()['signature']) return mtree.merkle_root
def main(): parser = argparse.ArgumentParser() parser.add_argument( '-s', '--size', help='Initial number of leaves', dest='size', default=2 ** 8 ) parser.add_argument( '-a', '--additional', help='Number of leaves that we need to append', dest='additional', default=2 ** 1 ) parser.add_argument( '-p', '--print', help=''' Beautify the whole tree. Recommended to use when the size of the tree is less than 10. ''', action='store_true', dest='printable' ) args = parser.parse_args() start, end = int(args.size), int(args.additional) count = start + end start_t = datetime.now() tree = MerkleTree(value for value in range(start)) print(f'Building: {_get_seconds(start_t)} seconds.') start_t = datetime.now() # appending for v in range(start, start + end): tree.append(v) print(f'Appending: {_get_seconds(start_t)} seconds.') print(f'Tree size: {getsize(tree)}') print(f'Number of leaves: {len(tree)}') if args.printable: beautify(tree) start_t = datetime.now() total, start_t = 0.0, datetime.now() max_t = min_t = None for leaf in range(count): cycle_t = datetime.now() proof = tree.get_proof(leaf) if not tree.verify_leaf_inclusion(leaf, proof): exit(f'Failed audit proof: {leaf}') seconds = _get_seconds(cycle_t) if max_t is None: max_t = min_t = seconds else: max_t = max(max_t, seconds) min_t = min(min_t, seconds) total += seconds print(f'Audit proof verification times:') _print_times( average=(total / float(count)), total=_get_seconds(start_t), max_t=max_t, min_t=min_t ) total, start_t = 0.0, datetime.now() max_t = min_t = None for limit in range(1, count): cycle_t = datetime.now() test = MerkleTree([value for value in range(limit)]) if tree < test: exit(f'Failed consistency proof: {limit}') seconds = _get_seconds(cycle_t) if max_t is None: max_t = min_t = seconds else: max_t = max(max_t, seconds) min_t = min(min_t, seconds) total += seconds print(f'Consitency proof verification times ({count} trees):') _print_times( average=(total / float(count)), total=_get_seconds(start_t), max_t=max_t, min_t=min_t )
def hashfunc(value): new_value = value return new_value # --------------- LEAF APPEND / TREE GENERATE TEST -------------------- # print("\n--------------- LEAF APPEND / TREE GENERATE TEST --------------------") # This test simulates accumulating nonces one at a time # Instantiate empty list data = [] # Instantiate empty Merkle tree for appending asciiTree = MerkleTree(data, hashfunc) # Add all ASCII characters to Merkle tree for i in ascii_lowercase: asciiTree.append(i.encode('utf-8')) # Print MerkleTree print("\nPrinting Merkle Tree") beautify(asciiTree) print("\nPrinting root") print(asciiTree.merkle_root) print("\nPrinting leaves") print(asciiTree.leaves) # Generate an audit proof the letter a print("\nGenerating audit proof for a") proof = asciiTree.get_proof('a') print("\nProof: ") print(proof)
async def get(self): """This method handles the GET requests for Tenant verifiers to talk with Provider verifiers """ rest_params = common.get_restful_params(self.request.uri) global tree if rest_params is None: common.echo_json_response( self, 405, "Not Implemented: Use /agents/interface") return if "agents" in rest_params: agent_id = rest_params["agents"] if agent_id is not None: agent = self.db.get_agent(agent_id) if agent != None: response = cloud_verifier_common.process_get_status(agent) common.echo_json_response(self, 200, "Success", response) else: #logger.info('GET returning 404 response. agent id: ' + agent_id + ' not found.') common.echo_json_response(self, 404, "agent id not found") else: # return the available keys in the DB json_response = self.db.get_agent_ids() common.echo_json_response(self, 200, "Success", {'uuids': json_response}) logger.info('GET returning 200 response for agent_id list') elif "verifier" in rest_params: partial_req = "1" # don't need a pub key agent = self.db.get_agent_ids() new_agent = self.db.get_agent(agent[0]) try: await nonce_col.put(rest_params["nonce"]) except Exception as e: print('error: ', e) new_agent['quote_col'].append(rest_params["nonce"]) self.db.update_all_agents('quote_col', new_agent['quote_col']) #Simulate busy TPM with async sleep function to allow testing of quote batching functionality await asyncio.sleep(10) try: agent = self.db.get_agent_ids() new_agent2 = self.db.get_agent(agent[0]) tree = MerkleTree([], hashfunc) logger.info("Concurrent Nonces: " + str(nonce_col.qsize())) for nonce in range(nonce_col.qsize()): temp = nonce_col.get() t = await temp logger.debug(t) tree.append(t) await nonce_col.put(t) logger.info("Making Merkle Tree in Provider Verifier") logger.info(beautify(tree)) nonce_proof = tree.get_proof(rest_params['nonce']) except Exception as e: print('error: ', e) rest_params['nonce'] = tree.merkle_root url = "http://%s:%d/quotes/integrity?nonce=%s&mask=%s&vmask=%s&partial=%s" % ( new_agent['ip'], new_agent['port'], rest_params["nonce"], rest_params["mask"], rest_params['vmask'], partial_req) res = tornado_requests.request("GET", url, context=None) response = await res json_response = json.loads(response.body) json_response_result = json_response["results"] json_response_result['nonce_proof'] = proof_to_string(nonce_proof) json_response_result['merkle_head'] = tree.merkle_root logger.debug("To string of Nonce Proof", json_response_result['merkle_head']) common.echo_json_response(self, 200, "Success", json_response_result) else: common.echo_json_response(self, 400, "uri not supported") logger.warning('GET returning 400 response. uri not supported: ' + self.request.path)