nettle-0.1.0: safe nettle binding

Portability | portable
Stability | experimental
Maintainer | stbuehler@web.de
Safe Haskell | None

Crypto.Nettle.Hash

Contents

- HashAlgorithm class
- hash algorithms
  - GOSTHASH94
  - MD family
  - RIPEMD160
  - SHA1
  - SHA2 family
  - SHA3 family

Description

This module exports hash algorithms supported by nettle: http://www.lysator.liu.se/~nisse/nettle/

Synopsis

- class HashAlgorithm a where
  - hashBlockSize :: Tagged a Int
  - hashDigestSize :: Tagged a Int
  - hashName :: Tagged a String
  - hashInit :: a
  - hashUpdate :: a -> ByteString -> a
  - hashUpdateLazy :: a -> ByteString -> a
  - hashFinalize :: a -> ByteString
  - hashHMAC :: ByteString -> Tagged a KeyedHash
- hash :: HashAlgorithm a => ByteString -> Tagged a ByteString
- hash' :: HashAlgorithm a => a -> ByteString -> ByteString
- hashLazy :: HashAlgorithm a => ByteString -> Tagged a ByteString
- hashLazy' :: HashAlgorithm a => a -> ByteString -> ByteString
- data GOSTHASH94
- data MD2
- data MD4
- data MD5
- data RIPEMD160
- data SHA1
- data SHA224
- data SHA256
- data SHA384
- data SHA512
- data SHA3_224
- data SHA3_256
- data SHA3_384
- data SHA3_512

# HashAlgorithm class

class HashAlgorithm a where Source

`HashAlgorithm` is a class that hash algorithms will implement. generating a digest is a 3 step procedure:

- `hashInit` to create a new context
- `hashUpdate` to hash data
- `hashFinalize` to extract the final digest

The final digest has `hashDigestSize` bytes, and the algorithm uses `hashBlockSize` as internal block size.

Methods

hashBlockSize :: Tagged a Int Source

Block size in bytes the hash algorithm operates on

hashDigestSize :: Tagged a Int Source

Digest size in bytes the hash algorithm returns

hashName :: Tagged a String Source

Name of the hash algorithm

hashInit :: aSource

Initialize a new context for this hash algorithm

hashUpdate :: a -> ByteString -> aSource

Update the context with bytestring, and return a new context with the updates.

hashUpdateLazy :: a -> ByteString -> aSource

Update the context with a lazy bytestring, and return a new context with the updates.

hashFinalize :: a -> ByteString Source

Finalize a context and return a digest.

hashHMAC :: ByteString -> Tagged a KeyedHash Source

Use `HashAlgorithm` for HMAC; can use a optimized variant or the default `hmacInit` one

Instances

HashAlgorithm SHA3_512 |
HashAlgorithm SHA3_384 |
HashAlgorithm SHA3_256 |
HashAlgorithm SHA3_224 |
HashAlgorithm SHA512 |
HashAlgorithm SHA384 |
HashAlgorithm SHA256 |
HashAlgorithm SHA224 |
HashAlgorithm SHA1 |
HashAlgorithm RIPEMD160 |
HashAlgorithm MD5 |
HashAlgorithm MD4 |
HashAlgorithm MD2 |
HashAlgorithm GOSTHASH94 |

hash :: HashAlgorithm a => ByteString -> Tagged a ByteString Source

Helper to hash a single (strict) `ByteString` in one step.

Example:

     untag (hash (fromString "abc") :: Tagged SHA256 B.ByteString)

hash' :: HashAlgorithm a => a -> ByteString -> ByteString Source

Untagged variant of `hash`; takes a (possible `undefined`) typed `HashAlgorithm` context as parameter.

Example:

     hash' (undefined :: SHA256) $ fromString "abc"

hashLazy :: HashAlgorithm a => ByteString -> Tagged a ByteString Source

Helper to hash a single (lazy) `ByteString` in one step.

Example:

     untag (hashLazy (fromString "abc") :: Tagged SHA256 L.ByteString)

hashLazy' :: HashAlgorithm a => a -> ByteString -> ByteString Source

Untagged variant of `hashLazy`; takes a (possible `undefined`) typed `HashAlgorithm` context as parameter.

Example:

     hashLazy' (undefined :: SHA256) $ fromString "abc"

# hash algorithms

Only members of the SHA2 and SHA3 family have no known weaknesses (according to http://www.lysator.liu.se/~nisse/nettle/nettle.html#Hash-functions)

## GOSTHASH94

data GOSTHASH94 Source

The GOST94 or GOST R 34.11-94 hash algorithm is a Soviet-era algorithm used in Russian government standards (see RFC 4357). It outputs message digests of 32 bytes (256 bits).

Instances

HashAlgorithm GOSTHASH94 |

## MD family

data MD2 Source

`MD2` is a hash function of Ronald Rivest's, described in RFC 1319. It outputs message digests of 16 bytes (128 bits).

Instances

HashAlgorithm MD2 |

data MD4 Source

`MD4` is a hash function of Ronald Rivest's, described in RFC 1320. It outputs message digests of 16 bytes (128 bits).

Instances

HashAlgorithm MD4 |

data MD5 Source

`MD5` is a hash function of Ronald Rivest's, described in RFC 1321. It outputs message digests of 16 bytes (128 bits).

Instances

HashAlgorithm MD5 |

## RIPEMD160

data RIPEMD160 Source

`RIPEMD160` is a hash function designed by Hans Dobbertin, Antoon Bosselaers, and Bart Preneel, as a strengthened version of RIPEMD. It produces message digests of 20 bytes (160 bits).

Instances

HashAlgorithm RIPEMD160 |

## SHA1

data SHA1 Source

`SHA1` is a hash function specified by NIST (The U.S. National Institute for Standards and Technology). It produces message digests of 20 bytes (160 bits).

Instances

HashAlgorithm SHA1 |

## SHA2 family

The SHA2 family supports digests lengths of 28, 32, 48 or 64 bytes (224, 256, 384, 512 bits), and the variants are named after the bit length.

The SHA2 family of hash functions were specified by NIST, intended as a replacement for `SHA1`.

data SHA224 Source

`SHA224` is a member of the SHA2 family which outputs messages digests of 28 bytes (224 bits).

Instances

HashAlgorithm SHA224 |

data SHA256 Source

`SHA256` is a member of the SHA2 family which outputs messages digests of 32 bytes (256 bits).

Instances

HashAlgorithm SHA256 |

data SHA384 Source

`SHA384` is a member of the SHA2 family which outputs messages digests of 48 bytes (384 bits).

Instances

HashAlgorithm SHA384 |

data SHA512 Source

`SHA512` is a member of the SHA2 family which outputs messages digests of 64 bytes (512 bits).

Instances

HashAlgorithm SHA512 |

## SHA3 family

The SHA3 family supports (like SHA2) digests lengths of 28, 32, 48 or 64 bytes (224, 256, 384, 512 bits), and the variants are named after the bit length.

The SHA3 hash functions were specified by NIST in response to weaknesses in SHA1, and doubts about SHA2 hash functions which structurally are very similar to SHA1. The standard is a result of a competition, where the winner, also known as Keccak, was designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche. It is structurally very different from all widely used earlier hash functions.

data SHA3_224 Source

`SHA3_224` is a member of the SHA3 family which outputs messages digests of 28 bytes (224 bits).

Instances

HashAlgorithm SHA3_224 |

data SHA3_256 Source

`SHA3_256` is a member of the SHA3 family which outputs messages digests of 32 bytes (256 bits).

Instances

HashAlgorithm SHA3_256 |

data SHA3_384 Source

`SHA3_384` is a member of the SHA3 family which outputs messages digests of 48 bytes (384 bits).

Instances

HashAlgorithm SHA3_384 |

data SHA3_512 Source

`SHA3_512` is a member of the SHA3 family which outputs messages digests of 64 bytes (512 bits).

Instances

HashAlgorithm SHA3_512 |