Go: crypto Index | Files | Directories

package crypto

import "crypto"

Package crypto collects common cryptographic constants.


Package Files


func RegisterHash Uses

func RegisterHash(h Hash, f func() hash.Hash)

RegisterHash registers a function that returns a new instance of the given hash function. This is intended to be called from the init function in packages that implement hash functions.

type Decrypter Uses

type Decrypter interface {
    // Public returns the public key corresponding to the opaque,
    // private key.
    Public() PublicKey

    // Decrypt decrypts msg. The opts argument should be appropriate for
    // the primitive used. See the documentation in each implementation for
    // details.
    Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)

Decrypter is an interface for an opaque private key that can be used for asymmetric decryption operations. An example would be an RSA key kept in a hardware module.

type DecrypterOpts Uses

type DecrypterOpts interface{}

type Hash Uses

type Hash uint

Hash identifies a cryptographic hash function that is implemented in another package.

const (
    MD4         Hash = 1 + iota // import golang.org/x/crypto/md4
    MD5                         // import crypto/md5
    SHA1                        // import crypto/sha1
    SHA224                      // import crypto/sha256
    SHA256                      // import crypto/sha256
    SHA384                      // import crypto/sha512
    SHA512                      // import crypto/sha512
    MD5SHA1                     // no implementation; MD5+SHA1 used for TLS RSA
    RIPEMD160                   // import golang.org/x/crypto/ripemd160
    SHA3_224                    // import golang.org/x/crypto/sha3
    SHA3_256                    // import golang.org/x/crypto/sha3
    SHA3_384                    // import golang.org/x/crypto/sha3
    SHA3_512                    // import golang.org/x/crypto/sha3
    SHA512_224                  // import crypto/sha512
    SHA512_256                  // import crypto/sha512
    BLAKE2s_256                 // import golang.org/x/crypto/blake2s
    BLAKE2b_256                 // import golang.org/x/crypto/blake2b
    BLAKE2b_384                 // import golang.org/x/crypto/blake2b
    BLAKE2b_512                 // import golang.org/x/crypto/blake2b


func (Hash) Available Uses

func (h Hash) Available() bool

Available reports whether the given hash function is linked into the binary.

func (Hash) HashFunc Uses

func (h Hash) HashFunc() Hash

HashFunc simply returns the value of h so that Hash implements SignerOpts.

func (Hash) New Uses

func (h Hash) New() hash.Hash

New returns a new hash.Hash calculating the given hash function. New panics if the hash function is not linked into the binary.

func (Hash) Size Uses

func (h Hash) Size() int

Size returns the length, in bytes, of a digest resulting from the given hash function. It doesn't require that the hash function in question be linked into the program.

type PrivateKey Uses

type PrivateKey interface{}

PrivateKey represents a private key using an unspecified algorithm.

type PublicKey Uses

type PublicKey interface{}

PublicKey represents a public key using an unspecified algorithm.

type Signer Uses

type Signer interface {
    // Public returns the public key corresponding to the opaque,
    // private key.
    Public() PublicKey

    // Sign signs digest with the private key, possibly using entropy from
    // rand. For an RSA key, the resulting signature should be either a
    // PKCS#1 v1.5 or PSS signature (as indicated by opts). For an (EC)DSA
    // key, it should be a DER-serialised, ASN.1 signature structure.
    // Hash implements the SignerOpts interface and, in most cases, one can
    // simply pass in the hash function used as opts. Sign may also attempt
    // to type assert opts to other types in order to obtain algorithm
    // specific values. See the documentation in each package for details.
    // Note that when a signature of a hash of a larger message is needed,
    // the caller is responsible for hashing the larger message and passing
    // the hash (as digest) and the hash function (as opts) to Sign.
    Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)

Signer is an interface for an opaque private key that can be used for signing operations. For example, an RSA key kept in a hardware module.

type SignerOpts Uses

type SignerOpts interface {
    // HashFunc returns an identifier for the hash function used to produce
    // the message passed to Signer.Sign, or else zero to indicate that no
    // hashing was done.
    HashFunc() Hash

SignerOpts contains options for signing with a Signer.


aesPackage aes implements AES encryption (formerly Rijndael), as defined in U.S.
cipherPackage cipher implements standard block cipher modes that can be wrapped around low-level block cipher implementations.
desPackage des implements the Data Encryption Standard (DES) and the Triple Data Encryption Algorithm (TDEA) as defined in U.S.
dsaPackage dsa implements the Digital Signature Algorithm, as defined in FIPS 186-3.
ecdsaPackage ecdsa implements the Elliptic Curve Digital Signature Algorithm, as defined in FIPS 186-3.
ellipticPackage elliptic implements several standard elliptic curves over prime fields.
hmacPackage hmac implements the Keyed-Hash Message Authentication Code (HMAC) as defined in U.S.
internal/cipherhwPackage cipherhw exposes common functions for detecting whether hardware support for certain ciphers and authenticators is present.
md5Package md5 implements the MD5 hash algorithm as defined in RFC 1321.
randPackage rand implements a cryptographically secure pseudorandom number generator.
rc4Package rc4 implements RC4 encryption, as defined in Bruce Schneier's Applied Cryptography.
rsaPackage rsa implements RSA encryption as specified in PKCS#1.
sha1Package sha1 implements the SHA-1 hash algorithm as defined in RFC 3174.
sha256Package sha256 implements the SHA224 and SHA256 hash algorithms as defined in FIPS 180-4.
sha512Package sha512 implements the SHA-384, SHA-512, SHA-512/224, and SHA-512/256 hash algorithms as defined in FIPS 180-4.
subtlePackage subtle implements functions that are often useful in cryptographic code but require careful thought to use correctly.
tlsPackage tls partially implements TLS 1.2, as specified in RFC 5246.
x509Package x509 parses X.509-encoded keys and certificates.
x509/pkixPackage pkix contains shared, low level structures used for ASN.1 parsing and serialization of X.509 certificates, CRL and OCSP.

Package crypto imports 3 packages (graph) and is imported by 2446 packages. Updated 2017-08-25. Refresh now. Tools for package owners.