公鑰密碼學：數位握手，Go Crypto 5

嘿，加密貨幣探索者！準備好進入公鑰密碼學的迷人世界了嗎？將其視為您可以在公共場合進行的秘密握手的數位形式。聽起來不可能？讓我們分解一下，看看 Go 如何幫助我們實現這個加密魔術！

RSA：公鑰加密貨幣的鼻祖

首先，我們有 RSA (Rivest-Shamir-Adleman)。它就像公鑰系統的睿智老祖父 - 已經存在了很多年並且仍然很強大。

RSA 金鑰產生：您的數位身份

讓我們從建立 RSA 金鑰開始：

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

func main() {
    // Let's make a 2048-bit key. It's like choosing a really long password!
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        panic("Oops! Our key generator is feeling shy today.")
    }

    publicKey := &privateKey.PublicKey

    fmt.Println("Tada! We've got our keys. Keep the private one secret!")
    fmt.Printf("Private Key: %v\n", privateKey)
    fmt.Printf("Public Key: %v\n", publicKey)
}

RSA加解密：傳遞密文

現在，讓我們使用這些金鑰來發送秘密訊息：

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

func main() {
    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
    publicKey := &privateKey.PublicKey

    secretMessage := []byte("RSA is like a magic envelope!")

    // Encryption - Sealing our magic envelope
    ciphertext, err := rsa.EncryptOAEP(
        sha256.New(),
        rand.Reader,
        publicKey,
        secretMessage,
        nil,
    )
    if err != nil {
        panic("Our magic envelope got stuck!")
    }

    fmt.Printf("Our secret message, encrypted: %x\n", ciphertext)

    // Decryption - Opening our magic envelope
    plaintext, err := rsa.DecryptOAEP(
        sha256.New(),
        rand.Reader,
        privateKey,
        ciphertext,
        nil,
    )
    if err != nil {
        panic("Uh-oh, we can't open our own envelope!")
    }

    fmt.Printf("Decrypted message: %s\n", plaintext)
}

RSA 簽名與驗證：您的數位簽名

RSA 不僅適用於秘密訊息。它還可以創建數位簽名：

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

func main() {
    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
    publicKey := &privateKey.PublicKey

    message := []byte("I solemnly swear that I am up to no good.")
    hash := sha256.Sum256(message)

    // Signing - Like signing a digital contract
    signature, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hash[:])
    if err != nil {
        panic("Our digital pen ran out of ink!")
    }

    fmt.Printf("Our digital signature: %x\n", signature)

    // Verification - Checking if the signature is genuine
    err = rsa.VerifyPKCS1v15(publicKey, crypto.SHA256, hash[:], signature)
    if err != nil {
        fmt.Println("Uh-oh, this signature looks fishy!")
    } else {
        fmt.Println("Signature checks out. Mischief managed!")
    }
}

橢圓曲線密碼學 (ECC)：區塊鏈上的新星

現在，我們來談談 ECC。它就像 RSA 更酷、更有效率的表弟。它透過更小的金鑰提供類似的安全性，這對於行動和物聯網設備來說非常有用。

ECDSA 金鑰產生：您的橢圓身份

讓我們建立 ECC 金鑰：

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "fmt"
)

func main() {
    privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        panic("Our elliptic curve generator took a wrong turn!")
    }

    publicKey := &privateKey.PublicKey

    fmt.Println("Voila! Our elliptic curve keys are ready.")
    fmt.Printf("Private Key: %v\n", privateKey)
    fmt.Printf("Public Key: %v\n", publicKey)
}

ECDSA 簽名與驗證：曲線簽名

現在，讓我們用橢圓鍵簽一些內容：

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/sha256"
    "fmt"
)

func main() {
    privateKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    publicKey := &privateKey.PublicKey

    message := []byte("Elliptic curves are mathematically delicious!")
    hash := sha256.Sum256(message)

    // Signing - Like signing with a very curvy pen
    r, s, err := ecdsa.Sign(rand.Reader, privateKey, hash[:])
    if err != nil {
        panic("Our curvy signature got a bit too curvy!")
    }

    fmt.Printf("Our elliptic signature: (r=%x, s=%x)\n", r, s)

    // Verification - Checking if our curvy signature is legit
    valid := ecdsa.Verify(publicKey, hash[:], r, s)
    fmt.Printf("Is our curvy signature valid? %v\n", valid)
}

金鑰管理：確保您的數位身分安全

現在，我們來談談如何確保這些金鑰的安全。這就像擁有一把非常重要的鑰匙，打開一扇非常重要的門 - 您希望確保它的安全！

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

func main() {
    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)

    // Encoding our private key - Like putting it in a special envelope
    privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
    privateKeyPEM := pem.EncodeToMemory(&pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: privateKeyBytes,
    })

    fmt.Printf("Our key in its special envelope:\n%s\n", privateKeyPEM)

    // Decoding our private key - Taking it out of the envelope
    block, _ := pem.Decode(privateKeyPEM)
    decodedPrivateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        panic("We forgot how to open our own envelope!")
    }

    fmt.Printf("Our key, safe and sound: %v\n", decodedPrivateKey)
}

公鑰密碼學的黃金法則

既然您正在使用這些強大的加密工具，請記住以下一些黃金規則：

1. 大小很重要：對於 RSA，要麼變大，要麼回家 - 至少 2048 位。對於 ECC，256 位元是最佳選擇。

2. 隨機性是你的朋友：總是使用加密/隨機數字來產生金鑰。使用弱隨機性就像使用“password123”作為密鑰。

3. 輪換您的密鑰：就像更改密碼一樣，定期輪換您的密鑰。

4. 標準格式之所以成為標準是有原因的：使用 PEM 來儲存和發送金鑰。這就像使用標準信封 - 每個人都知道如何處理它。

5. 填充不僅適用於家具：對於 RSA 加密，請始終使用 OAEP 填充。它就像是加密資料的氣泡包裝。

6. 簽名前雜湊：簽署大數據時，對雜湊值進行簽名，而不是資料本身。它更快而且同樣安全。

7. 效能很重要：公鑰操作可能很慢，尤其是 RSA。明智地使用它們。

接下來是什麼？

恭喜！您剛剛將公鑰加密新增到您的工具包。這些技術非常適合安全通訊、數位簽名以及在互聯網的狂野西部建立信任。

接下來，我們將深入研究數位簽章及其應用程式。這就像學習以一種無法偽造的方式寫下你的名字 - 很酷，對吧？

請記住，在密碼學領域，理解這些基礎知識至關重要。這就像在開始開車之前學習道路規則一樣。掌握這些，您將能夠順利地在 Go 中建立安全、強大的應用程式。

那麼，您嘗試使用朋友的公鑰為朋友加密訊息怎麼樣？或者也許實現一個簡單的數位簽章系統？安全、經過身份驗證的通訊世界觸手可及！快樂編碼，加密冠軍！

以上是公鑰密碼學：數位握手，Go Crypto 5的詳細內容。更多資訊請關注PHP中文網其他相關文章！