{-# LANGUAGE CPP                        #-}
{-# LANGUAGE QuasiQuotes                #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE BangPatterns               #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE ExistentialQuantification  #-}
{-# LANGUAGE TemplateHaskell            #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE TypeSynonymInstances       #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# OPTIONS_GHC -fno-warn-orphans       #-}
{-# OPTIONS_GHC -fno-warn-unused-binds  #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}


-- | The KeyStore and Associated Types
--
-- Note that most of these types and functions were generated by the
-- api-tools ("Data.Api.Tools") from the schema in "Data.KeyStore.Types.Schema",
-- marked down in <https://github.com/cdornan/keystore/blob/master/schema.md>.

module Data.KeyStore.Types
    ( module Data.KeyStore.Types
    , module Data.KeyStore.Types.NameAndSafeguard
    , module Data.KeyStore.Types.E
    , module Data.KeyStore.Types.UTC
    , PublicKey(..)
    , PrivateKey(..)
    ) where

import qualified Control.Lens                   as L
import qualified Crypto.PBKDF.ByteString        as P
import           Crypto.PubKey.RSA (PublicKey(..), PrivateKey(..))
import           Data.KeyStore.Types.Schema
import           Data.KeyStore.Types.NameAndSafeguard
import           Data.KeyStore.Types.E
import           Data.KeyStore.Types.UTC
import           Data.KeyStore.Types.AesonCompat
import           Data.API.Tools
import           Data.API.JSON
import           Data.API.Types
import qualified Data.ByteString                as B
import           Data.Coerce
import qualified Data.HashMap.Strict            as HM
import           Data.List
import qualified Data.Map                       as Map
import           Data.Ord
import qualified Data.Text                      as T
import           Data.Time
import           Data.String
import qualified Data.Vector                    as V
import           Text.KSRegex


$(generate                         keystoreSchema)


deriving instance Num Iterations
deriving instance Num Octets


-- | Keystore session context, created at the start of a session and passed
-- to the keystore access functions.

data Pattern =
    Pattern
      { Pattern -> String
_pat_string :: String
      , Pattern -> Regex
_pat_regex  :: Regex
      }

instance Eq Pattern where
    == :: Pattern -> Pattern -> Bool
(==) Pattern
pat Pattern
pat' = Pattern -> String
_pat_string Pattern
pat String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== Pattern -> String
_pat_string Pattern
pat'

instance Show Pattern where
    show :: Pattern -> String
show Pattern
pat     = String
"Pattern " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show(Pattern -> String
_pat_string Pattern
pat) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" <regex>"

instance IsString Pattern where
    fromString :: String -> Pattern
fromString String
s =
        Pattern :: String -> Regex -> Pattern
Pattern
            { _pat_string :: String
_pat_string = String
s
            , _pat_regex :: Regex
_pat_regex  = String -> Regex
mkRegex String
s
            }

pattern :: String -> Pattern
pattern :: String -> Pattern
pattern = String -> Pattern
forall a. IsString a => String -> a
fromString

inj_pattern :: REP__Pattern -> ParserWithErrs Pattern
inj_pattern :: REP__Pattern -> ParserWithErrs Pattern
inj_pattern (REP__Pattern Text
t) =
    Pattern -> ParserWithErrs Pattern
forall (m :: * -> *) a. Monad m => a -> m a
return (Pattern -> ParserWithErrs Pattern)
-> Pattern -> ParserWithErrs Pattern
forall a b. (a -> b) -> a -> b
$
        Pattern :: String -> Regex -> Pattern
Pattern
            { _pat_string :: String
_pat_string = String
s
            , _pat_regex :: Regex
_pat_regex  = String -> Regex
mkRegex String
s
            }
  where
    s :: String
s = Text -> String
T.unpack Text
t

prj_pattern :: Pattern -> REP__Pattern
prj_pattern :: Pattern -> REP__Pattern
prj_pattern = Text -> REP__Pattern
REP__Pattern (Text -> REP__Pattern)
-> (Pattern -> Text) -> Pattern -> REP__Pattern
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Text) -> (Pattern -> String) -> Pattern -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pattern -> String
_pat_string


newtype Settings = Settings { Settings -> HashMap Text Value
_Settings :: HM.HashMap T.Text Value }
    deriving (Settings -> Settings -> Bool
(Settings -> Settings -> Bool)
-> (Settings -> Settings -> Bool) -> Eq Settings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Settings -> Settings -> Bool
$c/= :: Settings -> Settings -> Bool
== :: Settings -> Settings -> Bool
$c== :: Settings -> Settings -> Bool
Eq,Int -> Settings -> ShowS
[Settings] -> ShowS
Settings -> String
(Int -> Settings -> ShowS)
-> (Settings -> String) -> ([Settings] -> ShowS) -> Show Settings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Settings] -> ShowS
$cshowList :: [Settings] -> ShowS
show :: Settings -> String
$cshow :: Settings -> String
showsPrec :: Int -> Settings -> ShowS
$cshowsPrec :: Int -> Settings -> ShowS
Show)

inj_settings :: REP__Settings -> ParserWithErrs Settings
inj_settings :: REP__Settings -> ParserWithErrs Settings
inj_settings REP__Settings { _stgs_json :: REP__Settings -> Value
_stgs_json = Object Object
o}
                = Settings -> ParserWithErrs Settings
forall (m :: * -> *) a. Monad m => a -> m a
return (Settings -> ParserWithErrs Settings)
-> Settings -> ParserWithErrs Settings
forall a b. (a -> b) -> a -> b
$ HashMap Text Value -> Settings
Settings (HashMap Text Value -> Settings) -> HashMap Text Value -> Settings
forall a b. (a -> b) -> a -> b
$ Object -> HashMap Text Value
forall a. KM a -> HashMap Text a
fromKM Object
o
inj_settings REP__Settings
_  = String -> ParserWithErrs Settings
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"object expected for settings"

prj_settings :: Settings -> REP__Settings
prj_settings :: Settings -> REP__Settings
prj_settings (Settings HashMap Text Value
hm) = REP__Settings :: Value -> REP__Settings
REP__Settings { _stgs_json :: Value
_stgs_json = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ HashMap Text Value -> Object
forall a. HashMap Text a -> KM a
intoKM HashMap Text Value
hm }

defaultSettings :: Settings
defaultSettings :: Settings
defaultSettings = Settings
forall a. Monoid a => a
mempty



#if __GLASGOW_HASKELL__ >= 804
instance Semigroup Settings where
  <> :: Settings -> Settings -> Settings
(<>) = Settings -> Settings -> Settings
mappendSettings
#endif

instance Monoid Settings where
  mempty :: Settings
mempty  = HashMap Text Value -> Settings
Settings HashMap Text Value
forall a. Monoid a => a
mempty
  -- mappend = mappendSettings

mappendSettings :: Settings -> Settings -> Settings
mappendSettings :: Settings -> Settings -> Settings
mappendSettings (Settings HashMap Text Value
fm_0) (Settings HashMap Text Value
fm_1) =
    HashMap Text Value -> Settings
Settings (HashMap Text Value -> Settings) -> HashMap Text Value -> Settings
forall a b. (a -> b) -> a -> b
$ (Value -> Value -> Value)
-> HashMap Text Value -> HashMap Text Value -> HashMap Text Value
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
HM.unionWith Value -> Value -> Value
cmb HashMap Text Value
fm_0 HashMap Text Value
fm_1
  where
    cmb :: Value -> Value -> Value
cmb Value
v0 Value
v1 =
      case (Value
v0,Value
v1) of
        (Array Array
v_0,Array Array
v_1) -> Array -> Value
Array (Array -> Value) -> Array -> Value
forall a b. (a -> b) -> a -> b
$ Array
v_0 Array -> Array -> Array
forall a. Vector a -> Vector a -> Vector a
V.++ Array
v_1
        (Value, Value)
_                     -> Value
marker

checkSettingsCollisions :: Settings -> [SettingID]
checkSettingsCollisions :: Settings -> [SettingID]
checkSettingsCollisions (Settings HashMap Text Value
hm) =
              [ Text -> SettingID
SettingID Text
k | (Text
k,Value
v)<-HashMap Text Value -> [(Text, Value)]
forall k v. HashMap k v -> [(k, v)]
HM.toList HashMap Text Value
hm, Value
vValue -> Value -> Bool
forall a. Eq a => a -> a -> Bool
==Value
marker ]

marker :: Value
marker :: Value
marker = Text -> Value
String Text
"*** Collision * in * Settings ***"


inj_safeguard :: REP__Safeguard -> ParserWithErrs Safeguard
inj_safeguard :: REP__Safeguard -> ParserWithErrs Safeguard
inj_safeguard = Safeguard -> ParserWithErrs Safeguard
forall (m :: * -> *) a. Monad m => a -> m a
return (Safeguard -> ParserWithErrs Safeguard)
-> (REP__Safeguard -> Safeguard)
-> REP__Safeguard
-> ParserWithErrs Safeguard
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Name] -> Safeguard
safeguard ([Name] -> Safeguard)
-> (REP__Safeguard -> [Name]) -> REP__Safeguard -> Safeguard
forall b c a. (b -> c) -> (a -> b) -> a -> c
. REP__Safeguard -> [Name]
_sg_names

prj_safeguard :: Safeguard -> REP__Safeguard
prj_safeguard :: Safeguard -> REP__Safeguard
prj_safeguard = [Name] -> REP__Safeguard
REP__Safeguard ([Name] -> REP__Safeguard)
-> (Safeguard -> [Name]) -> Safeguard -> REP__Safeguard
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Safeguard -> [Name]
safeguardKeys


inj_name :: REP__Name -> ParserWithErrs Name
inj_name :: REP__Name -> ParserWithErrs Name
inj_name = E Name -> ParserWithErrs Name
forall a. E a -> ParserWithErrs a
e2p (E Name -> ParserWithErrs Name)
-> (REP__Name -> E Name) -> REP__Name -> ParserWithErrs Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> E Name
name (String -> E Name) -> (REP__Name -> String) -> REP__Name -> E Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack (Text -> String) -> (REP__Name -> Text) -> REP__Name -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. REP__Name -> Text
_REP__Name

prj_name :: Name -> REP__Name
prj_name :: Name -> REP__Name
prj_name = Text -> REP__Name
REP__Name (Text -> REP__Name) -> (Name -> Text) -> Name -> REP__Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Text) -> (Name -> String) -> Name -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> String
_name



inj_PublicKey :: REP__PublicKey -> ParserWithErrs PublicKey
inj_PublicKey :: REP__PublicKey -> ParserWithErrs PublicKey
inj_PublicKey REP__PublicKey{Int
Integer
_puk_e :: Integer
_puk_n :: Integer
_puk_size :: Int
_puk_e :: REP__PublicKey -> Integer
_puk_n :: REP__PublicKey -> Integer
_puk_size :: REP__PublicKey -> Int
..} =
    PublicKey -> ParserWithErrs PublicKey
forall (m :: * -> *) a. Monad m => a -> m a
return
        PublicKey :: Int -> Integer -> Integer -> PublicKey
PublicKey
            { public_size :: Int
public_size = Int
_puk_size
            , public_n :: Integer
public_n    = Integer
_puk_n
            , public_e :: Integer
public_e    = Integer
_puk_e
            }

prj_PublicKey :: PublicKey -> REP__PublicKey
prj_PublicKey :: PublicKey -> REP__PublicKey
prj_PublicKey PublicKey{Int
Integer
public_e :: Integer
public_n :: Integer
public_size :: Int
public_e :: PublicKey -> Integer
public_n :: PublicKey -> Integer
public_size :: PublicKey -> Int
..} =
    REP__PublicKey :: Int -> Integer -> Integer -> REP__PublicKey
REP__PublicKey
        { _puk_size :: Int
_puk_size = Int
public_size
        , _puk_n :: Integer
_puk_n    = Integer
public_n
        , _puk_e :: Integer
_puk_e    = Integer
public_e
        }


inj_PrivateKey :: REP__PrivateKey -> ParserWithErrs PrivateKey
inj_PrivateKey :: REP__PrivateKey -> ParserWithErrs PrivateKey
inj_PrivateKey REP__PrivateKey{Integer
PublicKey
_prk_qinv :: Integer
_prk_dQ :: Integer
_prk_dP :: Integer
_prk_q :: Integer
_prk_p :: Integer
_prk_d :: Integer
_prk_pub :: PublicKey
_prk_qinv :: REP__PrivateKey -> Integer
_prk_dQ :: REP__PrivateKey -> Integer
_prk_dP :: REP__PrivateKey -> Integer
_prk_q :: REP__PrivateKey -> Integer
_prk_p :: REP__PrivateKey -> Integer
_prk_d :: REP__PrivateKey -> Integer
_prk_pub :: REP__PrivateKey -> PublicKey
..} =
    PrivateKey -> ParserWithErrs PrivateKey
forall (m :: * -> *) a. Monad m => a -> m a
return
        PrivateKey :: PublicKey
-> Integer
-> Integer
-> Integer
-> Integer
-> Integer
-> Integer
-> PrivateKey
PrivateKey
            { private_pub :: PublicKey
private_pub  = PublicKey
_prk_pub
            , private_d :: Integer
private_d    = Integer
_prk_d
            , private_p :: Integer
private_p    = Integer
_prk_p
            , private_q :: Integer
private_q    = Integer
_prk_q
            , private_dP :: Integer
private_dP   = Integer
_prk_dP
            , private_dQ :: Integer
private_dQ   = Integer
_prk_dQ
            , private_qinv :: Integer
private_qinv = Integer
_prk_qinv
            }

prj_PrivateKey :: PrivateKey -> REP__PrivateKey
prj_PrivateKey :: PrivateKey -> REP__PrivateKey
prj_PrivateKey PrivateKey{Integer
PublicKey
private_qinv :: Integer
private_dQ :: Integer
private_dP :: Integer
private_q :: Integer
private_p :: Integer
private_d :: Integer
private_pub :: PublicKey
private_qinv :: PrivateKey -> Integer
private_dQ :: PrivateKey -> Integer
private_dP :: PrivateKey -> Integer
private_q :: PrivateKey -> Integer
private_p :: PrivateKey -> Integer
private_d :: PrivateKey -> Integer
private_pub :: PrivateKey -> PublicKey
..} =
    REP__PrivateKey :: PublicKey
-> Integer
-> Integer
-> Integer
-> Integer
-> Integer
-> Integer
-> REP__PrivateKey
REP__PrivateKey
        { _prk_pub :: PublicKey
_prk_pub  = PublicKey
private_pub
        , _prk_d :: Integer
_prk_d    = Integer
private_d
        , _prk_p :: Integer
_prk_p    = Integer
private_p
        , _prk_q :: Integer
_prk_q    = Integer
private_q
        , _prk_dP :: Integer
_prk_dP   = Integer
private_dP
        , _prk_dQ :: Integer
_prk_dQ   = Integer
private_dQ
        , _prk_qinv :: Integer
_prk_qinv = Integer
private_qinv
        }


e2p :: E a -> ParserWithErrs a
e2p :: E a -> ParserWithErrs a
e2p = (Reason -> ParserWithErrs a)
-> (a -> ParserWithErrs a) -> E a -> ParserWithErrs a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> ParserWithErrs a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> ParserWithErrs a)
-> (Reason -> String) -> Reason -> ParserWithErrs a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reason -> String
showReason) a -> ParserWithErrs a
forall (m :: * -> *) a. Monad m => a -> m a
return

data Dirctn
    = Encrypting
    | Decrypting
    deriving (Int -> Dirctn -> ShowS
[Dirctn] -> ShowS
Dirctn -> String
(Int -> Dirctn -> ShowS)
-> (Dirctn -> String) -> ([Dirctn] -> ShowS) -> Show Dirctn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dirctn] -> ShowS
$cshowList :: [Dirctn] -> ShowS
show :: Dirctn -> String
$cshow :: Dirctn -> String
showsPrec :: Int -> Dirctn -> ShowS
$cshowsPrec :: Int -> Dirctn -> ShowS
Show)


pbkdf :: HashPRF
      -> ClearText
      -> Salt
      -> Iterations
      -> Octets
      -> (B.ByteString->a)
      -> a
pbkdf :: HashPRF
-> ClearText
-> Salt
-> Iterations
-> Octets
-> (ByteString -> a)
-> a
pbkdf HashPRF
hp (ClearText Binary
dat) (Salt Binary
st) (Iterations Int
k) (Octets Int
wd) ByteString -> a
c =
                                        ByteString -> a
c (ByteString -> a) -> ByteString -> a
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> Int -> Int -> ByteString
fn (Binary -> ByteString
_Binary Binary
dat) (Binary -> ByteString
_Binary Binary
st) Int
k Int
wd
  where
    fn :: ByteString -> ByteString -> Int -> Int -> ByteString
fn = case HashPRF
hp of
           HashPRF
PRF_sha1   -> ByteString -> ByteString -> Int -> Int -> ByteString
P.sha1PBKDF2
           HashPRF
PRF_sha256 -> ByteString -> ByteString -> Int -> Int -> ByteString
P.sha256PBKDF2
           HashPRF
PRF_sha512 -> ByteString -> ByteString -> Int -> Int -> ByteString
P.sha512PBKDF2

keyWidth :: Cipher -> Octets
keyWidth :: Cipher -> Octets
keyWidth Cipher
aes =
    case Cipher
aes of
       Cipher
CPH_aes128   -> Int -> Octets
Octets Int
16
       Cipher
CPH_aes192   -> Int -> Octets
Octets Int
24
       Cipher
CPH_aes256   -> Int -> Octets
Octets Int
32

void_ :: Void
void_ :: Void
void_ = Int -> Void
Void Int
0

map_from_list :: Ord a
              => String
              -> (c->[b])
              -> (b->a)
              -> (a->T.Text)
              -> c
              -> ParserWithErrs (Map.Map a b)
map_from_list :: String
-> (c -> [b])
-> (b -> a)
-> (a -> Text)
-> c
-> ParserWithErrs (Map a b)
map_from_list String
ty c -> [b]
xl b -> a
xf a -> Text
xt c
c =
    case [ a -> Text
xt (a -> Text) -> a -> Text
forall a b. (a -> b) -> a -> b
$ b -> a
xf b
b | b
b:b
_:[b]
_<-[[b]]
obss ] of
      [] -> Map a b -> ParserWithErrs (Map a b)
forall (m :: * -> *) a. Monad m => a -> m a
return (Map a b -> ParserWithErrs (Map a b))
-> Map a b -> ParserWithErrs (Map a b)
forall a b. (a -> b) -> a -> b
$ [(a, b)] -> Map a b
forall k a. [(k, a)] -> Map k a
Map.fromDistinctAscList [(a, b)]
ps
      [Text]
ds -> String -> ParserWithErrs (Map a b)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> ParserWithErrs (Map a b))
-> String -> ParserWithErrs (Map a b)
forall a b. (a -> b) -> a -> b
$ String
ty String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
": " String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Text] -> String
forall a. Show a => a -> String
show [Text]
ds String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"duplicated"
  where
    ps :: [(a, b)]
ps        = [ (b -> a
xf b
b,b
b) | [b
b]<-[[b]]
obss ]

    obss :: [[b]]
obss      = (b -> b -> Bool) -> [b] -> [[b]]
forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy b -> b -> Bool
same ([b] -> [[b]]) -> [b] -> [[b]]
forall a b. (a -> b) -> a -> b
$ (b -> b -> Ordering) -> [b] -> [b]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy ((b -> a) -> b -> b -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing b -> a
xf) ([b] -> [b]) -> [b] -> [b]
forall a b. (a -> b) -> a -> b
$ c -> [b]
xl c
c

    same :: b -> b -> Bool
same b
b b
b' = (b -> a) -> b -> b -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing b -> a
xf b
b b
b' Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ


$(generateAPITools keystoreSchema
                   [ enumTool
                   , jsonTool'
                   , lensTool
                   ])


instance ToJSON KeyStore where
  toJSON :: KeyStore -> Value
toJSON = KeyStore_ -> Value
forall a. ToJSON a => a -> Value
toJSON (KeyStore_ -> Value)
-> (KeyStore -> KeyStore_) -> KeyStore -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KeyStore -> KeyStore_
toKeyStore_

instance FromJSON KeyStore where
  parseJSON :: Value -> Parser KeyStore
parseJSON = (KeyStore_ -> KeyStore) -> Parser KeyStore_ -> Parser KeyStore
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap KeyStore_ -> KeyStore
fromKeyStore_ (Parser KeyStore_ -> Parser KeyStore)
-> (Value -> Parser KeyStore_) -> Value -> Parser KeyStore
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser KeyStore_
forall a. FromJSON a => Value -> Parser a
parseJSON

instance FromJSONWithErrs KeyStore where
  parseJSONWithErrs :: Value -> ParserWithErrs KeyStore
parseJSONWithErrs = (KeyStore_ -> KeyStore)
-> ParserWithErrs KeyStore_ -> ParserWithErrs KeyStore
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap KeyStore_ -> KeyStore
fromKeyStore_ (ParserWithErrs KeyStore_ -> ParserWithErrs KeyStore)
-> (Value -> ParserWithErrs KeyStore_)
-> Value
-> ParserWithErrs KeyStore
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> ParserWithErrs KeyStore_
forall a. FromJSONWithErrs a => Value -> ParserWithErrs a
parseJSONWithErrs


data KeyStore =
  KeyStore
    { KeyStore -> Configuration
_ks_config :: Configuration
    , KeyStore -> KeyMap
_ks_keymap :: KeyMap
    }
  deriving (Int -> KeyStore -> ShowS
[KeyStore] -> ShowS
KeyStore -> String
(Int -> KeyStore -> ShowS)
-> (KeyStore -> String) -> ([KeyStore] -> ShowS) -> Show KeyStore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [KeyStore] -> ShowS
$cshowList :: [KeyStore] -> ShowS
show :: KeyStore -> String
$cshow :: KeyStore -> String
showsPrec :: Int -> KeyStore -> ShowS
$cshowsPrec :: Int -> KeyStore -> ShowS
Show,KeyStore -> KeyStore -> Bool
(KeyStore -> KeyStore -> Bool)
-> (KeyStore -> KeyStore -> Bool) -> Eq KeyStore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KeyStore -> KeyStore -> Bool
$c/= :: KeyStore -> KeyStore -> Bool
== :: KeyStore -> KeyStore -> Bool
$c== :: KeyStore -> KeyStore -> Bool
Eq)

toKeyStore_ :: KeyStore -> KeyStore_
toKeyStore_ :: KeyStore -> KeyStore_
toKeyStore_ KeyStore{KeyMap
Configuration
_ks_keymap :: KeyMap
_ks_config :: Configuration
_ks_keymap :: KeyStore -> KeyMap
_ks_config :: KeyStore -> Configuration
..} =
  KeyStore_ :: Configuration_ -> KeyMap_ -> KeyStore_
KeyStore_
    { _z_ks_config :: Configuration_
_z_ks_config = Configuration -> Configuration_
toConfiguration_ Configuration
_ks_config
    , _z_ks_keymap :: KeyMap_
_z_ks_keymap = KeyMap -> KeyMap_
toKeyMap_        KeyMap
_ks_keymap
    }

fromKeyStore_ :: KeyStore_ -> KeyStore
fromKeyStore_ :: KeyStore_ -> KeyStore
fromKeyStore_ KeyStore_{KeyMap_
Configuration_
_z_ks_keymap :: KeyMap_
_z_ks_config :: Configuration_
_z_ks_keymap :: KeyStore_ -> KeyMap_
_z_ks_config :: KeyStore_ -> Configuration_
..} =
  KeyStore :: Configuration -> KeyMap -> KeyStore
KeyStore
    { _ks_config :: Configuration
_ks_config = Configuration_ -> Configuration
fromConfiguration_ Configuration_
_z_ks_config
    , _ks_keymap :: KeyMap
_ks_keymap = KeyMap_ -> KeyMap
fromKeyMap_        KeyMap_
_z_ks_keymap
    }

emptyKeyStore :: Configuration -> KeyStore
emptyKeyStore :: Configuration -> KeyStore
emptyKeyStore Configuration
cfg =
  KeyStore :: Configuration -> KeyMap -> KeyStore
KeyStore
      { _ks_config :: Configuration
_ks_config = Configuration
cfg
      , _ks_keymap :: KeyMap
_ks_keymap = KeyMap
emptyKeyMap
      }


data Configuration =
  Configuration
    { Configuration -> Settings
_cfg_settings :: Settings
    , Configuration -> TriggerMap
_cfg_triggers :: TriggerMap
    }
  deriving (Int -> Configuration -> ShowS
[Configuration] -> ShowS
Configuration -> String
(Int -> Configuration -> ShowS)
-> (Configuration -> String)
-> ([Configuration] -> ShowS)
-> Show Configuration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Configuration] -> ShowS
$cshowList :: [Configuration] -> ShowS
show :: Configuration -> String
$cshow :: Configuration -> String
showsPrec :: Int -> Configuration -> ShowS
$cshowsPrec :: Int -> Configuration -> ShowS
Show,Configuration -> Configuration -> Bool
(Configuration -> Configuration -> Bool)
-> (Configuration -> Configuration -> Bool) -> Eq Configuration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Configuration -> Configuration -> Bool
$c/= :: Configuration -> Configuration -> Bool
== :: Configuration -> Configuration -> Bool
$c== :: Configuration -> Configuration -> Bool
Eq)

toConfiguration_ :: Configuration -> Configuration_
toConfiguration_ :: Configuration -> Configuration_
toConfiguration_ Configuration{TriggerMap
Settings
_cfg_triggers :: TriggerMap
_cfg_settings :: Settings
_cfg_triggers :: Configuration -> TriggerMap
_cfg_settings :: Configuration -> Settings
..} =
  Configuration_ :: Settings -> TriggerMap_ -> Configuration_
Configuration_
    { _z_cfg_settings :: Settings
_z_cfg_settings =               Settings
_cfg_settings
    , _z_cfg_triggers :: TriggerMap_
_z_cfg_triggers = TriggerMap -> TriggerMap_
toTriggerMap_ TriggerMap
_cfg_triggers
    }

fromConfiguration_ :: Configuration_ -> Configuration
fromConfiguration_ :: Configuration_ -> Configuration
fromConfiguration_ Configuration_{Settings
TriggerMap_
_z_cfg_triggers :: TriggerMap_
_z_cfg_settings :: Settings
_z_cfg_triggers :: Configuration_ -> TriggerMap_
_z_cfg_settings :: Configuration_ -> Settings
..} =
  Configuration :: Settings -> TriggerMap -> Configuration
Configuration
    { _cfg_settings :: Settings
_cfg_settings =                 Settings
_z_cfg_settings
    , _cfg_triggers :: TriggerMap
_cfg_triggers = TriggerMap_ -> TriggerMap
fromTriggerMap_ TriggerMap_
_z_cfg_triggers
    }

defaultConfiguration :: Settings -> Configuration
defaultConfiguration :: Settings -> Configuration
defaultConfiguration Settings
stgs =
  Configuration :: Settings -> TriggerMap -> Configuration
Configuration
    { _cfg_settings :: Settings
_cfg_settings = Settings
stgs
    , _cfg_triggers :: TriggerMap
_cfg_triggers = TriggerMap
forall k a. Map k a
Map.empty
    }


type TriggerMap = Map.Map TriggerID Trigger

toTriggerMap_ :: TriggerMap -> TriggerMap_
toTriggerMap_ :: TriggerMap -> TriggerMap_
toTriggerMap_ TriggerMap
mp = [Trigger] -> TriggerMap_
TriggerMap_ ([Trigger] -> TriggerMap_) -> [Trigger] -> TriggerMap_
forall a b. (a -> b) -> a -> b
$ TriggerMap -> [Trigger]
forall k a. Map k a -> [a]
Map.elems TriggerMap
mp

fromTriggerMap_ :: TriggerMap_ -> TriggerMap
fromTriggerMap_ :: TriggerMap_ -> TriggerMap
fromTriggerMap_ TriggerMap_{[Trigger]
_z_tmp_map :: [Trigger]
_z_tmp_map :: TriggerMap_ -> [Trigger]
..} = [(TriggerID, Trigger)] -> TriggerMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
  [ (,) TriggerID
_trg_id Trigger
trg
    | trg :: Trigger
trg@Trigger{Settings
Pattern
TriggerID
_trg_settings :: Settings
_trg_pattern :: Pattern
_trg_id :: TriggerID
_trg_settings :: Trigger -> Settings
_trg_pattern :: Trigger -> Pattern
_trg_id :: Trigger -> TriggerID
..} <- [Trigger]
_z_tmp_map
    ]


type KeyMap = Map.Map Name Key

toKeyMap_ :: KeyMap -> KeyMap_
toKeyMap_ :: KeyMap -> KeyMap_
toKeyMap_ KeyMap
mp = [NameKeyAssoc_] -> KeyMap_
KeyMap_ ([NameKeyAssoc_] -> KeyMap_) -> [NameKeyAssoc_] -> KeyMap_
forall a b. (a -> b) -> a -> b
$
  [ Name -> Key_ -> NameKeyAssoc_
NameKeyAssoc_ Name
nm (Key_ -> NameKeyAssoc_) -> Key_ -> NameKeyAssoc_
forall a b. (a -> b) -> a -> b
$ Key -> Key_
toKey_ Key
ky
    | (Name
nm,Key
ky) <- KeyMap -> [(Name, Key)]
forall k a. Map k a -> [(k, a)]
Map.assocs KeyMap
mp
    ]

fromKeyMap_ :: KeyMap_ -> KeyMap
fromKeyMap_ :: KeyMap_ -> KeyMap
fromKeyMap_ KeyMap_
mp_ = [(Name, Key)] -> KeyMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
  [ (Name
_z_nka_name,Key_ -> Key
fromKey_ Key_
_z_nka_key)
    | NameKeyAssoc_{Name
Key_
_z_nka_key :: Key_
_z_nka_name :: Name
_z_nka_key :: NameKeyAssoc_ -> Key_
_z_nka_name :: NameKeyAssoc_ -> Name
..} <- KeyMap_ -> [NameKeyAssoc_]
_z_kmp_map KeyMap_
mp_
    ]

emptyKeyMap :: KeyMap
emptyKeyMap :: KeyMap
emptyKeyMap = KeyMap
forall k a. Map k a
Map.empty


data Key =
  Key
    { Key -> Name
_key_name          :: Name
    , Key -> Comment
_key_comment       :: Comment
    , Key -> Identity
_key_identity      :: Identity
    , Key -> Bool
_key_is_binary     :: Bool
    , Key -> Maybe EnvVar
_key_env_var       :: Maybe EnvVar
    , Key -> Maybe Hash
_key_hash          :: Maybe Hash
    , Key -> Maybe PublicKey
_key_public        :: Maybe PublicKey
    , Key -> EncrypedCopyMap
_key_secret_copies :: EncrypedCopyMap
    , Key -> Maybe ClearText
_key_clear_text    :: Maybe ClearText
    , Key -> Maybe PrivateKey
_key_clear_private :: Maybe PrivateKey
    , Key -> UTCTime
_key_created_at    :: UTCTime
    }
  deriving (Int -> Key -> ShowS
[Key] -> ShowS
Key -> String
(Int -> Key -> ShowS)
-> (Key -> String) -> ([Key] -> ShowS) -> Show Key
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Key] -> ShowS
$cshowList :: [Key] -> ShowS
show :: Key -> String
$cshow :: Key -> String
showsPrec :: Int -> Key -> ShowS
$cshowsPrec :: Int -> Key -> ShowS
Show,Key -> Key -> Bool
(Key -> Key -> Bool) -> (Key -> Key -> Bool) -> Eq Key
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Key -> Key -> Bool
$c/= :: Key -> Key -> Bool
== :: Key -> Key -> Bool
$c== :: Key -> Key -> Bool
Eq)

toKey_ :: Key -> Key_
toKey_ :: Key -> Key_
toKey_ Key{Bool
Maybe PublicKey
Maybe PrivateKey
Maybe ClearText
Maybe EnvVar
Maybe Hash
UTCTime
EncrypedCopyMap
Name
Comment
Identity
_key_created_at :: UTCTime
_key_clear_private :: Maybe PrivateKey
_key_clear_text :: Maybe ClearText
_key_secret_copies :: EncrypedCopyMap
_key_public :: Maybe PublicKey
_key_hash :: Maybe Hash
_key_env_var :: Maybe EnvVar
_key_is_binary :: Bool
_key_identity :: Identity
_key_comment :: Comment
_key_name :: Name
_key_created_at :: Key -> UTCTime
_key_clear_private :: Key -> Maybe PrivateKey
_key_clear_text :: Key -> Maybe ClearText
_key_secret_copies :: Key -> EncrypedCopyMap
_key_public :: Key -> Maybe PublicKey
_key_hash :: Key -> Maybe Hash
_key_env_var :: Key -> Maybe EnvVar
_key_is_binary :: Key -> Bool
_key_identity :: Key -> Identity
_key_comment :: Key -> Comment
_key_name :: Key -> Name
..} =
  Key_ :: Name
-> Comment
-> Identity
-> Bool
-> Maybe EnvVar
-> Maybe Hash
-> Maybe PublicKey
-> EncrypedCopyMap_
-> Maybe ClearText
-> Maybe PrivateKey
-> UTC
-> Key_
Key_
    { _z_key_name :: Name
_z_key_name          =                   Name
_key_name
    , _z_key_comment :: Comment
_z_key_comment       =                   Comment
_key_comment
    , _z_key_identity :: Identity
_z_key_identity      =                   Identity
_key_identity
    , _z_key_is_binary :: Bool
_z_key_is_binary     =                   Bool
_key_is_binary
    , _z_key_env_var :: Maybe EnvVar
_z_key_env_var       =                   Maybe EnvVar
_key_env_var
    , _z_key_hash :: Maybe Hash
_z_key_hash          =                   Maybe Hash
_key_hash
    , _z_key_public :: Maybe PublicKey
_z_key_public        =                   Maybe PublicKey
_key_public
    , _z_key_secret_copies :: EncrypedCopyMap_
_z_key_secret_copies = EncrypedCopyMap -> EncrypedCopyMap_
toEncrypedCopyMap EncrypedCopyMap
_key_secret_copies
    , _z_key_clear_text :: Maybe ClearText
_z_key_clear_text    =                   Maybe ClearText
_key_clear_text
    , _z_key_clear_private :: Maybe PrivateKey
_z_key_clear_private =                   Maybe PrivateKey
_key_clear_private
    , _z_key_created_at :: UTC
_z_key_created_at    = UTCTime -> UTC
UTC               UTCTime
_key_created_at
    }

fromKey_ :: Key_ -> Key
fromKey_ :: Key_ -> Key
fromKey_ Key_{Bool
Maybe PublicKey
Maybe PrivateKey
Maybe ClearText
Maybe EnvVar
Maybe Hash
Name
UTC
Comment
Identity
EncrypedCopyMap_
_z_key_created_at :: UTC
_z_key_clear_private :: Maybe PrivateKey
_z_key_clear_text :: Maybe ClearText
_z_key_secret_copies :: EncrypedCopyMap_
_z_key_public :: Maybe PublicKey
_z_key_hash :: Maybe Hash
_z_key_env_var :: Maybe EnvVar
_z_key_is_binary :: Bool
_z_key_identity :: Identity
_z_key_comment :: Comment
_z_key_name :: Name
_z_key_created_at :: Key_ -> UTC
_z_key_clear_private :: Key_ -> Maybe PrivateKey
_z_key_clear_text :: Key_ -> Maybe ClearText
_z_key_secret_copies :: Key_ -> EncrypedCopyMap_
_z_key_public :: Key_ -> Maybe PublicKey
_z_key_hash :: Key_ -> Maybe Hash
_z_key_env_var :: Key_ -> Maybe EnvVar
_z_key_is_binary :: Key_ -> Bool
_z_key_identity :: Key_ -> Identity
_z_key_comment :: Key_ -> Comment
_z_key_name :: Key_ -> Name
..} =
  Key :: Name
-> Comment
-> Identity
-> Bool
-> Maybe EnvVar
-> Maybe Hash
-> Maybe PublicKey
-> EncrypedCopyMap
-> Maybe ClearText
-> Maybe PrivateKey
-> UTCTime
-> Key
Key
    { _key_name :: Name
_key_name          =                     Name
_z_key_name
    , _key_comment :: Comment
_key_comment       =                     Comment
_z_key_comment
    , _key_identity :: Identity
_key_identity      =                     Identity
_z_key_identity
    , _key_is_binary :: Bool
_key_is_binary     =                     Bool
_z_key_is_binary
    , _key_env_var :: Maybe EnvVar
_key_env_var       =                     Maybe EnvVar
_z_key_env_var
    , _key_hash :: Maybe Hash
_key_hash          =                     Maybe Hash
_z_key_hash
    , _key_public :: Maybe PublicKey
_key_public        =                     Maybe PublicKey
_z_key_public
    , _key_secret_copies :: EncrypedCopyMap
_key_secret_copies = EncrypedCopyMap_ -> EncrypedCopyMap
fromEncrypedCopyMap EncrypedCopyMap_
_z_key_secret_copies
    , _key_clear_text :: Maybe ClearText
_key_clear_text    =                     Maybe ClearText
_z_key_clear_text
    , _key_clear_private :: Maybe PrivateKey
_key_clear_private =                     Maybe PrivateKey
_z_key_clear_private
    , _key_created_at :: UTCTime
_key_created_at    = UTC -> UTCTime
_UTC                UTC
_z_key_created_at
    }


type EncrypedCopyMap = Map.Map Safeguard EncrypedCopy

toEncrypedCopyMap :: EncrypedCopyMap -> EncrypedCopyMap_
toEncrypedCopyMap :: EncrypedCopyMap -> EncrypedCopyMap_
toEncrypedCopyMap EncrypedCopyMap
mp = [EncrypedCopy] -> EncrypedCopyMap_
EncrypedCopyMap_ ([EncrypedCopy] -> EncrypedCopyMap_)
-> [EncrypedCopy] -> EncrypedCopyMap_
forall a b. (a -> b) -> a -> b
$ EncrypedCopyMap -> [EncrypedCopy]
forall k a. Map k a -> [a]
Map.elems EncrypedCopyMap
mp

fromEncrypedCopyMap :: EncrypedCopyMap_ -> EncrypedCopyMap
fromEncrypedCopyMap :: EncrypedCopyMap_ -> EncrypedCopyMap
fromEncrypedCopyMap EncrypedCopyMap_{[EncrypedCopy]
_z_ecm_map :: [EncrypedCopy]
_z_ecm_map :: EncrypedCopyMap_ -> [EncrypedCopy]
..} = [(Safeguard, EncrypedCopy)] -> EncrypedCopyMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
  [ (,) Safeguard
_ec_safeguard EncrypedCopy
ec
    | ec :: EncrypedCopy
ec@EncrypedCopy{Safeguard
Salt
Iterations
HashPRF
Cipher
EncrypedCopyData
_ec_secret_data :: EncrypedCopyData
_ec_salt :: Salt
_ec_iterations :: Iterations
_ec_prf :: HashPRF
_ec_cipher :: Cipher
_ec_safeguard :: Safeguard
_ec_secret_data :: EncrypedCopy -> EncrypedCopyData
_ec_salt :: EncrypedCopy -> Salt
_ec_iterations :: EncrypedCopy -> Iterations
_ec_prf :: EncrypedCopy -> HashPRF
_ec_cipher :: EncrypedCopy -> Cipher
_ec_safeguard :: EncrypedCopy -> Safeguard
..} <- [EncrypedCopy]
_z_ecm_map
    ]


L.makeLenses ''KeyStore
L.makeLenses ''Configuration
L.makeLenses ''Key