Difference between a PKCS1 public key created by Go crypto libraries and "openssl rsa ..."-CodePudding

I try to generate a pair of a PKCS8 encoded private key and the corresponding PKCS1 encoded public key using the rsa and x509 packages of Go. I want to have the same behavior as the openssl commands below:

$ openssl genrsa 2048 | openssl pkcs8 -topk8 -inform PEM -out rsa_key.p8 -nocrypt
$ openssl rsa -in rsa_key.p8 -pubout -out rsa_key.pub

I have added my Go implementation below, boiled down to the essentials. To use it, I first generate a private key with GeneratePrivateKey (with bit size 2048 for the example attached on the end), and then encode the private key and the public key with the following two methods.

However, when running the second openssl command to encode the public key on the private key encoded by my Go implementation, the public keys differ (I included an example for the difference below). In particular, it looks as if the openssl output extends the output of my Go implementation by a prefix.

I would be grateful for any explaination of the difference (and in the best case, how I can fix my code). Thank you very much!

My Go code looks as follows:

package xyz

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
)

func GeneratePrivateKey(bitSize int) (*rsa.PrivateKey, error) {
    privateKey, err := rsa.GenerateKey(rand.Reader, bitSize)
    if err != nil {
        return nil, err
    }
    err = privateKey.Validate()
    if err != nil {
        return nil, err
    }
    return privateKey, nil
}

func EncodePrivateKeyToPEM(privateKey *rsa.PrivateKey) (string, error) {
    privateDER, err := x509.MarshalPKCS8PrivateKey(privateKey)
    if err != nil {
        return "", err
    }
    privateBlock := pem.Block{
        Type:    "RSA PRIVATE KEY",
        Headers: nil,
        Bytes:   privateDER,
    }
    privatePEM := pem.EncodeToMemory(&privateBlock)
    return string(privatePEM), nil
}

func EncodePublicKeyToPEM(privateKey *rsa.PrivateKey) string {
    publicRsaKey := x509.MarshalPKCS1PublicKey(&privateKey.PublicKey)
    publicKeyBytes := pem.EncodeToMemory(
        &pem.Block{
            Type:  "PUBLIC KEY",
            Bytes: publicRsaKey,
        })
    return string(publicKeyBytes)
}

An exemplary private key:

The public key as encoded by my Go implementation:

The public key as generated by the second openssl command (note that it only differs from the former by the prefix MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A)

CodePudding user response：

The OpenSSL statements generate a private key in PKCS#8 format and a public key in X.509/SPKI format, both PEM encoded.

The private key generated with the Go Code has the PKCS#8 format, but the PEM encoding uses the wrong header and footer (correct would be -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY-----). The fix is to adjust in EncodePrivateKeyToPEM() in the pem.Block() call the type accordingly (Type: "PRIVATE KEY").

In the case of the public key generated with the Go Code, the situation is reversed: Here, the header and footer correspond to those of a PEM encoded X.509/SPKI key. However, the body is PKCS#1 formatted. This is the reason why the keys differ. The fix is to use in EncodePublicKeyToPEM() the method MarshalPKIXPublicKey() for the X.509/SPKI format instead of MarshalPKCS1PublicKey().

By the way, the best way to inspect the keys is to use an ASN.1 parser, e.g. https://lapo.it/asn1js/.