Interface for cryptographically secure random byte generators.

The raaz library gives a relatively high level interface to randomness. The monad RandM captures a batch of actions that generate/use cryptographically secure random bytes. In particular, you can use the functions random and randomByteString to actually generate random elements.

The monad RandM is an an instance of MonadMemory and hence can be run either securely or insecurely. Here are some examples.

-- Generate a pair of random Word8's
import Raaz
import Data.Word

main :: IO ()
main = insecurely rPair >>= print
   where rPair :: RandM (Word8, Word8)
         rPair = (,) <$> random <$> random

-- A version of hello world that has gone nuts. Printed in base16
-- to save some terminal grief.

main = insecurely who >>= \ w -> putStrLn $ "hello " ++ showBase16 w
  where who :: RandM ByteString
        who = randomByteString 10

Some times you need additional memory to keep track of other stuff. The monad RT mem is meant for such uses. It should be seen as the analogue of the monad MT mem which in addition allows you to pick cryptographically secure random data. In fact, the combinator liftMT allows you to lift an MT action to the corresponding RT action.

Internal details

Generating unpredictable stream of bytes is one task that has burnt the fingers of a lot of programmers. Unfortunately, getting it correct is something of a black art. Raaz uses a stream cipher (chacha20), initialised with a starting random key/iv. The starting seed is then drawn from the system entropy pool.

TODO: For system entropy we use /dev/urandom on a posix systems (no windows support yet). Even on posix systems, depending on underlying operating system, there are better options. The recommended way to generate randomness on an OpenBSD system is through the function arc4random (note that arc4random does not use rc4 cipher anymore). Recent Linux kernels support the getrandom system call which unfortunately is not yet popular. These system specific calls are better because they take into consideration many edge cases like for example /dev/urandom not being accessible or protection from interrupts Eventually we will be supporting these calls.