+++ /dev/null
-// Package multihash is the Go implementation of
-// https://github.com/multiformats/multihash, or self-describing
-// hashes.
-package multihash
-
-import (
- "encoding/binary"
- "encoding/hex"
- "errors"
- "fmt"
- "math"
-
- b58 "github.com/mr-tron/base58/base58"
-)
-
-// errors
-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)")
-)
-
-// ErrInconsistentLen is returned when a decoded multihash has an inconsistent length
-type ErrInconsistentLen struct {
- dm *DecodedMultihash
-}
-
-func (e ErrInconsistentLen) Error() string {
- return fmt.Sprintf("multihash length inconsistent: %v", e.dm)
-}
-
-// constants
-const (
- ID = 0x00
- 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
-
- DBL_SHA2_256 = 0x56
-
- MURMUR3 = 0x22
-
- X11 = 0x1100
-)
-
-func init() {
- // Add blake2b (64 codes)
- for c := uint64(BLAKE2B_MIN); c <= BLAKE2B_MAX; c++ {
- n := c - BLAKE2B_MIN + 1
- name := fmt.Sprintf("blake2b-%d", n*8)
- Names[name] = c
- Codes[c] = name
- DefaultLengths[c] = int(n)
- }
-
- // Add blake2s (32 codes)
- for c := uint64(BLAKE2S_MIN); c <= BLAKE2S_MAX; c++ {
- n := c - BLAKE2S_MIN + 1
- name := fmt.Sprintf("blake2s-%d", n*8)
- Names[name] = c
- Codes[c] = name
- DefaultLengths[c] = int(n)
- }
-}
-
-// Names maps the name of a hash to the code
-var Names = map[string]uint64{
- "id": ID,
- "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": MURMUR3,
- "keccak-224": KECCAK_224,
- "keccak-256": KECCAK_256,
- "keccak-384": KECCAK_384,
- "keccak-512": KECCAK_512,
- "shake-128": SHAKE_128,
- "shake-256": SHAKE_256,
- "x11": X11,
-}
-
-// Codes maps a hash code to it's name
-var Codes = map[uint64]string{
- ID: "id",
- 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: "murmur3",
- KECCAK_224: "keccak-224",
- KECCAK_256: "keccak-256",
- KECCAK_384: "keccak-384",
- KECCAK_512: "keccak-512",
- SHAKE_128: "shake-128",
- SHAKE_256: "shake-256",
- X11: "x11",
-}
-
-// DefaultLengths maps a hash code to it's default length
-var DefaultLengths = map[uint64]int{
- ID: -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: 4,
- KECCAK_384: 48,
- KECCAK_512: 64,
- SHAKE_128: 32,
- SHAKE_256: 64,
- X11: 64,
-}
-
-func uvarint(buf []byte) (uint64, []byte, error) {
- n, c := binary.Uvarint(buf)
-
- if c == 0 {
- return n, buf, ErrVarintBufferShort
- } else if c < 0 {
- return n, buf[-c:], ErrVarintTooLong
- } else {
- return n, buf[c:], nil
- }
-}
-
-// DecodedMultihash represents a parsed multihash and allows
-// easy access to the different parts of a multihash.
-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
-}
-
-// Multihash is byte slice with the following form:
-// <hash function code><digest size><hash function output>.
-// See the spec for more information.
-type Multihash []byte
-
-// HexString returns the hex-encoded representation of a multihash.
-func (m *Multihash) HexString() string {
- return hex.EncodeToString([]byte(*m))
-}
-
-// String is an alias to HexString().
-func (m *Multihash) String() string {
- return m.HexString()
-}
-
-// FromHexString parses a hex-encoded multihash.
-func FromHexString(s string) (Multihash, error) {
- b, err := hex.DecodeString(s)
- if err != nil {
- return Multihash{}, err
- }
-
- return Cast(b)
-}
-
-// B58String returns the B58-encoded representation of a multihash.
-func (m Multihash) B58String() string {
- return b58.Encode([]byte(m))
-}
-
-// FromB58String parses a B58-encoded multihash.
-func FromB58String(s string) (m Multihash, err error) {
- b, err := b58.Decode(s)
- if err != nil {
- return Multihash{}, ErrInvalidMultihash
- }
-
- return Cast(b)
-}
-
-// Cast casts a buffer onto a multihash, and returns an error
-// if it does not work.
-func Cast(buf []byte) (Multihash, error) {
- dm, err := Decode(buf)
- if err != nil {
- return Multihash{}, err
- }
-
- if !ValidCode(dm.Code) {
- return Multihash{}, ErrUnknownCode
- }
-
- return Multihash(buf), nil
-}
-
-// Decode parses multihash bytes into a DecodedMultihash.
-func Decode(buf []byte) (*DecodedMultihash, error) {
-
- if len(buf) < 2 {
- return nil, ErrTooShort
- }
-
- var err error
- var code, length uint64
-
- code, buf, err = uvarint(buf)
- if err != nil {
- return nil, err
- }
-
- length, buf, err = uvarint(buf)
- if err != nil {
- return nil, err
- }
-
- if length > math.MaxInt32 {
- return nil, errors.New("digest too long, supporting only <= 2^31-1")
- }
-
- dm := &DecodedMultihash{
- Code: code,
- Name: Codes[code],
- Length: int(length),
- Digest: buf,
- }
-
- if len(dm.Digest) != dm.Length {
- return nil, ErrInconsistentLen{dm}
- }
-
- return dm, nil
-}
-
-// Encode a hash digest along with the specified function code.
-// Note: the length is derived from the length of the digest itself.
-func Encode(buf []byte, code uint64) ([]byte, error) {
-
- if !ValidCode(code) {
- return nil, ErrUnknownCode
- }
-
- start := make([]byte, 2*binary.MaxVarintLen64, 2*binary.MaxVarintLen64+len(buf))
- spot := start
- n := binary.PutUvarint(spot, code)
- spot = start[n:]
- n += binary.PutUvarint(spot, uint64(len(buf)))
-
- return append(start[:n], buf...), nil
-}
-
-// EncodeName is like Encode() but providing a string name
-// instead of a numeric code. See Names for allowed values.
-func EncodeName(buf []byte, name string) ([]byte, error) {
- return Encode(buf, Names[name])
-}
-
-// ValidCode checks whether a multihash code is valid.
-func ValidCode(code uint64) bool {
- _, ok := Codes[code]
- return ok
-}
OSDN Git Service
