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).
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) < 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!")
}
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.
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.
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:
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!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
