現実世界の暗号マジック: Go の暗号パッケージを機能させる、Go Crypto 13

こんにちは、暗号魔術師! Go の暗号パッケージを使って現実世界の魔法を体験してみませんか?これらのクールな暗号呪文をすべて学びました。今度はそれらをいくつかの実用的なエンチャントで使用してみましょう!安全なファイル暗号化の呪文と公開鍵基盤 (PKI) の召喚儀式という 2 つの強力なアーティファクトを作成します。

エンチャント #1: 安全なファイル暗号化の呪文

強力な AES-GCM (ガロア/カウンター モード) エンチャントを使用して、ファイルを安全に暗号化および復号化できる魔法の巻物を作成しましょう。この呪文は、秘密と完全性の両方を保護します!

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) < gcm.NonceSize() {
        return nil, errors.New("ciphertext too short")
    }

    nonce, ciphertext := ciphertext[:gcm.NonceSize()], ciphertext[gcm.NonceSize():]
    return gcm.Open(nil, nonce, ciphertext, nil)
}

// Enchant a file with our encryption spell
func encryptFile(inputFile, outputFile string, key []byte) error {
    plaintext, err := os.ReadFile(inputFile)
    if err != nil {
        return err
    }

    ciphertext, err := encrypt(plaintext, key)
    if err != nil {
        return err
    }

    return os.WriteFile(outputFile, ciphertext, 0644)
}

// Remove the encryption enchantment from a file
func decryptFile(inputFile, outputFile string, key []byte) error {
    ciphertext, err := os.ReadFile(inputFile)
    if err != nil {
        return err
    }

    plaintext, err := decrypt(ciphertext, key)
    if err != nil {
        return err
    }

    return os.WriteFile(outputFile, plaintext, 0644)
}

func main() {
    // Summon a magical key
    key := make([]byte, 32) // AES-256
    if _, err := rand.Read(key); err != nil {
        panic("Our magical key summoning failed!")
    }

    // Cast our encryption spell
    err := encryptFile("secret_scroll.txt", "encrypted_scroll.bin", key)
    if err != nil {
        panic("Our encryption spell fizzled!")
    }
    fmt.Println("Scroll successfully enchanted with secrecy!")

    // Remove the encryption enchantment
    err = decryptFile("encrypted_scroll.bin", "decrypted_scroll.txt", key)
    if err != nil {
        panic("Our decryption counter-spell backfired!")
    }
    fmt.Println("Scroll successfully disenchanted!")
}

この魔法の巻物は、AES-GCM を使用した安全なファイル暗号化を示しています。これには、魔法の事故に対する保護 (エラー処理)、ノンスの乱数の安全な呼び出し、適切な魔法のキー管理の実践が含まれます。

エンチャント #2: PKI 召喚の儀式

ここで、より複雑な儀式を実行して、基本的な公開鍵インフラストラクチャ (PKI) システムを呼び出しましょう。このシステムは、魔法の証明書を生成し、認証局 (CA) で署名し、これらの神秘的な文書を検証できます。

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

この神秘的な儀式は、次のような単純な PKI システムの作成を示しています。

1. 認証局 (CA) の呼び出し
2. CA を使用して、魔法の署名でドメイン証明書を祝福する
3. 魔法の羊皮紙への証明書と秘密鍵の書き込み (PEM 形式)

これらの例は、Go の暗号パッケージの実際のアプリケーションを示し、安全なファイル暗号化と基本的な PKI システムを示しています。これらには、適切なキー管理、安全な乱数生成、最新の暗号化アルゴリズムの使用など、これまでに説明したベスト プラクティスや概念の多くが組み込まれています。

覚えておいてください、若い魔法使いよ、これらの暗号システムを現実世界に実装するときは、あなたの呪文が他のマスター魔法使いによって徹底的にレビューされ、テストされていることを常に確認してください。そして、最も重要な魔法のコンポーネントについては、可能であれば確立されたグリモワール (ライブラリ) の使用を検討してください。

さあ、責任を持って暗号呪文を唱えてください!あなたの秘密が秘密のまま、あなたの身元が確認されたままになりますように!

以上が現実世界の暗号マジック: Go の暗号パッケージを機能させる、Go Crypto 13の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。