projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Pageant is now able to avoid asking for the passphrase when asked to
[u/mdw/putty] / pageant.c
1 /*
2 * Pageant: the PuTTY Authentication Agent.
3 */
4
5 #include <windows.h>
6 #ifndef NO_SECURITY
7 #include <aclapi.h>
8 #endif
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <ctype.h>
12 #include <assert.h>
13 #include <tchar.h>
14
15 #include "ssh.h"
16 #include "misc.h"
17 #include "tree234.h"
18
19 #define IDI_MAINICON 200
20 #define IDI_TRAYICON 201
21
22 #define WM_XUSER (WM_USER + 0x2000)
23 #define WM_SYSTRAY (WM_XUSER + 6)
24 #define WM_SYSTRAY2 (WM_XUSER + 7)
25
26 #define AGENT_COPYDATA_ID 0x804e50ba /* random goop */
27
28 /*
29 * FIXME: maybe some day we can sort this out ...
30 */
31 #define AGENT_MAX_MSGLEN 8192
32
33 #define IDM_CLOSE 0x0010
34 #define IDM_VIEWKEYS 0x0020
35 #define IDM_ADDKEY 0x0030
36 #define IDM_HELP 0x0040
37 #define IDM_ABOUT 0x0050
38
39 #define APPNAME "Pageant"
40
41 extern char ver[];
42
43 static HINSTANCE instance;
44 static HWND main_hwnd;
45 static HWND keylist;
46 static HWND aboutbox;
47 static HMENU systray_menu;
48 static int already_running;
49 static int requested_help;
50
51 static char *help_path;
52
53 static tree234 *rsakeys, *ssh2keys;
54
55 static int has_security;
56 #ifndef NO_SECURITY
57 typedef DWORD(WINAPI * gsi_fn_t)
58 (HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION,
59 PSID *, PSID *, PACL *, PACL *, PSECURITY_DESCRIPTOR *);
60 static gsi_fn_t getsecurityinfo;
61 #endif
62
63 /*
64 * Exports from pageantc.c
65 */
66 void agent_query(void *in, int inlen, void **out, int *outlen);
67 int agent_exists(void);
68
69 /*
70 * Forward references
71 */
72 static void *make_keylist1(int *length);
73 static void *make_keylist2(int *length);
74 static void *get_keylist1(void);
75 static void *get_keylist2(void);
76
77 /*
78 * We need this to link with the RSA code, because rsaencrypt()
79 * pads its data with random bytes. Since we only use rsadecrypt()
80 * and the signing functions, which are deterministic, this should
81 * never be called.
82 *
83 * If it _is_ called, there is a _serious_ problem, because it
84 * won't generate true random numbers. So we must scream, panic,
85 * and exit immediately if that should happen.
86 */
87 int random_byte(void)
88 {
89 MessageBox(main_hwnd, "Internal Error", APPNAME, MB_OK | MB_ICONERROR);
90 exit(0);
91 /* this line can't be reached but it placates MSVC's warnings :-) */
92 return 0;
93 }
94
95 /*
96 * Blob structure for passing to the asymmetric SSH2 key compare
97 * function, prototyped here.
98 */
99 struct blob {
100 unsigned char *blob;
101 int len;
102 };
103 static int cmpkeys_ssh2_asymm(void *av, void *bv);
104
105 /*
106 * This function is needed to link with the DES code. We need not
107 * have it do anything at all.
108 */
109 void logevent(char *msg)
110 {
111 }
112
113 #define GET_32BIT(cp) \
114 (((unsigned long)(unsigned char)(cp)[0] << 24) | \
115 ((unsigned long)(unsigned char)(cp)[1] << 16) | \
116 ((unsigned long)(unsigned char)(cp)[2] << 8) | \
117 ((unsigned long)(unsigned char)(cp)[3]))
118
119 #define PUT_32BIT(cp, value) { \
120 (cp)[0] = (unsigned char)((value) >> 24); \
121 (cp)[1] = (unsigned char)((value) >> 16); \
122 (cp)[2] = (unsigned char)((value) >> 8); \
123 (cp)[3] = (unsigned char)(value); }
124
125 #define PASSPHRASE_MAXLEN 512
126
127 struct PassphraseProcStruct {
128 char *passphrase;
129 char *comment;
130 };
131
132 static tree234 *passphrases = NULL;
133
134 /*
135 * After processing a list of filenames, we want to forget the
136 * passphrases.
137 */
138 static void forget_passphrases(void)
139 {
140 while (count234(passphrases) > 0) {
141 char *pp = index234(passphrases, 0);
142 memset(pp, 0, strlen(pp));
143 delpos234(passphrases, 0);
144 free(pp);
145 }
146 }
147
148 /*
149 * Dialog-box function for the Licence box.
150 */
151 static int CALLBACK LicenceProc(HWND hwnd, UINT msg,
152 WPARAM wParam, LPARAM lParam)
153 {
154 switch (msg) {
155 case WM_INITDIALOG:
156 return 1;
157 case WM_COMMAND:
158 switch (LOWORD(wParam)) {
159 case IDOK:
160 EndDialog(hwnd, 1);
161 return 0;
162 }
163 return 0;
164 case WM_CLOSE:
165 EndDialog(hwnd, 1);
166 return 0;
167 }
168 return 0;
169 }
170
171 /*
172 * Dialog-box function for the About box.
173 */
174 static int CALLBACK AboutProc(HWND hwnd, UINT msg,
175 WPARAM wParam, LPARAM lParam)
176 {
177 switch (msg) {
178 case WM_INITDIALOG:
179 SetDlgItemText(hwnd, 100, ver);
180 return 1;
181 case WM_COMMAND:
182 switch (LOWORD(wParam)) {
183 case IDOK:
184 aboutbox = NULL;
185 DestroyWindow(hwnd);
186 return 0;
187 case 101:
188 EnableWindow(hwnd, 0);
189 DialogBox(instance, MAKEINTRESOURCE(214), NULL, LicenceProc);
190 EnableWindow(hwnd, 1);
191 SetActiveWindow(hwnd);
192 return 0;
193 }
194 return 0;
195 case WM_CLOSE:
196 aboutbox = NULL;
197 DestroyWindow(hwnd);
198 return 0;
199 }
200 return 0;
201 }
202
203 static HWND passphrase_box;
204
205 /*
206 * Dialog-box function for the passphrase box.
207 */
208 static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
209 WPARAM wParam, LPARAM lParam)
210 {
211 static char *passphrase = NULL;
212 struct PassphraseProcStruct *p;
213
214 switch (msg) {
215 case WM_INITDIALOG:
216 passphrase_box = hwnd;
217 /*
218 * Centre the window.
219 */
220 { /* centre the window */
221 RECT rs, rd;
222 HWND hw;
223
224 hw = GetDesktopWindow();
225 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
226 MoveWindow(hwnd,
227 (rs.right + rs.left + rd.left - rd.right) / 2,
228 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
229 rd.right - rd.left, rd.bottom - rd.top, TRUE);
230 }
231
232 SetForegroundWindow(hwnd);
233 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
234 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
235 p = (struct PassphraseProcStruct *) lParam;
236 passphrase = p->passphrase;
237 if (p->comment)
238 SetDlgItemText(hwnd, 101, p->comment);
239 *passphrase = 0;
240 SetDlgItemText(hwnd, 102, passphrase);
241 return 0;
242 case WM_COMMAND:
243 switch (LOWORD(wParam)) {
244 case IDOK:
245 if (*passphrase)
246 EndDialog(hwnd, 1);
247 else
248 MessageBeep(0);
249 return 0;
250 case IDCANCEL:
251 EndDialog(hwnd, 0);
252 return 0;
253 case 102: /* edit box */
254 if ((HIWORD(wParam) == EN_CHANGE) && passphrase) {
255 GetDlgItemText(hwnd, 102, passphrase,
256 PASSPHRASE_MAXLEN - 1);
257 passphrase[PASSPHRASE_MAXLEN - 1] = '\0';
258 }
259 return 0;
260 }
261 return 0;
262 case WM_CLOSE:
263 EndDialog(hwnd, 0);
264 return 0;
265 }
266 return 0;
267 }
268
269 /*
270 * Warn about the obsolescent key file format.
271 */
272 void old_keyfile_warning(void)
273 {
274 static const char mbtitle[] = "PuTTY Key File Warning";
275 static const char message[] =
276 "You are loading an SSH 2 private key which has an\n"
277 "old version of the file format. This means your key\n"
278 "file is not fully tamperproof. Future versions of\n"
279 "PuTTY may stop supporting this private key format,\n"
280 "so we recommend you convert your key to the new\n"
281 "format.\n"
282 "\n"
283 "You can perform this conversion by loading the key\n"
284 "into PuTTYgen and then saving it again.";
285
286 MessageBox(NULL, message, mbtitle, MB_OK);
287 }
288
289 /*
290 * Update the visible key list.
291 */
292 static void keylist_update(void)
293 {
294 struct RSAKey *rkey;
295 struct ssh2_userkey *skey;
296 int i;
297
298 if (keylist) {
299 SendDlgItemMessage(keylist, 100, LB_RESETCONTENT, 0, 0);
300 for (i = 0; NULL != (rkey = index234(rsakeys, i)); i++) {
301 char listentry[512], *p;
302 /*
303 * Replace two spaces in the fingerprint with tabs, for
304 * nice alignment in the box.
305 */
306 strcpy(listentry, "ssh1\t");
307 p = listentry + strlen(listentry);
308 rsa_fingerprint(p, sizeof(listentry) - (p - listentry), rkey);
309 p = strchr(listentry, ' ');
310 if (p)
311 *p = '\t';
312 p = strchr(listentry, ' ');
313 if (p)
314 *p = '\t';
315 SendDlgItemMessage(keylist, 100, LB_ADDSTRING,
316 0, (LPARAM) listentry);
317 }
318 for (i = 0; NULL != (skey = index234(ssh2keys, i)); i++) {
319 char listentry[512], *p;
320 int len;
321 /*
322 * Replace two spaces in the fingerprint with tabs, for
323 * nice alignment in the box.
324 */
325 p = skey->alg->fingerprint(skey->data);
326 strncpy(listentry, p, sizeof(listentry));
327 p = strchr(listentry, ' ');
328 if (p)
329 *p = '\t';
330 p = strchr(listentry, ' ');
331 if (p)
332 *p = '\t';
333 len = strlen(listentry);
334 if (len < sizeof(listentry) - 2) {
335 listentry[len] = '\t';
336 strncpy(listentry + len + 1, skey->comment,
337 sizeof(listentry) - len - 1);
338 }
339 SendDlgItemMessage(keylist, 100, LB_ADDSTRING, 0,
340 (LPARAM) listentry);
341 }
342 SendDlgItemMessage(keylist, 100, LB_SETCURSEL, (WPARAM) - 1, 0);
343 }
344 }
345
346 /*
347 * This function loads a key from a file and adds it.
348 */
349 static void add_keyfile(char *filename)
350 {
351 char passphrase[PASSPHRASE_MAXLEN];
352 struct RSAKey *rkey = NULL;
353 struct ssh2_userkey *skey = NULL;
354 int needs_pass;
355 int ret;
356 int attempts;
357 char *comment;
358 struct PassphraseProcStruct pps;
359 int ver;
360 int original_pass;
361
362 ver = keyfile_version(filename);
363 if (ver == 0) {
364 MessageBox(NULL, "Couldn't load private key.", APPNAME,
365 MB_OK | MB_ICONERROR);
366 return;
367 }
368
369 /*
370 * See if the key is already loaded (in the primary Pageant,
371 * which may or may not be us).
372 */
373 {
374 void *blob;
375 unsigned char *keylist, *p;
376 int i, nkeys, bloblen;
377
378 if (ver == 1) {
379 if (!rsakey_pubblob(filename, &blob, &bloblen)) {
380 MessageBox(NULL, "Couldn't load private key.", APPNAME,
381 MB_OK | MB_ICONERROR);
382 return;
383 }
384 keylist = get_keylist1();
385 } else {
386 unsigned char *blob2;
387 blob = ssh2_userkey_loadpub(filename, NULL, &bloblen);
388 if (!blob) {
389 MessageBox(NULL, "Couldn't load private key.", APPNAME,
390 MB_OK | MB_ICONERROR);
391 return;
392 }
393 /* For our purposes we want the blob prefixed with its length */
394 blob2 = smalloc(bloblen+4);
395 PUT_32BIT(blob2, bloblen);
396 memcpy(blob2 + 4, blob, bloblen);
397 sfree(blob);
398 blob = blob2;
399
400 keylist = get_keylist2();
401 }
402 if (keylist) {
403 nkeys = GET_32BIT(keylist);
404 p = keylist + 4;
405
406 for (i = 0; i < nkeys; i++) {
407 if (!memcmp(blob, p, bloblen)) {
408 /* Key is already present; we can now leave. */
409 sfree(keylist);
410 sfree(blob);
411 return;
412 }
413 /* Now skip over public blob */
414 if (ver == 1)
415 p += rsa_public_blob_len(p);
416 else
417 p += 4 + GET_32BIT(p);
418 /* Now skip over comment field */
419 p += 4 + GET_32BIT(p);
420 }
421
422 sfree(keylist);
423 }
424
425 sfree(blob);
426 }
427
428 if (ver == 1)
429 needs_pass = rsakey_encrypted(filename, &comment);
430 else
431 needs_pass = ssh2_userkey_encrypted(filename, &comment);
432 attempts = 0;
433 if (ver == 1)
434 rkey = smalloc(sizeof(*rkey));
435 pps.passphrase = passphrase;
436 pps.comment = comment;
437 original_pass = 0;
438 do {
439 if (needs_pass) {
440 /* try all the remembered passphrases first */
441 char *pp = index234(passphrases, attempts);
442 if(pp) {
443 strcpy(passphrase, pp);
444 } else {
445 int dlgret;
446 original_pass = 1;
447 dlgret = DialogBoxParam(instance, MAKEINTRESOURCE(210),
448 NULL, PassphraseProc, (LPARAM) & pps);
449 passphrase_box = NULL;
450 if (!dlgret) {
451 if (comment)
452 sfree(comment);
453 if (ver == 1)
454 sfree(rkey);
455 return; /* operation cancelled */
456 }
457 }
458 } else
459 *passphrase = '\0';
460 if (ver == 1)
461 ret = loadrsakey(filename, rkey, passphrase);
462 else {
463 skey = ssh2_load_userkey(filename, passphrase);
464 if (skey == SSH2_WRONG_PASSPHRASE)
465 ret = -1;
466 else if (!skey)
467 ret = 0;
468 else
469 ret = 1;
470 }
471 attempts++;
472 } while (ret == -1);
473
474 /* if they typed in an ok passphrase, remember it */
475 if(original_pass && ret) {
476 char *pp = dupstr(passphrase);
477 addpos234(passphrases, pp, 0);
478 }
479
480 if (comment)
481 sfree(comment);
482 if (ret == 0) {
483 MessageBox(NULL, "Couldn't load private key.", APPNAME,
484 MB_OK | MB_ICONERROR);
485 if (ver == 1)
486 sfree(rkey);
487 return;
488 }
489 if (ver == 1) {
490 if (already_running) {
491 unsigned char *request, *response;
492 void *vresponse;
493 int reqlen, clen, resplen;
494
495 clen = strlen(rkey->comment);
496
497 reqlen = 4 + 1 + /* length, message type */
498 4 + /* bit count */
499 ssh1_bignum_length(rkey->modulus) +
500 ssh1_bignum_length(rkey->exponent) +
501 ssh1_bignum_length(rkey->private_exponent) +
502 ssh1_bignum_length(rkey->iqmp) +
503 ssh1_bignum_length(rkey->p) +
504 ssh1_bignum_length(rkey->q) + 4 + clen /* comment */
505 ;
506
507 request = smalloc(reqlen);
508
509 request[4] = SSH1_AGENTC_ADD_RSA_IDENTITY;
510 reqlen = 5;
511 PUT_32BIT(request + reqlen, bignum_bitcount(rkey->modulus));
512 reqlen += 4;
513 reqlen += ssh1_write_bignum(request + reqlen, rkey->modulus);
514 reqlen += ssh1_write_bignum(request + reqlen, rkey->exponent);
515 reqlen +=
516 ssh1_write_bignum(request + reqlen,
517 rkey->private_exponent);
518 reqlen += ssh1_write_bignum(request + reqlen, rkey->iqmp);
519 reqlen += ssh1_write_bignum(request + reqlen, rkey->p);
520 reqlen += ssh1_write_bignum(request + reqlen, rkey->q);
521 PUT_32BIT(request + reqlen, clen);
522 memcpy(request + reqlen + 4, rkey->comment, clen);
523 reqlen += 4 + clen;
524 PUT_32BIT(request, reqlen - 4);
525
526 agent_query(request, reqlen, &vresponse, &resplen);
527 response = vresponse;
528 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
529 MessageBox(NULL, "The already running Pageant "
530 "refused to add the key.", APPNAME,
531 MB_OK | MB_ICONERROR);
532
533 sfree(request);
534 sfree(response);
535 } else {
536 if (add234(rsakeys, rkey) != rkey)
537 sfree(rkey); /* already present, don't waste RAM */
538 }
539 } else {
540 if (already_running) {
541 unsigned char *request, *response;
542 void *vresponse;
543 int reqlen, alglen, clen, keybloblen, resplen;
544 alglen = strlen(skey->alg->name);
545 clen = strlen(skey->comment);
546
547 keybloblen = skey->alg->openssh_fmtkey(skey->data, NULL, 0);
548
549 reqlen = 4 + 1 + /* length, message type */
550 4 + alglen + /* algorithm name */
551 keybloblen + /* key data */
552 4 + clen /* comment */
553 ;
554
555 request = smalloc(reqlen);
556
557 request[4] = SSH2_AGENTC_ADD_IDENTITY;
558 reqlen = 5;
559 PUT_32BIT(request + reqlen, alglen);
560 reqlen += 4;
561 memcpy(request + reqlen, skey->alg->name, alglen);
562 reqlen += alglen;
563 reqlen += skey->alg->openssh_fmtkey(skey->data,
564 request + reqlen,
565 keybloblen);
566 PUT_32BIT(request + reqlen, clen);
567 memcpy(request + reqlen + 4, skey->comment, clen);
568 PUT_32BIT(request, reqlen - 4);
569 reqlen += clen + 4;
570
571 agent_query(request, reqlen, &vresponse, &resplen);
572 response = vresponse;
573 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
574 MessageBox(NULL, "The already running Pageant"
575 "refused to add the key.", APPNAME,
576 MB_OK | MB_ICONERROR);
577
578 sfree(request);
579 sfree(response);
580 } else {
581 if (add234(ssh2keys, skey) != skey) {
582 skey->alg->freekey(skey->data);
583 sfree(skey); /* already present, don't waste RAM */
584 }
585 }
586 }
587 }
588
589 /*
590 * Create an SSH1 key list in a malloc'ed buffer; return its
591 * length.
592 */
593 static void *make_keylist1(int *length)
594 {
595 int i, nkeys, len;
596 struct RSAKey *key;
597 unsigned char *blob, *p, *ret;
598 int bloblen;
599
600 /*
601 * Count up the number and length of keys we hold.
602 */
603 len = 4;
604 nkeys = 0;
605 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
606 nkeys++;
607 blob = rsa_public_blob(key, &bloblen);
608 len += bloblen;
609 sfree(blob);
610 len += 4 + strlen(key->comment);
611 }
612
613 /* Allocate the buffer. */
614 p = ret = smalloc(len);
615 if (length) *length = len;
616
617 PUT_32BIT(p, nkeys);
618 p += 4;
619 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
620 blob = rsa_public_blob(key, &bloblen);
621 memcpy(p, blob, bloblen);
622 p += bloblen;
623 sfree(blob);
624 PUT_32BIT(p, strlen(key->comment));
625 memcpy(p + 4, key->comment, strlen(key->comment));
626 p += 4 + strlen(key->comment);
627 }
628
629 assert(p - ret == len);
630 return ret;
631 }
632
633 /*
634 * Create an SSH2 key list in a malloc'ed buffer; return its
635 * length.
636 */
637 static void *make_keylist2(int *length)
638 {
639 struct ssh2_userkey *key;
640 int i, len, nkeys;
641 unsigned char *blob, *p, *ret;
642 int bloblen;
643
644 /*
645 * Count up the number and length of keys we hold.
646 */
647 len = 4;
648 nkeys = 0;
649 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
650 nkeys++;
651 len += 4; /* length field */
652 blob = key->alg->public_blob(key->data, &bloblen);
653 len += bloblen;
654 sfree(blob);
655 len += 4 + strlen(key->comment);
656 }
657
658 /* Allocate the buffer. */
659 p = ret = smalloc(len);
660 if (length) *length = len;
661
662 /*
663 * Packet header is the obvious five bytes, plus four
664 * bytes for the key count.
665 */
666 PUT_32BIT(p, nkeys);
667 p += 4;
668 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
669 blob = key->alg->public_blob(key->data, &bloblen);
670 PUT_32BIT(p, bloblen);
671 p += 4;
672 memcpy(p, blob, bloblen);
673 p += bloblen;
674 sfree(blob);
675 PUT_32BIT(p, strlen(key->comment));
676 memcpy(p + 4, key->comment, strlen(key->comment));
677 p += 4 + strlen(key->comment);
678 }
679
680 assert(p - ret == len);
681 return ret;
682 }
683
684 /*
685 * Acquire a keylist1 from the primary Pageant; this means either
686 * calling make_keylist1 (if that's us) or sending a message to the
687 * primary Pageant (if it's not).
688 */
689 static void *get_keylist1(void)
690 {
691 void *ret;
692
693 if (already_running) {
694 unsigned char request[5], *response;
695 void *vresponse;
696 int resplen;
697 request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
698 PUT_32BIT(request, 4);
699
700 agent_query(request, 5, &vresponse, &resplen);
701 response = vresponse;
702 if (resplen < 5 || response[4] != SSH1_AGENT_RSA_IDENTITIES_ANSWER)
703 return NULL;
704
705 ret = smalloc(resplen-5);
706 memcpy(ret, response+5, resplen-5);
707 sfree(response);
708 } else {
709 ret = make_keylist1(NULL);
710 }
711 return ret;
712 }
713
714 /*
715 * Acquire a keylist2 from the primary Pageant; this means either
716 * calling make_keylist2 (if that's us) or sending a message to the
717 * primary Pageant (if it's not).
718 */
719 static void *get_keylist2(void)
720 {
721 void *ret;
722
723 if (already_running) {
724 unsigned char request[5], *response;
725 void *vresponse;
726 int resplen;
727
728 request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
729 PUT_32BIT(request, 4);
730
731 agent_query(request, 5, &vresponse, &resplen);
732 response = vresponse;
733 if (resplen < 5 || response[4] != SSH2_AGENT_IDENTITIES_ANSWER)
734 return NULL;
735
736 ret = smalloc(resplen-5);
737 memcpy(ret, response+5, resplen-5);
738 sfree(response);
739 } else {
740 ret = make_keylist2(NULL);
741 }
742 return ret;
743 }
744
745 /*
746 * This is the main agent function that answers messages.
747 */
748 static void answer_msg(void *msg)
749 {
750 unsigned char *p = msg;
751 unsigned char *ret = msg;
752 int type;
753
754 /*
755 * Get the message type.
756 */
757 type = p[4];
758
759 p += 5;
760 switch (type) {
761 case SSH1_AGENTC_REQUEST_RSA_IDENTITIES:
762 /*
763 * Reply with SSH1_AGENT_RSA_IDENTITIES_ANSWER.
764 */
765 {
766 int len;
767 void *keylist;
768
769 ret[4] = SSH1_AGENT_RSA_IDENTITIES_ANSWER;
770 keylist = make_keylist1(&len);
771 if (len + 5 > AGENT_MAX_MSGLEN) {
772 sfree(keylist);
773 goto failure;
774 }
775 PUT_32BIT(ret, len + 1);
776 memcpy(ret + 5, keylist, len);
777 sfree(keylist);
778 }
779 break;
780 case SSH2_AGENTC_REQUEST_IDENTITIES:
781 /*
782 * Reply with SSH2_AGENT_IDENTITIES_ANSWER.
783 */
784 {
785 int len;
786 void *keylist;
787
788 ret[4] = SSH2_AGENT_IDENTITIES_ANSWER;
789 keylist = make_keylist2(&len);
790 if (len + 5 > AGENT_MAX_MSGLEN) {
791 sfree(keylist);
792 goto failure;
793 }
794 PUT_32BIT(ret, len + 1);
795 memcpy(ret + 5, keylist, len);
796 sfree(keylist);
797 }
798 break;
799 case SSH1_AGENTC_RSA_CHALLENGE:
800 /*
801 * Reply with either SSH1_AGENT_RSA_RESPONSE or
802 * SSH_AGENT_FAILURE, depending on whether we have that key
803 * or not.
804 */
805 {
806 struct RSAKey reqkey, *key;
807 Bignum challenge, response;
808 unsigned char response_source[48], response_md5[16];
809 struct MD5Context md5c;
810 int i, len;
811
812 p += 4;
813 p += ssh1_read_bignum(p, &reqkey.exponent);
814 p += ssh1_read_bignum(p, &reqkey.modulus);
815 p += ssh1_read_bignum(p, &challenge);
816 memcpy(response_source + 32, p, 16);
817 p += 16;
818 if (GET_32BIT(p) != 1 ||
819 (key = find234(rsakeys, &reqkey, NULL)) == NULL) {
820 freebn(reqkey.exponent);
821 freebn(reqkey.modulus);
822 freebn(challenge);
823 goto failure;
824 }
825 response = rsadecrypt(challenge, key);
826 for (i = 0; i < 32; i++)
827 response_source[i] = bignum_byte(response, 31 - i);
828
829 MD5Init(&md5c);
830 MD5Update(&md5c, response_source, 48);
831 MD5Final(response_md5, &md5c);
832 memset(response_source, 0, 48); /* burn the evidence */
833 freebn(response); /* and that evidence */
834 freebn(challenge); /* yes, and that evidence */
835 freebn(reqkey.exponent); /* and free some memory ... */
836 freebn(reqkey.modulus); /* ... while we're at it. */
837
838 /*
839 * Packet is the obvious five byte header, plus sixteen
840 * bytes of MD5.
841 */
842 len = 5 + 16;
843 PUT_32BIT(ret, len - 4);
844 ret[4] = SSH1_AGENT_RSA_RESPONSE;
845 memcpy(ret + 5, response_md5, 16);
846 }
847 break;
848 case SSH2_AGENTC_SIGN_REQUEST:
849 /*
850 * Reply with either SSH2_AGENT_SIGN_RESPONSE or
851 * SSH_AGENT_FAILURE, depending on whether we have that key
852 * or not.
853 */
854 {
855 struct ssh2_userkey *key;
856 struct blob b;
857 unsigned char *data, *signature;
858 int datalen, siglen, len;
859
860 b.len = GET_32BIT(p);
861 p += 4;
862 b.blob = p;
863 p += b.len;
864 datalen = GET_32BIT(p);
865 p += 4;
866 data = p;
867 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
868 if (!key)
869 goto failure;
870 signature = key->alg->sign(key->data, data, datalen, &siglen);
871 len = 5 + 4 + siglen;
872 PUT_32BIT(ret, len - 4);
873 ret[4] = SSH2_AGENT_SIGN_RESPONSE;
874 PUT_32BIT(ret + 5, siglen);
875 memcpy(ret + 5 + 4, signature, siglen);
876 sfree(signature);
877 }
878 break;
879 case SSH1_AGENTC_ADD_RSA_IDENTITY:
880 /*
881 * Add to the list and return SSH_AGENT_SUCCESS, or
882 * SSH_AGENT_FAILURE if the key was malformed.
883 */
884 {
885 struct RSAKey *key;
886 char *comment;
887 int commentlen;
888 key = smalloc(sizeof(struct RSAKey));
889 memset(key, 0, sizeof(struct RSAKey));
890 p += makekey(p, key, NULL, 1);
891 p += makeprivate(p, key);
892 p += ssh1_read_bignum(p, &key->iqmp); /* p^-1 mod q */
893 p += ssh1_read_bignum(p, &key->p); /* p */
894 p += ssh1_read_bignum(p, &key->q); /* q */
895 commentlen = GET_32BIT(p);
896 comment = smalloc(commentlen+1);
897 if (comment) {
898 memcpy(comment, p + 4, commentlen);
899 comment[commentlen] = '\0';
900 key->comment = comment;
901 }
902 PUT_32BIT(ret, 1);
903 ret[4] = SSH_AGENT_FAILURE;
904 if (add234(rsakeys, key) == key) {
905 keylist_update();
906 ret[4] = SSH_AGENT_SUCCESS;
907 } else {
908 freersakey(key);
909 sfree(key);
910 }
911 }
912 break;
913 case SSH2_AGENTC_ADD_IDENTITY:
914 /*
915 * Add to the list and return SSH_AGENT_SUCCESS, or
916 * SSH_AGENT_FAILURE if the key was malformed.
917 */
918 {
919 struct ssh2_userkey *key;
920 char *comment, *alg;
921 int alglen, commlen;
922 int bloblen;
923
924 key = smalloc(sizeof(struct ssh2_userkey));
925
926 alglen = GET_32BIT(p);
927 p += 4;
928 alg = p;
929 p += alglen;
930 /* Add further algorithm names here. */
931 if (alglen == 7 && !memcmp(alg, "ssh-rsa", 7))
932 key->alg = &ssh_rsa;
933 else if (alglen == 7 && !memcmp(alg, "ssh-dss", 7))
934 key->alg = &ssh_dss;
935 else {
936 sfree(key);
937 goto failure;
938 }
939
940 bloblen =
941 GET_32BIT((unsigned char *) msg) - (p -
942 (unsigned char *) msg -
943 4);
944 key->data = key->alg->openssh_createkey(&p, &bloblen);
945 if (!key->data) {
946 sfree(key);
947 goto failure;
948 }
949 commlen = GET_32BIT(p);
950 p += 4;
951
952 comment = smalloc(commlen + 1);
953 if (comment) {
954 memcpy(comment, p, commlen);
955 comment[commlen] = '\0';
956 }
957 key->comment = comment;
958
959 PUT_32BIT(ret, 1);
960 ret[4] = SSH_AGENT_FAILURE;
961 if (add234(ssh2keys, key) == key) {
962 keylist_update();
963 ret[4] = SSH_AGENT_SUCCESS;
964 } else {
965 key->alg->freekey(key->data);
966 sfree(key->comment);
967 sfree(key);
968 }
969 }
970 break;
971 case SSH1_AGENTC_REMOVE_RSA_IDENTITY:
972 /*
973 * Remove from the list and return SSH_AGENT_SUCCESS, or
974 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
975 * start with.
976 */
977 {
978 struct RSAKey reqkey, *key;
979
980 p += makekey(p, &reqkey, NULL, 0);
981 key = find234(rsakeys, &reqkey, NULL);
982 freebn(reqkey.exponent);
983 freebn(reqkey.modulus);
984 PUT_32BIT(ret, 1);
985 ret[4] = SSH_AGENT_FAILURE;
986 if (key) {
987 del234(rsakeys, key);
988 keylist_update();
989 freersakey(key);
990 sfree(key);
991 ret[4] = SSH_AGENT_SUCCESS;
992 }
993 }
994 break;
995 case SSH2_AGENTC_REMOVE_IDENTITY:
996 /*
997 * Remove from the list and return SSH_AGENT_SUCCESS, or
998 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
999 * start with.
1000 */
1001 {
1002 struct ssh2_userkey *key;
1003 struct blob b;
1004
1005 b.len = GET_32BIT(p);
1006 p += 4;
1007 b.blob = p;
1008 p += b.len;
1009 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
1010 if (!key)
1011 goto failure;
1012
1013 PUT_32BIT(ret, 1);
1014 ret[4] = SSH_AGENT_FAILURE;
1015 if (key) {
1016 del234(ssh2keys, key);
1017 keylist_update();
1018 key->alg->freekey(key->data);
1019 sfree(key);
1020 ret[4] = SSH_AGENT_SUCCESS;
1021 }
1022 }
1023 break;
1024 case SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES:
1025 /*
1026 * Remove all SSH1 keys. Always returns success.
1027 */
1028 {
1029 struct RSAKey *rkey;
1030
1031 while ((rkey = index234(rsakeys, 0)) != NULL) {
1032 del234(rsakeys, rkey);
1033 freersakey(rkey);
1034 sfree(rkey);
1035 }
1036 keylist_update();
1037
1038 PUT_32BIT(ret, 1);
1039 ret[4] = SSH_AGENT_SUCCESS;
1040 }
1041 break;
1042 case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
1043 /*
1044 * Remove all SSH2 keys. Always returns success.
1045 */
1046 {
1047 struct ssh2_userkey *skey;
1048
1049 while ((skey = index234(ssh2keys, 0)) != NULL) {
1050 del234(ssh2keys, skey);
1051 skey->alg->freekey(skey->data);
1052 sfree(skey);
1053 }
1054 keylist_update();
1055
1056 PUT_32BIT(ret, 1);
1057 ret[4] = SSH_AGENT_SUCCESS;
1058 }
1059 break;
1060 default:
1061 failure:
1062 /*
1063 * Unrecognised message. Return SSH_AGENT_FAILURE.
1064 */
1065 PUT_32BIT(ret, 1);
1066 ret[4] = SSH_AGENT_FAILURE;
1067 break;
1068 }
1069 }
1070
1071 /*
1072 * Key comparison function for the 2-3-4 tree of RSA keys.
1073 */
1074 static int cmpkeys_rsa(void *av, void *bv)
1075 {
1076 struct RSAKey *a = (struct RSAKey *) av;
1077 struct RSAKey *b = (struct RSAKey *) bv;
1078 Bignum am, bm;
1079 int alen, blen;
1080
1081 am = a->modulus;
1082 bm = b->modulus;
1083 /*
1084 * Compare by length of moduli.
1085 */
1086 alen = bignum_bitcount(am);
1087 blen = bignum_bitcount(bm);
1088 if (alen > blen)
1089 return +1;
1090 else if (alen < blen)
1091 return -1;
1092 /*
1093 * Now compare by moduli themselves.
1094 */
1095 alen = (alen + 7) / 8; /* byte count */
1096 while (alen-- > 0) {
1097 int abyte, bbyte;
1098 abyte = bignum_byte(am, alen);
1099 bbyte = bignum_byte(bm, alen);
1100 if (abyte > bbyte)
1101 return +1;
1102 else if (abyte < bbyte)
1103 return -1;
1104 }
1105 /*
1106 * Give up.
1107 */
1108 return 0;
1109 }
1110
1111 /*
1112 * Key comparison function for the 2-3-4 tree of SSH2 keys.
1113 */
1114 static int cmpkeys_ssh2(void *av, void *bv)
1115 {
1116 struct ssh2_userkey *a = (struct ssh2_userkey *) av;
1117 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
1118 int i;
1119 int alen, blen;
1120 unsigned char *ablob, *bblob;
1121 int c;
1122
1123 /*
1124 * Compare purely by public blob.
1125 */
1126 ablob = a->alg->public_blob(a->data, &alen);
1127 bblob = b->alg->public_blob(b->data, &blen);
1128
1129 c = 0;
1130 for (i = 0; i < alen && i < blen; i++) {
1131 if (ablob[i] < bblob[i]) {
1132 c = -1;
1133 break;
1134 } else if (ablob[i] > bblob[i]) {
1135 c = +1;
1136 break;
1137 }
1138 }
1139 if (c == 0 && i < alen)
1140 c = +1; /* a is longer */
1141 if (c == 0 && i < blen)
1142 c = -1; /* a is longer */
1143
1144 sfree(ablob);
1145 sfree(bblob);
1146
1147 return c;
1148 }
1149
1150 /*
1151 * Key comparison function for looking up a blob in the 2-3-4 tree
1152 * of SSH2 keys.
1153 */
1154 static int cmpkeys_ssh2_asymm(void *av, void *bv)
1155 {
1156 struct blob *a = (struct blob *) av;
1157 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
1158 int i;
1159 int alen, blen;
1160 unsigned char *ablob, *bblob;
1161 int c;
1162
1163 /*
1164 * Compare purely by public blob.
1165 */
1166 ablob = a->blob;
1167 alen = a->len;
1168 bblob = b->alg->public_blob(b->data, &blen);
1169
1170 c = 0;
1171 for (i = 0; i < alen && i < blen; i++) {
1172 if (ablob[i] < bblob[i]) {
1173 c = -1;
1174 break;
1175 } else if (ablob[i] > bblob[i]) {
1176 c = +1;
1177 break;
1178 }
1179 }
1180 if (c == 0 && i < alen)
1181 c = +1; /* a is longer */
1182 if (c == 0 && i < blen)
1183 c = -1; /* a is longer */
1184
1185 sfree(bblob);
1186
1187 return c;
1188 }
1189
1190 /*
1191 * Prompt for a key file to add, and add it.
1192 */
1193 static void prompt_add_keyfile(void)
1194 {
1195 OPENFILENAME of;
1196 char filename[FILENAME_MAX];
1197 char *filelist = smalloc(8192);
1198 char *filewalker;
1199 int n, dirlen;
1200
1201 memset(&of, 0, sizeof(of));
1202 #ifdef OPENFILENAME_SIZE_VERSION_400
1203 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
1204 #else
1205 of.lStructSize = sizeof(of);
1206 #endif
1207 of.hwndOwner = main_hwnd;
1208 of.lpstrFilter = "All Files\0*\0\0\0";
1209 of.lpstrCustomFilter = NULL;
1210 of.nFilterIndex = 1;
1211 of.lpstrFile = filelist;
1212 *filelist = '\0';
1213 of.nMaxFile = FILENAME_MAX;
1214 of.lpstrFileTitle = NULL;
1215 of.lpstrInitialDir = NULL;
1216 of.lpstrTitle = "Select Private Key File";
1217 of.Flags = OFN_ALLOWMULTISELECT | OFN_EXPLORER;
1218 if (GetOpenFileName(&of)) {
1219 if(strlen(filelist) > of.nFileOffset)
1220 /* Only one filename returned? */
1221 add_keyfile(filelist);
1222 else {
1223 /* we are returned a bunch of strings, end to
1224 * end. first string is the directory, the
1225 * rest the filenames. terminated with an
1226 * empty string.
1227 */
1228 filewalker = filelist;
1229 dirlen = strlen(filewalker);
1230 if(dirlen > FILENAME_MAX - 8) return;
1231 memcpy(filename, filewalker, dirlen);
1232
1233 filewalker += dirlen + 1;
1234 filename[dirlen++] = '\\';
1235
1236 /* then go over names one by one */
1237 for(;;) {
1238 n = strlen(filewalker) + 1;
1239 /* end of the list */
1240 if(n == 1)
1241 break;
1242 /* too big, shouldn't happen */
1243 if(n + dirlen > FILENAME_MAX)
1244 break;
1245
1246 memcpy(filename + dirlen, filewalker, n);
1247 filewalker += n;
1248
1249 add_keyfile(filename);
1250 }
1251 }
1252
1253 keylist_update();
1254 forget_passphrases();
1255 }
1256 sfree(filelist);
1257 }
1258
1259 /*
1260 * Dialog-box function for the key list box.
1261 */
1262 static int CALLBACK KeyListProc(HWND hwnd, UINT msg,
1263 WPARAM wParam, LPARAM lParam)
1264 {
1265 struct RSAKey *rkey;
1266 struct ssh2_userkey *skey;
1267
1268 switch (msg) {
1269 case WM_INITDIALOG:
1270 /*
1271 * Centre the window.
1272 */
1273 { /* centre the window */
1274 RECT rs, rd;
1275 HWND hw;
1276
1277 hw = GetDesktopWindow();
1278 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
1279 MoveWindow(hwnd,
1280 (rs.right + rs.left + rd.left - rd.right) / 2,
1281 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
1282 rd.right - rd.left, rd.bottom - rd.top, TRUE);
1283 }
1284
1285 if (help_path)
1286 SetWindowLong(hwnd, GWL_EXSTYLE,
1287 GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
1288 else {
1289 HWND item = GetDlgItem(hwnd, 103); /* the Help button */
1290 if (item)
1291 DestroyWindow(item);
1292 }
1293 requested_help = FALSE;
1294
1295 keylist = hwnd;
1296 {
1297 static int tabs[] = { 35, 60, 210 };
1298 SendDlgItemMessage(hwnd, 100, LB_SETTABSTOPS,
1299 sizeof(tabs) / sizeof(*tabs),
1300 (LPARAM) tabs);
1301 }
1302 keylist_update();
1303 return 0;
1304 case WM_COMMAND:
1305 switch (LOWORD(wParam)) {
1306 case IDOK:
1307 case IDCANCEL:
1308 keylist = NULL;
1309 DestroyWindow(hwnd);
1310 return 0;
1311 case 101: /* add key */
1312 if (HIWORD(wParam) == BN_CLICKED ||
1313 HIWORD(wParam) == BN_DOUBLECLICKED) {
1314 if (passphrase_box) {
1315 MessageBeep(MB_ICONERROR);
1316 SetForegroundWindow(passphrase_box);
1317 break;
1318 }
1319 prompt_add_keyfile();
1320 }
1321 return 0;
1322 case 102: /* remove key */
1323 if (HIWORD(wParam) == BN_CLICKED ||
1324 HIWORD(wParam) == BN_DOUBLECLICKED) {
1325 int i;
1326 int rCount, sCount;
1327 int *selectedArray;
1328
1329 /* our counter within the array of selected items */
1330 int itemNum;
1331
1332 /* get the number of items selected in the list */
1333 int numSelected =
1334 SendDlgItemMessage(hwnd, 100, LB_GETSELCOUNT, 0, 0);
1335
1336 /* none selected? that was silly */
1337 if (numSelected == 0) {
1338 MessageBeep(0);
1339 break;
1340 }
1341
1342 /* get item indices in an array */
1343 selectedArray = smalloc(numSelected * sizeof(int));
1344 SendDlgItemMessage(hwnd, 100, LB_GETSELITEMS,
1345 numSelected, (WPARAM)selectedArray);
1346
1347 itemNum = numSelected - 1;
1348 rCount = count234(rsakeys);
1349 sCount = count234(ssh2keys);
1350
1351 /* go through the non-rsakeys until we've covered them all,
1352 * and/or we're out of selected items to check. note that
1353 * we go *backwards*, to avoid complications from deleting
1354 * things hence altering the offset of subsequent items
1355 */
1356 for (i = sCount - 1; (itemNum >= 0) && (i >= 0); i--) {
1357 skey = index234(ssh2keys, i);
1358
1359 if (selectedArray[itemNum] == rCount + i) {
1360 del234(ssh2keys, skey);
1361 skey->alg->freekey(skey->data);
1362 sfree(skey);
1363 itemNum--;
1364 }
1365 }
1366
1367 /* do the same for the rsa keys */
1368 for (i = rCount - 1; (itemNum >= 0) && (i >= 0); i--) {
1369 rkey = index234(rsakeys, i);
1370
1371 if(selectedArray[itemNum] == i) {
1372 del234(rsakeys, rkey);
1373 freersakey(rkey);
1374 sfree(rkey);
1375 itemNum--;
1376 }
1377 }
1378
1379 sfree(selectedArray);
1380 keylist_update();
1381 }
1382 return 0;
1383 case 103: /* help */
1384 if (HIWORD(wParam) == BN_CLICKED ||
1385 HIWORD(wParam) == BN_DOUBLECLICKED) {
1386 if (help_path) {
1387 WinHelp(main_hwnd, help_path, HELP_COMMAND,
1388 (DWORD)"JI(`',`pageant.general')");
1389 requested_help = TRUE;
1390 }
1391 }
1392 return 0;
1393 }
1394 return 0;
1395 case WM_HELP:
1396 if (help_path) {
1397 int id = ((LPHELPINFO)lParam)->iCtrlId;
1398 char *cmd = NULL;
1399 switch (id) {
1400 case 100: cmd = "JI(`',`pageant.keylist')"; break;
1401 case 101: cmd = "JI(`',`pageant.addkey')"; break;
1402 case 102: cmd = "JI(`',`pageant.remkey')"; break;
1403 }
1404 if (cmd) {
1405 WinHelp(main_hwnd, help_path, HELP_COMMAND, (DWORD)cmd);
1406 requested_help = TRUE;
1407 } else {
1408 MessageBeep(0);
1409 }
1410 }
1411 break;
1412 case WM_CLOSE:
1413 keylist = NULL;
1414 DestroyWindow(hwnd);
1415 return 0;
1416 }
1417 return 0;
1418 }
1419
1420 /* Set up a system tray icon */
1421 static BOOL AddTrayIcon(HWND hwnd)
1422 {
1423 BOOL res;
1424 NOTIFYICONDATA tnid;
1425 HICON hicon;
1426
1427 #ifdef NIM_SETVERSION
1428 tnid.uVersion = 0;
1429 res = Shell_NotifyIcon(NIM_SETVERSION, &tnid);
1430 #endif
1431
1432 tnid.cbSize = sizeof(NOTIFYICONDATA);
1433 tnid.hWnd = hwnd;
1434 tnid.uID = 1; /* unique within this systray use */
1435 tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
1436 tnid.uCallbackMessage = WM_SYSTRAY;
1437 tnid.hIcon = hicon = LoadIcon(instance, MAKEINTRESOURCE(201));
1438 strcpy(tnid.szTip, "Pageant (PuTTY authentication agent)");
1439
1440 res = Shell_NotifyIcon(NIM_ADD, &tnid);
1441
1442 if (hicon) DestroyIcon(hicon);
1443
1444 return res;
1445 }
1446
1447 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1448 WPARAM wParam, LPARAM lParam)
1449 {
1450 int ret;
1451 static int menuinprogress;
1452 static UINT msgTaskbarCreated = 0;
1453
1454 switch (message) {
1455 case WM_CREATE:
1456 msgTaskbarCreated = RegisterWindowMessage(_T("TaskbarCreated"));
1457 break;
1458 default:
1459 if (message==msgTaskbarCreated) {
1460 /*
1461 * Explorer has been restarted, so the tray icon will
1462 * have been lost.
1463 */
1464 AddTrayIcon(hwnd);
1465 }
1466 break;
1467
1468 case WM_SYSTRAY:
1469 if (lParam == WM_RBUTTONUP) {
1470 POINT cursorpos;
1471 GetCursorPos(&cursorpos);
1472 PostMessage(hwnd, WM_SYSTRAY2, cursorpos.x, cursorpos.y);
1473 } else if (lParam == WM_LBUTTONDBLCLK) {
1474 /* Equivalent to IDM_VIEWKEYS. */
1475 PostMessage(hwnd, WM_COMMAND, IDM_VIEWKEYS, 0);
1476 }
1477 break;
1478 case WM_SYSTRAY2:
1479 if (!menuinprogress) {
1480 menuinprogress = 1;
1481 SetForegroundWindow(hwnd);
1482 ret = TrackPopupMenu(systray_menu,
1483 TPM_RIGHTALIGN | TPM_BOTTOMALIGN |
1484 TPM_RIGHTBUTTON,
1485 wParam, lParam, 0, hwnd, NULL);
1486 menuinprogress = 0;
1487 }
1488 break;
1489 case WM_COMMAND:
1490 case WM_SYSCOMMAND:
1491 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1492 case IDM_CLOSE:
1493 if (passphrase_box)
1494 SendMessage(passphrase_box, WM_CLOSE, 0, 0);
1495 SendMessage(hwnd, WM_CLOSE, 0, 0);
1496 break;
1497 case IDM_VIEWKEYS:
1498 if (!keylist) {
1499 keylist = CreateDialog(instance, MAKEINTRESOURCE(211),
1500 NULL, KeyListProc);
1501 ShowWindow(keylist, SW_SHOWNORMAL);
1502 /*
1503 * Sometimes the window comes up minimised / hidden
1504 * for no obvious reason. Prevent this.
1505 */
1506 SetForegroundWindow(keylist);
1507 SetWindowPos(keylist, HWND_TOP, 0, 0, 0, 0,
1508 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1509 }
1510 break;
1511 case IDM_ADDKEY:
1512 if (passphrase_box) {
1513 MessageBeep(MB_ICONERROR);
1514 SetForegroundWindow(passphrase_box);
1515 break;
1516 }
1517 prompt_add_keyfile();
1518 break;
1519 case IDM_ABOUT:
1520 if (!aboutbox) {
1521 aboutbox = CreateDialog(instance, MAKEINTRESOURCE(213),
1522 NULL, AboutProc);
1523 ShowWindow(aboutbox, SW_SHOWNORMAL);
1524 /*
1525 * Sometimes the window comes up minimised / hidden
1526 * for no obvious reason. Prevent this.
1527 */
1528 SetForegroundWindow(aboutbox);
1529 SetWindowPos(aboutbox, HWND_TOP, 0, 0, 0, 0,
1530 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1531 }
1532 break;
1533 case IDM_HELP:
1534 if (help_path) {
1535 WinHelp(main_hwnd, help_path, HELP_COMMAND,
1536 (DWORD)"JI(`',`pageant.general')");
1537 requested_help = TRUE;
1538 }
1539 break;
1540 }
1541 break;
1542 case WM_DESTROY:
1543 if (requested_help) {
1544 WinHelp(main_hwnd, help_path, HELP_QUIT, 0);
1545 requested_help = FALSE;
1546 }
1547 PostQuitMessage(0);
1548 return 0;
1549 case WM_COPYDATA:
1550 {
1551 COPYDATASTRUCT *cds;
1552 char *mapname;
1553 void *p;
1554 HANDLE filemap;
1555 #ifndef NO_SECURITY
1556 HANDLE proc;
1557 PSID mapowner, procowner;
1558 PSECURITY_DESCRIPTOR psd1 = NULL, psd2 = NULL;
1559 #endif
1560 int ret = 0;
1561
1562 cds = (COPYDATASTRUCT *) lParam;
1563 if (cds->dwData != AGENT_COPYDATA_ID)
1564 return 0; /* not our message, mate */
1565 mapname = (char *) cds->lpData;
1566 if (mapname[cds->cbData - 1] != '\0')
1567 return 0; /* failure to be ASCIZ! */
1568 #ifdef DEBUG_IPC
1569 debug(("mapname is :%s:\n", mapname));
1570 #endif
1571 filemap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, mapname);
1572 #ifdef DEBUG_IPC
1573 debug(("filemap is %p\n", filemap));
1574 #endif
1575 if (filemap != NULL && filemap != INVALID_HANDLE_VALUE) {
1576 #ifndef NO_SECURITY
1577 int rc;
1578 if (has_security) {
1579 if ((proc = OpenProcess(MAXIMUM_ALLOWED, FALSE,
1580 GetCurrentProcessId())) ==
1581 NULL) {
1582 #ifdef DEBUG_IPC
1583 debug(("couldn't get handle for process\n"));
1584 #endif
1585 return 0;
1586 }
1587 if (getsecurityinfo(proc, SE_KERNEL_OBJECT,
1588 OWNER_SECURITY_INFORMATION,
1589 &procowner, NULL, NULL, NULL,
1590 &psd2) != ERROR_SUCCESS) {
1591 #ifdef DEBUG_IPC
1592 debug(("couldn't get owner info for process\n"));
1593 #endif
1594 CloseHandle(proc);
1595 return 0; /* unable to get security info */
1596 }
1597 CloseHandle(proc);
1598 if ((rc = getsecurityinfo(filemap, SE_KERNEL_OBJECT,
1599 OWNER_SECURITY_INFORMATION,
1600 &mapowner, NULL, NULL, NULL,
1601 &psd1) != ERROR_SUCCESS)) {
1602 #ifdef DEBUG_IPC
1603 debug(
1604 ("couldn't get owner info for filemap: %d\n",
1605 rc));
1606 #endif
1607 return 0;
1608 }
1609 #ifdef DEBUG_IPC
1610 debug(("got security stuff\n"));
1611 #endif
1612 if (!EqualSid(mapowner, procowner))
1613 return 0; /* security ID mismatch! */
1614 #ifdef DEBUG_IPC
1615 debug(("security stuff matched\n"));
1616 #endif
1617 LocalFree(psd1);
1618 LocalFree(psd2);
1619 } else {
1620 #ifdef DEBUG_IPC
1621 debug(("security APIs not present\n"));
1622 #endif
1623 }
1624 #endif
1625 p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
1626 #ifdef DEBUG_IPC
1627 debug(("p is %p\n", p));
1628 {
1629 int i;
1630 for (i = 0; i < 5; i++)
1631 debug(
1632 ("p[%d]=%02x\n", i,
1633 ((unsigned char *) p)[i]));}
1634 #endif
1635 answer_msg(p);
1636 ret = 1;
1637 UnmapViewOfFile(p);
1638 }
1639 CloseHandle(filemap);
1640 return ret;
1641 }
1642 }
1643
1644 return DefWindowProc(hwnd, message, wParam, lParam);
1645 }
1646
1647 /*
1648 * Fork and Exec the command in cmdline. [DBW]
1649 */
1650 void spawn_cmd(char *cmdline, char * args, int show)
1651 {
1652 if (ShellExecute(NULL, _T("open"), cmdline,
1653 args, NULL, show) <= (HINSTANCE) 32) {
1654 TCHAR sMsg[140];
1655 sprintf(sMsg, _T("Failed to run \"%.100s\", Error: %d"), cmdline,
1656 (int)GetLastError());
1657 MessageBox(NULL, sMsg, APPNAME, MB_OK | MB_ICONEXCLAMATION);
1658 }
1659 }
1660
1661 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1662 {
1663 WNDCLASS wndclass;
1664 MSG msg;
1665 OSVERSIONINFO osi;
1666 HMODULE advapi;
1667 char *command = NULL;
1668 int added_keys = 0;
1669
1670 /*
1671 * Determine whether we're an NT system (should have security
1672 * APIs) or a non-NT system (don't do security).
1673 */
1674 memset(&osi, 0, sizeof(OSVERSIONINFO));
1675 osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1676 if (GetVersionEx(&osi) && osi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1677 has_security = TRUE;
1678 } else
1679 has_security = FALSE;
1680
1681 if (has_security) {
1682 #ifndef NO_SECURITY
1683 /*
1684 * Attempt to get the security API we need.
1685 */
1686 advapi = LoadLibrary("ADVAPI32.DLL");
1687 getsecurityinfo =
1688 (gsi_fn_t) GetProcAddress(advapi, "GetSecurityInfo");
1689 if (!getsecurityinfo) {
1690 MessageBox(NULL,
1691 "Unable to access security APIs. Pageant will\n"
1692 "not run, in case it causes a security breach.",
1693 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1694 return 1;
1695 }
1696 #else
1697 MessageBox(NULL,
1698 "This program has been compiled for Win9X and will\n"
1699 "not run on NT, in case it causes a security breach.",
1700 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1701 return 1;
1702 #endif
1703 } else
1704 advapi = NULL;
1705
1706 instance = inst;
1707
1708 /*
1709 * See if we can find our Help file.
1710 */
1711 {
1712 char b[2048], *p, *q, *r;
1713 FILE *fp;
1714 GetModuleFileName(NULL, b, sizeof(b) - 1);
1715 r = b;
1716 p = strrchr(b, '\\');
1717 if (p && p >= r) r = p+1;
1718 q = strrchr(b, ':');
1719 if (q && q >= r) r = q+1;
1720 strcpy(r, "putty.hlp");
1721 if ( (fp = fopen(b, "r")) != NULL) {
1722 help_path = dupstr(b);
1723 fclose(fp);
1724 } else
1725 help_path = NULL;
1726 }
1727
1728 /*
1729 * Find out if Pageant is already running.
1730 */
1731 already_running = FALSE;
1732 if (agent_exists())
1733 already_running = TRUE;
1734 else {
1735
1736 if (!prev) {
1737 wndclass.style = 0;
1738 wndclass.lpfnWndProc = WndProc;
1739 wndclass.cbClsExtra = 0;
1740 wndclass.cbWndExtra = 0;
1741 wndclass.hInstance = inst;
1742 wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
1743 wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM);
1744 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1745 wndclass.lpszMenuName = NULL;
1746 wndclass.lpszClassName = APPNAME;
1747
1748 RegisterClass(&wndclass);
1749 }
1750
1751 main_hwnd = keylist = NULL;
1752
1753 main_hwnd = CreateWindow(APPNAME, APPNAME,
1754 WS_OVERLAPPEDWINDOW | WS_VSCROLL,
1755 CW_USEDEFAULT, CW_USEDEFAULT,
1756 100, 100, NULL, NULL, inst, NULL);
1757
1758 /* Set up a system tray icon */
1759 AddTrayIcon(main_hwnd);
1760
1761 systray_menu = CreatePopupMenu();
1762 /* accelerators used: vkxa */
1763 AppendMenu(systray_menu, MF_ENABLED, IDM_VIEWKEYS,
1764 "&View Keys");
1765 AppendMenu(systray_menu, MF_ENABLED, IDM_ADDKEY, "Add &Key");
1766 AppendMenu(systray_menu, MF_SEPARATOR, 0, 0);
1767 if (help_path)
1768 AppendMenu(systray_menu, MF_ENABLED, IDM_HELP, "&Help");
1769 AppendMenu(systray_menu, MF_ENABLED, IDM_ABOUT, "&About");
1770 AppendMenu(systray_menu, MF_SEPARATOR, 0, 0);
1771 AppendMenu(systray_menu, MF_ENABLED, IDM_CLOSE, "E&xit");
1772
1773 ShowWindow(main_hwnd, SW_HIDE);
1774
1775 /*
1776 * Initialise storage for RSA keys.
1777 */
1778 rsakeys = newtree234(cmpkeys_rsa);
1779 ssh2keys = newtree234(cmpkeys_ssh2);
1780
1781 }
1782
1783 /*
1784 * Initialise storage for short-term passphrase cache.
1785 */
1786 passphrases = newtree234(NULL);
1787
1788 /*
1789 * Process the command line and add keys as listed on it.
1790 * If we already determined that we need to spawn a program from above we
1791 * need to ignore the first two arguments. [DBW]
1792 */
1793 {
1794 char *p;
1795 int inquotes = 0;
1796 p = cmdline;
1797 while (*p) {
1798 while (*p && isspace(*p))
1799 p++;
1800 if (*p && !isspace(*p)) {
1801 char *q = p, *pp = p;
1802 while (*p && (inquotes || !isspace(*p))) {
1803 if (*p == '"') {
1804 inquotes = !inquotes;
1805 p++;
1806 continue;
1807 }
1808 *pp++ = *p++;
1809 }
1810 if (*pp) {
1811 if (*p)
1812 p++;
1813 *pp++ = '\0';
1814 }
1815 if (!strcmp(q, "-c")) {
1816 /*
1817 * If we see `-c', then the rest of the
1818 * command line should be treated as a
1819 * command to be spawned.
1820 */
1821 while (*p && isspace(*p))
1822 p++;
1823 command = p;
1824 break;
1825 } else {
1826 add_keyfile(q);
1827 added_keys = TRUE;
1828 }
1829 }
1830 }
1831 }
1832
1833 /*
1834 * Forget any passphrase that we retained while going over
1835 * command line keyfiles.
1836 */
1837 forget_passphrases();
1838
1839 if (command) {
1840 char *args;
1841 if (command[0] == '"')
1842 args = strchr(++command, '"');
1843 else
1844 args = strchr(command, ' ');
1845 if (args) {
1846 *args++ = 0;
1847 while(*args && isspace(*args)) args++;
1848 }
1849 spawn_cmd(command, args, show);
1850 }
1851
1852 /*
1853 * If Pageant was already running, we leave now. If we haven't
1854 * even taken any auxiliary action (spawned a command or added
1855 * keys), complain.
1856 */
1857 if (already_running) {
1858 if (!command && !added_keys) {
1859 MessageBox(NULL, "Pageant is already running", "Pageant Error",
1860 MB_ICONERROR | MB_OK);
1861 }
1862 if (advapi)
1863 FreeLibrary(advapi);
1864 return 0;
1865 }
1866
1867 /*
1868 * Main message loop.
1869 */
1870 while (GetMessage(&msg, NULL, 0, 0) == 1) {
1871 TranslateMessage(&msg);
1872 DispatchMessage(&msg);
1873 }
1874
1875 /* Clean up the system tray icon */
1876 {
1877 NOTIFYICONDATA tnid;
1878
1879 tnid.cbSize = sizeof(NOTIFYICONDATA);
1880 tnid.hWnd = main_hwnd;
1881 tnid.uID = 1;
1882
1883 Shell_NotifyIcon(NIM_DELETE, &tnid);
1884
1885 DestroyMenu(systray_menu);
1886 }
1887
1888 if (advapi)
1889 FreeLibrary(advapi);
1890 exit(msg.wParam);
1891 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator