def __init__(self, density):
"""Initialize the simulation."""
#Initialize the container
container = LJContainer(density)
#Equilibriate the system
while self.t < EQUILIBRIATION_STEPS:
sys.stdout.write("\rEquilibriating the container: {0:3.1f}%".format(
self.t*100/EQUILIBRIATION_STEPS))
sys.stdout.flush()
#Do one 'tick' consisting of two integrations and a force update
container.tick(rescale=True)
#Increment time
self.t += 1
print("\n")
self.t = 0.0
#Start measuring
while self.t < MEASUREMENT_STEPS:
sys.stdout.write("\rCalculating averages: {0:3.1f}%".format(
self.t*100/MEASUREMENT_STEPS))
sys.stdout.flush()
#Do one 'tick' consisting of two integrations and a force update
container.tick(rescale=True)
#Sample averages
container.sample(self.t)
#Increment time
self.t += 1
#Store sampling data
util.write_data(container.data, density)
#Generate a plot of the measured properties
util.generate_report(density)
#Print out the average value for the pressure
pressure = util.calculate_average(container.data, "P")
#Write calculated pressure to disk
util.store_pressure(pressure, density)
print("\nAverage pressure for density {0}: {1:6.4}".format(
density, pressure))
def initial_exploit(self, debug=None):
print(f"=== Current state is {self.state} ===")
print("Are there untested high-risk issues?")
vuldata = None
for index, value in enumerate(self.data["issues"]):
if value["used"] == 0 and value["severity"] == "high" and ((debug == None) or (value["cwe"] == debug)):
vuldata = value
vuldata["cookie_string"] = self.data["cookie_string"]
self.data["issues"][index]["used"] = 1
j = json.dumps(self.data, indent=4)
with open(f'./Data/{self.target}.json', 'w') as w:
w.write(j)
break
if vuldata:
report_issue = None
self.path_count+=1
print("-> Yes!")
print(f"Start to attack {self.target} through issue {vuldata['name']}...")
if vuldata["cwe"] == 78:
report_issue = Execution.cmd_injection(vuldata)
elif vuldata["cwe"] == 79:
report_issue = Execution.xss(vuldata)
elif vuldata["cwe"] == 89:
report_issue = Execution.sql_injection(vuldata)
elif vuldata["cwe"] == 22 or vuldata["cwe"] == 98:
report_issue = Execution.LFI_Path(vuldata)
elif vuldata["cwe"] == 94:
report_issue = Execution.RFI(vuldata)
elif vuldata["cwe"] == 352:
report_issue = Execution.CSRF(vuldata, self.report)
if report_issue:
if report_issue["next_state"] == "initialization":
util.generate_report(self.path_count, self.report, report_issue)
self.exploit_back()
self.start()
elif report_issue["next_state"] == "basic":
self.get_shell_success()
if report_issue["cwe"] == 78:
path = Execution.pe_cmd(report_issue, lhost=self.lhost)
elif report_issue["cwe"] == 94:
path = Execution.pe_rfi(report_issue, lhost=self.lhost)
util.generate_report(self.path_count, self.report, path)
if path["Privilege escalation"]["next_state"] == "root":
self.pe_success()
self.back()
elif report_issue["next_state"] == "sql":
self.sql_success()
util.generate_report(self.path_count, self.report, report_issue)
self.back()
elif report_issue["next_state"] == "root":
self.pe_success()
util.generate_report(self.path_count, self.report, report_issue)
self.back()
else:
print("[!] This framework does not include the exploitation of this vulnerability.")
self.exploit_back()
self.start()
else:
print(f"-> No!")
print(f"[*] ============ Pentest Finished ============")
totaltime = int(time.time())-self.start_time
print(f"[*] Total time : {time.strftime('%H:%M:%S', time.gmtime(totaltime))}")
print(f"[*] Pentest report : ./Report/{self.report}")
]
for index, driver in enumerate(drivers):
find_task_page(driver, PLATFORM, TASK_NAME, TRAINING_MODE)
time.sleep(8)
if DATA_SPLIT == 'iid':
for i in range(len(DIGIT_CLASS_PATHS)):
driver.find_element_by_id('hidden-input_mnist_' +
str(i)).send_keys(' \n '.join(
digit_files[i]))
else:
for i in range(len(DIGIT_CLASS_PATHS)):
driver.find_element_by_id('hidden-input_mnist_' +
str(i)).send_keys(' \n '.join(
digit_partitions[i][index]))
# Start training on each driver
time.sleep(8)
start_training(drivers, TRAINING_TYPE, TIME_OFFSETS)
time.sleep(5)
generate_report('report.txt', \
drivers, \
start_time, \
'//*[@id="app"]/div/div/div/div/div/div/div/main/div/div/div[3]/div/div[1]/div/div[2]/p/span[1]', \
'//*[@id="app"]/div/div/div/div/div/div/div/main/div/div/div[3]/div/div[1]/div/div[1]/p/span[1]', \
10)
for driver in drivers:
driver.quit()
history = ae.fit(x=x_train,
y=x_train,
shuffle=True,
epochs=epochs,
batch_size=batch_size,
validation_data=(x_test, x_test))
end_time = datetime.datetime.today()
print(f"Completed {epochs} in {end_time-start_time}.")
# generate report here
r = {
'start_time': start_time,
'end_time': end_time,
'history': history.history,
'batch_size': batch_size,
'epochs': epochs,
'learning_rate': learning_rate,
'latent_dim': latent_dim,
'n_filters': n_filters,
'input_shape': input_shape,
'rate': rate,
'n_samples': n_samples,
'encoder': e,
'decoder': d,
'autoencoder': ae
}
util.generate_report(r)
"training history": training_history,
"start time": s,
"end time": e,
"elapsed time": elp,
"batch size": batch_size,
"epochs": epochs,
"input shape": input_shape,
"learning rate": lr,
"spect type": spect_type,
"spect size": spect_size,
"standard": standard,
"model": saved_model,
"train": train,
"folds": n_folds
}
final_loss = generate_report(report_dir, report_data)
pickle.dump(training_history,
open(os.path.join(report_dir, "training_history.pkl"), "wb"),
protocol=2)
# email report
with open(os.path.join(report_dir, "report_summary.txt"),
'r') as report_fp:
report_details = report_fp.read()
alert = email_alert()
alert.send(
subject=
"MixCNN Train Cycle {0}-{1:0>2}-{2:0>2} {3:0>2}:{4:0>2} [{5:0.4f}]"
.format(s.year, s.month, s.day, s.hour, s.minute, final_loss),
message=report_details)