Krypto-Magie aus der realen Welt: Das Krypto-Paket von Go in die Tat umsetzen, Go Crypto 13

Hey, Krypto-Zauberer! Sind Sie bereit, mit dem Kryptopaket von Go echte Magie zu erleben? Wir haben all diese coolen Krypto-Zauber gelernt, jetzt wollen wir sie in einigen praktischen Verzauberungen anwenden! Wir werden zwei mächtige Artefakte erstellen: einen sicheren Dateiverschlüsselungszauber und ein Beschwörungsritual für die Public Key Infrastructure (PKI).

Verzauberung Nr. 1: Der Zauber zur sicheren Dateiverschlüsselung

Lassen Sie uns eine magische Schriftrolle erstellen, die Dateien mithilfe der mächtigen AES-GCM-Verzauberung (Galois/Counter-Modus) sicher verschlüsseln und entschlüsseln kann. Dieser Zauber bietet sowohl Geheimhaltungs- als auch Integritätsschutz!

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>Diese magische Schriftrolle demonstriert die sichere Dateiverschlüsselung mit AES-GCM. Dazu gehören Schutz vor magischen Pannen (Fehlerbehandlung), sicheres Beschwören von Zufallszahlen für den Moment und ordnungsgemäße Praktiken zur Verwaltung magischer Schlüssel.</p>

<h2>
  
  
  Verzauberung Nr. 2: Das PKI-Beschwörungsritual
</h2>

<p>Lassen Sie uns nun ein komplexeres Ritual durchführen, um ein grundlegendes Public-Key-Infrastruktursystem (PKI) zu beschwören. Dieses System kann magische Zertifikate generieren, sie bei einer Zertifizierungsstelle (CA) signieren und diese mystischen Dokumente überprüfen.<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.")
}

Dieses mystische Ritual demonstriert die Schaffung eines einfachen PKI-Systems, einschließlich:

1. Einberufung einer Zertifizierungsstelle (CA)
2. Verwendung der CA, um ein Domänenzertifikat mit seiner magischen Signatur zu segnen
3. Einschreiben von Zertifikaten und privaten Schlüsseln auf magische Pergamente (PEM-Format)

Diese Beispiele zeigen reale Anwendungen des Kryptopakets von Go und demonstrieren eine sichere Dateiverschlüsselung und ein grundlegendes PKI-System. Sie beinhalten viele der von uns besprochenen Best Practices und Konzepte, wie z. B. ordnungsgemäße Schlüsselverwaltung, sichere Zufallszahlengenerierung und die Verwendung moderner kryptografischer Algorithmen.

Denken Sie daran, junger Zauberer: Stellen Sie bei der Implementierung dieser kryptografischen Systeme in der realen Welt immer sicher, dass Ihre Zauber von anderen Meisterzauberern gründlich überprüft und getestet werden. Und für die wichtigsten magischen Komponenten sollten Sie nach Möglichkeit die Verwendung etablierter Grimoires (Bibliotheken) in Betracht ziehen.

Jetzt machen Sie sich auf den Weg und wirken Sie Ihre Krypto-Zauber verantwortungsbewusst! Mögen Ihre Geheimnisse geheim bleiben und Ihre Identität bestätigt bleiben!

Das obige ist der detaillierte Inhalt vonKrypto-Magie aus der realen Welt: Das Krypto-Paket von Go in die Tat umsetzen, Go Crypto 13. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!