package hmac

Import Path
	crypto/hmac (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 2 packages

Involved Source Files

	   #d hmac.go
		Package hmac implements the Keyed-Hash Message Authentication Code (HMAC) as
		defined in U.S. Federal Information Processing Standards Publication 198.
		An HMAC is a cryptographic hash that uses a key to sign a message.
		The receiver verifies the hash by recomputing it using the same key.

		Receivers should be careful to use Equal to compare MACs in order to avoid
		timing side-channels:

		// ValidMAC reports whether messageMAC is a valid HMAC tag for message.
		func ValidMAC(message, messageMAC, key []byte) bool {
			mac := hmac.New(sha256.New, key)
			mac.Write(message)
			expectedMAC := mac.Sum(nil)
			return hmac.Equal(messageMAC, expectedMAC)
		}
Package-Level Type Names (total 2, neither is exported)

	/* sort exporteds by: alphabet | popularity */
	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type hmac (struct)

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			inner hash.Hash
			ipad []byte
			marshaled bool
				If marshaled is true, then opad and ipad do not contain a padded
				copy of the key, but rather the marshaled state of outer/inner after
				opad/ipad has been fed into it.

			opad []byte
			outer hash.Hash
		Methods (total 5, all are exported)
			(*T) BlockSize() int
			(*T) Reset()
			(*T) Size() int
			(*T) Sum(in []byte) []byte
			(*T) Write(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : hash.Hash
			*T : io.Writer

	 type marshalable (interface)
		Marshalable is the combination of encoding.BinaryMarshaler and
		encoding.BinaryUnmarshaler. Their method definitions are repeated here to
		avoid a dependency on the encoding package.

		Methods (total 2, both are exported)
			( T) MarshalBinary() ([]byte, error)
			( T) UnmarshalBinary([]byte) error
		Implemented By (at least 6, in which 2 are exported)
			*net/url.URL
			*time.Time
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			*crypto/md5.digest
			*crypto/sha1.digest
			*crypto/sha256.digest
			*crypto/sha512.digest
		Implements (at least 2, both are exported)
			 T : encoding.BinaryMarshaler
			 T : encoding.BinaryUnmarshaler


Package-Level Functions (total 2, both are exported)

	 func Equal(mac1, mac2 []byte) bool
		Equal compares two MACs for equality without leaking timing information.

	 func New(h func() hash.Hash, key []byte) hash.Hash
		New returns a new HMAC hash using the given hash.Hash type and key.
		New functions like sha256.New from crypto/sha256 can be used as h.
		h must return a new Hash every time it is called.
		Note that unlike other hash implementations in the standard library,
		the returned Hash does not implement encoding.BinaryMarshaler
		or encoding.BinaryUnmarshaler.

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.