def e_decimation(plaintext, key):
# your code here
if not isinstance(key, tuple):
print('Error (e_decimation): Invalid key')
return ''
if not isinstance(key[0], str) or not isinstance(key[1], int):
print('Error (e_decimation): Invalid key')
return ''
baseString = key[0]
m = len(baseString)
k = key[1]
if not mod.has_mul_inv(k, m):
print('Error (e_decimation): Invalid key')
return ''
ciphertext = ''
for p in plaintext:
if p.lower() in baseString:
x = baseString.index(p.lower())
y = mod.residue(k * x, m)
cipherChar = baseString[y]
ciphertext += cipherChar.upper() if p.isupper() else cipherChar
else:
ciphertext += p
return ciphertext
def d_decimation(ciphertext, key):
# your code here
if not isinstance(key, tuple):
print('Error (d_decimation): Invalid key')
return ''
if not isinstance(key[0], str) or not isinstance(key[1], int):
print('Error (d_decimation): Invalid key')
return ''
baseString = key[0]
m = len(baseString)
k = key[1]
if not mod.has_mul_inv(k, m):
print('Error (d_decimation): Invalid key')
return ''
m_i_k = mod.mul_inv(k, m)
plaintext = ''
for c in ciphertext:
if c.lower() in baseString:
y = baseString.index(c.lower())
x = mod.residue(m_i_k * y, m)
plainChar = baseString[x]
plaintext += plainChar.upper() if c.isupper() else plainChar
else:
plaintext += c
return plaintext
def inverse(A,m):
size = get_size(A)
d = det(A)
if not is_matrix(A):
return 'Error(inverse): invalid input'
elif size[0] < 2 or not mod.has_mul_inv(d, m):
return 'Error(inverse): matrix is not invertible'
elif size[0] != 2 and size[1] != 2:
return 'Error(inverse): Unsupported matrix size'
elif m < 1:
return 'Error(inverse): invalid mod'
d = mod.mul_inv(d % m, m)
inverse = new_matrix(size[0], size[1], 0)
inverse[0][0] = A[1][1]
inverse[0][1] = -A[0][1]
inverse[1][0] = -A[1][0]
inverse[1][1] = A[0][0]
for i in range(2):
for j in range(2):
inverse[i][j] %= m
inverse[i][j] *= d
inverse[i][j] %= m
return inverse
def d_affine(ciphertext, key):
# your code here
if not isinstance(key, tuple):
print('Error (e_affine): Invalid key')
return ''
if not isinstance(key[0], str) or not isinstance(key[1], list):
print('Error (e_affine): Invalid key')
return ''
if not isinstance(key[1][0], int) or not isinstance(key[1][1], int):
print('Error (e_affine): Invalid key')
return ''
baseString = key[0]
m = len(baseString)
alpha = key[1][0]
beta = key[1][1]
if not mod.has_mul_inv(alpha, m):
print('Error (e_affine): Invalid key')
return ''
m_i_alpha = mod.mul_inv(alpha, m)
plaintext = ''
for c in ciphertext:
if c.lower() in baseString:
y = baseString.index(c.lower())
x = mod.residue((y - beta) * m_i_alpha, m)
plainChar = baseString[x]
plaintext += plainChar.upper() if c.isupper() else plainChar
else:
plaintext += c
return plaintext
def e_decimation(plaintext, key):
# your code here
ciphertext = ''
# print("KEY 1:",key[1])
scopeAlpha = key[0]
# print(scopeAlpha)
if (mod.has_mul_inv(key[1], len(key[0])) != True):
print('Error (e_decimation): Invalid Key')
return 'Error (e_decimation): Invalid Key'
for i in range(len(plaintext)):
# print(plaintext[i])
if (plaintext[i].lower() in scopeAlpha):
if (plaintext[i].isupper()):
upper = True
else:
upper = False
cVal = key[1] * (scopeAlpha.index(
plaintext[i].lower())) % len(scopeAlpha)
# print("CVAL:", cVal)
cVal = cVal % len(scopeAlpha)
# cVal = cVal + 26 if upper else cVal
# print("CVAL:",cVal)
# print("cVal is:", chr(cVal))
ciphertext += scopeAlpha[cVal].upper(
) if upper else scopeAlpha[cVal]
else:
ciphertext += plaintext[i]
return ciphertext
def d_decimation(ciphertext, key):
plaintext = ''
baseString = key[0]
if mod.has_mul_inv(key[1], len(baseString)):
key = (key[0], mod.mul_inv(key[1], len(key[0])))
plaintext = e_decimation(ciphertext, key)
return plaintext
return 'Error (d_decimation): Invalid key'
def isValidKey_mathCipher(key):
# your code here
if not isinstance(key, tuple):
return False
if not isinstance(key[0], str) or not isinstance(key[1], list):
return False
if len(key[1]) != 3:
return False
for i in key[1]:
if not isinstance(i, int):
return False
if len(key[0]) < 2:
return False
baseString = key[0]
m = len(baseString)
a = key[1][0]
b = key[1][1]
if not mod.has_mul_inv(a, m) or not mod.has_mul_inv(b, m):
return False
return True
def e_decimation(plaintext,key):
ciphertext = ""
sample = []
text = key[0]
dec_key = mod.has_mul_inv(key[1],len(key[0]))
if not dec_key:
print('Error (e_decimation): Invalid key')
return
else:
dec_key = mod.mul_inv(key[1], len(text))
val = key[1]
for i in plaintext:
if i.lower() in text:
if i.isupper():
sample.append([mod.residue(text.index(i.lower())*val,len(key[0])),1])
else:
sample.append([mod.residue(text.index(i.lower())*val,len(key[0])),0])
# if 65<=ord(i)<=90:
# sample.append([mod.residue((ord(i)-65)*val,len(key[0])),1])
# elif 97<=ord(i)<=122:
# sample.append([mod.residue((ord(i)-97)*val,len(key[0])),0])
# else:
# sample.append([mod.residue((ord(i)-97)*val,len(key[0])),0])
else:
sample.append([ord(i),2])
for j in sample:
if j[1] == 1:
ciphertext+=text[j[0]].upper()
elif j[1]==0:
ciphertext+=text[j[0]]
else:
ciphertext += chr(j[0])
return ciphertext
def d_decimation(ciphertext,key):
plaintext = ""
sample = []
text = key[0]
val = key[1]
if val > len(text):
val = mod.residue(val, len(text))
dec_key = mod.has_mul_inv(val,len(text))
if not dec_key:
print('Error (d_decimation): Invalid key')
return
else:
dec_key = mod.mul_inv(key[1], len(text))
for i in ciphertext:
if i.lower() in text:
if i.isupper():
plaintext+= text[(mod.residue(text.index(i.lower())*dec_key,len(text)))].upper()
else:
plaintext+=text[(mod.residue(text.index(i.lower())*dec_key,len(text)))]
# if 65<=ord(i)<=90:
# sample.append([mod.residue((ord(i)-65)*dec_key,26),1])
# elif 97<=ord(i)<=122:
# sample.append([mod.residue((ord(i)-97)*dec_key,26),0])
else:
plaintext+=i
# for j in sample:
# if j[1] == 1:
# plaintext+=chr(j[0]+65).upper()
# elif j[1]==0:
# plaintext+=chr(j[0]+97)
# else:
# plaintext+= chr(j[0])
return plaintext
def d_decimation(ciphertext, key):
# your code here
plaintext = ''
scopeAlpha = key[0]
if (mod.has_mul_inv(key[1], len(key[0])) != True):
print('Error (d_decimation): Invalid Key')
return ('Error (d_decimation): Invalid Key')
for i in range(len(ciphertext)):
if (ciphertext[i].lower() in scopeAlpha):
if (ciphertext[i].isupper()):
upper = True
else:
upper = False
cVal = key[1] * (scopeAlpha.index(
ciphertext[i].lower())) % len(scopeAlpha)
plaintext += scopeAlpha[cVal].upper(
) if upper else scopeAlpha[cVal]
else:
plaintext += ciphertext[i]
return plaintext
def e_decimation(plaintext, key):
ciphertext = ''
baseString = key[0]
if mod.has_mul_inv(key[1], len(baseString)):
for c in plaintext:
if c.lower() in baseString:
b = baseString.find(c.lower())
if c.isupper():
x = mod.mul(key[1], b, len(baseString))
ciphertext += baseString[x].upper()
else:
x = mod.mul(key[1], b, len(baseString))
ciphertext += baseString[x]
else:
ciphertext += c
return ciphertext
return 'Error (e_decimation): Invalid key'
def e_affine(plaintext, key):
ciphertext = ''
baseString = key[0]
key = key[1]
if mod.has_mul_inv(key[0], len(baseString)):
for c in plaintext:
if c.lower() in baseString:
x = baseString.find(c.lower())
k = (key[0] * x + key[1]) % len(baseString)
if c.isupper():
ciphertext += baseString[k].upper()
else:
ciphertext += baseString[k]
else:
ciphertext += c
return ciphertext
return 'Error (e_affine): Invalid key'
def d_affine(ciphertext, key):
plaintext = ''
baseString = key[0]
key = key[1]
if mod.has_mul_inv(key[0], len(baseString)):
for c in ciphertext:
if c.lower() in baseString:
ci = baseString.find(c.lower())
a_inv = mod.mul_inv(key[0], len(baseString))
x = (a_inv * (ci - key[1])) % len(baseString)
if c.isupper():
plaintext += baseString[x].upper()
else:
plaintext += baseString[x]
else:
plaintext += c
return plaintext
return 'Error (d_affine): Invalid key'
def d_type3(ciphertext):
alpha = utilities.get_lower()
dictList = utilities.load_dictionary('engmix.txt')
for a in range(0, 5):
for b in range(0, 5):
for c in range(0, 5):
for d in range(0, 5):
key_matrix = matrix.new_matrix(2, 2, 0)
key_matrix[0][0] = a
key_matrix[0][1] = b
key_matrix[1][0] = c
key_matrix[1][1] = d
if mod.has_mul_inv(a * d - b * c, 26):
key = ''
for i in range(2):
for j in range(2):
key += alpha[key_matrix[i][j]]
first = d_hill(ciphertext, key)
k, plain = cryptanalysis_shift(first)
if utilities.is_plaintext(plain, dictList, 0.70):
return plain, (k, key)
def test_q1():
print("-------------------------------------------")
print("Testing Q1: Modular Arithmetic Library")
filename = 'q1_solution.txt'
outFile = open(filename, 'w')
print()
outFile.write('1- Testing residue_set:\n')
outFile.write('residue_set({}) = {}\n'.format(10, mod.residue_set(10)))
outFile.write('residue_set({}) = {}\n'.format(1, mod.residue_set(1)))
outFile.write('residue_set({}) = '.format(-5))
outFile.write('{}\n'.format(mod.residue_set(-5)))
outFile.write('residue_set({}) = '.format([5]))
outFile.write('{}\n'.format(mod.residue_set([5])))
outFile.write('\n')
outFile.write('2- Testing residue:\n')
outFile.write('residue({},{}) = {}\n'.format(17, 5, mod.residue(17, 5)))
outFile.write('residue({},{}) = '.format(3.4, 5))
outFile.write('{}\n'.format(mod.residue(3.4, 5)))
outFile.write('residue({},{}) = '.format(13, -5))
outFile.write('{}\n'.format(mod.residue(13, -5)))
outFile.write('\n')
outFile.write('3- Testing is_congruent:\n')
outFile.write('is_congruent({},{},{})= {}\n'.format(
22, 33, 11, mod.is_congruent(22, 33, 11)))
outFile.write('is_congruent({},{},{}) = {}\n'.format(
7, 9, 3, mod.is_congruent(7, 9, 3)))
outFile.write('is_congruent({},{},{})= '.format(3.4, 5, 9))
outFile.write('{}\n'.format(mod.is_congruent(3.4, 5, 9)))
outFile.write('is_congruent({},{},{}) = '.format(3, 5, -9))
outFile.write('{}\n'.format(mod.is_congruent(3, 5, -9)))
outFile.write('\n')
outFile.write('4- Testing add:\n')
outFile.write('add({},{},{}) = {}\n'.format(17, 23, 7, mod.add(17, 23,
7)))
outFile.write('add({},{},{}) = {}\n'.format(-17, 23, 7,
mod.add(-17, 23, 7)))
outFile.write('add({},{},{}) = {}\n'.format(17, -23, 7,
mod.add(17, -23, 7)))
outFile.write('add({},{},{}) = '.format(9, 17, 0))
outFile.write('{}\n'.format(mod.add(9, 17, 0)))
outFile.write('add({},{},{}) = '.format([9], 17, 7))
outFile.write('{}\n'.format(mod.add([9], 17, 7)))
outFile.write('add({},{},{}) = '.format(9, 17.1, 8))
outFile.write('{}\n'.format(mod.add(9, 17.1, 8)))
outFile.write('\n')
outFile.write('5- Testing sub:\n')
outFile.write('sub({},{},{}) = {}\n'.format(17, 23, 7, mod.sub(17, 23,
7)))
outFile.write('sub({},{},{}) = {}\n'.format(-17, 23, 7,
mod.sub(-17, 23, 7)))
outFile.write('sub({},{},{}) = {}\n'.format(17, -23, 7,
mod.sub(17, -23, 7)))
outFile.write('sub({},{},{}) = '.format(9, 17, 0))
outFile.write('{}\n'.format(mod.sub(9, 17, 0)))
outFile.write('sub({},{},{}) = '.format([9], 17, 7))
outFile.write('{}\n'.format(mod.sub([9], 17, 7)))
outFile.write('sub({},{},{}) = '.format(9, 17.1, 8))
outFile.write('{}\n'.format(mod.sub(9, 17.1, 8)))
outFile.write('\n')
outFile.write('6- Testing additive inverse:\n')
outFile.write('add_inv({},{}) = {}\n'.format(3, 5, mod.add_inv(3, 5)))
outFile.write('add_inv({},{}) = {}\n'.format(6, 1, mod.add_inv(6, 1)))
outFile.write('add_inv({},{})= {}\n'.format(22, 10, mod.add_inv(22, 10)))
outFile.write('add_inv({},{}) = '.format(6, -1))
outFile.write('{}\n'.format(mod.add_inv(6, -1)))
outFile.write('add_inv({},{}) = '.format(6.2, 6))
outFile.write('{}\n'.format(mod.add_inv(6.2, 6)))
a = 4
b = 2
m = 5
result = mod.sub(a, b, m) == mod.add(a, mod.add_inv(b, m), m)
outFile.write(
'sub({0},{1},{2}) == add({0},add_inv({1},{2}),{2})? = {3}\n'.format(
a, b, m, result))
outFile.write('\n')
outFile.write('7- Testing Addition Table:\n')
outFile.write('Addition Table for mode {} =\n'.format(5))
addTab = mod.add_table(5)
for i in range(len(addTab)):
outFile.write(str(addTab[i]))
outFile.write('\n')
outFile.write('Addition Table for mode {} =\n'.format(8))
addTab = mod.add_table(8)
for i in range(len(addTab)):
outFile.write(str(addTab[i]))
outFile.write('\n')
outFile.write('Addition Table for mode {} =\n'.format(0))
outFile.write(mod.add_table(0))
outFile.write('\n')
outFile.write('\n')
outFile.write('8- Testing Subtraction Table:\n')
outFile.write('Subtraction Table for mode {} =\n'.format(5))
subTab = mod.sub_table(5)
for i in range(len(subTab)):
outFile.write(str(subTab[i]))
outFile.write('\n')
outFile.write('Subtraction Table for mode {} =\n'.format(8))
subTab = mod.sub_table(8)
for i in range(len(subTab)):
outFile.write(str(subTab[i]))
outFile.write('\n')
outFile.write('Subtraction Table for mode {} =\n'.format([5]))
outFile.write(mod.sub_table([5]))
outFile.write('\n')
outFile.write('\n')
outFile.write('9- Testing Addition Inverse Table:\n')
outFile.write('Addition Inverse Table for mode {} =\n'.format(5))
addInvTab = mod.add_inv_table(5)
outFile.write(str(addInvTab[0]))
outFile.write('\n')
outFile.write(str(addInvTab[1]))
outFile.write('\n')
outFile.write('Addition Inverse Table for mode {} =\n'.format(26))
addInvTab = mod.add_inv_table(26)
outFile.write(str(addInvTab[0]))
outFile.write('\n')
outFile.write(str(addInvTab[1]))
outFile.write('\n')
outFile.write('Addition Inverse Table for mode {} =\n'.format(-2))
outFile.write(mod.add_inv_table(-2))
outFile.write('\n')
outFile.write('\n')
outFile.write('10- Testing mul:\n')
outFile.write('mul({},{},{}) = {}\n'.format(3, 5, 5, mod.mul(3, 5, 5)))
outFile.write('mul({},{},{}) = {}\n'.format(8, 3, 7, mod.mul(8, 3, 7)))
outFile.write('mul({},{},{})= {}\n'.format(17, -3, 7, mod.mul(17, -3,
7)))
outFile.write('mul({},{},{}) = '.format(9, 17, 0))
outFile.write('{}\n'.format(mod.mul(9, 17, 0)))
outFile.write('mul({},{},{}) = '.format([9], 17, 7))
outFile.write('{}\n'.format(mod.mul([9], 17, 7)))
outFile.write('mul({},{},{}) = '.format(9, 17.1, 8))
outFile.write('{}\n'.format(mod.mul(9, 17.1, 8)))
outFile.write('\n')
outFile.write('11- Testing Multiplication Table:\n')
outFile.write('Multiplication Table for mode {} =\n'.format(4))
mulTab = mod.mul_table(4)
for i in range(len(mulTab)):
outFile.write(str(mulTab[i]))
outFile.write('\n')
outFile.write('Multiplication Table for mode {} =\n'.format(5))
mulTab = mod.mul_table(5)
for i in range(len(mulTab)):
outFile.write(str(mulTab[i]))
outFile.write('\n')
outFile.write('Multiplication Table for mode {} =\n'.format(-5))
outFile.write(mod.mul_table(-5))
outFile.write('\n')
outFile.write('\n')
outFile.write('12- Testing is_prime:\n')
outFile.write('is_prime({}) = {}\n'.format(97, mod.is_prime(97)))
outFile.write('is_prime({}) = {}\n'.format(479, mod.is_prime(479)))
outFile.write('is_prime({})= {}\n'.format(1044, mod.is_prime(1044)))
outFile.write('is_prime({}) = {}\n'.format(0, mod.is_prime(0)))
outFile.write('is_prime({}) = {}\n'.format(-17, mod.is_prime(-17)))
outFile.write('\n')
outFile.write('13- Testing gcd:\n')
outFile.write('gcd({},{}) = {}\n'.format(629, 357, mod.gcd(629, 357)))
outFile.write('gcd({},{}) = {}\n'.format(440, 700, mod.gcd(440, 700)))
outFile.write('gcd({},{}) = {}\n'.format(-30, 700, mod.gcd(-30, 700)))
outFile.write('gcd({},{}) = {}\n'.format(540, -539, mod.gcd(540, -539)))
outFile.write('gcd({},{}) = '.format(711, 0))
outFile.write(mod.gcd(711, 0))
outFile.write('\n')
outFile.write('gcd({},{}) = '.format(0, 311))
outFile.write(mod.gcd(0, 311))
outFile.write('\n')
outFile.write('gcd({},{}) = '.format([9], 27))
outFile.write(mod.gcd([9], 27))
outFile.write('\n')
outFile.write('\n')
outFile.write('14- Testing is_relatively_prime:\n')
outFile.write('is_relatively_prime({},{}) = {}\n'.format(
4, 5, mod.is_relatively_prime(4, 5)))
outFile.write('is_relatively_prime({},{})= {}\n'.format(
540, 539, mod.is_relatively_prime(540, 539)))
outFile.write('is_relatively_prime({},{}) = {}\n'.format(
18, 26, mod.is_relatively_prime(18, 26)))
outFile.write('is_relatively_prime({},{}) = {}\n'.format(
0, 26, mod.is_relatively_prime(0, 26)))
outFile.write('is_relatively_prime({},{}) = '.format([1], 26))
outFile.write(mod.is_relatively_prime([1], 26))
outFile.write('\n')
outFile.write('\n')
outFile.write('15- Testing has_mul_inv:\n')
outFile.write('has_mul_inv({},{}) = {}\n'.format(
4, 5, mod.has_mul_inv(4, 5)))
outFile.write('has_mul_inv({},{}) = {}\n'.format(17, 26,
mod.has_mul_inv(17,
26)))
outFile.write('has_mul_inv({},{}) = {}\n'.format(18, 26,
mod.has_mul_inv(18,
26)))
outFile.write('has_mul_inv({},{}) = {}\n'.format(
0, 26, mod.has_mul_inv(0, 26)))
outFile.write('has_mul_inv({},{}) = '.format([1], 26))
outFile.write(mod.has_mul_inv([1], 26))
outFile.write('\n')
outFile.write('\n')
outFile.write('16- Testing EEA:\n')
outFile.write('eea({},{}) = {}\n'.format(700, 440, mod.eea(700, 440)))
outFile.write('eea({},{}) = {}\n'.format(88, 35, mod.eea(88, 35)))
outFile.write('eea({},{}) = {}\n'.format(35, 88, mod.eea(35, 88)))
outFile.write('eea({},{}) = {}\n'.format(-88, 35, mod.eea(-88, 35)))
outFile.write('eea({},{}) = {}\n'.format(88, -35, mod.eea(88, -35)))
outFile.write('eea({},{}) = '.format(0, 777))
outFile.write(mod.eea(0, 777))
outFile.write('\n')
outFile.write('\n')
outFile.write('17- Testing mul_inv:\n')
outFile.write('mul_inv({},{}) = {}\n'.format(23, 26, mod.mul_inv(23,
26)))
outFile.write('mul_inv({},{}) = {}\n'.format(5, 6, mod.mul_inv(5, 6)))
outFile.write('mul_inv({},{}) = {}\n'.format(24, 26, mod.mul_inv(24,
26)))
outFile.write('mul_inv({},{}) = {}\n'.format(700, 440,
mod.mul_inv(700, 440)))
outFile.write('mul_inv({},{}) = {}\n'.format(0, 777,
mod.mul_inv(700, 440)))
outFile.write('mul_inv({},{}) = '.format(1, [99]))
outFile.write(mod.mul_inv(1, [99]))
outFile.write('\n')
outFile.write('mul_inv({},{}) = '.format([1], 99))
outFile.write(mod.mul_inv([1], 99))
outFile.write('\n')
outFile.write('\n')
outFile.write('18- Testing Multiplicative Inverse Table:\n')
outFile.write('Multiplicative Inverse Table for mode {} =\n'.format(5))
mulInvTab = mod.mul_inv_table(5)
outFile.write(str(mulInvTab[0]))
outFile.write('\n')
outFile.write(str(mulInvTab[1]))
outFile.write('\n')
outFile.write('Multiplicative Inverse Table for mode {} =\n'.format(26))
mulInvTab = mod.mul_inv_table(26)
outFile.write(str(mulInvTab[0]))
outFile.write('\n')
outFile.write(str(mulInvTab[1]))
outFile.write('\n')
outFile.write('Multiplicative Inverse Table for mode {} =\n'.format(-2))
outFile.write(mod.mul_inv_table(-2))
outFile.write('\n')
outFile.write('\n')
outFile.close()
print('Comparing q1_solution with q1_sample:')
print(utilities_A4.compare_files('q1_solution.txt', 'q1_sample.txt'))
print()
print("-------------------------------------------")
return
