Kriptografi Kunci Awam: Jabat Tangan Digital, Go Crypto 5

Hai, penjelajah kripto! Bersedia untuk menyelami dunia kriptografi kunci awam yang menarik? Fikirkan ia sebagai setara digital jabat tangan rahsia yang boleh anda lakukan di khalayak ramai. Bunyi mustahil? Mari kita pecahkan dan lihat cara Go membantu kami melakukan helah sihir kriptografi ini!

RSA: The Granddaddy of Public-Key Crypto

Pertama sekali, kami mempunyai RSA (Rivest-Shamir-Adleman). Ia seperti datuk tua yang bijak dalam sistem kunci awam - telah wujud sejak sekian lama dan masih kukuh.

Penjanaan Utama RSA: Identiti Digital Anda

Mari mulakan dengan mencipta kunci RSA kami:

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

Penyulitan dan Penyahsulitan RSA: Melewati Nota Rahsia

Sekarang, mari gunakan kekunci ini untuk menghantar mesej rahsia:

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

Tandatangan dan Pengesahan RSA: Tandatangan Digital Anda

RSA bukan sahaja untuk mesej rahsia. Ia juga boleh mencipta tandatangan digital:

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

Kriptografi Lengkung Eliptik (ECC): Anak Baharu di Blok

Sekarang, mari bercakap tentang ECC. Ia seperti sepupu RSA yang lebih sejuk, lebih cekap. Ia menawarkan keselamatan yang serupa dengan kekunci yang lebih kecil, yang bagus untuk peranti mudah alih dan IoT.

Penjanaan Utama ECDSA: Identiti Eliptik Anda

Mari cipta kunci ECC kami:

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

Tandatangan dan Pengesahan ECDSA: Tandatangan Curvy

Sekarang, mari kita tandatangani sesuatu dengan kunci eliptik kami:

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

Pengurusan Utama: Menjaga Identiti Digital Anda Selamat

Sekarang, mari kita bincangkan tentang memastikan kunci ini selamat. Ia seperti mempunyai kunci yang sangat penting untuk pintu yang sangat penting - anda mahu memastikannya selamat!

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

Peraturan Emas Kriptografi Kunci Awam

Sekarang anda menggunakan alat crypto yang berkuasa ini, berikut ialah beberapa peraturan emas yang perlu diingat:

1. Saiz penting: Untuk RSA, pergi besar atau pulang ke rumah - sekurang-kurangnya 2048 bit. Untuk ECC, 256 bit ialah titik manis.

2. Randomness ialah rakan anda: Sentiasa gunakan crypto/rand untuk penjanaan kunci. Menggunakan rawak yang lemah adalah seperti menggunakan "kata laluan123" sebagai kunci anda.

3. Putar kekunci anda: Seperti menukar kata laluan anda, putar kunci anda dengan kerap.

4. Format standard adalah standard atas sebab tertentu: Gunakan PEM untuk menyimpan dan menghantar kunci. Ia seperti menggunakan sampul surat biasa - semua orang tahu cara mengendalikannya.

5. Padding bukan hanya untuk perabot: Untuk penyulitan RSA, sentiasa gunakan padding OAEP. Ia seperti balut gelembung untuk data anda yang disulitkan.

6. Cincang sebelum anda menandatangani: Apabila menandatangani data besar, tandatangani cincang, bukan data itu sendiri. Ia lebih pantas dan sama selamat.

7. Perkara prestasi: Operasi kunci awam boleh menjadi perlahan, terutamanya RSA. Gunakannya dengan bijak.

Apa Seterusnya?

Tahniah! Anda baru sahaja menambahkan kriptografi kunci awam pada kit alat anda. Teknik ini sesuai untuk komunikasi selamat, tandatangan digital dan membina kepercayaan di barat liar internet.

Seterusnya, kami akan mendalami tandatangan digital dan aplikasinya. Ia seperti belajar menulis nama anda dengan cara yang mustahil untuk dipalsukan - cukup bagus, bukan?

Ingat, dalam dunia kriptografi, memahami asas ini adalah penting. Ia seperti mempelajari peraturan jalan raya sebelum anda mula memandu. Kuasai ini dan anda akan berjaya mencipta aplikasi yang selamat dan mantap dalam Go.

Jadi, bagaimana pula anda cuba menyulitkan mesej untuk rakan menggunakan kunci awam mereka? Atau mungkin melaksanakan sistem tandatangan digital yang mudah? Dunia komunikasi yang selamat dan disahkan berada di hujung jari anda! Selamat pengekodan, juara crypto!

Atas ialah kandungan terperinci Kriptografi Kunci Awam: Jabat Tangan Digital, Go Crypto 5. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!