golang常用加密解密算法总结(AES、DES、RSA、Sha1、MD5)

Golang常用加密解密算法总结

Golang提供了丰富的加密解密算法库，本篇文章将介绍常用的加密解密算法：AES、DES、RSA、Sha1、MD5。

AES（Advanced Encryption Standard）

AES加密算法是目前应用最广泛的对称加密算法，在网络传输中常作为对称加密方式使用。AES算法支持多种不同的密钥长度，包括128位，192位和256位密钥长度。

下面是使用Go语言进行AES加密解密的示例：

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "fmt"
)

func encrypt(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    ciphertext := make([]byte, aes.BlockSize+len(plaintext))
    iv := ciphertext[:aes.BlockSize]
    if _, err := rand.Read(iv); err != nil {
        return nil, err
    }
    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)
    return ciphertext, nil
}

func decrypt(key, ciphertext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    if len(ciphertext) < aes.BlockSize {
        return nil, errors.New("ciphertext too short")
    }
    iv := ciphertext[:aes.BlockSize]
    ciphertext = ciphertext[aes.BlockSize:]
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext, ciphertext)
    return ciphertext, nil
}

func main() {
    key := []byte("thisisapassword12345")
    plaintext := []byte("The quick brown fox jumps over the lazy dog")
    ciphertext, err := encrypt(key, plaintext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("AES encrypted value: %x\n", ciphertext)

    decrypted, err := decrypt(key, ciphertext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("AES decrypted value: %s\n", decrypted)
}

DES（Data Encryption Standard）

DES加密算法是一种对称加密算法，密钥长度是56位。由于随着计算机技术的不断发展，DES算法越来越容易被攻破，因此目前已经不再被推荐使用。

下面是使用Go语言进行DES加密解密的示例：

package main

import (
    "crypto/cipher"
    "crypto/des"
    "fmt"
)

func encryptDES(key, plaintext []byte) ([]byte, error) {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil, err
    }
    ciphertext := make([]byte, len(plaintext))
    cbc := cipher.NewCBCEncrypter(block, key[:8])
    cbc.CryptBlocks(ciphertext, plaintext)
    return ciphertext, nil
}

func decryptDES(key, ciphertext []byte) ([]byte, error) {
    block, err := des.NewCipher(key)
    if err != nil {
        return nil, err
    }
    plaintext := make([]byte, len(ciphertext))
    cbc := cipher.NewCBCDecrypter(block, key[:8])
    cbc.CryptBlocks(plaintext, ciphertext)
    return plaintext, nil
}

func main() {
    key := []byte("password")
    plaintext := []byte("The quick brown fox jumps over the lazy dog")
    ciphertext, err := encryptDES(key, plaintext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("DES encrypted value: %x\n", ciphertext)

    decrypted, err := decryptDES(key, ciphertext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("DES decrypted value: %s\n", decrypted)
}

RSA（Rivest–Shamir–Adleman）

RSA算法是一种非对称加密算法，密钥分为公钥和私钥，用公钥加密数据，只有对应的私钥才能解密，反之亦然。RSA算法常防范网络中的中间人攻击。

下面是使用Go语言进行RSA加密解密的示例：

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "fmt"
)

func encryptRSA(pubkey *rsa.PublicKey, plaintext []byte) ([]byte, error) {
    ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, pubkey, plaintext)
    if err != nil {
        return nil, err
    }
    return ciphertext, nil
}

func decryptRSA(privkey *rsa.PrivateKey, ciphertext []byte) ([]byte, error) {
    plaintext, err := rsa.DecryptPKCS1v15(rand.Reader, privkey, ciphertext)
    if err != nil {
        return nil, err
    }
    return plaintext, nil
}

func main() {
    // 生成RSA密钥对
    privkey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        panic(err)
    }

    // 使用公钥加密
    pubkey := &privkey.PublicKey
    plaintext := []byte("The quick brown fox jumps over the lazy dog")
    ciphertext, err := encryptRSA(pubkey, plaintext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("RSA encrypted value: %x\n", ciphertext)

    // 使用私钥解密
    decrypted, err := decryptRSA(privkey, ciphertext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("RSA decrypted value: %s\n", decrypted)
}

SHA1（Secure Hash Algorithm 1）

SHA1算法是一种哈希算法，用于生成消息摘要，其输出是160位的二进制字符串。SHA1算法通常用于数字签名和认证应用程序。

下面是使用Go语言进行SHA1哈希的示例：

package main

import (
    "crypto/sha1"
    "fmt"
)

func sha1Hash(input []byte) []byte {
    h := sha1.New()
    h.Write(input)
    return h.Sum(nil)
}

func main() {
    input := []byte("The quick brown fox jumps over the lazy dog")
    hashed := sha1Hash(input)
    fmt.Printf("SHA1 HASH of %s: %x\n", input, hashed)
}

MD5（Message-Digest Algorithm 5）

MD5算法是一种哈希算法，通常用于一致性验证、数字签名和密码哈希存储等领域。其输出是128位的二进制字符串。

下面是使用Go语言进行MD5哈希的示例：

package main

import (
    "crypto/md5"
    "fmt"
)

func md5Hash(input []byte) []byte {
    h := md5.New()
    h.Write(input)
    return h.Sum(nil)
}

func main() {
    input := []byte("The quick brown fox jumps over the lazy dog")
    hashed := md5Hash(input)
    fmt.Printf("MD5 of %s: %x\n", input, hashed)
}

以上就是常用的加密解密算法在Go语言中的使用总结。