公開鍵暗号: デジタルハンドシェイク、Go Crypto 5-Golang-php.cn

Public-Key Cryptography: The Digital Handshake, Go Crypto 5

こんにちは、暗号探検家!公開鍵暗号の魅力的な世界に飛び込む準備はできていますか?これは、公共の場で行う秘密の握手のデジタル版と考えてください。不可能だと思われますか？分析して、この暗号魔法のトリックを実行するのに Go がどのように役立つかを見てみましょう!

RSA: 公開鍵暗号の祖父

まず、RSA (Rivest-Shamir-Adleman) です。それは、公開鍵システムの賢明な祖父のようなものです - 何年も前から存在し、今でも強力です。

RSA キーの生成: デジタル ID

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 のよりクールで効率的な従兄弟のようなものです。より小さいキーでも同様のセキュリティを提供するため、モバイルや IoT デバイスに最適です。

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 の署名と検証: Curvy 署名

さて、楕円キーを使って何かに署名してみましょう:

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)
}

ログイン後にコピー

キー管理: デジタル ID を安全に保つ

さて、これらの鍵を安全に保管する方法について話しましょう。それは、本当に重要なドアの非常に重要な鍵を持っているようなものです。それを安全に保管しておきたいと考えます。

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)
}

ログイン後にコピー

公開鍵暗号化の黄金律

これらの強力な暗号化ツールを使用しているので、心に留めておくべきいくつかの黄金律を以下に示します。

サイズは重要です: RSA の場合、大きくするか家に帰るか - 少なくとも 2048 ビット。 ECC の場合、256 ビットがスイートスポットです。
ランダム性は味方です: キーの生成には常に crypto/rand を使用します。弱いランダム性を使用することは、「password123」をキーとして使用することに似ています。
キーをローテーションします: パスワードを変更するのと同様に、キーを定期的にローテーションします。
標準形式には理由があります: キーの保存と送信には PEM を使用します。これは標準的な封筒を使用するようなもので、誰もがその扱い方を知っています。
パディングは家具だけではありません: RSA 暗号化の場合は、常に OAEP パディングを使用してください。これは、暗号化されたデータを緩衝材で包むようなものです。
署名前にハッシュする: 大きなデータに署名する場合は、データ自体ではなくハッシュに署名します。より高速かつ安全です。
パフォーマンスの問題: 公開鍵の操作は、特に RSA で遅くなることがあります。賢く使用してください。