{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

#include <openssl/opensslv.h>

-- |
-- Module: Data.Hash.Internal.OpenSSL
-- Copyright: Copyright © 2021 Lars Kuhtz <lakuhtz@gmail.com>
-- License: MIT
-- Maintainer: Lars Kuhtz <lakuhtz@gmail.com>
-- Stability: experimental
--
-- Bindings for OpenSSL EVP Message Digest Routines
--
module Data.Hash.Internal.OpenSSL
(

-- * EVP digest routines

  Algorithm(..)
, Ctx(..)
, Digest(..)
, newCtx
, initCtx
, updateCtx
, finalCtx

-- * Algorithms

, OpenSslDigest(..)
, OpenSslException(..)

-- ** SHA2
--
-- $sha2

, Sha2_224(..)
, Sha2_256(..)
, Sha2_384(..)
, Sha2_512(..)
, Sha2_512_224(..)
, Sha2_512_256(..)

-- ** SHA3
--
-- $sha3

, Sha3_224(..)
, Sha3_256(..)
, Sha3_384(..)
, Sha3_512(..)
, Shake128(..)
, Shake256(..)

-- ** Keccak
--
-- $keccak

, Keccak256(..)
, Keccak512(..)

-- ** Blake2
--
-- $blake2

, Blake2b512(..)
, Blake2s256(..)
) where

import Control.Exception
import Control.Monad

import qualified Data.ByteString.Short as BS
import Data.Void
import Data.Word

import Foreign.ForeignPtr
import Foreign.Marshal
import Foreign.Ptr

import GHC.IO

-- internal modules

import Data.Hash.Class.Mutable
import Data.Hash.Internal.Utils


#if OPENSSL_VERSION_NUMBER < 0x10100000L
#error "Unsupported OpenSSL version. Please install OpenSSL >= 1.1.0"
#endif

-- -------------------------------------------------------------------------- --
-- OpenSSL Message Digests

newtype OpenSslException = OpenSslException String
    deriving (Int -> OpenSslException -> ShowS
[OpenSslException] -> ShowS
OpenSslException -> String
(Int -> OpenSslException -> ShowS)
-> (OpenSslException -> String)
-> ([OpenSslException] -> ShowS)
-> Show OpenSslException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpenSslException] -> ShowS
$cshowList :: [OpenSslException] -> ShowS
show :: OpenSslException -> String
$cshow :: OpenSslException -> String
showsPrec :: Int -> OpenSslException -> ShowS
$cshowsPrec :: Int -> OpenSslException -> ShowS
Show)

instance Exception OpenSslException

newtype Algorithm = Algorithm (Ptr Void)
newtype Ctx a = Ctx (ForeignPtr Void)
newtype Digest a = Digest BS.ShortByteString
    deriving (Digest a -> Digest a -> Bool
(Digest a -> Digest a -> Bool)
-> (Digest a -> Digest a -> Bool) -> Eq (Digest a)
forall a. Digest a -> Digest a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Digest a -> Digest a -> Bool
$c/= :: forall a. Digest a -> Digest a -> Bool
== :: Digest a -> Digest a -> Bool
$c== :: forall a. Digest a -> Digest a -> Bool
Eq, Eq (Digest a)
Eq (Digest a)
-> (Digest a -> Digest a -> Ordering)
-> (Digest a -> Digest a -> Bool)
-> (Digest a -> Digest a -> Bool)
-> (Digest a -> Digest a -> Bool)
-> (Digest a -> Digest a -> Bool)
-> (Digest a -> Digest a -> Digest a)
-> (Digest a -> Digest a -> Digest a)
-> Ord (Digest a)
Digest a -> Digest a -> Bool
Digest a -> Digest a -> Ordering
Digest a -> Digest a -> Digest a
forall a. Eq (Digest a)
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Digest a -> Digest a -> Bool
forall a. Digest a -> Digest a -> Ordering
forall a. Digest a -> Digest a -> Digest a
min :: Digest a -> Digest a -> Digest a
$cmin :: forall a. Digest a -> Digest a -> Digest a
max :: Digest a -> Digest a -> Digest a
$cmax :: forall a. Digest a -> Digest a -> Digest a
>= :: Digest a -> Digest a -> Bool
$c>= :: forall a. Digest a -> Digest a -> Bool
> :: Digest a -> Digest a -> Bool
$c> :: forall a. Digest a -> Digest a -> Bool
<= :: Digest a -> Digest a -> Bool
$c<= :: forall a. Digest a -> Digest a -> Bool
< :: Digest a -> Digest a -> Bool
$c< :: forall a. Digest a -> Digest a -> Bool
compare :: Digest a -> Digest a -> Ordering
$ccompare :: forall a. Digest a -> Digest a -> Ordering
$cp1Ord :: forall a. Eq (Digest a)
Ord)
    deriving (Int -> Digest a -> ShowS
[Digest a] -> ShowS
Digest a -> String
(Int -> Digest a -> ShowS)
-> (Digest a -> String) -> ([Digest a] -> ShowS) -> Show (Digest a)
forall a. Int -> Digest a -> ShowS
forall a. [Digest a] -> ShowS
forall a. Digest a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Digest a] -> ShowS
$cshowList :: forall a. [Digest a] -> ShowS
show :: Digest a -> String
$cshow :: forall a. Digest a -> String
showsPrec :: Int -> Digest a -> ShowS
$cshowsPrec :: forall a. Int -> Digest a -> ShowS
Show) via B16ShortByteString

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
foreign import ccall unsafe "openssl/evp.h EVP_MD_CTX_new"
#else
foreign import ccall unsafe "openssl/evp.h EVP_MD_CTX_create"
#endif
    c_evp_ctx_new :: IO (Ptr a)

#if OPENSSL_VERSION_NUMBER >= 0x10100000L
foreign import ccall unsafe "openssl/evp.h &EVP_MD_CTX_free"
#else
foreign import ccall unsafe "openssl/evp.h &EVP_MD_CTX_destroy"
#endif
    c_evp_ctx_free_ptr :: FunPtr (Ptr a -> IO ())

-- obsolete, superseeded by EVP_DigestInit_ex instead, but not deprecated
-- (beware in case this becomes a macro in future versions)
--
foreign import ccall unsafe "opnessl/evp.h EVP_DigestInit"
    c_evp_digest_init :: Ptr ctx -> Ptr alg -> IO Bool

foreign import ccall unsafe "opnessl/evp.h EVP_DigestUpdate"
    c_evp_digest_update :: Ptr ctx -> Ptr d -> Int -> IO Bool

foreign import ccall unsafe "opnessl/evp.h EVP_DigestFinal"
    c_evp_digest_final :: Ptr ctx -> Ptr d -> Int -> IO Bool

#if OPENSSL_VERSION_NUMBER >= 0x30000000L
foreign import ccall unsafe "openssl/evp.h EVP_MD_CTX_get0_md"
#else
foreign import ccall unsafe "openssl/evp.h EVP_MD_CTX_md"
#endif
    c_evp_ctx_get0_md :: Ptr ctx -> IO Algorithm

#if OPENSSL_VERSION_NUMBER >= 0x30000000L
foreign import ccall unsafe "openssl/evp.h EVP_MD_get_size"
#else
foreign import ccall unsafe "openssl/evp.h EVP_MD_size"
#endif
    c_evp_get_size :: Algorithm -> IO Int

newCtx :: IO (Ctx a)
newCtx :: IO (Ctx a)
newCtx = (ForeignPtr Void -> Ctx a) -> IO (ForeignPtr Void) -> IO (Ctx a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ForeignPtr Void -> Ctx a
forall a. ForeignPtr Void -> Ctx a
Ctx (IO (ForeignPtr Void) -> IO (Ctx a))
-> IO (ForeignPtr Void) -> IO (Ctx a)
forall a b. (a -> b) -> a -> b
$ IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a. IO a -> IO a
mask_ (IO (ForeignPtr Void) -> IO (ForeignPtr Void))
-> IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Void
ptr <- IO (Ptr Void)
forall a. IO (Ptr a)
c_evp_ctx_new
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr Void
ptr Ptr Void -> Ptr Void -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Void
forall a. Ptr a
nullPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"failed to initialize context"
    FinalizerPtr Void -> Ptr Void -> IO (ForeignPtr Void)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr Void
forall a. FunPtr (Ptr a -> IO ())
c_evp_ctx_free_ptr Ptr Void
ptr
{-# INLINE newCtx #-}

initCtx :: Algorithm -> IO (Ctx a)
initCtx :: Algorithm -> IO (Ctx a)
initCtx (Algorithm Ptr Void
alg) = do
    Ctx ForeignPtr Void
ctx <- IO (Ctx Any)
forall a. IO (Ctx a)
newCtx
    Bool
r <- ForeignPtr Void -> (Ptr Void -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO Bool) -> IO Bool)
-> (Ptr Void -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Void
ptr ->
        Ptr Void -> Ptr Void -> IO Bool
forall ctx alg. Ptr ctx -> Ptr alg -> IO Bool
c_evp_digest_init Ptr Void
ptr Ptr Void
alg
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest initialization failed"
    Ctx a -> IO (Ctx a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ctx a -> IO (Ctx a)) -> Ctx a -> IO (Ctx a)
forall a b. (a -> b) -> a -> b
$ ForeignPtr Void -> Ctx a
forall a. ForeignPtr Void -> Ctx a
Ctx ForeignPtr Void
ctx
{-# INLINE initCtx #-}

updateCtx :: Ctx a -> Ptr Word8 -> Int -> IO ()
updateCtx :: Ctx a -> Ptr Word8 -> Int -> IO ()
updateCtx (Ctx ForeignPtr Void
ctx) Ptr Word8
d Int
c = ForeignPtr Void -> (Ptr Void -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO ()) -> IO ()) -> (Ptr Void -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Void
ptr -> do
    Bool
r <- Ptr Void -> Ptr Word8 -> Int -> IO Bool
forall ctx d. Ptr ctx -> Ptr d -> Int -> IO Bool
c_evp_digest_update Ptr Void
ptr Ptr Word8
d Int
c
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest update failed"
{-# INLINE updateCtx #-}

finalCtx :: Ctx a -> IO (Digest a)
finalCtx :: Ctx a -> IO (Digest a)
finalCtx (Ctx ForeignPtr Void
ctx) = ForeignPtr Void -> (Ptr Void -> IO (Digest a)) -> IO (Digest a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO (Digest a)) -> IO (Digest a))
-> (Ptr Void -> IO (Digest a)) -> IO (Digest a)
forall a b. (a -> b) -> a -> b
$ \Ptr Void
ptr -> do
    Int
s <- Ptr Void -> IO Algorithm
forall ctx. Ptr ctx -> IO Algorithm
c_evp_ctx_get0_md Ptr Void
ptr IO Algorithm -> (Algorithm -> IO Int) -> IO Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Algorithm -> IO Int
c_evp_get_size
    Int -> (Ptr CChar -> IO (Digest a)) -> IO (Digest a)
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
s ((Ptr CChar -> IO (Digest a)) -> IO (Digest a))
-> (Ptr CChar -> IO (Digest a)) -> IO (Digest a)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
dptr -> do
        Bool
r <- Ptr Void -> Ptr CChar -> Int -> IO Bool
forall ctx d. Ptr ctx -> Ptr d -> Int -> IO Bool
c_evp_digest_final Ptr Void
ptr Ptr CChar
dptr Int
0
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest finalization failed"
        ShortByteString -> Digest a
forall a. ShortByteString -> Digest a
Digest (ShortByteString -> Digest a)
-> IO ShortByteString -> IO (Digest a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CStringLen -> IO ShortByteString
BS.packCStringLen (Ptr CChar
dptr, Int
s)
{-# INLINE finalCtx #-}

-- -------------------------------------------------------------------------- --
-- Support for DerivingVia

class OpenSslDigest a where
    algorithm :: Algorithm

instance OpenSslDigest a => IncrementalHash (Digest a) where
    type Context (Digest a) = Ctx a
    update :: Context (Digest a) -> Ptr Word8 -> Int -> IO ()
update = Context (Digest a) -> Ptr Word8 -> Int -> IO ()
forall a. Ctx a -> Ptr Word8 -> Int -> IO ()
updateCtx
    finalize :: Context (Digest a) -> IO (Digest a)
finalize = Context (Digest a) -> IO (Digest a)
forall a. Ctx a -> IO (Digest a)
finalCtx
    {-# INLINE update #-}
    {-# INLINE finalize #-}

instance OpenSslDigest a => Hash (Digest a) where
    initialize :: IO (Context (Digest a))
initialize = Algorithm -> IO (Ctx a)
forall a. Algorithm -> IO (Ctx a)
initCtx (OpenSslDigest a => Algorithm
forall a. OpenSslDigest a => Algorithm
algorithm @a)
    {-# INLINE initialize #-}

-- -------------------------------------------------------------------------- --
-- Digests
-- -------------------------------------------------------------------------- --

-- -------------------------------------------------------------------------- --
-- SHA-2

-- $sha2
--
-- SHA-2 (Secure Hash Algorithm 2) is a family of cryptographic hash functions
-- standardized in NIST FIPS 180-4, first published in 2001. These functions
-- conform to NIST FIPS 180-4.
--
-- The following hash functions from the SHA-2 family are supported in
-- openssl-3.0 (cf. https://www.openssl.org/docs/man3.0/man3/EVP_sha224.html)
--
-- EVP_sha224, EVP_sha256, EVP_sha512_224, EVP_sha512_256, EVP_sha384,
-- EVP_sha512
--

foreign import ccall unsafe "openssl/evp.h EVP_sha224"
    c_evp_sha2_224 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha256"
    c_evp_sha2_256 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha384"
    c_evp_sha2_384 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha512"
    c_evp_sha2_512 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha512_224"
    c_evp_sha2_512_224 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha512_256"
    c_evp_sha2_512_256 :: Algorithm

newtype Sha2_224 = Sha2_224 BS.ShortByteString
    deriving (Sha2_224 -> Sha2_224 -> Bool
(Sha2_224 -> Sha2_224 -> Bool)
-> (Sha2_224 -> Sha2_224 -> Bool) -> Eq Sha2_224
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_224 -> Sha2_224 -> Bool
$c/= :: Sha2_224 -> Sha2_224 -> Bool
== :: Sha2_224 -> Sha2_224 -> Bool
$c== :: Sha2_224 -> Sha2_224 -> Bool
Eq, Eq Sha2_224
Eq Sha2_224
-> (Sha2_224 -> Sha2_224 -> Ordering)
-> (Sha2_224 -> Sha2_224 -> Bool)
-> (Sha2_224 -> Sha2_224 -> Bool)
-> (Sha2_224 -> Sha2_224 -> Bool)
-> (Sha2_224 -> Sha2_224 -> Bool)
-> (Sha2_224 -> Sha2_224 -> Sha2_224)
-> (Sha2_224 -> Sha2_224 -> Sha2_224)
-> Ord Sha2_224
Sha2_224 -> Sha2_224 -> Bool
Sha2_224 -> Sha2_224 -> Ordering
Sha2_224 -> Sha2_224 -> Sha2_224
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_224 -> Sha2_224 -> Sha2_224
$cmin :: Sha2_224 -> Sha2_224 -> Sha2_224
max :: Sha2_224 -> Sha2_224 -> Sha2_224
$cmax :: Sha2_224 -> Sha2_224 -> Sha2_224
>= :: Sha2_224 -> Sha2_224 -> Bool
$c>= :: Sha2_224 -> Sha2_224 -> Bool
> :: Sha2_224 -> Sha2_224 -> Bool
$c> :: Sha2_224 -> Sha2_224 -> Bool
<= :: Sha2_224 -> Sha2_224 -> Bool
$c<= :: Sha2_224 -> Sha2_224 -> Bool
< :: Sha2_224 -> Sha2_224 -> Bool
$c< :: Sha2_224 -> Sha2_224 -> Bool
compare :: Sha2_224 -> Sha2_224 -> Ordering
$ccompare :: Sha2_224 -> Sha2_224 -> Ordering
$cp1Ord :: Eq Sha2_224
Ord)
    deriving (Int -> Sha2_224 -> ShowS
[Sha2_224] -> ShowS
Sha2_224 -> String
(Int -> Sha2_224 -> ShowS)
-> (Sha2_224 -> String) -> ([Sha2_224] -> ShowS) -> Show Sha2_224
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_224] -> ShowS
$cshowList :: [Sha2_224] -> ShowS
show :: Sha2_224 -> String
$cshow :: Sha2_224 -> String
showsPrec :: Int -> Sha2_224 -> ShowS
$cshowsPrec :: Int -> Sha2_224 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_224 -> IO Sha2_224
Context Sha2_224 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_224 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_224 -> IO Sha2_224) -> IncrementalHash Sha2_224
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_224 -> IO Sha2_224
$cfinalize :: Context Sha2_224 -> IO Sha2_224
update :: Context Sha2_224 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_224 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_224)
IncrementalHash Sha2_224
IncrementalHash Sha2_224 -> IO (Context Sha2_224) -> Hash Sha2_224
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_224)
$cinitialize :: IO (Context Sha2_224)
$cp1Hash :: IncrementalHash Sha2_224
Hash) via (Digest Sha2_224)
instance OpenSslDigest Sha2_224 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_224

newtype Sha2_256 = Sha2_256 BS.ShortByteString
    deriving (Sha2_256 -> Sha2_256 -> Bool
(Sha2_256 -> Sha2_256 -> Bool)
-> (Sha2_256 -> Sha2_256 -> Bool) -> Eq Sha2_256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_256 -> Sha2_256 -> Bool
$c/= :: Sha2_256 -> Sha2_256 -> Bool
== :: Sha2_256 -> Sha2_256 -> Bool
$c== :: Sha2_256 -> Sha2_256 -> Bool
Eq, Eq Sha2_256
Eq Sha2_256
-> (Sha2_256 -> Sha2_256 -> Ordering)
-> (Sha2_256 -> Sha2_256 -> Bool)
-> (Sha2_256 -> Sha2_256 -> Bool)
-> (Sha2_256 -> Sha2_256 -> Bool)
-> (Sha2_256 -> Sha2_256 -> Bool)
-> (Sha2_256 -> Sha2_256 -> Sha2_256)
-> (Sha2_256 -> Sha2_256 -> Sha2_256)
-> Ord Sha2_256
Sha2_256 -> Sha2_256 -> Bool
Sha2_256 -> Sha2_256 -> Ordering
Sha2_256 -> Sha2_256 -> Sha2_256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_256 -> Sha2_256 -> Sha2_256
$cmin :: Sha2_256 -> Sha2_256 -> Sha2_256
max :: Sha2_256 -> Sha2_256 -> Sha2_256
$cmax :: Sha2_256 -> Sha2_256 -> Sha2_256
>= :: Sha2_256 -> Sha2_256 -> Bool
$c>= :: Sha2_256 -> Sha2_256 -> Bool
> :: Sha2_256 -> Sha2_256 -> Bool
$c> :: Sha2_256 -> Sha2_256 -> Bool
<= :: Sha2_256 -> Sha2_256 -> Bool
$c<= :: Sha2_256 -> Sha2_256 -> Bool
< :: Sha2_256 -> Sha2_256 -> Bool
$c< :: Sha2_256 -> Sha2_256 -> Bool
compare :: Sha2_256 -> Sha2_256 -> Ordering
$ccompare :: Sha2_256 -> Sha2_256 -> Ordering
$cp1Ord :: Eq Sha2_256
Ord)
    deriving (Int -> Sha2_256 -> ShowS
[Sha2_256] -> ShowS
Sha2_256 -> String
(Int -> Sha2_256 -> ShowS)
-> (Sha2_256 -> String) -> ([Sha2_256] -> ShowS) -> Show Sha2_256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_256] -> ShowS
$cshowList :: [Sha2_256] -> ShowS
show :: Sha2_256 -> String
$cshow :: Sha2_256 -> String
showsPrec :: Int -> Sha2_256 -> ShowS
$cshowsPrec :: Int -> Sha2_256 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_256 -> IO Sha2_256
Context Sha2_256 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_256 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_256 -> IO Sha2_256) -> IncrementalHash Sha2_256
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_256 -> IO Sha2_256
$cfinalize :: Context Sha2_256 -> IO Sha2_256
update :: Context Sha2_256 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_256 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_256)
IncrementalHash Sha2_256
IncrementalHash Sha2_256 -> IO (Context Sha2_256) -> Hash Sha2_256
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_256)
$cinitialize :: IO (Context Sha2_256)
$cp1Hash :: IncrementalHash Sha2_256
Hash) via (Digest Sha2_256)
instance OpenSslDigest Sha2_256 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_256

newtype Sha2_384 = Sha2_384 BS.ShortByteString
    deriving (Sha2_384 -> Sha2_384 -> Bool
(Sha2_384 -> Sha2_384 -> Bool)
-> (Sha2_384 -> Sha2_384 -> Bool) -> Eq Sha2_384
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_384 -> Sha2_384 -> Bool
$c/= :: Sha2_384 -> Sha2_384 -> Bool
== :: Sha2_384 -> Sha2_384 -> Bool
$c== :: Sha2_384 -> Sha2_384 -> Bool
Eq, Eq Sha2_384
Eq Sha2_384
-> (Sha2_384 -> Sha2_384 -> Ordering)
-> (Sha2_384 -> Sha2_384 -> Bool)
-> (Sha2_384 -> Sha2_384 -> Bool)
-> (Sha2_384 -> Sha2_384 -> Bool)
-> (Sha2_384 -> Sha2_384 -> Bool)
-> (Sha2_384 -> Sha2_384 -> Sha2_384)
-> (Sha2_384 -> Sha2_384 -> Sha2_384)
-> Ord Sha2_384
Sha2_384 -> Sha2_384 -> Bool
Sha2_384 -> Sha2_384 -> Ordering
Sha2_384 -> Sha2_384 -> Sha2_384
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_384 -> Sha2_384 -> Sha2_384
$cmin :: Sha2_384 -> Sha2_384 -> Sha2_384
max :: Sha2_384 -> Sha2_384 -> Sha2_384
$cmax :: Sha2_384 -> Sha2_384 -> Sha2_384
>= :: Sha2_384 -> Sha2_384 -> Bool
$c>= :: Sha2_384 -> Sha2_384 -> Bool
> :: Sha2_384 -> Sha2_384 -> Bool
$c> :: Sha2_384 -> Sha2_384 -> Bool
<= :: Sha2_384 -> Sha2_384 -> Bool
$c<= :: Sha2_384 -> Sha2_384 -> Bool
< :: Sha2_384 -> Sha2_384 -> Bool
$c< :: Sha2_384 -> Sha2_384 -> Bool
compare :: Sha2_384 -> Sha2_384 -> Ordering
$ccompare :: Sha2_384 -> Sha2_384 -> Ordering
$cp1Ord :: Eq Sha2_384
Ord)
    deriving (Int -> Sha2_384 -> ShowS
[Sha2_384] -> ShowS
Sha2_384 -> String
(Int -> Sha2_384 -> ShowS)
-> (Sha2_384 -> String) -> ([Sha2_384] -> ShowS) -> Show Sha2_384
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_384] -> ShowS
$cshowList :: [Sha2_384] -> ShowS
show :: Sha2_384 -> String
$cshow :: Sha2_384 -> String
showsPrec :: Int -> Sha2_384 -> ShowS
$cshowsPrec :: Int -> Sha2_384 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_384 -> IO Sha2_384
Context Sha2_384 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_384 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_384 -> IO Sha2_384) -> IncrementalHash Sha2_384
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_384 -> IO Sha2_384
$cfinalize :: Context Sha2_384 -> IO Sha2_384
update :: Context Sha2_384 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_384 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_384)
IncrementalHash Sha2_384
IncrementalHash Sha2_384 -> IO (Context Sha2_384) -> Hash Sha2_384
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_384)
$cinitialize :: IO (Context Sha2_384)
$cp1Hash :: IncrementalHash Sha2_384
Hash) via (Digest Sha2_384)
instance OpenSslDigest Sha2_384 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_384

newtype Sha2_512 = Sha2_512 BS.ShortByteString
    deriving (Sha2_512 -> Sha2_512 -> Bool
(Sha2_512 -> Sha2_512 -> Bool)
-> (Sha2_512 -> Sha2_512 -> Bool) -> Eq Sha2_512
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_512 -> Sha2_512 -> Bool
$c/= :: Sha2_512 -> Sha2_512 -> Bool
== :: Sha2_512 -> Sha2_512 -> Bool
$c== :: Sha2_512 -> Sha2_512 -> Bool
Eq, Eq Sha2_512
Eq Sha2_512
-> (Sha2_512 -> Sha2_512 -> Ordering)
-> (Sha2_512 -> Sha2_512 -> Bool)
-> (Sha2_512 -> Sha2_512 -> Bool)
-> (Sha2_512 -> Sha2_512 -> Bool)
-> (Sha2_512 -> Sha2_512 -> Bool)
-> (Sha2_512 -> Sha2_512 -> Sha2_512)
-> (Sha2_512 -> Sha2_512 -> Sha2_512)
-> Ord Sha2_512
Sha2_512 -> Sha2_512 -> Bool
Sha2_512 -> Sha2_512 -> Ordering
Sha2_512 -> Sha2_512 -> Sha2_512
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_512 -> Sha2_512 -> Sha2_512
$cmin :: Sha2_512 -> Sha2_512 -> Sha2_512
max :: Sha2_512 -> Sha2_512 -> Sha2_512
$cmax :: Sha2_512 -> Sha2_512 -> Sha2_512
>= :: Sha2_512 -> Sha2_512 -> Bool
$c>= :: Sha2_512 -> Sha2_512 -> Bool
> :: Sha2_512 -> Sha2_512 -> Bool
$c> :: Sha2_512 -> Sha2_512 -> Bool
<= :: Sha2_512 -> Sha2_512 -> Bool
$c<= :: Sha2_512 -> Sha2_512 -> Bool
< :: Sha2_512 -> Sha2_512 -> Bool
$c< :: Sha2_512 -> Sha2_512 -> Bool
compare :: Sha2_512 -> Sha2_512 -> Ordering
$ccompare :: Sha2_512 -> Sha2_512 -> Ordering
$cp1Ord :: Eq Sha2_512
Ord)
    deriving (Int -> Sha2_512 -> ShowS
[Sha2_512] -> ShowS
Sha2_512 -> String
(Int -> Sha2_512 -> ShowS)
-> (Sha2_512 -> String) -> ([Sha2_512] -> ShowS) -> Show Sha2_512
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_512] -> ShowS
$cshowList :: [Sha2_512] -> ShowS
show :: Sha2_512 -> String
$cshow :: Sha2_512 -> String
showsPrec :: Int -> Sha2_512 -> ShowS
$cshowsPrec :: Int -> Sha2_512 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_512 -> IO Sha2_512
Context Sha2_512 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_512 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_512 -> IO Sha2_512) -> IncrementalHash Sha2_512
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_512 -> IO Sha2_512
$cfinalize :: Context Sha2_512 -> IO Sha2_512
update :: Context Sha2_512 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_512 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_512)
IncrementalHash Sha2_512
IncrementalHash Sha2_512 -> IO (Context Sha2_512) -> Hash Sha2_512
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_512)
$cinitialize :: IO (Context Sha2_512)
$cp1Hash :: IncrementalHash Sha2_512
Hash) via (Digest Sha2_512)
instance OpenSslDigest Sha2_512 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_512

newtype Sha2_512_224 = Sha2_512_224 BS.ShortByteString
    deriving (Sha2_512_224 -> Sha2_512_224 -> Bool
(Sha2_512_224 -> Sha2_512_224 -> Bool)
-> (Sha2_512_224 -> Sha2_512_224 -> Bool) -> Eq Sha2_512_224
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c/= :: Sha2_512_224 -> Sha2_512_224 -> Bool
== :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c== :: Sha2_512_224 -> Sha2_512_224 -> Bool
Eq, Eq Sha2_512_224
Eq Sha2_512_224
-> (Sha2_512_224 -> Sha2_512_224 -> Ordering)
-> (Sha2_512_224 -> Sha2_512_224 -> Bool)
-> (Sha2_512_224 -> Sha2_512_224 -> Bool)
-> (Sha2_512_224 -> Sha2_512_224 -> Bool)
-> (Sha2_512_224 -> Sha2_512_224 -> Bool)
-> (Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224)
-> (Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224)
-> Ord Sha2_512_224
Sha2_512_224 -> Sha2_512_224 -> Bool
Sha2_512_224 -> Sha2_512_224 -> Ordering
Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224
$cmin :: Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224
max :: Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224
$cmax :: Sha2_512_224 -> Sha2_512_224 -> Sha2_512_224
>= :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c>= :: Sha2_512_224 -> Sha2_512_224 -> Bool
> :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c> :: Sha2_512_224 -> Sha2_512_224 -> Bool
<= :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c<= :: Sha2_512_224 -> Sha2_512_224 -> Bool
< :: Sha2_512_224 -> Sha2_512_224 -> Bool
$c< :: Sha2_512_224 -> Sha2_512_224 -> Bool
compare :: Sha2_512_224 -> Sha2_512_224 -> Ordering
$ccompare :: Sha2_512_224 -> Sha2_512_224 -> Ordering
$cp1Ord :: Eq Sha2_512_224
Ord)
    deriving (Int -> Sha2_512_224 -> ShowS
[Sha2_512_224] -> ShowS
Sha2_512_224 -> String
(Int -> Sha2_512_224 -> ShowS)
-> (Sha2_512_224 -> String)
-> ([Sha2_512_224] -> ShowS)
-> Show Sha2_512_224
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_512_224] -> ShowS
$cshowList :: [Sha2_512_224] -> ShowS
show :: Sha2_512_224 -> String
$cshow :: Sha2_512_224 -> String
showsPrec :: Int -> Sha2_512_224 -> ShowS
$cshowsPrec :: Int -> Sha2_512_224 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_512_224 -> IO Sha2_512_224
Context Sha2_512_224 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_512_224 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_512_224 -> IO Sha2_512_224)
-> IncrementalHash Sha2_512_224
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_512_224 -> IO Sha2_512_224
$cfinalize :: Context Sha2_512_224 -> IO Sha2_512_224
update :: Context Sha2_512_224 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_512_224 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_512_224)
IncrementalHash Sha2_512_224
IncrementalHash Sha2_512_224
-> IO (Context Sha2_512_224) -> Hash Sha2_512_224
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_512_224)
$cinitialize :: IO (Context Sha2_512_224)
$cp1Hash :: IncrementalHash Sha2_512_224
Hash) via (Digest Sha2_512_224)
instance OpenSslDigest Sha2_512_224 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_512_224

newtype Sha2_512_256 = Sha2_512_256 BS.ShortByteString
    deriving (Sha2_512_256 -> Sha2_512_256 -> Bool
(Sha2_512_256 -> Sha2_512_256 -> Bool)
-> (Sha2_512_256 -> Sha2_512_256 -> Bool) -> Eq Sha2_512_256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c/= :: Sha2_512_256 -> Sha2_512_256 -> Bool
== :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c== :: Sha2_512_256 -> Sha2_512_256 -> Bool
Eq, Eq Sha2_512_256
Eq Sha2_512_256
-> (Sha2_512_256 -> Sha2_512_256 -> Ordering)
-> (Sha2_512_256 -> Sha2_512_256 -> Bool)
-> (Sha2_512_256 -> Sha2_512_256 -> Bool)
-> (Sha2_512_256 -> Sha2_512_256 -> Bool)
-> (Sha2_512_256 -> Sha2_512_256 -> Bool)
-> (Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256)
-> (Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256)
-> Ord Sha2_512_256
Sha2_512_256 -> Sha2_512_256 -> Bool
Sha2_512_256 -> Sha2_512_256 -> Ordering
Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256
$cmin :: Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256
max :: Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256
$cmax :: Sha2_512_256 -> Sha2_512_256 -> Sha2_512_256
>= :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c>= :: Sha2_512_256 -> Sha2_512_256 -> Bool
> :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c> :: Sha2_512_256 -> Sha2_512_256 -> Bool
<= :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c<= :: Sha2_512_256 -> Sha2_512_256 -> Bool
< :: Sha2_512_256 -> Sha2_512_256 -> Bool
$c< :: Sha2_512_256 -> Sha2_512_256 -> Bool
compare :: Sha2_512_256 -> Sha2_512_256 -> Ordering
$ccompare :: Sha2_512_256 -> Sha2_512_256 -> Ordering
$cp1Ord :: Eq Sha2_512_256
Ord)
    deriving (Int -> Sha2_512_256 -> ShowS
[Sha2_512_256] -> ShowS
Sha2_512_256 -> String
(Int -> Sha2_512_256 -> ShowS)
-> (Sha2_512_256 -> String)
-> ([Sha2_512_256] -> ShowS)
-> Show Sha2_512_256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha2_512_256] -> ShowS
$cshowList :: [Sha2_512_256] -> ShowS
show :: Sha2_512_256 -> String
$cshow :: Sha2_512_256 -> String
showsPrec :: Int -> Sha2_512_256 -> ShowS
$cshowsPrec :: Int -> Sha2_512_256 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha2_512_256 -> IO Sha2_512_256
Context Sha2_512_256 -> Ptr Word8 -> Int -> IO ()
(Context Sha2_512_256 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha2_512_256 -> IO Sha2_512_256)
-> IncrementalHash Sha2_512_256
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha2_512_256 -> IO Sha2_512_256
$cfinalize :: Context Sha2_512_256 -> IO Sha2_512_256
update :: Context Sha2_512_256 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha2_512_256 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha2_512_256)
IncrementalHash Sha2_512_256
IncrementalHash Sha2_512_256
-> IO (Context Sha2_512_256) -> Hash Sha2_512_256
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha2_512_256)
$cinitialize :: IO (Context Sha2_512_256)
$cp1Hash :: IncrementalHash Sha2_512_256
Hash) via (Digest Sha2_512_256)
instance OpenSslDigest Sha2_512_256 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha2_512_256

-- -------------------------------------------------------------------------- --
-- SHA-3

-- $sha3
--
-- SHA-3 (Secure Hash Algorithm 3) is a family of cryptographic hash functions
-- standardized in NIST FIPS 202, first published in 2015. It is based on the
-- Keccak algorithm. These functions conform to NIST FIPS 202.
--
-- The following hash functions from the SHA-3 family are supported in
-- openssl-3.0 (cf. https://www.openssl.org/docs/man3.0/man3/EVP_sha3_224.html)
--
-- EVP_sha3_224, EVP_sha3_256, EVP_sha3_384, EVP_sha3_512, EVP_shake128,
-- EVP_shake256

foreign import ccall unsafe "openssl/evp.h EVP_sha3_224"
    c_evp_sha3_224 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha3_256"
    c_evp_sha3_256 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha3_384"
    c_evp_sha3_384 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_sha3_512"
    c_evp_sha3_512 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_shake128"
    c_evp_shake128 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_shake256"
    c_evp_shake256 :: Algorithm

newtype Sha3_224 = Sha3_224 BS.ShortByteString
    deriving (Sha3_224 -> Sha3_224 -> Bool
(Sha3_224 -> Sha3_224 -> Bool)
-> (Sha3_224 -> Sha3_224 -> Bool) -> Eq Sha3_224
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha3_224 -> Sha3_224 -> Bool
$c/= :: Sha3_224 -> Sha3_224 -> Bool
== :: Sha3_224 -> Sha3_224 -> Bool
$c== :: Sha3_224 -> Sha3_224 -> Bool
Eq, Eq Sha3_224
Eq Sha3_224
-> (Sha3_224 -> Sha3_224 -> Ordering)
-> (Sha3_224 -> Sha3_224 -> Bool)
-> (Sha3_224 -> Sha3_224 -> Bool)
-> (Sha3_224 -> Sha3_224 -> Bool)
-> (Sha3_224 -> Sha3_224 -> Bool)
-> (Sha3_224 -> Sha3_224 -> Sha3_224)
-> (Sha3_224 -> Sha3_224 -> Sha3_224)
-> Ord Sha3_224
Sha3_224 -> Sha3_224 -> Bool
Sha3_224 -> Sha3_224 -> Ordering
Sha3_224 -> Sha3_224 -> Sha3_224
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha3_224 -> Sha3_224 -> Sha3_224
$cmin :: Sha3_224 -> Sha3_224 -> Sha3_224
max :: Sha3_224 -> Sha3_224 -> Sha3_224
$cmax :: Sha3_224 -> Sha3_224 -> Sha3_224
>= :: Sha3_224 -> Sha3_224 -> Bool
$c>= :: Sha3_224 -> Sha3_224 -> Bool
> :: Sha3_224 -> Sha3_224 -> Bool
$c> :: Sha3_224 -> Sha3_224 -> Bool
<= :: Sha3_224 -> Sha3_224 -> Bool
$c<= :: Sha3_224 -> Sha3_224 -> Bool
< :: Sha3_224 -> Sha3_224 -> Bool
$c< :: Sha3_224 -> Sha3_224 -> Bool
compare :: Sha3_224 -> Sha3_224 -> Ordering
$ccompare :: Sha3_224 -> Sha3_224 -> Ordering
$cp1Ord :: Eq Sha3_224
Ord)
    deriving (Int -> Sha3_224 -> ShowS
[Sha3_224] -> ShowS
Sha3_224 -> String
(Int -> Sha3_224 -> ShowS)
-> (Sha3_224 -> String) -> ([Sha3_224] -> ShowS) -> Show Sha3_224
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha3_224] -> ShowS
$cshowList :: [Sha3_224] -> ShowS
show :: Sha3_224 -> String
$cshow :: Sha3_224 -> String
showsPrec :: Int -> Sha3_224 -> ShowS
$cshowsPrec :: Int -> Sha3_224 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha3_224 -> IO Sha3_224
Context Sha3_224 -> Ptr Word8 -> Int -> IO ()
(Context Sha3_224 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha3_224 -> IO Sha3_224) -> IncrementalHash Sha3_224
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha3_224 -> IO Sha3_224
$cfinalize :: Context Sha3_224 -> IO Sha3_224
update :: Context Sha3_224 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha3_224 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha3_224)
IncrementalHash Sha3_224
IncrementalHash Sha3_224 -> IO (Context Sha3_224) -> Hash Sha3_224
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha3_224)
$cinitialize :: IO (Context Sha3_224)
$cp1Hash :: IncrementalHash Sha3_224
Hash) via (Digest Sha3_224)
instance OpenSslDigest Sha3_224 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha3_224

newtype Sha3_256 = Sha3_256 BS.ShortByteString
    deriving (Sha3_256 -> Sha3_256 -> Bool
(Sha3_256 -> Sha3_256 -> Bool)
-> (Sha3_256 -> Sha3_256 -> Bool) -> Eq Sha3_256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha3_256 -> Sha3_256 -> Bool
$c/= :: Sha3_256 -> Sha3_256 -> Bool
== :: Sha3_256 -> Sha3_256 -> Bool
$c== :: Sha3_256 -> Sha3_256 -> Bool
Eq, Eq Sha3_256
Eq Sha3_256
-> (Sha3_256 -> Sha3_256 -> Ordering)
-> (Sha3_256 -> Sha3_256 -> Bool)
-> (Sha3_256 -> Sha3_256 -> Bool)
-> (Sha3_256 -> Sha3_256 -> Bool)
-> (Sha3_256 -> Sha3_256 -> Bool)
-> (Sha3_256 -> Sha3_256 -> Sha3_256)
-> (Sha3_256 -> Sha3_256 -> Sha3_256)
-> Ord Sha3_256
Sha3_256 -> Sha3_256 -> Bool
Sha3_256 -> Sha3_256 -> Ordering
Sha3_256 -> Sha3_256 -> Sha3_256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha3_256 -> Sha3_256 -> Sha3_256
$cmin :: Sha3_256 -> Sha3_256 -> Sha3_256
max :: Sha3_256 -> Sha3_256 -> Sha3_256
$cmax :: Sha3_256 -> Sha3_256 -> Sha3_256
>= :: Sha3_256 -> Sha3_256 -> Bool
$c>= :: Sha3_256 -> Sha3_256 -> Bool
> :: Sha3_256 -> Sha3_256 -> Bool
$c> :: Sha3_256 -> Sha3_256 -> Bool
<= :: Sha3_256 -> Sha3_256 -> Bool
$c<= :: Sha3_256 -> Sha3_256 -> Bool
< :: Sha3_256 -> Sha3_256 -> Bool
$c< :: Sha3_256 -> Sha3_256 -> Bool
compare :: Sha3_256 -> Sha3_256 -> Ordering
$ccompare :: Sha3_256 -> Sha3_256 -> Ordering
$cp1Ord :: Eq Sha3_256
Ord)
    deriving (Int -> Sha3_256 -> ShowS
[Sha3_256] -> ShowS
Sha3_256 -> String
(Int -> Sha3_256 -> ShowS)
-> (Sha3_256 -> String) -> ([Sha3_256] -> ShowS) -> Show Sha3_256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha3_256] -> ShowS
$cshowList :: [Sha3_256] -> ShowS
show :: Sha3_256 -> String
$cshow :: Sha3_256 -> String
showsPrec :: Int -> Sha3_256 -> ShowS
$cshowsPrec :: Int -> Sha3_256 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha3_256 -> IO Sha3_256
Context Sha3_256 -> Ptr Word8 -> Int -> IO ()
(Context Sha3_256 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha3_256 -> IO Sha3_256) -> IncrementalHash Sha3_256
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha3_256 -> IO Sha3_256
$cfinalize :: Context Sha3_256 -> IO Sha3_256
update :: Context Sha3_256 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha3_256 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha3_256)
IncrementalHash Sha3_256
IncrementalHash Sha3_256 -> IO (Context Sha3_256) -> Hash Sha3_256
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha3_256)
$cinitialize :: IO (Context Sha3_256)
$cp1Hash :: IncrementalHash Sha3_256
Hash) via (Digest Sha3_256)
instance OpenSslDigest Sha3_256 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha3_256

newtype Sha3_384 = Sha3_384 BS.ShortByteString
    deriving (Sha3_384 -> Sha3_384 -> Bool
(Sha3_384 -> Sha3_384 -> Bool)
-> (Sha3_384 -> Sha3_384 -> Bool) -> Eq Sha3_384
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha3_384 -> Sha3_384 -> Bool
$c/= :: Sha3_384 -> Sha3_384 -> Bool
== :: Sha3_384 -> Sha3_384 -> Bool
$c== :: Sha3_384 -> Sha3_384 -> Bool
Eq, Eq Sha3_384
Eq Sha3_384
-> (Sha3_384 -> Sha3_384 -> Ordering)
-> (Sha3_384 -> Sha3_384 -> Bool)
-> (Sha3_384 -> Sha3_384 -> Bool)
-> (Sha3_384 -> Sha3_384 -> Bool)
-> (Sha3_384 -> Sha3_384 -> Bool)
-> (Sha3_384 -> Sha3_384 -> Sha3_384)
-> (Sha3_384 -> Sha3_384 -> Sha3_384)
-> Ord Sha3_384
Sha3_384 -> Sha3_384 -> Bool
Sha3_384 -> Sha3_384 -> Ordering
Sha3_384 -> Sha3_384 -> Sha3_384
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha3_384 -> Sha3_384 -> Sha3_384
$cmin :: Sha3_384 -> Sha3_384 -> Sha3_384
max :: Sha3_384 -> Sha3_384 -> Sha3_384
$cmax :: Sha3_384 -> Sha3_384 -> Sha3_384
>= :: Sha3_384 -> Sha3_384 -> Bool
$c>= :: Sha3_384 -> Sha3_384 -> Bool
> :: Sha3_384 -> Sha3_384 -> Bool
$c> :: Sha3_384 -> Sha3_384 -> Bool
<= :: Sha3_384 -> Sha3_384 -> Bool
$c<= :: Sha3_384 -> Sha3_384 -> Bool
< :: Sha3_384 -> Sha3_384 -> Bool
$c< :: Sha3_384 -> Sha3_384 -> Bool
compare :: Sha3_384 -> Sha3_384 -> Ordering
$ccompare :: Sha3_384 -> Sha3_384 -> Ordering
$cp1Ord :: Eq Sha3_384
Ord)
    deriving (Int -> Sha3_384 -> ShowS
[Sha3_384] -> ShowS
Sha3_384 -> String
(Int -> Sha3_384 -> ShowS)
-> (Sha3_384 -> String) -> ([Sha3_384] -> ShowS) -> Show Sha3_384
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha3_384] -> ShowS
$cshowList :: [Sha3_384] -> ShowS
show :: Sha3_384 -> String
$cshow :: Sha3_384 -> String
showsPrec :: Int -> Sha3_384 -> ShowS
$cshowsPrec :: Int -> Sha3_384 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha3_384 -> IO Sha3_384
Context Sha3_384 -> Ptr Word8 -> Int -> IO ()
(Context Sha3_384 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha3_384 -> IO Sha3_384) -> IncrementalHash Sha3_384
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha3_384 -> IO Sha3_384
$cfinalize :: Context Sha3_384 -> IO Sha3_384
update :: Context Sha3_384 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha3_384 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha3_384)
IncrementalHash Sha3_384
IncrementalHash Sha3_384 -> IO (Context Sha3_384) -> Hash Sha3_384
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha3_384)
$cinitialize :: IO (Context Sha3_384)
$cp1Hash :: IncrementalHash Sha3_384
Hash) via (Digest Sha3_384)
instance OpenSslDigest Sha3_384 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha3_384

newtype Sha3_512 = Sha3_512 BS.ShortByteString
    deriving (Sha3_512 -> Sha3_512 -> Bool
(Sha3_512 -> Sha3_512 -> Bool)
-> (Sha3_512 -> Sha3_512 -> Bool) -> Eq Sha3_512
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sha3_512 -> Sha3_512 -> Bool
$c/= :: Sha3_512 -> Sha3_512 -> Bool
== :: Sha3_512 -> Sha3_512 -> Bool
$c== :: Sha3_512 -> Sha3_512 -> Bool
Eq, Eq Sha3_512
Eq Sha3_512
-> (Sha3_512 -> Sha3_512 -> Ordering)
-> (Sha3_512 -> Sha3_512 -> Bool)
-> (Sha3_512 -> Sha3_512 -> Bool)
-> (Sha3_512 -> Sha3_512 -> Bool)
-> (Sha3_512 -> Sha3_512 -> Bool)
-> (Sha3_512 -> Sha3_512 -> Sha3_512)
-> (Sha3_512 -> Sha3_512 -> Sha3_512)
-> Ord Sha3_512
Sha3_512 -> Sha3_512 -> Bool
Sha3_512 -> Sha3_512 -> Ordering
Sha3_512 -> Sha3_512 -> Sha3_512
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sha3_512 -> Sha3_512 -> Sha3_512
$cmin :: Sha3_512 -> Sha3_512 -> Sha3_512
max :: Sha3_512 -> Sha3_512 -> Sha3_512
$cmax :: Sha3_512 -> Sha3_512 -> Sha3_512
>= :: Sha3_512 -> Sha3_512 -> Bool
$c>= :: Sha3_512 -> Sha3_512 -> Bool
> :: Sha3_512 -> Sha3_512 -> Bool
$c> :: Sha3_512 -> Sha3_512 -> Bool
<= :: Sha3_512 -> Sha3_512 -> Bool
$c<= :: Sha3_512 -> Sha3_512 -> Bool
< :: Sha3_512 -> Sha3_512 -> Bool
$c< :: Sha3_512 -> Sha3_512 -> Bool
compare :: Sha3_512 -> Sha3_512 -> Ordering
$ccompare :: Sha3_512 -> Sha3_512 -> Ordering
$cp1Ord :: Eq Sha3_512
Ord)
    deriving (Int -> Sha3_512 -> ShowS
[Sha3_512] -> ShowS
Sha3_512 -> String
(Int -> Sha3_512 -> ShowS)
-> (Sha3_512 -> String) -> ([Sha3_512] -> ShowS) -> Show Sha3_512
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sha3_512] -> ShowS
$cshowList :: [Sha3_512] -> ShowS
show :: Sha3_512 -> String
$cshow :: Sha3_512 -> String
showsPrec :: Int -> Sha3_512 -> ShowS
$cshowsPrec :: Int -> Sha3_512 -> ShowS
Show) via B16ShortByteString
    deriving (Context Sha3_512 -> IO Sha3_512
Context Sha3_512 -> Ptr Word8 -> Int -> IO ()
(Context Sha3_512 -> Ptr Word8 -> Int -> IO ())
-> (Context Sha3_512 -> IO Sha3_512) -> IncrementalHash Sha3_512
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Sha3_512 -> IO Sha3_512
$cfinalize :: Context Sha3_512 -> IO Sha3_512
update :: Context Sha3_512 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Sha3_512 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Sha3_512)
IncrementalHash Sha3_512
IncrementalHash Sha3_512 -> IO (Context Sha3_512) -> Hash Sha3_512
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Sha3_512)
$cinitialize :: IO (Context Sha3_512)
$cp1Hash :: IncrementalHash Sha3_512
Hash) via (Digest Sha3_512)
instance OpenSslDigest Sha3_512 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_sha3_512

newtype Shake128 = Shake128 BS.ShortByteString
    deriving (Shake128 -> Shake128 -> Bool
(Shake128 -> Shake128 -> Bool)
-> (Shake128 -> Shake128 -> Bool) -> Eq Shake128
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Shake128 -> Shake128 -> Bool
$c/= :: Shake128 -> Shake128 -> Bool
== :: Shake128 -> Shake128 -> Bool
$c== :: Shake128 -> Shake128 -> Bool
Eq, Eq Shake128
Eq Shake128
-> (Shake128 -> Shake128 -> Ordering)
-> (Shake128 -> Shake128 -> Bool)
-> (Shake128 -> Shake128 -> Bool)
-> (Shake128 -> Shake128 -> Bool)
-> (Shake128 -> Shake128 -> Bool)
-> (Shake128 -> Shake128 -> Shake128)
-> (Shake128 -> Shake128 -> Shake128)
-> Ord Shake128
Shake128 -> Shake128 -> Bool
Shake128 -> Shake128 -> Ordering
Shake128 -> Shake128 -> Shake128
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Shake128 -> Shake128 -> Shake128
$cmin :: Shake128 -> Shake128 -> Shake128
max :: Shake128 -> Shake128 -> Shake128
$cmax :: Shake128 -> Shake128 -> Shake128
>= :: Shake128 -> Shake128 -> Bool
$c>= :: Shake128 -> Shake128 -> Bool
> :: Shake128 -> Shake128 -> Bool
$c> :: Shake128 -> Shake128 -> Bool
<= :: Shake128 -> Shake128 -> Bool
$c<= :: Shake128 -> Shake128 -> Bool
< :: Shake128 -> Shake128 -> Bool
$c< :: Shake128 -> Shake128 -> Bool
compare :: Shake128 -> Shake128 -> Ordering
$ccompare :: Shake128 -> Shake128 -> Ordering
$cp1Ord :: Eq Shake128
Ord)
    deriving (Int -> Shake128 -> ShowS
[Shake128] -> ShowS
Shake128 -> String
(Int -> Shake128 -> ShowS)
-> (Shake128 -> String) -> ([Shake128] -> ShowS) -> Show Shake128
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Shake128] -> ShowS
$cshowList :: [Shake128] -> ShowS
show :: Shake128 -> String
$cshow :: Shake128 -> String
showsPrec :: Int -> Shake128 -> ShowS
$cshowsPrec :: Int -> Shake128 -> ShowS
Show) via B16ShortByteString
    deriving (Context Shake128 -> IO Shake128
Context Shake128 -> Ptr Word8 -> Int -> IO ()
(Context Shake128 -> Ptr Word8 -> Int -> IO ())
-> (Context Shake128 -> IO Shake128) -> IncrementalHash Shake128
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Shake128 -> IO Shake128
$cfinalize :: Context Shake128 -> IO Shake128
update :: Context Shake128 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Shake128 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Shake128)
IncrementalHash Shake128
IncrementalHash Shake128 -> IO (Context Shake128) -> Hash Shake128
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Shake128)
$cinitialize :: IO (Context Shake128)
$cp1Hash :: IncrementalHash Shake128
Hash) via (Digest Shake128)
instance OpenSslDigest Shake128 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_shake128

newtype Shake256 = Shake256 BS.ShortByteString
    deriving (Shake256 -> Shake256 -> Bool
(Shake256 -> Shake256 -> Bool)
-> (Shake256 -> Shake256 -> Bool) -> Eq Shake256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Shake256 -> Shake256 -> Bool
$c/= :: Shake256 -> Shake256 -> Bool
== :: Shake256 -> Shake256 -> Bool
$c== :: Shake256 -> Shake256 -> Bool
Eq, Eq Shake256
Eq Shake256
-> (Shake256 -> Shake256 -> Ordering)
-> (Shake256 -> Shake256 -> Bool)
-> (Shake256 -> Shake256 -> Bool)
-> (Shake256 -> Shake256 -> Bool)
-> (Shake256 -> Shake256 -> Bool)
-> (Shake256 -> Shake256 -> Shake256)
-> (Shake256 -> Shake256 -> Shake256)
-> Ord Shake256
Shake256 -> Shake256 -> Bool
Shake256 -> Shake256 -> Ordering
Shake256 -> Shake256 -> Shake256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Shake256 -> Shake256 -> Shake256
$cmin :: Shake256 -> Shake256 -> Shake256
max :: Shake256 -> Shake256 -> Shake256
$cmax :: Shake256 -> Shake256 -> Shake256
>= :: Shake256 -> Shake256 -> Bool
$c>= :: Shake256 -> Shake256 -> Bool
> :: Shake256 -> Shake256 -> Bool
$c> :: Shake256 -> Shake256 -> Bool
<= :: Shake256 -> Shake256 -> Bool
$c<= :: Shake256 -> Shake256 -> Bool
< :: Shake256 -> Shake256 -> Bool
$c< :: Shake256 -> Shake256 -> Bool
compare :: Shake256 -> Shake256 -> Ordering
$ccompare :: Shake256 -> Shake256 -> Ordering
$cp1Ord :: Eq Shake256
Ord)
    deriving (Int -> Shake256 -> ShowS
[Shake256] -> ShowS
Shake256 -> String
(Int -> Shake256 -> ShowS)
-> (Shake256 -> String) -> ([Shake256] -> ShowS) -> Show Shake256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Shake256] -> ShowS
$cshowList :: [Shake256] -> ShowS
show :: Shake256 -> String
$cshow :: Shake256 -> String
showsPrec :: Int -> Shake256 -> ShowS
$cshowsPrec :: Int -> Shake256 -> ShowS
Show) via B16ShortByteString
    deriving (Context Shake256 -> IO Shake256
Context Shake256 -> Ptr Word8 -> Int -> IO ()
(Context Shake256 -> Ptr Word8 -> Int -> IO ())
-> (Context Shake256 -> IO Shake256) -> IncrementalHash Shake256
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Shake256 -> IO Shake256
$cfinalize :: Context Shake256 -> IO Shake256
update :: Context Shake256 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Shake256 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Shake256)
IncrementalHash Shake256
IncrementalHash Shake256 -> IO (Context Shake256) -> Hash Shake256
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Shake256)
$cinitialize :: IO (Context Shake256)
$cp1Hash :: IncrementalHash Shake256
Hash) via (Digest Shake256)
instance OpenSslDigest Shake256 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_shake256

-- -------------------------------------------------------------------------- --
-- Keccak

-- $keccak
--
-- This is the latest version of Keccak-256 hash function that was submitted to
-- the SHA3 competition. It is different from the final NIST SHA3 hash.
--
-- The difference between NIST SHA3-256 and Keccak-256 is the use of a different
-- padding character for the input message. The former uses '0x06' and the
-- latter uses '0x01'.
--
-- This version of Keccak-256 is used by the Ethereum project.
--
-- This implementation of Keccak-256 uses internal OpenSSL APIs. It may break
-- with new versions of OpenSSL. It may also be broken for existing versions of
-- OpenSSL. Portability of the code is unknown.
--
-- ONLY USE THIS CODE AFTER YOU HAVE VERIFIED THAT IT WORKS WITH OUR VERSION OF
-- OPENSSL.
--
-- For details see the file cbits/keccak.c.

-- KECCAK-256

newtype Keccak256 = Keccak256 BS.ShortByteString
    deriving (Keccak256 -> Keccak256 -> Bool
(Keccak256 -> Keccak256 -> Bool)
-> (Keccak256 -> Keccak256 -> Bool) -> Eq Keccak256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Keccak256 -> Keccak256 -> Bool
$c/= :: Keccak256 -> Keccak256 -> Bool
== :: Keccak256 -> Keccak256 -> Bool
$c== :: Keccak256 -> Keccak256 -> Bool
Eq, Eq Keccak256
Eq Keccak256
-> (Keccak256 -> Keccak256 -> Ordering)
-> (Keccak256 -> Keccak256 -> Bool)
-> (Keccak256 -> Keccak256 -> Bool)
-> (Keccak256 -> Keccak256 -> Bool)
-> (Keccak256 -> Keccak256 -> Bool)
-> (Keccak256 -> Keccak256 -> Keccak256)
-> (Keccak256 -> Keccak256 -> Keccak256)
-> Ord Keccak256
Keccak256 -> Keccak256 -> Bool
Keccak256 -> Keccak256 -> Ordering
Keccak256 -> Keccak256 -> Keccak256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Keccak256 -> Keccak256 -> Keccak256
$cmin :: Keccak256 -> Keccak256 -> Keccak256
max :: Keccak256 -> Keccak256 -> Keccak256
$cmax :: Keccak256 -> Keccak256 -> Keccak256
>= :: Keccak256 -> Keccak256 -> Bool
$c>= :: Keccak256 -> Keccak256 -> Bool
> :: Keccak256 -> Keccak256 -> Bool
$c> :: Keccak256 -> Keccak256 -> Bool
<= :: Keccak256 -> Keccak256 -> Bool
$c<= :: Keccak256 -> Keccak256 -> Bool
< :: Keccak256 -> Keccak256 -> Bool
$c< :: Keccak256 -> Keccak256 -> Bool
compare :: Keccak256 -> Keccak256 -> Ordering
$ccompare :: Keccak256 -> Keccak256 -> Ordering
$cp1Ord :: Eq Keccak256
Ord)
    deriving (Int -> Keccak256 -> ShowS
[Keccak256] -> ShowS
Keccak256 -> String
(Int -> Keccak256 -> ShowS)
-> (Keccak256 -> String)
-> ([Keccak256] -> ShowS)
-> Show Keccak256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Keccak256] -> ShowS
$cshowList :: [Keccak256] -> ShowS
show :: Keccak256 -> String
$cshow :: Keccak256 -> String
showsPrec :: Int -> Keccak256 -> ShowS
$cshowsPrec :: Int -> Keccak256 -> ShowS
Show) via B16ShortByteString

foreign import ccall unsafe "keccak.h keccak256_newctx"
    c_keccak256_newctx :: IO (Ptr ctx)

foreign import ccall unsafe "keccak.h keccak256_init"
    c_keccak256_init :: Ptr ctx -> IO Bool

foreign import ccall unsafe "keccak.h keccak256_update"
    c_keccak256_update :: Ptr ctx -> Ptr Word8 -> Int -> IO Bool

foreign import ccall unsafe "keccak.h keccak256_final"
    c_keccak256_final :: Ptr ctx -> Ptr Word8 -> IO Bool

foreign import ccall unsafe "keccak.h &keccak256_freectx"
    c_keccak256_freectx_ptr :: FunPtr (Ptr ctx -> IO ())

instance IncrementalHash Keccak256 where
    type Context Keccak256 = Ctx Keccak256
    update :: Context Keccak256 -> Ptr Word8 -> Int -> IO ()
update (Ctx ctx) Ptr Word8
ptr Int
n = ForeignPtr Void -> (Ptr Void -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO ()) -> IO ()) -> (Ptr Void -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Void
cptr -> do
        Bool
r <- Ptr Void -> Ptr Word8 -> Int -> IO Bool
forall ctx. Ptr ctx -> Ptr Word8 -> Int -> IO Bool
c_keccak256_update Ptr Void
cptr Ptr Word8
ptr Int
n
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest update failed"
    finalize :: Context Keccak256 -> IO Keccak256
finalize (Ctx ctx) = ForeignPtr Void -> (Ptr Void -> IO Keccak256) -> IO Keccak256
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO Keccak256) -> IO Keccak256)
-> (Ptr Void -> IO Keccak256) -> IO Keccak256
forall a b. (a -> b) -> a -> b
$ \Ptr Void
cptr -> do
        Int -> (Ptr Word8 -> IO Keccak256) -> IO Keccak256
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
32 ((Ptr Word8 -> IO Keccak256) -> IO Keccak256)
-> (Ptr Word8 -> IO Keccak256) -> IO Keccak256
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
dptr -> do
            Bool
r <- Ptr Void -> Ptr Word8 -> IO Bool
forall ctx. Ptr ctx -> Ptr Word8 -> IO Bool
c_keccak256_final Ptr Void
cptr Ptr Word8
dptr
            Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest finalization failed"
            ShortByteString -> Keccak256
Keccak256 (ShortByteString -> Keccak256)
-> IO ShortByteString -> IO Keccak256
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CStringLen -> IO ShortByteString
BS.packCStringLen (Ptr Word8 -> Ptr CChar
forall a b. Ptr a -> Ptr b
castPtr Ptr Word8
dptr, Int
32)
    {-# INLINE update #-}
    {-# INLINE finalize #-}


newKeccak256Ctx :: IO (Ctx Keccak256)
newKeccak256Ctx :: IO (Ctx Keccak256)
newKeccak256Ctx = (ForeignPtr Void -> Ctx Keccak256)
-> IO (ForeignPtr Void) -> IO (Ctx Keccak256)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ForeignPtr Void -> Ctx Keccak256
forall a. ForeignPtr Void -> Ctx a
Ctx (IO (ForeignPtr Void) -> IO (Ctx Keccak256))
-> IO (ForeignPtr Void) -> IO (Ctx Keccak256)
forall a b. (a -> b) -> a -> b
$ IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a. IO a -> IO a
mask_ (IO (ForeignPtr Void) -> IO (ForeignPtr Void))
-> IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Void
ptr <- IO (Ptr Void)
forall a. IO (Ptr a)
c_keccak256_newctx
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr Void
ptr Ptr Void -> Ptr Void -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Void
forall a. Ptr a
nullPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"failed to initialize context"
    FinalizerPtr Void -> Ptr Void -> IO (ForeignPtr Void)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr Void
forall a. FunPtr (Ptr a -> IO ())
c_keccak256_freectx_ptr Ptr Void
ptr
{-# INLINE newKeccak256Ctx #-}

instance Hash Keccak256 where
    initialize :: IO (Context Keccak256)
initialize = do
        Ctx ForeignPtr Void
ctx <- IO (Ctx Keccak256)
newKeccak256Ctx
        Bool
r <- ForeignPtr Void -> (Ptr Void -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO Bool) -> IO Bool)
-> (Ptr Void -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Void
ptr ->
            Ptr Void -> IO Bool
forall ctx. Ptr ctx -> IO Bool
c_keccak256_init Ptr Void
ptr
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest initialization failed"
        Ctx Keccak256 -> IO (Ctx Keccak256)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ctx Keccak256 -> IO (Ctx Keccak256))
-> Ctx Keccak256 -> IO (Ctx Keccak256)
forall a b. (a -> b) -> a -> b
$ ForeignPtr Void -> Ctx Keccak256
forall a. ForeignPtr Void -> Ctx a
Ctx ForeignPtr Void
ctx
    {-# INLINE initialize #-}

-- KECCAK-512

newtype Keccak512 = Keccak512 BS.ShortByteString
    deriving (Keccak512 -> Keccak512 -> Bool
(Keccak512 -> Keccak512 -> Bool)
-> (Keccak512 -> Keccak512 -> Bool) -> Eq Keccak512
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Keccak512 -> Keccak512 -> Bool
$c/= :: Keccak512 -> Keccak512 -> Bool
== :: Keccak512 -> Keccak512 -> Bool
$c== :: Keccak512 -> Keccak512 -> Bool
Eq, Eq Keccak512
Eq Keccak512
-> (Keccak512 -> Keccak512 -> Ordering)
-> (Keccak512 -> Keccak512 -> Bool)
-> (Keccak512 -> Keccak512 -> Bool)
-> (Keccak512 -> Keccak512 -> Bool)
-> (Keccak512 -> Keccak512 -> Bool)
-> (Keccak512 -> Keccak512 -> Keccak512)
-> (Keccak512 -> Keccak512 -> Keccak512)
-> Ord Keccak512
Keccak512 -> Keccak512 -> Bool
Keccak512 -> Keccak512 -> Ordering
Keccak512 -> Keccak512 -> Keccak512
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Keccak512 -> Keccak512 -> Keccak512
$cmin :: Keccak512 -> Keccak512 -> Keccak512
max :: Keccak512 -> Keccak512 -> Keccak512
$cmax :: Keccak512 -> Keccak512 -> Keccak512
>= :: Keccak512 -> Keccak512 -> Bool
$c>= :: Keccak512 -> Keccak512 -> Bool
> :: Keccak512 -> Keccak512 -> Bool
$c> :: Keccak512 -> Keccak512 -> Bool
<= :: Keccak512 -> Keccak512 -> Bool
$c<= :: Keccak512 -> Keccak512 -> Bool
< :: Keccak512 -> Keccak512 -> Bool
$c< :: Keccak512 -> Keccak512 -> Bool
compare :: Keccak512 -> Keccak512 -> Ordering
$ccompare :: Keccak512 -> Keccak512 -> Ordering
$cp1Ord :: Eq Keccak512
Ord)
    deriving (Int -> Keccak512 -> ShowS
[Keccak512] -> ShowS
Keccak512 -> String
(Int -> Keccak512 -> ShowS)
-> (Keccak512 -> String)
-> ([Keccak512] -> ShowS)
-> Show Keccak512
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Keccak512] -> ShowS
$cshowList :: [Keccak512] -> ShowS
show :: Keccak512 -> String
$cshow :: Keccak512 -> String
showsPrec :: Int -> Keccak512 -> ShowS
$cshowsPrec :: Int -> Keccak512 -> ShowS
Show) via B16ShortByteString

foreign import ccall unsafe "keccak.h keccak512_newctx"
    c_keccak512_newctx :: IO (Ptr ctx)

foreign import ccall unsafe "keccak.h keccak512_init"
    c_keccak512_init :: Ptr ctx -> IO Bool

foreign import ccall unsafe "keccak.h keccak512_update"
    c_keccak512_update :: Ptr ctx -> Ptr Word8 -> Int -> IO Bool

foreign import ccall unsafe "keccak.h keccak512_final"
    c_keccak512_final :: Ptr ctx -> Ptr Word8 -> IO Bool

foreign import ccall unsafe "keccak.h &keccak512_freectx"
    c_keccak512_freectx_ptr :: FunPtr (Ptr ctx -> IO ())

instance IncrementalHash Keccak512 where
    type Context Keccak512 = Ctx Keccak512
    update :: Context Keccak512 -> Ptr Word8 -> Int -> IO ()
update (Ctx ctx) Ptr Word8
ptr Int
n = ForeignPtr Void -> (Ptr Void -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO ()) -> IO ()) -> (Ptr Void -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Void
cptr -> do
        Bool
r <- Ptr Void -> Ptr Word8 -> Int -> IO Bool
forall ctx. Ptr ctx -> Ptr Word8 -> Int -> IO Bool
c_keccak512_update Ptr Void
cptr Ptr Word8
ptr Int
n
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest update failed"
    finalize :: Context Keccak512 -> IO Keccak512
finalize (Ctx ctx) = ForeignPtr Void -> (Ptr Void -> IO Keccak512) -> IO Keccak512
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO Keccak512) -> IO Keccak512)
-> (Ptr Void -> IO Keccak512) -> IO Keccak512
forall a b. (a -> b) -> a -> b
$ \Ptr Void
cptr -> do
        Int -> (Ptr Word8 -> IO Keccak512) -> IO Keccak512
forall a b. Int -> (Ptr a -> IO b) -> IO b
allocaBytes Int
64 ((Ptr Word8 -> IO Keccak512) -> IO Keccak512)
-> (Ptr Word8 -> IO Keccak512) -> IO Keccak512
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
dptr -> do
            Bool
r <- Ptr Void -> Ptr Word8 -> IO Bool
forall ctx. Ptr ctx -> Ptr Word8 -> IO Bool
c_keccak512_final Ptr Void
cptr Ptr Word8
dptr
            Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest finalization failed"
            ShortByteString -> Keccak512
Keccak512 (ShortByteString -> Keccak512)
-> IO ShortByteString -> IO Keccak512
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CStringLen -> IO ShortByteString
BS.packCStringLen (Ptr Word8 -> Ptr CChar
forall a b. Ptr a -> Ptr b
castPtr Ptr Word8
dptr, Int
64)
    {-# INLINE update #-}
    {-# INLINE finalize #-}


newKeccak512Ctx :: IO (Ctx Keccak512)
newKeccak512Ctx :: IO (Ctx Keccak512)
newKeccak512Ctx = (ForeignPtr Void -> Ctx Keccak512)
-> IO (ForeignPtr Void) -> IO (Ctx Keccak512)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ForeignPtr Void -> Ctx Keccak512
forall a. ForeignPtr Void -> Ctx a
Ctx (IO (ForeignPtr Void) -> IO (Ctx Keccak512))
-> IO (ForeignPtr Void) -> IO (Ctx Keccak512)
forall a b. (a -> b) -> a -> b
$ IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a. IO a -> IO a
mask_ (IO (ForeignPtr Void) -> IO (ForeignPtr Void))
-> IO (ForeignPtr Void) -> IO (ForeignPtr Void)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Void
ptr <- IO (Ptr Void)
forall a. IO (Ptr a)
c_keccak512_newctx
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Ptr Void
ptr Ptr Void -> Ptr Void -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Void
forall a. Ptr a
nullPtr) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"failed to initialize context"
    FinalizerPtr Void -> Ptr Void -> IO (ForeignPtr Void)
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr Void
forall a. FunPtr (Ptr a -> IO ())
c_keccak512_freectx_ptr Ptr Void
ptr
{-# INLINE newKeccak512Ctx #-}

instance Hash Keccak512 where
    initialize :: IO (Context Keccak512)
initialize = do
        Ctx ForeignPtr Void
ctx <- IO (Ctx Keccak512)
newKeccak512Ctx
        Bool
r <- ForeignPtr Void -> (Ptr Void -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr Void
ctx ((Ptr Void -> IO Bool) -> IO Bool)
-> (Ptr Void -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr Void
ptr ->
            Ptr Void -> IO Bool
forall ctx. Ptr ctx -> IO Bool
c_keccak512_init Ptr Void
ptr
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
r (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ OpenSslException -> IO ()
forall a e. Exception e => e -> a
throw (OpenSslException -> IO ()) -> OpenSslException -> IO ()
forall a b. (a -> b) -> a -> b
$ String -> OpenSslException
OpenSslException String
"digest initialization failed"
        Ctx Keccak512 -> IO (Ctx Keccak512)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ctx Keccak512 -> IO (Ctx Keccak512))
-> Ctx Keccak512 -> IO (Ctx Keccak512)
forall a b. (a -> b) -> a -> b
$ ForeignPtr Void -> Ctx Keccak512
forall a. ForeignPtr Void -> Ctx a
Ctx ForeignPtr Void
ctx
    {-# INLINE initialize #-}

-- -------------------------------------------------------------------------- --
-- Blake

-- $blake2
--
-- BLAKE2 is an improved version of BLAKE, which was submitted to the NIST SHA-3
-- algorithm competition. The BLAKE2s and BLAKE2b algorithms are described in
-- RFC 7693.
--
-- The following hash functions from the BLAKE2 family are supported in
-- openssl-3.0 (cf.
-- https://www.openssl.org/docs/man3.0/man3/EVP_blake2b512.html)
--
-- EVP_blake2b512, EVP_blake2s256
--
-- While the BLAKE2b and BLAKE2s algorithms supports a variable length digest,
-- this implementation outputs a digest of a fixed length (the maximum length
-- supported), which is 512-bits for BLAKE2b and 256-bits for BLAKE2s.
--
--

foreign import ccall unsafe "openssl/evp.h EVP_blake2b512"
    c_evp_blake2b512 :: Algorithm

foreign import ccall unsafe "openssl/evp.h EVP_blake2s256"
    c_evp_blake2s256 :: Algorithm

newtype Blake2b512 = Blake2b512 BS.ShortByteString
    deriving (Blake2b512 -> Blake2b512 -> Bool
(Blake2b512 -> Blake2b512 -> Bool)
-> (Blake2b512 -> Blake2b512 -> Bool) -> Eq Blake2b512
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Blake2b512 -> Blake2b512 -> Bool
$c/= :: Blake2b512 -> Blake2b512 -> Bool
== :: Blake2b512 -> Blake2b512 -> Bool
$c== :: Blake2b512 -> Blake2b512 -> Bool
Eq, Eq Blake2b512
Eq Blake2b512
-> (Blake2b512 -> Blake2b512 -> Ordering)
-> (Blake2b512 -> Blake2b512 -> Bool)
-> (Blake2b512 -> Blake2b512 -> Bool)
-> (Blake2b512 -> Blake2b512 -> Bool)
-> (Blake2b512 -> Blake2b512 -> Bool)
-> (Blake2b512 -> Blake2b512 -> Blake2b512)
-> (Blake2b512 -> Blake2b512 -> Blake2b512)
-> Ord Blake2b512
Blake2b512 -> Blake2b512 -> Bool
Blake2b512 -> Blake2b512 -> Ordering
Blake2b512 -> Blake2b512 -> Blake2b512
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Blake2b512 -> Blake2b512 -> Blake2b512
$cmin :: Blake2b512 -> Blake2b512 -> Blake2b512
max :: Blake2b512 -> Blake2b512 -> Blake2b512
$cmax :: Blake2b512 -> Blake2b512 -> Blake2b512
>= :: Blake2b512 -> Blake2b512 -> Bool
$c>= :: Blake2b512 -> Blake2b512 -> Bool
> :: Blake2b512 -> Blake2b512 -> Bool
$c> :: Blake2b512 -> Blake2b512 -> Bool
<= :: Blake2b512 -> Blake2b512 -> Bool
$c<= :: Blake2b512 -> Blake2b512 -> Bool
< :: Blake2b512 -> Blake2b512 -> Bool
$c< :: Blake2b512 -> Blake2b512 -> Bool
compare :: Blake2b512 -> Blake2b512 -> Ordering
$ccompare :: Blake2b512 -> Blake2b512 -> Ordering
$cp1Ord :: Eq Blake2b512
Ord)
    deriving (Int -> Blake2b512 -> ShowS
[Blake2b512] -> ShowS
Blake2b512 -> String
(Int -> Blake2b512 -> ShowS)
-> (Blake2b512 -> String)
-> ([Blake2b512] -> ShowS)
-> Show Blake2b512
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Blake2b512] -> ShowS
$cshowList :: [Blake2b512] -> ShowS
show :: Blake2b512 -> String
$cshow :: Blake2b512 -> String
showsPrec :: Int -> Blake2b512 -> ShowS
$cshowsPrec :: Int -> Blake2b512 -> ShowS
Show) via B16ShortByteString
    deriving (Context Blake2b512 -> IO Blake2b512
Context Blake2b512 -> Ptr Word8 -> Int -> IO ()
(Context Blake2b512 -> Ptr Word8 -> Int -> IO ())
-> (Context Blake2b512 -> IO Blake2b512)
-> IncrementalHash Blake2b512
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Blake2b512 -> IO Blake2b512
$cfinalize :: Context Blake2b512 -> IO Blake2b512
update :: Context Blake2b512 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Blake2b512 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Blake2b512)
IncrementalHash Blake2b512
IncrementalHash Blake2b512
-> IO (Context Blake2b512) -> Hash Blake2b512
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Blake2b512)
$cinitialize :: IO (Context Blake2b512)
$cp1Hash :: IncrementalHash Blake2b512
Hash) via (Digest Blake2b512)
instance OpenSslDigest Blake2b512 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_blake2b512

newtype Blake2s256 = Blake2s256 BS.ShortByteString
    deriving (Blake2s256 -> Blake2s256 -> Bool
(Blake2s256 -> Blake2s256 -> Bool)
-> (Blake2s256 -> Blake2s256 -> Bool) -> Eq Blake2s256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Blake2s256 -> Blake2s256 -> Bool
$c/= :: Blake2s256 -> Blake2s256 -> Bool
== :: Blake2s256 -> Blake2s256 -> Bool
$c== :: Blake2s256 -> Blake2s256 -> Bool
Eq, Eq Blake2s256
Eq Blake2s256
-> (Blake2s256 -> Blake2s256 -> Ordering)
-> (Blake2s256 -> Blake2s256 -> Bool)
-> (Blake2s256 -> Blake2s256 -> Bool)
-> (Blake2s256 -> Blake2s256 -> Bool)
-> (Blake2s256 -> Blake2s256 -> Bool)
-> (Blake2s256 -> Blake2s256 -> Blake2s256)
-> (Blake2s256 -> Blake2s256 -> Blake2s256)
-> Ord Blake2s256
Blake2s256 -> Blake2s256 -> Bool
Blake2s256 -> Blake2s256 -> Ordering
Blake2s256 -> Blake2s256 -> Blake2s256
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Blake2s256 -> Blake2s256 -> Blake2s256
$cmin :: Blake2s256 -> Blake2s256 -> Blake2s256
max :: Blake2s256 -> Blake2s256 -> Blake2s256
$cmax :: Blake2s256 -> Blake2s256 -> Blake2s256
>= :: Blake2s256 -> Blake2s256 -> Bool
$c>= :: Blake2s256 -> Blake2s256 -> Bool
> :: Blake2s256 -> Blake2s256 -> Bool
$c> :: Blake2s256 -> Blake2s256 -> Bool
<= :: Blake2s256 -> Blake2s256 -> Bool
$c<= :: Blake2s256 -> Blake2s256 -> Bool
< :: Blake2s256 -> Blake2s256 -> Bool
$c< :: Blake2s256 -> Blake2s256 -> Bool
compare :: Blake2s256 -> Blake2s256 -> Ordering
$ccompare :: Blake2s256 -> Blake2s256 -> Ordering
$cp1Ord :: Eq Blake2s256
Ord)
    deriving (Int -> Blake2s256 -> ShowS
[Blake2s256] -> ShowS
Blake2s256 -> String
(Int -> Blake2s256 -> ShowS)
-> (Blake2s256 -> String)
-> ([Blake2s256] -> ShowS)
-> Show Blake2s256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Blake2s256] -> ShowS
$cshowList :: [Blake2s256] -> ShowS
show :: Blake2s256 -> String
$cshow :: Blake2s256 -> String
showsPrec :: Int -> Blake2s256 -> ShowS
$cshowsPrec :: Int -> Blake2s256 -> ShowS
Show) via B16ShortByteString
    deriving (Context Blake2s256 -> IO Blake2s256
Context Blake2s256 -> Ptr Word8 -> Int -> IO ()
(Context Blake2s256 -> Ptr Word8 -> Int -> IO ())
-> (Context Blake2s256 -> IO Blake2s256)
-> IncrementalHash Blake2s256
forall a.
(Context a -> Ptr Word8 -> Int -> IO ())
-> (Context a -> IO a) -> IncrementalHash a
finalize :: Context Blake2s256 -> IO Blake2s256
$cfinalize :: Context Blake2s256 -> IO Blake2s256
update :: Context Blake2s256 -> Ptr Word8 -> Int -> IO ()
$cupdate :: Context Blake2s256 -> Ptr Word8 -> Int -> IO ()
IncrementalHash, IO (Context Blake2s256)
IncrementalHash Blake2s256
IncrementalHash Blake2s256
-> IO (Context Blake2s256) -> Hash Blake2s256
forall a. IncrementalHash a -> IO (Context a) -> Hash a
initialize :: IO (Context Blake2s256)
$cinitialize :: IO (Context Blake2s256)
$cp1Hash :: IncrementalHash Blake2s256
Hash) via (Digest Blake2s256)
instance OpenSslDigest Blake2s256 where algorithm :: Algorithm
algorithm = Algorithm
c_evp_blake2s256