Adapted to IO-based inteface pgpSign to reduce dependency on

random number generator interface.

Conflicts:
	kiki.hs

1 files changed, 100 insertions, 87 deletions

diff --git a/kiki.hs b/kiki.hs
index baa187f..3dc0edd 100644
--- a/kiki.hs
+++ b/kiki.hs
@@ -23,8 +23,8 @@ import Control.Monad
 import qualified Text.Show.Pretty as PP
 import Text.PrettyPrint as PP hiding ((<>))
 import Data.List
-import Data.OpenPGP.CryptoAPI hiding (sign)
-import qualified Data.OpenPGP.CryptoAPI as Stephen (sign)
+-- import Data.OpenPGP.CryptoAPI (verify,fingerprint,sign,decryptSecretKey)
+import OpenPGP
 import Data.Ord
 import Data.Maybe
 import Data.Bits
@@ -41,7 +41,7 @@ import qualified Crypto.Types.PubKey.ECC as ECC
 
 import Data.Char (toLower)
 import qualified Crypto.PubKey.RSA as RSA
-import Crypto.Random (newGenIO,SystemRandom)
+-- import Crypto.Random (newGenIO,SystemRandom)
 import Data.ASN1.Types
 import Data.ASN1.Encoding
 import Data.ASN1.BinaryEncoding
@@ -63,7 +63,8 @@ import System.IO.Error
 import ControlMaybe
 import Data.Char
 import Control.Arrow (first,second)
--- import Data.Traversable hiding (mapM,forM)
+import Data.Traversable hiding (mapM,forM,sequence)
+import qualified Data.Traversable as Traversable (mapM,forM,sequence)
 import System.Console.CmdArgs
 -- import System.Posix.Time
 import Data.Time.Clock.POSIX
@@ -80,6 +81,7 @@ instance Default S.ByteString where def = S.empty
 isBitCoinKey p =
     isKey p && key_algorithm p == ECDSA && ecc_curve p == oidToDER secp256k1_oid
 
+{-
 sign seckeys dta hashalgo keyid timestamp g = r
  where
     Message ks = seckeys
@@ -88,6 +90,7 @@ sign seckeys dta hashalgo keyid timestamp g = r
          [k] | isBitCoinKey k -> btc_sign (Message [k]) dta hashalgo keyid timestamp g
          [k] -> Stephen.sign (Message [k]) dta hashalgo keyid timestamp g
          ks  -> error $ "cannot determine a key to sign with"
+-}
 
 {-
 btc_sign :: (CryptoRandomGen g) =>
@@ -1662,11 +1665,14 @@ doImportG doDecrypt db m0 tag fname key = do
                 flip (flip maybe $ const $ return uids) has_torid $ do
                 wkun <- doDecrypt (packet top)
                 flip (maybe $ error "Bad passphrase?") wkun $ \wkun -> do
-                g <- newGenIO :: IO SystemRandom
-                timestamp <- now
                 let keyflags = keyFlags wkun (map packet $ flattenAllUids fname True uids)
                     uid = UserIDPacket idstr
-                    sig_ov = fst $ torsig g (packet top) wkun uid timestamp keyflags
+                    -- sig_ov = fst $ torsig g (packet top) wkun uid timestamp keyflags
+                    tor_ov = torSigOver (packet top) wkun uid keyflags
+                sig_ov <- pgpSign (Message [wkun])
+                                  tor_ov
+                                  SHA1
+                                  (fingerprint wkun)
                 flip (maybe $ warn "Failed to make signature" >> return uids)
                      (listToMaybe $ signatures_over sig_ov)
                      $ \sig -> do
@@ -1697,8 +1703,6 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
     let wk = packet top
     wkun <- doDecrypt wk
     flip (maybe $ error "Bad passphrase?") wkun $ \wkun -> do
-    g <- newGenIO :: IO SystemRandom
-    timestamp <- now
     let grip = fingerprint wk
         addOrigin new_sig = do
             flip (maybe $ error "Failed to make signature.") 
@@ -1706,21 +1710,8 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
                  $ \new_sig -> do
             let mp' = MappedPacket new_sig (Map.singleton fname (origin new_sig (-1)))
             return (mp', Map.empty)
-        newSig = do
-        let parsedkey = [packet $ subkey_p]
-            new_sig = fst $ sign (Message [wkun])
-                             (SubkeySignature wk
-                                              (head parsedkey)
-                                              (sigpackets 0x18
-                                                          hashed0
-                                                          ( IssuerPacket (fingerprint wk)
-                                                            : map EmbeddedSignaturePacket (signatures_over back_sig))))
-                             SHA1
-                             grip
-                             timestamp
-                             (g::SystemRandom)
-
-            hashed0 =
+        parsedkey = [packet $ subkey_p]
+        hashed0 =
                     [ KeyFlagsPacket
                         { certify_keys = False
                         , sign_data = False
@@ -1734,22 +1725,31 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
                         , notation_name = "usage@"
                         , notation_value = tag
                         }
-                    , SignatureCreationTimePacket (fromIntegral timestamp)
+                    -- implicitly added:
+                    -- , SignatureCreationTimePacket (fromIntegral timestamp)
                     ]
-
-            subgrip = fingerprint (head parsedkey)
-
-            back_sig = fst $ sign (Message parsedkey)
-                             (SubkeySignature wk
-                                              (head parsedkey)
-                                              (sigpackets 0x19
-                                                          hashed0
-                                                          [IssuerPacket subgrip]))
-                             SHA1
-                             subgrip
-                             timestamp
-                             (g::SystemRandom)
-        addOrigin new_sig
+        subgrip = fingerprint (head parsedkey)
+
+    back_sig <- pgpSign (Message parsedkey)
+                        (SubkeySignature wk
+                                         (head parsedkey)
+                                         (sigpackets 0x19
+                                                     hashed0
+                                                     [IssuerPacket subgrip]))
+                        SHA1
+                        subgrip
+    let unhashed0 = ( IssuerPacket (fingerprint wk)
+                     : map EmbeddedSignaturePacket (signatures_over back_sig))
+
+    new_sig <- pgpSign (Message [wkun])
+                       (SubkeySignature wk
+                                        (head parsedkey)
+                                        (sigpackets 0x18
+                                                   hashed0
+                                                   unhashed0))
+                      SHA1
+                      grip
+    let newSig = addOrigin new_sig
     flip (maybe newSig) mbsig $ \(mp,trustmap) -> do
     let sig = packet mp
         isCreation (SignatureCreationTimePacket {}) = True
@@ -1763,19 +1763,12 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
         exp = listToMaybe $ sort $
                  map unwrap es where unwrap (SignatureExpirationTimePacket x) = x
         expires = liftA2 (+) stamp exp
+    timestamp <- now
     if fmap ( (< timestamp) . fromIntegral) expires == Just True then do
         warn $ "Unable to update expired signature"
         return (mp,trustmap)
     else do
-        let new_sig = fst $ sign (Message [wkun])
-                                 (SubkeySignature wk
-                                    (packet subkey_p)
-                                     [sig'] )
-                             SHA1
-                             (fingerprint wk)
-                             timestamp
-                             (g::SystemRandom)
-            times = (:) (SignatureExpirationTimePacket (fromIntegral timestamp))
+        let times = (:) (SignatureExpirationTimePacket (fromIntegral timestamp))
                         $ maybeToList $ do
                             e <- expires
                             return $ SignatureExpirationTimePacket (e - fromIntegral timestamp)
@@ -1784,6 +1777,12 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
                         , notation_value = tag
                         , human_readable = True }
             sig' = sig { hashed_subpackets = times ++ [notation] ++ qs }
+        new_sig <- pgpSign (Message [wkun])
+                           (SubkeySignature wk
+                                            (packet subkey_p)
+                                            [sig'] )
+                           SHA1
+                           (fingerprint wk)
         addOrigin new_sig
 
 signature_time ov = case if null cs then ds else cs of
@@ -2049,12 +2048,13 @@ main = do
                             return $ undata (snd elm)
                             
                     undata (KeyData p _ _ _) = packet p
-                g <- newGenIO
-                stamp <- now
+                -- g <- newGenIO
+                -- stamp <- now
                 wkun <- flip (maybe $ return Nothing) wk $ \wk -> do
                             wkun <- decrypt wk
                             maybe (error $ "Bad passphrase?") (return . Just) wkun
-                return . snd $ Map.mapAccum (signTorIds stamp wkun keys) g use_db
+                -- return . snd $ Map.mapAccum (signTorIds stamp wkun keys) g use_db
+                Traversable.mapM (signTorIds wkun keys) use_db
         ret_db <- return $ fmap (const use_db) ret_db
 
         flip (maybe $ return ()) ret_db . const $ do
@@ -2138,28 +2138,25 @@ main = do
                         where
                             w0:ws = pub
 
-    signTorIds timestamp selfkey keys 
-               g kd@(KeyData k ksigs umap submap) = (g', KeyData k ksigs umap' submap)
+    signTorIds selfkey keys kd@(KeyData k ksigs umap submap) = do
+        umap' <- Traversable.mapM signIfTor (Map.mapWithKey (,) umap)
+        return (KeyData k ksigs umap' submap) :: IO KeyData
      where
-        _ = g :: SystemRandom
         mkey = packet k
-        (g',umap') = Map.mapAccumWithKey signIfTor g umap
-        signIfTor g str ps = if isTorID str then {- trace (unlines 
-                                                        [ "Found tor id: "
-                                                           ++show (str,fmap fingerprint selfkey)
-                                                        , "additional = " ++ intercalate "," (map showPacket additional)
-                                                        ]) -}
-                                                        (g',ps')
-                                            else (g,ps)
-          where
-            uidxs0 = map packet $ flattenUid "" True (str,ps)
-            om = Map.singleton "--autosign" (origin p (-1)) where p = UserIDPacket str
-            tmap = Map.empty
-            ps' = ( map ( (,tmap) . flip MappedPacket om) additional 
-                     ++ fst ps
-                  , Map.union om (snd ps) )
-
-            (uidxs, additional, xs'',g') = signSelfAuthTorKeys' selfkey g keys grip timestamp mkey uidxs0
+        signIfTor (str,ps) =
+            if isTorID str 
+                then do
+                    let uidxs0 = map packet $ flattenUid "" True (str,ps)
+                    -- addition<- signSelfAuthTorKeys' selfkey g keys grip timestamp mkey uidxs0
+                    additional <- signSelfAuthTorKeys' selfkey   keys grip           mkey uidxs0
+                    let ps' = ( map ( (,tmap) . flip MappedPacket om) additional 
+                                 ++ fst ps
+                              , Map.union om (snd ps) )
+                        om = Map.singleton "--autosign" (origin p (-1)) where p = UserIDPacket str
+                        tmap = Map.empty
+                    return ps'
+                else return ps
+
         torbindings = getTorKeys (map packet $ flattenTop "" True kd)
         isTorID str = and [ uid_topdomain parsed == "onion"
                             , uid_realname parsed `elem` ["","Anonymous"]
@@ -2172,6 +2169,7 @@ main = do
                             subdom = Char8.unpack subdom0
                             len = T.length (uid_subdomain parsed)
 
+    {-
     signSelfAuthTorKeys selfkey g sec grip timestamp xs = ys
      where
         keys = filter isKey sec
@@ -2179,8 +2177,16 @@ main = do
         uidxs0 = map snd xs
         (uidxs, additional, xs'',g') = signSelfAuthTorKeys' selfkey g keys grip timestamp mainpubkey uidxs0
         ys = uidxs++ additional++xs''
+    -}
 
-    signSelfAuthTorKeys' selfkey g keys grip timestamp  mainpubkey (uid:xs') = (uid:sigs,additional,xs'',g')
+    signSelfAuthTorKeys' selfkey keys grip mainpubkey (uid:xs') = do
+        new_sig <- let wkun = fromJust selfkey
+                       tor_ov = torSigOver mainpubkey wkun uid flgs
+                   in pgpSign (Message [wkun])
+                              tor_ov
+                              SHA1
+                              (fingerprint wkun)
+        return (additional new_sig) -- (uid:sigs,additional,xs'',g')
      where
         (sigs, xs'') = span isSignaturePacket xs'
         overs sig = signatures $ Message (keys++[mainpubkey,uid,sig])
@@ -2205,7 +2211,7 @@ main = do
                                                                    . (== keykey whosign) 
                                                                    . keykey))
                           vs
-        additional = do
+        additional new_sig = do
             guard $ {- trace (unlines $ [ "selfsigs = "++show (map ((\(_,_,k)->fingerprint k)) selfsigs)
                                      , " for mainkey = "++fingerprint mainpubkey] )
                         -}
@@ -2236,7 +2242,14 @@ main = do
         flgs = if keykey mainpubkey == keykey (fromJust selfkey)
                 then keyFlags0 mainpubkey (map (\(x,_,_)->x) selfsigs)
                 else []
-        (new_sig,g') = torsig g mainpubkey (fromJust selfkey) uid timestamp flgs
+        -- (new_sig,g') = todo g mainpubkey (fromJust selfkey) uid timestamp flgs
+        {-
+        new_sig <- let wkun = fromJust selfkey
+                   in pgpSign (Message [wkun])
+                              tor_ov
+                              SHA1
+                              (fingerprint wkun)
+        -}
 
         -- ys = uid:sigs++ additional++xs''
 
@@ -2488,6 +2501,7 @@ isSameKey a b = sort (key apub) == sort (key bpub)
     apub = secretToPublic a
     bpub = secretToPublic b
 
+{-
 existingKey (prepk,pks) remainder wkun wk parsedkey tag pre uids subkeys output_file grip = do
         -- putStrLn "Key already present."
         let pk:trail = pks
@@ -2637,6 +2651,7 @@ newKey wkun wk parsedkey tag pre uids subkeys output_file grip = do
         -}
 
         return ()
+-}
 
 
 
@@ -2731,27 +2746,25 @@ seek_key (KeyUidMatch pat) ps = if null bs
 groupTops ps = groupBy (\_ b -> not (isTopKey b)) ps
 
 
+{-
 makeTorUID g timestamp wkun keyflags topkey torkey = uid:signatures_over sig
  where
     torhash sub = maybe "" id $ derToBase32 <$> derRSA sub
     s = "Anonymous <root@" ++ take 16 (torhash torkey) ++ ".onion>"
     uid = UserIDPacket s
     sig = fst $ torsig g topkey wkun uid timestamp keyflags
+-}
 
-torsig g topk wkun uid timestamp extras
-    = sign (Message [wkun])
-                 (CertificationSignature (secretToPublic topk)
-                                         uid
-                                         (sigpackets 0x13
-                                                     subpackets
-                                                     subpackets_unh))
-                 SHA1
-                 (fingerprint wkun) {- (fromJust wkgrip) -}
-                 timestamp
-                 g
+-- torsig g topk wkun uid timestamp extras = todo
+torSigOver topk wkun uid extras
+    = CertificationSignature (secretToPublic topk)
+                             uid
+                             (sigpackets 0x13
+                                         subpackets
+                                         subpackets_unh)
    where
-    subpackets = [ SignatureCreationTimePacket (fromIntegral timestamp) ]
-                 ++ tsign
+    subpackets = -- implicit: [ SignatureCreationTimePacket (fromIntegral timestamp) ]
+                 tsign
                  ++ extras
     subpackets_unh = [IssuerPacket (fingerprint wkun)]
     tsign = if keykey wkun == keykey topk