Speichern des privaten ECDSA-Schlüssels in Go

Bei der Arbeit mit ECDSA-Schlüsselpaaren in Go besteht die Notwendigkeit, den privaten Schlüssel sicher zu speichern. Während die elliptic.Marshal-Methode die Codierung für den öffentlichen Schlüssel bereitstellt, gibt es kein Äquivalent für den privaten Schlüssel. In diesem Artikel wird erläutert, wie private Schlüssel in Go gespeichert und geladen werden.

Kodierung und Dekodierung

Um den privaten Schlüssel zu speichern, ist ein mehrstufiger Ansatz erforderlich ECDSA-Schlüsselverschlüsselung, Standardkodierung und ein Dateiformat. Die übliche Kombination umfasst die Verwendung des ECDSA-Algorithmus zur Schlüsselgenerierung, ]Der folgende Codeausschnitt zeigt, wie ECDSA-Schlüssel in Go kodiert und dekodiert werden:

import ( „Krypto/ecdsa“ „Krypto/elliptisch“ „Krypto/Rand“ „Krypto/x509“ „Kodierung/pem“ „fmt“ "reflektieren" ) func encode(privateKey *ecdsa.PrivateKey, publicKey *ecdsa.PublicKey) (string, string) { x509Encoded, _ := x509.MarshalECPrivateKey(privateKey) pemEncoded := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: x509Encoded}) x509EncodedPub, _ := x509.MarshalPKIXPublicKey(publicKey) pemEncodedPub := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: x509EncodedPub}) Rückgabe string(pemEncoded), string(pemEncodedPub) } func decode(pemEncoded string, pemEncodedPub string) (*ecdsa.PrivateKey, *ecdsa.PublicKey) { block, _ := pem.Decode([]byte(pemEncoded)) x509Encoded := block.Bytes privateKey, _ := x509.ParseECPrivateKey(x509Encoded) blockPub, _ := pem.Decode([]byte(pemEncodedPub)) x509EncodedPub := blockPub.Bytes genericPublicKey, _ := x509.ParsePKIXPublicKey(x509EncodedPub) publicKey := genericPublicKey.(*ecdsa.PublicKey) Geben Sie privateKey und publicKey zurück } func test() { privateKey, _ := ecdsa.GenerateKey(elliptic.P384(), rand.Reader) publicKey := &privateKey.PublicKey encPriv, encPub := encode(privateKey, publicKey) fmt.Println(encPriv) fmt.Println(encPub) priv2, pub2 := decode(encPriv, encPub) if !reflect.DeepEqual(privateKey, priv2) { fmt.Println("Private Schlüssel stimmen nicht überein.") } if !reflect.DeepEqual(publicKey, pub2) { fmt.Println("Öffentliche Schlüssel stimmen nicht überein.") } }In der Testfunktion:

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "reflect"
)

func encode(privateKey *ecdsa.PrivateKey, publicKey *ecdsa.PublicKey) (string, string) {
    x509Encoded, _ := x509.MarshalECPrivateKey(privateKey)
    pemEncoded := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: x509Encoded})

    x509EncodedPub, _ := x509.MarshalPKIXPublicKey(publicKey)
    pemEncodedPub := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: x509EncodedPub})

    return string(pemEncoded), string(pemEncodedPub)
}

func decode(pemEncoded string, pemEncodedPub string) (*ecdsa.PrivateKey, *ecdsa.PublicKey) {
    block, _ := pem.Decode([]byte(pemEncoded))
    x509Encoded := block.Bytes
    privateKey, _ := x509.ParseECPrivateKey(x509Encoded)

    blockPub, _ := pem.Decode([]byte(pemEncodedPub))
    x509EncodedPub := blockPub.Bytes
    genericPublicKey, _ := x509.ParsePKIXPublicKey(x509EncodedPub)
    publicKey := genericPublicKey.(*ecdsa.PublicKey)

    return privateKey, publicKey
}

func test() {
    privateKey, _ := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
    publicKey := &privateKey.PublicKey

    encPriv, encPub := encode(privateKey, publicKey)

    fmt.Println(encPriv)
    fmt.Println(encPub)

    priv2, pub2 := decode(encPriv, encPub)

    if !reflect.DeepEqual(privateKey, priv2) {
        fmt.Println("Private keys do not match.")
    }
    if !reflect.DeepEqual(publicKey, pub2) {
        fmt.Println("Public keys do not match.")
    }
}

1. Die wiederhergestellten Schlüssel werden mit dem Original verglichen diejenigen, um zu überprüfen, ob sie übereinstimmen.
2. Durch die Verwendung der oben beschriebenen Techniken können Sie private ECDSA-Schlüssel in Go sicher speichern und abrufen und so die Erstellung und Verwaltung digitaler Signaturen in Ihren Anwendungen ermöglichen.