See ChangeLog: Sat Mar 20 11:53:40 CET 1999 Werner Koch
[gnupg.git] / THOUGHTS
1
2
3 EGD
4 ====
5 Oh, and on embedding egd into the gpg package: I think if you just unpack it
6 into, say, util/egd/* then you can put something like this into configure.in:
7
8 AC_CHECK_PROG(perl_present, perl, true, false)
9 if $perl_present; then
10  AC_PATH_PROG(PERL, perl)
11  (cd util/egd; $PERL Makefile.PL FULLPERL=$PERL INSTALLBIN=$sbindir)
12 fi
13 AM_CONDITIONAL(WITH_EGD, $perl_present)
14
15 and add util/egd to the top-level Makefile directory list inside a WITH_EGD
16 conditional.
17
18
19
20 ====
21
22         /* we still have these if a signed signed more than one
23          * user ID.  I don't think that is makes sense to sign
24          * more than one user ID; an exception might be a user ID
25          * which is to be removed in near future.  Anyway it is
26          * always good to sign only those user ID which are
27          * unlikely to change.  It might be good to insert a
28          * user ID which does not contain an email address and
29          * mark this one with a special signature flag or let
30          * sign_key() suggest a user ID w/o an email address
31          */
32
33
34     * What shall we do if we have a valid subkey revocation certificate
35       but no subkey binding?  Is this a valid but revoked key?
36
37     * use a mmaped file for secure memory if mlock does not work and
38       make sure that this file is always wiped out.  Is this really
39       more secure than swapping out to the swap disk?  I don't
40       believe so because if an attacker has access to the physical
41       box (and he needs this to look at the swap area) he can also
42       leave a trojan horse which is far more easier than to analyze
43       memory dumps.  Question:  Is it possible that a Unix pages
44       an old (left over by some other process) swap page in for
45       another process - this should be considered a serious design
46       flow/bug.
47
48 Date: Mon, 4 Jan 1999 19:34:29 -0800 (PST)
49 From: Matthew Skala <mskala@ansuz.sooke.bc.ca>
50
51 - Signing with an expired key doesn't work by default, does work with a
52   special option.
53 - Verifying a signature that appears to have been made by an expired key
54   after its expiry date but is otherwise good reports the signature as BAD,
55   preferably with a message indicating that it's a key-expiry problem rather
56   than a cryptographically bad signature.
57 - Verifying a signature from a key that is now expired, where the
58   signature was made before the expiry date, reports the signature as
59   GOOD, possibly with a warning that the key has since expired.
60 - Encrypting to an expired key doesn't work by default, does work with a
61   special option.
62 - Decrypting always works, if you have the appropriate secret key and
63   passphrase.
64
65
66
67 -----BEGIN PGP SIGNED MESSAGE-----
68 Hash: SHA1
69
70 Hi Werner..
71
72 I was looking at some of the PROJECTS items in the recent gpg CVS and wanted
73 to comment on one of them:
74
75   * Add a way to override the current cipher/md implementations
76     by others (using extensions)
77
78 As you know I've been thinking about how to use a PalmPilot or an iButton in
79 some useful way in GPG. The two things that seem reasonable are:
80  1) keep the secret key in the device, only transferring it to the host
81     computer for the duration of the secret-key operation (sign or decrypt).
82     The key is never kept on disk, only in RAM. This removes the chance that
83     casual snooping on your office workstation will reveal your key (it
84     doesn't help against an active attack, but the attacker must leave a
85     tampered version of GPG around or otherwise get their code to run while
86     the key-storage device is attached to attack the key)
87  2) perform the secret-key operation on the device, so the secret key never
88     leaves the confines of that device. There are still attacks possible,
89     based upon talking to the device while it is connected and trying to
90     convince the device (and possibly the user) that it is the real GPG,
91     but in general this protects the key pretty strongly. Any individual
92     message is still vulnerable, but that's a tradeoff of the convenience of
93     composing that message on a full-sized screen+keyboard (plus the added
94     speed of encryption) vs. the security of writing the message on a
95     secure device.
96
97 I think there are a variety of ways of implementing these things, but a few
98 extension mechanisms in GPG should be enough to try various ways later on.
99
100 1) pass an argument string to loadable extension modules (maybe
101     gpg --load-extension foofish=arg1,arg2,arg3 ?)
102 2) allow multiple instances of the same extension module (presumably with
103    different arguments)
104 3) allow extension modules to use stdin/stdout/stderr as normal (probably
105    already in there), for giving feedback to the user, or possibly asking them
106    for a password of some sort
107 4) have an extension to provide secret keys:
108
109    It looks like most of the hooks for this are already in place, it just
110    needs an extension module which can register itself as a keyblock resource.
111
112    I'm thinking of a module for this that is given an external program name as
113    an argument. When the keyblock resource is asked to enumerate its keys, it
114    runs the external program (first with a "0" argument, then a "1", and so on
115    until the program reports that no more keys are available). The external
116    program returns one (possibly armored) secret key block each time. The
117    program might have some kind of special protocol to talk to the storage
118    device.  One thing that comes to mind is to simply include a random number
119    in the message sent over the serial port: the program would display this
120    number, the Pilot at the other end would display the number it receives, if
121    the user sees that both are the same they instruct the Pilot to release the
122    key, as basic protection against someone else asking for the key while it
123    is attached. More sophisticated schemes are possible depending upon how
124    much processing power and IO is available on the device. But the same
125    extension module should be able to handle as complex a scheme as one could
126    wish.
127
128    The current keyblock-resource interface would work fine, although it
129    might be more convenient if a resource could be asked for a key by id
130    instead of enumerating all of them and then searching through the resulting
131    list for a match. A module that provided public keys would have to work this
132    way (imagine a module that could automatically do an http fetch for a
133    particular key.. easily-added automatic key fetching). Without that ability
134    to fetch by id (which would require it to fall back to the other keyblock
135    resources if it failed), the user's device might be asked to release the
136    key even though some other secret key was the one needed.
137
138
139 5) have an extension to perform a secret-key operation without the actual
140    secret key material
141
142  basically something to indicate that any decrypt or sign operations that
143  occur for a specific keyid should call the extension module instead. The
144  secret key would not be extracted (it wouldn't be available anyway). The
145  module is given the keyid and the MPI of the block it is supposed to sign
146  or decrypt.
147
148  The module could then run an external program to do the operation. I'm
149  imagining a Pilot program which receives the data, asks the user if it can go
150  along with the operation (after displaying a hash of the request, which is
151  also displayed by the extension module's program to make sure the Pilot is
152  being asked to do the right operation), performs the signature or decryption,
153  then returns the data. This protocol could be made arbitrarily complex, with
154  a D-H key to encrypt the link, and both sides signing requests to
155  authenticate one to the other (although this transforms the the problem of
156  getting your secret key off your office workstation into the problem of
157  your workstation holding a key tells your Pilot that it is allowed to perform
158  the secret key operation, and if someone gets a hold of that key they may
159  be able to trick your pilot [plugged in somewhere else] to do the same thing
160  for them).
161
162  This is basically red/black separation, with the Pilot or iButton having the
163  perimeter beyond which the red data doesn't pass. Better than the secret-key
164  storage device but requires a lot more power on the device (the new iButtons
165  with the exponentiator could do it, but it would take way too much code space
166  on the old ones, although they would be fine for just carrying the keys).
167
168 The signature code might need to be extended to verify the signature you just
169 made, since an active intruder pretending to the the Pilot wouldn't be able to
170 make a valid signature (but they might sign your message with a different key
171 just to be annoying).
172
173 Anyway, just wanted to share my thoughts on some possibilities. I've been
174 carrying this little Java iButton on my keyring for months now, looking for
175 something cool to do with it, and I think that secure storage for my GPG key
176 would be just the right application.
177
178 cheers,
179  -Brian
180
181 -----BEGIN PGP SIGNATURE-----
182 Version: GnuPG v0.4.5 (GNU/Linux)
183 Comment: For info finger gcrypt@ftp.guug.de
184
185 iD8DBQE2c5oZkDmgv9E5zEwRArAwAKDWV5fpTtbGPiMPgl2Bpp0gvhbfQgCgzJuY
186 AmIQTk4s62/y2zMAHDdOzK0=
187 =jr7m
188 -----END PGP SIGNATURE-----
189
190
191
192 About a new Keyserver  (discussion with Allan Clark <allanc@sco.com>):
193 =====================
194
195 Some ideas:
196
197 o  the KS should verify signatures and only accept those
198    which are good.
199
200 o  Keep a blacklist of known bad signatures to minimize
201    the time needed to check them
202
203 o  Should be fast - I currently designing a new storage
204    system called keybox which takes advantage of the fact
205    that the keyID is highly random and can be directly be
206    used as a hash value and this keyID is (for v4 keys)
207    part of the fingerprint: So it is possible to use the
208    fingerprint as key but do an lookup by the keyID.
209
210 o  To be used as the "public keyring" in a LAN so that there
211    is no need to keep one on every machine.
212
213 o  Allow more that one file for key storage.
214
215 o  Use the HKS protocol and enhance it in a way that binary
216    keyrings can be transmitted.  (I already wrote some
217    http server and client code which can be used for this)
218    And extend it to allow reuse of a connection.
219
220 o  Keep a checksum (hash) of the entire keyblock so that a
221    client can easy check whether this keyblock has changed.
222    (keyblock = the entire key with all certificates etc.)
223    Transmitted in the HEAD info.
224
225 o  Allow efficient propagation of new keys and revocation
226    certificates.
227
228
229 Probably more things but this keyserver is not a goal for the
230 1.0 release. Someone should be able to fix some of the limitations
231 of the existing key servers (I think they bail out on some rfc2440
232 packet formats).
233