des-cbc 的go实现

package main

import (

    "bytes"

    "crypto/cipher"

    "crypto/des"

    "fmt"

)

/*

加密

算法：des, 分组模式：CBC

des:

密钥：8bytes

分组长度：8bytes

步骤：

1、创建并返回一个使用DES算法的cipher.Block接口。

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

2、经行数据填充 //TODO

3、分组

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

 

解密

步骤：

1、创建并返回一个使用DES算法的cipher.Block接口。

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

2、CBC分组

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

3、解密操作

4、去除填充

*/

type Block interface {

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

    BlockSize() int

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

    Encrypt(dst, src []byte)

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

    Decrypt(dst, src []byte)

}

type BlockMode interface {

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

    BlockSize() int

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

    CryptBlocks(dst, src []byte)

}

//填充函数，输入明文，分组长度，输出填充后的数据

func paddingInfo(src []byte, blockSize int) []byte {

    //1、得到明文的长度

    length := len(src)

    //2、需要填充的数据

    remians := length % blockSize

    paddnumber := blockSize - remians

    //3、把填充的数据转换为字符

    s1 := byte(paddnumber)

    //4、把字符拼接为数组

    s2 := bytes.Repeat([]byte{s1}, paddnumber)

    //5、把拼接的数组追加到src

    srcNew := append(src, s2...)

    //6、返回新的数组

    return srcNew

}

//加密：

func desCBCEncrypts(src, key []byte) []byte {

    fmt.Printf("加密开始，输入的数据为：%s\n", src)

    block, err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    src = paddingInfo(src, block.BlockSize())

    iv := bytes.Repeat([]byte("1"), block.BlockSize())

    blockMode := cipher.NewCBCEncrypter(block, iv)

    blockMode.CryptBlocks(src, src)

    fmt.Printf("加密结束，输出的数据为：%x\n", src)

    return src

}

//去除填充函数，输入密文，输出去除填充后的数据

func unpaddingInfo(plainText []byte) []byte {

    //1、得到密文的长度

    length := len(plainText)

    if length <= 0 {

        return []byte{}

    }

    //2、获取最后一个字符

    lastbyte := plainText[length-1]

    //3、把最后一个字符转换为数字

    unpaddingnumber := int(lastbyte)

    //4、去除明文中的数字

    //6、返回新的数组

    return plainText[:length-unpaddingnumber]

}

//解密：输入密文，密钥，得到明文

func desCBCDecrypts(ciperData, key []byte) []byte {

    fmt.Printf("解密开始，输入的数据为：%x\n", ciperData)

    block, err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    iv := bytes.Repeat([]byte("1"), block.BlockSize())

    blockMode := cipher.NewCBCDecrypter(block, iv)

    blockMode.CryptBlocks(ciperData, ciperData)

    plainText := unpaddingInfo(ciperData)

    fmt.Printf("解密结束，解密的数据为：%s\n", plainText)

    return plainText

}

func main() {

    src := []byte(" 不历一番寒彻骨，怎得梅香扑鼻来")

    key := []byte("12345678")

    data := desCBCEncrypts(src, key)

    fmt.Println("+++++++++++++++++++++++++++++++++++++++++++")

    msrc := desCBCDecrypts(data, key)

    fmt.Printf("解密结束，明文的数据为hex：%x\n", msrc)

}