Wie speichere ich private ECDSA-Schlüssel sicher in Go?

ECDSA-Privatschlüssel in Go speichern

Bei der Arbeit mit ECDSA-Schlüsselpaaren in Go besteht häufig die Notwendigkeit, den privaten Schlüssel sicher zu speichern. Dieser Leitfaden befasst sich mit Techniken zum effektiven Speichern privater Schlüssel in Dateien auf dem Computer des Benutzers.

Codieren und Decodieren privater Schlüssel

Go bietet keinen direkten Mechanismus für das Marshalling private Schlüssel mithilfe der elliptic.Marshal-Methode. Stattdessen ist ein mehrstufiger Codierungsprozess erforderlich:

1. Kryptografischer Algorithmus: Verwenden Sie den ECDSA-Algorithmus, um einen Schlüssel zu generieren, z. B. ecdsa.GenerateKey(elliptic.P384(), rand.Reader).
2. Standardkodierung: Konvertieren Sie den privaten Schlüssel in das x509-Format mit x509.MarshalECPrivateKey(privateKey).
3. Dateiformat: Kodieren Sie die x509-Struktur in das PEM-Format mit pem.EncodeToMemory(block), wobei block die x509-Struktur darstellt.

Probe Code

Der folgende Go-Code demonstriert den obigen Prozess:

package main

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

Durch die Speicherung des PEM-codierten privaten Schlüssels als Datei kann er später bei Bedarf abgerufen und dekodiert werden. Denken Sie daran, geeignete Sicherheitsmaßnahmen zu ergreifen, um die Datei vor unbefugtem Zugriff oder Offenlegung zu schützen.

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