    -- |
    -- Module      : Crypto.PubKey.DSA
    -- License     : BSD-style
    -- Maintainer  : Vincent Hanquez <vincent@snarc.org>
    -- Stability   : experimental
    -- Portability : Good
    --
    -- An implementation of the Digital Signature Algorithm (DSA)
    {-# LANGUAGE DeriveDataTypeable #-}
    module Crypto.PubKey.DSA
        ( Params(..)
        , Signature(..)
        , PublicKey(..)
        , PrivateKey(..)
        , PublicNumber
        , PrivateNumber
        -- * Generation
        , generatePrivate
        , calculatePublic
        -- * Signature primitive
        , sign
        , signWith
        -- * Verification primitive
        , verify
        -- * Key pair
        , KeyPair(..)
        , toPublicKey
        , toPrivateKey
        ) where

    import Data.Data
    import Data.Maybe

    import Crypto.Number.ModArithmetic (expFast, expSafe, inverse)
    import Crypto.Number.Generate
    import Crypto.Internal.ByteArray (ByteArrayAccess)
    import Crypto.Internal.Imports
    import Crypto.Hash
    import Crypto.PubKey.Internal (dsaTruncHash)
    import Crypto.Random.Types

    -- | DSA Public Number, usually embedded in DSA Public Key
    type PublicNumber = Integer

    -- | DSA Private Number, usually embedded in DSA Private Key
    type PrivateNumber = Integer

    -- | Represent DSA parameters namely P, G, and Q.
    data Params = Params
        { Params -> Integer
    params_p :: Integer -- ^ DSA p
        , Params -> Integer
    params_g :: Integer -- ^ DSA g
        , Params -> Integer
    params_q :: Integer -- ^ DSA q
        } deriving (Int -> Params -> ShowS
    [Params] -> ShowS
    Params -> String
    (Int -> Params -> ShowS)
    -> (Params -> String) -> ([Params] -> ShowS) -> Show Params
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Params -> ShowS
    showsPrec :: Int -> Params -> ShowS
    $cshow :: Params -> String
    show :: Params -> String
    $cshowList :: [Params] -> ShowS
    showList :: [Params] -> ShowS
    Show,ReadPrec [Params]
    ReadPrec Params
    Int -> ReadS Params
    ReadS [Params]
    (Int -> ReadS Params)
    -> ReadS [Params]
    -> ReadPrec Params
    -> ReadPrec [Params]
    -> Read Params
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Params
    readsPrec :: Int -> ReadS Params
    $creadList :: ReadS [Params]
    readList :: ReadS [Params]
    $creadPrec :: ReadPrec Params
    readPrec :: ReadPrec Params
    $creadListPrec :: ReadPrec [Params]
    readListPrec :: ReadPrec [Params]
    Read,Params -> Params -> Bool
    (Params -> Params -> Bool)
    -> (Params -> Params -> Bool) -> Eq Params
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Params -> Params -> Bool
    == :: Params -> Params -> Bool
    $c/= :: Params -> Params -> Bool
    /= :: Params -> Params -> Bool
    Eq,Typeable Params
    Typeable Params =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Params -> c Params)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Params)
    -> (Params -> Constr)
    -> (Params -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Params))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Params))
    -> ((forall b. Data b => b -> b) -> Params -> Params)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Params -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Params -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Params -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Params -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Params -> m Params)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Params -> m Params)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Params -> m Params)
    -> Data Params
    Params -> Constr
    Params -> DataType
    (forall b. Data b => b -> b) -> Params -> Params
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Params -> u
    forall u. (forall d. Data d => d -> u) -> Params -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Params
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Params -> c Params
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Params)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Params)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Params -> c Params
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Params -> c Params
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Params
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Params
    $ctoConstr :: Params -> Constr
    toConstr :: Params -> Constr
    $cdataTypeOf :: Params -> DataType
    dataTypeOf :: Params -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Params)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Params)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Params)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Params)
    $cgmapT :: (forall b. Data b => b -> b) -> Params -> Params
    gmapT :: (forall b. Data b => b -> b) -> Params -> Params
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Params -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Params -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Params -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Params -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Params -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Params -> m Params
    Data)

    instance NFData Params where
        rnf :: Params -> ()
    rnf (Params Integer
    p Integer
    g Integer
    q) = Integer
    p Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Integer
    g Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Integer
    q Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Represent a DSA signature namely R and S.
    data Signature = Signature
        { Signature -> Integer
    sign_r :: Integer -- ^ DSA r
        , Signature -> Integer
    sign_s :: Integer -- ^ DSA s
        } deriving (Int -> Signature -> ShowS
    [Signature] -> ShowS
    Signature -> String
    (Int -> Signature -> ShowS)
    -> (Signature -> String)
    -> ([Signature] -> ShowS)
    -> Show Signature
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Signature -> ShowS
    showsPrec :: Int -> Signature -> ShowS
    $cshow :: Signature -> String
    show :: Signature -> String
    $cshowList :: [Signature] -> ShowS
    showList :: [Signature] -> ShowS
    Show,ReadPrec [Signature]
    ReadPrec Signature
    Int -> ReadS Signature
    ReadS [Signature]
    (Int -> ReadS Signature)
    -> ReadS [Signature]
    -> ReadPrec Signature
    -> ReadPrec [Signature]
    -> Read Signature
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Signature
    readsPrec :: Int -> ReadS Signature
    $creadList :: ReadS [Signature]
    readList :: ReadS [Signature]
    $creadPrec :: ReadPrec Signature
    readPrec :: ReadPrec Signature
    $creadListPrec :: ReadPrec [Signature]
    readListPrec :: ReadPrec [Signature]
    Read,Signature -> Signature -> Bool
    (Signature -> Signature -> Bool)
    -> (Signature -> Signature -> Bool) -> Eq Signature
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Signature -> Signature -> Bool
    == :: Signature -> Signature -> Bool
    $c/= :: Signature -> Signature -> Bool
    /= :: Signature -> Signature -> Bool
    Eq,Typeable Signature
    Typeable Signature =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Signature -> c Signature)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Signature)
    -> (Signature -> Constr)
    -> (Signature -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Signature))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature))
    -> ((forall b. Data b => b -> b) -> Signature -> Signature)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Signature -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Signature -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Signature -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Signature -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Signature -> m Signature)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Signature -> m Signature)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Signature -> m Signature)
    -> Data Signature
    Signature -> Constr
    Signature -> DataType
    (forall b. Data b => b -> b) -> Signature -> Signature
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Signature -> u
    forall u. (forall d. Data d => d -> u) -> Signature -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Signature
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Signature -> c Signature
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Signature)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Signature -> c Signature
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Signature -> c Signature
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Signature
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Signature
    $ctoConstr :: Signature -> Constr
    toConstr :: Signature -> Constr
    $cdataTypeOf :: Signature -> DataType
    dataTypeOf :: Signature -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Signature)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Signature)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
    $cgmapT :: (forall b. Data b => b -> b) -> Signature -> Signature
    gmapT :: (forall b. Data b => b -> b) -> Signature -> Signature
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Signature -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Signature -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Signature -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Signature -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature
    Data)

    instance NFData Signature where
        rnf :: Signature -> ()
    rnf (Signature Integer
    r Integer
    s) = Integer
    r Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Integer
    s Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Represent a DSA public key.
    data PublicKey = PublicKey
        { PublicKey -> Params
    public_params :: Params       -- ^ DSA parameters
        , PublicKey -> Integer
    public_y      :: PublicNumber -- ^ DSA public Y
        } deriving (Int -> PublicKey -> ShowS
    [PublicKey] -> ShowS
    PublicKey -> String
    (Int -> PublicKey -> ShowS)
    -> (PublicKey -> String)
    -> ([PublicKey] -> ShowS)
    -> Show PublicKey
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PublicKey -> ShowS
    showsPrec :: Int -> PublicKey -> ShowS
    $cshow :: PublicKey -> String
    show :: PublicKey -> String
    $cshowList :: [PublicKey] -> ShowS
    showList :: [PublicKey] -> ShowS
    Show,ReadPrec [PublicKey]
    ReadPrec PublicKey
    Int -> ReadS PublicKey
    ReadS [PublicKey]
    (Int -> ReadS PublicKey)
    -> ReadS [PublicKey]
    -> ReadPrec PublicKey
    -> ReadPrec [PublicKey]
    -> Read PublicKey
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS PublicKey
    readsPrec :: Int -> ReadS PublicKey
    $creadList :: ReadS [PublicKey]
    readList :: ReadS [PublicKey]
    $creadPrec :: ReadPrec PublicKey
    readPrec :: ReadPrec PublicKey
    $creadListPrec :: ReadPrec [PublicKey]
    readListPrec :: ReadPrec [PublicKey]
    Read,PublicKey -> PublicKey -> Bool
    (PublicKey -> PublicKey -> Bool)
    -> (PublicKey -> PublicKey -> Bool) -> Eq PublicKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PublicKey -> PublicKey -> Bool
    == :: PublicKey -> PublicKey -> Bool
    $c/= :: PublicKey -> PublicKey -> Bool
    /= :: PublicKey -> PublicKey -> Bool
    Eq,Typeable PublicKey
    Typeable PublicKey =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> PublicKey -> c PublicKey)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PublicKey)
    -> (PublicKey -> Constr)
    -> (PublicKey -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PublicKey))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey))
    -> ((forall b. Data b => b -> b) -> PublicKey -> PublicKey)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PublicKey -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PublicKey -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PublicKey -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PublicKey -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
    -> Data PublicKey
    PublicKey -> Constr
    PublicKey -> DataType
    (forall b. Data b => b -> b) -> PublicKey -> PublicKey
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> PublicKey -> u
    forall u. (forall d. Data d => d -> u) -> PublicKey -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PublicKey
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PublicKey -> c PublicKey
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PublicKey)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PublicKey -> c PublicKey
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PublicKey -> c PublicKey
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PublicKey
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PublicKey
    $ctoConstr :: PublicKey -> Constr
    toConstr :: PublicKey -> Constr
    $cdataTypeOf :: PublicKey -> DataType
    dataTypeOf :: PublicKey -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PublicKey)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PublicKey)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
    $cgmapT :: (forall b. Data b => b -> b) -> PublicKey -> PublicKey
    gmapT :: (forall b. Data b => b -> b) -> PublicKey -> PublicKey
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PublicKey -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PublicKey -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PublicKey -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PublicKey -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
    Data)

    instance NFData PublicKey where
        rnf :: PublicKey -> ()
    rnf (PublicKey Params
    params Integer
    y) = Integer
    y Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Params
    params Params -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Represent a DSA private key.
    --
    -- Only x need to be secret.
    -- the DSA parameters are publicly shared with the other side.
    data PrivateKey = PrivateKey
        { PrivateKey -> Params
    private_params :: Params        -- ^ DSA parameters
        , PrivateKey -> Integer
    private_x      :: PrivateNumber -- ^ DSA private X
        } deriving (Int -> PrivateKey -> ShowS
    [PrivateKey] -> ShowS
    PrivateKey -> String
    (Int -> PrivateKey -> ShowS)
    -> (PrivateKey -> String)
    -> ([PrivateKey] -> ShowS)
    -> Show PrivateKey
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PrivateKey -> ShowS
    showsPrec :: Int -> PrivateKey -> ShowS
    $cshow :: PrivateKey -> String
    show :: PrivateKey -> String
    $cshowList :: [PrivateKey] -> ShowS
    showList :: [PrivateKey] -> ShowS
    Show,ReadPrec [PrivateKey]
    ReadPrec PrivateKey
    Int -> ReadS PrivateKey
    ReadS [PrivateKey]
    (Int -> ReadS PrivateKey)
    -> ReadS [PrivateKey]
    -> ReadPrec PrivateKey
    -> ReadPrec [PrivateKey]
    -> Read PrivateKey
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS PrivateKey
    readsPrec :: Int -> ReadS PrivateKey
    $creadList :: ReadS [PrivateKey]
    readList :: ReadS [PrivateKey]
    $creadPrec :: ReadPrec PrivateKey
    readPrec :: ReadPrec PrivateKey
    $creadListPrec :: ReadPrec [PrivateKey]
    readListPrec :: ReadPrec [PrivateKey]
    Read,PrivateKey -> PrivateKey -> Bool
    (PrivateKey -> PrivateKey -> Bool)
    -> (PrivateKey -> PrivateKey -> Bool) -> Eq PrivateKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrivateKey -> PrivateKey -> Bool
    == :: PrivateKey -> PrivateKey -> Bool
    $c/= :: PrivateKey -> PrivateKey -> Bool
    /= :: PrivateKey -> PrivateKey -> Bool
    Eq,Typeable PrivateKey
    Typeable PrivateKey =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> PrivateKey -> c PrivateKey)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PrivateKey)
    -> (PrivateKey -> Constr)
    -> (PrivateKey -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PrivateKey))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c PrivateKey))
    -> ((forall b. Data b => b -> b) -> PrivateKey -> PrivateKey)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PrivateKey -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> PrivateKey -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey)
    -> Data PrivateKey
    PrivateKey -> Constr
    PrivateKey -> DataType
    (forall b. Data b => b -> b) -> PrivateKey -> PrivateKey
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> PrivateKey -> u
    forall u. (forall d. Data d => d -> u) -> PrivateKey -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrivateKey
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrivateKey -> c PrivateKey
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrivateKey)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivateKey)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrivateKey -> c PrivateKey
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrivateKey -> c PrivateKey
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrivateKey
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrivateKey
    $ctoConstr :: PrivateKey -> Constr
    toConstr :: PrivateKey -> Constr
    $cdataTypeOf :: PrivateKey -> DataType
    dataTypeOf :: PrivateKey -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrivateKey)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrivateKey)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivateKey)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivateKey)
    $cgmapT :: (forall b. Data b => b -> b) -> PrivateKey -> PrivateKey
    gmapT :: (forall b. Data b => b -> b) -> PrivateKey -> PrivateKey
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrivateKey -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrivateKey -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PrivateKey -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrivateKey -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrivateKey -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrivateKey -> m PrivateKey
    Data)

    instance NFData PrivateKey where
        rnf :: PrivateKey -> ()
    rnf (PrivateKey Params
    params Integer
    x) = Integer
    x Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Params
    params Params -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Represent a DSA key pair
    data KeyPair = KeyPair Params PublicNumber PrivateNumber
        deriving (Int -> KeyPair -> ShowS
    [KeyPair] -> ShowS
    KeyPair -> String
    (Int -> KeyPair -> ShowS)
    -> (KeyPair -> String) -> ([KeyPair] -> ShowS) -> Show KeyPair
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> KeyPair -> ShowS
    showsPrec :: Int -> KeyPair -> ShowS
    $cshow :: KeyPair -> String
    show :: KeyPair -> String
    $cshowList :: [KeyPair] -> ShowS
    showList :: [KeyPair] -> ShowS
    Show,ReadPrec [KeyPair]
    ReadPrec KeyPair
    Int -> ReadS KeyPair
    ReadS [KeyPair]
    (Int -> ReadS KeyPair)
    -> ReadS [KeyPair]
    -> ReadPrec KeyPair
    -> ReadPrec [KeyPair]
    -> Read KeyPair
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS KeyPair
    readsPrec :: Int -> ReadS KeyPair
    $creadList :: ReadS [KeyPair]
    readList :: ReadS [KeyPair]
    $creadPrec :: ReadPrec KeyPair
    readPrec :: ReadPrec KeyPair
    $creadListPrec :: ReadPrec [KeyPair]
    readListPrec :: ReadPrec [KeyPair]
    Read,KeyPair -> KeyPair -> Bool
    (KeyPair -> KeyPair -> Bool)
    -> (KeyPair -> KeyPair -> Bool) -> Eq KeyPair
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: KeyPair -> KeyPair -> Bool
    == :: KeyPair -> KeyPair -> Bool
    $c/= :: KeyPair -> KeyPair -> Bool
    /= :: KeyPair -> KeyPair -> Bool
    Eq,Typeable KeyPair
    Typeable KeyPair =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> KeyPair -> c KeyPair)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c KeyPair)
    -> (KeyPair -> Constr)
    -> (KeyPair -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c KeyPair))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyPair))
    -> ((forall b. Data b => b -> b) -> KeyPair -> KeyPair)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> KeyPair -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> KeyPair -> r)
    -> (forall u. (forall d. Data d => d -> u) -> KeyPair -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> KeyPair -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair)
    -> Data KeyPair
    KeyPair -> Constr
    KeyPair -> DataType
    (forall b. Data b => b -> b) -> KeyPair -> KeyPair
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> KeyPair -> u
    forall u. (forall d. Data d => d -> u) -> KeyPair -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyPair
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyPair -> c KeyPair
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyPair)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyPair)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyPair -> c KeyPair
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyPair -> c KeyPair
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyPair
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyPair
    $ctoConstr :: KeyPair -> Constr
    toConstr :: KeyPair -> Constr
    $cdataTypeOf :: KeyPair -> DataType
    dataTypeOf :: KeyPair -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyPair)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyPair)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyPair)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyPair)
    $cgmapT :: (forall b. Data b => b -> b) -> KeyPair -> KeyPair
    gmapT :: (forall b. Data b => b -> b) -> KeyPair -> KeyPair
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyPair -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> KeyPair -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyPair -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyPair -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyPair -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyPair -> m KeyPair
    Data)

    instance NFData KeyPair where
        rnf :: KeyPair -> ()
    rnf (KeyPair Params
    params Integer
    y Integer
    x) = Integer
    x Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Integer
    y Integer -> () -> ()
    forall a b. a -> b -> b
    `seq` Params
    params Params -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    -- | Public key of a DSA Key pair
    toPublicKey :: KeyPair -> PublicKey
    toPublicKey :: KeyPair -> PublicKey
    toPublicKey (KeyPair Params
    params Integer
    pub Integer
    _) = Params -> Integer -> PublicKey
    PublicKey Params
    params Integer
    pub

    -- | Private key of a DSA Key pair
    toPrivateKey :: KeyPair -> PrivateKey
    toPrivateKey :: KeyPair -> PrivateKey
    toPrivateKey (KeyPair Params
    params Integer
    _ Integer
    priv) = Params -> Integer -> PrivateKey
    PrivateKey Params
    params Integer
    priv

    -- | generate a private number with no specific property
    -- this number is usually called X in DSA text.
    generatePrivate :: MonadRandom m => Params -> m PrivateNumber
    generatePrivate :: forall (m :: * -> *). MonadRandom m => Params -> m Integer
    generatePrivate (Params Integer
    _ Integer
    _ Integer
    q) = Integer -> m Integer
    forall (m :: * -> *). MonadRandom m => Integer -> m Integer
    generateMax Integer
    q

    -- | Calculate the public number from the parameters and the private key
    calculatePublic :: Params -> PrivateNumber -> PublicNumber
    calculatePublic :: Params -> Integer -> Integer
    calculatePublic (Params Integer
    p Integer
    g Integer
    _) Integer
    x = Integer -> Integer -> Integer -> Integer
    expSafe Integer
    g Integer
    x Integer
    p

    -- | sign message using the private key and an explicit k number.
    signWith :: (ByteArrayAccess msg, HashAlgorithm hash)
             => Integer         -- ^ k random number
             -> PrivateKey      -- ^ private key
             -> hash            -- ^ hash function
             -> msg             -- ^ message to sign
             -> Maybe Signature
    signWith :: forall msg hash.
    (ByteArrayAccess msg, HashAlgorithm hash) =>
    Integer -> PrivateKey -> hash -> msg -> Maybe Signature
    signWith Integer
    k PrivateKey
    pk hash
    hashAlg msg
    msg
        | Integer
    r Integer -> Integer -> Bool
    forall a. Eq a => a -> a -> Bool
    == Integer
    0 Bool -> Bool -> Bool
    || Integer
    s Integer -> Integer -> Bool
    forall a. Eq a => a -> a -> Bool
    == Integer
    0  = Maybe Signature
    forall a. Maybe a
    Nothing
        | Bool
    otherwise         = Signature -> Maybe Signature
    forall a. a -> Maybe a
    Just (Signature -> Maybe Signature) -> Signature -> Maybe Signature
    forall a b. (a -> b) -> a -> b
    $ Integer -> Integer -> Signature
    Signature Integer
    r Integer
    s
        where -- parameters
              (Params Integer
    p Integer
    g Integer
    q) = PrivateKey -> Params
    private_params PrivateKey
    pk
              x :: Integer
    x              = PrivateKey -> Integer
    private_x PrivateKey
    pk
              -- compute r,s
              kInv :: Integer
    kInv      = Maybe Integer -> Integer
    forall a. HasCallStack => Maybe a -> a
    fromJust (Maybe Integer -> Integer) -> Maybe Integer -> Integer
    forall a b. (a -> b) -> a -> b
    $ Integer -> Integer -> Maybe Integer
    inverse Integer
    k Integer
    q
              hm :: Integer
    hm        = hash -> msg -> Integer -> Integer
    forall msg hash.
    (ByteArrayAccess msg, HashAlgorithm hash) =>
    hash -> msg -> Integer -> Integer
    dsaTruncHash hash
    hashAlg msg
    msg Integer
    q
              r :: Integer
    r         = Integer -> Integer -> Integer -> Integer
    expSafe Integer
    g Integer
    k Integer
    p Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    q
              s :: Integer
    s         = (Integer
    kInv Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    * (Integer
    hm Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    + Integer
    x Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    * Integer
    r)) Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    q

    -- | sign message using the private key.
    sign :: (ByteArrayAccess msg, HashAlgorithm hash, MonadRandom m) => PrivateKey -> hash -> msg -> m Signature
    sign :: forall msg hash (m :: * -> *).
    (ByteArrayAccess msg, HashAlgorithm hash, MonadRandom m) =>
    PrivateKey -> hash -> msg -> m Signature
    sign PrivateKey
    pk hash
    hashAlg msg
    msg = do
        k <- Integer -> m Integer
    forall (m :: * -> *). MonadRandom m => Integer -> m Integer
    generateMax Integer
    q
        case signWith k pk hashAlg msg of
            Maybe Signature
    Nothing  -> PrivateKey -> hash -> msg -> m Signature
    forall msg hash (m :: * -> *).
    (ByteArrayAccess msg, HashAlgorithm hash, MonadRandom m) =>
    PrivateKey -> hash -> msg -> m Signature
    sign PrivateKey
    pk hash
    hashAlg msg
    msg
            Just Signature
    sig -> Signature -> m Signature
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Signature
    sig
      where
        (Params Integer
    _ Integer
    _ Integer
    q) = PrivateKey -> Params
    private_params PrivateKey
    pk

    -- | verify a bytestring using the public key.
    verify :: (ByteArrayAccess msg, HashAlgorithm hash) => hash -> PublicKey -> Signature -> msg -> Bool
    verify :: forall msg hash.
    (ByteArrayAccess msg, HashAlgorithm hash) =>
    hash -> PublicKey -> Signature -> msg -> Bool
    verify hash
    hashAlg PublicKey
    pk (Signature Integer
    r Integer
    s) msg
    m
        -- Reject the signature if either 0 < r < q or 0 < s < q is not satisfied.
        | Integer
    r Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Integer
    0 Bool -> Bool -> Bool
    || Integer
    r Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Integer
    q Bool -> Bool -> Bool
    || Integer
    s Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Integer
    0 Bool -> Bool -> Bool
    || Integer
    s Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Integer
    q = Bool
    False
        | Bool
    otherwise                            = Integer
    v Integer -> Integer -> Bool
    forall a. Eq a => a -> a -> Bool
    == Integer
    r
        where (Params Integer
    p Integer
    g Integer
    q) = PublicKey -> Params
    public_params PublicKey
    pk
              y :: Integer
    y       = PublicKey -> Integer
    public_y PublicKey
    pk
              hm :: Integer
    hm      = hash -> msg -> Integer -> Integer
    forall msg hash.
    (ByteArrayAccess msg, HashAlgorithm hash) =>
    hash -> msg -> Integer -> Integer
    dsaTruncHash hash
    hashAlg msg
    m Integer
    q
              w :: Integer
    w       = Maybe Integer -> Integer
    forall a. HasCallStack => Maybe a -> a
    fromJust (Maybe Integer -> Integer) -> Maybe Integer -> Integer
    forall a b. (a -> b) -> a -> b
    $ Integer -> Integer -> Maybe Integer
    inverse Integer
    s Integer
    q
              u1 :: Integer
    u1      = (Integer
    hmInteger -> Integer -> Integer
    forall a. Num a => a -> a -> a
    *Integer
    w) Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    q
              u2 :: Integer
    u2      = (Integer
    rInteger -> Integer -> Integer
    forall a. Num a => a -> a -> a
    *Integer
    w) Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    q
              v :: Integer
    v       = ((Integer -> Integer -> Integer -> Integer
    expFast Integer
    g Integer
    u1 Integer
    p) Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    * (Integer -> Integer -> Integer -> Integer
    expFast Integer
    y Integer
    u2 Integer
    p)) Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    p Integer -> Integer -> Integer
    forall a. Integral a => a -> a -> a
    `mod` Integer
    q