Copyright	(c) 2014 by Peter Simons
License	BSD3
Maintainer	simons@cryp.to
Stability	provisional
Portability	portable
Safe Haskell	None
Language	Haskell98

OpenSSL.Digest

Contents

High-level API
Low-level API
- Message Digest Engines
Helper Functions

Description

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

Synopsis

High-level API

data MessageDigest Source

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] Source

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 Source

A monadic interface to the digest computation.

newtype DigestState Source

The internal EVP context.

Constructors

DST (Ptr OpaqueContext)

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

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

update :: [Word8] -> Digest () Source

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 () Source

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

final :: Digest [Word8] Source

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 Source

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

Constructors

OpaqueContext

type Context = Ptr OpaqueContext Source

data OpaqueMDEngine Source

The message digest engines are opaque for us as well.

Constructors

OpaqueMDEngine

type MDEngine = Ptr OpaqueMDEngine Source

maxMDSize :: Int Source

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 Source

Create an EVP context. May be nullPtr.

ctxInit :: Context -> IO () Source

Initialize an EVP context.

ctxDestroy :: Context -> IO () Source

Destroy an EVP context and free the allocated resources.

digestInit :: Context -> MDEngine -> IO CInt Source

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

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

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

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

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.