--- /dev/null
+@c acl_hashes.texi
+
+@section Hash functions
+ A hash function is an algorithm to map an arbitrary long message (in the form
+ of a bit string) to a fixed length message digest or hash value.
+ The hash function aims to be collision free, which means that it is not
+ practicable to find two messages with the same hash value (although this
+ collision must exist). Also it should not be practicable to construct a
+ message which maps to a given hash value.
+
+@subsection List of available hash functions
+ The following hash functions are currently implemented:
+@itemize @bullet
+ @item Blake
+ @item BlueMidnightWish
+ @item CubeHash
+ @item Echo
+ @item Grøstl
+ @item Keccak
+ @item MD5
+ @item SHA-256
+ @item SHA-1
+ @item Shabal
+ @item Skein
+@end itemize
+
+@subsection High frequent parameters:
+@table @asis
+ @item block size
+ 512 bits
+ @item hash value size
+ 128 bits, 160 bits, 224 bits, 256 bits, 384 bits, 512 bits
+@end table
+
+
+@subsection Parts of a hash function
+@itemize @bullet
+ @item initialization function
+ @item compression algorithm
+ @item finalization function
+@end itemize
+
+@subsection hash function API
+ The API is not always consistent due to the fact that we tried to optimize the
+ code for size (flash, heap and stack) and speed (runtime of the different
+ components).
+ Generally the API of the implemented block ciphers consists of:
+@table @code
+ @item *_init
+ function, which implements the initialisation of the context
+ @item *_nextBlock
+ function, which implements the compression algorithm
+ @item *_lastBlock
+ function, which implements the the padding algorithm
+ @item *_ctx2hash
+ function, which turns a context into an actual hash value
+ @item *_ctx_t
+ context type, which can contains the state of a hashing process
+@end table
+
+@subsubsection @code{*_init} function
+ The @code{*_init} function generally takes a pointer to the context as parameter.
+ This function initializes the context with algorithm specific values.
+
+@subsubsection @code{*_nextBlock} function
+ The @code{*_nextBlock} function is the core of each hash function. It updates the hash
+ state with a given message block. So this function uses a context pointer and
+ a message pointer as parameters. The size of a message block is fixed for each
+ hash function (mostly 512 bit). For the last block of a messages which may be
+ smaller than the blocksize you have to use the @code{*_lastBlock} function described
+ below.
+
+@subsubsection @code{*_lastBlock} function
+ The @code{*_lastBlock} function finalizes the context with the last bits of a
+ message. Since the last block is not required to have the blocksize you have
+ to specify the length of the last block (normally in bits). This function
+ performs the padding and final processing.
+
+@subsubsection @code{*_ctx2hash} function
+ The @code{*_ctx2hash} function turns a given hash context into an actual hash value.
+ If multiple sized hash value may be created from a context it is necessary to
+ give the the size of the hash value as parameter.
+
+
+@subsection Hash function abstraction layer (HFAL)
+
+