github.com/lbryio/lbcd@v0.22.119/btcec/privkey.go (about)

     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  }