加密字符串补位

❶ 什么是安全散列算法SHA256

安全散列算法SHA（Secure Hash Algorithm）是美国国家安全局 （NSA） 设计，美国国家标准与技术研究院（NIST） 发布的一系列密码散列函数，包括 SHA-1、SHA-224、SHA-256、SHA-384 和 SHA-512 等变体。主要适用于数字签名标准（DigitalSignature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。下面以 SHA-1为例，介绍该算法计算消息摘要的原理。
对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。
SHA1有如下特性：不可以从消息摘要中复原信息；两个不同的消息不会产生同样的消息摘要。
一、术语和概念
（一）位(Bit)，字节（Byte）和字（Word）
SHA1始终把消息当成一个位（bit）字符串来处理。本文中，一个“字”（Word）是32位，而一个“字节”（Byte）是8位。比如，字符串“abc”可以被转换成一个位字符串：01100001 01100010 01100011。它也可以被表示成16进制字符串:0x616263.
（二）运算符和符号
下面的逻辑运算符都被运用于“字”（Word）
X^Y = X，Y逻辑与
X \/ Y = X，Y逻辑或
X XOR Y= X，Y逻辑异或
~X = X逻辑取反
X+Y定义如下：
字 X 和Y 代表两个整数 x 和y, 其中0 <= x < 2^32 且 0 <= y < 2^32. 令整数z= (x + y) mod 2^32. 这时候 0 <= z < 2^32. 将z转换成字Z,那么就是 Z = X + Y.
循环左移位操作符Sn(X)。X是一个字，n是一个整数，0<=n<=32。Sn(X)= (X<>32-n)
X<定义如下：抛弃最左边的n位数字，将各个位依次向左移动n位，然后用0填补右边的n位（最后结果还是32位）。X>>n是抛弃右边的n位，将各个位依次向右移动n位，然后在左边的n位填0。因此可以叫Sn(X)位循环移位运算
二、SHA1算法描述
在SHA1算法中，我们必须把原始消息（字符串，文件等）转换成位字符串。SHA1算法只接受位作为输入。假设我们对字符串“abc”产生消息摘要。首先，我们将它转换成位字符串如下：
01100001 0110001001100011
―――――――――――――
‘a’=97 ‘b’=98‘c’=99
这个位字符串的长度为24。下面我们需要5个步骤来计算MD5。
（一）补位
消息必须进行补位，以使其长度在对512取模以后的余数是448。也就是说，（补位后的消息长度）%512 = 448。即使长度已经满足对512取模后余数是448，补位也必须要进行。
补位是这样进行的：先补一个1，然后再补0，直到长度满足对512取模后余数是448。总而言之，补位是至少补一位，最多补512位。还是以前面的“abc”为例显示补位的过程。
原始信息：01100001 01100010 01100011
补位第一步：0110000101100010 01100011 1
首先补一个“1”
补位第二步：0110000101100010 01100011 10…..0
然后补423个“0”
我们可以把最后补位完成后的数据用16进制写成下面的样子
61626380 0000000000000000 00000000
00000000 0000000000000000 00000000
00000000 0000000000000000 00000000
00000000 00000000
现在，数据的长度是448了，我们可以进行下一步操作。
（二）补长度
所谓的补长度是将原始数据的长度补到已经进行了补位操作的消息后面。通常用一个64位的数据来表示原始消息的长度。如果消息长度不大于2^64，那么第一个字就是0。在进行了补长度的操作以后，整个消息就变成下面这样了（16进制格式）
61626380 0000000000000000 00000000
00000000 0000000000000000 00000000
00000000 0000000000000000 00000000
00000000 0000000000000000 00000018
如果原始的消息长度超过了512，我们需要将它补成512的倍数。然后我们把整个消息分成一个一个512位的数据块，分别处理每一个数据块，从而得到消息摘要。
（三）使用的常量
一系列的常量字K(0),K(1), ... , K(79)，如果以16进制给出。它们如下：
Kt = 0x5A827999 (0<= t <= 19)
Kt = 0x6ED9EBA1 (20<= t <= 39)
Kt = 0x8F1BBCDC (40<= t <= 59)
Kt = 0xCA62C1D6 (60<= t <= 79).
（四）需要使用的函数
在SHA1中我们需要一系列的函数。每个函数ft (0 <= t <= 79)都操作32位字B，C，D并且产生32位字作为输出。ft(B,C,D)可以如下定义
ft(B,C,D) = (B ANDC) or ((NOT B) AND D) ( 0 <= t <= 19)
ft(B,C,D) = B XOR CXOR D (20 <= t <= 39)
ft(B,C,D) = (B ANDC) or (B AND D) or (C AND D) (40 <= t <= 59)
ft(B,C,D) = B XOR CXOR D (60 <= t <= 79).
（五）计算消息摘要
必须使用进行了补位和补长度后的消息来计算消息摘要。计算需要两个缓冲区，每个都由5个32位的字组成，还需要一个80个32位字的缓冲区。第一个5个字的缓冲区被标识为A，B，C，D，E。第二个5个字的缓冲区被标识为H0,H1, H2, H3, H4。80个字的缓冲区被标识为W0,W1,..., W79
另外还需要一个一个字的TEMP缓冲区。
为了产生消息摘要，在第4部分中定义的16个字的数据块M1,M2,..., Mn
会依次进行处理，处理每个数据块Mi 包含80个步骤。
在处理每个数据块之前，缓冲区{Hi} 被初始化为下面的值（16进制）
H0 = 0x67452301
H1 = 0xEFCDAB89
H2 = 0x98BADCFE
H3 = 0x10325476
H4 = 0xC3D2E1F0.
现在开始处理M1, M2,... , Mn。为了处理 Mi,需要进行下面的步骤
(1). 将Mi 分成 16 个字 W0, W1, ... , W15,W0 是最左边的字
(2). 对于t = 16 到 79 令 Wt = S1(Wt-3 XOR Wt-8XOR Wt- 14 XOR Wt-16).
(3). 令A = H0, B = H1, C = H2, D = H3, E = H4.
(4) 对于t = 0 到 79，执行下面的循环
TEMP = S5(A) +ft(B,C,D) + E + Wt + Kt;
E = D; D = C; C =S30(B); B = A; A = TEMP;
(5). 令H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
在处理完所有的 Mn, 后，消息摘要是一个160位的字符串，以下面的顺序标识
H0 H1 H2 H3 H4.
对于SHA256、SHA384、SHA512。你也可以用相似的办法来计算消息摘要。对消息进行补位的算法完全是一样的。
三、SHA算法被破解了吗？
2013年9月10日美国约翰霍普金斯大学的计算机科学教授，知名的加密算法专家，Matthew Green被NSA要求删除他的一份关于破解加密算法的与NSA有关的博客。 同时约翰霍普金斯大学服务器上的该博客镜像也被要求删除。

加密算法专家，美国约翰霍普金斯大学教授Matthew Green
但当记者向该大学求证时，该校称从未收到来自NSA的要求要删除博客或镜像的资料，但记者却无法在原网址再找到该博客。幸运的是，从谷歌的缓存可以找到该博客。该博客提到NSA每年花费2.5亿美元来为自己在解密信息方面获取优势，并列举了NSA的一系列见不得人的做法。

在BitcoinTalk上，已经掀起了一轮争论：到底SHA-2是否安全？
部分认为不安全的观点包括：
NSA制造了sha-2, 我们不相信NSA，他们不可能不留后门。
棱镜事件已经明白的告诉我们，政府会用一切可能的手段来监视与解密。
虽然有很多人会研究SHA-2，且目前没有公开的证据表明有漏洞。但没有公开这并不能代表就没有，因为发现漏洞的人一定更倾向于保留这个秘密来自己利用，而不是公布。
部分认为安全的观点包括：
SHA-2是应用广泛的算法，应该已经经历了实践的检验。
美国的对头中国和俄国都有很多杰出的数学家，如果有问题的话，他们肯定已经发现了。
如果真的不安全，世界上安全的东西就太少了，我不能生活在提心吊胆里，所以我选择相信安全。

❷ 谁能通俗易懂地讲讲MD5加密原理

MD5算法的原理可简要的叙述为：MD5码以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。

在MD5算法中，首先需要对信息进行填充，这个数据按位(bit)补充，要求最终的位数对512求模的结果为448。也就是说数据补位后，其位数长度只差64位(bit)就是512的整数倍。

即便是这个数据的位数对512求模的结果正好是448也必须进行补位。

补位的实现过程：首先在数据后补一个1 bit； 接着在后面补上一堆0 bit, 直到整个数据的位数对512求模的结果正好为448。总之，至少补1位，而最多可能补512位。

(2)加密字符串补位扩展阅读

当需要保存某些密码信息以用于身份确认时，如果直接将密码信息以明码方式保存在数据库中，不使用任何保密措施，系统管理员就很容易能得到原来的密码信息，这些信息一旦泄露， 密码也很容易被破译。为了增加安全性，有必要对数据库中需要保密的信息进行加密，这样，即使有人得到了整个数据库，如果没有解密算法，也不能得到原来的密码信息。

MD5算法可以很好地解决这个问题，因为它可以将任意长度的输入串经过计算得到固定长度的输出，而且只有在明文相同的情况下，才能等到相同的密文，并且这个算法是不可逆的，即便得到了加密以后的密文，也不可能通过解密算法反算出明文。

这样就可以把用户的密码以MD5值（或类似的其它算法）的方式保存起来，用户注册的时候，系统是把用户输入的密码计算成 MD5 值，然后再去和系统中保存的 MD5 值进行比较，如果密文相同，就可以认定密码是正确的，否则密码错误。

通过这样的步骤，系统在并不知道用户密码明码的情况下就可以确定用户登录系统的合法性。这样不但可以避免用户的密码被具有系统管理员权限的用户知道，而且还在一定程度上增加了密码被破解的难度。

MD5 算法还可以作为一种电子签名的方法来使用，使用 MD5算法就可以为任何文件（不管其大小、格式、数量）产生一个独一无二的“数字指纹”，借助这个“数字指纹”，通过检查文件前后 MD5 值是否发生了改变，就可以知道源文件是否被改动。

❸ 对称加密算法以及使用方法

加密的原因：保证数据安全

加密必备要素：1、明文/密文    2、秘钥    3、算法

秘钥：在密码学中是一个定长的字符串、需要根据加密算法确定其长度

加密算法解密算法一般互逆、也可能相同

常用的两种加密方式：

对称加密：秘钥：加密解密使用同一个密钥、数据的机密性双向保证、加密效率高、适合加密于大数据大文件、加密强度不高(相对于非对称加密)

非对称加密：秘钥：加密解密使用的不同秘钥、有两个密钥、需要使用密钥生成算法生成两个秘钥、数据的机密性只能单向加密、如果想解决这个问题、双向都需要各自有一对秘钥、加密效率低、加密强度高

                    公钥：可以公开出来的密钥、公钥加密私钥解密

                    私钥：需要自己妥善保管、不能公开、私钥加密公钥解密

安全程度高：多次加密

按位异或运算

凯撒密码：加密方式    通过将铭文所使用的字母表按照一定的字数平移来进行加密

mod：取余

加密三要素：明文/密文(字母)、秘钥(3)、算法(向右平移3/-3)

安全常识：不要使用自己研发的算法、不要钻牛角尖、没必要研究底层实现、了解怎么应用；低强度的密码比不进行任何加密更危险；任何密码都会被破解；密码只是信息安全的一部分

保证数据的机密性、完整性、认证、不可否认性

计算机操作对象不是文字、而是由0或1排列而成的比特序列、程序存储在磁盘是二进制的字符串、为比特序列、将现实的东西映射为比特序列的操作称为编码、加密又称之为编码、解密称之为解码、根据ASCII对照表找到对应的数字、转换成二进制

三种对称加密算法：DES\3DES\ AES  

DES：已经被破解、除了用它来解密以前的明文、不再使用

密钥长度为56bit/8、为7byte、每隔7个bit会设置一个用于错误检查的比特、因此实际上是64bit

分组密码(以组为单位进行处理)：加密时是按照一个单位进行加密(8个字节/64bit为一组)、每一组结合秘钥通过加密算法得到密文、加密后的长度不变

3DES:三重DES为了增加DES的强度、将DES重复三次所得到的一种加密算法   密钥长度24byte、分成三份  加密--解密--加密 目的：为了兼容DES、秘钥1秘钥2相同==三个秘钥相同  ---加密一次        密钥1秘钥3相同--加密三次    三个密钥不相同最好、此时解密相当于加密、中间的一次解密是为了有三个密钥相同的情况

此时的解密操作与加密操作互逆，安全、效率低

数据先解密后加密可以么？可以、解密相当于加密、加密解密说的是算法

AES：(首选推荐)底层算法为Rijndael   分组长度为128bit、密钥长度为128bit到256bit范围内就可以   但是在AES中、密钥长度只有128bit\192bit\256bit     在go提供的接口中、只能是16字节(128bit)、其他语言中秘钥可以选择

目前为止最安全的、效率高

底层算法

分组密码的模式：

按位异或、对数据进行位运算、先将数据转换成二进制、按位异或操作符^、相同为真、不同为假、非0为假    按位异或一次为加密操作、按位异或两次为解密操作：a和b按位异或一次、结果再和b按位异或

ECB : 如果明文有规律、加密后的密文有规律不安全、go里不提供该接口、明文分组分成固定大小的块、如果最后一个分组不满足分组长度、则需要补位

CBC：密码链

问题：如何对字符串进行按位异或？解决了ECB的规律可查缺点、但是他不能并行处理、最后一个明文分组也需要填充 、初始化向量长度与分组长度相同

CFB:密文反馈模式

不需要填充最后一个分组、对密文进行加密

OFB：

不需要对最后一组进行填充

CTR计数器:

不需要对最后一组进行填充、不需要初始化向量     

Go中的实现

官方文档中：

在创建aes或者是des接口时都是调用如下的方法、返回的block为一个接口

func NewCipher(key [] byte ) ( cipher . Block , error )

type Block interface {

    // 返回加密字节块的大小

    BlockSize() int

    // 加密src的第一块数据并写入dst，src和dst可指向同一内存地址

    Encrypt(dst, src []byte)

    // 解密src的第一块数据并写入dst，src和dst可指向同一内存地址

    Decrypt(dst, src []byte)

}

Block接口代表一个使用特定密钥的底层块加/解密器。它提供了加密和解密独立数据块的能力。

Block的Encrypt/Decrypt也能进行加密、但是只能加密第一组、因为aes的密钥长度为16、所以进行操作的第一组数据长度也是16

如果分组模式选择的是cbc

func NewCBCEncrypter(b Block, iv []byte) BlockMode    加密

func NewCBCDecrypter(b Block, iv []byte) BlockMode    解密

加密解密都调用同一个方法CryptBlocks()

并且cbc分组模式都会遇到明文最后一个分组的补充、所以会用到加密字节的大小

返回一个密码分组链接模式的、底层用b加密的BlockMode接口，初始向量iv的长度必须等于b的块尺寸。iv自己定义

返回的BlockMode同样也是一个接口类型

type BlockMode interface {

    // 返回加密字节块的大小

    BlockSize() int

    // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址

    CryptBlocks(dst, src []byte)

}

BlockMode接口代表一个工作在块模式（如CBC、ECB等）的加/解密器

返回的BlockMode其实是一个cbc的指针类型中的b和iv

# 加密流程: 

1. 创建一个底层使用des/3des/aes的密码接口 "crypto/des" func NewCipher(key []byte) (cipher.Block, error) # -- des func NewTripleDESCipher(key []byte) (cipher.Block, error) # -- 3des "crypto/aes" func NewCipher(key []byte) (cipher.Block, error) # == aes 

2. 如果使用的是cbc/ecb分组模式需要对明文分组进行填充

3. 创建一个密码分组模式的接口对象 - cbc func NewCBCEncrypter(b Block, iv []byte) BlockMode # 加密 - cfb func NewCFBEncrypter(block Block, iv []byte) Stream # 加密 - ofb - ctr

 4. 加密, 得到密文

流程：

填充明文：

先求出最后一组中的字节数、创建新切片、长度为新切片、值也为切片的长度、然后利用bytes.Reapet将长度换成字节切片、追加到原明文中

//明文补充

func padPlaintText(plaintText []byte,blockSize int)[]byte{

    //1、求出需要填充的个数

    padNum := blockSize-len(plaintText) % blockSize

    //2、对填充的个数进行操作、与原明文进行合并

    newPadding := []byte{byte(padNum)}

    newPlain := bytes.Repeat(newPadding,padNum)

    plaintText = append(plaintText,newPlain...)

    return plaintText

}

去掉填充数据：

拿去切片中的最后一个字节、得到尾部填充的字节个数、截取返回

//解密后的明文曲调补充的地方

func createPlaintText(plaintText []byte,blockSize int)[]byte{

    //1、得到最后一个字节、并将字节转换成数字、去掉明文中此数字大小的字节

    padNum := int(plaintText[len(plaintText)-1])

    newPadding := plaintText[:len(plaintText)-padNum]

    return newPadding

}

des加密：

1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口

2、对明文进行填充

3、创建一个cbc模式的接口、需要创建iv初始化向量、返回一个blockmode对象

4、加密、调用blockmode中的cryptBlock函数进行加密、参数为目标参数和源参数

//des利用分组模式cbc进行加密

func EncryptoText(plaintText []byte,key []byte)[]byte{

    //1、创建des对象

    cipherBlock,err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、对明文进行填充

    newText := padPlaintText(plaintText,cipherBlock.BlockSize())

    //3、选择分组模式、其中向量的长度必须与分组长度相同

    iv := make([]byte,cipherBlock.BlockSize())

    blockMode := cipher.NewCBCEncrypter(cipherBlock,iv)

    //4、加密

    blockMode.CryptBlocks(newText,newText)

    return newText

}

des解密：

1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口

2、创建一个cbc模式的接口、需要创建iv初始化向量，返回一个blockmode对象

3、加密、调用blockmode中的cryptBlock函数进行解密、参数为目标参数和源参数

4、调用去掉填充数据的方法

//des利用分组模式cbc进行解密

func DecryptoText(cipherText []byte, key []byte)[]byte{

    //1、创建des对象

    cipherBlock,err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建cbc分组模式接口

    iv := []byte("12345678")

    blockMode := cipher.NewCBCDecrypter(cipherBlock,iv)

    //3、解密

    blockMode.CryptBlocks(cipherText,cipherText)

    //4、将解密后的数据进行去除填充的数据

    newText := clearPlaintText(cipherText,cipherBlock.BlockSize())

    return newText

}

Main函数调用

func main(){

    //需要进行加密的明文

    plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量" +

        "(一个数组、数组的长度与明文分组相等、数据来源:负责加密的人提供，加解密使用的初始化向量必须相同)")

    //密钥Key的长度需要与分组长度相同、且加密解密的密钥相同

    key := []byte("1234abcd")

    //调用加密函数

    cipherText := EncryptoText(plaintText,key)

    newPlaintText := DecryptoText(cipherText,key)

    fmt.Println(string(newPlaintText))

}

AES加密解密相同、所以只需要调用一次方法就可以加密、调用两次则解密

推荐是用分组模式：cbc、ctr

aes利用分组模式cbc进行加密

//对明文进行补充

func paddingPlaintText(plaintText []byte , blockSize int ) []byte {

    //1、求出分组余数

    padNum := blockSize - len(plaintText) % blockSize

    //2、将余数转换为字节切片、然后利用bytes.Repeat得出有该余数的大小的字节切片

    padByte := bytes.Repeat([]byte{byte(padNum)},padNum)

    //3、将补充的字节切片添加到原明文中

    plaintText = append(plaintText,padByte...)

    return plaintText

}

//aes加密

func encryptionText(plaintText []byte, key []byte) []byte {

    //1、创建aes对象

    block,err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、明文补充

    newText := paddingPlaintText(plaintText,block.BlockSize())

    //3、创建cbc对象

    iv := []byte("12345678abcdefgh")

    blockMode := cipher.NewCBCEncrypter(block,iv)

    //4、加密

    blockMode.CryptBlocks(newText,newText)

    return newText

}

//解密后的去尾

func clearplaintText(plaintText []byte, blockSize int) []byte {

    //1、得到最后一个字节、并转换成整型数据

    padNum := int(plaintText[len(plaintText)-1])

    //2、截取明文字节中去掉得到的整型数据之前的数据、此处出错、没有用len-padNum

    newText := plaintText[:len(plaintText)-padNum]

    return newText

}

//aes解密

func deCryptionText(crypherText []byte, key []byte ) []byte {

    //1、创建aes对象

    block, err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建cbc对象

    iv := []byte("12345678abcdefgh")

    blockMode := cipher.NewCBCDecrypter(block,iv)

    //3、解密

    blockMode.CryptBlocks(crypherText,crypherText)

    //4、去尾

    newText := clearplaintText(crypherText,block.BlockSize())

    return newText

}

func main(){

    //需要进行加密的明文

    plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量")

    //密钥Key的长度需要与分组长度相同、且加密解密的密钥相同

    key := []byte("12345678abcdefgh")

    //调用加密函数

    cipherText := encryptionText(plaintText,key)

    //调用解密函数

    newPlaintText := deCryptionText(cipherText,key)

    fmt.Println("解密后",string(newPlaintText))

}

//aes--ctr加密

func encryptionCtrText(plaintText []byte, key []byte) []byte {

    //1、创建aes对象

    block,err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建ctr对象，虽然ctr模式不需要iv，但是go中使用ctr时还是需要iv

    iv := []byte("12345678abcdefgh")

    stream := cipher.NewCTR(block,iv)

    stream.XORKeyStream(plaintText,plaintText)

    return plaintText

}

func main() {

//aes--ctr加密解密、调用两次即为解密、因为加密解密函数相同stream.XORKeyStream

    ctrcipherText := encryptionCtrText(plaintText, key)

    ctrPlaintText := encryptionCtrText(ctrcipherText,key)

    fmt.Println("aes解密后", string(ctrPlaintText))

}

英文单词：

明文：plaintext     密文：ciphertext   填充：padding/fill    去掉clear  加密Encryption  解密Decryption

❹ 什么是3DES对称加密算法

DES加密经过下面的步骤
1、提供明文和密钥,将明文按照64bit分块（对应8个字节），不足8个字节的可以进行填充（填充方式多种）,密钥必须为8个字节共64bit
填充方式：

当明文长度不为分组长度的整数倍时，需要在最后一个分组中填充一些数据使其凑满一个分组长度。
* NoPadding
API或算法本身不对数据进行处理，加密数据由加密双方约定填补算法。例如若对字符串数据进行加解密，可以补充\0或者空格，然后trim

* PKCS5Padding
加密前：数据字节长度对8取余，余数为m，若m>0,则补足8-m个字节，字节数值为8-m，即差几个字节就补几个字节，字节数值即为补充的字节数，若为0则补充8个字节的8
解密后：取最后一个字节，值为m，则从数据尾部删除m个字节，剩余数据即为加密前的原文。
例如：加密字符串为为AAA，则补位为AAA55555;加密字符串为BBBBBB，则补位为BBBBBB22；加密字符串为CCCCCCCC，则补位为CCCCCCCC88888888。

* PKCS7Padding
PKCS7Padding 的填充方式和PKCS5Padding 填充方式一样。只是加密块的字节数不同。PKCS5Padding明确定义了加密块是8字节，PKCS7Padding加密快可以是1-255之间。
2、选择加密模式

**ECB模式** 全称Electronic Codebook模式，译为电子密码本模式
**CBC模式** 全称Cipher Block Chaining模式，译为密文分组链接模式
**CFB模式** 全称Cipher FeedBack模式，译为密文反馈模式
**OFB模式** 全称Output Feedback模式，译为输出反馈模式。
**CTR模式** 全称Counter模式，译为计数器模式。
3、开始加密明文（内部原理--加密步骤，加密算法实现不做讲解）

image
1、将分块的64bit一组组加密，示列其中一组：将此组进行初始置换（IP置换），目的是将输入的64位数据块按位重新组合，并把输出分为L0、R0两部分，每部分各长32位。
2、开始Feistel结构的16次转换，第一次转换为：右侧数据R0和子密钥经过轮函数f生成用于加密左侧数据的比特序列，与左侧数据L0异或运算，
运算结果输出为加密后的左侧L0，右侧数据则直接输出为右侧R0。由于一次Feistel轮并不会加密右侧，因此需要将上一轮输出后的左右两侧对调后才正式完成一次Feistel加密，
3、DES算法共计进行16次Feistel轮，最后一轮输出后左右两侧无需对调，每次加密的子密钥不相同，子密钥是通过秘钥计算得到的。
4、末置换是初始置换的逆过程，DES最后一轮后，左、右两半部分并未进行交换，而是两部分合并形成一个分组做为末置换的输入
DES解密经过下面的步骤
1、拿到密文和加密的密钥
2、解密：DES加密和解密的过程一致，均使用Feistel网络实现，区别仅在于解密时，密文作为输入，并逆序使用子密钥。
3、讲解密后的明文去填充 (padding）得到的即为明文
Golang实现DES加密解密
package main

import (
"fmt"
"crypto/des"
"bytes"
"crypto/cipher"
)

func main() {
var miwen,_= DESEncode([]byte("hello world"),[]byte("12345678"))
fmt.Println(miwen) // [11 42 146 232 31 180 156 225 164 50 102 170 202 234 123 129],密文：最后5位是补码
var txt,_ = DESDecode(miwen,[]byte("12345678"))
fmt.Println(txt) // [104 101 108 108 111 32 119 111 114 108 100]明码
fmt.Printf("%s",txt) // hello world
}
// 加密函数
func DESEncode(orignData, key []byte)([]byte,error){

// 建立密码块
block ,err:=des.NewCipher(key)
if err!=nil{ return nil,err}

// 明文分组，不足的部分加padding
txt := PKCS5Padding(orignData,block.BlockSize())

// 设定加密模式,为了方便，初始向量直接使用key充当了（实际项目中，最好别这么做）
blockMode := cipher.NewCBCEncrypter(block,key)

// 创建密文长度的切片，用来存放密文字节
crypted :=make([]byte,len(txt))

// 开始加密,将txt作为源，crypted作为目的切片输入
blockMode.CryptBlocks(crypted,txt)

// 将加密后的切片返回
return crypted,nil
}
// 加密所需padding
func PKCS5Padding(ciphertext []byte,size int)[]byte{
padding := size - len(ciphertext)%size
padTex := bytes.Repeat([]byte{byte(padding)},padding)
return append(ciphertext,padTex...)
}
// 解密函数
func DESDecode(cripter, key []byte) ([]byte,error) {
// 建立密码块
block ,err:=des.NewCipher(key)
if err!=nil{ return nil,err}

// 设置解密模式，加密模式和解密模式要一样
blockMode := cipher.NewCBCDecrypter(block,key)

// 设置切片长度，用来存放明文字节
originData := make([]byte,len(cripter))

// 使用解密模式解密,将解密后的明文字节放入originData 切片中
blockMode.CryptBlocks(originData,cripter)

// 去除加密的padding部分
strByt := UnPKCS5Padding(origenData)

return strByt,nil
}
// 解密所需要的Unpadding
func UnPKCS5Padding(origin []byte) []byte{
// 获取最后一位转为整型，然后根据这个整型截取掉整型数量的长度
// 若此数为5，则减掉转换明文后的最后5位，即为我们输入的明文
var last = int(origin[len(origin)-1])
return origin[:len(origin)-last]
}
注意：在设置加密模式为CBC的时候，我们需要设置一个初始化向量，这个量的意思 在对称加密算法中，如果只有一个密钥来加密数据的话，明文中的相同文字就会也会被加密成相同的密文，这样密文和明文就有完全相同的结构，容易破解，如果给一个初始化向量，第一个明文使用初始化向量混合并加密，第二个明文用第一个明文的加密后的密文与第二个明文混合加密，这样加密出来的密文的结构则完全与明文不同，更加安全可靠。CBC模式图如下

CBC
3DES
DES 的常见变体是三重 DES，使用 168 位的密钥对资料进行三次加密的一种机制；它通常（但非始终）提供极其强大的安全性。如果三个 56 位的子元素都相同，则三重 DES 向后兼容 DES。
对比DES，发现只是换了NewTripleDESCipher。不过，需要注意的是，密钥长度必须24byte，否则直接返回错误。关于这一点，PHP中却不是这样的，只要是8byte以上就行；而java中，要求必须是24byte以上，内部会取前24byte（相当于就是24byte）。另外，初始化向量长度是8byte（目前各个语言都是如此，不是8byte会有问题）

❺ JAVA和.NET使用DES对称加密的区别

如果我说没有区别你会信吗？
但答案还真是这样，两者没有任何区别的，只不过实现的语言代码不同而已。
那么java与dot net之间的DES是否可以通用？答案也是完全通用。无论是Java的DES加密还是dot net的DES回密，均可以使用另一种语言且不限于Java或dot net解密。够明白吗？
DES其实只是一个算法，加密与解密我们都知道算法与密码是分离的。算法是公开的，都可以用，而密码是独立于算法的。所以DES在不同的语言中实现的算法根本就是一样的——也正是因为如此不管何种语言都是通用的（除非伪DES，要知道DES算法网上本身能搜到而且是一个标准，最先是由美国安全部门公开的）
再说一下，为什么有人“通”用不起来的原因。DES其实有CBC之类的参数的，也就是针对加密块选用的不同的加密手段。正是这个参数的原因，不同的语言中使用不同的参数做为默认值，所以使用默认的方式进行让两个串进行加解密肯定是不同的。DES使用一种模式（方法）加密，用另一种模式(方法）进行解密能得到正确的结果吗？一些人不怪自己的学艺不精，反说是两种语言的DES不通用（这也就是为什么网络上会出现诸多说java和dot net的DES加密方法不通用的原因）。
即便是自己使用的DES加密的代码也是通用的（前提你要遵守DES分开算法），但不要“重复实现已经实现的东西（专业术语叫造轮子）”。
附：
DES.Model属性取值
CBC 密码块链 (CBC) 模式引入了反馈。每个纯文本块在加密前，通过按位“异或”操作与前一个块的密码文本结合。这样确保了即使纯文本包含许多相同的块，这些块中的每一个也会加密为不同的密码文本块。在加密块之前，初始化向量通过按位“异或”操作与第一个纯文本块结合。如果密码文本块中有一个位出错，相应的纯文本块也将出错。此外，后面的块中与原出错位的位置相同的位也将出错。
ECB 电子密码本 (ECB) 模式分别加密每个块。这意味着任何纯文本块只要相同并且在同一消息中，或者在用相同的密钥加密的不同消息中，都将被转换成同样的密码文本块。如果要加密的纯文本包含大量重复的块，则逐块破解密码文本是可行的。另外，随时准备攻击的对手可能在您没有察觉的情况下替代和交换个别的块。如果密码文本块中有一个位出错，相应的整个纯文本块也将出错。
OFB 输出反馈 (OFB) 模式将少量递增的纯文本处理成密码文本，而不是一次处理整个块。此模式与 CFB 相似；这两种模式的唯一差别是移位寄存器的填充方式不同。如果密码文本中有一个位出错，纯文本中相应的位也将出错。但是，如果密码文本中有多余或者缺少的位，则那个位之后的纯文本都将出错。
CFB 密码反馈 (CFB) 模式将少量递增的纯文本处理成密码文本，而不是一次处理整个块。该模式使用在长度上为一个块且被分为几部分的移位寄存器。例如，如果块大小为 8 个字节，并且每次处理一个字节，则移位寄存器被分为 8 个部分。如果密码文本中有一个位出错，则一个纯文本位出错，并且移位寄存器损坏。这将导致接下来若干次递增的纯文本出错，直到出错位从移位寄存器中移出为止。
CTS 密码文本窃用 (CTS) 模式处理任何长度的纯文本并产生长度与纯文本长度匹配的密码文本。除了最后两个纯文本块外，对于所有其他块，此模式与 CBC 模式的行为相同。

DES.Padding属性的取值
None 不填充。
PKCS7 PKCS #7 填充字符串由一个字节序列组成，每个字节填充该字节序列的长度。
Zeros 填充字符串由设置为零的字节组成。
ANSIX923 ANSIX923 填充字符串由一个字节序列组成，此字节序列的最后一个字节填充字节序列的长度，其余字节均填充数字零。
ISO10126 ISO10126 填充字符串由一个字节序列组成，此字节序列的最后一个字节填充字节序列的长度，其余字节填充随机数据。

当Mode不同时，解密的内密内容能与相同吗？PaddingMode不同时，解密的内容的结尾部分能相同吗（填充结果只涉及到最后的一个块）.所以当不管何种语言使用相同的Mode及PaddingMode时，加解密的结果是相同的（当然不排除部分语言不实现全部的Mode和PaddingMode)但，基本的都是实现了的，所以基本上任何两种语言之间的DES都可以实现相同的加解密结果！而java和dot net中的DES显然指的是算法，两者是相同的，可以随意使用（Java中dot net中的Mode默认值是不同的，一定要设置相同的Mode和PaddingMode才可以的，不要双方都采用默认值，那样真的通不起来）