Crypto.Random

cryptonite-0.13: Cryptography Primitives sink

License | BSD-style
Maintainer | Vincent Hanquez <vincent@snarc.org>
Stability | stable
Portability | good
Safe Haskell | None
Language | Haskell2010

Crypto.Random

Contents

- Deterministic instances
- Deterministic Random class
- Random abstraction

Description

Synopsis

- data ChaChaDRG
- data SystemDRG
- getSystemDRG :: IO SystemDRG
- drgNew :: MonadRandom randomly => randomly ChaChaDRG
- drgNewTest :: (Word64, Word64, Word64, Word64, Word64) -> ChaChaDRG
- withDRG :: DRG gen => gen -> MonadPseudoRandom gen a -> (a, gen)
- withRandomBytes :: (ByteArray ba, DRG g) => g -> Int -> (ba -> a) -> (a, g)
- class DRG gen where
  - randomBytesGenerate :: ByteArray byteArray => Int -> gen -> (byteArray, gen)
- class (Functor m, Monad m) => MonadRandom m where
  - getRandomBytes :: ByteArray byteArray => Int -> m byteArray
- data MonadPseudoRandom gen a

# Deterministic instances

data ChaChaDRG

ChaCha Deterministic Random Generator

Instances

NFData ChaChaDRG |
DRG ChaChaDRG |

data SystemDRG

A referentially transparent System representation of the random evaluated out of the system.

Holding onto a specific DRG means that all the already evaluated bytes will be consistently replayed.

There's no need to reseed this DRG, as only pure entropy is represented here.

Instances

DRG SystemDRG |

# Deterministic Random class

getSystemDRG :: IO SystemDRG

Grab one instance of the System DRG

drgNew :: MonadRandom randomly => randomly ChaChaDRG

Create a new DRG from system entropy

drgNewTest :: (Word64, Word64, Word64, Word64, Word64) -> ChaChaDRG

Create a new DRG from 5 Word64.

This is a convenient interface to create deterministic interface for quickcheck style testing.

It can also be used in other contexts provided the input has been properly randomly generated.

withDRG :: DRG gen => gen -> MonadPseudoRandom gen a -> (a, gen)

Run a pure computation with a Deterministic Random Generator in the `MonadPseudoRandom`

withRandomBytes :: (ByteArray ba, DRG g) => g -> Int -> (ba -> a) -> (a, g)

Generate `len random bytes and mapped the bytes to the function` f.

This is equivalent to use Control.Arrow `first` with `randomBytesGenerate`

class DRG gen where

A Deterministic Random Generator (DRG) class

Methods

randomBytesGenerate :: ByteArray byteArray => Int -> gen -> (byteArray, gen)

Generate N bytes of randomness from a DRG

Instances

DRG ChaChaDRG |
DRG SystemDRG |

# Random abstraction

class (Functor m, Monad m) => MonadRandom m where

A monad constraint that allows to generate random bytes

Methods

getRandomBytes :: ByteArray byteArray => Int -> m byteArray

Instances

MonadRandom IO |
DRG gen => MonadRandom (MonadPseudoRandom gen) |

data MonadPseudoRandom gen a

A simple Monad class very similar to a State Monad with the state being a DRG.

Instances

DRG gen => Monad (MonadPseudoRandom gen) |
DRG gen => Functor (MonadPseudoRandom gen) |
DRG gen => Applicative (MonadPseudoRandom gen) |
DRG gen => MonadRandom (MonadPseudoRandom gen) |