Sihir Kripto Dunia Sebenar: Meletakkan Pakej Kripto Go Berfungsi, Go Crypto 13

Hai, ahli sihir crypto! Bersedia untuk melihat beberapa keajaiban dunia sebenar dengan pakej crypto Go? Kami telah mempelajari semua mantra kripto yang hebat ini, sekarang mari kita gunakannya dalam beberapa pesona praktikal! Kami akan mencipta dua artifak berkuasa: ejaan penyulitan fail selamat dan upacara pemanggilan Infrastruktur Kunci Awam (PKI).

Pesona #1: Ejaan Penyulitan Fail Selamat

Mari kita cipta skrol ajaib yang boleh menyulitkan dan menyahsulit fail dengan selamat menggunakan pesona AES-GCM (Galois/Counter Mode) yang hebat. Mantra ini menyediakan kedua-dua kerahsiaan dan perlindungan integriti!

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "errors"
    "fmt"
    "io"
    "os"
)

// Our encryption spell
func encrypt(plaintext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    nonce := make([]byte, gcm.NonceSize())
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }

    return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

// Our decryption counter-spell
func decrypt(ciphertext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    if len(ciphertext) 



<p>Tatal ajaib ini menunjukkan penyulitan fail selamat menggunakan AES-GCM. Ia termasuk perlindungan terhadap kemalangan ajaib (pengendalian ralat), pemanggilan nombor rawak yang selamat untuk nonce dan amalan pengurusan kunci ajaib yang betul.</p>

<h2>
  
  
  Pesona #2: Ritual Panggilan PKI
</h2>

<p>Sekarang, mari kita lakukan ritual yang lebih kompleks untuk memanggil sistem Infrastruktur Kunci Awam (PKI) asas. Sistem ini boleh menjana sijil ajaib, menandatanganinya dengan Pihak Berkuasa Sijil (CA) dan mengesahkan dokumen mistik ini.<br>
</p>

<pre class="brush:php;toolbar:false">package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "fmt"
    "math/big"
    "os"
    "time"
)

// Summon a magical key pair
func generateKey() (*ecdsa.PrivateKey, error) {
    return ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
}

// Create a mystical certificate
func createCertificate(template, parent *x509.Certificate, pub interface{}, priv interface{}) (*x509.Certificate, []byte, error) {
    certDER, err := x509.CreateCertificate(rand.Reader, template, parent, pub, priv)
    if err != nil {
        return nil, nil, err
    }

    cert, err := x509.ParseCertificate(certDER)
    if err != nil {
        return nil, nil, err
    }

    return cert, certDER, nil
}

// Summon a Certificate Authority
func generateCA() (*x509.Certificate, *ecdsa.PrivateKey, error) {
    caPrivKey, err := generateKey()
    if err != nil {
        return nil, nil, err
    }

    template := x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject: pkix.Name{
            Organization: []string{"Wizards' Council"},
        },
        NotBefore:             time.Now(),
        NotAfter:              time.Now().AddDate(10, 0, 0),
        KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
        ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
        BasicConstraintsValid: true,
        IsCA:                  true,
    }

    caCert, _, err := createCertificate(&template, &template, &caPrivKey.PublicKey, caPrivKey)
    if err != nil {
        return nil, nil, err
    }

    return caCert, caPrivKey, nil
}

// Generate a certificate for a magical domain
func generateCertificate(caCert *x509.Certificate, caPrivKey *ecdsa.PrivateKey, domain string) (*x509.Certificate, *ecdsa.PrivateKey, error) {
    certPrivKey, err := generateKey()
    if err != nil {
        return nil, nil, err
    }

    template := x509.Certificate{
        SerialNumber: big.NewInt(2),
        Subject: pkix.Name{
            Organization: []string{"Wizards' Guild"},
            CommonName:   domain,
        },
        NotBefore:   time.Now(),
        NotAfter:    time.Now().AddDate(1, 0, 0),
        KeyUsage:    x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
        ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
        DNSNames:    []string{domain},
    }

    cert, _, err := createCertificate(&template, caCert, &certPrivKey.PublicKey, caPrivKey)
    if err != nil {
        return nil, nil, err
    }

    return cert, certPrivKey, nil
}

// Inscribe a certificate onto a magical parchment (PEM)
func saveCertificateToPEM(cert *x509.Certificate, filename string) error {
    certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: cert.Raw})
    return os.WriteFile(filename, certPEM, 0644)
}

// Inscribe a private key onto a magical parchment (PEM)
func savePrivateKeyToPEM(privKey *ecdsa.PrivateKey, filename string) error {
    privKeyBytes, err := x509.MarshalECPrivateKey(privKey)
    if err != nil {
        return err
    }
    privKeyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: privKeyBytes})
    return os.WriteFile(filename, privKeyPEM, 0600)
}

func main() {
    // Summon the Certificate Authority
    caCert, caPrivKey, err := generateCA()
    if err != nil {
        panic("The CA summoning ritual failed!")
    }

    // Inscribe the CA certificate and private key
    err = saveCertificateToPEM(caCert, "ca_cert.pem")
    if err != nil {
        panic("Failed to inscribe the CA certificate!")
    }
    err = savePrivateKeyToPEM(caPrivKey, "ca_key.pem")
    if err != nil {
        panic("Failed to inscribe the CA private key!")
    }

    // Generate a certificate for a magical domain
    domain := "hogwarts.edu"
    cert, privKey, err := generateCertificate(caCert, caPrivKey, domain)
    if err != nil {
        panic("The domain certificate summoning failed!")
    }

    // Inscribe the domain certificate and private key
    err = saveCertificateToPEM(cert, "domain_cert.pem")
    if err != nil {
        panic("Failed to inscribe the domain certificate!")
    }
    err = savePrivateKeyToPEM(privKey, "domain_key.pem")
    if err != nil {
        panic("Failed to inscribe the domain private key!")
    }

    fmt.Println("The PKI summoning ritual was successful! CA and domain certificates have been manifested.")
}

Ritual mistik ini menunjukkan penciptaan sistem PKI yang mudah, termasuk:

1. Memanggil Pihak Berkuasa Sijil (CA)
2. Menggunakan CA untuk memberkati sijil domain dengan tandatangan ajaibnya
3. Memasukkan sijil dan kunci peribadi pada perkamen ajaib (format PEM)

Contoh ini mempamerkan aplikasi dunia sebenar pakej crypto Go, menunjukkan penyulitan fail selamat dan sistem PKI asas. Ia menggabungkan banyak amalan dan konsep terbaik yang telah kami bincangkan, seperti pengurusan kunci yang betul, penjanaan nombor rawak selamat dan penggunaan algoritma kriptografi moden.

Ingat, ahli sihir muda, apabila melaksanakan sistem kriptografi ini di dunia nyata, sentiasa pastikan mantra anda disemak dan diuji dengan teliti oleh ahli sihir induk yang lain. Dan untuk komponen ajaib yang paling kritikal, pertimbangkan untuk menggunakan grimoires (perpustakaan) sedia ada apabila boleh.

Sekarang maju dan lakukan mantra crypto anda dengan penuh tanggungjawab! Semoga rahsia anda kekal rahsia dan identiti anda kekal disahkan!

Atas ialah kandungan terperinci Sihir Kripto Dunia Sebenar: Meletakkan Pakej Kripto Go Berfungsi, Go Crypto 13. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!