Hai, ahli sihir crypto! Bersedia untuk melihat beberapa keajaiban dunia sebenar dengan pakej crypto Go? Kami telah mempelajari semua mantra kripto yang hebat ini, sekarang mari kita gunakannya dalam beberapa pesona praktikal! Kami akan mencipta dua artifak berkuasa: ejaan penyulitan fail selamat dan upacara pemanggilan Infrastruktur Kunci Awam (PKI).
Mari kita cipta skrol ajaib yang boleh menyulitkan dan menyahsulit fail dengan selamat menggunakan pesona AES-GCM (Galois/Counter Mode) yang hebat. Mantra ini menyediakan kedua-dua kerahsiaan dan perlindungan integriti!
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!")
}
Tatal ajaib ini menunjukkan penyulitan fail selamat menggunakan AES-GCM. Ia termasuk perlindungan terhadap kemalangan ajaib (pengendalian ralat), pemanggilan nombor rawak yang selamat untuk nonce dan amalan pengurusan kunci ajaib yang betul.
Sekarang, mari kita lakukan ritual yang lebih kompleks untuk memanggil sistem Infrastruktur Kunci Awam (PKI) asas. Sistem ini boleh menjana sijil ajaib, menandatanganinya dengan Pihak Berkuasa Sijil (CA) dan mengesahkan dokumen mistik ini.
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.")
}
Ritual mistik ini menunjukkan penciptaan sistem PKI yang mudah, termasuk:
Contoh ini mempamerkan aplikasi dunia sebenar pakej crypto Go, menunjukkan penyulitan fail selamat dan sistem PKI asas. Ia menggabungkan banyak amalan dan konsep terbaik yang telah kami bincangkan, seperti pengurusan kunci yang betul, penjanaan nombor rawak selamat dan penggunaan algoritma kriptografi moden.
Ingat, ahli sihir muda, apabila melaksanakan sistem kriptografi ini di dunia nyata, sentiasa pastikan mantra anda disemak dan diuji dengan teliti oleh ahli sihir induk yang lain. Dan untuk komponen ajaib yang paling kritikal, pertimbangkan untuk menggunakan grimoires (perpustakaan) sedia ada apabila boleh.
Sekarang maju dan lakukan mantra crypto anda dengan penuh tanggungjawab! Semoga rahsia anda kekal rahsia dan identiti anda kekal disahkan!
Atas ialah kandungan terperinci Sihir Kripto Dunia Sebenar: Meletakkan Pakej Kripto Go Berfungsi, Go Crypto 13. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
