cryptonite-0.24: Cryptography Primitives sink

LicenseBSD-style
MaintainerVincent Hanquez <vincent@snarc.org>
Stabilityexperimental
Portabilityunknown
Safe HaskellNone
LanguageHaskell2010

Crypto.Hash.Algorithms

Contents

Description

Definitions of known hash algorithms

Synopsis

Documentation

class HashAlgorithm a Source #

Class representing hashing algorithms.

The interface presented here is update in place and lowlevel. the Hash module takes care of hidding the mutable interface properly.

Instances

HashAlgorithm Whirlpool Source # 
HashAlgorithm Tiger Source # 
HashAlgorithm Skein512_512 Source # 
HashAlgorithm Skein512_384 Source # 
HashAlgorithm Skein512_256 Source # 
HashAlgorithm Skein512_224 Source # 
HashAlgorithm Skein256_256 Source # 
HashAlgorithm Skein256_224 Source # 
HashAlgorithm SHA512t_256 Source # 
HashAlgorithm SHA512t_224 Source # 
HashAlgorithm SHA512 Source # 
HashAlgorithm SHA384 Source # 
HashAlgorithm SHA3_512 Source # 
HashAlgorithm SHA3_384 Source # 
HashAlgorithm SHA3_256 Source # 
HashAlgorithm SHA3_224 Source # 
HashAlgorithm SHA256 Source # 
HashAlgorithm SHA224 Source # 
HashAlgorithm SHA1 Source # 
HashAlgorithm RIPEMD160 Source # 
HashAlgorithm MD5 Source # 
HashAlgorithm MD4 Source # 
HashAlgorithm MD2 Source # 
HashAlgorithm Keccak_512 Source # 
HashAlgorithm Keccak_384 Source # 
HashAlgorithm Keccak_256 Source # 
HashAlgorithm Keccak_224 Source # 
HashAlgorithm Blake2sp_256 Source # 
HashAlgorithm Blake2sp_224 Source # 
HashAlgorithm Blake2s_256 Source # 
HashAlgorithm Blake2s_224 Source # 
HashAlgorithm Blake2s_160 Source # 
HashAlgorithm Blake2bp_512 Source # 
HashAlgorithm Blake2b_512 Source # 
HashAlgorithm Blake2b_384 Source # 
HashAlgorithm Blake2b_256 Source # 
HashAlgorithm Blake2b_224 Source # 
HashAlgorithm Blake2b_160 Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen) => HashAlgorithm (SHAKE256 bitlen) Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen) => HashAlgorithm (SHAKE128 bitlen) Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 512) => HashAlgorithm (Blake2bp bitlen) Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 256) => HashAlgorithm (Blake2sp bitlen) Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 512) => HashAlgorithm (Blake2b bitlen) Source # 
(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 256) => HashAlgorithm (Blake2s bitlen) Source # 

hash algorithms

data Blake2s_160 Source #

Blake2s (160 bits) cryptographic hash algorithm

Constructors

Blake2s_160 

Instances

Data Blake2s_160 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_160 -> c Blake2s_160 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_160 #

toConstr :: Blake2s_160 -> Constr #

dataTypeOf :: Blake2s_160 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_160) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_160) #

gmapT :: (forall b. Data b => b -> b) -> Blake2s_160 -> Blake2s_160 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_160 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_160 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2s_160 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_160 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 #

Show Blake2s_160 Source # 
HashAlgorithm Blake2s_160 Source # 
type HashBlockSize Blake2s_160 Source # 
type HashDigestSize Blake2s_160 Source # 
type HashInternalContextSize Blake2s_160 Source # 

data Blake2s_224 Source #

Blake2s (224 bits) cryptographic hash algorithm

Constructors

Blake2s_224 

Instances

Data Blake2s_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_224 -> c Blake2s_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_224 #

toConstr :: Blake2s_224 -> Constr #

dataTypeOf :: Blake2s_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_224) #

gmapT :: (forall b. Data b => b -> b) -> Blake2s_224 -> Blake2s_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2s_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 #

Show Blake2s_224 Source # 
HashAlgorithm Blake2s_224 Source # 
type HashBlockSize Blake2s_224 Source # 
type HashDigestSize Blake2s_224 Source # 
type HashInternalContextSize Blake2s_224 Source # 

data Blake2s_256 Source #

Blake2s (256 bits) cryptographic hash algorithm

Constructors

Blake2s_256 

Instances

Data Blake2s_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_256 -> c Blake2s_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_256 #

toConstr :: Blake2s_256 -> Constr #

dataTypeOf :: Blake2s_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_256) #

gmapT :: (forall b. Data b => b -> b) -> Blake2s_256 -> Blake2s_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2s_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 #

Show Blake2s_256 Source # 
HashAlgorithm Blake2s_256 Source # 
type HashBlockSize Blake2s_256 Source # 
type HashDigestSize Blake2s_256 Source # 
type HashInternalContextSize Blake2s_256 Source # 

data Blake2sp_224 Source #

Blake2sp (224 bits) cryptographic hash algorithm

Constructors

Blake2sp_224 

Instances

Data Blake2sp_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2sp_224 -> c Blake2sp_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2sp_224 #

toConstr :: Blake2sp_224 -> Constr #

dataTypeOf :: Blake2sp_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2sp_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2sp_224) #

gmapT :: (forall b. Data b => b -> b) -> Blake2sp_224 -> Blake2sp_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2sp_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2sp_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 #

Show Blake2sp_224 Source # 
HashAlgorithm Blake2sp_224 Source # 
type HashBlockSize Blake2sp_224 Source # 
type HashDigestSize Blake2sp_224 Source # 
type HashInternalContextSize Blake2sp_224 Source # 

data Blake2sp_256 Source #

Blake2sp (256 bits) cryptographic hash algorithm

Constructors

Blake2sp_256 

Instances

Data Blake2sp_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2sp_256 -> c Blake2sp_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2sp_256 #

toConstr :: Blake2sp_256 -> Constr #

dataTypeOf :: Blake2sp_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2sp_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2sp_256) #

gmapT :: (forall b. Data b => b -> b) -> Blake2sp_256 -> Blake2sp_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2sp_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2sp_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 #

Show Blake2sp_256 Source # 
HashAlgorithm Blake2sp_256 Source # 
type HashBlockSize Blake2sp_256 Source # 
type HashDigestSize Blake2sp_256 Source # 
type HashInternalContextSize Blake2sp_256 Source # 

data Blake2b_160 Source #

Blake2b (160 bits) cryptographic hash algorithm

Constructors

Blake2b_160 

Instances

Data Blake2b_160 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_160 -> c Blake2b_160 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_160 #

toConstr :: Blake2b_160 -> Constr #

dataTypeOf :: Blake2b_160 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_160) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_160) #

gmapT :: (forall b. Data b => b -> b) -> Blake2b_160 -> Blake2b_160 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_160 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_160 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2b_160 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_160 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 #

Show Blake2b_160 Source # 
HashAlgorithm Blake2b_160 Source # 
type HashBlockSize Blake2b_160 Source # 
type HashDigestSize Blake2b_160 Source # 
type HashInternalContextSize Blake2b_160 Source # 

data Blake2b_224 Source #

Blake2b (224 bits) cryptographic hash algorithm

Constructors

Blake2b_224 

Instances

Data Blake2b_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_224 -> c Blake2b_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_224 #

toConstr :: Blake2b_224 -> Constr #

dataTypeOf :: Blake2b_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_224) #

gmapT :: (forall b. Data b => b -> b) -> Blake2b_224 -> Blake2b_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2b_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 #

Show Blake2b_224 Source # 
HashAlgorithm Blake2b_224 Source # 
type HashBlockSize Blake2b_224 Source # 
type HashDigestSize Blake2b_224 Source # 
type HashInternalContextSize Blake2b_224 Source # 

data Blake2b_256 Source #

Blake2b (256 bits) cryptographic hash algorithm

Constructors

Blake2b_256 

Instances

Data Blake2b_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_256 -> c Blake2b_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_256 #

toConstr :: Blake2b_256 -> Constr #

dataTypeOf :: Blake2b_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_256) #

gmapT :: (forall b. Data b => b -> b) -> Blake2b_256 -> Blake2b_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2b_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 #

Show Blake2b_256 Source # 
HashAlgorithm Blake2b_256 Source # 
type HashBlockSize Blake2b_256 Source # 
type HashDigestSize Blake2b_256 Source # 
type HashInternalContextSize Blake2b_256 Source # 

data Blake2b_384 Source #

Blake2b (384 bits) cryptographic hash algorithm

Constructors

Blake2b_384 

Instances

Data Blake2b_384 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_384 -> c Blake2b_384 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_384 #

toConstr :: Blake2b_384 -> Constr #

dataTypeOf :: Blake2b_384 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_384) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_384) #

gmapT :: (forall b. Data b => b -> b) -> Blake2b_384 -> Blake2b_384 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_384 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_384 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2b_384 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_384 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 #

Show Blake2b_384 Source # 
HashAlgorithm Blake2b_384 Source # 
type HashBlockSize Blake2b_384 Source # 
type HashDigestSize Blake2b_384 Source # 
type HashInternalContextSize Blake2b_384 Source # 

data Blake2b_512 Source #

Blake2b (512 bits) cryptographic hash algorithm

Constructors

Blake2b_512 

Instances

Data Blake2b_512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_512 -> c Blake2b_512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_512 #

toConstr :: Blake2b_512 -> Constr #

dataTypeOf :: Blake2b_512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_512) #

gmapT :: (forall b. Data b => b -> b) -> Blake2b_512 -> Blake2b_512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2b_512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 #

Show Blake2b_512 Source # 
HashAlgorithm Blake2b_512 Source # 
type HashBlockSize Blake2b_512 Source # 
type HashDigestSize Blake2b_512 Source # 
type HashInternalContextSize Blake2b_512 Source # 

data Blake2bp_512 Source #

Blake2bp (512 bits) cryptographic hash algorithm

Constructors

Blake2bp_512 

Instances

Data Blake2bp_512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2bp_512 -> c Blake2bp_512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2bp_512 #

toConstr :: Blake2bp_512 -> Constr #

dataTypeOf :: Blake2bp_512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Blake2bp_512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2bp_512) #

gmapT :: (forall b. Data b => b -> b) -> Blake2bp_512 -> Blake2bp_512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2bp_512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2bp_512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Blake2bp_512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2bp_512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 #

Show Blake2bp_512 Source # 
HashAlgorithm Blake2bp_512 Source # 
type HashBlockSize Blake2bp_512 Source # 
type HashDigestSize Blake2bp_512 Source # 
type HashInternalContextSize Blake2bp_512 Source # 

data MD2 Source #

MD2 cryptographic hash algorithm

Constructors

MD2 

Instances

Data MD2 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD2 -> c MD2 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD2 #

toConstr :: MD2 -> Constr #

dataTypeOf :: MD2 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MD2) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD2) #

gmapT :: (forall b. Data b => b -> b) -> MD2 -> MD2 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD2 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD2 -> r #

gmapQ :: (forall d. Data d => d -> u) -> MD2 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MD2 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 #

Show MD2 Source # 

Methods

showsPrec :: Int -> MD2 -> ShowS #

show :: MD2 -> String #

showList :: [MD2] -> ShowS #

HashAlgorithm MD2 Source # 
HashAlgorithmASN1 MD2 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest MD2 -> out

type HashBlockSize MD2 Source # 
type HashBlockSize MD2 = 16
type HashDigestSize MD2 Source # 
type HashInternalContextSize MD2 Source # 

data MD4 Source #

MD4 cryptographic hash algorithm

Constructors

MD4 

Instances

Data MD4 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD4 -> c MD4 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD4 #

toConstr :: MD4 -> Constr #

dataTypeOf :: MD4 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MD4) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD4) #

gmapT :: (forall b. Data b => b -> b) -> MD4 -> MD4 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD4 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD4 -> r #

gmapQ :: (forall d. Data d => d -> u) -> MD4 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MD4 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 #

Show MD4 Source # 

Methods

showsPrec :: Int -> MD4 -> ShowS #

show :: MD4 -> String #

showList :: [MD4] -> ShowS #

HashAlgorithm MD4 Source # 
type HashBlockSize MD4 Source # 
type HashBlockSize MD4 = 64
type HashDigestSize MD4 Source # 
type HashInternalContextSize MD4 Source # 

data MD5 Source #

MD5 cryptographic hash algorithm

Constructors

MD5 

Instances

Data MD5 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD5 -> c MD5 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD5 #

toConstr :: MD5 -> Constr #

dataTypeOf :: MD5 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MD5) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD5) #

gmapT :: (forall b. Data b => b -> b) -> MD5 -> MD5 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD5 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD5 -> r #

gmapQ :: (forall d. Data d => d -> u) -> MD5 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MD5 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 #

Show MD5 Source # 

Methods

showsPrec :: Int -> MD5 -> ShowS #

show :: MD5 -> String #

showList :: [MD5] -> ShowS #

HashAlgorithm MD5 Source # 
HashAlgorithmASN1 MD5 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest MD5 -> out

type HashBlockSize MD5 Source # 
type HashBlockSize MD5 = 64
type HashDigestSize MD5 Source # 
type HashInternalContextSize MD5 Source # 

data SHA1 Source #

SHA1 cryptographic hash algorithm

Constructors

SHA1 

Instances

Data SHA1 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA1 -> c SHA1 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA1 #

toConstr :: SHA1 -> Constr #

dataTypeOf :: SHA1 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA1) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA1) #

gmapT :: (forall b. Data b => b -> b) -> SHA1 -> SHA1 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA1 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA1 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA1 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA1 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 #

Show SHA1 Source # 

Methods

showsPrec :: Int -> SHA1 -> ShowS #

show :: SHA1 -> String #

showList :: [SHA1] -> ShowS #

HashAlgorithm SHA1 Source # 
HashAlgorithmASN1 SHA1 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA1 -> out

type HashBlockSize SHA1 Source # 
type HashDigestSize SHA1 Source # 
type HashInternalContextSize SHA1 Source # 

data SHA224 Source #

SHA224 cryptographic hash algorithm

Constructors

SHA224 

Instances

Data SHA224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA224 -> c SHA224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA224 #

toConstr :: SHA224 -> Constr #

dataTypeOf :: SHA224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA224) #

gmapT :: (forall b. Data b => b -> b) -> SHA224 -> SHA224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 #

Show SHA224 Source # 
HashAlgorithm SHA224 Source # 
HashAlgorithmASN1 SHA224 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA224 -> out

type HashBlockSize SHA224 Source # 
type HashDigestSize SHA224 Source # 
type HashInternalContextSize SHA224 Source # 

data SHA256 Source #

SHA256 cryptographic hash algorithm

Constructors

SHA256 

Instances

Data SHA256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA256 -> c SHA256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA256 #

toConstr :: SHA256 -> Constr #

dataTypeOf :: SHA256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA256) #

gmapT :: (forall b. Data b => b -> b) -> SHA256 -> SHA256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 #

Show SHA256 Source # 
HashAlgorithm SHA256 Source # 
HashAlgorithmASN1 SHA256 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA256 -> out

type HashBlockSize SHA256 Source # 
type HashDigestSize SHA256 Source # 
type HashInternalContextSize SHA256 Source # 

data SHA384 Source #

SHA384 cryptographic hash algorithm

Constructors

SHA384 

Instances

Data SHA384 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA384 -> c SHA384 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA384 #

toConstr :: SHA384 -> Constr #

dataTypeOf :: SHA384 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA384) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA384) #

gmapT :: (forall b. Data b => b -> b) -> SHA384 -> SHA384 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA384 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA384 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA384 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA384 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 #

Show SHA384 Source # 
HashAlgorithm SHA384 Source # 
HashAlgorithmASN1 SHA384 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA384 -> out

type HashBlockSize SHA384 Source # 
type HashDigestSize SHA384 Source # 
type HashInternalContextSize SHA384 Source # 

data SHA512 Source #

SHA512 cryptographic hash algorithm

Constructors

SHA512 

Instances

Data SHA512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512 -> c SHA512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512 #

toConstr :: SHA512 -> Constr #

dataTypeOf :: SHA512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512) #

gmapT :: (forall b. Data b => b -> b) -> SHA512 -> SHA512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 #

Show SHA512 Source # 
HashAlgorithm SHA512 Source # 
HashAlgorithmASN1 SHA512 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA512 -> out

type HashBlockSize SHA512 Source # 
type HashDigestSize SHA512 Source # 
type HashInternalContextSize SHA512 Source # 

data SHA512t_224 Source #

SHA512t (224 bits) cryptographic hash algorithm

Constructors

SHA512t_224 

Instances

Data SHA512t_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512t_224 -> c SHA512t_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512t_224 #

toConstr :: SHA512t_224 -> Constr #

dataTypeOf :: SHA512t_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA512t_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512t_224) #

gmapT :: (forall b. Data b => b -> b) -> SHA512t_224 -> SHA512t_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA512t_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512t_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 #

Show SHA512t_224 Source # 
HashAlgorithm SHA512t_224 Source # 
HashAlgorithmASN1 SHA512t_224 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA512t_224 -> out

type HashBlockSize SHA512t_224 Source # 
type HashDigestSize SHA512t_224 Source # 
type HashInternalContextSize SHA512t_224 Source # 

data SHA512t_256 Source #

SHA512t (256 bits) cryptographic hash algorithm

Constructors

SHA512t_256 

Instances

Data SHA512t_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512t_256 -> c SHA512t_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512t_256 #

toConstr :: SHA512t_256 -> Constr #

dataTypeOf :: SHA512t_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA512t_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512t_256) #

gmapT :: (forall b. Data b => b -> b) -> SHA512t_256 -> SHA512t_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA512t_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512t_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 #

Show SHA512t_256 Source # 
HashAlgorithm SHA512t_256 Source # 
HashAlgorithmASN1 SHA512t_256 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest SHA512t_256 -> out

type HashBlockSize SHA512t_256 Source # 
type HashDigestSize SHA512t_256 Source # 
type HashInternalContextSize SHA512t_256 Source # 

data RIPEMD160 Source #

RIPEMD160 cryptographic hash algorithm

Constructors

RIPEMD160 

Instances

Data RIPEMD160 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RIPEMD160 -> c RIPEMD160 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RIPEMD160 #

toConstr :: RIPEMD160 -> Constr #

dataTypeOf :: RIPEMD160 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RIPEMD160) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RIPEMD160) #

gmapT :: (forall b. Data b => b -> b) -> RIPEMD160 -> RIPEMD160 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RIPEMD160 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RIPEMD160 -> r #

gmapQ :: (forall d. Data d => d -> u) -> RIPEMD160 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RIPEMD160 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 #

Show RIPEMD160 Source # 
HashAlgorithm RIPEMD160 Source # 
HashAlgorithmASN1 RIPEMD160 Source # 

Methods

hashDigestASN1 :: ByteArray out => Digest RIPEMD160 -> out

type HashBlockSize RIPEMD160 Source # 
type HashDigestSize RIPEMD160 Source # 
type HashInternalContextSize RIPEMD160 Source # 

data Tiger Source #

Tiger cryptographic hash algorithm

Constructors

Tiger 

Instances

Data Tiger Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tiger -> c Tiger #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tiger #

toConstr :: Tiger -> Constr #

dataTypeOf :: Tiger -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Tiger) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tiger) #

gmapT :: (forall b. Data b => b -> b) -> Tiger -> Tiger #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tiger -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tiger -> r #

gmapQ :: (forall d. Data d => d -> u) -> Tiger -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tiger -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger #

Show Tiger Source # 

Methods

showsPrec :: Int -> Tiger -> ShowS #

show :: Tiger -> String #

showList :: [Tiger] -> ShowS #

HashAlgorithm Tiger Source # 
type HashBlockSize Tiger Source # 
type HashDigestSize Tiger Source # 
type HashInternalContextSize Tiger Source # 

data Keccak_224 Source #

Keccak (224 bits) cryptographic hash algorithm

Constructors

Keccak_224 

Instances

Data Keccak_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_224 -> c Keccak_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_224 #

toConstr :: Keccak_224 -> Constr #

dataTypeOf :: Keccak_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_224) #

gmapT :: (forall b. Data b => b -> b) -> Keccak_224 -> Keccak_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Keccak_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 #

Show Keccak_224 Source # 
HashAlgorithm Keccak_224 Source # 
type HashBlockSize Keccak_224 Source # 
type HashDigestSize Keccak_224 Source # 
type HashInternalContextSize Keccak_224 Source # 

data Keccak_256 Source #

Keccak (256 bits) cryptographic hash algorithm

Constructors

Keccak_256 

Instances

Data Keccak_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_256 -> c Keccak_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_256 #

toConstr :: Keccak_256 -> Constr #

dataTypeOf :: Keccak_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_256) #

gmapT :: (forall b. Data b => b -> b) -> Keccak_256 -> Keccak_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Keccak_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 #

Show Keccak_256 Source # 
HashAlgorithm Keccak_256 Source # 
type HashBlockSize Keccak_256 Source # 
type HashDigestSize Keccak_256 Source # 
type HashInternalContextSize Keccak_256 Source # 

data Keccak_384 Source #

Keccak (384 bits) cryptographic hash algorithm

Constructors

Keccak_384 

Instances

Data Keccak_384 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_384 -> c Keccak_384 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_384 #

toConstr :: Keccak_384 -> Constr #

dataTypeOf :: Keccak_384 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_384) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_384) #

gmapT :: (forall b. Data b => b -> b) -> Keccak_384 -> Keccak_384 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_384 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_384 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Keccak_384 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_384 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 #

Show Keccak_384 Source # 
HashAlgorithm Keccak_384 Source # 
type HashBlockSize Keccak_384 Source # 
type HashDigestSize Keccak_384 Source # 
type HashInternalContextSize Keccak_384 Source # 

data Keccak_512 Source #

Keccak (512 bits) cryptographic hash algorithm

Constructors

Keccak_512 

Instances

Data Keccak_512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_512 -> c Keccak_512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_512 #

toConstr :: Keccak_512 -> Constr #

dataTypeOf :: Keccak_512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_512) #

gmapT :: (forall b. Data b => b -> b) -> Keccak_512 -> Keccak_512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Keccak_512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 #

Show Keccak_512 Source # 
HashAlgorithm Keccak_512 Source # 
type HashBlockSize Keccak_512 Source # 
type HashDigestSize Keccak_512 Source # 
type HashInternalContextSize Keccak_512 Source # 

data SHA3_224 Source #

SHA3 (224 bits) cryptographic hash algorithm

Constructors

SHA3_224 

Instances

Data SHA3_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_224 -> c SHA3_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_224 #

toConstr :: SHA3_224 -> Constr #

dataTypeOf :: SHA3_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_224) #

gmapT :: (forall b. Data b => b -> b) -> SHA3_224 -> SHA3_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA3_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 #

Show SHA3_224 Source # 
HashAlgorithm SHA3_224 Source # 
type HashBlockSize SHA3_224 Source # 
type HashDigestSize SHA3_224 Source # 
type HashInternalContextSize SHA3_224 Source # 

data SHA3_256 Source #

SHA3 (256 bits) cryptographic hash algorithm

Constructors

SHA3_256 

Instances

Data SHA3_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_256 -> c SHA3_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_256 #

toConstr :: SHA3_256 -> Constr #

dataTypeOf :: SHA3_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_256) #

gmapT :: (forall b. Data b => b -> b) -> SHA3_256 -> SHA3_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA3_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 #

Show SHA3_256 Source # 
HashAlgorithm SHA3_256 Source # 
type HashBlockSize SHA3_256 Source # 
type HashDigestSize SHA3_256 Source # 
type HashInternalContextSize SHA3_256 Source # 

data SHA3_384 Source #

SHA3 (384 bits) cryptographic hash algorithm

Constructors

SHA3_384 

Instances

Data SHA3_384 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_384 -> c SHA3_384 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_384 #

toConstr :: SHA3_384 -> Constr #

dataTypeOf :: SHA3_384 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_384) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_384) #

gmapT :: (forall b. Data b => b -> b) -> SHA3_384 -> SHA3_384 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_384 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_384 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA3_384 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_384 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 #

Show SHA3_384 Source # 
HashAlgorithm SHA3_384 Source # 
type HashBlockSize SHA3_384 Source # 
type HashDigestSize SHA3_384 Source # 
type HashInternalContextSize SHA3_384 Source # 

data SHA3_512 Source #

SHA3 (512 bits) cryptographic hash algorithm

Constructors

SHA3_512 

Instances

Data SHA3_512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_512 -> c SHA3_512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_512 #

toConstr :: SHA3_512 -> Constr #

dataTypeOf :: SHA3_512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_512) #

gmapT :: (forall b. Data b => b -> b) -> SHA3_512 -> SHA3_512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> SHA3_512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 #

Show SHA3_512 Source # 
HashAlgorithm SHA3_512 Source # 
type HashBlockSize SHA3_512 Source # 
type HashDigestSize SHA3_512 Source # 
type HashInternalContextSize SHA3_512 Source # 

data SHAKE128 bitlen Source #

SHAKE128 (128 bits) extendable output function. Supports an arbitrary digest size (multiple of 8 bits), to be specified as a type parameter of kind Nat.

Note: outputs from SHAKE128 n and SHAKE128 m for the same input are correlated (one being a prefix of the other). Results are unrelated to SHAKE256 results.

Constructors

SHAKE128 

Instances

Show (SHAKE128 bitlen) Source # 

Methods

showsPrec :: Int -> SHAKE128 bitlen -> ShowS #

show :: SHAKE128 bitlen -> String #

showList :: [SHAKE128 bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen) => HashAlgorithm (SHAKE128 bitlen) Source # 
type HashBlockSize (SHAKE128 bitlen) Source # 
type HashBlockSize (SHAKE128 bitlen) = 168
type HashDigestSize (SHAKE128 bitlen) Source # 
type HashDigestSize (SHAKE128 bitlen)
type HashInternalContextSize (SHAKE128 bitlen) Source # 
type HashInternalContextSize (SHAKE128 bitlen) = 376

data SHAKE256 bitlen Source #

SHAKE256 (256 bits) extendable output function. Supports an arbitrary digest size (multiple of 8 bits), to be specified as a type parameter of kind Nat.

Note: outputs from SHAKE256 n and SHAKE256 m for the same input are correlated (one being a prefix of the other). Results are unrelated to SHAKE128 results.

Constructors

SHAKE256 

Instances

Show (SHAKE256 bitlen) Source # 

Methods

showsPrec :: Int -> SHAKE256 bitlen -> ShowS #

show :: SHAKE256 bitlen -> String #

showList :: [SHAKE256 bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen) => HashAlgorithm (SHAKE256 bitlen) Source # 
type HashBlockSize (SHAKE256 bitlen) Source # 
type HashBlockSize (SHAKE256 bitlen) = 136
type HashDigestSize (SHAKE256 bitlen) Source # 
type HashDigestSize (SHAKE256 bitlen)
type HashInternalContextSize (SHAKE256 bitlen) Source # 
type HashInternalContextSize (SHAKE256 bitlen) = 344

data Blake2b bitlen Source #

Fast cryptographic hash.

It is especially known to target 64bits architectures.

Known supported digest sizes:

  • Blake2b 160
  • Blake2b 224
  • Blake2b 256
  • Blake2b 384
  • Blake2b 512

Constructors

Blake2b 

Instances

Show (Blake2b bitlen) Source # 

Methods

showsPrec :: Int -> Blake2b bitlen -> ShowS #

show :: Blake2b bitlen -> String #

showList :: [Blake2b bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 512) => HashAlgorithm (Blake2b bitlen) Source # 
type HashBlockSize (Blake2b bitlen) Source # 
type HashBlockSize (Blake2b bitlen) = 128
type HashDigestSize (Blake2b bitlen) Source # 
type HashDigestSize (Blake2b bitlen)
type HashInternalContextSize (Blake2b bitlen) Source # 
type HashInternalContextSize (Blake2b bitlen) = 361

data Blake2bp bitlen Source #

Constructors

Blake2bp 

Instances

Show (Blake2bp bitlen) Source # 

Methods

showsPrec :: Int -> Blake2bp bitlen -> ShowS #

show :: Blake2bp bitlen -> String #

showList :: [Blake2bp bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 512) => HashAlgorithm (Blake2bp bitlen) Source # 
type HashBlockSize (Blake2bp bitlen) Source # 
type HashBlockSize (Blake2bp bitlen) = 128
type HashDigestSize (Blake2bp bitlen) Source # 
type HashDigestSize (Blake2bp bitlen)
type HashInternalContextSize (Blake2bp bitlen) Source # 
type HashInternalContextSize (Blake2bp bitlen) = 2325

data Blake2s bitlen Source #

Fast and secure alternative to SHA1 and HMAC-SHA1

It is espacially known to target 32bits architectures.

known supported digest sizes:

  • Blake2s 160
  • Blake2s 224
  • Blake2s 256

Constructors

Blake2s 

Instances

Show (Blake2s bitlen) Source # 

Methods

showsPrec :: Int -> Blake2s bitlen -> ShowS #

show :: Blake2s bitlen -> String #

showList :: [Blake2s bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 256) => HashAlgorithm (Blake2s bitlen) Source # 
type HashBlockSize (Blake2s bitlen) Source # 
type HashBlockSize (Blake2s bitlen) = 64
type HashDigestSize (Blake2s bitlen) Source # 
type HashDigestSize (Blake2s bitlen)
type HashInternalContextSize (Blake2s bitlen) Source # 
type HashInternalContextSize (Blake2s bitlen) = 185

data Blake2sp bitlen Source #

Constructors

Blake2sp 

Instances

Show (Blake2sp bitlen) Source # 

Methods

showsPrec :: Int -> Blake2sp bitlen -> ShowS #

show :: Blake2sp bitlen -> String #

showList :: [Blake2sp bitlen] -> ShowS #

(IsDivisibleBy8 bitlen, KnownNat bitlen, IsAtLeast bitlen 8, IsAtMost bitlen 256) => HashAlgorithm (Blake2sp bitlen) Source # 
type HashBlockSize (Blake2sp bitlen) Source # 
type HashBlockSize (Blake2sp bitlen) = 64
type HashDigestSize (Blake2sp bitlen) Source # 
type HashDigestSize (Blake2sp bitlen)
type HashInternalContextSize (Blake2sp bitlen) Source # 
type HashInternalContextSize (Blake2sp bitlen) = 2185

data Skein256_224 Source #

Skein256 (224 bits) cryptographic hash algorithm

Constructors

Skein256_224 

Instances

Data Skein256_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein256_224 -> c Skein256_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein256_224 #

toConstr :: Skein256_224 -> Constr #

dataTypeOf :: Skein256_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein256_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein256_224) #

gmapT :: (forall b. Data b => b -> b) -> Skein256_224 -> Skein256_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein256_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein256_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 #

Show Skein256_224 Source # 
HashAlgorithm Skein256_224 Source # 
type HashBlockSize Skein256_224 Source # 
type HashDigestSize Skein256_224 Source # 
type HashInternalContextSize Skein256_224 Source # 

data Skein256_256 Source #

Skein256 (256 bits) cryptographic hash algorithm

Constructors

Skein256_256 

Instances

Data Skein256_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein256_256 -> c Skein256_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein256_256 #

toConstr :: Skein256_256 -> Constr #

dataTypeOf :: Skein256_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein256_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein256_256) #

gmapT :: (forall b. Data b => b -> b) -> Skein256_256 -> Skein256_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein256_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein256_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 #

Show Skein256_256 Source # 
HashAlgorithm Skein256_256 Source # 
type HashBlockSize Skein256_256 Source # 
type HashDigestSize Skein256_256 Source # 
type HashInternalContextSize Skein256_256 Source # 

data Skein512_224 Source #

Skein512 (224 bits) cryptographic hash algorithm

Constructors

Skein512_224 

Instances

Data Skein512_224 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_224 -> c Skein512_224 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_224 #

toConstr :: Skein512_224 -> Constr #

dataTypeOf :: Skein512_224 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_224) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_224) #

gmapT :: (forall b. Data b => b -> b) -> Skein512_224 -> Skein512_224 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_224 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_224 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein512_224 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_224 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 #

Show Skein512_224 Source # 
HashAlgorithm Skein512_224 Source # 
type HashBlockSize Skein512_224 Source # 
type HashDigestSize Skein512_224 Source # 
type HashInternalContextSize Skein512_224 Source # 

data Skein512_256 Source #

Skein512 (256 bits) cryptographic hash algorithm

Constructors

Skein512_256 

Instances

Data Skein512_256 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_256 -> c Skein512_256 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_256 #

toConstr :: Skein512_256 -> Constr #

dataTypeOf :: Skein512_256 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_256) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_256) #

gmapT :: (forall b. Data b => b -> b) -> Skein512_256 -> Skein512_256 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_256 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_256 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein512_256 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_256 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 #

Show Skein512_256 Source # 
HashAlgorithm Skein512_256 Source # 
type HashBlockSize Skein512_256 Source # 
type HashDigestSize Skein512_256 Source # 
type HashInternalContextSize Skein512_256 Source # 

data Skein512_384 Source #

Skein512 (384 bits) cryptographic hash algorithm

Constructors

Skein512_384 

Instances

Data Skein512_384 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_384 -> c Skein512_384 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_384 #

toConstr :: Skein512_384 -> Constr #

dataTypeOf :: Skein512_384 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_384) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_384) #

gmapT :: (forall b. Data b => b -> b) -> Skein512_384 -> Skein512_384 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_384 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_384 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein512_384 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_384 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 #

Show Skein512_384 Source # 
HashAlgorithm Skein512_384 Source # 
type HashBlockSize Skein512_384 Source # 
type HashDigestSize Skein512_384 Source # 
type HashInternalContextSize Skein512_384 Source # 

data Skein512_512 Source #

Skein512 (512 bits) cryptographic hash algorithm

Constructors

Skein512_512 

Instances

Data Skein512_512 Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_512 -> c Skein512_512 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_512 #

toConstr :: Skein512_512 -> Constr #

dataTypeOf :: Skein512_512 -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_512) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_512) #

gmapT :: (forall b. Data b => b -> b) -> Skein512_512 -> Skein512_512 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_512 -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_512 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Skein512_512 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_512 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 #

Show Skein512_512 Source # 
HashAlgorithm Skein512_512 Source # 
type HashBlockSize Skein512_512 Source # 
type HashDigestSize Skein512_512 Source # 
type HashInternalContextSize Skein512_512 Source # 

data Whirlpool Source #

Whirlpool cryptographic hash algorithm

Constructors

Whirlpool 

Instances

Data Whirlpool Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Whirlpool -> c Whirlpool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Whirlpool #

toConstr :: Whirlpool -> Constr #

dataTypeOf :: Whirlpool -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Whirlpool) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Whirlpool) #

gmapT :: (forall b. Data b => b -> b) -> Whirlpool -> Whirlpool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Whirlpool -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Whirlpool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Whirlpool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Whirlpool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool #

Show Whirlpool Source # 
HashAlgorithm Whirlpool Source # 
type HashBlockSize Whirlpool Source # 
type HashDigestSize Whirlpool Source # 
type HashInternalContextSize Whirlpool Source #