SkillAgentSearch skills...

DES

DES, 3DES & CBC 模式的详细解释和他们代码的具体实现

GenerateConvertImprove

Install / Use

/learn @Chang-LeHung/DES
About this skill

Quality Score

0/100

Supported Platforms

Universal

README

DES 加密详解

DES explanation in Java 本项目是使用java语言实现DES，3DES加密算法，使用CBC模式实现加密文件，并做成了软件mybox，并提供了源码实现，如果你对它感兴趣也可以那它进行加密测试，或者仔细查看源码文件，如果想进行源码实现，请重点阅读DES.java文件。 如果你对DES, 3DES, CBC模式不熟悉请先阅读下面的文档或者它的pdf形式，在这里提供了对DES, 3DES, CBC模式详细解释，供大家参考。

mybox 使用方法如下

  • 查看帮助文档 
    .\mymybox-64-bit.exe
或者
.\mymybox-64-bit.exe -help
    结果如下，加密时需要提供3个密钥和初始化向量，都是十六位的十进制数，即提供了加密需要的64位01二进制数 
    ############################### MyBox ##################################
### Description:                                                    ###
### Software MyBox was Written by Mr. HuChang in Java on 10/27/2020 ###
 _____________
< @牧牛的铃铛 >
 -------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||---- w|
                ||     ||
Usage mybox:
 mybox [FILED] ... [STRING] ...
   -key1        --first secret key
                    default=0123456789abcdef
   -output      --output file path
                    default=mybox
   -input       --input file path
                    default=null
   -iv  --initialization vector of CBC encryption mode
                    default=0123456789abcdef
   -key2        --second secret key
                    default=0123456789abcdef
   -key3        --third secret key
                    default=0123456789abcdef
   -mode        --encrypt or decrypt
                    default=en
  • 加密示例 
    .\mybox-64-bit.exe -input .\README.md -key1 0123456789abcdef -key2 0123456789abcdef -key3 0123456789abcdef -iv 0123456789abcdef -mode encrypt -output result
  • 解密示例 
    .\mybox-64-bit.exe -input .\result.mybox -key1 0123456789abcdef -key2 0123456789abcdef -key3 0123456789abcdef -iv 0123456789abcdef -mode decrypt -output ans.md

DES，CBC模式，3DES详解如下

如果查看不了下面的图片文档，请参考Image show进行解决

DES算法——从小白到登堂入室

从字符串信息到01比特数

首先什么是加密？加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。(百度百科)

简单来说比如像下面这样：原文经过加密算法之后被加密成密文。

image-20201110204711992

原文被加密成密文之后意义发生了改变窃听者就不能发现消息内容，这正是加密信息的意义。计算机中的信息在经过物理层的时候最终都会变成01比特流，加密也正是基于比特流，如果想变成信息只需经过编码即可。例如想Java/Python将字符串或数字变成比特流。

Python将数字变成01字符

num = 100
print(bin(num)) # 0b1100100

其中1100100正是100的二进制数，如果我们自己来实现可以这样

def to_bits(num, length):
	return [num >> (length - i - 1) & 1 for i in range(length)]

num = 100
print(to_bits(num, 7)) # [1, 1, 0, 0, 1, 0, 0]

对于字符串来说首先得进行字符编码编码，具体如下：

s = "Hello World"

encoded = s.encode("utf-8") # 使用 UTF-8 对 s 进行编码，编码的结果便是数据

for num in encoded:
	print(num, end=" ")
# 72 101 108 108 111 32 87 111 114 108 100

编码后的结果是数据(72 101 108 108 111 32 87 111 114 108 100)，那么就可以使用上述方法将数字变成01比特数，把得到结果连接起来便得到了字符串的01比特流。

**<font color="red" face="Monaco">DES(Data Encryption Standard)</font>**是第一个广泛应用于商用数据保密的密码算法，虽然DES由于秘钥空间限制已经能被破解而被高级加密标准<font color="red">AES</font>取代，但是它设计思想仍然有很重要的参考价值。下面就具体说明DES加密算法~~~

DES加密的关键过程主要有下面三个。

  • <font color="red">由初始秘钥生成子秘钥</font>
  • <font color="red">轮函数</font>
  • <font color="red">置换</font>

DES算法流程

首先从整体上来了解一下DES加密的流程。

image-20201112105800561

DES加密算法的明文的长度是确定的，是由64个0，1数字组成，秘钥也是如此由64个01数字组成。

  • 首先明文经过**<font color="red">初始置换</font>**得到初始置换后的信息T。

    • 进行**<font color="red">初始置换</font>**首先需要一张初始置换表，如下

      public static byte[][] initIPSub = {
            {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}
  };

      一共8行8列64个数。置换规则 (第i行第j列，原文为 M 置换结果为 T，初始置换表为 I): $T_{(i * 8 + j + 1)}=M_{I[i][j]}$， i, j从0开始。

      例如第一行第一列58，即原文的M第58位为置换后的信息T的第一位，第二列：原文M第50位为T的第二位,以此类推......

      image-20201111001820006

  • 16轮运算，由于16轮运算比较复杂稍微再进行详解。

  • **<font color="red">初始逆置换</font>**和初始置换表一样，都是8x8的置换表，只是置换表内容发生了变化，除此之外其余步骤一样。

    • **<font color="red">初始逆置换</font>**表

      public static byte[][] initIPInverseSub = {
            {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}
    };

秘钥生成

在之后进行16轮轮函数运算时需要用到子秘钥，接下来将讲解具体的由初始秘钥生成子秘钥的过程。子秘钥生成流程图如下：

image-20201111211815836

由上图初始秘钥(64位，提供用来加密的秘钥，整个DES加密需要提供的就是 <font color='red'>明文和秘钥</font>)

  • 置换选择1

    置换还是和之前初始置换和初始置换一样，只是表不同而已，置换选择1所用到的表如下：

    public static byte[][] keySub1 = {
            {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}
    };

    置换选择表1和之前的表不同的地方在于它是一个8x7的表，也就是说会将初始秘钥的64位变成56位，但是规则仍然是一样，只不过前面一共换了64位，这里只换56位而已。在进行初始置换之后再进行分割，将得到的56比特数字分割成左右两部分。

    image-20201111193003882

  • $LS_i$函数 $$ LS_i= \begin{cases} 循环左移一位, & \text{i $\in$ {1, 2, 9, 16}}\ 循环左移两位, & \text{i $\in$ {3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15}} \end{cases} $$

    循环左移示例

    image-20201111211259129

    每一个$C_i$和$D_i$都需要经过$LS_i$输出$C_{i+1}$和$D_{i + 1}$，并且$C_{i+1}$和$D_{i + 1}$将作为$LS_{i+1}$的输入得到$C_{i + 2}$和$D_{i+2}$以此类推......

  • 在经过$LS_{i}$函数之后得到$C_{i+1}$和$D_{i + 1}$将他们拼接成$C_{i+1}$$D_{i + 1}$再经过置换选择2得到一把子秘钥，置换规则和之前一样，置换选择2的内容如下：

    public static byte[][] keySub2 = {
            {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}
  };

    这是一张8x6的表，也就是说只置换48次，置换的子钥是一个48位的比特数。

加密过程

在上面我们完成了==DES加密==过程中的==置换==和==子秘钥生成==了，接下就开始具体了解加密过程了。首先我们将经过初始置换后的T分成左右两个部分，拆分方法和上面秘钥经过置换选择1的分法一样，只不过位数发生了变化，将T分成左右两部分L, R他们各占32位。其中： $$ L_0 = x_{1}^{'}x_{2}^{'}x_{3}^{'}...x_{30}^{'}x_{31}^{'}x_{32}^{'}\ R_0 = x_{33}^{'}x_{34}^{'}x_{35}^{'}...x_{62}^{'}x_{63}^{'}x_{64}^{'} $$ 然后就需要利用$L_0和R_0$进行16次的加密过程了，加密过程的算法如下，其中F是轮函数，它的输出一个32位的比特数之后会说明它的具体实现，$\bigoplus$是异或运算： $$ \begin{cases} L_i=R_{i-1}\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 1, 2, ..., 16\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ K_i是子秘钥生成过程中生成的第i把秘钥\ R_i=L_{i-1}\bigoplus F(R_{i-1}, K_i) \end{cases} $$ 加密流程图如下图所示：

image-20201112105846997

在经过16轮加密运算之后得到的$R_{16}, L_{16}$都是32位的比特数，将他们拼接成$R_{16} L_{16}$，==注意不是$L_{16} R_{16}$，而是$R_{16} L_{16}$==。在经过初始逆置换(具体可以查看最开始的DES加密流程图)就可以得到密文了。

轮函数

根据上面很容易知道，在进行加密的时候对信息$L_i, R_i$的迭代需要使用到轮函数$F$，接下来对它进行详解。轮函数流程图如下：

image-20201112110125546

根据公式： $$ \begin{cases} L_i=R_{i-1}\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 1, 2, ..., 16\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ K_i是子秘钥生成过程中生成的第i把秘钥\ R_i=L_{i-1}\bigoplus F(R_{i-1}, K_i) \end{cases} $$ 轮函数的输入是$R_{i - 1}和K_i$，首先$R_{i - 1}$通过==扩展置换==由32变成48位，扩展置换也和之前的置换方式一致，它也有它的置换表，如下：

public static byte[][] extendsTable = {
            {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}
    };

一共8行6列，因此置换结果有48位。扩展置换得到结果再与48为的子秘钥$K_i$进行异或运算，得到一个新的48位的结果，下面就需要将得到的48为的结果分解成8份，每份含有6位的比特数，分割方式如下：

image-20201112113539518

这里的$S_i$统称为$S盒$，一共8，每个$S$的输出是一个4位的比特数，范围就是：0000 ~ 1111，十进制表示就是从0到15。那么$S$盒是如何映射的呢？

首先先来了解$S$的结构，一共8个盒，每个盒的构成都一样，均为行为4列为16的表，具体如下：

public static byte[][] 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}
    };
    public static byte[][] 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}
    };
    public static byte[][] S3 = {
            {10, 0, 9, 14, 6, 3, 15, 5, 1, 1

Chang-LeHung

View profile

View on GitHub
GitHub Stars16
CategoryDevelopment
Updated5mo ago
Forks1
Chang-LeHung/DES

Languages

Java

Security Score

77/100

Audited on Oct 11, 2025

No findings