-- PKITypes.hs: OpenPGP (RFC4880) data types for public/secret keys
-- Copyright © 2012-2019  Clint Adams
-- This software is released under the terms of the Expat license.
-- (See the LICENSE file).
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TemplateHaskell #-}

module Codec.Encryption.OpenPGP.Types.Internal.PKITypes where

import GHC.Generics (Generic)

import Codec.Encryption.OpenPGP.Types.Internal.Base
import Codec.Encryption.OpenPGP.Types.Internal.CryptoniteNewtypes

import qualified Data.Aeson as A
import qualified Data.Aeson.TH as ATH
import qualified Data.ByteString as B
import Data.ByteString.Lazy (ByteString)
import qualified Data.ByteString.Lazy as BL
import Data.Data (Data)
import Data.Hashable (Hashable(..))
import Data.Monoid ((<>))
import Data.Ord (comparing)
import Data.Text.Prettyprint.Doc (Pretty(..), (<+>))
import Data.Typeable (Typeable)
import Data.Word (Word16)

data EdSigningCurve =
  Ed25519
  deriving (Typeable EdSigningCurve
Constr
DataType
Typeable EdSigningCurve =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EdSigningCurve -> c EdSigningCurve)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EdSigningCurve)
-> (EdSigningCurve -> Constr)
-> (EdSigningCurve -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EdSigningCurve))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EdSigningCurve))
-> ((forall b. Data b => b -> b)
    -> EdSigningCurve -> EdSigningCurve)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EdSigningCurve -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EdSigningCurve -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EdSigningCurve -> m EdSigningCurve)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EdSigningCurve -> m EdSigningCurve)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EdSigningCurve -> m EdSigningCurve)
-> Data EdSigningCurve
EdSigningCurve -> Constr
EdSigningCurve -> DataType
(forall b. Data b => b -> b) -> EdSigningCurve -> EdSigningCurve
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EdSigningCurve -> c EdSigningCurve
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EdSigningCurve
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) -> EdSigningCurve -> u
forall u. (forall d. Data d => d -> u) -> EdSigningCurve -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EdSigningCurve
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EdSigningCurve -> c EdSigningCurve
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EdSigningCurve)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EdSigningCurve)
$cEd25519 :: Constr
$tEdSigningCurve :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
gmapMp :: (forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
gmapM :: (forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EdSigningCurve -> m EdSigningCurve
gmapQi :: Int -> (forall d. Data d => d -> u) -> EdSigningCurve -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EdSigningCurve -> u
gmapQ :: (forall d. Data d => d -> u) -> EdSigningCurve -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EdSigningCurve -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EdSigningCurve -> r
gmapT :: (forall b. Data b => b -> b) -> EdSigningCurve -> EdSigningCurve
$cgmapT :: (forall b. Data b => b -> b) -> EdSigningCurve -> EdSigningCurve
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EdSigningCurve)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EdSigningCurve)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EdSigningCurve)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EdSigningCurve)
dataTypeOf :: EdSigningCurve -> DataType
$cdataTypeOf :: EdSigningCurve -> DataType
toConstr :: EdSigningCurve -> Constr
$ctoConstr :: EdSigningCurve -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EdSigningCurve
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EdSigningCurve
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EdSigningCurve -> c EdSigningCurve
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EdSigningCurve -> c EdSigningCurve
$cp1Data :: Typeable EdSigningCurve
Data, EdSigningCurve -> EdSigningCurve -> Bool
(EdSigningCurve -> EdSigningCurve -> Bool)
-> (EdSigningCurve -> EdSigningCurve -> Bool) -> Eq EdSigningCurve
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EdSigningCurve -> EdSigningCurve -> Bool
$c/= :: EdSigningCurve -> EdSigningCurve -> Bool
== :: EdSigningCurve -> EdSigningCurve -> Bool
$c== :: EdSigningCurve -> EdSigningCurve -> Bool
Eq, (forall x. EdSigningCurve -> Rep EdSigningCurve x)
-> (forall x. Rep EdSigningCurve x -> EdSigningCurve)
-> Generic EdSigningCurve
forall x. Rep EdSigningCurve x -> EdSigningCurve
forall x. EdSigningCurve -> Rep EdSigningCurve x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EdSigningCurve x -> EdSigningCurve
$cfrom :: forall x. EdSigningCurve -> Rep EdSigningCurve x
Generic, Eq EdSigningCurve
Eq EdSigningCurve =>
(EdSigningCurve -> EdSigningCurve -> Ordering)
-> (EdSigningCurve -> EdSigningCurve -> Bool)
-> (EdSigningCurve -> EdSigningCurve -> Bool)
-> (EdSigningCurve -> EdSigningCurve -> Bool)
-> (EdSigningCurve -> EdSigningCurve -> Bool)
-> (EdSigningCurve -> EdSigningCurve -> EdSigningCurve)
-> (EdSigningCurve -> EdSigningCurve -> EdSigningCurve)
-> Ord EdSigningCurve
EdSigningCurve -> EdSigningCurve -> Bool
EdSigningCurve -> EdSigningCurve -> Ordering
EdSigningCurve -> EdSigningCurve -> EdSigningCurve
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EdSigningCurve -> EdSigningCurve -> EdSigningCurve
$cmin :: EdSigningCurve -> EdSigningCurve -> EdSigningCurve
max :: EdSigningCurve -> EdSigningCurve -> EdSigningCurve
$cmax :: EdSigningCurve -> EdSigningCurve -> EdSigningCurve
>= :: EdSigningCurve -> EdSigningCurve -> Bool
$c>= :: EdSigningCurve -> EdSigningCurve -> Bool
> :: EdSigningCurve -> EdSigningCurve -> Bool
$c> :: EdSigningCurve -> EdSigningCurve -> Bool
<= :: EdSigningCurve -> EdSigningCurve -> Bool
$c<= :: EdSigningCurve -> EdSigningCurve -> Bool
< :: EdSigningCurve -> EdSigningCurve -> Bool
$c< :: EdSigningCurve -> EdSigningCurve -> Bool
compare :: EdSigningCurve -> EdSigningCurve -> Ordering
$ccompare :: EdSigningCurve -> EdSigningCurve -> Ordering
$cp1Ord :: Eq EdSigningCurve
Ord, Int -> EdSigningCurve -> ShowS
[EdSigningCurve] -> ShowS
EdSigningCurve -> String
(Int -> EdSigningCurve -> ShowS)
-> (EdSigningCurve -> String)
-> ([EdSigningCurve] -> ShowS)
-> Show EdSigningCurve
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EdSigningCurve] -> ShowS
$cshowList :: [EdSigningCurve] -> ShowS
show :: EdSigningCurve -> String
$cshow :: EdSigningCurve -> String
showsPrec :: Int -> EdSigningCurve -> ShowS
$cshowsPrec :: Int -> EdSigningCurve -> ShowS
Show, Typeable)

instance Hashable EdSigningCurve

instance Pretty EdSigningCurve where
  pretty :: EdSigningCurve -> Doc ann
pretty Ed25519 = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "Ed25519"

instance A.FromJSON EdSigningCurve

instance A.ToJSON EdSigningCurve

newtype EPoint =
  EPoint
    { EPoint -> Integer
unEPoint :: Integer
    }
  deriving (Typeable EPoint
Constr
DataType
Typeable EPoint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EPoint -> c EPoint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EPoint)
-> (EPoint -> Constr)
-> (EPoint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EPoint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPoint))
-> ((forall b. Data b => b -> b) -> EPoint -> EPoint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EPoint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EPoint -> r)
-> (forall u. (forall d. Data d => d -> u) -> EPoint -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EPoint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EPoint -> m EPoint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EPoint -> m EPoint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EPoint -> m EPoint)
-> Data EPoint
EPoint -> Constr
EPoint -> DataType
(forall b. Data b => b -> b) -> EPoint -> EPoint
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPoint -> c EPoint
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPoint
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) -> EPoint -> u
forall u. (forall d. Data d => d -> u) -> EPoint -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EPoint -> m EPoint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPoint -> m EPoint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPoint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPoint -> c EPoint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EPoint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPoint)
$cEPoint :: Constr
$tEPoint :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EPoint -> m EPoint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPoint -> m EPoint
gmapMp :: (forall d. Data d => d -> m d) -> EPoint -> m EPoint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPoint -> m EPoint
gmapM :: (forall d. Data d => d -> m d) -> EPoint -> m EPoint
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EPoint -> m EPoint
gmapQi :: Int -> (forall d. Data d => d -> u) -> EPoint -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EPoint -> u
gmapQ :: (forall d. Data d => d -> u) -> EPoint -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EPoint -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPoint -> r
gmapT :: (forall b. Data b => b -> b) -> EPoint -> EPoint
$cgmapT :: (forall b. Data b => b -> b) -> EPoint -> EPoint
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPoint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPoint)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EPoint)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EPoint)
dataTypeOf :: EPoint -> DataType
$cdataTypeOf :: EPoint -> DataType
toConstr :: EPoint -> Constr
$ctoConstr :: EPoint -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPoint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPoint
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPoint -> c EPoint
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPoint -> c EPoint
$cp1Data :: Typeable EPoint
Data, EPoint -> EPoint -> Bool
(EPoint -> EPoint -> Bool)
-> (EPoint -> EPoint -> Bool) -> Eq EPoint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EPoint -> EPoint -> Bool
$c/= :: EPoint -> EPoint -> Bool
== :: EPoint -> EPoint -> Bool
$c== :: EPoint -> EPoint -> Bool
Eq, (forall x. EPoint -> Rep EPoint x)
-> (forall x. Rep EPoint x -> EPoint) -> Generic EPoint
forall x. Rep EPoint x -> EPoint
forall x. EPoint -> Rep EPoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EPoint x -> EPoint
$cfrom :: forall x. EPoint -> Rep EPoint x
Generic, Eq EPoint
Eq EPoint =>
(EPoint -> EPoint -> Ordering)
-> (EPoint -> EPoint -> Bool)
-> (EPoint -> EPoint -> Bool)
-> (EPoint -> EPoint -> Bool)
-> (EPoint -> EPoint -> Bool)
-> (EPoint -> EPoint -> EPoint)
-> (EPoint -> EPoint -> EPoint)
-> Ord EPoint
EPoint -> EPoint -> Bool
EPoint -> EPoint -> Ordering
EPoint -> EPoint -> EPoint
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EPoint -> EPoint -> EPoint
$cmin :: EPoint -> EPoint -> EPoint
max :: EPoint -> EPoint -> EPoint
$cmax :: EPoint -> EPoint -> EPoint
>= :: EPoint -> EPoint -> Bool
$c>= :: EPoint -> EPoint -> Bool
> :: EPoint -> EPoint -> Bool
$c> :: EPoint -> EPoint -> Bool
<= :: EPoint -> EPoint -> Bool
$c<= :: EPoint -> EPoint -> Bool
< :: EPoint -> EPoint -> Bool
$c< :: EPoint -> EPoint -> Bool
compare :: EPoint -> EPoint -> Ordering
$ccompare :: EPoint -> EPoint -> Ordering
$cp1Ord :: Eq EPoint
Ord, [EPoint] -> Doc ann
EPoint -> Doc ann
(forall ann. EPoint -> Doc ann)
-> (forall ann. [EPoint] -> Doc ann) -> Pretty EPoint
forall ann. [EPoint] -> Doc ann
forall ann. EPoint -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
prettyList :: [EPoint] -> Doc ann
$cprettyList :: forall ann. [EPoint] -> Doc ann
pretty :: EPoint -> Doc ann
$cpretty :: forall ann. EPoint -> Doc ann
Pretty, Int -> EPoint -> ShowS
[EPoint] -> ShowS
EPoint -> String
(Int -> EPoint -> ShowS)
-> (EPoint -> String) -> ([EPoint] -> ShowS) -> Show EPoint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EPoint] -> ShowS
$cshowList :: [EPoint] -> ShowS
show :: EPoint -> String
$cshow :: EPoint -> String
showsPrec :: Int -> EPoint -> ShowS
$cshowsPrec :: Int -> EPoint -> ShowS
Show, Typeable)

instance Hashable EPoint

instance A.FromJSON EPoint

instance A.ToJSON EPoint

data PKey
  = RSAPubKey RSA_PublicKey
  | DSAPubKey DSA_PublicKey
  | ElGamalPubKey Integer Integer Integer
  | ECDHPubKey PKey HashAlgorithm SymmetricAlgorithm
  | ECDSAPubKey ECDSA_PublicKey
  | EdDSAPubKey EdSigningCurve EPoint
  | UnknownPKey ByteString
  deriving (Typeable PKey
Constr
DataType
Typeable PKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PKey -> c PKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PKey)
-> (PKey -> Constr)
-> (PKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKey))
-> ((forall b. Data b => b -> b) -> PKey -> PKey)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> PKey -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PKey -> m PKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKey -> m PKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKey -> m PKey)
-> Data PKey
PKey -> Constr
PKey -> DataType
(forall b. Data b => b -> b) -> PKey -> PKey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKey -> c PKey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKey
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) -> PKey -> u
forall u. (forall d. Data d => d -> u) -> PKey -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKey -> m PKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKey -> m PKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKey -> c PKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKey)
$cUnknownPKey :: Constr
$cEdDSAPubKey :: Constr
$cECDSAPubKey :: Constr
$cECDHPubKey :: Constr
$cElGamalPubKey :: Constr
$cDSAPubKey :: Constr
$cRSAPubKey :: Constr
$tPKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PKey -> m PKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKey -> m PKey
gmapMp :: (forall d. Data d => d -> m d) -> PKey -> m PKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKey -> m PKey
gmapM :: (forall d. Data d => d -> m d) -> PKey -> m PKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKey -> m PKey
gmapQi :: Int -> (forall d. Data d => d -> u) -> PKey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PKey -> u
gmapQ :: (forall d. Data d => d -> u) -> PKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PKey -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKey -> r
gmapT :: (forall b. Data b => b -> b) -> PKey -> PKey
$cgmapT :: (forall b. Data b => b -> b) -> PKey -> PKey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKey)
dataTypeOf :: PKey -> DataType
$cdataTypeOf :: PKey -> DataType
toConstr :: PKey -> Constr
$ctoConstr :: PKey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKey -> c PKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKey -> c PKey
$cp1Data :: Typeable PKey
Data, PKey -> PKey -> Bool
(PKey -> PKey -> Bool) -> (PKey -> PKey -> Bool) -> Eq PKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PKey -> PKey -> Bool
$c/= :: PKey -> PKey -> Bool
== :: PKey -> PKey -> Bool
$c== :: PKey -> PKey -> Bool
Eq, (forall x. PKey -> Rep PKey x)
-> (forall x. Rep PKey x -> PKey) -> Generic PKey
forall x. Rep PKey x -> PKey
forall x. PKey -> Rep PKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PKey x -> PKey
$cfrom :: forall x. PKey -> Rep PKey x
Generic, Eq PKey
Eq PKey =>
(PKey -> PKey -> Ordering)
-> (PKey -> PKey -> Bool)
-> (PKey -> PKey -> Bool)
-> (PKey -> PKey -> Bool)
-> (PKey -> PKey -> Bool)
-> (PKey -> PKey -> PKey)
-> (PKey -> PKey -> PKey)
-> Ord PKey
PKey -> PKey -> Bool
PKey -> PKey -> Ordering
PKey -> PKey -> PKey
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PKey -> PKey -> PKey
$cmin :: PKey -> PKey -> PKey
max :: PKey -> PKey -> PKey
$cmax :: PKey -> PKey -> PKey
>= :: PKey -> PKey -> Bool
$c>= :: PKey -> PKey -> Bool
> :: PKey -> PKey -> Bool
$c> :: PKey -> PKey -> Bool
<= :: PKey -> PKey -> Bool
$c<= :: PKey -> PKey -> Bool
< :: PKey -> PKey -> Bool
$c< :: PKey -> PKey -> Bool
compare :: PKey -> PKey -> Ordering
$ccompare :: PKey -> PKey -> Ordering
$cp1Ord :: Eq PKey
Ord, Int -> PKey -> ShowS
[PKey] -> ShowS
PKey -> String
(Int -> PKey -> ShowS)
-> (PKey -> String) -> ([PKey] -> ShowS) -> Show PKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PKey] -> ShowS
$cshowList :: [PKey] -> ShowS
show :: PKey -> String
$cshow :: PKey -> String
showsPrec :: Int -> PKey -> ShowS
$cshowsPrec :: Int -> PKey -> ShowS
Show, Typeable)

instance Hashable PKey

instance Pretty PKey where
  pretty :: PKey -> Doc ann
pretty (RSAPubKey p :: RSA_PublicKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "RSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> RSA_PublicKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty RSA_PublicKey
p
  pretty (DSAPubKey p :: DSA_PublicKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "DSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> DSA_PublicKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty DSA_PublicKey
p
  pretty (ElGamalPubKey p :: Integer
p g :: Integer
g y :: Integer
y) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "Elgamal" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
g Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
y
  pretty (ECDHPubKey p :: PKey
p ha :: HashAlgorithm
ha sa :: SymmetricAlgorithm
sa) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "ECDH" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> PKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty PKey
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> SymmetricAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty SymmetricAlgorithm
sa
  pretty (ECDSAPubKey p :: ECDSA_PublicKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "ECDSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ECDSA_PublicKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ECDSA_PublicKey
p
  pretty (EdDSAPubKey c :: EdSigningCurve
c ep :: EPoint
ep) = EdSigningCurve -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty EdSigningCurve
c Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> EPoint -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty EPoint
ep
  pretty (UnknownPKey bs :: ByteString
bs) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "<unknown>" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)

instance A.ToJSON PKey where
  toJSON :: PKey -> Value
toJSON (RSAPubKey p :: RSA_PublicKey
p) = RSA_PublicKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON RSA_PublicKey
p
  toJSON (DSAPubKey p :: DSA_PublicKey
p) = DSA_PublicKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON DSA_PublicKey
p
  toJSON (ElGamalPubKey p :: Integer
p g :: Integer
g y :: Integer
y) = (Integer, Integer, Integer) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Integer
p, Integer
g, Integer
y)
  toJSON (ECDHPubKey p :: PKey
p ha :: HashAlgorithm
ha sa :: SymmetricAlgorithm
sa) = (PKey, HashAlgorithm, SymmetricAlgorithm) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (PKey
p, HashAlgorithm
ha, SymmetricAlgorithm
sa)
  toJSON (ECDSAPubKey p :: ECDSA_PublicKey
p) = ECDSA_PublicKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON ECDSA_PublicKey
p
  toJSON (EdDSAPubKey c :: EdSigningCurve
c ep :: EPoint
ep) = (EdSigningCurve, EPoint) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (EdSigningCurve
c, EPoint
ep)
  toJSON (UnknownPKey bs :: ByteString
bs) = [Word8] -> Value
forall a. ToJSON a => a -> Value
A.toJSON (ByteString -> [Word8]
BL.unpack ByteString
bs)

data SKey
  = RSAPrivateKey RSA_PrivateKey
  | DSAPrivateKey DSA_PrivateKey
  | ElGamalPrivateKey Integer
  | ECDHPrivateKey ECDSA_PrivateKey
  | ECDSAPrivateKey ECDSA_PrivateKey
  | EdDSAPrivateKey EdSigningCurve B.ByteString
  | UnknownSKey ByteString
  deriving (Typeable SKey
Constr
DataType
Typeable SKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SKey -> c SKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SKey)
-> (SKey -> Constr)
-> (SKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKey))
-> ((forall b. Data b => b -> b) -> SKey -> SKey)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> SKey -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SKey -> m SKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKey -> m SKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKey -> m SKey)
-> Data SKey
SKey -> Constr
SKey -> DataType
(forall b. Data b => b -> b) -> SKey -> SKey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKey -> c SKey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKey
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) -> SKey -> u
forall u. (forall d. Data d => d -> u) -> SKey -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKey -> m SKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKey -> m SKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKey -> c SKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKey)
$cUnknownSKey :: Constr
$cEdDSAPrivateKey :: Constr
$cECDSAPrivateKey :: Constr
$cECDHPrivateKey :: Constr
$cElGamalPrivateKey :: Constr
$cDSAPrivateKey :: Constr
$cRSAPrivateKey :: Constr
$tSKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SKey -> m SKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKey -> m SKey
gmapMp :: (forall d. Data d => d -> m d) -> SKey -> m SKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKey -> m SKey
gmapM :: (forall d. Data d => d -> m d) -> SKey -> m SKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKey -> m SKey
gmapQi :: Int -> (forall d. Data d => d -> u) -> SKey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SKey -> u
gmapQ :: (forall d. Data d => d -> u) -> SKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SKey -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKey -> r
gmapT :: (forall b. Data b => b -> b) -> SKey -> SKey
$cgmapT :: (forall b. Data b => b -> b) -> SKey -> SKey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKey)
dataTypeOf :: SKey -> DataType
$cdataTypeOf :: SKey -> DataType
toConstr :: SKey -> Constr
$ctoConstr :: SKey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKey -> c SKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKey -> c SKey
$cp1Data :: Typeable SKey
Data, SKey -> SKey -> Bool
(SKey -> SKey -> Bool) -> (SKey -> SKey -> Bool) -> Eq SKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SKey -> SKey -> Bool
$c/= :: SKey -> SKey -> Bool
== :: SKey -> SKey -> Bool
$c== :: SKey -> SKey -> Bool
Eq, (forall x. SKey -> Rep SKey x)
-> (forall x. Rep SKey x -> SKey) -> Generic SKey
forall x. Rep SKey x -> SKey
forall x. SKey -> Rep SKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SKey x -> SKey
$cfrom :: forall x. SKey -> Rep SKey x
Generic, Int -> SKey -> ShowS
[SKey] -> ShowS
SKey -> String
(Int -> SKey -> ShowS)
-> (SKey -> String) -> ([SKey] -> ShowS) -> Show SKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SKey] -> ShowS
$cshowList :: [SKey] -> ShowS
show :: SKey -> String
$cshow :: SKey -> String
showsPrec :: Int -> SKey -> ShowS
$cshowsPrec :: Int -> SKey -> ShowS
Show, Typeable)

instance Hashable SKey

instance Pretty SKey where
  pretty :: SKey -> Doc ann
pretty (RSAPrivateKey p :: RSA_PrivateKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "RSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> RSA_PrivateKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty RSA_PrivateKey
p
  pretty (DSAPrivateKey p :: DSA_PrivateKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "DSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> DSA_PrivateKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty DSA_PrivateKey
p
  pretty (ElGamalPrivateKey p :: Integer
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "Elgamal" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
p
  pretty (ECDHPrivateKey p :: ECDSA_PrivateKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "ECDH" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ECDSA_PrivateKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ECDSA_PrivateKey
p
  pretty (ECDSAPrivateKey p :: ECDSA_PrivateKey
p) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "ECDSA" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ECDSA_PrivateKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ECDSA_PrivateKey
p
  pretty (EdDSAPrivateKey c :: EdSigningCurve
c bs :: ByteString
bs) =
    EdSigningCurve -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty EdSigningCurve
c Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper (ByteString -> ByteString
BL.fromStrict ByteString
bs))
  pretty (UnknownSKey bs :: ByteString
bs) = String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "<unknown>" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)

instance A.ToJSON SKey where
  toJSON :: SKey -> Value
toJSON (RSAPrivateKey k :: RSA_PrivateKey
k) = RSA_PrivateKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON RSA_PrivateKey
k
  toJSON (DSAPrivateKey k :: DSA_PrivateKey
k) = DSA_PrivateKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON DSA_PrivateKey
k
  toJSON (ElGamalPrivateKey k :: Integer
k) = Integer -> Value
forall a. ToJSON a => a -> Value
A.toJSON Integer
k
  toJSON (ECDHPrivateKey k :: ECDSA_PrivateKey
k) = ECDSA_PrivateKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON ECDSA_PrivateKey
k
  toJSON (ECDSAPrivateKey k :: ECDSA_PrivateKey
k) = ECDSA_PrivateKey -> Value
forall a. ToJSON a => a -> Value
A.toJSON ECDSA_PrivateKey
k
  toJSON (EdDSAPrivateKey c :: EdSigningCurve
c bs :: ByteString
bs) = (EdSigningCurve, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (EdSigningCurve
c, ByteString -> [Word8]
B.unpack ByteString
bs)
  toJSON (UnknownSKey bs :: ByteString
bs) = [Word8] -> Value
forall a. ToJSON a => a -> Value
A.toJSON (ByteString -> [Word8]
BL.unpack ByteString
bs)

data PKPayload =
  PKPayload
    { PKPayload -> KeyVersion
_keyVersion :: KeyVersion
    , PKPayload -> ThirtyTwoBitTimeStamp
_timestamp :: ThirtyTwoBitTimeStamp
    , PKPayload -> V3Expiration
_v3exp :: V3Expiration
    , PKPayload -> PubKeyAlgorithm
_pkalgo :: PubKeyAlgorithm
    , PKPayload -> PKey
_pubkey :: PKey
    }
  deriving (Typeable PKPayload
Constr
DataType
Typeable PKPayload =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PKPayload -> c PKPayload)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PKPayload)
-> (PKPayload -> Constr)
-> (PKPayload -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PKPayload))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKPayload))
-> ((forall b. Data b => b -> b) -> PKPayload -> PKPayload)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PKPayload -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PKPayload -> r)
-> (forall u. (forall d. Data d => d -> u) -> PKPayload -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PKPayload -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload)
-> Data PKPayload
PKPayload -> Constr
PKPayload -> DataType
(forall b. Data b => b -> b) -> PKPayload -> PKPayload
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKPayload -> c PKPayload
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKPayload
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) -> PKPayload -> u
forall u. (forall d. Data d => d -> u) -> PKPayload -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKPayload
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKPayload -> c PKPayload
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKPayload)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKPayload)
$cPKPayload :: Constr
$tPKPayload :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
gmapMp :: (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
gmapM :: (forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKPayload -> m PKPayload
gmapQi :: Int -> (forall d. Data d => d -> u) -> PKPayload -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PKPayload -> u
gmapQ :: (forall d. Data d => d -> u) -> PKPayload -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PKPayload -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PKPayload -> r
gmapT :: (forall b. Data b => b -> b) -> PKPayload -> PKPayload
$cgmapT :: (forall b. Data b => b -> b) -> PKPayload -> PKPayload
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKPayload)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKPayload)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PKPayload)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKPayload)
dataTypeOf :: PKPayload -> DataType
$cdataTypeOf :: PKPayload -> DataType
toConstr :: PKPayload -> Constr
$ctoConstr :: PKPayload -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKPayload
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKPayload
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKPayload -> c PKPayload
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKPayload -> c PKPayload
$cp1Data :: Typeable PKPayload
Data, PKPayload -> PKPayload -> Bool
(PKPayload -> PKPayload -> Bool)
-> (PKPayload -> PKPayload -> Bool) -> Eq PKPayload
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PKPayload -> PKPayload -> Bool
$c/= :: PKPayload -> PKPayload -> Bool
== :: PKPayload -> PKPayload -> Bool
$c== :: PKPayload -> PKPayload -> Bool
Eq, (forall x. PKPayload -> Rep PKPayload x)
-> (forall x. Rep PKPayload x -> PKPayload) -> Generic PKPayload
forall x. Rep PKPayload x -> PKPayload
forall x. PKPayload -> Rep PKPayload x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PKPayload x -> PKPayload
$cfrom :: forall x. PKPayload -> Rep PKPayload x
Generic, Int -> PKPayload -> ShowS
[PKPayload] -> ShowS
PKPayload -> String
(Int -> PKPayload -> ShowS)
-> (PKPayload -> String)
-> ([PKPayload] -> ShowS)
-> Show PKPayload
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PKPayload] -> ShowS
$cshowList :: [PKPayload] -> ShowS
show :: PKPayload -> String
$cshow :: PKPayload -> String
showsPrec :: Int -> PKPayload -> ShowS
$cshowsPrec :: Int -> PKPayload -> ShowS
Show, Typeable)

instance Ord PKPayload where
  compare :: PKPayload -> PKPayload -> Ordering
compare =
    (PKPayload -> KeyVersion) -> PKPayload -> PKPayload -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PKPayload -> KeyVersion
_keyVersion (PKPayload -> PKPayload -> Ordering)
-> (PKPayload -> PKPayload -> Ordering)
-> PKPayload
-> PKPayload
-> Ordering
forall a. Semigroup a => a -> a -> a
<> (PKPayload -> ThirtyTwoBitTimeStamp)
-> PKPayload -> PKPayload -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PKPayload -> ThirtyTwoBitTimeStamp
_timestamp (PKPayload -> PKPayload -> Ordering)
-> (PKPayload -> PKPayload -> Ordering)
-> PKPayload
-> PKPayload
-> Ordering
forall a. Semigroup a => a -> a -> a
<> (PKPayload -> V3Expiration) -> PKPayload -> PKPayload -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PKPayload -> V3Expiration
_v3exp (PKPayload -> PKPayload -> Ordering)
-> (PKPayload -> PKPayload -> Ordering)
-> PKPayload
-> PKPayload
-> Ordering
forall a. Semigroup a => a -> a -> a
<>
    (PKPayload -> PubKeyAlgorithm)
-> PKPayload -> PKPayload -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PKPayload -> PubKeyAlgorithm
_pkalgo (PKPayload -> PKPayload -> Ordering)
-> (PKPayload -> PKPayload -> Ordering)
-> PKPayload
-> PKPayload
-> Ordering
forall a. Semigroup a => a -> a -> a
<>
    (PKPayload -> PKey) -> PKPayload -> PKPayload -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PKPayload -> PKey
_pubkey

instance Hashable PKPayload

instance Pretty PKPayload where
  pretty :: PKPayload -> Doc ann
pretty (PKPayload kv :: KeyVersion
kv ts :: ThirtyTwoBitTimeStamp
ts v3e :: V3Expiration
v3e pka :: PubKeyAlgorithm
pka p :: PKey
p) =
    KeyVersion -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty KeyVersion
kv Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ThirtyTwoBitTimeStamp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ThirtyTwoBitTimeStamp
ts Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> V3Expiration -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty V3Expiration
v3e Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> PKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty PKey
p

$(ATH.deriveToJSON ATH.defaultOptions ''PKPayload)

data SKAddendum
  = SUS16bit SymmetricAlgorithm S2K IV ByteString
  | SUSSHA1 SymmetricAlgorithm S2K IV ByteString
  | SUSym SymmetricAlgorithm IV ByteString
  | SUUnencrypted SKey Word16
  deriving (Typeable SKAddendum
Constr
DataType
Typeable SKAddendum =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SKAddendum -> c SKAddendum)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SKAddendum)
-> (SKAddendum -> Constr)
-> (SKAddendum -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SKAddendum))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SKAddendum))
-> ((forall b. Data b => b -> b) -> SKAddendum -> SKAddendum)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SKAddendum -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SKAddendum -> r)
-> (forall u. (forall d. Data d => d -> u) -> SKAddendum -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SKAddendum -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum)
-> Data SKAddendum
SKAddendum -> Constr
SKAddendum -> DataType
(forall b. Data b => b -> b) -> SKAddendum -> SKAddendum
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKAddendum -> c SKAddendum
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKAddendum
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) -> SKAddendum -> u
forall u. (forall d. Data d => d -> u) -> SKAddendum -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKAddendum
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKAddendum -> c SKAddendum
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKAddendum)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKAddendum)
$cSUUnencrypted :: Constr
$cSUSym :: Constr
$cSUSSHA1 :: Constr
$cSUS16bit :: Constr
$tSKAddendum :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
gmapMp :: (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
gmapM :: (forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKAddendum -> m SKAddendum
gmapQi :: Int -> (forall d. Data d => d -> u) -> SKAddendum -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SKAddendum -> u
gmapQ :: (forall d. Data d => d -> u) -> SKAddendum -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SKAddendum -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SKAddendum -> r
gmapT :: (forall b. Data b => b -> b) -> SKAddendum -> SKAddendum
$cgmapT :: (forall b. Data b => b -> b) -> SKAddendum -> SKAddendum
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKAddendum)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKAddendum)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SKAddendum)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKAddendum)
dataTypeOf :: SKAddendum -> DataType
$cdataTypeOf :: SKAddendum -> DataType
toConstr :: SKAddendum -> Constr
$ctoConstr :: SKAddendum -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKAddendum
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKAddendum
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKAddendum -> c SKAddendum
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKAddendum -> c SKAddendum
$cp1Data :: Typeable SKAddendum
Data, SKAddendum -> SKAddendum -> Bool
(SKAddendum -> SKAddendum -> Bool)
-> (SKAddendum -> SKAddendum -> Bool) -> Eq SKAddendum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SKAddendum -> SKAddendum -> Bool
$c/= :: SKAddendum -> SKAddendum -> Bool
== :: SKAddendum -> SKAddendum -> Bool
$c== :: SKAddendum -> SKAddendum -> Bool
Eq, (forall x. SKAddendum -> Rep SKAddendum x)
-> (forall x. Rep SKAddendum x -> SKAddendum) -> Generic SKAddendum
forall x. Rep SKAddendum x -> SKAddendum
forall x. SKAddendum -> Rep SKAddendum x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SKAddendum x -> SKAddendum
$cfrom :: forall x. SKAddendum -> Rep SKAddendum x
Generic, Int -> SKAddendum -> ShowS
[SKAddendum] -> ShowS
SKAddendum -> String
(Int -> SKAddendum -> ShowS)
-> (SKAddendum -> String)
-> ([SKAddendum] -> ShowS)
-> Show SKAddendum
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SKAddendum] -> ShowS
$cshowList :: [SKAddendum] -> ShowS
show :: SKAddendum -> String
$cshow :: SKAddendum -> String
showsPrec :: Int -> SKAddendum -> ShowS
$cshowsPrec :: Int -> SKAddendum -> ShowS
Show, Typeable)

instance Ord SKAddendum where
  compare :: SKAddendum -> SKAddendum -> Ordering
compare a :: SKAddendum
a b :: SKAddendum
b = SKAddendum -> String
forall a. Show a => a -> String
show SKAddendum
a String -> String -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` SKAddendum -> String
forall a. Show a => a -> String
show SKAddendum
b -- FIXME: this is ridiculous

instance Hashable SKAddendum

instance Pretty SKAddendum where
  pretty :: SKAddendum -> Doc ann
pretty (SUS16bit sa :: SymmetricAlgorithm
sa s2k :: S2K
s2k iv :: IV
iv bs :: ByteString
bs) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "SUS16bit" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SymmetricAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty SymmetricAlgorithm
sa Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> S2K -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty S2K
s2k Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> IV -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty IV
iv Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)
  pretty (SUSSHA1 sa :: SymmetricAlgorithm
sa s2k :: S2K
s2k iv :: IV
iv bs :: ByteString
bs) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "SUSSHA1" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SymmetricAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty SymmetricAlgorithm
sa Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> S2K -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty S2K
s2k Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> IV -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty IV
iv Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)
  pretty (SUSym sa :: SymmetricAlgorithm
sa iv :: IV
iv bs :: ByteString
bs) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "SUSym" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> SymmetricAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty SymmetricAlgorithm
sa Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> IV -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty IV
iv Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)
  pretty (SUUnencrypted s :: SKey
s ck :: V3Expiration
ck) =
    String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty "SUUnencrypted" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> SKey -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty SKey
s Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> V3Expiration -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty V3Expiration
ck

instance A.ToJSON SKAddendum where
  toJSON :: SKAddendum -> Value
toJSON (SUS16bit sa :: SymmetricAlgorithm
sa s2k :: S2K
s2k iv :: IV
iv bs :: ByteString
bs) = (SymmetricAlgorithm, S2K, IV, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (SymmetricAlgorithm
sa, S2K
s2k, IV
iv, ByteString -> [Word8]
BL.unpack ByteString
bs)
  toJSON (SUSSHA1 sa :: SymmetricAlgorithm
sa s2k :: S2K
s2k iv :: IV
iv bs :: ByteString
bs) = (SymmetricAlgorithm, S2K, IV, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (SymmetricAlgorithm
sa, S2K
s2k, IV
iv, ByteString -> [Word8]
BL.unpack ByteString
bs)
  toJSON (SUSym sa :: SymmetricAlgorithm
sa iv :: IV
iv bs :: ByteString
bs) = (SymmetricAlgorithm, IV, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (SymmetricAlgorithm
sa, IV
iv, ByteString -> [Word8]
BL.unpack ByteString
bs)
  toJSON (SUUnencrypted s :: SKey
s ck :: V3Expiration
ck) = (SKey, V3Expiration) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (SKey
s, V3Expiration
ck)