def generate_sgx_key(sgx_server_url, ssl_port) -> tuple:
if not os.path.isdir(SGX_SSL_CERTS_PATH):
os.makedirs(SGX_SSL_CERTS_PATH)
if ssl_port is not None:
client = SgxClient(sgx_server_url, SGX_SSL_CERTS_PATH)
else:
client = SgxClient(sgx_server_url)
return client.generate_key()
def test_delete():
sgx = SgxClient(os.environ['SERVER'],
path_to_cert=os.environ.get('CERT_PATH'),
n=2,
t=2)
random_dkg_id = random.randint(0, 10**50)
bls_key_name = ("BLS_KEY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(0)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
insecure_bls_private_key = "f253bad7b1f62b8ff60bbf451cf2e8e9ebb5d6e9bff450c55b8d5504b8c63d3"
response = sgx.import_bls_private_key(bls_key_name,
insecure_bls_private_key)
assert len(response) > 0
sgx.delete_bls_key(bls_key_name)
try:
sgx.delete_bls_key(bls_key_name)
except SgxServerError as e:
assert str(e) == f'BLS key not found: {bls_key_name}'
print("TEST DELETE BLS KEY PASSED")
def test_poly_existance():
sgx = SgxClient(os.environ['SERVER'],
path_to_cert=os.environ.get('CERT_PATH'),
n=2,
t=2)
random_dkg_id = random.randint(0, 10**50)
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(0)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
assert sgx.generate_dkg_poly(poly_name) == DkgPolyStatus.NEW_GENERATED
assert sgx.is_poly_exists(poly_name)
poly_name_incorrect = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(0)}"
":DKG_ID:"
f"{str(random_dkg_id+1)}")
assert not sgx.is_poly_exists(poly_name_incorrect)
response = sgx.generate_dkg_poly(poly_name)
assert response == DkgPolyStatus.PREEXISTING
print("TEST POLY EXISTANCE PASSED")
def __init__(self, sgx_endpoint, web3, key_name=None, path_to_cert=None):
self.sgx_client = SgxClient(sgx_endpoint, path_to_cert=path_to_cert)
self._web3 = web3
if key_name is None:
self._key_name, self._address, self._public_key = self._generate()
else:
self._key_name = key_name
self._address, self._public_key = self._get_account(key_name)
def generate_sgx_key(config):
if not SGX_SERVER_URL:
raise SGXConnecionError('SGX server URL is not provided')
if not config.sgx_key_name:
sgx = SgxClient(SGX_SERVER_URL, SGX_CERTIFICATES_FOLDER)
key_info = sgx.generate_key()
logger.info(
arguments_list_string(
{
'Name': key_info.name,
'Address': key_info.address
}, 'Generated new SGX key'))
config.sgx_key_name = key_info.name
def sgx_status():
logger.debug(request)
sgx = SgxClient(SGX_SERVER_URL, SGX_CERTIFICATES_FOLDER)
try:
status = sgx.get_server_status()
except Exception: # todo: catch specific error - edit sgx.py
status = 1
res = {
'status': status,
'status_name': SGXStatus(status).name,
'sgx_server_url': SGX_SERVER_URL
}
return construct_ok_response(res)
def test_import():
sgx = SgxClient(os.environ['SERVER'],
path_to_cert=os.environ.get('CERT_PATH'),
n=2,
t=2)
random_dkg_id = random.randint(0, 10**50)
bls_key_name = ("BLS_KEY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(0)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
insecure_bls_private_key = "f253bad7b1f62b8ff60bbf451cf2e8e9ebb5d6e9bff450c55b8d5504b8c63d3"
response = sgx.import_bls_private_key(bls_key_name,
insecure_bls_private_key)
assert len(response) > 0
print("TEST IMPORT BLS KEY PASSED")
def __init__(self, node_id_dkg, node_id_contract, skale, t, n, schain_name,
public_keys, node_ids_dkg, node_ids_contract, eth_key_name):
self.sgx = SgxClient(os.environ['SGX_SERVER_URL'],
n=n,
t=t,
path_to_cert=SGX_CERTIFICATES_FOLDER)
self.schain_name = schain_name
self.group_index = skale.web3.sha3(text=self.schain_name)
self.node_id_contract = node_id_contract
self.node_id_dkg = node_id_dkg
self.skale = skale
self.t = t
self.n = n
self.eth_key_name = eth_key_name
self.incoming_verification_vector = ['0' for _ in range(n)]
self.incoming_secret_key_contribution = ['0' for _ in range(n)]
self.public_keys = public_keys
self.node_ids_dkg = node_ids_dkg
self.node_ids_contract = node_ids_contract
self.dkg_contract_functions = self.skale.dkg.contract.functions
logger.info(
f'sChain: {self.schain_name}. Node id on chain is {self.node_id_dkg}; '
f'Node id on contract is {self.node_id_contract}')
from web3 import Web3
from sgx import SgxClient
from dotenv import load_dotenv
import os
load_dotenv()
w3 = Web3(Web3.HTTPProvider(os.environ['GETH']))
sgx = SgxClient(os.environ['SERVER'], os.environ.get('CERT_PATH'))
txn = {
'to': os.environ['TEST_ACCOUNT'],
'value': 0,
'gas': 2000000,
'gasPrice': 0,
'chainId': w3.eth.chainId
}
def sign_and_send():
generated_key = sgx.generate_key()
key = generated_key.name
account = sgx.get_account(key).address
txn['nonce'] = w3.eth.getTransactionCount(account)
signed_txn = sgx.sign(txn, key)
tx = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
return w3.toHex(tx)
def get_info():
def perform_dkg(t, n, with_0x=True, with_complaint=False):
sgx = SgxClient(os.environ['SERVER'],
path_to_cert=os.environ.get('CERT_PATH'),
n=n,
t=t)
public_keys = []
key_name = []
random_dkg_id = random.randint(0, 10**50)
for i in range(n):
generated_key = sgx.generate_key()
if with_0x:
public_keys.append(generated_key.public_key)
else:
public_keys.append(generated_key.public_key[2:])
key_name.append(generated_key.name)
sleep(1)
for i in range(n):
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(i)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
response = sgx.generate_dkg_poly(poly_name)
if response == DkgPolyStatus.FAIL:
raise TypeError("failed generate dkg poly for " + str(i))
sleep(5)
verification_vector = []
for i in range(n):
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(i)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
verification_vector.append(sgx.get_verification_vector(poly_name))
sleep(5)
hexed_vv = []
for vv in verification_vector:
cur_hexed = ""
for elem in vv:
cur_hexed += convert_g2_point_to_hex(elem)
hexed_vv.append(cur_hexed)
secret_key_contribution = []
for i in range(n):
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(i)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
secret_key_contribution.append(
sgx.get_secret_key_contribution(poly_name, public_keys))
sleep(5)
if not with_complaint:
for i in range(n):
for j in range(n):
if not sgx.verify_secret_share(
hexed_vv[j], key_name[i],
secret_key_contribution[j][192 * i:192 * (i + 1)], i):
raise ValueError(f'{i} failed to verify {j}')
sleep(5)
public_keys = sgx.calculate_all_bls_public_keys(hexed_vv)
for i in range(n):
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(i)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
bls_key_name = ("BLS_KEY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(i)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
sgx.create_bls_private_key(
poly_name, bls_key_name, key_name[i],
"".join(secret_key_contribution[j][192 * i:192 * (i + 1)]
for j in range(n)))
public_key = sgx.get_bls_public_key(bls_key_name)
assert ":".join(public_key) == public_keys[i]
sleep(5)
else:
corrupted_secret_key_contribution = secret_key_contribution[0]
secret_key_contribution[0] = secret_key_contribution[1]
for i in range(n):
for j in range(n):
if j == 0:
assert not sgx.verify_secret_share(
hexed_vv[j], key_name[i],
secret_key_contribution[j][192 * i:192 * (i + 1)], i)
else:
assert sgx.verify_secret_share(
hexed_vv[j], key_name[i],
secret_key_contribution[j][192 * i:192 * (i + 1)], i)
sleep(5)
poly_name = ("POLY:SCHAIN_ID:"
f"{str(0)}"
":NODE_ID:"
f"{str(0)}"
":DKG_ID:"
f"{str(random_dkg_id)}")
perform_complaint(sgx, t, poly_name, public_keys[1],
corrupted_secret_key_contribution[192:256])
import os
from telnetlib import Telnet
from dotenv import load_dotenv
from eth_account._utils import transactions
from hexbytes import HexBytes
from web3 import Web3
from sgx import SgxClient
load_dotenv()
SGX_URL = os.getenv('SERVER')
GETH_URL = os.getenv('GETH')
sgx = SgxClient(SGX_URL, os.getenv('CERT_PATH'))
w3 = Web3(Web3.HTTPProvider(GETH_URL))
txn = {
'to': os.getenv('TEST_ACCOUNT'),
'value': 0,
'gas': 2000000,
'gasPrice': 0,
'chainId': w3.eth.chainId
}
def test_server_connection():
parsed_url = urllib.parse.urlparse(SGX_URL)
with Telnet(parsed_url.hostname, parsed_url.port, timeout=5) as tn:
tn.msg('Test')