Introduction à la méthode d'implémentation du chiffrement et du déchiffrement DES en Python (code)

Ce que cet article vous apporte est une introduction à la méthode (code) d'implémentation du cryptage et du déchiffrement DES en Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

DES (Data Encryption Standard) utilise une longueur de bloc de 64 bits et une longueur de clé de 56 bits. Il faut une entrée 64 bits et subit une série de transformations pour obtenir une sortie 64 bits. Le décryptage utilise les mêmes étapes et les mêmes clés, la seule différence est que l'ordre des clés est inversé par rapport au processus de cryptage.

Cryptage DES :

L'entrée de cet algorithme est le texte en clair à chiffrer et la clé utilisée pour le chiffrement, tous deux d'une longueur de 64 bits. Les 8ème, 16ème, 24ème, 32ème, 40ème, 48ème, 56ème et 64ème bits de la clé sont des bits de parité.

1. Traitement du texte brut

Lire le texte brut dans le programme et le convertir en chaîne binaire

def inputText(filename):
    with open(filename,'r')as f:
        text = f.read()
    text = text.split('\n')
    text = [eval(x) for x in text]
    text = ['{:08b}'.format(x) for x in text]
    text = ''.join(text)
    
    return text

Effectuer le remplacement IP sur le texte brut et diviser en sous-chaînes gauche et droite Chaîne

def IP_Transposition(plaintext):
    LR = []
    for i in IP:
        LR.append(int(plaintext[i-1]))
    L = LR[:32]
    R = LR[32:]
    return L,R

2 Traitement des clés

Lire la clé dans le programme et la stocker sous la forme d'une chaîne binaire

Effectuer le remplacement PC-1 de la clé, et divisée en deux sous-chaînes

#密钥置换
def Key_Transposition(key):
    CD = []
    for i in PC_1:
        CD.append(int(key[i-1]))
    C = CD[:28]
    D = CD[28:]
    return C,D

La clé doit être permutée et compressée avant de générer la clé requise pour l'itération

#密钥压缩
def Key_Compress(C,D):
    key = C+D
    new_key = []
    for i in PC_2:
        new_key.append(key[i-1])
    return new_key

Générer la sous-chaîne requise pour chaque itération de DES Key, afin qu'elle puisse être utilisée directement lors du cryptage et du déchiffrement

def generateKset(key):
    key = inputKey(key)
    C,D = Key_Transposition(key)
    K = []
    for i in LeftRotate:
        C = Key_LeftRotate(C,i)
        C = Key_LeftRotate(D,i)
        K.append(Key_Compress(C,D))
    return K

3 Fonction F

À chaque tour de transformation, l'ensemble du processus peut. être exprimé par la formule suivante :

$$ L_i = R_{i-1} $$

$$ R_i = L_{i-1}bigoplus F(R_{i-1},K_i) $$

La clé ronde Ki a une longueur de 48 bits et R a une longueur de 32 bits. Tout d'abord, R est remplacé et étendu à 48 bits. Ces 48 bits sont XOR avec Ki. Le résultat est généré en utilisant la substitution. fonction pour générer une sortie 32 bits. La sortie 32 bits est XORée avec L après avoir été remplacée par P, et la nouvelle fonction de remplacement R

est composée de 8 cases S. Chaque case S a une entrée 6 bits et une sortie 4 bits. Pour chaque boîte S, les premier et dernier bits de l'entrée forment un nombre binaire de 2 bits, qui est utilisé pour sélectionner l'une des 4 lignes de valeurs alternatives dans la boîte S, et les 4 bits du milieu sont utilisés pour sélectionner une des 16 colonnes.

#明文R扩展为48位
def R_expand(R):
    new_R = []
    for i in E:
        new_R.append(R[i-1])
    return new_R

#将两列表元素异或
def xor(input1,input2):
    xor_result = []
    for i in range(0,len(input1)):
        xor_result.append(int(input1[i])^int(input2[i]))
    return xor_result

#将异或的结果进行S盒代替
def S_Substitution(xor_result):
    s_result = []
    for i in range(0,8):
        tmp = xor_result[i*6:i*6+5]
        row = tmp[0]*2+tmp[-1]
        col = tmp[1]*8+tmp[2]*4+tmp[3]*2+tmp[4]
        s_result.append('{:04b}'.format(S[i][row][col]))
    s_result = ''.join(s_result)
    return s_result
#F函数
def F(R,K):
    new_R = R_expand(R)
    R_Kxor= xor(new_R,K)
    s_result = S_Substitution(R_Kxor)
    p_result = P_Transposition(s_result)
    return p_result

#将S盒代替的结果进行P置换
def P_Transposition(s_result):
    p_result = []
    for i in P:
        p_result.append(int(s_result[i-1]))
    return p_result

4. Processus de cryptage

Le cryptage DES nécessite 16 tours d'itérations. Les 15 premiers tours d'itérations doivent échanger L et R à la fin de chaque fois. pas d'échange

def DES_encrypt(filename,key,outputFile):
    #从文件中读取明文
    plaintext = inputText(filename)
    #将明文进行置换分离
    L,R = IP_Transposition(plaintext)
    #生成Kset
    K = generateKset(key)
    for i in range(0,15):
        oldR = R
        #F函数
        p_result = F(R,K[i])
        R = xor(L,p_result)
        L = oldR
    p_result = F(R,K[15])
    L = xor(L,p_result)
    #IP逆置换
    reversedP = IP_reverseTransp(L+R)
    #生成16进制表示的密文
    Cipher = generateHex(reversedP)
    #将密文写入outputFile文件
    writeFile(outputFile,Cipher)
    return Cipher

Déchiffrement DES :

def DES_decrypt(filename,key,outputFile):
    #文件中读取密文
    Ciphertext = inputText(filename)
    #将密文进行置换分离
    L,R = IP_Transposition(Ciphertext)
    #生成Kset
    K = generateKset(key)
    for i in range(15,0,-1):
        oldR = R
        #F函数
        p_result = F(R,K[i])
        R = xor(L,p_result)
        L = oldR
    
    p_result = F(R,K[0])
    L = xor(L,p_result)
    reversedP = IP_reverseTransp(L+R)
    plaintext = generateHex(reversedP)
    writeFile(outputFile,plaintext)
    return plaintext

Adresse du code source https://github.com/SuQinghang...

Cet article est par ici, et il y en a plus. Pour un contenu passionnant, vous pouvez faire attention à la colonne

tutoriel vidéo python sur le site Web PHP chinois !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!