Comment puis-je stocker et récupérer en toute sécurité les clés privées ECDSA dans Go ?

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 le test fonction :

1. Une nouvelle paire de clés privée/publique ECDSA est générée.
2. Les clés privées et publiques sont codées et les chaînes codées sont imprimées.
3. Les clés codées les chaînes 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 match.

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.

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!