OpenSSL.Digest

This module proivdes a high-level API to the message digest algorithms found in OpenSSL's crypto library. Link with -lcrypto when using this module.

Here is a short example program which runs all available digests on a string:

example :: (Enum a) => [a] -> IO [String]
example input = mapM hash [minBound .. maxBound]
  where
  hash f = fmap (fmt f) (digest f (toWord input))
  fmt f  = shows f . (":    \t"++) . (>>=toHex)
  toWord = map (toEnum . fromEnum)

And when called, the function prints:

*Digest> example "open sesame" >>= putStr . unlines
Null:
MD5:       54ef36ec71201fdf9d1423fd26f97f6b
SHA:       2ccefef64c76ac0d42ca1657457977675890c42f
SHA1:      5bcaff7f22ff533ca099b3408ead876c0ebba9a7
DSS:       5bcaff7f22ff533ca099b3408ead876c0ebba9a7
DSS1:      5bcaff7f22ff533ca099b3408ead876c0ebba9a7
RIPEMD160: bdb2bba6ec93bd566dc1181cadbc92176aa78382
MDC2:      112db2200ce1e9db3c2d132aea4ef7d0
SHA224:    1ee0f9d93a873a67fe781852d716cb3e5904e015aafaa4d1ff1a81bc
SHA256:    41ef4bb0b23661e66301aac36066912dac037827b4ae63a7b1165a5aa93ed4eb
SHA384:    ae2a5d6649035c00efe2bc1b5c97f4d5ff97fa2df06f273afa0231c425e8aff30e4cc1db5e5756e8d2245a1514ad1a2d
SHA512:    8470cdd3bf1ef85d5f092bce5ae5af97ce50820481bf43b2413807fec37e2785b533a65d4c7d71695b141d81ebcd4b6c4def4284e6067f0b400000001b230205

High-level API

data MessageDigest

The message digest algorithms we support.

Constructors

Null

0 bit

MD5

128 bit

SHA

160 bit

SHA1

160 bit

DSS

other name for SHA1

DSS1

other name for SHA1

RIPEMD160

160 bit

MDC2

128 bit

SHA224

224 bit

SHA256

256 bit

SHA384

384 bit

SHA512

512 bit

Instances

Bounded MessageDigest

Enum MessageDigest

Eq MessageDigest

Show MessageDigest

digest :: MessageDigest -> [Word8] -> IO [Word8]

A convenience wrapper which computes the given digest over a list of Word8. Unlike the monadic interface, this function does not allow the computation to be restarted.

type Digest a = StateT DigestState IO a

A monadic interface to the digest computation.

newtype DigestState

The internal EVP context.

Constructors

DST (Ptr OpaqueContext)

mkDigest :: MessageDigest -> (DigestState -> IO a) -> IO a

Run an IO computation with an initialized DigestState. All resources will be freed when the computation returns.

update :: [Word8] -> Digest ()

Update the internal state with a block of data. This function is just a wrapper for update', which creates an array in memory using withArray.

update' :: (Ptr Word8, Int) -> Digest ()

Update the internal state with a block of data from memory. This is the faster version of update.

final :: Digest [Word8]

Wrap up the computation, add padding, do whatever has to be done, and return the final hash. The length of the result depends on the chosen MessageDigest. Do not call more than once!

Low-level API

data OpaqueContext

The EVP context used by OpenSSL is opaque for us; we only access it through a Ptr.

Constructors

OpaqueContext

type Context = Ptr OpaqueContext

data OpaqueMDEngine

The message digest engines are opaque for us as well.

Constructors

OpaqueMDEngine

type MDEngine = Ptr OpaqueMDEngine

maxMDSize :: Int

Maximum size of all message digests supported by OpenSSL. Allocate a buffer of this size for digestFinal if you want to stay generic.

ctxCreate :: IO Context

Create an EVP context. May be nullPtr.

ctxInit :: Context -> IO ()

Initialize an EVP context.

ctxDestroy :: Context -> IO ()

Destroy an EVP context and free the allocated resources.

digestInit :: Context -> MDEngine -> IO CInt

Set the message digest engine for digestUpdate calls. Returns /=0 in case of an error.

digestUpdate :: Context -> Ptr Word8 -> CUInt -> IO CInt

Update the internal context with a block of input. Returns /=0 in case of an error.

digestFinal :: Context -> Ptr Word8 -> Ptr CUInt -> IO CInt

Wrap up the digest computation and return the final digest. Do not call repeatedly on the same context! Returns /=0 in case of an error. The pointer to the unsigned integer may be nullPtr. If it is not, digestFinal will store the length of the computed digest there.

Message Digest Engines

mdDSS :: IO MDEngine

mdDSS1 :: IO MDEngine

mdMD5 :: IO MDEngine

mdNull :: IO MDEngine

mdMDC2 :: IO MDEngine

mdRIPEMD160 :: IO MDEngine

mdSHA :: IO MDEngine

mdSHA1 :: IO MDEngine

mdSHA224 :: IO MDEngine

mdSHA256 :: IO MDEngine

mdSHA384 :: IO MDEngine

mdSHA512 :: IO MDEngine

toMDEngine :: MessageDigest -> IO MDEngine

Map a MessageDigest type into the the corresponding MDEngine.

Helper Functions

toHex :: Word8 -> String

Neat helper to print digests with: \ws :: [Word8] -> ws >>= toHex