des算法vb

Ⅰ 求教des算法的详细过程

des算法的详细过程：
1-1、变换密钥
取得64位的密钥，每个第8位作为奇偶校验位。
1-2、变换密钥。
1-2-1、舍弃64位密钥中的奇偶校验位，根据下表（PC-1）进行密钥变换得到56位的密钥，在变换中，奇偶校验位以被舍弃。
Permuted Choice 1 (PC-1)
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-2-2、将变换后的密钥分为两个部分，开始的28位称为C[0]，最后的28位称为D[0]。
1-2-3、生成16个子密钥，初始I=1。
1-2-3-1、同时将C[I]、D[I]左移1位或2位，根据I值决定左移的位数。见下表
I： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位数： 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1
1-2-3-2、将C[I]D[I]作为一个整体按下表（PC-2）变换，得到48位的K[I]
Permuted Choice 2 (PC-2)
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
1-2-3-3、从1-2-3-1处循环执行，直到K[16]被计算完成。
2、处理64位的数据
2-1、取得64位的数据，如果数据长度不足64位，应该将其扩展为64位（例如补零）
2-2、将64位数据按下表变换（IP）
Initial Permutation (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
2-3、将变换后的数据分为两部分，开始的32位称为L[0]，最后的32位称为R[0]。
2-4、用16个子密钥加密数据，初始I=1。
2-4-1、将32位的R[I-1]按下表（E）扩展为48位的E[I-1]
Expansion (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
2-4-2、异或E[I-1]和K[I]，即E[I-1] XOR K[I]
2-4-3、将异或后的结果分为8个6位长的部分，第1位到第6位称为B[1]，第7位到第12位称为B[2]，依此类推，第43位到第48位称为B[8]。
2-4-4、按S表变换所有的B[J]，初始J=1。所有在S表的值都被当作4位长度处理。
2-4-4-1、将B[J]的第1位和第6位组合为一个2位长度的变量M，M作为在S[J]中的行号。
2-4-4-2、将B[J]的第2位到第5位组合，作为一个4位长度的变量N，N作为在S[J]中的列号。
2-4-4-3、用S[J][M][N]来取代B[J]。
Substitution Box 1 (S[1])
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
S[2]
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
S[3]
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
S[4]
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
S[5]
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
S[6]
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
S[7]
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
S[8]
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
2-4-4-4、从2-4-4-1处循环执行，直到B[8]被替代完成。
2-4-4-5、将B[1]到B[8]组合，按下表（P）变换，得到P。
Permutation 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
2-4-6、异或P和L[I-1]结果放在R[I]，即R[I]=P XOR L[I-1]。
2-4-7、L[I]=R[I-1]
2-4-8、从2-4-1处开始循环执行，直到K[16]被变换完成。
2-4-5、组合变换后的R[16]L[16]（注意：R作为开始的32位），按下表（IP-1）变换得到最后的结果。
Final Permutation (IP**-1)
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
以上就是DES算法的描述。

Ⅱ 我想做一个加密解密文件的VB程序！用des加密解密方法！！！ 希望高手解答！

vb.net code注意随机密码按钮在没用，调试时你自己输入密码，一定为8位，我是将文件存在D盘，你自己在修改一下，那个就很简单
Imports System.IO
Imports System.Security.Cryptography
Imports System.Text
Public Class Form1
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim sSecretKey As String = Me.TextBox2.Text
EncryptFile(Me.TextBox1.Text, "D:\JMtest.txt", sSecretKey)
End Sub
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim sSecretKey As String = Me.TextBox2.Text
DecryptFile("D:\JMtest.txt", "D:\Decrypted.txt", sSecretKey)
End Sub
Sub EncryptFile(ByVal sInputFilename As String, ByVal sOutputFilename As String, ByVal sKey As String)
Dim fsInput As New FileStream(sInputFilename, FileMode.Open, FileAccess.Read)
Dim fsEncrypted As New FileStream(sOutputFilename, FileMode.Create, FileAccess.Write)
Dim DES As New DESCryptoServiceProvider
DES.Key = ASCIIEncoding.ASCII.GetBytes(sKey)
DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey)
Dim desencrypt As ICryptoTransform = DES.CreateEncryptor()
Dim cryptostream As New CryptoStream(fsEncrypted, desencrypt, CryptoStreamMode.Write)
Dim byteArrayInput(fsInput.Length - 1) As Byte
fsInput.Read(byteArrayInput, 0, byteArrayInput.Length)
cryptostream.Write(byteArrayInput, 0, byteArrayInput.Length)
cryptostream.Close()
End Sub
Sub DecryptFile(ByVal sInputFilename As String, ByVal sOutputFilename As String, ByVal sKey As String)
Dim DES As New DESCryptoServiceProvider
DES.Key() = ASCIIEncoding.ASCII.GetBytes(sKey)
DES.IV = ASCIIEncoding.ASCII.GetBytes(sKey)
Dim fsread As New FileStream(sInputFilename, FileMode.Open, FileAccess.Read)
Dim desdecrypt As ICryptoTransform = DES.CreateDecryptor
Dim cryptostreamDecr As New CryptoStream(fsread, desdecrypt, CryptoStreamMode.Read)
Dim fsDecrypted As New StreamWriter(sOutputFilename)
fsDecrypted.Write(New StreamReader(cryptostreamDecr, System.Text.ASCIIEncoding.Default).ReadToEnd)
fsDecrypted.Flush()
fsDecrypted.Close()
End Sub
Private Sub BtnChoose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnChoose.Click
OpenFileDialog1.FileName = ""
OpenFileDialog1.Filter = "txt files (*.txt)|*.txt"
OpenFileDialog1.ShowDialog()
If OpenFileDialog1.FileName <> "" Then
Me.TextBox1.Text = OpenFileDialog1.FileName
End If
End Sub
End Class

Ⅲ 2.2 DES/3DES算法 -- 算法介绍

DES 算法和 DESSede 算法统称DES系列算法，是对称加密算法领域的经典加密算法。 DESSede (又称 3DES )使用三次迭代增加算法安全性。DES算法是众多对称加密算法的基础，很多算法都是基于该算法演变而来。

虽然DES被取代了，但是DES的CBC工作模式是基础性的算法和工作模型，有很强的意义，在遗留系统中也有一些使用的。

DES的算法是采用分组加密工作模式，流程比较复杂，大致流程如下：

DES 和 3DES 适合一般加密性场景，当前大部分是遗留系统在使用，还有一部分可能是系统没有支持 AES 等其他加密手段被迫使用。

JDK仅支持 56位的密钥长度 （出口限制），对称加密系列算法的特点是：密钥长度越高安全性越高，因此JDK本身自带的 DES 和 3DES 算法仅适合学术和一般场景使用，Bouncy Castle提供了64位密钥长度的支持。

3DES 是对 DES 的一种改良算法，针对 DES 算法密钥短，迭代次数少的缺点做了改进。但是 3DES 算法速度慢，密钥计算时间长，加密效率不高，实际使用也不多。

DES 的 3 大安全痛点：

Ⅳ 对称加密算法之DES介绍

DES (Data Encryption Standard)是分组对称密码算法。

DES算法利用 多次组合替代算法 和 换位算法 ，分散和错乱的相互作用，把明文编制成密码强度很高的密文，它的加密和解密用的是同一算法。

DES算法，是一种 乘积密码 ，其在算法结构上主要采用了 置换 、 代替 、 模二相加 等函数，通过 轮函数 迭代的方式来进行计算和工作。

DES算法也会使用到数据置换技术，主要有初始置换 IP 和逆初始置换 IP^-1 两种类型。DES算法使用置换运算的目的是将原始明文的所有格式及所有数据全部打乱重排。而在轮加密函数中，即将数据全部打乱重排，同时在数据格式方面，将原有的32位数据格式，扩展成为48位数据格式，目的是为了满足S盒组对数据长度和数据格式规范的要求。

一组数据信息经过一系列的非线性变换以后，很难从中推导出其计算的过程和使用的非线性组合；但是如果这组数据信息使用的是线性变换，计算就容易的多。在DES算法中，属于非线性变换的计算过程只有S盒，其余的数据计算和变换都是属于线性变换，所以DES算法安全的关键在于S盒的安全强度。此外，S盒和置换IP相互配合，形成了很强的抗差分攻击和抗线性攻击能力，其中抗差分攻击能力更强一些。

DES算法是一种分组加密机制，将明文分成N个组，然后对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。

DES加密是对每个分组进行加密，所以输入的参数为分组明文和密钥，明文分组需要置换和迭代，密钥也需要置换和循环移位。在初始置换IP中，根据一张8*8的置换表，将64位的明文打乱、打杂，从而提高加密的强度；再经过16次的迭代运算，在这些迭代运算中，要运用到子密钥；每组形成的初始密文，再次经过初始逆置换 IP^-1 ，它是初始置换的逆运算，最后得到分组的最终密文。

图2右半部分，给出了作用56比特密钥的过程。DES算法的加密密钥是64比特，但是由于密钥的第n*8(n=1,2…8)是校验(保证含有奇数个1)，因此实际参与加密的的密钥只有 56比特 。开始时，密钥经过一个置换，然后经过循环左移和另一个置换分别得到子密钥ki，供每一轮的迭代加密使用。每轮的置换函数都一样，但是由于密钥位的重复迭代使得子密钥互不相同。

DES算法 利用多次组合替代算法和换位算法，分散和错乱的相互作用，把明文编制成密码强度很高的密文，它的加密和解密用的是同一算法。

DES算法详述：DES对64位明文分组(密钥56bit)进行操作。

1、 初始置换函数IP：64位明文分组x经过一个初始置换函数IP，产生64位的输出x0，再将分组x0分成左半部分L0和右半部分R0：即将输入的第58位换到第一位，第50位换到第2位，…，依次类推，最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位。例，设置换前的输入值为D1D2D3…D64，则经过初始置换后的结果为：L0=D58D50…D8；R0=D57D49…D7.其置换规则如表1所示。

DES加密过程最后的逆置换 IP^-1 ，是表1的 逆过程 。就是把原来的每一位都恢复过去，即把第1位的数据，放回到第58位，把第2位的数据，放回到第50位。

2、 获取子密钥 Ki ：DES加密算法的密钥长度为56位，一般表示为64位(每个第8位用于奇偶校验)，将用户提供的64位初始密钥经过一系列的处理得到K1,K2,…,K16，分别作为 1~16 轮运算的 16个子密钥 。

(1). 将64位密钥去掉8个校验位，用密钥置换 PC-1 (表2)置换剩下的56位密钥；

(2). 将56位分成前28位C0和后28位D0，即 PC-1(K56)=C0D0 ;

(3). 根据轮数，这两部分分别循环左移1位或2位，表3：

(4). 移动后，将两部分合并成56位后通过压缩置换PC-2(表4)后得到48位子密钥，即Ki=PC-2(CiDi).

子密钥产生如图2所示：

3、 密码函数F(非线性的)

(1). 函数F的操作步骤：密码函数F 的输入是32比特数据和48比特的子密钥：
A．扩展置换(E):将数据的右半部分Ri从32位扩展为48位。位选择函数(也称E盒)，如表5所示：

B．异或：扩展后的48位输出E(Ri)与压缩后的48位密钥Ki作异或运算；

C．S盒替代：将异或得到的48位结果分成八个6位的块，每一块通过对应的一个S盒产生一个4位的输出。

(2)、D、P盒置换：将八个S盒的输出连在一起生成一个32位的输出，输出结果再通过置换P产生一个32位的输出即：F(Ri,Ki)，F(Ri,Ki)算法描述如图3，最后，将P盒置换的结果与最初的64位分组的左半部分异或，然后，左、右半部分交换，开始下一轮计算。

4、密文输出：经过16次迭代运算后，得到L16、R16，将此作为输入，进行逆置换，即得到密文输出。逆置换正好是初始置的逆运算。例如，第1位经过初始置换后，处于第40位，而通过逆置换，又将第40位换回到第1位，其逆置换规则如表8所示：

图4为DES算法加密原理图：

DES算法加密和解密过程采用相同的算法，并采用相同的加密密钥和解密密钥，两者的区别是：(1)、DES加密是从L0、R0到L15、R15进行变换，而解密时是从L15、R15到L0、R0进行变换的；(2)、加密时各轮的加密密钥为K0K1…K15，而解密时各轮的解密密钥为K15K14…K0；(3)、加密时密钥循环左移，解密时密钥循环右移。

DES加密过程分析：

(1)、首先要生成64位密钥，这64位的密钥经过“子密钥算法”换转后，将得到总共16个子密钥。将这些子密钥标识为Kn(n=1,2,…,16)。这些子密钥主要用于总共十六次的加密迭代过程中的加密工具。

(2)、其次要将明文信息按64位数据格式为一组，对所有明文信息进行分组处理。每一段的64位明文都要经过初试置换IP，置换的目的是将数据信息全部打乱重排。然后将打乱的数据分为左右两块，左边一块共32位为一组，标识为L0；右边一块也是32位为一组，标识为R0.

(3)、置换后的数据块总共要进行总共十六次的加密迭代过程。加密迭代主要由加密函数f来实现。首先使用子密钥K1对右边32位的R0进行加密处理，得到的结果也是32位的；然后再将这个32位的结果数据与左边32位的L0进行模2处理，从而再次得到一个32位的数据组。我们将最终得到的这个32位组数据，作为第二次加密迭代的L1，往后的每一次迭代过程都与上述过程相同。

(4)、在结束了最后一轮加密迭代之后，会产生一个64位的数据信息组，然后我们将这个64位数据信息组按原有的数据排列顺序平均分为左右两等分，然后将左右两等分的部分进行位置调换，即原来左等分的数据整体位移至右侧，而原来右等分的数据则整体位移至左侧，这样经过合并后的数据将再次经过逆初始置换IP^-1的计算，我们最终将得到一组64位的密文。

DES解密过程分析：DES的解密过程与它的加密过程是一样的，这是由于DES算法本身属于对称密码体制算法，其加密和解密的过程可以共用同一个过程和运算。

DES加密函数f：在DES算法中，要将64位的明文顺利加密输出成64位的密文，而完成这项任务的核心部分就是加密函数f。加密函数f的主要作用是在第m次的加密迭代中使用子密钥Km对Km-1进行加密操作。加密函数f在加密过程中总共需要运行16轮。

十六轮迭代算法：它先将经过置换后的明文分成两组，每组32位；同时密钥也被分成了两组，每组28位，两组密钥经过运算，再联合成一个48位的密钥，参与到明文加密的运算当中。S盒子，它由8个4*16的矩阵构成，每一行放着0到15的数据，顺序各个不同，是由IBM公司设计好的。经过异或运算的明文，是一个48位的数据，在送入到S盒子的时候，被分成了8份，每份6位，每一份经过一个S盒子，经过运算后输出为4位，即是一个0到15的数字的二进制表示形式。具体运算过程为，将输入的6位中的第1位为第6位合并成一个二进制数，表示行号，其余4位也合并成一个二进制数，表示列号。在当前S盒子中，以这个行号和列号为准，取出相应的数，并以二进制的形式表示，输出，即得到4位的输出，8个S盒子共计32位。

DES算法优缺点：

(1)、产生密钥简单，但密钥必须高度保密，因而难以做到一次一密；

(2)、DES的安全性依赖于密钥的保密。攻击破解DES算法的一个主要方法是通过密钥搜索，使用运算速度非常高的计算机通过排列组合枚举的方式不断尝试各种可能的密钥，直到破解为止。一般，DES算法使用56位长的密钥，通过简单计算可知所有可能的密钥数量最多是2^56个。随着巨型计算机运算速度的不断提高，DES算法的安全性也将随之下降，然而在一般的民用商业场合，DES的安全性仍是足够可信赖的。

(3)、DES算法加密解密速度比较快，密钥比较短，加密效率很高但通信双方都要保持密钥的秘密性，为了安全还需要经常更换DES密钥。

参考链接 ： https://blog.csdn.net/fengbingchun/article/details/42273257

Ⅳ 想要vb实现的des、rsa算法加密的程序 代码 感激万分。。。。。

gram
rem (c) W.Buchanan
rem Jan 2002

Function check_prime(ByVal val As Long) As Boolean
Dim primes
primes = Array(1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397)
check_prime = False

For i = 0 To 78
If (val = primes(i)) Then
prime = True
End If
Next i
check_prime = prime
End Function

Function decrypt(ByVal c, ByVal n, ByVal d As Long)

Dim i, g, f As Long

On Error GoTo errorhandler

If (d Mod 2 = 0) Then
g = 1
Else
g = c
End If

For i = 1 To d / 2

f = c * c Mod n
g = f * g Mod n
Next i
decrypt = g

Exit Function
errorhandler:
Select Case Err.Number ' Evaluate error number.
Case 6
status.Text = "Calculation overflow, please select smaller values"
Case Else
status.Text = "Calculation error"
End Select

End Function

Function getD(ByVal e As Long, ByVal PHI As Long) As Long
Dim u(3) As Long
Dim v(3) As Long
Dim q, temp1, temp2, temp3 As Long

u(0) = 1
u(1) = 0
u(2) = PHI
v(0) = 0
v(1) = 1
v(2) = e

While (v(2) <> 0)
q = Int(u(2) / v(2))
temp1 = u(0) - q * v(0)
temp2 = u(1) - q * v(1)
temp3 = u(2) - q * v(2)
u(0) = v(0)
u(1) = v(1)
u(2) = v(2)
v(0) = temp1
v(1) = temp2
v(2) = temp3
Wend
If (u(1) < 0) Then
getD = (u(1) + PHI)
Else
getD = u(1)
End If
End Function

Function getE(ByVal PHI As Long) As Long
Dim great, e As Long

great = 0
e = 2

While (great <> 1)
e = e + 1
great = get_common_denom(e, PHI)
Wend
getE = e
End Function

Function get_common_denom(ByVal e As Long, ByVal PHI As Long)
Dim great, temp, a As Long

If (e > PHI) Then
While (e Mod PHI <> 0)
temp = e Mod PHI
e = PHI
PHI = temp
Wend
great = PHI
Else
While (PHI Mod e <> 0)
a = PHI Mod e
PHI = e
e = a
Wend
great = e
End If
get_common_denom = great
End Function

Private Sub show_primes()
status.Text = "1"
no_primes = 1
For i = 2 To 400
prime = True
For j = 2 To (i / 2)
If ((i Mod j) = 0) Then
prime = False
End If
Next j

If (prime = True) Then
no_primes = no_primes + 1
status.Text = status.Text + ", " + Str(i)
End If
Next i
status.Text = status.Text + vbCrLf + "Number of primes found:" + Str(no_primes)
End Sub

Private Sub Command1_Click()
Dim p, q, n, e, PHI, d, m, c As Long

p = Text1.Text
q = Text2.Text
If (check_prime(p) = False) Then
status.Text = "p is not a prime or is too large, please re-enter"
ElseIf (check_prime(q) = False) Then
status.Text = "q is not a prime or is too large, please re-enter"
Else
n = p * q
Text3.Text = n

PHI = (p - 1) * (q - 1)
e = getE((PHI))
d = getD((e), (PHI))
Text4.Text = PHI
Text5.Text = d
Text6.Text = e
m = Text7.Text

c = (m ^ e) Mod n
Text8.Text = c
m = decrypt(c, n, d)
Text9.Text = m
Label12.Caption = "Decrypt key =<" + Str(d) + "," + Str(n) + ">"
Label13.Caption = "Encrypt key =<" + Str(e) + "," + Str(n) + ">"
End If
End Sub

Private Sub Command2_Click()
End
End Sub

Private Sub Command3_Click()
frmBrowser.Show
End Sub

Private Sub Command4_Click()
Call show_primes
End Sub

Ⅵ des加密算法

des加密算法如下：

一、DES加密算法简介

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

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

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

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