def save_to_file(self, file_name="password_file.pswd"):
"""Save the file to disk after encrypting it.
Args:
file_name (str): path to created file
"""
with open(file_name, "wb") as file:
pickle.dump(self, file)
encrypt_file(file_name, load_key(self.master_key))
def get_secrets(options):
''' Retrieves the secrets from the user specified file '''
secretsFile = options.secretsFile
tempFile = tempfile.NamedTemporaryFile(delete=False)
if options.secretsEncrypted.lower() == 'true':
decrypt(load_key(options.keyFile), secretsFile, tempFile.name)
secretsFile = tempFile.name
secrets = read_json_file(secretsFile)
tempFile.close()
return secrets
def open_password_file(password_file: str = None,
key_path: str = None) -> None:
"""Open a Password File if the right key file is given.
Args:
password_file (str): Path to Password File
key_path (str): Path to Key file
"""
if password_file is None:
password_file = input("Path to password file: ")
if key_path is None:
key_path = input("Path to key file: ")
decrypt_file(password_file, load_key(key_path))
with open(password_file, "rb") as file:
password_object = pickle.load(file)
password_object.master_key = key_path
password_object.menu()
def initiate(self):
# Load first shard from disk
shard_0 = load_key("../keys/shard_0.pkl")
key_shard_list = [shard_0]
initiation_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
initiation_socket.bind(("0.0.0.0", self.initiation_port))
initiation_socket.listen(5)
print "\nServer awaiting key initialization..."
connection, address = initiation_socket.accept()
# Receiving twice, as key shards are larger than 8k causing serialization(pickling) issues over the network
key_shard_1 = receive_object(connection)
key_shard_list.append(key_shard_1.key_shard)
key_shard_2 = receive_object(connection)
key_shard_list.append(key_shard_2.key_shard)
initiation_socket.close()
# Generate Paillier keys
secret = recover_secret(key_shard_list)
self.paillier_keys = recover_paillier_keys_from_secret(secret)
def run_setup(options, secrets, package_version):
''' Runs a sequence of tsm commands to perform setup '''
tsm_path = os.path.join(options.installDir, 'packages',
'bin.' + str(package_version), 'tsm.cmd')
tabcmd_path = os.path.join(options.installDir, 'packages',
'bin.' + str(package_version), 'tabcmd.exe')
port = options.controllerPort
# activate a trial and/or any license keys specified in the secrets file
product_keys = secrets.get('product_keys')
if (isinstance(product_keys, list)):
if ('trial' in product_keys):
run_tsm_command(tsm_path, secrets,
['licenses', 'activate', '--trial'], port)
print('Activated trial')
for productKey in product_keys:
if (len(productKey) > 0 and productKey != 'trial'):
run_tsm_command(
tsm_path, secrets,
['licenses', 'activate', '--license-key', productKey],
port)
print('Activated license key: ' + productKey)
run_tsm_command(tsm_path, secrets,
['register', '--file', options.registrationFile], port)
if options.saveNodeConfiguration == 'yes':
run_tsm_command(tsm_path, secrets, [
'topology', 'nodes', 'get-bootstrap-file', '--file',
options.nodeConfigurationDirectory
], port)
print('Node configuration file saved.')
configFile = options.configFile
tempFile = tempfile.NamedTemporaryFile(delete=False)
if options.configEncrypted.lower() == 'true':
decrypt(load_key(options.keyFile), options.configFile, tempFile.name)
configFile = tempFile.name
run_tsm_command(tsm_path, secrets,
['settings', 'import', '--config-only', '-f', configFile],
port)
print('Configuration settings imported')
# set config keys
if 'configKeys' in configFile:
config = read_json_file(configFile)
for key, value in config:
run_tsm_command(tsm_path, secrets,
['configuration', 'set', '-k', key, '-v', value],
port)
print('config keys set')
run_tsm_command(
tsm_path, secrets,
['pending-changes', 'apply', '--ignore-prompt', '--ignore-warnings'],
port)
print('Configuration applied')
run_tsm_command(tsm_path, secrets,
['initialize', '--request-timeout', '7200'], port)
print('Initialization completed')
get_nodes_and_apply_topology(configFile, tsm_path, secrets, port)
run_tsm_command(
tsm_path, secrets,
['pending-changes', 'apply', '--ignore-prompt', '--ignore-warnings'],
port)
print('Topology applied')
if options.start == 'yes':
run_tsm_command(tsm_path, secrets,
['start', '--request-timeout', '1800'], port)
print('Server is installed and running')
run_tabcmd_command(tabcmd_path, [
'initialuser', '--server',
'localhost:' + str(getGatewayPort(configFile)), '--username',
secrets['content_admin_user'], '--password',
secrets['content_admin_pass']
])
print('Initial admin created')
print('Installation complete')
if options.configEncrypted.lower() == 'true':
tempFile.close()
from communication_objects import KeyShard
from crypto import load_key
import socket
from network_interface import send_object
import time
if __name__ == "__main__":
# Fetch key shards(shard 1 & shard 2)
shard_1 = load_key("../keys/shard_1.pkl")
shard_2 = load_key("../keys/shard_2.pkl")
# Create objects to be sent to server
key_shard_1 = KeyShard(shard_1)
key_shard_2 = KeyShard(shard_2)
# Create socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("127.0.0.1", 5001))
# Send it on port 5001(server initiation port)
send_object(sock, key_shard_1)
# FIX: For invalid and under constructed pickle
# Time delay allows enough time to pickle the new object cleanly
time.sleep(1)
send_object(sock, key_shard_2)
sock.close()