def __init__(self, config, signup_data, measurements):
self.config = config
self.enclave_data = signup_data
self.sealed_data = signup_data.sealed_data
self.verifying_key = signup_data.verifying_key
self.encryption_key = signup_data.encryption_key
# TODO: EncryptionKeyNonce and EncryptionKeySignature are hardcoded
# to dummy values.
# Need to come up with a scheme to generate both for every unique
# encryption key.
self.encryption_key_nonce = ""
self.encryption_key_signature = ""
self.enclave_id = signup_data.enclave_id
self.extended_measurements = measurements
# ProofDataType is one of TEE prefixed type
# TODO: Read ProofDataType from config file
self.proof_data_type = config.get("WorkerConfig")["ProofDataType"]
self.proof_data = signup_data.proof_data
# Key pair for work order receipt signing
# This is temporary approach
self.private_key = utils.generate_signing_keys()
self.public_key = self.private_key.GetPublicKey().Serialize()
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 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()
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)
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 ParseCommandLine(config, args):
logger.info(
'***************** TRUSTED COMPUTE FRAMEWORK (TCF)*****************')
global input_json_str
global input_json_dir
global server_uri
global output_json_file_name
global consensus_file_name
global sig_obj
global worker_obj
global private_key
global encrypted_session_key
global session_iv
parser = argparse.ArgumentParser()
parser.add_argument(
"--logfile",
help="Name of the log file, __screen__ for standard output",
type=str)
parser.add_argument("-p",
"--private_key",
help="Private Key of the Client",
type=str,
default=None)
parser.add_argument("--loglevel", help="Logging level", type=str)
parser.add_argument("-i",
"--input_file",
help="JSON input file name",
type=str,
default="input.json")
parser.add_argument("--input_dir",
help="Logging level",
type=str,
default=[])
parser.add_argument("-c",
"--connect_uri",
help="URI to send requests to",
type=str,
default=[])
parser.add_argument("output_file",
help="JSON output file name",
type=str,
default="output.json",
nargs="?")
options = parser.parse_args(args)
if config.get("Logging") is None:
config["Logging"] = {"LogFile": "__screen__", "LogLevel": "INFO"}
if options.logfile:
config["Logging"]["LogFile"] = options.logfile
if options.loglevel:
config["Logging"]["LogLevel"] = options.loglevel.upper()
input_json_str = None
input_json_dir = None
if options.connect_uri:
server_uri = options.connect_uri
else:
logger.error("ERROR: Please enter the server URI")
if options.input_dir:
logger.info("Load Json Directory from %s", options.input_dir)
input_json_dir = options.input_dir
elif options.input_file:
try:
logger.info("load JSON input from %s", options.input_file)
with open(options.input_file, "r") as file:
input_json_str = file.read()
except:
logger.error("ERROR: Failed to read from file %s",
options.input_file)
else:
logger.info("No input found")
if options.output_file:
output_json_file_name = options.output_file
else:
output_json_file_name = None
if options.private_key:
private_key = options.private_key
else:
# Generating the private Key for the client
private_key = enclave_helper.generate_signing_keys()
# Initializing Signature object, Worker Object
sig_obj = signature.ClientSignature()
worker_obj = worker.SGXWorkerDetails()
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 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 ParseCommandLine(config, args) :
logger.info('***************** INTEL TRUSTED COMPUTE FRAMEWORK (TCF)*****************')
global input_json_str
global input_json_dir
global server_uri
global output_json_file_name
global consensus_file_name
global sig_obj
global worker_obj
global private_key
parser = argparse.ArgumentParser()
parser.add_argument('--logfile', help='Name of the log file, __screen__ for standard output', type=str)
parser.add_argument('-p', '--private_key',help="Private Key of the Client", type=str, default=None)
parser.add_argument('--loglevel', help='Logging level', type=str)
parser.add_argument('-i', '--input_file', help='JSON input file name', type=str, default='input.json')
parser.add_argument('--input_dir', help='Logging level', type=str, default=[])
parser.add_argument(
'-c', '--connect_uri', help='URI to send requests to', type=str, default=[])
parser.add_argument(
'output_file',
help='JSON output file name',
type=str,
default='output.json',
nargs='?')
options = parser.parse_args(args)
if config.get('Logging') is None :
config['Logging'] = {
'LogFile' : '__screen__',
'LogLevel' : 'INFO'
}
if options.logfile :
config['Logging']['LogFile'] = options.logfile
if options.loglevel :
config['Logging']['LogLevel'] = options.loglevel.upper()
input_json_str = None
input_json_dir = None
if options.connect_uri:
server_uri = options.connect_uri
else:
logger.error("ERROR: Please enter the server URI")
if options.input_dir:
logger.info('Load Json Directory from %s',options.input_dir)
input_json_dir = options.input_dir
elif options.input_file:
try:
logger.info('load JSON input from %s', options.input_file)
with open(options.input_file, "r") as file:
input_json_str = file.read()
except:
logger.error("ERROR: Failed to read from file %s", options.input_file)
else :
logger.info('No input found')
if options.output_file:
output_json_file_name = options.output_file
else:
output_json_file_name = None
if options.private_key:
private_key = options.private_key
else:#Generating the private Key for the client
private_key = helper.generate_signing_keys()
# Initializing Signature object, Worker Object
sig_obj = signature.ClientSignature()
worker_obj = worker.WorkerDetails()
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)
