公開鍵暗号: デジタル ハンドシェイク、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)
}

公開鍵暗号化の黄金律

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

1. サイズは重要です: RSA の場合、大きくするか家に帰るか - 少なくとも 2048 ビット。 ECC の場合、256 ビットがスイート スポットです。

2. ランダム性は味方です: キーの生成には常に crypto/rand を使用します。弱いランダム性を使用することは、「password123」をキーとして使用することに似ています。

3. キーをローテーションします: パスワードを変更するのと同様に、キーを定期的にローテーションします。

4. 標準形式には理由があります: キーの保存と送信には PEM を使用します。これは標準的な封筒を使用するようなもので、誰もがその扱い方を知っています。

5. パディングは家具だけではありません: RSA 暗号化の場合は、常に OAEP パディングを使用してください。これは、暗号化されたデータを緩衝材で包むようなものです。

6. 署名前にハッシュする: 大きなデータに署名する場合は、データ自体ではなくハッシュに署名します。より高速かつ安全です。

7. パフォーマンスの問題: 公開鍵の操作は、特に RSA で遅くなることがあります。賢く使用してください。

次は何ですか?

おめでとうございます!公開キー暗号化をツールキットに追加しました。これらの技術は、インターネットの荒野における安全な通信、デジタル署名、信頼の構築に最適です。

次は、デジタル署名とその応用について詳しく見ていきます。それは、偽造不可能な方法で自分の名前を書くことを学ぶようなものです - とてもクールですよね?

暗号の世界では、これらの基本を理解することが重要であることを覚えておいてください。運転を始める前に交通ルールを学ぶようなものです。これらをマスターすれば、Go で安全で堅牢なアプリケーションを作成できるようになります。

それでは、公開キーを使用して友人へのメッセージを暗号化してみてはどうでしょうか?それとも単純なデジタル署名システムを実装するのでしょうか?安全で認証された通信の世界がすぐに利用できます。コーディングを楽しんでください、暗号化チャンピオン!

以上が公開鍵暗号: デジタル ハンドシェイク、Go Crypto 5の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。