La magie de la cryptographie dans le monde réel : mettre le package Crypto de Go au travail, Go Crypto 13

Hé là, magicien de la cryptographie ! Prêt à découvrir la magie du monde réel avec le package cryptographique de Go ? Nous avons appris tous ces sorts cryptographiques sympas, mettons-les maintenant à profit dans des enchantements pratiques ! Nous allons créer deux artefacts puissants : un sort de cryptage de fichiers sécurisé et un rituel d'invocation d'infrastructure à clé publique (PKI).

Enchantement n°1 : le sort de cryptage sécurisé des fichiers

Créons un parchemin magique capable de crypter et de décrypter des fichiers en toute sécurité à l'aide du puissant enchantement AES-GCM (Galois/Counter Mode). Ce sort offre à la fois une protection contre le secret et l'intégrité !

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>Ce parchemin magique démontre le cryptage sécurisé des fichiers à l'aide d'AES-GCM. Il comprend une protection contre les incidents magiques (gestion des erreurs), une invocation sécurisée de nombres aléatoires pour le moment et des pratiques appropriées de gestion des clés magiques.</p>

<h2>
  
  
  Enchantement n°2 : Le rituel d'invocation PKI
</h2>

<p>Maintenant, effectuons un rituel plus complexe pour invoquer un système de base d'infrastructure à clé publique (PKI). Ce système peut générer des certificats magiques, les signer avec une autorité de certification (CA) et vérifier ces documents mystiques.<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.")
}

Ce rituel mystique démontre la création d'un système PKI simple, comprenant :

1. Invoquer une autorité de certification (CA)
2. Utiliser l'AC pour bénir un certificat de domaine avec sa signature magique
3. Inscription de certificats et clés privées sur des parchemins magiques (format PEM)

Ces exemples présentent des applications réelles du package de chiffrement de Go, démontrant le cryptage sécurisé des fichiers et un système PKI de base. Ils intègrent bon nombre des meilleures pratiques et concepts dont nous avons discuté, tels que la gestion appropriée des clés, la génération sécurisée de nombres aléatoires et l'utilisation d'algorithmes cryptographiques modernes.

N'oubliez pas, jeune sorcier, lorsque vous implémentez ces systèmes cryptographiques dans le monde réel, assurez-vous toujours que vos sorts sont soigneusement examinés et testés par d'autres maîtres sorciers. Et pour les composants magiques les plus critiques, envisagez d'utiliser des grimoires (bibliothèques) établis lorsque cela est possible.

Maintenant, lancez vos sorts cryptographiques de manière responsable ! Que vos secrets restent secrets et que vos identités restent vérifiées !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!