class MerkleTreeGenerator(object): def __init__(self): self.tree = MerkleTools(hash_type='sha256') def populate(self, node_generator): """ Populate Merkle Tree with data from node_generator. This requires that node_generator yield byte[] elements. Hashes, computes hex digest, and adds it to the Merkle Tree :param node_generator: :return: """ for data in node_generator: hashed = hash_byte_array(data) self.tree.add_leaf(hashed) def get_blockchain_data(self): """ Finalize tree and return byte array to issue on blockchain :return: """ self.tree.make_tree() merkle_root = self.tree.get_merkle_root() return h2b(ensure_string(merkle_root)) def get_proof_generator(self, tx_id, chain=Chain.bitcoin_mainnet): """ Returns a generator (1-time iterator) of proofs in insertion order. :param tx_id: blockchain transaction id :return: """ root = ensure_string(self.tree.get_merkle_root()) node_count = len(self.tree.leaves) for index in range(0, node_count): proof = self.tree.get_proof(index) proof2 = [] for p in proof: dict2 = dict() for key, value in p.items(): dict2[key] = ensure_string(value) proof2.append(dict2) target_hash = ensure_string(self.tree.get_leaf(index)) merkle_proof = { "type": ['MerkleProof2017', 'Extension'], "merkleRoot": root, "targetHash": target_hash, "proof": proof2, "anchors": [{ "sourceId": to_source_id(tx_id, chain), "type": chain.blockchain_type.external_display_value, "chain": chain.external_display_value }] } yield merkle_proof
def gen_merkle_tree(tx_list): mt = MerkleTools(hash_type="sha256") mt.add_leaf(tx_list, True) mt.make_tree() for index in range(0, mt.leaves.__len__()): logger.info("Transaction" + str(index) + ": " + mt.get_leaf(index)) while not mt.is_ready: logger.error("mt is not ready!") return mt.get_merkle_root()
def main(): # get paramters and contract details # print(contractHash) #preprocess_queue = queue.LifoQueue() #inference_queue = queue.LifoQueue() preprocess_queue = mp.Queue() inference_queue = mp.Queue() # postprocess_queue = Queue() p1 = mp.Process(target=inference, args=(preprocess_queue, inference_queue)) p2 = mp.Process(target=preprocessing, args=(preprocess_queue, )) #p1 = Process(target=dummy) #p2 = Process(target=dummy) # p3 = Process(target=Show_Image_mp, args=(Processed_frames, show, Final_frames)) p1.start() p2.start() # p3.start() sk = SigningKey(Parameters.private_key_contractor) contractHash = Helperfunctions.hashContract().encode('latin1') dont_show = Parameters.dont_show merkle_tree_interval = OutsourceContract.merkle_tree_interval hostname = Parameters.ip_outsourcer # Use to receive from other computer port = Parameters.port_outsourcer sendingPort = Parameters.sendingPort #import tensorflow as tf # time.sleep(1.0) # configure responder responder = re.Responder(hostname, sendingPort) # statistics info moving_average_points = 50 # statistics moving_average_fps = MovingAverage(moving_average_points) moving_average_receive_time = MovingAverage(moving_average_points) moving_average_decompress_time = MovingAverage(moving_average_points) # moving_average_model_load_image_time = MovingAverage(moving_average_points) moving_average_img_preprocessing_time = MovingAverage( moving_average_points) moving_average_model_inference_time = MovingAverage(moving_average_points) moving_average_img_postprocessing_time = MovingAverage( moving_average_points) moving_average_reply_time = MovingAverage(moving_average_points) moving_average_image_show_time = MovingAverage(moving_average_points) moving_average_verify_image_sig_time = MovingAverage(moving_average_points) moving_average_response_signing_time = MovingAverage(moving_average_points) image_count = 0 a = 0 b = 0 if merkle_tree_interval > 0: mt = MerkleTools() mtOld = MerkleTools() interval_count = 0 mtOld_leaf_indices = {} mt_leaf_indices = {} # rendundancy_counter = 0 # rendundancy_counter2 = 0 current_challenge = 1 merkle_root = '' # stringsend = '' last_challenge = 0 image_showed_time = time.perf_counter() # init while True: # start_time = time.perf_counter() if not inference_queue.empty(): queueData = inference_queue.get() while not inference_queue.empty(): queueData = inference_queue.get() start_time = image_showed_time # # boxes, scores, classes, valid_detections, name, original_image #queueData=inference_queue.get() #inference_queue.task_done() # boxes=queueData[0] # scores=queueData[1] # classes=queueData[2] # valid_detections=queueData[3] # name = queueData[4] # original_image = queueData[5] boxtext = queueData[0] image = queueData[1] name = queueData[2] if merkle_tree_interval > 0: outsorucer_signature = name[:-5] outsourcer_image_count = name[-5] outsourcer_number_of_outputs_received = name[-4] outsourcer_random_number = name[-3] outsourcer_interval_count = name[-2] outsourcer_time_to_challenge = bool(name[-1]) received_time = time.perf_counter() image_preprocessing_time = time.perf_counter() decompressed_time = time.perf_counter() verify_time = time.perf_counter() # inference # region # endregion model_inferenced_time = time.perf_counter() # image postprocessing # region h = time.perf_counter() # endregion if merkle_tree_interval == 0: boxtext = 'Image' + str(name[-2]) + ':;' + boxtext else: boxtext = 'Image' + str( outsourcer_image_count) + ':;' + boxtext image_postprocessing_time = time.perf_counter() # sign message ->need to add image_count/interval_count (for merkle tree sig), contract hash to output and verificaton if merkle_tree_interval == 0: # sig = sk.sign_deterministic(boxtext.encode('latin1')) sig = sk.sign(boxtext.encode('latin1') + contractHash).signature # sig = list(sig) sig = sig.decode('latin1') # send reply responder.respond(boxtext + ';--' + sig) else: # print(image_count) # add leafs dynamiclly to merkle tree mt.add_leaf(boxtext, True) # remember indices for challenge mt_leaf_indices[ outsourcer_image_count] = image_count % merkle_tree_interval # print(image_count % merkle_tree_interval) response = boxtext # time to send a new merkle root # e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree if image_count > 1 and (image_count + 1) % merkle_tree_interval == 0: # print(image_count) a = time.perf_counter() # rendundancy_counter = 2 mt.make_tree() merkle_root = mt.get_merkle_root() sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root # resond with merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') interval_count += 1 mtOld = mt # save old merkle tree for challenge # mtOld_leaf_indices.clear() # clear old indices mtOld_leaf_indices.clear() mtOld_leaf_indices = mt_leaf_indices.copy( ) # save old indices for challenge # print(mtOld_leaf_indices) mt_leaf_indices.clear() # clear for new indices # mt_leaf_indices = {} mt = MerkleTools( ) # construct new merkle tree for next interval te = time.perf_counter() - a # print('1', te, image_count) else: # if this is true then the outsourcer has not received the merkle root yet -> send again if interval_count > outsourcer_image_count: sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') # print('2', image_count) else: # in this case outsourcer has confirmed to have recieved the merkle root # in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again if outsourcer_time_to_challenge and image_count - last_challenge > 3: last_challenge = image_count if outsourcer_random_number in mtOld_leaf_indices: # if challenge can be found, send proof back outsourcer_random_number_index = mtOld_leaf_indices[ outsourcer_random_number] else: # if challenge index cannot be found return leaf 0 outsourcer_random_number_index = 0 # print('proof index not found') proofs = mtOld.get_proof( outsourcer_random_number_index) stringsend = '' for proof in proofs: stringsend += ';--' # indicate start of proof stringsend += proof.__str__() # send proof stringsend += ';--' # send leaf stringsend += mtOld.get_leaf( outsourcer_random_number_index) stringsend += ';--' stringsend += mtOld.get_merkle_root() # send root stringarr = [] stringarr = stringsend.split(';--') leaf_node = stringarr[-2] root_node = stringarr[-1] proof_string = stringarr[0:-2] # sign proof and contract details sig = sk.sign( str(stringarr[1:]).encode('latin1') + bytes(interval_count - 1) + contractHash).signature # print(str(stringarr).encode('latin1') + bytes(interval_count-1) + contractHash) # print(stringarr) # attach signature response += ';--' + sig.decode('latin1') response += stringsend # attach challenge response to response # print('3', te, image_count) responder.respond(response) response_signing_time = time.perf_counter() # print(response_signing_time- image_postprocessing_time) replied_time = time.perf_counter() # display image if not dont_show: # image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imshow('raspberrypi', image) if cv2.waitKey(1) == ord('q'): responder.respond('abort12345:6') sys.exit( 'Contract aborted: Contractor ended contract according to custom' ) image_showed_time = time.perf_counter() # statistics moving_average_fps.add(1 / (image_showed_time - start_time)) moving_average_receive_time.add(received_time - start_time) moving_average_decompress_time.add(decompressed_time - received_time) moving_average_verify_image_sig_time.add(verify_time - decompressed_time) moving_average_img_preprocessing_time.add( image_preprocessing_time - verify_time) moving_average_model_inference_time.add(model_inferenced_time - image_preprocessing_time) moving_average_img_postprocessing_time.add( image_postprocessing_time - model_inferenced_time) moving_average_response_signing_time.add( response_signing_time - image_postprocessing_time) # adjust for merkle root moving_average_reply_time.add(replied_time - response_signing_time) moving_average_image_show_time.add(image_showed_time - replied_time) total_time=moving_average_receive_time.get_moving_average() \ + moving_average_decompress_time.get_moving_average() \ + moving_average_verify_image_sig_time.get_moving_average() \ + moving_average_img_preprocessing_time.get_moving_average() \ + moving_average_model_inference_time.get_moving_average() \ + moving_average_img_postprocessing_time.get_moving_average() \ + moving_average_response_signing_time.get_moving_average() \ + moving_average_reply_time.get_moving_average() \ + moving_average_image_show_time.get_moving_average() if (image_count == 800): a = time.perf_counter() if (image_count == 1200): a = time.perf_counter() - a print(a) # terminal prints if image_count % 20 == 0: print( " total: %4.1fms (%4.1ffps) " " receiving %4.1f (%4.1f%%) " " decoding %4.1f (%4.1f%%) " " verifying %4.1f (%4.1f%%) " " preprocessing %4.1f (%4.1f%%) " " model inference %4.1f (%4.1f%%) " " postprocessing %4.1f (%4.1f%%) " " signing %4.1f (%4.1f%%) " " replying %4.1f (%4.1f%%) " " display %4.1f (%4.1f%%) " % ( 1000 / moving_average_fps.get_moving_average(), moving_average_fps.get_moving_average(), moving_average_receive_time.get_moving_average() * 1000, moving_average_receive_time.get_moving_average() / total_time * 100, moving_average_decompress_time.get_moving_average() * 1000, moving_average_decompress_time.get_moving_average() / total_time * 100, moving_average_verify_image_sig_time. get_moving_average() * 1000, moving_average_verify_image_sig_time. get_moving_average() / total_time * 100, moving_average_img_preprocessing_time. get_moving_average() * 1000, moving_average_img_preprocessing_time. get_moving_average() / total_time * 100, moving_average_model_inference_time.get_moving_average( ) * 1000, moving_average_model_inference_time.get_moving_average( ) / total_time * 100, moving_average_img_postprocessing_time. get_moving_average() * 1000, moving_average_img_postprocessing_time. get_moving_average() / total_time * 100, moving_average_response_signing_time. get_moving_average() * 1000, moving_average_response_signing_time. get_moving_average() / total_time * 100, moving_average_reply_time.get_moving_average() * 1000, moving_average_reply_time.get_moving_average() / total_time * 100, moving_average_image_show_time.get_moving_average() * 1000, moving_average_image_show_time.get_moving_average() / total_time * 100, ), end='\r') # counter image_count += 1
class ChainPointV2(object): def __init__(self, hash_type="sha256"): self.hash_type = hash_type.lower() self.mk = MerkleTools(hash_type) '''Wraps merkletools method''' def reset_tree(self): self.mk.reset_tree() '''Wraps merkletools method''' def add_leaf(self, values, do_hash=False): self.mk.add_leaf(values, do_hash) '''Wraps merkletools method''' def get_leaf(self, index): return self.mk.get_leaf(index) '''Wraps merkletools method''' def get_leaf_count(self): return self.mk.get_leaf_count() '''Wraps merkletools method''' def get_tree_ready_state(self): return self.mk.get_tree_ready_state() '''Wraps merkletools method''' def make_tree(self): self.mk.make_tree() '''Wraps merkletools method''' def get_merkle_root(self): return self.mk.get_merkle_root() '''Wraps merkletools method''' def get_proof(self, index): return self.mk.get_proof(index) '''Wraps merkletools method''' def validate_proof(self, proof, target_hash, merkle_root): return self.mk.validate_proof(proof, target_hash, merkle_root) def get_chainpoint_hash_type(self): return CHAINPOINT_HASH_TYPES[self.hash_type] ''' Returns the chainpoint v2 blockchain receipt for specific leaf Currently only works for BTC anchors ''' def get_receipt(self, index, btc_source_id): if self.get_tree_ready_state(): return { "@context": CHAINPOINT_CONTEXT, "type": self.get_chainpoint_hash_type(), "targetHash": self.get_leaf(index), "merkleRoot": self.get_merkle_root(), "proof": self.get_proof(index), "anchors": [{ "type": "BTCOpReturn", "sourceId": btc_source_id }] } else: return None ''' Validates a chainpoint receipt. Currently only for BTC anchors receipt is the chainpoint_proof metadata from the pdf file. certificate_hash is the hash of the certificate after we removed the chainpoint_proof metadata issuer_identifier is a fixed 8 bytes issuer code that displays on the blockchain testnet specifies if testnet or mainnet was used ''' # TODO consider using exceptions instead of (bool, text) tuples; this is # really only needed for valid but soon to expire def validate_receipt(self, receipt, certificate_hash, issuer_identifier='', testnet=False): # check context and hash type if (receipt['@context'].lower() != CHAINPOINT_CONTEXT): return False, "wrong chainpoint context" if (receipt['type'] not in CHAINPOINT_HASH_TYPES.values()): return False, "type not in CHAINPOINT_HASH_TYPES" target_hash = receipt['targetHash'] merkle_root = receipt['merkleRoot'] proof = receipt['proof'] # validate actual hash if target_hash.lower() != certificate_hash.lower(): return False, "certificate hash is different than the one in receipt" # validate merkle proof if (not self.validate_proof(proof, target_hash, merkle_root)): return False, "certificate's hash is not in merkle root" txid = self.get_txid_from_receipt(receipt) # validate anchor op_return_hex = network_utils.get_op_return_hex_from_blockchain( txid, testnet) # ignore issuer_identifier for now (it is string in CRED but used to be # hex so we need a smart way to get it) -- TODO: obsolete it !!! #issuer_id_hex = utils.text_to_hex(issuer_identifier) # if op_return starts with CRED it is using the meta-protocol op_dict = cred_protocol.parse_op_return_hex(op_return_hex) if op_dict: version_hex = op_dict['version'] command_hex = op_dict['cmd'] # could check if it is equal to issuer_id_hex issuer_hex = op_dict['data']['issuer_identifier'] # get merkle root hash_hex = op_dict['data']['merkle_root'] # if issue with expiry get expiry date if command_hex == cred_protocol.hex_op('op_issue_abs_expiry'): expiry_hex = op_return_hex[96:116] else: expiry_hex = None #print(version_hex) #print(command_hex) #print(issuer_hex) #print(hash_hex) #print(merkle_root.lower()) # otherwise op_return should be fixed to 7 bytes or 14 hex chars (old prefix method) else: ignore_hex_chars = 14 hash_hex = op_return_hex[ignore_hex_chars:] if (not merkle_root.lower() == hash_hex.lower()): return False, "certificate's merkle root is different than the one in the blockchain" # only for CRED protocol certificates check expiration date if # issued with expiry date if op_dict and expiry_hex: expiry = utils.hex_to_int(expiry_hex) if expiry > int(time.time()): return True, "valid until: " + str(expiry) else: return False, "certificate expired at: " + str(expiry) return True, None # def get_op_return_hex_from_blockchain(self, txid, testnet): # # uses blockcypher API for now -- TODO: expand to consult multiple services # if testnet: # blockcypher_url = "https://api.blockcypher.com/v1/btc/test3/txs/" + txid # else: # blockcypher_url = "https://api.blockcypher.com/v1/btc/main/txs/" + txid # # response = requests.get(blockcypher_url).json() # outputs = response['outputs'] # hash_hex = "" # for o in outputs: # script = o['script'] # if script.startswith('6a'): # # when > 75 op_pushdata1 (4c) is used before length # if script.startswith('6a4c'): # # 2 for 1 byte op_return + 2 for 1 byte op_pushdata1 + 2 for 1 byte data length # ignore_hex_chars = 6 # else: # # 2 for 1 byte op_return + 2 for 1 byte data length # ignore_hex_chars = 4 # # hash_hex = script[ignore_hex_chars:] # break # return hash_hex def get_txid_from_receipt(self, receipt): # get anchor # TODO currently gets only the first valid (BTC) anchor anchors = receipt['anchors'] txid = '' for a in anchors: if a['type'] in CHAINPOINT_ANCHOR_TYPES.values(): txid = a['sourceId'] break return txid
class ChainPointV2(object): def __init__(self, hash_type="sha256"): self.hash_type = hash_type.lower() self.mk = MerkleTools(hash_type) '''Wraps merkletools method''' def reset_tree(self): self.mk.reset_tree() '''Wraps merkletools method''' def add_leaf(self, values, do_hash=False): self.mk.add_leaf(values, do_hash) '''Wraps merkletools method''' def get_leaf(self, index): return self.mk.get_leaf(index) '''Wraps merkletools method''' def get_leaf_count(self): return self.mk.get_leaf_count() '''Wraps merkletools method''' def get_tree_ready_state(self): return self.mk.get_tree_ready_state() '''Wraps merkletools method''' def make_tree(self): self.mk.make_tree() '''Wraps merkletools method''' def get_merkle_root(self): return self.mk.get_merkle_root() '''Wraps merkletools method''' def get_proof(self, index): return self.mk.get_proof(index) '''Wraps merkletools method''' def validate_proof(self, proof, target_hash, merkle_root): return self.mk.validate_proof(proof, target_hash, merkle_root) def get_chainpoint_hash_type(self): return CHAINPOINT_HASH_TYPES[self.hash_type] ''' Returns the chainpoint v2 blockchain receipt for specific leaf Currently only works for bitcoin and litecoin anchors ''' def get_receipt(self, index, source_id, chain, testnet): chain_type = utils.get_chain_type(chain, testnet) if(chain_type is not None and self.get_tree_ready_state()): return { "@context": CHAINPOINT_CONTEXT, "type": self.get_chainpoint_hash_type(), "targetHash": self.get_leaf(index), "merkleRoot": self.get_merkle_root(), "proof": self.get_proof(index), "anchors": [ { "type": CHAINPOINT_ANCHOR_TYPES[chain_type], "sourceId": source_id } ] } else: return None ''' Validates a chainpoint receipt. Currently for BTC and LTC anchors receipt is the chainpoint_proof metadata from the pdf file. certificate_hash is the hash of the certificate after we removed the chainpoint_proof metadata issuer_identifier is a fixed 8 bytes issuer code that displays on the blockchain ''' # TODO consider using exceptions instead of (bool, text) tuples; this is # really only needed for valid but soon to expire def validate_receipt(self, receipt, op_return_hex, certificate_hash, issuer_identifier=''): # check context and hash type if(receipt['@context'].lower() != CHAINPOINT_CONTEXT): return False, "wrong chainpoint context" if(receipt['type'] not in CHAINPOINT_HASH_TYPES.values()): return False, "chainpoint type not in CHAINPOINT_HASH_TYPES" # currently only one anchor at a time is allowed; thus 0 if(receipt['anchors'][0]['type'] not in CHAINPOINT_ANCHOR_TYPES.values()): return False, "anchor type not in CHAINPOINT_ANCHOR_TYPES" target_hash = receipt['targetHash'] merkle_root = receipt['merkleRoot'] proof = receipt['proof'] # validate actual hash if target_hash.lower() != certificate_hash.lower(): return False, "certificate hash is different than the one in receipt" # validate merkle proof if(not self.validate_proof(proof, target_hash, merkle_root)): return False, "certificate's hash is not in merkle root" # ignore issuer_identifier for now (it is string in CRED but used to be # hex so we need a smart way to get it) -- TODO: obsolete it !!! #issuer_id_hex = utils.text_to_hex(issuer_identifier) # if op_return starts with CRED it is using the meta-protocol op_dict = cred_protocol.parse_op_return_hex(op_return_hex) if op_dict: version_hex = op_dict['version'] command_hex = op_dict['cmd'] # could check if it is equal to issuer_id_hex issuer_hex = op_dict['data']['issuer_identifier'] # get merkle root hash_hex = op_dict['data']['merkle_root'] # if issue with expiry get expiry date if command_hex == cred_protocol.hex_op('op_issue_abs_expiry'): expiry_hex = op_return_hex[96:116] else: expiry_hex = None #print(version_hex) #print(command_hex) #print(issuer_hex) #print(hash_hex) #print(merkle_root.lower()) # otherwise op_return should be fixed to 7 bytes or 14 hex chars (old prefix method) else: ignore_hex_chars = 14 hash_hex = op_return_hex[ignore_hex_chars:] if(not merkle_root.lower() == hash_hex.lower()): return False, "certificate's merkle root is different than the one in the blockchain" # only for CRED protocol certificates check expiration date if # issued with expiry date if op_dict and expiry_hex: expiry = utils.hex_to_int(expiry_hex) if expiry > int(time.time()): return True, "valid until: " + str(expiry) else: return False, "certificate expired at: " + str(expiry) return True, None # TODO: DELETE - NOT USED ANYWHERE !! def get_chain_testnet_txid_from_receipt(self, receipt): # get anchor # TODO currently gets only the first valid anchor anchors = receipt['anchors'] chain = '' testnet = False txid = '' for a in anchors: if a['type'] in CHAINPOINT_ANCHOR_TYPES.values(): if(a['type'] == 'BTCOpReturn'): chain = 'bitcoin' testnet = False elif(a['type'] == 'LTCOpReturn'): chain = 'litecoin' testnet = False elif(a['type'] == 'BTCTestnetOpReturn'): chain = 'bitcoin' testnet = True elif(a['type'] == 'LTCTestnetOpReturn'): chain = 'litecoin' testnet = True txid = a['sourceId'] break return chain, testnet, txid
def _run3(self, merkle_tree_interval, contractHash, hostname, sendingPort): self._readyToReceive.set() sk = SigningKey(Parameters.private_key_self) dont_show = Parameters.dont_show if Parameters.is_contractor == True: display_name = 'Contractor' else: display_name = 'Verifier' responder = re.Responder(hostname, sendingPort) if merkle_tree_interval > 0: mt = MerkleTools() mtOld = MerkleTools() interval_count = 0 mtOld_leaf_indices = {} mt_leaf_indices = {} current_challenge = 1 merkle_root = '' last_challenge = 0 while not self._stop: self._received.wait() self._received.clear() boxtext = self._data3[0] image = self._data3[1] name = self._data3[2] self._image_count = self._data3[3] if merkle_tree_interval == 0: sig = sk.sign(boxtext.encode('latin1') + contractHash).signature sig = sig.decode('latin1') # send reply responder.respond(boxtext + ';--' + sig) else: image_count = self._image_count outsorucer_signature = name[:-5] outsourcer_image_count = name[-5] outsourcer_number_of_outputs_received = name[-4] outsourcer_random_number = name[-3] outsourcer_interval_count = name[-2] outsourcer_time_to_challenge = bool(name[-1]) mt.add_leaf(boxtext, True) mt_leaf_indices[ outsourcer_image_count] = image_count % merkle_tree_interval response = boxtext # time to send a new merkle root # e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree if image_count > 1 and (image_count + 1) % merkle_tree_interval == 0: mt.make_tree() merkle_root = mt.get_merkle_root() sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root # resond with merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') interval_count += 1 mtOld = mt # save old merkle tree for challenge mtOld_leaf_indices.clear() mtOld_leaf_indices = mt_leaf_indices.copy( ) # save old indices for challenge mt_leaf_indices.clear() # clear for new indices mt = MerkleTools( ) # construct new merkle tree for next interval else: # if this is true then the outsourcer has not received the merkle root yet -> send again if interval_count > outsourcer_image_count: sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') else: # in this case outsourcer has confirmed to have recieved the merkle root # in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again if outsourcer_time_to_challenge and image_count - last_challenge > 3: last_challenge = image_count if outsourcer_random_number in mtOld_leaf_indices: # if challenge can be found, send proof back outsourcer_random_number_index = mtOld_leaf_indices[ outsourcer_random_number] else: # if challenge index cannot be found return leaf 0 outsourcer_random_number_index = 0 proofs = mtOld.get_proof( outsourcer_random_number_index) stringsend = '' for proof in proofs: stringsend += ';--' # indicate start of proof stringsend += proof.__str__() # send proof stringsend += ';--' # send leaf stringsend += mtOld.get_leaf( outsourcer_random_number_index) stringsend += ';--' stringsend += mtOld.get_merkle_root() # send root stringarr = [] stringarr = stringsend.split(';--') leaf_node = stringarr[-2] root_node = stringarr[-1] proof_string = stringarr[0:-2] sig = sk.sign( str(stringarr[1:]).encode('latin1') + bytes(interval_count - 1) + contractHash ).signature # sign proof and contract details # attach signature response += ';--' + sig.decode('latin1') response += stringsend # attach challenge response to response responder.respond(response) # display image if not dont_show: # image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imshow(display_name, image) if cv2.waitKey(1) == ord('q'): responder.respond('abort12345:6') if self._stop: sys.exit(self._stop_message) else: self._stop = True self._stop_message = 'Contract aborted: Contractor ended contract according to custom' print(self._stop_message) sys.exit(self._stop_message) self._readyToReceive.set()
class MerkleTreeGenerator(object): def __init__(self): self.tree = MerkleTools(hash_type='sha256') def populate(self, node_generator): """ Populate Merkle Tree with data from node_generator. This requires that node_generator yield byte[] elements. Hashes, computes hex digest, and adds it to the Merkle Tree :param node_generator: :return: """ for data in node_generator: hashed = hash_byte_array(data) self.tree.add_leaf(hashed) def get_blockchain_data(self): """ Finalize tree and return byte array to issue on blockchain :return: """ self.tree.make_tree() merkle_root = self.tree.get_merkle_root() return h2b(ensure_string(merkle_root)) def get_proof_generator(self, tx_id, app_config, verification_method, chain=Chain.bitcoin_mainnet): """ Returns a generator (1-time iterator) of proofs in insertion order. :param tx_id: blockchain transaction id :return: """ root = ensure_string(self.tree.get_merkle_root()) node_count = len(self.tree.leaves) for index in range(0, node_count): proof = self.tree.get_proof(index) proof2 = [] #Change back to smart contract proof & verification for p in proof: dict2 = dict() for key, value in p.items(): dict2[key] = ensure_string(value) proof2.append(dict2) target_hash = ensure_string(self.tree.get_leaf(index)) """ Add additional parameters for smart contract certification """ if app_config.issuing_method == "smart_contract": from cert_issuer.blockchain_handlers.ethereum_sc.ens import ENSConnector ens = ENSConnector(app_config) abi = ens.get_abi() mp2019 = MerkleProof2019() print(helpers.tx_to_blink(chain, tx_id)) merkle_json = { "path": proof2, "merkleRoot": root, "targetHash": target_hash, #Possibly adjust anchor to merkle_proof dict "anchors": [helpers.tx_to_blink(chain, tx_id)] } logging.info('merkle_json: %s', str(merkle_json)) proof_value = mp2019.encode(merkle_json) merkle_proof = { "type": "MerkleProof2019", "created": datetime.now().isoformat(), "proofValue": proof_value.decode('utf8'), "proofPurpose": "assertionMethod", "verificationMethod": verification_method, #Add ENS name for issuer validation "ens_name": app_config.ens_name } #Uncomment after checking verification """ "anchors": [{ #helpers.tx_to_blink(chain, tx_id), "sourceId": to_source_id(tx_id, chain), "type": "ETHSmartContract", "contract_address": app_config.contract_address, "ens_name": app_config.ens_name, "contract_abi": abi }] """ else: mp2019 = MerkleProof2019() merkle_json = { "path": proof2, "merkleRoot": root, "targetHash": target_hash, "anchors": [helpers.tx_to_blink(chain, tx_id)] } logging.info('merkle_json: %s', str(merkle_json)) proof_value = mp2019.encode(merkle_json) merkle_proof = { "type": "MerkleProof2019", "created": datetime.now().isoformat(), "proofValue": proof_value.decode('utf8'), "proofPurpose": "assertionMethod", "verificationMethod": verification_method } yield merkle_proof
mempool = list(map(str, temp.split(","))) mt = MerkleTools(hash_type="sha256") s=input("Enter txn id to check:") txn= str(s) for i in range(len(mempool)): mt.add_leaf(mempool[i]) mt.make_tree() proof=mt.get_proof(mempool.index(txn)+1) if mt.validate_proof(proof, mt.get_leaf(mempool.index(txn)+1), mt.get_merkle_root())==True: print("Transaction is in mempool") print("Witness:", proof) else: print("Transaction not in mempool")
myMerkleT.add_leaf(["Security", "Room14", "Professor"], True) # My first leaves. myMerkleT.add_leaf(["Room12", "blockchain", "Python"], True) # This adds three leaves to the Tree. myMerkleT.add_leaf(["Name:Justice", "Course:Computer Science"], True) # Another three leaves. myMerkleT.make_tree() # Creating the Merkle Tree. print('') numberOfLeaves = myMerkleT.get_leaf_count() print("The number of leaves of this tree is: ", numberOfLeaves) print("root:", myMerkleT.get_merkle_root()) print("The value at leaf 2 is: ", myMerkleT.get_leaf(2)) print("The array of hash objects for the leaf at index 2 is: ", myMerkleT.get_proof(2)) print('') print('************************ Merkle Proof ****************************') print(myMerkleT.validate_proof(myMerkleT.get_proof(2), myMerkleT.get_leaf(2), myMerkleT.get_merkle_root())) # True print('************************ Merkle Proof ****************************') TestData = ["My Professor is helping me to learn well."] def DataTest(testItem): dataPrep = str(json.dumps(TestData)) testItem = (sha256(dataPrep.encode())).hexdigest() return testItem
def main(_argv): # get paramters and contract details vk = VerifyKey(OutsourceContract.public_key_outsourcer) sk = SigningKey(Parameters.private_key_contractor) model = OutsourceContract.model framework = Parameters.framework tiny = OutsourceContract.tiny weights = Parameters.weights count = Parameters.count dont_show = Parameters.dont_show info = Parameters.info crop = Parameters.crop input_size = Parameters.input_size iou = Parameters.iou score = Parameters.score merkle_tree_interval = OutsourceContract.merkle_tree_interval hostname = Parameters.ip_outsourcer # Use to receive from other computer port = Parameters.port_outsourcer sendingPort = Parameters.sendingPort minimum_receive_rate_from_contractor = Parameters.minimum_receive_rate_from_contractor contractHash = Helperfunctions.hashContract().encode('latin1') # print(contractHash) # configure video stream receiver receiver = vss.VideoStreamSubscriber(hostname, port) time.sleep(2) preProcesser = Preprocesser(receiver, vk, merkle_tree_interval, minimum_receive_rate_from_contractor) time.sleep(2) print('RPi Stream -> Receiver Initialized') # time.sleep(1.0) # configure gpu usage config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) # load model if framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=weights) else: saved_model_loaded = tf.saved_model.load( weights, tags=[tag_constants.SERVING]) # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # configure responder responder = re.Responder(hostname, sendingPort) # statistics info moving_average_points = 50 # statistics moving_average_fps = MovingAverage(moving_average_points) moving_average_receive_time = MovingAverage(moving_average_points) moving_average_decompress_time = MovingAverage(moving_average_points) #moving_average_model_load_image_time = MovingAverage(moving_average_points) moving_average_img_preprocessing_time = MovingAverage( moving_average_points) moving_average_model_inference_time = MovingAverage(moving_average_points) moving_average_img_postprocessing_time = MovingAverage( moving_average_points) moving_average_reply_time = MovingAverage(moving_average_points) moving_average_image_show_time = MovingAverage(moving_average_points) moving_average_verify_image_sig_time = MovingAverage(moving_average_points) moving_average_response_signing_time = MovingAverage(moving_average_points) image_count = 0 a = 0 b = 0 if merkle_tree_interval > 0: mt = MerkleTools() mtOld = MerkleTools() interval_count = 0 mtOld_leaf_indices = {} mt_leaf_indices = {} #rendundancy_counter = 0 #rendundancy_counter2 = 0 current_challenge = 1 merkle_root = '' #stringsend = '' last_challenge = 0 while True: start_time = time.perf_counter() data = preProcesser.receive() images_data = data[0] name = data[1] received_time = time.perf_counter() decompressed_time = time.perf_counter() verify_time = time.perf_counter() image_preprocessing_time = time.perf_counter() # receive image # region # name[:-2] image signature, name # inference # region if framework == 'tflite': interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [interpreter.get_tensor( output_details[i]['index']) for i in range(len(output_details))] if model == 'yolov3' and tiny == True: boxes, pred_conf = filter_boxes( pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: boxes, pred_conf = filter_boxes( pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size])) else: infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] # endregion model_inferenced_time = time.perf_counter() # image postprocessing # region h = time.perf_counter() boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=iou, score_threshold=score ) # 1.2ms # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = original_image.shape bboxes = utils.format_boxes( boxes.numpy()[0], original_h, original_w) # 1ms # hold all detection data in one variable pred_bbox = [bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0]] # by default allow all classes in .names file allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only people) #allowed_classes = ['person'] # if crop flag is enabled, crop each detection and save it as new image if crop: crop_path = os.path.join( os.getcwd(), 'detections', 'crop', image_name) try: os.mkdir(crop_path) except FileExistsError: pass crop_objects(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB), pred_bbox, crop_path, allowed_classes) if count: # count objects found counted_classes = count_objects( pred_bbox, by_class=False, allowed_classes=allowed_classes) # loop through dict and print for key, value in counted_classes.items(): print("Number of {}s: {}".format(key, value)) boxtext, image = utils.draw_bbox( original_image, pred_bbox, info, counted_classes, allowed_classes=allowed_classes) else: boxtext, image = utils.draw_bbox( original_image, pred_bbox, info, allowed_classes=allowed_classes) # 0.5ms image = Image.fromarray(image.astype(np.uint8)) # 0.3ms # endregion if merkle_tree_interval == 0: boxtext = 'Image' + str(name[-2]) + ':;' + boxtext else: boxtext = 'Image' + str(outsourcer_image_count) + ':;' + boxtext image_postprocessing_time = time.perf_counter() # sign message ->need to add image_count/interval_count (for merkle tree sig), contract hash to output and verificaton if merkle_tree_interval == 0: #sig = sk.sign_deterministic(boxtext.encode('latin1')) sig = sk.sign(boxtext.encode('latin1') + contractHash).signature #sig = list(sig) sig = sig.decode('latin1') # send reply responder.respond(boxtext + ';--' + sig) else: # print(image_count) mt.add_leaf(boxtext, True) #add leafs dynamiclly to merkle tree mt_leaf_indices[outsourcer_image_count] = image_count % merkle_tree_interval #remember indices for challenge #print(image_count % merkle_tree_interval) response = boxtext # time to send a new merkle root if image_count > 1 and (image_count+1) % merkle_tree_interval == 0: #e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree #print(image_count) a = time.perf_counter() #rendundancy_counter = 2 mt.make_tree() merkle_root = mt.get_merkle_root() sig = sk.sign(merkle_root.encode( 'latin1') + bytes(interval_count) + contractHash).signature # sign merkle root # resond with merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') interval_count += 1 mtOld = mt # save old merkle tree for challenge #mtOld_leaf_indices.clear() # clear old indices mtOld_leaf_indices.clear() mtOld_leaf_indices = mt_leaf_indices.copy() #save old indices for challenge #print(mtOld_leaf_indices) mt_leaf_indices.clear() #clear for new indices #mt_leaf_indices = {} mt = MerkleTools() # construct new merkle tree for next interval te = time.perf_counter()-a # print('1', te, image_count) else: if interval_count > outsourcer_image_count : #if this is true then the outsourcer has not received the merkle root yet -> send again sig = sk.sign(merkle_root.encode( 'latin1') + bytes(interval_count) + contractHash).signature # sign merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') # print('2', image_count) else: # in this case outsourcer has confirmed to have recieved the merkle root if outsourcer_time_to_challenge and image_count - last_challenge > 3: #in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again last_challenge = image_count if outsourcer_random_number in mtOld_leaf_indices: outsourcer_random_number_index = mtOld_leaf_indices[outsourcer_random_number] #if challenge can be found, send proof back else: outsourcer_random_number_index = 0 #if challenge index cannot be found return leaf 0 #print('proof index not found') proofs = mtOld.get_proof(outsourcer_random_number_index) stringsend = '' for proof in proofs: stringsend += ';--' # indicate start of proof stringsend += proof.__str__() # send proof stringsend += ';--' # send leaf stringsend += mtOld.get_leaf(outsourcer_random_number_index) stringsend += ';--' stringsend += mtOld.get_merkle_root() # send root stringarr = [] stringarr = stringsend.split(';--') leaf_node = stringarr[-2] root_node = stringarr[-1] proof_string = stringarr[0:-2] sig = sk.sign(str(stringarr[1:]).encode('latin1') + bytes(interval_count-1) + contractHash).signature # sign proof and contract details #print(str(stringarr).encode('latin1') + bytes(interval_count-1) + contractHash) #print(stringarr) # attach signature response += ';--' + sig.decode('latin1') response += stringsend # attach challenge response to response # print('3', te, image_count) responder.respond(response) response_signing_time = time.perf_counter() # print(response_signing_time- image_postprocessing_time) replied_time = time.perf_counter() # display image if not dont_show: # image.show() image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imshow('raspberrypi', image) if cv2.waitKey(1) == ord('q'): responder.respond('abort12345:6') sys.exit( 'Contract aborted: Contractor ended contract according to custom') image_showed_time = time.perf_counter() # statistics moving_average_fps.add(1 / (image_showed_time - start_time)) moving_average_receive_time.add(received_time - start_time) moving_average_decompress_time.add(decompressed_time - received_time) moving_average_verify_image_sig_time.add( verify_time - decompressed_time) moving_average_img_preprocessing_time.add( image_preprocessing_time - verify_time) moving_average_model_inference_time.add( model_inferenced_time - image_preprocessing_time) moving_average_img_postprocessing_time.add( image_postprocessing_time - model_inferenced_time) moving_average_response_signing_time.add( response_signing_time - image_postprocessing_time) # adjust for merkle root moving_average_reply_time.add(replied_time - response_signing_time) moving_average_image_show_time.add(image_showed_time - replied_time) total_time = moving_average_receive_time.get_moving_average() \ + moving_average_decompress_time.get_moving_average() \ + moving_average_verify_image_sig_time.get_moving_average() \ + moving_average_img_preprocessing_time.get_moving_average() \ + moving_average_model_inference_time.get_moving_average() \ + moving_average_img_postprocessing_time.get_moving_average() \ + moving_average_response_signing_time.get_moving_average() \ + moving_average_reply_time.get_moving_average() \ + moving_average_image_show_time.get_moving_average() if(image_count == 800): a = time.perf_counter() if(image_count == 1200): a = time.perf_counter() - a print(a) # terminal prints if image_count % 20 == 0: print(" total: %4.1fms (%4.1ffps) " " receiving %4.1f (%4.1f%%) " " decoding %4.1f (%4.1f%%) " " verifying %4.1f (%4.1f%%) " " preprocessing %4.1f (%4.1f%%) " " model inference %4.1f (%4.1f%%) " " postprocessing %4.1f (%4.1f%%) " " signing %4.1f (%4.1f%%) " " replying %4.1f (%4.1f%%) " " display %4.1f (%4.1f%%) " % ( 1000/moving_average_fps.get_moving_average(), moving_average_fps.get_moving_average(), moving_average_receive_time.get_moving_average()*1000, moving_average_receive_time.get_moving_average() / total_time * 100, moving_average_decompress_time.get_moving_average()*1000, moving_average_decompress_time.get_moving_average() / total_time * 100, moving_average_verify_image_sig_time.get_moving_average()*1000, moving_average_verify_image_sig_time.get_moving_average() / total_time * 100, moving_average_img_preprocessing_time.get_moving_average()*1000, moving_average_img_preprocessing_time.get_moving_average() / total_time * 100, moving_average_model_inference_time.get_moving_average()*1000, moving_average_model_inference_time.get_moving_average() / total_time * 100, moving_average_img_postprocessing_time.get_moving_average()*1000, moving_average_img_postprocessing_time.get_moving_average() / total_time * 100, moving_average_response_signing_time.get_moving_average()*1000, moving_average_response_signing_time.get_moving_average() / total_time * 100, moving_average_reply_time.get_moving_average() * 1000, moving_average_reply_time.get_moving_average() / total_time * 100, moving_average_image_show_time.get_moving_average()*1000, moving_average_image_show_time.get_moving_average() / total_time * 100,), end='\r') # counter image_count += 1
from merkletools import MerkleTools mt = MerkleTools(hash_type="md5") list_data = ['Hello', 'World', 'Is', 'First'] mt.add_leaf(list_data, True) mt.make_tree() print(mt.get_leaf(0)) print(mt.get_leaf(1)) print(mt.get_leaf(2)) print(mt.get_leaf(3)) print(mt.get_proof(0)) print(mt.get_merkle_root())
from merkletools import MerkleTools mt = MerkleTools() mt.add_leaf("tierion", True) mt.add_leaf(["bitcoin", "blockchain"], True) mt.make_tree() print mt.get_leaf_count() print "root:", mt.get_merkle_root( ) # root: '777765f15d171871b00034ee55e48ffdf76afbc44ed0bcff5c82f31351d333c2ed1' print mt.get_proof( 1 ) # [{left: '2da7240f6c88536be72abe9f04e454c6478ee29709fc3729ddfb942f804fbf08'}, # {right: 'ef7797e13d3a75526946a3bcf00daec9fc9c9c4d51ddc7cc5df888f74dd434d1'}] print mt.validate_proof(mt.get_proof(1), mt.get_leaf(1), mt.get_merkle_root())
def main(_argv): # get paramters and contract details if Parameters.is_contractor == True: # checks if this machine is outsourcer or verifier vk = VerifyKey(OutsourceContract.public_key_outsourcer) contractHash = Helperfunctions.hashContract().encode('latin1') model_to_use = OutsourceContract.model tiny = OutsourceContract.tiny merkle_tree_interval = OutsourceContract.merkle_tree_interval display_name = 'Contractor' else: vk = VerifyKey(VerifierContract.public_key_outsourcer) contractHash = Helperfunctions.hashVerifierContract().encode('latin1') model_to_use = VerifierContract.model tiny = VerifierContract.tiny merkle_tree_interval = 0 display_name = 'Verifier' sk = SigningKey(Parameters.private_key_self) framework = Parameters.framework weights = Parameters.weights count = Parameters.count dont_show = Parameters.dont_show info = Parameters.info crop = Parameters.crop input_size = Parameters.input_size iou = Parameters.iou score = Parameters.score hostname = Parameters.ip_outsourcer port = Parameters.port_outsourcer sendingPort = Parameters.sendingPort minimum_receive_rate_from_contractor = Parameters.minimum_receive_rate_from_contractor # configure video stream receiver receiver = vss.VideoStreamSubscriber(hostname, port) print('Receiver Initialized') # configure gpu usage config = ConfigProto() config.gpu_options.allow_growth = True session = InteractiveSession(config=config) # load model if framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=weights) else: saved_model_loaded = tf.saved_model.load(weights, tags=[tag_constants.SERVING]) # read in all class names from config class_names = utils.read_class_names(cfg.YOLO.CLASSES) # configure responder responder = re.Responder(hostname, sendingPort) # configure and iniitialize statistic variables moving_average_points = 50 moving_average_fps = MovingAverage(moving_average_points) moving_average_receive_time = MovingAverage(moving_average_points) moving_average_decompress_time = MovingAverage(moving_average_points) moving_average_img_preprocessing_time = MovingAverage( moving_average_points) moving_average_model_inference_time = MovingAverage(moving_average_points) moving_average_img_postprocessing_time = MovingAverage( moving_average_points) moving_average_reply_time = MovingAverage(moving_average_points) moving_average_image_show_time = MovingAverage(moving_average_points) moving_average_verify_image_sig_time = MovingAverage(moving_average_points) moving_average_response_signing_time = MovingAverage(moving_average_points) image_count = 0 acknowledged_frames = 0 a = 0 b = 0 # configure Merkle tree related variables if merkle trees are to be used if merkle_tree_interval > 0: mt = MerkleTools() mtOld = MerkleTools() interval_count = 0 mtOld_leaf_indices = {} mt_leaf_indices = {} current_challenge = 1 merkle_root = '' last_challenge = 0 # start real time processing and verification while True: start_time = time.perf_counter() # receive image name, compressed = receiver.receive() if name == 'abort': sys.exit('Contract aborted by outsourcer according to custom') received_time = time.perf_counter() # decompress image decompressedImage = cv2.imdecode( np.frombuffer(compressed, dtype='uint8'), -1) decompressed_time = time.perf_counter() # verify image (verify if signature matches image, contract hash and image count, and number of outptuts received) if merkle_tree_interval == 0: try: vk.verify( bytes(compressed) + contractHash + bytes(name[-2]) + bytes(name[-1]), bytes(name[:-2])) except: sys.exit( 'Contract aborted: Outsourcer signature does not match input. Possible Consquences for Outsourcer: Blacklist, Bad Review' ) if name[-1] < (image_count - 2) * minimum_receive_rate_from_contractor or name[ -1] < acknowledged_frames: sys.exit( 'Contract aborted: Outsourcer did not acknowledge enough ouputs. Possible Consquences for Outsourcer: Blacklist, Bad Review' ) acknowledged_frames = name[-1] else: # verify if signature matches image, contract hash, and image count, and number of intervals, and random number try: vk.verify( bytes(compressed) + contractHash + bytes(name[-5]) + bytes(name[-4]) + bytes(name[-3]) + bytes(name[-2]) + bytes(name[-1]), bytes(name[:-5])) except: sys.exit( 'Contract aborted: Outsourcer signature does not match input. Possible Consquences for Outsourcer: Blacklist, Bad Review' ) if name[-4] < (image_count - 2) * minimum_receive_rate_from_contractor or name[ -4] < acknowledged_frames: sys.exit( 'Contract aborted: Outsourcer did not acknowledge enough ouputs. Possible Consquences for Outsourcer: Blacklist, Bad Review' ) acknowledged_frames = name[-4] outsorucer_signature = name[:-5] outsourcer_image_count = name[-5] outsourcer_number_of_outputs_received = name[-4] outsourcer_random_number = name[-3] outsourcer_interval_count = name[-2] outsourcer_time_to_challenge = bool(name[-1]) verify_time = time.perf_counter() # image preprocessing original_image = cv2.cvtColor(decompressedImage, cv2.COLOR_BGR2RGB) image_data = cv2.resize(original_image, (input_size, input_size)) # 0.4ms image_data = image_data / 255. # 2.53ms images_data = [] for i in range(1): images_data.append(image_data) images_data = np.asarray(images_data).astype(np.float32) # 3.15ms image_preprocessing_time = time.perf_counter() # inference if framework == 'tflite': interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() interpreter.set_tensor(input_details[0]['index'], images_data) interpreter.invoke() pred = [ interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details)) ] if model_to_use == 'yolov3' and tiny == True: boxes, pred_conf = filter_boxes(pred[1], pred[0], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant( [input_size, input_size])) else: infer = saved_model_loaded.signatures['serving_default'] batch_data = tf.constant(images_data) pred_bbox = infer(batch_data) for key, value in pred_bbox.items(): boxes = value[:, :, 0:4] pred_conf = value[:, :, 4:] model_inferenced_time = time.perf_counter() # image postprocessing # region h = time.perf_counter() boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression( boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)), scores=tf.reshape( pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])), max_output_size_per_class=50, max_total_size=50, iou_threshold=iou, score_threshold=score) # 1.2ms # format bounding boxes from normalized ymin, xmin, ymax, xmax ---> xmin, ymin, xmax, ymax original_h, original_w, _ = original_image.shape bboxes = utils.format_boxes(boxes.numpy()[0], original_h, original_w) # 1ms # hold all detection data in one variable pred_bbox = [ bboxes, scores.numpy()[0], classes.numpy()[0], valid_detections.numpy()[0] ] # by default allow all classes in .names file allowed_classes = list(class_names.values()) # custom allowed classes (uncomment line below to allow detections for only people) #allowed_classes = ['person'] # if crop flag is enabled, crop each detection and save it as new image if crop: crop_path = os.path.join(os.getcwd(), 'detections', 'crop', image_name) try: os.mkdir(crop_path) except FileExistsError: pass crop_objects(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB), pred_bbox, crop_path, allowed_classes) if count: # count objects found counted_classes = count_objects(pred_bbox, by_class=False, allowed_classes=allowed_classes) # loop through dict and print for key, value in counted_classes.items(): print("Number of {}s: {}".format(key, value)) boxtext, image = utils.draw_bbox(original_image, pred_bbox, info, counted_classes, allowed_classes=allowed_classes) else: boxtext, image = utils.draw_bbox( original_image, pred_bbox, info, allowed_classes=allowed_classes) # 0.5ms image = Image.fromarray(image.astype(np.uint8)) # 0.3ms # endregion # prepare response if merkle_tree_interval == 0: boxtext = 'Image' + str(name[-2]) + ':;' + boxtext else: boxtext = 'Image' + str(outsourcer_image_count) + ':;' + boxtext #boxtext += "Object found: Person" #dishonest image_postprocessing_time = time.perf_counter() if merkle_tree_interval == 0: sig = sk.sign(boxtext.encode('latin1') + contractHash).signature sig = sig.decode('latin1') # send reply responder.respond(boxtext + ';--' + sig) else: mt.add_leaf(boxtext, True) # add leafs dynamiclly to merkle tree # remember indices for challenge mt_leaf_indices[ outsourcer_image_count] = image_count % merkle_tree_interval response = boxtext # if statement is true then it's time to send a new merkle root # e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree if image_count > 1 and (image_count + 1) % merkle_tree_interval == 0: mt.make_tree() merkle_root = mt.get_merkle_root() #merkle_root = mt.get_leaf(0) #dishonest sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root # resond with merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') interval_count += 1 mtOld = mt # save old merkle tree for challenge mtOld_leaf_indices.clear() mtOld_leaf_indices = mt_leaf_indices.copy( ) # save old indices for challenge mt_leaf_indices.clear() # clear for new indices mt = MerkleTools( ) # construct new merkle tree for next interval else: # if statement is true then it's time to resend the merkle root because outsourcer has not received it yet # if this is true then the outsourcer has not received the merkle root yet -> send again if interval_count > outsourcer_image_count: sig = sk.sign( merkle_root.encode('latin1') + bytes(interval_count) + contractHash).signature # sign merkle root response += ';--' + str(merkle_root) + \ ';--' + sig.decode('latin1') else: # in this case outsourcer has confirmed to have recieved the merkle root # if statement is true then it's time to resond to a challenge from the outsourcer # in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again if outsourcer_time_to_challenge and image_count - last_challenge > 3: last_challenge = image_count if outsourcer_random_number in mtOld_leaf_indices: # if challenge can be found, send proof back outsourcer_random_number_index = mtOld_leaf_indices[ outsourcer_random_number] else: # if challenge index cannot be found return leaf 0 outsourcer_random_number_index = 0 proofs = mtOld.get_proof( outsourcer_random_number_index) stringsend = '' for proof in proofs: stringsend += ';--' # indicate start of proof stringsend += proof.__str__() # send proof stringsend += ';--' # send leaf stringsend += mtOld.get_leaf( outsourcer_random_number_index) stringsend += ';--' stringsend += mtOld.get_merkle_root() # send root stringarr = [] stringarr = stringsend.split(';--') leaf_node = stringarr[-2] root_node = stringarr[-1] proof_string = stringarr[0:-2] sig = sk.sign( str(stringarr[1:]).encode('latin1') + bytes(interval_count - 1) + contractHash ).signature # sign proof and contract details # attach signature response += ';--' + sig.decode('latin1') response += stringsend # attach challenge response to response responder.respond(response) response_signing_time = time.perf_counter() replied_time = time.perf_counter() # display image if not dont_show: image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) cv2.imshow(display_name, image) if cv2.waitKey(1) == ord('q'): responder.respond('abort12345:6') sys.exit( 'Contract aborted: Ended contract according to custom') image_showed_time = time.perf_counter() # statistics moving_average_fps.add(1 / (image_showed_time - start_time)) moving_average_receive_time.add(received_time - start_time) moving_average_decompress_time.add(decompressed_time - received_time) moving_average_verify_image_sig_time.add(verify_time - decompressed_time) moving_average_img_preprocessing_time.add(image_preprocessing_time - verify_time) moving_average_model_inference_time.add(model_inferenced_time - image_preprocessing_time) moving_average_img_postprocessing_time.add(image_postprocessing_time - model_inferenced_time) moving_average_response_signing_time.add( response_signing_time - image_postprocessing_time) # adjust for merkle root moving_average_reply_time.add(replied_time - response_signing_time) moving_average_image_show_time.add(image_showed_time - replied_time) total_time = moving_average_receive_time.get_moving_average() \ + moving_average_decompress_time.get_moving_average() \ + moving_average_verify_image_sig_time.get_moving_average() \ + moving_average_img_preprocessing_time.get_moving_average() \ + moving_average_model_inference_time.get_moving_average() \ + moving_average_img_postprocessing_time.get_moving_average() \ + moving_average_response_signing_time.get_moving_average() \ + moving_average_reply_time.get_moving_average() \ + moving_average_image_show_time.get_moving_average() # count seconds it takes to process 400 images after a 800 frames warm-up time if (image_count == 800): a = time.perf_counter() if (image_count == 1200): a = time.perf_counter() - a print(a) # terminal prints if image_count % 20 == 0: print( " total: %4.1fms (%4.1ffps) " " receiving %4.1f (%4.1f%%) " " decoding %4.1f (%4.1f%%) " " verifying %4.1f (%4.1f%%) " " preprocessing %4.1f (%4.1f%%) " " model inference %4.1f (%4.1f%%) " " postprocessing %4.1f (%4.1f%%) " " signing %4.1f (%4.1f%%) " " replying %4.1f (%4.1f%%) " " display %4.1f (%4.1f%%) " % ( 1000 / moving_average_fps.get_moving_average(), moving_average_fps.get_moving_average(), moving_average_receive_time.get_moving_average() * 1000, moving_average_receive_time.get_moving_average() / total_time * 100, moving_average_decompress_time.get_moving_average() * 1000, moving_average_decompress_time.get_moving_average() / total_time * 100, moving_average_verify_image_sig_time.get_moving_average() * 1000, moving_average_verify_image_sig_time.get_moving_average() / total_time * 100, moving_average_img_preprocessing_time.get_moving_average() * 1000, moving_average_img_preprocessing_time.get_moving_average() / total_time * 100, moving_average_model_inference_time.get_moving_average() * 1000, moving_average_model_inference_time.get_moving_average() / total_time * 100, moving_average_img_postprocessing_time.get_moving_average( ) * 1000, moving_average_img_postprocessing_time.get_moving_average( ) / total_time * 100, moving_average_response_signing_time.get_moving_average() * 1000, moving_average_response_signing_time.get_moving_average() / total_time * 100, moving_average_reply_time.get_moving_average() * 1000, moving_average_reply_time.get_moving_average() / total_time * 100, moving_average_image_show_time.get_moving_average() * 1000, moving_average_image_show_time.get_moving_average() / total_time * 100, ), end='\r') # counter image_count += 1
else: # if challenge index cannot be found return leaf 0 outsourcer_random_number_index = 0 #print('proof index not found') proofs = mtOld.get_proof( outsourcer_random_number_index) stringsend = '' for proof in proofs: stringsend += ';--' # indicate start of proof stringsend += proof.__str__() # send proof stringsend += ';--' # send leaf stringsend += mtOld.get_leaf( outsourcer_random_number_index) stringsend += ';--' stringsend += mtOld.get_merkle_root() # send root stringarr = [] stringarr = stringsend.split(';--') leaf_node = stringarr[-2] root_node = stringarr[-1] proof_string = stringarr[0:-2] sig = sk.sign(str(stringarr[1:]).encode('latin1') + bytes( interval_count-1) + contractHash).signature # sign proof and contract details # attach signature response += ';--' + sig.decode('latin1')