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