bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-06 02:25:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

update comments for package gaes/gdes; update function names for gdes

Browse Source
This commit is contained in:
John
2019-09-11 23:22:15 +08:00
parent 006054d13a
commit e8a9c7ac72
3 changed files with 99 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
crypto/gaes/gaes.go
View File

@ -30,7 +30,9 @@ func Decrypt(cipherText []byte, key []byte, iv ...[]byte) ([]byte, error) {
return DecryptCBC(cipherText, key, iv...)
}
// AES加密, 使用CBC模式，注意key必须为16/24/32位长度，iv初始化向量为非必需参数。
// EncryptCBC encrypts <plainText> using CBC mode.
// Note that the key must be 16/24/32 bit length.
// The parameter <iv> initialization vector is unnecessary.
func EncryptCBC(plainText []byte, key []byte, iv ...[]byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
@ -51,7 +53,9 @@ func EncryptCBC(plainText []byte, key []byte, iv ...[]byte) ([]byte, error) {
return cipherText, nil
}
// AES解密, 使用CBC模式，注意key必须为16/24/32位长度，iv初始化向量为非必需参数
// DecryptCBC decrypts <cipherText> using CBC mode.
// Note that the key must be 16/24/32 bit length.
// The parameter <iv> initialization vector is unnecessary.
func DecryptCBC(cipherText []byte, key []byte, iv ...[]byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
@ -111,15 +115,16 @@ func PKCS5UnPadding(src []byte, blockSize int) ([]byte, error) {
return src[:(length - unpadding)], nil
}
// AES加密, 使用CFB模式。
// 注意key必须为16/24/32位长度，padding返回补位长度，iv初始化向量为非必需参数。
// EncryptCFB encrypts <plainText> using CFB mode.
// Note that the key must be 16/24/32 bit length.
// The parameter <iv> initialization vector is unnecessary.
func EncryptCFB(plainText []byte, key []byte, padding *int, iv ...[]byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
blockSize := block.BlockSize()
plainText, *padding = ZeroPadding(plainText, blockSize) //补位0
plainText, *padding = ZeroPadding(plainText, blockSize)
ivValue := ([]byte)(nil)
if len(iv) > 0 {
ivValue = iv[0]
@ -132,9 +137,10 @@ func EncryptCFB(plainText []byte, key []byte, padding *int, iv ...[]byte) ([]byt
return cipherText, nil
}
// AES解密, 使用CFB模式。
// 注意key必须为16/24/32位长度，unpadding为去补位长度，iv初始化向量为非必需参数。
func DecryptCFB(cipherText []byte, key []byte, unpadding int, iv ...[]byte) ([]byte, error) {
// DecryptCFB decrypts <plainText> using CFB mode.
// Note that the key must be 16/24/32 bit length.
// The parameter <iv> initialization vector is unnecessary.
func DecryptCFB(cipherText []byte, key []byte, unPadding int, iv ...[]byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
@ -151,17 +157,17 @@ func DecryptCFB(cipherText []byte, key []byte, unpadding int, iv ...[]byte) ([]b
stream := cipher.NewCFBDecrypter(block, ivValue)
plainText := make([]byte, len(cipherText))
stream.XORKeyStream(plainText, cipherText)
plainText = ZeroUnPadding(plainText, unpadding) //去补位0
plainText = ZeroUnPadding(plainText, unPadding)
return plainText, nil
}
func ZeroPadding(ciphertext []byte, blockSize int) ([]byte, int) {
padding := blockSize - len(ciphertext)%blockSize
padtext := bytes.Repeat([]byte{byte(0)}, padding)
return append(ciphertext, padtext...), padding
func ZeroPadding(cipherText []byte, blockSize int) ([]byte, int) {
padding := blockSize - len(cipherText)%blockSize
padText := bytes.Repeat([]byte{byte(0)}, padding)
return append(cipherText, padText...), padding
}
func ZeroUnPadding(plaintext []byte, unpadding int) []byte {
func ZeroUnPadding(plaintext []byte, unPadding int) []byte {
length := len(plaintext)
return plaintext[:(length - unpadding)]
return plaintext[:(length - unPadding)]
}

80
crypto/gdes/gdes.go
View File

@ -19,9 +19,9 @@ const (
PKCS5PADDING
)
// ECB模式DES加密
func DesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
text, err := Padding(clearText, padding)
// EncryptECB encrypts <plainText> using ECB mode.
func EncryptECB(plainText []byte, key []byte, padding int) ([]byte, error) {
text, err := Padding(plainText, padding)
if err != nil {
return nil, err
}
@ -41,8 +41,8 @@ func DesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
return cipherText, nil
}
// ECB模式DES解密
func DesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
// DecryptECB decrypts <cipherText> using ECB mode.
func DecryptECB(cipherText []byte, key []byte, padding int) ([]byte, error) {
text := make([]byte, len(cipherText))
block, err := des.NewCipher(key)
if err != nil {
@ -55,20 +55,21 @@ func DesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
block.Decrypt(text[begin:end], cipherText[begin:end])
}
clearText, err := UnPadding(text, padding)
plainText, err := UnPadding(text, padding)
if err != nil {
return nil, err
}
return clearText, nil
return plainText, nil
}
// ECB模式3DES加密，密钥长度可以是16或24位长
func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
// EncryptECBTriple encrypts <plainText> using TripleDES and ECB mode.
// The length of the <key> should be either 16 or 24 bytes.
func EncryptECBTriple(plainText []byte, key []byte, padding int) ([]byte, error) {
if len(key) != 16 && len(key) != 24 {
return nil, errors.New("key length error")
}
text, err := Padding(clearText, padding)
text, err := Padding(plainText, padding)
if err != nil {
return nil, err
}
@ -95,8 +96,9 @@ func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, err
return cipherText, nil
}
// ECB模式3DES解密，密钥长度可以是16或24位长
func TripleDesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
// DecryptECBTriple decrypts <cipherText> using TripleDES and ECB mode.
// The length of the <key> should be either 16 or 24 bytes.
func DecryptECBTriple(cipherText []byte, key []byte, padding int) ([]byte, error) {
if len(key) != 16 && len(key) != 24 {
return nil, errors.New("key length error")
}
@ -121,15 +123,15 @@ func TripleDesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, er
block.Decrypt(text[begin:end], cipherText[begin:end])
}
clearText, err := UnPadding(text, padding)
plainText, err := UnPadding(text, padding)
if err != nil {
return nil, err
}
return clearText, nil
return plainText, nil
}
// CBC模式DES加密
func DesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) ([]byte, error) {
// EncryptCBC encrypts <plainText> using CBC mode.
func EncryptCBC(plainText []byte, key []byte, iv []byte, padding int) ([]byte, error) {
block, err := des.NewCipher(key)
if err != nil {
return nil, err
@ -139,7 +141,7 @@ func DesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) ([]byte
return nil, errors.New("iv length invalid")
}
text, err := Padding(clearText, padding)
text, err := Padding(plainText, padding)
if err != nil {
return nil, err
}
@ -151,8 +153,8 @@ func DesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) ([]byte
return cipherText, nil
}
// CBC模式DES解密
func DesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int) ([]byte, error) {
// DecryptCBC decrypts <cipherText> using CBC mode.
func DecryptCBC(cipherText []byte, key []byte, iv []byte, padding int) ([]byte, error) {
block, err := des.NewCipher(key)
if err != nil {
return nil, err
@ -166,16 +168,16 @@ func DesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int) ([]byt
decrypter := cipher.NewCBCDecrypter(block, iv)
decrypter.CryptBlocks(text, cipherText)
clearText, err := UnPadding(text, padding)
plainText, err := UnPadding(text, padding)
if err != nil {
return nil, err
}
return clearText, nil
return plainText, nil
}
// CBC模式3DES加密
func TripleDesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) ([]byte, error) {
// EncryptCBCTriple encrypts <plainText> using TripleDES and CBC mode.
func EncryptCBCTriple(plainText []byte, key []byte, iv []byte, padding int) ([]byte, error) {
if len(key) != 16 && len(key) != 24 {
return nil, errors.New("key length invalid")
}
@ -197,7 +199,7 @@ func TripleDesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) (
return nil, errors.New("iv length invalid")
}
text, err := Padding(clearText, padding)
text, err := Padding(plainText, padding)
if err != nil {
return nil, err
}
@ -209,8 +211,8 @@ func TripleDesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) (
return cipherText, nil
}
// CBC模式3DES解密
func TripleDesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int) ([]byte, error) {
// DecryptCBCTriple decrypts <cipherText> using TripleDES and CBC mode.
func DecryptCBCTriple(cipherText []byte, key []byte, iv []byte, padding int) ([]byte, error) {
if len(key) != 16 && len(key) != 24 {
return nil, errors.New("key length invalid")
}
@ -236,29 +238,26 @@ func TripleDesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int)
decrypter := cipher.NewCBCDecrypter(block, iv)
decrypter.CryptBlocks(text, cipherText)
clearText, err := UnPadding(text, padding)
plainText, err := UnPadding(text, padding)
if err != nil {
return nil, err
}
return clearText, nil
return plainText, nil
}
// PKCS5补位
func PKCS5Padding(text []byte, blockSize int) []byte {
func PaddingPKCS5(text []byte, blockSize int) []byte {
padding := blockSize - len(text)%blockSize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(text, padtext...)
padText := bytes.Repeat([]byte{byte(padding)}, padding)
return append(text, padText...)
}
// 去除PKCS5补位
func PKCS5Unpadding(text []byte) []byte {
func UnPaddingPKCS5(text []byte) []byte {
length := len(text)
padtext := int(text[length-1])
return text[:(length - padtext)]
padText := int(text[length-1])
return text[:(length - padText)]
}
// 补位方法
func Padding(text []byte, padding int) ([]byte, error) {
switch padding {
case NOPADDING:
@ -266,7 +265,7 @@ func Padding(text []byte, padding int) ([]byte, error) {
return nil, errors.New("text length invalid")
}
case PKCS5PADDING:
return PKCS5Padding(text, 8), nil
return PaddingPKCS5(text, 8), nil
default:
return nil, errors.New("padding type error")
}
@ -274,7 +273,6 @@ func Padding(text []byte, padding int) ([]byte, error) {
return text, nil
}
// 去除补位方法
func UnPadding(text []byte, padding int) ([]byte, error) {
switch padding {
case NOPADDING:
@ -282,9 +280,9 @@ func UnPadding(text []byte, padding int) ([]byte, error) {
return nil, errors.New("text length invalid")
}
case PKCS5PADDING:
return PKCS5Unpadding(text), nil
return UnPaddingPKCS5(text), nil
default:
return nil, errors.New("padding type error.")
return nil, errors.New("padding type error")
}
return text, nil
}

78
crypto/gdes/gdes_test.go
View File

@ -27,26 +27,26 @@ func TestDesECB(t *testing.T) {
padding := gdes.NOPADDING
result := "858b176da8b12503"
// encrypt test
cipherText, err := gdes.DesECBEncrypt(key, text, padding)
cipherText, err := gdes.EncryptECB(text, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
clearText, err := gdes.DecryptECB(cipherText, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "12345678")
// encrypt err test. when throw exception,the err is not equal nil and the string is nil
errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
errEncrypt, err := gdes.EncryptECB(text, key, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
errEncrypt, err = gdes.DesECBEncrypt(errKey, text, padding)
errEncrypt, err = gdes.EncryptECB(text, errKey, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// err decrypt test.
errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding)
errDecrypt, err := gdes.DecryptECB(cipherText, errKey, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
errDecrypt, err = gdes.DesECBDecrypt(key, cipherText, errPadding)
errDecrypt, err = gdes.DecryptECB(cipherText, key, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
})
@ -57,19 +57,19 @@ func TestDesECB(t *testing.T) {
padding := gdes.PKCS5PADDING
errPadding := 5
result := "858b176da8b12503ad6a88b4fa37833d"
cipherText, err := gdes.DesECBEncrypt(key, text, padding)
cipherText, err := gdes.EncryptECB(text, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
clearText, err := gdes.DecryptECB(cipherText, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "12345678")
// err test
errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
errEncrypt, err := gdes.EncryptECB(text, key, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding)
errDecrypt, err := gdes.DecryptECB(cipherText, errKey, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
})
@ -82,15 +82,15 @@ func Test3DesECB(t *testing.T) {
padding := gdes.NOPADDING
result := "a23ee24b98c26263a23ee24b98c26263"
// encrypt test
cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
cipherText, err := gdes.EncryptECBTriple(text, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
clearText, err := gdes.DecryptECBTriple(cipherText, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "1234567812345678")
// err test
errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
errEncrypt, err := gdes.EncryptECB(text, key, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
})
@ -102,23 +102,23 @@ func Test3DesECB(t *testing.T) {
errPadding := 5
result := "37989b1effc07a6d00ff89a7d052e79f"
// encrypt test
cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
cipherText, err := gdes.EncryptECBTriple(text, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
clearText, err := gdes.DecryptECBTriple(cipherText, key, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "123456789")
// err test, when key is err, but text and padding is right
errEncrypt, err := gdes.TripleDesECBEncrypt(errKey, text, padding)
errEncrypt, err := gdes.EncryptECBTriple(text, errKey, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// when padding is err,but key and text is right
errEncrypt, err = gdes.TripleDesECBEncrypt(key, text, errPadding)
errEncrypt, err = gdes.EncryptECBTriple(text, key, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// decrypt err test,when key is err
errEncrypt, err = gdes.TripleDesECBDecrypt(errKey, text, padding)
errEncrypt, err = gdes.DecryptECBTriple(text, errKey, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
})
@ -132,35 +132,35 @@ func TestDesCBC(t *testing.T) {
iv := []byte("12345678")
result := "40826a5800608c87585ca7c9efabee47"
// encrypt test
cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
cipherText, err := gdes.EncryptCBC(text, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
clearText, err := gdes.DecryptCBC(cipherText, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "1234567812345678")
// encrypt err test.
errEncrypt, err := gdes.DesCBCEncrypt(errKey, text, iv, padding)
errEncrypt, err := gdes.EncryptCBC(text, errKey, iv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// the iv is err
errEncrypt, err = gdes.DesCBCEncrypt(key, text, errIv, padding)
errEncrypt, err = gdes.EncryptCBC(text, key, errIv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// the padding is err
errEncrypt, err = gdes.DesCBCEncrypt(key, text, iv, errPadding)
errEncrypt, err = gdes.EncryptCBC(text, key, iv, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// decrypt err test. the key is err
errDecrypt, err := gdes.DesCBCDecrypt(errKey, cipherText, iv, padding)
errDecrypt, err := gdes.DecryptCBC(cipherText, errKey, iv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
// the iv is err
errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, errIv, padding)
errDecrypt, err = gdes.DecryptCBC(cipherText, key, errIv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
// the padding is err
errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, iv, errPadding)
errDecrypt, err = gdes.DecryptCBC(cipherText, key, iv, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
})
@ -172,15 +172,15 @@ func TestDesCBC(t *testing.T) {
iv := []byte("12345678")
result := "40826a5800608c87100a25d86ac7c52c"
// encrypt test
cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
cipherText, err := gdes.EncryptCBC(text, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
clearText, err := gdes.DecryptCBC(cipherText, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "12345678")
// err test
errEncrypt, err := gdes.DesCBCEncrypt(key, text, errIv, padding)
errEncrypt, err := gdes.EncryptCBC(text, key, errIv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
})
@ -194,35 +194,35 @@ func Test3DesCBC(t *testing.T) {
iv := []byte("12345678")
result := "bfde1394e265d5f738d5cab170c77c88"
// encrypt test
cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
cipherText, err := gdes.EncryptCBCTriple(text, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
clearText, err := gdes.DecryptCBCTriple(cipherText, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "1234567812345678")
// encrypt err test
errEncrypt, err := gdes.TripleDesCBCEncrypt(errKey, text, iv, padding)
errEncrypt, err := gdes.EncryptCBCTriple(text, errKey, iv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// the iv is err
errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, errIv, padding)
errEncrypt, err = gdes.EncryptCBCTriple(text, key, errIv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// the padding is err
errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, iv, errPadding)
errEncrypt, err = gdes.EncryptCBCTriple(text, key, iv, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errEncrypt, nil)
// decrypt err test
errDecrypt, err := gdes.TripleDesCBCDecrypt(errKey, cipherText, iv, padding)
errDecrypt, err := gdes.DecryptCBCTriple(cipherText, errKey, iv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
// the iv is err
errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, errIv, padding)
errDecrypt, err = gdes.DecryptCBCTriple(cipherText, key, errIv, padding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
// the padding is err
errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, iv, errPadding)
errDecrypt, err = gdes.DecryptCBCTriple(cipherText, key, iv, errPadding)
gtest.AssertNE(err, nil)
gtest.AssertEQ(errDecrypt, nil)
})
@ -233,11 +233,11 @@ func Test3DesCBC(t *testing.T) {
iv := []byte("12345678")
result := "40826a5800608c87100a25d86ac7c52c"
// encrypt test
cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
cipherText, err := gdes.EncryptCBCTriple(text, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(hex.EncodeToString(cipherText), result)
// decrypt test
clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
clearText, err := gdes.DecryptCBCTriple(cipherText, key, iv, padding)
gtest.AssertEQ(err, nil)
gtest.AssertEQ(string(clearText), "12345678")
})