crypto

Documentation

Index

• Constants
• Variables
• func CompatibleAlgorithms(sigAlgo SignatureAlgorithm, hashAlgo HashAlgorithm) bool
• type Hash
• type HashAlgorithm
  • func StringToHashAlgorithm(s string) HashAlgorithm
• type Hasher
  • func NewHasher(algo HashAlgorithm) (Hasher, error)
  • func NewKeccak_256() Hasher
  • func NewSHA2_256() Hasher
  • func NewSHA2_384() Hasher
  • func NewSHA3_256() Hasher
  • func NewSHA3_384() Hasher
• type InMemorySigner
  • func NewInMemorySigner(privateKey PrivateKey, hashAlgo HashAlgorithm) (InMemorySigner, error)
  • func (s InMemorySigner) PublicKey() PublicKey
  • func (s InMemorySigner) Sign(message []byte) ([]byte, error)
• type NaiveSigner
  • func NewNaiveSigner(privateKey PrivateKey, hashAlgo HashAlgorithm) (NaiveSigner, error)
• type PrivateKey
  • func DecodePrivateKeyHex(sigAlgo SignatureAlgorithm, s string) (PrivateKey, error)
  • func GeneratePrivateKey(sigAlgo SignatureAlgorithm, seed []byte) (PrivateKey, error)
• type PublicKey
  • func DecodePublicKeyHex(sigAlgo SignatureAlgorithm, s string) (PublicKey, error)
  • func DecodePublicKeyPEM(sigAlgo SignatureAlgorithm, s string) (PublicKey, error)
• type SignatureAlgorithm
  • func StringToSignatureAlgorithm(s string) SignatureAlgorithm
• type Signer

Constants

const (
	UnknownSignatureAlgorithm SignatureAlgorithm = crypto.UnknownSigningAlgorithm
	// ECDSA_P256 is ECDSA on NIST P-256 curve
	ECDSA_P256 = crypto.ECDSAP256
	// ECDSA_secp256k1 is ECDSA on secp256k1 curve
	ECDSA_secp256k1 = crypto.ECDSASecp256k1
)

const (
	UnknownHashAlgorithm HashAlgorithm = hash.UnknownHashingAlgorithm
	SHA2_256                           = hash.SHA2_256
	SHA2_384                           = hash.SHA2_384
	SHA3_256                           = hash.SHA3_256
	SHA3_384                           = hash.SHA3_384
	Keccak256                          = hash.Keccak_256
)

const MinSeedLength = crypto.KeyGenSeedMinLen

MinSeedLength is the generic minimum seed length. It is recommended to use seeds with enough entropy, preferably from a secure RNG. The key generation process extracts and expands the entropy of the seed.

Variables

var DecodePrivateKey = crypto.DecodePrivateKey

DecodePrivateKey decodes a raw byte encoded private key with the given signature algorithm.

var DecodePublicKey = crypto.DecodePublicKey

DecodePublicKey decodes a raw byte encoded public key with the given signature algorithm.

Functions

func CompatibleAlgorithms

func CompatibleAlgorithms(sigAlgo SignatureAlgorithm, hashAlgo HashAlgorithm) bool

CompatibleAlgorithms returns true if the signature and hash algorithms is a valid pair for a signing key supported by the package.

The package currently supports ECDSA with the 2 curves P-256 and secp256k1. Both curves can be paired with a supported hash function of 256-bits output (SHA2-256, SHA3-256, Keccak256)

Types

type Hash

type Hash = hash.Hash

type HashAlgorithm

type HashAlgorithm = hash.HashingAlgorithm

HashAlgorithm is an identifier for a hash algorithm.

func StringToHashAlgorithm

func StringToHashAlgorithm(s string) HashAlgorithm

StringToHashAlgorithm converts a string to a HashAlgorithm.

type Hasher

type Hasher = hash.Hasher

func NewHasher

func NewHasher(algo HashAlgorithm) (Hasher, error)

NewHasher initializes and returns a new hasher with the given hash algorithm.

This function returns an error if the hash algorithm is invalid.

func NewKeccak_256

func NewKeccak_256() Hasher

NewKeccak_256 returns a new instance of Keccak256 hasher.

func NewSHA2_256

func NewSHA2_256() Hasher

NewSHA2_256 returns a new instance of SHA2-256 hasher.

func NewSHA2_384

func NewSHA2_384() Hasher

NewSHA2_384 returns a new instance of SHA2-384 hasher.

func NewSHA3_256

func NewSHA3_256() Hasher

NewSHA3_256 returns a new instance of SHA3-256 hasher.

func NewSHA3_384

func NewSHA3_384() Hasher

NewSHA3_384 returns a new instance of SHA3-384 hasher.

type InMemorySigner

type InMemorySigner struct {
	PrivateKey PrivateKey
	Hasher     Hasher
}

An InMemorySigner is a signer that generates signatures using an in-memory private key.

InMemorySigner implements simple signing that does not protect the private key against any tampering or side channel attacks. The implementation is pure software and does not include any isolation or secure-hardware protecion. InMemorySigner should not be used for sensitive keys (for instance production keys) unless extra protection measures are taken.

func NewInMemorySigner

func NewInMemorySigner(privateKey PrivateKey, hashAlgo HashAlgorithm) (InMemorySigner, error)

NewInMemorySigner initializes and returns a new in-memory signer with the provided private key and hashing algorithm.

It returns an error if the signature and hashing algorithms are not compatible.

func (InMemorySigner) PublicKey

func (s InMemorySigner) PublicKey() PublicKey

func (InMemorySigner) Sign

func (s InMemorySigner) Sign(message []byte) ([]byte, error)

type NaiveSigner

type NaiveSigner = InMemorySigner

NaiveSigner is an alias for InMemorySigner.

func NewNaiveSigner

func NewNaiveSigner(privateKey PrivateKey, hashAlgo HashAlgorithm) (NaiveSigner, error)

NewNaiveSigner is an alias for NewInMemorySigner.

type PrivateKey

type PrivateKey = crypto.PrivateKey

A PrivateKey is a cryptographic private key that can be used for in-memory signing.

func DecodePrivateKeyHex

func DecodePrivateKeyHex(sigAlgo SignatureAlgorithm, s string) (PrivateKey, error)

DecodePrivateKeyHex decodes a raw hex encoded private key with the given signature algorithm.

func GeneratePrivateKey

func GeneratePrivateKey(sigAlgo SignatureAlgorithm, seed []byte) (PrivateKey, error)

GeneratePrivateKey generates a private key with the specified signature algorithm from the given seed. Note that the output key is directly mapped from the seed. The seed is therefore equivalent to the private key. This implementation is pure software and does not include any isolation or secure-hardware protecion. The function should not be used for sensitive keys (for instance production keys) unless extra protection measures are taken.

type PublicKey

type PublicKey = crypto.PublicKey

A PublicKey is a cryptographic public key that can be used to verify signatures.

func DecodePublicKeyHex

func DecodePublicKeyHex(sigAlgo SignatureAlgorithm, s string) (PublicKey, error)

DecodePublicKeyHex decodes a raw hex encoded public key with the given signature algorithm.

func DecodePublicKeyPEM

func DecodePublicKeyPEM(sigAlgo SignatureAlgorithm, s string) (PublicKey, error)

DecodePublicKeyHex decodes a PEM ECDSA public key with the given curve, encoded in `sigAlgo`.

The function only supports ECDSA with P256 and secp256k1 curves.

type SignatureAlgorithm

type SignatureAlgorithm = crypto.SigningAlgorithm

SignatureAlgorithm is an identifier for a signature algorithm (and parameters if applicable).

func StringToSignatureAlgorithm

func StringToSignatureAlgorithm(s string) SignatureAlgorithm

StringToSignatureAlgorithm converts a string to a SignatureAlgorithm.

type Signer

type Signer interface {
	// Sign signs the given message with this signer.
	Sign(message []byte) ([]byte, error)
	// PublicKey returns the verification public key corresponding to the signer
	PublicKey() PublicKey
}

A Signer is capable of generating cryptographic signatures.