Wie kann ich private ECDSA-Schlüssel in Go sicher speichern und abrufen?

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:

In der Testfunktion:

Ein neues privates/öffentliches ECDSA-Schlüsselpaar wird generiert.

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

Die privaten und öffentlichen Schlüssel werden codiert und die codierten Zeichenfolgen werden gedruckt.

Die codierten Zeichenfolgen werden decodiert, um die Originalschlüssel wiederherzustellen.

1. Die wiederhergestellten Schlüssel werden mit denen verglichen Originale, 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.

Das obige ist der detaillierte Inhalt vonWie kann ich private ECDSA-Schlüssel in Go sicher speichern und abrufen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!