def test_bruteforce_complex_float(self):
self.assertEqual(self.wallet.max_budget, 500)
available_shares = [
Share("Share - DUPH", "100.01", "12.25"),
Share("Share - GTAN", "26.04", "38.06"),
Share("Share - USUF", "9.25", "27.69"),
Share("Share - CFOZ", "10.64", "38.21"),
Share("Share - QLRX", "50.72", "27.47"),
Share("Share - HKFP", "230.97", "19.66"),
Share("Share - PPPH", "24.06", "38.2"),
Share("Share - HLJY", "78.98", "5.54"),
Share("Share - CTCR", "160.6", "12.4")
]
bruteforce(self.wallet, available_shares)
# Expected_folder values come from the output of utils/knapsack_solver_google.py
# used with roundings of this test values (the scripts only accepts integers as input)
# Script results:
# Total value (total_profit) = 98
# Total weight (total_cost) : 493
# Packed items (indexes in available_shares) : [1, 4, 5, 6, 8]
# Packed_weights (prices in available_shares) : [26, 51, 231, 24, 161]
expected_folder = {
"Share - GTAN": 26.04,
"Share - QLRX": 50.72,
"Share - HKFP": 230.97,
"Share - PPPH": 24.06,
"Share - CTCR": 160.6
}
self.assertEqual(dict(self.wallet.folder), expected_folder)
self.assertEqual(self.wallet.total_cost, 492.39)
self.assertEqual(self.wallet.total_profit, 98.35)
def between(lst):
if len(lst) <= 3:
return bruteforce(lst)
lhalf = lst[0:len(lst) / 2]
rhalf = lst[len(lst) / 2:len(lst)]
d = between(lhalf)
d_new = between(rhalf)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + d_new[1])
min_y = lhalf[-1][1] - d[0]
max_y = rhalf[0][1] + d[0]
d_new = bruteforce([p for p in lhalf if p[1] > min_y] +
[p for p in rhalf if p[1] < max_y])
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + [p for p in d_new[1] if p not in d[1]])
return d
def brute(domain, dict, thread):
print('The brute scanning for subdomain is running.....\n')
if dict is None:
position = os.getcwd()
position = position + '/_dict/222.txt'
# print(position)
else:
position = dict
bruteforce.bruteforce(domain, position, thread)
def authenticate(self, username=None, password=None):
try:
user = User.objects.get(email=username)
if user.check_password(password):
return user
except User.DoesNotExist:
pass
# bruteforce
if username is not None:
bruteforce(username)
return None
def test_bruteforce_simple(self):
self.assertEqual(self.wallet.max_budget, 500)
available_shares = [
Share("Share-1", "1", "1"),
Share("Share-2", "10", "1"),
Share("Share-3", "100", "1")
]
bruteforce(self.wallet, available_shares)
expected_folder = {"Share-1": 1, "Share-2": 10, "Share-3": 100}
self.assertEqual(self.wallet.folder, expected_folder)
self.assertEqual(self.wallet.total_cost, 111)
self.assertEqual(self.wallet.total_profit, 1.11)
def test_bruteforce_simple_float(self):
self.assertEqual(self.wallet.max_budget, 500)
available_shares = [
Share("Share-1", "0.5", "1.5"),
Share("Share-2", "10.22", "12.3"),
Share("Share-3", "100.3", "22")
]
bruteforce(self.wallet, available_shares)
expected_folder = {"Share-1": 0.5, "Share-2": 10.22, "Share-3": 100.3}
self.assertEqual(self.wallet.folder, expected_folder)
self.assertEqual(self.wallet.total_cost, 111.02)
self.assertEqual(self.wallet.total_profit, 23.34)
def verify(G, s, cutoff):
n = G.order()
#read graph from G
happiness = {}
stress = {}
for i in range(n):
happiness[i] = {}
stress[i] = {}
for i in range(n):
for j in range(i + 1, n):
happiness[i][j] = G.get_edge_data(i, j)['happiness']
stress[i][j] = G.get_edge_data(i, j)['stress']
if n <= 10:
bf_arr, bf_val = bruteforce.bruteforce(happiness, stress,
len(list(happiness.keys())), s)
bf_val = bf_val
assignments = {}
for i in range(len(bf_arr)):
for person in bf_arr[i]:
assignments[person] = i
return assignments, len(bf_arr), bf_val
elif n == 20 or n == 50:
answer, rooms, best_k = lp_cutoff(happiness, stress, s, n, cutoff)
return rooms, best_k, answer
else:
return "Graph sizes that aren't <=10, 20, or 50 nodes aren't accepted"
def naive(lst):
lst = sorted(lst)
if (len(lst) <= 3):
return bruteforce(lst)
else:
lhalf = lst[0:len(lst) / 2]
rhalf = lst[len(lst) / 2:len(lst)]
d = naive(lhalf)
d_new = naive(rhalf)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + d_new[1])
m = []
for p in lhalf:
if p[0] > lhalf[-1][0] - d[0]:
m.append(p)
for p in rhalf:
if p[0] < rhalf[0][0] - d[0]:
m.append(p)
sorted_m = sorted(m, sorty)
d_new = between(sorted_m)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + [p for p in d_new[1] if p not in d[1]])
return d
def generating(iter):
number_of_machines = int(input("Ile maszyn?: "))
number_of_tasks = int(input("Ile zadan?: "))
times = []
durationBruteforce = []
durationJohnson = []
i = 0
while i < iter:
generatedTasks = []
cnt_tasks = 0
cnt_machines = 0
for cnt_tasks in range(0, number_of_tasks):
rows = []
for cnt_machines in range(0, number_of_machines):
rows.append(int(random.uniform(1, 10)))
print("{}".format(rows))
generatedTasks.append(Task(cnt_tasks, rows))
bruteforceOrder, timeBruteforce = bruteforce(
copy.deepcopy(generatedTasks), number_of_machines)
johnsonOrder, timeJohnson = johnson(copy.deepcopy(generatedTasks),
number_of_machines)
durationBruteforce.append(timeBruteforce)
durationJohnson.append(timeJohnson)
bruteforceMakespan = makespan(bruteforceOrder, generatedTasks,
number_of_machines)
johnsonMakespan = makespan(johnsonOrder, generatedTasks,
number_of_machines)
i += 1
if johnsonMakespan == bruteforceMakespan:
times.append(johnsonMakespan)
else:
times.append(-1)
x = PrettyTable()
print("")
print("----------------------------------------------------------")
x.field_names = [
"l.p.", "Johnson Makespan", "Poprawnosc", "Czas Bruteforce [ms]",
"Czas Johnson [ms]"
]
k = 0
for k in range(0, iter):
if times[k] == -1:
x.add_row([
k + 1, "{}".format(times[k]), "Nie",
"{}".format(durationBruteforce[k]),
"{}".format(durationJohnson[k])
])
else:
x.add_row([
k + 1, "{}".format(times[k]), "Tak",
"{}".format(durationBruteforce[k]),
"{}".format(durationJohnson[k])
])
print(x)
def run():
path = input(
"Which method do you want to use? \nBrute force (1), Dynamic (2), Best First Branch Bound (3), or Backtracking (4)?\nOr press q to quit : "
)
if path == '1':
time1 = datetime.datetime.now()
print(bruteforce.bruteforce(W, items[2], items[1], len(items[0])))
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Brute force: Time taken: %s ms" %
int(tdelta.total_seconds() * 1000))
print("\n")
run()
elif path == '2':
time1 = datetime.datetime.now()
print(dynamic.dynamic(W, items[2], items[1], len(items[0])))
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Dynamic: Time taken: %s ms" %
int(tdelta.total_seconds() * 1000))
print("\n")
run()
elif path == '3':
time1 = datetime.datetime.now()
print(
firstBranchBound.firstBranchBound(W, items[2], items[1],
len(items[0])))
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Best First Branch Bound: Time taken: %s ms" %
int(tdelta.total_seconds() * 1000))
print("\n")
run()
elif path == '4':
time1 = datetime.datetime.now()
print(backtracking.backtracking(W, items[2], items[1], len(items[0])))
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Backtracking: Time taken: %s ms" %
int(tdelta.total_seconds() * 1000))
print("\n")
run()
elif path == 'q':
sys.exit("See ya!")
else:
print("Error: no valid option chosen. Please try again.")
print("\n")
run()
def main_menu():
choice = input(
"Press :\n1 to manage users\n2 to manage ftp\n3 to test brute force\n4 to scan ports\n5 to try the mail bombing\n6 to see the logs file\n7 to exit\n"
)
if choice == "1":
logs.writeInLogSimple(user.username, " à lancer la gestion d'User")
users_menu()
main_menu()
elif choice == "2":
logs.writeInLogSimple(user.username, " à lancer la gestion FTP")
checkdirect()
ftp_menu()
main_menu()
elif choice == "3":
logs.writeInLogSimple(user.username, " à lancer le bruteforce")
bruteforce.bruteforce()
main_menu()
elif choice == "4":
logs.writeInLogSimple(user.username, " à lancer le scan de port")
portscan_menu()
main_menu()
elif choice == "5":
logs.writeInLogSimple(user.username, " à lancer le mail bombing")
smtp.lancement()
main_menu()
elif choice == "6":
filename = "log.txt"
with open(filename) as f:
data = f.readlines()
for n, line in enumerate(data, 1):
print('{:2}.'.format(n), line.rstrip())
# logs()
main_menu()
elif choice == "7":
exit()
else:
print("Wrong key")
main_menu()
def between(lst):
if (len(lst) <= 3):
return bruteforce(lst)
else:
lhalf = lst[0:len(lst) / 2]
rhalf = lst[len(lst) / 2:len(lst)]
d = between(lhalf)
d_new = between(rhalf)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + d_new[1])
d_new = bruteforce([p for p in lhalf if p[0] > lhalf[-1][0] - d[0]] +
[p for p in rhalf if p[0] < rhalf[0][0] + d[0]])
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + [p for p in d_new[1] if p not in d[1]])
return d
def run():
path = input("Which method do you want to use? \nBrute force (1), Dynamic (2), Best First Branch Bound (3), or Backtracking (4)?\nOr press q to quit : ")
if path == '1':
time1 = datetime.datetime.now()
print( bruteforce.bruteforce(W, items[2], items[1], len(items[0])) )
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Brute force: Time taken: %s ms" % int(tdelta.total_seconds()*1000) )
print("\n")
run()
elif path == '2':
time1 = datetime.datetime.now()
print( dynamic.dynamic(W, items[2], items[1], len(items[0])) )
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Dynamic: Time taken: %s ms" % int(tdelta.total_seconds()*1000) )
print("\n")
run()
elif path == '3':
time1 = datetime.datetime.now()
print( firstBranchBound.firstBranchBound(W, items[2], items[1], len(items[0])) )
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Best First Branch Bound: Time taken: %s ms" % int(tdelta.total_seconds()*1000) )
print("\n")
run()
elif path == '4':
time1 = datetime.datetime.now()
print( backtracking.backtracking(W, items[2], items[1], len(items[0])) )
time2 = datetime.datetime.now()
tdelta = time2 - time1
print("Backtracking: Time taken: %s ms" % int(tdelta.total_seconds()*1000) )
print("\n")
run()
elif path == 'q':
sys.exit("See ya!")
else:
print("Error: no valid option chosen. Please try again.")
print("\n")
run()
def solve(G, s):
"""
Args:
G: networkx.Graph
s: stress_budget
Returns:
D: Dictionary mapping for student to breakout room r e.g. {0:2, 1:0, 2:1, 3:2}
k: Number of breakout rooms
"""
n = G.order()
happiness = {}
stress = {}
for i in range(n):
happiness[i] = {}
stress[i] = {}
for i in range(n):
for j in range(i + 1, n):
happiness[i][j] = G.get_edge_data(i, j)['happiness']
stress[i][j] = G.get_edge_data(i, j)['stress']
print("Input Size:", n)
if n <= 10: #brute force approach
start_time = time.perf_counter()
bf_arr, bf_val = bruteforce.bruteforce(happiness, stress,
len(list(happiness.keys())), s)
bf_val = round(bf_val, 3)
end_time = time.perf_counter()
print("Brute Force Approach Time:", end_time - start_time)
#ILP
start_time = time.perf_counter()
answer, rooms, best_k = lp.lp_solve(happiness, stress, s, n)
end_time = time.perf_counter()
times.append(end_time - start_time)
print("Gurobi Approach Time: ", end_time - start_time)
print("Gurobi Answer: ", answer)
#print("Gurobi Rooms (raw): ", rooms, best_k)
print("Gurobi Rooms:", order(rooms)[0])
if n <= 10:
#assert bf_val == answer, "Incorrect computation"
print("Brutef Rooms:", bf_arr)
print("Brutef Answer:", bf_val)
return rooms, order(rooms)[1]
def main():
# x_list = [100, 75, 15, 495, 995, 995, 995, 995, 510, 110]
# target = 635
x_list = [
1150,
495,
995,
995,
995,
995,
100,
750,
3305,
75,
510,
3265,
2145,
1935,
140,
140,
15,
1330,
2800,
1250,
350,
850,
110,
]
target = 8270
time0 = time()
bf = bruteforce.bruteforce(x_list, target)
time1 = time()
so = stackoverflow.stackoverflow(x_list, target)
time2 = time()
he = hetland.bb_knapsack(x_list, target)
time3 = time()
wi = wikipedia.approx_with_accounting_and_duplicates(x_list, target)
time4 = time()
print "Brute force:", bf, time1 - time0
print "Stackoverflow:", so, time2 - time1
print "Hetland:", he, time3 - time2
print "Wikipedia:", wi, time4 - time3
def main():
# x_list = [100, 75, 15, 495, 995, 995, 995, 995, 510, 110]
# target = 635
x_list = [1150, 495, 995, 995, 995, 995, 100, 750, 3305, 75, 510, 3265, 2145, 1935, 140, 140, 15, 1330, 2800, 1250, 350, 850, 110]
target = 8270
time0 = time()
bf = bruteforce.bruteforce(x_list, target)
time1 = time()
so = stackoverflow.stackoverflow(x_list, target)
time2 = time()
he = hetland.bb_knapsack(x_list, target)
time3 = time()
wi = wikipedia.approx_with_accounting_and_duplicates(x_list, target)
time4 = time()
print 'Brute force:', bf, time1 - time0
print 'Stackoverflow:', so, time2 - time1
print 'Hetland:', he, time3 - time2
print 'Wikipedia:', wi, time4 - time3
def naive(lst):
if len(lst) <= 3:
return bruteforce(lst)
lhalf = lst[0:len(lst) / 2]
rhalf = lst[len(lst) / 2:len(lst)]
d = naive(lhalf)
d_new = naive(rhalf)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + d_new[1])
min_x = lhalf[-1][0] - d[0]
max_x = rhalf[0][0] + d[0]
lst = []
for i in reversed(xrange(len(lhalf))):
if lhalf[i][0] > min_x:
lst.append(lhalf[i])
else:
break
for i in xrange(len(rhalf)):
if rhalf[i][0] < max_x:
lst.append(rhalf[i])
else:
break
d_new = between(sorted(lst, sorty))
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + [p for p in d_new[1] if p not in d[1]])
return d
def enhanced(lst, ysorted):
if len(lst) <= 3:
return bruteforce(lst)
lhalf = lst[0:len(lst) / 2]
rhalf = lst[len(lst) / 2:len(lst)]
lmax_x = lhalf[-1][0]
rmin_x = rhalf[0][0]
lysorted = []
rysorted = []
for p in ysorted:
if p[0] <= lmax_x:
lysorted.append(p)
else:
rysorted.append(p)
d = enhanced(lhalf, lysorted)
d_new = enhanced(rhalf, rysorted)
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + d_new[1])
min_x = lmax_x - d[0]
max_x = rmin_x + d[0]
d_new = between([p for p in lysorted if p[0] > min_x] +
[p for p in rysorted if p[0] < max_x])
if d_new[0] < d[0]:
d = d_new
elif d_new[0] == d[0]:
d = (d[0], d[1] + [p for p in d_new[1] if p not in d[1]])
return d
def solve(G, s):
"""
Args:
G: networkx.Graph
s: stress_budget
Returns:
D: Dictionary mapping for student to breakout room r e.g. {0:2, 1:0, 2:1, 3:2}
k: Number of breakout rooms
"""
n = G.order()
#read graph from G
happiness = {}
stress = {}
for i in range(n):
happiness[i] = {}
stress[i] = {}
for i in range(n):
for j in range(i + 1, n):
happiness[i][j] = G.get_edge_data(i, j)['happiness']
stress[i][j] = G.get_edge_data(i, j)['stress']
if n <= 10:
bf_arr, bf_val = bruteforce.bruteforce(happiness, stress,
len(list(happiness.keys())), s)
bf_val = bf_val
assignments = {}
for i in range(len(bf_arr)):
for person in bf_arr[i]:
assignments[person] = i
return assignments, len(bf_arr), bf_val
elif n == 20 or n == 50:
answer, rooms, best_k = lp.lp_solve(happiness, stress, s, n)
return rooms, best_k, answer
else:
return "Graph sizes that aren't <=10, 20, or 50 nodes aren't accepted"
def __call__(self):
self.menu.add("Force brute", MethodMenu(data_file=self.data_file))
self.menu.add("Glouton", MethodMenu(data_file=self.data_file))
self.menu.add("Force brute sur les meilleurs profits (%)",
MethodMenu(data_file=self.data_file))
self.menu.add("Programmation dynamique",
MethodMenu(data_file=self.data_file))
self.menu.add("Retour au menu principal", HomeMenu())
self.menu.add("Quitter", ExitMenu())
user_choice = self.menu.get_user_choice()
market = import_actions_data(file=self.data_file)
if isinstance(user_choice, ExitMenu) or isinstance(
user_choice, HomeMenu):
return user_choice()
cap = input_cap()
start_time = time.time()
if self.menu.choice == 0:
portfolio = bruteforce(market, cap=cap)
elif self.menu.choice == 1:
portfolio = greedy(market=market, cap=cap)
elif self.menu.choice == 2:
number_best_actions = input_number_of_actions()
portfolio = bruteforce_with_n_best_actions(market=market,
cap=cap,
n=number_best_actions)
elif self.menu.choice == 3:
number_of_decimals = input_number_of_decimals()
portfolio = KS_dynamic(market=market,
cap=cap,
ndigits=number_of_decimals)
end_time = time.time()
display_best_portfolio(portfolio)
print(
f"Temps d'exécution : {int((end_time - start_time)//60)} min {int(round((end_time - start_time)%60, ndigits=0))} s."
)
return user_choice()
output_file = open("output_" + name + ".txt", "w")
output_file.write(str(result[0]) + "\n")
for pair in sorted(result[1]):
output_file.write(str(pair[0][0]) + " " + str(pair[0][1]) + " " + str(pair[1][0]) + " " + str(pair[1][1]) + "\n")
output_file.close()
if __name__ == "__main__":
input_file = open(argv[2], "r")
points = []
for line in input_file:
line = line.split()
try:
points.append((int(line[0]), int(line[1])))
except ValueError:
points.append((float(line[0]), float(line[1])))
input_file.close()
xsorted = sorted(points, sortx)
import time
t = time.time()
if argv[1] == "-b":
print_to_file(bruteforce.bruteforce(xsorted), "bruteforce")
elif argv[1] == "-d":
print_to_file(divideandconquer.naive(xsorted), "divideandconquer")
elif argv[1] == "-e":
print_to_file(enhanceddnc.enhanced(xsorted, (sorted(points, sorty))), "enhanceddnc")
print time.time() - t
from bruteforce import bruteforce
import genetic
from analyze import timer
things = knapsack.generate_things(22)
things = knapsack.second_example
weight_limit = 3000
print("Weight Limit: %dkg" % weight_limit)
print("")
print("Bruteforce Algorithm")
print("----------")
with timer():
result = bruteforce(things, weight_limit)
knapsack.print_stats(result[1])
print("")
print("Genetic Algorithm")
print("----------")
with timer():
population, generations = genetic.run_evolution(
populate_func=partial(genetic.generate_population,
size=10,
genome_length=len(things)),
fitness_func=partial(knapsack.fitness,
things=things,
weight_limit=weight_limit),
import read_data, bruteforce, johnson
##############################################
TWO_OR_THREE = 3 #Two or three machines algorithm??
##############################################
print("Starting program...")
##MAIN##
if (TWO_OR_THREE == 2):
tasks_val, machines_val, tasks = read_data.read_data("data_2m.txt")
if (TWO_OR_THREE == 3):
tasks_val, machines_val, tasks = read_data.read_data("data_3m.txt")
print("The package ta000 has been loaded")
bruteforce.bruteforce(tasks, machines_val, tasks_val)
johnson.johnson_algorithm(machines_val, tasks)
def bruteforce_with_n_best_actions(market, cap, n):
market_selection = n_best_actions(market, n)
portfolio = bruteforce(market_selection, cap)
return portfolio
# #################################实现登录过程结束
# #################################检查密码是否正确开始
# if True:
# if r.status_code == 302: # 根据实际情况修改此处，判定登录成功
if "错误" not in r.text: # 根据实际情况修改此处，判定登录成功
msg = login_info
# 登录成功则把登录信息保存到success_queue
success_queue.put(msg)
# 把登录成功的用户名添加到 success_username中，之后可以跳过这个用户名的密码的爆破
success_username.append(username)
print('【爆破成功，用户名:{},密码:{}】'.format(username, password))
# 如果想要爆破出来一个密码就立刻停止爆破，那么此处调用函数stop_brute，反之则注释此处
# stop_brute()
# ################################# 检查密码是否正确结束
if __name__ == "__main__":
args = utils.get_parse()
dict_username = args.get('dict_username', "username.txt")
dict_password = args.get('dict_password', "password.txt")
utils.get_dict(dict_username, dict_password)
bruteforce(login, thread_num=5)
def get_parse() -> dict:
parser = argparse.ArgumentParser()
parser.add_argument("--username", "-u", help="用户名字典")
parser.add_argument("--password", "-p", help="密码字典")
dic = vars(parser.parse_args())
return dic
def get_captcha(img):
"""
识别验证码
:return:
"""
# 识别验证码
pass
code = "af3z"
return code
if __name__ == "__main__":
args = get_parse()
dict_username = args.get('dict_username', "username.txt")
dict_password = args.get('dict_password', "password.txt")
get_dict(dict_username, dict_password)
bruteforce(login_captcha, thread_num=1)
evaluations.append(utility.countConnections(s, edges))
if utility.isclique(solution, edges):
penalty = 0
else:
penalty = -1
return penalty + sum(evaluations) / (len(nodes) *
(len(nodes) - len(solution)) *
(len(solution) - 1))
print("from input")
print(goalFunction([6, 7, 4, 5], input_nodes, input_edges))
print(goalFunction([2, 3, 4, 6], input_nodes, input_edges))
print(goalFunction([2, 3, 4, 7], input_nodes, input_edges))
print(goalFunction([2, 3, 4, 5], input_nodes, input_edges))
solution = bruteforce.bruteforce(input_nodes, input_edges)
print(goalFunction(solution, input_nodes, input_edges))
print(solution)
print()
print("from rand")
nodes2, edges2 = utility.generateGraph(graphSize=20)
rand_solution = utility.randSolution(nodes2)
print(rand_solution)
print(goalFunction(rand_solution, nodes2, edges2))
brut_solution = bruteforce.bruteforce(nodes2, edges2)
print(goalFunction(brut_solution, nodes2, edges2))
print(brut_solution)
#PREPROCESSING
tic = time.clock()
dol = Dolphinn(P, D, K)
toc = time.clock()
print "Preprocessing time: ", toc - tic
#QUERIES
tic = time.clock()
#assign keys to queries
solQ = dol.queries(Q, M, num_of_probes)
toc = time.clock()
print "Average query time (Dolphinn): ", (toc - tic) / len(Q)
#BRUTEFORCE
tic = time.clock()
solQQ = bf.bruteforce(P, Q)
toc = time.clock()
print "Average query time (Bruteforce): ", (toc - tic) / len(Q)
#COMPUTE ACCURACY: max ratio (found distance)/(NN distance), number of exact NNs found
n = 0
mmax = 0
for i in range(len(solQ)):
if mmax < np.linalg.norm(np.subtract(P[solQ[i][0]],
Q[i])) / np.linalg.norm(
np.subtract(P[solQQ[i]], Q[i])):
mmax = np.linalg.norm(np.subtract(P[solQ[i][0]],
Q[i])) / np.linalg.norm(
np.subtract(P[solQQ[i]], Q[i]))
if solQ[i][0] == solQQ[i]:
n = n + 1
def driver_function(output_name, MAX_POINTS, MAX_SETS):
#generating 2d list for testing
max_average_time = 0
list_of_lists = []
current_list = []
for i in range(0, MAX_SETS):
for j in range(0, MAX_POINTS):
a = point_class.Point(random.randint(MIN_VAL, MAX_VAL),
random.randint(MIN_VAL, MAX_VAL))
current_list.append(a)
list_of_lists.append(current_list[:])
current_list = []
list_of_times = []
bf_rets = []
qh_rets = []
"""
#rough way to test hulls being drawn
extra_points = []
MAX_POINTS = MAX_POINTS + 8
extra_points.append(point_class.Point(3,3))
extra_points.append(point_class.Point(50,0))
extra_points.append(point_class.Point(97,3))
extra_points.append(point_class.Point(100,50))
extra_points.append(point_class.Point(97,97))
extra_points.append(point_class.Point(50,100))
extra_points.append(point_class.Point(3,97))
extra_points.append(point_class.Point(0,50))
for i in extra_points:
list_of_lists[0].append(i)
"""
# print("\n\nbruteforce:")
for index, current_list in enumerate(list_of_lists):
# print("current list:")
# for p in current_list:
# print("\t", p.x, ",", p.y)
run_time = time.time_ns()
a = bruteforce(current_list)
run_time = time.time_ns() - run_time
run_time /= 1000000000.0
list_of_times.append(run_time)
a = sorted(a)
bf_rets.append(a)
# for p in a:
# print("\t", p.x, ",", p.y)
# print("# of items: ", len(a))
f = open(output_name + "bf.txt", 'w')
f.write("brute force:\n")
average_time = 0
list_of_times = sorted(list_of_times)
for i in list_of_times:
output_string = "\trun time: " + str(i) + " seconds\n"
f.write(output_string)
average_time = average_time + i
average_time /= len(list_of_times)
average_time_string = "average time: " + str(average_time)
f.write(average_time_string)
if (average_time > max_average_time):
max_average_time = average_time
# print("\n\nquickhull:")
list_of_times = []
for index, current_list in enumerate(list_of_lists):
# print("current list:")
# for p in current_list:
# print("\t", p.x, ",", p.y)
run_time = time.time_ns()
b = quickhull(current_list)
run_time = time.time_ns() - run_time
run_time /= 1000000000.0
list_of_times.append(run_time)
b.sort()
qh_rets.append(b)
# for p in b:
# print("\t", p.x, ",", p.y)
# print("# of items: ", len(b))
g = open(output_name + "qh.txt", 'w')
g.write("quickhull\n")
average_time = 0
list_of_times = sorted(list_of_times)
for i in list_of_times:
output_string = "\trun time: " + str(i) + " seconds\n"
g.write(output_string)
average_time = average_time + i
average_time /= len(list_of_times)
average_time_string = "average time: " + str(average_time)
g.write(average_time_string)
if (average_time > max_average_time):
max_average_time = average_time
bf_rets = sorted(bf_rets)
qh_rets = sorted(qh_rets)
if (bf_rets == qh_rets):
print("returns match!")
else:
h = open(output_name + "_ERROR_LOG.txt", 'w')
print("ERROR RETURNS DO NOT MATCH")
for bf, qh in zip(bf_rets, qh_rets):
h.write(" bf qh")
for i, j in zip(bf, qh):
b = ""
if i != j:
b = "NONMATCHING"
h.write(str(i) + " " + str(j) + b)
h.close()
f.close()
g.close()
return max_average_time
def main():
# Create arguments parser
parser = argparse.ArgumentParser(
description='Program which helps to crack zip passwords by bruteforce',
epilog=
'Default symbols set is all lowercase and uppercase letter and digits')
parser.add_argument('filename', help='Name of zip file to crack')
parser.add_argument('-min',
type=int,
default=1,
nargs='?',
help='Minimal length of password (default = 1)')
parser.add_argument('-max',
type=int,
default=6,
nargs='?',
help='Maximal length of password (default = 6)')
parser.add_argument('-l',
'--lower',
action='store_true',
help='Includes lowercase alphabet symbols')
parser.add_argument('-u',
'--upper',
action='store_true',
help='Includes uppercase alphabet symbols')
parser.add_argument('-d',
'--digits',
action='store_true',
help='Includes numerical symbols')
parser.add_argument('-s',
'--special',
action='store_true',
help='Includes special symbols')
parser.add_argument('-b',
'--bar',
default=True,
action='store_false',
help='Disable statusbar')
parser.add_argument(
'-e',
'--estimate',
type=str,
nargs='?',
help=
'Check entered password and calculate number of password checked to bruteforce it. If you\'re using special symbols or spaces, please wrap your password by \' \' for instance: \'password\''
)
args = parser.parse_args()
try:
z = zipfile.ZipFile(args.filename, 'r')
except:
print('Wrong filename')
exit(1)
# Create alphabet for brute force method
symbols = ''
if args.lower:
symbols += string.ascii_lowercase
if args.upper:
symbols += string.ascii_uppercase
if args.digits:
symbols += string.digits
if args.special:
symbols += string.punctuation
if len(symbols) == 0:
symbols += string.ascii_letters + string.digits
combinationNumber = 0
for i in range(args.min, args.max + 1):
combinationNumber += len(symbols)**i
print('Number of possible password combinations is:',
combinationNumber,
end='\n\n')
if args.estimate:
for char in args.estimate:
if char not in symbols:
print('Wrong set of symbols')
exit(0)
symbols = ''.join(OrderedDict.fromkeys(symbols))
print('{} password'.format(
('Incorrect',
'Correct')[bruteforce.checkpass(z, bytes(args.estimate,
'utf8'))]))
checked = bruteforce.calculate(args.estimate, symbols)
print('Number of passwords need to bruteforce it:', checked)
args.max = 1
start = time()
bruteforce.bruteforce(1, 1, symbols, z, args.bar, False)
end = time()
speed = len(symbols) / (end - start)
print('Average speed is', str(round(speed, 2)) + 'p/s')
print('\nTime needed to bruteforce it: ',
str(round(checked / speed, 2)) + 's')
exit(1)
else:
if (int(args.min) > int(args.max)):
print('-min should be less than -max')
exit(1)
start = time()
counter = bruteforce.bruteforce(args.min, args.max, symbols, z, args.bar)
end = time()
if counter != combinationNumber:
print('Number of passwords checked:', counter)
print('Average speed:',
str(round((counter / (end - start)), 2)) + 'p/s',
end='\n\n')
else:
print('Password not found')
print('Time elapsed:', str(round((end - start), 2)) + 's')
return False
else:
pass
else:
print("连接异常")
except Exception as e:
print(e)
# except requests.exceptions.ConnectionError:
# print("代理不可用,更换代理")
# CUR_PROXY = utils.get_proxy()
# print("当前使用代理:{}".format(CUR_PROXY))
# except requests.exceptions.Timeout:
# print("代理连接速度过慢，更换代理！")
# CUR_PROXY = utils.get_proxy()
# print("当前使用代理:{}".format(CUR_PROXY))
# except:
# # print('未知情况')
# pass
if __name__ == "__main__":
# 开启代理池
args = utils.get_parse()
dict_username = args.get('dict_username', "username.txt")
dict_password = args.get('dict_password', "password.txt")
utils.get_dict(dict_username, dict_password)
bruteforce(login_bypass_ip_limit, thread_num=5)
import numpy as np
if __name__ == "__main__":
#original system
A,b,c,func,MatrixSigns,VariablesSigns = enter.ReadFile('problem.txt')
#canonical form
CanonSys = canon.Convert(A,b,c,func,MatrixSigns, VariablesSigns)
NpCanonForm = simplex.NpCanonicalForm(CanonSys)
x = simplex.starting_vector(NpCanonForm)
# x = simplex.starting_vector_method2(NpCanonForm).x # TODO разобраться
print("--- simplex algorithm: primal problem ---")
print(simplex.simplex_method(NpCanonForm, x).x)
print("------ brute force: primal problem ------")
print(bruteforce.bruteforce(NpCanonForm))
#dual system
dual.CheckSigns(A, b, MatrixSigns) #only >= sign allowed in finding min problem
TransA = dual.TransposeMatrix(A) #transposing matrix A
Newb = dual.NewVector(c) #finding dual vector b
Newc = dual.NewCoeff(b) #finding coefficients of dual goal function
NewMatrixSigns = dual.NewMSigns(VariablesSigns) #finding signs of dual matrix
NewVariableSigns = dual.NewVSigns(MatrixSigns) #finding signs of dual variables
Newfunc = dual.NewFunction(func) #finding dual problem type
#canon dual system
DualCanonSys = canon.Convert(TransA,Newb,Newc,Newfunc,NewMatrixSigns,NewVariableSigns)
NpCanonForm = simplex.NpCanonicalForm(DualCanonSys)
def init_dict():
# args = utils.get_parse()
args = dict()
dict_username = args.get('dict_username', "username.txt")
dict_password = args.get('dict_password', "password.txt")
utils.get_dict(dict_username, dict_password)
return dict_username, dict_password
if __name__ == "__main__":
if len(sys.argv) > 1:
if sys.argv[1] == 'i':
# ip limit
init_dict()
bruteforce(login_bypass_ip_limit, thread_num=5)
elif sys.argv[1] == 's':
# slide captcha
init_dict()
bruteforce(login_slide, thread_num=1)
elif sys.argv[1] == 'u':
# user limit
dict_username, dict_password = init_dict()
for curr_round in range(0, settings.MAX_ROUND):
print("[INFO] 开始第{0}轮爆破".format(curr_round))
utils.get_dict(dict_username, dict_password)
bruteforce(login_limit_user, thread_num=5)
print("[INFO] Sleep.")
time.sleep(2)
print_result()
