Golang如何使用 crypto 包实现加密算法_Golang crypto 数据加密与解密方法

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "io"
)

func encrypt(plaintext []byte, key []byte) (string, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return "", err
    }

    nonce := make([]byte, gcm.NonceSize())
    if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
        return "", err
    }

    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
    return base64.StdEncoding.EncodeToString(ciphertext), nil
}

func decrypt(ciphertextStr string, key []byte) ([]byte, error) {
    data, err := base64.StdEncoding.DecodeString(ciphertextStr)
    if err != nil {
        return nil, err
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    nonceSize := gcm.NonceSize()
    if len(data) < nonceSize {
        return nil, fmt.Errorf("ciphertext too short")
    }

    nonce, ciphertext := data[:nonceSize], data[nonceSize:]
    return gcm.Open(nil, nonce, ciphertext, nil)
}

func main() {
    key := []byte("example key 1234") // 16字节密钥（AES-128）
    plaintext := []byte("Hello, this is a secret message!")

    encrypted, err := encrypt(plaintext, key)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Encrypted: %s\n", encrypted)

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

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
    "fmt"
)

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

    // 获取公钥
    publicKey := &privateKey.PublicKey

    plaintext := []byte("This is a secret message only for RSA.")

    // 使用公钥加密
    ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, plaintext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Encrypted (base64): %s\n", 
        base64.StdEncoding.EncodeToString(ciphertext))

    // 使用私钥解密
    decrypted, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, ciphertext)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Decrypted: %s\n", decrypted)
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func main() {
    data := "hello world"
    key := []byte("my-secret-key")

    // SHA256 哈希
    hash := sha256.Sum256([]byte(data))
    fmt.Printf("SHA256: %s\n", hex.EncodeToString(hash[:]))

    // HMAC-SHA256
    h := hmac.New(sha256.New, key)
    h.Write([]byte(data))
    mac := h.Sum(nil)
    fmt.Printf("HMAC-SHA256: %s\n", hex.EncodeToString(mac))
}