def decode(self):
hash_f = int.from_bytes(self.message, 'big') % self.p
lhs = (fme(self.open_key, self.r, self.p) *
fme(self.r, self.s, self.p)) % self.p
rhs = fme(self.g, hash_f, self.p)
if lhs != rhs:
sys.exit(1)
def __init__(self, message):
self.p = part_1.gen_p()
self.g = gen_g(self.p)
self.message = SHA256.new(message).digest() # return
self.x = random.randint(1, self.p - 1)
self.open_key = fme(self.g, self.x, self.p)
self.k = gen_coprime_integer_in_range(self.p - 1, 1, self.p - 1)
self.r = fme(self.g, self.k, self.p) # return
self.u = 0
self.s = 0 # return
def decode(self):
hash_f = int.from_bytes(SHA256.new(self.message).digest(),
'big') % self.n
w = fme(self.signature, self.d, self.n)
if hash_f != w:
sys.exit(1)
def gen_g(p):
if not part_1.is_prime(p):
print('GEN_G: \'p\' is not prime !')
g = random.randint(1, p - 1)
while fme(g, (p - 1) / 2, p) == 1:
g = random.randint(1, p - 1)
return g
def encode(self):
x = random.randint(1, self.q) # 9 - secret key
self.y = fme(self.a, x, self.p) # open key
h = int.from_bytes(self.message, 'big') % self.q
k = self.q - 1 # 6
while (self.r == 0 or self.s == 0) and k > 0:
try:
k -= 1
self.r = fme(self.a, k, self.p) % self.q
self.s = (k * h + x * self.r) % self.q
print('r =', self.r, ' s =', self.s)
except ValueError:
print('Except. K =', k)
continue
if k == 0:
raise Exception('Encode. Failed configuration.')
def shamir_protocol(file_path):
with open(file_path, 'rb') as file:
message = file.read()
file.close()
p = part_1.gen_p()
c_a = gen_c(p)
d_a = part_1.gcd(c_a, p - 1)[1]
c_b = gen_c(p)
d_b = part_1.gcd(c_b, p - 1)[1]
if int.from_bytes(message, 'big') >= p:
x1 = [0] * len(message)
x2 = [0] * len(message)
x3 = [0] * len(message)
x4 = [0] * len(message)
for i in range(0, len(message)):
x1[i] = fme(message[i], c_a, p)
x2[i] = fme(x1[i], c_b, p)
x3[i] = fme(x2[i], d_a, p)
x4[i] = fme(x3[i], d_b, p)
output = bytearray(x4)
with open("shamir_protocol_output.gif", 'wb') as file:
file.write(output)
for i in range(0, len(message)):
if x4[i] == message[i]:
print(x4[i], ' == ', message[i])
continue
else:
print(x4[i], ' != ', message[i])
print("Error!")
return False
print("Successful!")
return True
else:
x1 = fme(int.from_bytes(message, 'big'), c_a, p)
x2 = fme(x1, c_b, p)
x3 = fme(x2, d_a, p)
x4 = fme(x3, d_b, p)
if not x4 == int.from_bytes(message, 'big'):
print(x4, ' != ', message)
print("Error!")
return False
print(x4, ' == ', message)
print("Successful!")
return True
def __init__(self, message):
self.message = SHA256.new(message).digest() # return
self.q = number.getPrime(2) # 11
self.p = number.getPrime(10) # 67
b = 0
while b == 0:
try:
b = _number_new.exact_div(self.p - 1, self.q)
except ValueError:
self.q = number.getPrime(7)
self.p = number.getPrime(20)
self.a = self.p - 1
while fme(self.a, self.q, self.p) != 1 and self.a > 1:
self.a -= 1
self.r = 0 # return
self.s = 0 # return
self.y = 0
print('(' + str(self.p == b * self.q + 1) + ') p = bq + 1')
print('(' + str(fme(self.a, self.q, self.p) == 1) + ') a^q mod p = 1')
def elgamal_encryption(file_path):
with open(file_path, 'rb') as file:
message = file.read()
file.close()
p = part_1.gen_p()
g = part_1.gen_g(p)
c_b = random.randint(1, p - 1)
d_b = fme(g, c_b, p)
if int.from_bytes(message, 'big') >= p:
k = [0] * len(message)
r = [0] * len(message)
e = [0] * len(message)
tmp = [0] * len(message)
for i in range(0, len(message)):
k[i] = random.randint(1, p - 2)
r[i] = fme(g, k[i], p)
e[i] = message[i] * fme(d_b, k[i], p)
tmp[i] = e[i] * fme(r[i], p - 1 - c_b, p)
result = bytearray(tmp)
with open('elgamal_encryption_output.gif', 'wb') as file:
file.write(result)
for i in range(0, len(message)):
if tmp[i] == message[i]:
print(tmp[i], ' == ', message[i])
continue
else:
print(tmp[i], ' != ', message[i])
print("Error!")
return False
print('Successful')
return True
else:
k = random.randint(1, p - 2)
r = fme(g, k, p)
e = message * fme(d_b, k, p) % p
mx = e * fme(r, p - 1 - c_b, p) % p
if message == mx:
print(message, ' == ', mx)
print("Successful!")
return True
print(message, ' != ', mx)
print("Error!")
return False
def proof_cycle(self):
for elem in self.graph.data:
actual = self.coded[self.graph.alt_indices[elem[0]]][
self.graph.alt_indices[elem[1]]]
expect = self.encrypted[self.graph.alt_indices[elem[0]]][
self.graph.alt_indices[elem[1]]]
if not fme(actual, 3, self.n) == expect:
raise ValueError('Error: proof cycle 1.1')
cycle = self.graph.ham_cycle
for i in range(0, len(self.graph.ham_cycle) - 1):
if not [cycle[i], cycle[i + 1]] in self.graph.points:
if not [cycle[i + 1], cycle[i]] in self.graph.points:
raise ValueError('Error: proof cycle 1.2')
def proof_isomorphism(self):
for i in range(0, len(self.graph.isom_graph)):
for j in range(0, len(self.graph.isom_graph[i])):
tmp = fme(self.coded[i][j], 3, self.n)
if not tmp == self.encrypted[i][j]:
raise ValueError('Error:' + str(tmp) + '!=' +
str(self.encrypted[i][j]))
result = np.zeros((8, 8))
for i in range(0, len(self.graph.isom_graph)):
for j in range(0, len(self.graph.isom_graph[i])):
result[i][j] = self.coded[i][j] % 10
for elem in self.graph.isom_graph:
if not result[self.graph.alt_indices[elem[0]]][
self.graph.alt_indices[elem[1]]] == self.graph.data[
elem[0]][elem[1]]:
raise ValueError('Error: proof isomorphism 1.1')
if not result[self.graph.alt_indices[elem[1]]][
self.graph.alt_indices[elem[0]]] == self.graph.data[
elem[1]][elem[0]]:
raise ValueError('Error: proof isomorphism 1.2')
def encode(self):
hash_f = int.from_bytes(SHA256.new(self.message).digest(),
'big') % self.n
self.signature = fme(hash_f, self.c, self.n)
def decrypt(self):
result = [0] * len(self.message)
for i in range(0, len(self.message)):
result[i] = fme(self.message[i], self.c, self.n)
return result
def encrypt(self):
for i in range(0, len(self.graph.isom_graph)):
for j in range(0, len(self.graph.isom_graph[i])):
self.coded[i][j] += self.graph.isom_graph[i][
j] + random.randint(1, 10) * 10
self.encrypted[i][j] += fme(self.coded[i][j], 3, self.n)
