go使用des加密

发表于 | 更新于: 2021-09-27 | 分类于
字数统计: 1.4k | 阅读时长 ≈ 6 | 评论: | 阅读:

一、DES算法简介

DES(Data Encryption Standard)是一种常见的分组加密算法，由IBM公司在1971年提出。它是一种对称加密算法，也就是说它使用同一个密钥来加密和解密数据。

二、密钥

DES使用一个56位的初始密钥，但是这里提供的是一个64位的值，这是因为在硬件实现中每8位可以用于奇偶校验。可以通过设定8位字符串，由crypto/des库的des.NewCipher(key)函数生成密钥

三、填充算法

DES分组的大小是64位，如果加密的数据长度不是64位的倍数，可以按照某种具体的规则来填充位。常用的填充算法有pkcs5，zero等

pkcs5填充

//pkcs5补码算法
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
    padding := blockSize - len(ciphertext)%blockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}

//pkcs5减码算法
func pkcs5UnPadding(origData []byte) []byte {
    length := len(origData)
    unpadding := int(origData[length-1])
    return origData[:(length - unpadding)]
}

zero填充

//zero补码算法
func zeroPadding(ciphertext []byte, blockSize int) []byte {
    padding := blockSize - len(ciphertext)%blockSize
    padtext := bytes.Repeat([]byte{0}, padding)
    return append(ciphertext, padtext...)
}

//zero减码算法
func zeroUnPadding(origData []byte) []byte {
    return bytes.TrimFunc(origData,
        func(r rune) bool {
            return r == rune(0)
        })
}

四、加密模式

  • 密码分组链接模式（Cipher Block Chaining，简称CBC）：是一种循环模式，前一个分组的密文和当前分组的明文异或操作后再加密，这样做的目的是增强破解难度。
  • 电码本模式（Electronic Codebook Book，简称ECB）：是一种基础的加密方式，密文被分割成分组长度相等的块（不足补齐），然后单独一个个加密，一个个输出组成密文。
  • 计算器模式（Counter，简称CTR）：计算器模式不常见，在CTR模式中， 有一个自增的算子，这个算子用密钥加密之后的输出和明文异或的结果得到密文，相当于一次一密。这种加密方式简单快速，安全可靠，而且可以并行加密，但是在计算器不能维持很长的情况下，密钥只能使用一次。
  • 输出反馈模式（Output FeedBack，简称OFB）：实际上是一种反馈模式，目的也是增强破解的难度。
  • 密码反馈模式（Cipher FeedBack，简称CFB）：实际上是一种反馈模式，目的也是增强破解的难度。
//---------------DES ECB加密--------------------
// data: 明文数据
// key: 密钥字符串
// 返回密文数据
func DesECBEncrypt(data, key []byte) []byte {
    //NewCipher创建一个新的加密块
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    bs := block.BlockSize()
    // pkcs5填充
    data = pkcs5Padding(data, bs)
    if len(data)%bs != 0 {
        return nil
    }

    out := make([]byte, len(data))
    dst := out
    for len(data) > 0 {
        //Encrypt加密第一个块，将其结果保存到dst
        block.Encrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }
    return out
}

//---------------DES ECB解密--------------------
// data: 密文数据
// key: 密钥字符串
// 返回明文数据
func DesECBDecrypter(data, key []byte) []byte {
    //NewCipher创建一个新的加密块
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    bs := block.BlockSize()
    if len(data)%bs != 0 {
        return nil
    }

    out := make([]byte, len(data))
    dst := out
    for len(data) > 0 {
        //Encrypt加密第一个块，将其结果保存到dst
        block.Decrypt(dst, data[:bs])
        data = data[bs:]
        dst = dst[bs:]
    }

    // pkcs5填充
    out = pkcs5UnPadding(out)

    return out
}

//---------------DES CBC加密--------------------
// data: 明文数据
// key: 密钥字符串
// iv:iv向量
// 返回密文数据
func DesCBCEncrypt(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    // pkcs5填充
    data = pkcs5Padding(data, block.BlockSize())
    cryptText := make([]byte, len(data))

    blockMode := cipher.NewCBCEncrypter(block, iv)
    blockMode.CryptBlocks(cryptText, data)
    return cryptText
}

//---------------DES CBC解密--------------------
// data: 密文数据
// key: 密钥字符串
// iv:iv向量
// 返回明文数据
func DesCBCDecrypter(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    blockMode := cipher.NewCBCDecrypter(block, iv)
    cryptText := make([]byte, len(data))
    blockMode.CryptBlocks(cryptText, data)
    // pkcs5填充
    cryptText = pkcs5UnPadding(cryptText)

    return cryptText
}

//---------------DES CTR加密--------------------
// data: 明文数据
// key: 密钥字符串
// iv:iv向量
// 返回密文数据
func DesCTREncrypt(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    // pkcs5填充
    data = pkcs5Padding(data, block.BlockSize())
    cryptText := make([]byte, len(data))

    blockMode := cipher.NewCTR(block, iv)
    blockMode.XORKeyStream(cryptText, data)
    return cryptText
}

//---------------DES CTR解密--------------------
// data: 密文数据
// key: 密钥字符串
// iv:iv向量
// 返回明文数据
func DesCTRDecrypter(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    blockMode := cipher.NewCTR(block, iv)
    cryptText := make([]byte, len(data))
    blockMode.XORKeyStream(cryptText, data)

    // pkcs5填充
    cryptText = pkcs5UnPadding(cryptText)

    return cryptText
}

//---------------DES OFB加密--------------------
// data: 明文数据
// key: 密钥字符串
// iv:iv向量
// 返回密文数据
func DesOFBEncrypt(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    // pkcs5填充
    data = pkcs5Padding(data, block.BlockSize())
    cryptText := make([]byte, len(data))

    blockMode := cipher.NewOFB(block, iv)
    blockMode.XORKeyStream(cryptText, data)
    return cryptText
}

//---------------DES OFB解密--------------------
// data: 密文数据
// key: 密钥字符串
// iv:iv向量
// 返回明文数据
func DesOFBDecrypter(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    blockMode := cipher.NewOFB(block, iv)
    cryptText := make([]byte, len(data))
    blockMode.XORKeyStream(cryptText, data)

    // pkcs5填充
    cryptText = pkcs5UnPadding(cryptText)

    return cryptText
}

//---------------DES CFB加密--------------------
// data: 明文数据
// key: 密钥字符串
// iv:iv向量
// 返回密文数据
func DesCFBEncrypt(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    // pkcs5填充
    data = pkcs5Padding(data, block.BlockSize())
    cryptText := make([]byte, len(data))

    blockMode := cipher.NewCFBDecrypter(block, iv)
    blockMode.XORKeyStream(cryptText, data)
    return cryptText
}

//---------------DES CFB解密--------------------
// data: 密文数据
// key: 密钥字符串
// iv:iv向量
// 返回明文数据
func DesCFBDecrypter(data, key, iv []byte) []byte {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil
    }

    blockMode := cipher.NewCFBEncrypter(block, iv)
    cryptText := make([]byte, len(data))
    blockMode.XORKeyStream(cryptText, data)

    // pkcs5填充
    cryptText = pkcs5UnPadding(cryptText)

    return cryptText
}

五、测试

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

func main() {
    key := []byte("12345678")
    src := []byte("这是需要加密的明文哦！")

    // ECB 加密
    cipher := DesECBEncrypt(src, key)

    // 转base64
    bs64 := base64.StdEncoding.EncodeToString(cipher)
    fmt.Println(bs64)

    // 转回byte
    bt, err := base64.StdEncoding.DecodeString(bs64)
    if err != nil {
        fmt.Println("base64转换失败")
    }
    // ECB 解密
    str := DesECBEncrypt(bt, key)
    fmt.Println(str)
}
0%