Crypto.Hash.MD5

cryptohash-md5-0.11.101.0: Fast, pure and practical MD5 implementation

License | BSD-style
Maintainer | Herbert Valerio Riedel <hvr@gnu.org>
Stability | stable
Portability | unknown
Safe Haskell | Trustworthy
Language | Haskell2010

Crypto.Hash.MD5

Contents

- Incremental API
- Single Pass API
  - HMAC-MD5

Description

A module containing MD5 bindings

Synopsis

- newtype Ctx = Ctx ByteString
- init :: Ctx
- update :: Ctx -> ByteString -> Ctx
- updates :: Ctx -> [ByteString] -> Ctx
- finalize :: Ctx -> ByteString
- finalizeAndLength :: Ctx -> (ByteString, Word64)
- start :: ByteString -> Ctx
- startlazy :: ByteString -> Ctx
- hash :: ByteString -> ByteString
- hashlazy :: ByteString -> ByteString
- hashlazyAndLength :: ByteString -> (ByteString, Word64)
- hmac :: ByteString -> ByteString -> ByteString
- hmaclazy :: ByteString -> ByteString -> ByteString
- hmaclazyAndLength :: ByteString -> ByteString -> (ByteString, Word64)

# Incremental API

This API is based on 4 different functions, similar to the lowlevel operations of a typical hash:

- `init`: create a new hash context
- `update`: update non-destructively a new hash context with a strict bytestring
- `updates`: same as update, except that it takes a list of strict bytestrings
- `finalize`: finalize the context and returns a digest bytestring.

all those operations are completely pure, and instead of changing the context as usual in others language, it re-allocates a new context each time.

Example:

    import qualified Data.ByteString
    import qualified Crypto.Hash.MD5 as MD5

    main = print digest
      where
        digest = MD5.finalize ctx
        ctx    = foldl MD5.update ctx0 (map Data.ByteString.pack [ [1,2,3], [4,5,6] ])
        ctx0   = MD5.init

newtype Ctx #

MD5 Context

The context data is exactly 88 bytes long, however the data in the context is stored in host-endianness.

The context data is made up of

- a `Word64` representing the number of bytes already feed to hash algorithm so far,
- a 64-element `Word8` buffer holding partial input-chunks, and finally
- a 4-element `Word32` array holding the current work-in-progress digest-value.

Consequently, a MD5 digest as produced by `hash`, `hashlazy`, or `finalize` is 16 bytes long.

Constructors

Ctx ByteString |

#### Instances

Instances details

Eq Ctx # |
Instance details Defined in Crypto.Hash.MD5.FFI Methods (==) :: Ctx -> Ctx -> Bool # (/=) :: Ctx -> Ctx -> Bool #

init :: Ctx #

create a new hash context

update :: Ctx -> ByteString -> Ctx #

update a context with a bytestring

updates :: Ctx -> [ByteString] -> Ctx #

updates a context with multiple bytestrings

finalize :: Ctx -> ByteString #

finalize the context into a digest bytestring (16 bytes)

finalizeAndLength :: Ctx -> (ByteString, Word64) #

Variant of `finalize` also returning length of hashed content

Since: 0.11.101.0

start :: ByteString -> Ctx #

hash a strict bytestring into a `Ctx`

Since: 0.11.101.0

startlazy :: ByteString -> Ctx #

hash a lazy bytestring into a `Ctx`

Since: 0.11.101.0

# Single Pass API

This API use the incremental API under the hood to provide the common all-in-one operations to create digests out of a `ByteString` and lazy `ByteString`.

- `hash`: create a digest (`init` + `update` + `finalize`) from a strict `ByteString`
- `hashlazy`: create a digest (`init` + `update` + `finalize`) from a lazy `ByteString`
- `hashlazyAndLength`: create a digest (`init` + `update` + `finalizeAndLength`) from a lazy `ByteString`

Example:

    import qualified Data.ByteString
    import qualified Crypto.Hash.MD5 as MD5

    main = print $ MD5.hash (Data.ByteString.pack [0..255])

NOTE: The returned digest is a binary `ByteString`. For converting to a base16/hex encoded digest the base16-bytestring package is recommended.

hash :: ByteString -> ByteString #

hash a strict bytestring into a digest bytestring (16 bytes)

hashlazy :: ByteString -> ByteString #

hash a lazy bytestring into a digest bytestring (16 bytes)

hashlazyAndLength :: ByteString -> (ByteString, Word64) #

Variant of `hashlazy` which simultaneously computes the hash and length of a lazy bytestring.

Since: 0.11.101.0

## HMAC-MD5

RFC2104-compatible HMAC-MD5 digests

hmac #

Arguments

:: ByteString | secret
-> ByteString | message
-> ByteString |

Compute 16-byte RFC2104-compatible HMAC-Md5 digest for a strict bytestring message

Since: 0.11.100.0

hmaclazy #

Arguments

:: ByteString | secret
-> ByteString | message
-> ByteString |

Compute 16-byte RFC2104-compatible HMAC-MD5 digest for a lazy bytestring message

Since: 0.11.100.0

hmaclazyAndLength #

Arguments

:: ByteString | secret
-> ByteString | message
-> (ByteString, Word64) | digest (32 bytes) and length of message

Variant of `hmaclazy` which also returns length of message

Since: 0.11.101.0