120 lines
3.4 KiB
Go
120 lines
3.4 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package certutil
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"encoding/asn1"
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
var (
|
|
oidNamedCurveP224 = asn1.ObjectIdentifier{1, 3, 132, 0, 33}
|
|
oidNamedCurveP256 = asn1.ObjectIdentifier{1, 2, 840, 10045, 3, 1, 7}
|
|
oidNamedCurveP384 = asn1.ObjectIdentifier{1, 3, 132, 0, 34}
|
|
oidNamedCurveP521 = asn1.ObjectIdentifier{1, 3, 132, 0, 35}
|
|
|
|
oidPublicKeyRSA = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}
|
|
oidPublicKeyDSA = asn1.ObjectIdentifier{1, 2, 840, 10040, 4, 1}
|
|
oidPublicKeyECDSA = asn1.ObjectIdentifier{1, 2, 840, 10045, 2, 1}
|
|
)
|
|
|
|
// pkcs8 reflects an ASN.1, PKCS#8 PrivateKey. See
|
|
// ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-8/pkcs-8v1_2.asn
|
|
// and RFC 5208.
|
|
type pkcs8 struct {
|
|
Version int
|
|
Algo pkix.AlgorithmIdentifier
|
|
PrivateKey []byte
|
|
// optional attributes omitted.
|
|
}
|
|
|
|
type ecPrivateKey struct {
|
|
Version int
|
|
PrivateKey []byte
|
|
NamedCurveOID asn1.ObjectIdentifier `asn1:"optional,explicit,tag:0"`
|
|
PublicKey asn1.BitString `asn1:"optional,explicit,tag:1"`
|
|
}
|
|
|
|
// MarshalPKCS8PrivateKey converts a private key to PKCS#8 encoded form.
|
|
// The following key types are supported: *rsa.PrivateKey, *ecdsa.PublicKey.
|
|
// Unsupported key types result in an error.
|
|
//
|
|
// See RFC 5208.
|
|
func MarshalPKCS8PrivateKey(key interface{}) ([]byte, error) {
|
|
var privKey pkcs8
|
|
|
|
switch k := key.(type) {
|
|
case *rsa.PrivateKey:
|
|
privKey.Algo = pkix.AlgorithmIdentifier{
|
|
Algorithm: oidPublicKeyRSA,
|
|
Parameters: asn1.NullRawValue,
|
|
}
|
|
privKey.PrivateKey = x509.MarshalPKCS1PrivateKey(k)
|
|
|
|
case *ecdsa.PrivateKey:
|
|
oid, ok := oidFromNamedCurve(k.Curve)
|
|
if !ok {
|
|
return nil, errors.New("x509: unknown curve while marshalling to PKCS#8")
|
|
}
|
|
|
|
oidBytes, err := asn1.Marshal(oid)
|
|
if err != nil {
|
|
return nil, errors.New("x509: failed to marshal curve OID: " + err.Error())
|
|
}
|
|
|
|
privKey.Algo = pkix.AlgorithmIdentifier{
|
|
Algorithm: oidPublicKeyECDSA,
|
|
Parameters: asn1.RawValue{
|
|
FullBytes: oidBytes,
|
|
},
|
|
}
|
|
|
|
if privKey.PrivateKey, err = marshalECPrivateKeyWithOID(k, nil); err != nil {
|
|
return nil, errors.New("x509: failed to marshal EC private key while building PKCS#8: " + err.Error())
|
|
}
|
|
|
|
default:
|
|
return nil, fmt.Errorf("x509: unknown key type while marshalling PKCS#8: %T", key)
|
|
}
|
|
|
|
return asn1.Marshal(privKey)
|
|
}
|
|
|
|
func oidFromNamedCurve(curve elliptic.Curve) (asn1.ObjectIdentifier, bool) {
|
|
switch curve {
|
|
case elliptic.P224():
|
|
return oidNamedCurveP224, true
|
|
case elliptic.P256():
|
|
return oidNamedCurveP256, true
|
|
case elliptic.P384():
|
|
return oidNamedCurveP384, true
|
|
case elliptic.P521():
|
|
return oidNamedCurveP521, true
|
|
}
|
|
|
|
return nil, false
|
|
}
|
|
|
|
// marshalECPrivateKey marshals an EC private key into ASN.1, DER format and
|
|
// sets the curve ID to the given OID, or omits it if OID is nil.
|
|
func marshalECPrivateKeyWithOID(key *ecdsa.PrivateKey, oid asn1.ObjectIdentifier) ([]byte, error) {
|
|
privateKeyBytes := key.D.Bytes()
|
|
paddedPrivateKey := make([]byte, (key.Curve.Params().N.BitLen()+7)/8)
|
|
copy(paddedPrivateKey[len(paddedPrivateKey)-len(privateKeyBytes):], privateKeyBytes)
|
|
|
|
return asn1.Marshal(ecPrivateKey{
|
|
Version: 1,
|
|
PrivateKey: paddedPrivateKey,
|
|
NamedCurveOID: oid,
|
|
PublicKey: asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)},
|
|
})
|
|
}
|