DES

des.py

import random

PC1 = [57, 49, 41, 33, 25, 17,  9,
       1, 58, 50, 42, 34, 26, 18,
       10,  2, 59, 51, 43, 35, 27,
       19, 11,  3, 60, 52, 44, 36,
       63, 55, 47, 39, 31, 23, 15,
       7, 62, 54, 46, 38, 30, 22,
       14,  6, 61, 53, 45, 37, 29,
       21, 13,  5, 28, 20, 12,  4]

PC2 = [14,  17,  11,  24,   1,   5,
       3,   28,  15,   6,  21,  10,
       23,  19,  12,   4,  26,   8,
       16,   7,  27,  20,  13,   2,
       41,  52,  31,  37,  47,  55,
       30,  40,  51,  45,  33,  48,
       44,  49,  39,  56,  34,  53,
       46,  42,  50,  36,  29,  32]

LSHIFT_MAP = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

IP = [58, 50, 42, 34, 26, 18, 10, 2,
      60, 52, 44, 36, 28, 20, 12, 4,
      62, 54, 46, 38, 30, 22, 14, 6,
      64, 56, 48, 40, 32, 24, 16, 8,
      57, 49, 41, 33, 25, 17,  9, 1,
      59, 51, 43, 35, 27, 19, 11, 3,
      61, 53, 45, 37, 29, 21, 13, 5,
      63, 55, 47, 39, 31, 23, 15, 7]

EBox = [32, 1, 2, 3, 4, 5,
        4,  5, 6, 7, 8, 9,
        8,  9, 10, 11, 12, 13,
        12, 13, 14, 15, 16, 17,
        16, 17, 18, 19, 20, 21,
        20, 21, 22, 23, 24, 25,
        24, 25, 26, 27, 28, 29,
        28, 29, 30, 31, 32, 1]

SBox = [
    # S1
    [
        [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
        [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
        [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
        [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
    ],

    # S2
    [
        [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
        [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
        [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
        [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
    ],

    # S3
    [
        [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
        [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
        [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
        [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
    ],

    # S4
    [
        [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
        [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
        [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
        [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
    ],

    # S5
    [
        [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
        [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
        [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
        [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
    ],

    # S6
    [
        [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
        [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
        [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
        [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
    ],

    # S7
    [
        [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
        [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
        [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
        [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
    ],

    # S8
    [
        [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
        [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
        [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
        [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
    ],
]

PBox = [16, 7, 20, 21, 29, 12, 28, 17,
        1, 15, 23, 26, 5, 18, 31, 10,
        2, 8, 24, 14, 32, 27, 3, 9,
        19, 13, 30, 6, 22, 11, 4, 25]

FP = [40, 8, 48, 16, 56, 24, 64, 32,
      39, 7, 47, 15, 55, 23, 63, 31,
      38, 6, 46, 14, 54, 22, 62, 30,
      37, 5, 45, 13, 53, 21, 61, 29,
      36, 4, 44, 12, 52, 20, 60, 28,
      35, 3, 43, 11, 51, 19, 59, 27,
      34, 2, 42, 10, 50, 18, 58, 26,
      33, 1, 41, 9, 49, 17, 57, 25]


def permutation_IP(message):
    result = ['']*len(IP)
    for i, c in enumerate(IP):
        result[i] = message[c-1]
    return result


# 假设key是一个str list
def permutation_PC1(key):
    nkey = [''] * len(PC1)
    for i, c in enumerate(PC1):
        nkey[i] = key[c-1]
    return nkey


def permutation_PC2(key):
    nkey = [''] * len(PC2)
    for i, c in enumerate(PC2):
        nkey[i] = key[c-1]
    return nkey

def l_shift(data, digits):
    l = data[digits:]
    l += data[:digits]
    return l

def generate_subkey(key, ):
    subkey = []
    key = permutation_PC1(key)
    assert len(key) == 56
    c = key[:28]
    d = key[28:]
    # subkey.append(key)
    for i in LSHIFT_MAP:
        c = l_shift(c, i)
        d = l_shift(d, i)
        key = permutation_PC2(c + d)
        assert len(key) == 48
        subkey.append(key)
    return subkey


def expend(r_message):
    n_message = [''] * len(EBox)
    for i, c in enumerate(EBox):
        n_message[i] = r_message[c-1]
    return n_message


def permutation_SBox(message):
    message_list = []
    result_list = []
    for i in range(0, len(message), 6):
        message_list.append(message[i:i+6])
    for i, block in enumerate(message_list):
        sbox = SBox[i]
        num1 = int(block[0] + block[5],2)
        num2 = int(''.join(block[1:5]),2)
        n = bin(sbox[num1][num2])[2:].zfill(4)
        result_list += list(n)
    return result_list

def permutation_PBox(message):
    n_message = [''] * len(PBox)
    for i,c in enumerate(PBox):
        n_message[i] = message[c-1]
    return n_message


def permutation_FP(message):
    n_message = [''] * len(FP)
    for i,c in enumerate(FP):
        n_message[i] = message[c-1]
    return n_message

def xor(message, key):
    result = []
    assert len(message) == len(key)
    for i in range(len(message)):
        if message[i] == key[i]:
            result.append('0')
        else:
            result.append('1')
    return list(result)


def F(R, key):
    R = expend(R)
    R = xor(R,key)
    R = permutation_SBox(R)
    R = permutation_PBox(R)
    return R

def encrypt(message, key):
    message = permutation_IP(message)
    subkey = generate_subkey(key)
    L, R = message[:32],message[32:]
    for i, key in enumerate(subkey):
        L_new = R
        R = F(R, key)
        R_new = xor(L,R)
        L, R = L_new, R_new
    message = R + L
    message = permutation_FP(message)
    return message

def decrypt(message, key):
    message = permutation_IP(message)
    subkey = generate_subkey(key)[::-1]
    L, R = message[:32],message[32:]
    for i, key in enumerate(subkey):
        L_new = R
        R = F(R, key)
        R_new = xor(L,R)
        L, R = L_new, R_new
    message = R + L
    message = permutation_FP(message)
    return message

def main():
    key = bin(random.getrandbits(64))[2:].zfill(64)
    print('Key:', key)
    key = list(key)

    message = bin(random.getrandbits(64))[2:].zfill(64)
    print('Plain Message:', message)

    cipher = encrypt(list(message), key)
    print('Cipher:', ''.join(cipher))

    dec_message = decrypt(cipher, key)
    dec_message = ''.join(dec_message)
    print('Deced Message:', dec_message)

    print('Deced Message == Plain Message?', dec_message == message)

if __name__=="__main__":
    main()