chore: add some comments

Author: leeqvip

3des.go

@@ -2,7 +2,7 @@ package openssl
 
 import "crypto/des"
 
-// Des3ECBEncrypt
+// Des3ECBEncrypt encrypts data using the ECB mode of the 3DES algorithm.
 func Des3ECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := des.NewTripleDESCipher(key)
 	if err != nil {
@@ -11,7 +11,7 @@ func Des3ECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBEncrypt(block, src, padding)
 }
 
-// Des3ECBDecrypt
+// Des3ECBDecrypt decrypts data using the ECB mode of the 3DES algorithm.
 func Des3ECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := des.NewTripleDESCipher(key)
 	if err != nil {
@@ -21,7 +21,7 @@ func Des3ECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBDecrypt(block, src, padding)
 }
 
-// Des3CBCEncrypt
+// Des3CBCEncrypt encrypts data using the CBC mode of the 3DES algorithm.
 func Des3CBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := des.NewTripleDESCipher(key)
 	if err != nil {
@@ -31,7 +31,7 @@ func Des3CBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	return CBCEncrypt(block, src, iv, padding)
 }
 
-// Des3CBCDecrypt
+// Des3CBCDecrypt decrypts data using the CBC mode of the 3DES algorithm.
 func Des3CBCDecrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := des.NewTripleDESCipher(key)
 	if err != nil {

aes.go

@@ -6,7 +6,7 @@ import (
 	"crypto/cipher"
 )
 
-// AesECBEncrypt
+// AesECBEncrypt encrypts data using the ECB mode of the AES algorithm.
 func AesECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := AesNewCipher(key)
 	if err != nil {
@@ -15,7 +15,7 @@ func AesECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBEncrypt(block, src, padding)
 }
 
-// AesECBDecrypt
+// AesECBDecrypt decrypts data using the ECB mode of the AES algorithm.
 func AesECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := AesNewCipher(key)
 	if err != nil {
@@ -25,7 +25,7 @@ func AesECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBDecrypt(block, src, padding)
 }
 
-// AesCBCEncrypt
+// AesCBCEncrypt encrypts data using the CBC mode of the AES algorithm.
 func AesCBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := AesNewCipher(key)
 	if err != nil {
@@ -35,7 +35,7 @@ func AesCBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	return CBCEncrypt(block, src, iv, padding)
 }
 
-// AesCBCDecrypt
+// AesCBCDecrypt decrypts data using the CBC mode of the AES algorithm.
 func AesCBCDecrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := AesNewCipher(key)
 	if err != nil {
@@ -45,13 +45,12 @@ func AesCBCDecrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	return CBCDecrypt(block, src, iv, padding)
 }
 
-// AesNewCipher creates and returns a new AES cipher.Block.
-// it will automatically pad the length of the key.
+// AesNewCipher creates and returns a new AES cipher block. Automatically pads the key length.
 func AesNewCipher(key []byte) (cipher.Block, error) {
 	return aes.NewCipher(aesKeyPending(key))
 }
 
-// aesKeyPending The length of the key can be 16/24/32 characters (128/192/256 bits)
+// aesKeyPending ensures the key length is 16, 24, or 32 bytes (128, 192, or 256 bits).
 func aesKeyPending(key []byte) []byte {
 	k := len(key)
 	count := 0

cbc.go

@@ -5,7 +5,7 @@ import (
 	"crypto/cipher"
 )
 
-// CBCEncrypt
+// CBCEncrypt encrypts data using the CBC (Cipher Block Chaining) mode.
 func CBCEncrypt(block cipher.Block, src, iv []byte, padding string) ([]byte, error) {
 	blockSize := block.BlockSize()
 	src = Padding(padding, src, blockSize)
@@ -24,7 +24,7 @@ func CBCEncrypt(block cipher.Block, src, iv []byte, padding string) ([]byte, err
 	return encryptData, nil
 }
 
-// CBCDecrypt
+// CBCDecrypt decrypts data using the CBC (Cipher Block Chaining) mode.
 func CBCDecrypt(block cipher.Block, src, iv []byte, padding string) ([]byte, error) {
 
 	dst := make([]byte, len(src))
@@ -41,7 +41,7 @@ func CBCDecrypt(block cipher.Block, src, iv []byte, padding string) ([]byte, err
 	return UnPadding(padding, dst)
 }
 
-// cbcIVPending auto pad length to block size
+// cbcIVPending automatically pads or truncates the IV to match the block size.
 func cbcIVPending(iv []byte, blockSize int) []byte {
 	k := len(iv)
 	if k < blockSize {

covprofile

@@ -6,7 +6,7 @@ import (
 	"crypto/des"
 )
 
-// DesECBEncrypt
+// DesECBEncrypt encrypts data using the ECB mode of the DES algorithm.
 func DesECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := DesNewCipher(key)
 	if err != nil {
@@ -15,7 +15,7 @@ func DesECBEncrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBEncrypt(block, src, padding)
 }
 
-// DesECBDecrypt
+// DesECBDecrypt decrypts data using the ECB mode of the DES algorithm.
 func DesECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	block, err := DesNewCipher(key)
 	if err != nil {
@@ -25,7 +25,7 @@ func DesECBDecrypt(src, key []byte, padding string) ([]byte, error) {
 	return ECBDecrypt(block, src, padding)
 }
 
-// DesCBCEncrypt
+// DesCBCEncrypt encrypts data using the CBC mode of the DES algorithm.
 func DesCBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := DesNewCipher(key)
 	if err != nil {
@@ -35,7 +35,7 @@ func DesCBCEncrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	return CBCEncrypt(block, src, iv, padding)
 }
 
-// DesCBCDecrypt
+// DesCBCDecrypt decrypts data using the CBC mode of the DES algorithm.
 func DesCBCDecrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	block, err := DesNewCipher(key)
 	if err != nil {
@@ -45,7 +45,7 @@ func DesCBCDecrypt(src, key, iv []byte, padding string) ([]byte, error) {
 	return CBCDecrypt(block, src, iv, padding)
 }
 
-// DesNewCipher creates and returns a new DES cipher.Block.
+// DesNewCipher creates and returns a new DES cipher block, adjusting the key length if necessary.
 func DesNewCipher(key []byte) (cipher.Block, error) {
 	if len(key) < 8 {
 		key = append(key, bytes.Repeat([]byte{0}, 8-len(key))...)

des.go

@@ -4,6 +4,7 @@ import (
 	"crypto/cipher"
 )
 
+// Encrypts data using the ECB (Electronic Codebook) mode.
 func ECBEncrypt(block cipher.Block, src []byte, padding string) ([]byte, error) {
 	blockSize := block.BlockSize()
 	src = Padding(padding, src, blockSize)
@@ -16,6 +17,7 @@ func ECBEncrypt(block cipher.Block, src []byte, padding string) ([]byte, error)
 	return encryptData, nil
 }
 
+// Decrypts data using the ECB (Electronic Codebook) mode.
 func ECBDecrypt(block cipher.Block, src []byte, padding string) ([]byte, error) {
 	dst := make([]byte, len(src))
 
@@ -30,6 +32,7 @@ type ecb struct {
 	blockSize int
 }
 
+// Creates a new ECB struct.
 func newECB(b cipher.Block) *ecb {
 	return &ecb{
 		b:         b,
@@ -47,6 +50,7 @@ func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
 
 func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
 
+// Encrypts a series of blocks using the ECB mode.
 func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
 	if len(src)%x.blockSize != 0 {
 		panic("crypto/cipher: input not full blocks")
@@ -71,6 +75,7 @@ func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
 
 func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
 
+// Decrypts a series of blocks using the ECB mode.
 func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
 	if len(src)%x.blockSize != 0 {
 		panic("crypto/cipher: input not full blocks")

ecb.go

@@ -4,6 +4,7 @@ import (
 	"crypto/sha1"
 )
 
+// Generates a key based on the input data and specified block size.
 func KeyGenerator(src []byte, blockSize int) []byte {
 	hashs := SHA1(SHA1(src))
 	maxLen := len(hashs)
@@ -14,6 +15,7 @@ func KeyGenerator(src []byte, blockSize int) []byte {
 	return hashs[0:blockSize]
 }
 
+// Computes the SHA-1 hash of the input data.
 func SHA1(data []byte) []byte {
 	h := sha1.New()
 	_, _ = h.Write(data)

key.go

@@ -5,14 +5,14 @@ import (
 	"encoding/hex"
 )
 
-// Md5 Calculate the md5 hash of a string
+// Calculates the MD5 hash of a given string.
 func Md5(str string) []byte {
 	h := md5.New()
 	_, _ = h.Write([]byte(str))
 	return h.Sum(nil)
 }
 
-// Md5ToString Calculate the md5 hash of a string, return hex string
+// Calculates the MD5 hash of a given string and returns the result as a hexadecimal string.
 func Md5ToString(str string) string {
 	return hex.EncodeToString(Md5(str))
 }

md5.go

@@ -5,12 +5,14 @@ import (
 	"errors"
 )
 
+// Error indicating an issue during the unpadding process.
 var ErrUnPadding = errors.New("UnPadding error")
 
 const PKCS5_PADDING = "PKCS5"
 const PKCS7_PADDING = "PKCS7"
 const ZEROS_PADDING = "ZEROS"
 
+// Applies the specified padding scheme to the input data.
 func Padding(padding string, src []byte, blockSize int) []byte {
 	switch padding {
 	case PKCS5_PADDING:
@@ -23,6 +25,7 @@ func Padding(padding string, src []byte, blockSize int) []byte {
 	return src
 }
 
+// Removes the specified padding from the input data.
 func UnPadding(padding string, src []byte) ([]byte, error) {
 	switch padding {
 	case PKCS5_PADDING:
@@ -35,20 +38,24 @@ func UnPadding(padding string, src []byte) ([]byte, error) {
 	return src, nil
 }
 
+// Applies PKCS5 padding to the input data. In practice, it uses PKCS7 padding.
 func PKCS5Padding(src []byte, blockSize int) []byte {
 	return PKCS7Padding(src, blockSize)
 }
 
+// Removes PKCS5 padding from the input data. In practice, it uses PKCS7 unpadding.
 func PKCS5Unpadding(src []byte) ([]byte, error) {
 	return PKCS7UnPadding(src)
 }
 
+// Applies PKCS7 padding to the input data.
 func PKCS7Padding(src []byte, blockSize int) []byte {
 	padding := blockSize - len(src)%blockSize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(src, padtext...)
 }
 
+// Removes PKCS7 padding from the input data.
 func PKCS7UnPadding(src []byte) ([]byte, error) {
 	length := len(src)
 	if length == 0 {
@@ -61,6 +68,7 @@ func PKCS7UnPadding(src []byte) ([]byte, error) {
 	return src[:(length - unpadding)], nil
 }
 
+// Applies zero padding to the input data.
 func ZerosPadding(src []byte, blockSize int) []byte {
 	paddingCount := blockSize - len(src)%blockSize
 	if paddingCount == 0 {
@@ -70,6 +78,7 @@ func ZerosPadding(src []byte, blockSize int) []byte {
 	}
 }
 
+// Removes zero padding from the input data.
 func ZerosUnPadding(src []byte) ([]byte, error) {
 	for i := len(src) - 1; ; i-- {
 		if src[i] != 0 {