🔐 非对称加密算法

const crypto = require('crypto');

// 生成 RSA 密钥对
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
    modulusLength: 2048,
    publicExponent: 0x10001,
    privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
    publicKeyEncoding: { type: 'pkcs1', format: 'pem' }
});

// 加密
const message = "Hello, RSA!";
const encrypted = crypto.publicEncrypt(
    { key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
    Buffer.from(message)
);
console.log("加密:", encrypted.toString('base64').substring(0, 50) + "...");

// 解密
const decrypted = crypto.privateDecrypt(
    { key: privateKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
    encrypted
);
console.log("解密:", decrypted.toString('utf8'));

// 签名
const sign = crypto.createSign('SHA256');
sign.update(message);
sign.end();
const signature = sign.sign(privateKey).toString('base64');
console.log("签名:", signature.substring(0, 50) + "...");

// 验证签名
const verify = crypto.createVerify('SHA256');
verify.update(message);
verify.end();
const isValid = verify.verify(publicKey, Buffer.from(signature, 'base64'));
console.log("签名验证:", isValid);

package main

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

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

    // 加密
    message := []byte("Hello, RSA!")
    ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey, message, nil)
    if err != nil {
        panic(err)
    }
    fmt.Printf("密文：%s\n", hex.EncodeToString(ciphertext)[:50]+"...")

    // 解密
    plaintext, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, privateKey, ciphertext, nil)
    if err != nil {
        panic(err)
    }
    fmt.Printf("明文：%s\n", string(plaintext))

    // 签名
    hashed := sha256.Sum256(message)
    signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed[:])
    if err != nil {
        panic(err)
    }
    fmt.Printf("签名：%s\n", hex.EncodeToString(signature)[:50]+"...")

    // 验证签名
    err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hashed[:], signature)
    if err != nil {
        fmt.Printf("签名验证失败：%v\n", err)
    } else {
        fmt.Println("签名验证成功!")
    }

    // 保存私钥到 PEM
    privBytes := x509.MarshalPKCS1PrivateKey(privateKey)
    privPEM := pem.EncodeToMemory(&pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: privBytes,
    })
    fmt.Printf("\n私钥 PEM:\n%s\n", string(privPEM)[:100]+"...")
}

package main

import (
    "crypto/rand"
    "crypto/sha256"
    "crypto/subtle"
    "encoding/hex"
    "fmt"
    "math/big"
)

// RFC 3526 2048 位 MODP 组
var (
    p, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"+
        "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"+
        "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"+
        "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"+
        "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC"+
        "2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"+
        "83655D23DCA3AD961C62F356208552BB9ED529077096966D"+
        "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"+
        "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"+
        "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"+
        "15728E5A8AACAA68FFFFFFFFFFFFFFFF", 16)
    g = big.NewInt(2)
)

func generatePrivateKey() *big.Int {
    priv, _ := rand.Int(rand.Reader, p)
    return priv
}

func computePublicKey(priv *big.Int) *big.Int {
    return new(big.Int).Exp(g, priv, p)
}

func computeSharedKey(priv, pub *big.Int) []byte {
    shared := new(big.Int).Exp(pub, priv, p)
    hash := sha256.Sum256(shared.Bytes())
    return hash[:]
}

func main() {
    // Alice 生成密钥对
    alicePriv := generatePrivateKey()
    alicePub := computePublicKey(alicePriv)

    // Bob 生成密钥对
    bobPriv := generatePrivateKey()
    bobPub := computePublicKey(bobPriv)

    // 计算共享密钥
    aliceShared := computeSharedKey(alicePriv, bobPub)
    bobShared := computeSharedKey(bobPriv, alicePub)

    fmt.Printf("Alice 共享密钥：%s\n", hex.EncodeToString(aliceShared)[:50]+"...")
    fmt.Printf("Bob 共享密钥：%s\n", hex.EncodeToString(bobShared)[:50]+"...")
    fmt.Printf("密钥匹配：%v\n", subtle.ConstantTimeCompare(aliceShared, bobShared) == 1)
}

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "math/big"
)

func main() {
    // 生成 ECC 密钥对（使用 P-256 曲线）
    privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        panic(err)
    }
    publicKey := &privateKey.PublicKey

    fmt.Printf("私钥长度：%d 位\n", privateKey.Params().BitSize)
    fmt.Printf("公钥长度：%d 位\n", publicKey.Params().BitSize)

    // ECDH 密钥交换
    alicePriv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    bobPriv, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)

    aliceShared, _ := alicePriv.Curve.ScalarMult(bobPriv.X, bobPriv.Y, alicePriv.D.Bytes())
    bobShared, _ := bobPriv.Curve.ScalarMult(alicePriv.X, alicePriv.Y, bobPriv.D.Bytes())

    fmt.Printf("\nAlice 共享密钥：%s\n", hex.EncodeToString(aliceShared.Bytes())[:50]+"...")
    fmt.Printf("Bob 共享密钥：%s\n", hex.EncodeToString(bobShared.Bytes())[:50]+"...")
    fmt.Printf("密钥匹配：%v\n", aliceShared.Cmp(bobShared) == 0)

    // ECDSA 签名
    message := []byte("Hello, ECC!")
    hashed := sha256.Sum256(message)
    r, s, err := ecdsa.Sign(rand.Reader, privateKey, hashed[:])
    if err != nil {
        panic(err)
    }
    fmt.Printf("\n签名 r: %s\n", hex.EncodeToString(r.Bytes())[:50]+"...")
    fmt.Printf("签名 s: %s\n", hex.EncodeToString(s.Bytes())[:50]+"...")

    // 验证签名
    valid := ecdsa.Verify(publicKey, hashed[:], r, s)
    fmt.Printf("签名验证：%v\n", valid)

    // 显示公钥坐标
    fmt.Printf("\n公钥坐标:\n  X: %s\n  Y: %s\n", 
        publicKey.X.Text(16)[:32], publicKey.Y.Text(16)[:32])
}