def evaluate(self, message): self.result_text.set("Waiting for evaluation result...") self.update() # Create, sign, and submit workorder # Convert workloadId to hex workload_id = "heart-disease-eval" workload_id = workload_id.encode("UTF-8").hex() session_iv = utility.generate_iv() session_key = utility.generate_key() encrypted_session_key = utility.generate_encrypted_key( session_key, worker_obj.encryption_key) requester_nonce = secrets.token_hex(32) work_order_id = secrets.token_hex(32) requester_id = secrets.token_hex(32) wo_submit_json = jrpc_request.WorkOrderSubmitJson( 3, 6000, "JSON-RPC", work_order_id, worker_id, workload_id, requester_id, encrypted_session_key, session_iv, requester_nonce, worker_encryption_key=base64.b64decode( worker_obj.encryption_key).hex(), data_encryption_algorithm="AES-GCM-256") wo_submit_json.add_in_data(message) private_key = utility.generate_signing_keys() direct_wrapper.init_work_order(config) # Set text for JSON sidebar self.request_json = json.dumps(json.loads( direct_wrapper.work_order_submit(wo_submit_json, encrypted_session_key, worker_obj, private_key, session_key, session_iv)), indent=4) # Retrieve result and set GUI result text wo_get_result_json = jrpc_request.WorkOrderGetResultJson( 4, work_order_id) self.result_json = json.dumps(direct_wrapper.work_order_get_result( wo_get_result_json, session_key, session_iv), indent=4) # Set text for JSON sidebar self.result_text.set( json.loads(self.result_json)["outData"][0]["data"]) # Retrieve receipt direct_wrapper.init_work_order_receipt(config) wo_receipt_retrieve_json = \ jrpc_request.WorkOrderReceiptRetrieveJson(5, work_order_id) # Set text for JSON sidebar self.receipt_json = \ json.dumps(direct_wrapper.work_order_receipt_retrieve( wo_receipt_retrieve_json), indent=4)
def __init__(self, work_order_id, worker_id, workload_id, requester_id, session_key, session_iv, requester_nonce, verifying_key=None, payload_format="JSON-RPC", response_timeout_msecs=6000, result_uri=None, notify_uri=None, worker_encryption_key=None, data_encryption_algorithm=None): self.params_obj = {} self.set_work_order_id(work_order_id) self.set_response_timeout_msecs(response_timeout_msecs) self.set_payload_format(payload_format) if result_uri: self.set_result_uri(result_uri) if notify_uri: self.set_notify_uri(notify_uri) self.set_worker_id(worker_id) self.set_workload_id(workload_id) self.set_requester_id(requester_id) if worker_encryption_key: self.set_worker_encryption_key( worker_encryption_key.encode("UTF-8").hex()) if data_encryption_algorithm: self.set_data_encryption_algorithm(data_encryption_algorithm) encrypted_session_key = utility.generate_encrypted_key( session_key, worker_encryption_key) self.set_encrypted_session_key( crypto.byte_array_to_hex(encrypted_session_key)) self.session_iv = session_iv self.set_session_key_iv(crypto.byte_array_to_hex(session_iv)) self.set_requester_nonce(requester_nonce) self.params_obj["encryptedRequestHash"] = "" self.params_obj["requesterSignature"] = "" self.params_obj["inData"] = [] self.session_key = session_key
def evaluate(self, message): self.result_text.set("Waiting for evaluation result...") self.update() # Create, sign, and submit workorder # Convert workloadId to hex workload_id = "heart-disease-eval" workload_id = workload_id.encode("UTF-8").hex() session_iv = utility.generate_iv() session_key = utility.generate_key() encrypted_session_key = utility.generate_encrypted_key( session_key, worker_obj.encryption_key) requester_nonce = secrets.token_hex(16) work_order_id = secrets.token_hex(32) requester_id = secrets.token_hex(32) wo_params = WorkOrderParams( work_order_id, worker_id, workload_id, requester_id, session_key, session_iv, requester_nonce, result_uri=" ", notify_uri=" ", worker_encryption_key=worker_obj.encryption_key, data_encryption_algorithm="AES-GCM-256" ) wo_params.add_in_data(message) private_key = utility.generate_signing_keys() wo_params.add_encrypted_request_hash() if wo_params.add_requester_signature(private_key) == False: logger.info("Work order request signing failed\n") sys.exit(1) # Set text for JSON sidebar req_id = 51 self.request_json = wo_params.to_string() work_order_instance = direct_jrpc.create_work_order( config ) response = work_order_instance.work_order_submit( wo_params.get_params(), wo_params.get_in_data(), wo_params.get_out_data(), id=req_id ) logger.info("Work order submit response : {}\n ".format( json.dumps(response, indent=4) )) if "error" in response and response["error"]["code"] != WorkOrderStatus.PENDING: sys.exit(1) req_id += 1 # Retrieve result and set GUI result text res = work_order_instance.work_order_get_result( work_order_id, req_id ) self.result_json = json.dumps(res, indent=4) if "result" in res: decrypted_res = utility.decrypted_response( json.dumps(res), session_key, session_iv ) # Set text for JSON sidebar self.result_text.set( decrypted_res[0]["data"]) # Retrieve receipt # Set text for JSON sidebar wo_receipt_instance = direct_jrpc.create_work_order_receipt( config ) req_id += 1 self.receipt_json = json.dumps( wo_receipt_instance.work_order_receipt_retrieve( work_order_id, req_id ), indent=4 )
def LocalMain(config): if not input_json_str and not input_json_dir: logger.error("JSON input file is not provided") exit(1) if not output_json_file_name: logger.error("JSON output file is not provided") exit(1) if not server_uri: logger.error("Server URI is not provided") exit(1) logger.info("Execute work order") uri_client = GenericServiceClient(server_uri) response = None wo_id = None if input_json_dir: directory = os.fsencode(input_json_dir) files = os.listdir(directory) for file in sorted(files): logger.info("---------------Input file name: %s ---------------\n", file.decode("utf-8")) input_json_str1 = futils.read_json_file( (directory.decode("utf-8") + file.decode("utf-8"))) # ----------------------------------------------------------------- # If Client request is WorkOrderSubmit, a requester payload's # signature with the requester private signing key is generated. if "WorkOrderSubmit" in input_json_str1: # Update workOrderId , workerId and workloadId input_json_obj = json.loads(input_json_str1) wo_id = hex(random.randint(1, 2**64 - 1)) input_json_obj["params"]["workOrderId"] = wo_id input_json_obj["params"]["workerId"] = worker_obj.worker_id # Convert workloadId to a hex string and update the request workload_id = input_json_obj["params"]["workloadId"] workload_id_hex = workload_id.encode("UTF-8").hex() input_json_obj["params"]["workloadId"] = workload_id_hex input_json_str1 = json.dumps(input_json_obj) # Generate session iv an encrypted session key session_iv = enclave_helper.generate_iv() session_key = enclave_helper.generate_key() encrypted_session_key = enclave_helper.generate_encrypted_key( session_key, worker_obj.encryption_key) input_json_str1, status = sig_obj.generate_client_signature( input_json_str1, worker_obj, private_key, session_key, session_iv, encrypted_session_key) if status != SignatureStatus.PASSED: logger.info("Generate signature failed\n") exit(1) if input_json_str1 is None: continue # ----------------------------------------------------------------- # Update the worker ID if response: if "workerId" in input_json_str1: # Retrieve the worker id from the "WorkerRetrieve" # response and update the worker id information for # further json requests. if "result" in response and "ids" in response[ "result"].keys(): input_json_final = json.loads(input_json_str1) worker_id = response["result"]["ids"][0] input_json_final["params"]["workerId"] = worker_id input_json_str1 = json.dumps(input_json_final) logger.info( "**********Worker details Updated with " "Worker ID*********\n%s\n", input_json_str1) # ----------------------------------------------------------------- if "WorkOrderGetResult" in input_json_str1 or "WorkOrderReceiptRetrieve": input_json_obj = json.loads(input_json_str1) input_json_obj["params"]["workOrderId"] = wo_id input_json_str1 = json.dumps(input_json_obj) logger.info("*********Request Json********* \n%s\n", input_json_str1) response = uri_client._postmsg(input_json_str1) logger.info("**********Received Response*********\n%s\n", response) # ----------------------------------------------------------------- # Worker details are loaded into Worker_Obj if "WorkerRetrieve" in input_json_str1 and "result" in response: worker_obj.load_worker(response) # ----------------------------------------------------------------- # Polling for the "WorkOrderGetResult" and break when you get the result while ("WorkOrderGetResult" in input_json_str1 and "result" not in response): if response["error"]["code"] != WorkOrderStatus.PENDING: break response = uri_client._postmsg(input_json_str1) logger.info("Received Response : %s, \n \n ", response) time.sleep(3) # ----------------------------------------------------------------- # Verify the signature if ("WorkOrderGetResult" in input_json_str1): if "error" in response: # Response has error, hence skip Signature verification logger.info("Work order response has error, " "skipping signature verification") continue sig_bool = sig_obj.verify_signature( response, worker_obj.verification_key) try: if sig_bool > 0: logger.info("Signature Verified") enclave_helper.decrypted_response( response, session_key, session_iv) else: logger.info("Signature verification Failed") exit(1) except: logger.error( "ERROR: Failed to analyze Signature Verification") exit(1) # ----------------------------------------------------------------- else: logger.info("Input Request %s", input_json_str) response = uri_client._postmsg(input_json_str) logger.info("Received Response : %s , \n \n ", response) exit(0)
def Main(args=None): ParseCommandLine(args) config["Logging"] = { "LogFile": "__screen__", "LogLevel": "INFO" } plogger.setup_loggers(config.get("Logging", {})) sys.stdout = plogger.stream_to_logger( logging.getLogger("STDOUT"), logging.DEBUG) sys.stderr = plogger.stream_to_logger( logging.getLogger("STDERR"), logging.WARN) logger.info("***************** AVALON *****************") # Connect to registry list and retrieve registry if not off_chain: direct_wrapper.init_worker_registry_list(config) registry_lookup_result = direct_wrapper.registry_lookup() if (registry_lookup_result[0] == 0): logger.warn("No registries found") sys.exit(1) registry_retrieve_result = direct_wrapper.registry_retrieve( registry_lookup_result[2][0]) config["tcf"]["json_rpc_uri"] = registry_retrieve_result[0] # Prepare worker direct_wrapper.init_worker_registry(config) global worker_id if not worker_id: worker_lookup_json = jrpc_request.WorkerLookupJson( 1, worker_type=1) worker_lookup_result = direct_wrapper.worker_lookup( worker_lookup_json) if "result" in worker_lookup_result and \ "ids" in worker_lookup_result["result"].keys(): if worker_lookup_result["result"]["totalCount"] != 0: worker_id = \ worker_lookup_result["result"]["ids"][0] else: logger.error("ERROR: No workers found") sys.exit(1) else: logger.error("ERROR: Failed to lookup worker") sys.exit(1) worker_retrieve_json = jrpc_request.WorkerRetrieveJson(2, worker_id) worker_obj.load_worker( direct_wrapper.worker_retrieve(worker_retrieve_json)) logger.info("********** Worker details Updated with Worker ID" + "*********\n%s\n", worker_id) # Convert workloadId to hex workload_id = "echo-result" workload_id = workload_id.encode("UTF-8").hex() # Create work order wo_submit_json = jrpc_request.WorkOrderSubmitJson( 3, 6000, "pformat", worker_id, workload_id, "0x2345", worker_encryption_key=base64.b64decode( worker_obj.worker_encryption_key).hex(), data_encryption_algorithm="AES-GCM-256") wo_id = wo_submit_json.get_work_order_id() # Sign work order private_key = utility.generate_signing_keys() session_key = utility.generate_key() session_iv = utility.generate_iv() encrypted_session_key = utility.generate_encrypted_key( session_key, worker_obj.worker_encryption_key) # Generate one time key used for encrypting inData data_key = utility.generate_key() # Initialation vector of size 12 bytes with all zeros. data_iv = bytearray(12) encrypted_key = utility.generate_encrypted_key( data_key, worker_obj.worker_encryption_key) encrypted_data_encryption_key = utility.encrypt_data( encrypted_key, session_key) encrypted_data_encryption_key_str = ''.join( format(i, '02x') for i in encrypted_data_encryption_key) data_iv_str = ''.join(format(i, '02x') for i in data_iv) wo_submit_json.add_in_data( message, None, encrypted_data_encryption_key_str, data_iv_str) # Submit work order direct_wrapper.init_work_order(config) direct_wrapper.work_order_submit( wo_submit_json, encrypted_session_key, worker_obj, private_key, session_key, session_iv, data_key, data_iv) # Retrieve result wo_get_result_json = jrpc_request.WorkOrderGetResultJson(4, wo_id) direct_wrapper.work_order_get_result( wo_get_result_json, session_key, session_iv, data_key, data_iv)
def Main(args=None): ParseCommandLine(args) config["Logging"] = {"LogFile": "__screen__", "LogLevel": "INFO"} plogger.setup_loggers(config.get("Logging", {})) sys.stdout = plogger.stream_to_logger(logging.getLogger("STDOUT"), logging.DEBUG) sys.stderr = plogger.stream_to_logger(logging.getLogger("STDERR"), logging.WARN) logger.info("***************** TRUSTED COMPUTE FRAMEWORK (TCF)" + \ " *****************") # Connect to registry list and retrieve registry if not off_chain: direct_wrapper.init_worker_registry_list(config) registry_lookup_result = direct_wrapper.registry_lookup() if (registry_lookup_result[0] == 0): logger.warn("No registries found") sys.exit(1) registry_retrieve_result = direct_wrapper.registry_retrieve( registry_lookup_result[2][0]) config["tcf"]["json_rpc_uri"] = registry_retrieve_result[0] # Prepare worker direct_wrapper.init_worker_registry(config) global worker_id if not worker_id: worker_lookup_json = jrpc_request.WorkerLookupJson(1, worker_type=1) worker_lookup_result = direct_wrapper.worker_lookup(worker_lookup_json) if "result" in worker_lookup_result and \ "ids" in worker_lookup_result["result"].keys(): if worker_lookup_result["result"]["totalCount"] != 0: worker_id = worker_lookup_result["result"]["ids"][0] else: logger.error("ERROR: No workers found") sys.exit(1) else: logger.error("ERROR: Failed to lookup worker") sys.exit(1) worker_retrieve_json = jrpc_request.WorkerRetrieveJson(2, worker_id) worker_obj.load_worker( direct_wrapper.worker_retrieve(worker_retrieve_json)) logger.info("**********Worker details Updated with Worker ID" + \ "*********\n%s\n", worker_id) # Convert workloadId to hex workload_id = "echo-result".encode("UTF-8").hex() work_order_id = secrets.token_hex(32) requester_id = secrets.token_hex(32) session_iv = utility.generate_iv() session_key = utility.generate_key() encrypted_session_key = utility.generate_encrypted_key( session_key, worker_obj.encryption_key) requester_nonce = secrets.token_hex(32) # Create work order wo_submit_json = jrpc_request.WorkOrderSubmitJson( 3, 6000, "JSON-RPC", work_order_id, worker_id, workload_id, requester_id, encrypted_session_key, session_iv, requester_nonce, worker_encryption_key=base64.b64decode( worker_obj.encryption_key).hex(), data_encryption_algorithm="AES-GCM-256") wo_submit_json.add_in_data(message) # Sign work order private_key = utility.generate_signing_keys() # Submit work order direct_wrapper.init_work_order(config) direct_wrapper.work_order_submit(wo_submit_json, encrypted_session_key, worker_obj, private_key, session_key, session_iv) # Retrieve result wo_get_result_json = jrpc_request.WorkOrderGetResultJson(4, work_order_id) direct_wrapper.work_order_get_result(wo_get_result_json, session_key, session_iv) # Retrieve receipt wo_receipt_retrieve_json = \ jrpc_request.WorkOrderReceiptRetrieveJson(5, work_order_id) direct_wrapper.init_work_order_receipt(config) direct_wrapper.work_order_receipt_retrieve(wo_receipt_retrieve_json)
def evaluate(self, message): """Create and submit workorder and wait for result.""" self.result_text.set("Waiting for evaluation result...") self.update() # Create, sign, and submit workorder. # Convert workloadId to hex. workload_id = "heart-disease-eval" workload_id = workload_id.encode("UTF-8").hex() session_iv = utility.generate_iv() session_key = utility.generate_key() encrypted_session_key = utility.generate_encrypted_key( session_key, worker_obj.encryption_key) requester_nonce = secrets.token_hex(16) work_order_id = secrets.token_hex(32) requester_id = secrets.token_hex(32) wo_params = WorkOrderParams( work_order_id, worker_id, workload_id, requester_id, session_key, session_iv, requester_nonce, result_uri=" ", notify_uri=" ", worker_encryption_key=worker_obj.encryption_key, data_encryption_algorithm="AES-GCM-256") wo_params.add_in_data(message) wo_params.add_encrypted_request_hash() if requester_signature: private_key = utility.generate_signing_keys() # Add requester signature and requester verifying_key if wo_params.add_requester_signature(private_key) == \ False: logger.info("Work order request signing failed") exit(1) # Set text for JSON sidebar req_id = 51 self.request_json = wo_params.to_string() work_order_instance = direct_jrpc.create_work_order(config) response = work_order_instance.work_order_submit( wo_params.get_params(), wo_params.get_in_data(), wo_params.get_out_data(), id=req_id) logger.info("Work order submit response : {}\n ".format( json.dumps(response, indent=4))) if "error" in response and response["error"]["code"] != \ WorkOrderStatus.PENDING: sys.exit(1) req_id += 1 # Retrieve result and set GUI result text res = work_order_instance.work_order_get_result(work_order_id, req_id) self.result_json = json.dumps(res, indent=4) if "result" in res: sig_obj = signature.ClientSignature() status = sig_obj.verify_signature(res, worker_obj.verification_key) try: if status == SignatureStatus.PASSED: logger.info("Signature verification" + \ " Successful") decrypted_res = utility. \ decrypted_response( res, session_key, session_iv) logger.info("\n" + \ "Decrypted response:\n {}". format(decrypted_res)) else: logger.info("Signature verification" + \ " Failed") sys.exit(1) except: logger.info("ERROR: Failed to decrypt response") sys.exit(1) else: logger.info("\n Work order get result failed {}\n". \ format(res)) sys.exit(1) # Set text for JSON sidebar self.result_text.set(decrypted_res[0]["data"]) # Retrieve receipt # Set text for JSON sidebar wo_receipt_instance = direct_jrpc.create_work_order_receipt(config) req_id += 1 self.receipt_json = json.dumps( wo_receipt_instance.work_order_receipt_retrieve( work_order_id, req_id), indent=4)