실제 암호화폐의 마법: Go&#s 암호화 패키지를 작동하게 하기, Go Crypto 13

안녕하세요, 암호화폐 마법사님! Go의 암호화폐 패키지로 실제 세계의 마법을 볼 준비가 되셨나요? 우리는 이 멋진 암호 주문을 모두 배웠습니다. 이제 이를 실용적인 마법에 사용해 보겠습니다! 안전한 파일 암호화 주문과 공개 키 인프라(PKI) 소환 의식이라는 두 가지 강력한 아티팩트를 만들겠습니다.

마법 #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을 사용한 안전한 파일 암호화를 보여줍니다. 여기에는 마법 사고로부터의 보호(오류 처리), nonce에 대한 안전한 난수 소환, 적절한 마법 키 관리 방법이 포함됩니다.

마법 #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&#s 암호화 패키지를 작동하게 하기, Go Crypto 13의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!