def check_username_exists(check_username_exists_json):
try:
check_username_exists_dict = json_decoder.decode(
check_username_exists_json)
# if new installation, create new user table
if not (user_table_exists()):
create_new_user_table()
# check user table is username exists
fileObject = open("USERTABLE", "rb")
table = pickle.load(fileObject)
if any(obj['username'] == check_username_exists_dict['username']
for obj in table):
return json_encoder.encode({
"message": "Success",
"comment": "Username exists"
})
return json_encoder.encode({
"message": "Success",
"comment": "Username available"
})
except:
return json_encoder.encode({
"message": "Failure",
"comment": "Other error"
})
def check_username_exists(check_username_exists_json):
check_username_exists_dict = json_decoder.decode(
check_username_exists_json)
print("\n", check_username_exists_dict, "\n")
# if new installation, create new user table
if not (user_table_exists()):
create_new_user_table()
# check user table is username exists
fileObject = open("USERTABLE", "rb")
table = pickle.load(fileObject)
print("\n", table, "\n")
if any(obj['username'] == check_username_exists_dict['username']
for obj in table):
print("exists")
return json_encoder.encode({
"message": "Success",
"comment": "Username exists"
})
return json_encoder.encode({
"message": "Success",
"comment": "Username available"
})
def check_notebook_name_exists(check_notebook_name_exists_json):
check_notebook_name_exists_dict = json_decoder.decode(
check_notebook_name_exists_json)
# if new installation, create global notebooks table
if not (notebook_global_table_exist()):
create_notebook_global_table()
# opens the global notebooks table, and checks whether notebook exists
fileObject = open("NOTEBOOKS_DATA", "rb")
table = pickle.load(fileObject)
if any(obj['notebook_name'] ==
check_notebook_name_exists_dict['notebook_name'] for obj in table):
return json_encoder.encode({
"message": "Success",
"comment": "Notebook name exists"
})
return json_encoder.encode({
"message": "Success",
"comment": "Notebook name available"
})
def export_pdf(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
url = [
"/upload-data", "/build-model", "/train-model", "/results",
"/investigate-model"
]
merger = PdfFileMerger()
# go over the 5 pages of the notebook and save them as pdfs using google-chrome invoked through shell.
# will not work on windows
for i in range(5):
os.system("google-chrome --headless --disable-gpu --print-to-pdf=\"" +
notebook_name_dict['notebook_name'] + 'out' + str(i) +
'.pdf' + "\" http://localhost:8080/notebook/" +
notebook_name_dict['notebook_name'] + url[i])
# merge the pdfs while deleting them
for i in range(5):
merger.append(
open(notebook_name_dict['notebook_name'] + 'out' + str(i) + '.pdf',
'rb'))
remove(notebook_name_dict['notebook_name'] + 'out' + str(i) + '.pdf')
# save the merged pdf
with open(notebook_name_dict['notebook_name'] + '_report.pdf', 'wb') as fp:
merger.write(fp)
# return PDF type data, to open on the browser
return Response(open(notebook_name_dict['notebook_name'] + '_report.pdf',
'rb').read(),
mimetype="application/pdf")
def load_existing_notebook_details(notebook_details):
# Send data to UI to load back existing notebook
print(notebook_details)
data = json_decoder.decode(notebook_details)
notebook = get_notebook_data(data['notebook_name'])
dct = {}
for key in notebook:
dct[key] = notebook[key]
return json_encoder.encode({"message": "Success", "notebook_data": dct})
def pick_tool(vulnerabilities_json):
print("here")
status_code = -1
status_message = 'Error'
return_data = ""
print(vulnerabilities_json)
# vulnerabilities_dict = json_encoder.encode(vulnerabilities_json)
vulnerabilities_dict = json_decoder.decode(vulnerabilities_json)
vulnerabilities = vulnerabilities_dict["vulnerabilities"]
username = vulnerabilities_dict["username"]
print("\nusername: "******"\n")
url = vulnerabilities_dict["url"]
url = url.strip('\"')
print("\n " + vulnerabilities_dict["url"] + "\n")
if "ssl" in vulnerabilities:
url = url.split('//')
if url[0] == 'https:' or url[0] == 'http:':
url.pop(0)
url_modified = ''.join(map(str, url))
url_modified = url_modified.split('/')
url_modified_stripped = url_modified[0]
print(url_modified_stripped)
ss = VulnerabilityScanTools()
return_data += ss.sslyzer_scan("www.pes.edu:443", "full")
elif "xsser" in vulnerabilities:
ss = VulnerabilityScanTools()
return_data += ss.xsser_scan("https://hack.me/")
elif "nikto" in vulnerabilities:
ss = VulnerabilityScanTools()
return_data += ss.nikto_scan("www.isanalytics.com")
print("Notebook name", vulnerabilities_dict["notebook_name"])
#setting notebook data
fileObject = open("NOTEBOOK_" + vulnerabilities_dict["notebook_name"],
"rb")
table = pickle.load(fileObject)
print(type(table))
fileObject.close()
table["url"] = vulnerabilities_dict["url"]
table["vulnerabilities"] = vulnerabilities_dict["vulnerabilities"]
table["report"] = return_data
fileObject = open("NOTEBOOK_" + vulnerabilities_dict["notebook_name"],
"wb")
pickle.dump(table, fileObject)
fileObject.close()
print("return data", return_data)
return json_encoder.encode({"message": "Success", "report": return_data})
def get_roc_curve(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
# does predict on testing data
# to invoke keras predict
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model("NOTEBOOK_" +
notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
probs = model.predict(notebook['x_test'])
# to invoke sklearn predict
else:
probs = notebook['model'].predict_proba(notebook['x_test'])
preds = probs[:, 1]
fpr, tpr, threshold = roc_curve(notebook['y_test'], preds)
roc_auc = auc(fpr, tpr)
# Create ROC plot
plt.title('Receiver Operating Characteristic')
plt.plot(fpr, tpr, 'b', label='AUC = %0.2f' % roc_auc)
plt.legend(loc='lower right')
plt.plot([0, 1], [0, 1], 'r--')
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
# Save plot to be used by vue.js
filename = "NOTEBOOK_" + notebook['notebook_name'] + "_roc_curve.jpg"
plt.savefig("../UI/src/assets/" + filename)
plt.clf()
# Save file name in notebook
notebook['roc_curve'] = filename
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({"message": "Success", "roc_curve": filename})
def get_user_notebooks(get_user_notebooks_json):
get_user_notebooks_dict = json_decoder.decode(get_user_notebooks_json)
# opens user table and returns list of notebooks opened by that user
table = pickle.load(open("USERTABLE", "rb"))
print("table", table, get_user_notebooks_dict)
for obj in table:
if (obj['username'] == get_user_notebooks_dict['username']):
print("username match")
return json_encoder.encode({
"message": "Success",
"notebook_names": obj['notebooks']
})
return json_encoder.encode({"message": "Failure"})
def get_confusion_matrix(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
# to invoke keras predict
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model("NOTEBOOK_" +
notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
prediction = model.predict(notebook['x_test'])
prediction = numpy.array(list(map(numpy.argmax, prediction)))
# to invoke sklearn predict
else:
model = notebook['model']
prediction = model.predict(notebook['x_test'])
# de-"one hot"
y_test = notebook['y_test']
if len(y_test.shape) > 1:
y_test = numpy.array(list(map(numpy.argmax, y_test)))
matrix = confusion_matrix(notebook['y_test'], prediction).ravel()
# save confusion matrix in notebook
# did not consider for multiclass labels while displaying
notebook['confusion_matrix'] = matrix
notebook['true_negative'] = int(matrix[0])
notebook['false_positive'] = int(matrix[1])
notebook['false_negative'] = int(matrix[2])
notebook['true_positive'] = int(matrix[3])
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({
"message": "Success",
"confusion_matrix": matrix.tolist()
})
def get_epoch_details(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
# Yield the events of epoch ending
def epoch_done_streamer():
# Busy wait - can be improved
while True:
if notebook['_epoch_done']:
# reset the epoch done notifier; continue to wait busily
notebook['_epoch_done'] = False
# send just a signal to reload the image created, therefore data = 0
yield 'event: EPOCH_END\ndata: 0\n\n'
# return Server sent events
return Response(epoch_done_streamer(), mimetype="text/event-stream")
def get_accuracy(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
# to invoke keras predict
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model("NOTEBOOK_" +
notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
prediction = model.predict(notebook['x_test'])
prediction = numpy.array(list(map(numpy.argmax, prediction)))
# to invoke sklearn predict
else:
model = notebook['model']
prediction = model.predict(notebook['x_test'])
# de-"one hot"
y_test = notebook['y_test']
if len(y_test.shape) > 1:
y_test = numpy.array(list(map(numpy.argmax, y_test)))
accuracy = accuracy_score(notebook['y_test'], prediction)
# save accuracy in notebook
notebook['accuracy'] = accuracy
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({
"message": "Success",
"accuracy": str(accuracy)
})
def investigate_model(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
def predict_fn(instance):
if notebook['model_type'] == "NEURAL NETWORK":
return keras.models.model_from_json(notebook['model']).predict(
[instance])
try:
return notebook['model'].predict_proba(instance)
except:
return notebook['model'].predict(instance)
def explain_instance_image_data(instance):
newshape = numpy.prod(instance.shape)
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model(
"NOTEBOOK_" + notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
target = list(
map(
numpy.argmax,
model.predict(
numpy.reshape(instance,
newshape=(1, *instance.shape)))[0]))[0]
else:
target = notebook['model'].predict(
numpy.reshape(instance, newshape=newshape))
plt.savefig("../UI/src/assets/" + "NOTEBOOK_" +
notebook['notebook_name'] +
"_investigate_model_instance0.jpg")
plt.clf()
explainer = lt.LimeTabularExplainer(
training_data=notebook['x_train'],
feature_names=[str(i) for i in range(len(instance))]
if 'column_names' not in notebook else notebook['column_names'])
exp = explainer.explain_instance(instance,
predict_fn,
num_features=len(instance),
num_samples=newshape,
labels=(target, ))
exp.as_pyplot_figure(label=target).savefig(
"../UI/src/assets/" + "NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance1.jpg",
figsize=(50, 50))
exp.save_to_file(file_path="../UI/src/assets/" + "NOTEBOOK_" +
notebook['notebook_name'] +
"_investigate_model_instance.html")
explaination_list = exp.as_map()[target]
constructed_image = numpy.zeros(shape=len(explaination_list))
for i, j in explaination_list:
constructed_image[i] = 0.5 + j / 2
constructed_image = numpy.reshape(constructed_image,
newshape=instance.shape)
plt.savefig("../UI/src/assets/" + "NOTEBOOK_" +
notebook['notebook_name'] +
"_investigate_model_instance2.jpg")
plt.clf()
notebook['explanation'] = "NOTEBOOK_" + notebook[
'notebook_name'] + "_investigate_model_instance.html"
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({
'instance':
"NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance0.jpg",
'explanation':
"NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance.html",
'constructed':
"NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance2.jpg"
})
def explain_instance_tabular_data(instance):
newshape = numpy.prod(instance.shape)
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model(
"NOTEBOOK_" + notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
target = list(
map(
numpy.argmax,
model.predict(
numpy.reshape(instance,
newshape=(1, *instance.shape)))[0]))[0]
else:
target = notebook['model'].predict([instance])[0]
explainer = lt.LimeTabularExplainer(
training_data=notebook['x_train'],
feature_names=[str(i) for i in range(len(instance))])
exp = explainer.explain_instance(instance,
predict_fn,
num_features=len(instance),
num_samples=min(
len(notebook['x_train']), 100),
labels=(target, ))
exp.as_pyplot_figure(label=target).savefig(
"../UI/src/assets/" + "NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance1.jpg",
figsize=(50, 50))
exp.save_to_file(file_path="../UI/src/assets/" + "NOTEBOOK_" +
notebook['notebook_name'] +
"_investigate_model_instance.html")
notebook['explanation'] = "NOTEBOOK_" + notebook[
'notebook_name'] + "_investigate_model_instance.html"
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({
'explanation':
"NOTEBOOK_" + notebook['notebook_name'] +
"_investigate_model_instance.html"
})
is_image = len(notebook['x_test'][0].shape) >= 2
if is_image:
return explain_instance_image_data(
notebook['x_train'][numpy.random.randint(
0, len(notebook['x_test'] - 1))])
else:
return explain_instance_tabular_data(
notebook['x_train'][numpy.random.randint(
0, len(notebook['x_test'] - 1))])
def get_precision_recall_curve(notebook_name_json):
notebook_name_dict = json_decoder.decode(notebook_name_json)
notebook = get_notebook_data(notebook_name_dict['notebook_name'])
# to invoke sklearn predict
if notebook['model_type'] == "NEURAL NETWORK":
model = keras.models.load_model("NOTEBOOK_" +
notebook_name_dict['notebook_name'] +
"_neural_network_model.hdf5")
prediction = model.predict(notebook['x_test'])
prediction = numpy.array(list(map(numpy.argmax, prediction)))
# to invoke sklearn predict
else:
model = notebook['model']
prediction = model.predict(notebook['x_test'])
y_score = prediction
# de-"one hot"
y_test = notebook['y_test']
if len(y_test.shape) > 1:
y_test = numpy.array(list(map(numpy.argmax, y_test)))
# Average precision curve for only binary class problems
# can iterate for multi class
y_test[y_test == y_test.min()] = 0
y_test[y_test != 0] = 1
average_precision = average_precision_score(y_test, y_score)
notebook['average_precision_score'] = average_precision
precision, recall, _ = precision_recall_curve(y_test, y_score)
# create precision recall curve
plt.step(recall, precision, color='b', alpha=0.2, where='post')
plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('2-class Precision-Recall curve: AP={0:0.2f}'.format(
average_precision))
# save data and filename in the notebook for reloading
filename = "NOTEBOOK_" + notebook[
'notebook_name'] + "_precision_recall_curve.jpg"
plt.savefig("../UI/src/assets/" + filename)
plt.clf()
notebook['precision_recall_curve'] = filename
notebook['average_precision_score'] = average_precision
notebook['recall'] = recall.mean()
set_notebook_data(notebook_name_dict['notebook_name'])
try:
keras.backend.clear_session()
except:
pass
return json_encoder.encode({
"message": "Success",
"precision_recall_curve": filename,
"average_precision_score": average_precision,
"recall": recall.mean()
})