[u/mdw/putty] / pageant.c

/*
 * Pageant: the PuTTY Authentication Agent.
 */

#include <windows.h>
#include <stdio.h> /* FIXME */
#include "putty.h" /* FIXME */
#include "ssh.h"
#include "tree234.h"

#define IDI_MAINICON 200
#define IDI_TRAYICON 201

#define WM_XUSER     (WM_USER + 0x2000)
#define WM_SYSTRAY   (WM_XUSER + 6)
#define WM_SYSTRAY2  (WM_XUSER + 7)
#define WM_CLOSEMEM  (WM_XUSER + 10)

#define IDM_CLOSE    0x0010
#define IDM_VIEWKEYS 0x0020

#define APPNAME "Pageant"

#define SSH_AGENTC_REQUEST_RSA_IDENTITIES    1
#define SSH_AGENT_RSA_IDENTITIES_ANSWER      2
#define SSH_AGENTC_RSA_CHALLENGE             3
#define SSH_AGENT_RSA_RESPONSE               4
#define SSH_AGENT_FAILURE                    5
#define SSH_AGENT_SUCCESS                    6
#define SSH_AGENTC_ADD_RSA_IDENTITY          7
#define SSH_AGENTC_REMOVE_RSA_IDENTITY       8

HINSTANCE instance;
HWND hwnd;
HWND keylist;
HMENU systray_menu;

tree234 *rsakeys;

/*
 * We need this to link with the RSA code, because rsaencrypt()
 * pads its data with random bytes. Since we only use rsadecrypt(),
 * which is deterministic, this should never be called.
 *
 * If it _is_ called, there is a _serious_ problem, because it
 * won't generate true random numbers. So we must scream, panic,
 * and exit immediately if that should happen.
 */
int random_byte(void) {
    MessageBox(hwnd, "Internal Error", APPNAME, MB_OK | MB_ICONERROR);
    exit(0);
}

/*
 * This function is needed to link with the DES code. We need not
 * have it do anything at all.
 */
void logevent(char *msg) {
}

#define GET_32BIT(cp) \
    (((unsigned long)(unsigned char)(cp)[0] << 24) | \
    ((unsigned long)(unsigned char)(cp)[1] << 16) | \
    ((unsigned long)(unsigned char)(cp)[2] << 8) | \
    ((unsigned long)(unsigned char)(cp)[3]))

#define PUT_32BIT(cp, value) { \
    (cp)[0] = (unsigned char)((value) >> 24); \
    (cp)[1] = (unsigned char)((value) >> 16); \
    (cp)[2] = (unsigned char)((value) >> 8); \
    (cp)[3] = (unsigned char)(value); }

#define PASSPHRASE_MAXLEN 512

/*
 * Dialog-box function for the passphrase box.
 */
static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
                                   WPARAM wParam, LPARAM lParam) {
    static char *passphrase;

    switch (msg) {
      case WM_INITDIALOG:
        passphrase = (char *)lParam;
        *passphrase = 0;
        return 0;
      case WM_COMMAND:
	switch (LOWORD(wParam)) {
	  case IDOK:
	    if (*passphrase)
		EndDialog (hwnd, 1);
	    else
		MessageBeep (0);
	    return 0;
	  case IDCANCEL:
	    EndDialog (hwnd, 0);
	    return 0;
          case 102:                    /* edit box */
	    if (HIWORD(wParam) == EN_CHANGE) {
                GetDlgItemText (hwnd, 102, passphrase, PASSPHRASE_MAXLEN-1);
                passphrase[PASSPHRASE_MAXLEN-1] = '\0';
            }
            return 0;
	}
	return 0;
      case WM_CLOSE:
	EndDialog (hwnd, 0);
	return 0;
    }
    return 0;
}

/*
 * This function loads a key from a file and adds it.
 */
void add_keyfile(char *filename) {
    char passphrase[PASSPHRASE_MAXLEN];
    struct RSAKey *key;
    int needs_pass;
    int ret;
    int attempts;

    needs_pass = rsakey_encrypted(filename);
    attempts = 0;
    key = malloc(sizeof(*key));
    do {
        if (needs_pass) {
            int dlgret;
            dlgret = DialogBoxParam(instance, MAKEINTRESOURCE(210),
                                    NULL, PassphraseProc,
                                    (LPARAM)passphrase);
            if (!dlgret) {
                free(key);
                return;                /* operation cancelled */
            }
        } else
            *passphrase = '\0';
        ret = loadrsakey(filename, key, passphrase);
        attempts++;
    } while (ret == -1);
    if (ret == 0) {
        MessageBox(NULL, "Couldn't load public key.", APPNAME,
                   MB_OK | MB_ICONERROR);
        free(key);
        return;
    }
    if (add234(rsakeys, key) != key)
        free(key);                     /* already present, don't waste RAM */
}

/*
 * This is the main agent function that answers messages.
 */
void answer_msg(void *in, int inlen, void **out, int *outlen) {
    unsigned char *ret;
    unsigned char *p = in;
    int type;

    *out = NULL;                       /* default `no go' response */

    /*
     * Basic sanity checks. len >= 5, and len[0:4] holds len-4.
     */
    if (inlen < 5 || GET_32BIT(p) != (unsigned long)(inlen-4))
        return;

    /*
     * Get the message type.
     */
    type = p[4];

    p += 5;

    switch (type) {
      case SSH_AGENTC_REQUEST_RSA_IDENTITIES:
        /*
         * Reply with SSH_AGENT_RSA_IDENTITIES_ANSWER.
         */
        {
            enum234 e;
            struct RSAKey *key;
            int len, nkeys;

            /*
             * Count up the number and length of keys we hold.
             */
            len = nkeys = 0;
            for (key = first234(rsakeys, &e); key; key = next234(&e)) {
                nkeys++;
                len += 4;              /* length field */
                len += ssh1_bignum_length(key->exponent);
                len += ssh1_bignum_length(key->modulus);
                len += 4 + strlen(key->comment);
            }

            /*
             * Packet header is the obvious five bytes, plus four
             * bytes for the key count.
             */
            len += 5 + 4;
            if ((ret = malloc(len)) != NULL) {
                PUT_32BIT(ret, len-4);
                ret[4] = SSH_AGENT_RSA_IDENTITIES_ANSWER;
                PUT_32BIT(ret+5, nkeys);
                p = ret + 5 + 4;
                for (key = first234(rsakeys, &e); key; key = next234(&e)) {
                    PUT_32BIT(p, ssh1_bignum_bitcount(key->modulus));
                    p += 4;
                    p += ssh1_write_bignum(p, key->exponent);
                    p += ssh1_write_bignum(p, key->modulus);
                    PUT_32BIT(p, strlen(key->comment));
                    memcpy(p+4, key->comment, strlen(key->comment));
                    p += 4 + strlen(key->comment);
                }
            }
        }
        break;
      case SSH_AGENTC_RSA_CHALLENGE:
        /*
         * Reply with either SSH_AGENT_RSA_RESPONSE or
         * SSH_AGENT_FAILURE, depending on whether we have that key
         * or not.
         */
        {
            struct RSAKey reqkey, *key;
            Bignum challenge, response;
            unsigned char response_source[48], response_md5[16];
            struct MD5Context md5c;
            int i, len;

            p += 4;
            p += ssh1_read_bignum(p, &reqkey.exponent);
            p += ssh1_read_bignum(p, &reqkey.modulus);
            p += ssh1_read_bignum(p, &challenge);
            memcpy(response_source+32, p, 16); p += 16;
            if (GET_32BIT(p) != 1 ||
                (key = find234(rsakeys, &reqkey, NULL)) == NULL) {
                freebn(reqkey.exponent);
                freebn(reqkey.modulus);
                freebn(challenge);
                goto failure;
            }
            response = rsadecrypt(challenge, key);
            for (i = 0; i < 32; i++)
                response_source[i] = bignum_byte(response, 31-i);

            MD5Init(&md5c);
            MD5Update(&md5c, response_source, 48);
            MD5Final(response_md5, &md5c);
            memset(response_source, 0, 48);   /* burn the evidence */
            freebn(response);          /* and that evidence */
            freebn(challenge);         /* yes, and that evidence */
            freebn(reqkey.exponent);   /* and free some memory ... */
            freebn(reqkey.modulus);    /* ... while we're at it. */

            /*
             * Packet is the obvious five byte header, plus sixteen
             * bytes of MD5.
             */
            len = 5 + 16;
            if ((ret = malloc(len)) != NULL) {
                PUT_32BIT(ret, len-4);
                ret[4] = SSH_AGENT_RSA_RESPONSE;
                memcpy(ret+5, response_md5, 16);
            }
        }
        break;
#if 0 /* FIXME: implement these */
      case SSH_AGENTC_ADD_RSA_IDENTITY:
        /*
         * Add to the list and return SSH_AGENT_SUCCESS, or
         * SSH_AGENT_FAILURE if the key was malformed.
         */
        break;
      case SSH_AGENTC_REMOVE_RSA_IDENTITY:
        /*
         * Remove from the list and return SSH_AGENT_SUCCESS, or
         * perhaps SSH_AGENT_FAILURE if it wasn't in the list to
         * start with.
         */
        break;
#endif
      default:
        failure:
        /*
         * Unrecognised message. Return SSH_AGENT_FAILURE.
         */
        if ((ret = malloc(5)) != NULL) {
            PUT_32BIT(ret, 1);
            ret[4] = SSH_AGENT_FAILURE;
        }
        break;
    }

    if (ret) {
        *out = ret;
        *outlen = 4 + GET_32BIT(ret);
    }
}

/*
 * Key comparison function for the 2-3-4 tree of RSA keys.
 */
int cmpkeys(void *av, void *bv) {
    struct RSAKey *a = (struct RSAKey *)av;
    struct RSAKey *b = (struct RSAKey *)bv;
    Bignum am, bm;
    int alen, blen;

    am = a->modulus;
    bm = b->modulus;
    /*
     * Compare by length of moduli.
     */
    alen = ssh1_bignum_bitcount(am);
    blen = ssh1_bignum_bitcount(bm);
    if (alen > blen) return +1; else if (alen < blen) return -1;
    /*
     * Now compare by moduli themselves.
     */
    alen = (alen + 7) / 8;             /* byte count */
    while (alen-- > 0) {
        int abyte, bbyte;
        abyte = bignum_byte(am, alen);
        bbyte = bignum_byte(bm, alen);
        if (abyte > bbyte) return +1; else if (abyte < bbyte) return -1;
    }
    /*
     * Give up.
     */
    return 0;
}

static void error(char *s) {
    MessageBox(hwnd, s, APPNAME, MB_OK | MB_ICONERROR);
}

/*
 * Dialog-box function for the key list box.
 */
static int CALLBACK KeyListProc(HWND hwnd, UINT msg,
                                WPARAM wParam, LPARAM lParam) {
    enum234 e;
    struct RSAKey *key;
    OPENFILENAME of;
    char filename[FILENAME_MAX];

    switch (msg) {
      case WM_INITDIALOG:
        for (key = first234(rsakeys, &e); key; key = next234(&e)) {
            SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
                                0, (LPARAM) key->comment);
        }
        return 0;
      case WM_COMMAND:
	switch (LOWORD(wParam)) {
	  case IDOK:
	  case IDCANCEL:
            keylist = NULL;
            DestroyWindow(hwnd);
            return 0;
          case 101:                    /* add key */
	    if (HIWORD(wParam) == BN_CLICKED ||
		HIWORD(wParam) == BN_DOUBLECLICKED) {
                memset(&of, 0, sizeof(of));
#ifdef OPENFILENAME_SIZE_VERSION_400
                of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
#else
                of.lStructSize = sizeof(of);
#endif
                of.hwndOwner = hwnd;
                of.lpstrFilter = "All Files\0*\0\0\0";
                of.lpstrCustomFilter = NULL;
                of.nFilterIndex = 1;
                of.lpstrFile = filename; *filename = '\0';
                of.nMaxFile = sizeof(filename);
                of.lpstrFileTitle = NULL;
                of.lpstrInitialDir = NULL;
                of.lpstrTitle = "Select Public Key File";
                of.Flags = 0;
                if (GetOpenFileName(&of)) {
                    add_keyfile(filename);
                }
                SendDlgItemMessage(hwnd, 100, LB_RESETCONTENT, 0, 0);
                for (key = first234(rsakeys, &e); key; key = next234(&e)) {
                    SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
                                        0, (LPARAM) key->comment);
                }
		SendDlgItemMessage (hwnd, 100, LB_SETCURSEL, (WPARAM) -1, 0);
            }
            return 0;
          case 102:                    /* remove key */
	    if (HIWORD(wParam) == BN_CLICKED ||
		HIWORD(wParam) == BN_DOUBLECLICKED) {
		int n = SendDlgItemMessage (hwnd, 100, LB_GETCURSEL, 0, 0);
		if (n == LB_ERR || n == 0) {
		    MessageBeep(0);
		    break;
		}
                for (key = first234(rsakeys, &e); key; key = next234(&e))
                    if (n-- == 0)
                        break;
                del234(rsakeys, key);
                freersakey(key); free(key);
                SendDlgItemMessage(hwnd, 100, LB_RESETCONTENT, 0, 0);
                for (key = first234(rsakeys, &e); key; key = next234(&e)) {
                    SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
                                        0, (LPARAM) key->comment);
                }
		SendDlgItemMessage (hwnd, 100, LB_SETCURSEL, (WPARAM) -1, 0);
            }
            return 0;
	}
	return 0;
      case WM_CLOSE:
        keylist = NULL;
        DestroyWindow(hwnd);
	return 0;
    }
    return 0;
}

static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
                                 WPARAM wParam, LPARAM lParam) {
    int ret;
    static int menuinprogress;

    switch (message) {
      case WM_SYSTRAY:
        if (lParam == WM_RBUTTONUP) {
            POINT cursorpos;
            GetCursorPos(&cursorpos);
            PostMessage(hwnd, WM_SYSTRAY2, cursorpos.x, cursorpos.y);
        }
        break;
      case WM_SYSTRAY2:
        if (!menuinprogress) {
            menuinprogress = 1;
            SetForegroundWindow(hwnd);
            ret = TrackPopupMenu(systray_menu,
                                 TPM_RIGHTALIGN | TPM_BOTTOMALIGN |
                                 TPM_RIGHTBUTTON,
                                 wParam, lParam, 0, hwnd, NULL);
            menuinprogress = 0;
        }
        break;
      case WM_COMMAND:
      case WM_SYSCOMMAND:
	switch (wParam & ~0xF) {       /* low 4 bits reserved to Windows */
          case IDM_CLOSE:
            SendMessage(hwnd, WM_CLOSE, 0, 0);
            break;
          case IDM_VIEWKEYS:
            if (!keylist) {
                keylist = CreateDialog (instance, MAKEINTRESOURCE(211),
                                        NULL, KeyListProc);
                ShowWindow (keylist, SW_SHOWNORMAL);
            }
            break;
        }
        break;
      case WM_DESTROY:
	PostQuitMessage (0);
	return 0;
      case WM_COPYDATA:
        {
            COPYDATASTRUCT *cds;
            void *in, *out, *ret;
            int inlen, outlen;
            HANDLE filemap;
            char mapname[64];
            int id;

            cds = (COPYDATASTRUCT *)lParam;
            /*
             * FIXME: use dwData somehow.
             */
            in = cds->lpData;
            inlen = cds->cbData;
            answer_msg(in, inlen, &out, &outlen);
            if (out) {
                id = 0;
                do {
                    sprintf(mapname, "PageantReply%08x", ++id);
		    filemap = CreateFileMapping(INVALID_HANDLE_VALUE,
                                                NULL, PAGE_READWRITE,
						0, outlen+sizeof(int),
                                                mapname);
                } while (filemap == INVALID_HANDLE_VALUE);
                ret = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0,
                                    outlen+sizeof(int));
                if (ret) {
                    *((int *)ret) = outlen;
                    memcpy(((int *)ret)+1, out, outlen);
                    UnmapViewOfFile(ret);
                    return id;
                }
            } else
                return 0;              /* invalid request */
        }
        break;
      case WM_CLOSEMEM:
        /*
         * FIXME!
         */
        break;
    }

    return DefWindowProc (hwnd, message, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
    WNDCLASS wndclass;
    MSG msg;

    instance = inst;

    if (!prev) {
	wndclass.style         = 0;
	wndclass.lpfnWndProc   = WndProc;
	wndclass.cbClsExtra    = 0;
	wndclass.cbWndExtra    = 0;
	wndclass.hInstance     = inst;
	wndclass.hIcon         = LoadIcon (inst,
					   MAKEINTRESOURCE(IDI_MAINICON));
	wndclass.hCursor       = LoadCursor (NULL, IDC_IBEAM);
	wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
	wndclass.lpszMenuName  = NULL;
	wndclass.lpszClassName = APPNAME;

	RegisterClass (&wndclass);
    }

    hwnd = keylist = NULL;

    hwnd = CreateWindow (APPNAME, APPNAME,
                         WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         100, 100, NULL, NULL, inst, NULL);

    /* Set up a system tray icon */
    {
        BOOL res;
        NOTIFYICONDATA tnid;
        HICON hicon;

#ifdef NIM_SETVERSION
        tnid.uVersion = 0;
        res = Shell_NotifyIcon(NIM_SETVERSION, &tnid);
#endif

        tnid.cbSize = sizeof(NOTIFYICONDATA); 
        tnid.hWnd = hwnd; 
        tnid.uID = 1;                  /* unique within this systray use */
        tnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; 
        tnid.uCallbackMessage = WM_SYSTRAY;
        tnid.hIcon = hicon = LoadIcon (instance, MAKEINTRESOURCE(201));
        strcpy(tnid.szTip, "Pageant (PuTTY authentication agent)");

        res = Shell_NotifyIcon(NIM_ADD, &tnid); 

        if (hicon) 
            DestroyIcon(hicon); 

        systray_menu = CreatePopupMenu();
        AppendMenu (systray_menu, MF_ENABLED, IDM_VIEWKEYS, "View Keys");
        AppendMenu (systray_menu, MF_ENABLED, IDM_CLOSE, "Terminate");
    }

    ShowWindow (hwnd, SW_HIDE);

    /*
     * Initialise storage for RSA keys.
     */
    rsakeys = newtree234(cmpkeys);

    /*
     * Process the command line and add RSA keys as listed on it.
     * FIXME: we don't support spaces in filenames here. We should.
     */
    {
        char *p = cmdline;
        while (*p) {
            while (*p && isspace(*p)) p++;
            if (*p && !isspace(*p)) {
                char *q = p;
                while (*p && !isspace(*p)) p++;
                if (*p) *p++ = '\0';
                add_keyfile(q);
            }
        }
    }

    /*
     * Main message loop.
     */
    while (GetMessage(&msg, NULL, 0, 0) == 1) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    /* Clean up the system tray icon */
    {
        NOTIFYICONDATA tnid;

        tnid.cbSize = sizeof(NOTIFYICONDATA); 
        tnid.hWnd = hwnd;
        tnid.uID = 1;

        Shell_NotifyIcon(NIM_DELETE, &tnid); 

        DestroyMenu(systray_menu);
    }

    exit(msg.wParam);
}
Commit	Line	Data
5c58ad2d	1	/*
	2	* Pageant: the PuTTY Authentication Agent.
	3	*/
	4
	5	#include <windows.h>
	6	#include <stdio.h> /* FIXME */
	7	#include "putty.h" /* FIXME */
	8	#include "ssh.h"
	9	#include "tree234.h"
	10
	11	#define IDI_MAINICON 200
	12	#define IDI_TRAYICON 201
	13
	14	#define WM_XUSER (WM_USER + 0x2000)
	15	#define WM_SYSTRAY (WM_XUSER + 6)
	16	#define WM_SYSTRAY2 (WM_XUSER + 7)
	17	#define WM_CLOSEMEM (WM_XUSER + 10)
	18
	19	#define IDM_CLOSE 0x0010
	20	#define IDM_VIEWKEYS 0x0020
	21
	22	#define APPNAME "Pageant"
	23
5c58ad2d	24	#define SSH_AGENTC_REQUEST_RSA_IDENTITIES 1
	25	#define SSH_AGENT_RSA_IDENTITIES_ANSWER 2
	26	#define SSH_AGENTC_RSA_CHALLENGE 3
	27	#define SSH_AGENT_RSA_RESPONSE 4
	28	#define SSH_AGENT_FAILURE 5
	29	#define SSH_AGENT_SUCCESS 6
	30	#define SSH_AGENTC_ADD_RSA_IDENTITY 7
	31	#define SSH_AGENTC_REMOVE_RSA_IDENTITY 8
	32
	33	HINSTANCE instance;
	34	HWND hwnd;
	35	HWND keylist;
	36	HMENU systray_menu;
	37
	38	tree234 *rsakeys;
	39
	40	/*
	41	* We need this to link with the RSA code, because rsaencrypt()
	42	* pads its data with random bytes. Since we only use rsadecrypt(),
	43	* which is deterministic, this should never be called.
	44	*
	45	* If it _is_ called, there is a _serious_ problem, because it
	46	* won't generate true random numbers. So we must scream, panic,
	47	* and exit immediately if that should happen.
	48	*/
	49	int random_byte(void) {
	50	MessageBox(hwnd, "Internal Error", APPNAME, MB_OK \| MB_ICONERROR);
	51	exit(0);
	52	}
	53
	54	/*
	55	* This function is needed to link with the DES code. We need not
	56	* have it do anything at all.
	57	*/
	58	void logevent(char *msg) {
	59	}
	60
	61	#define GET_32BIT(cp) \
	62	(((unsigned long)(unsigned char)(cp)[0] << 24) \| \
	63	((unsigned long)(unsigned char)(cp)[1] << 16) \| \
	64	((unsigned long)(unsigned char)(cp)[2] << 8) \| \
	65	((unsigned long)(unsigned char)(cp)[3]))
	66
	67	#define PUT_32BIT(cp, value) { \
	68	(cp)[0] = (unsigned char)((value) >> 24); \
	69	(cp)[1] = (unsigned char)((value) >> 16); \
	70	(cp)[2] = (unsigned char)((value) >> 8); \
	71	(cp)[3] = (unsigned char)(value); }
	72
	73	#define PASSPHRASE_MAXLEN 512
	74
	75	/*
	76	* Dialog-box function for the passphrase box.
	77	*/
	78	static int CALLBACK PassphraseProc(HWND hwnd, UINT msg,
	79	WPARAM wParam, LPARAM lParam) {
	80	static char *passphrase;
	81
	82	switch (msg) {
	83	case WM_INITDIALOG:
	84	passphrase = (char *)lParam;
	85	*passphrase = 0;
	86	return 0;
	87	case WM_COMMAND:
88	switch (LOWORD(wParam)) {
89	case IDOK:
90	if (*passphrase)
91	EndDialog (hwnd, 1);
92	else
93	MessageBeep (0);
94	return 0;
95	case IDCANCEL:
96	EndDialog (hwnd, 0);
97	return 0;
98	case 102: /* edit box */
99	if (HIWORD(wParam) == EN_CHANGE) {
100	GetDlgItemText (hwnd, 102, passphrase, PASSPHRASE_MAXLEN-1);
101	passphrase[PASSPHRASE_MAXLEN-1] = '\0';
102	}
103	return 0;
104	}
105	return 0;
106	case WM_CLOSE:
107	EndDialog (hwnd, 0);
108	return 0;
109	}
110	return 0;
111	}
112
113	/*
114	* This function loads a key from a file and adds it.
115	*/
116	void add_keyfile(char *filename) {
117	char passphrase[PASSPHRASE_MAXLEN];
118	struct RSAKey *key;
119	int needs_pass;
120	int ret;
121	int attempts;
122
123	needs_pass = rsakey_encrypted(filename);
124	attempts = 0;
125	key = malloc(sizeof(*key));
126	do {
127	if (needs_pass) {
128	int dlgret;
129	dlgret = DialogBoxParam(instance, MAKEINTRESOURCE(210),
130	NULL, PassphraseProc,
131	(LPARAM)passphrase);
132	if (!dlgret) {
133	free(key);
134	return; /* operation cancelled */
135	}
136	} else
137	*passphrase = '\0';
138	ret = loadrsakey(filename, key, passphrase);
139	attempts++;
140	} while (ret == -1);
141	if (ret == 0) {
142	MessageBox(NULL, "Couldn't load public key.", APPNAME,
143	MB_OK \| MB_ICONERROR);
144	free(key);
145	return;
146	}
147	if (add234(rsakeys, key) != key)
148	free(key); /* already present, don't waste RAM */
149	}
150
151	/*
152	* This is the main agent function that answers messages.
153	*/
154	void answer_msg(void in, int inlen, void out, int outlen) {
155	unsigned char *ret;
156	unsigned char *p = in;
157	int type;
158
159	out = NULL; / default `no go' response */
160
161	/*
162	* Basic sanity checks. len >= 5, and len[0:4] holds len-4.
163	*/
164	if (inlen < 5 \|\| GET_32BIT(p) != (unsigned long)(inlen-4))
165	return;
166
167	/*
168	* Get the message type.
169	*/
170	type = p[4];
171
172	p += 5;
173
174	switch (type) {
175	case SSH_AGENTC_REQUEST_RSA_IDENTITIES:
176	/*
177	* Reply with SSH_AGENT_RSA_IDENTITIES_ANSWER.
178	*/
179	{
180	enum234 e;
181	struct RSAKey *key;
182	int len, nkeys;
183
184	/*
185	* Count up the number and length of keys we hold.
186	*/
187	len = nkeys = 0;
188	for (key = first234(rsakeys, &e); key; key = next234(&e)) {
189	nkeys++;
190	len += 4; /* length field */
191	len += ssh1_bignum_length(key->exponent);
192	len += ssh1_bignum_length(key->modulus);
193	len += 4 + strlen(key->comment);
194	}
195
196	/*
197	* Packet header is the obvious five bytes, plus four
198	* bytes for the key count.
199	*/
200	len += 5 + 4;
201	if ((ret = malloc(len)) != NULL) {
202	PUT_32BIT(ret, len-4);
203	ret[4] = SSH_AGENT_RSA_IDENTITIES_ANSWER;
204	PUT_32BIT(ret+5, nkeys);
205	p = ret + 5 + 4;
206	for (key = first234(rsakeys, &e); key; key = next234(&e)) {
207	PUT_32BIT(p, ssh1_bignum_bitcount(key->modulus));
208	p += 4;
209	p += ssh1_write_bignum(p, key->exponent);
210	p += ssh1_write_bignum(p, key->modulus);
211	PUT_32BIT(p, strlen(key->comment));
212	memcpy(p+4, key->comment, strlen(key->comment));
213	p += 4 + strlen(key->comment);
214	}
215	}
216	}
217	break;
218	case SSH_AGENTC_RSA_CHALLENGE:
219	/*
220	* Reply with either SSH_AGENT_RSA_RESPONSE or
221	* SSH_AGENT_FAILURE, depending on whether we have that key
222	* or not.
223	*/
224	{
225	struct RSAKey reqkey, *key;
226	Bignum challenge, response;
227	unsigned char response_source[48], response_md5[16];
228	struct MD5Context md5c;
229	int i, len;
230
231	p += 4;
232	p += ssh1_read_bignum(p, &reqkey.exponent);
233	p += ssh1_read_bignum(p, &reqkey.modulus);
234	p += ssh1_read_bignum(p, &challenge);
235	memcpy(response_source+32, p, 16); p += 16;
236	if (GET_32BIT(p) != 1 \|\|
237	(key = find234(rsakeys, &reqkey, NULL)) == NULL) {
238	freebn(reqkey.exponent);
239	freebn(reqkey.modulus);
240	freebn(challenge);
241	goto failure;
242	}
243	response = rsadecrypt(challenge, key);
244	for (i = 0; i < 32; i++)
245	response_source[i] = bignum_byte(response, 31-i);
246
247	MD5Init(&md5c);
248	MD5Update(&md5c, response_source, 48);
249	MD5Final(response_md5, &md5c);
250	memset(response_source, 0, 48); /* burn the evidence */
251	freebn(response); /* and that evidence */
252	freebn(challenge); /* yes, and that evidence */
253	freebn(reqkey.exponent); /* and free some memory ... */
254	freebn(reqkey.modulus); /* ... while we're at it. */
255
256	/*
257	* Packet is the obvious five byte header, plus sixteen
258	* bytes of MD5.
259	*/
260	len = 5 + 16;
261	if ((ret = malloc(len)) != NULL) {
262	PUT_32BIT(ret, len-4);
263	ret[4] = SSH_AGENT_RSA_RESPONSE;
264	memcpy(ret+5, response_md5, 16);
265	}
266	}
267	break;
268	#if 0 /* FIXME: implement these */
269	case SSH_AGENTC_ADD_RSA_IDENTITY:
270	/*
271	* Add to the list and return SSH_AGENT_SUCCESS, or
272	* SSH_AGENT_FAILURE if the key was malformed.
273	*/
274	break;
275	case SSH_AGENTC_REMOVE_RSA_IDENTITY:
276	/*
277	* Remove from the list and return SSH_AGENT_SUCCESS, or
278	* perhaps SSH_AGENT_FAILURE if it wasn't in the list to
279	* start with.
280	*/
281	break;
282	#endif
283	default:
284	failure:
285	/*
286	* Unrecognised message. Return SSH_AGENT_FAILURE.
287	*/
288	if ((ret = malloc(5)) != NULL) {
289	PUT_32BIT(ret, 1);
290	ret[4] = SSH_AGENT_FAILURE;
291	}
292	break;
293	}
294
295	if (ret) {
296	*out = ret;
297	*outlen = 4 + GET_32BIT(ret);
298	}
299	}
300
301	/*
302	* Key comparison function for the 2-3-4 tree of RSA keys.
303	*/
304	int cmpkeys(void av, void bv) {
305	struct RSAKey a = (struct RSAKey )av;
306	struct RSAKey b = (struct RSAKey )bv;
307	Bignum am, bm;
308	int alen, blen;
309
310	am = a->modulus;
311	bm = b->modulus;
312	/*
313	* Compare by length of moduli.
314	*/
315	alen = ssh1_bignum_bitcount(am);
316	blen = ssh1_bignum_bitcount(bm);
317	if (alen > blen) return +1; else if (alen < blen) return -1;
318	/*
319	* Now compare by moduli themselves.
320	*/
321	alen = (alen + 7) / 8; /* byte count */
322	while (alen-- > 0) {
323	int abyte, bbyte;
324	abyte = bignum_byte(am, alen);
325	bbyte = bignum_byte(bm, alen);
326	if (abyte > bbyte) return +1; else if (abyte < bbyte) return -1;
327	}
328	/*
329	* Give up.
330	*/
331	return 0;
332	}
333
334	static void error(char *s) {
335	MessageBox(hwnd, s, APPNAME, MB_OK \| MB_ICONERROR);
336	}
337
338	/*
339	* Dialog-box function for the key list box.
340	*/
341	static int CALLBACK KeyListProc(HWND hwnd, UINT msg,
342	WPARAM wParam, LPARAM lParam) {
343	enum234 e;
344	struct RSAKey *key;
345	OPENFILENAME of;
346	char filename[FILENAME_MAX];
347
348	switch (msg) {
349	case WM_INITDIALOG:
350	for (key = first234(rsakeys, &e); key; key = next234(&e)) {
351	SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
352	0, (LPARAM) key->comment);
353	}
354	return 0;
355	case WM_COMMAND:
356	switch (LOWORD(wParam)) {
357	case IDOK:
358	case IDCANCEL:
359	keylist = NULL;
360	DestroyWindow(hwnd);
361	return 0;
362	case 101: /* add key */
363	if (HIWORD(wParam) == BN_CLICKED \|\|
364	HIWORD(wParam) == BN_DOUBLECLICKED) {
365	memset(&of, 0, sizeof(of));
366	#ifdef OPENFILENAME_SIZE_VERSION_400
367	of.lStructSize = OPENFILENAME_SIZE_VERSION_400;
368	#else
369	of.lStructSize = sizeof(of);
370	#endif
371	of.hwndOwner = hwnd;
372	of.lpstrFilter = "All Files\0*\0\0\0";
373	of.lpstrCustomFilter = NULL;
374	of.nFilterIndex = 1;
375	of.lpstrFile = filename; *filename = '\0';
376	of.nMaxFile = sizeof(filename);
377	of.lpstrFileTitle = NULL;
378	of.lpstrInitialDir = NULL;
379	of.lpstrTitle = "Select Public Key File";
380	of.Flags = 0;
381	if (GetOpenFileName(&of)) {
382	add_keyfile(filename);
383	}
384	SendDlgItemMessage(hwnd, 100, LB_RESETCONTENT, 0, 0);
385	for (key = first234(rsakeys, &e); key; key = next234(&e)) {
386	SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
387	0, (LPARAM) key->comment);
388	}
389	SendDlgItemMessage (hwnd, 100, LB_SETCURSEL, (WPARAM) -1, 0);
390	}
391	return 0;
392	case 102: /* remove key */
393	if (HIWORD(wParam) == BN_CLICKED \|\|
394	HIWORD(wParam) == BN_DOUBLECLICKED) {
395	int n = SendDlgItemMessage (hwnd, 100, LB_GETCURSEL, 0, 0);
396	if (n == LB_ERR \|\| n == 0) {
397	MessageBeep(0);
398	break;
399	}
400	for (key = first234(rsakeys, &e); key; key = next234(&e))
401	if (n-- == 0)
402	break;
403	del234(rsakeys, key);
404	freersakey(key); free(key);
405	SendDlgItemMessage(hwnd, 100, LB_RESETCONTENT, 0, 0);
406	for (key = first234(rsakeys, &e); key; key = next234(&e)) {
407	SendDlgItemMessage (hwnd, 100, LB_ADDSTRING,
408	0, (LPARAM) key->comment);
409	}
410	SendDlgItemMessage (hwnd, 100, LB_SETCURSEL, (WPARAM) -1, 0);
411	}
412	return 0;
413	}
414	return 0;
415	case WM_CLOSE:
416	keylist = NULL;
417	DestroyWindow(hwnd);
418	return 0;
419	}
420	return 0;
421	}
422
423	static LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
424	WPARAM wParam, LPARAM lParam) {
425	int ret;
426	static int menuinprogress;
427
428	switch (message) {
429	case WM_SYSTRAY:
430	if (lParam == WM_RBUTTONUP) {
431	POINT cursorpos;
432	GetCursorPos(&cursorpos);
433	PostMessage(hwnd, WM_SYSTRAY2, cursorpos.x, cursorpos.y);
434	}
435	break;
436	case WM_SYSTRAY2:
437	if (!menuinprogress) {
438	menuinprogress = 1;
439	SetForegroundWindow(hwnd);
440	ret = TrackPopupMenu(systray_menu,
441	TPM_RIGHTALIGN \| TPM_BOTTOMALIGN \|
442	TPM_RIGHTBUTTON,
443	wParam, lParam, 0, hwnd, NULL);
444	menuinprogress = 0;
445	}
446	break;
447	case WM_COMMAND:
448	case WM_SYSCOMMAND:
449	switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
450	case IDM_CLOSE:
451	SendMessage(hwnd, WM_CLOSE, 0, 0);
452	break;
453	case IDM_VIEWKEYS:
454	if (!keylist) {
455	keylist = CreateDialog (instance, MAKEINTRESOURCE(211),
456	NULL, KeyListProc);
457	ShowWindow (keylist, SW_SHOWNORMAL);
458	}
459	break;
460	}
461	break;
462	case WM_DESTROY:
463	PostQuitMessage (0);
464	return 0;
465	case WM_COPYDATA:
466	{
467	COPYDATASTRUCT *cds;
468	void in, out, *ret;
469	int inlen, outlen;
470	HANDLE filemap;
471	char mapname[64];
472	int id;
473
474	cds = (COPYDATASTRUCT *)lParam;
475	/*
476	* FIXME: use dwData somehow.
477	*/
478	in = cds->lpData;
479	inlen = cds->cbData;
480	answer_msg(in, inlen, &out, &outlen);
481	if (out) {
482	id = 0;
483	do {
484	sprintf(mapname, "PageantReply%08x", ++id);
485	filemap = CreateFileMapping(INVALID_HANDLE_VALUE,
486	NULL, PAGE_READWRITE,
487	0, outlen+sizeof(int),
488	mapname);
489	} while (filemap == INVALID_HANDLE_VALUE);
490	ret = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0,
491	outlen+sizeof(int));
492	if (ret) {
493	((int )ret) = outlen;
494	memcpy(((int *)ret)+1, out, outlen);
495	UnmapViewOfFile(ret);
496	return id;
497	}
498	} else
499	return 0; /* invalid request */
500	}
501	break;
502	case WM_CLOSEMEM:
503	/*
504	* FIXME!
505	*/
506	break;
507	}
508
509	return DefWindowProc (hwnd, message, wParam, lParam);
510	}
511
512	int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) {
513	WNDCLASS wndclass;
5c58ad2d	514	MSG msg;
	515
	516	instance = inst;
	517
	518	if (!prev) {
	519	wndclass.style = 0;
	520	wndclass.lpfnWndProc = WndProc;
	521	wndclass.cbClsExtra = 0;
	522	wndclass.cbWndExtra = 0;
	523	wndclass.hInstance = inst;
	524	wndclass.hIcon = LoadIcon (inst,
	525	MAKEINTRESOURCE(IDI_MAINICON));
	526	wndclass.hCursor = LoadCursor (NULL, IDC_IBEAM);
	527	wndclass.hbrBackground = GetStockObject (BLACK_BRUSH);
	528	wndclass.lpszMenuName = NULL;
	529	wndclass.lpszClassName = APPNAME;
	530
	531	RegisterClass (&wndclass);
	532	}
	533
	534	hwnd = keylist = NULL;
	535
	536	hwnd = CreateWindow (APPNAME, APPNAME,
	537	WS_OVERLAPPEDWINDOW \| WS_VSCROLL,
	538	CW_USEDEFAULT, CW_USEDEFAULT,
	539	100, 100, NULL, NULL, inst, NULL);
	540
	541	/* Set up a system tray icon */
	542	{
	543	BOOL res;
	544	NOTIFYICONDATA tnid;
	545	HICON hicon;
	546
	547	#ifdef NIM_SETVERSION
	548	tnid.uVersion = 0;
	549	res = Shell_NotifyIcon(NIM_SETVERSION, &tnid);
	550	#endif
	551
	552	tnid.cbSize = sizeof(NOTIFYICONDATA);
	553	tnid.hWnd = hwnd;
	554	tnid.uID = 1; /* unique within this systray use */
	555	tnid.uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
	556	tnid.uCallbackMessage = WM_SYSTRAY;
	557	tnid.hIcon = hicon = LoadIcon (instance, MAKEINTRESOURCE(201));
	558	strcpy(tnid.szTip, "Pageant (PuTTY authentication agent)");
	559
	560	res = Shell_NotifyIcon(NIM_ADD, &tnid);
	561
	562	if (hicon)
	563	DestroyIcon(hicon);
	564
	565	systray_menu = CreatePopupMenu();
	566	AppendMenu (systray_menu, MF_ENABLED, IDM_VIEWKEYS, "View Keys");
	567	AppendMenu (systray_menu, MF_ENABLED, IDM_CLOSE, "Terminate");
	568	}
	569
	570	ShowWindow (hwnd, SW_HIDE);
	571
	572	/*
dacbd0e8	573	* Initialise storage for RSA keys.
	574	*/
	575	rsakeys = newtree234(cmpkeys);
	576
	577	/*
	578	* Process the command line and add RSA keys as listed on it.
	579	* FIXME: we don't support spaces in filenames here. We should.
5c58ad2d	580	*/
5c58ad2d	581	{
dacbd0e8	582	char *p = cmdline;
	583	while (*p) {
	584	while (p && isspace(p)) p++;
	585	if (p && !isspace(p)) {
	586	char *q = p;
	587	while (p && !isspace(p)) p++;
	588	if (p) p++ = '\0';
	589	add_keyfile(q);
	590	}
	591	}
5c58ad2d	592	}
	593
	594	/*
dacbd0e8	595	* Main message loop.
5c58ad2d	596	*/
5c58ad2d	597	while (GetMessage(&msg, NULL, 0, 0) == 1) {
	598	TranslateMessage(&msg);
	599	DispatchMessage(&msg);
	600	}
	601
	602	/* Clean up the system tray icon */
	603	{
	604	NOTIFYICONDATA tnid;
	605
	606	tnid.cbSize = sizeof(NOTIFYICONDATA);
	607	tnid.hWnd = hwnd;
	608	tnid.uID = 1;
	609
	610	Shell_NotifyIcon(NIM_DELETE, &tnid);
	611
	612	DestroyMenu(systray_menu);
	613	}
	614
	615	exit(msg.wParam);
	616	}