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')
