Control.Monad.CryptoRandom

Much like the MonadRandom package (Control.Monad.Random), this module provides plumbing for the CryptoRandomGen generators.

Documentation

class CRandom a where

CRandom a is much like the Random class from the System.Random module in the "random" package. The main difference is CRandom builds on "crypto-api"'s CryptoRandomGen, so it allows explicit failure.

crandomR (low,high) g as typically instantiated will generate a value between [low, high] inclusively, swapping the pair if high < low.

Provided instances for crandom g generates randoms between the bounds and between +/- 2^256 for Integer.

The crandomR function has degraded (theoretically unbounded, probabilistically decent) performance the closer your range size (high - low) is to 2^n (from the top).

Minimal complete definition

crandom

Methods

crandom :: CryptoRandomGen g => g -> Either GenError (a, g)

crandoms :: CryptoRandomGen g => g -> [a]

Instances

CRandom Bool

CRandom Int

CRandom Int8

CRandom Int16

CRandom Int32

CRandom Int64

CRandom Word8

CRandom Word16

CRandom Word32

CRandom Word64

class CRandomR a where

Minimal complete definition

crandomR

Methods

crandomR :: CryptoRandomGen g => (a, a) -> g -> Either GenError (a, g)

crandomRs :: CryptoRandomGen g => (a, a) -> g -> [a]

Instances

CRandomR Int

CRandomR Int8

CRandomR Int16

CRandomR Int32

CRandomR Int64

CRandomR Integer

CRandomR Word8

CRandomR Word16

CRandomR Word32

CRandomR Word64

class (ContainsGenError e, MonadError e m) => MonadCRandom e m where

MonadCRandom m represents a monad that can produce random values (or fail with a GenError). It is suggested you use the CRandT transformer in your monad stack.

Methods

getCRandom :: CRandom a => m a

getBytes :: Int -> m ByteString

getBytesWithEntropy :: Int -> ByteString -> m ByteString

doReseed :: ByteString -> m ()

Instances

MonadCRandom e m => MonadCRandom e (ReaderT r m)

(Monoid w, MonadCRandom e m) => MonadCRandom e (WriterT w m)

(Monoid w, MonadCRandom e m) => MonadCRandom e (WriterT w m)

MonadCRandom e m => MonadCRandom e (StateT s m)

MonadCRandom e m => MonadCRandom e (StateT s m)

(ContainsGenError e, Monad m, CryptoRandomGen g) => MonadCRandom e (CRandT g e m)

(Monoid w, MonadCRandom e m) => MonadCRandom e (RWST r w s m)

(Monoid w, MonadCRandom e m) => MonadCRandom e (RWST r w s m)

class (ContainsGenError e, MonadError e m) => MonadCRandomR e m where

Methods

getCRandomR :: CRandomR a => (a, a) -> m a

Instances

MonadCRandomR e m => MonadCRandomR e (ReaderT r m)

(MonadCRandomR e m, Monoid w) => MonadCRandomR e (WriterT w m)

(MonadCRandomR e m, Monoid w) => MonadCRandomR e (WriterT w m)

MonadCRandomR e m => MonadCRandomR e (StateT s m)

MonadCRandomR e m => MonadCRandomR e (StateT s m)

(ContainsGenError e, Monad m, CryptoRandomGen g) => MonadCRandomR e (CRandT g e m)

(MonadCRandomR e m, Monoid w) => MonadCRandomR e (RWST r w s m)

(MonadCRandomR e m, Monoid w) => MonadCRandomR e (RWST r w s m)

class ContainsGenError e where

Methods

toGenError :: e -> Maybe GenError

fromGenError :: GenError -> e

Instances

ContainsGenError GenError

newtype CRandT g e m a

CRandT is the transformer suggested for MonadCRandom.

Constructors

CRandT

Fields

unCRandT :: StateT g (ExceptT e m) a

Instances

Monad m => MonadError e (CRandT g e m)

MonadReader r m => MonadReader r (CRandT g e m)

MonadState s m => MonadState s (CRandT g e m)

MonadWriter w m => MonadWriter w (CRandT g e m)

(ContainsGenError e, Monad m, CryptoRandomGen g) => MonadCRandomR e (CRandT g e m)

(ContainsGenError e, Monad m, CryptoRandomGen g) => MonadCRandom e (CRandT g e m)

MonadTrans (CRandT g e)

Monad m => Monad (CRandT g e m)

Functor m => Functor (CRandT g e m)

MonadFix m => MonadFix (CRandT g e m)

Monad m => Applicative (CRandT g e m)

MonadIO m => MonadIO (CRandT g e m)

MonadCont m => MonadCont (CRandT g e m)

type CRand g e = CRandT g e Identity

Simple users of generators can use CRand for quick and easy generation of randoms. See below for a simple use of newGenIO (from "crypto-api"), getCRandom, getBytes, and runCRandom.

@getRandPair = do int <- getCRandom bytes <- getBytes 100 return (int, bytes)

func = do g <- newGenIO case runCRand getRandPair g of Right ((int,bytes), g') -> useRandomVals (int,bytes) Left x -> handleGenError x @

runCRandT :: ContainsGenError e => CRandT g e m a -> g -> m (Either e (a, g))

evalCRandT :: (ContainsGenError e, Monad m) => CRandT g e m a -> g -> m (Either e a)

runCRand :: ContainsGenError e => CRand g e a -> g -> Either e (a, g)

evalCRand :: CRand g GenError a -> g -> Either GenError a

newGenCRand :: (CryptoRandomGen g, MonadCRandom GenError m, Functor m) => m g

liftCRand :: (g -> Either e (a, g)) -> CRand g e a

liftCRandT :: Monad m => (g -> Either e (a, g)) -> CRandT g e m a

module Crypto.Random