Python des加密

最新推荐文章于 2021-02-12 16:03:47 发布
转载 最新推荐文章于 2021-02-12 16:03:47 发布 · 164 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/xxWang/blog/749820
文章标签：

#python

为什么80%的码农都做不了架构师？>>> hot3.png

def strToBt(str):
    leng = len(str)

    bt = [0] * 64

    if leng < 4:

        for i in range(leng):
            k = str[i]
            for j in range(16):
                pow = 1
                for m in range(15 - j):
                    pow *= 2

                bt[16 * i + j] = int(k / pow) % 2

        for p in range(leng, 4):
            k = 0
            for q in range(16):
                pow = 1
                for m in range(15 - q):
                    pow *= 2

                bt[16 * p + q] = int(k / pow) % 2


    else:
        for i in range(4):
            k = str[i]
            for j in range(16):
                pow = 1
                for m in range(15 - j):
                    pow *= 2

                bt[16 * i + j] = int(k / pow) % 2

    return bt


def generateKeys(keyByte):
    key = [0] * 56
    keys = [[0] * 48 for i in range(16)]

    loop = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

    for i in range(7):
        for j in range(8):
            k = 7 - j
            key[i * 8 + j] = keyByte[8 * k + i]

    for i in range(16):
        for j in range(loop[i]):
            tempLeft = key[0]
            tempRight = key[28]
            for k in range(27):
                key[k] = key[k + 1]
                key[28 + k] = key[29 + k]

            key[27] = tempLeft
            key[55] = tempRight

        tempKey = [0] * 48
        tempKey[0] = key[13]
        tempKey[1] = key[16]
        tempKey[2] = key[10]
        tempKey[3] = key[23]
        tempKey[4] = key[0]
        tempKey[5] = key[4]
        tempKey[6] = key[2]
        tempKey[7] = key[27]
        tempKey[8] = key[14]
        tempKey[9] = key[5]
        tempKey[10] = key[20]
        tempKey[11] = key[9]
        tempKey[12] = key[22]
        tempKey[13] = key[18]
        tempKey[14] = key[11]
        tempKey[15] = key[3]
        tempKey[16] = key[25]
        tempKey[17] = key[7]
        tempKey[18] = key[15]
        tempKey[19] = key[6]
        tempKey[20] = key[26]
        tempKey[21] = key[19]
        tempKey[22] = key[12]
        tempKey[23] = key[1]
        tempKey[24] = key[40]
        tempKey[25] = key[51]
        tempKey[26] = key[30]
        tempKey[27] = key[36]
        tempKey[28] = key[46]
        tempKey[29] = key[54]
        tempKey[30] = key[29]
        tempKey[31] = key[39]
        tempKey[32] = key[50]
        tempKey[33] = key[44]
        tempKey[34] = key[32]
        tempKey[35] = key[47]
        tempKey[36] = key[43]
        tempKey[37] = key[48]
        tempKey[38] = key[38]
        tempKey[39] = key[55]
        tempKey[40] = key[33]
        tempKey[41] = key[52]
        tempKey[42] = key[45]
        tempKey[43] = key[41]
        tempKey[44] = key[49]
        tempKey[45] = key[35]
        tempKey[46] = key[28]
        tempKey[47] = key[31]

        for m in range(48):
            keys[i][m] = tempKey[m]

    return keys


def initPermute(originalData):
    ipByte = [0] * 64
    m = 1
    n = 0
    for i in range(4):
        for k in range(8):
            j = 7 - k
            # print("i=" + str(i) + ",j=" + str(j) + ",k=" + str(k) + ",m=" + str(m) + ",n=" + str(n));
            ipByte[i * 8 + k] = originalData[j * 8 + m]
            ipByte[i * 8 + k + 32] = originalData[j * 8 + n]

        m += 2
        n += 2

    return ipByte


def xor(byteOne, byteTwo):
    xorByte = [0] * len(byteOne)
    for i in range(len(byteOne)):
        xorByte[i] = byteOne[i] ^ byteTwo[i]

    return xorByte


def pPermute(sBoxByte):
    pBoxPermute = [0] * 32
    pBoxPermute[0] = sBoxByte[15]
    pBoxPermute[1] = sBoxByte[6]
    pBoxPermute[2] = sBoxByte[19]
    pBoxPermute[3] = sBoxByte[20]
    pBoxPermute[4] = sBoxByte[28]
    pBoxPermute[5] = sBoxByte[11]
    pBoxPermute[6] = sBoxByte[27]
    pBoxPermute[7] = sBoxByte[16]
    pBoxPermute[8] = sBoxByte[0]
    pBoxPermute[9] = sBoxByte[14]
    pBoxPermute[10] = sBoxByte[22]
    pBoxPermute[11] = sBoxByte[25]
    pBoxPermute[12] = sBoxByte[4]
    pBoxPermute[13] = sBoxByte[17]
    pBoxPermute[14] = sBoxByte[30]
    pBoxPermute[15] = sBoxByte[9]
    pBoxPermute[16] = sBoxByte[1]
    pBoxPermute[17] = sBoxByte[7]
    pBoxPermute[18] = sBoxByte[23]
    pBoxPermute[19] = sBoxByte[13]
    pBoxPermute[20] = sBoxByte[31]
    pBoxPermute[21] = sBoxByte[26]
    pBoxPermute[22] = sBoxByte[2]
    pBoxPermute[23] = sBoxByte[8]
    pBoxPermute[24] = sBoxByte[18]
    pBoxPermute[25] = sBoxByte[12]
    pBoxPermute[26] = sBoxByte[29]
    pBoxPermute[27] = sBoxByte[5]
    pBoxPermute[28] = sBoxByte[21]
    pBoxPermute[29] = sBoxByte[10]
    pBoxPermute[30] = sBoxByte[3]
    pBoxPermute[31] = sBoxByte[24]

    return pBoxPermute


binary = ["0000",
          "0001",
          "0010",
          "0011",
          "0100",
          "0101",
          "0110",
          "0111",
          "1000",
          "1001",
          "1010",
          "1011",
          "1100",
          "1101",
          "1110",
          "1111"]


def getBoxBinary(i):
    return binary[i]


def sBoxPermute(expandByte):
    sBoxByte = [0] * 32

    s = [
        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ],

        [
            [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]
        ]
    ]

    for m in range(8):
        i = expandByte[m * 6 + 0] * 2 + expandByte[m * 6 + 5]
        j = expandByte[m * 6 + 1] * 2 * 2 * 2 + expandByte[m * 6 + 2] * 2 * 2 + expandByte[m * 6 + 3] * 2 + expandByte[
            m * 6 + 4]

        binary = getBoxBinary(s[m][i][j])

        sBoxByte[m * 4 + 0] = int(binary[0:1])
        sBoxByte[m * 4 + 1] = int(binary[1:2])
        sBoxByte[m * 4 + 2] = int(binary[2:3])
        sBoxByte[m * 4 + 3] = int(binary[3:4])

    return sBoxByte


def expandPermute(rightData):
    epByte = [0] * 48

    for i in range(8):
        if i == 0:
            epByte[i * 6 + 0] = rightData[31]
        else:
            epByte[i * 6 + 0] = rightData[i * 4 - 1]

        epByte[i * 6 + 1] = rightData[i * 4 + 0]
        epByte[i * 6 + 2] = rightData[i * 4 + 1]
        epByte[i * 6 + 3] = rightData[i * 4 + 2]
        epByte[i * 6 + 4] = rightData[i * 4 + 3]

        if i == 7:
            epByte[i * 6 + 5] = rightData[0]
        else:
            epByte[i * 6 + 5] = rightData[i * 4 + 4]

    return epByte


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


def enc(dataByte, keyByte):
    keys = generateKeys(keyByte)

    ipByte = initPermute(dataByte)
    # print_bytes(ipByte, "ipByte")

    ipLeft = [0] * 32
    ipRight = [0] * 32
    tempLeft = [0] * 32

    for k in range(32):
        ipLeft[k] = ipByte[k]
        ipRight[k] = ipByte[32 + k]

    for i in range(16):
        for j in range(32):
            tempLeft[j] = ipLeft[j]
            ipLeft[j] = ipRight[j]

        key = [0] * 48
        for m in range(48):
            key[m] = keys[i][m]

        t = xor(expandPermute(ipRight), key)
        tempRight = xor(pPermute(sBoxPermute(t)), tempLeft)

        for n in range(32):
            ipRight[n] = tempRight[n]

    finalData = [0] * 64
    for i in range(32):
        finalData[i] = ipRight[i]
        finalData[32 + i] = ipLeft[i]

    return finallyPermute(finalData)


def bt4ToHex(binary):
    hex = ""
    if binary == "0000":
        hex = "0"
    elif binary == "0001":
        hex = "1"
    elif binary == "0010":
        hex = "2"
    elif binary == "0011":
        hex = "3"
    elif binary == "0100":
        hex = "4"
    elif binary == "0101":
        hex = "5"
    elif binary == "0110":
        hex = "6"
    elif binary == "0111":
        hex = "7"
    elif binary == "1000":
        hex = "8"
    elif binary == "1001":
        hex = "9"
    elif binary == "1010":
        hex = "A"
    elif binary == "1011":
        hex = "B"
    elif binary == "1100":
        hex = "C"
    elif binary == "1101":
        hex = "D"
    elif binary == "1110":
        hex = "E"
    elif binary == "1111":
        hex = "F"

    return hex


def bt64ToHex(byteData):
    hex = ""
    for i in range(16):
        bt = ""
        for j in range(4):
            bt += str(byteData[i * 4 + j])

        hex += bt4ToHex(bt)

    return hex


def print_bytes(bytes, name=None):
    if name:
        print(name, end='=')

    x = ''
    for n in bytes:
        x += str(n)
    print(x)


def des(data, key1, key2, key3):
    leng = len(data)

    encData = ''

    keyBt1 = strToBt(key1)
    keyBt2 = strToBt(key2)
    keyBt3 = strToBt(key3)

    iterator = int(leng / 4)
    remainder = leng % 4

    for i in range(iterator):
        tempData = data[i * 4: i * 4 + 4]
        tempByte = strToBt(tempData)

        tempBt = tempByte
        tempBt = enc(tempBt, keyBt1)
        tempBt = enc(tempBt, keyBt2)
        tempBt = enc(tempBt, keyBt3)

        encData += bt64ToHex(tempBt)

    if remainder > 0:
        tempByte = strToBt(data[iterator * 4:])

        tempBt = tempByte
        tempBt = enc(tempBt, keyBt1)
        tempBt = enc(tempBt, keyBt2)
        tempBt = enc(tempBt, keyBt3)

        encData += bt64ToHex(tempBt)

    return encData

if __name__ == '__main__':

    k1 = strToBt(b"h17")
    x = generateKeys(k1)

    print(des(b'123456123456123456123456', b"h17", b"8r0", b"QVQ"))

转载于:https://my.oschina.net/xxWang/blog/749820

spring项目中对jdbc.properties中的明文密码加密解密
Nuist_LHY的博客
09-28 4019
背景 在使用spring开发应用时，需要连接数据库，一般把数据库信息放在一个属性配置文件中，比如jdbc.properties，里面用明文的方式存储着数据库的敏感信息用户名username和密码password，容易产生安全问题，所以要对其进行加密。 思路 使用对称加密工具对密码加密解密 将解密后的数据存入到jdbc.properties配置文件中 自定义DBPropertyPlaceholderConfigurer，...
Python DES 加密详细教程
最新发布
注释比代码长
04-17 871
DES：DES 算法类，支持不同模式和填充方式。DES3：3DES 算法类，支持三重 DES 加密（加密 - 解密 - 加密或解密 - 加密 - 解密）。2-key 3DES：使用两个密钥，加密过程为加密 - 解密 - 加密，密钥长度为 112 位（2×56 位）。3-key 3DES：使用三个不同密钥，加密过程为加密 - 加密 - 加密，密钥长度为 168 位（3×56 位），但实际中常用加密 - 解密 - 加密模式以兼容单 DES。优点：历史悠久，实现成熟，适用于旧系统兼容；
数据aes加密sbox
09-05
数据aes加密sbox
des加密之后乱码问题
花道的博客
01-11 9161
普通的des加密： byte[] keys=password.getBytes(); DESKeySpec desKey = new DESKeySpec(keys); SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); SecretKey s
python实现DES加密和解密
热门推荐
yuaneuro的博客
10-24 1万+
DES是一种将64比特的明文加密成64比特的密文对称密码算法。DES是以64比特的明文为一个单位来进行加密的，这个64比特的单位成为分组，所以DES密码又称为分组密码 DES的基本结构是由Horst Feistel 设计的，因此也称为Feistel网络或Feistel结构，在Feistel网络中加密的哥哥步骤成为轮(round)，整个加密过程就是进行若干次轮的循环。如下图所示(来自百度百科)： 下面用具体的代码实现DES的加密，解密的过程完全一样，不过是密钥逆用。 1.首先将将明文和密钥转化为二进制，
js des加密 java_Des加密（js+java结果一致）
weixin_35660038的博客
02-12 649
des加密算法，javascript版本和java版本目录：1.资源文件下载2.JavaScript文件(des.js)3.html文件(des.html)4.java文件(des.java)正文：1.des资源文件下载(des.js+des.html+des.java)2.JavaScript文件(des.js)/***DES加密/解密*@CopyrightCopyright(c)20...
Python Des加密
09-17
工具类，实现基于Des的加密，方便Python3的工程使用
Python DES加密实现原理及实例解析
09-16
以下是一些Python代码片段，展示了如何实现DES加密的关键步骤，如十进制到二进制转换、置换、异或运算等。实际的完整实现还包括上述提到的所有置换、扩展和S盒、P盒运算。 ```python def INT_BIN(NUM): i = bin...
Python Des加密解密如何实现软件注册码机器码
12-23
这篇文章主要介绍了Python Des加密解密如何实现软件注册码机器码,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 原理 判断路径下是否存在识别文件，若存在就...
Python基于DES算法加密解密实例
09-21
主要介绍了Python基于DES算法加密解密实现方法,以实例形式分析了DES算法实现加密解密的相关技巧,需要的朋友可以参考下
Base64ToHexString.exe
10-29
base64转hexstring工具，可以自由输入base64字符，通过点击转换按钮，对数据进行解析，适合日志里打印的base64字符串，转换为byte字节
Des前台加密、后台解密Demo
在路上。。。
12-24 4796
Des是加密的一种方式，该例子可以实现前台加密&&解密，后台加密&&解密，前后台可以互相转换。
DES加密和解密
weixin_34082695的博客
05-19 105
2019独角兽企业重金招聘Python工程师标准>>> ...
python实现DES算法
Cosmopolitan的博客
12-26 3759
pycrypto库下载:http://pan.baidu.com/s/1nvNtCvB (python2.7的版本),直接安装就可以了from Crypto.Cipher import DES #第三方库导入，没有的话去百度云下载class MyDESCrypt: #自己实现的DES加密类 key = chr(11)+chr(11)+chr(11)+chr(11)+chr(11)+chr(11
Python：弹珠游戏
qq_43776408的博客
08-29 655
from tkinter import * from random import randint def getRandomColor(): color = "#" for j in range(6): color += toHexChar(randint(0, 15)) return color def toHexChar(hexValue): ...
LoadRunner实现DES加密（二）
小他529的博客
02-20 1084
上篇说道LoadRunner中引用DES.h文件，对字符串进行加密，加密耗时很长，这篇主要讲生成DES加密的dll文件，在LoadRunner中引用，解决耗时问题。 编译工具本次生成dll，是用的Eclipse for c/c++进行开发的，编译工具选择的是MinGW，工具的安装过程如下：
Des加密（js+java结果一致）
傾城如夢
12-10 241
des加密算法，javascript版本和java版本 目录： 　　1.资源文件下载 　　2.JavaScript文件（des.js） 　　3.html文件（des.html） 　　4.java文件(des.java) 正文： 1.des资源文件下载（des.js+des.html+des.java） 　　http://download.youkuaiyun.com/download/love...
js清空浏览器cokie缓存_js之清除Cookie
weixin_36177083的博客
12-24 557
/*** Copyright (c) 2013-Nowhttp://jeesite.comAll rights reserved.*/packagecom.lms.common.utils;importjava.io.UnsupportedEncodingException;importjava.util.ArrayList;importjava.util.List;/*** DES加密解密工具*...
Python DES加密模块pyDes-2.0.1安装使用指南
标签 "python DES加密" 提供了两个关键词：Python 和 DES加密。Python 是一种广泛使用的高级编程语言，它以其简单易学的语法而受到开发者的青睐。DES加密是数据加密标准（Data Encryption Standard）的简称，是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值