hash.h File Reference

#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
#include "hash-ops.h"

Include dependency graph for hash.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	crypto::is_blob_type< T >
	a descriptor for dispatching serialize More...
struct	crypto::has_free_serializer< T >
	a descriptor for dispatching serialize More...
struct	crypto::is_basic_type< T >
	a descriptor for dispatching serialize More...
struct	crypto::is_basic_type< std::pair< F, S > >
struct	crypto::is_basic_type< std::string >
struct	crypto::serializer< Archive, T >
	... wouldn't a class be better? More...
union	crypto::hash_state

Namespaces
namespace	crypto
	crypto namespace.
namespace	crypto::serialization
namespace	detail
	declaration and default definition for the functions used the API
namespace	crypto::serialization::detail

Macros
#define	true   1
#define	false   0
#define	_MSC_STDINT_H_
#define	_W64
#define	INT8_MIN   ((int8_t)_I8_MIN)
#define	INT8_MAX   _I8_MAX
#define	INT16_MIN   ((int16_t)_I16_MIN)
#define	INT16_MAX   _I16_MAX
#define	INT32_MIN   ((int32_t)_I32_MIN)
#define	INT32_MAX   _I32_MAX
#define	INT64_MIN   ((int64_t)_I64_MIN)
#define	INT64_MAX   _I64_MAX
#define	UINT8_MAX   _UI8_MAX
#define	UINT16_MAX   _UI16_MAX
#define	UINT32_MAX   _UI32_MAX
#define	UINT64_MAX   _UI64_MAX
#define	INT_LEAST8_MIN   INT8_MIN
#define	INT_LEAST8_MAX   INT8_MAX
#define	INT_LEAST16_MIN   INT16_MIN
#define	INT_LEAST16_MAX   INT16_MAX
#define	INT_LEAST32_MIN   INT32_MIN
#define	INT_LEAST32_MAX   INT32_MAX
#define	INT_LEAST64_MIN   INT64_MIN
#define	INT_LEAST64_MAX   INT64_MAX
#define	UINT_LEAST8_MAX   UINT8_MAX
#define	UINT_LEAST16_MAX   UINT16_MAX
#define	UINT_LEAST32_MAX   UINT32_MAX
#define	UINT_LEAST64_MAX   UINT64_MAX
#define	INT_FAST8_MIN   INT8_MIN
#define	INT_FAST8_MAX   INT8_MAX
#define	INT_FAST16_MIN   INT16_MIN
#define	INT_FAST16_MAX   INT16_MAX
#define	INT_FAST32_MIN   INT32_MIN
#define	INT_FAST32_MAX   INT32_MAX
#define	INT_FAST64_MIN   INT64_MIN
#define	INT_FAST64_MAX   INT64_MAX
#define	UINT_FAST8_MAX   UINT8_MAX
#define	UINT_FAST16_MAX   UINT16_MAX
#define	UINT_FAST32_MAX   UINT32_MAX
#define	UINT_FAST64_MAX   UINT64_MAX
#define	INTPTR_MIN   INT32_MIN
#define	INTPTR_MAX   INT32_MAX
#define	UINTPTR_MAX   UINT32_MAX
#define	INTMAX_MIN   INT64_MIN
#define	INTMAX_MAX   INT64_MAX
#define	UINTMAX_MAX   UINT64_MAX
#define	PTRDIFF_MIN   _I32_MIN
#define	PTRDIFF_MAX   _I32_MAX
#define	SIG_ATOMIC_MIN   INT_MIN
#define	SIG_ATOMIC_MAX   INT_MAX
#define	SIZE_MAX   _UI32_MAX
#define	WCHAR_MIN   0
#define	WCHAR_MAX   _UI16_MAX
#define	WINT_MIN   0
#define	WINT_MAX   _UI16_MAX
#define	INT8_C(val)
#define	INT16_C(val)
#define	INT32_C(val)
#define	INT64_C(val)
#define	UINT8_C(val)
#define	UINT16_C(val)
#define	UINT32_C(val)
#define	UINT64_C(val)
#define	INTMAX_C   INT64_C
#define	UINTMAX_C   UINT64_C
#define	BLOB_SERIALIZER(T)
#define	FREE_SERIALIZER(T)
#define	VARIANT_TAG(Archive, Type, Tag)
#define	BEGIN_SERIALIZE()
#define	BEGIN_SERIALIZE_OBJECT()
#define	PREPARE_CUSTOM_VECTOR_SERIALIZATION(size, vec)
#define	PREPARE_CUSTOM_DEQUE_SERIALIZATION(size, vec)
#define	END_SERIALIZE()
#define	VALUE(f)
#define	FIELD_N(t, f)
#define	FIELD(f)
#define	FIELDS(f)
#define	VARINT_FIELD(f)
#define	VARINT_FIELD_N(t, f)
#define	LITTLE_ENDIAN   1234
#define	BIG_ENDIAN   4321
#define	PDP_ENDIAN   3412
#define	BYTE_ORDER   LITTLE_ENDIAN
#define	IDENT32(x)
#define	IDENT64(x)
#define	SWAP32(x)
#define	SWAP64(x)
#define	UNUSED
#define	SWAP32LE   IDENT32
#define	SWAP32BE   SWAP32
#define	swap32le   ident32
#define	swap32be   swap32
#define	mem_inplace_swap32le   mem_inplace_ident
#define	mem_inplace_swap32be   mem_inplace_swap32
#define	memcpy_swap32le   memcpy_ident32
#define	memcpy_swap32be   memcpy_swap32
#define	SWAP64LE   IDENT64
#define	SWAP64BE   SWAP64
#define	swap64le   ident64
#define	swap64be   swap64
#define	mem_inplace_swap64le   mem_inplace_ident
#define	mem_inplace_swap64be   mem_inplace_swap64
#define	memcpy_swap64le   memcpy_ident64
#define	memcpy_swap64be   memcpy_swap64
#define	PUSH_WARNINGS   _Pragma("GCC diagnostic push")
#define	POP_WARNINGS   _Pragma("GCC diagnostic pop")
#define	DISABLE_VS_WARNINGS(w)
#define	DISABLE_GCC_WARNING   DISABLE_GCC_AND_CLANG_WARNING
#define	DISABLE_CLANG_WARNING(w)
#define	DISABLE_GCC_AND_CLANG_WARNING(w)

Typedefs
typedef int	crypto::bool
typedef signed char	crypto::int8_t
typedef signed short	crypto::int16_t
typedef signed int	crypto::int32_t
typedef unsigned char	crypto::uint8_t
typedef unsigned short	crypto::uint16_t
typedef unsigned int	crypto::uint32_t
typedef signed __int64	crypto::int64_t
typedef unsigned __int64	crypto::uint64_t
typedef int8_t	crypto::int_least8_t
typedef int16_t	crypto::int_least16_t
typedef int32_t	crypto::int_least32_t
typedef int64_t	crypto::int_least64_t
typedef uint8_t	crypto::uint_least8_t
typedef uint16_t	crypto::uint_least16_t
typedef uint32_t	crypto::uint_least32_t
typedef uint64_t	crypto::uint_least64_t
typedef int8_t	crypto::int_fast8_t
typedef int16_t	crypto::int_fast16_t
typedef int32_t	crypto::int_fast32_t
typedef int64_t	crypto::int_fast64_t
typedef uint8_t	crypto::uint_fast8_t
typedef uint16_t	crypto::uint_fast16_t
typedef uint32_t	crypto::uint_fast32_t
typedef uint64_t	crypto::uint_fast64_t
typedef _W64 signed int	crypto::intptr_t
typedef _W64 unsigned int	crypto::uintptr_t
typedef int64_t	crypto::intmax_t
typedef uint64_t	crypto::uintmax_t

Enumerations
enum	{ crypto::HASH_SIZE = 32 , crypto::HASH_DATA_AREA = 136 }

Functions
template<class Archive, class T>
bool	crypto::do_serialize (Archive &ar, T &v)
	just calls the serialize function defined for ar and v...
template<class Archive>
bool	crypto::do_serialize (Archive &ar, bool &v)
template<typename T>
void	crypto::serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void	crypto::serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< false > &)
template<typename T>
void	crypto::serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void	crypto::serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< false > &)
template<class Stream>
bool	crypto::serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< true >, bool noeof)
template<class Stream>
bool	crypto::serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< false >, bool noeof)
template<class Archive>
bool	crypto::serialization::check_stream_state (Archive &ar, bool noeof=false)
template<class Archive, class T>
bool	crypto::serialization::serialize (Archive &ar, T &v)
template<class Archive, class T>
bool	crypto::serialization::serialize_noeof (Archive &ar, T &v)
template<template< bool > class Archive>
bool	crypto::do_serialize (Archive< false > &ar, std::string &str)
template<template< bool > class Archive>
bool	crypto::do_serialize (Archive< true > &ar, std::string &str)
void	crypto::hash_permutation (union hash_state *state)
void	crypto::hash_process (union hash_state *state, const uint8_t *buf, size_t count)
void	crypto::cn_fast_hash (const void *data, size_t length, char *hash)
void	crypto::cn_slow_hash (const void *data, size_t length, char *hash, int variant, int prehashed, uint64_t height)
void	crypto::hash_extra_blake (const void *data, size_t length, char *hash)
void	crypto::hash_extra_groestl (const void *data, size_t length, char *hash)
void	crypto::hash_extra_jh (const void *data, size_t length, char *hash)
void	crypto::hash_extra_skein (const void *data, size_t length, char *hash)
void	crypto::tree_hash (const char(*hashes)[HASH_SIZE], size_t count, char *root_hash)
void	crypto::cn_fast_hash (const void *data, std::size_t length, hash &hash)
hash	crypto::cn_fast_hash (const void *data, std::size_t length)
void	crypto::cn_slow_hash (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	crypto::cn_slow_hash_prehashed (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	crypto::tree_hash (const hash *hashes, std::size_t count, hash &root_hash)
std::ostream &	crypto::operator<< (std::ostream &o, const crypto::hash &v)
std::ostream &	crypto::operator<< (std::ostream &o, const crypto::hash8 &v)
std::ostream &	crypto::operator<< (std::ostream &o, const crypto::hash64 &v)

Variables
	crypto::PUSH_WARNINGS
POD_CLASS	crypto::hash
POD_CLASS	crypto::hash8
POD_CLASS	crypto::hash64

Macro Definition Documentation

_MSC_STDINT_H_

#define _MSC_STDINT_H_

Definition at line 43 of file hash.h.

_W64

#define _W64

BEGIN_SERIALIZE

#define BEGIN_SERIALIZE

(

)

Value:

template <bool W, template <bool> class Archive>          \
bool do_serialize(Archive<W> &ar) {

BEGIN_SERIALIZE_OBJECT

#define BEGIN_SERIALIZE_OBJECT

(

)

Value:

template <bool W, template <bool> class Archive>          \
bool do_serialize(Archive<W> &ar) {                   \
  ar.begin_object();                          \
  bool r = do_serialize_object(ar);                   \
  ar.end_object();                            \
  return r;                               \
}                                 \
template <bool W, template <bool> class Archive>          \
bool do_serialize_object(Archive<W> &ar){

BIG_ENDIAN

#define BIG_ENDIAN   4321

BLOB_SERIALIZER

#define BLOB_SERIALIZER

(

T

)

Value:

template<>                                \
struct is_blob_type<T> {                      \
  typedef boost::true_type type;                  \
}

BYTE_ORDER

#define BYTE_ORDER   LITTLE_ENDIAN

DISABLE_CLANG_WARNING

#define DISABLE_CLANG_WARNING

(

w

)

DISABLE_GCC_AND_CLANG_WARNING

#define DISABLE_GCC_AND_CLANG_WARNING

(

w

)

Value:

_Pragma(BOOST_PP_STRINGIZE(GCC diagnostic ignored BOOST_PP_STRINGIZE(-W##w)))

DISABLE_GCC_WARNING

#define DISABLE_GCC_WARNING   DISABLE_GCC_AND_CLANG_WARNING

DISABLE_VS_WARNINGS

#define DISABLE_VS_WARNINGS

(

w

)

END_SERIALIZE

#define END_SERIALIZE

(

)

Value:

return ar.stream().good();            \
}

false

#define false   0

FIELD

#define FIELD

(

f

)

Value:

do {                          \
  ar.tag(#f);                     \
  bool r = ::do_serialize(ar, f);         \
  if (!r || !ar.stream().good()) return false;    \
} while(0);

FIELD_N

#define FIELD_N	(		t,
			f )

Value:

do {                          \
  ar.tag(t);                      \
  bool r = ::do_serialize(ar, f);         \
  if (!r || !ar.stream().good()) return false;    \
} while(0);

FIELDS

#define FIELDS

(

f

)

Value:

do {                                  \
  bool r = ::do_serialize(ar, f);                 \
  if (!r || !ar.stream().good()) return false;            \
} while(0);

FREE_SERIALIZER

#define FREE_SERIALIZER

(

T

)

Value:

template<>                                \
struct has_free_serializer<T> {                   \
  typedef boost::true_type type;                  \
}

IDENT32

#define IDENT32

(

x

)

Value:

((uint32_t) (x))

IDENT64

#define IDENT64

(

x

)

Value:

((uint64_t) (x))

INT16_C

#define INT16_C

(

val

)

Value:

val##i16

INT16_MAX

#define INT16_MAX   _I16_MAX

INT16_MIN

#define INT16_MIN   ((int16_t)_I16_MIN)

INT32_C

#define INT32_C

(

val

)

Value:

val##i32

INT32_MAX

#define INT32_MAX   _I32_MAX

INT32_MIN

#define INT32_MIN   ((int32_t)_I32_MIN)

INT64_C

#define INT64_C

(

val

)

Value:

val##i64

INT64_MAX

#define INT64_MAX   _I64_MAX

INT64_MIN

#define INT64_MIN   ((int64_t)_I64_MIN)

INT8_C

#define INT8_C

(

val

)

Value:

val##i8

INT8_MAX

#define INT8_MAX   _I8_MAX

INT8_MIN

#define INT8_MIN   ((int8_t)_I8_MIN)

INT_FAST16_MAX

#define INT_FAST16_MAX   INT16_MAX

INT_FAST16_MIN

#define INT_FAST16_MIN   INT16_MIN

INT_FAST32_MAX

#define INT_FAST32_MAX   INT32_MAX

INT_FAST32_MIN

#define INT_FAST32_MIN   INT32_MIN

INT_FAST64_MAX

#define INT_FAST64_MAX   INT64_MAX

INT_FAST64_MIN

#define INT_FAST64_MIN   INT64_MIN

INT_FAST8_MAX

#define INT_FAST8_MAX   INT8_MAX

INT_FAST8_MIN

#define INT_FAST8_MIN   INT8_MIN

INT_LEAST16_MAX

#define INT_LEAST16_MAX   INT16_MAX

INT_LEAST16_MIN

#define INT_LEAST16_MIN   INT16_MIN

INT_LEAST32_MAX

#define INT_LEAST32_MAX   INT32_MAX

INT_LEAST32_MIN

#define INT_LEAST32_MIN   INT32_MIN

INT_LEAST64_MAX

#define INT_LEAST64_MAX   INT64_MAX

INT_LEAST64_MIN

#define INT_LEAST64_MIN   INT64_MIN

INT_LEAST8_MAX

#define INT_LEAST8_MAX   INT8_MAX

INT_LEAST8_MIN

#define INT_LEAST8_MIN   INT8_MIN

INTMAX_C

#define INTMAX_C   INT64_C

INTMAX_MAX

#define INTMAX_MAX   INT64_MAX

INTMAX_MIN

#define INTMAX_MIN   INT64_MIN

INTPTR_MAX

#define INTPTR_MAX   INT32_MAX

INTPTR_MIN

#define INTPTR_MIN   INT32_MIN

LITTLE_ENDIAN

#define LITTLE_ENDIAN   1234

mem_inplace_swap32be

#define mem_inplace_swap32be   mem_inplace_swap32

mem_inplace_swap32le

#define mem_inplace_swap32le   mem_inplace_ident

mem_inplace_swap64be

#define mem_inplace_swap64be   mem_inplace_swap64

mem_inplace_swap64le

#define mem_inplace_swap64le   mem_inplace_ident

memcpy_swap32be

#define memcpy_swap32be   memcpy_swap32

memcpy_swap32le

#define memcpy_swap32le   memcpy_ident32

memcpy_swap64be

#define memcpy_swap64be   memcpy_swap64

memcpy_swap64le

#define memcpy_swap64le   memcpy_ident64

PDP_ENDIAN

#define PDP_ENDIAN   3412

POP_WARNINGS

#define POP_WARNINGS   _Pragma("GCC diagnostic pop")

PREPARE_CUSTOM_DEQUE_SERIALIZATION

#define PREPARE_CUSTOM_DEQUE_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_deque_serialization(size, vec, typename Archive<W>::is_saving())

PREPARE_CUSTOM_VECTOR_SERIALIZATION

#define PREPARE_CUSTOM_VECTOR_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())

PTRDIFF_MAX

#define PTRDIFF_MAX   _I32_MAX

PTRDIFF_MIN

#define PTRDIFF_MIN   _I32_MIN

PUSH_WARNINGS

#define PUSH_WARNINGS   _Pragma("GCC diagnostic push")

SIG_ATOMIC_MAX

#define SIG_ATOMIC_MAX   INT_MAX

SIG_ATOMIC_MIN

#define SIG_ATOMIC_MIN   INT_MIN

SIZE_MAX

#define SIZE_MAX   _UI32_MAX

SWAP32

#define SWAP32

(

x

)

Value:

((((uint32_t) (x) & 0x000000ff) << 24) | \
(((uint32_t) (x) & 0x0000ff00) <<  8) | \
(((uint32_t) (x) & 0x00ff0000) >>  8) | \
(((uint32_t) (x) & 0xff000000) >> 24))

SWAP32BE

#define SWAP32BE   SWAP32

swap32be

#define swap32be   swap32

SWAP32LE

#define SWAP32LE   IDENT32

swap32le

#define swap32le   ident32

SWAP64

#define SWAP64

(

x

)

Value:

((((uint64_t) (x) & 0x00000000000000ff) << 56) | \
(((uint64_t) (x) & 0x000000000000ff00) << 40) | \
(((uint64_t) (x) & 0x0000000000ff0000) << 24) | \
(((uint64_t) (x) & 0x00000000ff000000) <<  8) | \
(((uint64_t) (x) & 0x000000ff00000000) >>  8) | \
(((uint64_t) (x) & 0x0000ff0000000000) >> 24) | \
(((uint64_t) (x) & 0x00ff000000000000) >> 40) | \
(((uint64_t) (x) & 0xff00000000000000) >> 56))

SWAP64BE

#define SWAP64BE   SWAP64

swap64be

#define swap64be   swap64

SWAP64LE

#define SWAP64LE   IDENT64

swap64le

#define swap64le   ident64

true

#define true   1

UINT16_C

#define UINT16_C

(

val

)

Value:

val##ui16

UINT16_MAX

#define UINT16_MAX   _UI16_MAX

UINT32_C

#define UINT32_C

(

val

)

Value:

val##ui32

UINT32_MAX

#define UINT32_MAX   _UI32_MAX

UINT64_C

#define UINT64_C

(

val

)

Value:

val##ui64

UINT64_MAX

#define UINT64_MAX   _UI64_MAX

UINT8_C

#define UINT8_C

(

val

)

Value:

val##ui8

UINT8_MAX

#define UINT8_MAX   _UI8_MAX

UINT_FAST16_MAX

#define UINT_FAST16_MAX   UINT16_MAX

UINT_FAST32_MAX

#define UINT_FAST32_MAX   UINT32_MAX

UINT_FAST64_MAX

#define UINT_FAST64_MAX   UINT64_MAX

UINT_FAST8_MAX

#define UINT_FAST8_MAX   UINT8_MAX

UINT_LEAST16_MAX

#define UINT_LEAST16_MAX   UINT16_MAX

UINT_LEAST32_MAX

#define UINT_LEAST32_MAX   UINT32_MAX

UINT_LEAST64_MAX

#define UINT_LEAST64_MAX   UINT64_MAX

UINT_LEAST8_MAX

#define UINT_LEAST8_MAX   UINT8_MAX

UINTMAX_C

#define UINTMAX_C   UINT64_C

UINTMAX_MAX

#define UINTMAX_MAX   UINT64_MAX

UINTPTR_MAX

#define UINTPTR_MAX   UINT32_MAX

UNUSED

#define UNUSED

VALUE

#define VALUE

(

f

)

Value:

do {                          \
  ar.tag(#f);                     \
  bool r = ::do_serialize(ar, f);         \
  if (!r || !ar.stream().good()) return false;    \
} while(0);

VARIANT_TAG

#define VARIANT_TAG	(		Archive,
			Type,
			Tag )

Value:

template <bool W>                         \
struct variant_serialization_traits<Archive<W>, Type> {       \
  static inline typename Archive<W>::variant_tag_type get_tag() { \
    return Tag;                           \
  }                                   \
}

VARINT_FIELD

#define VARINT_FIELD

(

f

)

Value:

do {                      \
  ar.tag(#f);                 \
  ar.serialize_varint(f);         \
  if (!ar.stream().good()) return false;  \
} while(0);

VARINT_FIELD_N

#define VARINT_FIELD_N	(		t,
			f )

Value:

do {                      \
  ar.tag(t);                  \
  ar.serialize_varint(f);         \
  if (!ar.stream().good()) return false;  \
} while(0);

WCHAR_MAX

#define WCHAR_MAX   _UI16_MAX

WCHAR_MIN

#define WCHAR_MIN   0

WINT_MAX

#define WINT_MAX   _UI16_MAX

WINT_MIN

#define WINT_MIN   0