projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Placate gcc's `-Wall' warnings.
[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 <tchar.h>
13
14 #include "ssh.h"
15 #include "tree234.h"
16
17 #define IDI_MAINICON 200
18 #define IDI_TRAYICON 201
19
20 #define WM_XUSER (WM_USER + 0x2000)
21 #define WM_SYSTRAY (WM_XUSER + 6)
22 #define WM_SYSTRAY2 (WM_XUSER + 7)
23
24 #define AGENT_COPYDATA_ID 0x804e50ba /* random goop */
25
26 /*
27 * FIXME: maybe some day we can sort this out ...
28 */
29 #define AGENT_MAX_MSGLEN 8192
30
31 #define IDM_CLOSE 0x0010
32 #define IDM_VIEWKEYS 0x0020
33 #define IDM_ADDKEY 0x0030
34 #define IDM_ABOUT 0x0040
35
36 #define APPNAME "Pageant"
37
38 extern char ver[];
39
40 static HINSTANCE instance;
41 static HWND hwnd;
42 static HWND keylist;
43 static HWND aboutbox;
44 static HMENU systray_menu;
45 static int already_running;
46
47 static tree234 *rsakeys, *ssh2keys;
48
49 static int has_security;
50 #ifndef NO_SECURITY
51 typedef DWORD(WINAPI * gsi_fn_t)
52 (HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION,
53 PSID *, PSID *, PACL *, PACL *, PSECURITY_DESCRIPTOR *);
54 static gsi_fn_t getsecurityinfo;
55 #endif
56
57 /*
58 * Exports from pageantc.c
59 */
60 void agent_query(void *in, int inlen, void **out, int *outlen);
61 int agent_exists(void);
62
63 /*
64 * We need this to link with the RSA code, because rsaencrypt()
65 * pads its data with random bytes. Since we only use rsadecrypt()
66 * and the signing functions, which are deterministic, this should
67 * never be called.
68 *
69 * If it _is_ called, there is a _serious_ problem, because it
70 * won't generate true random numbers. So we must scream, panic,
71 * and exit immediately if that should happen.
72 */
73 int random_byte(void)
74 {
75 MessageBox(hwnd, "Internal Error", APPNAME, MB_OK | MB_ICONERROR);
76 exit(0);
77 }
78
79 /*
80 * Blob structure for passing to the asymmetric SSH2 key compare
81 * function, prototyped here.
82 */
83 struct blob {
84 unsigned char *blob;
85 int len;
86 };
87 static int cmpkeys_ssh2_asymm(void *av, void *bv);
88
89 /*
90 * This function is needed to link with the DES code. We need not
91 * have it do anything at all.
92 */
93 void logevent(char *msg)
94 {
95 }
96
97 #define GET_32BIT(cp) \
98 (((unsigned long)(unsigned char)(cp)[0] << 24) | \
99 ((unsigned long)(unsigned char)(cp)[1] << 16) | \
100 ((unsigned long)(unsigned char)(cp)[2] << 8) | \
101 ((unsigned long)(unsigned char)(cp)[3]))
102
103 #define PUT_32BIT(cp, value) { \
104 (cp)[0] = (unsigned char)((value) >> 24); \
105 (cp)[1] = (unsigned char)((value) >> 16); \
106 (cp)[2] = (unsigned char)((value) >> 8); \
107 (cp)[3] = (unsigned char)(value); }
108
109 #define PASSPHRASE_MAXLEN 512
110
111 struct PassphraseProcStruct {
112 char *passphrase;
113 char *comment;
114 };
115
116 /*
117 * Dialog-box function for the Licence box.
118 */
119 static int CALLBACK LicenceProc(HWND hwnd, UINT msg,
120 WPARAM wParam, LPARAM lParam)
121 {
122 switch (msg) {
123 case WM_INITDIALOG:
124 return 1;
125 case WM_COMMAND:
126 switch (LOWORD(wParam)) {
127 case IDOK:
128 EndDialog(hwnd, 1);
129 return 0;
130 }
131 return 0;
132 case WM_CLOSE:
133 EndDialog(hwnd, 1);
134 return 0;
135 }
136 return 0;
137 }
138
139 /*
140 * Dialog-box function for the About box.
141 */
142 static int CALLBACK AboutProc(HWND hwnd, UINT msg,
143 WPARAM wParam, LPARAM lParam)
144 {
145 switch (msg) {
146 case WM_INITDIALOG:
147 SetDlgItemText(hwnd, 100, ver);
148 return 1;
149 case WM_COMMAND:
150 switch (LOWORD(wParam)) {
151 case IDOK:
152 aboutbox = NULL;
153 DestroyWindow(hwnd);
154 return 0;
155 case 101:
156 EnableWindow(hwnd, 0);
157 DialogBox(instance, MAKEINTRESOURCE(214), NULL, LicenceProc);
158 EnableWindow(hwnd, 1);
159 SetActiveWindow(hwnd);
160 return 0;
161 }
162 return 0;
163 case WM_CLOSE:
164 aboutbox = NULL;
165 DestroyWindow(hwnd);
166 return 0;
167 }
168 return 0;
169 }
170
171 /*
172 * Dialog-box function for the passphrase box.
173 */
174 static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
175 WPARAM wParam, LPARAM lParam)
176 {
177 static char *passphrase = NULL;
178 struct PassphraseProcStruct *p;
179
180 switch (msg) {
181 case WM_INITDIALOG:
182 /*
183 * Centre the window.
184 */
185 { /* centre the window */
186 RECT rs, rd;
187 HWND hw;
188
189 hw = GetDesktopWindow();
190 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
191 MoveWindow(hwnd,
192 (rs.right + rs.left + rd.left - rd.right) / 2,
193 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
194 rd.right - rd.left, rd.bottom - rd.top, TRUE);
195 }
196
197 SetForegroundWindow(hwnd);
198 SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
199 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
200 p = (struct PassphraseProcStruct *) lParam;
201 passphrase = p->passphrase;
202 if (p->comment)
203 SetDlgItemText(hwnd, 101, p->comment);
204 *passphrase = 0;
205 SetDlgItemText(hwnd, 102, passphrase);
206 return 0;
207 case WM_COMMAND:
208 switch (LOWORD(wParam)) {
209 case IDOK:
210 if (*passphrase)
211 EndDialog(hwnd, 1);
212 else
213 MessageBeep(0);
214 return 0;
215 case IDCANCEL:
216 EndDialog(hwnd, 0);
217 return 0;
218 case 102: /* edit box */
219 if ((HIWORD(wParam) == EN_CHANGE) && passphrase) {
220 GetDlgItemText(hwnd, 102, passphrase,
221 PASSPHRASE_MAXLEN - 1);
222 passphrase[PASSPHRASE_MAXLEN - 1] = '\0';
223 }
224 return 0;
225 }
226 return 0;
227 case WM_CLOSE:
228 EndDialog(hwnd, 0);
229 return 0;
230 }
231 return 0;
232 }
233
234 /*
235 * Update the visible key list.
236 */
237 static void keylist_update(void)
238 {
239 struct RSAKey *rkey;
240 struct ssh2_userkey *skey;
241 int i;
242
243 if (keylist) {
244 SendDlgItemMessage(keylist, 100, LB_RESETCONTENT, 0, 0);
245 for (i = 0; NULL != (rkey = index234(rsakeys, i)); i++) {
246 char listentry[512], *p;
247 /*
248 * Replace two spaces in the fingerprint with tabs, for
249 * nice alignment in the box.
250 */
251 strcpy(listentry, "ssh1\t");
252 p = listentry + strlen(listentry);
253 rsa_fingerprint(p, sizeof(listentry) - (p - listentry), rkey);
254 p = strchr(listentry, ' ');
255 if (p)
256 *p = '\t';
257 p = strchr(listentry, ' ');
258 if (p)
259 *p = '\t';
260 SendDlgItemMessage(keylist, 100, LB_ADDSTRING,
261 0, (LPARAM) listentry);
262 }
263 for (i = 0; NULL != (skey = index234(ssh2keys, i)); i++) {
264 char listentry[512], *p;
265 int len;
266 /*
267 * Replace two spaces in the fingerprint with tabs, for
268 * nice alignment in the box.
269 */
270 p = skey->alg->fingerprint(skey->data);
271 strncpy(listentry, p, sizeof(listentry));
272 p = strchr(listentry, ' ');
273 if (p)
274 *p = '\t';
275 p = strchr(listentry, ' ');
276 if (p)
277 *p = '\t';
278 len = strlen(listentry);
279 if (len < sizeof(listentry) - 2) {
280 listentry[len] = '\t';
281 strncpy(listentry + len + 1, skey->comment,
282 sizeof(listentry) - len - 1);
283 }
284 SendDlgItemMessage(keylist, 100, LB_ADDSTRING, 0,
285 (LPARAM) listentry);
286 }
287 SendDlgItemMessage(keylist, 100, LB_SETCURSEL, (WPARAM) - 1, 0);
288 }
289 }
290
291 /*
292 * This function loads a key from a file and adds it.
293 */
294 static void add_keyfile(char *filename)
295 {
296 char passphrase[PASSPHRASE_MAXLEN];
297 struct RSAKey *rkey = NULL;
298 struct ssh2_userkey *skey = NULL;
299 int needs_pass;
300 int ret;
301 int attempts;
302 char *comment;
303 struct PassphraseProcStruct pps;
304 int ver;
305
306 ver = keyfile_version(filename);
307 if (ver == 0) {
308 MessageBox(NULL, "Couldn't load private key.", APPNAME,
309 MB_OK | MB_ICONERROR);
310 return;
311 }
312
313 if (ver == 1)
314 needs_pass = rsakey_encrypted(filename, &comment);
315 else
316 needs_pass = ssh2_userkey_encrypted(filename, &comment);
317 attempts = 0;
318 if (ver == 1)
319 rkey = smalloc(sizeof(*rkey));
320 pps.passphrase = passphrase;
321 pps.comment = comment;
322 do {
323 if (needs_pass) {
324 int dlgret;
325 dlgret = DialogBoxParam(instance, MAKEINTRESOURCE(210),
326 NULL, PassphraseProc, (LPARAM) & pps);
327 if (!dlgret) {
328 if (comment)
329 sfree(comment);
330 if (ver == 1)
331 sfree(rkey);
332 return; /* operation cancelled */
333 }
334 } else
335 *passphrase = '\0';
336 if (ver == 1)
337 ret = loadrsakey(filename, rkey, passphrase);
338 else {
339 skey = ssh2_load_userkey(filename, passphrase);
340 if (skey == SSH2_WRONG_PASSPHRASE)
341 ret = -1;
342 else if (!skey)
343 ret = 0;
344 else
345 ret = 1;
346 }
347 attempts++;
348 } while (ret == -1);
349 if (comment)
350 sfree(comment);
351 if (ret == 0) {
352 MessageBox(NULL, "Couldn't load private key.", APPNAME,
353 MB_OK | MB_ICONERROR);
354 if (ver == 1)
355 sfree(rkey);
356 return;
357 }
358 if (ver == 1) {
359 if (already_running) {
360 unsigned char *request, *response;
361 void *vresponse;
362 int reqlen, clen, resplen;
363
364 clen = strlen(rkey->comment);
365
366 reqlen = 4 + 1 + /* length, message type */
367 4 + /* bit count */
368 ssh1_bignum_length(rkey->modulus) +
369 ssh1_bignum_length(rkey->exponent) +
370 ssh1_bignum_length(rkey->private_exponent) +
371 ssh1_bignum_length(rkey->iqmp) +
372 ssh1_bignum_length(rkey->p) +
373 ssh1_bignum_length(rkey->q) + 4 + clen /* comment */
374 ;
375
376 request = smalloc(reqlen);
377
378 request[4] = SSH1_AGENTC_ADD_RSA_IDENTITY;
379 reqlen = 5;
380 PUT_32BIT(request + reqlen, bignum_bitcount(rkey->modulus));
381 reqlen += 4;
382 reqlen += ssh1_write_bignum(request + reqlen, rkey->modulus);
383 reqlen += ssh1_write_bignum(request + reqlen, rkey->exponent);
384 reqlen +=
385 ssh1_write_bignum(request + reqlen,
386 rkey->private_exponent);
387 reqlen += ssh1_write_bignum(request + reqlen, rkey->iqmp);
388 reqlen += ssh1_write_bignum(request + reqlen, rkey->p);
389 reqlen += ssh1_write_bignum(request + reqlen, rkey->q);
390 PUT_32BIT(request + reqlen, clen);
391 memcpy(request + reqlen + 4, rkey->comment, clen);
392 reqlen += 4 + clen;
393 PUT_32BIT(request, reqlen - 4);
394
395 agent_query(request, reqlen, &vresponse, &resplen);
396 response = vresponse;
397 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
398 MessageBox(NULL, "The already running Pageant "
399 "refused to add the key.", APPNAME,
400 MB_OK | MB_ICONERROR);
401 } else {
402 if (add234(rsakeys, rkey) != rkey)
403 sfree(rkey); /* already present, don't waste RAM */
404 }
405 } else {
406 if (already_running) {
407 unsigned char *request, *response;
408 void *vresponse;
409 int reqlen, alglen, clen, keybloblen, resplen;
410 alglen = strlen(skey->alg->name);
411 clen = strlen(skey->comment);
412
413 keybloblen = skey->alg->openssh_fmtkey(skey->data, NULL, 0);
414
415 reqlen = 4 + 1 + /* length, message type */
416 4 + alglen + /* algorithm name */
417 keybloblen + /* key data */
418 4 + clen /* comment */
419 ;
420
421 request = smalloc(reqlen);
422
423 request[4] = SSH2_AGENTC_ADD_IDENTITY;
424 reqlen = 5;
425 PUT_32BIT(request + reqlen, alglen);
426 reqlen += 4;
427 memcpy(request + reqlen, skey->alg->name, alglen);
428 reqlen += alglen;
429 reqlen += skey->alg->openssh_fmtkey(skey->data,
430 request + reqlen,
431 keybloblen);
432 PUT_32BIT(request + reqlen, clen);
433 memcpy(request + reqlen + 4, skey->comment, clen);
434 PUT_32BIT(request, reqlen - 4);
435 reqlen += clen + 4;
436
437 agent_query(request, reqlen, &vresponse, &resplen);
438 response = vresponse;
439 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
440 MessageBox(NULL, "The already running Pageant"
441 "refused to add the key.", APPNAME,
442 MB_OK | MB_ICONERROR);
443 } else {
444 if (add234(ssh2keys, skey) != skey) {
445 skey->alg->freekey(skey->data);
446 sfree(skey); /* already present, don't waste RAM */
447 }
448 }
449 }
450 }
451
452 /*
453 * This is the main agent function that answers messages.
454 */
455 static void answer_msg(void *msg)
456 {
457 unsigned char *p = msg;
458 unsigned char *ret = msg;
459 int type;
460
461 /*
462 * Get the message type.
463 */
464 type = p[4];
465
466 p += 5;
467 switch (type) {
468 case SSH1_AGENTC_REQUEST_RSA_IDENTITIES:
469 /*
470 * Reply with SSH1_AGENT_RSA_IDENTITIES_ANSWER.
471 */
472 {
473 struct RSAKey *key;
474 int len, nkeys;
475 int i;
476
477 /*
478 * Count up the number and length of keys we hold.
479 */
480 len = nkeys = 0;
481 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
482 nkeys++;
483 len += 4; /* length field */
484 len += ssh1_bignum_length(key->exponent);
485 len += ssh1_bignum_length(key->modulus);
486 len += 4 + strlen(key->comment);
487 }
488
489 /*
490 * Packet header is the obvious five bytes, plus four
491 * bytes for the key count.
492 */
493 len += 5 + 4;
494 if (len > AGENT_MAX_MSGLEN)
495 goto failure; /* aaargh! too much stuff! */
496 PUT_32BIT(ret, len - 4);
497 ret[4] = SSH1_AGENT_RSA_IDENTITIES_ANSWER;
498 PUT_32BIT(ret + 5, nkeys);
499 p = ret + 5 + 4;
500 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
501 PUT_32BIT(p, bignum_bitcount(key->modulus));
502 p += 4;
503 p += ssh1_write_bignum(p, key->exponent);
504 p += ssh1_write_bignum(p, key->modulus);
505 PUT_32BIT(p, strlen(key->comment));
506 memcpy(p + 4, key->comment, strlen(key->comment));
507 p += 4 + strlen(key->comment);
508 }
509 }
510 break;
511 case SSH2_AGENTC_REQUEST_IDENTITIES:
512 /*
513 * Reply with SSH2_AGENT_IDENTITIES_ANSWER.
514 */
515 {
516 struct ssh2_userkey *key;
517 int len, nkeys;
518 unsigned char *blob;
519 int bloblen;
520 int i;
521
522 /*
523 * Count up the number and length of keys we hold.
524 */
525 len = nkeys = 0;
526 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
527 nkeys++;
528 len += 4; /* length field */
529 blob = key->alg->public_blob(key->data, &bloblen);
530 len += bloblen;
531 sfree(blob);
532 len += 4 + strlen(key->comment);
533 }
534
535 /*
536 * Packet header is the obvious five bytes, plus four
537 * bytes for the key count.
538 */
539 len += 5 + 4;
540 if (len > AGENT_MAX_MSGLEN)
541 goto failure; /* aaargh! too much stuff! */
542 PUT_32BIT(ret, len - 4);
543 ret[4] = SSH2_AGENT_IDENTITIES_ANSWER;
544 PUT_32BIT(ret + 5, nkeys);
545 p = ret + 5 + 4;
546 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
547 blob = key->alg->public_blob(key->data, &bloblen);
548 PUT_32BIT(p, bloblen);
549 p += 4;
550 memcpy(p, blob, bloblen);
551 p += bloblen;
552 sfree(blob);
553 PUT_32BIT(p, strlen(key->comment));
554 memcpy(p + 4, key->comment, strlen(key->comment));
555 p += 4 + strlen(key->comment);
556 }
557 }
558 break;
559 case SSH1_AGENTC_RSA_CHALLENGE:
560 /*
561 * Reply with either SSH1_AGENT_RSA_RESPONSE or
562 * SSH_AGENT_FAILURE, depending on whether we have that key
563 * or not.
564 */
565 {
566 struct RSAKey reqkey, *key;
567 Bignum challenge, response;
568 unsigned char response_source[48], response_md5[16];
569 struct MD5Context md5c;
570 int i, len;
571
572 p += 4;
573 p += ssh1_read_bignum(p, &reqkey.exponent);
574 p += ssh1_read_bignum(p, &reqkey.modulus);
575 p += ssh1_read_bignum(p, &challenge);
576 memcpy(response_source + 32, p, 16);
577 p += 16;
578 if (GET_32BIT(p) != 1 ||
579 (key = find234(rsakeys, &reqkey, NULL)) == NULL) {
580 freebn(reqkey.exponent);
581 freebn(reqkey.modulus);
582 freebn(challenge);
583 goto failure;
584 }
585 response = rsadecrypt(challenge, key);
586 for (i = 0; i < 32; i++)
587 response_source[i] = bignum_byte(response, 31 - i);
588
589 MD5Init(&md5c);
590 MD5Update(&md5c, response_source, 48);
591 MD5Final(response_md5, &md5c);
592 memset(response_source, 0, 48); /* burn the evidence */
593 freebn(response); /* and that evidence */
594 freebn(challenge); /* yes, and that evidence */
595 freebn(reqkey.exponent); /* and free some memory ... */
596 freebn(reqkey.modulus); /* ... while we're at it. */
597
598 /*
599 * Packet is the obvious five byte header, plus sixteen
600 * bytes of MD5.
601 */
602 len = 5 + 16;
603 PUT_32BIT(ret, len - 4);
604 ret[4] = SSH1_AGENT_RSA_RESPONSE;
605 memcpy(ret + 5, response_md5, 16);
606 }
607 break;
608 case SSH2_AGENTC_SIGN_REQUEST:
609 /*
610 * Reply with either SSH2_AGENT_RSA_RESPONSE or
611 * SSH_AGENT_FAILURE, depending on whether we have that key
612 * or not.
613 */
614 {
615 struct ssh2_userkey *key;
616 struct blob b;
617 unsigned char *data, *signature;
618 int datalen, siglen, len;
619
620 b.len = GET_32BIT(p);
621 p += 4;
622 b.blob = p;
623 p += b.len;
624 datalen = GET_32BIT(p);
625 p += 4;
626 data = p;
627 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
628 if (!key)
629 goto failure;
630 signature = key->alg->sign(key->data, data, datalen, &siglen);
631 len = 5 + 4 + siglen;
632 PUT_32BIT(ret, len - 4);
633 ret[4] = SSH2_AGENT_SIGN_RESPONSE;
634 PUT_32BIT(ret + 5, siglen);
635 memcpy(ret + 5 + 4, signature, siglen);
636 sfree(signature);
637 }
638 break;
639 case SSH1_AGENTC_ADD_RSA_IDENTITY:
640 /*
641 * Add to the list and return SSH_AGENT_SUCCESS, or
642 * SSH_AGENT_FAILURE if the key was malformed.
643 */
644 {
645 struct RSAKey *key;
646 char *comment;
647 key = smalloc(sizeof(struct RSAKey));
648 memset(key, 0, sizeof(key));
649 p += makekey(p, key, NULL, 1);
650 p += makeprivate(p, key);
651 p += ssh1_read_bignum(p, key->iqmp); /* p^-1 mod q */
652 p += ssh1_read_bignum(p, key->p); /* p */
653 p += ssh1_read_bignum(p, key->q); /* q */
654 comment = smalloc(GET_32BIT(p));
655 if (comment) {
656 memcpy(comment, p + 4, GET_32BIT(p));
657 key->comment = comment;
658 }
659 PUT_32BIT(ret, 1);
660 ret[4] = SSH_AGENT_FAILURE;
661 if (add234(rsakeys, key) == key) {
662 keylist_update();
663 ret[4] = SSH_AGENT_SUCCESS;
664 } else {
665 freersakey(key);
666 sfree(key);
667 }
668 }
669 break;
670 case SSH2_AGENTC_ADD_IDENTITY:
671 /*
672 * Add to the list and return SSH_AGENT_SUCCESS, or
673 * SSH_AGENT_FAILURE if the key was malformed.
674 */
675 {
676 struct ssh2_userkey *key;
677 char *comment, *alg;
678 int alglen, commlen;
679 int bloblen;
680
681 key = smalloc(sizeof(struct ssh2_userkey));
682
683 alglen = GET_32BIT(p);
684 p += 4;
685 alg = p;
686 p += alglen;
687 /* Add further algorithm names here. */
688 if (alglen == 7 && !memcmp(alg, "ssh-rsa", 7))
689 key->alg = &ssh_rsa;
690 else {
691 sfree(key);
692 goto failure;
693 }
694
695 bloblen =
696 GET_32BIT((unsigned char *) msg) - (p -
697 (unsigned char *) msg -
698 4);
699 key->data = key->alg->openssh_createkey(&p, &bloblen);
700 if (!key->data) {
701 sfree(key);
702 goto failure;
703 }
704 commlen = GET_32BIT(p);
705 p += 4;
706
707 comment = smalloc(commlen + 1);
708 if (comment) {
709 memcpy(comment, p, commlen);
710 comment[commlen] = '\0';
711 }
712 key->comment = comment;
713
714 PUT_32BIT(ret, 1);
715 ret[4] = SSH_AGENT_FAILURE;
716 if (add234(ssh2keys, key) == key) {
717 keylist_update();
718 ret[4] = SSH_AGENT_SUCCESS;
719 } else {
720 key->alg->freekey(key->data);
721 sfree(key->comment);
722 sfree(key);
723 }
724 }
725 break;
726 case SSH1_AGENTC_REMOVE_RSA_IDENTITY:
727 /*
728 * Remove from the list and return SSH_AGENT_SUCCESS, or
729 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
730 * start with.
731 */
732 {
733 struct RSAKey reqkey, *key;
734
735 p += makekey(p, &reqkey, NULL, 0);
736 key = find234(rsakeys, &reqkey, NULL);
737 freebn(reqkey.exponent);
738 freebn(reqkey.modulus);
739 PUT_32BIT(ret, 1);
740 ret[4] = SSH_AGENT_FAILURE;
741 if (key) {
742 del234(rsakeys, key);
743 keylist_update();
744 freersakey(key);
745 sfree(key);
746 ret[4] = SSH_AGENT_SUCCESS;
747 }
748 }
749 break;
750 case SSH2_AGENTC_REMOVE_IDENTITY:
751 /*
752 * Remove from the list and return SSH_AGENT_SUCCESS, or
753 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
754 * start with.
755 */
756 {
757 struct ssh2_userkey *key;
758 struct blob b;
759
760 b.len = GET_32BIT(p);
761 p += 4;
762 b.blob = p;
763 p += b.len;
764 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
765 if (!key)
766 goto failure;
767
768 PUT_32BIT(ret, 1);
769 ret[4] = SSH_AGENT_FAILURE;
770 if (key) {
771 del234(ssh2keys, key);
772 keylist_update();
773 key->alg->freekey(key->data);
774 sfree(key);
775 ret[4] = SSH_AGENT_SUCCESS;
776 }
777 }
778 break;
779 case SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES:
780 /*
781 * Remove all SSH1 keys. Always returns success.
782 */
783 {
784 struct RSAKey *rkey;
785
786 while ((rkey = index234(rsakeys, 0)) != NULL) {
787 del234(rsakeys, rkey);
788 freersakey(rkey);
789 sfree(rkey);
790 }
791 keylist_update();
792
793 PUT_32BIT(ret, 1);
794 ret[4] = SSH_AGENT_SUCCESS;
795 }
796 break;
797 case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
798 /*
799 * Remove all SSH2 keys. Always returns success.
800 */
801 {
802 struct ssh2_userkey *skey;
803
804 while ((skey = index234(ssh2keys, 0)) != NULL) {
805 del234(ssh2keys, skey);
806 skey->alg->freekey(skey->data);
807 sfree(skey);
808 }
809 keylist_update();
810
811 PUT_32BIT(ret, 1);
812 ret[4] = SSH_AGENT_SUCCESS;
813 }
814 break;
815 default:
816 failure:
817 /*
818 * Unrecognised message. Return SSH_AGENT_FAILURE.
819 */
820 PUT_32BIT(ret, 1);
821 ret[4] = SSH_AGENT_FAILURE;
822 break;
823 }
824 }
825
826 /*
827 * Key comparison function for the 2-3-4 tree of RSA keys.
828 */
829 static int cmpkeys_rsa(void *av, void *bv)
830 {
831 struct RSAKey *a = (struct RSAKey *) av;
832 struct RSAKey *b = (struct RSAKey *) bv;
833 Bignum am, bm;
834 int alen, blen;
835
836 am = a->modulus;
837 bm = b->modulus;
838 /*
839 * Compare by length of moduli.
840 */
841 alen = bignum_bitcount(am);
842 blen = bignum_bitcount(bm);
843 if (alen > blen)
844 return +1;
845 else if (alen < blen)
846 return -1;
847 /*
848 * Now compare by moduli themselves.
849 */
850 alen = (alen + 7) / 8; /* byte count */
851 while (alen-- > 0) {
852 int abyte, bbyte;
853 abyte = bignum_byte(am, alen);
854 bbyte = bignum_byte(bm, alen);
855 if (abyte > bbyte)
856 return +1;
857 else if (abyte < bbyte)
858 return -1;
859 }
860 /*
861 * Give up.
862 */
863 return 0;
864 }
865
866 /*
867 * Key comparison function for the 2-3-4 tree of SSH2 keys.
868 */
869 static int cmpkeys_ssh2(void *av, void *bv)
870 {
871 struct ssh2_userkey *a = (struct ssh2_userkey *) av;
872 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
873 int i;
874 int alen, blen;
875 unsigned char *ablob, *bblob;
876 int c;
877
878 /*
879 * Compare purely by public blob.
880 */
881 ablob = a->alg->public_blob(a->data, &alen);
882 bblob = b->alg->public_blob(b->data, &blen);
883
884 c = 0;
885 for (i = 0; i < alen && i < blen; i++) {
886 if (ablob[i] < bblob[i]) {
887 c = -1;
888 break;
889 } else if (ablob[i] > bblob[i]) {
890 c = +1;
891 break;
892 }
893 }
894 if (c == 0 && i < alen)
895 c = +1; /* a is longer */
896 if (c == 0 && i < blen)
897 c = -1; /* a is longer */
898
899 sfree(ablob);
900 sfree(bblob);
901
902 return c;
903 }
904
905 /*
906 * Key comparison function for looking up a blob in the 2-3-4 tree
907 * of SSH2 keys.
908 */
909 static int cmpkeys_ssh2_asymm(void *av, void *bv)
910 {
911 struct blob *a = (struct blob *) av;
912 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
913 int i;
914 int alen, blen;
915 unsigned char *ablob, *bblob;
916 int c;
917
918 /*
919 * Compare purely by public blob.
920 */
921 ablob = a->blob;
922 alen = a->len;
923 bblob = b->alg->public_blob(b->data, &blen);
924
925 c = 0;
926 for (i = 0; i < alen && i < blen; i++) {
927 if (ablob[i] < bblob[i]) {
928 c = -1;
929 break;
930 } else if (ablob[i] > bblob[i]) {
931 c = +1;
932 break;
933 }
934 }
935 if (c == 0 && i < alen)
936 c = +1; /* a is longer */
937 if (c == 0 && i < blen)
938 c = -1; /* a is longer */
939
940 sfree(bblob);
941
942 return c;
943 }
944
945 /*
946 * Prompt for a key file to add, and add it.
947 */
948 static void prompt_add_keyfile(void)
949 {
950 OPENFILENAME of;
951 char filename[FILENAME_MAX];
952 memset(&of, 0, sizeof(of));
953 #ifdef OPENFILENAME_SIZE_VERSION_400
954 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
955 #else
956 of.lStructSize = sizeof(of);
957 #endif
958 of.hwndOwner = hwnd;
959 of.lpstrFilter = "All Files\0*\0\0\0";
960 of.lpstrCustomFilter = NULL;
961 of.nFilterIndex = 1;
962 of.lpstrFile = filename;
963 *filename = '\0';
964 of.nMaxFile = sizeof(filename);
965 of.lpstrFileTitle = NULL;
966 of.lpstrInitialDir = NULL;
967 of.lpstrTitle = "Select Private Key File";
968 of.Flags = 0;
969 if (GetOpenFileName(&of)) {
970 add_keyfile(filename);
971 keylist_update();
972 }
973 }
974
975 /*
976 * Dialog-box function for the key list box.
977 */
978 static int CALLBACK KeyListProc(HWND hwnd, UINT msg,
979 WPARAM wParam, LPARAM lParam)
980 {
981 struct RSAKey *rkey;
982 struct ssh2_userkey *skey;
983
984 switch (msg) {
985 case WM_INITDIALOG:
986 /*
987 * Centre the window.
988 */
989 { /* centre the window */
990 RECT rs, rd;
991 HWND hw;
992
993 hw = GetDesktopWindow();
994 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
995 MoveWindow(hwnd,
996 (rs.right + rs.left + rd.left - rd.right) / 2,
997 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
998 rd.right - rd.left, rd.bottom - rd.top, TRUE);
999 }
1000
1001 keylist = hwnd;
1002 {
1003 static int tabs[] = { 35, 60, 210 };
1004 SendDlgItemMessage(hwnd, 100, LB_SETTABSTOPS,
1005 sizeof(tabs) / sizeof(*tabs),
1006 (LPARAM) tabs);
1007 }
1008 keylist_update();
1009 return 0;
1010 case WM_COMMAND:
1011 switch (LOWORD(wParam)) {
1012 case IDOK:
1013 case IDCANCEL:
1014 keylist = NULL;
1015 DestroyWindow(hwnd);
1016 return 0;
1017 case 101: /* add key */
1018 if (HIWORD(wParam) == BN_CLICKED ||
1019 HIWORD(wParam) == BN_DOUBLECLICKED) {
1020 prompt_add_keyfile();
1021 }
1022 return 0;
1023 case 102: /* remove key */
1024 if (HIWORD(wParam) == BN_CLICKED ||
1025 HIWORD(wParam) == BN_DOUBLECLICKED) {
1026 int n = SendDlgItemMessage(hwnd, 100, LB_GETCURSEL, 0, 0);
1027 int i;
1028 if (n == LB_ERR) {
1029 MessageBeep(0);
1030 break;
1031 }
1032 for (i = 0; NULL != (rkey = index234(rsakeys, i)); i++)
1033 if (n-- == 0)
1034 break;
1035 if (rkey) {
1036 del234(rsakeys, rkey);
1037 freersakey(rkey);
1038 sfree(rkey);
1039 } else {
1040 for (i = 0; NULL != (skey = index234(ssh2keys, i));
1041 i++) if (n-- == 0)
1042 break;
1043 if (skey) {
1044 del234(ssh2keys, skey);
1045 skey->alg->freekey(skey->data);
1046 sfree(skey);
1047 }
1048 }
1049 keylist_update();
1050 }
1051 return 0;
1052 }
1053 return 0;
1054 case WM_CLOSE:
1055 keylist = NULL;
1056 DestroyWindow(hwnd);
1057 return 0;
1058 }
1059 return 0;
1060 }
1061
1062 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1063 WPARAM wParam, LPARAM lParam)
1064 {
1065 int ret;
1066 static int menuinprogress;
1067
1068 switch (message) {
1069 case WM_SYSTRAY:
1070 if (lParam == WM_RBUTTONUP) {
1071 POINT cursorpos;
1072 GetCursorPos(&cursorpos);
1073 PostMessage(hwnd, WM_SYSTRAY2, cursorpos.x, cursorpos.y);
1074 } else if (lParam == WM_LBUTTONDBLCLK) {
1075 /* Equivalent to IDM_VIEWKEYS. */
1076 PostMessage(hwnd, WM_COMMAND, IDM_VIEWKEYS, 0);
1077 }
1078 break;
1079 case WM_SYSTRAY2:
1080 if (!menuinprogress) {
1081 menuinprogress = 1;
1082 SetForegroundWindow(hwnd);
1083 ret = TrackPopupMenu(systray_menu,
1084 TPM_RIGHTALIGN | TPM_BOTTOMALIGN |
1085 TPM_RIGHTBUTTON,
1086 wParam, lParam, 0, hwnd, NULL);
1087 menuinprogress = 0;
1088 }
1089 break;
1090 case WM_COMMAND:
1091 case WM_SYSCOMMAND:
1092 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1093 case IDM_CLOSE:
1094 SendMessage(hwnd, WM_CLOSE, 0, 0);
1095 break;
1096 case IDM_VIEWKEYS:
1097 if (!keylist) {
1098 keylist = CreateDialog(instance, MAKEINTRESOURCE(211),
1099 NULL, KeyListProc);
1100 ShowWindow(keylist, SW_SHOWNORMAL);
1101 /*
1102 * Sometimes the window comes up minimised / hidden
1103 * for no obvious reason. Prevent this.
1104 */
1105 SetForegroundWindow(keylist);
1106 SetWindowPos(keylist, HWND_TOP, 0, 0, 0, 0,
1107 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1108 }
1109 break;
1110 case IDM_ADDKEY:
1111 prompt_add_keyfile();
1112 break;
1113 case IDM_ABOUT:
1114 if (!aboutbox) {
1115 aboutbox = CreateDialog(instance, MAKEINTRESOURCE(213),
1116 NULL, AboutProc);
1117 ShowWindow(aboutbox, SW_SHOWNORMAL);
1118 /*
1119 * Sometimes the window comes up minimised / hidden
1120 * for no obvious reason. Prevent this.
1121 */
1122 SetForegroundWindow(aboutbox);
1123 SetWindowPos(aboutbox, HWND_TOP, 0, 0, 0, 0,
1124 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1125 }
1126 break;
1127 }
1128 break;
1129 case WM_DESTROY:
1130 PostQuitMessage(0);
1131 return 0;
1132 case WM_COPYDATA:
1133 {
1134 COPYDATASTRUCT *cds;
1135 char *mapname;
1136 void *p;
1137 HANDLE filemap;
1138 #ifndef NO_SECURITY
1139 HANDLE proc;
1140 PSID mapowner, procowner;
1141 PSECURITY_DESCRIPTOR psd1 = NULL, psd2 = NULL;
1142 #endif
1143 int ret = 0;
1144
1145 cds = (COPYDATASTRUCT *) lParam;
1146 if (cds->dwData != AGENT_COPYDATA_ID)
1147 return 0; /* not our message, mate */
1148 mapname = (char *) cds->lpData;
1149 if (mapname[cds->cbData - 1] != '\0')
1150 return 0; /* failure to be ASCIZ! */
1151 #ifdef DEBUG_IPC
1152 debug(("mapname is :%s:\n", mapname));
1153 #endif
1154 filemap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, mapname);
1155 #ifdef DEBUG_IPC
1156 debug(("filemap is %p\n", filemap));
1157 #endif
1158 if (filemap != NULL && filemap != INVALID_HANDLE_VALUE) {
1159 #ifndef NO_SECURITY
1160 int rc;
1161 if (has_security) {
1162 if ((proc = OpenProcess(MAXIMUM_ALLOWED, FALSE,
1163 GetCurrentProcessId())) ==
1164 NULL) {
1165 #ifdef DEBUG_IPC
1166 debug(("couldn't get handle for process\n"));
1167 #endif
1168 return 0;
1169 }
1170 if (getsecurityinfo(proc, SE_KERNEL_OBJECT,
1171 OWNER_SECURITY_INFORMATION,
1172 &procowner, NULL, NULL, NULL,
1173 &psd2) != ERROR_SUCCESS) {
1174 #ifdef DEBUG_IPC
1175 debug(("couldn't get owner info for process\n"));
1176 #endif
1177 CloseHandle(proc);
1178 return 0; /* unable to get security info */
1179 }
1180 CloseHandle(proc);
1181 if ((rc = getsecurityinfo(filemap, SE_KERNEL_OBJECT,
1182 OWNER_SECURITY_INFORMATION,
1183 &mapowner, NULL, NULL, NULL,
1184 &psd1) != ERROR_SUCCESS)) {
1185 #ifdef DEBUG_IPC
1186 debug(
1187 ("couldn't get owner info for filemap: %d\n",
1188 rc));
1189 #endif
1190 return 0;
1191 }
1192 #ifdef DEBUG_IPC
1193 debug(("got security stuff\n"));
1194 #endif
1195 if (!EqualSid(mapowner, procowner))
1196 return 0; /* security ID mismatch! */
1197 #ifdef DEBUG_IPC
1198 debug(("security stuff matched\n"));
1199 #endif
1200 LocalFree(psd1);
1201 LocalFree(psd2);
1202 } else {
1203 #ifdef DEBUG_IPC
1204 debug(("security APIs not present\n"));
1205 #endif
1206 }
1207 #endif
1208 p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
1209 #ifdef DEBUG_IPC
1210 debug(("p is %p\n", p));
1211 {
1212 int i;
1213 for (i = 0; i < 5; i++)
1214 debug(
1215 ("p[%d]=%02x\n", i,
1216 ((unsigned char *) p)[i]));}
1217 #endif
1218 answer_msg(p);
1219 ret = 1;
1220 UnmapViewOfFile(p);
1221 }
1222 CloseHandle(filemap);
1223 return ret;
1224 }
1225 }
1226
1227 return DefWindowProc(hwnd, message, wParam, lParam);
1228 }
1229
1230 /*
1231 * Fork and Exec the command in cmdline. [DBW]
1232 */
1233 void spawn_cmd(char *cmdline, int show)
1234 {
1235 if (ShellExecute(NULL, _T("open"), cmdline,
1236 NULL, NULL, show) <= (HINSTANCE) 32) {
1237 TCHAR sMsg[140];
1238 sprintf(sMsg, _T("Failed to run \"%.100s\", Error: %d"), cmdline,
1239 (int)GetLastError());
1240 MessageBox(NULL, sMsg, APPNAME, MB_OK | MB_ICONEXCLAMATION);
1241 }
1242 }
1243
1244 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1245 {
1246 WNDCLASS wndclass;
1247 MSG msg;
1248 OSVERSIONINFO osi;
1249 HMODULE advapi;
1250 char *command = NULL;
1251 int added_keys = 0;
1252
1253 /*
1254 * Determine whether we're an NT system (should have security
1255 * APIs) or a non-NT system (don't do security).
1256 */
1257 memset(&osi, 0, sizeof(OSVERSIONINFO));
1258 osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1259 if (GetVersionEx(&osi) && osi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1260 has_security = TRUE;
1261 } else
1262 has_security = FALSE;
1263
1264 if (has_security) {
1265 #ifndef NO_SECURITY
1266 /*
1267 * Attempt to get the security API we need.
1268 */
1269 advapi = LoadLibrary("ADVAPI32.DLL");
1270 getsecurityinfo =
1271 (gsi_fn_t) GetProcAddress(advapi, "GetSecurityInfo");
1272 if (!getsecurityinfo) {
1273 MessageBox(NULL,
1274 "Unable to access security APIs. Pageant will\n"
1275 "not run, in case it causes a security breach.",
1276 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1277 return 1;
1278 }
1279 #else
1280 MessageBox(NULL,
1281 "This program has been compiled for Win9X and will\n"
1282 "not run on NT, in case it causes a security breach.",
1283 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1284 return 1;
1285 #endif
1286 } else
1287 advapi = NULL;
1288
1289 instance = inst;
1290
1291 /*
1292 * Find out if Pageant is already running.
1293 */
1294 already_running = FALSE;
1295 if (agent_exists())
1296 already_running = TRUE;
1297 else {
1298
1299 if (!prev) {
1300 wndclass.style = 0;
1301 wndclass.lpfnWndProc = WndProc;
1302 wndclass.cbClsExtra = 0;
1303 wndclass.cbWndExtra = 0;
1304 wndclass.hInstance = inst;
1305 wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
1306 wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM);
1307 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1308 wndclass.lpszMenuName = NULL;
1309 wndclass.lpszClassName = APPNAME;
1310
1311 RegisterClass(&wndclass);
1312 }
1313
1314 hwnd = keylist = NULL;
1315
1316 hwnd = CreateWindow(APPNAME, APPNAME,
1317 WS_OVERLAPPEDWINDOW | WS_VSCROLL,
1318 CW_USEDEFAULT, CW_USEDEFAULT,
1319 100, 100, NULL, NULL, inst, NULL);
1320
1321 /* Set up a system tray icon */
1322 {
1323 BOOL res;
1324 NOTIFYICONDATA tnid;
1325 HICON hicon;
1326
1327 #ifdef NIM_SETVERSION
1328 tnid.uVersion = 0;
1329 res = Shell_NotifyIcon(NIM_SETVERSION, &tnid);
1330 #endif
1331
1332 tnid.cbSize = sizeof(NOTIFYICONDATA);
1333 tnid.hWnd = hwnd;
1334 tnid.uID = 1; /* unique within this systray use */
1335 tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
1336 tnid.uCallbackMessage = WM_SYSTRAY;
1337 tnid.hIcon = hicon = LoadIcon(instance, MAKEINTRESOURCE(201));
1338 strcpy(tnid.szTip, "Pageant (PuTTY authentication agent)");
1339
1340 res = Shell_NotifyIcon(NIM_ADD, &tnid);
1341
1342 if (hicon)
1343 DestroyIcon(hicon);
1344
1345 systray_menu = CreatePopupMenu();
1346 /* accelerators used: vkxa */
1347 AppendMenu(systray_menu, MF_ENABLED, IDM_VIEWKEYS,
1348 "&View Keys");
1349 AppendMenu(systray_menu, MF_ENABLED, IDM_ADDKEY, "Add &Key");
1350 AppendMenu(systray_menu, MF_ENABLED, IDM_ABOUT, "&About");
1351 AppendMenu(systray_menu, MF_ENABLED, IDM_CLOSE, "E&xit");
1352 }
1353
1354 ShowWindow(hwnd, SW_HIDE);
1355
1356 /*
1357 * Initialise storage for RSA keys.
1358 */
1359 rsakeys = newtree234(cmpkeys_rsa);
1360 ssh2keys = newtree234(cmpkeys_ssh2);
1361
1362 }
1363
1364 /*
1365 * Process the command line and add keys as listed on it.
1366 * If we already determined that we need to spawn a program from above we
1367 * need to ignore the first two arguments. [DBW]
1368 */
1369 {
1370 char *p;
1371 int inquotes = 0;
1372 p = cmdline;
1373 while (*p) {
1374 while (*p && isspace(*p))
1375 p++;
1376 if (*p && !isspace(*p)) {
1377 char *q = p, *pp = p;
1378 while (*p && (inquotes || !isspace(*p))) {
1379 if (*p == '"') {
1380 inquotes = !inquotes;
1381 p++;
1382 continue;
1383 }
1384 *pp++ = *p++;
1385 }
1386 if (*pp) {
1387 if (*p)
1388 p++;
1389 *pp++ = '\0';
1390 }
1391 if (!strcmp(q, "-c")) {
1392 /*
1393 * If we see `-c', then the rest of the
1394 * command line should be treated as a
1395 * command to be spawned.
1396 */
1397 while (*p && isspace(*p))
1398 p++;
1399 command = p;
1400 break;
1401 } else {
1402 add_keyfile(q);
1403 added_keys = TRUE;
1404 }
1405 }
1406 }
1407 }
1408
1409 if (command)
1410 spawn_cmd(command, show);
1411
1412 /*
1413 * If Pageant was already running, we leave now. If we haven't
1414 * even taken any auxiliary action (spawned a command or added
1415 * keys), complain.
1416 */
1417 if (already_running) {
1418 if (!command && !added_keys) {
1419 MessageBox(NULL, "Pageant is already running", "Pageant Error",
1420 MB_ICONERROR | MB_OK);
1421 }
1422 if (advapi)
1423 FreeLibrary(advapi);
1424 return 0;
1425 }
1426
1427 /*
1428 * Main message loop.
1429 */
1430 while (GetMessage(&msg, NULL, 0, 0) == 1) {
1431 TranslateMessage(&msg);
1432 DispatchMessage(&msg);
1433 }
1434
1435 /* Clean up the system tray icon */
1436 {
1437 NOTIFYICONDATA tnid;
1438
1439 tnid.cbSize = sizeof(NOTIFYICONDATA);
1440 tnid.hWnd = hwnd;
1441 tnid.uID = 1;
1442
1443 Shell_NotifyIcon(NIM_DELETE, &tnid);
1444
1445 DestroyMenu(systray_menu);
1446 }
1447
1448 if (advapi)
1449 FreeLibrary(advapi);
1450 exit(msg.wParam);
1451 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator