{-# OPTIONS_HADDOCK prune #-}
{-# LANGUAGE BangPatterns #-}
module Crypto.CSPRNG (
Gen
, new
, new_system
, word64
, word64_range
, int_range
, bytes
, split
, wipe
) where
import Control.Monad.Primitive (PrimMonad, PrimState, unsafeIOToPrim)
import Control.Monad.ST (ST)
import qualified Crypto.Cipher.ChaCha as ChaCha
import qualified Crypto.Entropy as Entropy
import qualified Crypto.Range as Range
import Data.Bits ((.&.), complement)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Unsafe as BU
import qualified Data.Primitive.ByteArray as BA
import Data.Word (Word8, Word64, byteSwap64)
import Foreign.ForeignPtr (touchForeignPtr)
import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
import Foreign.Marshal.Utils (copyBytes)
import Foreign.Ptr (Ptr, castPtr, plusPtr)
import GHC.ByteOrder (ByteOrder(..), targetByteOrder)
import GHC.Exts (RealWorld)
fi :: (Integral a, Num b) => a -> b
fi :: forall a b. (Integral a, Num b) => a -> b
fi = a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE fi #-}
le64 :: Word64 -> Word64
le64 :: Word64 -> Word64
le64 Word64
w = case ByteOrder
targetByteOrder of
ByteOrder
LittleEndian -> Word64
w
ByteOrder
BigEndian -> Word64 -> Word64
byteSwap64 Word64
w
{-# INLINE le64 #-}
newtype Gen s = Gen (BA.MutableByteArray s)
_KEY, _NONCE, _POS, _OUT, _SIZE, _AVAIL :: Int
_KEY :: Int
_KEY = Int
0
_NONCE :: Int
_NONCE = Int
32
_POS :: Int
_POS = Int
48
_OUT :: Int
_OUT = Int
64
_SIZE :: Int
_SIZE = Int
1088
_AVAIL :: Int
_AVAIL = Int
992
alloc :: PrimMonad m => m (BA.MutableByteArray (PrimState m))
alloc :: forall (m :: * -> *).
PrimMonad m =>
m (MutableByteArray (PrimState m))
alloc = do
st <- Int -> m (MutableByteArray (PrimState m))
forall (m :: * -> *).
PrimMonad m =>
Int -> m (MutableByteArray (PrimState m))
BA.newPinnedByteArray Int
_SIZE
BA.setByteArray st 0 _SIZE (0 :: Word8)
pure st
{-# INLINE alloc #-}
read_pos :: PrimMonad m => BA.MutableByteArray (PrimState m) -> m Int
read_pos :: forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m Int
read_pos MutableByteArray (PrimState m)
st = do
!p <- MutableByteArray (PrimState m) -> Int -> m Word64
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> m a
BA.readByteArray MutableByteArray (PrimState m)
st (Int
_POS Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
8)
pure $! fi (p :: Word64)
{-# INLINE read_pos #-}
write_pos :: PrimMonad m => BA.MutableByteArray (PrimState m) -> Int -> m ()
write_pos :: forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Int -> m ()
write_pos MutableByteArray (PrimState m)
st Int
p = MutableByteArray (PrimState m) -> Int -> Word64 -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
BA.writeByteArray MutableByteArray (PrimState m)
st (Int
_POS Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
8) (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fi Int
p :: Word64)
{-# INLINE write_pos #-}
ptr :: BA.MutableByteArray s -> Int -> Ptr Word8
ptr :: forall s. MutableByteArray s -> Int -> Ptr Word8
ptr MutableByteArray s
st Int
off = MutableByteArray s -> Ptr Word8
forall s. MutableByteArray s -> Ptr Word8
BA.mutableByteArrayContents MutableByteArray s
st Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
off
{-# INLINE ptr #-}
refill :: PrimMonad m => BA.MutableByteArray (PrimState m) -> m ()
refill :: forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m ()
refill MutableByteArray (PrimState m)
st = do
IO () -> m ()
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
Rounds
-> FeedForward
-> Ptr Word8
-> Word32
-> Ptr Word8
-> Ptr Word8
-> Int
-> IO ()
ChaCha._interleaved_into Rounds
ChaCha.ChaCha8 FeedForward
ChaCha.FeedForwardKey
(MutableByteArray (PrimState m) -> Int -> Ptr Word8
forall s. MutableByteArray s -> Int -> Ptr Word8
ptr MutableByteArray (PrimState m)
st Int
_KEY) Word32
0 (MutableByteArray (PrimState m) -> Int -> Ptr Word8
forall s. MutableByteArray s -> Int -> Ptr Word8
ptr MutableByteArray (PrimState m)
st Int
_NONCE) (MutableByteArray (PrimState m) -> Int -> Ptr Word8
forall s. MutableByteArray s -> Int -> Ptr Word8
ptr MutableByteArray (PrimState m)
st Int
_OUT) Int
4
MutableByteArray (PrimState m)
-> Int -> MutableByteArray (PrimState m) -> Int -> Int -> m ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> MutableByteArray (PrimState m) -> Int -> Int -> m ()
BA.copyMutableByteArray MutableByteArray (PrimState m)
st Int
_KEY MutableByteArray (PrimState m)
st (Int
_OUT Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
_AVAIL) Int
32
MutableByteArray (PrimState m) -> Int -> Int -> Word8 -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> Int -> a -> m ()
BA.setByteArray MutableByteArray (PrimState m)
st (Int
_OUT Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
_AVAIL) Int
32 (Word8
0 :: Word8)
MutableByteArray (PrimState m) -> Int -> m ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Int -> m ()
write_pos MutableByteArray (PrimState m)
st Int
0
{-# INLINABLE refill #-}
{-# SPECIALIZE refill :: BA.MutableByteArray RealWorld -> IO () #-}
{-# SPECIALIZE refill :: BA.MutableByteArray s -> ST s () #-}
fill
:: PrimMonad m
=> BA.MutableByteArray (PrimState m)
-> Ptr Word8
-> Int
-> m ()
fill :: forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Ptr Word8 -> Int -> m ()
fill MutableByteArray (PrimState m)
st Ptr Word8
dst Int
n = Int -> m ()
forall {f :: * -> *}.
(PrimState f ~ PrimState m, PrimMonad f) =>
Int -> f ()
loop Int
0 where
loop :: Int -> f ()
loop !Int
off
| Int
off Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = () -> f ()
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise = do
!pos <- MutableByteArray (PrimState f) -> f Int
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m Int
read_pos MutableByteArray (PrimState m)
MutableByteArray (PrimState f)
st
if pos == _AVAIL
then do
refill st
loop off
else do
let !k = Int -> Int -> Int
forall a. Ord a => a -> a -> a
min (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
off) (Int
_AVAIL Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
pos)
!d = Ptr Word8
dst Ptr Word8 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
off :: Ptr Word8
BA.copyMutableByteArrayToPtr d st (_OUT + pos) k
BA.setByteArray st (_OUT + pos) k (0 :: Word8)
write_pos st (pos + k)
loop (off + k)
{-# INLINABLE fill #-}
new
:: PrimMonad m
=> BS.ByteString
-> m (Maybe (Gen (PrimState m)))
new :: forall (m :: * -> *).
PrimMonad m =>
ByteString -> m (Maybe (Gen (PrimState m)))
new seed :: ByteString
seed@(BI.PS ForeignPtr Word8
_ Int
_ Int
l)
| Int
l Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
32 = Maybe (Gen (PrimState m)) -> m (Maybe (Gen (PrimState m)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Gen (PrimState m))
forall a. Maybe a
Nothing
| Bool
otherwise = do
st <- m (MutableByteArray (PrimState m))
forall (m :: * -> *).
PrimMonad m =>
m (MutableByteArray (PrimState m))
alloc
unsafeIOToPrim $ BU.unsafeUseAsCString seed $ \CString
sp ->
Ptr Word8 -> Ptr Word8 -> Int -> IO ()
forall a. Ptr a -> Ptr a -> Int -> IO ()
copyBytes (MutableByteArray (PrimState m) -> Int -> Ptr Word8
forall s. MutableByteArray s -> Int -> Ptr Word8
ptr MutableByteArray (PrimState m)
st Int
_KEY) (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
sp) Int
32
refill st
pure $! Just (Gen st)
{-# INLINABLE new #-}
{-# SPECIALIZE new :: BS.ByteString -> IO (Maybe (Gen RealWorld)) #-}
{-# SPECIALIZE new :: BS.ByteString -> ST s (Maybe (Gen s)) #-}
new_system :: IO (Maybe (Gen RealWorld))
new_system :: IO (Maybe (Gen RealWorld))
new_system = do
st <- IO (MutableByteArray RealWorld)
IO (MutableByteArray (PrimState IO))
forall (m :: * -> *).
PrimMonad m =>
m (MutableByteArray (PrimState m))
alloc
ok <- Entropy.fill (ptr st _KEY) 32
if not ok
then pure Nothing
else do
refill st
pure $! Just (Gen st)
word64 :: PrimMonad m => Gen (PrimState m) -> m Word64
word64 :: forall (m :: * -> *). PrimMonad m => Gen (PrimState m) -> m Word64
word64 (Gen MutableByteArray (PrimState m)
st) = do
!pos <- MutableByteArray (PrimState m) -> m Int
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m Int
read_pos MutableByteArray (PrimState m)
st
let !aligned = (Int
pos Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7) Int -> Int -> Int
forall a. Bits a => a -> a -> a
.&. Int -> Int
forall a. Bits a => a -> a
complement Int
7
!p <- if aligned + 8 > _AVAIL
then do
refill st
pure 0
else pure aligned
let !ix = (Int
_OUT Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
p) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
8
!w <- BA.readByteArray st ix
BA.writeByteArray st ix (0 :: Word64)
write_pos st (p + 8)
pure $! le64 w
{-# INLINE word64 #-}
word64_range
:: PrimMonad m => Word64 -> Word64 -> Gen (PrimState m) -> m Word64
word64_range :: forall (m :: * -> *).
PrimMonad m =>
Word64 -> Word64 -> Gen (PrimState m) -> m Word64
word64_range Word64
a Word64
b Gen (PrimState m)
gen = do
let !lo :: Word64
lo = Word64 -> Word64 -> Word64
forall a. Ord a => a -> a -> a
min Word64
a Word64
b
!hi :: Word64
hi = Word64 -> Word64 -> Word64
forall a. Ord a => a -> a -> a
max Word64
a Word64
b
!r <- m Word64 -> Word64 -> m Word64
forall (m :: * -> *). Monad m => m Word64 -> Word64 -> m Word64
Range.upto (Gen (PrimState m) -> m Word64
forall (m :: * -> *). PrimMonad m => Gen (PrimState m) -> m Word64
word64 Gen (PrimState m)
gen) (Word64
hi Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
lo)
pure $! lo + r
{-# INLINE word64_range #-}
int_range :: PrimMonad m => Int -> Int -> Gen (PrimState m) -> m Int
int_range :: forall (m :: * -> *).
PrimMonad m =>
Int -> Int -> Gen (PrimState m) -> m Int
int_range Int
a Int
b Gen (PrimState m)
gen = do
let !lo :: Int
lo = Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
a Int
b
!hi :: Int
hi = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
a Int
b
!r <- m Word64 -> Word64 -> m Word64
forall (m :: * -> *). Monad m => m Word64 -> Word64 -> m Word64
Range.upto (Gen (PrimState m) -> m Word64
forall (m :: * -> *). PrimMonad m => Gen (PrimState m) -> m Word64
word64 Gen (PrimState m)
gen) (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fi Int
hi Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fi Int
lo)
pure $! lo + fi r
{-# INLINE int_range #-}
bytes :: PrimMonad m => Int -> Gen (PrimState m) -> m BS.ByteString
bytes :: forall (m :: * -> *).
PrimMonad m =>
Int -> Gen (PrimState m) -> m ByteString
bytes Int
n (Gen MutableByteArray (PrimState m)
st)
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = ByteString -> m ByteString
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
BS.empty
| Bool
otherwise = do
fp <- IO (ForeignPtr Word8) -> m (ForeignPtr Word8)
forall (m :: * -> *) a. PrimMonad m => IO a -> m a
unsafeIOToPrim (Int -> IO (ForeignPtr Word8)
forall a. Int -> IO (ForeignPtr a)
BI.mallocByteString Int
n)
fill st (unsafeForeignPtrToPtr fp) n
unsafeIOToPrim (touchForeignPtr fp)
pure $! BI.BS fp n
{-# INLINABLE bytes #-}
{-# SPECIALIZE bytes :: Int -> Gen RealWorld -> IO BS.ByteString #-}
{-# SPECIALIZE bytes :: Int -> Gen s -> ST s BS.ByteString #-}
split :: PrimMonad m => Gen (PrimState m) -> m (Gen (PrimState m))
split :: forall (m :: * -> *).
PrimMonad m =>
Gen (PrimState m) -> m (Gen (PrimState m))
split (Gen MutableByteArray (PrimState m)
st) = do
child <- m (MutableByteArray (PrimState m))
forall (m :: * -> *).
PrimMonad m =>
m (MutableByteArray (PrimState m))
alloc
fill st (ptr child _KEY) 32
refill child
pure $! Gen child
{-# INLINABLE split #-}
wipe :: PrimMonad m => Gen (PrimState m) -> m ()
wipe :: forall (m :: * -> *). PrimMonad m => Gen (PrimState m) -> m ()
wipe (Gen MutableByteArray (PrimState m)
st) = do
MutableByteArray (PrimState m) -> Int -> Int -> Word8 -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> Int -> a -> m ()
BA.setByteArray MutableByteArray (PrimState m)
st Int
0 Int
_SIZE (Word8
0 :: Word8)
MutableByteArray (PrimState m) -> Int -> m ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Int -> m ()
write_pos MutableByteArray (PrimState m)
st Int
_AVAIL
{-# INLINE wipe #-}