1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
|
---------------------------------------------------------------------------
-- |
-- Module : KeyRing
--
-- Maintainer : joe@jerkface.net
-- Stability : experimental
--
-- kiki is a command-line utility for manipulating GnuPG's keyring files. This
-- module is the programmer-facing API it uses to do that.
--
-- Note: This is *not* a public facing API. I (the author) consider this
-- library to be internal to kiki and subject to change at my whim.
--
-- Typically, a client to this module would prepare a 'KeyRingOperation'
-- describing what he wants done, and then invoke 'runKeyRing' to make it
-- happen.
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternGuards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE ViewPatterns #-}
module KeyRing (module KeyRing.Types, module Transforms, module PacketTranscoder, module KeyRing, module KeyRing.BuildKeyDB) where
import System.Environment
import Control.Monad
import Control.Exception ( catch )
import System.IO.Error ( isDoesNotExistError )
import Data.Bool
import Data.Maybe
import Data.Either
import Data.Char
import Data.Ord
import Data.List
import Data.OpenPGP
import Data.Functor
import Data.Monoid
import Data.Tuple ( swap )
import Data.Bits ( (.|.), (.&.) )
import Control.Applicative ( Applicative, pure, liftA2, (<*>) )
import System.Directory ( getHomeDirectory, doesFileExist, createDirectoryIfMissing )
import Control.Arrow ( first, second )
import Data.OpenPGP.Util
import Data.ByteString.Lazy ( ByteString )
import Text.Show.Pretty as PP ( ppShow )
import Data.Binary {- decode, decodeOrFail -}
import ControlMaybe ( handleIO_ )
import Data.ASN1.Types ( toASN1, ASN1Object, fromASN1
, ASN1(Start,End,IntVal,OID,BitString,Null), ASN1ConstructionType(Sequence) )
import Data.ASN1.BitArray ( BitArray(..), toBitArray )
import Data.ASN1.Encoding ( encodeASN1, encodeASN1', decodeASN1, decodeASN1' )
import Data.ASN1.BinaryEncoding ( DER(..) )
import Data.Time.Clock.POSIX ( POSIXTime, utcTimeToPOSIXSeconds )
import Data.Time.Clock ( UTCTime )
import Data.Bits ( Bits, shiftR )
import Data.Text.Encoding ( encodeUtf8 )
import qualified Data.Map as Map
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString as S
#if defined(VERSION_memory)
import qualified Data.ByteString.Char8 as S8
import Data.ByteArray.Encoding
#elif defined(VERSION_dataenc)
import qualified Codec.Binary.Base32 as Base32
import qualified Codec.Binary.Base64 as Base64
#endif
#if !defined(VERSION_cryptonite)
import qualified Crypto.Hash.SHA1 as SHA1
import qualified Crypto.Types.PubKey.ECC as ECC
#else
import qualified Crypto.Hash as Vincent
import Data.ByteArray (convert)
import qualified Crypto.PubKey.ECC.Types as ECC
#endif
import qualified Data.X509 as X509
import qualified Crypto.PubKey.RSA as RSA
import qualified Codec.Compression.GZip as GZip
import qualified Data.Text as T ( Text, unpack, pack,
strip, reverse, drop, break, dropAround, length )
import qualified System.Posix.Types as Posix
import System.Posix.Files ( modificationTime, getFileStatus, getFdStatus
, setFileCreationMask, setFileTimes )
#if MIN_VERSION_x509(1,5,0)
import Data.Hourglass.Types
import Data.Hourglass
#endif
#if MIN_VERSION_unix(2,7,0)
import System.Posix.Files ( setFdTimesHiRes )
import Foreign.C.Types ( CTime(..), CLong, CInt(..) )
#else
import Foreign.C.Types ( CTime(..), CLong, CInt(..) )
import Foreign.Marshal.Array ( withArray )
import Foreign.Ptr
import Foreign.C.Error ( throwErrnoIfMinus1_ )
import Foreign.Storable
#endif
import System.FilePath ( takeDirectory )
import System.IO (hPutStrLn,withFile,IOMode(..), Handle, hPutStr, stderr, hClose)
import Data.IORef
import System.Posix.IO ( fdToHandle )
import qualified Data.Traversable as Traversable
import Data.Traversable ( sequenceA )
#if ! MIN_VERSION_base(4,6,0)
import GHC.Exts ( Down(..) )
#endif
#if MIN_VERSION_binary(0,7,0)
import Debug.Trace
#endif
import Network.Socket -- (SockAddr)
import qualified Data.ByteString.Lazy.Char8 as Char8
import qualified Codec.Encryption.OpenPGP.ASCIIArmor as ASCIIArmor
import Codec.Encryption.OpenPGP.ASCIIArmor.Types
import Compat
import TimeUtil
import PEM
import ScanningParser
import qualified Hosts
import qualified CryptoCoins
import Base58
import FunctorToMaybe
import DotLock
import ProcessUtils (systemEnv, ExitCode(ExitFailure, ExitSuccess) )
import GnuPGAgent as Agent
import KeyRing.BuildKeyDB {- (accBindings, backsig, buildKeyDB,
combineTransforms, concatSort,
derRSA, derToBase32, filterMatches,
findTag, fingerdress,
flattenAllUids, flattenKeys,
flattenSub, flattenTop,
generateInternals, getBindings,
getHostnames, getSubkeys,
importSecretKey, insertSubkey,
isKey, isSecretKey,
isSubkeySignature, isUserID,
keyFlags0, keyPacket, keyflags,
keykey, mappedPacket, matchSpec,
matchpr, merge, mergeKeyPacket,
mkUsage, origin,
packetFromPublicRSAKey,
parseCertBlob, parseSingleSpec,
parseSpec, parseUID,
performManipulations,
readInputFileL, readSecretPEMFile,
resolveForReport, resolveInputFile,
rsaKeyFromPacket, secp256k1_id,
secretToPublic, seek_key,
selectKey0, selectPublicKey,
showPacket, sortByHint,
subkeyMappedPacket, torhash,
usageFromFilter) -}
import KeyRing.Types
import PacketTranscoder
import Transforms
data HomeDir =
HomeDir { homevar :: String
, appdir :: String
, optfile_alts :: [String]
}
home :: HomeDir
home = HomeDir
{ homevar = "GNUPGHOME"
, appdir = ".gnupg"
, optfile_alts = ["keys.conf","gpg.conf-2","gpg.conf"]
}
isMutable :: StreamInfo -> Bool
isMutable stream | KF_None <- fill stream = False
isMutable _ = True
filesToLock :: (Map.Map InputFile StreamInfo) -> InputFileContext -> [FilePath]
filesToLock opfiles ctx = do
(f,stream) <- Map.toList opfiles
case fill stream of
KF_None -> []
_ -> resolveInputFile ctx f
-- kret :: a -> KeyRingOperation a
-- kret x = KeyRingOperation Map.empty Nothing (KeyRingAction x)
data PKCS8_RSAPublicKey = RSAKey8 MPI MPI deriving Show
pkcs8 :: RSAPublicKey -> PKCS8_RSAPublicKey
pkcs8 (RSAKey n e) = RSAKey8 n e
instance ASN1Object PKCS8_RSAPublicKey where
-- PKCS #8 Public key data
toASN1 (RSAKey8 (MPI n) (MPI e))
= \xs -> Start Sequence
: Start Sequence
: OID [1,2,840,113549,1,1,1]
: Null -- Doesn't seem to be neccessary, but i'm adding it
-- to match PEM files I see in the wild.
: End Sequence
: BitString (toBitArray bs 0)
: End Sequence
: xs
where
pubkey = [ Start Sequence, IntVal n, IntVal e, End Sequence ]
bs = encodeASN1' DER pubkey
fromASN1 (Start Sequence:IntVal modulus:IntVal pubexp:End Sequence:xs) =
Right (RSAKey8 (MPI modulus) (MPI pubexp) , xs)
fromASN1 (Start Sequence:Start Sequence:OID [1,2,840,113549,1,1,1]:Null:End Sequence:BitString b:End Sequence:xs) =
case decodeASN1' DER bs of
Right as -> fromASN1 as
Left e -> Left ("fromASN1: RSAPublicKey: "++show e)
where
BitArray _ bs = b
fromASN1 (Start Sequence:Start Sequence:OID [1,2,840,113549,1,1,1]:End Sequence:BitString b:End Sequence:xs) =
case decodeASN1' DER bs of
Right as -> fromASN1 as
Left e -> Left ("fromASN1: RSAPublicKey: "++show e)
where
BitArray _ bs = b
fromASN1 _ =
Left "fromASN1: RSAPublicKey: unexpected format"
reportString :: KikiReportAction -> String
reportString x = uncamel $ show x
-- | Errors in kiki are indicated by the returning of this record.
data KikiResult a = KikiResult
{ kikiCondition :: KikiCondition a
-- ^ The result or a fatal error condition.
, kikiReport :: KikiReport
-- ^ A list of non-fatal warnings and informational messages
-- along with the files that triggered them.
}
x509cert :: SignatureSubpacket -> Maybe Char8.ByteString
x509cert (NotationDataPacket
{ human_readable = False
, notation_name = "x509cert@"
, notation_value = u
}) = Just (Char8.pack u)
x509cert _ = Nothing
getStr :: SingleKeySpec -> String
getStr (FingerprintMatch x) = x
getStr (SubstringMatch _ x) = x
getStr _ = ""
-- | Spec
--
-- The product type, SingleKeySpec³ = Circle × Identity × Key.
--
-- Key - A single public or private key (subkey, or master without subkeys) (eg, pem file)
-- Identity - A single master key with all its subkeys
-- Circle - A collection of master keys with their subkeys (eg, gpg file)
--
-- The three fields are deliminated by slashes.
--
-- When context does not disambiguate, use the following default rules:
-- There are(is)
-- - no slashes, so interpret as Key
-- - one slash, so interpret as Identity/Key
-- - two slashes, so interpret as Circle/Identity/Key
--
-- (Any of the fields may be left empty.)
type Spec = (SingleKeySpec,SingleKeySpec,SingleKeySpec)
data SpecError = SpecENone String
| SpecEMissMatch String (Maybe MatchingField) MatchingField
| SpecETooBig Spec
| SpecETooMany String
deriving (Eq,Show,Ord)
-- t:tor -- (AnyMatch , AnyMatch, SubstringMatch type "tor")
-- u:joe -- (AnyMatch , SubstringMatch user "joe", FingerprintMatch "" )
-- u:joe/ -- (AnyMatch , SubstringMatch user "joe", FingerprintMatch "!" )
-- fp:4A39F/tor -- (AnyMatch , FingerprintMatch "4A39F", SubstringMatch type "tor")
-- u:joe/tor -- (AnyMatch , SubstringMatch user "joe", SubstringMatch type "tor")
-- u:joe/t:tor -- (AnyMatch , SubstringMatch user "joe", SubstringMatch type "tor")
-- u:joe/fp:4abf30 -- (AnyMatch , SubstringMatch user "joe", FingerprintMatch "4abf30")
-- joe/tor -- (AnyMatch , SubstringMatch user "joe", SubstringMatch type "tor")
-- u:joe//fp:4abf30 -- (SubstringMatch user "joe", AnyMatch , FingerprintMatch "4abf30")
-- c:buds//fp:4abf3 -- (SubstringMatch circ "buds", AnyMatch , FingerprintMatch "4abf3" )
--
-- where type = Just KeyTypeField
-- user = Just UserIDField
-- circ = Just GroupIDField
-- | parseSpec3 - Parse a key specification.
parseSpec3 :: Maybe MatchingField -> String -> Either SpecError Spec
parseSpec3 maybeExpecting spec@(wordsBy '/' -> fields) =
tooBigError maybeExpecting =<< applyContext maybeExpecting . fixUpSubstrMatch <$>
case fields of
[] -> Left (SpecENone spec)
xs@[t] ->
let ds = [0]
x = l ds xs
getTup1 [x] = tupSection1 (adjustPos x maybeExpecting) x
where
tupSection1 0 = (AnyMatch,AnyMatch,)
tupSection1 1 = (AnyMatch,,AnyMatch)
tupSection1 2 = (,AnyMatch,AnyMatch)
tupSection1 _ = tupSection1 0
in if all fst x then Right $ getTup1 (map (fst . snd) x)
else Left $ mismatch x
xs@[u,t] ->
let ds = [1,0]
x = l ds xs
getTup2 [u,t] = indexHole (head (filter (`notElem` gots [u,t]) [0..2])) u t
where gots xs = zipWith gotIndex [1,0] xs
indexHole 0 = (,,AnyMatch)
indexHole 1 = (,AnyMatch,)
indexHole 2 = (AnyMatch,,)
in if all fst x then Right $ getTup2 (map (fst . snd) x)
else Left $ mismatch x
xs@[c,u,t] ->
let ds = [2,1,0]
x = l ds xs
getTup3 [a,b,c] = (a,b,c)
in if all fst x then Right $ getTup3 (map (fst . snd) x)
else Left $ mismatch x
_ -> Left (SpecETooMany spec)
where expectIndex dflt = maybe dflt fromEnum maybeExpecting
l :: [Int] -> [String] -> [(Bool, (SingleKeySpec,Int))]
l defaults specs = zipWith (\x y -> (valid (p x) y, (p x,y))) specs defaults
where p x = parseSingleSpec x
valid :: SingleKeySpec -> Int -> Bool
valid spec dflt = ("tuc"::String) !! gotIndex dflt spec `notElem` forbidden (gotIndex dflt spec)
where
forbidden 0 = "uc" :: [Char]
forbidden 1 = "tc"
forbidden 2 = "tu"
adjustPos (SubstringMatch (Just KeyTypeField) _) Nothing = 0
adjustPos (SubstringMatch (Just UserIDField) _) Nothing = 1
adjustPos (SubstringMatch (Just GroupIDField) _) Nothing = 2
adjustPos _ (Just i) = fromEnum i
gotIndex :: Int -> SingleKeySpec -> Int
gotIndex dflt (SubstringMatch (Just got) _) = fromEnum got
gotIndex dflt _ = dflt
-- FIXME: This throws an exception if input is
-- not an erroneous SubstringMatch.
mismatch :: [(Bool,(SingleKeySpec,Int))] -> SpecError
mismatch xs = case find (not . fst) (reverse xs) of
Just (_,(SubstringMatch mbF s,n)) -> SpecEMissMatch s mbF (toEnum n)
fixUpSubstrMatch (g,u,t) = (set GroupIDField g, set UserIDField u, set KeyTypeField t)
where
set field (SubstringMatch Nothing xs) = SubstringMatch (Just field) xs
set _ EmptyMatch = AnyMatch
set field x = x
applyContext :: Maybe MatchingField -> Spec -> Spec
applyContext Nothing x = x
applyContext (Just KeyTypeField) ((AnyMatch,u,AnyMatch)) = (AnyMatch,AnyMatch,u)
applyContext (Just KeyTypeField) ((g,u,AnyMatch)) = (g,AnyMatch,u)
applyContext (Just KeyTypeField) x = x
applyContext (Just UserIDField) ((AnyMatch,AnyMatch,x)) = (AnyMatch,x,AnyMatch)
applyContext (Just UserIDField) ((AnyMatch,u,x)) = (AnyMatch,u,x)
applyContext (Just UserIDField) x = x
applyContext (Just GroupIDField) ((AnyMatch,AnyMatch,x)) = (x,AnyMatch,AnyMatch)
applyContext (Just GroupIDField) ((AnyMatch,u,x)) = (u,AnyMatch,x)
applyContext (Just GroupIDField) x = x
--applyContext (Just UserIDField) (Right (g,u,x)) = Left $
-- SpecEMissMatch (getStr g) (Just GroupIDField) UserIDField
tooBigError _ s@(_,_,SubstringMatch (Just GroupIDField) str) = Left $
SpecEMissMatch str (Just GroupIDField) KeyTypeField
tooBigError _ s@(_,SubstringMatch (Just GroupIDField) str,_) = Left $
SpecEMissMatch str (Just GroupIDField) UserIDField
tooBigError Nothing x = return x
tooBigError (Just UserIDField) s@(g,u,t) | g /= AnyMatch = Left $
SpecETooBig s -- (getStr g) (Just GroupIDField) UserIDField
tooBigError (Just KeyTypeField) s@(g,u,t) | g /= AnyMatch = Left $
SpecETooBig s --(getStr g) (Just GroupIDField) KeyTypeField
tooBigError _ x = return x
wordsBy :: Eq a => a -> [a] -> [[a]]
wordsBy _ [] = []
wordsBy c xs = let (b,a) = span (/=c) xs
in b:wordsBy c (drop 1 a)
{-
- BUGGY
parseSpec grip spec = (topspec,subspec)
where
(topspec0,subspec0) = unprefix '/' spec
(toptyp,top) = unprefix ':' topspec0
(subtyp,sub) = unprefix ':' subspec0
topspec = case () of
_ | null top && or [ subtyp=="fp"
, null subtyp && is40digitHex sub
]
-> KeyGrip sub
_ | null top && null grip -> KeyUidMatch sub
_ | null top -> KeyGrip grip
_ | toptyp=="fp" || (null toptyp && is40digitHex top)
-> KeyGrip top
_ | toptyp=="u" -> KeyUidMatch top
_ -> KeyUidMatch top
subspec = case subtyp of
"t" -> Just sub
"fp" | top=="" -> Nothing
"" | top=="" && is40digitHex sub -> Nothing
"" -> listToMaybe sub >> Just sub
_ -> Nothing
is40digitHex xs = ys == xs && length ys==40
where
ys = filter ishex xs
ishex c | '0' <= c && c <= '9' = True
| 'A' <= c && c <= 'F' = True
| 'a' <= c && c <= 'f' = True
ishex c = False
-- | Split a string into two at the first occurance of the given
-- delimiter. If the delimeter does not occur, then the first
-- item of the returned pair is empty and the second item is the
-- input string.
unprefix c spec = if null (snd p) then swap p else (fst p, tail (snd p))
where p = break (==c) spec
-}
filterNewSubs :: FilePath -> (KeySpec,Maybe String) -> KeyData -> KeyData
filterNewSubs fname spec (KeyData p sigs uids subs) = KeyData p sigs uids subs'
where
matchAll = KeyGrip ""
subkeySpec (KeyGrip grip,Nothing) = (matchAll, KeyGrip grip)
subkeySpec (topspec,Just mtag) = (topspec , KeyTag (packet p) mtag)
match spec mps
= not . null
. snd
. seek_key spec
. map packet
$ mps
old sub = isJust (Map.lookup fname $ locations $ subkeyMappedPacket sub)
oldOrMatch spec sub = old sub
|| match spec (flattenSub "" True sub)
subs' = Map.filter (if match topspec $ flattenTop "" True (KeyData p sigs uids Map.empty)
then oldOrMatch subspec
else old)
subs
where
(topspec,subspec) = subkeySpec spec
selectSecretKey :: (KeySpec,Maybe String) -> KeyDB -> Maybe Packet
selectSecretKey (spec,mtag) db = selectKey0 False (spec,mtag) db
selectPublicKeyAndSigs :: (KeySpec,Maybe String) -> KeyDB -> [(KeyKey,Packet,[Packet])]
selectPublicKeyAndSigs (spec,mtag) db =
case mtag of
Nothing -> do
(kk,r) <- Map.toList $ fmap (findbyspec spec) db
(sub,sigs) <- r
return (kk,sub,sigs)
Just tag -> Map.toList (Map.filter (matchSpec spec) db) >>= findsubs tag
where
topresult kd = (keyPacket kd, map (packet .fst) $ keySigAndTrusts kd)
findbyspec (KeyGrip g) kd = do
filter ismatch $
topresult kd
: map (\(SubKey sub sigs)-> (packet sub, map (packet . fst) sigs))
(Map.elems $ keySubKeys kd)
where
ismatch (p,sigs) = matchpr g p ==g
findbyspec spec kd = if matchSpec spec kd then [topresult kd] else []
findsubs tag (kk, KeyData topk _ _ subs) = Map.elems subs >>= gettag
where
gettag (SubKey sub sigs) = do
let (_,mb,_) = findTag [mkUsage tag] (packet topk) (packet sub) sigs
(hastag,_) <- maybeToList mb
guard hastag
return $ (kk, packet sub, map (packet . fst) sigs)
{-
selectAll :: Bool -> (KeySpec,Maybe String) -> KeyDB -> [(Packet,Maybe Packet)]
selectAll wantPublic (spec,mtag) db = do
let Message ps = flattenKeys wantPublic db
ys = snd $ seek_key spec ps
y <- take 1 ys
case mtag of
Nothing -> return (y,Nothing)
Just tag ->
let search ys1 = do
let zs = snd $ seek_key (KeyTag y tag) ys1
z <- take 1 zs
(y,Just z):search (drop 1 zs)
in search (drop 1 ys)
-}
writeInputFileL :: InputFileContext
-> InputFile -> ByteString -> IO ()
writeInputFileL ctx (Pipe _ fd) bs = fdToHandle fd >>= (`L.hPut` bs)
writeInputFileL ctx (FileDesc fd) bs = fdToHandle fd >>= (`L.hPut` bs)
writeInputFileL ctx inp bs = do
let fname = resolveInputFile ctx inp
mapM_ (`L.writeFile` bs) fname
-- writeStamped0 :: InputFileContext -> InputFile -> Posix.EpochTime -> L.ByteString -> IO ()
-- writeStamped0 :: InputFileContext -> InputFile
getWriteFD :: InputFile -> Maybe Posix.Fd
getWriteFD (Pipe _ fd) = Just fd
getWriteFD (FileDesc fd) = Just fd
getWriteFD _ = Nothing
writeStamped0 :: InputFileContext
-> InputFile
-> Posix.EpochTime
-> (Either Handle FilePath -> t -> IO ())
-> t
-> IO ()
writeStamped0 ctx (getWriteFD -> Just fd) stamp dowrite bs = do
h <- fdToHandle fd
dowrite (Left h) bs
handleIO_ (return ())
$ setFdTimesHiRes fd (realToFrac stamp) (realToFrac stamp)
writeStamped0 ctx inp stamp dowrite bs = do
let fname = resolveInputFile ctx inp
forM_ fname $ \fname -> do
createDirectoryIfMissing True $ takeDirectory fname
dowrite (Right fname) bs
setFileTimes fname stamp stamp
{- This may be useful later. Commented for now, as it is not used.
-
writeStampedL :: InputFileContext -> InputFile -> Posix.EpochTime -> L.ByteString -> IO ()
writeStampedL ctx f stamp bs = writeStamped0 ctx f stamp (either L.hPut L.writeFile) bs
-}
writeStamped :: InputFileContext -> InputFile -> Posix.EpochTime -> String -> IO ()
writeStamped ctx f stamp str = writeStamped0 ctx f stamp (either (\h x-> hPutStr h x >> hClose h) writeFile) str
{-
- This may be useful later. Commented for now as it is not used.
-
doesInputFileExist :: InputFileContext -> InputFile -> IO Bool
doesInputFileExist ctx f = do
case resolveInputFile ctx f of
[n] -> doesFileExist n
_ -> return True
-}
writeHostsFiles
:: KeyRingOperation -> InputFileContext
-> ([Hosts.Hosts],
[Hosts.Hosts],
Hosts.Hosts,
[(SockAddr, (t1, [Char8.ByteString]))],
[SockAddr])
-> IO [(FilePath, KikiReportAction)]
writeHostsFiles krd ctx (hostdbs0,hostdbs,u1,gpgnames,outgoing_names) = do
let hns = files isMutableHosts
isMutableHosts stream | KF_None <- fill stream = False
isMutableHosts stream | Hosts <- typ stream = True
isMutableHosts _ = False
files istyp = do
(f,stream) <- Map.toList (opFiles krd)
guard (istyp stream)
return f -- resolveInputFile ctx f
-- 3. add hostnames from gpg for addresses not in U
let u = foldl' f u1 ans
ans = reverse $ do
(addr,(_,ns)) <- gpgnames
guard $ addr `elem` outgoing_names -- . null $ Hosts.namesForAddress addr u0
n <- ns
return (addr,n)
f h (addr,n) = Hosts.assignNewName addr n h
-- 4. for each host db H, union H with U and write it out as H'
-- only if there is a non-empty diff
rss <- forM (zip hns $ zip hostdbs0 hostdbs) $ \(fname,(h0,h1)) -> do
let h = h1 `Hosts.plus` u
d = Hosts.diff h0 h
rs = map ((fname,) . HostsDiff) d
unless (null d) $ writeInputFileL ctx fname $ Hosts.encode h
return $ map (first $ resolveForReport $ Just ctx) rs
return $ concat rss
unconditionally :: IO (KikiCondition a) -> IO a
unconditionally action = do
r <- action
case r of
KikiSuccess x -> return x
e -> error $ errorString e
-- No instance for (ASN1Object RSA.PublicKey)
decodeBlob :: ParsedCert -> ByteString
decodeBlob cert =
if 0 /= (bs `L.index` 0) .&. 0x10
then bs
else let (keypos0,bs') = L.splitAt 2 bs
keypos :: Word16
keypos = decode keypos0
ds = GZip.decompress bs'
(prekey,postkey) = L.splitAt (fromIntegral keypos) ds
in prekey <> key <> postkey
where
bs = pcertBlob cert
key = maybe "" (encodeASN1 DER . flip toASN1 []) $ rsaKeyFromPacket $ pcertKey cert
isCryptoCoinKey :: Packet -> Bool
isCryptoCoinKey p =
and [ isKey p
, key_algorithm p == ECDSA
, lookup 'c' (key p) == Just (MPI secp256k1_id)
]
getCryptoCoinTag :: Packet -> Maybe CryptoCoins.CoinNetwork
getCryptoCoinTag p | isSignaturePacket p = do
-- CryptoCoins.secret
let sps = hashed_subpackets p ++ unhashed_subpackets p
u <- listToMaybe $ mapMaybe usage sps
CryptoCoins.lookupNetwork CryptoCoins.network_name u
getCryptoCoinTag _ = Nothing
coinKeysOwnedBy :: KeyDB -> Maybe Packet -> [(CryptoCoins.CoinNetwork,MappedPacket)]
coinKeysOwnedBy db wk = do
wk <- maybeToList wk
let kk = keykey wk
KeyData top topsigs uids subs <- maybeToList $ Map.lookup kk db
(subkk,SubKey mp sigs) <- Map.toList subs
let sub = packet mp
guard $ isCryptoCoinKey sub
tag <- take 1 $ mapMaybe (getCryptoCoinTag . packet . fst) sigs
return (tag,mp)
walletImportFormat :: Word8 -> Packet -> String
walletImportFormat idbyte k = secret_base58_foo
where
-- isSecret (SecretKeyPacket {}) = True
-- isSecret _ = False
secret_base58_foo = base58_encode seckey
Just d = lookup 'd' (key k)
(_,bigendian) = S.splitAt 2 (S.concat $ L.toChunks $ encode d)
seckey = S.cons idbyte bigendian
writeWalletKeys :: KeyRingOperation -> KeyDB -> Maybe Packet -> IO (KikiCondition [(FilePath,KikiReportAction)])
writeWalletKeys krd db wk = do
let cs = db `coinKeysOwnedBy` wk
-- export wallet keys
isMutableWallet stream | KF_None <- fill stream = False
isMutableWallet stream | WalletFile {} <- typ stream = True
isMutableWallet _ = False
files pred = do
(f,stream) <- Map.toList (opFiles krd)
guard (pred stream)
resolveInputFile (InputFileContext "" "") f
let writeWallet report n = do
let cs' = do
(nw,mp) <- cs
-- let fns = Map.keys (locations mp)
-- trace ("COIN KEY: "++show fns) $ return ()
guard . not $ Map.member n (locations mp)
let wip = walletImportFormat (CryptoCoins.private_byte_id nw) (packet mp)
return (CryptoCoins.network_name nw,wip)
handleIO_ (return report) $ do
-- TODO: This AppendMode stratagy is not easy to adapt from FilePath-based
-- to InputFile-based.
withFile n AppendMode $ \fh -> do
rs <- forM cs' $ \(net,wip) -> do
hPutStrLn fh wip
return (n, NewWalletKey net)
return (report ++ rs)
report <- foldM writeWallet [] (files isMutableWallet)
return $ KikiSuccess report
-- | returns Just True so as to indicate that
-- the public portions of keys will be imported
importPublic :: Maybe Bool
importPublic = Just True
-- | returns False True so as to indicate that
-- the public portions of keys will be imported
importSecret :: Maybe Bool
importSecret = Just False
-- TODO: Do we need to memoize this?
guardAuthentic :: KeyRingRuntime -> KeyData -> Maybe ()
guardAuthentic rt keydata = guard (isauth rt keydata)
isauth :: KeyRingRuntime -> KeyData -> Bool
isauth rt keydata = dont_have keydata && maybe False (`has_good_sig` keydata) wk
where wk = workingKey (rtGrip rt) (rtKeyDB rt)
dont_have (KeyData p _ _ _) = not . Map.member (rtPubring rt)
$ locations p
has_good_sig wk (KeyData k sigs uids subs) = any goodsig $ Map.toList uids
where
goodsig (uidstr,(sigs,_)) = not . null $ do
sig0 <- fmap (packet . fst) sigs
pre_ov <- signatures (Message [packet k, UserIDPacket uidstr, sig0])
signatures_over $ verify (Message [wk]) pre_ov
workingKey grip use_db = listToMaybe $ do
fp <- maybeToList grip
elm <- Map.elems use_db
guard $ matchSpec (KeyGrip fp) elm
return $ keyPacket elm
mkarmor :: Access -> L.ByteString -> [Armor]
mkarmor access bs = [Armor typ [] bs]
where
typ = case access of
Pub -> ArmorPublicKeyBlock
Sec -> ArmorPrivateKeyBlock
AutoAccess -> ArmorPrivateKeyBlock -- I don't know, so don't make it look sharable.
writeRingKeys :: KeyRingOperation -> KeyRingRuntime -> Map.Map InputFile Message
-> [(FilePath,KikiReportAction)]
{-
-> KeyDB -> Maybe Packet
-> FilePath -> FilePath
-}
-> IO (KikiCondition [(FilePath,KikiReportAction)])
writeRingKeys krd rt {- db wk secring pubring -} unspilled report_manips = do
let isring (KeyRingFile {}) = True
isring _ = False
db = rtKeyDB rt
secring = rtSecring rt
pubring = rtPubring rt
ctx = InputFileContext secring pubring
let s = do
(f,f0,stream) <- do
(f0,stream) <- Map.toList (opFiles krd)
guard (isring $ typ stream)
f <- resolveInputFile ctx f0
return (f,f0,stream)
let db' = fromMaybe db $ do
msg <- Map.lookup f0 unspilled
return $ merge db f0 msg
x = do
let wantedForFill :: Access -> KeyFilter -> KeyData -> Maybe Bool
wantedForFill acc KF_None = importByExistingMaster
-- Note the KF_None case is almost irrelevent as it will be
-- filtered later when isMutable returns False.
-- We use importByExistingMaster in order to generate
-- MissingPacket warnings. To disable those warnings, use
-- const Nothing instead.
wantedForFill acc (KF_Match {}) = importByExistingMaster
wantedForFill acc KF_Subkeys = importByExistingMaster
wantedForFill acc KF_Authentic = \kd -> do guardAuthentic rt kd
importByAccess acc kd
wantedForFill acc KF_All = importByAccess acc
importByAccess Pub kd = importPublic
importByAccess Sec kd = importSecret
importByAccess AutoAccess kd =
mplus (importByExistingMaster kd)
(error $ f ++ ": write public or secret key to file?")
importByExistingMaster kd@(KeyData p _ _ _) =
fmap originallyPublic $ Map.lookup f $ locations p
d <- sortByHint f keyMappedPacket (Map.elems db')
acc <- maybeToList $ Map.lookup f0 (rtRingAccess rt)
only_public <- maybeToList $ wantedForFill acc (fill stream) d
guard $ only_public || isSecretKey (keyPacket d)
case fill stream of
KF_Match usage -> do grip <- maybeToList $ rtGrip rt
flattenTop f only_public
$ filterNewSubs f (parseSpec grip usage) d -- TODO: parseSpec3
_ -> flattenTop f only_public d
new_packets = filter isnew x
where isnew p = isNothing (Map.lookup (resolveForReport Nothing f0) $ locations p)
-- TODO: We depend on an exact string match between the reported
-- file origin of the deleted packet and the path of the file we are
-- writing. Verify that this is a safe assumption.
isdeleted (f',DeletedPacket _) = f'==f
isdeleted _ = False
guard (not (null new_packets) || any isdeleted report_manips)
return ((f0,stream),(new_packets,x))
let (towrites,report) = foldl' go ([],[]) s
where
go (ws,report) ((f,stream),(new_packets,x)) = (ws++writes, report++(items <$> new_packets))
where
mutable = isMutable stream
writes | mutable = [(stream,f,x)]
| otherwise = []
items c = ( concat $ resolveInputFile ctx f
, bool MissingPacket NewPacket mutable $ showPacket (packet c)
)
forM_ towrites $ \(stream,f,xs) -> do
let encoding = case typ stream of PGPPackets AsciiArmor -> AsciiArmor
_ -> BinaryPackets
enc = case encoding of
BinaryPackets -> id
AsciiArmor -> ASCIIArmor.encodeLazy . mkarmor (access stream)
writeInputFileL ctx f $ enc $ encode $ Message $ map packet xs
return $ KikiSuccess report
{-
getSubkeysForExport kk subspec db = do
kd <- maybeToList $ Map.lookup kk db
subkeysForExport subspec kd
-}
-- | If provided Nothing for the first argument, this function returns the
-- master key of the given identity. Otherwise, it returns all the subkeys of
-- the given identity which have a usage tag that matches the first argument.
subkeysForExport :: Maybe String -> KeyData -> [MappedPacket]
subkeysForExport subspec (KeyData key _ _ subkeys) = do
let subs tag = do
e <- Map.elems subkeys
guard $ doSearch key tag e
return $ subkeyMappedPacket e
maybe [key] subs subspec
where
doSearch key tag (SubKey sub_mp sigtrusts) =
let (_,v,_) = findTag [mkUsage tag]
(packet key)
(packet sub_mp)
sigtrusts
in fmap fst v==Just True
data PemType = PemPublicKey | PemPrivateKey | PemCertificate
pemTypeString :: PemType -> String
pemTypeString PemPublicKey = "PUBLIC KEY"
pemTypeString PemPrivateKey = "PRIVATE KEY"
pemTypeString PemCertificate = "CERTIFICATE"
writePEM :: PemType -> String -> String
writePEM (pemTypeString -> typ) dta = pem
where
pem = unlines . concat $
[ ["-----BEGIN " <> typ <> "-----"]
, split64s dta
, ["-----END " <> typ <> "-----"] ]
split64s :: String -> [String]
split64s "" = []
split64s dta = line : split64s rest where (line,rest) = splitAt 64 dta
-- 64 byte lines
rsaPrivateKeyFromPacket :: Packet -> Maybe RSAPrivateKey
rsaPrivateKeyFromPacket pkt@(SecretKeyPacket {}) = do
-- public fields...
n <- lookup 'n' $ key pkt
e <- lookup 'e' $ key pkt
-- secret fields
MPI d <- lookup 'd' $ key pkt
MPI q <- lookup 'p' $ key pkt -- Note: p & q swapped
MPI p <- lookup 'q' $ key pkt -- Note: p & q swapped
-- Note: Here we fail if 'u' key is missing.
-- Ideally, it would be better to compute (inverse q) mod p
-- see Algebra.Structures.EuclideanDomain.extendedEuclidAlg
-- (package constructive-algebra)
coefficient <- lookup 'u' $ key pkt
let dmodp1 = MPI $ d `mod` (p - 1)
dmodqminus1 = MPI $ d `mod` (q - 1)
return $ RSAPrivateKey
{ rsaN = n
, rsaE = e
, rsaD = MPI d
, rsaP = MPI p
, rsaQ = MPI q
, rsaDmodP1 = dmodp1
, rsaDmodQminus1 = dmodqminus1
, rsaCoefficient = coefficient }
rsaPrivateKeyFromPacket _ = Nothing
secretPemFromPacket :: Packet -> Maybe String
secretPemFromPacket packet = pemFromPacket Sec packet
pemFromPacket :: Access -> Packet -> Maybe String
pemFromPacket Sec packet =
case key_algorithm packet of
RSA -> do
rsa <- rsaPrivateKeyFromPacket packet -- RSAPrivateKey
let asn1 = toASN1 rsa []
bs = encodeASN1 DER asn1
#if defined(VERSION_memory)
dta = S8.unpack $ convertToBase Base64 (L.toStrict bs)
#elif defined(VERSION_dataenc)
dta = Base64.encode (L.unpack bs)
#endif
output = writePEM PemPrivateKey dta
Just output
algo -> Nothing
pemFromPacket Pub packet =
case key_algorithm packet of
RSA -> do
rsa <- rsaKeyFromPacket packet
let asn1 = toASN1 (pkcs8 rsa) []
bs = encodeASN1 DER asn1
#if defined(VERSION_memory)
dta = S8.unpack $ convertToBase Base64 (L.toStrict bs)
#elif defined(VERSION_dataenc)
dta = Base64.encode (L.unpack bs)
#endif
output = writePEM PemPublicKey dta
Just output
algo -> Nothing
pemFromPacket AutoAccess p@(PublicKeyPacket {}) = pemFromPacket Pub p
pemFromPacket AutoAccess p@(SecretKeyPacket {}) = pemFromPacket Sec p
pemFromPacket AutoAccess _ = Nothing
writeKeyToFile ::
StreamInfo -> InputFile -> Packet -> IO [(InputFile, KikiReportAction)]
writeKeyToFile stream@(StreamInfo { typ = PEMFile }) fname packet = do
case pemFromPacket (access stream) packet of
Just output -> do
let stamp = toEnum . fromEnum $ timestamp packet
handleIO_ (return [(fname, FailedFileWrite)]) $ do
saved_mask <- setFileCreationMask 0o077
-- Note: The key's timestamp is included in it's fingerprint.
-- Therefore, we should attempt to preserve it.
writeStamped (InputFileContext "" "") fname stamp output
setFileCreationMask saved_mask
return [(fname, ExportedSubkey)]
Nothing -> return [(fname, UnableToExport (key_algorithm packet) $ fingerprint packet)]
writeKeyToFile StreamInfo { typ = DNSPresentation } fname packet = do
case key_algorithm packet of
RSA -> do
flip (maybe (return []))
(rsaPrivateKeyFromPacket packet) -- RSAPrivateKey
$ \rsa -> do
let -- asn1 = toASN1 rsa []
-- bs = encodeASN1 DER asn1
-- dta = Base64.encode (L.unpack bs)
#if defined(VERSION_memory)
b64 ac rsa = S8.unpack $ convertToBase Base64 $ i2bs_unsized i
#elif defined(VERSION_dataenc)
b64 ac rsa = Base64.encode (S.unpack $ i2bs_unsized i)
#endif
where
MPI i = ac rsa
i2bs_unsized :: Integer -> S.ByteString
i2bs_unsized 0 = S.singleton 0
i2bs_unsized i = S.reverse $ S.unfoldr go i
where go i' = if i' <= 0 then Nothing
else Just (fromIntegral i', (i' `shiftR` 8))
output = unlines
[ "Private-key-format: v1.2"
, "Algorithm: 8 (RSASHA256)"
, "Modulus: " ++ b64 rsaN rsa
, "PublicExponent: " ++ b64 rsaE rsa
, "PrivateExponent: " ++ b64 rsaD rsa
, "Prime1: " ++ b64 rsaP rsa
, "Prime2: " ++ b64 rsaQ rsa
, "Exponent1: " ++ b64 rsaDmodP1 rsa
, "Exponent2: " ++ b64 rsaDmodQminus1 rsa
, "Coefficient: " ++ b64 rsaCoefficient rsa
]
stamp = toEnum . fromEnum $ timestamp packet
handleIO_ (return [(fname, FailedFileWrite)]) $ do
saved_mask <- setFileCreationMask 0o077
-- Note: The key's timestamp is included in it's fingerprint.
-- Therefore, we should attempt to preserve it.
writeStamped (InputFileContext "" "") fname stamp output
setFileCreationMask saved_mask
return [(fname, ExportedSubkey)]
algo -> return [(fname, UnableToExport algo $ fingerprint packet)]
writePEMKeys :: (PacketDecrypter)
-> KeyDB
-> [(FilePath,Maybe String,[MappedPacket],StreamInfo)]
-> IO (KikiCondition [(FilePath,KikiReportAction)])
writePEMKeys doDecrypt db exports = do
ds <- mapM decryptKeys exports
let ds' = map functorToEither ds
if null (lefts ds')
then do
rs <- mapM (\(f,stream,p) -> writeKeyToFile stream (ArgFile f) p)
(rights ds')
return $ KikiSuccess (map (first $ resolveForReport Nothing) $ concat rs)
else do
return (head $ lefts ds')
where
decryptKeys (fname,subspec,[p],stream@(StreamInfo { access=Pub }))
= return $ KikiSuccess (fname,stream,packet p) -- public keys are never encrypted.
decryptKeys (fname,subspec,[p],stream) = do
pun <- doDecrypt p
try pun $ \pun -> do
return $ KikiSuccess (fname,stream,pun)
initializeMissingPEMFiles ::
KeyRingOperation
-> InputFileContext
-> Maybe String
-> Maybe MappedPacket
-> PacketTranscoder
-> KeyDB
-> IO (KikiCondition ( (KeyDB,[( FilePath
, Maybe String
, [MappedPacket]
, StreamInfo )])
, [(FilePath,KikiReportAction)]))
initializeMissingPEMFiles operation ctx grip mwk transcode db = do
let decrypt = transcode (Unencrypted,S2K 100 "")
-- nonexistants - files missing from disk.
nonexistents <-
filterM (fmap not . doesFileExist . fst)
$ do (f,t) <- Map.toList (opFiles operation)
f <- resolveInputFile ctx f
return (f,t)
-- missing - mutable files not in the keyring and not on disk
-- notmissing - mutable keys in the keyring, but not on disk
let (missing,notmissing) = partition (\(_,_,ns,_)->null (ns >>= snd)) $ do
(fname,stream) <- nonexistents
let mutableTag
| isMutable stream = usageFromFilter (fill stream)
| otherwise = Nothing
usage <- maybeToList mutableTag
-- TODO: Use parseSpec3
-- TODO: Report error if generating without specifying usage tag.
let (topspec,subspec) = parseSpec (fromMaybe "" grip) usage
-- ms will contain duplicates if a top key has multiple matching
-- subkeys. This is intentional.
-- ms = map (keykey . fst) $ selectAll True (topspec,subspec) db
-- ms = filterMatches topspec $ Map.toList db
ns = do
(kk,kd) <- filterMatches topspec $ Map.toList db
return (kk , subkeysForExport subspec kd)
return (fname,subspec,ns,stream)
(exports0,ambiguous) = partition (\(_,_,ns,_)->null $ drop 1 $ (ns>>=snd))
notmissing
exports = map (\(f,subspec,ns,stream) -> (f,subspec,ns >>= snd,stream)) exports0
ambiguity (f,topspec,subspec,_) = do
return $ AmbiguousKeySpec f
ifnotnull (x:xs) f g = f x
ifnotnull _ f g = g
ifnotnull ambiguous ambiguity $ do
-- create nonexistent files via external commands
do
let cmds = mapMaybe getcmd missing
where
getcmd (fname,subspec,ms,stream) = do
cmd <- case initializer stream of
External str -> Just str
_ -> Nothing
return (fname,subspec,ms,stream,cmd)
rs <- forM cmds $ \tup@(fname,subspec,ms,stream,cmd) -> do
e <- systemEnv [ ("file",fname)
, ("usage",fromMaybe "" subspec) ]
cmd
case e of
ExitFailure num -> return (tup,FailedExternal num)
ExitSuccess -> return (tup,ExternallyGeneratedFile)
v <- foldM (importSecretKey transcode)
(KikiSuccess (db,[])) $ do
((f,subspec,ms,stream,cmd),r) <- rs
guard $ case r of
ExternallyGeneratedFile -> True
_ -> False
return (ArgFile f,subspec,map fst ms,stream,cmd)
try v $ \(db,import_rs) -> do
-- generateInternals
let internals = mapMaybe getParams $ do
(f,stream) <- nonexistents
usage <- take 1 $ mapMaybe usageFromFilter [fill stream,spill stream]
let (topspec,subspec) = parseSpec (fromMaybe "" grip) usage
guard $ null $ do
(kk,kd) <- filterMatches topspec $ Map.toList db
subkeysForExport subspec kd
return (f,stream)
where
getParams (fname,stream) =
case initializer stream of
Internal p -> do _ <- internalInitializer stream
Just $ Right (p, stream)
WarnMissing warning -> Just $ Left warning
_ -> Nothing
internalInitializer StreamInfo
{ initializer = Internal _
, spill = KF_Match tag } = Just tag
internalInitializer _ = Nothing
mapM_ (hPutStrLn stderr) (lefts internals)
v <- generateInternals transcode mwk db (rights internals)
try v $ \(db,internals_rs) -> do
return $ KikiSuccess ((db,exports), map (\((f,_,_,_,_),r)->(f,r)) rs
++ import_rs ++ internals_rs)
-- FIXME: try' should probably accept a list of KikiReportActions.
-- This would be useful for reporting on disk writes that have already
-- succeded prior to this termination.
try' :: Monad m => KikiCondition t -> (t -> m (KikiResult a)) -> m (KikiResult a)
try' v body =
case functorToEither v of
Left e -> return $ KikiResult e []
Right wkun -> body wkun
-- | Load and update key files according to the specified 'KeyRingOperation'.
runKeyRing :: KeyRingOperation -> IO (KikiResult KeyRingRuntime)
runKeyRing operation =
withLockedKeyring (opHome operation)
(opFiles operation)
$ realRunKeyRing operation
withLockedKeyring :: Maybe FilePath
-> Map.Map InputFile StreamInfo
-> (InputFileContext -> Maybe String -> IO (KikiResult a))
-> IO (KikiResult a)
withLockedKeyring homespec opfiles go = do
-- get homedir and keyring files + fingerprint for working key
homedir <- getHomeDir homespec
try' homedir $ \(_homedir, secring, pubring, grip0) -> do
let ctx = InputFileContext secring pubring
tolocks = filesToLock opfiles ctx
secring <- return Nothing
pubring <- return Nothing
(locks :: [(Maybe DotLock, FilePath)]) <-
forM tolocks $ \f -> do
createDirectoryIfMissing True $ takeDirectory f
lk <- dotlock_create f 0
v <- flip (maybe $ return Nothing) lk $ \lk -> do
e <- dotlock_take lk (-1)
if e==0 then return $ Just lk
else dotlock_destroy lk >> return Nothing
return (v,f)
let (lked, map snd -> failed_locks) = partition (isJust . fst) locks
ret <-
if not $ null failed_locks
then return $ KikiResult (FailedToLock failed_locks) []
else go ctx grip0
forM_ lked $ \(Just lk, fname) -> dotlock_release lk
return ret
realRunKeyRing :: KeyRingOperation -> InputFileContext -> Maybe String -> IO (KikiResult KeyRingRuntime)
realRunKeyRing operation ctx grip0 = do
bresult <- buildKeyDB ctx grip0 operation
try' bresult $ \((db, grip, wk, hs, accs,transcode,unspilled), report_imports) -> do
externals_ret <- initializeMissingPEMFiles operation
ctx
grip
wk
transcode
db
try' externals_ret $ \((db, exports), report_externals) -> do
let decrypt = transcode (Unencrypted,S2K 100 "")
rt = KeyRingRuntime
{ rtPubring = homepubPath ctx
, rtSecring = homesecPath ctx
, rtGrip = grip
, rtWorkingKey = fmap packet wk
, rtKeyDB = db
, rtRingAccess = accs
, rtPassphrases = transcode
}
-- Maybe add signatures, delete subkeys
r <- performManipulations decrypt
rt
wk
(combineTransforms $ opTransforms operation)
try' r $ \(rt,report_manips) -> do
r <- writeWalletKeys operation (rtKeyDB rt) (fmap packet wk)
try' r $ \report_wallets -> do
r <- writeRingKeys operation rt unspilled report_manips
try' r $ \report_rings -> do
r <- writePEMKeys decrypt (rtKeyDB rt) exports
try' r $ \report_pems -> do
import_hosts <- writeHostsFiles operation ctx hs
return $ KikiResult (KikiSuccess rt)
$ concat [ report_imports
, report_externals
, report_manips
, report_wallets
, report_rings
, report_pems ]
parseOptionFile :: FilePath -> IO [String]
parseOptionFile fname = do
xs <- fmap lines (readFile fname)
let ys = filter notComment xs
notComment ('#':_) = False
notComment cs = not (all isSpace cs)
return ys
-- | returns ( home directory
-- , path to secret ring
-- , path to public ring
-- , fingerprint of working key
-- )
getHomeDir :: Maybe FilePath -> IO (KikiCondition (FilePath,FilePath,FilePath,Maybe String))
getHomeDir protohome = do
homedir <- envhomedir protohome
flip (maybe (return CantFindHome))
homedir $ \homedir -> do
-- putStrLn $ "homedir = " ++show homedir
let secring = homedir ++ "/" ++ "secring.gpg"
pubring = homedir ++ "/" ++ "pubring.gpg"
-- putStrLn $ "secring = " ++ show secring
workingkey <- getWorkingKey homedir
return $ KikiSuccess (homedir,secring,pubring,workingkey)
where
envhomedir opt = do
gnupghome <- fmap (mfilter (/="")) $ lookupEnv (homevar home)
homed <- fmap (mfilter (/="") . Just) getHomeDirectory
let homegnupg = (++('/':(appdir home))) <$> homed
let val = (opt `mplus` gnupghome `mplus` homegnupg)
return $ val
-- TODO: rename this to getGrip
getWorkingKey homedir = do
let o = Nothing
h = Just homedir
ofile <- fmap listToMaybe . flip (maybe (return [])) h $ \h ->
let optfiles = map (second ((h++"/")++))
(maybe optfile_alts' (:[]) o')
optfile_alts' = zip (False:repeat True) (optfile_alts home)
o' = fmap (False,) o
in filterM (doesFileExist . snd) optfiles
args <- flip (maybe $ return []) ofile $
\(forgive,fname) -> parseOptionFile fname
let config = map (topair . words) args
where topair (x:xs) = (x,xs)
return $ lookup "default-key" config >>= listToMaybe
#if MIN_VERSION_base(4,6,0)
#else
lookupEnv :: String -> IO (Maybe String)
lookupEnv var =
handleIO_ (return Nothing) $ fmap Just (getEnv var)
#endif
{-
onionName :: KeyData -> (SockAddr,L.ByteString)
onionName kd = (addr,name)
where
(addr,(name:_,_)) = getHostnames kd
-}
#if ! MIN_VERSION_unix(2,7,0)
setFdTimesHiRes :: Posix.Fd -> POSIXTime -> POSIXTime -> IO ()
setFdTimesHiRes (Posix.Fd fd) atime mtime =
withArray [toCTimeSpec atime, toCTimeSpec mtime] $ \times ->
throwErrnoIfMinus1_ "setFdTimesHiRes" (c_futimens fd times)
data CTimeSpec = CTimeSpec Posix.EpochTime CLong
instance Storable CTimeSpec where
sizeOf _ = (16)
alignment _ = alignment (undefined :: CInt)
poke p (CTimeSpec sec nsec) = do
((\hsc_ptr -> pokeByteOff hsc_ptr 0)) p sec
((\hsc_ptr -> pokeByteOff hsc_ptr 8)) p nsec
peek p = do
sec <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
nsec <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
return $ CTimeSpec sec nsec
toCTimeSpec :: POSIXTime -> CTimeSpec
toCTimeSpec t = CTimeSpec (CTime sec) (truncate $ 10^(9::Int) * frac)
where
(sec, frac) = if (frac' < 0) then (sec' - 1, frac' + 1) else (sec', frac')
(sec', frac') = properFraction $ toRational t
foreign import ccall unsafe "futimens"
c_futimens :: CInt -> Ptr CTimeSpec -> IO CInt
#endif
|