diff --git a/Crypto/Hash/MD2.hs b/Crypto/Hash/MD2.hs
--- a/Crypto/Hash/MD2.hs
+++ b/Crypto/Hash/MD2.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "md2.h md2_init"
+foreign import ccall unsafe "md2.h cryptohash_md2_init"
     c_md2_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "md2.h md2_update"
+foreign import ccall "md2.h cryptohash_md2_update"
     c_md2_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "md2.h md2_finalize"
+foreign import ccall unsafe "md2.h cryptohash_md2_finalize"
     c_md2_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/MD4.hs b/Crypto/Hash/MD4.hs
--- a/Crypto/Hash/MD4.hs
+++ b/Crypto/Hash/MD4.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "md4.h md4_init"
+foreign import ccall unsafe "md4.h cryptohash_md4_init"
     c_md4_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "md4.h md4_update"
+foreign import ccall "md4.h cryptohash_md4_update"
     c_md4_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "md4.h md4_finalize"
+foreign import ccall unsafe "md4.h cryptohash_md4_finalize"
     c_md4_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/MD5.hs b/Crypto/Hash/MD5.hs
--- a/Crypto/Hash/MD5.hs
+++ b/Crypto/Hash/MD5.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "md5.h md5_init"
+foreign import ccall unsafe "md5.h cryptohash_md5_init"
     c_md5_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "md5.h md5_update"
+foreign import ccall "md5.h cryptohash_md5_update"
     c_md5_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "md5.h md5_finalize"
+foreign import ccall unsafe "md5.h cryptohash_md5_finalize"
     c_md5_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/RIPEMD160.hs b/Crypto/Hash/RIPEMD160.hs
--- a/Crypto/Hash/RIPEMD160.hs
+++ b/Crypto/Hash/RIPEMD160.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "ripemd.h ripemd160_init"
+foreign import ccall unsafe "ripemd.h cryptohash_ripemd160_init"
     c_ripemd160_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "ripemd.h ripemd160_update"
+foreign import ccall "ripemd.h cryptohash_ripemd160_update"
     c_ripemd160_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "ripemd.h ripemd160_finalize"
+foreign import ccall unsafe "ripemd.h cryptohash_ripemd160_finalize"
     c_ripemd160_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA1.hs b/Crypto/Hash/SHA1.hs
--- a/Crypto/Hash/SHA1.hs
+++ b/Crypto/Hash/SHA1.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha1.h sha1_init"
+foreign import ccall unsafe "sha1.h cryptohash_sha1_init"
     c_sha1_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "sha1.h sha1_update"
+foreign import ccall "sha1.h cryptohash_sha1_update"
     c_sha1_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha1.h sha1_finalize"
+foreign import ccall unsafe "sha1.h cryptohash_sha1_finalize"
     c_sha1_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA224.hs b/Crypto/Hash/SHA224.hs
--- a/Crypto/Hash/SHA224.hs
+++ b/Crypto/Hash/SHA224.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha256.h sha224_init"
+foreign import ccall unsafe "sha256.h cryptohash_sha224_init"
     c_sha224_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "sha256.h sha224_update"
+foreign import ccall "sha256.h cryptohash_sha224_update"
     c_sha224_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha256.h sha224_finalize"
+foreign import ccall unsafe "sha256.h cryptohash_sha224_finalize"
     c_sha224_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA256.hs b/Crypto/Hash/SHA256.hs
--- a/Crypto/Hash/SHA256.hs
+++ b/Crypto/Hash/SHA256.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha256.h sha256_init"
+foreign import ccall unsafe "sha256.h cryptohash_sha256_init"
     c_sha256_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "sha256.h sha256_update"
+foreign import ccall "sha256.h cryptohash_sha256_update"
     c_sha256_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha256.h sha256_finalize"
+foreign import ccall unsafe "sha256.h cryptohash_sha256_finalize"
     c_sha256_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA3.hs b/Crypto/Hash/SHA3.hs
--- a/Crypto/Hash/SHA3.hs
+++ b/Crypto/Hash/SHA3.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha3.h sha3_init"
+foreign import ccall unsafe "sha3.h cryptohash_sha3_init"
     c_sha3_init :: Ptr Ctx -> Word32 -> IO ()
 
-foreign import ccall "sha3.h sha3_update"
+foreign import ccall "sha3.h cryptohash_sha3_update"
     c_sha3_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha3.h sha3_finalize"
+foreign import ccall unsafe "sha3.h cryptohash_sha3_finalize"
     c_sha3_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA384.hs b/Crypto/Hash/SHA384.hs
--- a/Crypto/Hash/SHA384.hs
+++ b/Crypto/Hash/SHA384.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha512.h sha384_init"
+foreign import ccall unsafe "sha512.h cryptohash_sha384_init"
     c_sha384_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "sha512.h sha384_update"
+foreign import ccall "sha512.h cryptohash_sha384_update"
     c_sha384_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha512.h sha384_finalize"
+foreign import ccall unsafe "sha512.h cryptohash_sha384_finalize"
     c_sha384_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/SHA512.hs b/Crypto/Hash/SHA512.hs
--- a/Crypto/Hash/SHA512.hs
+++ b/Crypto/Hash/SHA512.hs
@@ -85,16 +85,16 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "sha512.h sha512_init"
+foreign import ccall unsafe "sha512.h cryptohash_sha512_init"
     c_sha512_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "sha512.h sha512_update"
+foreign import ccall "sha512.h cryptohash_sha512_update"
     c_sha512_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "sha512.h sha512_finalize"
+foreign import ccall unsafe "sha512.h cryptohash_sha512_finalize"
     c_sha512_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
-foreign import ccall unsafe "sha512.h sha512_init_t"
+foreign import ccall unsafe "sha512.h cryptohash_sha512_init_t"
     c_sha512_init_t :: Ptr Ctx -> Int -> IO ()
 
 {-# NOINLINE init_t #-}
diff --git a/Crypto/Hash/Skein256.hs b/Crypto/Hash/Skein256.hs
--- a/Crypto/Hash/Skein256.hs
+++ b/Crypto/Hash/Skein256.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "skein256.h skein256_init"
+foreign import ccall unsafe "skein256.h cryptohash_skein256_init"
     c_skein256_init :: Ptr Ctx -> Word32 -> IO ()
 
-foreign import ccall "skein256.h skein256_update"
+foreign import ccall "skein256.h cryptohash_skein256_update"
     c_skein256_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "skein256.h skein256_finalize"
+foreign import ccall unsafe "skein256.h cryptohash_skein256_finalize"
     c_skein256_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/Skein512.hs b/Crypto/Hash/Skein512.hs
--- a/Crypto/Hash/Skein512.hs
+++ b/Crypto/Hash/Skein512.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "skein512.h skein512_init"
+foreign import ccall unsafe "skein512.h cryptohash_skein512_init"
     c_skein512_init :: Ptr Ctx -> Word32 -> IO ()
 
-foreign import ccall "skein512.h skein512_update"
+foreign import ccall "skein512.h cryptohash_skein512_update"
     c_skein512_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "skein512.h skein512_finalize"
+foreign import ccall unsafe "skein512.h cryptohash_skein512_finalize"
     c_skein512_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/Tiger.hs b/Crypto/Hash/Tiger.hs
--- a/Crypto/Hash/Tiger.hs
+++ b/Crypto/Hash/Tiger.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "tiger.h tiger_init"
+foreign import ccall unsafe "tiger.h cryptohash_tiger_init"
     c_tiger_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "tiger.h tiger_update"
+foreign import ccall "tiger.h cryptohash_tiger_update"
     c_tiger_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "tiger.h tiger_finalize"
+foreign import ccall unsafe "tiger.h cryptohash_tiger_finalize"
     c_tiger_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/Crypto/Hash/Whirlpool.hs b/Crypto/Hash/Whirlpool.hs
--- a/Crypto/Hash/Whirlpool.hs
+++ b/Crypto/Hash/Whirlpool.hs
@@ -84,13 +84,13 @@
 withCtxNewThrow :: (Ptr Ctx -> IO a) -> IO a
 withCtxNewThrow f = allocaBytes sizeCtx (f . castPtr)
 
-foreign import ccall unsafe "whirlpool.h whirlpool_init"
+foreign import ccall unsafe "whirlpool.h cryptohash_whirlpool_init"
     c_whirlpool_init :: Ptr Ctx -> IO ()
 
-foreign import ccall "whirlpool.h whirlpool_update"
+foreign import ccall "whirlpool.h cryptohash_whirlpool_update"
     c_whirlpool_update :: Ptr Ctx -> Ptr Word8 -> Word32 -> IO ()
 
-foreign import ccall unsafe "whirlpool.h whirlpool_finalize"
+foreign import ccall unsafe "whirlpool.h cryptohash_whirlpool_finalize"
     c_whirlpool_finalize :: Ptr Ctx -> Ptr Word8 -> IO ()
 
 updateInternalIO :: Ptr Ctx -> ByteString -> IO ()
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,15 +1,15 @@
 CryptoHash
 ==========
 
-hs-cryptohash provides lots of different secure digest algorithms, also
-called cryptohashes. It exposes every common hashes, but also some
-more exotic hashes, provides an extensive list of hashes available
-with a consistant API.
+`hs-cryptohash` provides many different secure digest algorithms, also
+called cryptographic hash functions or, simply, cryptohashes. The package
+exports common hash functions, as well as some more exotic ones, and
+provides a single API for them all.
 
-The general performance are comparable to the most optimised hashes
+The general performance is comparable to the most optimised implementations
 available.
 
-The complete list of supported hashes:
+Here is the complete list of supported algorithms:
 
 * MD2, MD4, MD5 
 * RIPEMD160
@@ -24,11 +24,9 @@
 
     import qualified Crypto.Hash.<HASH> as <Hash>
 
-suggestion: it's easier to import qualified since there's
-a collision with the init symbol, but for only importing
-the hash or hashlazy function there's no such need.
-
-Every hashes, exposes a very similar API.
+We recommend using `import qualified` because the APIs are similar and
+many of the modules reuse the same names. However, if you are ony using
+one module, there is no need to qualify the names.
 
 Incremental API
 ---------------
diff --git a/cbits/bitfn.h b/cbits/bitfn.h
--- a/cbits/bitfn.h
+++ b/cbits/bitfn.h
@@ -175,6 +175,8 @@
 #elif defined( __QNXNTO__ ) && defined( __BIGENDIAN__ )
   # define BIG_ENDIAN 1234
   # define BYTE_ORDER    BIG_ENDIAN
+#elif defined( _AIX )
+  # include <sys/machine.h>
 #else
   # include <endian.h>
 #endif
diff --git a/cbits/md2.c b/cbits/md2.c
--- a/cbits/md2.c
+++ b/cbits/md2.c
@@ -27,7 +27,7 @@
 #include "bitfn.h"
 #include "md2.h"
 
-void md2_init(struct md2_ctx *ctx)
+void cryptohash_md2_init(struct md2_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 	ctx->sz = 0ULL;
@@ -96,7 +96,7 @@
 		t = ctx->cksum[i] ^= S_table[buf[i] ^ t];
 }
 
-void md2_update(struct md2_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_md2_update(struct md2_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -122,14 +122,14 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void md2_finalize(struct md2_ctx *ctx, uint8_t *out)
+void cryptohash_md2_finalize(struct md2_ctx *ctx, uint8_t *out)
 {
 	uint32_t index, padlen;
 
 	index = ctx->sz & 0xf;
 	padlen = 16 - index;
 
-	md2_update(ctx, padding_table[padlen], padlen);
-	md2_update(ctx, ctx->cksum, 16);
+	cryptohash_md2_update(ctx, padding_table[padlen], padlen);
+	cryptohash_md2_update(ctx, ctx->cksum, 16);
 	memcpy(out, ctx->h, 16);
 }
diff --git a/cbits/md2.h b/cbits/md2.h
--- a/cbits/md2.h
+++ b/cbits/md2.h
@@ -37,8 +37,8 @@
 #define MD2_DIGEST_SIZE		16
 #define MD2_CTX_SIZE		sizeof(struct md2_ctx)
 
-void md2_init(struct md2_ctx *ctx);
-void md2_update(struct md2_ctx *ctx, uint8_t *data, uint32_t len);
-void md2_finalize(struct md2_ctx *ctx, uint8_t *out);
+void cryptohash_md2_init(struct md2_ctx *ctx);
+void cryptohash_md2_update(struct md2_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_md2_finalize(struct md2_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/md4.c b/cbits/md4.c
--- a/cbits/md4.c
+++ b/cbits/md4.c
@@ -27,7 +27,7 @@
 #include "bitfn.h"
 #include "md4.h"
 
-void md4_init(struct md4_ctx *ctx)
+void cryptohash_md4_init(struct md4_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -113,7 +113,7 @@
 	ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
 }
 
-void md4_update(struct md4_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_md4_update(struct md4_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -139,7 +139,7 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void md4_finalize(struct md4_ctx *ctx, uint8_t *out)
+void cryptohash_md4_finalize(struct md4_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x80, };
 	uint64_t bits;
@@ -151,10 +151,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	md4_update(ctx, padding, padlen);
+	cryptohash_md4_update(ctx, padding, padlen);
 
 	/* append length */
-	md4_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_md4_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* output hash */
 	le32_to_cpu_array((uint32_t *) out, ctx->h, 4);
diff --git a/cbits/md4.h b/cbits/md4.h
--- a/cbits/md4.h
+++ b/cbits/md4.h
@@ -36,8 +36,8 @@
 #define MD4_DIGEST_SIZE		16
 #define MD4_CTX_SIZE		sizeof(struct md4_ctx)
 
-void md4_init(struct md4_ctx *ctx);
-void md4_update(struct md4_ctx *ctx, uint8_t *data, uint32_t len);
-void md4_finalize(struct md4_ctx *ctx, uint8_t *out);
+void cryptohash_md4_init(struct md4_ctx *ctx);
+void cryptohash_md4_update(struct md4_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_md4_finalize(struct md4_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/md5.c b/cbits/md5.c
--- a/cbits/md5.c
+++ b/cbits/md5.c
@@ -27,7 +27,7 @@
 #include "bitfn.h"
 #include "md5.h"
 
-void md5_init(struct md5_ctx *ctx)
+void cryptohash_md5_init(struct md5_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -126,7 +126,7 @@
 	ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
 }
 
-void md5_update(struct md5_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_md5_update(struct md5_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -152,7 +152,7 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void md5_finalize(struct md5_ctx *ctx, uint8_t *out)
+void cryptohash_md5_finalize(struct md5_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x80, };
 	uint64_t bits;
@@ -165,10 +165,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	md5_update(ctx, padding, padlen);
+	cryptohash_md5_update(ctx, padding, padlen);
 
 	/* append length */
-	md5_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_md5_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* output hash */
 	p[0] = cpu_to_le32(ctx->h[0]);
diff --git a/cbits/md5.h b/cbits/md5.h
--- a/cbits/md5.h
+++ b/cbits/md5.h
@@ -36,8 +36,8 @@
 #define MD5_DIGEST_SIZE		16
 #define MD5_CTX_SIZE		sizeof(struct md5_ctx)
 
-void md5_init(struct md5_ctx *ctx);
-void md5_update(struct md5_ctx *ctx, uint8_t *data, uint32_t len);
-void md5_finalize(struct md5_ctx *ctx, uint8_t *out);
+void cryptohash_md5_init(struct md5_ctx *ctx);
+void cryptohash_md5_update(struct md5_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_md5_finalize(struct md5_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/ripemd.c b/cbits/ripemd.c
--- a/cbits/ripemd.c
+++ b/cbits/ripemd.c
@@ -26,7 +26,7 @@
 #include "bitfn.h"
 #include <string.h>
 
-void ripemd160_init(struct ripemd160_ctx *ctx)
+void cryptohash_ripemd160_init(struct ripemd160_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -249,7 +249,7 @@
 	ctx->h[0] = d2;
 }
 
-void ripemd160_update(struct ripemd160_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_ripemd160_update(struct ripemd160_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -272,7 +272,7 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void ripemd160_finalize(struct ripemd160_ctx *ctx, uint8_t *out)
+void cryptohash_ripemd160_finalize(struct ripemd160_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x80, };
 	uint64_t bits;
@@ -285,10 +285,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	ripemd160_update(ctx, padding, padlen);
+	cryptohash_ripemd160_update(ctx, padding, padlen);
 
 	/* append length */
-	ripemd160_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_ripemd160_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* output digest */
 	p[0] = cpu_to_le32(ctx->h[0]);
diff --git a/cbits/ripemd.h b/cbits/ripemd.h
--- a/cbits/ripemd.h
+++ b/cbits/ripemd.h
@@ -36,8 +36,8 @@
 #define RIPEMD160_DIGEST_SIZE	20
 #define RIPEMD160_CTX_SIZE	sizeof(struct ripemd160_ctx)
 
-void ripemd160_init(struct ripemd160_ctx *ctx);
-void ripemd160_update(struct ripemd160_ctx *ctx, uint8_t *data, uint32_t len);
-void ripemd160_finalize(struct ripemd160_ctx *ctx, uint8_t *out);
+void cryptohash_ripemd160_init(struct ripemd160_ctx *ctx);
+void cryptohash_ripemd160_update(struct ripemd160_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_ripemd160_finalize(struct ripemd160_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/sha1.c b/cbits/sha1.c
--- a/cbits/sha1.c
+++ b/cbits/sha1.c
@@ -26,7 +26,7 @@
 #include "sha1.h"
 #include "bitfn.h"
 
-void sha1_init(struct sha1_ctx *ctx)
+void cryptohash_sha1_init(struct sha1_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -155,7 +155,7 @@
 	ctx->h[4] += e;
 }
 
-void sha1_update(struct sha1_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha1_update(struct sha1_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -182,7 +182,7 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void sha1_finalize(struct sha1_ctx *ctx, uint8_t *out)
+void cryptohash_sha1_finalize(struct sha1_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x80, };
 	uint64_t bits;
@@ -195,10 +195,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	sha1_update(ctx, padding, padlen);
+	cryptohash_sha1_update(ctx, padding, padlen);
 
 	/* append length */
-	sha1_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_sha1_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* output hash */
 	p[0] = cpu_to_be32(ctx->h[0]);
diff --git a/cbits/sha1.h b/cbits/sha1.h
--- a/cbits/sha1.h
+++ b/cbits/sha1.h
@@ -36,8 +36,8 @@
 #define SHA1_DIGEST_SIZE	20
 #define SHA1_CTX_SIZE 		(sizeof(struct sha1_ctx))
 
-void sha1_init(struct sha1_ctx *ctx);
-void sha1_update(struct sha1_ctx *ctx, uint8_t *data, uint32_t len);
-void sha1_finalize(struct sha1_ctx *ctx, uint8_t *out);
+void cryptohash_sha1_init(struct sha1_ctx *ctx);
+void cryptohash_sha1_update(struct sha1_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha1_finalize(struct sha1_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/sha256.c b/cbits/sha256.c
--- a/cbits/sha256.c
+++ b/cbits/sha256.c
@@ -26,7 +26,7 @@
 #include "sha256.h"
 #include "bitfn.h"
 
-void sha224_init(struct sha224_ctx *ctx)
+void cryptohash_sha224_init(struct sha224_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -40,7 +40,7 @@
 	ctx->h[7] = 0xbefa4fa4;
 }
 
-void sha256_init(struct sha256_ctx *ctx)
+void cryptohash_sha256_init(struct sha256_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -110,12 +110,12 @@
 	ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
 }
 
-void sha224_update(struct sha224_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha224_update(struct sha224_ctx *ctx, uint8_t *data, uint32_t len)
 {
-	return sha256_update(ctx, data, len);
+	return cryptohash_sha256_update(ctx, data, len);
 }
 
-void sha256_update(struct sha256_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha256_update(struct sha256_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -143,15 +143,15 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void sha224_finalize(struct sha224_ctx *ctx, uint8_t *out)
+void cryptohash_sha224_finalize(struct sha224_ctx *ctx, uint8_t *out)
 {
 	uint8_t intermediate[SHA256_DIGEST_SIZE];
 
-	sha256_finalize(ctx, intermediate);
+	cryptohash_sha256_finalize(ctx, intermediate);
 	memcpy(out, intermediate, SHA224_DIGEST_SIZE);
 }
 
-void sha256_finalize(struct sha256_ctx *ctx, uint8_t *out)
+void cryptohash_sha256_finalize(struct sha256_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x80, };
 	uint64_t bits;
@@ -164,10 +164,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	sha256_update(ctx, padding, padlen);
+	cryptohash_sha256_update(ctx, padding, padlen);
 
 	/* append length */
-	sha256_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_sha256_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* store to digest */
 	for (i = 0; i < 8; i++)
diff --git a/cbits/sha256.h b/cbits/sha256.h
--- a/cbits/sha256.h
+++ b/cbits/sha256.h
@@ -42,12 +42,12 @@
 #define SHA256_DIGEST_SIZE	32
 #define SHA256_CTX_SIZE		sizeof(struct sha256_ctx)
 
-void sha224_init(struct sha224_ctx *ctx);
-void sha224_update(struct sha224_ctx *ctx, uint8_t *data, uint32_t len);
-void sha224_finalize(struct sha224_ctx *ctx, uint8_t *out);
+void cryptohash_sha224_init(struct sha224_ctx *ctx);
+void cryptohash_sha224_update(struct sha224_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha224_finalize(struct sha224_ctx *ctx, uint8_t *out);
 
-void sha256_init(struct sha256_ctx *ctx);
-void sha256_update(struct sha256_ctx *ctx, uint8_t *data, uint32_t len);
-void sha256_finalize(struct sha256_ctx *ctx, uint8_t *out);
+void cryptohash_sha256_init(struct sha256_ctx *ctx);
+void cryptohash_sha256_update(struct sha256_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha256_finalize(struct sha256_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/sha3.c b/cbits/sha3.c
--- a/cbits/sha3.c
+++ b/cbits/sha3.c
@@ -97,14 +97,14 @@
 	}
 }
 
-void sha3_init(struct sha3_ctx *ctx, uint32_t hashlen)
+void cryptohash_sha3_init(struct sha3_ctx *ctx, uint32_t hashlen)
 {
 	memset(ctx, 0, sizeof(*ctx));
 	ctx->hashlen = hashlen / 8;
 	ctx->bufsz = 200 - 2 * ctx->hashlen;
 }
 
-void sha3_update(struct sha3_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha3_update(struct sha3_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t to_fill;
 
@@ -135,7 +135,7 @@
 	}
 }
 
-void sha3_finalize(struct sha3_ctx *ctx, uint8_t *out)
+void cryptohash_sha3_finalize(struct sha3_ctx *ctx, uint8_t *out)
 {
 	uint64_t w[25];
 
diff --git a/cbits/sha3.h b/cbits/sha3.h
--- a/cbits/sha3.h
+++ b/cbits/sha3.h
@@ -38,8 +38,8 @@
 
 #define SHA3_CTX_SIZE		sizeof(struct sha3_ctx)
 
-void sha3_init(struct sha3_ctx *ctx, uint32_t hashlen);
-void sha3_update(struct sha3_ctx *ctx, uint8_t *data, uint32_t len);
-void sha3_finalize(struct sha3_ctx *ctx, uint8_t *out);
+void cryptohash_sha3_init(struct sha3_ctx *ctx, uint32_t hashlen);
+void cryptohash_sha3_update(struct sha3_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha3_finalize(struct sha3_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/sha512.c b/cbits/sha512.c
--- a/cbits/sha512.c
+++ b/cbits/sha512.c
@@ -26,7 +26,7 @@
 #include "bitfn.h"
 #include "sha512.h"
 
-void sha384_init(struct sha512_ctx *ctx)
+void cryptohash_sha384_init(struct sha512_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -40,7 +40,7 @@
 	ctx->h[7] = 0x47b5481dbefa4fa4ULL;
 }
 
-void sha512_init(struct sha512_ctx *ctx)
+void cryptohash_sha512_init(struct sha512_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -127,12 +127,12 @@
 	ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
 }
 
-void sha384_update(struct sha384_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha384_update(struct sha384_ctx *ctx, uint8_t *data, uint32_t len)
 {
-	return sha512_update(ctx, data, len);
+	return cryptohash_sha512_update(ctx, data, len);
 }
 
-void sha512_update(struct sha512_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_sha512_update(struct sha512_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	unsigned int index, to_fill;
 
@@ -162,15 +162,15 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void sha384_finalize(struct sha384_ctx *ctx, uint8_t *out)
+void cryptohash_sha384_finalize(struct sha384_ctx *ctx, uint8_t *out)
 {
 	uint8_t intermediate[SHA512_DIGEST_SIZE];
 
-	sha512_finalize(ctx, intermediate);
+	cryptohash_sha512_finalize(ctx, intermediate);
 	memcpy(out, intermediate, SHA384_DIGEST_SIZE);
 }
 
-void sha512_finalize(struct sha512_ctx *ctx, uint8_t *out)
+void cryptohash_sha512_finalize(struct sha512_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[128] = { 0x80, };
 	uint32_t i, index, padlen;
@@ -184,10 +184,10 @@
 	/* pad out to 56 */
 	index = (unsigned int) (ctx->sz[0] & 0x7f);
 	padlen = (index < 112) ? (112 - index) : ((128 + 112) - index);
-	sha512_update(ctx, padding, padlen);
+	cryptohash_sha512_update(ctx, padding, padlen);
 
 	/* append length */
-	sha512_update(ctx, (uint8_t *) bits, sizeof(bits));
+	cryptohash_sha512_update(ctx, (uint8_t *) bits, sizeof(bits));
 
 	/* store to digest */
 	for (i = 0; i < 8; i++)
@@ -196,7 +196,7 @@
 
 #include <stdio.h>
 
-void sha512_init_t(struct sha512_ctx *ctx, int t)
+void cryptohash_sha512_init_t(struct sha512_ctx *ctx, int t)
 {
 	memset(ctx, 0, sizeof(*ctx));
 	if (t >= 512)
@@ -228,13 +228,13 @@
 		uint8_t out[64];
 		int i;
 
-		sha512_init(ctx);
+		cryptohash_sha512_init(ctx);
 		for (i = 0; i < 8; i++)
 			ctx->h[i] ^= 0xa5a5a5a5a5a5a5a5ULL;
 
 		i = sprintf(buf, "SHA-512/%d", t);
-		sha512_update(ctx, buf, i);
-		sha512_finalize(ctx, out);
+		cryptohash_sha512_update(ctx, buf, i);
+		cryptohash_sha512_finalize(ctx, out);
 
 		/* re-init the context, otherwise len is changed */
 		memset(ctx, 0, sizeof(*ctx));
diff --git a/cbits/sha512.h b/cbits/sha512.h
--- a/cbits/sha512.h
+++ b/cbits/sha512.h
@@ -35,20 +35,20 @@
 
 #define sha384_ctx sha512_ctx
 
-#define SHA384_DIGEST_SIZE	64
+#define SHA384_DIGEST_SIZE	48
 #define SHA384_CTX_SIZE		sizeof(struct sha384_ctx)
 
 #define SHA512_DIGEST_SIZE	64
 #define SHA512_CTX_SIZE		sizeof(struct sha512_ctx)
 
-void sha384_init(struct sha384_ctx *ctx);
-void sha384_update(struct sha384_ctx *ctx, uint8_t *data, uint32_t len);
-void sha384_finalize(struct sha384_ctx *ctx, uint8_t *out);
+void cryptohash_sha384_init(struct sha384_ctx *ctx);
+void cryptohash_sha384_update(struct sha384_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha384_finalize(struct sha384_ctx *ctx, uint8_t *out);
 
-void sha512_init(struct sha512_ctx *ctx);
-void sha512_update(struct sha512_ctx *ctx, uint8_t *data, uint32_t len);
-void sha512_finalize(struct sha512_ctx *ctx, uint8_t *out);
+void cryptohash_sha512_init(struct sha512_ctx *ctx);
+void cryptohash_sha512_update(struct sha512_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_sha512_finalize(struct sha512_ctx *ctx, uint8_t *out);
 
-void sha512_init_t(struct sha512_ctx *ctx, int t);
+void cryptohash_sha512_init_t(struct sha512_ctx *ctx, int t);
 
 #endif
diff --git a/cbits/skein256.c b/cbits/skein256.c
--- a/cbits/skein256.c
+++ b/cbits/skein256.c
@@ -103,7 +103,7 @@
         ctx->h[3] = x[3] ^ cpu_to_le64(buf[3]);
 }
 
-void skein256_init(struct skein256_ctx *ctx, uint32_t hashlen)
+void cryptohash_skein256_init(struct skein256_ctx *ctx, uint32_t hashlen)
 {
 	uint64_t buf[4];
 	memset(ctx, 0, sizeof(*ctx));
@@ -120,7 +120,7 @@
 	SET_TYPE(ctx, FLAG_FIRST | FLAG_TYPE(TYPE_MSG));
 }
 
-void skein256_update(struct skein256_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_skein256_update(struct skein256_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t to_fill;
 
@@ -155,7 +155,7 @@
 	}
 }
 
-void skein256_finalize(struct skein256_ctx *ctx, uint8_t *out)
+void cryptohash_skein256_finalize(struct skein256_ctx *ctx, uint8_t *out)
 {
 	uint32_t outsize;
 	uint64_t *p = (uint64_t *) out;
diff --git a/cbits/skein256.h b/cbits/skein256.h
--- a/cbits/skein256.h
+++ b/cbits/skein256.h
@@ -38,8 +38,8 @@
 
 #define SKEIN256_CTX_SIZE		sizeof(struct skein256_ctx)
 
-void skein256_init(struct skein256_ctx *ctx, uint32_t hashlen);
-void skein256_update(struct skein256_ctx *ctx, uint8_t *data, uint32_t len);
-void skein256_finalize(struct skein256_ctx *ctx, uint8_t *out);
+void cryptohash_skein256_init(struct skein256_ctx *ctx, uint32_t hashlen);
+void cryptohash_skein256_update(struct skein256_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_skein256_finalize(struct skein256_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/skein512.c b/cbits/skein512.c
--- a/cbits/skein512.c
+++ b/cbits/skein512.c
@@ -121,7 +121,7 @@
         ctx->h[7] = x[7] ^ cpu_to_le64(buf[7]);
 }
 
-void skein512_init(struct skein512_ctx *ctx, uint32_t hashlen)
+void cryptohash_skein512_init(struct skein512_ctx *ctx, uint32_t hashlen)
 {
 	uint64_t buf[8];
 	memset(ctx, 0, sizeof(*ctx));
@@ -138,7 +138,7 @@
 	SET_TYPE(ctx, FLAG_FIRST | FLAG_TYPE(TYPE_MSG));
 }
 
-void skein512_update(struct skein512_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_skein512_update(struct skein512_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t to_fill;
 
@@ -173,7 +173,7 @@
 	}
 }
 
-void skein512_finalize(struct skein512_ctx *ctx, uint8_t *out)
+void cryptohash_skein512_finalize(struct skein512_ctx *ctx, uint8_t *out)
 {
 	uint32_t outsize;
 	uint64_t *p = (uint64_t *) out;
diff --git a/cbits/skein512.h b/cbits/skein512.h
--- a/cbits/skein512.h
+++ b/cbits/skein512.h
@@ -38,8 +38,8 @@
 
 #define SKEIN512_CTX_SIZE		sizeof(struct skein512_ctx)
 
-void skein512_init(struct skein512_ctx *ctx, uint32_t hashlen);
-void skein512_update(struct skein512_ctx *ctx, uint8_t *data, uint32_t len);
-void skein512_finalize(struct skein512_ctx *ctx, uint8_t *out);
+void cryptohash_skein512_init(struct skein512_ctx *ctx, uint32_t hashlen);
+void cryptohash_skein512_update(struct skein512_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_skein512_finalize(struct skein512_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/tiger.c b/cbits/tiger.c
--- a/cbits/tiger.c
+++ b/cbits/tiger.c
@@ -296,7 +296,7 @@
 	0xcd56d9430ea8280eULL,0xc12591d7535f5065ULL, 0xc83223f1720aef96ULL,0xc3a0396f7363a51fULL,
 }; 
 
-void tiger_init(struct tiger_ctx *ctx)
+void cryptohash_tiger_init(struct tiger_ctx *ctx)
 {
 	memset(ctx, 0, sizeof(*ctx));
 
@@ -363,7 +363,7 @@
 	ctx->h[2] += c;
 }
 
-void tiger_update(struct tiger_ctx *ctx, uint8_t *data, uint32_t len)
+void cryptohash_tiger_update(struct tiger_ctx *ctx, uint8_t *data, uint32_t len)
 {
 	uint32_t index, to_fill;
 
@@ -390,7 +390,7 @@
 		memcpy(ctx->buf + index, data, len);
 }
 
-void tiger_finalize(struct tiger_ctx *ctx, uint8_t *out)
+void cryptohash_tiger_finalize(struct tiger_ctx *ctx, uint8_t *out)
 {
 	static uint8_t padding[64] = { 0x01, };
 	uint64_t bits;
@@ -403,10 +403,10 @@
 	/* pad out to 56 */
 	index = (uint32_t) (ctx->sz & 0x3f);
 	padlen = (index < 56) ? (56 - index) : ((64 + 56) - index);
-	tiger_update(ctx, padding, padlen);
+	cryptohash_tiger_update(ctx, padding, padlen);
 
 	/* append length */
-	tiger_update(ctx, (uint8_t *) &bits, sizeof(bits));
+	cryptohash_tiger_update(ctx, (uint8_t *) &bits, sizeof(bits));
 
 	/* output hash */
 	p[0] = cpu_to_le64(ctx->h[0]);
diff --git a/cbits/tiger.h b/cbits/tiger.h
--- a/cbits/tiger.h
+++ b/cbits/tiger.h
@@ -36,8 +36,8 @@
 #define TIGER_DIGEST_SIZE	24
 #define TIGER_CTX_SIZE 		(sizeof(struct tiger_ctx))
 
-void tiger_init(struct tiger_ctx *ctx);
-void tiger_update(struct tiger_ctx *ctx, uint8_t *data, uint32_t len);
-void tiger_finalize(struct tiger_ctx *ctx, uint8_t *out);
+void cryptohash_tiger_init(struct tiger_ctx *ctx);
+void cryptohash_tiger_update(struct tiger_ctx *ctx, uint8_t *data, uint32_t len);
+void cryptohash_tiger_finalize(struct tiger_ctx *ctx, uint8_t *out);
 
 #endif
diff --git a/cbits/whirlpool.c b/cbits/whirlpool.c
--- a/cbits/whirlpool.c
+++ b/cbits/whirlpool.c
@@ -828,7 +828,7 @@
 /**
  * Initialize the hashing state.
  */
-void whirlpool_init(struct whirlpool_ctx * const ctx)
+void cryptohash_whirlpool_init(struct whirlpool_ctx * const ctx)
 {
 	int i;
 
@@ -848,7 +848,7 @@
  *
  * This method maintains the invariant: bufferBits < DIGESTBITS
  */
-void whirlpool_update(struct whirlpool_ctx * const ctx, const uint8_t * const source, uint32_t sourceBytes)
+void cryptohash_whirlpool_update(struct whirlpool_ctx * const ctx, const uint8_t * const source, uint32_t sourceBytes)
 {
 	/*
 	   sourcePos
@@ -966,7 +966,7 @@
  * 
  * This method uses the invariant: bufferBits < DIGESTBITS
  */
-void whirlpool_finalize(struct whirlpool_ctx * const ctx, uint8_t * const result)
+void cryptohash_whirlpool_finalize(struct whirlpool_ctx * const ctx, uint8_t * const result)
 {
 	int i;
 	uint8_t *buffer    = ctx->buffer;
diff --git a/cbits/whirlpool.h b/cbits/whirlpool.h
--- a/cbits/whirlpool.h
+++ b/cbits/whirlpool.h
@@ -24,8 +24,8 @@
 	uint64_t hash[DIGESTBYTES/8];    /* the hashing state */
 } whirlpool_ctx;
 
-void whirlpool_init(struct whirlpool_ctx * const ctx);
-void whirlpool_update(struct whirlpool_ctx * const ctx, const uint8_t * const source, uint32_t len);
-void whirlpool_finalize(struct whirlpool_ctx * const ctx, uint8_t * const result);
+void cryptohash_whirlpool_init(struct whirlpool_ctx * const ctx);
+void cryptohash_whirlpool_update(struct whirlpool_ctx * const ctx, const uint8_t * const source, uint32_t len);
+void cryptohash_whirlpool_finalize(struct whirlpool_ctx * const ctx, uint8_t * const result);
 
 #endif
diff --git a/cryptohash.cabal b/cryptohash.cabal
--- a/cryptohash.cabal
+++ b/cryptohash.cabal
@@ -1,5 +1,5 @@
 Name:                cryptohash
-Version:             0.11.6
+Version:             0.11.7
 Description:
     A collection of crypto hashes, with a practical incremental and one-pass, pure APIs,
     with performance close to the fastest implementations available in other languages.