vendor/github.com/btcsuite/btcd/btcec/privkey.go

   1 // Copyright (c) 2013-2016 The btcsuite developers
   2 // Use of this source code is governed by an ISC
   3 // license that can be found in the LICENSE file.
   4
   5 package btcec
   6
   7 import (
   8         "crypto/ecdsa"
   9         "crypto/elliptic"
  10         "crypto/rand"
  11         "math/big"
  12 )
  13
  14 // PrivateKey wraps an ecdsa.PrivateKey as a convenience mainly for signing
  15 // things with the the private key without having to directly import the ecdsa
  16 // package.
  17 type PrivateKey ecdsa.PrivateKey
  18
  19 // PrivKeyFromBytes returns a private and public key for `curve' based on the
  20 // private key passed as an argument as a byte slice.
  21 func PrivKeyFromBytes(curve elliptic.Curve, pk []byte) (*PrivateKey,
  22         *PublicKey) {
  23         x, y := curve.ScalarBaseMult(pk)
  24
  25         priv := &ecdsa.PrivateKey{
  26                 PublicKey: ecdsa.PublicKey{
  27                         Curve: curve,
  28                         X:     x,
  29                         Y:     y,
  30                 },
  31                 D: new(big.Int).SetBytes(pk),
  32         }
  33
  34         return (*PrivateKey)(priv), (*PublicKey)(&priv.PublicKey)
  35 }
  36
  37 // NewPrivateKey is a wrapper for ecdsa.GenerateKey that returns a PrivateKey
  38 // instead of the normal ecdsa.PrivateKey.
  39 func NewPrivateKey(curve elliptic.Curve) (*PrivateKey, error) {
  40         key, err := ecdsa.GenerateKey(curve, rand.Reader)
  41         if err != nil {
  42                 return nil, err
  43         }
  44         return (*PrivateKey)(key), nil
  45 }
  46
  47 // PubKey returns the PublicKey corresponding to this private key.
  48 func (p *PrivateKey) PubKey() *PublicKey {
  49         return (*PublicKey)(&p.PublicKey)
  50 }
  51
  52 // ToECDSA returns the private key as a *ecdsa.PrivateKey.
  53 func (p *PrivateKey) ToECDSA() *ecdsa.PrivateKey {
  54         return (*ecdsa.PrivateKey)(p)
  55 }
  56
  57 // Sign generates an ECDSA signature for the provided hash (which should be the result
  58 // of hashing a larger message) using the private key. Produced signature
  59 // is deterministic (same message and same key yield the same signature) and canonical
  60 // in accordance with RFC6979 and BIP0062.
  61 func (p *PrivateKey) Sign(hash []byte) (*Signature, error) {
  62         return signRFC6979(p, hash)
  63 }
  64
  65 // PrivKeyBytesLen defines the length in bytes of a serialized private key.
  66 const PrivKeyBytesLen = 32
  67
  68 // Serialize returns the private key number d as a big-endian binary-encoded
  69 // number, padded to a length of 32 bytes.
  70 func (p *PrivateKey) Serialize() []byte {
  71         b := make([]byte, 0, PrivKeyBytesLen)
  72         return paddedAppend(PrivKeyBytesLen, b, p.ToECDSA().D.Bytes())
  73 }