def work_order_get_result(self, wo_get_result_json, session_key,
session_iv, data_key=None, data_iv=None):
if self.work_order == None:
logger.error("ERROR: Work order adaptor not initialized")
sys.exit(1)
logger.info("*********Request Json********* \n%s\n",
wo_get_result_json.get_json_str_indent())
response = self.work_order.work_order_get_result(
wo_get_result_json.get_work_order_id(),
wo_get_result_json.get_id())
logger.info("**********Received Response*********\n%s\n",
json.dumps(response))
# Poll for the "WorkOrderGetResult" and break when you get the result
while("result" not in response):
if response["error"]["code"] == 9:
break
response = self.work_order.work_order_get_result(
wo_get_result_json.get_work_order_id(),
wo_get_result_json.get_id())
if "result" not in response:
logger.info(" Received Response : %s, \n \n ", response)
time.sleep(3)
else:
logger.info(" Received Response : %s, \n \n ",
json.dumps(response, indent=4))
return enclave_helper.decrypted_response(
json.dumps(response), 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:
registry_list_instance = direct_jrpc.create_worker_registry_list(
config)
# Lookup returns tuple, first element is number of registries and
# second is element is lookup tag and
# third is list of organization ids.
registry_count, lookup_tag, registry_list = \
registry_list_instance.registry_lookup()
logger.info("\n Registry lookup response: registry count: {} " +
"lookup tag: {} registry list: {}\n".format(
registry_count, lookup_tag, registry_list))
if (registry_count == 0):
logger.warn("No registries found")
sys.exit(1)
# Retrieve the first registry details.
registry_retrieve_result = registry_list_instance.registry_retrieve(
registry_list[0])
logger.info("\n Registry retrieve response: {}\n".format(
registry_retrieve_result))
config["tcf"]["json_rpc_uri"] = registry_retrieve_result[0]
# Prepare worker
req_id = 31
global worker_id
worker_registry_instance = direct_jrpc.create_worker_registry(config)
if not worker_id:
worker_lookup_result = worker_registry_instance.worker_lookup(
worker_type=WorkerType.TEE_SGX, id=req_id)
logger.info("\n Worker lookup response: {}\n".format(
json.dumps(worker_lookup_result, indent=4)))
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)
req_id += 1
worker_retrieve_result = worker_registry_instance.worker_retrieve(
worker_id, req_id)
logger.info("\n Worker retrieve response: {}\n".format(
json.dumps(worker_retrieve_result, indent=4)))
worker_obj.load_worker(worker_retrieve_result)
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()
requester_nonce = secrets.token_hex(16)
# Create work order
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")
# Add worker input data
if input_data_hash:
# Compute data hash for data params inData
data_hash = utility.compute_data_hash(message)
# Convert data_hash to hex
data_hash = hex_utils.byte_array_to_hex_str(data_hash)
wo_params.add_in_data(message, data_hash)
else:
wo_params.add_in_data(message)
# Encrypt work order request hash
wo_params.add_encrypted_request_hash()
private_key = utility.generate_signing_keys()
if requester_signature:
# Add requester signature and requester verifying_key
if wo_params.add_requester_signature(private_key) is False:
logger.info("Work order request signing failed")
exit(1)
# Submit work order
logger.info("Work order submit request : %s, \n \n ",
wo_params.to_string(req_id))
work_order_instance = direct_jrpc.create_work_order(config)
req_id += 1
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)
# Create receipt
wo_receipt_instance = direct_jrpc.create_work_order_receipt(config)
req_id += 1
# Create work order receipt object using WorkOrderReceiptRequest class
wo_request = json.loads(wo_params.to_string(req_id))
wo_receipt_obj = WorkOrderReceiptRequest()
wo_create_receipt = wo_receipt_obj.create_receipt(
wo_request, ReceiptCreateStatus.PENDING.value, private_key)
logger.info("Work order create receipt request : {} \n \n ".format(
json.dumps(wo_create_receipt, indent=4)))
# Submit work order create receipt jrpc request
wo_receipt_resp = wo_receipt_instance.work_order_receipt_create(
wo_create_receipt["workOrderId"], wo_create_receipt["workerServiceId"],
wo_create_receipt["workerId"], wo_create_receipt["requesterId"],
wo_create_receipt["receiptCreateStatus"],
wo_create_receipt["workOrderRequestHash"],
wo_create_receipt["requesterGeneratedNonce"],
wo_create_receipt["requesterSignature"],
wo_create_receipt["signatureRules"],
wo_create_receipt["receiptVerificationKey"], req_id)
logger.info("Work order create receipt response : {} \n \n ".format(
wo_receipt_resp))
# Retrieve result
req_id += 1
res = work_order_instance.work_order_get_result(work_order_id, req_id)
logger.info("Work order get result : {}\n ".format(
json.dumps(res, indent=4)))
sig_obj = signature.ClientSignature()
if "result" in res:
status = sig_obj.verify_signature(res, worker_obj.verification_key)
try:
if status == SignatureStatus.PASSED:
logger.info(
"Work order response signature verification Successful")
decrypted_res = utility.decrypted_response(
res, session_key, session_iv)
logger.info("\nDecrypted response:\n {}".format(decrypted_res))
if input_data_hash:
decrypted_data = decrypted_res[0]["data"]
data_hash_in_resp = (decrypted_res[0]["dataHash"]).upper()
# Verify data hash in response
if utility.verify_data_hash(decrypted_data,
data_hash_in_resp) is False:
sys.exit(1)
else:
logger.info("Signature verification Failed")
sys.exit(1)
except Exception as err:
logger.error("ERROR: Failed to decrypt response: %s", str(err))
sys.exit(1)
else:
logger.info("\n Work order get result failed {}\n".format(res))
sys.exit(1)
# Retrieve receipt
receipt_res = wo_receipt_instance.work_order_receipt_retrieve(
work_order_id, id=req_id)
logger.info("\n Retrieve receipt response:\n {}".format(
json.dumps(receipt_res, indent=4)))
# Retrieve last update to receipt by passing 0xFFFFFFFF
req_id += 1
receipt_update_retrieve = \
wo_receipt_instance.work_order_receipt_update_retrieve(
work_order_id,
None,
1 << 32,
id=req_id)
logger.info("\n Last update to receipt receipt is:\n {}".format(
json.dumps(receipt_update_retrieve, indent=4)))
status = sig_obj.verify_update_receipt_signature(receipt_update_retrieve)
if status == SignatureStatus.PASSED:
logger.info(
"Work order receipt retrieve signature verification Successful")
else:
logger.info(
"Work order receipt retrieve signature verification failed!!")
sys.exit(1)
# Receipt lookup based on requesterId
req_id += 1
receipt_lookup_res = wo_receipt_instance.work_order_receipt_lookup(
requester_id=requester_id, id=req_id)
logger.info("\n Work order receipt lookup response :\n {}".format(
json.dumps(receipt_lookup_res, indent=4)))
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("***************** TRUSTED COMPUTE FRAMEWORK (TCF)" +
" *****************")
global direct_jrpc
direct_jrpc = DirectJsonRpcApiAdaptorFactory(config_file=None,
config=config)
global address
if mode == "registry" and address:
logger.info("\n Worker registry contract address is unsupported \n")
sys.exit(-1)
# Connect to registry list and retrieve registry
global uri
if not uri and mode == "listing":
registry_list_instance = direct_jrpc.create_worker_registry_list_adaptor(
config)
# Lookup returns tuple, first element is number of registries and
# second is element is lookup tag and third is list of organization ids.
registry_count, lookup_tag, registry_list = registry_list_instance.registry_lookup(
)
logger.info(
"\n Registry lookup response: registry count: {} lookup tag: {} registry list: {}\n"
.format(registry_count, lookup_tag, registry_list))
if (registry_count == 0):
logger.warn("No registries found")
sys.exit(1)
# Retrieve the fist registry details.
registry_retrieve_result = registry_list_instance.registry_retrieve(
registry_list[0])
logger.info("\n Registry retrieve response: {}\n".format(
registry_retrieve_result))
config["tcf"]["json_rpc_uri"] = registry_retrieve_result[0]
# Prepare worker
req_id = 31
global worker_id
if not worker_id:
worker_registry_instance = direct_jrpc.create_worker_registry_adaptor(
config)
worker_lookup_result = worker_registry_instance.worker_lookup(
worker_type=WorkerType.TEE_SGX, id=req_id)
logger.info("\n Worker lookup response: {}\n".format(
json.dumps(worker_lookup_result, indent=4)))
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)
req_id += 1
worker_retrieve_result = worker_registry_instance.worker_retrieve(
worker_id, req_id)
logger.info("\n Worker retrieve response: {}\n".format(
json.dumps(worker_retrieve_result, indent=4)))
if "error" in worker_retrieve_result:
logger.error("Unable to retrieve worker details\n")
sys.exit(1)
# Initializing Worker Object
worker_obj = worker_details.SGXWorkerDetails()
worker_obj.load_worker(worker_retrieve_result)
logger.info("**********Worker details Updated with Worker ID" + \
"*********\n%s\n", worker_id)
# Convert workloadId to hex
global workload_id
workload_id = workload_id.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()
requester_nonce = secrets.token_hex(16)
# Create work order
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")
# Add worker input data
global in_data
wo_params.add_in_data(in_data)
# Sign work order
private_key = utility.generate_signing_keys()
wo_params.add_encrypted_request_hash()
wo_params.add_requester_signature(private_key)
# Submit work order
logger.info("Work order submit request : %s, \n \n ",
wo_params.to_string())
work_order_instance = direct_jrpc.create_work_order_adaptor(config)
req_id += 1
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)
# Retrieve result
req_id += 1
res = work_order_instance.work_order_get_result(work_order_id, req_id)
logger.info("Work order get result : {}\n ".format(
json.dumps(res, indent=4)))
if "result" in res:
decrypted_res = utility.decrypted_response(json.dumps(res),
session_key, session_iv)
logger.info("\nDecrypted response:\n {}".format(decrypted_res))
else:
sys.exit(1)
# Retrieve receipt
wo_receipt_instance = direct_jrpc.create_work_order_receipt_adaptor(config)
req_id += 1
receipt_res = wo_receipt_instance.work_order_receipt_retrieve(
work_order_id, id=req_id)
logger.info("\Retrieve receipt response:\n {}".format(
json.dumps(receipt_res, 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
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 = helper.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 :
session_iv = helper.generate_sessioniv()
encrypted_session_key = helper.generate_encrypted_session_key(session_iv, worker_obj.worker_encryption_key)
input_json_obj = json.loads(input_json_str1)
wo_id = None
input_json_str1 = sig_obj.generate_client_signature(input_json_str1, worker_obj, private_key, session_iv, encrypted_session_key)
if input_json_str1 is None :
logger.error("Request could not be signed hence rejecting this workorder submit request")
wo_id = input_json_obj["params"]["workOrderId"]
continue
#----------------------------------------------------------------------------------
# Update the worker ID
if response:
if "workerId" in input_json_str1 :
#Retrieving the worker id from the "WorkerRetrieve" response and update the worker id information for the further json requests
if 'result' in response and 'ids' in response["result"].keys():
input_json_final = json.loads(input_json_str1)
input_json_final['params']['workerId'] = response['result']['ids'][0]
input_json_str1 = json.dumps(input_json_final)
logger.info("**********Worker details Updated with Worker ID*********\n%s\n", response['result']['ids'][0])
#-----------------------------------------------------------------------------------
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"] == 9:
break
input_json_obj = json.loads(input_json_str1)
if wo_id == input_json_obj["params"]["workOrderId"] :
logger.error("This work order request was rejected by client. Hence no result ")
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 ):
sig_bool = sig_obj.verify_signature(json.dumps(response),worker_obj)
try:
if sig_bool > 0:
logger.info('Signature Verified')
else :
logger.info('Signature Failed')
except:
logger.error("ERROR: Failed to analyze Signature Verification")
helper.decrypted_response(json.dumps(response), encrypted_session_key)
#----------------------------------------------------------------------------------
else :
logger.info('Input Request %s', input_json_str)
response = uri_client._postmsg(input_json_str_1)
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("***************** TRUSTED COMPUTE FRAMEWORK (TCF)" +
" *****************")
global direct_jrpc
direct_jrpc = DirectJsonRpcApiConnector(config_file=None, config=config)
global address
if mode == "registry" and address:
logger.error("\n Worker registry contract address is unsupported \n")
sys.exit(-1)
# Connect to registry list and retrieve registry
global uri
if not uri and mode == "listing":
registry_list_instance = direct_jrpc.create_worker_registry_list(
config
)
# Lookup returns tuple, first element is number of registries and
# second is element is lookup tag and third is list of organization ids.
registry_count, lookup_tag, registry_list = registry_list_instance.registry_lookup()
logger.info("\n Registry lookup response: registry count: {} lookup tag: {} registry list: {}\n".format(
registry_count, lookup_tag, registry_list
))
if (registry_count == 0):
logger.error("No registries found")
sys.exit(1)
# Retrieve the fist registry details.
registry_retrieve_result = registry_list_instance.registry_retrieve(registry_list[0])
logger.info("\n Registry retrieve response: {}\n".format(
registry_retrieve_result
))
config["tcf"]["json_rpc_uri"] = registry_retrieve_result[0]
# Prepare worker
req_id = 31
global worker_id
if not worker_id:
worker_registry_instance = direct_jrpc.create_worker_registry(
config
)
worker_lookup_result = worker_registry_instance.worker_lookup(
worker_type=WorkerType.TEE_SGX, id=req_id
)
logger.info("\n Worker lookup response: {}\n".format(
json.dumps(worker_lookup_result, indent=4)
))
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)
req_id += 1
worker_retrieve_result = worker_registry_instance.worker_retrieve(
worker_id, req_id
)
logger.info("\n Worker retrieve response: {}\n".format(
json.dumps(worker_retrieve_result, indent=4)
))
if "error" in worker_retrieve_result:
logger.error("Unable to retrieve worker details\n")
sys.exit(1)
# Initializing Worker Object
worker_obj = worker_details.SGXWorkerDetails()
worker_obj.load_worker(worker_retrieve_result)
logger.info("**********Worker details Updated with Worker ID" +
"*********\n%s\n", worker_id)
# Convert workloadId to hex
global workload_id
workload_id = workload_id.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()
requester_nonce = secrets.token_hex(16)
# Create work order
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"
)
# Add worker input data
global in_data
for value in in_data:
wo_params.add_in_data(value)
# Encrypt work order request hash
wo_params.add_encrypted_request_hash()
private_key = utility.generate_signing_keys()
if requester_signature:
# Add requester signature and requester verifying_key
if wo_params.add_requester_signature(private_key) is False:
logger.info("Work order request signing failed")
exit(1)
# Submit work order
logger.info("Work order submit request : %s, \n \n ",
wo_params.to_string(req_id))
work_order_instance = direct_jrpc.create_work_order(
config
)
req_id += 1
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)
wo_receipt_instance = direct_jrpc.create_work_order_receipt(
config
)
# Create receipt
if show_receipt:
req_id += 1
# Create work order receipt object using WorkOrderReceiptRequest class
wo_request = json.loads(wo_params.to_string(req_id))
wo_receipt_obj = WorkOrderReceiptRequest()
wo_create_receipt = wo_receipt_obj.create_receipt(
wo_request,
ReceiptCreateStatus.PENDING.value,
private_key
)
logger.info("Work order create receipt request : {} \n \n ".format(
json.dumps(wo_create_receipt, indent=4)
))
# Submit work order create receipt jrpc request
wo_receipt_resp = wo_receipt_instance.work_order_receipt_create(
wo_create_receipt["workOrderId"],
wo_create_receipt["workerServiceId"],
wo_create_receipt["workerId"],
wo_create_receipt["requesterId"],
wo_create_receipt["receiptCreateStatus"],
wo_create_receipt["workOrderRequestHash"],
wo_create_receipt["requesterGeneratedNonce"],
wo_create_receipt["requesterSignature"],
wo_create_receipt["signatureRules"],
wo_create_receipt["receiptVerificationKey"],
req_id
)
logger.info("Work order create receipt response : {} \n \n ".format(
wo_receipt_resp
))
# Retrieve result
req_id += 1
res = work_order_instance.work_order_get_result(
work_order_id,
req_id
)
logger.info("Work order get result : {}\n ".format(
json.dumps(res, indent=4)
))
sig_obj = signature.ClientSignature()
if "result" in res:
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)
if show_decrypted_output:
logger.info("\nDecrypted response:\n {}"
.format(decrypted_res))
else:
logger.error("Signature verification Failed")
sys.exit(1)
except:
logger.error("ERROR: Failed to decrypt response")
sys.exit(1)
else:
logger.error("\n Work order get result failed {}\n".format(
res
))
sys.exit(1)
if show_receipt:
# Retrieve receipt
req_id += 1
receipt_res = wo_receipt_instance.work_order_receipt_retrieve(
work_order_id,
id=req_id
)
logger.info("\n Retrieve receipt response:\n {}".format(
json.dumps(receipt_res, indent=4)
))
# Retrieve last update to receipt by passing 0xFFFFFFFF
req_id += 1
receipt_update_retrieve = wo_receipt_instance.work_order_receipt_update_retrieve(
work_order_id,
None,
1 << 32,
id=req_id
)
logger.info("\n Last update to receipt receipt is:\n {}".format(
json.dumps(receipt_update_retrieve, indent=4)
))
status = sig_obj.verify_update_receipt_signature(receipt_update_retrieve)
if status == SignatureStatus.PASSED:
logger.info("Work order receipt retrieve signature verification Successful")
else:
logger.info("Work order receipt retrieve signature verification failed!!")
sys.exit(1)