go-multihash: github.com/multiformats/go-multihash Index | Examples | Files | Directories

package multihash

import "github.com/multiformats/go-multihash"

Package multihash is the Go implementation of https://github.com/multiformats/multihash, or self-describing hashes.

Index

Examples

Package Files

io.go multihash.go set.go sum.go

Constants

const (
    IDENTITY = 0x00
    // Deprecated: use IDENTITY
    ID         = IDENTITY
    SHA1       = 0x11
    SHA2_256   = 0x12
    SHA2_512   = 0x13
    SHA3_224   = 0x17
    SHA3_256   = 0x16
    SHA3_384   = 0x15
    SHA3_512   = 0x14
    SHA3       = SHA3_512
    KECCAK_224 = 0x1A
    KECCAK_256 = 0x1B
    KECCAK_384 = 0x1C
    KECCAK_512 = 0x1D

    SHAKE_128 = 0x18
    SHAKE_256 = 0x19

    BLAKE2B_MIN = 0xb201
    BLAKE2B_MAX = 0xb240
    BLAKE2S_MIN = 0xb241
    BLAKE2S_MAX = 0xb260

    MD5 = 0xd5

    DBL_SHA2_256 = 0x56

    MURMUR3_128 = 0x22
    // Deprecated: use MURMUR3_128
    MURMUR3 = MURMUR3_128

    SHA2_256_TRUNC254_PADDED  = 0x1012
    X11                       = 0x1100
    POSEIDON_BLS12_381_A1_FC1 = 0xb401
)

constants

Variables

var (
    ErrUnknownCode      = errors.New("unknown multihash code")
    ErrTooShort         = errors.New("multihash too short. must be >= 2 bytes")
    ErrTooLong          = errors.New("multihash too long. must be < 129 bytes")
    ErrLenNotSupported  = errors.New("multihash does not yet support digests longer than 127 bytes")
    ErrInvalidMultihash = errors.New("input isn't valid multihash")

    ErrVarintBufferShort = errors.New("uvarint: buffer too small")
    ErrVarintTooLong     = errors.New("uvarint: varint too big (max 64bit)")
)

errors

var Codes = map[uint64]string{
    IDENTITY:                  "identity",
    SHA1:                      "sha1",
    SHA2_256:                  "sha2-256",
    SHA2_512:                  "sha2-512",
    SHA3_224:                  "sha3-224",
    SHA3_256:                  "sha3-256",
    SHA3_384:                  "sha3-384",
    SHA3_512:                  "sha3-512",
    DBL_SHA2_256:              "dbl-sha2-256",
    MURMUR3_128:               "murmur3-128",
    KECCAK_224:                "keccak-224",
    KECCAK_256:                "keccak-256",
    KECCAK_384:                "keccak-384",
    KECCAK_512:                "keccak-512",
    SHAKE_128:                 "shake-128",
    SHAKE_256:                 "shake-256",
    SHA2_256_TRUNC254_PADDED:  "sha2-256-trunc254-padded",
    X11:                       "x11",
    POSEIDON_BLS12_381_A1_FC1: "poseidon-bls12_381-a2-fc1",
    MD5:                       "md5",
}

Codes maps a hash code to it's name

var DefaultLengths = map[uint64]int{
    IDENTITY:     -1,
    SHA1:         20,
    SHA2_256:     32,
    SHA2_512:     64,
    SHA3_224:     28,
    SHA3_256:     32,
    SHA3_384:     48,
    SHA3_512:     64,
    DBL_SHA2_256: 32,
    KECCAK_224:   28,
    KECCAK_256:   32,
    MURMUR3_128:  4,
    KECCAK_384:   48,
    KECCAK_512:   64,
    SHAKE_128:    32,
    SHAKE_256:    64,
    X11:          64,
    MD5:          16,
}

DefaultLengths maps a hash code to it's default length

var ErrLenTooLarge = errors.New("requested length was too large for digest")
var ErrSumNotSupported = errors.New("Function not implemented. Complain to lib maintainer.")

ErrSumNotSupported is returned when the Sum function code is not implemented

var Names = map[string]uint64{
    "identity":                  IDENTITY,
    "sha1":                      SHA1,
    "sha2-256":                  SHA2_256,
    "sha2-512":                  SHA2_512,
    "sha3":                      SHA3_512,
    "sha3-224":                  SHA3_224,
    "sha3-256":                  SHA3_256,
    "sha3-384":                  SHA3_384,
    "sha3-512":                  SHA3_512,
    "dbl-sha2-256":              DBL_SHA2_256,
    "murmur3-128":               MURMUR3_128,
    "keccak-224":                KECCAK_224,
    "keccak-256":                KECCAK_256,
    "keccak-384":                KECCAK_384,
    "keccak-512":                KECCAK_512,
    "shake-128":                 SHAKE_128,
    "shake-256":                 SHAKE_256,
    "sha2-256-trunc254-padded":  SHA2_256_TRUNC254_PADDED,
    "x11":                       X11,
    "md5":                       MD5,
    "poseidon-bls12_381-a2-fc1": POSEIDON_BLS12_381_A1_FC1,
}

Names maps the name of a hash to the code

func Encode Uses

func Encode(buf []byte, code uint64) ([]byte, error)

Encode a hash digest along with the specified function code. Note: the length is derived from the length of the digest itself.

func EncodeName Uses

func EncodeName(buf []byte, name string) ([]byte, error)

EncodeName is like Encode() but providing a string name instead of a numeric code. See Names for allowed values.

Code:

// ignores errors for simplicity - don't do that at home.
buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
mhbuf, _ := EncodeName(buf, "sha1")
mhhex := hex.EncodeToString(mhbuf)
fmt.Printf("hex: %v\n", mhhex)

Output:

hex: 11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33

func RegisterHashFunc Uses

func RegisterHashFunc(code uint64, hashFunc HashFunc) error

RegisterHashFunc adds an entry to the package-level code -> hash func map. The hash function must return at least the requested number of bytes. If it returns more, the hash will be truncated.

func ValidCode Uses

func ValidCode(code uint64) bool

ValidCode checks whether a multihash code is valid.

type DecodedMultihash Uses

type DecodedMultihash struct {
    Code   uint64
    Name   string
    Length int    // Length is just int as it is type of len() opearator
    Digest []byte // Digest holds the raw multihash bytes
}

DecodedMultihash represents a parsed multihash and allows easy access to the different parts of a multihash.

func Decode Uses

func Decode(buf []byte) (*DecodedMultihash, error)

Decode parses multihash bytes into a DecodedMultihash.

Code:

// ignores errors for simplicity - don't do that at home.
buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")
mhbuf, _ := EncodeName(buf, "sha1")
o, _ := Decode(mhbuf)
mhhex := hex.EncodeToString(o.Digest)
fmt.Printf("obj: %v 0x%x %d %s\n", o.Name, o.Code, o.Length, mhhex)

Output:

obj: sha1 0x11 20 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33

type ErrInconsistentLen Uses

type ErrInconsistentLen struct {
    // contains filtered or unexported fields
}

ErrInconsistentLen is returned when a decoded multihash has an inconsistent length

func (ErrInconsistentLen) Error Uses

func (e ErrInconsistentLen) Error() string

type HashFunc Uses

type HashFunc func(data []byte, length int) (digest []byte, err error)

HashFunc is a hash function that hashes data into digest.

The length is the size the digest will be truncated to. While the hash function isn't responsible for truncating the digest, it may want to error if the length is invalid for the hash function (e.g., truncation would make the hash useless).

type Multihash Uses

type Multihash []byte

Multihash is byte slice with the following form: <hash function code><digest size><hash function output>. See the spec for more information.

func Cast Uses

func Cast(buf []byte) (Multihash, error)

Cast casts a buffer onto a multihash, and returns an error if it does not work.

func FromB58String Uses

func FromB58String(s string) (m Multihash, err error)

FromB58String parses a B58-encoded multihash.

func FromHexString Uses

func FromHexString(s string) (Multihash, error)

FromHexString parses a hex-encoded multihash.

func MHFromBytes Uses

func MHFromBytes(buf []byte) (int, Multihash, error)

MHFromBytes reads a multihash from the given byte buffer, returning the number of bytes read as well as the multihash

func Sum Uses

func Sum(data []byte, code uint64, length int) (Multihash, error)

Sum obtains the cryptographic sum of a given buffer. The length parameter indicates the length of the resulting digest and passing a negative value use default length values for the selected hash function.

func (Multihash) B58String Uses

func (m Multihash) B58String() string

B58String returns the B58-encoded representation of a multihash.

func (*Multihash) HexString Uses

func (m *Multihash) HexString() string

HexString returns the hex-encoded representation of a multihash.

func (*Multihash) String Uses

func (m *Multihash) String() string

String is an alias to HexString().

type Reader Uses

type Reader interface {
    io.Reader

    ReadMultihash() (Multihash, error)
}

Reader is an io.Reader wrapper that exposes a function to read a whole multihash, parse it, and return it.

func NewReader Uses

func NewReader(r io.Reader) Reader

NewReader wraps an io.Reader with a multihash.Reader

type Set Uses

type Set struct {
    // contains filtered or unexported fields
}

Set is a set of Multihashes, holding one copy per Multihash.

func NewSet Uses

func NewSet() *Set

NewSet creates a new set correctly initialized.

func (*Set) Add Uses

func (s *Set) Add(m Multihash)

Add adds a new multihash to the set.

func (*Set) All Uses

func (s *Set) All() []Multihash

All returns a slice with all the elements in the set.

func (*Set) ForEach Uses

func (s *Set) ForEach(f func(m Multihash) error) error

ForEach runs f(m) with each multihash in the set. If returns immediately if f(m) returns an error.

func (*Set) Has Uses

func (s *Set) Has(m Multihash) bool

Has returns true if the element is in the set.

func (*Set) Len Uses

func (s *Set) Len() int

Len returns the number of elements in the set.

func (*Set) Remove Uses

func (s *Set) Remove(m Multihash)

Remove removes an element from the set.

func (*Set) Visit Uses

func (s *Set) Visit(m Multihash) bool

Visit adds a multihash only if it is not in the set already. Returns true if the multihash was added (was not in the set before).

type Writer Uses

type Writer interface {
    io.Writer

    WriteMultihash(Multihash) error
}

Writer is an io.Writer wrapper that exposes a function to write a whole multihash.

func NewWriter Uses

func NewWriter(w io.Writer) Writer

NewWriter wraps an io.Writer with a multihash.Writer

Directories

PathSynopsis
multihash
optsPackage opts helps to write commands which may take multihash options.

Package multihash imports 15 packages (graph) and is imported by 289 packages. Updated 2020-05-13. Refresh now. Tools for package owners.