Comment stocker les clés privées ECDSA en toute sécurité dans Go ?

Stockage des clés privées ECDSA dans Go

Lorsque vous travaillez avec des paires de clés ECDSA dans Go, il est souvent nécessaire de stocker la clé privée en toute sécurité. Ce guide abordera les techniques permettant de stocker efficacement les clés privées dans des fichiers sur l'ordinateur de l'utilisateur.

Encodage et décodage des clés privées

Go ne fournit pas de mécanisme direct de marshaling. clés privées en utilisant la méthode elliptic.Marshal. Au lieu de cela, un processus d'encodage en plusieurs étapes est requis :

1. Algorithme cryptographique : Utilisez l'algorithme ECDSA pour générer une clé, telle que ecdsa.GenerateKey(elliptic.P384(), rand.Reader).
2. Encodage standard :Convertir la clé privée au format x509 à l'aide de x509.MarshalECPrivateKey(privateKey).
3. Format de fichier : Encodez la structure x509 au format PEM à l'aide de pem.EncodeToMemory(block), où block représente la structure x509 .

Échantillon Code

Le code Go suivant illustre le processus ci-dessus :

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

En stockant la clé privée codée PEM sous forme de fichier, elle peut être récupérée et décodée ultérieurement si nécessaire. N'oubliez pas de prendre des mesures de sécurité appropriées pour protéger le fichier contre tout accès ou exposition non autorisé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!