go-ethereum: github.com/axiomzen/go-ethereum/crypto/ecies Index | Files

package ecies

import "github.com/axiomzen/go-ethereum/crypto/ecies"

Index

Package Files

ecies.go params.go

Variables

var (
    ErrImport                     = fmt.Errorf("ecies: failed to import key")
    ErrInvalidCurve               = fmt.Errorf("ecies: invalid elliptic curve")
    ErrInvalidParams              = fmt.Errorf("ecies: invalid ECIES parameters")
    ErrInvalidPublicKey           = fmt.Errorf("ecies: invalid public key")
    ErrSharedKeyIsPointAtInfinity = fmt.Errorf("ecies: shared key is point at infinity")
    ErrSharedKeyTooBig            = fmt.Errorf("ecies: shared key params are too big")
)
var (
    ErrKeyDataTooLong = fmt.Errorf("ecies: can't supply requested key data")
    ErrSharedTooLong  = fmt.Errorf("ecies: shared secret is too long")
    ErrInvalidMessage = fmt.Errorf("ecies: invalid message")
)
var (
    DefaultCurve                  = ethcrypto.S256()
    ErrUnsupportedECDHAlgorithm   = fmt.Errorf("ecies: unsupported ECDH algorithm")
    ErrUnsupportedECIESParameters = fmt.Errorf("ecies: unsupported ECIES parameters")
)
var (
    ECIES_AES128_SHA256 = &ECIESParams{
        Hash:      sha256.New,
        hashAlgo:  crypto.SHA256,
        Cipher:    aes.NewCipher,
        BlockSize: aes.BlockSize,
        KeyLen:    16,
    }

    ECIES_AES256_SHA256 = &ECIESParams{
        Hash:      sha256.New,
        hashAlgo:  crypto.SHA256,
        Cipher:    aes.NewCipher,
        BlockSize: aes.BlockSize,
        KeyLen:    32,
    }

    ECIES_AES256_SHA384 = &ECIESParams{
        Hash:      sha512.New384,
        hashAlgo:  crypto.SHA384,
        Cipher:    aes.NewCipher,
        BlockSize: aes.BlockSize,
        KeyLen:    32,
    }

    ECIES_AES256_SHA512 = &ECIESParams{
        Hash:      sha512.New,
        hashAlgo:  crypto.SHA512,
        Cipher:    aes.NewCipher,
        BlockSize: aes.BlockSize,
        KeyLen:    32,
    }
)

func AddParamsForCurve Uses

func AddParamsForCurve(curve elliptic.Curve, params *ECIESParams)

func Encrypt Uses

func Encrypt(rand io.Reader, pub *PublicKey, m, s1, s2 []byte) (ct []byte, err error)

Encrypt encrypts a message using ECIES as specified in SEC 1, 5.1.

s1 and s2 contain shared information that is not part of the resulting ciphertext. s1 is fed into key derivation, s2 is fed into the MAC. If the shared information parameters aren't being used, they should be nil.

func MaxSharedKeyLength Uses

func MaxSharedKeyLength(pub *PublicKey) int

MaxSharedKeyLength returns the maximum length of the shared key the public key can produce.

type ECIESParams Uses

type ECIESParams struct {
    Hash func() hash.Hash // hash function

    Cipher    func([]byte) (cipher.Block, error) // symmetric cipher
    BlockSize int                                // block size of symmetric cipher
    KeyLen    int                                // length of symmetric key
    // contains filtered or unexported fields
}

func ParamsFromCurve Uses

func ParamsFromCurve(curve elliptic.Curve) (params *ECIESParams)

ParamsFromCurve selects parameters optimal for the selected elliptic curve. Only the curves P256, P384, and P512 are supported.

type PrivateKey Uses

type PrivateKey struct {
    PublicKey
    D   *big.Int
}

PrivateKey is a representation of an elliptic curve private key.

func GenerateKey Uses

func GenerateKey(rand io.Reader, curve elliptic.Curve, params *ECIESParams) (prv *PrivateKey, err error)

Generate an elliptic curve public / private keypair. If params is nil, the recommended default parameters for the key will be chosen.

func ImportECDSA Uses

func ImportECDSA(prv *ecdsa.PrivateKey) *PrivateKey

Import an ECDSA private key as an ECIES private key.

func (*PrivateKey) Decrypt Uses

func (prv *PrivateKey) Decrypt(c, s1, s2 []byte) (m []byte, err error)

Decrypt decrypts an ECIES ciphertext.

func (*PrivateKey) ExportECDSA Uses

func (prv *PrivateKey) ExportECDSA() *ecdsa.PrivateKey

Export an ECIES private key as an ECDSA private key.

func (*PrivateKey) GenerateShared Uses

func (prv *PrivateKey) GenerateShared(pub *PublicKey, skLen, macLen int) (sk []byte, err error)

ECDH key agreement method used to establish secret keys for encryption.

type PublicKey Uses

type PublicKey struct {
    X   *big.Int
    Y   *big.Int
    elliptic.Curve
    Params *ECIESParams
}

PublicKey is a representation of an elliptic curve public key.

func ImportECDSAPublic Uses

func ImportECDSAPublic(pub *ecdsa.PublicKey) *PublicKey

Import an ECDSA public key as an ECIES public key.

func (*PublicKey) ExportECDSA Uses

func (pub *PublicKey) ExportECDSA() *ecdsa.PublicKey

Export an ECIES public key as an ECDSA public key.

Package ecies imports 14 packages (graph). Updated 2019-07-06. Refresh now. Tools for package owners.