def verify(message, p, q, alpha, s, r, beta):
w = invert(s, q)
u1 = (w * int(sha1(message).hexdigest(), 16)) % q
u2 = (w * r) % q
v = (fast_pow(alpha, u1, p) * fast_pow(beta, u2, p)) % p % q
if v == r:
return True
return False
def find_generator_of_group(order):
# так как в нашем случае порядок группы - простое число, то мощность мультипликативной группы = phi(p) = p - 1
# так как в этой задаче мы выражали p как 2q + 1, где q - простое, то простые делители числа p это (p-1)// 2 и 2
# тогда достаточно проверить только степень (p - 1) / 2 и (p-1) // ((p-1)// 2)
if order == 2:
return 1
factor_1 = 2
factor_2 = (order - 1) // 2
print('Start looking for primitive number of the group ...')
# случайно выбираем число из группы для тестирования
while True:
a = random.randint(2, order - 1)
if not fast_pow(a, order - 1 // factor_1, order) == 1 and not fast_pow(a, order - 1 // factor_2, order) == 1:
return a
def get_subgroup_generator(p, q):
while True:
c = random.randrange(2, p - 1)
exp = (p - 1) // q
alpha = fast_pow(c, exp, p)
if alpha > 1:
break
return alpha
def decrypt(self, cipher):
# D = (self.B ** 2 + 4 * cipher) % self.N
mp = fast_pow(cipher, (self.p + 1) // 4, self.p)
mq = fast_pow(cipher, (self.q + 1) // 4, self.q)
rem, yq, yp = extended_euclid_iterative(self.q, self.p)
d1 = (yp * self.p * mq + yq * self.q * mp) % self.N
d2 = self.N - d1
d3 = (yp * self.p * mq - yq * self.q * mp) % self.N
d4 = self.N - d3
d = (d1, d2, d3, d4)
m = []
for di in d:
m.append(di)
return m
def miller_test(r, num):
a = 2 + random.randint(1, num - 4)
x = fast_pow(a, r, num)
if x == 1 or x == num - 1:
return True
while r != num - 1:
x = (x * x) % num
r *= 2
if x == 1:
return False
if x == num - 1:
return True
return False
def __init__(self, k_bits=160):
self.k_bits = k_bits
self.p = find_big_prime(self.k_bits)
self.alpha = find_generator_of_group(self.p)
self.k_pr = random.randint(2, self.p - 2)
self.k_pub = fast_pow(self.alpha, self.k_pr, self.p)
def __init__(self, p, alpha, k_pub):
i = random.randint(2, p - 2)
self.p = p
self.k_ephemeral = fast_pow(alpha, i, p)
self.k_masking = fast_pow(k_pub, i, p)
def decrypt(self, k_ephemeral, y):
# чтобы найти обратный используем малую теорему Ферма где k_E ^ (p-1) eq. to 1 mod p
# k_masking = k_ephemeral ^ k_pr mod p
k_masking_inv = fast_pow(k_ephemeral, self.p - self.k_pr - 1, self.p)
x = (y * k_masking_inv) % self.p
return x
def generate_key(p, q, alpha):
d = random.randint(2, q)
beta = fast_pow(alpha, d, p)
return d, beta
from sem3.task2.task2 import fast_pow
# 595 ^ 703 mod 991 = 342
# 3 ^ 618970019642690137449562110 mod 618970019642690137449562111 = 1
if __name__ == '__main__':
num, exp, mod = input(
'Введите число, степень и модуль через пробел').split(' ')
print('Результат: {}'.format(fast_pow(int(num), int(exp), int(mod))))
def sign(message, p, q, alpha, d):
ke = random.randint(2, q)
r = fast_pow(alpha, ke, p) % q
m = int(sha1(message).hexdigest(), 16)
s = (invert(ke, q) * (m + r * d)) % q
return r, s
ke = random.randint(2, q)
r = fast_pow(alpha, ke, p) % q
m = int(sha1(message).hexdigest(), 16)
s = (invert(ke, q) * (m + r * d)) % q
return r, s
def verify(message, p, q, alpha, s, r, beta):
w = invert(s, q)
u1 = (w * int(sha1(message).hexdigest(), 16)) % q
u2 = (w * r) % q
v = (fast_pow(alpha, u1, p) * fast_pow(beta, u2, p)) % p % q
if v == r:
return True
return False
if __name__ == '__main__':
p, q = prime_gen()
alpha = get_subgroup_generator(p, q)
assert fast_pow(alpha, q, p) == 1 and alpha > 1
d, beta = generate_key(p, q, alpha)
text = "Text for encrypt"
message = str.encode(text, "ascii")
r, s = sign(message, p, q, alpha, d)
verify(message, p, q, alpha, s, r, beta)
if verify(message, p, q, alpha, s, r, beta):
print('Verification succeeded')