path: root/kiki.hs

{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE ViewPatterns  #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE CPP #-}
module Main ( main ) where

import Control.Applicative
import Control.Monad
import Data.ASN1.BinaryEncoding
import Data.ASN1.Encoding
import Data.ASN1.Types
import Data.Binary
import Data.Bits
import Data.Char
import Data.IORef
import Data.List
import Data.Maybe
import Data.OpenPGP
import Data.Ord
import Data.Text.Encoding
-- import System.Posix.User
import System.FilePath.Posix
import System.Directory
import System.Environment
import System.Exit
import System.IO (hPutStrLn,stderr)
import qualified Codec.Binary.Base64 as Base64
import qualified Crypto.Hash.RIPEMD160 as RIPEMD160
import qualified Crypto.Hash.SHA256    as SHA256
import qualified Data.ByteString      as S
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Lazy.Char8 as Char8
import qualified Data.Map as Map
import Control.Arrow   (first,second)
import Data.Binary.Get (runGet)
import Data.Binary.Put (putWord32be,runPut,putByteString)
import Data.Time.Clock.POSIX ( posixSecondsToUTCTime )
import Data.Monoid ( (<>) )

import Data.OpenPGP.Util (verify,fingerprint)
import ScanningParser
import PEM
import DotLock
import LengthPrefixedBE
import KeyRing
import Base58
import qualified CryptoCoins
-- import Chroot
import ProcessUtils

-- {-# ANN module ("HLint: ignore Eta reduce"::String) #-}
-- {-# ANN module ("HLint: ignore Use camelCase"::String) #-}

{-
 -
 -
    accBindings :: forall t a a1 a2.
                   Bits t =>
                   [(t, (Packet, Packet), [a], [a1], [a2])]
                   -> [(t, (Packet, Packet), [a], [a1], [a2])]
    bitcoinAddress :: Word8 -> Packet -> String
    cannonical_eckey :: forall b b1.
                        (Integral b1, Integral b) =>
                        b -> b1 -> [Word8]
    commands :: [(String, String)]
    decode_sshrsa :: Char8.ByteString -> Maybe RSAPublicKey
    disjoint_fp :: [Packet] -> [[Packet]]
    doAutosign :: forall t. t -> KeyData -> [PacketUpdate]
    fpmatch :: Maybe [Char] -> Packet -> Bool
    getBindings :: [Packet]
                   -> ([([Packet], [SignatureOver])],
                       [(Word8,
                         (Packet, Packet),
                         [String],
                         [SignatureSubpacket],
                         [Packet])])
    isCertificationSig :: SignatureOver -> Bool
    isSubkeySignature :: SignatureOver -> Bool
    kiki :: forall a.
            (Eq a, Data.String.IsString a) =>
            a -> [[Char]] -> IO ()
    kiki_sync_help :: IO ()
    listKeys :: [Packet] -> [Char]
    listKeysFiltered :: [[Char]] -> [Packet] -> [Char]
    :Main.main :: IO ()
    main :: IO ()
    partitionStaticArguments :: forall a.
                                Ord a =>
                                [(a, Int)] -> [a] -> ([[a]], [a])
    readPublicKey :: Char8.ByteString -> RSAPublicKey
    show_all :: KeyDB -> IO ()
    show_id :: forall t.
                String -> t -> Map.Map KeyRing.KeyKey KeyData -> IO ()
    show_pem :: String -> String -> KeyDB -> IO ()
    show_ssh :: String -> String -> KeyDB -> IO ()
    show_whose_key :: Maybe RSAPublicKey -> KeyDB -> IO ()
    show_wip :: String -> String -> KeyDB -> IO ()
    show_wk :: FilePath
               -> Maybe [Char] -> Map.Map KeyRing.KeyKey KeyData -> IO ()
    smallpr :: Packet -> [Char]
    sshrsa :: Integer -> Integer -> Char8.ByteString
    toLast :: forall x. (x -> x) -> [x] -> [x]
    verifyBindings :: [Packet]
                      -> [Packet] -> ([SignatureOver], [SignatureOver])
    warn :: String -> IO ()
    whoseKey :: RSAPublicKey -> KeyDB -> [KeyData]
 -
 -
 -}

warn str = hPutStrLn stderr str

sshrsa :: Integer -> Integer -> Char8.ByteString
sshrsa e n = runPut $ do
    putWord32be 7
    putByteString "ssh-rsa"
    put (LengthPrefixedBE e)
    put (LengthPrefixedBE n)

decode_sshrsa :: Char8.ByteString -> Maybe RSAPublicKey
decode_sshrsa bs = do
    let (pre,bs1) = Char8.splitAt 11 bs
    guard $ pre == runPut (putWord32be 7 >> putByteString "ssh-rsa")
    let rsakey = flip runGet bs1 $ do
            LengthPrefixedBE e <- get
            LengthPrefixedBE n <- get
            return $ RSAKey (MPI n) (MPI e)
    return rsakey

isCertificationSig (CertificationSignature {}) = True
isCertificationSig _                           = True

fpmatch grip key =
    (==) Nothing
         (fmap (backend (fingerprint key)) grip >>= guard . not)
 where
    backend xs ys = and $ zipWith (==) (reverse xs) (reverse ys)

listKeys pkts = listKeysFiltered [] pkts

listKeysFiltered grips pkts = do
    -- FIXME: Will not show any output when there are no subkeys.
    let (certs,bs) = getBindings pkts
        as = accBindings bs
        defaultkind (k:_) hs = k
        defaultkind []    hs = fromMaybe "subkey"
                                     ( listToMaybe
                                     . mapMaybe (fmap usageString . keyflags)
                                     $ hs)
        kinds = map (\(_,_,k,h,_)->defaultkind k h) as
        kindwidth = maximum $ map length kinds
        kindcol = min 20 kindwidth
        code (c,(m,s),_,_,_) = (fingerprint_material m,-c)
        ownerkey (_,(a,_),_,_,_) = a
        sameMaster (ownerkey->a) (ownerkey->b) = fingerprint_material a==fingerprint_material b
        matchgrip _ | null grips = True
        matchgrip ((code,(top,sub), kind, hashed,claimants):_) | any (flip fpmatch top . Just) grips = True
        matchgrip _ = False
        gs = filter matchgrip $ groupBy sameMaster (sortBy (comparing code) as)
        showsigs claimants = map (\k -> "      " ++ "^ signed: " ++ fingerprint k) claimants
    subs@((_,(top,_),_,_,_):_) <- gs
    let subkeys = do
            (code,(top,sub), kind, hashed,claimants) <- subs
            let ar = case code of
                        0 -> " ??? "
                        1 -> " --> "
                        2 -> " <-- "
                        3 -> " <-> "
                formkind = take kindcol $ defaultkind kind hashed ++ repeat ' '
                -- torhash = fromMaybe "" $ derToBase32 <$> derRSA sub
                (netid,kind') = maybe (0x0,"bitcoin")
                                      (\n->(CryptoCoins.publicByteFromName n,n))
                                      $ listToMaybe kind
            unlines $
                concat  [ " "
                        -- , grip top
                        , ar
                        , formkind
                        , " "
                        , fingerprint sub
                        , " " ++ (torhash sub)
                        -- , " " ++ (concatMap (printf "%02X") $ S.unpack (ecc_curve sub))
                        ] -- ++ ppShow hashed
                    : if isCryptoCoinKey sub
                        -- then ("      " ++ "B⃦ " ++ bitcoinAddress sub) : showsigs claimants
                        -- then ("      " ++ "BTC " ++ bitcoinAddress sub) : showsigs claimants
                        then ("      " ++ "¢ "++kind'++":" ++ bitcoinAddress netid sub) : showsigs claimants
                        else showsigs claimants
        torkeys = do
            (code,(top,sub), kind, hashed,claimants) <- subs
            guard ("tor" `elem` kind)
            guard (code .&. 0x2 /= 0)
            maybeToList $ derToBase32 <$> derRSA sub
        uid = {- fromMaybe "" . listToMaybe $ -} do
            (keys,sigs) <- certs
            sig <- sigs
            guard (isCertificationSig sig)
            guard (topkey sig == top)
            let issuers = do
                    sig_over <- signatures_over sig
                    i <- maybeToList $ signature_issuer sig_over
                    maybeToList $ find_key (matchpr i) (Message keys) (reverse (take 16 (reverse i)))
                (primary,secondary) = partition (==top) issuers

            -- trace ("PRIMARY: "++show (map fingerprint primary)) $ return ()
            -- trace ("SECONDARY: "++show (map fingerprint secondary)) $ return ()
            guard (not (null primary))

            let UserIDPacket uid = user_id sig
                parsed = parseUID uid
                ar = maybe " --> " (const " <-> ") $ do
                        guard (uid_topdomain parsed == "onion" )
                        guard ( uid_realname parsed `elem` ["","Anonymous"])
                        guard (     uid_user parsed == "root" )
                        let subdom0 = L.fromChunks [encodeUtf8 (uid_subdomain parsed)]
                            len = L.length subdom0
                            subdom = Char8.unpack subdom0
                            match = (==subdom) . take (fromIntegral len)
                        guard (len >= 16)
                        listToMaybe $ filter match torkeys
            unlines $  (" " ++ ar ++ "@" ++ " " ++ uid_full parsed) : showsigs secondary
        -- (_,sigs) = unzip certs
    "master-key " ++ fingerprint top ++ "\n" ++ uid ++"  ...\n" ++ subkeys ++ "\n"


{-
 - modify a UID to test the verify function properly
 - fails
modifyUID (UserIDPacket str) = UserIDPacket str'
 where
    (fstname,rst) = break (==' ') str
    str' = mod fstname ++ rst
    mod "Bob" = "Bob Slacking"
    mod x     = x
modifyUID other              = other
-}

readPublicKey :: Char8.ByteString -> RSAPublicKey
readPublicKey bs = fromMaybe er $ do
    let (pre,bs1) = Char8.splitAt 7 bs
    guard $ pre == "ssh-rsa"
    let (sp,bs2) = Char8.span isSpace bs1
    guard $ not (Char8.null sp)
    bs3 <- listToMaybe $ Char8.words bs2
    qq <- L.pack `fmap` Base64.decode (Char8.unpack bs3)
    decode_sshrsa qq
 where
    er = error "Unsupported key format"

-- | Returns the given list with its last element modified.
toLast :: (x -> x) -> [x] -> [x]
toLast f []  = []
toLast f [x] = [f x]
toLast f (x:xs) = x : toLast f xs

-- partitionStaticArguments :: Ord a => [(a, Int)] -> [a] -> ([[a]], [a])
partitionStaticArguments specs args = psa args
 where
    smap = Map.fromList specs
    psa [] = ([],[])
    psa (a:as) =
      case Map.lookup a smap of
        Nothing -> second (a:) $ psa as
        Just n  -> first ((a:take n as):) $ psa (drop n as)

show_wk secring_file grip db = do
    let sec_db = Map.filter gripmatch db
        gripmatch (KeyData p _ _ _) =
            Map.member secring_file (locations p)
            || Map.member "&secret" (locations p)
        Message sec = flattenKeys False sec_db
    putStrLn $ listKeysFiltered (maybeToList grip) sec

show_all db = do
    let Message packets = flattenKeys True db
    putStrLn $ listKeys packets

show_whose_key input_key db =
    flip (maybe $ return ()) input_key $ \input_key -> do
    let ks = whoseKey input_key db
    case ks of
        [KeyData k _ uids _] -> do
            putStrLn $ fingerprint (packet k)
            mapM_ putStrLn $ Map.keys uids
        (_:_) -> error "ambiguous"
        [] -> return ()

show_pem keyspec wkgrip db = do
    let s = parseSpec wkgrip keyspec
    flip (maybe . void $ warn (keyspec ++ ": not found"))
         (selectPublicKey s db)
         $ \k -> do
    let rsa = pkcs8 . fromJust $ rsaKeyFromPacket k
        der = encodeASN1 DER (toASN1 rsa [])
        qq  = Base64.encode (L.unpack der)
    putStrLn $
        writePEM "PUBLIC KEY" qq -- ("TODO "++show keyspec)

show_ssh keyspec wkgrip db = either warn putStrLn $ show_ssh' keyspec wkgrip db

show_ssh' keyspec wkgrip db = do
    let s = parseSpec wkgrip keyspec
    flip (maybe . Left $ keyspec ++ ": not found")
         (selectPublicKey s db)
         $ \k -> do
    let Just (RSAKey (MPI n) (MPI e)) = rsaKeyFromPacket k
        bs = sshrsa e n
        blob = Base64.encode (L.unpack bs)
    return $ "ssh-rsa " ++ blob

show_id keyspec wkgrip db = do
    let s = parseSpec "" keyspec
    let ps = do
            (_,k) <- filterMatches (fst s) (Map.toList db)
            mp <- flattenTop "" True k
            return $ packet mp
    -- putStrLn $ "show key " ++ show s
    putStrLn $ listKeys ps

show_wip keyspec wkgrip db = do
    let s = parseSpec wkgrip keyspec
    flip (maybe $ void (warn (keyspec ++ ": not found")))
         (selectSecretKey s db)
         $ \k -> do
    let nwb = maybe 0x80 CryptoCoins.secretByteFromName $ snd s
    putStrLn $ walletImportFormat nwb k

show_torhash pubkey _ = do
    bs <- Char8.readFile pubkey 
    let parsekey f dta  = do
            let mdta = L.pack <$> Base64.decode (Char8.unpack dta)
            e <- decodeASN1 DER <$> mdta
            asn1 <- either (const Nothing) (Just) e
            k <- either (const Nothing) (Just . fst) (fromASN1 asn1)
            return $ f (packetFromPublicRSAKey undefined) k
        addy hsh = take 16 hsh ++ ".onion " ++ hsh
        pkcs1 = fmap ( parsekey (\f (RSAKey n e)  -> f n e) . pemBlob )
                     $ pemParser (Just "RSA PUBLIC KEY")
        pkcs8 = fmap ( parsekey (\f (RSAKey8 n e) -> f n e) . pemBlob )
                     $ pemParser (Just "PUBLIC KEY")
        cert = fmap (fmap pcertKey . parseCertBlob False . pemBlob)
                     $ pemParser (Just "CERTIFICATE")
        keys = catMaybes $ scanAndParse (pkcs1 <> pkcs8 <> cert) $ Char8.lines bs
    mapM_ (putStrLn . addy . torhash) keys

show_cert keyspec wkgrip db = do
    let s = parseSpec wkgrip keyspec
    case selectPublicKeyAndSigs s db of
        [] -> void $ warn (keyspec ++ ": not found")
        [(k,sigs)] -> do
            {-
            let rsa = pkcs8 . fromJust $ rsaKeyFromPacket k
                der = encodeASN1 DER (toASN1 rsa [])
                qq  = Base64.encode (L.unpack der)
            putStrLn $ writePEM "PUBLIC KEY (TODO: CERT)" qq -- ("TODO "++show keyspec)
            -}
            let cs = mapMaybe x509cert $ (sigs >>= hashed_subpackets)
                ds = map decodeBlob $ map (ParsedCert k (posixSecondsToUTCTime $ fromIntegral $ timestamp k)) cs
                qqs = map (Base64.encode . L.unpack) ds
                pems = map (writePEM "CERTIFICATE") qqs
            forM_ pems putStrLn
        _ -> void $ warn (keyspec ++ ": ambiguous")
    
{-
show_cert certfile _ = do
    bs <- Char8.readFile certfile
    let dta = scanAndParse (fmap pemBlob $ pemParser $ Just "CERTIFICATE") $ Char8.lines bs
        mdta = do
            dta <- listToMaybe dta
            L.pack <$> Base64.decode (Char8.unpack dta)
    let c = mdta >>= parseCertBlob True
        d = mdta >>= parseCertBlob False
        -- e = mdta >>= parseCertBlob 2
        -- b64 = Base64.encode . S.unpack
        b64L = Base64.encode . L.unpack
        -- hex = Base16.encode . S.unpack
        hexL = Base16.encode . L.unpack
    putStrLn $ maybe "" (fingerprint . pcertKey) c
    putStrLn $ maybe "" (torhash . pcertKey) c
    putStrLn ""
    putStrLn ""
    putStrLn $ maybe "" (("key = " ++) . show . pcertKey) c
    putStrLn ""
    putStrLn $ maybe "" (("small blob length = " ++) . show . L.length . pcertBlob) c
    putStrLn $ maybe "" (("small blob = " ++) . b64L . pcertBlob) c
    putStrLn $ maybe "" (("   decoded = " ++) . b64L . decodeBlob) c
    putStrLn ""
    putStrLn $ maybe "" (("  big blob length = " ++) . show . L.length . pcertBlob) d
    putStrLn $ maybe "" (("  big blob = " ++) . b64L . pcertBlob) d
    putStrLn $ maybe "" (("   decoded = " ++) . b64L . decodeBlob) d
    {-
    putStrLn ""
    putStrLn $ maybe "" ((" gzip blob length = " ++) . show . L.length . pcertBlob) e
    putStrLn ""
    putStrLn $ maybe "" ((" gzip blob = " ++) . b64L . pcertBlob) e
    -}
    -- ASN1 starts: 
    --   1  2  3  4  5  6  7  8
    --   cl....pc.tag..........
    -- Start Sequence tag = 0x10
    -- Start Sequence cl = 0
    let v = encodeASN1 DER [Start Sequence]
    putStrLn ""
    putStrLn $ "prefix = " ++ hexL v
    return ()
-}

cannonical_eckey x y = 0x4:pad32(numToBytes x) ++ pad32(numToBytes y) :: [Word8]
 where
  numToBytes n = reverse $ unfoldr getbyte n
    where
        getbyte d = do
            guard (d/=0)
            let (q,b) = d `divMod` 256
            return (fromIntegral b,q)
  pad32 xs = replicate zlen 0 ++ xs
    where
        zlen = 32 - length xs


bitcoinAddress network_id k = address
    where
            Just (MPI x) = lookup 'x' (key k)
            Just (MPI y) = lookup 'y' (key k)
            pub = cannonical_eckey x y
            hash = S.cons network_id . RIPEMD160.hash . SHA256.hash . S.pack $  pub
            address = base58_encode hash

whoseKey :: RSAPublicKey -> KeyDB -> [KeyData]
whoseKey rsakey db = filter matchkey (Map.elems db)
 where
    matchkey (KeyData k _ _ subs) =
        any (ismatch k) $ Map.elems subs

    ismatch k (SubKey mp sigs) =
          Just rsakey == rsaKeyFromPacket (packet mp)
       && any (check (packet k) (packet mp)) sigs

    check k sub (sig,_) = not . null $ do
        s <- signatures . Message $ [k,sub,packet sig]
        fw <- signatures_over $ verify (Message [k]) s
        subsig <- mapMaybe backsig (unhashed_subpackets $ packet sig)
        subsig_so <- signatures (Message [k,sub,subsig])
        guard (  isSubkeySignature subsig_so
              && isSameKey (topkey subsig_so) k
              && isSameKey (subkey subsig_so) sub )
        s2 <- signatures . Message $ [k,sub,subsig]
        signatures_over $ verify (Message [sub]) s2

    isSameKey a b = sort (key apub) == sort (key bpub)
     where
        apub = secretToPublic a
        bpub = secretToPublic b



kiki_usage bSecret cmd = putStr $
        case cmd of
         "show" -> unlines $
            ["kiki show [options...]"
            ,""
            ,"     show displays infomration about keys stored in the data files which resides in"
            ,"     the home directory (see --homedir)."
            ,""
            ,"     The files pubring.gpg and subring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set."
            ,""
            ,"     Subkeys that are imported with kiki are given an annotation \"usage@\" which"
            ,"     indicates what the key is for.  This tag can be used as a SPEC to select a"
            ,"     particular key.  Master keys may be specified by using fingerprints or by"
            ,"     specifying a substring of an associated UID."
            ,"Options: "
            ] ++ commonOptions ++
                ["     --working"
                ,"           Show fingerprints for the working key (which will be used to"
                ,"           make signatures) and all its subkeys and UID."
                ,""
                ,"     --key SPEC"
                ,"           Show fingerprints for the specified key and all its subkeys"
                ,"           and UID."
                ,""
                ,"     --all Show fingerprints and UIDs and usage tags for all known keys."
                ,""
                ,"     --whose-key"
                ,"           Shows the fingerprint and UIDs of the key that owns the one that"
                ,"           is input on stdin in ssh-rsa format."
                ,""
                ,"     --pem SPEC"
                ,"           Outputs the PKCS #8 public key corresponding to SPEC."
                ,""
                ,"     --cert SPEC"
                ,"           Outputs X509 certificates associated with the key SPEC."
                ,""
                ,"     --ssh SPEC"
                ,"           Outputs the ssh-rsa blob for the specified public key."
                ,""
                ,"     --wip SPEC"
                ,"           Outputs the secret crypto-coin key in Wallet Input Format."
                ,""
                ,"     --torhash FILE"
                ,"           Outputs tor address and base32 hash of the PEM-format key in"
                ,"           the given file."
                ,""
                ,"     --help     Shows this help screen."
                ,""
                ] ++ keyspec
         "sync-secret" -> unlines $
            ["kiki sync-secret [options...]"
            ,""
            ,"     sync-secret merges a set of key files into a combined database and then"
            ,"     uses the database to update all the input files, those inside and outside of"
            ,"     of the home directory (see --homedir), to have the most complete information."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set."
            ,""
            ,"     Subkeys that are imported with kiki are given an annotation \"usage@\" which"
            ,"     indicates what the key is for.  This tag can be used as a SPEC to select a"
            ,"     particular key.  Master keys may be specified by using fingerprints or by"
            ,"     specifying a substring of an associated UID."
            ] ++ syncflags ++ keyspec
         "sync-public" -> unlines $
            ["kiki sync-public [options...]"
            ,""
            ,"     sync-public merges a set of key files into a combined database and then"
            ,"     uses the database to update all the input files, those inside and outside of"
            ,"     of the home directory (see --homedir), to have the most complete information."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set. However, the"
            ,"     difference betwen this command and sync-secret is that no secret keys are"
            ,"     modified by this command regardless of input. Export of secret keys is"
            ,"     possible using this command, but will only occur if the secret master key"
            ,"     is already in the external file. (TODO, remove this capacity entirely)"
            ,""
            ,"     Subkeys that are imported with kiki are given an annotation \"usage@\" which"
            ,"     indicates what the key is for.  This tag can be used as a SPEC to select a"
            ,"     particular key.  Master keys may be specified by using fingerprints or by"
            ,"     specifying a substring of an associated UID."
            ] ++ syncflags ++ keyspec
         "import-secret" -> unlines $
            ["kiki import-secret [options...]"
            ,""
            ,"     import-secret uses a set of key files to update your keyring.  It does not"
            ,"     alter any files outside of the home directory (see --homedir)."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set."
            ,""
            ,"     Subkeys that are imported with kiki are given an annotation \"usage@\" which"
            ,"     indicates what the key is for.  This tag can be used as a SPEC to select a"
            ,"     particular key.  Master keys may be specified by using fingerprints or by"
            ,"     specifying a substring of an associated UID."
            ] ++ syncflags ++ keyspec
         "import-public" -> unlines $
            ["kiki import-public [options...]"
            ,""
            ,"     import-public uses a set of key files to update your keyring.  It does not"
            ,"     alter any files outside of the home directory (see --homedir). Nor does it"
            ,"     alter your secring.gpg file."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set. However, the"
            ,"     difference betwen this command and import-secret is that no secret keys are"
            ,"     modified by this command regardless of input. Export of secret keys is"
            ,"     possible using this command, but will only occur if the secret master key"
            ,"     is already in the external file. (TODO, remove this capacity entirely)"
            ,""
            ,"     Subkeys that are imported with kiki are given an annotation \"usage@\" which"
            ,"     indicates what the key is for.  This tag can be used as a SPEC to select a"
            ,"     particular key.  Master keys may be specified by using fingerprints or by"
            ,"     specifying a substring of an associated UID."
            ] ++ syncflags ++ keyspec
         "export-secret" -> unlines $
            ["kiki export-secret [options...]"
            ,""
            ,"     export-secret updates a set of key files using information from your keyring."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set."
            ,""
            ] ++ syncflags ++ keyspec
         "export-public" -> unlines $
            ["kiki export-public [options...]"
            ,""
            ,"     export-public updates a set of key files using information from your keyring."
            ,""
            ,"     The files pubring.gpg and secring.gpg in the directory specified by the "
            ,"     --homedir option are implicitly included in the keyring set. However, the"
            ,"     difference betwen this command and export-secret is that no secret keys are"
            ,"     exported by this command regardless of input."
            ,""
            ] ++ syncflags ++ keyspec
        where 
            commonOptions :: [String]
            commonOptions =
                ["     --homedir DIR"
                ,"                Where to find the the files secring.gpg and pubring.gpg. The "
                ,"                default location is taken from the environment variable "
                ,"                GNUPGHOME."
                ,""
                ,"     --passphrase-fd N"
                ,"                Read passphrase from the given file descriptor."
                ,""
                ]
            syncflags :: [String]
            syncflags =
                [""
                ,"Flags:"] ++ commonOptions ++
                    ["     --import   Add master keys to pubring.gpg.  Without this option, only UID"
                    ,"                and subkey data is updated. "
                    ,""
                    ,"     --import-if-authentic"
                    ,"                Add signed master keys to pubring.gpg.  Like --import except that"
                    ,"                only keys with signatures from the working key (--show-wk) are"
                    ,"                imported."
                    ,""
                    ,"     --autosign Sign all cross-certified tor-style UIDs."
                    ,"                A tor-style UID is of the form:"
                    ,"                        Anonymous <root@HOSTNAME.onion>"
                    ,"                It is considered cross certified if there exists a cross-certified"
                    ,"                'tor' subkey corresponding to the address HOSTNAME.onion."
                    ,""
                    ,"Merging:"
                    ,"     --keyrings FILE FILE..."
                    ,"                Provide keyring files other than the implicit secring.gpg and"
                    ,"                pubring.gpg in the --homedir.  This option is implicit unless"
                    ,"                --keypairs or --wallets is used."
                    ,""]
                    ++ do
                       guard bSecret
                       return $ unlines
                        ["     --wallets  FILE FILE..."
                        ,"                Provide wallet files with secret crypto-coin keys in Wallet"
                        ,"                Import Format.  The keys will be treated as subkeys of your"
                        ,"                current working key (the one shown by --show-wk)."
                        ,""
                        ,"     --keypairs KEYSPEC KEYSPEC..."
                        ,"                A keypair is a secret key coupled with it's corresponding public"
                        ,"                key, both of which are ordinarily stored in a single file in pem"
                        ,"                format. Users incognisant of the fact that the public key (which"
                        ,"                is also stored separately) is in this file, often think of it as"
                        ,"                their secret key file."
                        ,""
                        ,"                Each KEYSPEC specifies that a key should match the content and"
                        ,"                timestamp of an external PKCS #1 private RSA key file."
                        ,"                "
                        ,"                KEYSPEC ::= SPEC=FILE{CMD} "
                        ,""
                        ,"                The form of SPEC is documented below. If there is only one master"
                        ,"                key in your keyring and only one key is used for each purpose, then"
                        ,"                it is possible for SPEC in this case to merely be a tag which offers"
                        ,"                information about what this key is used for, for example, any of"
                        ,"                `tor', `ssh-client', `ssh-host', or `strongswan' will do."
                        ,""
                        ,"                If neither SPEC or FILE match any keys, then the CMD will be "
                        ,"                executed in order to create the FILE."
                        ,""]
            keyspec = -- unlines $
                 ["Specifying keys on the kiki command line:"
                 ,""
                 ,"  SPEC ::= MASTER/SUBKEY"
                 ,""
                 ,"  SPEC indicates a specific key in the keyring, in it's longest incarnation,"
                 ,"  it is of the form MASTER/SUBKEY where MASTER and SUBKEY are documented below."
                 ,"  If kiki can infer the key unambiguously, either via the command in question or"
                 ,"  the contents of the keyring, then it is permissable to ommit either MASTER or"
                 ,"  SUBKEY, in which case the slash may also be ommitted unless it is used via its"
                 ,"  position to indicate whether a SUBKEY or MASTER is intended."
                 ,""
                 ,"  MASTER may be any of"
                 ,"     * The tail end of a fingerprint prefixed by 'fp:'"
                 ,"     * A sub-string of a user id (without slashes) prefixed by 'u:'"
                 ,"     * 40 characters of hexidecimal (kiki will assume this to be a fingerprint)"
                 ,"     * A sub-string of a user id (without slashes, the prefix 'u:' is optional)"
                 ,""
                 ,"  SUBKEY may be any of"
                 ,"     * The tail end of a fingerprint prefixed by 'fp:'"
                 ,"     * An exact match of a usage tag prefixed by 't:'"
                 ,"     * 40 characters of hexidecimal (kiki will assume this to be a fingerprint)"
                 ,"     * An exact match of a usage tag (The prefix 't:' is optional)"
                 ,""
                 ,"     In parsing the spec, kiki will attempt to match the string to one of the"
                 ,"     above formats, in the order presented."
                 ,""
                 ,"  Examples of valid SPEC strings:"
                 ,""
                 ,"      fp:4A39F/tor"
                 ,"      u:joe/tor"
                 ,"      u:joe/t:tor"
                 ,"      u:joe/fp:4abf30"
                 ,"      joe/tor"
                 ,"      5E24CD442AA6965D2012E62A905C24185D5379C2"
                 ]

processArgs sargspec polyVariadicArgs defaultPoly args_raw = (sargs,margs)
    where
        (args,trail1) = break (=="--") args_raw
        trail = drop 1 trail1
        commonArgSpec = [ ("--homedir",1)
                        , ("--passphrase-fd",1)
                        , ("--help",0)
                        ]
        sargspec' = commonArgSpec ++ sargspec
        (sargs,margs) =
                (sargs, foldl' (\m (k:xs)->Map.alter (appendArgs k xs) k m)
                               Map.empty
                               gargs)
                    where (sargs,vargs) = partitionStaticArguments sargspec' args
                          argspec = map fst sargspec' ++ polyVariadicArgs
                          args' = if map (take 1) (take 1 vargs) == ["-"]
                                    then vargs
                                    else defaultPoly:vargs
                          -- grouped args
                          gargs = (sargs ++)
                                  . toLast (++trail)
                                  . groupBy (\_ s-> take 1 s /= "-")
                                  $ args'
                          appendArgs k xs opt =
                            if k `elem` argspec
                              then Just . maybe xs (++xs) $ opt
                              else error . unlines $ [ "unrecognized option "++k
                                                     , "Use --help for usage." ]

data CommonArgsParsed = CommonArgsParsed { cap_homespec :: Maybe String, cap_passfd :: Maybe InputFile }

parseCommonArgs margs = CommonArgsParsed { cap_homespec = homespec, cap_passfd = passfd }
    where
        passphrase_fd = concat <$> Map.lookup "--passphrase-fd" margs
        homespec = join . take 1 <$> Map.lookup "--homedir" margs
        passfd = fmap (FileDesc . read) passphrase_fd

parseKeySpecs = map $ \specfile -> do
    let (spec,efilecmd) = break (=='=') specfile
    guard $ take 1 efilecmd=="="
    let filecmd = drop 1 efilecmd
    let (file,bcmdb0) = break (=='{') filecmd
        bcmdb = if null bcmdb0 then "{}" else bcmdb0
    guard $ take 1 bcmdb=="{"
    let bdmcb = (dropWhile isSpace . reverse) bcmdb
    guard $ take 1 bdmcb == "}"
    let cmd = (drop 1 . reverse . drop 1) bdmcb
    Just (spec,file,cmd)

--kiki :: (Eq a, Data.String.IsString a) => a -> [String] -> IO ()
sync bExport bImport bSecret cmdarg args_raw = do
    let (sargs,margs) = processArgs sargspec polyVariadicArgs "--keyrings" args_raw
        sargspec = [ ("--import",0)
                   , ("--autosign",0)
                   , ("--import-if-authentic",0)
                   , ("--show-wk",0)
                   {-, ("--show-all",0)
                   , ("--show-whose-key",0)
                   , ("--show-key",1)
                   , ("--show-pem",1)
                   , ("--show-ssh",1)
                   , ("--show-wip",1) -}
                   ]
        polyVariadicArgs = ["--keyrings"
                           ,"--hosts" ]
                           ++ do guard bSecret
                                 [ "--keypairs", "--wallets" ]
    -- putStrLn $ "margs = " ++ show (Map.assocs margs)
    unkeysRef <- newIORef Map.empty
    pwRef <- newIORef Nothing
    let keypairs0 = parseKeySpecs (fromMaybe [] $ Map.lookup "--keypairs" margs)
        keyrings_ = fromMaybe [] $ Map.lookup "--keyrings" margs
        wallets   = fromMaybe [] $ Map.lookup "--wallets" margs
        passphrase_fd = concat <$> Map.lookup "--passphrase-fd" margs

    when (any isNothing keypairs0) $ do
        warn "Syntax error in key pair specification"
        exitFailure

    input_key <- maybe (return Nothing)
                       (const $ fmap (Just . readPublicKey) Char8.getContents)
                    $ Map.lookup "--show-whose-key" margs

    let keypairs = catMaybes keypairs0
        homespec = join . take 1 <$> Map.lookup "--homedir" margs
        passfd = fmap (FileDesc . read) passphrase_fd
        reftyp = if bExport then KF_Subkeys
                            else KF_None
        pems = flip map keypairs 
                $ \(usage,path,cmd) ->
                    let cmd' = mfilter (not . null) (Just cmd)
                    in if bExport
                        then (ArgFile path, StreamInfo { fill = KF_Match usage
                                                       , spill = KF_Match usage
                                                       , typ = PEMFile
                                                       , access = Sec
                                                       , initializer = cmd'
                                                       , transforms = []
                                                       } )
                        else if isNothing cmd'
                                then ( ArgFile path
                                     , (buildStreamInfo KF_None PEMFile)
                                        { spill = KF_Match usage })
                                else error "Unexpected PEM file initializer."
        walts = map (\fname -> ( ArgFile fname
                               , (buildStreamInfo reftyp WalletFile) { access = Sec }))
                    wallets
        rings = map (\fname -> ( ArgFile fname
                               , buildStreamInfo reftyp KeyRingFile ))
                    keyrings_
        hosts = maybe [] (map decorate) $ Map.lookup "--hosts" margs
                    where decorate fname = (ArgFile fname, buildStreamInfo reftyp Hosts)
        pubfill = maybe KF_Subkeys id
                        $ mplus import_f importifauth_f
            where
                import_f       = fmap (const KF_All)
                                   $ Map.lookup "--import" margs
                importifauth_f = fmap (const KF_Authentic)
                                   $ Map.lookup "--import-if-authentic" margs
        buildStreamInfo rtyp ftyp = StreamInfo { typ = ftyp
                                               , fill = rtyp
                                               , spill = KF_All
                                               , access = AutoAccess
                                               , initializer = Nothing
                                               , transforms = [] }
        kikiOp = KeyRingOperation
            { opFiles = Map.fromList $
                [ ( HomeSec, buildStreamInfo (if bSecret && bImport then KF_All
                                                                    else KF_None)
                                             KeyRingFile )
                , ( HomePub, buildStreamInfo (if bImport then pubfill
                                                         else KF_None)
                                             KeyRingFile )
                ]
                ++ rings
                ++ if bSecret then pems else []
                ++ if bSecret then walts else []
                ++ hosts
            , opPassphrases = do pfile <- maybeToList passfd
                                 return $ PassphraseSpec Nothing Nothing pfile
            , opTransforms = maybe [] (const [Autosign]) $ Map.lookup "--autosign" margs
            , opHome = homespec
            }

    (\f -> maybe f (const $ kiki_usage bSecret cmdarg) $ Map.lookup "--help" margs) $ do
    KikiResult rt report <- runKeyRing kikiOp 

    case rt of
      KikiSuccess rt -> do -- interpret --show-* commands.
            let grip = rtGrip rt
            let shspec = Map.fromList [("--show-wk", const $ show_wk (rtSecring rt) grip)
                                      {-,("--show-all",const show_all)
                                      ,("--show-whose-key", const $ show_whose_key input_key)
                                      ,("--show-key",\[x] -> show_id x $ fromMaybe "" grip)
                                      ,("--show-pem",\[x] -> show_pem x $ fromMaybe "" grip)
                                      ,("--show-ssh",\[x] -> show_ssh x $ fromMaybe "" grip)
                                      ,("--show-wip",\[x] -> show_wip x $ fromMaybe "" grip)-}
                                      ]
                shargs = mapMaybe (\(x:xs) -> (,xs) <$> Map.lookup x shspec) sargs

            forM_ shargs $ \(cmd,args) -> cmd args (rtKeyDB rt)
      err -> putStrLn $ errorString err

    forM_ report $ \(fname,act) -> do
        putStrLn $ fname ++ ": " ++ reportString act

kiki "sync-secret" args_raw =
    sync True True True "sync-secret" args_raw

kiki "sync-public" args_raw =
    sync True True False "sync-public" args_raw

kiki "import-secret" args_raw =
    sync False True True "import-secret" args_raw

kiki "import-public" args_raw =
    sync False True False "import-public" args_raw

kiki "export-secret" args_raw =
    sync True False True "export-secret" args_raw

kiki "export-public" args_raw =
    sync True False False "export-public" args_raw

kiki "working-key" args = do
    if "--help" `notElem` args
        then sync False False False "working-key" ["--show-wk"]
        else putStrLn $
            unlines ["working-key"
                    ,""
                    ,"    Displays the master key with its subkeys that will be"
                    ,"    used for making signatures"]

-- Generic help
kiki "help" [] = do
    putStrLn "Valid commands are:"
    let longest = maximum $ map (length . fst) commands
        pad cmd = take (longest+3) $ cmd ++ repeat ' '
    forM commands $ \(cmd,help) -> do
        putStrLn $ "   " ++ pad cmd ++ help
    putStr . unlines $ [""
                       ,"See 'kiki help <command>' for more information on a specific command."
                       ]
    return ()

kiki "help" args = forM_ args $ \arg -> case lookup arg commands of
    Nothing -> putStrLn $ "No help available for commmand '" ++ arg ++ "'."
    _       -> kiki arg ["--help"]

kiki "show" args = do
    let (sargs,margs) = processArgs sargspec polyVariadicArgs "--show" args
        sargspec = [ ("--working",0) --("--show-wk",0)
                   , ("--all",0)     --("--show-all",0)
                   , ("--whose-key",0)
                   , ("--key",1)
                   , ("--pem",1)
                   , ("--ssh",1)
                   , ("--wip",1)
                   , ("--cert",1)
                   , ("--torhash",1)
                   ]
        polyVariadicArgs = ["--show"]
    let cap = parseCommonArgs margs 
        homespec = cap_homespec cap
        passfd = cap_passfd cap
        pems = []
        rings = []
        hosts = []
        walts = []
        streaminfo = StreamInfo { fill = KF_None
                                , typ = KeyRingFile
                                , spill = KF_All
                                , initializer = Nothing
                                , access = AutoAccess
                                , transforms = []
                                }
        kikiOp = KeyRingOperation
            { opFiles = Map.fromList $
                [ ( HomeSec, streaminfo { access = Sec })
                , ( HomePub, streaminfo { access = Pub })
                ]
                ++ rings
                ++ pems 
                ++ walts 
                ++ hosts
            , opPassphrases = do pfile <- maybeToList passfd
                                 return $ PassphraseSpec Nothing Nothing pfile
            , opTransforms = []
            , opHome = homespec
            }

    (\f -> maybe f (const $ kiki_usage False "show") $ Map.lookup "--help" margs) $ do
    KikiResult rt report <- runKeyRing kikiOp 

    input_key <- maybe (return Nothing)
                       (const $ fmap (Just . readPublicKey) Char8.getContents)
                    $ Map.lookup "--whose-key" margs

    case rt of
      KikiSuccess rt -> do -- interpret --show-* commands.
            let grip = rtGrip rt
            let shspec = Map.fromList [("--working", const $ show_wk (rtSecring rt) grip)
                                      ,("--all",const show_all)
                                      ,("--whose-key", const $ show_whose_key input_key)
                                      ,("--key",\[x] -> show_id x $ fromMaybe "" grip)
                                      ,("--pem",\[x] -> show_pem x $ fromMaybe "" grip)
                                      ,("--ssh",\[x] -> show_ssh x $ fromMaybe "" grip)
                                      ,("--wip",\[x] -> show_wip x $ fromMaybe "" grip)
                                      ,("--cert",\[x] -> show_cert x $ fromMaybe "" grip)
                                      ,("--torhash",\[x] -> show_torhash x)
                                      ]
                shargs = mapMaybe (\(x:xs) -> (,xs) <$> Map.lookup x shspec) sargs

            forM_ shargs $ \(cmd,args) -> cmd args (rtKeyDB rt)
      err -> putStrLn $ errorString err

    forM_ report $ \(fname,act) -> do
        putStrLn $ fname ++ ": " ++ reportString act

kiki "merge" [] = do
    putStr . unlines $
        [ "kiki merge [ --passphrase-fd=FD ... ]"
        , "           ( --home[=HOMEDIR]"
        , "           | --type=(keyring|pem|wallet|hosts)"
        , "           | --access=[auto|secret|public]"
        , "           | --flow=(fill|spill|sync)[,(subkeys|match=SPEC)]"
        , "           | --create=CMD"
        , "           | --autosign[=no]"
        , "           | --"
        , "           | FILE ) ..."]
kiki "merge" args | "--help" `elem` args = do
    kiki "merge" []
    -- TODO: more help
kiki "merge" args = do
    KikiResult rt report <- runKeyRing op
    case rt of
      KikiSuccess rt -> return ()
      err            -> putStrLn $ errorString err
    forM_ report $ \(fname,act) -> do
        putStrLn $ fname ++ ": " ++ reportString act
 where
    (_,(_,op)) = foldl' buildOp (True,(flow,noop)) args
    noop = KeyRingOperation
            { opFiles = Map.empty
            , opTransforms = []
            , opHome = Nothing
            , opPassphrases = []
            }
    flow = StreamInfo
            { access = AutoAccess
            , typ = KeyRingFile
            , spill = KF_None
            , fill = KF_None
            , initializer = Nothing
            , transforms = []
            }
    updateFlow fil spil mtch flow = spill' $ fill' $ flow
     where
        fill' flow  = flow { fill  = if fil  then val else KF_None }
        spill' flow = flow { spill = if spil then val else KF_None }
        val = either (\subkeys -> if subkeys then KF_Subkeys else KF_All)
                     KF_Match
                     mtch
    parseFlow spec =
        if null bads
            then Just ( ( "spill" `elem` goods
                         || "sync" `elem` goods
                        , "fill" `elem` goods
                         || "sync" `elem` goods )
                      , maybe (Left $ "subkeys" `elem` goods)
                              Right
                              match )
            else Nothing
     where
        ws = case groupBy (\_ c->c/=',') spec of
                w:xs -> w:map (drop 1) xs
                []   -> []
        (goods,bads) = partition acceptable ws
        acceptable "spill"   = True
        acceptable "fill"    = True
        acceptable "sync"    = True
        acceptable "subkeys" = True
        acceptable s | "match=" `isPrefixOf` s = True
        acceptable _ = False
        match = listToMaybe $ do
            m <- filter ("match=" `isPrefixOf`) goods
            return $ drop 6 m

    doFile :: StreamInfo -> KeyRingOperation -> FilePath -> (StreamInfo,KeyRingOperation)
    doFile flow op fname =
        ( flow
        , op { opFiles= Map.insert (ArgFile fname) flow (opFiles op) })

    doAutosign :: Bool -> StreamInfo -> KeyRingOperation -> (StreamInfo,KeyRingOperation)
    doAutosign True flow op = 
        if Map.null (opFiles op)
            then (flow, op { opTransforms = opTransforms op ++ [Autosign] })
            else (flow { transforms = transforms flow ++ [Autosign] }, op)
    doAutosign False flow op =
        ( flow { transforms = filter (/=Autosign) (transforms flow) }
        , op { opTransforms = filter (/=Autosign) (opTransforms op) } )

    doPassphrase :: StreamInfo -> KeyRingOperation -> String -> (StreamInfo,KeyRingOperation)
    doPassphrase flow op pass =
        if Map.null (opFiles op)
            then ( flow
                 , op { opPassphrases = PassphraseSpec Nothing Nothing pfd
                                        : opPassphrases op } )
            else error "passphrase-fd must come before any file arguments or --home"
     where
        pfd = FileDesc (read pass)

    buildOp (False,(flow,op)) fname = (False,doFile flow op fname)
    buildOp (True,(flow,op)) arg@(splitArg->parsed) =
        case parsed of
            Left ("",Nothing) -> (False,(flow,op))
            _ -> (True,) dispatch
     where
      dispatch =
        case parsed of
            Right fname -> doFile flow op fname
            Left ("autosign",Nothing)     -> doAutosign True  flow op
            Left ("autosign",Just "y")    -> doAutosign True  flow op
            Left ("autosign",Just "yes")  -> doAutosign True  flow op
            Left ("autosign",Just "true") -> doAutosign True  flow op
            Left ("autosign",Just "n")    -> doAutosign False flow op
            Left ("autosign",Just "no")   -> doAutosign False flow op
            Left ("autosign",Just "false")-> doAutosign False flow op
            Left ("passphrase-fd",Just pass) -> doPassphrase flow op pass
            Left ("create",Just cmd) ->
                ( flow { initializer = if null cmd then Nothing else Just cmd }
                , op )
            Left ("type",Just "keyring") -> ( flow { typ = KeyRingFile }, op )
            Left ("type",Just "pem"    ) -> ( flow { typ = PEMFile     }, op )
            Left ("type",Just "wallet" ) -> ( flow { typ = WalletFile  }, op )
            Left ("type",Just "hosts"  ) -> ( flow { typ = Hosts       }, op )
            Left ("access",Just "public") -> ( flow { access = Pub }, op )
            Left ("access",Just "secret") -> ( flow { access = Sec }, op )
            Left ("access",Just "auto")   -> ( flow { access = AutoAccess }, op )
            Left ("home",mb) ->
                ( flow
                , op { opFiles = Map.insert HomePub flow { typ=KeyRingFile
                                                         , access=Pub }
                                 $ Map.insert HomeSec flow { typ=KeyRingFile
                                                           , access=Sec }
                                 $ opFiles op
                     , opHome = opHome op `mplus` mb
                     }
                )
            Left ("flow",Just flowspec) ->
                case parseFlow flowspec of
                    Just ( (fil,spil), mtch ) ->
                        ( updateFlow fil spil mtch flow
                        , op )
                    Nothing -> error "Valid flow words are: spill,fill,sync,subkeys or match=KEYSPEC"
            Left (option,_) -> error $ "Unrecognized option: " ++ option

kiki "init-key" args | "--help" `elem` args = do
    putStr . unlines $
        [ "kiki init-key [ --passphrase-fd=FD"
        , "              | --home[=HOMEDIR]"
        , "              | --chroot=ROOTDIR ] ..."]
    return ()
kiki "init-key" args = do
    {-
    me <- getEffectiveUserID
    if me/=0 then error "This command requires root." else do
    -}
    let as = lefts $ map splitArg args
        lefts = mapMaybe isLeft where { isLeft (Left x) = Just x; isLeft _ = Nothing }
        bads = map fst as \\ ["passphrase-fd","home","chroot"]
    if not (null bads) then error ("Bad option: " ++ unwords bads) else do
    let rootdir = fmap (fromMaybe "") $ lookup "chroot" as
    if rootdir==Just "" then error "--chroot requires an argument" else do
    -- maybe id fchroot rootdir $ do
    args <- return $ map (second $ fromMaybe "") as

    let homespec = mplus ( (++) <$> rootdir <*> lookup "home" args )
                         (fmap (++"/root/.gnupg") rootdir)
        sshkeygen size = Just $ concat [ "mkdir -p \"$(dirname $file)\" && "
                                       , "ssh-keygen -P \"\" -q -f $file -b "
                                       , show size ]
        mkdirFor path = do
            let dir = takeDirectory path
            putStrLn $ "mkdirFor " ++ show dir
            createDirectoryIfMissing True dir
        -- ssl = Just "mkdir -p \"$(dirname $file)\" && openssl genrsa -out $file 1024"
    (home,secring,pubring,mbwk) <- unconditionally $ getHomeDir homespec
    putStrLn $ "home = " ++ show (home,secring,pubring,mbwk)
    gotsec <- doesFileExist secring
    when (not gotsec) $ do
        let mkpath = home ++ "/master-key"
        mkdirFor mkpath
        e <- systemEnv [ ("file",mkpath) ] (fromJust $ sshkeygen 4096)
        case e of
            ExitFailure num -> error "ssh-keygen failed to create master key"
            ExitSuccess     -> return ()
        [PEMPacket mk] <- readSecretPEMFile (ArgFile mkpath)
        writeInputFileL (InputFileContext secring pubring)
                        HomeSec
                        ( encode $ Message [mk { is_subkey = False }] )
    gotpub <- doesFileExist pubring
    when (not gotpub) $ do
        writeInputFileL (InputFileContext secring pubring)
                        HomePub
                        ( encode $ Message [] )

    -- TODO: These should be read from a configuration file
    let torpath = fromMaybe "" rootdir ++ "/var/lib/tor/samizdat/private_key"
        sshcpath0 = fromMaybe "" rootdir ++ "/root/.ssh/id_rsa"
        sshspath0 = fromMaybe "" rootdir ++ "/etc/ssh/ssh_host_rsa_key"
        ipsecpath0 = fromMaybe "" rootdir ++ "/etc/ipsec.d/private/%(onion).pem"
        sshcpathpub0 = fromMaybe "" rootdir ++ "/root/.ssh/id_rsa.pub"
        sshspathpub0 = fromMaybe "" rootdir ++ "/etc/ssh/ssh_host_rsa_key.pub"
        ipsecpathpub0 = fromMaybe "" rootdir ++ "/etc/ipsec.d/certs/%(onion).pem"
    
    -- First, we ensure that the tor key exists and is imported
    -- so that we know where to put the strongswan key.
    let passfd = fmap (FileDesc . read) $ lookup "passphrase-fd" args
        buildStreamInfo rtyp ftyp = StreamInfo { typ = ftyp
                                               , fill = rtyp
                                               , spill = KF_All
                                               , access = AutoAccess
                                               , initializer = Nothing
                                               , transforms = [] }
        peminfo bits usage =
                  StreamInfo { typ = PEMFile
                             , fill = KF_Match usage
                             , spill = KF_Match usage
                             , access = Sec
                             , initializer = sshkeygen bits
                             , transforms = []
                             }
        op = KeyRingOperation
             { opFiles = Map.fromList $
                [ ( HomeSec, buildStreamInfo KF_All KeyRingFile )
                , ( HomePub, (buildStreamInfo KF_All KeyRingFile) { access = Pub } )
                , ( ArgFile torpath, peminfo 1024 "tor" ) ]
             , opPassphrases = do pfd <- maybeToList passfd
                                  return $ PassphraseSpec Nothing Nothing pfd
             , opHome = homespec
             , opTransforms = []
             }
    mkdirFor torpath
    KikiResult rt report <- runKeyRing op
    forM_ report $ \(fname,act) -> do
        putStrLn $ fname ++ ": " ++ reportString act
    rt <- unconditionally $ return rt
    
    -- Now import, export, or generate the remaining secret keys.
    let oname = do wk <- rtWorkingKey rt
                   onionNameForContact (keykey wk) (rtKeyDB rt)
    flip (maybe $ error "Missing tor key") oname $ \oname -> do
    let [ sshcpath , sshspath , ipsecpath ]
            = map (interp (Map.fromList [("onion",oname)]))
                  [ sshcpath0, sshspath0, ipsecpath0 ]
    let op2 = op
             { opFiles = Map.fromList $
                [ ( HomeSec, buildStreamInfo KF_All KeyRingFile )
                , ( HomePub, (buildStreamInfo KF_All KeyRingFile) { access = Pub } )
                , ( ArgFile ipsecpath, peminfo 1024 "strongswan" )
                , ( ArgFile sshcpath, peminfo 2048 "ssh-client" )
                , ( ArgFile sshspath, peminfo 2048 "ssh-server" ) ]
             , opPassphrases = [ PassphraseMemoizer (rtPassphrases rt) ]
             }
    forM_ [sshcpath,sshspath,ipsecpath] mkdirFor
    KikiResult rt report <- runKeyRing op2
    forM_ report $ \(fname,act) -> do
        putStrLn $ fname ++ ": " ++ reportString act
    rt <- unconditionally $ return rt
    
    -- Finally, export public keys if they do not exist.
    flip (maybe $ warn "missing working key?") (rtGrip rt) $ \grip -> do
    -- TODO: the .pub file paths should be read from config also
    gotc <- doesFileExist (sshcpath++".pub")
    when (not gotc) $ do
        either warn (writeFile $ sshcpath++".pub")
            $ show_ssh' "ssh-client" grip (rtKeyDB rt)
    goth <- doesFileExist (sshspath++".pub")
    when (not goth) $ do
        either warn (writeFile $ sshspath++".pub")
            $ show_ssh' "ssh-host" grip (rtKeyDB rt)

    -- TODO: strongswan public /etc/ipsec.d/certs/%(onion).pem

    return ()

splitArg :: String -> Either (String,Maybe String) String
splitArg arg =
    case hyphens of
        ""  -> Right name
        "-" -> error $ "Unrecognized option: " ++ arg
        _   -> Left $ parseLongOption name
 where
    (hyphens, name) = span (=='-') arg
    parseLongOption name = (key,val v)
     where
        (key,v) = break (=='=') name
        val ('=':vs) = Just vs
        val _        = Nothing

commands :: [(String,String)]
commands =
 [ ( "help", "display usage information" )
 --, ( "sync", "update key files of various kinds by propogating information" )
 , ( "show", "display information from your keyrings")
 , ( "sync-secret", "update key files of various kinds by propogating information (both secret and public)" )
 , ( "sync-public", "update key files of various kinds by propogating public information" )
 , ( "import-secret", "import (both public and secret) information into your keyring" )
 , ( "import-public", "import (public) information into your keyring" )
 , ( "export-secret", "export (both public and secret) information into your keyring" )
 , ( "export-public", "import (public) information into your keyring" )
 , ( "working-key", "show the current working master key and its subkeys" )
 , ( "merge", "low level import/export operation" )
 , ( "init-key", "initialize the samizdat key ring")
 ]

interp vars raw = es >>= interp1
 where
    gs = groupBy (\_ c -> c/='%') raw
    es = dropWhile null $ gobbleEscapes ("":gs)
            where gobbleEscapes (a:"%":b:bs) = (a++b) : gobbleEscapes bs
                  gobbleEscapes (g:gs)       = g : gobbleEscapes gs
                  gobbleEscapes []           = []
    interp1 ('%':'(':str) = fromMaybe "" (Map.lookup key vars) ++ drop 1 rest
                            where (key,rest) = break (==')') str
    interp1 plain = plain

main = do
    dotlock_init
    args_raw <- getArgs
    case args_raw of

        [] -> kiki "working-key" []

        cmd : args | cmd `elem` map fst commands
          -> kiki cmd args

        _ -> kiki "help" [] --args_raw