Categorygithub.com/ngchain/secp256k1
modulepackage
0.0.0-20200408111354-30fe4481b484
Repository: https://github.com/ngchain/secp256k1.git
Documentation: pkg.go.dev
Overview
Versions
1
Dependencies
22
Dependents
7
Files
2.7k SLOC

# README

secp256k1

GoDoc

Package secp256k1 implements secp256k1 elliptic curve cryptography needed for working with Decred. It is designed so that it may be used with the standard crypto/ecdsa packages provided with go. A comprehensive suite of test is provided to ensure proper functionality. Package dcrec was originally based on work from ThePiachu which is licensed under the same terms as Go, but it has signficantly diverged since then. The Decred developers original is licensed under the liberal ISC license.

Although this package was primarily written for dcrd, it has intentionally been designed so it can be used as a standalone package for any projects needing to use secp256k1 elliptic curve cryptography.

Installation and Updating

$ go get -u github.com/ngchain/secp256k1

Examples

  • Sign Message Demonstrates signing a message with a secp256k1 private key that is first parsed form raw bytes and serializing the generated signature.

  • Verify Signature Demonstrates verifying a secp256k1 signature against a public key that is first parsed from raw bytes. The signature is also parsed from raw bytes.

  • Encryption Demonstrates encrypting a message for a public key that is first parsed from raw bytes, then decrypting it using the corresponding private key.

  • Decryption Demonstrates decrypting a message using a private key that is first parsed from raw bytes.

License

Package dcrec is licensed under the copyfree ISC License except for dcrec.go and dcrec_test.go which is under the same license as Go.

# Functions

Decrypt decrypts data that was encrypted using the Encrypt function.
Encrypt encrypts data for the target public key using AES-256-CBC.
GenerateKey generates a key using a random number generator, returning the private scalar and the corresponding public key points.
GeneratePrivateKey is a wrapper for ecdsa.GenerateKey that returns a PrivateKey instead of the normal ecdsa.PrivateKey.
GenerateSharedSecret generates a shared secret based on a private key and a public key using Diffie-Hellman key exchange (ECDH) (RFC 4753).
HashBlake256 calculates hash(b) and returns the resulting bytes.
NewPrivateKey instantiates a new private key from a scalar encoded as a big integer.
NewPublicKey instantiates a new public key with the given X,Y coordinates.
NewSignature instantiates a new signature given some R,S values.
NonceRFC6979 generates an ECDSA nonce (`k`) deterministically according to RFC 6979.
ParseDERSignature parses a signature in DER format for the curve type `curve` into a Signature type.
ParsePubKey parses a public key for a koblitz curve from a bytestring into a ecdsa.Publickey, verifying that it is valid.
ParseSignature parses a signature in BER format for the curve type `curve' into a Signature type, performing some basic sanity checks.
PrivKeyFromBytes returns a private and public key for `curve' based on the private key passed as an argument as a byte slice.
PrivKeyFromScalar is the same as PrivKeyFromBytes in secp256k1.
RecoverCompact verifies the compact signature "signature" of "hash" for the Koblitz curve in "curve".
S256 returns a Curve which implements secp256k1.
SignCompact produces a compact signature of the data in hash with the given private key on the given koblitz curve.

# Constants

PrivKeyBytesLen defines the length in bytes of a serialized private key.
These constants define the lengths of serialized public keys.
These constants define the lengths of serialized public keys.

# Variables

ErrInvalidMAC occurs when Message Authentication Check (MAC) fails during decryption.

# Structs

KoblitzCurve supports a koblitz curve implementation that fits the ECC Curve interface from crypto/elliptic.
Signature is a type representing an ecdsa signature.

# Type aliases

PrivateKey wraps an ecdsa.PrivateKey as a convenience mainly for signing things with the private key without having to directly import the ecdsa package.
PublicKey is an ecdsa.PublicKey with additional functions to serialize in uncompressed and compressed formats.