x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)

La fonction entre parenthèses dépend de ce que Go a détecté : `ParsePKCS1PrivateKey`, `ParseECPrivateKey` ou `ParsePKCS8PrivateKey`. L’équivalent pour les clés publiques est « x509: failed to parse public key (use ParsePKCS1PublicKey instead for this key format) ». Des octets qui ne correspondent à aucun de ces formats produisent plutôt une `asn1: structure error`.

Go crypto/x509 — ParsePKCS8PrivateKey / ParsePKCS1PrivateKey / ParseECPrivateKey / ParsePKIXPublicKey

Ce que cela signifie

Vous avez passé les octets DER d’un conteneur de clé privée à l’analyseur prévu pour un autre, et Go a reconnu de quel conteneur il s’agit réellement. Il existe trois encodages courants : PKCS#8 (`-----BEGIN PRIVATE KEY-----`, tout algorithme), PKCS#1 (`-----BEGIN RSA PRIVATE KEY-----`, RSA uniquement) et SEC 1 (`-----BEGIN EC PRIVATE KEY-----`, EC uniquement). L’indication entre parenthèses nomme la fonction qui analysera vos octets. La clé elle-même est correcte.

Pourquoi cela se produit

• Clé RSA en PKCS#1, le code attend du PKCS#8

  fréquente

  `openssl genrsa` (OpenSSL 1.x) et de nombreux outils plus anciens écrivent `RSA PRIVATE KEY` ; le code écrit pour la sortie de `openssl genpkey` appelle `ParsePKCS8PrivateKey`. L’inverse se produit aussi avec des outils plus récents.

• Clé EC au format SEC 1

  fréquente

  `openssl ecparam -genkey` écrit `EC PRIVATE KEY` (SEC 1, RFC 5915). Cette clé doit être passée à `ParseECPrivateKey` ou convertie en PKCS#8.

• Clé publique RSA PKCS#1 passée à ParsePKIXPublicKey

  occasionnelle

  `-----BEGIN RSA PUBLIC KEY-----` est la structure PKCS#1 nue, sans l’identifiant d’algorithme que porte `PUBLIC KEY` (SPKI).

Comment corriger l’erreur

1. 1.

   Choisir la fonction d’analyse selon le type PEM

   Le libellé PEM vous indique le conteneur. Aiguillez selon `block.Type` au lieu de supposer un format unique.

   func parsePrivateKeyPEM(data []byte) (crypto.Signer, error) {
   	block, _ := pem.Decode(data)
   	if block == nil {
   		return nil, errors.New("no PEM block found")
   	}
   	switch block.Type {
   	case "PRIVATE KEY": // PKCS#8: RSA, ECDSA, Ed25519, X25519
   		key, err := x509.ParsePKCS8PrivateKey(block.Bytes)
   		if err != nil {
   			return nil, err
   		}
   		signer, ok := key.(crypto.Signer)
   		if !ok {
   			return nil, fmt.Errorf("%T cannot sign", key)
   		}
   		return signer, nil
   	case "RSA PRIVATE KEY": // PKCS#1
   		return x509.ParsePKCS1PrivateKey(block.Bytes)
   	case "EC PRIVATE KEY": // SEC 1
   		return x509.ParseECPrivateKey(block.Bytes)
   	default:
   		return nil, fmt.Errorf("unsupported PEM type %q", block.Type)
   	}
   }

2. 2.

   Normaliser les clés en PKCS#8 et SPKI

   PKCS#8 pour les clés privées et SPKI pour les clés publiques fonctionnent avec tous les algorithmes et toutes les bibliothèques modernes. Convertissez une fois pour toutes, lors du provisionnement.

   # Normalise any private key to PKCS#8 ("-----BEGIN PRIVATE KEY-----")
   openssl pkcs8 -topk8 -nocrypt -in legacy.pem -out key.pk8.pem
   # Public keys: PKCS#1 "RSA PUBLIC KEY" -> SPKI "PUBLIC KEY"
   openssl rsa -RSAPublicKey_in -in rsa-pub.pem -pubout -out spki.pem

← Parcourir toute la base de données des erreurs de signature