Golang中的加密与解密实践

随着互联网的不断发展，越来越多的信息需要传输，而这些信息中很多都是敏感信息，为了保证信息安全，加密技术就被广泛应用。在Golang中，我们可以通过各种加密算法来保证信息安全，同时也可以通过相应的解密算法来还原加密后的信息。本文将介绍一些常见的加密与解密算法，并提供相应的代码示例。

一、MD5加密算法

MD5是一种哈希算法，它将任意长度的二进制值映射为一个128位的小写字母和数字组成的字符串。MD5算法具有抗碰撞特性，即不同的输入得到的哈希值很难相同。在Golang中，我们可以通过crypto/md5包来实现MD5加密算法。

示例代码：

```go
import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
)
 
// 对字符串进行MD5加密
func Md5Encrypt(str string) string {
    md5Ctx := md5.New()
    md5Ctx.Write([]byte(str))
    cipherStr := md5Ctx.Sum(nil)
    return hex.EncodeToString(cipherStr)
}
 
func main() {
    str := "hello world"
    encryptedStr := Md5Encrypt(str)
    fmt.Println("加密前：", str)
    fmt.Println("加密后：", encryptedStr)
}
```

二、AES加密算法

AES是一种对称加密算法，它是目前最流行的加密算法之一，具有高效、安全、可靠等特点。在Golang中，我们可以通过crypto/aes包来实现AES加密算法。

示例代码：

```go
import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "fmt"
)
 
// 对字符串进行AES加密
func AesEncrypt(str, key string) (string, error) {
    strBytes := []byte(str)
    keyBytes := []byte(key)
 
    block, err := aes.NewCipher(keyBytes)
    if err != nil {
        return "", err
    }
 
    blockSize := block.BlockSize()
    strBytes = PKCS5Padding(strBytes, blockSize)
 
    iv := keyBytes[:blockSize]
 
    blockMode := cipher.NewCBCEncrypter(block, iv)
    cipherText := make([]byte, len(strBytes))
    blockMode.CryptBlocks(cipherText, strBytes)
 
    return base64.StdEncoding.EncodeToString(cipherText), nil
}
 
// 对字符串进行AES解密
func AesDecrypt(str, key string) (string, error) {
    strBytes, err := base64.StdEncoding.DecodeString(str)
    if err != nil {
        return "", err
    }
    keyBytes := []byte(key)
 
    block, err := aes.NewCipher(keyBytes)
    if err != nil {
        return "", err
    }
 
    blockSize := block.BlockSize()
 
    iv := keyBytes[:blockSize]
 
    blockMode := cipher.NewCBCDecrypter(block, iv)
    origData := make([]byte, len(strBytes))
 
    blockMode.CryptBlocks(origData, strBytes)
    origData = PKCS5UnPadding(origData)
 
    return string(origData), nil
}
 
// PKCS5填充
func PKCS5Padding(cipherText []byte, blockSize int) []byte {
    padding := blockSize - len(cipherText)%blockSize
    padText := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(cipherText, padText...)
}
 
// PKCS5去除填充
func PKCS5UnPadding(origData []byte) []byte {
    length := len(origData)
    unPadding := int(origData[length-1])
    return origData[:(length - unPadding)]
}
 
func main() {
    str := "hello world"
    key := "1234567890123456"
 
    encryptedStr, err := AesEncrypt(str, key)
    if err != nil {
        fmt.Println("加密失败：", err)
        return
    }
 
    decryptedStr, err := AesDecrypt(encryptedStr, key)
    if err != nil {
        fmt.Println("解密失败：", err)
        return
    }
 
    fmt.Println("加密前：", str)
    fmt.Println("加密后：", encryptedStr)
    fmt.Println("解密后：", decryptedStr)
}
```

三、RSA加密算法

RSA是一种非对称加密算法，它通过公钥加密、私钥解密的方式实现信息的安全传输。在Golang中，我们可以通过crypto/rsa包来实现RSA加密算法。

示例代码：

```go
import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "fmt"
)
 
// 生成RSA密钥对
func GenerateRsaKeyPair() (*rsa.PrivateKey, error) {
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        return nil, err
    }
    return privateKey, nil
}
 
// 使用公钥进行RSA加密
func RsaEncrypt(plainText []byte, publicKey []byte) ([]byte, error) {
    block, _ := pem.Decode(publicKey)
    if block == nil {
        return nil, fmt.Errorf("public key error")
    }
 
    pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }
 
    pub := pubInterface.(*rsa.PublicKey)
    cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pub, plainText)
    if err != nil {
        return nil, err
    }
 
    return cipherText, nil
}
 
// 使用私钥进行RSA解密
func RsaDecrypt(cipherText []byte, privateKey []byte) ([]byte, error) {
    block, _ := pem.Decode(privateKey)
    if block == nil {
        return nil, fmt.Errorf("private key error")
    }
 
    priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, err
    }
 
    plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priv, cipherText)
    if err != nil {
        return nil, err
    }
 
    return plainText, nil
}
 
func main() {
    str := "hello world"
 
    privateKey, err := GenerateRsaKeyPair()
    if err != nil {
        fmt.Println("生成密钥对失败：", err)
        return
    }
 
    publicKey := &privateKey.PublicKey
 
    cipherText, err := RsaEncrypt([]byte(str), []byte(publicKey))
    if err != nil {
        fmt.Println("加密失败：", err)
        return
    }
 
    plainText, err := RsaDecrypt(cipherText, []byte(privateKey))
    if err != nil {
        fmt.Println("解密失败：", err)
        return
    }
 
    fmt.Println("加密前：", str)
    fmt.Println("加密后：", base64.StdEncoding.EncodeToString(cipherText))
    fmt.Println("解密后：", string(plainText))
}
```

四、总结

本文介绍了Golang中常见的加密与解密算法，包括MD5、AES、RSA等。这些加密算法在实际开发中非常常见，开发者需要在保证信息安全的前提下，选择合适的加密算法来保护数据的安全。同时，本文提供了相应的代码示例，读者可以根据需要进行调整和使用。