sec1.go

Documentation: crypto/x509

		 1  // Copyright 2012 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package x509
		 6  
		 7  import (
		 8  	"crypto/ecdsa"
		 9  	"crypto/elliptic"
		10  	"encoding/asn1"
		11  	"errors"
		12  	"fmt"
		13  	"math/big"
		14  )
		15  
		16  const ecPrivKeyVersion = 1
		17  
		18  // ecPrivateKey reflects an ASN.1 Elliptic Curve Private Key Structure.
		19  // References:
		20  //	 RFC 5915
		21  //	 SEC1 - http://www.secg.org/sec1-v2.pdf
		22  // Per RFC 5915 the NamedCurveOID is marked as ASN.1 OPTIONAL, however in
		23  // most cases it is not.
		24  type ecPrivateKey struct {
		25  	Version			 int
		26  	PrivateKey		[]byte
		27  	NamedCurveOID asn1.ObjectIdentifier `asn1:"optional,explicit,tag:0"`
		28  	PublicKey		 asn1.BitString				`asn1:"optional,explicit,tag:1"`
		29  }
		30  
		31  // ParseECPrivateKey parses an EC private key in SEC 1, ASN.1 DER form.
		32  //
		33  // This kind of key is commonly encoded in PEM blocks of type "EC PRIVATE KEY".
		34  func ParseECPrivateKey(der []byte) (*ecdsa.PrivateKey, error) {
		35  	return parseECPrivateKey(nil, der)
		36  }
		37  
		38  // MarshalECPrivateKey converts an EC private key to SEC 1, ASN.1 DER form.
		39  //
		40  // This kind of key is commonly encoded in PEM blocks of type "EC PRIVATE KEY".
		41  // For a more flexible key format which is not EC specific, use
		42  // MarshalPKCS8PrivateKey.
		43  func MarshalECPrivateKey(key *ecdsa.PrivateKey) ([]byte, error) {
		44  	oid, ok := oidFromNamedCurve(key.Curve)
		45  	if !ok {
		46  		return nil, errors.New("x509: unknown elliptic curve")
		47  	}
		48  
		49  	return marshalECPrivateKeyWithOID(key, oid)
		50  }
		51  
		52  // marshalECPrivateKey marshals an EC private key into ASN.1, DER format and
		53  // sets the curve ID to the given OID, or omits it if OID is nil.
		54  func marshalECPrivateKeyWithOID(key *ecdsa.PrivateKey, oid asn1.ObjectIdentifier) ([]byte, error) {
		55  	privateKey := make([]byte, (key.Curve.Params().N.BitLen()+7)/8)
		56  	return asn1.Marshal(ecPrivateKey{
		57  		Version:			 1,
		58  		PrivateKey:		key.D.FillBytes(privateKey),
		59  		NamedCurveOID: oid,
		60  		PublicKey:		 asn1.BitString{Bytes: elliptic.Marshal(key.Curve, key.X, key.Y)},
		61  	})
		62  }
		63  
		64  // parseECPrivateKey parses an ASN.1 Elliptic Curve Private Key Structure.
		65  // The OID for the named curve may be provided from another source (such as
		66  // the PKCS8 container) - if it is provided then use this instead of the OID
		67  // that may exist in the EC private key structure.
		68  func parseECPrivateKey(namedCurveOID *asn1.ObjectIdentifier, der []byte) (key *ecdsa.PrivateKey, err error) {
		69  	var privKey ecPrivateKey
		70  	if _, err := asn1.Unmarshal(der, &privKey); err != nil {
		71  		if _, err := asn1.Unmarshal(der, &pkcs8{}); err == nil {
		72  			return nil, errors.New("x509: failed to parse private key (use ParsePKCS8PrivateKey instead for this key format)")
		73  		}
		74  		if _, err := asn1.Unmarshal(der, &pkcs1PrivateKey{}); err == nil {
		75  			return nil, errors.New("x509: failed to parse private key (use ParsePKCS1PrivateKey instead for this key format)")
		76  		}
		77  		return nil, errors.New("x509: failed to parse EC private key: " + err.Error())
		78  	}
		79  	if privKey.Version != ecPrivKeyVersion {
		80  		return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
		81  	}
		82  
		83  	var curve elliptic.Curve
		84  	if namedCurveOID != nil {
		85  		curve = namedCurveFromOID(*namedCurveOID)
		86  	} else {
		87  		curve = namedCurveFromOID(privKey.NamedCurveOID)
		88  	}
		89  	if curve == nil {
		90  		return nil, errors.New("x509: unknown elliptic curve")
		91  	}
		92  
		93  	k := new(big.Int).SetBytes(privKey.PrivateKey)
		94  	curveOrder := curve.Params().N
		95  	if k.Cmp(curveOrder) >= 0 {
		96  		return nil, errors.New("x509: invalid elliptic curve private key value")
		97  	}
		98  	priv := new(ecdsa.PrivateKey)
		99  	priv.Curve = curve
	 100  	priv.D = k
	 101  
	 102  	privateKey := make([]byte, (curveOrder.BitLen()+7)/8)
	 103  
	 104  	// Some private keys have leading zero padding. This is invalid
	 105  	// according to [SEC1], but this code will ignore it.
	 106  	for len(privKey.PrivateKey) > len(privateKey) {
	 107  		if privKey.PrivateKey[0] != 0 {
	 108  			return nil, errors.New("x509: invalid private key length")
	 109  		}
	 110  		privKey.PrivateKey = privKey.PrivateKey[1:]
	 111  	}
	 112  
	 113  	// Some private keys remove all leading zeros, this is also invalid
	 114  	// according to [SEC1] but since OpenSSL used to do this, we ignore
	 115  	// this too.
	 116  	copy(privateKey[len(privateKey)-len(privKey.PrivateKey):], privKey.PrivateKey)
	 117  	priv.X, priv.Y = curve.ScalarBaseMult(privateKey)
	 118  
	 119  	return priv, nil
	 120  }
	 121
View as plain text