Implémenter d'anciens chiffrements en python

Code ancien typique

Code César (code de décalage)

Implémentation cryptographique

Le cryptage César crypte en décalant l'alphabet d'un certain nombre de caractères. Si le nombre de décalages est n, il est appelé ROT N. Par exemple, quand il est 3, c'est ROT3.

caesar_cipher.py

#chiffrement
def encrypt(plain_text, shift_num):
	cipher = ""    #Cryptogramme
	for char in plain_text:
		if(char.isupper()):    #Quand dans la capitale
		    cipher += chr((ord(char) + shift_num - 65) % 26 + 65)
		else:                  #En minuscules
			cipher += chr((ord(char) + shift_num - 97) % 26 + 97)
	return cipher

#Texte brut
plain  = "draemon"

#Nombre de postes,clé
s = 3

print("Plain Text : " + plain) 
print("shift_num : " + str(s))
print("cipher : " + encrypt(plain, s))

Quand tu cours

% python caesar_cipher.py 
Plain Text : draemon
shift_num : 3
cipher : gudhprq

J'ai pu le chiffrer.

Décrypter avec Brute Force Attack

Étant donné que l'anglais ne comporte que 26 caractères, il existe au maximum 26 façons de le décaler.

caesar_decipher.py

#Décrypter avec Brute Force Attack
def decrypt(cipher_text):  
	for shift_num in range(26):
		answer = ""  #Changement de clé_Résultat lors du décodage avec num
		for char in cipher_text:
			if(ord(char) - shift_num < 65):        #Lorsqu'il est capitalisé et devient plus petit que A lorsqu'il est décalé
				answer += chr(ord(char) - shift_num + 26)
			elif(ord(char) - shift_num < 97):      #Lorsqu'il est inférieur à a lorsqu'il est décalé
				answer += chr(ord(char) - shift_num + 26)

			else:                                   #En minuscules
				answer += chr(ord(char) - shift_num)

		print("clé" + str(shift_num) + "Décrypter avec →" + answer)


#Cryptogramme
cipher  = "gudhprq"

#Décryptage
decrypt(cipher) 

Quand tu fais ça

% python caesar_decipher.py
Décrypter avec la clé 0 → gudhprq
Décrypter avec la clé 1 → ftcgoqp
Décrypter avec la clé 2 → esbfnpo
Décrypter avec la clé 3 → draemon
Décrypter avec la clé 4 → cqzdlnm
Décrypter avec la clé 5 → bpyckml
Décrypter avec la clé 6 → aoxbjlk
Décrypter avec la clé 7 → znwaikj
Décrypter avec la clé 8 → ymvzhji
Décrypter avec la clé 9 → xluygih
Décrypter avec la clé 10 → wktxfhg
Décrypter avec la clé 11 → vjswegf
Décrypter avec la clé 12 → uirvdfe
Décrypter avec la clé 13 → thquced
Décrypter avec la clé 14 → sgptbdc
Décrypter avec la clé 15 → rfosacb
Décrypter avec la clé 16 → qenrzba
Décrypter avec la clé 17 → pdmqyaz
Décrypter avec la clé 18 → oclpxzy
Décrypter avec la clé 19 → nbkowyx
Décrypter avec la clé 20 → majnvxw
Décrypter avec la clé 21 → lzimuwv
Décrypter avec la clé 22 → kyhltvu
Décrypter avec la clé 23 → jxgksut
Décrypter avec la clé 24 → iwfjrts
Décrypter avec la clé 25 → hveiqsr

Le plus significatif d'entre eux est décrypté avec la clé 3.

Code de translittération unique

Le code César est crypté en décalant l'alphabet, tandis que le code de translittération unique est crypté en remplaçant l'alphabet par un alphabet différent. Par exemple, lorsque le texte brut est «draemon», il devient «jixbors» lorsqu'il est chiffré selon le tableau de correspondance suivant.

Implémentation cryptographique

Cette fois, j'ai utilisé le fichier texte jobs_quote.txt, qui résume les citations en anglais de Steve Jobs Quotations en texte brut, et utilisé une seule traduction. Cryptez avec cryptage. Cependant, par souci de simplicité, ne considérez que l'alphabet (en majuscules et en minuscules).

simple_substitution.py

import random
import re

#Fonction de chiffrement
def simple_sub_cipher():

    #Générer une liste d'alphabets ASCII
	alphabets = [65 + i for i in range(26)] + [97 + i for i in range(26)]    
	new_alphabets = [65 + i for i in range(26)] + [97 + i for i in range(26)]

	random.shuffle(new_alphabets)      #Trier au hasard
	

	path = 'jobs_quote.txt'         #chemin du fichier texte
	with open(path) as f:
		words = f.read()      #Lire le fichier texte
		words = re.sub(r'[\W0-9_]', "", words)     #Effacez tout sauf l'alphabet

        #Remplacer par de nouveaux alphabets dans l'ordre à partir d'un
		for old, new in zip(alphabets, new_alphabets):
			words = words.replace(chr(old), chr(new))

		print(words)      #Affichage du texte crypté


simple_sub_cipher()

Quand tu cours

% python simple*
QPAacTWfDfDATDQTjAcTWaPLWQCPDfaHQcQfTGAAacafTTAQTLTFaHAAacaAacTWQLOaGOCGODcATTAATDaGQWATCGEATTAkDnALDEaCGEfTjATTAQQaODcfTTAQcCcVaHODEaAAaPCGcfTTAWaHQaODfGcATTACjTjAfHDPafWaHffafkTjCACjPafWaHfQaODfjQAjaGQWFWjTWCGEGaATTAWaHOTGOaGODGAfTADaGATDATCGEjATTATfDfDTQQWCLnafATGAVaHOTGAOaGGDOAATDcaAjQaakCGEPaffTfcWaHOTGaGQWOaGGDOAATDLQaakCGEFTOkfTfcjEaWaHTTODAaAfHjAATTAATDcaAjfCQQjaLDTafOaGGDOACGWaHfPHAHfDQLATDaGQWnDfjaGQkGafATTAjQajATIHTfADfaPTFCQQCaGcaQQTfjCGaGDWDTfQAjODfWOTTfTOADfFHCQcCGEECLnQDOTGFDTTfcDfATTGOaLnQDqVaHTTODAafafkTTfcAaEDAWaHfATCGkCGEOQDTGAaLTkDCAjCLnQDbHACAjfafATCACGATDDGcFDOTHjDaGODWaHEDAATDfDWaHOTGLaODLaHGATCGjQAjfDTQQWTTfcAacDjCEGnfacHOAjFWPaOHjEfaHnjfQaAaPACLDjnDanQDcaGAkGaffTTAATDWfTGAHGACQWaHjTafCAAaATDLbDCGEATDfCOTDjALTGCGATDODLDADfWcaDjGALTAADfAaLDHaCGEAaFDcTAGCETAjTWCGEfDODcaGDjaLDATCGEfaGcDfPHQATTAjfTTALTAADfjAaLDnTDOHfDPaffnnQDCjGaAOajAOHAACGEnTDOHfDPaffnnQDCjAaCGGaOTADCAjfTWaHAaPCAjOHffDGAnfDcCOTLDGAnTDaGQWfTWAacaEfDTAfafkCjAaQaODfTTAWaHcaQPWaHTTODGAPaHGcCAWDAkDDnQaakCGEcaGAjDAAQDfjfCATTQQLTAADfjaPATDTDTfAWaHQQkGaffTDGWaHPCGcCAVaHfOHjAaLDfjcfDTLaPTTTnnCDfTGcFDAADfQCPDcaGALaODnfacHOAjWGfCOTQCODjEATWTHGEfWEATWPaaQCjTQfaHQcAfTcDTQQaPLWADOTGaQaEWPafTGTPADfGaaGfCATEaOfTADjKDLDLFDfCGEATTAWaHTfDEaCGEAacCDCjATDFDjAfTWQkGafAaTOaCcATDAfTnaPATCGkCGEWaHTTODjaLDATCGEAaQajDCHTQCAWCjLafDCLnafATGAATTGIHTGACAWLGDTaLDfHGCjLHOTFDAADfATTGAfacaHFQDjEaLDACLDjfTDGWaHCGGaOTADWaHLTkDLCjATkDjQACjFDjAAaTcLCAATDLIHCOkQWTGcEDAaGfCATCLnfaOCGEWaHfaATDfCGGaOTACaGjQGGaOTACaGcCjACGEHCjTDjFDAfDDGTQDTcDfTGcTPaQQafDfcaWaHfTGAAajnDGcATDfDjAaPWaHfQCPDjDQQCGEjHETfDcfTADfafcaWaHfTGATOTTGODAaOTTGEDATDfafQcVaHfACLDCjQCLCADcjacaGAfTjADCAQCOCGEjaLDaGDDQjDjQCPDcaGAFDAfTnnDcFWcaELTfTCOTCjQCOCGEfCATATDfDjHQAjaPaATDfnDanQDjATCGkCGEcaGAQDAATDGaCjDaPaATDfjanCGCaGjcfafGaHAWaHfafGCGGDfOaCODfGcLajACLnafATGATTODATDOaHfTEDAaPaQQafWaHfTDTfATGcCGAHCACaGnTDWjaLDTafTQfDTcWkGaffTTAWaHAfHQWfTGAAaFDOaLDWODfWATCGEDQjDCjjDOaGcTfWbDTWTfcjACOkaPIHTQCAWEaLDnDanQDTfDGAHjDcAaTGDGOCfaGLDGAfTDfDDqODQQDGODCjDqnDOADcQLTjnfaHcaPfTTAfDcaGAcaTjQTLaPfTTAfDcaQcCcGAjDDCAATDGFHACAAHfGDcaHAATTAEDAACGEPCfDcPfaLfnnQDfTjATDFDjAATCGEATTAOaHQcTTODDODfTTnnDGDcAaLDnTDTDTOCGDjjaPFDCGEjHOODjjPHQfTjfDnQTODcFWATDQCETAGDjjaPFDCGETFDECGGDfTETCGQDjjjHfDTFaHADODfWATCGEQAPfDDcLDAaDGADfaGDaPATDLajAOfDTACODnDfCacjaPLWQCPDQPWaHQCODDTOTcTWTjCPCAfTjWaHfQTjAjaLDcTWWaHQQLajAODfATCGQWFDfCETAVaHOTGAjHjATjkOHjAaLDfjfTTAATDWfTGATGcATDGAfWAaECODATTAAaATDLbWATDACLDWaHEDACAFHCQAATDWQQfTGAjaLDATCGEGDf

J'ai pu le chiffrer en une phrase dénuée de sens.

Décrypté par analyse de fréquence

L'analyse de fréquence consiste à vérifier la fréquence des lettres.

Par exemple, selon Frequency Analysis Wikipedia, général Le plus couramment utilisé est «e». Le second vient «i», le troisième vient «a», le quatrième vient «t» et le cinquième vient «n».

Ici, analysons la fréquence de jobs_quote.txt.

frequency_analyzer.py

import re

path = 'jobs_quote.txt'  #paramètre de chemin
with open(path) as f:
	words = f.read()   #Lire le fichier
	words = re.sub(r'[\W0-9_]', "", words).lower()

	char_set = { alphabet for alphabet in words } #Séparez un caractère à la fois
	char_freq = { alphabet : words.count(alphabet) for alphabet in char_set }  #Comptez le nombre de caractères

	sorted_char_freq = sorted(char_freq.items(), key = lambda x:x[1],reverse = True)    #Trier par fréquence

	print(sorted_char_freq)#indiquer

Quand tu cours

% python freq*             
[('t', 285), ('e', 269), ('o', 244), ('n', 172), ('a', 168), ('i', 167), ('s', 128), ('r', 122), ('h', 118), ('l', 92), ('u', 89), ('y', 85), ('d', 84), ('m', 66), ('w', 64), ('c', 60), ('g', 55), ('f', 47), ('p', 39), ('v', 34), ('b', 32), ('k', 23), ('q', 5), ('x', 3), ('j', 1)]

C'est devenu. Ce n'est pas exactement le même que le résultat de l'analyse de fréquence de Wikipédia précédemment, mais le résultat est assez similaire étant donné qu'il s'agit d'une citation.

Au fait, si vous connaissez t et e, vous pouvez facilement deviner les, they, he, get, etc. qui sont souvent utilisés en anglais. Vous pouvez déchiffrer cela en travaillant dur.

Autres chiffres historiques

ROT13

Le nombre de décalages du code César est de 13.

Soit x le texte brut

ROT_{13}(ROT_{13}(x)) = ROT_{0}(x)

Il existe 26 alphabets, donc si vous répétez deux fois ROT13, vous reviendrez à la phrase ci-dessous. Lorsque ravin est converti en ROT13, il est utilisé pour le jeu de mots comme enivar.

>>> import codecs
>>> codecs.decode('abc', 'rot13')
'nop'

Code Visionel

Il est appelé le carré de visionel de tableau suivant avec l'alphabet décalé un par un.

Par exemple, lorsque le texte brut est «DRAEMON» et que la clé est «ABC», «D» est «D» dans la ligne A et la colonne D, R est «S» dans la ligne B et la colonne R, et A est la ligne C et la colonne A «C». Sera. Si le texte brut est plus long que la clé, utilisez la clé à plusieurs reprises. En d'autres termes, le «E» suivant est E dans la ligne A et la colonne E. Si cela se répète, il sera chiffré en tant que «DSCENQN». Il est important de ne pas connaître le cycle de clé (3 dans ce cas).

Ici, a = 0, b = 1, ..., z = 26, pi est le i-ème caractère du texte brut, Ki est le i-ème caractère de la clé et Ci est le i-ème caractère du texte crypté.

C_i = (P_i + K_i)mod26

Au fait, si le décodage s'exprime de la même manière

P_i = (C_i - K_i)mod26

Sera.

Il existe deux méthodes de décryptage: ** Cassis Key Test ** et ** Key Deduction **.

Le ** Test de clé de Cassis ** se concentre sur la répétition des touches et ne peut pas être utilisé lorsqu'il est très long (plus de la moitié de la longueur d'un texte brut).

Code Uesugi

Comme le code visuel, mettez le pseudonyme plat dans un tableau de 7 carrés, attribuez des nombres verticalement et horizontalement, et cryptez avec le numéro correspondant au pseudonyme plat.

Par exemple, «shino» est chiffré comme «75, 36, 46».