-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Symmetrical block and stream ciphers.
--   
--   Symmetrical block and stream ciphers.
@package cryptocipher
@version 0.4.0



-- | <i>Deprecated: Use crypto-pubkey Crypto.PubKey.DSA</i>
module Crypto.Cipher.DSA
data Error

-- | signature is not valid r or s is not between the bound 0..q
InvalidSignature :: Error

-- | the random generator returns an error. give the opportunity to reseed
--   for example.
RandomGenFailure :: GenError -> Error

-- | Represent DSA parameters namely P, G, and Q.
type Params = (Integer, Integer, Integer)

-- | Represent a DSA signature namely R and S.
type Signature = (Integer, Integer)

-- | Represent a DSA public key.
data PublicKey :: *
PublicKey :: Params -> Integer -> PublicKey

-- | DSA parameters
public_params :: PublicKey -> Params

-- | DSA public Y
public_y :: PublicKey -> Integer

-- | Represent a DSA private key.
--   
--   Only x need to be secret. the DSA parameters are publicly shared with
--   the other side.
data PrivateKey :: *
PrivateKey :: Params -> Integer -> PrivateKey

-- | DSA parameters
private_params :: PrivateKey -> Params

-- | DSA private X
private_x :: PrivateKey -> Integer

-- | sign message using the private key.
sign :: CryptoRandomGen g => g -> (ByteString -> ByteString) -> PrivateKey -> ByteString -> Either GenError (Signature, g)

-- | verify a bytestring using the public key.
verify :: Signature -> (ByteString -> ByteString) -> PublicKey -> ByteString -> Either Error Bool
instance Show Error
instance Eq Error



-- | <i>Deprecated: Use crypto-pubkey Crypto.PubKey.DH</i>
module Crypto.Cipher.DH

-- | Represent Diffie Hellman parameters namely P (prime), and G
--   (generator).
type Params = (Integer, Integer)

-- | Represent Diffie Hellman public number Y.
data PublicNumber :: *

-- | Represent Diffie Hellman private number X.
data PrivateNumber :: *

-- | Represent Diffie Hellman shared secret.
data SharedKey :: *

-- | generate params from a specific generator (2 or 5 are common values)
--   we generate a safe prime (a prime number of the form 2p+1 where p is
--   also prime)
generateParams :: CryptoRandomGen g => g -> Int -> Integer -> Either GenError (Params, g)

-- | generate a private number with no specific property this number is
--   usually called X in DH text.
generatePrivate :: CryptoRandomGen g => g -> Int -> Either GenError (PrivateNumber, g)

-- | generate a public number that is for the other party benefits. this
--   number is usually called Y in DH text.
generatePublic :: Params -> PrivateNumber -> PublicNumber

-- | generate a shared key using our private number and the other party
--   public number
getShared :: Params -> PrivateNumber -> PublicNumber -> SharedKey



-- | <i>Deprecated: Use crypto-pubkey Crypto.PubKey.RSA</i>
module Crypto.Cipher.RSA
data Error

-- | the message to decrypt is not of the correct size (need to be ==
--   private_size)
MessageSizeIncorrect :: Error

-- | the message to encrypt is too long (&gt;= private_size - 11)
MessageTooLong :: Error

-- | the message decrypted doesn't have a PKCS15 structure (0 2 .. 0 msg)
MessageNotRecognized :: Error

-- | the signature generated through the hash is too long to process with
--   this key
SignatureTooLong :: Error

-- | the random generator returns an error. give the opportunity to reseed
--   for example.
RandomGenFailure :: GenError -> Error

-- | the whole key is probably not valid, since the message is bigger than
--   the key size
KeyInternalError :: Error

-- | Represent a RSA public key
data PublicKey :: *
PublicKey :: Int -> Integer -> Integer -> PublicKey

-- | size of key in bytes
public_size :: PublicKey -> Int

-- | public p*q
public_n :: PublicKey -> Integer

-- | public exponant e
public_e :: PublicKey -> Integer

-- | Represent a RSA private key.
--   
--   Only the pub, d fields are mandatory to fill.
--   
--   p, q, dP, dQ, qinv are by-product during RSA generation, but are
--   useful to record here to speed up massively the decrypt and sign
--   operation.
--   
--   implementations can leave optional fields to 0.
data PrivateKey :: *
PrivateKey :: PublicKey -> Integer -> Integer -> Integer -> Integer -> Integer -> Integer -> PrivateKey

-- | public part of a private key (size, n and e)
private_pub :: PrivateKey -> PublicKey

-- | private exponant d
private_d :: PrivateKey -> Integer

-- | p prime number
private_p :: PrivateKey -> Integer

-- | q prime number
private_q :: PrivateKey -> Integer

-- | d mod (p-1)
private_dP :: PrivateKey -> Integer

-- | d mod (q-1)
private_dQ :: PrivateKey -> Integer

-- | q^(-1) mod p
private_qinv :: PrivateKey -> Integer
type HashF = ByteString -> ByteString
type HashASN1 = ByteString

-- | generate a pair of (private, public) key of size in bytes.
generate :: CryptoRandomGen g => g -> Int -> Integer -> Either Error ((PublicKey, PrivateKey), g)

-- | decrypt message using the private key.
decrypt :: PrivateKey -> ByteString -> Either Error ByteString

-- | encrypt a bytestring using the public key and a CryptoRandomGen random
--   generator. - the message need to be smaller than the key size - 11
encrypt :: CryptoRandomGen g => g -> PublicKey -> ByteString -> Either Error (ByteString, g)

-- | sign message using private key, a hash and its ASN1 description
sign :: HashF -> HashASN1 -> PrivateKey -> ByteString -> Either Error ByteString

-- | verify message with the signed message
verify :: HashF -> HashASN1 -> PublicKey -> ByteString -> ByteString -> Either Error Bool
instance Show Error
instance Eq Error


-- | this only cover Camellia 128 bits for now, API will change once 192
--   and 256 mode are implemented too
module Crypto.Cipher.Camellia
data Key
Key :: Vector Word64 -> Vector Word64 -> Vector Word64 -> Key
k :: Key -> Vector Word64
kw :: Key -> Vector Word64
ke :: Key -> Vector Word64
initKey128 :: ByteString -> Either String Key

-- | encrypt with the key a bytestring and returns the encrypted bytestring
encrypt :: Key -> ByteString -> ByteString

-- | decrypt with the key a bytestring and returns the encrypted bytestring
decrypt :: Key -> ByteString -> ByteString
instance Show Word128
instance Eq Word128
instance Show Key


module Crypto.Cipher.Blowfish
data Blowfish
data Key
initKey :: ByteString -> Either String Key
encrypt :: Key -> ByteString -> ByteString
decrypt :: Key -> ByteString -> ByteString
instance Eq Key
instance Show Key
instance Serialize Key
instance Serialize Blowfish


module Crypto.Cipher.RC4


module Crypto.Cipher.AES