![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pgpsort.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / contrib / pgpsort|
Return to pgpsort.c CVS log | Up to [PGP] / pgp / contrib / pgpsort |
1.1 root 1: /******************************************************
2: * *
3: * PGPSort: a utility to sort PGP 2.x keyrings *
4: * . *
5: * (c)1995 by Stale Schumacher <[email protected]> *
6: * Version 1.01 - 1995/09/04 *
7: * *
8: * This program is placed in the public domain and *
9: * may be freely distributed and modified, as long *
10: * as this copyright notice remains intact. The code *
11: * was written from scratch based on the PGP 2.x *
12: * format specifications, and contains no source *
13: * from the PGP distribution. Based on a TurboPascal *
14: * implementation by the same author. *
15: * *
16: * DISCLAIMER: PGPSort will always make a backup of *
17: * the keyring before sorting it, but the author *
18: * cannot take any responsibility for damage that *
19: * the program may cause. Use PGPSort at your own *
20: * risk! *
21: * *
22: * NOTE FOR PROGRAMMERS: This program was written *
23: * for portability, _not_ for speed! :-) *
24: * *
25: ******************************************************/
26:
27: #include <stdlib.h>
28: #include <stdio.h>
29: #include <string.h>
30: #include <ctype.h>
31:
32: #define MAXKEYS 20000 /* Increase this if necessary */
33:
34: #ifndef TRUE
35: #define FALSE 0
36: #define TRUE !FALSE
37: #endif
38:
39: #ifndef SEEK_SET
40: #define SEEK_SET 0
41: #endif
42:
43: #ifndef MIN
44: #define MIN(a,b) ((a)<(b)?(a):(b))
45: #endif
46:
47: #ifndef FILENAME_MAX
48: #include <sys/param.h>
49: #ifdef MAXPATHLEN
50: #define FILENAME_MAX MAXPATHLEN
51: #endif
52: #endif
53:
54: typedef unsigned char byte;
55: typedef unsigned char boolean;
56: typedef unsigned short word16;
57: typedef unsigned long word32;
58:
59: #define CTB_PUBKEY 24
60: #define CTB_SECKEY 20
61: #define CTB_USERID 52
62: #define CTB_TRUST 48
63: #define CTB_SIG 8
64:
65: #define ERR_OK 0
66: #define ERR_ILLEGAL_PARAMS 1
67: #define ERR_FILE_NOT_OPEN 2
68: #define ERR_NOT_A_KEYRING 3
69: #define ERR_COULD_NOT_BACKUP 4
70: #define ERR_KEYRING_CORRUPT 5
71: #define ERR_OUT_OF_MEMORY 6
72:
73: #define SORT_NOSORT 0
74: #define SORT_ON_USERID 1
75: #define SORT_ON_KEYID 2
76: #define SORT_ON_DATE 3
77: #define SORT_ON_SIZE 4
78:
79: #define ASCENDING TRUE
80: #define DESCENDING FALSE
81:
82: #define BADKEY_NO_USERID 0
83: #define BADKEY_BOGUS_USERID 1
84: #define BADKEY_SECRET_KEY 2
85:
86: struct keydata {
87: long fpos;
88: word32 length,
89: keyid,
90: date;
91: word16 size;
92: char userid[26];
93: boolean secret,
94: removed;
95: };
96:
97: struct keydata *key[MAXKEYS];
98: int keys = 0;
99: int sort_criterion;
100: boolean sort_order;
101: boolean remove_bad_keys;
102:
103: word32 get_packet_length(byte ctb, FILE *fp)
104: {
105: byte l[4] = {1,2,4,0},
106: llength = l[ctb & 0x03],
107: i;
108: word32 length = 0;
109:
110: for (i=0; i<llength; i++)
111: length = (length << 8) + (byte) fgetc(fp);
112: return length;
113: }
114:
115: word32 read_word32(FILE *fp)
116: {
117: int i;
118: word32 word;
119:
120: for (i=0; i<32/8; i++)
121: word = (word << 8) + (byte) fgetc(fp);
122: return word;
123: }
124:
125: word16 read_word16(FILE *fp)
126: {
127: int i;
128: word16 word;
129:
130: for (i=0; i<16/8; i++)
131: word = (word << 8) + (byte) fgetc(fp);
132: return word;
133: }
134:
135: char *strupper(char *s)
136: {
137: char *p;
138: for (p=s; *p; p++)
139: *p=toupper(*p);
140: return s;
141: }
142:
143: char *strend(char *s)
144: {
145: char *p;
146: for (p=s; *p; p++);
147: return p;
148: }
149:
150: char *strstrip(char *s)
151: {
152: char *p;
153: # define stripchar(c) (c==' ' || c=='>' || c=='-')
154:
155: p=strend(s);
156: for (p--; p >= s && stripchar(*p); p--)
157: *p='\0';
158: return s;
159: }
160:
161: char *force_extension(char *filename, char *extension)
162: {
163: char *p;
164: p=strrchr(filename, '.');
165: if (!p) p=strend(filename);
166: strcpy(p, extension);
167: return filename;
168: }
169:
170: char *add_slash(char *directory)
171: {
172: char *p;
173: p=strend(directory); p--;
174: if (*p != '/' && strchr(directory, '/'))
175: strcat(directory, "/"); /* Unix */
176: if (*p != '\\' && strchr(directory, '\\'))
177: strcat(directory, "\\"); /* MS-DOS */
178: return directory;
179: }
180:
181: void prompt_for_removal(int keynr, char *userid, int cause)
182: {
183: char date[11];
184: int c;
185:
186: switch (cause) {
187: case BADKEY_NO_USERID:
188: printf("The following key has no attached userID:\n"); break;
189: case BADKEY_BOGUS_USERID:
190: printf("The following key seems to have a bogus user ID:\n"); break;
191: case BADKEY_SECRET_KEY:
192: printf("The keyring contains a secret key:\n"); break;
193: }
194: if (key[keynr]->secret)
195: printf("sec ");
196: else
197: printf("pub ");
198: strftime(date,sizeof(date),"%Y/%m/%d",gmtime(&key[keynr]->date));
199: printf("%4d/%8lX %s %s\n",key[keynr]->size,key[keynr]->keyid,date,userid);
200: printf("Remove it <y/N>? ");
201: fflush(stdin); c = getchar();
202: key[keynr]->removed = (c=='y' || c=='Y');
203: printf("\n");
204: }
205:
206: char *get_username(char *userid)
207: {
208: char s[256];
209: char *p = userid;
210:
211: /* Isolate name from email address, telephone number etc. */
212: while (isalpha(*p) || isspace(*p) || *p=='.' || *p=='-') p++;
213: if (p > userid) *p='\0';
214: strupper(strstrip(userid));
215:
216: /* Derive name from email address? */
217: if (*userid == '<') {
218: strcpy(userid, userid+1);
219: }
220:
221: /* Remove titles */
222: p=strend(userid);
223: if (!strcmp(p-2, " I")) *(p-2)='\0';
224: if (!strcmp(p-3, " II")) *(p-3)='\0';
225: if (!strcmp(p-4, " III")) *(p-4)='\0';
226: if (!strcmp(p-4, " JR.")) *(p-4)='\0';
227: if (!strcmp(p-5, " M.D.")) *(p-5)='\0';
228:
229: /* Swap first and last names */
230: if ((p = strrchr(userid, ' ')) != NULL) {
231: strcpy(s,p+1);
232: *p = '\0';
233: strcpy(userid, strcat(s, userid));
234: }
235:
236: /* Return the user name on a form that may easily be sorted */
237: return userid;
238: }
239:
240: int keycmp(struct keydata *key1, struct keydata *key2)
241: {
242: int c;
243: switch (sort_criterion) {
244: case SORT_ON_USERID: c = strcmp(key1->userid, key2->userid) ; break;
245: case SORT_ON_KEYID : c = key1->keyid < key2->keyid ? -1 : +1; break;
246: case SORT_ON_SIZE : c = key1->size < key2->size ? -1 : +1; break;
247: case SORT_ON_DATE : c = key1->date < key2->date ? -1 : +1; break;
248: }
249: if (sort_order==DESCENDING) c = -c;
250: return c;
251: }
252:
253: void swap(struct keydata *v[], int i, int j)
254: {
255: struct keydata *temp;
256: temp = v[i]; v[i] = v[j]; v[j] = temp;
257: }
258:
259: void sort_keydata(struct keydata *v[], int left, int right)
260: {
261: int i, last;
262: if (left >= right) return;
263: swap(v, left, (left+right)/2);
264: last = left;
265: for (i = left+1; i <= right; i++)
266: if (keycmp(v[i], v[left]) < 0)
267: swap(v, ++last, i);
268: swap(v, left, last);
269: sort_keydata(v, left, last-1);
270: sort_keydata(v, last+1, right);
271: }
272:
273: int sort_keyring(char *keyring)
274: {
275: FILE *ifp,
276: *ofp;
277: long count,
278: fpos = 0L,
279: ctbpos = 0L;
280: byte ctb;
281: word32 packet_length;
282: char userid[256],
283: bakring[FILENAME_MAX];
284: boolean is_pubring,
285: first_userid = FALSE;
286: byte buf[256];
287: int i,
288: status = ERR_OK;
289:
290: # define error(s) {status = s; goto end;}
291:
292: /* Read through the whole keyring and gather keydata */
293: if (!(ifp = fopen(keyring,"rb")))
294: return ERR_FILE_NOT_OPEN;
295: count = fread(&ctb, 1, 1, ifp);
296: if ((ctb & 60) == CTB_PUBKEY)
297: is_pubring = TRUE;
298: else if ((ctb & 60) == CTB_SECKEY)
299: is_pubring = FALSE;
300: else
301: error(ERR_NOT_A_KEYRING);
302: while (count > 0) {
303: if (!(ctb & 0x80))
304: error(ERR_KEYRING_CORRUPT);
305: packet_length = get_packet_length(ctb, ifp);
306: fpos = ftell(ifp);
307: ctb = (ctb & 60);
308: switch (ctb) {
309: case CTB_PUBKEY:
310: case CTB_SECKEY:
311: if (first_userid && remove_bad_keys && (!key[keys-1]->removed))
312: prompt_for_removal(keys-1,"",BADKEY_NO_USERID);
313: if (keys == MAXKEYS)
314: error(ERR_OUT_OF_MEMORY);
315: if (!(key[keys] = malloc(sizeof(struct keydata))))
316: error(ERR_OUT_OF_MEMORY);
317: if (keys>0) key[keys-1]->length = ctbpos - key[keys-1]->fpos;
318: key[keys]->fpos = ctbpos;
319: key[keys]->length = packet_length;
320: fseek(ifp, fpos+1, SEEK_SET); key[keys]->date = read_word32(ifp);
321: fseek(ifp, fpos+8, SEEK_SET); key[keys]->size = read_word16(ifp);
322: fseek(ifp, fpos+6+(key[keys]->size+7)/8, SEEK_SET);
323: key[keys]->keyid = read_word32(ifp);
324: key[keys]->removed = FALSE;
325: key[keys]->secret = (ctb==CTB_SECKEY);
326: first_userid = TRUE;
327: keys++;
328: break;
329: case CTB_USERID:
330: fread(&userid, packet_length, 1, ifp);
331: userid[packet_length]='\0';
332: if (remove_bad_keys && (!key[keys-1]->removed)) {
333: if (strstr(userid,"FUCK") || strstr(userid,"DICK") ||
334: strstr(userid,"SHIT") || strstr(userid,"BEGIN") ||
335: strstr(userid,"***") || strstr(userid,"@whitehouse.gov") ||
336: strlen(userid) > 150)
337: prompt_for_removal(keys-1,userid,BADKEY_BOGUS_USERID);
338: }
339: if (first_userid) {
340: if (key[keys-1]->secret && remove_bad_keys && (!key[keys-1]->removed)
341: && is_pubring)
342: prompt_for_removal(keys-1,userid,BADKEY_SECRET_KEY);
343: strncpy(key[keys-1]->userid, get_username(userid),
344: sizeof(key[keys-1]->userid));
345: first_userid = FALSE;
346: }
347: case CTB_TRUST:
348: case CTB_SIG:
349: break;
350: default:
351: error(ERR_NOT_A_KEYRING);
352: }
353: fseek(ifp, ctbpos = fpos += packet_length, SEEK_SET);
354: count = fread(&ctb, 1, 1, ifp);
355: }
356: key[keys-1]->length = ctbpos - key[keys-1]->fpos;
357: fclose(ifp);
358:
359: /* Sort keydata in main memory */
360: if (sort_criterion != SORT_NOSORT)
361: sort_keydata(key,0,keys-1);
362:
363: /* Backup the unsorted keyring in case something goes wrong */
364: strcpy(bakring,keyring);
365: force_extension(bakring,".bak");
366: remove(bakring);
367: if (rename(keyring,bakring))
368: error(ERR_COULD_NOT_BACKUP);
369:
370: /* Copy the keys from old to new keyring in sorted order */
371: if (!(ifp=fopen(bakring,"rb")))
372: error(ERR_COULD_NOT_BACKUP);
373: if (!(ofp=fopen(keyring,"wb")))
374: error(ERR_COULD_NOT_BACKUP);
375: for (i=0; i<keys; i++)
376: if (!key[i]->removed) {
377: fseek(ifp,key[i]->fpos, SEEK_SET);
378: while (key[i]->length > 0) {
379: size_t bytes = MIN(key[i]->length, sizeof(buf));
380: fread(&buf, bytes, 1, ifp);
381: fwrite(&buf, bytes, 1, ofp);
382: key[i]->length -= bytes;
383: }
384: }
385: fclose(ofp);
386:
387: end:
388: /* Remember to cleanup after us */
389: fclose(ifp);
390: for (i = 0; i < keys; i++)
391: free(key[i]);
392: return status;
393: }
394:
395: void show_usage()
396: {
397: fprintf(stderr, "\nPGPSort v1.01 (c) 1995 [email protected]\n\n");
398: fprintf(stderr, "Synopsis: Sorts PGP 2.x keyrings\n\n");
399: fprintf(stderr, "Usage : pgpsort +u[r] [keyring] - sort on user ID\n");
400: fprintf(stderr, " pgpsort +k[r] [keyring] - sort on key ID\n");
401: fprintf(stderr, " pgpsort +s[r] [keyring] - sort on key size\n");
402: fprintf(stderr, " pgpsort +d[r] [keyring] - sort on date of creation\n");
403: fprintf(stderr, " pgpsort -r [keyring] - remove keys (no sorting)\n\n");
404: fprintf(stderr, " Use 'r' to remove bad keys\n");
405: fprintf(stderr, " Use '-' instead of '+' to sort in descending order\n\n");
406: exit(ERR_ILLEGAL_PARAMS);
407: }
408:
409: int main(int argc, char *argv[])
410: {
411: char *sort_option;
412: char filename[FILENAME_MAX];
413:
414: /* Parse command line options */
415: if (argc==2 || argc==3) {
416: sort_option = argv[1];
417: if (argc==3)
418: strcpy(filename, argv[2]);
419: else {
420: printf("No filename given, assuming default keyring.\n");
421: if (getenv("PGPPATH"))
422: add_slash(strcpy(filename, getenv("PGPPATH")));
423: else if (getenv("HOME") && strchr(getenv("HOME"), '/'))
424: strcat(add_slash(strcpy(filename, getenv("HOME"))), ".pgp/");
425: else
426: filename[0]='\0';
427: strcat(filename, "pubring.pgp");
428: }
429: } else
430: show_usage();
431: if (strlen(sort_option)==2 || strlen(sort_option)==3) {
432: switch (sort_option[0]) {
433: case '+': sort_order=ASCENDING; break;
434: case '-': sort_order=DESCENDING; break;
435: default : show_usage();
436: }
437: if (strlen(sort_option)==2)
438: remove_bad_keys = FALSE;
439: else if (sort_option[1]!='r' && sort_option[2]=='r')
440: remove_bad_keys = TRUE;
441: else
442: show_usage();
443: switch (sort_option[1]) {
444: case 'u': sort_criterion=SORT_ON_USERID; break;
445: case 'k': sort_criterion=SORT_ON_KEYID; break;
446: case 's': sort_criterion=SORT_ON_SIZE; break;
447: case 'd': sort_criterion=SORT_ON_DATE; break;
448: case 'r': sort_criterion=SORT_NOSORT;
449: remove_bad_keys=TRUE; break;
450: default : show_usage();
451: }
452: } else
453: show_usage();
454:
455: /* OK, attempt to sort the keyring */
456: switch (sort_keyring(filename)) {
457: case ERR_OK:
458: printf("Keyring '%s' ", filename);
459: switch (sort_criterion) {
460: case SORT_NOSORT : printf("processed.\n"); break;
461: case SORT_ON_USERID: printf("sorted on user ID.\n"); break;
462: case SORT_ON_KEYID : printf("sorted on key ID.\n"); break;
463: case SORT_ON_SIZE : printf("sorted on key size.\n"); break;
464: case SORT_ON_DATE : printf("sorted on date.\n");
465: }
466: return ERR_OK;
467: case ERR_FILE_NOT_OPEN:
468: fprintf(stderr, "Could not open keyring file '%s'.\n", filename);
469: return ERR_FILE_NOT_OPEN;
470: case ERR_NOT_A_KEYRING:
471: fprintf(stderr, "File '%s' is not a PGP 2.x keyring.\n", filename);
472: return ERR_NOT_A_KEYRING;
473: case ERR_COULD_NOT_BACKUP:
474: fprintf(stderr, "Could not create backup file, keyring not sorted.\n");
475: return ERR_COULD_NOT_BACKUP;
476: case ERR_KEYRING_CORRUPT:
477: fprintf(stderr, "Keyring '%s' is corrupt, cannot sort it.\n", filename);
478: return ERR_KEYRING_CORRUPT;
479: case ERR_OUT_OF_MEMORY:
480: fprintf(stderr, "Out of memory: keyring '%s' is too big to sort.\n", filename);
481: return ERR_OUT_OF_MEMORY;
482: }
483:
484: return 0; /* Just to please some compilers */
485: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.