crypto

Documentation

Index

• Constants
• func CreateAddress(b common.Address, nonce uint64) common.Address
• func Decrypt(prv *ecdsa.PrivateKey, ct []byte) ([]byte, error)
• func Ecrecover(hash, sig []byte) ([]byte, error)
• func Encrypt(pub *ecdsa.PublicKey, message []byte) ([]byte, error)
• func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error)
• func FromECDSA(prv *ecdsa.PrivateKey) []byte
• func FromECDSAPub(pub *ecdsa.PublicKey) []byte
• func GenerateKey() (*ecdsa.PrivateKey, error)
• func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error)
• func ImportBlockTestKey(privKeyBytes []byte) error
• func Keccak256(data ...[]byte) []byte
• func Keccak256Hash(data ...[]byte) (h common.Hash)
• func LoadECDSA(file string) (*ecdsa.PrivateKey, error)
• func PKCS7Unpad(in []byte) []byte
• func PubkeyToAddress(p ecdsa.PublicKey) common.Address
• func Ripemd160(data []byte) []byte
• func SaveECDSA(file string, key *ecdsa.PrivateKey) error
• func Sha256(data []byte) []byte
• func Sha3(data ...[]byte) []byte
• func Sha3Hash(data ...[]byte) common.Hash
• func SigToPub(hash, sig []byte) (*ecdsa.PublicKey, error)
• func Sign(hash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error)
• func ToECDSA(prv []byte) *ecdsa.PrivateKey
• func ToECDSAPub(pub []byte) *ecdsa.PublicKey
• func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool
• type Key
  • func DecryptKey(keyjson []byte, auth string) (*Key, error)
  • func GenerateNewKeyDefault(ks KeyStore, rand io.Reader, auth string) (key *Key, err error)
  • func ImportPreSaleKey(keyStore KeyStore, keyJSON []byte, password string) (*Key, error)
  • func NewKey(rand io.Reader) *Key
  • func NewKeyForDirectICAP(rand io.Reader) *Key
  • func NewKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key
  • func (k *Key) MarshalJSON() (j []byte, err error)
  • func (k *Key) UnmarshalJSON(j []byte) (err error)
• type KeyStore
  • func NewKeyStorePassphrase(path string, scryptN int, scryptP int) KeyStore
  • func NewKeyStorePlain(path string) KeyStore

Constants

const (

	// n,r,p = 2^18, 8, 1 uses 256MB memory and approx 1s CPU time on a modern CPU.
	StandardScryptN = 1 << 18
	StandardScryptP = 1

	// n,r,p = 2^12, 8, 6 uses 4MB memory and approx 100ms CPU time on a modern CPU.
	LightScryptN = 1 << 12
	LightScryptP = 6
)

Functions

func CreateAddress

func CreateAddress(b common.Address, nonce uint64) common.Address

Creates an ethereum address given the bytes and the nonce

func Decrypt

func Decrypt(prv *ecdsa.PrivateKey, ct []byte) ([]byte, error)

func Ecrecover

func Ecrecover(hash, sig []byte) ([]byte, error)

func Encrypt

func Encrypt(pub *ecdsa.PublicKey, message []byte) ([]byte, error)

func EncryptKey

func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error)

EncryptKey encrypts a key using the specified scrypt parameters into a json blob that can be decrypted later on.

func FromECDSA

func FromECDSA(prv *ecdsa.PrivateKey) []byte

func FromECDSAPub

func FromECDSAPub(pub *ecdsa.PublicKey) []byte

func GenerateKey

func GenerateKey() (*ecdsa.PrivateKey, error)

func HexToECDSA

func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error)

HexToECDSA parses a secp256k1 private key.

func ImportBlockTestKey

func ImportBlockTestKey(privKeyBytes []byte) error

Used only by block tests.

func Keccak256

func Keccak256(data ...[]byte) []byte

func Keccak256Hash

func Keccak256Hash(data ...[]byte) (h common.Hash)

func LoadECDSA

func LoadECDSA(file string) (*ecdsa.PrivateKey, error)

LoadECDSA loads a secp256k1 private key from the given file. The key data is expected to be hex-encoded.

func PKCS7Unpad

func PKCS7Unpad(in []byte) []byte

From https://leanpub.com/gocrypto/read#leanpub-auto-block-cipher-modes

func PubkeyToAddress

func PubkeyToAddress(p ecdsa.PublicKey) common.Address

func Ripemd160

func Ripemd160(data []byte) []byte

func SaveECDSA

func SaveECDSA(file string, key *ecdsa.PrivateKey) error

SaveECDSA saves a secp256k1 private key to the given file with restrictive permissions. The key data is saved hex-encoded.

func Sha256

func Sha256(data []byte) []byte

func Sha3

func Sha3(data ...[]byte) []byte

Deprecated: For backward compatibility as other packages depend on these

func Sha3Hash

func Sha3Hash(data ...[]byte) common.Hash

func SigToPub

func SigToPub(hash, sig []byte) (*ecdsa.PublicKey, error)

func Sign

func Sign(hash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error)

func ToECDSA

func ToECDSA(prv []byte) *ecdsa.PrivateKey

New methods using proper ecdsa keys from the stdlib

func ToECDSAPub

func ToECDSAPub(pub []byte) *ecdsa.PublicKey

func ValidateSignatureValues

func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool

Types

type Key

type Key struct {
	Id uuid.UUID // Version 4 "random" for unique id not derived from key data
	// to simplify lookups we also store the address
	Address common.Address
	// we only store privkey as pubkey/address can be derived from it
	// privkey in this struct is always in plaintext
	PrivateKey *ecdsa.PrivateKey
}

func DecryptKey

func DecryptKey(keyjson []byte, auth string) (*Key, error)

DecryptKey decrypts a key from a json blob, returning the private key itself.

func GenerateNewKeyDefault

func GenerateNewKeyDefault(ks KeyStore, rand io.Reader, auth string) (key *Key, err error)

func ImportPreSaleKey

func ImportPreSaleKey(keyStore KeyStore, keyJSON []byte, password string) (*Key, error)

creates a Key and stores that in the given KeyStore by decrypting a presale key JSON

func NewKey

func NewKey(rand io.Reader) *Key

func NewKeyForDirectICAP

func NewKeyForDirectICAP(rand io.Reader) *Key

generate key whose address fits into < 155 bits so it can fit into the Direct ICAP spec. for simplicity and easier compatibility with other libs, we retry until the first byte is 0.

func NewKeyFromECDSA

func NewKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key

func (*Key) MarshalJSON

func (k *Key) MarshalJSON() (j []byte, err error)

func (*Key) UnmarshalJSON

func (k *Key) UnmarshalJSON(j []byte) (err error)

type KeyStore

type KeyStore interface {
	// create new key using io.Reader entropy source and optionally using auth string
	GenerateNewKey(io.Reader, string) (*Key, error)
	GetKey(common.Address, string) (*Key, error) // get key from addr and auth string
	GetKeyAddresses() ([]common.Address, error)  // get all addresses
	StoreKey(*Key, string) error                 // store key optionally using auth string
	DeleteKey(common.Address, string) error      // delete key by addr and auth string
	Cleanup(keyAddr common.Address) (err error)
}

func NewKeyStorePassphrase

func NewKeyStorePassphrase(path string, scryptN int, scryptP int) KeyStore

func NewKeyStorePlain

func NewKeyStorePlain(path string) KeyStore