{-# OPTIONS_HADDOCK hide #-}
{-# LANGUAGE BangPatterns #-}

-- |
-- Module: Crypto.Xoshiro
-- Copyright: (c) 2026 Jared Tobin
-- License: MIT
-- Maintainer: Jared Tobin <jared@ppad.tech>
--
-- The xoshiro256++ state, step function, scrambler, jumps, and
-- seeding, shared by the mutable and pure generators.

module Crypto.Xoshiro (
    S(..)
  , output
  , next
  , jump
  , long_jump
  , seed
  , from_words
  , system
  ) where

import qualified Crypto.Entropy as Entropy
import Data.Bits ((.|.), (.^.), (.<<.), (.>>.))
import qualified Data.Bits as B
import Data.Word (Word64)
import Foreign.Marshal.Alloc (allocaBytes)
import Foreign.Ptr (Ptr, castPtr)
import Foreign.Storable (peekElemOff)

rotl :: Word64 -> Int -> Word64
rotl :: Word64 -> Int -> Word64
rotl Word64
x Int
k = (Word64
x Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.<<. Int
k) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. (Word64
x Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.>>. (Int
64 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
k))
{-# INLINE rotl #-}

-- | A xoshiro256++ state, which must not be all zero.
data S = S
  {-# UNPACK #-} !Word64
  {-# UNPACK #-} !Word64
  {-# UNPACK #-} !Word64
  {-# UNPACK #-} !Word64

-- | The ++ scrambler: the output for a state.
output :: S -> Word64
output :: S -> Word64
output (S Word64
s0 Word64
_ Word64
_ Word64
s3) = Word64 -> Int -> Word64
rotl (Word64
s0 Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
s3) Int
23 Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
s0
{-# INLINE output #-}

-- | The linear engine: the next state.
next :: S -> S
next :: S -> S
next (S Word64
s0 Word64
s1 Word64
s2 Word64
s3) =
  let !t :: Word64
t   = Word64
s1 Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.<<. Int
17
      !a2 :: Word64
a2  = Word64
s2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
s0
      !a3 :: Word64
a3  = Word64
s3 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
s1
      !b1 :: Word64
b1  = Word64
s1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
a2
      !b0 :: Word64
b0  = Word64
s0 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
a3
      !b2 :: Word64
b2  = Word64
a2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
t
      !b3 :: Word64
b3  = Word64 -> Int -> Word64
rotl Word64
a3 Int
45
  in  Word64 -> Word64 -> Word64 -> Word64 -> S
S Word64
b0 Word64
b1 Word64
b2 Word64
b3
{-# INLINE next #-}

xor_s :: S -> S -> S
xor_s :: S -> S -> S
xor_s (S Word64
a0 Word64
a1 Word64
a2 Word64
a3) (S Word64
b0 Word64
b1 Word64
b2 Word64
b3) =
  Word64 -> Word64 -> Word64 -> Word64 -> S
S (Word64
a0 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
b0) (Word64
a1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
b1) (Word64
a2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
b2) (Word64
a3 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. Word64
b3)
{-# INLINE xor_s #-}

data P = P !S !S

-- advance the state by the jump polynomial with the given coefficients
leap :: Word64 -> Word64 -> Word64 -> Word64 -> S -> S
leap :: Word64 -> Word64 -> Word64 -> Word64 -> S -> S
leap Word64
j0 Word64
j1 Word64
j2 Word64
j3 S
s0 =
  let !(P S
acc S
_) =
        Word64 -> P -> P
coef Word64
j3 (Word64 -> P -> P
coef Word64
j2 (Word64 -> P -> P
coef Word64
j1 (Word64 -> P -> P
coef Word64
j0 (S -> S -> P
P (Word64 -> Word64 -> Word64 -> Word64 -> S
S Word64
0 Word64
0 Word64
0 Word64
0) S
s0))))
  in  S
acc
  where
    coef :: Word64 -> P -> P
    coef :: Word64 -> P -> P
coef Word64
j = Int -> P -> P
loop Int
0 where
      loop :: Int -> P -> P
      loop :: Int -> P -> P
loop !Int
b p :: P
p@(P S
acc S
s)
        | Int
b Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
64   = P
p
        | Bool
otherwise =
            let !nacc :: S
nacc | Word64 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
B.testBit Word64
j Int
b = S -> S -> S
xor_s S
acc S
s
                      | Bool
otherwise     = S
acc
            in  Int -> P -> P
loop (Int
b Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (S -> S -> P
P S
nacc (S -> S
next S
s))

-- | Advance a state by 2 ^ 128 steps.
jump :: S -> S
jump :: S -> S
jump = Word64 -> Word64 -> Word64 -> Word64 -> S -> S
leap Word64
0x180ec6d33cfd0aba Word64
0xd5a61266f0c9392c
            Word64
0xa9582618e03fc9aa Word64
0x39abdc4529b1661c

-- | Advance a state by 2 ^ 192 steps.
long_jump :: S -> S
long_jump :: S -> S
long_jump = Word64 -> Word64 -> Word64 -> Word64 -> S -> S
leap Word64
0x76e15d3efefdcbbf Word64
0xc5004e441c522fb3
                 Word64
0x77710069854ee241 Word64
0x39109bb02acbe635

data SM = SM {-# UNPACK #-} !Word64 {-# UNPACK #-} !Word64

splitmix64 :: Word64 -> SM
splitmix64 :: Word64 -> SM
splitmix64 Word64
x =
  let !nx :: Word64
nx = Word64
x Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
0x9e3779b97f4a7c15
      !z0 :: Word64
z0 = (Word64
nx Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. (Word64
nx Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.>>. Int
30)) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
* Word64
0xbf58476d1ce4e5b9
      !z1 :: Word64
z1 = (Word64
z0 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. (Word64
z0 Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.>>. Int
27)) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
* Word64
0x94d049bb133111eb
  in  Word64 -> Word64 -> SM
SM Word64
nx (Word64
z1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.^. (Word64
z1 Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
.>>. Int
31))
{-# INLINE splitmix64 #-}

-- | A state expanded from a 64-bit seed via splitmix64, per the
--   xoshiro authors' recommendation. It is never all zero.
seed :: Word64 -> S
seed :: Word64 -> S
seed Word64
x =
  let !(SM Word64
x0 Word64
s0) = Word64 -> SM
splitmix64 Word64
x
      !(SM Word64
x1 Word64
s1) = Word64 -> SM
splitmix64 Word64
x0
      !(SM Word64
x2 Word64
s2) = Word64 -> SM
splitmix64 Word64
x1
      !(SM Word64
_  Word64
s3) = Word64 -> SM
splitmix64 Word64
x2
  in  Word64 -> Word64 -> Word64 -> Word64 -> S
S Word64
s0 Word64
s1 Word64
s2 Word64
s3

-- | A state from the given words, unless they are all zero.
from_words :: Word64 -> Word64 -> Word64 -> Word64 -> Maybe S
from_words :: Word64 -> Word64 -> Word64 -> Word64 -> Maybe S
from_words Word64
s0 Word64
s1 Word64
s2 Word64
s3
  | Word64
s0 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
s1 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
s2 Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.|. Word64
s3 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
0 = Maybe S
forall a. Maybe a
Nothing
  | Bool
otherwise = S -> Maybe S
forall a. a -> Maybe a
Just (Word64 -> Word64 -> Word64 -> Word64 -> S
S Word64
s0 Word64
s1 Word64
s2 Word64
s3)
{-# INLINE from_words #-}

-- | A state drawn from the operating system's entropy source, unless
--   that fails.
system :: IO (Maybe S)
system :: IO (Maybe S)
system = Int -> (Ptr Word8 -> IO (Maybe S)) -> IO (Maybe S)
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
32 ((Ptr Word8 -> IO (Maybe S)) -> IO (Maybe S))
-> (Ptr Word8 -> IO (Maybe S)) -> IO (Maybe S)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
buf -> do
  ok <- Ptr Word8 -> Int -> IO Bool
Entropy.fill Ptr Word8
buf Int
32
  if   not ok
  then pure Nothing
  else do
    let p = Ptr Word8 -> Ptr Word64
forall a b. Ptr a -> Ptr b
castPtr Ptr Word8
buf :: Ptr Word64
    s0 <- peekElemOff p 0
    s1 <- peekElemOff p 1
    s2 <- peekElemOff p 2
    s3 <- peekElemOff p 3
    pure $! from_words s0 s1 s2 s3