完善其他类型的加解密

aesx/aesx.go

@@ -9,46 +9,116 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"strings"
 )
 
-func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
+// AES-256-ECB 加密,返回大写的十六进制字符串
-	padding := blockSize - len(ciphertext)%blockSize
+func EncryptECBHex(input, key string) (string, error) {
-	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	// 创建AES加密器
-	return append(ciphertext, padtext...)
+	block, err := aes.NewCipher([]byte(key))
-}
-
-func PKCS7UnPadding(origData []byte) []byte {
-	length := len(origData)
-	unpadding := int(origData[length-1])
-	return origData[:(length - unpadding)]
-}
-
-// AES加密,CBC
-func AesEncrypt(origData, key []byte) ([]byte, error) {
-	block, err := aes.NewCipher(key)
 	if err != nil {
-		return nil, err
+		return "", err
+	}
+
+	// 对输入数据进行PKCS7填充
+	paddedInput := PKCS7Padding([]byte(input), block.BlockSize())
+
+	// ECB模式加密
+	encrypted := make([]byte, len(paddedInput))
+	for i := 0; i < len(paddedInput); i += aes.BlockSize {
+		block.Encrypt(encrypted[i:i+aes.BlockSize], paddedInput[i:i+aes.BlockSize])
+	}
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(encrypted)
+	return strings.ToUpper(result), nil
+}
+
+// AES-256-ECB 解密,输入大写的十六进制字符串
+func DecryptECBHex(encryptedHex, key string) (string, error) {
+	encrypted, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", fmt.Errorf("创建AES解密器失败: %v", err)
+	}
+
+	// ECB模式解密
+	decrypted := make([]byte, len(encrypted))
+	for i := 0; i < len(encrypted); i += aes.BlockSize {
+		block.Decrypt(decrypted[i:i+aes.BlockSize], encrypted[i:i+aes.BlockSize])
+	}
+
+	// 去除PKCS7填充
+	unpaddedData, err := PKCS7UnPadding(decrypted)
+	if err != nil {
+		return "", fmt.Errorf("去除填充失败: %v", err)
+	}
+	return string(unpaddedData), nil
+}
+
+// AES-256-CBC 加密
+func EncryptCBCHex(plaintext, key string) (string, error) {
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
 	}
 	blockSize := block.BlockSize()
-	origData = PKCS7Padding(origData, blockSize)
+	plainBytes := PKCS7Padding([]byte(plaintext), blockSize)
-	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+
-	crypted := make([]byte, len(origData))
+	// 创建密文字节切片，包含IV空间
-	blockMode.CryptBlocks(crypted, origData)
+	cipherbyte := make([]byte, aes.BlockSize+len(plainBytes))
-	return crypted, nil
+
+	// 生成随机IV
+	iv := cipherbyte[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CBC模式加密器
+	blockMode := cipher.NewCBCEncrypter(block, iv)
+
+	// 加密数据
+	blockMode.CryptBlocks(cipherbyte[aes.BlockSize:], plainBytes)
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
 }
 
-// AES解密
+// AES-256-CBC 解密
-func AesDecrypt(crypted, key []byte) ([]byte, error) {
+func DecryptCBCHex(encryptedHex, key string) (string, error) {
-	block, err := aes.NewCipher(key)
+	cipherbyte, err := hex.DecodeString(encryptedHex)
 	if err != nil {
-		return nil, err
+		return "", fmt.Errorf("hex解码失败: %v", err)
 	}
-	blockSize := block.BlockSize()
+
-	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+	if len(cipherbyte) < aes.BlockSize {
-	origData := make([]byte, len(crypted))
+		return "", errors.New("ciphertext too short")
-	blockMode.CryptBlocks(origData, crypted)
+	}
-	origData = PKCS7UnPadding(origData)
+
-	return origData, nil
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	iv := cipherbyte[:aes.BlockSize]
+	cipherbyte = cipherbyte[aes.BlockSize:]
+	if len(cipherbyte)%aes.BlockSize != 0 {
+		return "", errors.New("ciphertext is not a multiple of the block size")
+	}
+
+	blockMode := cipher.NewCBCDecrypter(block, iv)
+	origData := make([]byte, len(cipherbyte))
+	blockMode.CryptBlocks(origData, cipherbyte)
+	origBy, err := PKCS7UnPadding(origData)
+	if err != nil {
+		return "", err
+	}
+	return string(origBy), nil
 }
 
 /*
@@ -81,12 +151,10 @@ func AESCBCEncrypt(key, plaintext string) (ciphertext string, err error) {
 	return
 }
 
-/*
+// AES  CBC 解码
-AES  CBC 解码
+// key:解密key
-key:解密key
+// ciphertext:加密返回的串
-ciphertext:加密返回的串
+// plaintext：解密后的字符串
-plaintext：解密后的字符串
-*/
 func AESCBCDecrypter(key, ciphertext string) (plaintext string, err error) {
 	cipherbyte, _ := hex.DecodeString(ciphertext)
 	keybyte := []byte(key)
@@ -112,13 +180,11 @@ func AESCBCDecrypter(key, ciphertext string) (plaintext string, err error) {
 	return
 }
 
-/*
+// AES  GCM 加密
-AES  GCM 加密
+// key:加密key
-key:加密key
+// plaintext：加密明文
-plaintext：加密明文
+// ciphertext:解密返回字节字符串[ 整型以十六进制方式显示]
-ciphertext:解密返回字节字符串[ 整型以十六进制方式显示]
+func EncryptGCM(key, plaintext string) (ciphertext, noncetext string, err error) {
-*/
-func AESGCMEncrypt(key, plaintext string) (ciphertext, noncetext string, err error) {
 	plainbyte := []byte(plaintext)
 	keybyte := []byte(key)
 	block, err := aes.NewCipher(keybyte)
@@ -143,13 +209,11 @@ func AESGCMEncrypt(key, plaintext string) (ciphertext, noncetext string, err err
 	return
 }
 
-/*
+// AES  GCM 解码
-AES  GCM 解码
+// key:解密key
-key:解密key
+// ciphertext:加密返回的串
-ciphertext:加密返回的串
+// plaintext：解密后的字符串
-plaintext：解密后的字符串
+func DecryptGCM(key, ciphertext, noncetext string) (plaintext string, err error) {
-*/
-func AESGCMDecrypter(key, ciphertext, noncetext string) (plaintext string, err error) {
 	cipherbyte, _ := hex.DecodeString(ciphertext)
 	nonce, _ := hex.DecodeString(noncetext)
 	keybyte := []byte(key)
@@ -172,3 +236,136 @@ func AESGCMDecrypter(key, ciphertext, noncetext string) (plaintext string, err e
 	plaintext = string(plainbyte[:])
 	return
 }
+
+// AES CFB 加密
+func EncryptCFBHex(plaintext, key string) (string, error) {
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, aes.BlockSize+len(plaintext))
+
+	// 生成随机IV
+	iv := cipherbyte[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CFB模式加密器
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(cipherbyte[aes.BlockSize:], []byte(plaintext))
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// AES CFB 解密
+func DecryptCFBHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < aes.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 获取IV
+	iv := cipherbyte[:aes.BlockSize]
+	cipherbyte = cipherbyte[aes.BlockSize:]
+
+	// 创建CFB模式解密器
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(cipherbyte, cipherbyte)
+
+	return string(cipherbyte), nil
+}
+
+// AES OFB 加密
+func EncryptOFBHex(plaintext, key string) (string, error) {
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, aes.BlockSize+len(plaintext))
+
+	// 生成随机IV
+	iv := cipherbyte[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建OFB模式加密器
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(cipherbyte[aes.BlockSize:], []byte(plaintext))
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// AES OFB 解密
+func DecryptOFBHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < aes.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := aes.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 获取IV
+	iv := cipherbyte[:aes.BlockSize]
+	cipherbyte = cipherbyte[aes.BlockSize:]
+
+	// 创建OFB模式解密器
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(cipherbyte, cipherbyte)
+
+	return string(cipherbyte), nil
+}
+
+// PKCS7补码
+func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+// 去除PKCS7补码
+func PKCS7UnPadding(data []byte) ([]byte, error) {
+	length := len(data)
+	if length == 0 {
+		return nil, errors.New("ciphertext is empty")
+	}
+
+	unpadding := int(data[length-1])
+	if unpadding > length || unpadding == 0 {
+		return nil, errors.New("unpadding size is invalid")
+	}
+
+	// 检查填充是否正确
+	for i := length - unpadding; i < length; i++ {
+		if data[i] != byte(unpadding) {
+			return nil, errors.New("invalid padding")
+		}
+	}
+
+	return data[:(length - unpadding)], nil
+}

aesx/aesx_test.go

@@ -7,7 +7,7 @@ import (
 	"code.yun.ink/pkg/encryptx/aesx"
 )
 
-func TestAes(t *testing.T) {
+func TestGCM(t *testing.T) {
 	key := "example key 1234"
 	plaintext := "exampleplaintext"
 
@@ -21,16 +21,97 @@ func TestAes(t *testing.T) {
 	fmt.Println(plaintext, err)
 	///GCM
 	noncetext := ""
-	ciphertext, noncetext, err = aesx.AESGCMEncrypt(key, plaintext)
+	ciphertext, noncetext, err = aesx.EncryptGCM(key, plaintext)
 	fmt.Println(ciphertext, err)
 
-	plaintext, err = aesx.AESGCMDecrypter(key, ciphertext, noncetext)
+	plaintext, err = aesx.DecryptGCM(key, ciphertext, noncetext)
 	fmt.Println(plaintext, err)
 }
 
-func TestDemo(t *testing.T) {
+func TestECB(t *testing.T) {
-	c := []byte("08I2GfoqfIlUYgteelimxQ")
+	key := "example key 1234"
-	c := []byte("rRq++jXDMPDVcUkXAZA9kg==:o57DgQ+iQMXpERuShWs/XA==")
+	plaintext := "exampleplaintext"
-	a,e := aesx.AesDecrypt(c, k)
+	
-	fmt.Println(a,e)
+	// 测试ECB加密和解密
+	encrypted, err := aesx.EncryptECBHex(plaintext, key)
+	if err != nil {
+		t.Fatalf("ECB加密失败: %v", err)
+	}
+	fmt.Printf("ECB加密结果: %s\n", encrypted)
+
+	decrypted, err := aesx.DecryptECBHex(encrypted, key)
+	if err != nil {
+		t.Fatalf("ECB解密失败: %v", err)
+	}
+	fmt.Printf("ECB解密结果: %s\n", decrypted)
+
+	if decrypted != plaintext {
+		t.Fatalf("ECB解密结果不匹配，原文: %s, 解密结果: %s", plaintext, decrypted)
+	}
+}
+
+func TestCBC(t *testing.T) {
+	key := "example key 1234"
+	plaintext := "exampleplaintext"
+
+	// 测试CBC加密和解密
+	encrypted, err := aesx.EncryptCBCHex(plaintext, key)
+	if err != nil {
+		t.Fatalf("CBC加密失败: %v", err)
+	}
+	fmt.Printf("CBC加密结果: %s\n", encrypted)
+
+	decrypted, err := aesx.DecryptCBCHex(encrypted, key)
+	if err != nil {
+		t.Fatalf("CBC解密失败: %v", err)
+	}
+	fmt.Printf("CBC解密结果: %s\n", decrypted)
+
+	if decrypted != plaintext {
+		t.Fatalf("CBC解密结果不匹配，原文: %s, 解密结果: %s", plaintext, decrypted)
+	}
+}
+
+func TestCFB(t *testing.T) {
+	key := "example key 1234"
+	plaintext := "exampleplaintext"
+
+	// 测试CFB加密和解密
+	encrypted, err := aesx.EncryptCFBHex(plaintext, key)
+	if err != nil {
+		t.Fatalf("CFB加密失败: %v", err)
+	}
+	fmt.Printf("CFB加密结果: %s\n", encrypted)
+
+	decrypted, err := aesx.DecryptCFBHex(encrypted, key)
+	if err != nil {
+		t.Fatalf("CFB解密失败: %v", err)
+	}
+	fmt.Printf("CFB解密结果: %s\n", decrypted)
+
+	if decrypted != plaintext {
+		t.Fatalf("CFB解密结果不匹配，原文: %s, 解密结果: %s", plaintext, decrypted)
+	}
+}
+
+func TestOFB(t *testing.T) {
+	key := "example key 1234"
+	plaintext := "exampleplaintext"
+
+	// 测试OFB加密和解密
+	encrypted, err := aesx.EncryptOFBHex(plaintext, key)
+	if err != nil {
+		t.Fatalf("OFB加密失败: %v", err)
+	}
+	fmt.Printf("OFB加密结果: %s\n", encrypted)
+
+	decrypted, err := aesx.DecryptOFBHex(encrypted, key)
+	if err != nil {
+		t.Fatalf("OFB解密失败: %v", err)
+	}
+	fmt.Printf("OFB解密结果: %s\n", decrypted)
+
+	if decrypted != plaintext {
+		t.Fatalf("OFB解密结果不匹配，原文: %s, 解密结果: %s", plaintext, decrypted)
+	}
 }

desx/desx.go

@@ -0,0 +1,203 @@
+package desx
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// DES-ECB 加密,返回大写的十六进制字符串
+func EncryptECBHex(input, key string) (string, error) {
+	// 创建DES加密器
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 对输入数据进行PKCS7填充
+	paddedInput := PKCS7Padding([]byte(input), block.BlockSize())
+
+	// ECB模式加密
+	encrypted := make([]byte, len(paddedInput))
+	for i := 0; i < len(paddedInput); i += des.BlockSize {
+		block.Encrypt(encrypted[i:i+des.BlockSize], paddedInput[i:i+des.BlockSize])
+	}
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(encrypted)
+	return strings.ToUpper(result), nil
+}
+
+// DES-ECB 解密,输入大写的十六进制字符串
+func DecryptECBHex(encryptedHex, key string) (string, error) {
+	encrypted, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", fmt.Errorf("创建DES解密器失败: %v", err)
+	}
+
+	// ECB模式解密
+	decrypted := make([]byte, len(encrypted))
+	for i := 0; i < len(encrypted); i += des.BlockSize {
+		block.Decrypt(decrypted[i:i+des.BlockSize], encrypted[i:i+des.BlockSize])
+	}
+
+	// 去除PKCS7填充
+	unpaddedData, err := PKCS7UnPadding(decrypted)
+	if err != nil {
+		return "", fmt.Errorf("去除填充失败: %v", err)
+	}
+	return string(unpaddedData), nil
+}
+
+// DES-CBC 加密
+func EncryptCBCHex(plaintext, key string) (string, error) {
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+	blockSize := block.BlockSize()
+	plainBytes := PKCS7Padding([]byte(plaintext), blockSize)
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, des.BlockSize+len(plainBytes))
+
+	// 生成随机IV
+	iv := cipherbyte[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CBC模式加密器
+	blockMode := cipher.NewCBCEncrypter(block, iv)
+
+	// 加密数据
+	blockMode.CryptBlocks(cipherbyte[des.BlockSize:], plainBytes)
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// DES-CBC 解密
+func DecryptCBCHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < des.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	iv := cipherbyte[:des.BlockSize]
+	cipherbyte = cipherbyte[des.BlockSize:]
+	if len(cipherbyte)%des.BlockSize != 0 {
+		return "", errors.New("ciphertext is not a multiple of the block size")
+	}
+
+	blockMode := cipher.NewCBCDecrypter(block, iv)
+	origData := make([]byte, len(cipherbyte))
+	blockMode.CryptBlocks(origData, cipherbyte)
+	origBy, err := PKCS7UnPadding(origData)
+	if err != nil {
+		return "", err
+	}
+	return string(origBy), nil
+}
+
+// DES-CFB 加密
+func EncryptCFBHex(plaintext, key string) (string, error) {
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, des.BlockSize+len(plaintext))
+
+	// 生成随机IV
+	iv := cipherbyte[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CFB模式加密器
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(cipherbyte[des.BlockSize:], []byte(plaintext))
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// DES-CFB 解密
+func DecryptCFBHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < des.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := des.NewCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 获取IV
+	iv := cipherbyte[:des.BlockSize]
+	cipherbyte = cipherbyte[des.BlockSize:]
+
+	// 创建CFB模式解密器
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(cipherbyte, cipherbyte)
+
+	return string(cipherbyte), nil
+}
+
+// PKCS7补码
+func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+// 去除PKCS7补码
+func PKCS7UnPadding(data []byte) ([]byte, error) {
+	length := len(data)
+	if length == 0 {
+		return nil, errors.New("ciphertext is empty")
+	}
+
+	unpadding := int(data[length-1])
+	if unpadding > length || unpadding == 0 {
+		return nil, errors.New("unpadding size is invalid")
+	}
+
+	// 检查填充是否正确
+	for i := length - unpadding; i < length; i++ {
+		if data[i] != byte(unpadding) {
+			return nil, errors.New("invalid padding")
+		}
+	}
+
+	return data[:(length - unpadding)], nil
+}

hmacx/hmacx.go

@@ -0,0 +1,22 @@
+package hmacx
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/hex"
+)
+
+// HMAC-SHA256 计算消息认证码
+func HMACSHA256(message, key string) string {
+	mac := hmac.New(sha256.New, []byte(key))
+	mac.Write([]byte(message))
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+// HMAC-SHA512 计算消息认证码
+func HMACSHA512(message, key string) string {
+	mac := hmac.New(sha512.New, []byte(key))
+	mac.Write([]byte(message))
+	return hex.EncodeToString(mac.Sum(nil))
+}

pbkdf2x/pbkdf2x.go

@@ -0,0 +1,66 @@
+package pbkdf2x
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+
+	"golang.org/x/crypto/pbkdf2"
+)
+
+// GenerateSalt 生成随机盐值
+func GenerateSalt(length int) (string, error) {
+	if length <= 0 {
+		return "", fmt.Errorf("盐值长度必须大于0")
+	}
+
+	salt := make([]byte, length)
+	_, err := rand.Read(salt)
+	if err != nil {
+		return "", fmt.Errorf("生成盐值失败: %v", err)
+	}
+
+	return hex.EncodeToString(salt), nil
+}
+
+// DeriveKeyFromPassword 使用PBKDF2从密码派生密钥
+// password: 原始密码
+// saltHex: 十六进制格式的盐值
+// iterations: 迭代次数，推荐至少10000次
+// keyLength: 派生密钥的长度（字节）
+func DeriveKeyFromPassword(password, saltHex string, iterations, keyLength int) (string, error) {
+	// 解码盐值
+	salt, err := hex.DecodeString(saltHex)
+	if err != nil {
+		return "", fmt.Errorf("盐值解码失败: %v", err)
+	}
+
+	// 使用PBKDF2派生密钥
+	key := pbkdf2.Key([]byte(password), salt, iterations, keyLength, sha256.New)
+
+	// 返回十六进制格式的密钥
+	return hex.EncodeToString(key), nil
+}
+
+// DeriveKeyFromPasswordWithRandomSalt 使用PBKDF2从密码派生密钥，并自动生成随机盐值
+// password: 原始密码
+// saltLength: 盐值长度（字节）
+// iterations: 迭代次数，推荐至少10000次
+// keyLength: 派生密钥的长度（字节）
+// 返回值: 密钥(十六进制), 盐值(十六进制), 错误
+func DeriveKeyFromPasswordWithRandomSalt(password string, saltLength, iterations, keyLength int) (string, string, error) {
+	// 生成随机盐值
+	saltHex, err := GenerateSalt(saltLength)
+	if err != nil {
+		return "", "", err
+	}
+
+	// 派生密钥
+	keyHex, err := DeriveKeyFromPassword(password, saltHex, iterations, keyLength)
+	if err != nil {
+		return "", "", err
+	}
+
+	return keyHex, saltHex, nil
+}

tdesx/tdesx.go

@@ -0,0 +1,203 @@
+package tdesx
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// 3DES-ECB 加密,返回大写的十六进制字符串
+func EncryptECBHex(input, key string) (string, error) {
+	// 创建3DES加密器
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 对输入数据进行PKCS7填充
+	paddedInput := PKCS7Padding([]byte(input), block.BlockSize())
+
+	// ECB模式加密
+	encrypted := make([]byte, len(paddedInput))
+	for i := 0; i < len(paddedInput); i += des.BlockSize {
+		block.Encrypt(encrypted[i:i+des.BlockSize], paddedInput[i:i+des.BlockSize])
+	}
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(encrypted)
+	return strings.ToUpper(result), nil
+}
+
+// 3DES-ECB 解密,输入大写的十六进制字符串
+func DecryptECBHex(encryptedHex, key string) (string, error) {
+	encrypted, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", fmt.Errorf("创建3DES解密器失败: %v", err)
+	}
+
+	// ECB模式解密
+	decrypted := make([]byte, len(encrypted))
+	for i := 0; i < len(encrypted); i += des.BlockSize {
+		block.Decrypt(decrypted[i:i+des.BlockSize], encrypted[i:i+des.BlockSize])
+	}
+
+	// 去除PKCS7填充
+	unpaddedData, err := PKCS7UnPadding(decrypted)
+	if err != nil {
+		return "", fmt.Errorf("去除填充失败: %v", err)
+	}
+	return string(unpaddedData), nil
+}
+
+// 3DES-CBC 加密
+func EncryptCBCHex(plaintext, key string) (string, error) {
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+	blockSize := block.BlockSize()
+	plainBytes := PKCS7Padding([]byte(plaintext), blockSize)
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, des.BlockSize+len(plainBytes))
+
+	// 生成随机IV
+	iv := cipherbyte[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CBC模式加密器
+	blockMode := cipher.NewCBCEncrypter(block, iv)
+
+	// 加密数据
+	blockMode.CryptBlocks(cipherbyte[des.BlockSize:], plainBytes)
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// 3DES-CBC 解密
+func DecryptCBCHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < des.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	iv := cipherbyte[:des.BlockSize]
+	cipherbyte = cipherbyte[des.BlockSize:]
+	if len(cipherbyte)%des.BlockSize != 0 {
+		return "", errors.New("ciphertext is not a multiple of the block size")
+	}
+
+	blockMode := cipher.NewCBCDecrypter(block, iv)
+	origData := make([]byte, len(cipherbyte))
+	blockMode.CryptBlocks(origData, cipherbyte)
+	origBy, err := PKCS7UnPadding(origData)
+	if err != nil {
+		return "", err
+	}
+	return string(origBy), nil
+}
+
+// 3DES-CFB 加密
+func EncryptCFBHex(plaintext, key string) (string, error) {
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 创建密文字节切片，包含IV空间
+	cipherbyte := make([]byte, des.BlockSize+len(plaintext))
+
+	// 生成随机IV
+	iv := cipherbyte[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return "", err
+	}
+
+	// 创建CFB模式加密器
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(cipherbyte[des.BlockSize:], []byte(plaintext))
+
+	// 转换为十六进制并大写
+	result := hex.EncodeToString(cipherbyte)
+	return strings.ToUpper(result), nil
+}
+
+// 3DES-CFB 解密
+func DecryptCFBHex(encryptedHex, key string) (string, error) {
+	cipherbyte, err := hex.DecodeString(encryptedHex)
+	if err != nil {
+		return "", fmt.Errorf("hex解码失败: %v", err)
+	}
+
+	if len(cipherbyte) < des.BlockSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	block, err := des.NewTripleDESCipher([]byte(key))
+	if err != nil {
+		return "", err
+	}
+
+	// 获取IV
+	iv := cipherbyte[:des.BlockSize]
+	cipherbyte = cipherbyte[des.BlockSize:]
+
+	// 创建CFB模式解密器
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(cipherbyte, cipherbyte)
+
+	return string(cipherbyte), nil
+}
+
+// PKCS7补码
+func PKCS7Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+// 去除PKCS7补码
+func PKCS7UnPadding(data []byte) ([]byte, error) {
+	length := len(data)
+	if length == 0 {
+		return nil, errors.New("ciphertext is empty")
+	}
+
+	unpadding := int(data[length-1])
+	if unpadding > length || unpadding == 0 {
+		return nil, errors.New("unpadding size is invalid")
+	}
+
+	// 检查填充是否正确
+	for i := length - unpadding; i < length; i++ {
+		if data[i] != byte(unpadding) {
+			return nil, errors.New("invalid padding")
+		}
+	}
+
+	return data[:(length - unpadding)], nil
+}