]> git.sommitrealweird.co.uk Git - onak.git/blob - keyindex.c
cscvs to tla changeset 7
[onak.git] / keyindex.c
1 /*
2  * keyindex.c - Routines to list an OpenPGP key.
3  *
4  * Jonathan McDowell <noodles@earth.li>
5  *
6  * Copyright 2002 Project Purple
7  */
8
9 #include <assert.h>
10 #include <stdbool.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <time.h>
15
16 #include "getcgi.h"
17 #include "hash.h"
18 #include "keydb.h"
19 #include "keyid.h"
20 #include "keyindex.h"
21 #include "keystructs.h"
22 #include "ll.h"
23 #include "stats.h"
24
25 int parse_subpackets(unsigned char *data, bool html)
26 {
27         int offset = 0;
28         int length = 0;
29         int packetlen = 0;
30         char *uid;
31
32         assert(data != NULL);
33
34         length = (data[0] << 8) + data[1] + 2;
35
36         offset = 2;
37         while (offset < length) {
38                 packetlen = data[offset++];
39                 if (packetlen > 191 && packetlen < 255) {
40                         packetlen = ((packetlen - 192) << 8) +
41                                         data[offset++] + 192;
42                 } else if (packetlen == 255) {
43                         packetlen = data[offset++];
44                         packetlen <<= 8;
45                         packetlen = data[offset++];
46                         packetlen <<= 8;
47                         packetlen = data[offset++];
48                         packetlen <<= 8;
49                         packetlen = data[offset++];
50                 }
51                 switch (data[offset]) {
52                 case 2:
53                         /*
54                          * Signature creation time. Might want to output this?
55                          */
56                         break;
57                 case 16:
58                         uid = keyid2uid(
59                                 ((uint64_t) data[offset+packetlen - 8] << 56) +
60                                 ((uint64_t) data[offset+packetlen - 7] << 48) +
61                                 ((uint64_t) data[offset+packetlen - 6] << 40) +
62                                 ((uint64_t) data[offset+packetlen - 5] << 32) +
63                                 ((uint64_t) data[offset+packetlen - 4] << 24) +
64                                 ((uint64_t) data[offset+packetlen - 3] << 16) +
65                                 ((uint64_t) data[offset+packetlen - 2] << 8) +
66                                 data[offset+packetlen - 1]);
67                         if (html && uid != NULL) {
68                                 printf("sig         <a href=\"lookup?op=get&"
69                                         "search=%02X%02X%02X%02X\">"
70                                         "%02X%02X%02X%02X</a>             "
71                                         "<a href=\"lookup?op=vindex&"
72                                         "search=0x%02X%02X%02X%02X\">"
73                                         "%s</a>\n",
74                                         data[offset+packetlen - 4],
75                                         data[offset+packetlen - 3],
76                                         data[offset+packetlen - 2],
77                                         data[offset+packetlen - 1],
78                                         data[offset+packetlen - 4],
79                                         data[offset+packetlen - 3],
80                                         data[offset+packetlen - 2],
81                                         data[offset+packetlen - 1],
82
83                                         data[offset+packetlen - 4],
84                                         data[offset+packetlen - 3],
85                                         data[offset+packetlen - 2],
86                                         data[offset+packetlen - 1],
87                                         txt2html(uid));
88                         } else if (html && uid == NULL) {
89                                 printf("sig         "
90                                         "%02X%02X%02X%02X             "
91                                         "[User id not found]\n",
92                                         data[offset+packetlen - 4],
93                                         data[offset+packetlen - 3],
94                                         data[offset+packetlen - 2],
95                                         data[offset+packetlen - 1]);
96                         } else {
97                                 printf("sig         %02X%02X%02X%02X"
98                                                 "             %s\n",
99                                         data[offset+packetlen - 4],
100                                         data[offset+packetlen - 3],
101                                         data[offset+packetlen - 2],
102                                         data[offset+packetlen - 1],
103                                         (uid != NULL) ? uid :
104                                         "[User id not found]");
105                         }
106                         break;
107                 default:
108                         /*
109                          * We don't care about unrecognized packets unless bit
110                          * 7 is set in which case we prefer an error than
111                          * ignoring it.
112                          */
113                         assert(!(data[offset] & 0x80));
114                 }
115                 offset += packetlen;
116         }
117
118         return length;
119 }
120
121 int list_sigs(struct openpgp_packet_list *sigs, bool html)
122 {
123         int length = 0;
124         char *uid;
125
126         while (sigs != NULL) {
127                 switch (sigs->packet->data[0]) {
128                 case 2:
129                 case 3:
130                         uid = keyid2uid(
131                                 ((uint64_t) sigs->packet->data[7] << 56) +
132                                 ((uint64_t) sigs->packet->data[8] << 48) +
133                                 ((uint64_t) sigs->packet->data[9] << 40) +
134                                 ((uint64_t) sigs->packet->data[10] << 32) +
135                                 ((uint64_t) sigs->packet->data[11] << 24) +
136                                 ((uint64_t) sigs->packet->data[12] << 16) +
137                                 ((uint64_t) sigs->packet->data[13] << 8) +
138                                 sigs->packet->data[14]);
139                         if (html && uid != NULL) {
140                                 printf("sig         <a href=\"lookup?op=get&"
141                                         "search=%02X%02X%02X%02X\">"
142                                         "%02X%02X%02X%02X</a>             "
143                                         "<a href=\"lookup?op=vindex&"
144                                         "search=0x%02X%02X%02X%02X\">"
145                                         "%s</a>\n",
146                                         sigs->packet->data[11],
147                                         sigs->packet->data[12],
148                                         sigs->packet->data[13],
149                                         sigs->packet->data[14],
150                                         sigs->packet->data[11],
151                                         sigs->packet->data[12],
152                                         sigs->packet->data[13],
153                                         sigs->packet->data[14],
154
155                                         sigs->packet->data[11],
156                                         sigs->packet->data[12],
157                                         sigs->packet->data[13],
158                                         sigs->packet->data[14],
159                                         txt2html(uid));
160                         } else if (html && uid == NULL) {
161                                 printf("sig         %02X%02X%02X%02X"
162                                         "             "
163                                         "[User id not found]\n",
164                                         sigs->packet->data[11],
165                                         sigs->packet->data[12],
166                                         sigs->packet->data[13],
167                                         sigs->packet->data[14]);
168                         } else {
169                                 printf("sig         %02X%02X%02X%02X"
170                                                 "             %s\n",
171                                         sigs->packet->data[11],
172                                         sigs->packet->data[12],
173                                         sigs->packet->data[13],
174                                         sigs->packet->data[14],
175                                         (uid != NULL) ? uid :
176                                         "[User id not found]");
177                         }
178                         break;
179                 case 4:
180                         length = parse_subpackets(&sigs->packet->data[4], html);
181                         parse_subpackets(&sigs->packet->data[length + 4], html);
182                         break;
183                 default:
184                         printf("sig        [Unknown packet version %d]",
185                                         sigs->packet->data[0]);
186                 }
187                 sigs = sigs->next;
188         }
189
190         return 0;
191 }
192
193 int list_uids(struct openpgp_signedpacket_list *uids, bool verbose, bool html)
194 {
195         char buf[1024];
196
197         while (uids != NULL) {
198                 if (uids->packet->tag == 13) {
199                         snprintf(buf, 1023, "%.*s",
200                                 (int) uids->packet->length,
201                                 uids->packet->data);
202                         printf("uid                             %s\n",
203                                 (html) ? txt2html(buf) : buf);
204                 } else if (uids->packet->tag == 17) {
205                         printf("uid                             "
206                                 "[photo id]\n");
207                 }
208                 if (verbose) {
209                         list_sigs(uids->sigs, html);
210                 }
211                 uids = uids->next;
212         }
213
214         return 0;
215 }
216
217 /**
218  *      key_index - List a set of OpenPGP keys.
219  *      @keys: The keys to display.
220  *      @verbose: Should we list sigs as well?
221  *      @fingerprint: List the fingerprint?
222  *      @html: Should the output be tailored for HTML?
223  *
224  *      This function takes a list of OpenPGP public keys and displays an index
225  *      of them. Useful for debugging or the keyserver Index function.
226  */
227 int key_index(struct openpgp_publickey *keys, bool verbose, bool fingerprint,
228                         bool html)
229 {
230         struct openpgp_signedpacket_list        *curuid = NULL;
231         struct tm                               *created = NULL;
232         time_t                                   created_time = 0;
233         int                                      type = 0;
234         int                                      length = 0;
235         char                                     buf[1024];
236
237         if (html) {
238                 puts("<pre>");
239         }
240         puts("Type   bits/keyID    Date       User ID");
241         while (keys != NULL) {
242                 created_time = (keys->publickey->data[1] << 24) +
243                                         (keys->publickey->data[2] << 16) +
244                                         (keys->publickey->data[3] << 8) +
245                                         keys->publickey->data[4];
246                 created = gmtime(&created_time);
247
248                 switch (keys->publickey->data[0]) {
249                 case 2:
250                 case 3:
251                         type = keys->publickey->data[7];
252                         length = (keys->publickey->data[8] << 8) +
253                                         keys->publickey->data[9];
254                         break;
255                 case 4:
256                         type = keys->publickey->data[5];
257                         length = (keys->publickey->data[6] << 8) +
258                                         keys->publickey->data[7];
259                         break;
260                 default:
261                         fprintf(stderr, "Unknown key type: %d\n",
262                                 keys->publickey->data[0]);
263                 }
264                 
265                 printf("pub  %5d%c/%08X %04d/%02d/%02d ",
266                         length,
267                         (type == 1) ? 'R' : ((type == 17) ? 'D' : '?'),
268                         (uint32_t) (get_keyid(keys) & 0xFFFFFFFF),
269                         created->tm_year + 1900,
270                         created->tm_mon + 1,
271                         created->tm_mday);
272
273                 curuid = keys->uids;
274                 if (curuid != NULL && curuid->packet->tag == 13) {
275                         snprintf(buf, 1023, "%.*s",
276                                 (int) curuid->packet->length,
277                                 curuid->packet->data);
278                         printf("%s\n", (html) ? txt2html(buf) : buf);
279                         if (verbose) {
280                                 list_sigs(curuid->sigs, html);
281                         }
282                         curuid = curuid->next;
283                 } else {
284                         putchar('\n');
285                 }
286
287                 list_uids(curuid, verbose, html);
288
289                 //TODO: List subkeys.
290
291                 keys = keys->next;
292         }
293
294         if (html) {
295                 puts("</pre>");
296         }
297
298         return 0;
299 }
300
301
302 int get_subpackets_keyid(unsigned char *data, uint64_t *keyid)
303 {
304         int offset = 0;
305         int length = 0;
306         int packetlen = 0;
307
308         assert(data != NULL);
309
310         length = (data[0] << 8) + data[1] + 2;
311
312         offset = 2;
313         while (offset < length) {
314                 packetlen = data[offset++];
315                 if (packetlen > 191 && packetlen < 255) {
316                         packetlen = ((packetlen - 192) << 8) +
317                                         data[offset++] + 192;
318                 } else if (packetlen == 255) {
319                         packetlen = data[offset++];
320                         packetlen <<= 8;
321                         packetlen = data[offset++];
322                         packetlen <<= 8;
323                         packetlen = data[offset++];
324                         packetlen <<= 8;
325                         packetlen = data[offset++];
326                 }
327                 switch (data[offset]) {
328                 case 2:
329                         /*
330                          * Signature creation time. Might want to output this?
331                          */
332                         break;
333                 case 0x83:
334                         /*
335                          * Signature expiration time. Might want to output this?
336                          */
337                         break;
338                 case 16:
339                         *keyid = data[offset+packetlen - 8];
340                         *keyid <<= 8;
341                         *keyid += data[offset+packetlen - 7];
342                         *keyid <<= 8;
343                         *keyid += data[offset+packetlen - 6];
344                         *keyid <<= 8;
345                         *keyid += data[offset+packetlen - 5];
346                         *keyid <<= 8;
347                         *keyid += data[offset+packetlen - 4];
348                         *keyid <<= 8;
349                         *keyid += data[offset+packetlen - 3];
350                         *keyid <<= 8;
351                         *keyid += data[offset+packetlen - 2];
352                         *keyid <<= 8;
353                         *keyid += data[offset+packetlen - 1];
354                         break;
355                 default:
356                         /*
357                          * We don't care about unrecognized packets unless bit
358                          * 7 is set in which case we prefer an error than
359                          * ignoring it.
360                          */
361                         assert(!(data[offset] & 0x80));
362                 }
363                 offset += packetlen;
364         }
365
366         return length;
367 }
368
369
370 /**
371  *      keysigs - Return the sigs on a given OpenPGP signature list.
372  *      @curll: The current linked list. Can be NULL to create a new list.
373  *      @sigs: The signature list we want the sigs on.
374  *
375  *      Returns a linked list of stats_key elements containing the sigs on the
376  *      supplied OpenPGP packet list.
377  */
378 struct ll *keysigs(struct ll *curll,
379                 struct openpgp_packet_list *sigs)
380 {
381         int length = 0;
382         uint64_t keyid = 0;
383         
384         while (sigs != NULL) {
385                 keyid = 0;
386                 switch (sigs->packet->data[0]) {
387                 case 2:
388                 case 3:
389                         keyid = sigs->packet->data[7];
390                         keyid <<= 8;
391                         keyid += sigs->packet->data[8];
392                         keyid <<= 8;
393                         keyid += sigs->packet->data[9];
394                         keyid <<= 8;
395                         keyid += sigs->packet->data[10];
396                         keyid <<= 8;
397                         keyid += sigs->packet->data[11];
398                         keyid <<= 8;
399                         keyid += sigs->packet->data[12];
400                         keyid <<= 8;
401                         keyid += sigs->packet->data[13];
402                         keyid <<= 8;
403                         keyid += sigs->packet->data[14];
404                         break;
405                 case 4:
406                         length = get_subpackets_keyid(&sigs->packet->data[4],
407                                         &keyid);
408                         get_subpackets_keyid(&sigs->packet->data[length + 4],
409                                         &keyid);
410                         /*
411                          * Don't bother to look at the unsigned packets.
412                          */
413                         break;
414                 default:
415                         break;
416                 }
417                 sigs = sigs->next;
418                 curll = lladd(curll, createandaddtohash(keyid));
419         }
420
421         return curll;
422 }
423
424 /*
425  * TODO: Abstract out; all our linked lists should be generic and then we can
426  * llsize them.
427  */
428 int spsize(struct openpgp_signedpacket_list *list)
429 {
430         int size = 0;
431         struct openpgp_signedpacket_list *cur;
432
433         for (cur = list; cur != NULL; cur = cur->next, size++) ;
434
435         return size;
436 }
437
438 /**
439  *      keyuids - Takes a key and returns an array of its UIDs
440  *      @key: The key to get the uids of.
441  *      @primary: A pointer to store the primary UID in.
442  *
443  *      keyuids takes a public key structure and builds an array of the UIDs 
444  *      on the key. It also attempts to work out the primary UID and returns a
445  *      separate pointer to that particular element of the array.
446  */
447 char **keyuids(struct openpgp_publickey *key, char **primary)
448 {
449         struct openpgp_signedpacket_list *curuid = NULL;
450         char buf[1024];
451         char **uids = NULL;
452         int count = 0;
453
454         if (key != NULL && key->uids != NULL) {
455                 uids = malloc((spsize(key->uids) + 1) * sizeof (char *));
456         
457                 curuid = key->uids;
458                 while (curuid != NULL) {
459                         buf[0] = 0;
460                         if (curuid->packet->tag == 13) {
461                                 snprintf(buf, 1023, "%.*s",
462                                                 (int) curuid->packet->length,
463                                                 curuid->packet->data);
464                                 uids[count++] = strdup(buf);
465                         }
466                         curuid = curuid -> next;
467                 }
468                 uids[count] = NULL;
469         }
470         /*
471          * TODO: Parse subpackets for real primary ID (v4 keys)
472          */
473         if (primary != NULL) {
474                 *primary = uids[0];
475         }
476
477         return uids;
478 }