diff --git a/crypto/gaes/gaes.go b/crypto/gaes/gaes.go index b9428755d..d0ddb9ae7 100644 --- a/crypto/gaes/gaes.go +++ b/crypto/gaes/gaes.go @@ -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 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)] } diff --git a/crypto/gdes/gdes.go b/crypto/gdes/gdes.go index 7316d28d7..7f1b59e94 100644 --- a/crypto/gdes/gdes.go +++ b/crypto/gdes/gdes.go @@ -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 } diff --git a/crypto/gdes/gdes_test.go b/crypto/gdes/gdes_test.go index 01a3bc69d..7cce587c6 100644 --- a/crypto/gdes/gdes_test.go +++ b/crypto/gdes/gdes_test.go @@ -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") })