2022-06-24发表2022-09-26更新安卓逆向20 分钟读完 (大约3007个字)

安卓逆向学习之DES加密算法

DES 算法简介

DES(Data Encryption Standard)是目前最为流行的加密算法之一。DES 是对称的，也就是说它使用同一个密钥来加密和解密数据。

DES 还是一种分组加密算法，该算法每次处理固定长度的数据段，称之为分组。DES 分组的大小是 64 位，如果加密的数据长度不是 64 位的倍数，可以按照某种具体的规则来填充位。

从本质上来说，DES 的安全性依赖于虚假表象，从密码学的术语来讲就是依赖于“混乱和扩散”的原则。混乱的目的是为隐藏任何明文同密文、或者密钥之间的关系，而扩散的目的是使明文中的有效位和密钥一起组成尽可能多的密文。两者结合到一起就使得安全性变得相对较高。

DES 算法具体通过对明文进行一系列的排列和替换操作来将其加密。过程的关键就是从给定的初始密钥中得到 16 个子密钥的函数。要加密一组明文，每个子密钥按照顺序（1-16）以一系列的位操作施加于数据上，每个子密钥一次，一共重复 16 次。每一次迭代称之为一轮。要对密文进行解密可以采用同样的步骤，只是子密钥是按照逆向的顺序（16-1）对密文进行处理。

DES 算法框架

以下是 DES 的算法框架

从这个图中我们可以看到

明文传入 IP 进行置换进行 16 次迭代将 R16 与 L16 拼接 IP 逆置换生成密文

从 64-bit 的主钥匙里面选取特定的 56 位，其余的位就没用了。于是我们现在手上有了一个 56 位的布尔数组。把它分成左、右两个半密钥，它们都是 28-bit 的布尔数组。
左、右两个半密钥都左旋（也就是循环左移。整个数组往左移，左边弹出去了的东西补到最右边去）一定位数，这个左移的位数也是指定的。有些轮次是 1 位，有些轮次是 2 位。
把左、右半密钥拼起来，再做一个置换，就得到了这一轮生成的子密钥。这个置换是从 56-bit 的数组里面选取指定的 48 位。所以现在每一轮都可以生成一个 48 位的子密钥。（注意，步骤 3 并不改变左右半密钥）。
重复步骤 2、步骤 3 一共 16 次，于是得到了 16 个 48-bit 的子密钥。

现在我们手上有了 16 把子密钥。遂开始加密：

输入的明文（长度为 64 的布尔数组）做一个置换(IP 置换)。仍然得到 64-bit 的数组（不然就丢失信息了！）
把得到的数组拆成左、右两半边。每边是 32 位长度。
每一轮迭代，都是接收一组 L, R，返回 L', R' ，作为下一轮迭代的 L, R . 迭代过程如下：
L′=RR′=L⊕F(R,subkey)其中 F 函数（称为轮函数）是整个算法的核心，功能是：以一个子密钥，加密 32-bit 的信息。
利用之前得到的 16 个子密钥，执行步骤 3 一共 16 次。
将最终的 R 与 L 拼接，再做一次置换(FP 置换)，即得到密文。

具体步骤

IP 置换

本质上就是根据表进行位置交换

第 1 位与第 58 位进行交换

第 2 位与第 50 位进行交换

轮函数

E 扩展置换

这步的目的是将 32 位的数据变成 48 位的与 48bit 的 Key 进行置换运算

举个例子

例如第二行 0001 -> 10010

1
2
3

第二位原数据 0001
第一位的数据1101的最后一位1变成了 1 -> 10001
第三位的数据0011的第一位0变成0 -> 100010

转变成了一个 48 位 bit 的数据在与 48 位的 key 进行 XOR 运算得到运算结果后再进行 S 盒的压缩

S 盒压缩处理

目的是将原来的 6 位的数据变成 4 位的数据

$；$

例如

$原数据$

$头数据进制进制第三行$

$中间数据进制进制第列$

P 盒置换

$盒置换结果$

IP 逆置换

持续进行 16 次迭代将迭代结果与 L16 R16 拼接进行 IP-1 逆运算得到最终密文

密钥生成

红色标注就是较验证值由 64 位去掉 8 位校验值=56 位

再通过 IV 偏移量进行 16 次左移[内循环左移]

分为 C0 D0 进行左移动 1 位得到 C1 D1

C1 D1 左移动 1 位得到 C2 D2 以此类推

C1 D1 进行 PC-2 置换得到 48 位的 Key

Python 代码

编码(encode)与加密(encrypt)都是把一条数据变成另一条数据的函数，但它们有本质的区别——编码是公开的，是双向函数。任何人都可以把信息编码，也可以把信息解码。典型例子：十六进制编码、base64 编码，以及 rot13 “加密”。它虽然名字是加密，但它事实上是一个编码——任何知道算法规则的人，都可以进行解密。

加密是私密的。必须有密钥才能加密，也必须有密钥才能解密（公钥与私钥可能不同）。此外，优秀的加密算法，安全性应该依赖于密钥的保密程度、解密的难度，而无关乎算法的秘密——也就是说，任何人都知道这个加密、解密算法是怎样的，任何人都可以实现算法，但拿不到密钥就没法解密。典型的例子是 RSA、DES、AES 等密码体系。

应当意识到，编码是不可靠的。置换之类的简单编码方式尤其不可靠。作为密码的设计者，应当假设攻击者知道算法的每一处细节，也就是说，设计算法的时候，应该认为编码对信息安全完全没有帮助。

有了这些概念在心里，我们来详细讨论 DES 算法。

密钥生成

PC1

# 选择置换1
# 从64位输入密钥中选择56位，分为左右两个28位半密钥
def PC1(key):
    pc1_l = [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]
    pc1_r = [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]

    return [key[x - 1] for x in pc1_l], [key[x - 1] for x in pc1_r]

PC2

# 选择置换2
# 从56位的密钥中选取48位子密钥
def PC2(key):
    assert len(key) == 56

    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]
    return [key[x - 1] for x in pc2]

生成密钥

# 子密钥生成算法，由一个64位主密钥导出16个48位子密钥
def keyGen(key):
    assert len(key) == 64

    l, r = PC1(key)
    off = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
    res = []

    for x in range(16):
        l = leftRotate(l, off[x])
        r = leftRotate(r, off[x])

        res.append(PC2(l + r))

    return res

轮函数

E 置换

# 扩张置换，将32位的半块扩展到48位
def Expand(a):
    assert len(a) == 32
    e = [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]
    return [a[x - 1] for x in e]

S 盒压缩

# S盒变换，输入48位，输出32位
def S(a):
    assert len(a) == 48

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

    a = np.array(a, dtype=int).reshape(8, 6)
    res = []

    for i in range(8):
        # 用 S_box[i] 处理6位a[i]，得到4位输出
        p = a[i]
        r = S_box[i][bin2int([p[0], p[5], p[1], p[2], p[3], p[4]])]
        res.append(int2bin(r, 4))

    res = np.array(res).flatten().tolist()
    assert len(res) == 32

    return res

P 置换

# P置换
def P(a):
    assert len(a) == 32

    p = [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]
    return [a[x - 1] for x in p]

F 函数

# F函数，用于处理一个半块
def Feistel(a, subKey):
    assert len(a) == 32
    assert len(subKey) == 48

    t = binXor(Expand(a), subKey)
    t = S(t)
    t = P(t)

    return t

测试

运行结果

网站给出的结果一致正确

代码

from functools import reduce
import numpy as np


# 整数转二进制数组，指定位长 n，大端序
def int2bin(a, n):
    assert 0 <= n and a < 2 ** n
    res = np.zeros(n, dtype=int)

    for x in range(n):
        res[n - x - 1] = a % 2
        a = a // 2
    return res.tolist()


assert int2bin(0x1a, 10) == [0, 0, 0, 0, 0, 1, 1, 0, 1, 0]


# 二进制数组转整数，大端序
def bin2int(a):
    return reduce(lambda x, y: x * 2 + y, a)


assert bin2int([0, 0, 0, 0, 0, 1, 1, 0, 1, 0]) == 0x1a


# 循环左移off位
def leftRotate(a, off):
    return a[off:] + a[:off]


assert leftRotate([0, 1, 0, 1, 1], 2) == [0, 1, 1, 0, 1]


# 异或
def binXor(a, b):
    assert len(a) == len(b)
    return [x ^ y for x, y in zip(a, b)]


assert binXor([1, 1, 0, 1], [0, 1, 1, 0]) == [1, 0, 1, 1]


# 初始置换
def IP(a):
    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]
    return [a[x - 1] for x in ip]


testM = [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
         0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]
assert IP(testM) == [1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                     1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0]


# 最终置换
def FP(a):
    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]
    return [a[x - 1] for x in fp]


# 选择置换1
# 从64位输入密钥中选择56位，分为左右两个28位半密钥
def PC1(key):
    pc1_l = [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]
    pc1_r = [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]

    return [key[x - 1] for x in pc1_l], [key[x - 1] for x in pc1_r]


testKey = [0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1,
           1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1]
testL, testR = PC1(testKey)
assert testL + testR == [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1,
                         0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1]


# 选择置换2
# 从56位的密钥中选取48位子密钥
def PC2(key):
    assert len(key) == 56

    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]
    return [key[x - 1] for x in pc2]


# 子密钥生成算法，由一个64位主密钥导出16个48位子密钥
def keyGen(key):
    assert len(key) == 64

    l, r = PC1(key)
    off = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
    res = []

    for x in range(16):
        l = leftRotate(l, off[x])
        r = leftRotate(r, off[x])

        res.append(PC2(l + r))

    return res


assert keyGen(testKey)[-1] == [1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1,
                               1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1]


# S盒变换，输入48位，输出32位
def S(a):
    assert len(a) == 48

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

    a = np.array(a, dtype=int).reshape(8, 6)
    res = []

    for i in range(8):
        # 用 S_box[i] 处理6位a[i]，得到4位输出
        p = a[i]
        r = S_box[i][bin2int([p[0], p[5], p[1], p[2], p[3], p[4]])]
        res.append(int2bin(r, 4))

    res = np.array(res).flatten().tolist()
    assert len(res) == 32

    return res


# 扩张置换，将32位的半块扩展到48位
def Expand(a):
    assert len(a) == 32
    e = [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]
    return [a[x - 1] for x in e]


# P置换
def P(a):
    assert len(a) == 32

    p = [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]
    return [a[x - 1] for x in p]


# F函数，用于处理一个半块
def Feistel(a, subKey):
    assert len(a) == 32
    assert len(subKey) == 48

    t = binXor(Expand(a), subKey)
    t = S(t)
    t = P(t)

    return t


def goRound(l, r, subKey):
    return r, binXor(l, Feistel(r, subKey))


def DES(plain, key, method):
    subkeys = keyGen(int2bin(key, 64))

    if method == 'decrypt':
        subkeys = subkeys[::-1]

    m = IP(int2bin(plain, 64))

    l, r = np.array(m, dtype=int).reshape(2, -1).tolist()

    for i in range(16):
        l, r = goRound(l, r, subkeys[i])

    return bin2int(FP(r + l))


print(hex(DES(0x11aabbccddeeff01, 0xcafababedeadbeaf, 'encrypt')))
# 0x2973a7e54ec730a3
print(hex(DES(0x2973a7e54ec730a3, 0xcafababedeadbeaf, 'decrypt')))

总结

首先介绍几个重要的历史时间节点。

① 1973 年，美国国家标准局(NBS)向社会公开征集加密算法，一直盯加密算法标准。

② 1974 年，第二次征集。

③ 1975 年，选中 IBM 的算法，公布征求意见。

④ 1977 年 1 月 15 日正式颁布。

⑤ 1998 年底以后停用。

⑥ 1999 年颁布 3DES 为新标准。

标准加密算法的目标：

① 用于保护政府机构和商业部门的非机密的敏感数据。

② 用于加密保护静态存储和传输信道中的数据。

③ 安全使用 10~15 年。

DES 算法是单射的分组密码算法，是密码学发展的一个重要的阶段（现代密码学诞生的标志之一），对算法的标准化研究和分组密码的发展有重大意义。

目前攻击 DES 的最有效的办法是密钥穷举攻击。

参考文章/视频

https://www.bilibili.com/read/cv13258932

https://www.bilibili.com/video/BV1KQ4y127AT?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=28386b7c9a7b50491dec215cf2ec6197

https://www.cnblogs.com/idreamo/p/9333753.html

https://www.ruanx.net/des/

安卓逆向学习之DES加密算法

https://www.mineseb.cn/2022/06/24/安卓逆向学习之DES加密算法/

作者

Codecat

发布于

2022-06-24

更新于

2022-09-26

许可协议

#加密算法

安卓逆向学习之DES加密算法

DES 算法简介

DES 算法框架

具体步骤

IP 置换

轮函数

E 扩展置换

S 盒压缩处理

P 盒置换

IP 逆置换

密钥生成

Python 代码

密钥生成

PC1

PC2

生成密钥

轮函数

E 置换

S 盒压缩

P 置换

F 函数

测试

运行结果

代码

总结

作者

发布于

更新于

许可协议

评论

目录

最新文章

链接