4.1.1 核心代码

DES的加密案例，如下例所示。

例1-1 DES

1 package main

2 import (

3    "bytes"

4    "crypto/cipher"

5    "crypto/des"

6    "encoding/base64"

7    "fmt"

8 )

9 func main(){

10    key := []byte("00000000") //秘钥只占8个字节

11    arr := "千锋教育"

12    fmt.Println("------------DES加密解密字节数组")

13    fmt.Println("加密前：",arr)

14    resultArr, _ := DesEncrypt([]byte(arr), key)

15    fmt.Printf("加密后：%x\n", resultArr)

16    resultArr, _ = DesDecrypt(resultArr, key)

17    fmt.Println("解密后：", string(resultArr))

18    fmt.Println("------------DES加密解密字符串")

19    cipherText, _ := DesEncryptString(arr, key)

20    fmt.Println("加密后：" , cipherText)

21    originalText, _ := DesDecryptString(cipherText, key)

22    fmt.Println("解密后：", originalText)

23 

24 }

25 //DES加密字节数组，返回字节数组

26 func DesEncrypt(originalBytes, key []byte) ([]byte, error) {

27    block, err := des.NewCipher(key)

28    if err != nil {

29       return nil, err

30    }

31    originalBytes = PKCS5Padding(originalBytes, block.BlockSize())

32    blockMode := cipher.NewCBCEncrypter(block, key)

33    cipherArr := make([]byte, len(originalBytes))

34    blockMode.CryptBlocks(cipherArr, originalBytes)

35    return cipherArr, nil

36 }

37 //DES解密字节数组，返回字节数组

38 func DesDecrypt(cipherBytes, key []byte) ([]byte, error) {

39    block, err := des.NewCipher(key)

40    if err != nil {

41       return nil, err

42    }

43    blockMode := cipher.NewCBCDecrypter(block, key)

44    originalText := make([]byte, len(cipherBytes))

45    blockMode.CryptBlocks(originalText, cipherBytes)

46    originalText = PKCS5UnPadding(originalText)

47    return originalText, nil

48 }

49 //DES加密文本，返回加密后文本

50 func DesEncryptString(originalText string, key []byte) (string, error) {

51    cipherArr, err := DesEncrypt([]byte(originalText), key)

52    if err != nil {

53       return "", err

54    }

55    base64str := base64.StdEncoding.EncodeToString(cipherArr)

56    return base64str, nil

57 }

58 //对加密文本进行DES解密，返回解密后明文

59 func DesDecryptString(cipherText string, key []byte) (string, error) {

60    cipherArr, _ := base64.StdEncoding.DecodeString(cipherText)

61    cipherArr, err := DesDecrypt(cipherArr, key)

62    if err != nil {

63       return "", err

64    }

65    return string(cipherArr), nil

66 }

67 func PKCS5Padding(ciphertext []byte, blockSize int) []byte {

68  padding := blockSize - len(ciphertext)%blockSize

69  padtext := bytes.Repeat([]byte{byte(padding)}, padding)

70  return append(ciphertext, padtext...)

71 }

72 func PKCS5UnPadding(origData []byte) []byte {

73  length := len(origData)

74  // 去掉最后一个字节 unpadding 次

75  unpadding := int(origData[length-1])

76  return origData[:(length - unpadding)]

77 }

运行结果如图所示。

图4.1 运行结果

3DES加密解密的案例，如下所示。

例1-2 3DES

1 package main

2 import (

3  "bytes"

4  "crypto/cipher"

5  "crypto/des"

6  "encoding/base64"

7  "fmt"

8 )

9 func main() {

10  key := []byte("abcdefghijklmnopqrstuvwx") //秘钥占24个字节

11  fmt.Println("------------3DES加密解密字节数组")

12  str := "我爱Go语言"

13  result, _ := TripleDesEncrypt([]byte(str), key)

14  fmt.Printf("加密后：%x\n", result)

15  origData, _ := TripleDesDecrypt(result, key)

16  fmt.Println("解密后：", string(origData))

17  fmt.Println("------------3DES加密解密字符串")

18  cipherText, _ := TripleDesEncrypt2Str(str, key)

19  fmt.Println("加密后：", cipherText)

20  originalText, _ := TripleDesDecrypt2Str(cipherText, key)

21  fmt.Println("解密后：", originalText)

22 }

23 // 3DES加密字节数组，返回字节数组

24 func TripleDesEncrypt(originalBytes, key []byte) ([]byte, error) {

25    block, err := des.NewTripleDESCipher(key)

26    if err != nil {

27       return nil, err

28    }

29    originalBytes = PKCS5Padding(originalBytes, block.BlockSize())

30    // originalBytes = ZeroPadding(originalBytes, block.BlockSize())

31    blockMode := cipher.NewCBCEncrypter(block, key[:8])

32    cipherArr := make([]byte, len(originalBytes))

33    blockMode.CryptBlocks(cipherArr, originalBytes)

34    return cipherArr, nil

35 }

36 // 3DES解密字节数组，返回字节数组

37 func TripleDesDecrypt(cipherBytes, key []byte) ([]byte, error) {

38    block, err := des.NewTripleDESCipher(key)

39    if err != nil {

40       return nil, err

41    }

42    blockMode := cipher.NewCBCDecrypter(block, key[:8])

43    originalArr := make([]byte, len(cipherBytes))

44    blockMode.CryptBlocks(originalArr, cipherBytes)

45    originalArr = PKCS5UnPadding(originalArr)

46    // origData = ZeroUnPadding(origData)

47    return originalArr, nil

48 }

49 // 3DES加密字符串，返回base64处理后字符串

50 func TripleDesEncrypt2Str(originalText string, key []byte) (string, error) {

51    block, err := des.NewTripleDESCipher(key)

52    if err != nil {

53       return "", err

54    }

55    originalData := PKCS5Padding([]byte(originalText), block.BlockSize())

56    // originalData = ZeroPadding(originalData, block.BlockSize())

57    blockMode := cipher.NewCBCEncrypter(block, key[:8])

58    cipherArr := make([]byte, len(originalData))

59    blockMode.CryptBlocks(cipherArr, originalData)

60    cipherText := base64.StdEncoding.EncodeToString(cipherArr)

61    return cipherText, nil

62 }

63 // 3DES解密base64处理后的加密字符串，返回明文字符串

64 func TripleDesDecrypt2Str(cipherText string, key []byte) (string, error) {

65    cipherArr, _ := base64.StdEncoding.DecodeString(cipherText)

66    block, err := des.NewTripleDESCipher(key)

67    if err != nil {

68       return "", err

69    }

70    blockMode := cipher.NewCBCDecrypter(block, key[:8])

71    originalArr := make([]byte, len(cipherArr))

72    blockMode.CryptBlocks(originalArr, cipherArr)

73    originalArr = PKCS5UnPadding(originalArr)

74    // origData = ZeroUnPadding(origData)

75    return string(originalArr), nil

76 }

77 func PKCS5Padding(ciphertext []byte, blockSize int) []byte {

78  padding := blockSize - len(ciphertext)%blockSize

79  padtext := bytes.Repeat([]byte{byte(padding)}, padding)

80  return append(ciphertext, padtext...)

81 }

82 func PKCS5UnPadding(origData []byte) []byte {

83  length := len(origData)

84  // 去掉最后一个字节 unpadding 次

85  unpadding := int(origData[length-1])

86  return origData[:(length - unpadding)]

87 }

运行结果如图所示。

图4.2 运行结果

AES加密解密的案例，如例所示。

例1-3 AES

1 package main

2 import (

3  "bytes"

4  "crypto/aes"

5  "crypto/cipher"

6  "encoding/base64"

7  "fmt"

8 )

9 func main() {

10  // AES-128。key长度：16, 24, 32 bytes 对应 AES-128, AES-192, AES-256

11  key := []byte("1234567890abcdefghijklmnopqrstuv")

12  str := "区块链很有趣"

13  fmt.Println("------------AES加密解密字节数组")

14  resultArr, _ := AesEncrypt([]byte(str), key)

15  fmt.Printf("加密后：%x\n", resultArr)

16  resultArr, _ = AesDecrypt(resultArr, key)

17  fmt.Println("解密后：", string(resultArr))

18  fmt.Println("------------AES加密解密字符串")

19  cipherText, _ := AesEncryptString(str, key)

20  fmt.Println("加密后：", cipherText)

21  originalText, _ := AesDecryptString(cipherText, key)

22  fmt.Println("解密后：", originalText)

23 }

24 //AES加密字节数组，返回字节数组

25 func AesEncrypt(originalBytes, key []byte) ([]byte, error) {

26    block, err := aes.NewCipher(key)

27    if err != nil {

28       return nil, err

29    }

30    blockSize := block.BlockSize()

31    originalBytes = PKCS5Padding(originalBytes, blockSize)

32    blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])

33    cipherBytes := make([]byte, len(originalBytes))

34    blockMode.CryptBlocks(cipherBytes, originalBytes)

35    return cipherBytes, nil

36 }

37 //AES解密字节数组，返回字节数组

38 func AesDecrypt(cipherBytes, key []byte) ([]byte, error) {

39    block, err := aes.NewCipher(key)

40    if err != nil {

41       return nil, err

42    }

43    blockSize := block.BlockSize()

44    blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])

45    originalBytes := make([]byte, len(cipherBytes))

46    blockMode.CryptBlocks(originalBytes, cipherBytes)

47    originalBytes = PKCS5UnPadding(originalBytes)

48    return originalBytes, nil

49 }

50 //AES加密文本，返回对加密后字节数组进行base64处理后字符串

51 func AesEncryptString(originalText string, key []byte) (string, error) {

52    cipherBytes, err := AesEncrypt([]byte(originalText), key)

53    if err != nil {

54       return "", err

55    }

56    base64str := base64.StdEncoding.EncodeToString(cipherBytes)

57    return base64str, nil

58 }

59 //对Base64处理后的加密文本进行DES解密，返回解密后明文

60 func AesDecryptString(cipherText string, key []byte) (string, error) {

61    cipherBytes, _ := base64.StdEncoding.DecodeString(cipherText)

62    cipherBytes, err := AesDecrypt(cipherBytes, key)

63    if err != nil {

64       return "", err

65    }

66    return string(cipherBytes), nil

67 }

68 func PKCS5Padding(ciphertext []byte, blockSize int) []byte {

69  padding := blockSize - len(ciphertext)%blockSize

70  padtext := bytes.Repeat([]byte{byte(padding)}, padding)

71  return append(ciphertext, padtext...)

72 }

73 func PKCS5UnPadding(origData []byte) []byte {

74  length := len(origData)

75  // 去掉最后一个字节 unpadding 次

76  unpadding := int(origData[length-1])

77  return origData[:(length - unpadding)]

78 }

运行结果如图所示。

图4.3 运行结果