projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Run entire source base through GNU indent to tidy up the varying
[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;
298 struct ssh2_userkey *skey;
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 int reqlen, clen, resplen;
362
363 clen = strlen(rkey->comment);
364
365 reqlen = 4 + 1 + /* length, message type */
366 4 + /* bit count */
367 ssh1_bignum_length(rkey->modulus) +
368 ssh1_bignum_length(rkey->exponent) +
369 ssh1_bignum_length(rkey->private_exponent) +
370 ssh1_bignum_length(rkey->iqmp) +
371 ssh1_bignum_length(rkey->p) +
372 ssh1_bignum_length(rkey->q) + 4 + clen /* comment */
373 ;
374
375 request = smalloc(reqlen);
376
377 request[4] = SSH1_AGENTC_ADD_RSA_IDENTITY;
378 reqlen = 5;
379 PUT_32BIT(request + reqlen, bignum_bitcount(rkey->modulus));
380 reqlen += 4;
381 reqlen += ssh1_write_bignum(request + reqlen, rkey->modulus);
382 reqlen += ssh1_write_bignum(request + reqlen, rkey->exponent);
383 reqlen +=
384 ssh1_write_bignum(request + reqlen,
385 rkey->private_exponent);
386 reqlen += ssh1_write_bignum(request + reqlen, rkey->iqmp);
387 reqlen += ssh1_write_bignum(request + reqlen, rkey->p);
388 reqlen += ssh1_write_bignum(request + reqlen, rkey->q);
389 PUT_32BIT(request + reqlen, clen);
390 memcpy(request + reqlen + 4, rkey->comment, clen);
391 reqlen += 4 + clen;
392 PUT_32BIT(request, reqlen - 4);
393
394 agent_query(request, reqlen, &response, &resplen);
395 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
396 MessageBox(NULL, "The already running Pageant "
397 "refused to add the key.", APPNAME,
398 MB_OK | MB_ICONERROR);
399 } else {
400 if (add234(rsakeys, rkey) != rkey)
401 sfree(rkey); /* already present, don't waste RAM */
402 }
403 } else {
404 if (already_running) {
405 unsigned char *request, *response;
406 int reqlen, alglen, clen, keybloblen, resplen;
407 alglen = strlen(skey->alg->name);
408 clen = strlen(skey->comment);
409
410 keybloblen = skey->alg->openssh_fmtkey(skey->data, NULL, 0);
411
412 reqlen = 4 + 1 + /* length, message type */
413 4 + alglen + /* algorithm name */
414 keybloblen + /* key data */
415 4 + clen /* comment */
416 ;
417
418 request = smalloc(reqlen);
419
420 request[4] = SSH2_AGENTC_ADD_IDENTITY;
421 reqlen = 5;
422 PUT_32BIT(request + reqlen, alglen);
423 reqlen += 4;
424 memcpy(request + reqlen, skey->alg->name, alglen);
425 reqlen += alglen;
426 reqlen += skey->alg->openssh_fmtkey(skey->data,
427 request + reqlen,
428 keybloblen);
429 PUT_32BIT(request + reqlen, clen);
430 memcpy(request + reqlen + 4, skey->comment, clen);
431 PUT_32BIT(request, reqlen - 4);
432 reqlen += clen + 4;
433
434 agent_query(request, reqlen, &response, &resplen);
435 if (resplen < 5 || response[4] != SSH_AGENT_SUCCESS)
436 MessageBox(NULL, "The already running Pageant"
437 "refused to add the key.", APPNAME,
438 MB_OK | MB_ICONERROR);
439 } else {
440 if (add234(ssh2keys, skey) != skey) {
441 skey->alg->freekey(skey->data);
442 sfree(skey); /* already present, don't waste RAM */
443 }
444 }
445 }
446 }
447
448 /*
449 * This is the main agent function that answers messages.
450 */
451 static void answer_msg(void *msg)
452 {
453 unsigned char *p = msg;
454 unsigned char *ret = msg;
455 int type;
456
457 /*
458 * Get the message type.
459 */
460 type = p[4];
461
462 p += 5;
463 switch (type) {
464 case SSH1_AGENTC_REQUEST_RSA_IDENTITIES:
465 /*
466 * Reply with SSH1_AGENT_RSA_IDENTITIES_ANSWER.
467 */
468 {
469 struct RSAKey *key;
470 int len, nkeys;
471 int i;
472
473 /*
474 * Count up the number and length of keys we hold.
475 */
476 len = nkeys = 0;
477 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
478 nkeys++;
479 len += 4; /* length field */
480 len += ssh1_bignum_length(key->exponent);
481 len += ssh1_bignum_length(key->modulus);
482 len += 4 + strlen(key->comment);
483 }
484
485 /*
486 * Packet header is the obvious five bytes, plus four
487 * bytes for the key count.
488 */
489 len += 5 + 4;
490 if (len > AGENT_MAX_MSGLEN)
491 goto failure; /* aaargh! too much stuff! */
492 PUT_32BIT(ret, len - 4);
493 ret[4] = SSH1_AGENT_RSA_IDENTITIES_ANSWER;
494 PUT_32BIT(ret + 5, nkeys);
495 p = ret + 5 + 4;
496 for (i = 0; NULL != (key = index234(rsakeys, i)); i++) {
497 PUT_32BIT(p, bignum_bitcount(key->modulus));
498 p += 4;
499 p += ssh1_write_bignum(p, key->exponent);
500 p += ssh1_write_bignum(p, key->modulus);
501 PUT_32BIT(p, strlen(key->comment));
502 memcpy(p + 4, key->comment, strlen(key->comment));
503 p += 4 + strlen(key->comment);
504 }
505 }
506 break;
507 case SSH2_AGENTC_REQUEST_IDENTITIES:
508 /*
509 * Reply with SSH2_AGENT_IDENTITIES_ANSWER.
510 */
511 {
512 struct ssh2_userkey *key;
513 int len, nkeys;
514 unsigned char *blob;
515 int bloblen;
516 int i;
517
518 /*
519 * Count up the number and length of keys we hold.
520 */
521 len = nkeys = 0;
522 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
523 nkeys++;
524 len += 4; /* length field */
525 blob = key->alg->public_blob(key->data, &bloblen);
526 len += bloblen;
527 sfree(blob);
528 len += 4 + strlen(key->comment);
529 }
530
531 /*
532 * Packet header is the obvious five bytes, plus four
533 * bytes for the key count.
534 */
535 len += 5 + 4;
536 if (len > AGENT_MAX_MSGLEN)
537 goto failure; /* aaargh! too much stuff! */
538 PUT_32BIT(ret, len - 4);
539 ret[4] = SSH2_AGENT_IDENTITIES_ANSWER;
540 PUT_32BIT(ret + 5, nkeys);
541 p = ret + 5 + 4;
542 for (i = 0; NULL != (key = index234(ssh2keys, i)); i++) {
543 blob = key->alg->public_blob(key->data, &bloblen);
544 PUT_32BIT(p, bloblen);
545 p += 4;
546 memcpy(p, blob, bloblen);
547 p += bloblen;
548 sfree(blob);
549 PUT_32BIT(p, strlen(key->comment));
550 memcpy(p + 4, key->comment, strlen(key->comment));
551 p += 4 + strlen(key->comment);
552 }
553 }
554 break;
555 case SSH1_AGENTC_RSA_CHALLENGE:
556 /*
557 * Reply with either SSH1_AGENT_RSA_RESPONSE or
558 * SSH_AGENT_FAILURE, depending on whether we have that key
559 * or not.
560 */
561 {
562 struct RSAKey reqkey, *key;
563 Bignum challenge, response;
564 unsigned char response_source[48], response_md5[16];
565 struct MD5Context md5c;
566 int i, len;
567
568 p += 4;
569 p += ssh1_read_bignum(p, &reqkey.exponent);
570 p += ssh1_read_bignum(p, &reqkey.modulus);
571 p += ssh1_read_bignum(p, &challenge);
572 memcpy(response_source + 32, p, 16);
573 p += 16;
574 if (GET_32BIT(p) != 1 ||
575 (key = find234(rsakeys, &reqkey, NULL)) == NULL) {
576 freebn(reqkey.exponent);
577 freebn(reqkey.modulus);
578 freebn(challenge);
579 goto failure;
580 }
581 response = rsadecrypt(challenge, key);
582 for (i = 0; i < 32; i++)
583 response_source[i] = bignum_byte(response, 31 - i);
584
585 MD5Init(&md5c);
586 MD5Update(&md5c, response_source, 48);
587 MD5Final(response_md5, &md5c);
588 memset(response_source, 0, 48); /* burn the evidence */
589 freebn(response); /* and that evidence */
590 freebn(challenge); /* yes, and that evidence */
591 freebn(reqkey.exponent); /* and free some memory ... */
592 freebn(reqkey.modulus); /* ... while we're at it. */
593
594 /*
595 * Packet is the obvious five byte header, plus sixteen
596 * bytes of MD5.
597 */
598 len = 5 + 16;
599 PUT_32BIT(ret, len - 4);
600 ret[4] = SSH1_AGENT_RSA_RESPONSE;
601 memcpy(ret + 5, response_md5, 16);
602 }
603 break;
604 case SSH2_AGENTC_SIGN_REQUEST:
605 /*
606 * Reply with either SSH2_AGENT_RSA_RESPONSE or
607 * SSH_AGENT_FAILURE, depending on whether we have that key
608 * or not.
609 */
610 {
611 struct ssh2_userkey *key;
612 struct blob b;
613 unsigned char *data, *signature;
614 int datalen, siglen, len;
615
616 b.len = GET_32BIT(p);
617 p += 4;
618 b.blob = p;
619 p += b.len;
620 datalen = GET_32BIT(p);
621 p += 4;
622 data = p;
623 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
624 if (!key)
625 goto failure;
626 signature = key->alg->sign(key->data, data, datalen, &siglen);
627 len = 5 + 4 + siglen;
628 PUT_32BIT(ret, len - 4);
629 ret[4] = SSH2_AGENT_SIGN_RESPONSE;
630 PUT_32BIT(ret + 5, siglen);
631 memcpy(ret + 5 + 4, signature, siglen);
632 sfree(signature);
633 }
634 break;
635 case SSH1_AGENTC_ADD_RSA_IDENTITY:
636 /*
637 * Add to the list and return SSH_AGENT_SUCCESS, or
638 * SSH_AGENT_FAILURE if the key was malformed.
639 */
640 {
641 struct RSAKey *key;
642 char *comment;
643 key = smalloc(sizeof(struct RSAKey));
644 memset(key, 0, sizeof(key));
645 p += makekey(p, key, NULL, 1);
646 p += makeprivate(p, key);
647 p += ssh1_read_bignum(p, key->iqmp); /* p^-1 mod q */
648 p += ssh1_read_bignum(p, key->p); /* p */
649 p += ssh1_read_bignum(p, key->q); /* q */
650 comment = smalloc(GET_32BIT(p));
651 if (comment) {
652 memcpy(comment, p + 4, GET_32BIT(p));
653 key->comment = comment;
654 }
655 PUT_32BIT(ret, 1);
656 ret[4] = SSH_AGENT_FAILURE;
657 if (add234(rsakeys, key) == key) {
658 keylist_update();
659 ret[4] = SSH_AGENT_SUCCESS;
660 } else {
661 freersakey(key);
662 sfree(key);
663 }
664 }
665 break;
666 case SSH2_AGENTC_ADD_IDENTITY:
667 /*
668 * Add to the list and return SSH_AGENT_SUCCESS, or
669 * SSH_AGENT_FAILURE if the key was malformed.
670 */
671 {
672 struct ssh2_userkey *key;
673 char *comment, *alg;
674 int alglen, commlen;
675 int bloblen;
676
677 key = smalloc(sizeof(struct ssh2_userkey));
678
679 alglen = GET_32BIT(p);
680 p += 4;
681 alg = p;
682 p += alglen;
683 /* Add further algorithm names here. */
684 if (alglen == 7 && !memcmp(alg, "ssh-rsa", 7))
685 key->alg = &ssh_rsa;
686 else {
687 sfree(key);
688 goto failure;
689 }
690
691 bloblen =
692 GET_32BIT((unsigned char *) msg) - (p -
693 (unsigned char *) msg -
694 4);
695 key->data = key->alg->openssh_createkey(&p, &bloblen);
696 if (!key->data) {
697 sfree(key);
698 goto failure;
699 }
700 commlen = GET_32BIT(p);
701 p += 4;
702
703 comment = smalloc(commlen + 1);
704 if (comment) {
705 memcpy(comment, p, commlen);
706 comment[commlen] = '\0';
707 }
708 key->comment = comment;
709
710 PUT_32BIT(ret, 1);
711 ret[4] = SSH_AGENT_FAILURE;
712 if (add234(ssh2keys, key) == key) {
713 keylist_update();
714 ret[4] = SSH_AGENT_SUCCESS;
715 } else {
716 key->alg->freekey(key->data);
717 sfree(key->comment);
718 sfree(key);
719 }
720 }
721 break;
722 case SSH1_AGENTC_REMOVE_RSA_IDENTITY:
723 /*
724 * Remove from the list and return SSH_AGENT_SUCCESS, or
725 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
726 * start with.
727 */
728 {
729 struct RSAKey reqkey, *key;
730
731 p += makekey(p, &reqkey, NULL, 0);
732 key = find234(rsakeys, &reqkey, NULL);
733 freebn(reqkey.exponent);
734 freebn(reqkey.modulus);
735 PUT_32BIT(ret, 1);
736 ret[4] = SSH_AGENT_FAILURE;
737 if (key) {
738 del234(rsakeys, key);
739 keylist_update();
740 freersakey(key);
741 sfree(key);
742 ret[4] = SSH_AGENT_SUCCESS;
743 }
744 }
745 break;
746 case SSH2_AGENTC_REMOVE_IDENTITY:
747 /*
748 * Remove from the list and return SSH_AGENT_SUCCESS, or
749 * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
750 * start with.
751 */
752 {
753 struct ssh2_userkey *key;
754 struct blob b;
755
756 b.len = GET_32BIT(p);
757 p += 4;
758 b.blob = p;
759 p += b.len;
760 key = find234(ssh2keys, &b, cmpkeys_ssh2_asymm);
761 if (!key)
762 goto failure;
763
764 PUT_32BIT(ret, 1);
765 ret[4] = SSH_AGENT_FAILURE;
766 if (key) {
767 del234(ssh2keys, key);
768 keylist_update();
769 key->alg->freekey(key->data);
770 sfree(key);
771 ret[4] = SSH_AGENT_SUCCESS;
772 }
773 }
774 break;
775 case SSH1_AGENTC_REMOVE_ALL_RSA_IDENTITIES:
776 /*
777 * Remove all SSH1 keys. Always returns success.
778 */
779 {
780 struct RSAKey *rkey;
781
782 while ((rkey = index234(rsakeys, 0)) != NULL) {
783 del234(rsakeys, rkey);
784 freersakey(rkey);
785 sfree(rkey);
786 }
787 keylist_update();
788
789 PUT_32BIT(ret, 1);
790 ret[4] = SSH_AGENT_SUCCESS;
791 }
792 break;
793 case SSH2_AGENTC_REMOVE_ALL_IDENTITIES:
794 /*
795 * Remove all SSH2 keys. Always returns success.
796 */
797 {
798 struct ssh2_userkey *skey;
799
800 while ((skey = index234(ssh2keys, 0)) != NULL) {
801 del234(ssh2keys, skey);
802 skey->alg->freekey(skey->data);
803 sfree(skey);
804 }
805 keylist_update();
806
807 PUT_32BIT(ret, 1);
808 ret[4] = SSH_AGENT_SUCCESS;
809 }
810 break;
811 default:
812 failure:
813 /*
814 * Unrecognised message. Return SSH_AGENT_FAILURE.
815 */
816 PUT_32BIT(ret, 1);
817 ret[4] = SSH_AGENT_FAILURE;
818 break;
819 }
820 }
821
822 /*
823 * Key comparison function for the 2-3-4 tree of RSA keys.
824 */
825 static int cmpkeys_rsa(void *av, void *bv)
826 {
827 struct RSAKey *a = (struct RSAKey *) av;
828 struct RSAKey *b = (struct RSAKey *) bv;
829 Bignum am, bm;
830 int alen, blen;
831
832 am = a->modulus;
833 bm = b->modulus;
834 /*
835 * Compare by length of moduli.
836 */
837 alen = bignum_bitcount(am);
838 blen = bignum_bitcount(bm);
839 if (alen > blen)
840 return +1;
841 else if (alen < blen)
842 return -1;
843 /*
844 * Now compare by moduli themselves.
845 */
846 alen = (alen + 7) / 8; /* byte count */
847 while (alen-- > 0) {
848 int abyte, bbyte;
849 abyte = bignum_byte(am, alen);
850 bbyte = bignum_byte(bm, alen);
851 if (abyte > bbyte)
852 return +1;
853 else if (abyte < bbyte)
854 return -1;
855 }
856 /*
857 * Give up.
858 */
859 return 0;
860 }
861
862 /*
863 * Key comparison function for the 2-3-4 tree of SSH2 keys.
864 */
865 static int cmpkeys_ssh2(void *av, void *bv)
866 {
867 struct ssh2_userkey *a = (struct ssh2_userkey *) av;
868 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
869 int i;
870 int alen, blen;
871 unsigned char *ablob, *bblob;
872 int c;
873
874 /*
875 * Compare purely by public blob.
876 */
877 ablob = a->alg->public_blob(a->data, &alen);
878 bblob = b->alg->public_blob(b->data, &blen);
879
880 c = 0;
881 for (i = 0; i < alen && i < blen; i++) {
882 if (ablob[i] < bblob[i]) {
883 c = -1;
884 break;
885 } else if (ablob[i] > bblob[i]) {
886 c = +1;
887 break;
888 }
889 }
890 if (c == 0 && i < alen)
891 c = +1; /* a is longer */
892 if (c == 0 && i < blen)
893 c = -1; /* a is longer */
894
895 sfree(ablob);
896 sfree(bblob);
897
898 return c;
899 }
900
901 /*
902 * Key comparison function for looking up a blob in the 2-3-4 tree
903 * of SSH2 keys.
904 */
905 static int cmpkeys_ssh2_asymm(void *av, void *bv)
906 {
907 struct blob *a = (struct blob *) av;
908 struct ssh2_userkey *b = (struct ssh2_userkey *) bv;
909 int i;
910 int alen, blen;
911 unsigned char *ablob, *bblob;
912 int c;
913
914 /*
915 * Compare purely by public blob.
916 */
917 ablob = a->blob;
918 alen = a->len;
919 bblob = b->alg->public_blob(b->data, &blen);
920
921 c = 0;
922 for (i = 0; i < alen && i < blen; i++) {
923 if (ablob[i] < bblob[i]) {
924 c = -1;
925 break;
926 } else if (ablob[i] > bblob[i]) {
927 c = +1;
928 break;
929 }
930 }
931 if (c == 0 && i < alen)
932 c = +1; /* a is longer */
933 if (c == 0 && i < blen)
934 c = -1; /* a is longer */
935
936 sfree(bblob);
937
938 return c;
939 }
940
941 static void error(char *s)
942 {
943 MessageBox(hwnd, s, APPNAME, MB_OK | MB_ICONERROR);
944 }
945
946 /*
947 * Prompt for a key file to add, and add it.
948 */
949 static void prompt_add_keyfile(void)
950 {
951 OPENFILENAME of;
952 char filename[FILENAME_MAX];
953 memset(&of, 0, sizeof(of));
954 #ifdef OPENFILENAME_SIZE_VERSION_400
955 of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
956 #else
957 of.lStructSize = sizeof(of);
958 #endif
959 of.hwndOwner = hwnd;
960 of.lpstrFilter = "All Files\0*\0\0\0";
961 of.lpstrCustomFilter = NULL;
962 of.nFilterIndex = 1;
963 of.lpstrFile = filename;
964 *filename = '\0';
965 of.nMaxFile = sizeof(filename);
966 of.lpstrFileTitle = NULL;
967 of.lpstrInitialDir = NULL;
968 of.lpstrTitle = "Select Private Key File";
969 of.Flags = 0;
970 if (GetOpenFileName(&of)) {
971 add_keyfile(filename);
972 keylist_update();
973 }
974 }
975
976 /*
977 * Dialog-box function for the key list box.
978 */
979 static int CALLBACK KeyListProc(HWND hwnd, UINT msg,
980 WPARAM wParam, LPARAM lParam)
981 {
982 struct RSAKey *rkey;
983 struct ssh2_userkey *skey;
984
985 switch (msg) {
986 case WM_INITDIALOG:
987 /*
988 * Centre the window.
989 */
990 { /* centre the window */
991 RECT rs, rd;
992 HWND hw;
993
994 hw = GetDesktopWindow();
995 if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
996 MoveWindow(hwnd,
997 (rs.right + rs.left + rd.left - rd.right) / 2,
998 (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
999 rd.right - rd.left, rd.bottom - rd.top, TRUE);
1000 }
1001
1002 keylist = hwnd;
1003 {
1004 static int tabs[] = { 35, 60, 210 };
1005 SendDlgItemMessage(hwnd, 100, LB_SETTABSTOPS,
1006 sizeof(tabs) / sizeof(*tabs),
1007 (LPARAM) tabs);
1008 }
1009 keylist_update();
1010 return 0;
1011 case WM_COMMAND:
1012 switch (LOWORD(wParam)) {
1013 case IDOK:
1014 case IDCANCEL:
1015 keylist = NULL;
1016 DestroyWindow(hwnd);
1017 return 0;
1018 case 101: /* add key */
1019 if (HIWORD(wParam) == BN_CLICKED ||
1020 HIWORD(wParam) == BN_DOUBLECLICKED) {
1021 prompt_add_keyfile();
1022 }
1023 return 0;
1024 case 102: /* remove key */
1025 if (HIWORD(wParam) == BN_CLICKED ||
1026 HIWORD(wParam) == BN_DOUBLECLICKED) {
1027 int n = SendDlgItemMessage(hwnd, 100, LB_GETCURSEL, 0, 0);
1028 int i;
1029 if (n == LB_ERR) {
1030 MessageBeep(0);
1031 break;
1032 }
1033 for (i = 0; NULL != (rkey = index234(rsakeys, i)); i++)
1034 if (n-- == 0)
1035 break;
1036 if (rkey) {
1037 del234(rsakeys, rkey);
1038 freersakey(rkey);
1039 sfree(rkey);
1040 } else {
1041 for (i = 0; NULL != (skey = index234(ssh2keys, i));
1042 i++) if (n-- == 0)
1043 break;
1044 if (skey) {
1045 del234(ssh2keys, skey);
1046 skey->alg->freekey(skey->data);
1047 sfree(skey);
1048 }
1049 }
1050 keylist_update();
1051 }
1052 return 0;
1053 }
1054 return 0;
1055 case WM_CLOSE:
1056 keylist = NULL;
1057 DestroyWindow(hwnd);
1058 return 0;
1059 }
1060 return 0;
1061 }
1062
1063 static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
1064 WPARAM wParam, LPARAM lParam)
1065 {
1066 int ret;
1067 static int menuinprogress;
1068
1069 switch (message) {
1070 case WM_SYSTRAY:
1071 if (lParam == WM_RBUTTONUP) {
1072 POINT cursorpos;
1073 GetCursorPos(&cursorpos);
1074 PostMessage(hwnd, WM_SYSTRAY2, cursorpos.x, cursorpos.y);
1075 } else if (lParam == WM_LBUTTONDBLCLK) {
1076 /* Equivalent to IDM_VIEWKEYS. */
1077 PostMessage(hwnd, WM_COMMAND, IDM_VIEWKEYS, 0);
1078 }
1079 break;
1080 case WM_SYSTRAY2:
1081 if (!menuinprogress) {
1082 menuinprogress = 1;
1083 SetForegroundWindow(hwnd);
1084 ret = TrackPopupMenu(systray_menu,
1085 TPM_RIGHTALIGN | TPM_BOTTOMALIGN |
1086 TPM_RIGHTBUTTON,
1087 wParam, lParam, 0, hwnd, NULL);
1088 menuinprogress = 0;
1089 }
1090 break;
1091 case WM_COMMAND:
1092 case WM_SYSCOMMAND:
1093 switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
1094 case IDM_CLOSE:
1095 SendMessage(hwnd, WM_CLOSE, 0, 0);
1096 break;
1097 case IDM_VIEWKEYS:
1098 if (!keylist) {
1099 keylist = CreateDialog(instance, MAKEINTRESOURCE(211),
1100 NULL, KeyListProc);
1101 ShowWindow(keylist, SW_SHOWNORMAL);
1102 /*
1103 * Sometimes the window comes up minimised / hidden
1104 * for no obvious reason. Prevent this.
1105 */
1106 SetForegroundWindow(keylist);
1107 SetWindowPos(keylist, HWND_TOP, 0, 0, 0, 0,
1108 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1109 }
1110 break;
1111 case IDM_ADDKEY:
1112 prompt_add_keyfile();
1113 break;
1114 case IDM_ABOUT:
1115 if (!aboutbox) {
1116 aboutbox = CreateDialog(instance, MAKEINTRESOURCE(213),
1117 NULL, AboutProc);
1118 ShowWindow(aboutbox, SW_SHOWNORMAL);
1119 /*
1120 * Sometimes the window comes up minimised / hidden
1121 * for no obvious reason. Prevent this.
1122 */
1123 SetForegroundWindow(aboutbox);
1124 SetWindowPos(aboutbox, HWND_TOP, 0, 0, 0, 0,
1125 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
1126 }
1127 break;
1128 }
1129 break;
1130 case WM_DESTROY:
1131 PostQuitMessage(0);
1132 return 0;
1133 case WM_COPYDATA:
1134 {
1135 COPYDATASTRUCT *cds;
1136 char *mapname;
1137 void *p;
1138 HANDLE filemap, proc;
1139 PSID mapowner, procowner;
1140 PSECURITY_DESCRIPTOR psd1 = NULL, psd2 = NULL;
1141 int ret = 0;
1142
1143 cds = (COPYDATASTRUCT *) lParam;
1144 if (cds->dwData != AGENT_COPYDATA_ID)
1145 return 0; /* not our message, mate */
1146 mapname = (char *) cds->lpData;
1147 if (mapname[cds->cbData - 1] != '\0')
1148 return 0; /* failure to be ASCIZ! */
1149 #ifdef DEBUG_IPC
1150 debug(("mapname is :%s:\n", mapname));
1151 #endif
1152 filemap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, mapname);
1153 #ifdef DEBUG_IPC
1154 debug(("filemap is %p\n", filemap));
1155 #endif
1156 if (filemap != NULL && filemap != INVALID_HANDLE_VALUE) {
1157 int rc;
1158 #ifndef NO_SECURITY
1159 if (has_security) {
1160 if ((proc = OpenProcess(MAXIMUM_ALLOWED, FALSE,
1161 GetCurrentProcessId())) ==
1162 NULL) {
1163 #ifdef DEBUG_IPC
1164 debug(("couldn't get handle for process\n"));
1165 #endif
1166 return 0;
1167 }
1168 if (getsecurityinfo(proc, SE_KERNEL_OBJECT,
1169 OWNER_SECURITY_INFORMATION,
1170 &procowner, NULL, NULL, NULL,
1171 &psd2) != ERROR_SUCCESS) {
1172 #ifdef DEBUG_IPC
1173 debug(("couldn't get owner info for process\n"));
1174 #endif
1175 CloseHandle(proc);
1176 return 0; /* unable to get security info */
1177 }
1178 CloseHandle(proc);
1179 if ((rc = getsecurityinfo(filemap, SE_KERNEL_OBJECT,
1180 OWNER_SECURITY_INFORMATION,
1181 &mapowner, NULL, NULL, NULL,
1182 &psd1) != ERROR_SUCCESS)) {
1183 #ifdef DEBUG_IPC
1184 debug(
1185 ("couldn't get owner info for filemap: %d\n",
1186 rc));
1187 #endif
1188 return 0;
1189 }
1190 #ifdef DEBUG_IPC
1191 debug(("got security stuff\n"));
1192 #endif
1193 if (!EqualSid(mapowner, procowner))
1194 return 0; /* security ID mismatch! */
1195 #ifdef DEBUG_IPC
1196 debug(("security stuff matched\n"));
1197 #endif
1198 LocalFree(psd1);
1199 LocalFree(psd2);
1200 } else {
1201 #ifdef DEBUG_IPC
1202 debug(("security APIs not present\n"));
1203 #endif
1204 }
1205 #endif
1206 p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
1207 #ifdef DEBUG_IPC
1208 debug(("p is %p\n", p));
1209 {
1210 int i;
1211 for (i = 0; i < 5; i++)
1212 debug(
1213 ("p[%d]=%02x\n", i,
1214 ((unsigned char *) p)[i]));}
1215 #endif
1216 answer_msg(p);
1217 ret = 1;
1218 UnmapViewOfFile(p);
1219 }
1220 CloseHandle(filemap);
1221 return ret;
1222 }
1223 }
1224
1225 return DefWindowProc(hwnd, message, wParam, lParam);
1226 }
1227
1228 /*
1229 * Fork and Exec the command in cmdline. [DBW]
1230 */
1231 void spawn_cmd(char *cmdline, int show)
1232 {
1233 if (ShellExecute(NULL, _T("open"), cmdline,
1234 NULL, NULL, show) <= (HINSTANCE) 32) {
1235 TCHAR sMsg[140];
1236 sprintf(sMsg, _T("Failed to run \"%.100s\", Error: %d"), cmdline,
1237 GetLastError());
1238 MessageBox(NULL, sMsg, APPNAME, MB_OK | MB_ICONEXCLAMATION);
1239 }
1240 }
1241
1242 int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
1243 {
1244 WNDCLASS wndclass;
1245 MSG msg;
1246 OSVERSIONINFO osi;
1247 HMODULE advapi;
1248 char *command = NULL;
1249 int added_keys = 0;
1250
1251 /*
1252 * Determine whether we're an NT system (should have security
1253 * APIs) or a non-NT system (don't do security).
1254 */
1255 memset(&osi, 0, sizeof(OSVERSIONINFO));
1256 osi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1257 if (GetVersionEx(&osi) && osi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1258 has_security = TRUE;
1259 } else
1260 has_security = FALSE;
1261
1262 if (has_security) {
1263 #ifndef NO_SECURITY
1264 /*
1265 * Attempt to get the security API we need.
1266 */
1267 advapi = LoadLibrary("ADVAPI32.DLL");
1268 getsecurityinfo =
1269 (gsi_fn_t) GetProcAddress(advapi, "GetSecurityInfo");
1270 if (!getsecurityinfo) {
1271 MessageBox(NULL,
1272 "Unable to access security APIs. Pageant will\n"
1273 "not run, in case it causes a security breach.",
1274 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1275 return 1;
1276 }
1277 #else
1278 MessageBox(NULL,
1279 "This program has been compiled for Win9X and will\n"
1280 "not run on NT, in case it causes a security breach.",
1281 "Pageant Fatal Error", MB_ICONERROR | MB_OK);
1282 return 1;
1283 #endif
1284 } else
1285 advapi = NULL;
1286
1287 instance = inst;
1288
1289 /*
1290 * Find out if Pageant is already running.
1291 */
1292 already_running = FALSE;
1293 if (agent_exists())
1294 already_running = TRUE;
1295 else {
1296
1297 if (!prev) {
1298 wndclass.style = 0;
1299 wndclass.lpfnWndProc = WndProc;
1300 wndclass.cbClsExtra = 0;
1301 wndclass.cbWndExtra = 0;
1302 wndclass.hInstance = inst;
1303 wndclass.hIcon = LoadIcon(inst, MAKEINTRESOURCE(IDI_MAINICON));
1304 wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM);
1305 wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
1306 wndclass.lpszMenuName = NULL;
1307 wndclass.lpszClassName = APPNAME;
1308
1309 RegisterClass(&wndclass);
1310 }
1311
1312 hwnd = keylist = NULL;
1313
1314 hwnd = CreateWindow(APPNAME, APPNAME,
1315 WS_OVERLAPPEDWINDOW | WS_VSCROLL,
1316 CW_USEDEFAULT, CW_USEDEFAULT,
1317 100, 100, NULL, NULL, inst, NULL);
1318
1319 /* Set up a system tray icon */
1320 {
1321 BOOL res;
1322 NOTIFYICONDATA tnid;
1323 HICON hicon;
1324
1325 #ifdef NIM_SETVERSION
1326 tnid.uVersion = 0;
1327 res = Shell_NotifyIcon(NIM_SETVERSION, &tnid);
1328 #endif
1329
1330 tnid.cbSize = sizeof(NOTIFYICONDATA);
1331 tnid.hWnd = hwnd;
1332 tnid.uID = 1; /* unique within this systray use */
1333 tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
1334 tnid.uCallbackMessage = WM_SYSTRAY;
1335 tnid.hIcon = hicon = LoadIcon(instance, MAKEINTRESOURCE(201));
1336 strcpy(tnid.szTip, "Pageant (PuTTY authentication agent)");
1337
1338 res = Shell_NotifyIcon(NIM_ADD, &tnid);
1339
1340 if (hicon)
1341 DestroyIcon(hicon);
1342
1343 systray_menu = CreatePopupMenu();
1344 /* accelerators used: vkxa */
1345 AppendMenu(systray_menu, MF_ENABLED, IDM_VIEWKEYS,
1346 "&View Keys");
1347 AppendMenu(systray_menu, MF_ENABLED, IDM_ADDKEY, "Add &Key");
1348 AppendMenu(systray_menu, MF_ENABLED, IDM_ABOUT, "&About");
1349 AppendMenu(systray_menu, MF_ENABLED, IDM_CLOSE, "E&xit");
1350 }
1351
1352 ShowWindow(hwnd, SW_HIDE);
1353
1354 /*
1355 * Initialise storage for RSA keys.
1356 */
1357 rsakeys = newtree234(cmpkeys_rsa);
1358 ssh2keys = newtree234(cmpkeys_ssh2);
1359
1360 }
1361
1362 /*
1363 * Process the command line and add keys as listed on it.
1364 * If we already determined that we need to spawn a program from above we
1365 * need to ignore the first two arguments. [DBW]
1366 */
1367 {
1368 char *p;
1369 int inquotes = 0;
1370 int ignorearg = 0;
1371 p = cmdline;
1372 while (*p) {
1373 while (*p && isspace(*p))
1374 p++;
1375 if (*p && !isspace(*p)) {
1376 char *q = p, *pp = p;
1377 while (*p && (inquotes || !isspace(*p))) {
1378 if (*p == '"') {
1379 inquotes = !inquotes;
1380 p++;
1381 continue;
1382 }
1383 *pp++ = *p++;
1384 }
1385 if (*pp) {
1386 if (*p)
1387 p++;
1388 *pp++ = '\0';
1389 }
1390 if (!strcmp(q, "-c")) {
1391 /*
1392 * If we see `-c', then the rest of the
1393 * command line should be treated as a
1394 * command to be spawned.
1395 */
1396 while (*p && isspace(*p))
1397 p++;
1398 command = p;
1399 break;
1400 } else {
1401 add_keyfile(q);
1402 added_keys = TRUE;
1403 }
1404 }
1405 }
1406 }
1407
1408 if (command)
1409 spawn_cmd(command, show);
1410
1411 /*
1412 * If Pageant was already running, we leave now. If we haven't
1413 * even taken any auxiliary action (spawned a command or added
1414 * keys), complain.
1415 */
1416 if (already_running) {
1417 if (!command && !added_keys) {
1418 MessageBox(NULL, "Pageant is already running", "Pageant Error",
1419 MB_ICONERROR | MB_OK);
1420 }
1421 if (advapi)
1422 FreeLibrary(advapi);
1423 return 0;
1424 }
1425
1426 /*
1427 * Main message loop.
1428 */
1429 while (GetMessage(&msg, NULL, 0, 0) == 1) {
1430 TranslateMessage(&msg);
1431 DispatchMessage(&msg);
1432 }
1433
1434 /* Clean up the system tray icon */
1435 {
1436 NOTIFYICONDATA tnid;
1437
1438 tnid.cbSize = sizeof(NOTIFYICONDATA);
1439 tnid.hWnd = hwnd;
1440 tnid.uID = 1;
1441
1442 Shell_NotifyIcon(NIM_DELETE, &tnid);
1443
1444 DestroyMenu(systray_menu);
1445 }
1446
1447 if (advapi)
1448 FreeLibrary(advapi);
1449 exit(msg.wParam);
1450 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator