mhash - Hash Library
mhash 0.6.5
#include "mhash.h"
Informative Functions
size_t mhash_count(void); size_t mhash_get_block_size(hashid type); char *mhash_get_hash_name(hashid type); size_t mhash_get_hash_pblock(hashid type);
Key Generation Functions
int mhash_keygen(keygenid algorithm, hashid opt_algorithm, unsigned long count,
void* keyword, int keysize, void* salt, int saltsize,
unsigned char* password, int passwordlen);
Initializing Functions
MHASH mhash_init(hashid type); MHASH hmac_mhash_init(const hashid type, void *key, int keysize, int block);
Update Functions
int mhash(MHASH thread, const void *plaintext, size_t size);
Finalizing Functions
void *mhash_end(MHASH thread); void *hmac_mhash_end(MHASH thread);
Available Hashes
enum hashid {
MHASH_CRC32,
MHASH_MD5,
MHASH_SHA1,
MHASH_HAVAL,
MHASH_RIPEMD160,
MHASH_SNEFRU,
MHASH_TIGER,
MHASH_GOST,
MHASH_CRC32B
};
typedef enum hashid hashid;
Available Key Generation algorithms
enum keygenid {
KEYGEN_MCRYPT,
KEYGEN_ASIS,
KEYGEN_HEX,
KEYGEN_S2K_SIMPLE,
KEYGEN_S2K_SALTED,
KEYGEN_S2K_ISALTED
};
typedef enum keygenid keygenid;
The mhash library provides an easy to use C interface for several hash algorithms (also known as ``one-way'' algorithm). These can be used to create checksums, message digests and more. Currently, MD5, SHA1, GOST, TIGER, RIPE-MD160, HAVAL and several other algorithms are supported.
We will describe the API of mhash in detail now. The order follows the one in the SYNOPSIS directly.
This returns the hashid of the last available hash. Hashes are numbered from 0 to mhash_count().
If type exists, this returns the used blocksize of the hash type in bytes. Otherwise, it returns 0.
If type exists, this returns the name of the hash type. Otherwise, a
NULL pointer is returned. The string is allocated with malloc(3)
seperately, so do not forget to free(3) it.
It returns the block size that the algorithm operates. This is used in hmac_mhash_init. If the return value is 0 you shouldn't use that algorithm in HMAC.
This setups a context to begin hashing using the algorithm type. It returns a descriptor to that context which will result in leaking
memory, if you do not call mhash_end(3) later. Returns MHASH_FAILED on failure.
This setups a context to begin hashing using the algorithm type in
HMAC mode.
HMAC is a mechanism for message authentication using cryptographic hash functions, and is described in rfc2104.
key should be a pointer to the key and keysize its len. The block is the block size (in bytes) that the algorithm operates. It should be
obtained by mhash_get_hash_pblock(). If its 0 it defaults to
64. After calling it you should use mhash() to update the
context. It returns a descriptor to that context which will result in
leaking memory, if you do not call hmac_mhash_end(3) later.
Returns MHASH_FAILED on failure. =item int mhash
(MHASH thread, const void *plaintext, size_t size);
This updates the context described by thread with plaintext. size is the length of plaintext which may be binary data.
This frees all resources associated with thread and returns the result of the whole hashing operation (the ``digest'').
This frees all resources associated with thread and returns the result of the whole hashing operation (the ``mac'').
This function, generates a key from a password. The password is read from password and it's len should be in passwordlen. If it is desirable (and supported by the algorithm, eg. KEYGEN_S2K_SALTED) a salt may be specified in salt or may be NULL. The key generation algorithm is specified in algorithm, and that algorithm may (internally) use the algorithm specified in opt_algorithm, which should be a hash algorithm. The algorithm may use the count internally (eg. KEYGEN_S2K_ISALTED). The generated keyword is stored in keyword, which should be (at least) keysize bytes long.
This function returns 1 if the specified key generation algorithm needs a salt to be specified.
This function returns 1 if the specified key generation algorithm needs the
count field in mhash_keygen(). The count field tells the
algorithm to hash repeatedly the password and to stop when count bytes have been processed.
This function returns the size of the salt size, that the specific algorithm will use. If it returns 0, then there is no limitation in the size.
This function returns 1 if the specified key generation algorithm needs a
hash algorithm to be specified in the opt_algorithm field in mhash_keygen().
This returns the keygenid of the last available key generation algorithm. Algorithms are numbered
from 0 to mhash_keygen_count().
If type exists, this returns the name of the keygen type. Otherwise, a
NULL pointer is returned. The string is allocated with malloc(3)
seperately, so do not forget to free(3) it.
Hashing STDIN until EOF.
#include <mhash.h> #include <stdio.h> #include <stdlib.h>
int main(void)
{
int i;
MHASH td;
unsigned char buffer;
unsigned char *hash;
td = mhash_init(MHASH_MD5);
if (td == MHASH_FAILED) exit(1);
while (fread(&buffer, 1, 1, stdin) == 1) {
mhash(td, &buffer, 1);
}
hash = mhash_end(td);
printf("Hash:");
for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) {
printf("%.2x", hash[i]);
}
printf("\n");
exit(0); }
An example program using HMAC:
#include <mhash.h> #include <stdio.h>
int main()
{
char password[] = "Jefe";
int keylen = 4;
char data[] = "what do ya want for nothing?";
int datalen = 28;
MHASH td;
unsigned char *mac;
int j;
td = hmac_mhash_init(MHASH_MD5, password, keylen,
mhash_get_hash_pblock(MHASH_MD5));
mhash(td, data, datalen);
mac = hmac_mhash_end(td);
/* * The output should be 0x750c783e6ab0b503eaa86e310a5db738 * according to RFC 2104. */
printf("0x");
for (j = 0; j < mhash_get_block_size(MHASH_MD5); j++) {
printf("%.2x", mac[j]);
}
printf("\n");
exit(0);
}
This library was originally written by Nikos Mavroyanopoulos <nmav@hellug.gr> who passed the project over to Sascha Schumann <sascha@schumann.cx> in May 1999.
If you find any, please send a bug report (preferrably together with a patch) to the maintainer Sascha Schumann <sascha@schumann.cx> with a detailed description on how to reproduce the bug.
Sascha Schumann <sascha@schumann.cx>