def search(table_name):
if os.path.exists(databases_root_folder + table_name):
db = ScaDatabase(databases_root_folder + table_name)
analysis_all = db.select_all(Analysis)
analyses = []
hp = []
for analysis in analysis_all:
final_key_ranks = db.select_final_key_rank_json_from_analysis(KeyRank, analysis.id)
if len(final_key_ranks) > 0:
hyper_parameters = db.select_from_analysis(HyperParameter, analysis.id)
training_hyper_parameters = hyper_parameters.hyper_parameters
training_hyper_parameters[0]['guessing_entropy'] = final_key_ranks[0][0]['key_rank']
hp.append(training_hyper_parameters[0])
exp = hip.Experiment().from_iterable(hp)
exp.display_data(hip.Displays.PARALLEL_PLOT).update({
'hide': ['uid', 'key_rank', 'key'], # Hide some columns
'order': ['guessing_entropy'], # Put column time first on the left
})
exp.validate()
exp.to_html("webapp/templates/hiplot.html")
return render_template("dashboard/search.html", analyses=analyses)
return render_template("dashboard/search.html", analyses=[])
def table():
db_files = []
# r=root, d=directories, f = files
for r, d, f in os.walk(databases_root_folder):
for file in f:
if file.endswith(".sqlite"):
db_files.append(file)
all_tables = []
all_tables_names = []
for db_file in db_files:
if os.path.exists(databases_root_folder + db_file):
db = ScaDatabase(databases_root_folder + db_file)
analysis_all = db.select_all(Analysis)
analyses = []
for analysis in analysis_all:
if not analysis.deleted:
localtimezone = pytz.timezone(os.getenv("TIME_ZONE"))
analysis_datetime = datetime.strptime(str(analysis.datetime), "%Y-%m-%d %H:%M:%S.%f").astimezone(
localtimezone).__format__(
"%b %d, %Y %H:%M:%S")
final_key_ranks = db.select_final_key_rank_json_from_analysis(KeyRank, analysis.id)
final_success_rates = db.select_final_success_rate_from_analysis(SuccessRate, analysis.id)
neural_network = db.select_from_analysis(NeuralNetwork, analysis.id)
analyses.append({
"id": analysis.id,
"datetime": analysis_datetime,
"dataset": analysis.dataset,
"settings": analysis.settings,
"elapsed_time": time.strftime('%H:%M:%S', time.gmtime(analysis.elapsed_time)),
"key_ranks": final_key_ranks,
"success_rates": final_success_rates,
"neural_network_name": "not ready" if neural_network is None else neural_network.model_name
})
all_tables.append(analyses)
all_tables_names.append(db_file)
return render_template("tables.html", all_tables=all_tables, all_tables_names=all_tables_names)
def generate_script(script_filename, databases_root_folder, table_name,
analysis_id):
script_py_file = open(
"scripts/{}_{}.py".format(script_filename,
table_name.replace(".sqlite", "")), "w+")
script_py_file.write("from tensorflow.keras.optimizers import *\n")
script_py_file.write("from tensorflow.keras.layers import *\n")
script_py_file.write("from tensorflow.keras.models import *\n")
script_py_file.write("from aisy.sca_deep_learning_aes import AisyAes\n")
db = ScaDatabase(databases_root_folder + table_name)
analysis = db.select_analysis(Analysis, analysis_id)
neural_network_model = db.select_from_analysis(NeuralNetwork, analysis_id)
# get training hyper-parameters information from database
hyper_parameters = db.select_all_from_analysis(HyperParameter, analysis_id)
hyper_parameters_single = hyper_parameters[0].hyper_parameters[0]
hyper_parameter_search = None
if len(hyper_parameters) > 1:
hyper_parameter_search = db.select_from_analysis(
HyperParameterSearch, analysis.id)
leakage_models = db.select_from_analysis(LeakageModel, analysis_id)
leakage_model_parameters = leakage_models.leakage_model[0]
script_py_file.write('\naisy = AisyAes()')
script_py_file.write('\naisy.set_dataset("{}")'.format(analysis.dataset))
script_py_file.write('\naisy.set_database_name("{}")'.format(table_name))
script_py_file.write('\naisy.set_aes_leakage_model(')
for index, key in enumerate(leakage_model_parameters):
if isinstance(leakage_model_parameters[key], str):
script_py_file.write('{}="{}"'.format(
key, leakage_model_parameters[key]))
else:
script_py_file.write('{}={}'.format(key,
leakage_model_parameters[key]))
if index < len(leakage_model_parameters) - 1:
script_py_file.write(', ')
script_py_file.write(')')
script_py_file.write('\naisy.set_key("{}")'.format(
hyper_parameters_single['key']))
script_py_file.write('\naisy.set_number_of_profiling_traces({})'.format(
hyper_parameters_single['profiling_traces']))
script_py_file.write('\naisy.set_number_of_attack_traces({})'.format(
hyper_parameters_single['attack_traces']))
script_py_file.write('\naisy.set_first_sample({})'.format(
hyper_parameters_single['first_sample']))
script_py_file.write('\naisy.set_number_of_samples({})'.format(
hyper_parameters_single['number_of_samples']))
script_py_file.write('\naisy.set_batch_size({})'.format(
hyper_parameters_single['batch_size']))
script_py_file.write('\naisy.set_epochs({})'.format(
hyper_parameters_single['epochs']))
if len(hyper_parameters) == 1:
script_py_file.write('\n\n\n{}'.format(
neural_network_model.description))
script_py_file.write('\n\naisy.set_neural_network({})'.format(
neural_network_model.model_name))
else:
if "grid_search" in analysis.settings:
script_py_file.write('\ngrid_search = {}'.format(
analysis.settings["grid_search"]))
if "random_search" in analysis.settings:
script_py_file.write('\nrandom_search = {}'.format(
analysis.settings["random_search"]))
if "early_stopping" in analysis.settings:
script_py_file.write('\nearly_stopping = {}'.format(
analysis.settings["early_stopping"]))
script_py_file.write('\n\naisy.run(')
script_py_file.write('\n key_rank_executions={},'.format(
analysis.settings["key_rank_executions"]))
script_py_file.write('\n key_rank_report_interval={},'.format(
analysis.settings["key_rank_report_interval"]))
script_py_file.write('\n key_rank_attack_traces={},'.format(
analysis.settings["key_rank_attack_traces"]))
if "early_stopping" in analysis.settings:
script_py_file.write('\n early_stopping=early_stopping,')
if "ensemble" in analysis.settings:
script_py_file.write('\n ensemble=[{}],'.format(
analysis.settings["ensemble"]))
if len(hyper_parameters) == 1:
script_py_file.write('\n)\n')
else:
if hyper_parameter_search.search_type == "Grid Search":
script_py_file.write('\n grid_search=grid_search')
else:
script_py_file.write('\n random_search=random_search')
script_py_file.write('\n)\n')
script_py_file.close()
def __init__(self, database_name, db_filename, dataset, settings, elapsed_time):
self.db = ScaDatabase(database_name)
tables.base().metadata.create_all(self.db.engine)
new_insert = Analysis(db_filename=db_filename, dataset=dataset, settings=settings, elapsed_time=elapsed_time, deleted=False)
self.analysis_id = self.db.insert(new_insert)
class ScaDatabaseInserts:
def __init__(self, database_name, db_filename, dataset, settings, elapsed_time):
self.db = ScaDatabase(database_name)
tables.base().metadata.create_all(self.db.engine)
new_insert = Analysis(db_filename=db_filename, dataset=dataset, settings=settings, elapsed_time=elapsed_time, deleted=False)
self.analysis_id = self.db.insert(new_insert)
def get_analysis_id(self):
return self.analysis_id
def update_elapsed_time_analysis(self, elapsed_time):
self.db.session.query(Analysis).filter(Analysis.id == self.analysis_id).update({"elapsed_time": elapsed_time})
self.db.session.commit()
def save_hyper_parameters(self, hyper_parameters):
new_insert = HyperParameter(hyper_parameters=hyper_parameters, analysis_id=self.analysis_id)
return self.db.insert(new_insert)
def save_neural_network(self, description, model_name):
new_insert = NeuralNetwork(model_name=model_name, description=description, analysis_id=self.analysis_id)
return self.db.insert(new_insert)
def save_leakage_model(self, leakage_model):
new_insert = LeakageModel(leakage_model=leakage_model, analysis_id=self.analysis_id)
return self.db.insert(new_insert)
def save_metric(self, data, key_byte, metric):
for value in data:
new_insert = Metric(value=value, key_byte=key_byte, metric=metric, analysis_id=self.analysis_id)
self.db.insert(new_insert)
def save_key_rank_json(self, values, key_byte, report_interval, metric):
new_insert = KeyRank(values=values, key_byte=key_byte, report_interval=report_interval, metric=metric,
analysis_id=self.analysis_id)
self.db.insert(new_insert)
def save_success_rate_json(self, values, key_byte, report_interval, metric):
new_insert = SuccessRate(values=values, key_byte=key_byte, report_interval=report_interval, metric=metric,
analysis_id=self.analysis_id)
self.db.insert(new_insert)
def save_visualization(self, values, epoch, key_byte, report_interval, metric):
new_insert = Visualization(values=values, epoch=epoch, key_byte=key_byte, report_interval=report_interval, metric=metric,
analysis_id=self.analysis_id)
self.db.insert(new_insert)
def save_hyper_parameters_search(self, search_type, hyper_parameters, best_hyper_parameters):
new_insert = HyperParameterSearch(search_type=search_type, hyper_parameters_settings=hyper_parameters,
best_hyper_parameters=best_hyper_parameters, analysis_id=self.analysis_id)
return self.db.insert(new_insert)
def save_confusion_matrix(self, y_pred, y_true, key_byte):
new_insert = ConfusionMatrix(y_pred=y_pred, y_true=y_true, key_byte=key_byte, analysis_id=self.analysis_id)
self.db.insert(new_insert)
def save_probability_rank(self, ranks, classes, correct_key_byte, key_guess, title, key_byte):
new_insert = ProbabilityRank(ranks=ranks, classes=classes, correct_key_byte=correct_key_byte, key_guess=key_guess,
title=title, key_byte=key_byte, analysis_id=self.analysis_id)
self.db.insert(new_insert)
def delete_analysis(analysis_id, table_name):
db = ScaDatabase(databases_root_folder + table_name)
db.soft_delete_analysis_from_table(Analysis, analysis_id)
return "ok"
def gen_plot(analysis_id, table_name, metric):
db = ScaDatabase(databases_root_folder + table_name)
analysis = db.select_analysis(Analysis, analysis_id)
if metric == "Guessing_Entropy":
result_key_byte = db.select_values_from_analysis_json(KeyRank, analysis_id)
elif metric == "Success_Rate":
result_key_byte = db.select_values_from_analysis_json(SuccessRate, analysis_id)
else:
result_key_byte = []
all_metrics_names = db.select_metrics(Metric, analysis_id)
if metric == "accuracy":
for metric_name in all_metrics_names:
if metric in metric_name:
if "grid_search" in analysis.settings or "random_search" in analysis.settings:
if "best" in metric_name:
result_key_byte.append(db.select_values_from_metric(Metric, metric_name, analysis_id)[0])
else:
result_key_byte.append(db.select_values_from_metric(Metric, metric_name, analysis_id)[0])
elif metric == "loss":
for metric_name in all_metrics_names:
if metric in metric_name:
if "grid_search" in analysis.settings or "random_search" in analysis.settings:
if "best" in metric_name:
result_key_byte.append(db.select_values_from_metric(Metric, metric_name, analysis_id)[0])
else:
result_key_byte.append(db.select_values_from_metric(Metric, metric_name, analysis_id)[0])
else:
result_key_byte.append(db.select_values_from_metric(Metric, metric, analysis_id)[0])
my_dpi = 100
plt.figure(figsize=(800 / my_dpi, 600 / my_dpi), dpi=my_dpi)
dir_analysis_id = "resources/figures/{}".format(analysis_id)
if not os.path.exists(dir_analysis_id):
os.makedirs(dir_analysis_id)
if metric == "Guessing_Entropy" or metric == "Success_Rate":
for res in result_key_byte:
plt.plot(np.arange(res['report_interval'], (len(res['values']) + 1) * res['report_interval'], res['report_interval']),
res['values'],
label=res['metric'])
plt.legend(loc='best', fontsize=13)
plt.xlim([1, len(res['values']) * res['report_interval']])
plt.ylabel(metric.replace("_", " "), fontsize=13)
if metric == "Guessing_Entropy" or metric == "Success_Rate":
plt.xlabel("Attack Traces", fontsize=13)
else:
plt.xlabel("Epochs", fontsize=13)
plt.grid(ls='--')
plt.savefig("{}/{}_{}_{}.png".format(dir_analysis_id, metric, analysis_id, table_name.replace(".sqlite", "")),
format="png")
else:
for res in result_key_byte:
plt.plot(np.arange(1, len(res['values']) + 1, 1), res['values'], label=res['metric'])
plt.legend(loc='best', fontsize=13)
plt.xlim([1, len(res['values'])])
plt.ylabel(metric.replace("_", " "), fontsize=13)
plt.xlabel("Epochs", fontsize=13)
plt.grid(ls='--')
plt.savefig("{}/{}_{}_{}.png".format(dir_analysis_id, metric, analysis_id, table_name.replace(".sqlite", "")),
format="png")
return "ok"
def result(analysis_id, table_name):
db = ScaDatabase(databases_root_folder + table_name)
# get neural network information from database
analysis = db.select_analysis(Analysis, analysis_id)
sca_views = ScaViews(analysis_id, db)
all_metric_plots = sca_views.metric_plots()
all_accuracy_plots = sca_views.accuracy_plots()
dash_app_accuracy.layout = html.Div(children=[all_accuracy_plots])
all_loss_plots = sca_views.loss_plots()
dash_app_loss.layout = html.Div(children=[all_loss_plots])
if "ensemble" in analysis.settings:
all_key_rank_plots = sca_views.ensemble_plots_key_rank()
else:
all_key_rank_plots = sca_views.key_rank_plots()
dash_app_key_ranks.layout = html.Div(children=[all_key_rank_plots])
if "ensemble" in analysis.settings:
all_success_rate_plots = sca_views.ensemble_plots_success_rate()
else:
all_success_rate_plots = sca_views.success_rate_plots()
dash_app_success_rates.layout = html.Div(children=[all_success_rate_plots])
# get neural network information from database
neural_network_model = db.select_from_analysis(NeuralNetwork, analysis_id)
# get training hyper-parameters information from database
hyper_parameters = db.select_all_from_analysis(HyperParameter, analysis_id)
training_hyper_parameters = []
for hp in hyper_parameters:
training_hyper_parameters.append(hp.hyper_parameters)
hyper_parameter_search = []
if len(hyper_parameters) > 1:
hyper_parameter_search = db.select_from_analysis(HyperParameterSearch, analysis.id)
# get leakage model information from database
leakage_models = db.select_from_analysis(LeakageModel, analysis_id)
leakage_model_parameters = leakage_models.leakage_model
# get visualization plots
all_visualization_plots = sca_views.visualization_plots()
all_visualization_heatmap_plots = sca_views.visualization_plots_heatmap()
# confusion matrix plot
all_confusion_matrix_plots = sca_views.confusion_matrix_plots()
return render_template("dashboard/result.html",
all_plots=all_metric_plots,
all_key_rank_plots=all_key_rank_plots,
all_success_rate_plots=all_success_rate_plots,
neural_network_description=neural_network_model.description,
training_hyper_parameters=training_hyper_parameters,
hyper_parameters=hyper_parameters,
hyper_parameter_search=hyper_parameter_search,
leakage_model_parameters=leakage_model_parameters,
all_visualization_plots=all_visualization_plots,
all_visualization_heatmap_plots=all_visualization_heatmap_plots,
all_confusion_matrix_plots=all_confusion_matrix_plots,
analysis=analysis)