{-# 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.Time.Clock.POSIX ( posixSecondsToUTCTime ) import Data.Monoid ( (<>) ) import Data.OpenPGP.Util (verify,fingerprint) import ScanningParser import PEM import DotLock import KeyRing import Base58 import qualified CryptoCoins -- import Chroot import ProcessUtils import qualified SSHKey as SSH import Text.Printf -- {-# 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 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 fingerprints of keys to show -- @pkts list of pgp packets -- Build the display output -- Operates in List Monad... -- returns all output as a single string listKeysFiltered grips pkts = do let masterkeys = filter (\k -> isKey k && not (is_subkey k)) pkts (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) singles = filter (\k -> fingerprint k `notElem` map fingerprint parents) masterkeys -- \\ parents where parents = do subs@((_,(top,_),_,_,_):_) <- gs return top showsigs claimants = map (\k -> " " ++ "^ signed: " ++ fingerprint k) claimants subs0 <- map Left gs ++ map Right singles let (top,subs) = case subs0 of Left subs1@((_,(top0,_),_,_,_):_) -> (top0,subs1) Right top0 -> (top0,[]) 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 = RSAKey (MPI n) (MPI e) where (n,e) = fromMaybe (error "Unsupported key format") $ SSH.blobkey bs -- | 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 -- printf "show_wk(%s,%s,%s)\n" (show secring_file) (show grip) (show db) 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 = either warn putStrLn $ show_pem' keyspec wkgrip db show_pem' keyspec wkgrip db = do let s = parseSpec wkgrip keyspec flip (maybe . Left $ keyspec ++ ": not found") (selectPublicKey s db) pemFromPacket pemFromPacket k = do let rsa = pkcs8 . fromJust $ rsaKeyFromPacket k der = encodeASN1 DER (toASN1 rsa []) qq = Base64.encode (L.unpack der) return $ 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 = SSH.keyblob (n,e) blob = Char8.unpack bs return 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. (See 'kiki help spec' for more information.)" ,"" ," --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." ," (See 'kiki help spec' for more information.)" ,"" ," --cert SPEC" ," Outputs X509 certificates associated with the key SPEC." ," (See 'kiki help spec' for more information.)" ,"" ," --ssh SPEC" ," Outputs the ssh-rsa blob for the specified public key." ," (See 'kiki help spec' for more information.)" ,"" ," --wip SPEC" ," Outputs the secret crypto-coin key in Wallet Input Format." ," (See 'kiki help spec' for more information.)" ,"" ," --torhash FILE" ," Outputs tor address and base32 hash of the PEM-format key in" ," the given file." ,"" ," --help Shows this help screen." ,"" ] "sync-secret" -> unlines $ ["kiki sync-secret [KEYSPEC ...]" ,"kiki sync-secret FLAGS [--keypairs KEYSPEC ...] [--keyrings FILE ...] [--hosts FILE ...]" ," [--wallets FILE ...]" ,"" ," 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 even if they" ," are not included after the --keyrings option." ,"" ," 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." ,"" ," If no \"INPUT FILE\" options (documented below) are specified, then arguments" ," are implicitly interpreted as being KEYSPECs for the --keypairs option." ,"" ,"FLAGS" ," --help Gives usage information" ,"" ," --homedir PATH Specifies the path where pubring.gpg and secring.gpg are located." ," Typically this would be your ~/.gnupg or the contents of the" ," GNUPGHOME environment variable." ,"" ," --passphrase-fd FD The file descriptor from which to read a passphrase." ,"" ," --import Update home keyring files (pubring.gpg and secring.gpg) with" ," new master keys found in the input files specified by the" ," --keyrings option. Note that new subkeys for known master-key" ," identities will be imported regardless." ,"" ," --import-if-authentic" ," Like --import except that it requires a signature from the" ," working key on any new identities that are imported into the" ," home keyring files." ,"" ," --autosign Create or sign a self-authenticating UID based on tor key." ," Combine this with --import-if-authentic to import self-authenticating" ," identities that may not have previously been signed." ,"" ," --show-wk After the operation completes, output the possibly modified working" ," key identity information." ,"" ,"INPUT FILES" ," --keypairs [KEYSPEC ...]" ," KEYSPEC := tag '=' file '{' '}'" ," | tag '=' file" ," Note that this option is implicit if no options documented in this section" ," were specified. See 'kiki help spec' for more information." ,"" ," --keyrings [FILE ...]" ," These files are PGP keyring files. The format is similar to that of the" ," GNU GPG state files: pubring.gpg and secring.gpg. Those files needn't be" ," specified here as they are included implicitly." ,"" ," --wallets [FILE ...]" ," Bitcoin wallet files. TODO: document format." ,"" ," --hosts [FILE ...]" ," EXPERIMENTAL! May be removed in the future. This option specifies files" ," from which to read or write hostname aliases. The format is the same as" ," /etc/hosts on unix systems. WARNING: hostname aliases may be imported into" ," the gpg keyring files, but they are currently NOT signed and may be altered" ," in transit." ] ++ syncflags "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." ,"" ," (See 'kiki help spec' for more information.)" ] ++ syncflags "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." ,"" ," (See 'kiki help spec' for more information.)" ] ++ syncflags "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." ,"" ," (See 'kiki help spec' for more information.)" ] ++ syncflags "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." ,"" ," (See 'kiki help spec' for more information.)" ,"" ] ++ syncflags "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." ,"" ," (See 'kiki help spec' for more information.)" ,"" ] ++ syncflags "spec" -> unlines 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 " ," 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 elsewhere. 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." ," (See 'kiki help spec' for more information.)" ,""] 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) buildStreamInfo :: KeyFilter -> FileType -> StreamInfo buildStreamInfo rtyp ftyp = StreamInfo { typ = ftyp , fill = rtyp , spill = KF_All , access = AutoAccess , initializer = Nothing , transforms = [] } sync :: Bool -> Bool -> Bool -> String -> [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 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 :: String -> [String] -> IO () 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 ' for more information on a specific command." ,"Or see 'kiki help spec' for kiki's notation for specifying keys." ] return () kiki "help" args = forM_ args $ \arg -> case lookup arg commands of Nothing | arg == "spec" -> kiki_usage False arg Nothing | arg == "SPEC" -> kiki_usage False arg 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 let noChrootArg = rootdir == Nothing bUnprivileged = (me/=0) && noChrootArg 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 osHomeDir <- if bUnprivileged then getHomeDirectory else return "/root" -- 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. -- (use SimpleConfig) let torpath = fromMaybe "" rootdir ++ "/var/lib/tor/samizdat/private_key" sshcpath0 = fromMaybe "" rootdir ++ osHomeDir ".ssh" "id_rsa" sshspath0 = fromMaybe "" rootdir ++ "/etc/ssh/ssh_host_rsa_key" ipsecpath0 = fromMaybe "" rootdir ++ "/etc/ipsec.d/private/%(onion).pem" sshcpathpub0 = fromMaybe "" rootdir ++ osHomeDir ".ssh" "id_rsa.pub" sshspathpub0 = fromMaybe "" rootdir ++ "/etc/ssh/ssh_host_rsa_key.pub" ipsecpathpub0 = fromMaybe "" rootdir ++ "/etc/ipsec.d/certs/%(onion).pem" contactipsec0 = 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 = [] } doNothing = return () nop = KeyRingOperation { opFiles = Map.empty , opPassphrases = do pfd <- maybeToList passfd return $ PassphraseSpec Nothing Nothing pfd , opHome=homespec, opTransforms = [] } if bUnprivileged then doNothing else mkdirFor torpath KikiResult rt report <- runKeyRing (if bUnprivileged then nop else op) forM_ report $ \(fname,act) -> do putStrLn $ fname ++ ": " ++ reportString act rt <- case rt of BadPassphrase -> error "Operation requires correct passphrase. (Hint: Use --passphrase-fd=0 to input it on stdin.)" _ -> unconditionally $ return rt -- Now import, export, or generate the remaining secret keys. let oname' = do wk <- rtWorkingKey rt onionNameForContact (keykey wk) (rtKeyDB rt) if (oname' == Nothing) && (not bUnprivileged) then error "Missing tor key" else do let oname = fromMaybe "" oname' let [ sshcpath, sshcpathpub ] = {- map (interp (Map.fromList [("onion",oname)]))-} [ sshcpath0, sshcpathpub0 ] [ sshspath , ipsecpath ] = map (interp (Map.fromList [("onion",oname)])) [ sshspath0, ipsecpath0 ] [ sshspathpub, ipsecpathpub ] = map (interp (Map.fromList [("onion",oname)])) [ sshspathpub0, ipsecpathpub0 ] let opPriv = 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) ] } opUnPriv = op { opFiles = Map.fromList $ [ ( HomeSec, buildStreamInfo KF_All KeyRingFile ) , ( HomePub, (buildStreamInfo KF_All KeyRingFile) { access = Pub } ) , ( ArgFile sshcpath, peminfo 2048 "ssh-client" ) ] , opPassphrases = [ PassphraseMemoizer (rtPassphrases rt) ] } mapM_ mkdirFor $ [sshcpath,sshcpathpub] ++ if not bUnprivileged then [sshspath,ipsecpath,sshspathpub,ipsecpathpub] else [] KikiResult rt report <- runKeyRing (if bUnprivileged then opUnPriv else opPriv) forM_ report $ \(fname,act) -> do putStrLn $ fname ++ ": " ++ reportString act rt <- case rt of BadPassphrase -> error "Operation requires correct passphrase. (Hint: Use --passphrase-fd=0 to input it on stdin.)" _ -> unconditionally $ return rt -- Finally, export public keys if they do not exist. flip (maybe $ warn "missing working key?") (rtGrip rt) $ \grip -> do gotc <- doesFileExist (sshcpathpub) when (not gotc) $ do either warn (writeFile sshcpathpub) $ show_ssh' "ssh-client" grip (rtKeyDB rt) if (not bUnprivileged) then do goth <- doesFileExist (sshspathpub) when (not goth) $ do either warn (writeFile $ sshspathpub) $ show_ssh' "ssh-host" grip (rtKeyDB rt) goti <- doesFileExist (ipsecpathpub) when (not goti) $ do either warn (writeFile $ ipsecpathpub) $ show_pem' "strongswan" grip (rtKeyDB rt) else return () let cs = filter notme (Map.elems $ rtKeyDB rt) kk = keykey (fromJust $ rtWorkingKey rt) notme kd = keykey (keyPacket kd) /= kk installConctact kd = do let (_,(ns,_)) = getHostnames kd contactname = fmap Char8.unpack $ listToMaybe ns flip (maybe $ return ()) contactname $ \contactname -> do let cpath = interp (Map.singleton "onion" contactname) contactipsec0 kspec = ( KeyGrip $ fingerprint $ keyPacket kd , Just "strongswan" ) mbk = selectPublicKey kspec $ Map.singleton (keykey $ keyPacket kd) kd flip (maybe $ return ()) mbk $ \k -> do goti <- doesFileExist (cpath) when (not goti) $ do either warn (writeFile $ cpath) $ pemFromPacket k mapM_ installConctact cs kiki "delete" args | "--help" `elem` args = do putStr . unlines $ [ "kiki delete ..." , "" , " Delete the subkeys specified by the given fingerprints along" , " with all associated signatures and trust markers." ] return () kiki "delete" args = do let (sargs,margs) = processArgs sargspec polyVariadicArgs "--delete" args where sargspec = [] polyVariadicArgs = ["--delete"] passfd = fmap (FileDesc . read) passphrase_fd where passphrase_fd = concat <$> Map.lookup "--passphrase-fd" margs fps = fromMaybe [] $ Map.lookup "--delete" margs homespec = join . take 1 <$> Map.lookup "--homedir" margs kikiOp = KeyRingOperation { opFiles = Map.fromList $ [ ( HomeSec, buildStreamInfo KF_All KeyRingFile ) , ( HomePub, buildStreamInfo KF_All KeyRingFile ) ] , opPassphrases = do pfile <- maybeToList passfd return $ PassphraseSpec Nothing Nothing pfile , opTransforms = map DeleteSubKey fps , opHome = homespec } KikiResult rt report <- runKeyRing kikiOp forM_ report $ \(fname,act) -> do putStrLn $ fname ++ ": " ++ reportString act 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") , ( "delete", "Delete a subkey and its associated signatures" ) ] 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