diff --git a/__pycache__/chiffrement_affine.cpython-38.pyc b/__pycache__/chiffrement_affine.cpython-38.pyc index 62dc468..b6a6652 100644 Binary files a/__pycache__/chiffrement_affine.cpython-38.pyc and b/__pycache__/chiffrement_affine.cpython-38.pyc differ diff --git a/__pycache__/crypt_and_decrypt.cpython-38.pyc b/__pycache__/crypt_and_decrypt.cpython-38.pyc new file mode 100644 index 0000000..3fbbd00 Binary files /dev/null and b/__pycache__/crypt_and_decrypt.cpython-38.pyc differ diff --git a/__pycache__/find_key.cpython-38.pyc b/__pycache__/find_key.cpython-38.pyc new file mode 100644 index 0000000..eccc9b8 Binary files /dev/null and b/__pycache__/find_key.cpython-38.pyc differ diff --git a/crypt_and_decrypt.py b/crypt_and_decrypt.py new file mode 100644 index 0000000..87f315f --- /dev/null +++ b/crypt_and_decrypt.py @@ -0,0 +1,65 @@ +def createFile(filename: str) -> None: + """ Créer le fichier si il n'existe pas + """ + try: + with open(filename, 'x') as f: + f.write('') + except FileExistsError: + return None + + +def cryptByteFile(filenameIn: str, keya: int, keyb: int, filenameOut = 'result') -> None: + """ Ecrit dans filenameOut, filenameIn crypté avec le chiffrement affine + """ + createFile(filenameOut) + fdin = open(filenameIn, "rb") + fdout = open(filenameOut, "wb") + data = fdin.read(1) + while data != b'': + fdout.write(chiffrementAffineByte(data, keya, keyb)) + data = fdin.read(1) + fdin.close() + fdout.close() + + +def chiffrementAffineByte(data: bytes, keya: int, keyb: int) -> bytes: + """ Renvoie le byte data crypté avec le chiffrement affine + """ + alphabet = [] + for i in range(256): + alphabet.append(i) + x = alphabet.index(int.from_bytes(data, "little")) + y = (keya*x+keyb)%256 + return bytes([alphabet[y]]) + +def inverse(a): + """ Renvoie l'inverse du module de a et x par 256 + """ + x = 0 + while (a*x%256 != 1): + x += 1 + return x + +def dechiffrementAffineByte(data: bytes, keya: int, keyb: int) -> bytes: + """ Renvoie le byte data décrypté avec le chiffrement affine + """ + alphabet = [] + for i in range(256): + alphabet.append(i) + x = alphabet.index(int.from_bytes(data, "little")) + y = (inverse(keya)*(x-keyb))%256 + return bytes([alphabet[y]]) + + +def decryptByteFile(filenameIn: str, keya: int, keyb: int, filenameOut = 'result') -> None: + """ Ecrit dans filenameOut, filenameIn décrypté avec le chiffrement affine + """ + createFile(filenameOut) + fdin = open(filenameIn, "rb") + fdout = open(filenameOut, "wb") + data = fdin.read(1) + while data != b'': + fdout.write(dechiffrementAffineByte(data, keya, keyb)) + data = fdin.read(1) + fdin.close() + fdout.close() \ No newline at end of file diff --git a/find_key.py b/find_key.py new file mode 100644 index 0000000..b9df4b0 --- /dev/null +++ b/find_key.py @@ -0,0 +1,77 @@ +from crypt_and_decrypt import * + +def byteFreq(filenameIn: str) -> dict: + """ byteDict est un dictionnaire tel que + * une clé est un octet + * la valeur associée est la fréquence de ce octet. + + Met à jour byteDict avec la liste de octets lbyte. + """ + lbyte = [] + byteDict = {} + fdin = open(filenameIn, "rb") + data = fdin.read(1) + while data != b'': + lbyte.append(data) + data = fdin.read(1) + for octet in lbyte: + if octet in byteDict: + freq = byteDict[octet] + 1 + else: + freq = 1 + byteDict[octet] = freq + return byteDict + + +def sortbyteFreq(byteFreq : dict) -> list: + """ Renvoie la liste de couples (octet, freq) de byteFreq. + Les couples sont triés par ordre décroissant de freq. + """ + byteList = [(octet, byteFreq[octet]) for octet in byteFreq] + k = 1 + while k < len(byteList): + i = k + while i > 0 and byteList[i - 1][1] < byteList[i][1]: + byteList[i - 1], byteList[i] = byteList[i], byteList[i - 1] + i = i - 1 + k = k + 1 + return byteList + + +def findKeywrite(data: bytes, dataout: bytes, filenameOut = 'result'): + """Ecrit dans filenameOut les couples de clé possible pour que data soit égale à dataout. + """ + createFile(filenameOut) + fdout = open(filenameOut, "w") + for keya in range(1, 256): + if keya % 2 != 0: + for keyb in range(1, 256): + i = dechiffrementAffineByte(data, keya, keyb) + if i == dataout: + fdout.write("keya: ") + fdout.write(str(keya)) + fdout.write(" ") + fdout.write("keyb: ") + fdout.write(str(keyb)) + fdout.write("\n") + +def findKeyList(data: bytes, dataout: bytes): + """Renvoie la liste des couples de clé possible pour que data soit égale à dataout. + """ + L = [] + for keya in range(1, 256): + if keya % 2 != 0: + for keyb in range(1, 256): + i = dechiffrementAffineByte(data, keya, keyb) + if i == dataout: + t = (keya, keyb) + L.append(t) + return L + +def comparKey(L: list, M: list) -> tuple: + """Compare les couples de clé valeur et renvoie le couple commun aux 2 listes M et L. + """ + for i in range(len(L)): + for y in range(len(M)): + if L[i] == M[y]: + return L[i] diff --git a/jeudetest.py b/jeudetest.py index 8d76197..a7ed512 100644 --- a/jeudetest.py +++ b/jeudetest.py @@ -1,12 +1,13 @@ -from chiffrement_affine import * +from crypt_and_decrypt import * +from find_key import * -print(sortbyteFreq(byteFreq("data"))) +#print(sortbyteFreq(byteFreq("data"))) #findKeywrite(b'\xaa', b'\x20', "keyoutspace") #findKeywrite(b'\x31', b'\x65', "keyoute") #print(findKeyList(b'\xaa', b'\x20')) -print(comparKey(findKeyList(b'\xaa', b'\x20'), findKeyList(b'\x31', b'\x65'))) +#print(comparKey(findKeyList(b'\xaa', b'\x20'), findKeyList(b'\x31', b'\x65'))) #cryptByteFile('tescrypt.txt', 1, 3, "resulttest2") #cryptByteFile('data', 1, 3, 'resultcryptdata') #cryptByteFile('monkey.jpg', 1, 3)