AES 对称加密中的 ECB 实现

AES 对称加密

加密策略包含：对称、非对称、不可逆…等多种加密模式，用于密码学、工学…等多个学科领域。
互联网常规用法，是为保障核心数据的安全传输及证书鉴权采取加密策略。开源的工具包，棱角比较明显，加密对象及密钥需要符合一定的设计。【比如，位数限制…等】

这里简单介绍一下封装完毕，直接可以采用的方式。有需要的同学，可以拿去修饰使用。

ECB 算法实现

针对每个加密策略，其实拥有很多种实现方式。比如 AES 加密，有 ECB 、GCM、CBC…等多种实现算法。

今天这里介绍一种 ECB 模式实现。

package main

import (
	"fmt"
	"encoding/hex"
	"bytes"
	"crypto/aes"
)

// AesTool AES ECB模式的加密解密
type AesTool struct {
    
    
	//128 192 256位的其中一个 长度 对应分别是 16 24 32字节长度
	Key       []byte
	BlockSize int
}

func NewAesTool(key []byte, blockSize int) *AesTool {
    
    
	return &AesTool{
    
    Key: key, BlockSize: blockSize}
}

func (a *AesTool) padding(src []byte) []byte {
    
    
	if len(src)%a.BlockSize == 0 {
    
    
		//不用填充
		return src
	}

	//填充个数
	paddingCount := a.BlockSize - len(src)%a.BlockSize
	//填充数据
	return append(src, bytes.Repeat([]byte{
    
    byte(0)}, paddingCount)...)
}

func (a *AesTool) unPadding(src []byte) []byte {
    
    
	for i := len(src) - 1; i >= 0; i-- {
    
    
		if src[i] != 0 {
    
    
			return src[:i+1]
		}
	}
	return nil
}

func (a *AesTool) Encrypt(src []byte) ([]byte, error) {
    
    
	//key只能是 16 24 32长度
	block, err := aes.NewCipher([]byte(a.Key))
	if err != nil {
    
    
		return nil, err
	}
	//padding
	src = a.padding(src)

	//返回加密结果
	encryptData := make([]byte, 0, len(src))
	//存储每次加密的数据
	tmpData := make([]byte, a.BlockSize)

	//分组分块加密
	for index := 0; index < len(src); index += a.BlockSize {
    
    
		block.Encrypt(tmpData, src[index:index+a.BlockSize])
		encryptData = append(encryptData, tmpData...)
	}
	return encryptData, nil
}

func (a *AesTool) Decrypt(src []byte) ([]byte, error) {
    
    
	//key只能是 16 24 32长度
	block, err := aes.NewCipher([]byte(a.Key))
	if err != nil {
    
    
		return nil, err
	}
	//返回加密结果
	decryptData := make([]byte, 0, len(src))
	//存储每次加密的数据
	dst := make([]byte, a.BlockSize)

	if len(src)%a.BlockSize != 0 {
    
    
		return nil, nil
	}

	//分组分块解密
	for index := 0; index < len(src); index += a.BlockSize {
    
    
		block.Decrypt(dst, src[index:index+a.BlockSize])
		decryptData = append(decryptData, dst...)
	}

	if len(decryptData) != len(src) {
    
    
		return nil, nil
	}
	return a.unPadding(decryptData), nil
}

func ECBDecrypter(appKey, param string) (string, error) {
    
    
	encMarkHex, _ := hex.DecodeString(param)
	key, encryptData := []byte(appKey), encMarkHex
	tool := NewAesTool(key, 16)
	decryptData, err := tool.Decrypt(encryptData)
	if err != nil {
    
    
		return "", err
	}
	return string(decryptData), nil
}

func ECBEncrypter(appKey, param string) ([]byte, error) {
    
    
	key, originData := []byte(appKey), []byte(param)
	tool := NewAesTool(key, 16)
	encryptData, err := tool.Encrypt(originData)
	if err != nil {
    
    
		return nil, err
	}
	return encryptData, nil
}
func main() {
    
    
    key := "QUAHSOJKDJSKDJXH"
    arm := "hello world"

	ciphertext, _ := ECBEncrypter(key, arm)
	screat := hex.EncodeToString(ciphertext)

	fmt.Println(screat)

	plaintext, _ := ECBDecrypter(key, screat)
	fmt.Println(plaintext)
}

加密实例

2ca4e82ac182a25862bdf704f7c40e67 //密文
hello world //明文