plaintext_input_1
def hashing(plaintext, length=32):
seed = 0
hash = []
salt = 0
random_length_num = 1
text = "abcdefghjiklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ)(*&%$#@!"
for char in plaintext:
random_length_num += ord(char)
while salt <= length:
seed += ord(plaintext[salt % len(plaintext)]) + salt * random_length_num
hash.append(text[(seed**salt*random_length_num) % len(text)])
salt += 1
return hash
print("".join(hashing(plaintext_input_1)))
plaintext = plaintext_input_1
seed = 0
hash = []
salt = 0
random_length_num = 1
text = "abcdefghjiklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ)(*&%$#@!"
for char in plaintext:
random_length_num += ord(char)
print(random_length_num)
while salt <= 32:
seed += ord(plaintext[salt % len(plaintext)]) + salt * random_length_num
hash.append(text[(seed**salt*random_length_num) % len(text)])
salt += 1
print("".join(hash))
plaintext_input_1
plaintext = plaintext_input_1
def hashing(plaintext, length=32):
seed = 0
hash = []
salt = 0
random_length_num = 1
text = "abcdefghjiklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ)(*&%$#@!"
for char in plaintext:
random_length_num += ord(char)
random_length_num += ~ len(plaintext)
while salt <= length:
seed += ord(plaintext[salt % len(plaintext)]) + salt * random_length_num
hash.append(text[(seed**salt*random_length_num) % len(text)])
salt += 1
random_length_num += 1
return hash
print("".join(hashing(plaintext_input_1)))
seed_input_1
2283 / 10000
seed = seed_input_1
def lowercase_word(seed):
word = ""
seed *= 1
while seed > 0:
word += chr(seed % 26 + 97)
seed = seed // 26
return word
def multiple_letters(seed):
word = ""
while seed > 0:
word += chr(seed % 26 + 97)
seed -= 26
return word
print(lowercase_word(seed))
print(multiple_letters(seed))
def thread_function(hashes):
file2 = open("hash_collisions.txt", "a")
try:
counter = 0
for line in hashes:
for word in hashes:
if jf.jaro_distance(line.split()[0], word.split()[0]) > 0.9 and line != word:
file2.write(line + word + '\n')
if counter % 500 == 0:
print(counter, time.asctime())
counter += 1
file2.close()
except KeyboardInterrupt:
print("Keyboard interrupt")
file2.close()
exit()
# mp.cpu_count() returns the number of usable hardware CPU cores
# text_buffer is the contents of the file with the hashes
for i in range(mp.cpu_count()):
end = start + len(text_buffer) // mp.cpu_count()
p = Process(target=thread_function, args=(text_buffer[start:end],))
p.start()
start = end
for i in range(mp.cpu_count()):
p.join()
print("Done at " + time.asctime())
plaintext_input_2
plaintext_input_3
import jellyfish as jf
def hashing(plaintext, length=32):
seed = 0
hash = []
salt = 0
random_length_num = 1
text = "abcdefghjiklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ)(*&%$#@!"
for char in plaintext:
random_length_num += ord(char)
random_length_num += ~ len(plaintext)
while salt <= length:
seed += ord(plaintext[salt % len(plaintext)]) + salt * random_length_num
hash.append(text[(seed**salt*random_length_num) % len(text)])
salt += 1
random_length_num += 1
return hash
plaintext1 = plaintext_input_2
plaintext2 = plaintext_input_3
print("".join(hashing(plaintext1)))
print("".join(hashing(plaintext2)))
print(jf.jaro_distance("".join(hashing(plaintext1)), "".join(hashing(plaintext2))))
arguments = []
file = open("hash-times.txt", "w")
file.close()
for i in range(1000):
arguments.append("xg"*(i+1))
for i in range(1000//mp.cpu_count()):
try:
processes = []
for j in range(mp.cpu_count()):
processes.append(mp.Process(target=hashing, args=(arguments[i*mp.cpu_count()+j],)))
for process in processes:
process.start()
for process in processes:
process.join()
except (KeyboardInterrupt or IndexError):
for process in processes:
process.terminate()
break
from statistics import fmean
import matplotlib.pyplot as plt
from scipy.ndimage.filters import gaussian_filter1d
import numpy as np
from scipy.optimize import curve_fit
def horizontal_line(limit, y):
return [y for i in range(limit)]
# Exponential formula
def exponential(x, a, b):
return a*np.exp(b*x)
# My usual line of best fit for exponential
def line_of_best_fit(x1, x2, y1, y2):
b = (y2/y1)**(1/(x2-x1))
a = y1
print(f"y = {a}*{b}^x")
values = [a*b**i for i in range(x2)]
return values, f"y = {a}({b})^x"
def average_graphs(y_val1, y_val2):
average_graph = []
for i in range (len(y_val1)):
average_graph.append(fmean([y_val1[i], y_val2[i]]))
return average_graph
########### Data Preparation ###########
# File reading
file = open("tests\hash-times_50000.txt", "r")
times = file.read().split()
times = [float(i) for i in times]
# Smooth the data with a gaussian filter
times_smoothed = gaussian_filter1d(times, sigma=25)
########### Line of Best Fit ###########
# Find line of best fit with usual formula
lineofbestfit1, equation = line_of_best_fit(0, len(times), times_smoothed[0], times_smoothed[-1])
# Find line of best fit with curve_fit
pars, cov = curve_fit(f=exponential, xdata=range(len(times_smoothed)), ydata=times_smoothed, p0=[0, 0], bounds=(-np.inf, np.inf))
lineofbestfit2 = exponential(range(len(times_smoothed)), *pars)
# Find line of best fit by averaging the two lobfs
average_lobf = average_graphs(lineofbestfit1, lineofbestfit2)
########### Difference Graphs ###########
# Find difference between parent graph and first line of best fit
difference_graph1 = []
for i in range(len(times_smoothed)):
difference_graph1.append(times_smoothed[i] - lineofbestfit1[i])
# Find difference between parent graph and second line of best fit
difference_graph2 = []
for i in range(len(times_smoothed)):
difference_graph2.append(times_smoothed[i] - lineofbestfit2[i])
difference_graph3 = []
for i in range(len(times_smoothed)):
difference_graph3.append(times_smoothed[i] - average_lobf[i])
########### Plotting Graphs ###########
print(f"differnce_graph1: {fmean(difference_graph1)} \ndifference_graph2: {fmean(difference_graph2)} \ndifference_graph3: {fmean(difference_graph3)}")
print(min((fmean(difference_graph1)), fmean(difference_graph2), fmean(difference_graph3)))
# Plot the data graphs
fig, ax = plt.subplots(2)
ax[0].plot(times_smoothed, color="black")
ax[0].plot(lineofbestfit1, linestyle='dashdot', color="green")
ax[0].plot(lineofbestfit2, linestyle=':', linewidth=2, color='blue')
#ax[0].plot(average_lobf, color="red")
#ax[0].plot(lineofbestfit3, color="orange")
# Plot the difference graphs
ax[1].plot(difference_graph1, color="green")
ax[1].plot(difference_graph2, color="blue")
#ax[1].plot(difference_graph3, color="red")
ax[1].plot(horizontal_line(len(times_smoothed), 0), linestyle=':')
# Formatting
ax[0].set_title(file.name, y=1.2, pad=-14)
ax[0].set_ylabel("Time (s)", labelpad=10)
ax[0].set_xlabel("Hash Length", labelpad=10)
ax[1].set_ylabel("Difference (s)", labelpad=10)
ax[1].set_xlabel("Hash Length", labelpad=10)
ax[0].legend(["Data", "Line of Best Fit", "Line of Best Fit (curve_fit)"], loc="upper left")
ax[1].legend(["Difference (Line of Best Fit)", "Difference (Line of Best Fit (curve_fit))", "Reference Horizontal Line"], loc="upper left")
ax = plt.gca()
ax.set_yticks(ax.get_yticks()[::1]) # Set y-ticks to every second value
plt.grid(False) # Remove grid
file.close()
plt.show()