libgo/go/crypto/x509/pkcs1.go

   1 // Copyright 2011 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/rsa"
   9         "encoding/asn1"
  10         "errors"
  11         "math/big"
  12 )
  13
  14 // pkcs1PrivateKey is a structure which mirrors the PKCS#1 ASN.1 for an RSA private key.
  15 type pkcs1PrivateKey struct {
  16         Version int
  17         N       *big.Int
  18         E       int
  19         D       *big.Int
  20         P       *big.Int
  21         Q       *big.Int
  22         // We ignore these values, if present, because rsa will calculate them.
  23         Dp   *big.Int `asn1:"optional"`
  24         Dq   *big.Int `asn1:"optional"`
  25         Qinv *big.Int `asn1:"optional"`
  26
  27         AdditionalPrimes []pkcs1AdditionalRSAPrime `asn1:"optional,omitempty"`
  28 }
  29
  30 type pkcs1AdditionalRSAPrime struct {
  31         Prime *big.Int
  32
  33         // We ignore these values because rsa will calculate them.
  34         Exp   *big.Int
  35         Coeff *big.Int
  36 }
  37
  38 // ParsePKCS1PrivateKey returns an RSA private key from its ASN.1 PKCS#1 DER encoded form.
  39 func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err error) {
  40         var priv pkcs1PrivateKey
  41         rest, err := asn1.Unmarshal(der, &priv)
  42         if len(rest) > 0 {
  43                 err = asn1.SyntaxError{Msg: "trailing data"}
  44                 return
  45         }
  46         if err != nil {
  47                 return
  48         }
  49
  50         if priv.Version > 1 {
  51                 return nil, errors.New("x509: unsupported private key version")
  52         }
  53
  54         if priv.N.Sign() <= 0 || priv.D.Sign() <= 0 || priv.P.Sign() <= 0 || priv.Q.Sign() <= 0 {
  55                 return nil, errors.New("x509: private key contains zero or negative value")
  56         }
  57
  58         key = new(rsa.PrivateKey)
  59         key.PublicKey = rsa.PublicKey{
  60                 E: priv.E,
  61                 N: priv.N,
  62         }
  63
  64         key.D = priv.D
  65         key.Primes = make([]*big.Int, 2+len(priv.AdditionalPrimes))
  66         key.Primes[0] = priv.P
  67         key.Primes[1] = priv.Q
  68         for i, a := range priv.AdditionalPrimes {
  69                 if a.Prime.Sign() <= 0 {
  70                         return nil, errors.New("x509: private key contains zero or negative prime")
  71                 }
  72                 key.Primes[i+2] = a.Prime
  73                 // We ignore the other two values because rsa will calculate
  74                 // them as needed.
  75         }
  76
  77         err = key.Validate()
  78         if err != nil {
  79                 return nil, err
  80         }
  81         key.Precompute()
  82
  83         return
  84 }
  85
  86 // MarshalPKCS1PrivateKey converts a private key to ASN.1 DER encoded form.
  87 func MarshalPKCS1PrivateKey(key *rsa.PrivateKey) []byte {
  88         key.Precompute()
  89
  90         version := 0
  91         if len(key.Primes) > 2 {
  92                 version = 1
  93         }
  94
  95         priv := pkcs1PrivateKey{
  96                 Version: version,
  97                 N:       key.N,
  98                 E:       key.PublicKey.E,
  99                 D:       key.D,
 100                 P:       key.Primes[0],
 101                 Q:       key.Primes[1],
 102                 Dp:      key.Precomputed.Dp,
 103                 Dq:      key.Precomputed.Dq,
 104                 Qinv:    key.Precomputed.Qinv,
 105         }
 106
 107         priv.AdditionalPrimes = make([]pkcs1AdditionalRSAPrime, len(key.Precomputed.CRTValues))
 108         for i, values := range key.Precomputed.CRTValues {
 109                 priv.AdditionalPrimes[i].Prime = key.Primes[2+i]
 110                 priv.AdditionalPrimes[i].Exp = values.Exp
 111                 priv.AdditionalPrimes[i].Coeff = values.Coeff
 112         }
 113
 114         b, _ := asn1.Marshal(priv)
 115         return b
 116 }
 117
 118 // rsaPublicKey reflects the ASN.1 structure of a PKCS#1 public key.
 119 type rsaPublicKey struct {
 120         N *big.Int
 121         E int
 122 }