Documentation
¶
Overview ¶
Package digest provides a generalized type to opaquely represent message digests and their operations within the registry. The Digest type is designed to serve as a flexible identifier in a content-addressable system. More importantly, it provides tools and wrappers to work with hash.Hash-based digests with little effort.
Basics ¶
The format of a digest is simply a string with two parts, dubbed the "algorithm" and the "digest", separated by a colon:
<algorithm>:<digest>
An example of a sha256 digest representation follows:
sha256:7173b809ca12ec5dee4506cd86be934c4596dd234ee82c0662eac04a8c2c71dc
In this case, the string "sha256" is the algorithm and the hex bytes are the "digest".
Because the Digest type is simply a string, once a valid Digest is obtained, comparisons are cheap, quick and simple to express with the standard equality operator.
Verification ¶
The main benefit of using the Digest type is simple verification against a given digest. The Verifier interface, modeled after the stdlib hash.Hash interface, provides a common write sink for digest verification. After writing is complete, calling the Verifier.Verified method will indicate whether or not the stream of bytes matches the target digest.
Missing Features ¶
In addition to the above, we intend to add the following features to this package:
1. A Digester type that supports write sink digest calculation.
2. Suspend and resume of ongoing digest calculations to support efficient digest verification in the registry.
Index ¶
- Variables
- type Algorithm
- func (a Algorithm) Available() bool
- func (a Algorithm) Digester() Digester
- func (a Algorithm) Encode(d []byte) string
- func (a Algorithm) FromBytes(p []byte) Digest
- func (a Algorithm) FromReader(rd io.Reader) (Digest, error)
- func (a Algorithm) FromString(s string) Digest
- func (a Algorithm) Hash() hash.Hash
- func (a *Algorithm) Set(value string) error
- func (a Algorithm) Size() int
- func (a Algorithm) String() string
- func (a Algorithm) Validate(encoded string) error
- type Digest
- func FromBytes(p []byte) Digest
- func FromReader(rd io.Reader) (Digest, error)
- func FromString(s string) Digest
- func NewDigest(alg Algorithm, h hash.Hash) Digest
- func NewDigestFromBytes(alg Algorithm, p []byte) Digest
- func NewDigestFromEncoded(alg Algorithm, encoded string) Digest
- func NewDigestFromHex(alg, hex string) Digest
- func Parse(s string) (Digest, error)
- type Digester
- type Verifier
Constants ¶
This section is empty.
Variables ¶
var ( // ErrDigestInvalidFormat returned when digest format invalid. ErrDigestInvalidFormat = fmt.Errorf("invalid checksum digest format") // ErrDigestInvalidLength returned when digest has invalid length. ErrDigestInvalidLength = fmt.Errorf("invalid checksum digest length") // ErrDigestUnsupported returned when the digest algorithm is unsupported. ErrDigestUnsupported = fmt.Errorf("unsupported digest algorithm") )
var DigestRegexp = regexp.MustCompile(`[a-z0-9]+(?:[.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+`)
DigestRegexp matches valid digest types.
var DigestRegexpAnchored = regexp.MustCompile(`^` + DigestRegexp.String() + `$`)
DigestRegexpAnchored matches valid digest types, anchored to the start and end of the match.
Functions ¶
This section is empty.
Types ¶
type Algorithm ¶
type Algorithm string
Algorithm identifies and implementation of a digester by an identifier. Note the that this defines both the hash algorithm used and the string encoding.
const ( SHA256 Algorithm = "sha256" // sha256 with hex encoding (lower case only) SHA384 Algorithm = "sha384" // sha384 with hex encoding (lower case only) SHA512 Algorithm = "sha512" // sha512 with hex encoding (lower case only) // Canonical is the primary digest algorithm used with the distribution // project. Other digests may be used but this one is the primary storage // digest. Canonical = SHA256 )
supported digest types
func (Algorithm) Available ¶
Available returns true if the digest type is available for use. If this returns false, Digester and Hash will return nil.
func (Algorithm) Digester ¶
Digester returns a new digester for the specified algorithm. If the algorithm does not have a digester implementation, nil will be returned. This can be checked by calling Available before calling Digester.
func (Algorithm) Encode ¶
Encode encodes the raw bytes of a digest, typically from a hash.Hash, into the encoded portion of the digest.
func (Algorithm) FromBytes ¶
FromBytes digests the input and returns a Digest.
func (Algorithm) FromReader ¶
FromReader returns the digest of the reader using the algorithm.
func (Algorithm) FromString ¶
FromString digests the string input and returns a Digest.
func (Algorithm) Hash ¶
Hash returns a new hash as used by the algorithm. If not available, the method will panic. Check Algorithm.Available() before calling.
func (*Algorithm) Set ¶
Set implemented to allow use of Algorithm as a command line flag.
func (Algorithm) Size ¶
Size returns number of bytes returned by the hash.
type Digest ¶
type Digest string
Digest allows simple protection of hex formatted digest strings, prefixed by their algorithm. Strings of type Digest have some guarantee of being in the correct format and it provides quick access to the components of a digest string.
The following is an example of the contents of Digest types:
sha256:7173b809ca12ec5dee4506cd86be934c4596dd234ee82c0662eac04a8c2c71dc
This allows to abstract the digest behind this type and work only in those terms.
func FromReader ¶
FromReader consumes the content of rd until io.EOF, returning canonical digest.
func FromString ¶
FromString digests the input and returns a Digest.
func NewDigest ¶
NewDigest returns a Digest from alg and a hash.Hash object.
func NewDigestFromBytes ¶
NewDigestFromBytes returns a new digest from the byte contents of p. Typically, this can come from hash.Hash.Sum(...) or xxx.SumXXX(...) functions. This is also useful for rebuilding digests from binary serializations.
func NewDigestFromEncoded ¶
NewDigestFromEncoded returns a Digest from alg and the encoded digest.
func NewDigestFromHex ¶
NewDigestFromHex is deprecated. Please use NewDigestFromEncoded.
func Parse ¶
Parse parses s and returns the validated digest object. An error will be returned if the format is invalid.
func (Digest) Algorithm ¶
Algorithm returns the algorithm portion of the digest. This will panic if the underlying digest is not in a valid format.
func (Digest) Encoded ¶
Encoded returns the encoded portion of the digest. This will panic if the underlying digest is not in a valid format.
func (Digest) Validate ¶
Validate checks that the contents of d is a valid digest, returning an error if not.
type Digester ¶
type Digester interface {
Hash() hash.Hash // provides direct access to underlying hash instance.
Digest() Digest
}
Digester calculates the digest of written data. Writes should go directly to the return value of Hash, while calling Digest will return the current value of the digest.
type Verifier ¶
type Verifier interface {
io.Writer
// Verified will return true if the content written to Verifier matches
// the digest.
Verified() bool
}
Verifier presents a general verification interface to be used with message digests and other byte stream verifications. Users instantiate a Verifier from one of the various methods, write the data under test to it then check the result with the Verified method.
Source Files