Stockage de la clé privée ECDSA dans Go

Lorsque vous travaillez avec des paires de clés ECDSA dans Go, il est nécessaire de stocker la clé privée en toute sécurité. Bien que la méthode elliptic.Marshal fournisse le codage de la clé publique, il n'existe pas d'équivalent pour la clé privée. Cet article explique comment enregistrer et charger des clés privées dans Go.

Encodage et décodage

Pour stocker la clé privée, il est nécessaire d'adopter une approche en plusieurs étapes impliquant Cryptage par clé ECDSA, codage standard et format de fichier. La combinaison courante implique l'utilisation de l'algorithme ECDSA pour la génération de clés, de X.509 pour le codage et du format PEM (Privacy-Enhanced Mail) pour le stockage.

Exemple de code

L'extrait de code suivant montre comment encoder et décoder les clés ECDSA dans Go :

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

Dans la fonction de test :

1. Une nouvelle paire de clés privée/publique ECDSA est générée.
2. Les clés privée et publique sont codées et les chaînes codées sont imprimé.
3. Les chaînes encodées sont décodées pour récupérer les clés d'origine.
4. Les clés récupérées sont comparées à celles d'origine pour vérifier si elles correspondent.

En utilisant les techniques décrites ci-dessus, vous pouvez stocker et récupérer en toute sécurité les clés privées ECDSA dans Go, permettant la création et la gestion de signatures numériques au sein de vos applications.