Armazenando a chave privada ECDSA no Go

Ao trabalhar com pares de chaves ECDSA no Go, surge a necessidade de armazenar a chave privada com segurança. Embora o método elliptic.Marshal forneça codificação para a chave pública, não há equivalente para a chave privada. Este artigo explora como salvar e carregar chaves privadas em Go.

Codificação e decodificação

Para armazenar a chave privada, é necessário adotar uma abordagem de várias etapas envolvendo Criptografia de chave ECDSA, codificação padrão e formato de arquivo. A combinação comum envolve o uso do algoritmo ECDSA para geração de chave, X.509 para codificação e o formato PEM (Privacy-Enhanced Mail) para armazenamento.

Exemplo de código

O trecho de código a seguir demonstra como codificar e decodificar chaves ECDSA em 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.")
    }
}

Na função de teste:

1. Um novo par de chaves privadas/públicas ECDSA é gerado.
2. As chaves privadas e públicas são codificadas e as strings codificadas são impresso.
3. As strings codificadas são decodificadas para recuperar as chaves originais.
4. As chaves recuperadas são comparadas com as originais para verificar se elas match.

Ao utilizar as técnicas descritas acima, você pode armazenar e recuperar com segurança chaves privadas ECDSA em Go, permitindo a criação e o gerenciamento de assinaturas digitais em seus aplicativos.