projects / u / mdw / putty / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
When a userpass interaction has finished, make sure the 'prompts' structure
[u/mdw/putty] / ssh.c
CommitLineData
374330e2 1#include <stdio.h>
2#include <stdlib.h>
fb09bf1c 3#include <stdarg.h>
4#include <assert.h>
374330e2 5
6#include "putty.h"
dacbd0e8 7#include "tree234.h"
fb09bf1c 8#include "ssh.h"
374330e2 9
10#ifndef FALSE
11#define FALSE 0
12#endif
13#ifndef TRUE
14#define TRUE 1
15#endif
16
32874aea 17#define SSH1_MSG_DISCONNECT 1 /* 0x1 */
18#define SSH1_SMSG_PUBLIC_KEY 2 /* 0x2 */
19#define SSH1_CMSG_SESSION_KEY 3 /* 0x3 */
20#define SSH1_CMSG_USER 4 /* 0x4 */
21#define SSH1_CMSG_AUTH_RSA 6 /* 0x6 */
22#define SSH1_SMSG_AUTH_RSA_CHALLENGE 7 /* 0x7 */
23#define SSH1_CMSG_AUTH_RSA_RESPONSE 8 /* 0x8 */
24#define SSH1_CMSG_AUTH_PASSWORD 9 /* 0x9 */
25#define SSH1_CMSG_REQUEST_PTY 10 /* 0xa */
26#define SSH1_CMSG_WINDOW_SIZE 11 /* 0xb */
27#define SSH1_CMSG_EXEC_SHELL 12 /* 0xc */
28#define SSH1_CMSG_EXEC_CMD 13 /* 0xd */
29#define SSH1_SMSG_SUCCESS 14 /* 0xe */
30#define SSH1_SMSG_FAILURE 15 /* 0xf */
31#define SSH1_CMSG_STDIN_DATA 16 /* 0x10 */
32#define SSH1_SMSG_STDOUT_DATA 17 /* 0x11 */
33#define SSH1_SMSG_STDERR_DATA 18 /* 0x12 */
34#define SSH1_CMSG_EOF 19 /* 0x13 */
35#define SSH1_SMSG_EXIT_STATUS 20 /* 0x14 */
36#define SSH1_MSG_CHANNEL_OPEN_CONFIRMATION 21 /* 0x15 */
37#define SSH1_MSG_CHANNEL_OPEN_FAILURE 22 /* 0x16 */
38#define SSH1_MSG_CHANNEL_DATA 23 /* 0x17 */
39#define SSH1_MSG_CHANNEL_CLOSE 24 /* 0x18 */
40#define SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION 25 /* 0x19 */
41#define SSH1_SMSG_X11_OPEN 27 /* 0x1b */
42#define SSH1_CMSG_PORT_FORWARD_REQUEST 28 /* 0x1c */
43#define SSH1_MSG_PORT_OPEN 29 /* 0x1d */
44#define SSH1_CMSG_AGENT_REQUEST_FORWARDING 30 /* 0x1e */
45#define SSH1_SMSG_AGENT_OPEN 31 /* 0x1f */
46#define SSH1_MSG_IGNORE 32 /* 0x20 */
47#define SSH1_CMSG_EXIT_CONFIRMATION 33 /* 0x21 */
48#define SSH1_CMSG_X11_REQUEST_FORWARDING 34 /* 0x22 */
49#define SSH1_CMSG_AUTH_RHOSTS_RSA 35 /* 0x23 */
50#define SSH1_MSG_DEBUG 36 /* 0x24 */
51#define SSH1_CMSG_REQUEST_COMPRESSION 37 /* 0x25 */
52#define SSH1_CMSG_AUTH_TIS 39 /* 0x27 */
53#define SSH1_SMSG_AUTH_TIS_CHALLENGE 40 /* 0x28 */
54#define SSH1_CMSG_AUTH_TIS_RESPONSE 41 /* 0x29 */
55#define SSH1_CMSG_AUTH_CCARD 70 /* 0x46 */
56#define SSH1_SMSG_AUTH_CCARD_CHALLENGE 71 /* 0x47 */
57#define SSH1_CMSG_AUTH_CCARD_RESPONSE 72 /* 0x48 */
58
59#define SSH1_AUTH_TIS 5 /* 0x5 */
60#define SSH1_AUTH_CCARD 16 /* 0x10 */
61
62#define SSH1_PROTOFLAG_SCREEN_NUMBER 1 /* 0x1 */
b96dc54c 63/* Mask for protoflags we will echo back to server if seen */
32874aea 64#define SSH1_PROTOFLAGS_SUPPORTED 0 /* 0x1 */
65
66#define SSH2_MSG_DISCONNECT 1 /* 0x1 */
67#define SSH2_MSG_IGNORE 2 /* 0x2 */
68#define SSH2_MSG_UNIMPLEMENTED 3 /* 0x3 */
69#define SSH2_MSG_DEBUG 4 /* 0x4 */
70#define SSH2_MSG_SERVICE_REQUEST 5 /* 0x5 */
71#define SSH2_MSG_SERVICE_ACCEPT 6 /* 0x6 */
72#define SSH2_MSG_KEXINIT 20 /* 0x14 */
73#define SSH2_MSG_NEWKEYS 21 /* 0x15 */
74#define SSH2_MSG_KEXDH_INIT 30 /* 0x1e */
75#define SSH2_MSG_KEXDH_REPLY 31 /* 0x1f */
76#define SSH2_MSG_KEX_DH_GEX_REQUEST 30 /* 0x1e */
77#define SSH2_MSG_KEX_DH_GEX_GROUP 31 /* 0x1f */
78#define SSH2_MSG_KEX_DH_GEX_INIT 32 /* 0x20 */
79#define SSH2_MSG_KEX_DH_GEX_REPLY 33 /* 0x21 */
80#define SSH2_MSG_USERAUTH_REQUEST 50 /* 0x32 */
81#define SSH2_MSG_USERAUTH_FAILURE 51 /* 0x33 */
82#define SSH2_MSG_USERAUTH_SUCCESS 52 /* 0x34 */
83#define SSH2_MSG_USERAUTH_BANNER 53 /* 0x35 */
84#define SSH2_MSG_USERAUTH_PK_OK 60 /* 0x3c */
85#define SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ 60 /* 0x3c */
761187b6 86#define SSH2_MSG_USERAUTH_INFO_REQUEST 60 /* 0x3c */
87#define SSH2_MSG_USERAUTH_INFO_RESPONSE 61 /* 0x3d */
32874aea 88#define SSH2_MSG_GLOBAL_REQUEST 80 /* 0x50 */
89#define SSH2_MSG_REQUEST_SUCCESS 81 /* 0x51 */
90#define SSH2_MSG_REQUEST_FAILURE 82 /* 0x52 */
91#define SSH2_MSG_CHANNEL_OPEN 90 /* 0x5a */
92#define SSH2_MSG_CHANNEL_OPEN_CONFIRMATION 91 /* 0x5b */
93#define SSH2_MSG_CHANNEL_OPEN_FAILURE 92 /* 0x5c */
94#define SSH2_MSG_CHANNEL_WINDOW_ADJUST 93 /* 0x5d */
95#define SSH2_MSG_CHANNEL_DATA 94 /* 0x5e */
96#define SSH2_MSG_CHANNEL_EXTENDED_DATA 95 /* 0x5f */
97#define SSH2_MSG_CHANNEL_EOF 96 /* 0x60 */
98#define SSH2_MSG_CHANNEL_CLOSE 97 /* 0x61 */
99#define SSH2_MSG_CHANNEL_REQUEST 98 /* 0x62 */
100#define SSH2_MSG_CHANNEL_SUCCESS 99 /* 0x63 */
101#define SSH2_MSG_CHANNEL_FAILURE 100 /* 0x64 */
102
00db133f 103/*
104 * Packet type contexts, so that ssh2_pkt_type can correctly decode
105 * the ambiguous type numbers back into the correct type strings.
106 */
d1aaf71d 107#define SSH2_PKTCTX_DHGROUP 0x0001
00db133f 108#define SSH2_PKTCTX_DHGEX 0x0002
149d2abc 109#define SSH2_PKTCTX_KEX_MASK 0x000F
00db133f 110#define SSH2_PKTCTX_PUBLICKEY 0x0010
111#define SSH2_PKTCTX_PASSWORD 0x0020
112#define SSH2_PKTCTX_KBDINTER 0x0040
113#define SSH2_PKTCTX_AUTH_MASK 0x00F0
114
32874aea 115#define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1 /* 0x1 */
116#define SSH2_DISCONNECT_PROTOCOL_ERROR 2 /* 0x2 */
117#define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED 3 /* 0x3 */
118#define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4 /* 0x4 */
119#define SSH2_DISCONNECT_MAC_ERROR 5 /* 0x5 */
120#define SSH2_DISCONNECT_COMPRESSION_ERROR 6 /* 0x6 */
121#define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE 7 /* 0x7 */
122#define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8 /* 0x8 */
123#define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9 /* 0x9 */
124#define SSH2_DISCONNECT_CONNECTION_LOST 10 /* 0xa */
125#define SSH2_DISCONNECT_BY_APPLICATION 11 /* 0xb */
126#define SSH2_DISCONNECT_TOO_MANY_CONNECTIONS 12 /* 0xc */
127#define SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER 13 /* 0xd */
128#define SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14 /* 0xe */
129#define SSH2_DISCONNECT_ILLEGAL_USER_NAME 15 /* 0xf */
38c4a8da 130
131static const char *const ssh2_disconnect_reasons[] = {
132 NULL,
afb4d0dc 133 "host not allowed to connect",
134 "protocol error",
135 "key exchange failed",
136 "host authentication failed",
1da38d29 137 "MAC error",
afb4d0dc 138 "compression error",
139 "service not available",
140 "protocol version not supported",
141 "host key not verifiable",
142 "connection lost",
143 "by application",
144 "too many connections",
145 "auth cancelled by user",
146 "no more auth methods available",
147 "illegal user name",
38c4a8da 148};
9005f3ba 149
32874aea 150#define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED 1 /* 0x1 */
151#define SSH2_OPEN_CONNECT_FAILED 2 /* 0x2 */
152#define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE 3 /* 0x3 */
153#define SSH2_OPEN_RESOURCE_SHORTAGE 4 /* 0x4 */
d211621f 154
32874aea 155#define SSH2_EXTENDED_DATA_STDERR 1 /* 0x1 */
fb09bf1c 156
7d503c31 157/*
158 * Various remote-bug flags.
159 */
160#define BUG_CHOKES_ON_SSH1_IGNORE 1
161#define BUG_SSH2_HMAC 2
bd358db1 162#define BUG_NEEDS_SSH1_PLAIN_PASSWORD 4
0df73905 163#define BUG_CHOKES_ON_RSA 8
1dd353b5 164#define BUG_SSH2_RSA_PADDING 16
088bde77 165#define BUG_SSH2_DERIVEKEY 32
f382c87d 166#define BUG_SSH2_REKEY 64
dda87a28 167#define BUG_SSH2_PK_SESSIONID 128
bd358db1 168
c6ccd5c2 169/*
170 * Codes for terminal modes.
171 * Most of these are the same in SSH-1 and SSH-2.
172 * This list is derived from draft-ietf-secsh-connect-25 and
173 * SSH-1 RFC-1.2.31.
174 */
175static const struct {
176 const char* const mode;
177 int opcode;
178 enum { TTY_OP_CHAR, TTY_OP_BOOL } type;
179} ssh_ttymodes[] = {
180 /* "V" prefix discarded for special characters relative to SSH specs */
181 { "INTR", 1, TTY_OP_CHAR },
182 { "QUIT", 2, TTY_OP_CHAR },
183 { "ERASE", 3, TTY_OP_CHAR },
184 { "KILL", 4, TTY_OP_CHAR },
185 { "EOF", 5, TTY_OP_CHAR },
186 { "EOL", 6, TTY_OP_CHAR },
187 { "EOL2", 7, TTY_OP_CHAR },
188 { "START", 8, TTY_OP_CHAR },
189 { "STOP", 9, TTY_OP_CHAR },
190 { "SUSP", 10, TTY_OP_CHAR },
191 { "DSUSP", 11, TTY_OP_CHAR },
192 { "REPRINT", 12, TTY_OP_CHAR },
193 { "WERASE", 13, TTY_OP_CHAR },
194 { "LNEXT", 14, TTY_OP_CHAR },
195 { "FLUSH", 15, TTY_OP_CHAR },
196 { "SWTCH", 16, TTY_OP_CHAR },
197 { "STATUS", 17, TTY_OP_CHAR },
198 { "DISCARD", 18, TTY_OP_CHAR },
199 { "IGNPAR", 30, TTY_OP_BOOL },
200 { "PARMRK", 31, TTY_OP_BOOL },
201 { "INPCK", 32, TTY_OP_BOOL },
202 { "ISTRIP", 33, TTY_OP_BOOL },
203 { "INLCR", 34, TTY_OP_BOOL },
204 { "IGNCR", 35, TTY_OP_BOOL },
205 { "ICRNL", 36, TTY_OP_BOOL },
206 { "IUCLC", 37, TTY_OP_BOOL },
207 { "IXON", 38, TTY_OP_BOOL },
208 { "IXANY", 39, TTY_OP_BOOL },
209 { "IXOFF", 40, TTY_OP_BOOL },
210 { "IMAXBEL", 41, TTY_OP_BOOL },
211 { "ISIG", 50, TTY_OP_BOOL },
212 { "ICANON", 51, TTY_OP_BOOL },
213 { "XCASE", 52, TTY_OP_BOOL },
214 { "ECHO", 53, TTY_OP_BOOL },
215 { "ECHOE", 54, TTY_OP_BOOL },
216 { "ECHOK", 55, TTY_OP_BOOL },
217 { "ECHONL", 56, TTY_OP_BOOL },
218 { "NOFLSH", 57, TTY_OP_BOOL },
219 { "TOSTOP", 58, TTY_OP_BOOL },
220 { "IEXTEN", 59, TTY_OP_BOOL },
221 { "ECHOCTL", 60, TTY_OP_BOOL },
222 { "ECHOKE", 61, TTY_OP_BOOL },
223 { "PENDIN", 62, TTY_OP_BOOL }, /* XXX is this a real mode? */
224 { "OPOST", 70, TTY_OP_BOOL },
225 { "OLCUC", 71, TTY_OP_BOOL },
226 { "ONLCR", 72, TTY_OP_BOOL },
227 { "OCRNL", 73, TTY_OP_BOOL },
228 { "ONOCR", 74, TTY_OP_BOOL },
229 { "ONLRET", 75, TTY_OP_BOOL },
230 { "CS7", 90, TTY_OP_BOOL },
231 { "CS8", 91, TTY_OP_BOOL },
232 { "PARENB", 92, TTY_OP_BOOL },
233 { "PARODD", 93, TTY_OP_BOOL }
234};
235
236/* Miscellaneous other tty-related constants. */
237#define SSH_TTY_OP_END 0
238/* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */
239#define SSH1_TTY_OP_ISPEED 192
240#define SSH1_TTY_OP_OSPEED 193
241#define SSH2_TTY_OP_ISPEED 128
242#define SSH2_TTY_OP_OSPEED 129
243
244/* Helper functions for parsing tty-related config. */
245static unsigned int ssh_tty_parse_specchar(char *s)
246{
247 unsigned int ret;
248 if (*s) {
249 char *next = NULL;
250 ret = ctrlparse(s, &next);
251 if (!next) ret = s[0];
252 } else {
253 ret = 255; /* special value meaning "don't set" */
254 }
255 return ret;
256}
257static unsigned int ssh_tty_parse_boolean(char *s)
258{
259 if (stricmp(s, "yes") == 0 ||
260 stricmp(s, "on") == 0 ||
261 stricmp(s, "true") == 0 ||
262 stricmp(s, "+") == 0)
263 return 1; /* true */
264 else if (stricmp(s, "no") == 0 ||
265 stricmp(s, "off") == 0 ||
266 stricmp(s, "false") == 0 ||
267 stricmp(s, "-") == 0)
268 return 0; /* false */
269 else
270 return (atoi(s) != 0);
271}
272
00db133f 273#define translate(x) if (type == x) return #x
51470298 274#define translatec(x,ctx) if (type == x && (pkt_ctx & ctx)) return #x
ae9ae89f 275static char *ssh1_pkt_type(int type)
00db133f 276{
277 translate(SSH1_MSG_DISCONNECT);
278 translate(SSH1_SMSG_PUBLIC_KEY);
279 translate(SSH1_CMSG_SESSION_KEY);
280 translate(SSH1_CMSG_USER);
281 translate(SSH1_CMSG_AUTH_RSA);
282 translate(SSH1_SMSG_AUTH_RSA_CHALLENGE);
283 translate(SSH1_CMSG_AUTH_RSA_RESPONSE);
284 translate(SSH1_CMSG_AUTH_PASSWORD);
285 translate(SSH1_CMSG_REQUEST_PTY);
286 translate(SSH1_CMSG_WINDOW_SIZE);
287 translate(SSH1_CMSG_EXEC_SHELL);
288 translate(SSH1_CMSG_EXEC_CMD);
289 translate(SSH1_SMSG_SUCCESS);
290 translate(SSH1_SMSG_FAILURE);
291 translate(SSH1_CMSG_STDIN_DATA);
292 translate(SSH1_SMSG_STDOUT_DATA);
293 translate(SSH1_SMSG_STDERR_DATA);
294 translate(SSH1_CMSG_EOF);
295 translate(SSH1_SMSG_EXIT_STATUS);
296 translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION);
297 translate(SSH1_MSG_CHANNEL_OPEN_FAILURE);
298 translate(SSH1_MSG_CHANNEL_DATA);
299 translate(SSH1_MSG_CHANNEL_CLOSE);
300 translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION);
301 translate(SSH1_SMSG_X11_OPEN);
302 translate(SSH1_CMSG_PORT_FORWARD_REQUEST);
303 translate(SSH1_MSG_PORT_OPEN);
304 translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING);
305 translate(SSH1_SMSG_AGENT_OPEN);
306 translate(SSH1_MSG_IGNORE);
307 translate(SSH1_CMSG_EXIT_CONFIRMATION);
308 translate(SSH1_CMSG_X11_REQUEST_FORWARDING);
309 translate(SSH1_CMSG_AUTH_RHOSTS_RSA);
310 translate(SSH1_MSG_DEBUG);
311 translate(SSH1_CMSG_REQUEST_COMPRESSION);
312 translate(SSH1_CMSG_AUTH_TIS);
313 translate(SSH1_SMSG_AUTH_TIS_CHALLENGE);
314 translate(SSH1_CMSG_AUTH_TIS_RESPONSE);
315 translate(SSH1_CMSG_AUTH_CCARD);
316 translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE);
317 translate(SSH1_CMSG_AUTH_CCARD_RESPONSE);
318 return "unknown";
319}
ae9ae89f 320static char *ssh2_pkt_type(int pkt_ctx, int type)
00db133f 321{
322 translate(SSH2_MSG_DISCONNECT);
323 translate(SSH2_MSG_IGNORE);
324 translate(SSH2_MSG_UNIMPLEMENTED);
325 translate(SSH2_MSG_DEBUG);
326 translate(SSH2_MSG_SERVICE_REQUEST);
327 translate(SSH2_MSG_SERVICE_ACCEPT);
328 translate(SSH2_MSG_KEXINIT);
329 translate(SSH2_MSG_NEWKEYS);
d1aaf71d 330 translatec(SSH2_MSG_KEXDH_INIT, SSH2_PKTCTX_DHGROUP);
331 translatec(SSH2_MSG_KEXDH_REPLY, SSH2_PKTCTX_DHGROUP);
00db133f 332 translatec(SSH2_MSG_KEX_DH_GEX_REQUEST, SSH2_PKTCTX_DHGEX);
333 translatec(SSH2_MSG_KEX_DH_GEX_GROUP, SSH2_PKTCTX_DHGEX);
334 translatec(SSH2_MSG_KEX_DH_GEX_INIT, SSH2_PKTCTX_DHGEX);
335 translatec(SSH2_MSG_KEX_DH_GEX_REPLY, SSH2_PKTCTX_DHGEX);
336 translate(SSH2_MSG_USERAUTH_REQUEST);
337 translate(SSH2_MSG_USERAUTH_FAILURE);
338 translate(SSH2_MSG_USERAUTH_SUCCESS);
339 translate(SSH2_MSG_USERAUTH_BANNER);
340 translatec(SSH2_MSG_USERAUTH_PK_OK, SSH2_PKTCTX_PUBLICKEY);
341 translatec(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, SSH2_PKTCTX_PASSWORD);
342 translatec(SSH2_MSG_USERAUTH_INFO_REQUEST, SSH2_PKTCTX_KBDINTER);
343 translatec(SSH2_MSG_USERAUTH_INFO_RESPONSE, SSH2_PKTCTX_KBDINTER);
344 translate(SSH2_MSG_GLOBAL_REQUEST);
345 translate(SSH2_MSG_REQUEST_SUCCESS);
346 translate(SSH2_MSG_REQUEST_FAILURE);
347 translate(SSH2_MSG_CHANNEL_OPEN);
348 translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
349 translate(SSH2_MSG_CHANNEL_OPEN_FAILURE);
350 translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
351 translate(SSH2_MSG_CHANNEL_DATA);
352 translate(SSH2_MSG_CHANNEL_EXTENDED_DATA);
353 translate(SSH2_MSG_CHANNEL_EOF);
354 translate(SSH2_MSG_CHANNEL_CLOSE);
355 translate(SSH2_MSG_CHANNEL_REQUEST);
356 translate(SSH2_MSG_CHANNEL_SUCCESS);
357 translate(SSH2_MSG_CHANNEL_FAILURE);
358 return "unknown";
359}
360#undef translate
361#undef translatec
7d503c31 362
9a10ecf4 363/* Enumeration values for fields in SSH-1 packets */
364enum {
365 PKT_END, PKT_INT, PKT_CHAR, PKT_DATA, PKT_STR, PKT_BIGNUM,
366 /* These values are for communicating relevant semantics of
367 * fields to the packet logging code. */
368 PKTT_OTHER, PKTT_PASSWORD, PKTT_DATA
369};
972a41c8 370
acddebd9 371/*
372 * Coroutine mechanics for the sillier bits of the code. If these
373 * macros look impenetrable to you, you might find it helpful to
374 * read
375 *
376 * http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
377 *
378 * which explains the theory behind these macros.
b624d1e6 379 *
380 * In particular, if you are getting `case expression not constant'
381 * errors when building with MS Visual Studio, this is because MS's
382 * Edit and Continue debugging feature causes their compiler to
383 * violate ANSI C. To disable Edit and Continue debugging:
384 *
385 * - right-click ssh.c in the FileView
386 * - click Settings
387 * - select the C/C++ tab and the General category
388 * - under `Debug info:', select anything _other_ than `Program
389 * Database for Edit and Continue'.
acddebd9 390 */
51470298 391#define crBegin(v) { int *crLine = &v; switch(v) { case 0:;
392#define crState(t) \
393 struct t *s; \
3d88e64d 394 if (!ssh->t) ssh->t = snew(struct t); \
51470298 395 s = ssh->t;
396#define crFinish(z) } *crLine = 0; return (z); }
397#define crFinishV } *crLine = 0; return; }
374330e2 398#define crReturn(z) \
399 do {\
51470298 400 *crLine =__LINE__; return (z); case __LINE__:;\
374330e2 401 } while (0)
402#define crReturnV \
403 do {\
51470298 404 *crLine=__LINE__; return; case __LINE__:;\
374330e2 405 } while (0)
51470298 406#define crStop(z) do{ *crLine = 0; return (z); }while(0)
407#define crStopV do{ *crLine = 0; return; }while(0)
fb09bf1c 408#define crWaitUntil(c) do { crReturn(0); } while (!(c))
7cca0d81 409#define crWaitUntilV(c) do { crReturnV; } while (!(c))
374330e2 410
51470298 411typedef struct ssh_tag *Ssh;
ff3187f6 412struct Packet;
413
dacd8872 414static struct Packet *ssh1_pkt_init(int pkt_type);
ff3187f6 415static struct Packet *ssh2_pkt_init(int pkt_type);
dacd8872 416static void ssh_pkt_ensure(struct Packet *, int length);
417static void ssh_pkt_adddata(struct Packet *, void *data, int len);
418static void ssh_pkt_addbyte(struct Packet *, unsigned char value);
ff3187f6 419static void ssh2_pkt_addbool(struct Packet *, unsigned char value);
dacd8872 420static void ssh_pkt_adduint32(struct Packet *, unsigned long value);
421static void ssh_pkt_addstring_start(struct Packet *);
422static void ssh_pkt_addstring_str(struct Packet *, char *data);
423static void ssh_pkt_addstring_data(struct Packet *, char *data, int len);
424static void ssh_pkt_addstring(struct Packet *, char *data);
d8baa528 425static unsigned char *ssh2_mpint_fmt(Bignum b, int *len);
dacd8872 426static void ssh1_pkt_addmp(struct Packet *, Bignum b);
ff3187f6 427static void ssh2_pkt_addmp(struct Packet *, Bignum b);
428static int ssh2_pkt_construct(Ssh, struct Packet *);
429static void ssh2_pkt_send(Ssh, struct Packet *);
590f6a5f 430static void ssh2_pkt_send_noqueue(Ssh, struct Packet *);
ff3187f6 431static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
432 struct Packet *pktin);
433static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
434 struct Packet *pktin);
3d63ca2e 435
5471d09a 436/*
437 * Buffer management constants. There are several of these for
438 * various different purposes:
439 *
440 * - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
441 * on a local data stream before we throttle the whole SSH
2e85c969 442 * connection (in SSH-1 only). Throttling the whole connection is
5471d09a 443 * pretty drastic so we set this high in the hope it won't
444 * happen very often.
445 *
446 * - SSH_MAX_BACKLOG is the amount of backlog that must build up
447 * on the SSH connection itself before we defensively throttle
448 * _all_ local data streams. This is pretty drastic too (though
2e85c969 449 * thankfully unlikely in SSH-2 since the window mechanism should
5471d09a 450 * ensure that the server never has any need to throttle its end
451 * of the connection), so we set this high as well.
452 *
2e85c969 453 * - OUR_V2_WINSIZE is the maximum window size we present on SSH-2
5471d09a 454 * channels.
455 */
456
457#define SSH1_BUFFER_LIMIT 32768
458#define SSH_MAX_BACKLOG 32768
459#define OUR_V2_WINSIZE 16384
954d5c5a 460#define OUR_V2_MAXPKT 0x4000UL
d74d141c 461
edd0cb8a 462/* Maximum length of passwords/passphrases (arbitrary) */
463#define SSH_MAX_PASSWORD_LEN 100
464
85cc02bb 465const static struct ssh_signkey *hostkey_algs[] = { &ssh_rsa, &ssh_dss };
e5574168 466
8b2715b2 467const static struct ssh_mac *macs[] = {
6668a75e 468 &ssh_hmac_sha1, &ssh_hmac_sha1_96, &ssh_hmac_md5
32874aea 469};
8b2715b2 470const static struct ssh_mac *buggymacs[] = {
6668a75e 471 &ssh_hmac_sha1_buggy, &ssh_hmac_sha1_96_buggy, &ssh_hmac_md5
32874aea 472};
e5574168 473
5366aed8 474static void *ssh_comp_none_init(void)
475{
476 return NULL;
477}
478static void ssh_comp_none_cleanup(void *handle)
32874aea 479{
480}
5366aed8 481static int ssh_comp_none_block(void *handle, unsigned char *block, int len,
32874aea 482 unsigned char **outblock, int *outlen)
483{
484 return 0;
485}
5366aed8 486static int ssh_comp_none_disable(void *handle)
32874aea 487{
4ba9b64b 488 return 0;
489}
57476f6b 490const static struct ssh_compress ssh_comp_none = {
4ba9b64b 491 "none",
5366aed8 492 ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
493 ssh_comp_none_init, ssh_comp_none_cleanup, ssh_comp_none_block,
494 ssh_comp_none_disable, NULL
e5574168 495};
4ba9b64b 496extern const struct ssh_compress ssh_zlib;
497const static struct ssh_compress *compressions[] = {
32874aea 498 &ssh_zlib, &ssh_comp_none
499};
374330e2 500
32874aea 501enum { /* channel types */
783415f8 502 CHAN_MAINSESSION,
503 CHAN_X11,
504 CHAN_AGENT,
bc240b21 505 CHAN_SOCKDATA,
506 CHAN_SOCKDATA_DORMANT /* one the remote hasn't confirmed */
783415f8 507};
508
dacbd0e8 509/*
510 * 2-3-4 tree storing channels.
511 */
512struct ssh_channel {
51470298 513 Ssh ssh; /* pointer back to main context */
d211621f 514 unsigned remoteid, localid;
dacbd0e8 515 int type;
64d6ff88 516 /* True if we opened this channel but server hasn't confirmed. */
517 int halfopen;
0357890f 518 /*
2e85c969 519 * In SSH-1, this value contains four bits:
0357890f 520 *
521 * 1 We have sent SSH1_MSG_CHANNEL_CLOSE.
522 * 2 We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
523 * 4 We have received SSH1_MSG_CHANNEL_CLOSE.
524 * 8 We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
525 *
526 * A channel is completely finished with when all four bits are set.
527 */
dacbd0e8 528 int closes;
5471d09a 529 union {
530 struct ssh1_data_channel {
531 int throttling;
532 } v1;
533 struct ssh2_data_channel {
534 bufchain outbuffer;
535 unsigned remwindow, remmaxpkt;
536 unsigned locwindow;
537 } v2;
538 } v;
dacbd0e8 539 union {
32874aea 540 struct ssh_agent_channel {
541 unsigned char *message;
542 unsigned char msglen[4];
a03c9f9c 543 unsigned lensofar, totallen;
32874aea 544 } a;
545 struct ssh_x11_channel {
546 Socket s;
547 } x11;
d74d141c 548 struct ssh_pfd_channel {
549 Socket s;
550 } pfd;
dacbd0e8 551 } u;
552};
57476f6b 553
d74d141c 554/*
2e85c969 555 * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2
556 * use this structure in different ways, reflecting SSH-2's
bc240b21 557 * altogether saner approach to port forwarding.
558 *
2e85c969 559 * In SSH-1, you arrange a remote forwarding by sending the server
bc240b21 560 * the remote port number, and the local destination host:port.
561 * When a connection comes in, the server sends you back that
562 * host:port pair, and you connect to it. This is a ready-made
563 * security hole if you're not on the ball: a malicious server
564 * could send you back _any_ host:port pair, so if you trustingly
565 * connect to the address it gives you then you've just opened the
566 * entire inside of your corporate network just by connecting
567 * through it to a dodgy SSH server. Hence, we must store a list of
568 * host:port pairs we _are_ trying to forward to, and reject a
569 * connection request from the server if it's not in the list.
570 *
2e85c969 571 * In SSH-2, each side of the connection minds its own business and
bc240b21 572 * doesn't send unnecessary information to the other. You arrange a
573 * remote forwarding by sending the server just the remote port
574 * number. When a connection comes in, the server tells you which
575 * of its ports was connected to; and _you_ have to remember what
576 * local host:port pair went with that port number.
577 *
2e85c969 578 * Hence, in SSH-1 this structure is indexed by destination
579 * host:port pair, whereas in SSH-2 it is indexed by source port.
d74d141c 580 */
fda2feb1 581struct ssh_portfwd; /* forward declaration */
582
d74d141c 583struct ssh_rportfwd {
bc240b21 584 unsigned sport, dport;
585 char dhost[256];
06fadff5 586 char *sportdesc;
fda2feb1 587 struct ssh_portfwd *pfrec;
d74d141c 588};
fda2feb1 589#define free_rportfwd(pf) ( \
590 ((pf) ? (sfree((pf)->sportdesc)) : (void)0 ), sfree(pf) )
591
592/*
593 * Separately to the rportfwd tree (which is for looking up port
594 * open requests from the server), a tree of _these_ structures is
595 * used to keep track of all the currently open port forwardings,
596 * so that we can reconfigure in mid-session if the user requests
597 * it.
598 */
599struct ssh_portfwd {
84328ddb 600 enum { DESTROY, KEEP, CREATE } status;
fda2feb1 601 int type;
602 unsigned sport, dport;
603 char *saddr, *daddr;
3fe92132 604 char *sserv, *dserv;
fda2feb1 605 struct ssh_rportfwd *remote;
05581745 606 int addressfamily;
fda2feb1 607 void *local;
608};
609#define free_portfwd(pf) ( \
3fe92132 610 ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr), \
611 sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) )
d74d141c 612
57476f6b 613struct Packet {
dacd8872 614 long length; /* length of `data' actually used */
615 long forcepad; /* SSH-2: force padding to at least this length */
616 int type; /* only used for incoming packets */
617 unsigned long sequence; /* SSH-2 incoming sequence number */
618 unsigned char *data; /* allocated storage */
619 unsigned char *body; /* offset of payload within `data' */
620 long savedpos; /* temporary index into `data' (for strings) */
621 long maxlen; /* amount of storage allocated for `data' */
622 long encrypted_len; /* for SSH-2 total-size counting */
ff3187f6 623
624 /*
625 * State associated with packet logging
626 */
627 int logmode;
628 int nblanks;
629 struct logblank_t *blanks;
57476f6b 630};
631
1c1a7262 632static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
ff3187f6 633 struct Packet *pktin);
1c1a7262 634static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
ff3187f6 635 struct Packet *pktin);
b09eaa88 636static void ssh1_protocol_setup(Ssh ssh);
637static void ssh2_protocol_setup(Ssh ssh);
51470298 638static void ssh_size(void *handle, int width, int height);
639static void ssh_special(void *handle, Telnet_Special);
5471d09a 640static int ssh2_try_send(struct ssh_channel *c);
51470298 641static void ssh2_add_channel_data(struct ssh_channel *c, char *buf, int len);
642static void ssh_throttle_all(Ssh ssh, int enable, int bufsize);
5471d09a 643static void ssh2_set_window(struct ssh_channel *c, unsigned newwin);
51470298 644static int ssh_sendbuffer(void *handle);
ac934965 645static int ssh_do_close(Ssh ssh, int notify_exit);
ff3187f6 646static unsigned long ssh_pkt_getuint32(struct Packet *pkt);
647static int ssh2_pkt_getbool(struct Packet *pkt);
648static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length);
9442dd57 649static void ssh2_timer(void *ctx, long now);
1c1a7262 650static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
9442dd57 651 struct Packet *pktin);
57476f6b 652
51470298 653struct rdpkt1_state_tag {
57476f6b 654 long len, pad, biglen, to_read;
655 unsigned long realcrc, gotcrc;
656 unsigned char *p;
657 int i;
658 int chunk;
ff3187f6 659 struct Packet *pktin;
51470298 660};
57476f6b 661
51470298 662struct rdpkt2_state_tag {
960e736a 663 long len, pad, payload, packetlen, maclen;
664 int i;
665 int cipherblk;
666 unsigned long incoming_sequence;
ff3187f6 667 struct Packet *pktin;
51470298 668};
669
b09eaa88 670typedef void (*handler_fn_t)(Ssh ssh, struct Packet *pktin);
06fadff5 671typedef void (*chandler_fn_t)(Ssh ssh, struct Packet *pktin, void *ctx);
672
673struct queued_handler;
674struct queued_handler {
675 int msg1, msg2;
676 chandler_fn_t handler;
677 void *ctx;
678 struct queued_handler *next;
679};
b09eaa88 680
51470298 681struct ssh_tag {
682 const struct plug_function_table *fn;
683 /* the above field _must_ be first in the structure */
684
4320baf7 685 char *v_c, *v_s;
b672f405 686 void *exhash;
51470298 687
688 Socket s;
689
b9d7bcad 690 void *ldisc;
a8327734 691 void *logctx;
b9d7bcad 692
51470298 693 unsigned char session_key[32];
694 int v1_compressing;
695 int v1_remote_protoflags;
696 int v1_local_protoflags;
697 int agentfwd_enabled;
698 int X11_fwd_enabled;
699 int remote_bugs;
700 const struct ssh_cipher *cipher;
371e569c 701 void *v1_cipher_ctx;
0183b242 702 void *crcda_ctx;
51470298 703 const struct ssh2_cipher *cscipher, *sccipher;
371e569c 704 void *cs_cipher_ctx, *sc_cipher_ctx;
51470298 705 const struct ssh_mac *csmac, *scmac;
e0e1a00d 706 void *cs_mac_ctx, *sc_mac_ctx;
51470298 707 const struct ssh_compress *cscomp, *sccomp;
5366aed8 708 void *cs_comp_ctx, *sc_comp_ctx;
51470298 709 const struct ssh_kex *kex;
710 const struct ssh_signkey *hostkey;
2ccb2fc8 711 unsigned char v2_session_id[32];
b672f405 712 int v2_session_id_len;
27cd7fc2 713 void *kex_ctx;
51470298 714
715 char *savedhost;
716 int savedport;
717 int send_ok;
718 int echoing, editing;
719
720 void *frontend;
721
db219738 722 int ospeed, ispeed; /* temporaries */
51470298 723 int term_width, term_height;
724
725 tree234 *channels; /* indexed by local id */
726 struct ssh_channel *mainchan; /* primary session channel */
727 int exitcode;
ac934965 728 int close_expected;
9e296bfa 729 int clean_exit;
51470298 730
fda2feb1 731 tree234 *rportfwds, *portfwds;
51470298 732
733 enum {
734 SSH_STATE_PREPACKET,
735 SSH_STATE_BEFORE_SIZE,
736 SSH_STATE_INTERMED,
737 SSH_STATE_SESSION,
738 SSH_STATE_CLOSED
739 } state;
740
741 int size_needed, eof_needed;
742
590f6a5f 743 struct Packet **queue;
744 int queuelen, queuesize;
745 int queueing;
51470298 746 unsigned char *deferred_send_data;
747 int deferred_len, deferred_size;
748
749 /*
750 * Gross hack: pscp will try to start SFTP but fall back to
751 * scp1 if that fails. This variable is the means by which
752 * scp.c can reach into the SSH code and find out which one it
753 * got.
754 */
755 int fallback_cmd;
756
6bbce591 757 bufchain banner; /* accumulates banners during do_ssh2_authconn */
51470298 758
51470298 759 int pkt_ctx;
760
302121de 761 void *x11auth;
762
51470298 763 int version;
764 int v1_throttle_count;
765 int overall_bufsize;
766 int throttled_all;
767 int v1_stdout_throttling;
a8756193 768 unsigned long v2_outgoing_sequence;
51470298 769
770 int ssh1_rdpkt_crstate;
771 int ssh2_rdpkt_crstate;
772 int do_ssh_init_crstate;
773 int ssh_gotdata_crstate;
51470298 774 int do_ssh1_login_crstate;
b09eaa88 775 int do_ssh1_connection_crstate;
51470298 776 int do_ssh2_transport_crstate;
777 int do_ssh2_authconn_crstate;
778
779 void *do_ssh_init_state;
780 void *do_ssh1_login_state;
781 void *do_ssh2_transport_state;
782 void *do_ssh2_authconn_state;
783
784 struct rdpkt1_state_tag rdpkt1_state;
785 struct rdpkt2_state_tag rdpkt2_state;
786
2e85c969 787 /* SSH-1 and SSH-2 use this for different things, but both use it */
b09eaa88 788 int protocol_initial_phase_done;
789
1c1a7262 790 void (*protocol) (Ssh ssh, void *vin, int inlen,
ff3187f6 791 struct Packet *pkt);
792 struct Packet *(*s_rdpkt) (Ssh ssh, unsigned char **data, int *datalen);
86916870 793
794 /*
795 * We maintain a full _copy_ of a Config structure here, not
796 * merely a pointer to it. That way, when we're passed a new
797 * one for reconfiguration, we can check the differences and
798 * potentially reconfigure port forwardings etc in mid-session.
799 */
800 Config cfg;
839f10db 801
802 /*
3d9449a1 803 * Used to transfer data back from async callbacks.
839f10db 804 */
805 void *agent_response;
806 int agent_response_len;
3d9449a1 807 int user_response;
808
809 /*
810 * The SSH connection can be set as `frozen', meaning we are
811 * not currently accepting incoming data from the network. This
812 * is slightly more serious than setting the _socket_ as
813 * frozen, because we may already have had data passed to us
814 * from the network which we need to delay processing until
815 * after the freeze is lifted, so we also need a bufchain to
816 * store that data.
817 */
818 int frozen;
819 bufchain queued_incoming_data;
b09eaa88 820
821 /*
822 * Dispatch table for packet types that we may have to deal
823 * with at any time.
824 */
825 handler_fn_t packet_dispatch[256];
39934deb 826
827 /*
06fadff5 828 * Queues of one-off handler functions for success/failure
829 * indications from a request.
830 */
831 struct queued_handler *qhead, *qtail;
832
833 /*
39934deb 834 * This module deals with sending keepalives.
835 */
836 Pinger pinger;
9442dd57 837
838 /*
839 * Track incoming and outgoing data sizes and time, for
840 * size-based rekeys.
841 */
842 unsigned long incoming_data_size, outgoing_data_size, deferred_data_size;
d57f70af 843 unsigned long max_data_size;
9442dd57 844 int kex_in_progress;
e6c1536e 845 long next_rekey, last_rekey;
e13bba36 846 char *deferred_rekey_reason; /* points to STATIC string; don't free */
51470298 847};
960e736a 848
382908ad 849#define logevent(s) logevent(ssh->frontend, s)
a8327734 850
851/* logevent, only printf-formatted. */
cbe2d68f 852static void logeventf(Ssh ssh, const char *fmt, ...)
a8327734 853{
854 va_list ap;
57356d63 855 char *buf;
a8327734 856
857 va_start(ap, fmt);
57356d63 858 buf = dupvprintf(fmt, ap);
a8327734 859 va_end(ap);
57356d63 860 logevent(buf);
57356d63 861 sfree(buf);
a8327734 862}
863
6b5cf8b4 864#define bombout(msg) \
865 do { \
866 char *text = dupprintf msg; \
ac934965 867 ssh_do_close(ssh, FALSE); \
6b5cf8b4 868 logevent(text); \
869 connection_fatal(ssh->frontend, "%s", text); \
870 sfree(text); \
871 } while (0)
a8327734 872
9a10ecf4 873/* Functions to leave bits out of the SSH packet log file. */
874
ff3187f6 875static void dont_log_password(Ssh ssh, struct Packet *pkt, int blanktype)
9a10ecf4 876{
877 if (ssh->cfg.logomitpass)
ff3187f6 878 pkt->logmode = blanktype;
9a10ecf4 879}
880
ff3187f6 881static void dont_log_data(Ssh ssh, struct Packet *pkt, int blanktype)
9a10ecf4 882{
883 if (ssh->cfg.logomitdata)
ff3187f6 884 pkt->logmode = blanktype;
9a10ecf4 885}
886
ff3187f6 887static void end_log_omission(Ssh ssh, struct Packet *pkt)
9a10ecf4 888{
ff3187f6 889 pkt->logmode = PKTLOG_EMIT;
9a10ecf4 890}
891
c6ccd5c2 892/* Helper function for common bits of parsing cfg.ttymodes. */
893static void parse_ttymodes(Ssh ssh, char *modes,
894 void (*do_mode)(void *data, char *mode, char *val),
895 void *data)
896{
897 while (*modes) {
898 char *t = strchr(modes, '\t');
899 char *m = snewn(t-modes+1, char);
900 char *val;
901 strncpy(m, modes, t-modes);
902 m[t-modes] = '\0';
903 if (*(t+1) == 'A')
904 val = get_ttymode(ssh->frontend, m);
905 else
906 val = dupstr(t+2);
907 if (val)
908 do_mode(data, m, val);
909 sfree(m);
910 sfree(val);
911 modes += strlen(modes) + 1;
912 }
913}
914
32874aea 915static int ssh_channelcmp(void *av, void *bv)
916{
917 struct ssh_channel *a = (struct ssh_channel *) av;
918 struct ssh_channel *b = (struct ssh_channel *) bv;
919 if (a->localid < b->localid)
920 return -1;
921 if (a->localid > b->localid)
922 return +1;
dacbd0e8 923 return 0;
924}
32874aea 925static int ssh_channelfind(void *av, void *bv)
926{
927 unsigned *a = (unsigned *) av;
928 struct ssh_channel *b = (struct ssh_channel *) bv;
929 if (*a < b->localid)
930 return -1;
931 if (*a > b->localid)
932 return +1;
dacbd0e8 933 return 0;
934}
935
bc240b21 936static int ssh_rportcmp_ssh1(void *av, void *bv)
d74d141c 937{
938 struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
939 struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
940 int i;
bc240b21 941 if ( (i = strcmp(a->dhost, b->dhost)) != 0)
d74d141c 942 return i < 0 ? -1 : +1;
bc240b21 943 if (a->dport > b->dport)
944 return +1;
945 if (a->dport < b->dport)
946 return -1;
947 return 0;
948}
949
950static int ssh_rportcmp_ssh2(void *av, void *bv)
951{
952 struct ssh_rportfwd *a = (struct ssh_rportfwd *) av;
953 struct ssh_rportfwd *b = (struct ssh_rportfwd *) bv;
cdcbdf3b 954
bc240b21 955 if (a->sport > b->sport)
d74d141c 956 return +1;
bc240b21 957 if (a->sport < b->sport)
958 return -1;
d74d141c 959 return 0;
960}
961
fda2feb1 962/*
963 * Special form of strcmp which can cope with NULL inputs. NULL is
964 * defined to sort before even the empty string.
965 */
966static int nullstrcmp(const char *a, const char *b)
967{
968 if (a == NULL && b == NULL)
969 return 0;
970 if (a == NULL)
971 return -1;
972 if (b == NULL)
973 return +1;
974 return strcmp(a, b);
975}
976
977static int ssh_portcmp(void *av, void *bv)
978{
979 struct ssh_portfwd *a = (struct ssh_portfwd *) av;
980 struct ssh_portfwd *b = (struct ssh_portfwd *) bv;
981 int i;
982 if (a->type > b->type)
983 return +1;
984 if (a->type < b->type)
985 return -1;
84328ddb 986 if (a->addressfamily > b->addressfamily)
987 return +1;
988 if (a->addressfamily < b->addressfamily)
989 return -1;
fda2feb1 990 if ( (i = nullstrcmp(a->saddr, b->saddr)) != 0)
991 return i < 0 ? -1 : +1;
992 if (a->sport > b->sport)
993 return +1;
994 if (a->sport < b->sport)
995 return -1;
996 if (a->type != 'D') {
997 if ( (i = nullstrcmp(a->daddr, b->daddr)) != 0)
998 return i < 0 ? -1 : +1;
999 if (a->dport > b->dport)
1000 return +1;
1001 if (a->dport < b->dport)
1002 return -1;
1003 }
1004 return 0;
1005}
1006
51470298 1007static int alloc_channel_id(Ssh ssh)
32874aea 1008{
260f3dec 1009 const unsigned CHANNEL_NUMBER_OFFSET = 256;
1010 unsigned low, high, mid;
d2371c81 1011 int tsize;
1012 struct ssh_channel *c;
1013
1014 /*
1015 * First-fit allocation of channel numbers: always pick the
1016 * lowest unused one. To do this, binary-search using the
1017 * counted B-tree to find the largest channel ID which is in a
1018 * contiguous sequence from the beginning. (Precisely
1019 * everything in that sequence must have ID equal to its tree
1020 * index plus CHANNEL_NUMBER_OFFSET.)
1021 */
51470298 1022 tsize = count234(ssh->channels);
d2371c81 1023
32874aea 1024 low = -1;
1025 high = tsize;
d2371c81 1026 while (high - low > 1) {
1027 mid = (high + low) / 2;
51470298 1028 c = index234(ssh->channels, mid);
d2371c81 1029 if (c->localid == mid + CHANNEL_NUMBER_OFFSET)
1030 low = mid; /* this one is fine */
1031 else
1032 high = mid; /* this one is past it */
1033 }
1034 /*
1035 * Now low points to either -1, or the tree index of the
1036 * largest ID in the initial sequence.
1037 */
1038 {
1039 unsigned i = low + 1 + CHANNEL_NUMBER_OFFSET;
51470298 1040 assert(NULL == find234(ssh->channels, &i, ssh_channelfind));
d2371c81 1041 }
1042 return low + 1 + CHANNEL_NUMBER_OFFSET;
1043}
1044
edd0cb8a 1045static void c_write_stderr(int trusted, const char *buf, int len)
1046{
1047 int i;
1048 for (i = 0; i < len; i++)
1049 if (buf[i] != '\r' && (trusted || buf[i] & 0x60))
1050 fputc(buf[i], stderr);
1051}
1052
9fab77dc 1053static void c_write(Ssh ssh, const char *buf, int len)
32874aea 1054{
edd0cb8a 1055 if (flags & FLAG_STDERR)
1056 c_write_stderr(1, buf, len);
1057 else
1058 from_backend(ssh->frontend, 1, buf, len);
3bdaf79d 1059}
1060
9fab77dc 1061static void c_write_untrusted(Ssh ssh, const char *buf, int len)
32874aea 1062{
edd0cb8a 1063 if (flags & FLAG_STDERR)
1064 c_write_stderr(0, buf, len);
1065 else
1066 from_backend_untrusted(ssh->frontend, buf, len);
a209e957 1067}
1068
9fab77dc 1069static void c_write_str(Ssh ssh, const char *buf)
32874aea 1070{
51470298 1071 c_write(ssh, buf, strlen(buf));
1408a877 1072}
1073
ff3187f6 1074static void ssh_free_packet(struct Packet *pkt)
1075{
1076 sfree(pkt->data);
1077 sfree(pkt);
1078}
1079static struct Packet *ssh_new_packet(void)
1080{
1081 struct Packet *pkt = snew(struct Packet);
1082
dacd8872 1083 pkt->body = pkt->data = NULL;
ff3187f6 1084 pkt->maxlen = 0;
1085 pkt->logmode = PKTLOG_EMIT;
1086 pkt->nblanks = 0;
1087 pkt->blanks = NULL;
1088
1089 return pkt;
1090}
1091
fb09bf1c 1092/*
1093 * Collect incoming data in the incoming packet buffer.
e5574168 1094 * Decipher and verify the packet when it is completely read.
1095 * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
fb09bf1c 1096 * Update the *data and *datalen variables.
ff3187f6 1097 * Return a Packet structure when a packet is completed.
fb09bf1c 1098 */
ff3187f6 1099static struct Packet *ssh1_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
fb09bf1c 1100{
51470298 1101 struct rdpkt1_state_tag *st = &ssh->rdpkt1_state;
374330e2 1102
51470298 1103 crBegin(ssh->ssh1_rdpkt_crstate);
374330e2 1104
ff3187f6 1105 st->pktin = ssh_new_packet();
1106
1107 st->pktin->type = 0;
1108 st->pktin->length = 0;
374330e2 1109
57476f6b 1110 for (st->i = st->len = 0; st->i < 4; st->i++) {
fb09bf1c 1111 while ((*datalen) == 0)
ff3187f6 1112 crReturn(NULL);
57476f6b 1113 st->len = (st->len << 8) + **data;
fb09bf1c 1114 (*data)++, (*datalen)--;
1115 }
374330e2 1116
57476f6b 1117 st->pad = 8 - (st->len % 8);
1118 st->biglen = st->len + st->pad;
ff3187f6 1119 st->pktin->length = st->len - 5;
fb09bf1c 1120
ae0500e5 1121 if (st->biglen < 0) {
1122 bombout(("Extremely large packet length from server suggests"
1123 " data stream corruption"));
ff3187f6 1124 ssh_free_packet(st->pktin);
1125 crStop(NULL);
ae0500e5 1126 }
1127
ff3187f6 1128 st->pktin->maxlen = st->biglen;
1129 st->pktin->data = snewn(st->biglen + APIEXTRA, unsigned char);
374330e2 1130
57476f6b 1131 st->to_read = st->biglen;
ff3187f6 1132 st->p = st->pktin->data;
57476f6b 1133 while (st->to_read > 0) {
32874aea 1134 st->chunk = st->to_read;
fb09bf1c 1135 while ((*datalen) == 0)
ff3187f6 1136 crReturn(NULL);
57476f6b 1137 if (st->chunk > (*datalen))
1138 st->chunk = (*datalen);
1139 memcpy(st->p, *data, st->chunk);
1140 *data += st->chunk;
1141 *datalen -= st->chunk;
1142 st->p += st->chunk;
1143 st->to_read -= st->chunk;
fb09bf1c 1144 }
374330e2 1145
ff3187f6 1146 if (ssh->cipher && detect_attack(ssh->crcda_ctx, st->pktin->data,
0183b242 1147 st->biglen, NULL)) {
6b5cf8b4 1148 bombout(("Network attack (CRC compensation) detected!"));
ff3187f6 1149 ssh_free_packet(st->pktin);
1150 crStop(NULL);
9a3a93a5 1151 }
1152
51470298 1153 if (ssh->cipher)
ff3187f6 1154 ssh->cipher->decrypt(ssh->v1_cipher_ctx, st->pktin->data, st->biglen);
374330e2 1155
ff3187f6 1156 st->realcrc = crc32_compute(st->pktin->data, st->biglen - 4);
1157 st->gotcrc = GET_32BIT(st->pktin->data + st->biglen - 4);
57476f6b 1158 if (st->gotcrc != st->realcrc) {
6b5cf8b4 1159 bombout(("Incorrect CRC received on packet"));
ff3187f6 1160 ssh_free_packet(st->pktin);
1161 crStop(NULL);
fb09bf1c 1162 }
572f871e 1163
ff3187f6 1164 st->pktin->body = st->pktin->data + st->pad + 1;
1165 st->pktin->savedpos = 0;
4ba9b64b 1166
51470298 1167 if (ssh->v1_compressing) {
4ba9b64b 1168 unsigned char *decompblk;
1169 int decomplen;
36b8d9bb 1170 if (!zlib_decompress_block(ssh->sc_comp_ctx,
ff3187f6 1171 st->pktin->body - 1, st->pktin->length + 1,
36b8d9bb 1172 &decompblk, &decomplen)) {
1173 bombout(("Zlib decompression encountered invalid data"));
ff3187f6 1174 ssh_free_packet(st->pktin);
1175 crStop(NULL);
36b8d9bb 1176 }
4ba9b64b 1177
ff3187f6 1178 if (st->pktin->maxlen < st->pad + decomplen) {
1179 st->pktin->maxlen = st->pad + decomplen;
1180 st->pktin->data = sresize(st->pktin->data,
1181 st->pktin->maxlen + APIEXTRA,
3d88e64d 1182 unsigned char);
ff3187f6 1183 st->pktin->body = st->pktin->data + st->pad + 1;
4ba9b64b 1184 }
1185
ff3187f6 1186 memcpy(st->pktin->body - 1, decompblk, decomplen);
dcbde236 1187 sfree(decompblk);
ff3187f6 1188 st->pktin->length = decomplen - 1;
4ba9b64b 1189 }
1190
ff3187f6 1191 st->pktin->type = st->pktin->body[-1];
00db133f 1192
9a10ecf4 1193 /*
1194 * Log incoming packet, possibly omitting sensitive fields.
1195 */
1196 if (ssh->logctx) {
1197 int nblanks = 0;
1198 struct logblank_t blank;
1199 if (ssh->cfg.logomitdata) {
1200 int do_blank = FALSE, blank_prefix = 0;
1201 /* "Session data" packets - omit the data field */
ff3187f6 1202 if ((st->pktin->type == SSH1_SMSG_STDOUT_DATA) ||
1203 (st->pktin->type == SSH1_SMSG_STDERR_DATA)) {
9a10ecf4 1204 do_blank = TRUE; blank_prefix = 0;
ff3187f6 1205 } else if (st->pktin->type == SSH1_MSG_CHANNEL_DATA) {
9a10ecf4 1206 do_blank = TRUE; blank_prefix = 4;
1207 }
1208 if (do_blank) {
1209 blank.offset = blank_prefix;
ff3187f6 1210 blank.len = st->pktin->length;
9a10ecf4 1211 blank.type = PKTLOG_OMIT;
1212 nblanks = 1;
1213 }
1214 }
a8327734 1215 log_packet(ssh->logctx,
ff3187f6 1216 PKT_INCOMING, st->pktin->type,
1217 ssh1_pkt_type(st->pktin->type),
1218 st->pktin->body, st->pktin->length,
9a10ecf4 1219 nblanks, &blank);
1220 }
00db133f 1221
ff3187f6 1222 crFinish(st->pktin);
fb09bf1c 1223}
1224
ff3187f6 1225static struct Packet *ssh2_rdpkt(Ssh ssh, unsigned char **data, int *datalen)
e5574168 1226{
51470298 1227 struct rdpkt2_state_tag *st = &ssh->rdpkt2_state;
e5574168 1228
51470298 1229 crBegin(ssh->ssh2_rdpkt_crstate);
e5574168 1230
ff3187f6 1231 st->pktin = ssh_new_packet();
1232
1233 st->pktin->type = 0;
1234 st->pktin->length = 0;
51470298 1235 if (ssh->sccipher)
1236 st->cipherblk = ssh->sccipher->blksize;
e5574168 1237 else
32874aea 1238 st->cipherblk = 8;
960e736a 1239 if (st->cipherblk < 8)
32874aea 1240 st->cipherblk = 8;
960e736a 1241
ff3187f6 1242 st->pktin->data = snewn(st->cipherblk + APIEXTRA, unsigned char);
e5574168 1243
1244 /*
1245 * Acquire and decrypt the first block of the packet. This will
1246 * contain the length and padding details.
1247 */
32874aea 1248 for (st->i = st->len = 0; st->i < st->cipherblk; st->i++) {
e5574168 1249 while ((*datalen) == 0)
ff3187f6 1250 crReturn(NULL);
1251 st->pktin->data[st->i] = *(*data)++;
32874aea 1252 (*datalen)--;
e5574168 1253 }
4252c9cc 1254
51470298 1255 if (ssh->sccipher)
371e569c 1256 ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
ff3187f6 1257 st->pktin->data, st->cipherblk);
e5574168 1258
1259 /*
1260 * Now get the length and padding figures.
1261 */
ff3187f6 1262 st->len = GET_32BIT(st->pktin->data);
1263 st->pad = st->pktin->data[4];
e5574168 1264
1265 /*
717dc483 1266 * _Completely_ silly lengths should be stomped on before they
1267 * do us any more damage.
1268 */
cba1e4b5 1269 if (st->len < 0 || st->len > 35000 || st->pad < 4 ||
1270 st->len - st->pad < 1 || (st->len + 4) % st->cipherblk != 0) {
6b5cf8b4 1271 bombout(("Incoming packet was garbled on decryption"));
ff3187f6 1272 ssh_free_packet(st->pktin);
1273 crStop(NULL);
717dc483 1274 }
1275
1276 /*
e5574168 1277 * This enables us to deduce the payload length.
1278 */
960e736a 1279 st->payload = st->len - st->pad - 1;
e5574168 1280
ff3187f6 1281 st->pktin->length = st->payload + 5;
e5574168 1282
1283 /*
1284 * So now we can work out the total packet length.
1285 */
960e736a 1286 st->packetlen = st->len + 4;
51470298 1287 st->maclen = ssh->scmac ? ssh->scmac->len : 0;
e5574168 1288
1289 /*
ff3187f6 1290 * Allocate memory for the rest of the packet.
e5574168 1291 */
ff3187f6 1292 st->pktin->maxlen = st->packetlen + st->maclen;
1293 st->pktin->data = sresize(st->pktin->data,
1294 st->pktin->maxlen + APIEXTRA,
1295 unsigned char);
e5574168 1296
1297 /*
1298 * Read and decrypt the remainder of the packet.
1299 */
32874aea 1300 for (st->i = st->cipherblk; st->i < st->packetlen + st->maclen;
1301 st->i++) {
e5574168 1302 while ((*datalen) == 0)
ff3187f6 1303 crReturn(NULL);
1304 st->pktin->data[st->i] = *(*data)++;
32874aea 1305 (*datalen)--;
e5574168 1306 }
1307 /* Decrypt everything _except_ the MAC. */
51470298 1308 if (ssh->sccipher)
371e569c 1309 ssh->sccipher->decrypt(ssh->sc_cipher_ctx,
ff3187f6 1310 st->pktin->data + st->cipherblk,
51470298 1311 st->packetlen - st->cipherblk);
e5574168 1312
9442dd57 1313 st->pktin->encrypted_len = st->packetlen;
1314
e5574168 1315 /*
1316 * Check the MAC.
1317 */
51470298 1318 if (ssh->scmac
ff3187f6 1319 && !ssh->scmac->verify(ssh->sc_mac_ctx, st->pktin->data, st->len + 4,
51470298 1320 st->incoming_sequence)) {
6b5cf8b4 1321 bombout(("Incorrect MAC received on packet"));
ff3187f6 1322 ssh_free_packet(st->pktin);
1323 crStop(NULL);
8d5de777 1324 }
b09eaa88 1325
1326 st->pktin->sequence = st->incoming_sequence++;
e5574168 1327
4ba9b64b 1328 /*
1329 * Decompress packet payload.
1330 */
1331 {
1332 unsigned char *newpayload;
1333 int newlen;
51470298 1334 if (ssh->sccomp &&
5366aed8 1335 ssh->sccomp->decompress(ssh->sc_comp_ctx,
ff3187f6 1336 st->pktin->data + 5, st->pktin->length - 5,
51470298 1337 &newpayload, &newlen)) {
ff3187f6 1338 if (st->pktin->maxlen < newlen + 5) {
1339 st->pktin->maxlen = newlen + 5;
1340 st->pktin->data = sresize(st->pktin->data,
1341 st->pktin->maxlen + APIEXTRA,
3d88e64d 1342 unsigned char);
4ba9b64b 1343 }
ff3187f6 1344 st->pktin->length = 5 + newlen;
1345 memcpy(st->pktin->data + 5, newpayload, newlen);
dcbde236 1346 sfree(newpayload);
4ba9b64b 1347 }
1348 }
1349
ff3187f6 1350 st->pktin->savedpos = 6;
1351 st->pktin->body = st->pktin->data;
1352 st->pktin->type = st->pktin->data[5];
e5574168 1353
9a10ecf4 1354 /*
1355 * Log incoming packet, possibly omitting sensitive fields.
1356 */
1357 if (ssh->logctx) {
1358 int nblanks = 0;
1359 struct logblank_t blank;
1360 if (ssh->cfg.logomitdata) {
1361 int do_blank = FALSE, blank_prefix = 0;
1362 /* "Session data" packets - omit the data field */
ff3187f6 1363 if (st->pktin->type == SSH2_MSG_CHANNEL_DATA) {
9a10ecf4 1364 do_blank = TRUE; blank_prefix = 4;
ff3187f6 1365 } else if (st->pktin->type == SSH2_MSG_CHANNEL_EXTENDED_DATA) {
9a10ecf4 1366 do_blank = TRUE; blank_prefix = 8;
1367 }
1368 if (do_blank) {
1369 blank.offset = blank_prefix;
ff3187f6 1370 blank.len = (st->pktin->length-6) - blank_prefix;
9a10ecf4 1371 blank.type = PKTLOG_OMIT;
1372 nblanks = 1;
1373 }
1374 }
ff3187f6 1375 log_packet(ssh->logctx, PKT_INCOMING, st->pktin->type,
1376 ssh2_pkt_type(ssh->pkt_ctx, st->pktin->type),
1377 st->pktin->data+6, st->pktin->length-6,
9a10ecf4 1378 nblanks, &blank);
1379 }
00db133f 1380
ff3187f6 1381 crFinish(st->pktin);
e5574168 1382}
1383
dacd8872 1384static int s_wrpkt_prepare(Ssh ssh, struct Packet *pkt, int *offset_p)
32874aea 1385{
dacd8872 1386 int pad, biglen, i, pktoffs;
374330e2 1387 unsigned long crc;
fd7a4aad 1388#ifdef __SC__
1389 /*
1390 * XXX various versions of SC (including 8.8.4) screw up the
1391 * register allocation in this function and use the same register
1392 * (D6) for len and as a temporary, with predictable results. The
1393 * following sledgehammer prevents this.
1394 */
1395 volatile
1396#endif
1397 int len;
374330e2 1398
a8327734 1399 if (ssh->logctx)
dacd8872 1400 log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[12],
1401 ssh1_pkt_type(pkt->data[12]),
1402 pkt->body, pkt->length - (pkt->body - pkt->data),
ff3187f6 1403 pkt->nblanks, pkt->blanks);
1404 sfree(pkt->blanks); pkt->blanks = NULL;
1405 pkt->nblanks = 0;
00db133f 1406
51470298 1407 if (ssh->v1_compressing) {
4ba9b64b 1408 unsigned char *compblk;
1409 int complen;
5366aed8 1410 zlib_compress_block(ssh->cs_comp_ctx,
dacd8872 1411 pkt->data + 12, pkt->length - 12,
4ba9b64b 1412 &compblk, &complen);
dacd8872 1413 memcpy(pkt->data + 12, compblk, complen);
dcbde236 1414 sfree(compblk);
dacd8872 1415 pkt->length = complen + 12;
4ba9b64b 1416 }
1417
dacd8872 1418 ssh_pkt_ensure(pkt, pkt->length + 4); /* space for CRC */
1419 pkt->length += 4;
1420 len = pkt->length - 4 - 8; /* len(type+data+CRC) */
32874aea 1421 pad = 8 - (len % 8);
dacd8872 1422 pktoffs = 8 - pad;
1423 biglen = len + pad; /* len(padding+type+data+CRC) */
374330e2 1424
dacd8872 1425 for (i = pktoffs; i < 4+8; i++)
1426 pkt->data[i] = random_byte();
1427 crc = crc32_compute(pkt->data + pktoffs + 4, biglen - 4); /* all ex len */
1428 PUT_32BIT(pkt->data + pktoffs + 4 + biglen - 4, crc);
1429 PUT_32BIT(pkt->data + pktoffs, len);
374330e2 1430
51470298 1431 if (ssh->cipher)
dacd8872 1432 ssh->cipher->encrypt(ssh->v1_cipher_ctx,
1433 pkt->data + pktoffs + 4, biglen);
374330e2 1434
dacd8872 1435 if (offset_p) *offset_p = pktoffs;
1436 return biglen + 4; /* len(length+padding+type+data+CRC) */
39065bed 1437}
1438
ff3187f6 1439static void s_wrpkt(Ssh ssh, struct Packet *pkt)
32874aea 1440{
dacd8872 1441 int len, backlog, offset;
1442 len = s_wrpkt_prepare(ssh, pkt, &offset);
1443 backlog = sk_write(ssh->s, (char *)pkt->data + offset, len);
5471d09a 1444 if (backlog > SSH_MAX_BACKLOG)
51470298 1445 ssh_throttle_all(ssh, 1, backlog);
dacd8872 1446 ssh_free_packet(pkt);
39065bed 1447}
1448
ff3187f6 1449static void s_wrpkt_defer(Ssh ssh, struct Packet *pkt)
32874aea 1450{
dacd8872 1451 int len, offset;
1452 len = s_wrpkt_prepare(ssh, pkt, &offset);
51470298 1453 if (ssh->deferred_len + len > ssh->deferred_size) {
1454 ssh->deferred_size = ssh->deferred_len + len + 128;
3d88e64d 1455 ssh->deferred_send_data = sresize(ssh->deferred_send_data,
1456 ssh->deferred_size,
1457 unsigned char);
39065bed 1458 }
dacd8872 1459 memcpy(ssh->deferred_send_data + ssh->deferred_len,
1460 pkt->data + offset, len);
51470298 1461 ssh->deferred_len += len;
dacd8872 1462 ssh_free_packet(pkt);
374330e2 1463}
1464
fb09bf1c 1465/*
dacd8872 1466 * Construct a SSH-1 packet with the specified contents.
1467 * (This all-at-once interface used to be the only one, but now SSH-1
1468 * packets can also be constructed incrementally.)
fb09bf1c 1469 */
dacd8872 1470static struct Packet *construct_packet(Ssh ssh, int pkttype, va_list ap)
fb09bf1c 1471{
dacd8872 1472 int argtype;
7cca0d81 1473 Bignum bn;
ff3187f6 1474 struct Packet *pkt;
fb09bf1c 1475
dacd8872 1476 pkt = ssh1_pkt_init(pkttype);
fb09bf1c 1477
dacd8872 1478 while ((argtype = va_arg(ap, int)) != PKT_END) {
1479 unsigned char *argp, argchar;
1480 unsigned long argint;
1481 int arglen;
fb09bf1c 1482 switch (argtype) {
9a10ecf4 1483 /* Actual fields in the packet */
fb09bf1c 1484 case PKT_INT:
dacd8872 1485 argint = va_arg(ap, int);
1486 ssh_pkt_adduint32(pkt, argint);
fb09bf1c 1487 break;
1488 case PKT_CHAR:
dacd8872 1489 argchar = (unsigned char) va_arg(ap, int);
1490 ssh_pkt_addbyte(pkt, argchar);
fb09bf1c 1491 break;
1492 case PKT_DATA:
dacd8872 1493 argp = va_arg(ap, unsigned char *);
1494 arglen = va_arg(ap, int);
1495 ssh_pkt_adddata(pkt, argp, arglen);
fb09bf1c 1496 break;
1497 case PKT_STR:
dacd8872 1498 argp = va_arg(ap, unsigned char *);
1499 ssh_pkt_addstring(pkt, argp);
fb09bf1c 1500 break;
7cca0d81 1501 case PKT_BIGNUM:
dacd8872 1502 bn = va_arg(ap, Bignum);
1503 ssh1_pkt_addmp(pkt, bn);
9a10ecf4 1504 break;
1505 /* Tokens for modifications to packet logging */
1506 case PKTT_PASSWORD:
ff3187f6 1507 dont_log_password(ssh, pkt, PKTLOG_BLANK);
9a10ecf4 1508 break;
1509 case PKTT_DATA:
ff3187f6 1510 dont_log_data(ssh, pkt, PKTLOG_OMIT);
7cca0d81 1511 break;
9a10ecf4 1512 case PKTT_OTHER:
ff3187f6 1513 end_log_omission(ssh, pkt);
9a10ecf4 1514 break;
1515 }
fb09bf1c 1516 }
ff3187f6 1517
1518 return pkt;
39065bed 1519}
fb09bf1c 1520
51470298 1521static void send_packet(Ssh ssh, int pkttype, ...)
32874aea 1522{
ff3187f6 1523 struct Packet *pkt;
dacd8872 1524 va_list ap;
1525 va_start(ap, pkttype);
1526 pkt = construct_packet(ssh, pkttype, ap);
1527 va_end(ap);
ff3187f6 1528 s_wrpkt(ssh, pkt);
fb09bf1c 1529}
1530
51470298 1531static void defer_packet(Ssh ssh, int pkttype, ...)
32874aea 1532{
ff3187f6 1533 struct Packet *pkt;
dacd8872 1534 va_list ap;
1535 va_start(ap, pkttype);
1536 pkt = construct_packet(ssh, pkttype, ap);
1537 va_end(ap);
ff3187f6 1538 s_wrpkt_defer(ssh, pkt);
39065bed 1539}
1540
32874aea 1541static int ssh_versioncmp(char *a, char *b)
1542{
9697bfd2 1543 char *ae, *be;
1544 unsigned long av, bv;
1545
43aa02a7 1546 av = strtoul(a, &ae, 10);
1547 bv = strtoul(b, &be, 10);
32874aea 1548 if (av != bv)
1549 return (av < bv ? -1 : +1);
1550 if (*ae == '.')
1551 ae++;
1552 if (*be == '.')
1553 be++;
43aa02a7 1554 av = strtoul(ae, &ae, 10);
1555 bv = strtoul(be, &be, 10);
32874aea 1556 if (av != bv)
1557 return (av < bv ? -1 : +1);
9697bfd2 1558 return 0;
1559}
1560
e5574168 1561/*
a92dd380 1562 * Utility routines for putting an SSH-protocol `string' and
b672f405 1563 * `uint32' into a hash state.
e5574168 1564 */
b672f405 1565static void hash_string(const struct ssh_hash *h, void *s, void *str, int len)
32874aea 1566{
e5574168 1567 unsigned char lenblk[4];
e5574168 1568 PUT_32BIT(lenblk, len);
b672f405 1569 h->bytes(s, lenblk, 4);
1570 h->bytes(s, str, len);
e5574168 1571}
1572
b672f405 1573static void hash_uint32(const struct ssh_hash *h, void *s, unsigned i)
32874aea 1574{
a92dd380 1575 unsigned char intblk[4];
1576 PUT_32BIT(intblk, i);
b672f405 1577 h->bytes(s, intblk, 4);
a92dd380 1578}
1579
7cca0d81 1580/*
dacd8872 1581 * Packet construction functions. Mostly shared between SSH-1 and SSH-2.
7cca0d81 1582 */
dacd8872 1583static void ssh_pkt_ensure(struct Packet *pkt, int length)
32874aea 1584{
ff3187f6 1585 if (pkt->maxlen < length) {
dacd8872 1586 unsigned char *body = pkt->body;
3d71de0b 1587 int offset = body ? body - pkt->data : 0;
ff3187f6 1588 pkt->maxlen = length + 256;
1589 pkt->data = sresize(pkt->data, pkt->maxlen + APIEXTRA, unsigned char);
dacd8872 1590 if (body) pkt->body = pkt->data + offset;
7cca0d81 1591 }
783415f8 1592}
dacd8872 1593static void ssh_pkt_adddata(struct Packet *pkt, void *data, int len)
32874aea 1594{
ff3187f6 1595 if (pkt->logmode != PKTLOG_EMIT) {
1596 pkt->nblanks++;
1597 pkt->blanks = sresize(pkt->blanks, pkt->nblanks, struct logblank_t);
dacd8872 1598 assert(pkt->body);
1599 pkt->blanks[pkt->nblanks-1].offset = pkt->length -
1600 (pkt->body - pkt->data);
ff3187f6 1601 pkt->blanks[pkt->nblanks-1].len = len;
1602 pkt->blanks[pkt->nblanks-1].type = pkt->logmode;
1603 }
1604 pkt->length += len;
dacd8872 1605 ssh_pkt_ensure(pkt, pkt->length);
ff3187f6 1606 memcpy(pkt->data + pkt->length - len, data, len);
7cca0d81 1607}
dacd8872 1608static void ssh_pkt_addbyte(struct Packet *pkt, unsigned char byte)
32874aea 1609{
dacd8872 1610 ssh_pkt_adddata(pkt, &byte, 1);
7cca0d81 1611}
ff3187f6 1612static void ssh2_pkt_addbool(struct Packet *pkt, unsigned char value)
32874aea 1613{
dacd8872 1614 ssh_pkt_adddata(pkt, &value, 1);
7cca0d81 1615}
dacd8872 1616static void ssh_pkt_adduint32(struct Packet *pkt, unsigned long value)
32874aea 1617{
7cca0d81 1618 unsigned char x[4];
1619 PUT_32BIT(x, value);
dacd8872 1620 ssh_pkt_adddata(pkt, x, 4);
7cca0d81 1621}
dacd8872 1622static void ssh_pkt_addstring_start(struct Packet *pkt)
32874aea 1623{
dacd8872 1624 ssh_pkt_adduint32(pkt, 0);
ff3187f6 1625 pkt->savedpos = pkt->length;
7cca0d81 1626}
dacd8872 1627static void ssh_pkt_addstring_str(struct Packet *pkt, char *data)
32874aea 1628{
dacd8872 1629 ssh_pkt_adddata(pkt, data, strlen(data));
ff3187f6 1630 PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos);
7cca0d81 1631}
dacd8872 1632static void ssh_pkt_addstring_data(struct Packet *pkt, char *data, int len)
32874aea 1633{
dacd8872 1634 ssh_pkt_adddata(pkt, data, len);
ff3187f6 1635 PUT_32BIT(pkt->data + pkt->savedpos - 4, pkt->length - pkt->savedpos);
7cca0d81 1636}
dacd8872 1637static void ssh_pkt_addstring(struct Packet *pkt, char *data)
1638{
1639 ssh_pkt_addstring_start(pkt);
1640 ssh_pkt_addstring_str(pkt, data);
1641}
1642static void ssh1_pkt_addmp(struct Packet *pkt, Bignum b)
32874aea 1643{
dacd8872 1644 int len = ssh1_bignum_length(b);
1645 unsigned char *data = snewn(len, char);
1646 (void) ssh1_write_bignum(data, b);
1647 ssh_pkt_adddata(pkt, data, len);
1648 sfree(data);
7cca0d81 1649}
d8baa528 1650static unsigned char *ssh2_mpint_fmt(Bignum b, int *len)
32874aea 1651{
7cca0d81 1652 unsigned char *p;
32874aea 1653 int i, n = (bignum_bitcount(b) + 7) / 8;
3d88e64d 1654 p = snewn(n + 1, unsigned char);
7cca0d81 1655 p[0] = 0;
3709bfe9 1656 for (i = 1; i <= n; i++)
32874aea 1657 p[i] = bignum_byte(b, n - i);
7cca0d81 1658 i = 0;
32874aea 1659 while (i <= n && p[i] == 0 && (p[i + 1] & 0x80) == 0)
1660 i++;
1661 memmove(p, p + i, n + 1 - i);
1662 *len = n + 1 - i;
7cca0d81 1663 return p;
1664}
ff3187f6 1665static void ssh2_pkt_addmp(struct Packet *pkt, Bignum b)
32874aea 1666{
7cca0d81 1667 unsigned char *p;
1668 int len;
1669 p = ssh2_mpint_fmt(b, &len);
dacd8872 1670 ssh_pkt_addstring_start(pkt);
1671 ssh_pkt_addstring_data(pkt, (char *)p, len);
dcbde236 1672 sfree(p);
7cca0d81 1673}
b185170a 1674
dacd8872 1675static struct Packet *ssh1_pkt_init(int pkt_type)
1676{
1677 struct Packet *pkt = ssh_new_packet();
1678 pkt->length = 4 + 8; /* space for length + max padding */
1679 ssh_pkt_addbyte(pkt, pkt_type);
1680 pkt->body = pkt->data + pkt->length;
1681 return pkt;
1682}
1683
1684/* For legacy code (SSH-1 and -2 packet construction used to be separate) */
1685#define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length)
1686#define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len)
1687#define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte)
1688#define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value)
1689#define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt)
1690#define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data)
1691#define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len)
1692#define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data)
1693
1694static struct Packet *ssh2_pkt_init(int pkt_type)
1695{
1696 struct Packet *pkt = ssh_new_packet();
3d71de0b 1697 pkt->length = 5; /* space for packet length + padding length */
dacd8872 1698 pkt->forcepad = 0;
1699 ssh_pkt_addbyte(pkt, (unsigned char) pkt_type);
3d71de0b 1700 pkt->body = pkt->data + pkt->length; /* after packet type */
dacd8872 1701 return pkt;
1702}
1703
b185170a 1704/*
2e85c969 1705 * Construct an SSH-2 final-form packet: compress it, encrypt it,
b185170a 1706 * put the MAC on it. Final packet, ready to be sent, is stored in
ff3187f6 1707 * pkt->data. Total length is returned.
b185170a 1708 */
ff3187f6 1709static int ssh2_pkt_construct(Ssh ssh, struct Packet *pkt)
32874aea 1710{
7cca0d81 1711 int cipherblk, maclen, padding, i;
7cca0d81 1712
a8327734 1713 if (ssh->logctx)
ff3187f6 1714 log_packet(ssh->logctx, PKT_OUTGOING, pkt->data[5],
1715 ssh2_pkt_type(ssh->pkt_ctx, pkt->data[5]),
dacd8872 1716 pkt->body, pkt->length - (pkt->body - pkt->data),
ff3187f6 1717 pkt->nblanks, pkt->blanks);
1718 sfree(pkt->blanks); pkt->blanks = NULL;
1719 pkt->nblanks = 0;
00db133f 1720
7cca0d81 1721 /*
4ba9b64b 1722 * Compress packet payload.
1723 */
4ba9b64b 1724 {
1725 unsigned char *newpayload;
1726 int newlen;
51470298 1727 if (ssh->cscomp &&
ff3187f6 1728 ssh->cscomp->compress(ssh->cs_comp_ctx, pkt->data + 5,
1729 pkt->length - 5,
51470298 1730 &newpayload, &newlen)) {
ff3187f6 1731 pkt->length = 5;
1732 ssh2_pkt_adddata(pkt, newpayload, newlen);
dcbde236 1733 sfree(newpayload);
4ba9b64b 1734 }
1735 }
1736
1737 /*
7cca0d81 1738 * Add padding. At least four bytes, and must also bring total
1739 * length (minus MAC) up to a multiple of the block size.
95d2d262 1740 * If pkt->forcepad is set, make sure the packet is at least that size
1741 * after padding.
7cca0d81 1742 */
51470298 1743 cipherblk = ssh->cscipher ? ssh->cscipher->blksize : 8; /* block size */
32874aea 1744 cipherblk = cipherblk < 8 ? 8 : cipherblk; /* or 8 if blksize < 8 */
7cca0d81 1745 padding = 4;
95d2d262 1746 if (pkt->length + padding < pkt->forcepad)
1747 padding = pkt->forcepad - pkt->length;
32874aea 1748 padding +=
ff3187f6 1749 (cipherblk - (pkt->length + padding) % cipherblk) % cipherblk;
95d2d262 1750 assert(padding <= 255);
51470298 1751 maclen = ssh->csmac ? ssh->csmac->len : 0;
ff3187f6 1752 ssh2_pkt_ensure(pkt, pkt->length + padding + maclen);
1753 pkt->data[4] = padding;
7cca0d81 1754 for (i = 0; i < padding; i++)
ff3187f6 1755 pkt->data[pkt->length + i] = random_byte();
1756 PUT_32BIT(pkt->data, pkt->length + padding - 4);
51470298 1757 if (ssh->csmac)
ff3187f6 1758 ssh->csmac->generate(ssh->cs_mac_ctx, pkt->data,
1759 pkt->length + padding,
51470298 1760 ssh->v2_outgoing_sequence);
1761 ssh->v2_outgoing_sequence++; /* whether or not we MACed */
1762
1763 if (ssh->cscipher)
371e569c 1764 ssh->cscipher->encrypt(ssh->cs_cipher_ctx,
ff3187f6 1765 pkt->data, pkt->length + padding);
51470298 1766
9442dd57 1767 pkt->encrypted_len = pkt->length + padding;
1768
ff3187f6 1769 /* Ready-to-send packet starts at pkt->data. We return length. */
1770 return pkt->length + padding + maclen;
b185170a 1771}
1772
1773/*
590f6a5f 1774 * Routines called from the main SSH code to send packets. There
1775 * are quite a few of these, because we have two separate
1776 * mechanisms for delaying the sending of packets:
1777 *
1778 * - In order to send an IGNORE message and a password message in
1779 * a single fixed-length blob, we require the ability to
1780 * concatenate the encrypted forms of those two packets _into_ a
1781 * single blob and then pass it to our <network.h> transport
1782 * layer in one go. Hence, there's a deferment mechanism which
1783 * works after packet encryption.
1784 *
1785 * - In order to avoid sending any connection-layer messages
1786 * during repeat key exchange, we have to queue up any such
1787 * outgoing messages _before_ they are encrypted (and in
1788 * particular before they're allocated sequence numbers), and
1789 * then send them once we've finished.
1790 *
1791 * I call these mechanisms `defer' and `queue' respectively, so as
1792 * to distinguish them reasonably easily.
1793 *
1794 * The functions send_noqueue() and defer_noqueue() free the packet
1795 * structure they are passed. Every outgoing packet goes through
1796 * precisely one of these functions in its life; packets passed to
1797 * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of
1798 * these or get queued, and then when the queue is later emptied
1799 * the packets are all passed to defer_noqueue().
97ab28d7 1800 *
1801 * When using a CBC-mode cipher, it's necessary to ensure that an
1802 * attacker can't provide data to be encrypted using an IV that they
1803 * know. We ensure this by prefixing each packet that might contain
1804 * user data with an SSH_MSG_IGNORE. This is done using the deferral
1805 * mechanism, so in this case send_noqueue() ends up redirecting to
1806 * defer_noqueue(). If you don't like this inefficiency, don't use
1807 * CBC.
b185170a 1808 */
590f6a5f 1809
97ab28d7 1810static void ssh2_pkt_defer_noqueue(Ssh, struct Packet *, int);
1811static void ssh_pkt_defersend(Ssh);
1812
590f6a5f 1813/*
2e85c969 1814 * Send an SSH-2 packet immediately, without queuing or deferring.
590f6a5f 1815 */
1816static void ssh2_pkt_send_noqueue(Ssh ssh, struct Packet *pkt)
32874aea 1817{
5471d09a 1818 int len;
1819 int backlog;
97ab28d7 1820 if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC)) {
1821 /* We need to send two packets, so use the deferral mechanism. */
1822 ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
1823 ssh_pkt_defersend(ssh);
1824 return;
1825 }
ff3187f6 1826 len = ssh2_pkt_construct(ssh, pkt);
1827 backlog = sk_write(ssh->s, (char *)pkt->data, len);
5471d09a 1828 if (backlog > SSH_MAX_BACKLOG)
51470298 1829 ssh_throttle_all(ssh, 1, backlog);
9442dd57 1830
1831 ssh->outgoing_data_size += pkt->encrypted_len;
1832 if (!ssh->kex_in_progress &&
d57f70af 1833 ssh->max_data_size != 0 &&
1834 ssh->outgoing_data_size > ssh->max_data_size)
f382c87d 1835 do_ssh2_transport(ssh, "too much data sent", -1, NULL);
9442dd57 1836
ff3187f6 1837 ssh_free_packet(pkt);
b185170a 1838}
1839
1840/*
2e85c969 1841 * Defer an SSH-2 packet.
b185170a 1842 */
97ab28d7 1843static void ssh2_pkt_defer_noqueue(Ssh ssh, struct Packet *pkt, int noignore)
32874aea 1844{
97ab28d7 1845 int len;
1846 if (ssh->cscipher != NULL && (ssh->cscipher->flags & SSH_CIPHER_IS_CBC) &&
1847 ssh->deferred_len == 0 && !noignore) {
1848 /*
1849 * Interpose an SSH_MSG_IGNORE to ensure that user data don't
1850 * get encrypted with a known IV.
1851 */
1852 struct Packet *ipkt = ssh2_pkt_init(SSH2_MSG_IGNORE);
1853 ssh2_pkt_defer_noqueue(ssh, ipkt, TRUE);
1854 }
1855 len = ssh2_pkt_construct(ssh, pkt);
51470298 1856 if (ssh->deferred_len + len > ssh->deferred_size) {
1857 ssh->deferred_size = ssh->deferred_len + len + 128;
3d88e64d 1858 ssh->deferred_send_data = sresize(ssh->deferred_send_data,
1859 ssh->deferred_size,
1860 unsigned char);
b185170a 1861 }
ff3187f6 1862 memcpy(ssh->deferred_send_data + ssh->deferred_len, pkt->data, len);
51470298 1863 ssh->deferred_len += len;
9442dd57 1864 ssh->deferred_data_size += pkt->encrypted_len;
ff3187f6 1865 ssh_free_packet(pkt);
b185170a 1866}
1867
1868/*
2e85c969 1869 * Queue an SSH-2 packet.
590f6a5f 1870 */
1871static void ssh2_pkt_queue(Ssh ssh, struct Packet *pkt)
1872{
1873 assert(ssh->queueing);
1874
1875 if (ssh->queuelen >= ssh->queuesize) {
1876 ssh->queuesize = ssh->queuelen + 32;
1877 ssh->queue = sresize(ssh->queue, ssh->queuesize, struct Packet *);
1878 }
1879
1880 ssh->queue[ssh->queuelen++] = pkt;
1881}
1882
1883/*
1884 * Either queue or send a packet, depending on whether queueing is
1885 * set.
1886 */
1887static void ssh2_pkt_send(Ssh ssh, struct Packet *pkt)
1888{
1889 if (ssh->queueing)
1890 ssh2_pkt_queue(ssh, pkt);
1891 else
1892 ssh2_pkt_send_noqueue(ssh, pkt);
1893}
1894
95d2d262 1895#if 0 /* disused */
590f6a5f 1896/*
1897 * Either queue or defer a packet, depending on whether queueing is
1898 * set.
1899 */
1900static void ssh2_pkt_defer(Ssh ssh, struct Packet *pkt)
1901{
1902 if (ssh->queueing)
1903 ssh2_pkt_queue(ssh, pkt);
1904 else
97ab28d7 1905 ssh2_pkt_defer_noqueue(ssh, pkt, FALSE);
590f6a5f 1906}
95d2d262 1907#endif
590f6a5f 1908
1909/*
b185170a 1910 * Send the whole deferred data block constructed by
2e85c969 1911 * ssh2_pkt_defer() or SSH-1's defer_packet().
590f6a5f 1912 *
1913 * The expected use of the defer mechanism is that you call
1914 * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If
1915 * not currently queueing, this simply sets up deferred_send_data
1916 * and then sends it. If we _are_ currently queueing, the calls to
1917 * ssh2_pkt_defer() put the deferred packets on to the queue
1918 * instead, and therefore ssh_pkt_defersend() has no deferred data
1919 * to send. Hence, there's no need to make it conditional on
1920 * ssh->queueing.
b185170a 1921 */
51470298 1922static void ssh_pkt_defersend(Ssh ssh)
32874aea 1923{
5471d09a 1924 int backlog;
d8baa528 1925 backlog = sk_write(ssh->s, (char *)ssh->deferred_send_data,
1926 ssh->deferred_len);
51470298 1927 ssh->deferred_len = ssh->deferred_size = 0;
1928 sfree(ssh->deferred_send_data);
1929 ssh->deferred_send_data = NULL;
5471d09a 1930 if (backlog > SSH_MAX_BACKLOG)
51470298 1931 ssh_throttle_all(ssh, 1, backlog);
9442dd57 1932
1933 ssh->outgoing_data_size += ssh->deferred_data_size;
1934 if (!ssh->kex_in_progress &&
d57f70af 1935 ssh->max_data_size != 0 &&
1936 ssh->outgoing_data_size > ssh->max_data_size)
f382c87d 1937 do_ssh2_transport(ssh, "too much data sent", -1, NULL);
9442dd57 1938 ssh->deferred_data_size = 0;
7cca0d81 1939}
1940
590f6a5f 1941/*
2e85c969 1942 * Send all queued SSH-2 packets. We send them by means of
590f6a5f 1943 * ssh2_pkt_defer_noqueue(), in case they included a pair of
1944 * packets that needed to be lumped together.
1945 */
1946static void ssh2_pkt_queuesend(Ssh ssh)
1947{
1948 int i;
1949
1950 assert(!ssh->queueing);
1951
1952 for (i = 0; i < ssh->queuelen; i++)
97ab28d7 1953 ssh2_pkt_defer_noqueue(ssh, ssh->queue[i], FALSE);
590f6a5f 1954 ssh->queuelen = 0;
1955
1956 ssh_pkt_defersend(ssh);
1957}
1958
7cca0d81 1959#if 0
32874aea 1960void bndebug(char *string, Bignum b)
1961{
7cca0d81 1962 unsigned char *p;
1963 int i, len;
1964 p = ssh2_mpint_fmt(b, &len);
1965 debug(("%s", string));
1966 for (i = 0; i < len; i++)
32874aea 1967 debug((" %02x", p[i]));
765c4200 1968 debug(("\n"));
dcbde236 1969 sfree(p);
7cca0d81 1970}
1971#endif
1972
b672f405 1973static void hash_mpint(const struct ssh_hash *h, void *s, Bignum b)
32874aea 1974{
7cca0d81 1975 unsigned char *p;
1976 int len;
1977 p = ssh2_mpint_fmt(b, &len);
b672f405 1978 hash_string(h, s, p, len);
dcbde236 1979 sfree(p);
7cca0d81 1980}
1981
1982/*
2e85c969 1983 * Packet decode functions for both SSH-1 and SSH-2.
7cca0d81 1984 */
ff3187f6 1985static unsigned long ssh_pkt_getuint32(struct Packet *pkt)
32874aea 1986{
7cca0d81 1987 unsigned long value;
ff3187f6 1988 if (pkt->length - pkt->savedpos < 4)
32874aea 1989 return 0; /* arrgh, no way to decline (FIXME?) */
ff3187f6 1990 value = GET_32BIT(pkt->body + pkt->savedpos);
1991 pkt->savedpos += 4;
7cca0d81 1992 return value;
1993}
ff3187f6 1994static int ssh2_pkt_getbool(struct Packet *pkt)
32874aea 1995{
65a22376 1996 unsigned long value;
ff3187f6 1997 if (pkt->length - pkt->savedpos < 1)
32874aea 1998 return 0; /* arrgh, no way to decline (FIXME?) */
ff3187f6 1999 value = pkt->body[pkt->savedpos] != 0;
2000 pkt->savedpos++;
65a22376 2001 return value;
2002}
ff3187f6 2003static void ssh_pkt_getstring(struct Packet *pkt, char **p, int *length)
32874aea 2004{
57356d63 2005 int len;
7cca0d81 2006 *p = NULL;
45068b27 2007 *length = 0;
ff3187f6 2008 if (pkt->length - pkt->savedpos < 4)
32874aea 2009 return;
ff3187f6 2010 len = GET_32BIT(pkt->body + pkt->savedpos);
57356d63 2011 if (len < 0)
2012 return;
2013 *length = len;
ff3187f6 2014 pkt->savedpos += 4;
2015 if (pkt->length - pkt->savedpos < *length)
32874aea 2016 return;
ff3187f6 2017 *p = (char *)(pkt->body + pkt->savedpos);
2018 pkt->savedpos += *length;
7cca0d81 2019}
ff3187f6 2020static void *ssh_pkt_getdata(struct Packet *pkt, int length)
0016d70b 2021{
ff3187f6 2022 if (pkt->length - pkt->savedpos < length)
0016d70b 2023 return NULL;
ff3187f6 2024 pkt->savedpos += length;
2025 return pkt->body + (pkt->savedpos - length);
0016d70b 2026}
ff3187f6 2027static int ssh1_pkt_getrsakey(struct Packet *pkt, struct RSAKey *key,
0016d70b 2028 unsigned char **keystr)
2029{
2030 int j;
2031
ff3187f6 2032 j = makekey(pkt->body + pkt->savedpos,
2033 pkt->length - pkt->savedpos,
0016d70b 2034 key, keystr, 0);
2035
2036 if (j < 0)
2037 return FALSE;
2038
ff3187f6 2039 pkt->savedpos += j;
2040 assert(pkt->savedpos < pkt->length);
0016d70b 2041
2042 return TRUE;
2043}
ff3187f6 2044static Bignum ssh1_pkt_getmp(struct Packet *pkt)
0016d70b 2045{
2046 int j;
2047 Bignum b;
2048
ff3187f6 2049 j = ssh1_read_bignum(pkt->body + pkt->savedpos,
2050 pkt->length - pkt->savedpos, &b);
0016d70b 2051
2052 if (j < 0)
2053 return NULL;
2054
ff3187f6 2055 pkt->savedpos += j;
0016d70b 2056 return b;
2057}
ff3187f6 2058static Bignum ssh2_pkt_getmp(struct Packet *pkt)
32874aea 2059{
7cca0d81 2060 char *p;
3709bfe9 2061 int length;
7cca0d81 2062 Bignum b;
2063
ff3187f6 2064 ssh_pkt_getstring(pkt, &p, &length);
7cca0d81 2065 if (!p)
32874aea 2066 return NULL;
ff3187f6 2067 if (p[0] & 0x80)
32874aea 2068 return NULL;
d8baa528 2069 b = bignum_from_bytes((unsigned char *)p, length);
7cca0d81 2070 return b;
2071}
2072
7d503c31 2073/*
2e85c969 2074 * Helper function to add an SSH-2 signature blob to a packet.
1dd353b5 2075 * Expects to be shown the public key blob as well as the signature
2076 * blob. Normally works just like ssh2_pkt_addstring, but will
2077 * fiddle with the signature packet if necessary for
2078 * BUG_SSH2_RSA_PADDING.
2079 */
ff3187f6 2080static void ssh2_add_sigblob(Ssh ssh, struct Packet *pkt,
2081 void *pkblob_v, int pkblob_len,
1dd353b5 2082 void *sigblob_v, int sigblob_len)
2083{
2084 unsigned char *pkblob = (unsigned char *)pkblob_v;
2085 unsigned char *sigblob = (unsigned char *)sigblob_v;
2086
2087 /* dmemdump(pkblob, pkblob_len); */
2088 /* dmemdump(sigblob, sigblob_len); */
2089
2090 /*
2091 * See if this is in fact an ssh-rsa signature and a buggy
2092 * server; otherwise we can just do this the easy way.
2093 */
51470298 2094 if ((ssh->remote_bugs & BUG_SSH2_RSA_PADDING) &&
1dd353b5 2095 (GET_32BIT(pkblob) == 7 && !memcmp(pkblob+4, "ssh-rsa", 7))) {
2096 int pos, len, siglen;
2097
2098 /*
2099 * Find the byte length of the modulus.
2100 */
2101
2102 pos = 4+7; /* skip over "ssh-rsa" */
2103 pos += 4 + GET_32BIT(pkblob+pos); /* skip over exponent */
2104 len = GET_32BIT(pkblob+pos); /* find length of modulus */
2105 pos += 4; /* find modulus itself */
2106 while (len > 0 && pkblob[pos] == 0)
2107 len--, pos++;
2108 /* debug(("modulus length is %d\n", len)); */
2109
2110 /*
2111 * Now find the signature integer.
2112 */
2113 pos = 4+7; /* skip over "ssh-rsa" */
2114 siglen = GET_32BIT(sigblob+pos);
2115 /* debug(("signature length is %d\n", siglen)); */
2116
2117 if (len != siglen) {
2118 unsigned char newlen[4];
ff3187f6 2119 ssh2_pkt_addstring_start(pkt);
2120 ssh2_pkt_addstring_data(pkt, (char *)sigblob, pos);
1dd353b5 2121 /* dmemdump(sigblob, pos); */
2122 pos += 4; /* point to start of actual sig */
2123 PUT_32BIT(newlen, len);
ff3187f6 2124 ssh2_pkt_addstring_data(pkt, (char *)newlen, 4);
1dd353b5 2125 /* dmemdump(newlen, 4); */
2126 newlen[0] = 0;
2127 while (len-- > siglen) {
ff3187f6 2128 ssh2_pkt_addstring_data(pkt, (char *)newlen, 1);
1dd353b5 2129 /* dmemdump(newlen, 1); */
2130 }
ff3187f6 2131 ssh2_pkt_addstring_data(pkt, (char *)(sigblob+pos), siglen);
1dd353b5 2132 /* dmemdump(sigblob+pos, siglen); */
2133 return;
2134 }
2135
2136 /* Otherwise fall through and do it the easy way. */
2137 }
2138
ff3187f6 2139 ssh2_pkt_addstring_start(pkt);
2140 ssh2_pkt_addstring_data(pkt, (char *)sigblob, sigblob_len);
1dd353b5 2141}
2142
2143/*
7d503c31 2144 * Examine the remote side's version string and compare it against
2145 * a list of known buggy implementations.
2146 */
51470298 2147static void ssh_detect_bugs(Ssh ssh, char *vstring)
32874aea 2148{
2149 char *imp; /* pointer to implementation part */
7d503c31 2150 imp = vstring;
2151 imp += strcspn(imp, "-");
bd358db1 2152 if (*imp) imp++;
7d503c31 2153 imp += strcspn(imp, "-");
bd358db1 2154 if (*imp) imp++;
7d503c31 2155
51470298 2156 ssh->remote_bugs = 0;
7d503c31 2157
5ecd7ad0 2158 if (ssh->cfg.sshbug_ignore1 == FORCE_ON ||
2159 (ssh->cfg.sshbug_ignore1 == AUTO &&
2c9c6388 2160 (!strcmp(imp, "1.2.18") || !strcmp(imp, "1.2.19") ||
2161 !strcmp(imp, "1.2.20") || !strcmp(imp, "1.2.21") ||
46ac09aa 2162 !strcmp(imp, "1.2.22") || !strcmp(imp, "Cisco-1.25") ||
bd0b4caf 2163 !strcmp(imp, "OSU_1.4alpha3") || !strcmp(imp, "OSU_1.5alpha4")))) {
32874aea 2164 /*
2165 * These versions don't support SSH1_MSG_IGNORE, so we have
2166 * to use a different defence against password length
2167 * sniffing.
2168 */
51470298 2169 ssh->remote_bugs |= BUG_CHOKES_ON_SSH1_IGNORE;
2e85c969 2170 logevent("We believe remote version has SSH-1 ignore bug");
7d503c31 2171 }
2172
5ecd7ad0 2173 if (ssh->cfg.sshbug_plainpw1 == FORCE_ON ||
2174 (ssh->cfg.sshbug_plainpw1 == AUTO &&
46ac09aa 2175 (!strcmp(imp, "Cisco-1.25") || !strcmp(imp, "OSU_1.4alpha3")))) {
bd358db1 2176 /*
2177 * These versions need a plain password sent; they can't
2178 * handle having a null and a random length of data after
2179 * the password.
2180 */
51470298 2181 ssh->remote_bugs |= BUG_NEEDS_SSH1_PLAIN_PASSWORD;
2e85c969 2182 logevent("We believe remote version needs a plain SSH-1 password");
bd358db1 2183 }
2184
5ecd7ad0 2185 if (ssh->cfg.sshbug_rsa1 == FORCE_ON ||
2186 (ssh->cfg.sshbug_rsa1 == AUTO &&
2c9c6388 2187 (!strcmp(imp, "Cisco-1.25")))) {
0df73905 2188 /*
2189 * These versions apparently have no clue whatever about
2190 * RSA authentication and will panic and die if they see
2191 * an AUTH_RSA message.
2192 */
51470298 2193 ssh->remote_bugs |= BUG_CHOKES_ON_RSA;
19f47a7d 2194 logevent("We believe remote version can't handle SSH-1 RSA authentication");
0df73905 2195 }
2196
5ecd7ad0 2197 if (ssh->cfg.sshbug_hmac2 == FORCE_ON ||
2198 (ssh->cfg.sshbug_hmac2 == AUTO &&
b9f387af 2199 !wc_match("* VShell", imp) &&
831301f6 2200 (wc_match("2.1.0*", imp) || wc_match("2.0.*", imp) ||
2201 wc_match("2.2.0*", imp) || wc_match("2.3.0*", imp) ||
2202 wc_match("2.1 *", imp)))) {
32874aea 2203 /*
2204 * These versions have the HMAC bug.
2205 */
51470298 2206 ssh->remote_bugs |= BUG_SSH2_HMAC;
2e85c969 2207 logevent("We believe remote version has SSH-2 HMAC bug");
7d503c31 2208 }
1dd353b5 2209
5ecd7ad0 2210 if (ssh->cfg.sshbug_derivekey2 == FORCE_ON ||
2211 (ssh->cfg.sshbug_derivekey2 == AUTO &&
b9f387af 2212 !wc_match("* VShell", imp) &&
2856a1b9 2213 (wc_match("2.0.0*", imp) || wc_match("2.0.10*", imp) ))) {
088bde77 2214 /*
2215 * These versions have the key-derivation bug (failing to
2216 * include the literal shared secret in the hashes that
2217 * generate the keys).
2218 */
51470298 2219 ssh->remote_bugs |= BUG_SSH2_DERIVEKEY;
2e85c969 2220 logevent("We believe remote version has SSH-2 key-derivation bug");
088bde77 2221 }
2222
5ecd7ad0 2223 if (ssh->cfg.sshbug_rsapad2 == FORCE_ON ||
2224 (ssh->cfg.sshbug_rsapad2 == AUTO &&
831301f6 2225 (wc_match("OpenSSH_2.[5-9]*", imp) ||
2226 wc_match("OpenSSH_3.[0-2]*", imp)))) {
1dd353b5 2227 /*
2e85c969 2228 * These versions have the SSH-2 RSA padding bug.
1dd353b5 2229 */
51470298 2230 ssh->remote_bugs |= BUG_SSH2_RSA_PADDING;
2e85c969 2231 logevent("We believe remote version has SSH-2 RSA padding bug");
1dd353b5 2232 }
8e975795 2233
dda87a28 2234 if (ssh->cfg.sshbug_pksessid2 == FORCE_ON ||
2235 (ssh->cfg.sshbug_pksessid2 == AUTO &&
2236 wc_match("OpenSSH_2.[0-2]*", imp))) {
2237 /*
2e85c969 2238 * These versions have the SSH-2 session-ID bug in
dda87a28 2239 * public-key authentication.
2240 */
2241 ssh->remote_bugs |= BUG_SSH2_PK_SESSIONID;
2e85c969 2242 logevent("We believe remote version has SSH-2 public-key-session-ID bug");
dda87a28 2243 }
f382c87d 2244
2245 if (ssh->cfg.sshbug_rekey2 == FORCE_ON ||
2246 (ssh->cfg.sshbug_rekey2 == AUTO &&
39b8712f 2247 (wc_match("DigiSSH_2.0", imp) ||
2248 wc_match("OpenSSH_2.[0-4]*", imp) ||
e12d95a5 2249 wc_match("OpenSSH_2.5.[0-3]*", imp) ||
2250 wc_match("Sun_SSH_1.0", imp) ||
f4275b53 2251 wc_match("Sun_SSH_1.0.1", imp) ||
96bd26de 2252 /* All versions <= 1.2.6 (they changed their format in 1.2.7) */
2253 wc_match("WeOnlyDo-*", imp)))) {
f382c87d 2254 /*
2e85c969 2255 * These versions have the SSH-2 rekey bug.
f382c87d 2256 */
2257 ssh->remote_bugs |= BUG_SSH2_REKEY;
2e85c969 2258 logevent("We believe remote version has SSH-2 rekey bug");
f382c87d 2259 }
7d503c31 2260}
2261
d38d6a1f 2262/*
2263 * The `software version' part of an SSH version string is required
2264 * to contain no spaces or minus signs.
2265 */
2266static void ssh_fix_verstring(char *str)
2267{
2268 /* Eat "SSH-<protoversion>-". */
2269 assert(*str == 'S'); str++;
2270 assert(*str == 'S'); str++;
2271 assert(*str == 'H'); str++;
2272 assert(*str == '-'); str++;
2273 while (*str && *str != '-') str++;
2274 assert(*str == '-'); str++;
2275
2276 /* Convert minus signs and spaces in the remaining string into
2277 * underscores. */
2278 while (*str) {
2279 if (*str == '-' || *str == ' ')
2280 *str = '_';
2281 str++;
2282 }
2283}
2284
51470298 2285static int do_ssh_init(Ssh ssh, unsigned char c)
32874aea 2286{
51470298 2287 struct do_ssh_init_state {
2288 int vslen;
2289 char version[10];
2290 char *vstring;
2291 int vstrsize;
2292 int i;
2293 int proto1, proto2;
2294 };
2295 crState(do_ssh_init_state);
374330e2 2296
51470298 2297 crBegin(ssh->do_ssh_init_crstate);
8df7a775 2298
8c1835c0 2299 /* Search for a line beginning with the string "SSH-" in the input. */
2300 for (;;) {
2301 if (c != 'S') goto no;
2302 crReturn(1);
2303 if (c != 'S') goto no;
2304 crReturn(1);
2305 if (c != 'H') goto no;
2306 crReturn(1);
2307 if (c != '-') goto no;
2308 break;
2309 no:
2310 while (c != '\012')
2311 crReturn(1);
2312 crReturn(1);
374330e2 2313 }
8df7a775 2314
51470298 2315 s->vstrsize = 16;
3d88e64d 2316 s->vstring = snewn(s->vstrsize, char);
51470298 2317 strcpy(s->vstring, "SSH-");
2318 s->vslen = 4;
2319 s->i = 0;
374330e2 2320 while (1) {
8df7a775 2321 crReturn(1); /* get another char */
51470298 2322 if (s->vslen >= s->vstrsize - 1) {
2323 s->vstrsize += 16;
3d88e64d 2324 s->vstring = sresize(s->vstring, s->vstrsize, char);
32874aea 2325 }
51470298 2326 s->vstring[s->vslen++] = c;
2327 if (s->i >= 0) {
374330e2 2328 if (c == '-') {
51470298 2329 s->version[s->i] = '\0';
2330 s->i = -1;
2331 } else if (s->i < sizeof(s->version) - 1)
2332 s->version[s->i++] = c;
c4ffc4d0 2333 } else if (c == '\012')
374330e2 2334 break;
2335 }
2336
51470298 2337 ssh->agentfwd_enabled = FALSE;
2338 ssh->rdpkt2_state.incoming_sequence = 0;
960e736a 2339
51470298 2340 s->vstring[s->vslen] = 0;
a7d4653a 2341 s->vstring[strcspn(s->vstring, "\015\012")] = '\0';/* remove EOL chars */
fb983202 2342 logeventf(ssh, "Server version: %s", s->vstring);
51470298 2343 ssh_detect_bugs(ssh, s->vstring);
c5e9c988 2344
adf799dd 2345 /*
38d228a2 2346 * Decide which SSH protocol version to support.
adf799dd 2347 */
38d228a2 2348
2349 /* Anything strictly below "2.0" means protocol 1 is supported. */
51470298 2350 s->proto1 = ssh_versioncmp(s->version, "2.0") < 0;
38d228a2 2351 /* Anything greater or equal to "1.99" means protocol 2 is supported. */
51470298 2352 s->proto2 = ssh_versioncmp(s->version, "1.99") >= 0;
38d228a2 2353
86916870 2354 if (ssh->cfg.sshprot == 0 && !s->proto1) {
6b5cf8b4 2355 bombout(("SSH protocol version 1 required by user but not provided by server"));
7ffdbc1a 2356 crStop(0);
38d228a2 2357 }
86916870 2358 if (ssh->cfg.sshprot == 3 && !s->proto2) {
6b5cf8b4 2359 bombout(("SSH protocol version 2 required by user but not provided by server"));
7ffdbc1a 2360 crStop(0);
38d228a2 2361 }
2362
d38d6a1f 2363 {
2364 char *verstring;
2365
2366 if (s->proto2 && (ssh->cfg.sshprot >= 2 || !s->proto1)) {
2367 /*
2368 * Construct a v2 version string.
2369 */
a7d4653a 2370 verstring = dupprintf("SSH-2.0-%s\015\012", sshver);
d38d6a1f 2371 ssh->version = 2;
2372 } else {
2373 /*
2374 * Construct a v1 version string.
2375 */
a7d4653a 2376 verstring = dupprintf("SSH-%s-%s\012",
d38d6a1f 2377 (ssh_versioncmp(s->version, "1.5") <= 0 ?
2378 s->version : "1.5"),
2379 sshver);
2380 ssh->version = 1;
2381 }
2382
2383 ssh_fix_verstring(verstring);
2384
2385 if (ssh->version == 2) {
4320baf7 2386 size_t len;
d38d6a1f 2387 /*
2388 * Hash our version string and their version string.
2389 */
4320baf7 2390 len = strcspn(verstring, "\015\012");
2391 ssh->v_c = snewn(len + 1, char);
2392 memcpy(ssh->v_c, verstring, len);
2393 ssh->v_c[len] = 0;
2394 len = strcspn(s->vstring, "\015\012");
2395 ssh->v_s = snewn(len + 1, char);
2396 memcpy(ssh->v_s, s->vstring, len);
2397 ssh->v_s[len] = 0;
2398
d38d6a1f 2399 /*
2e85c969 2400 * Initialise SSH-2 protocol.
d38d6a1f 2401 */
2402 ssh->protocol = ssh2_protocol;
2403 ssh2_protocol_setup(ssh);
2404 ssh->s_rdpkt = ssh2_rdpkt;
2405 } else {
2406 /*
2e85c969 2407 * Initialise SSH-1 protocol.
d38d6a1f 2408 */
2409 ssh->protocol = ssh1_protocol;
2410 ssh1_protocol_setup(ssh);
2411 ssh->s_rdpkt = ssh1_rdpkt;
2412 }
2413 logeventf(ssh, "We claim version: %.*s",
a7d4653a 2414 strcspn(verstring, "\015\012"), verstring);
51470298 2415 sk_write(ssh->s, verstring, strlen(verstring));
d38d6a1f 2416 sfree(verstring);
f475e40a 2417 if (ssh->version == 2)
6a755251 2418 do_ssh2_transport(ssh, NULL, -1, NULL);
e5574168 2419 }
d38d6a1f 2420
2421 logeventf(ssh, "Using SSH protocol version %d", ssh->version);
2422
125105d1 2423 update_specials_menu(ssh->frontend);
51470298 2424 ssh->state = SSH_STATE_BEFORE_SIZE;
39934deb 2425 ssh->pinger = pinger_new(&ssh->cfg, &ssh_backend, ssh);
8df7a775 2426
51470298 2427 sfree(s->vstring);
50526e47 2428
8df7a775 2429 crFinish(0);
2430}
2431
3d9449a1 2432static void ssh_process_incoming_data(Ssh ssh,
2433 unsigned char **data, int *datalen)
2434{
2435 struct Packet *pktin = ssh->s_rdpkt(ssh, data, datalen);
2436 if (pktin) {
2437 ssh->protocol(ssh, NULL, 0, pktin);
2438 ssh_free_packet(pktin);
2439 }
2440}
2441
2442static void ssh_queue_incoming_data(Ssh ssh,
2443 unsigned char **data, int *datalen)
2444{
2445 bufchain_add(&ssh->queued_incoming_data, *data, *datalen);
2446 *data += *datalen;
2447 *datalen = 0;
2448}
2449
2450static void ssh_process_queued_incoming_data(Ssh ssh)
2451{
2452 void *vdata;
2453 unsigned char *data;
2454 int len, origlen;
2455
2456 while (!ssh->frozen && bufchain_size(&ssh->queued_incoming_data)) {
2457 bufchain_prefix(&ssh->queued_incoming_data, &vdata, &len);
2458 data = vdata;
2459 origlen = len;
2460
2461 while (!ssh->frozen && len > 0)
2462 ssh_process_incoming_data(ssh, &data, &len);
2463
2464 if (origlen > len)
2465 bufchain_consume(&ssh->queued_incoming_data, origlen - len);
2466 }
2467}
2468
2469static void ssh_set_frozen(Ssh ssh, int frozen)
2470{
a5a6f839 2471 if (ssh->s)
2472 sk_set_frozen(ssh->s, frozen);
3d9449a1 2473 ssh->frozen = frozen;
2474}
2475
51470298 2476static void ssh_gotdata(Ssh ssh, unsigned char *data, int datalen)
8df7a775 2477{
51470298 2478 crBegin(ssh->ssh_gotdata_crstate);
8df7a775 2479
2480 /*
2481 * To begin with, feed the characters one by one to the
2482 * protocol initialisation / selection function do_ssh_init().
2483 * When that returns 0, we're done with the initial greeting
2484 * exchange and can move on to packet discipline.
2485 */
2486 while (1) {
51470298 2487 int ret; /* need not be kept across crReturn */
8df7a775 2488 if (datalen == 0)
2489 crReturnV; /* more data please */
51470298 2490 ret = do_ssh_init(ssh, *data);
32874aea 2491 data++;
2492 datalen--;
8df7a775 2493 if (ret == 0)
2494 break;
2495 }
2496
2497 /*
2498 * We emerge from that loop when the initial negotiation is
2499 * over and we have selected an s_rdpkt function. Now pass
2500 * everything to s_rdpkt, and then pass the resulting packets
2501 * to the proper protocol handler.
2502 */
3d9449a1 2503
8df7a775 2504 while (1) {
e375106c 2505 while (bufchain_size(&ssh->queued_incoming_data) > 0 || datalen > 0) {
2506 if (ssh->frozen) {
3d9449a1 2507 ssh_queue_incoming_data(ssh, &data, &datalen);
e375106c 2508 /* This uses up all data and cannot cause anything interesting
2509 * to happen; indeed, for anything to happen at all, we must
2510 * return, so break out. */
2511 break;
2512 } else if (bufchain_size(&ssh->queued_incoming_data) > 0) {
2513 /* This uses up some or all data, and may freeze the
2514 * session. */
2515 ssh_process_queued_incoming_data(ssh);
2516 } else {
2517 /* This uses up some or all data, and may freeze the
2518 * session. */
2519 ssh_process_incoming_data(ssh, &data, &datalen);
2520 }
2521 /* FIXME this is probably EBW. */
ff3187f6 2522 if (ssh->state == SSH_STATE_CLOSED)
2523 return;
8df7a775 2524 }
e375106c 2525 /* We're out of data. Go and get some more. */
8df7a775 2526 crReturnV;
2527 }
2528 crFinishV;
2529}
2530
ac934965 2531static int ssh_do_close(Ssh ssh, int notify_exit)
32874aea 2532{
80ffa58b 2533 int ret = 0;
36f94d1f 2534 struct ssh_channel *c;
2535
51470298 2536 ssh->state = SSH_STATE_CLOSED;
ecbb0000 2537 expire_timer_context(ssh);
51470298 2538 if (ssh->s) {
2539 sk_close(ssh->s);
2540 ssh->s = NULL;
ac934965 2541 if (notify_exit)
2542 notify_remote_exit(ssh->frontend);
2543 else
2544 ret = 1;
f3ab576e 2545 }
36f94d1f 2546 /*
80ffa58b 2547 * Now we must shut down any port- and X-forwarded channels going
36f94d1f 2548 * through this connection.
2549 */
74a98066 2550 if (ssh->channels) {
80ffa58b 2551 while (NULL != (c = index234(ssh->channels, 0))) {
74a98066 2552 switch (c->type) {
2553 case CHAN_X11:
2554 x11_close(c->u.x11.s);
2555 break;
2556 case CHAN_SOCKDATA:
2557 pfd_close(c->u.pfd.s);
2558 break;
2559 }
80ffa58b 2560 del234(ssh->channels, c); /* moving next one to index 0 */
74a98066 2561 if (ssh->version == 2)
2562 bufchain_clear(&c->v.v2.outbuffer);
2563 sfree(c);
36f94d1f 2564 }
36f94d1f 2565 }
f8c9f9df 2566 /*
2567 * Go through port-forwardings, and close any associated
2568 * listening sockets.
2569 */
2570 if (ssh->portfwds) {
2571 struct ssh_portfwd *pf;
2572 while (NULL != (pf = index234(ssh->portfwds, 0))) {
2573 /* Dispose of any listening socket. */
2574 if (pf->local)
2575 pfd_terminate(pf->local);
2576 del234(ssh->portfwds, pf); /* moving next one to index 0 */
2577 free_portfwd(pf);
2578 }
2579 }
ac934965 2580
2581 return ret;
36f94d1f 2582}
2583
7555d6a5 2584static void ssh_log(Plug plug, int type, SockAddr addr, int port,
2585 const char *error_msg, int error_code)
2586{
2587 Ssh ssh = (Ssh) plug;
2588 char addrbuf[256], *msg;
2589
2590 sk_getaddr(addr, addrbuf, lenof(addrbuf));
2591
2592 if (type == 0)
2593 msg = dupprintf("Connecting to %s port %d", addrbuf, port);
2594 else
2595 msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg);
2596
2597 logevent(msg);
fb983202 2598 sfree(msg);
7555d6a5 2599}
2600
cbe2d68f 2601static int ssh_closing(Plug plug, const char *error_msg, int error_code,
36f94d1f 2602 int calling_back)
2603{
2604 Ssh ssh = (Ssh) plug;
ac934965 2605 int need_notify = ssh_do_close(ssh, FALSE);
2606
9e296bfa 2607 if (!error_msg) {
2608 if (!ssh->close_expected)
2609 error_msg = "Server unexpectedly closed network connection";
2610 else
2611 error_msg = "Server closed network connection";
ac934965 2612 }
2613
2425184b 2614 if (need_notify)
2615 notify_remote_exit(ssh->frontend);
2616
9e296bfa 2617 if (error_msg)
247308b5 2618 logevent(error_msg);
9e296bfa 2619 if (!ssh->close_expected || !ssh->clean_exit)
971bcc0a 2620 connection_fatal(ssh->frontend, "%s", error_msg);
7e78000d 2621 return 0;
2622}
2623
32874aea 2624static int ssh_receive(Plug plug, int urgent, char *data, int len)
2625{
51470298 2626 Ssh ssh = (Ssh) plug;
d8baa528 2627 ssh_gotdata(ssh, (unsigned char *)data, len);
51470298 2628 if (ssh->state == SSH_STATE_CLOSED) {
ac934965 2629 ssh_do_close(ssh, TRUE);
32874aea 2630 return 0;
3257deae 2631 }
fef97f43 2632 return 1;
374330e2 2633}
2634
5471d09a 2635static void ssh_sent(Plug plug, int bufsize)
2636{
51470298 2637 Ssh ssh = (Ssh) plug;
5471d09a 2638 /*
2639 * If the send backlog on the SSH socket itself clears, we
2640 * should unthrottle the whole world if it was throttled.
2641 */
2642 if (bufsize < SSH_MAX_BACKLOG)
51470298 2643 ssh_throttle_all(ssh, 0, bufsize);
5471d09a 2644}
2645
fb09bf1c 2646/*
8df7a775 2647 * Connect to specified host and port.
2648 * Returns an error message, or NULL on success.
6e1ebb76 2649 * Also places the canonical host name into `realhost'. It must be
2650 * freed by the caller.
8df7a775 2651 */
cbe2d68f 2652static const char *connect_to_host(Ssh ssh, char *host, int port,
79bf227b 2653 char **realhost, int nodelay, int keepalive)
8df7a775 2654{
51470298 2655 static const struct plug_function_table fn_table = {
7555d6a5 2656 ssh_log,
7e78000d 2657 ssh_closing,
5471d09a 2658 ssh_receive,
2659 ssh_sent,
2660 NULL
51470298 2661 };
7e78000d 2662
8df7a775 2663 SockAddr addr;
cbe2d68f 2664 const char *err;
8df7a775 2665
3d88e64d 2666 ssh->savedhost = snewn(1 + strlen(host), char);
51470298 2667 strcpy(ssh->savedhost, host);
8df7a775 2668
2669 if (port < 0)
2670 port = 22; /* default ssh port */
51470298 2671 ssh->savedport = port;
8df7a775 2672
2673 /*
2674 * Try to find host.
2675 */
05581745 2676 logeventf(ssh, "Looking up host \"%s\"%s", host,
2677 (ssh->cfg.addressfamily == ADDRTYPE_IPV4 ? " (IPv4)" :
2678 (ssh->cfg.addressfamily == ADDRTYPE_IPV6 ? " (IPv6)" : "")));
2679 addr = name_lookup(host, port, realhost, &ssh->cfg,
2680 ssh->cfg.addressfamily);
170c1e6e 2681 if ((err = sk_addr_error(addr)) != NULL) {
2682 sk_addr_free(addr);
8df7a775 2683 return err;
170c1e6e 2684 }
8df7a775 2685
8df7a775 2686 /*
2687 * Open socket.
2688 */
51470298 2689 ssh->fn = &fn_table;
e8fa8f62 2690 ssh->s = new_connection(addr, *realhost, port,
79bf227b 2691 0, 1, nodelay, keepalive, (Plug) ssh, &ssh->cfg);
70e5d0fd 2692 if ((err = sk_socket_error(ssh->s)) != NULL) {
51470298 2693 ssh->s = NULL;
39934deb 2694 notify_remote_exit(ssh->frontend);
8df7a775 2695 return err;
67c4ba2e 2696 }
8df7a775 2697
8df7a775 2698 return NULL;
2699}
2700
2701/*
5471d09a 2702 * Throttle or unthrottle the SSH connection.
2703 */
51470298 2704static void ssh1_throttle(Ssh ssh, int adjust)
5471d09a 2705{
51470298 2706 int old_count = ssh->v1_throttle_count;
2707 ssh->v1_throttle_count += adjust;
2708 assert(ssh->v1_throttle_count >= 0);
2709 if (ssh->v1_throttle_count && !old_count) {
3d9449a1 2710 ssh_set_frozen(ssh, 1);
51470298 2711 } else if (!ssh->v1_throttle_count && old_count) {
3d9449a1 2712 ssh_set_frozen(ssh, 0);
5471d09a 2713 }
2714}
2715
2716/*
2717 * Throttle or unthrottle _all_ local data streams (for when sends
2718 * on the SSH connection itself back up).
2719 */
51470298 2720static void ssh_throttle_all(Ssh ssh, int enable, int bufsize)
5471d09a 2721{
2722 int i;
2723 struct ssh_channel *c;
2724
51470298 2725 if (enable == ssh->throttled_all)
5471d09a 2726 return;
51470298 2727 ssh->throttled_all = enable;
2728 ssh->overall_bufsize = bufsize;
2729 if (!ssh->channels)
5471d09a 2730 return;
51470298 2731 for (i = 0; NULL != (c = index234(ssh->channels, i)); i++) {
5471d09a 2732 switch (c->type) {
2733 case CHAN_MAINSESSION:
2734 /*
2735 * This is treated separately, outside the switch.
2736 */
2737 break;
2738 case CHAN_X11:
2739 x11_override_throttle(c->u.x11.s, enable);
2740 break;
2741 case CHAN_AGENT:
2742 /* Agent channels require no buffer management. */
2743 break;
2744 case CHAN_SOCKDATA:
36f94d1f 2745 pfd_override_throttle(c->u.pfd.s, enable);
5471d09a 2746 break;
2747 }
2748 }
2749}
2750
f11d78f2 2751static void ssh_agent_callback(void *sshv, void *reply, int replylen)
839f10db 2752{
2753 Ssh ssh = (Ssh) sshv;
2754
2755 ssh->agent_response = reply;
2756 ssh->agent_response_len = replylen;
2757
2758 if (ssh->version == 1)
ff3187f6 2759 do_ssh1_login(ssh, NULL, -1, NULL);
839f10db 2760 else
ff3187f6 2761 do_ssh2_authconn(ssh, NULL, -1, NULL);
839f10db 2762}
2763
3d9449a1 2764static void ssh_dialog_callback(void *sshv, int ret)
2765{
2766 Ssh ssh = (Ssh) sshv;
2767
2768 ssh->user_response = ret;
2769
2770 if (ssh->version == 1)
2771 do_ssh1_login(ssh, NULL, -1, NULL);
2772 else
2773 do_ssh2_transport(ssh, NULL, -1, NULL);
2774
2775 /*
2776 * This may have unfrozen the SSH connection, so do a
2777 * queued-data run.
2778 */
2779 ssh_process_queued_incoming_data(ssh);
2780}
2781
f11d78f2 2782static void ssh_agentf_callback(void *cv, void *reply, int replylen)
839f10db 2783{
2784 struct ssh_channel *c = (struct ssh_channel *)cv;
2785 Ssh ssh = c->ssh;
2786 void *sentreply = reply;
2787
2788 if (!sentreply) {
2789 /* Fake SSH_AGENT_FAILURE. */
2790 sentreply = "\0\0\0\1\5";
2791 replylen = 5;
2792 }
2793 if (ssh->version == 2) {
2794 ssh2_add_channel_data(c, sentreply, replylen);
2795 ssh2_try_send(c);
2796 } else {
2797 send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
2798 PKT_INT, c->remoteid,
9a10ecf4 2799 PKTT_DATA,
839f10db 2800 PKT_INT, replylen,
2801 PKT_DATA, sentreply, replylen,
9a10ecf4 2802 PKTT_OTHER,
839f10db 2803 PKT_END);
2804 }
2805 if (reply)
2806 sfree(reply);
2807}
2808
0405e71f 2809/*
9e296bfa 2810 * Client-initiated disconnection. Send a DISCONNECT if `wire_reason'
2811 * non-NULL, otherwise just close the connection. `client_reason' == NULL
2812 * => log `wire_reason'.
2813 */
2814static void ssh_disconnect(Ssh ssh, char *client_reason, char *wire_reason,
2815 int code, int clean_exit)
2816{
2817 char *error;
2818 if (!client_reason)
2819 client_reason = wire_reason;
2820 if (client_reason)
2821 error = dupprintf("Disconnected: %s", client_reason);
2822 else
2823 error = dupstr("Disconnected");
2824 if (wire_reason) {
2825 if (ssh->version == 1) {
2826 send_packet(ssh, SSH1_MSG_DISCONNECT, PKT_STR, wire_reason,
2827 PKT_END);
2828 } else if (ssh->version == 2) {
2829 struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_DISCONNECT);
2830 ssh2_pkt_adduint32(pktout, code);
2831 ssh2_pkt_addstring(pktout, wire_reason);
2832 ssh2_pkt_addstring(pktout, "en"); /* language tag */
2833 ssh2_pkt_send_noqueue(ssh, pktout);
2834 }
2835 }
2836 ssh->close_expected = TRUE;
2837 ssh->clean_exit = clean_exit;
2838 ssh_closing((Plug)ssh, error, 0, 0);
2839 sfree(error);
2840}
2841
2842/*
fb09bf1c 2843 * Handle the key exchange and user authentication phases.
2844 */
ff3187f6 2845static int do_ssh1_login(Ssh ssh, unsigned char *in, int inlen,
2846 struct Packet *pktin)
fb09bf1c 2847{
0016d70b 2848 int i, j, ret;
2849 unsigned char cookie[8], *ptr;
374330e2 2850 struct RSAKey servkey, hostkey;
2851 struct MD5Context md5c;
51470298 2852 struct do_ssh1_login_state {
2853 int len;
2854 unsigned char *rsabuf, *keystr1, *keystr2;
2855 unsigned long supported_ciphers_mask, supported_auths_mask;
2856 int tried_publickey, tried_agent;
2857 int tis_auth_refused, ccard_auth_refused;
2858 unsigned char session_id[16];
2859 int cipher_type;
2860 char username[100];
2861 void *publickey_blob;
2862 int publickey_bloblen;
edd0cb8a 2863 char *publickey_comment;
2864 int publickey_encrypted;
2865 prompts_t *cur_prompt;
51470298 2866 char c;
2867 int pwpkt_type;
2868 unsigned char request[5], *response, *p;
2869 int responselen;
2870 int keyi, nkeys;
2871 int authed;
2872 struct RSAKey key;
2873 Bignum challenge;
2874 char *commentp;
2875 int commentlen;
3d9449a1 2876 int dlgret;
51470298 2877 };
2878 crState(do_ssh1_login_state);
2879
2880 crBegin(ssh->do_ssh1_login_crstate);
374330e2 2881
ff3187f6 2882 if (!pktin)
2883 crWaitUntil(pktin);
374330e2 2884
ff3187f6 2885 if (pktin->type != SSH1_SMSG_PUBLIC_KEY) {
6b5cf8b4 2886 bombout(("Public key packet not received"));
7ffdbc1a 2887 crStop(0);
8d5de777 2888 }
374330e2 2889
c5e9c988 2890 logevent("Received public keys");
374330e2 2891
ff3187f6 2892 ptr = ssh_pkt_getdata(pktin, 8);
0016d70b 2893 if (!ptr) {
2e85c969 2894 bombout(("SSH-1 public key packet stopped before random cookie"));
0016d70b 2895 crStop(0);
2896 }
2897 memcpy(cookie, ptr, 8);
374330e2 2898
ff3187f6 2899 if (!ssh1_pkt_getrsakey(pktin, &servkey, &s->keystr1) ||
2900 !ssh1_pkt_getrsakey(pktin, &hostkey, &s->keystr2)) {
2e85c969 2901 bombout(("Failed to read SSH-1 public keys from public key packet"));
0016d70b 2902 crStop(0);
2903 }
374330e2 2904
c5e9c988 2905 /*
1c2a93c4 2906 * Log the host key fingerprint.
c5e9c988 2907 */
c5e9c988 2908 {
2909 char logmsg[80];
1c2a93c4 2910 logevent("Host key fingerprint is:");
c5e9c988 2911 strcpy(logmsg, " ");
32874aea 2912 hostkey.comment = NULL;
2913 rsa_fingerprint(logmsg + strlen(logmsg),
2914 sizeof(logmsg) - strlen(logmsg), &hostkey);
c5e9c988 2915 logevent(logmsg);
2916 }
2917
ff3187f6 2918 ssh->v1_remote_protoflags = ssh_pkt_getuint32(pktin);
2919 s->supported_ciphers_mask = ssh_pkt_getuint32(pktin);
2920 s->supported_auths_mask = ssh_pkt_getuint32(pktin);
bea1ef5f 2921
51470298 2922 ssh->v1_local_protoflags =
2923 ssh->v1_remote_protoflags & SSH1_PROTOFLAGS_SUPPORTED;
2924 ssh->v1_local_protoflags |= SSH1_PROTOFLAG_SCREEN_NUMBER;
b96dc54c 2925
c5e9c988 2926 MD5Init(&md5c);
51470298 2927 MD5Update(&md5c, s->keystr2, hostkey.bytes);
2928 MD5Update(&md5c, s->keystr1, servkey.bytes);
0016d70b 2929 MD5Update(&md5c, cookie, 8);
51470298 2930 MD5Final(s->session_id, &md5c);
374330e2 2931
32874aea 2932 for (i = 0; i < 32; i++)
51470298 2933 ssh->session_key[i] = random_byte();
374330e2 2934
0016d70b 2935 /*
2936 * Verify that the `bits' and `bytes' parameters match.
2937 */
2938 if (hostkey.bits > hostkey.bytes * 8 ||
2939 servkey.bits > servkey.bytes * 8) {
2e85c969 2940 bombout(("SSH-1 public keys were badly formatted"));
0016d70b 2941 crStop(0);
2942 }
2943
51470298 2944 s->len = (hostkey.bytes > servkey.bytes ? hostkey.bytes : servkey.bytes);
374330e2 2945
3d88e64d 2946 s->rsabuf = snewn(s->len, unsigned char);
374330e2 2947
89ee5268 2948 /*
2949 * Verify the host key.
2950 */
2951 {
32874aea 2952 /*
2953 * First format the key into a string.
2954 */
2955 int len = rsastr_len(&hostkey);
2956 char fingerprint[100];
3d88e64d 2957 char *keystr = snewn(len, char);
32874aea 2958 rsastr_fmt(keystr, &hostkey);
2959 rsa_fingerprint(fingerprint, sizeof(fingerprint), &hostkey);
3d9449a1 2960
2961 ssh_set_frozen(ssh, 1);
2962 s->dlgret = verify_ssh_host_key(ssh->frontend,
2963 ssh->savedhost, ssh->savedport,
2964 "rsa", keystr, fingerprint,
2965 ssh_dialog_callback, ssh);
32874aea 2966 sfree(keystr);
3d9449a1 2967 if (s->dlgret < 0) {
2968 do {
2969 crReturn(0);
2970 if (pktin) {
2971 bombout(("Unexpected data from server while waiting"
2972 " for user host key response"));
2973 crStop(0);
2974 }
2975 } while (pktin || inlen > 0);
2976 s->dlgret = ssh->user_response;
2977 }
2978 ssh_set_frozen(ssh, 0);
2979
2980 if (s->dlgret == 0) {
9e296bfa 2981 ssh_disconnect(ssh, "User aborted at host key verification",
2982 NULL, 0, TRUE);
2b3f6c19 2983 crStop(0);
3d9449a1 2984 }
32874aea 2985 }
2986
2987 for (i = 0; i < 32; i++) {
51470298 2988 s->rsabuf[i] = ssh->session_key[i];
374330e2 2989 if (i < 16)
51470298 2990 s->rsabuf[i] ^= s->session_id[i];
374330e2 2991 }
2992
2993 if (hostkey.bytes > servkey.bytes) {
0016d70b 2994 ret = rsaencrypt(s->rsabuf, 32, &servkey);
2995 if (ret)
2996 ret = rsaencrypt(s->rsabuf, servkey.bytes, &hostkey);
374330e2 2997 } else {
0016d70b 2998 ret = rsaencrypt(s->rsabuf, 32, &hostkey);
2999 if (ret)
3000 ret = rsaencrypt(s->rsabuf, hostkey.bytes, &servkey);
3001 }
3002 if (!ret) {
2e85c969 3003 bombout(("SSH-1 public key encryptions failed due to bad formatting"));
0016d70b 3004 crStop(0);
374330e2 3005 }
3006
c5e9c988 3007 logevent("Encrypted session key");
3008
ca20bfcf 3009 {
3010 int cipher_chosen = 0, warn = 0;
3011 char *cipher_string = NULL;
51470298 3012 int i;
ca20bfcf 3013 for (i = 0; !cipher_chosen && i < CIPHER_MAX; i++) {
86916870 3014 int next_cipher = ssh->cfg.ssh_cipherlist[i];
ca20bfcf 3015 if (next_cipher == CIPHER_WARN) {
3016 /* If/when we choose a cipher, warn about it */
3017 warn = 1;
3018 } else if (next_cipher == CIPHER_AES) {
3019 /* XXX Probably don't need to mention this. */
2e85c969 3020 logevent("AES not supported in SSH-1, skipping");
ca20bfcf 3021 } else {
3022 switch (next_cipher) {
51470298 3023 case CIPHER_3DES: s->cipher_type = SSH_CIPHER_3DES;
ca20bfcf 3024 cipher_string = "3DES"; break;
51470298 3025 case CIPHER_BLOWFISH: s->cipher_type = SSH_CIPHER_BLOWFISH;
ca20bfcf 3026 cipher_string = "Blowfish"; break;
51470298 3027 case CIPHER_DES: s->cipher_type = SSH_CIPHER_DES;
ca20bfcf 3028 cipher_string = "single-DES"; break;
3029 }
51470298 3030 if (s->supported_ciphers_mask & (1 << s->cipher_type))
ca20bfcf 3031 cipher_chosen = 1;
3032 }
3033 }
3034 if (!cipher_chosen) {
51470298 3035 if ((s->supported_ciphers_mask & (1 << SSH_CIPHER_3DES)) == 0)
2e85c969 3036 bombout(("Server violates SSH-1 protocol by not "
ca20bfcf 3037 "supporting 3DES encryption"));
3038 else
3039 /* shouldn't happen */
6b5cf8b4 3040 bombout(("No supported ciphers found"));
7ffdbc1a 3041 crStop(0);
a99a05c0 3042 }
ca20bfcf 3043
3044 /* Warn about chosen cipher if necessary. */
bb348ab1 3045 if (warn) {
3d9449a1 3046 ssh_set_frozen(ssh, 1);
3047 s->dlgret = askalg(ssh->frontend, "cipher", cipher_string,
3048 ssh_dialog_callback, ssh);
3049 if (s->dlgret < 0) {
3050 do {
3051 crReturn(0);
3052 if (pktin) {
3053 bombout(("Unexpected data from server while waiting"
3054 " for user response"));
3055 crStop(0);
3056 }
3057 } while (pktin || inlen > 0);
3058 s->dlgret = ssh->user_response;
3059 }
3060 ssh_set_frozen(ssh, 0);
3061 if (s->dlgret == 0) {
9e296bfa 3062 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
3063 0, TRUE);
96ccde8b 3064 crStop(0);
3d9449a1 3065 }
bb348ab1 3066 }
bea1ef5f 3067 }
ca20bfcf 3068
51470298 3069 switch (s->cipher_type) {
32874aea 3070 case SSH_CIPHER_3DES:
3071 logevent("Using 3DES encryption");
3072 break;
3073 case SSH_CIPHER_DES:
3074 logevent("Using single-DES encryption");
3075 break;
3076 case SSH_CIPHER_BLOWFISH:
3077 logevent("Using Blowfish encryption");
3078 break;
c5e9c988 3079 }
bea1ef5f 3080
51470298 3081 send_packet(ssh, SSH1_CMSG_SESSION_KEY,
3082 PKT_CHAR, s->cipher_type,
32874aea 3083 PKT_DATA, cookie, 8,
51470298 3084 PKT_CHAR, (s->len * 8) >> 8, PKT_CHAR, (s->len * 8) & 0xFF,
3085 PKT_DATA, s->rsabuf, s->len,
3086 PKT_INT, ssh->v1_local_protoflags, PKT_END);
fb09bf1c 3087
c5e9c988 3088 logevent("Trying to enable encryption...");
374330e2 3089
51470298 3090 sfree(s->rsabuf);
374330e2 3091
51470298 3092 ssh->cipher = (s->cipher_type == SSH_CIPHER_BLOWFISH ? &ssh_blowfish_ssh1 :
3093 s->cipher_type == SSH_CIPHER_DES ? &ssh_des :
3094 &ssh_3des);
371e569c 3095 ssh->v1_cipher_ctx = ssh->cipher->make_context();
3096 ssh->cipher->sesskey(ssh->v1_cipher_ctx, ssh->session_key);
57356d63 3097 logeventf(ssh, "Initialised %s encryption", ssh->cipher->text_name);
374330e2 3098
0183b242 3099 ssh->crcda_ctx = crcda_make_context();
3100 logevent("Installing CRC compensation attack detector");
3101
679539d7 3102 if (servkey.modulus) {
3103 sfree(servkey.modulus);
3104 servkey.modulus = NULL;
3105 }
3106 if (servkey.exponent) {
3107 sfree(servkey.exponent);
3108 servkey.exponent = NULL;
3109 }
3110 if (hostkey.modulus) {
3111 sfree(hostkey.modulus);
3112 hostkey.modulus = NULL;
3113 }
3114 if (hostkey.exponent) {
3115 sfree(hostkey.exponent);
3116 hostkey.exponent = NULL;
3117 }
ff3187f6 3118 crWaitUntil(pktin);
374330e2 3119
ff3187f6 3120 if (pktin->type != SSH1_SMSG_SUCCESS) {
6b5cf8b4 3121 bombout(("Encryption not successfully enabled"));
7ffdbc1a 3122 crStop(0);
8d5de777 3123 }
374330e2 3124
c5e9c988 3125 logevent("Successfully started encryption");
3126
edd0cb8a 3127 fflush(stdout); /* FIXME eh? */
374330e2 3128 {
aa09f7d0 3129 if (!*ssh->cfg.username) {
edd0cb8a 3130 int ret; /* need not be kept over crReturn */
3131 s->cur_prompt = new_prompts(ssh->frontend);
3132 s->cur_prompt->to_server = TRUE;
3133 s->cur_prompt->name = dupstr("SSH login name");
3134 add_prompt(s->cur_prompt, dupstr("login as: "), TRUE,
3135 lenof(s->username));
3136 ret = get_userpass_input(s->cur_prompt, NULL, 0);
3137 while (ret < 0) {
51470298 3138 ssh->send_ok = 1;
edd0cb8a 3139 crWaitUntil(!pktin);
3140 ret = get_userpass_input(s->cur_prompt, in, inlen);
3141 ssh->send_ok = 0;
3142 }
3143 if (!ret) {
3144 /*
3145 * Failed to get a username. Terminate.
3146 */
3147 free_prompts(s->cur_prompt);
3148 ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
3149 crStop(0);
32874aea 3150 }
edd0cb8a 3151 memcpy(s->username, s->cur_prompt->prompts[0]->result,
3152 lenof(s->username));
3153 free_prompts(s->cur_prompt);
32874aea 3154 } else {
86916870 3155 strncpy(s->username, ssh->cfg.username, sizeof(s->username));
51470298 3156 s->username[sizeof(s->username)-1] = '\0';
374330e2 3157 }
fb09bf1c 3158
51470298 3159 send_packet(ssh, SSH1_CMSG_USER, PKT_STR, s->username, PKT_END);
c5e9c988 3160 {
edd0cb8a 3161 char *userlog = dupprintf("Sent username \"%s\"", s->username);
c5e9c988 3162 logevent(userlog);
32874aea 3163 if (flags & FLAG_INTERACTIVE &&
3164 (!((flags & FLAG_STDERR) && (flags & FLAG_VERBOSE)))) {
51470298 3165 c_write_str(ssh, userlog);
edd0cb8a 3166 c_write_str(ssh, "\r\n");
3c8e959b 3167 }
edd0cb8a 3168 sfree(userlog);
c5e9c988 3169 }
374330e2 3170 }
3171
ff3187f6 3172 crWaitUntil(pktin);
374330e2 3173
51470298 3174 if ((ssh->remote_bugs & BUG_CHOKES_ON_RSA)) {
0df73905 3175 /* We must not attempt PK auth. Pretend we've already tried it. */
51470298 3176 s->tried_publickey = s->tried_agent = 1;
0df73905 3177 } else {
51470298 3178 s->tried_publickey = s->tried_agent = 0;
0df73905 3179 }
51470298 3180 s->tis_auth_refused = s->ccard_auth_refused = 0;
edd0cb8a 3181 /*
3182 * Load the public half of any configured keyfile for later use.
3183 */
9a30e26b 3184 if (!filename_is_null(ssh->cfg.keyfile)) {
edd0cb8a 3185 int keytype;
3186 logeventf(ssh, "Reading private key file \"%.150s\"",
3187 filename_to_str(&ssh->cfg.keyfile));
3188 keytype = key_type(&ssh->cfg.keyfile);
3189 if (keytype == SSH_KEYTYPE_SSH1) {
3190 const char *error;
3191 if (rsakey_pubblob(&ssh->cfg.keyfile,
3192 &s->publickey_blob, &s->publickey_bloblen,
3193 &s->publickey_comment, &error)) {
3194 s->publickey_encrypted = rsakey_encrypted(&ssh->cfg.keyfile,
3195 NULL);
3196 } else {
3197 char *msgbuf;
3198 logeventf(ssh, "Unable to load private key (%s)", error);
3199 msgbuf = dupprintf("Unable to load private key file "
3200 "\"%.150s\" (%s)\r\n",
3201 filename_to_str(&ssh->cfg.keyfile),
3202 error);
3203 c_write_str(ssh, msgbuf);
3204 sfree(msgbuf);
3205 s->publickey_blob = NULL;
3206 }
3207 } else {
3208 char *msgbuf;
3209 logeventf(ssh, "Unable to use this key file (%s)",
3210 key_type_to_str(keytype));
3211 msgbuf = dupprintf("Unable to use key file \"%.150s\""
3212 " (%s)\r\n",
3213 filename_to_str(&ssh->cfg.keyfile),
3214 key_type_to_str(keytype));
3215 c_write_str(ssh, msgbuf);
3216 sfree(msgbuf);
51470298 3217 s->publickey_blob = NULL;
edd0cb8a 3218 }
396778f1 3219 } else
51470298 3220 s->publickey_blob = NULL;
7cca0d81 3221
ff3187f6 3222 while (pktin->type == SSH1_SMSG_FAILURE) {
51470298 3223 s->pwpkt_type = SSH1_CMSG_AUTH_PASSWORD;
614a20a0 3224
51470298 3225 if (agent_exists() && !s->tried_agent) {
32874aea 3226 /*
3227 * Attempt RSA authentication using Pageant.
3228 */
32874aea 3229 void *r;
3230
51470298 3231 s->authed = FALSE;
3232 s->tried_agent = 1;
32874aea 3233 logevent("Pageant is running. Requesting keys.");
3234
3235 /* Request the keys held by the agent. */
51470298 3236 PUT_32BIT(s->request, 1);
3237 s->request[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES;
839f10db 3238 if (!agent_query(s->request, 5, &r, &s->responselen,
3239 ssh_agent_callback, ssh)) {
3240 do {
3241 crReturn(0);
ff3187f6 3242 if (pktin) {
839f10db 3243 bombout(("Unexpected data from server while waiting"
3244 " for agent response"));
3245 crStop(0);
3246 }
ff3187f6 3247 } while (pktin || inlen > 0);
839f10db 3248 r = ssh->agent_response;
3249 s->responselen = ssh->agent_response_len;
3250 }
51470298 3251 s->response = (unsigned char *) r;
3252 if (s->response && s->responselen >= 5 &&
3253 s->response[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER) {
3254 s->p = s->response + 5;
3255 s->nkeys = GET_32BIT(s->p);
3256 s->p += 4;
2e85c969 3257 logeventf(ssh, "Pageant has %d SSH-1 keys", s->nkeys);
51470298 3258 for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
fb983202 3259 logeventf(ssh, "Trying Pageant key #%d", s->keyi);
51470298 3260 if (s->publickey_blob &&
3261 !memcmp(s->p, s->publickey_blob,
3262 s->publickey_bloblen)) {
396778f1 3263 logevent("This key matches configured key file");
51470298 3264 s->tried_publickey = 1;
396778f1 3265 }
51470298 3266 s->p += 4;
0016d70b 3267 {
3268 int n, ok = FALSE;
3269 do { /* do while (0) to make breaking easy */
3270 n = ssh1_read_bignum
3271 (s->p, s->responselen-(s->p-s->response),
3272 &s->key.exponent);
3273 if (n < 0)
3274 break;
3275 s->p += n;
3276 n = ssh1_read_bignum
3277 (s->p, s->responselen-(s->p-s->response),
3278 &s->key.modulus);
3279 if (n < 0)
3280 break;
3281 s->p += n;
3282 if (s->responselen - (s->p-s->response) < 4)
3283 break;
3284 s->commentlen = GET_32BIT(s->p);
3285 s->p += 4;
3286 if (s->responselen - (s->p-s->response) <
3287 s->commentlen)
3288 break;
3289 s->commentp = (char *)s->p;
3290 s->p += s->commentlen;
3291 ok = TRUE;
3292 } while (0);
3293 if (!ok) {
3294 logevent("Pageant key list packet was truncated");
3295 break;
3296 }
3297 }
51470298 3298 send_packet(ssh, SSH1_CMSG_AUTH_RSA,
3299 PKT_BIGNUM, s->key.modulus, PKT_END);
ff3187f6 3300 crWaitUntil(pktin);
3301 if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
32874aea 3302 logevent("Key refused");
3303 continue;
3304 }
3305 logevent("Received RSA challenge");
ff3187f6 3306 if ((s->challenge = ssh1_pkt_getmp(pktin)) == NULL) {
0016d70b 3307 bombout(("Server's RSA challenge was badly formatted"));
3308 crStop(0);
3309 }
3310
32874aea 3311 {
3312 char *agentreq, *q, *ret;
2d466ffd 3313 void *vret;
32874aea 3314 int len, retlen;
3315 len = 1 + 4; /* message type, bit count */
51470298 3316 len += ssh1_bignum_length(s->key.exponent);
3317 len += ssh1_bignum_length(s->key.modulus);
3318 len += ssh1_bignum_length(s->challenge);
32874aea 3319 len += 16; /* session id */
3320 len += 4; /* response format */
3d88e64d 3321 agentreq = snewn(4 + len, char);
32874aea 3322 PUT_32BIT(agentreq, len);
3323 q = agentreq + 4;
3324 *q++ = SSH1_AGENTC_RSA_CHALLENGE;
51470298 3325 PUT_32BIT(q, bignum_bitcount(s->key.modulus));
32874aea 3326 q += 4;
51470298 3327 q += ssh1_write_bignum(q, s->key.exponent);
3328 q += ssh1_write_bignum(q, s->key.modulus);
3329 q += ssh1_write_bignum(q, s->challenge);
3330 memcpy(q, s->session_id, 16);
32874aea 3331 q += 16;
3332 PUT_32BIT(q, 1); /* response format */
839f10db 3333 if (!agent_query(agentreq, len + 4, &vret, &retlen,
3334 ssh_agent_callback, ssh)) {
3335 sfree(agentreq);
3336 do {
3337 crReturn(0);
ff3187f6 3338 if (pktin) {
839f10db 3339 bombout(("Unexpected data from server"
3340 " while waiting for agent"
3341 " response"));
3342 crStop(0);
3343 }
ff3187f6 3344 } while (pktin || inlen > 0);
839f10db 3345 vret = ssh->agent_response;
3346 retlen = ssh->agent_response_len;
3347 } else
3348 sfree(agentreq);
2d466ffd 3349 ret = vret;
32874aea 3350 if (ret) {
3351 if (ret[4] == SSH1_AGENT_RSA_RESPONSE) {
3352 logevent("Sending Pageant's response");
51470298 3353 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
32874aea 3354 PKT_DATA, ret + 5, 16,
3355 PKT_END);
3356 sfree(ret);
ff3187f6 3357 crWaitUntil(pktin);
3358 if (pktin->type == SSH1_SMSG_SUCCESS) {
32874aea 3359 logevent
3360 ("Pageant's response accepted");
3361 if (flags & FLAG_VERBOSE) {
51470298 3362 c_write_str(ssh, "Authenticated using"
3363 " RSA key \"");
3364 c_write(ssh, s->commentp,
3365 s->commentlen);
3366 c_write_str(ssh, "\" from agent\r\n");
32874aea 3367 }
51470298 3368 s->authed = TRUE;
32874aea 3369 } else
3370 logevent
3371 ("Pageant's response not accepted");
3372 } else {
3373 logevent
3374 ("Pageant failed to answer challenge");
3375 sfree(ret);
3376 }
3377 } else {
3378 logevent("No reply received from Pageant");
3379 }
3380 }
51470298 3381 freebn(s->key.exponent);
3382 freebn(s->key.modulus);
3383 freebn(s->challenge);
3384 if (s->authed)
32874aea 3385 break;
3386 }
29b1d0b3 3387 sfree(s->response);
32874aea 3388 }
51470298 3389 if (s->authed)
32874aea 3390 break;
3391 }
edd0cb8a 3392 if (s->publickey_blob && !s->tried_publickey) {
3393 /*
3394 * Try public key authentication with the specified
3395 * key file.
3396 */
3397 int got_passphrase; /* need not be kept over crReturn */
3398 if (flags & FLAG_VERBOSE)
3399 c_write_str(ssh, "Trying public key authentication.\r\n");
3400 logeventf(ssh, "Trying public key \"%s\"",
3401 filename_to_str(&ssh->cfg.keyfile));
3402 s->tried_publickey = 1;
3403 got_passphrase = FALSE;
3404 while (!got_passphrase) {
3405 /*
3406 * Get a passphrase, if necessary.
3407 */
3408 char *passphrase = NULL; /* only written after crReturn */
3409 const char *error;
3410 if (!s->publickey_encrypted) {
3411 if (flags & FLAG_VERBOSE)
3412 c_write_str(ssh, "No passphrase required.\r\n");
3413 passphrase = NULL;
3414 } else {
3415 int ret; /* need not be kept over crReturn */
3416 s->cur_prompt = new_prompts(ssh->frontend);
3417 s->cur_prompt->to_server = FALSE;
3418 s->cur_prompt->name = dupstr("SSH key passphrase");
3419 add_prompt(s->cur_prompt,
3420 dupprintf("Passphrase for key \"%.100s\": ",
3421 s->publickey_comment),
3422 FALSE, SSH_MAX_PASSWORD_LEN);
3423 ret = get_userpass_input(s->cur_prompt, NULL, 0);
3424 while (ret < 0) {
3425 ssh->send_ok = 1;
3426 crWaitUntil(!pktin);
3427 ret = get_userpass_input(s->cur_prompt, in, inlen);
3428 ssh->send_ok = 0;
3429 }
3430 if (!ret) {
3431 /* Failed to get a passphrase. Terminate. */
3432 free_prompts(s->cur_prompt);
3433 ssh_disconnect(ssh, NULL, "Unable to authenticate",
3434 0, TRUE);
3435 crStop(0);
3436 }
3437 passphrase = dupstr(s->cur_prompt->prompts[0]->result);
3438 free_prompts(s->cur_prompt);
3439 }
3440 /*
3441 * Try decrypting key with passphrase.
3442 */
3443 ret = loadrsakey(&ssh->cfg.keyfile, &s->key, passphrase,
3444 &error);
3445 if (passphrase) {
3446 memset(passphrase, 0, strlen(passphrase));
3447 sfree(passphrase);
3448 }
3449 if (ret == 1) {
3450 /* Correct passphrase. */
3451 got_passphrase = TRUE;
3452 } else if (ret == 0) {
3453 c_write_str(ssh, "Couldn't load private key from ");
3454 c_write_str(ssh, filename_to_str(&ssh->cfg.keyfile));
3455 c_write_str(ssh, " (");
3456 c_write_str(ssh, error);
3457 c_write_str(ssh, ").\r\n");
3458 got_passphrase = FALSE;
3459 break; /* go and try something else */
3460 } else if (ret == -1) {
3461 c_write_str(ssh, "Wrong passphrase.\r\n"); /* FIXME */
3462 s->tried_publickey = 0;
3463 got_passphrase = FALSE;
3464 /* and try again */
3465 }
3466 }
3467
3468 if (got_passphrase) {
3469
3470 /*
3471 * Send a public key attempt.
3472 */
3473 send_packet(ssh, SSH1_CMSG_AUTH_RSA,
3474 PKT_BIGNUM, s->key.modulus, PKT_END);
3475
3476 crWaitUntil(pktin);
3477 if (pktin->type == SSH1_SMSG_FAILURE) {
3478 c_write_str(ssh, "Server refused our public key.\r\n");
3479 continue; /* go and try password */
3480 }
3481 if (pktin->type != SSH1_SMSG_AUTH_RSA_CHALLENGE) {
3482 bombout(("Bizarre response to offer of public key"));
3483 crStop(0);
3484 }
3485
3486 {
3487 int i;
3488 unsigned char buffer[32];
3489 Bignum challenge, response;
3490
3491 if ((challenge = ssh1_pkt_getmp(pktin)) == NULL) {
3492 bombout(("Server's RSA challenge was badly formatted"));
3493 crStop(0);
3494 }
3495 response = rsadecrypt(challenge, &s->key);
3496 freebn(s->key.private_exponent);/* burn the evidence */
3497
3498 for (i = 0; i < 32; i++) {
3499 buffer[i] = bignum_byte(response, 31 - i);
3500 }
3501
3502 MD5Init(&md5c);
3503 MD5Update(&md5c, buffer, 32);
3504 MD5Update(&md5c, s->session_id, 16);
3505 MD5Final(buffer, &md5c);
3506
3507 send_packet(ssh, SSH1_CMSG_AUTH_RSA_RESPONSE,
3508 PKT_DATA, buffer, 16, PKT_END);
3509
3510 freebn(challenge);
3511 freebn(response);
3512 }
3513
3514 crWaitUntil(pktin);
3515 if (pktin->type == SSH1_SMSG_FAILURE) {
3516 if (flags & FLAG_VERBOSE)
3517 c_write_str(ssh, "Failed to authenticate with"
3518 " our public key.\r\n");
3519 continue; /* go and try password */
3520 } else if (pktin->type != SSH1_SMSG_SUCCESS) {
3521 bombout(("Bizarre response to RSA authentication response"));
3522 crStop(0);
3523 }
3524
3525 break; /* we're through! */
3526 }
3527
3528 }
3529
3530 /*
3531 * Otherwise, try various forms of password-like authentication.
3532 */
3533 s->cur_prompt = new_prompts(ssh->frontend);
32874aea 3534
86916870 3535 if (ssh->cfg.try_tis_auth &&
51470298 3536 (s->supported_auths_mask & (1 << SSH1_AUTH_TIS)) &&
3537 !s->tis_auth_refused) {
3538 s->pwpkt_type = SSH1_CMSG_AUTH_TIS_RESPONSE;
32874aea 3539 logevent("Requested TIS authentication");
51470298 3540 send_packet(ssh, SSH1_CMSG_AUTH_TIS, PKT_END);
ff3187f6 3541 crWaitUntil(pktin);
3542 if (pktin->type != SSH1_SMSG_AUTH_TIS_CHALLENGE) {
32874aea 3543 logevent("TIS authentication declined");
3544 if (flags & FLAG_INTERACTIVE)
51470298 3545 c_write_str(ssh, "TIS authentication refused.\r\n");
3546 s->tis_auth_refused = 1;
614a20a0 3547 continue;
32874aea 3548 } else {
0016d70b 3549 char *challenge;
3550 int challengelen;
edd0cb8a 3551 char *instr_suf, *prompt;
0016d70b 3552
ff3187f6 3553 ssh_pkt_getstring(pktin, &challenge, &challengelen);
0016d70b 3554 if (!challenge) {
3555 bombout(("TIS challenge packet was badly formed"));
3556 crStop(0);
3557 }
32874aea 3558 logevent("Received TIS challenge");
edd0cb8a 3559 s->cur_prompt->to_server = TRUE;
3560 s->cur_prompt->name = dupstr("SSH TIS authentication");
614a20a0 3561 /* Prompt heuristic comes from OpenSSH */
edd0cb8a 3562 if (memchr(challenge, '\n', challengelen)) {
3563 instr_suf = dupstr("");
3564 prompt = dupprintf("%.*s", challengelen, challenge);
3565 } else {
3566 instr_suf = dupprintf("%.*s", challengelen, challenge);
3567 prompt = dupstr("Response: ");
3568 }
3569 s->cur_prompt->instruction =
3570 dupprintf("Using TIS authentication.%s%s",
3571 (*instr_suf) ? "\n" : "",
3572 instr_suf);
3573 s->cur_prompt->instr_reqd = TRUE;
3574 add_prompt(s->cur_prompt, prompt, FALSE, SSH_MAX_PASSWORD_LEN);
3575 sfree(instr_suf);
32874aea 3576 }
3577 }
86916870 3578 if (ssh->cfg.try_tis_auth &&
51470298 3579 (s->supported_auths_mask & (1 << SSH1_AUTH_CCARD)) &&
3580 !s->ccard_auth_refused) {
3581 s->pwpkt_type = SSH1_CMSG_AUTH_CCARD_RESPONSE;
32874aea 3582 logevent("Requested CryptoCard authentication");
51470298 3583 send_packet(ssh, SSH1_CMSG_AUTH_CCARD, PKT_END);
ff3187f6 3584 crWaitUntil(pktin);
3585 if (pktin->type != SSH1_SMSG_AUTH_CCARD_CHALLENGE) {
32874aea 3586 logevent("CryptoCard authentication declined");
51470298 3587 c_write_str(ssh, "CryptoCard authentication refused.\r\n");
3588 s->ccard_auth_refused = 1;
614a20a0 3589 continue;
32874aea 3590 } else {
0016d70b 3591 char *challenge;
3592 int challengelen;
edd0cb8a 3593 char *instr_suf, *prompt;
0016d70b 3594
ff3187f6 3595 ssh_pkt_getstring(pktin, &challenge, &challengelen);
0016d70b 3596 if (!challenge) {
3597 bombout(("CryptoCard challenge packet was badly formed"));
3598 crStop(0);
3599 }
32874aea 3600 logevent("Received CryptoCard challenge");
edd0cb8a 3601 s->cur_prompt->to_server = TRUE;
3602 s->cur_prompt->name = dupstr("SSH CryptoCard authentication");
3603 s->cur_prompt->name_reqd = FALSE;
3604 /* Prompt heuristic comes from OpenSSH */
3605 if (memchr(challenge, '\n', challengelen)) {
3606 instr_suf = dupstr("");
3607 prompt = dupprintf("%.*s", challengelen, challenge);
3608 } else {
3609 instr_suf = dupprintf("%.*s", challengelen, challenge);
3610 prompt = dupstr("Response: ");
3611 }
3612 s->cur_prompt->instruction =
3613 dupprintf("Using CryptoCard authentication.%s%s",
3614 (*instr_suf) ? "\n" : "",
3615 instr_suf);
3616 s->cur_prompt->instr_reqd = TRUE;
3617 add_prompt(s->cur_prompt, prompt, FALSE, SSH_MAX_PASSWORD_LEN);
3618 sfree(instr_suf);
32874aea 3619 }
3620 }
51470298 3621 if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
edd0cb8a 3622 s->cur_prompt->to_server = TRUE;
3623 s->cur_prompt->name = dupstr("SSH password");
3624 add_prompt(s->cur_prompt, dupprintf("%.90s@%.90s's password: ",
3625 s->username, ssh->savedhost),
3626 FALSE, SSH_MAX_PASSWORD_LEN);
32874aea 3627 }
a52f067e 3628
614a20a0 3629 /*
3630 * Show password prompt, having first obtained it via a TIS
3631 * or CryptoCard exchange if we're doing TIS or CryptoCard
3632 * authentication.
3633 */
edd0cb8a 3634 {
3635 int ret; /* need not be kept over crReturn */
3636 ret = get_userpass_input(s->cur_prompt, NULL, 0);
3637 while (ret < 0) {
3638 ssh->send_ok = 1;
3639 crWaitUntil(!pktin);
3640 ret = get_userpass_input(s->cur_prompt, in, inlen);
3641 ssh->send_ok = 0;
3642 }
3643 if (!ret) {
32874aea 3644 /*
edd0cb8a 3645 * Failed to get a password (for example
32874aea 3646 * because one was supplied on the command line
3647 * which has already failed to work). Terminate.
3648 */
edd0cb8a 3649 free_prompts(s->cur_prompt);
3650 ssh_disconnect(ssh, NULL, "Unable to authenticate", 0, TRUE);
3651 crStop(0);
32874aea 3652 }
32874aea 3653 }
3654
edd0cb8a 3655 if (s->pwpkt_type == SSH1_CMSG_AUTH_PASSWORD) {
32874aea 3656 /*
edd0cb8a 3657 * Defence against traffic analysis: we send a
3658 * whole bunch of packets containing strings of
3659 * different lengths. One of these strings is the
3660 * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
3661 * The others are all random data in
3662 * SSH1_MSG_IGNORE packets. This way a passive
3663 * listener can't tell which is the password, and
3664 * hence can't deduce the password length.
3665 *
3666 * Anybody with a password length greater than 16
3667 * bytes is going to have enough entropy in their
3668 * password that a listener won't find it _that_
3669 * much help to know how long it is. So what we'll
3670 * do is:
3671 *
3672 * - if password length < 16, we send 15 packets
3673 * containing string lengths 1 through 15
3674 *
3675 * - otherwise, we let N be the nearest multiple
3676 * of 8 below the password length, and send 8
3677 * packets containing string lengths N through
3678 * N+7. This won't obscure the order of
3679 * magnitude of the password length, but it will
3680 * introduce a bit of extra uncertainty.
3681 *
3682 * A few servers (the old 1.2.18 through 1.2.22)
3683 * can't deal with SSH1_MSG_IGNORE. For these
3684 * servers, we need an alternative defence. We make
3685 * use of the fact that the password is interpreted
3686 * as a C string: so we can append a NUL, then some
3687 * random data.
3688 *
3689 * One server (a Cisco one) can deal with neither
3690 * SSH1_MSG_IGNORE _nor_ a padded password string.
3691 * For this server we are left with no defences
3692 * against password length sniffing.
32874aea 3693 */
edd0cb8a 3694 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE)) {
32874aea 3695 /*
edd0cb8a 3696 * The server can deal with SSH1_MSG_IGNORE, so
3697 * we can use the primary defence.
32874aea 3698 */
edd0cb8a 3699 int bottom, top, pwlen, i;
3700 char *randomstr;
32874aea 3701
edd0cb8a 3702 pwlen = strlen(s->cur_prompt->prompts[0]->result);
3703 if (pwlen < 16) {
3704 bottom = 0; /* zero length passwords are OK! :-) */
3705 top = 15;
3706 } else {
3707 bottom = pwlen & ~7;
3708 top = bottom + 7;
3709 }
32874aea 3710
edd0cb8a 3711 assert(pwlen >= bottom && pwlen <= top);
32874aea 3712
edd0cb8a 3713 randomstr = snewn(top + 1, char);
32874aea 3714
edd0cb8a 3715 for (i = bottom; i <= top; i++) {
3716 if (i == pwlen) {
3717 defer_packet(ssh, s->pwpkt_type,
3718 PKTT_PASSWORD, PKT_STR,
3719 s->cur_prompt->prompts[0]->result,
3720 PKTT_OTHER, PKT_END);
3721 } else {
3722 for (j = 0; j < i; j++) {
3723 do {
3724 randomstr[j] = random_byte();
3725 } while (randomstr[j] == '\0');
32874aea 3726 }
edd0cb8a 3727 randomstr[i] = '\0';
3728 defer_packet(ssh, SSH1_MSG_IGNORE,
3729 PKT_STR, randomstr, PKT_END);
32874aea 3730 }
edd0cb8a 3731 }
3732 logevent("Sending password with camouflage packets");
3733 ssh_pkt_defersend(ssh);
3734 sfree(randomstr);
3735 }
3736 else if (!(ssh->remote_bugs & BUG_NEEDS_SSH1_PLAIN_PASSWORD)) {
3737 /*
3738 * The server can't deal with SSH1_MSG_IGNORE
3739 * but can deal with padded passwords, so we
3740 * can use the secondary defence.
3741 */
3742 char string[64];
3743 char *ss;
3744 int len;
3745
3746 len = strlen(s->cur_prompt->prompts[0]->result);
3747 if (len < sizeof(string)) {
3748 ss = string;
3749 strcpy(string, s->cur_prompt->prompts[0]->result);
3750 len++; /* cover the zero byte */
3751 while (len < sizeof(string)) {
3752 string[len++] = (char) random_byte();
bd358db1 3753 }
bd358db1 3754 } else {
edd0cb8a 3755 ss = s->cur_prompt->prompts[0]->result;
32874aea 3756 }
edd0cb8a 3757 logevent("Sending length-padded password");
9a10ecf4 3758 send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
edd0cb8a 3759 PKT_INT, len, PKT_DATA, ss, len,
3760 PKTT_OTHER, PKT_END);
3761 } else {
3762 /*
3763 * The server has _both_
3764 * BUG_CHOKES_ON_SSH1_IGNORE and
3765 * BUG_NEEDS_SSH1_PLAIN_PASSWORD. There is
3766 * therefore nothing we can do.
3767 */
3768 int len;
3769 len = strlen(s->cur_prompt->prompts[0]->result);
3770 logevent("Sending unpadded password");
3771 send_packet(ssh, s->pwpkt_type,
3772 PKTT_PASSWORD, PKT_INT, len,
3773 PKT_DATA, s->cur_prompt->prompts[0]->result, len,
3774 PKTT_OTHER, PKT_END);
32874aea 3775 }
edd0cb8a 3776 } else {
3777 send_packet(ssh, s->pwpkt_type, PKTT_PASSWORD,
3778 PKT_STR, s->cur_prompt->prompts[0]->result,
3779 PKTT_OTHER, PKT_END);
32874aea 3780 }
c5e9c988 3781 logevent("Sent password");
edd0cb8a 3782 free_prompts(s->cur_prompt);
ff3187f6 3783 crWaitUntil(pktin);
3784 if (pktin->type == SSH1_SMSG_FAILURE) {
32874aea 3785 if (flags & FLAG_VERBOSE)
51470298 3786 c_write_str(ssh, "Access denied\r\n");
c5e9c988 3787 logevent("Authentication refused");
ff3187f6 3788 } else if (pktin->type != SSH1_SMSG_SUCCESS) {
3789 bombout(("Strange packet received, type %d", pktin->type));
7ffdbc1a 3790 crStop(0);
374330e2 3791 }
3792 }
3793
edd0cb8a 3794 /* Clear up */
3795 if (s->publickey_blob) {
3796 sfree(s->publickey_blob);
3797 sfree(s->publickey_comment);
3798 }
3799
c5e9c988 3800 logevent("Authentication successful");
3801
fb09bf1c 3802 crFinish(1);
3803}
3804
32874aea 3805void sshfwd_close(struct ssh_channel *c)
3806{
51470298 3807 Ssh ssh = c->ssh;
3808
1ef619ae 3809 if (ssh->state == SSH_STATE_CLOSED)
36f94d1f 3810 return;
36f94d1f 3811
80e48603 3812 if (c && !c->closes) {
4ed34d25 3813 /*
64d6ff88 3814 * If halfopen is true, we have sent
4ed34d25 3815 * CHANNEL_OPEN for this channel, but it hasn't even been
3816 * acknowledged by the server. So we must set a close flag
3817 * on it now, and then when the server acks the channel
3818 * open, we can close it then.
3819 */
64d6ff88 3820 if (!c->halfopen) {
51470298 3821 if (ssh->version == 1) {
3822 send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE, PKT_INT, c->remoteid,
4ed34d25 3823 PKT_END);
3824 } else {
ff3187f6 3825 struct Packet *pktout;
3826 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
3827 ssh2_pkt_adduint32(pktout, c->remoteid);
3828 ssh2_pkt_send(ssh, pktout);
4ed34d25 3829 }
32874aea 3830 }
0357890f 3831 c->closes = 1; /* sent MSG_CLOSE */
32874aea 3832 if (c->type == CHAN_X11) {
3833 c->u.x11.s = NULL;
d74d141c 3834 logevent("Forwarded X11 connection terminated");
4ed34d25 3835 } else if (c->type == CHAN_SOCKDATA ||
3836 c->type == CHAN_SOCKDATA_DORMANT) {
d74d141c 3837 c->u.pfd.s = NULL;
3838 logevent("Forwarded port closed");
32874aea 3839 }
3840 }
3841}
3842
5471d09a 3843int sshfwd_write(struct ssh_channel *c, char *buf, int len)
32874aea 3844{
51470298 3845 Ssh ssh = c->ssh;
3846
1ef619ae 3847 if (ssh->state == SSH_STATE_CLOSED)
36f94d1f 3848 return 0;
36f94d1f 3849
51470298 3850 if (ssh->version == 1) {
3851 send_packet(ssh, SSH1_MSG_CHANNEL_DATA,
32874aea 3852 PKT_INT, c->remoteid,
9a10ecf4 3853 PKTT_DATA,
3854 PKT_INT, len, PKT_DATA, buf, len,
3855 PKTT_OTHER, PKT_END);
5471d09a 3856 /*
2e85c969 3857 * In SSH-1 we can return 0 here - implying that forwarded
5471d09a 3858 * connections are never individually throttled - because
3859 * the only circumstance that can cause throttling will be
3860 * the whole SSH connection backing up, in which case
3861 * _everything_ will be throttled as a whole.
3862 */
3863 return 0;
783415f8 3864 } else {
32874aea 3865 ssh2_add_channel_data(c, buf, len);
5471d09a 3866 return ssh2_try_send(c);
3867 }
3868}
3869
3870void sshfwd_unthrottle(struct ssh_channel *c, int bufsize)
3871{
51470298 3872 Ssh ssh = c->ssh;
3873
1ef619ae 3874 if (ssh->state == SSH_STATE_CLOSED)
36f94d1f 3875 return;
36f94d1f 3876
51470298 3877 if (ssh->version == 1) {
5471d09a 3878 if (c->v.v1.throttling && bufsize < SSH1_BUFFER_LIMIT) {
3879 c->v.v1.throttling = 0;
51470298 3880 ssh1_throttle(ssh, -1);
5471d09a 3881 }
3882 } else {
3883 ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
783415f8 3884 }
9c964e85 3885}
3886
06fadff5 3887static void ssh_queueing_handler(Ssh ssh, struct Packet *pktin)
3888{
3889 struct queued_handler *qh = ssh->qhead;
3890
3891 assert(qh != NULL);
3892
3893 assert(pktin->type == qh->msg1 || pktin->type == qh->msg2);
3894
3895 if (qh->msg1 > 0) {
3896 assert(ssh->packet_dispatch[qh->msg1] == ssh_queueing_handler);
3897 ssh->packet_dispatch[qh->msg1] = NULL;
3898 }
3899 if (qh->msg2 > 0) {
3900 assert(ssh->packet_dispatch[qh->msg2] == ssh_queueing_handler);
3901 ssh->packet_dispatch[qh->msg2] = NULL;
3902 }
3903
3904 if (qh->next) {
3905 ssh->qhead = qh->next;
3906
3907 if (ssh->qhead->msg1 > 0) {
3908 assert(ssh->packet_dispatch[ssh->qhead->msg1] == NULL);
3909 ssh->packet_dispatch[ssh->qhead->msg1] = ssh_queueing_handler;
3910 }
3911 if (ssh->qhead->msg2 > 0) {
3912 assert(ssh->packet_dispatch[ssh->qhead->msg2] == NULL);
3913 ssh->packet_dispatch[ssh->qhead->msg2] = ssh_queueing_handler;
3914 }
3915 } else {
3916 ssh->qhead = ssh->qtail = NULL;
3917 ssh->packet_dispatch[pktin->type] = NULL;
3918 }
3919
3920 qh->handler(ssh, pktin, qh->ctx);
3921
3922 sfree(qh);
3923}
3924
3925static void ssh_queue_handler(Ssh ssh, int msg1, int msg2,
3926 chandler_fn_t handler, void *ctx)
3927{
3928 struct queued_handler *qh;
3929
3930 qh = snew(struct queued_handler);
3931 qh->msg1 = msg1;
3932 qh->msg2 = msg2;
3933 qh->handler = handler;
3934 qh->ctx = ctx;
3935 qh->next = NULL;
3936
3937 if (ssh->qtail == NULL) {
3938 ssh->qhead = qh;
3939
3940 if (qh->msg1 > 0) {
3941 assert(ssh->packet_dispatch[qh->msg1] == NULL);
3942 ssh->packet_dispatch[qh->msg1] = ssh_queueing_handler;
3943 }
3944 if (qh->msg2 > 0) {
3945 assert(ssh->packet_dispatch[qh->msg2] == NULL);
3946 ssh->packet_dispatch[qh->msg2] = ssh_queueing_handler;
3947 }
3948 } else {
3949 ssh->qtail->next = qh;
3950 }
3951 ssh->qtail = qh;
3952}
3953
3954static void ssh_rportfwd_succfail(Ssh ssh, struct Packet *pktin, void *ctx)
3955{
3956 struct ssh_rportfwd *rpf, *pf = (struct ssh_rportfwd *)ctx;
3957
3958 if (pktin->type == (ssh->version == 1 ? SSH1_SMSG_SUCCESS :
3959 SSH2_MSG_REQUEST_SUCCESS)) {
3960 logeventf(ssh, "Remote port forwarding from %s enabled",
3961 pf->sportdesc);
3962 } else {
3963 logeventf(ssh, "Remote port forwarding from %s refused",
3964 pf->sportdesc);
3965
3966 rpf = del234(ssh->rportfwds, pf);
3967 assert(rpf == pf);
fda2feb1 3968 free_rportfwd(pf);
06fadff5 3969 }
3970}
3971
3972static void ssh_setup_portfwd(Ssh ssh, const Config *cfg)
3973{
84328ddb 3974 const char *portfwd_strptr = cfg->portfwd;
3975 struct ssh_portfwd *epf;
3976 int i;
06fadff5 3977
fda2feb1 3978 if (!ssh->portfwds) {
3979 ssh->portfwds = newtree234(ssh_portcmp);
3980 } else {
3981 /*
3982 * Go through the existing port forwardings and tag them
84328ddb 3983 * with status==DESTROY. Any that we want to keep will be
3984 * re-enabled (status==KEEP) as we go through the
3985 * configuration and find out which bits are the same as
3986 * they were before.
fda2feb1 3987 */
3988 struct ssh_portfwd *epf;
3989 int i;
3990 for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
84328ddb 3991 epf->status = DESTROY;
fda2feb1 3992 }
3993
06fadff5 3994 while (*portfwd_strptr) {
84328ddb 3995 char address_family, type;
3996 int sport,dport,sserv,dserv;
3997 char sports[256], dports[256], saddr[256], host[256];
3998 int n;
3999
05581745 4000 address_family = 'A';
4001 type = 'L';
84328ddb 4002 if (*portfwd_strptr == 'A' ||
4003 *portfwd_strptr == '4' ||
4004 *portfwd_strptr == '6')
4005 address_family = *portfwd_strptr++;
4006 if (*portfwd_strptr == 'L' ||
4007 *portfwd_strptr == 'R' ||
4008 *portfwd_strptr == 'D')
4009 type = *portfwd_strptr++;
05581745 4010
06fadff5 4011 saddr[0] = '\0';
05581745 4012
06fadff5 4013 n = 0;
4014 while (*portfwd_strptr && *portfwd_strptr != '\t') {
4015 if (*portfwd_strptr == ':') {
4016 /*
4017 * We've seen a colon in the middle of the
4018 * source port number. This means that
4019 * everything we've seen until now is the
4020 * source _address_, so we'll move it into
4021 * saddr and start sports from the beginning
4022 * again.
4023 */
4024 portfwd_strptr++;
4025 sports[n] = '\0';
4026 if (ssh->version == 1 && type == 'R') {
2e85c969 4027 logeventf(ssh, "SSH-1 cannot handle remote source address "
06fadff5 4028 "spec \"%s\"; ignoring", sports);
4029 } else
4030 strcpy(saddr, sports);
4031 n = 0;
4032 }
019164b0 4033 if (n < lenof(sports)-1) sports[n++] = *portfwd_strptr++;
06fadff5 4034 }
4035 sports[n] = 0;
4036 if (type != 'D') {
4037 if (*portfwd_strptr == '\t')
4038 portfwd_strptr++;
4039 n = 0;
4040 while (*portfwd_strptr && *portfwd_strptr != ':') {
019164b0 4041 if (n < lenof(host)-1) host[n++] = *portfwd_strptr++;
06fadff5 4042 }
4043 host[n] = 0;
4044 if (*portfwd_strptr == ':')
4045 portfwd_strptr++;
4046 n = 0;
4047 while (*portfwd_strptr) {
019164b0 4048 if (n < lenof(dports)-1) dports[n++] = *portfwd_strptr++;
06fadff5 4049 }
4050 dports[n] = 0;
4051 portfwd_strptr++;
4052 dport = atoi(dports);
4053 dserv = 0;
4054 if (dport == 0) {
4055 dserv = 1;
4056 dport = net_service_lookup(dports);
4057 if (!dport) {
4058 logeventf(ssh, "Service lookup failed for destination"
4059 " port \"%s\"", dports);
4060 }
4061 }
4062 } else {
4063 while (*portfwd_strptr) portfwd_strptr++;
a9e72926 4064 host[0] = 0;
4065 dports[0] = 0;
06fadff5 4066 dport = dserv = -1;
4067 portfwd_strptr++; /* eat the NUL and move to next one */
4068 }
4069 sport = atoi(sports);
4070 sserv = 0;
4071 if (sport == 0) {
4072 sserv = 1;
4073 sport = net_service_lookup(sports);
4074 if (!sport) {
4075 logeventf(ssh, "Service lookup failed for source"
4076 " port \"%s\"", sports);
4077 }
4078 }
4079 if (sport && dport) {
4080 /* Set up a description of the source port. */
fda2feb1 4081 struct ssh_portfwd *pfrec, *epfrec;
fda2feb1 4082
4083 pfrec = snew(struct ssh_portfwd);
4084 pfrec->type = type;
4085 pfrec->saddr = *saddr ? dupstr(saddr) : NULL;
3fe92132 4086 pfrec->sserv = sserv ? dupstr(sports) : NULL;
fda2feb1 4087 pfrec->sport = sport;
84328ddb 4088 pfrec->daddr = *host ? dupstr(host) : NULL;
3fe92132 4089 pfrec->dserv = dserv ? dupstr(dports) : NULL;
fda2feb1 4090 pfrec->dport = dport;
4091 pfrec->local = NULL;
4092 pfrec->remote = NULL;
05581745 4093 pfrec->addressfamily = (address_family == '4' ? ADDRTYPE_IPV4 :
4094 address_family == '6' ? ADDRTYPE_IPV6 :
4095 ADDRTYPE_UNSPEC);
fda2feb1 4096
4097 epfrec = add234(ssh->portfwds, pfrec);
4098 if (epfrec != pfrec) {
4099 /*
4100 * We already have a port forwarding with precisely
4101 * these parameters. Hence, no need to do anything;
84328ddb 4102 * simply tag the existing one as KEEP.
fda2feb1 4103 */
84328ddb 4104 epfrec->status = KEEP;
fda2feb1 4105 free_portfwd(pfrec);
84328ddb 4106 } else {
4107 pfrec->status = CREATE;
4108 }
4109 }
4110 }
4111
4112 /*
4113 * Now go through and destroy any port forwardings which were
4114 * not re-enabled.
4115 */
4116 for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
4117 if (epf->status == DESTROY) {
4118 char *message;
4119
4120 message = dupprintf("%s port forwarding from %s%s%d",
4121 epf->type == 'L' ? "local" :
4122 epf->type == 'R' ? "remote" : "dynamic",
4123 epf->saddr ? epf->saddr : "",
4124 epf->saddr ? ":" : "",
4125 epf->sport);
4126
4127 if (epf->type != 'D') {
4128 char *msg2 = dupprintf("%s to %s:%d", message,
4129 epf->daddr, epf->dport);
4130 sfree(message);
4131 message = msg2;
4132 }
4133
4134 logeventf(ssh, "Cancelling %s", message);
4135 sfree(message);
4136
4137 if (epf->remote) {
4138 struct ssh_rportfwd *rpf = epf->remote;
4139 struct Packet *pktout;
4140
4141 /*
4142 * Cancel the port forwarding at the server
4143 * end.
4144 */
4145 if (ssh->version == 1) {
4146 /*
4147 * We cannot cancel listening ports on the
2e85c969 4148 * server side in SSH-1! There's no message
84328ddb 4149 * to support it. Instead, we simply remove
4150 * the rportfwd record from the local end
4151 * so that any connections the server tries
4152 * to make on it are rejected.
4153 */
4154 } else {
4155 pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
4156 ssh2_pkt_addstring(pktout, "cancel-tcpip-forward");
4157 ssh2_pkt_addbool(pktout, 0);/* _don't_ want reply */
4158 if (epf->saddr) {
4159 ssh2_pkt_addstring(pktout, epf->saddr);
4160 } else if (ssh->cfg.rport_acceptall) {
5188540b 4161 /* XXX: ssh->cfg.rport_acceptall may not represent
4162 * what was used to open the original connection,
4163 * since it's reconfigurable. */
84328ddb 4164 ssh2_pkt_addstring(pktout, "0.0.0.0");
4165 } else {
4166 ssh2_pkt_addstring(pktout, "127.0.0.1");
4167 }
4168 ssh2_pkt_adduint32(pktout, epf->sport);
4169 ssh2_pkt_send(ssh, pktout);
4170 }
4171
4172 del234(ssh->rportfwds, rpf);
4173 free_rportfwd(rpf);
4174 } else if (epf->local) {
4175 pfd_terminate(epf->local);
4176 }
4177
4178 delpos234(ssh->portfwds, i);
4179 free_portfwd(epf);
4180 i--; /* so we don't skip one in the list */
4181 }
4182
4183 /*
4184 * And finally, set up any new port forwardings (status==CREATE).
4185 */
4186 for (i = 0; (epf = index234(ssh->portfwds, i)) != NULL; i++)
4187 if (epf->status == CREATE) {
4188 char *sportdesc, *dportdesc;
3fe92132 4189 sportdesc = dupprintf("%s%s%s%s%d%s",
84328ddb 4190 epf->saddr ? epf->saddr : "",
4191 epf->saddr ? ":" : "",
3fe92132 4192 epf->sserv ? epf->sserv : "",
4193 epf->sserv ? "(" : "",
4194 epf->sport,
4195 epf->sserv ? ")" : "");
84328ddb 4196 if (epf->type == 'D') {
4197 dportdesc = NULL;
4198 } else {
3fe92132 4199 dportdesc = dupprintf("%s:%s%s%d%s",
4200 epf->daddr,
4201 epf->dserv ? epf->dserv : "",
4202 epf->dserv ? "(" : "",
4203 epf->dport,
4204 epf->dserv ? ")" : "");
84328ddb 4205 }
05581745 4206
84328ddb 4207 if (epf->type == 'L') {
4208 const char *err = pfd_addforward(epf->daddr, epf->dport,
4209 epf->saddr, epf->sport,
5188540b 4210 ssh, cfg,
84328ddb 4211 &epf->local,
4212 epf->addressfamily);
4213
4214 logeventf(ssh, "Local %sport %s forwarding to %s%s%s",
4215 epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
4216 epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
4217 sportdesc, dportdesc,
4218 err ? " failed: " : "", err ? err : "");
4219 } else if (epf->type == 'D') {
06fadff5 4220 const char *err = pfd_addforward(NULL, -1,
84328ddb 4221 epf->saddr, epf->sport,
5188540b 4222 ssh, cfg,
84328ddb 4223 &epf->local,
4224 epf->addressfamily);
4225
4226 logeventf(ssh, "Local %sport %s SOCKS dynamic forwarding%s%s",
4227 epf->addressfamily == ADDRTYPE_IPV4 ? "IPv4 " :
4228 epf->addressfamily == ADDRTYPE_IPV6 ? "IPv6 " : "",
4229 sportdesc,
4230 err ? " failed: " : "", err ? err : "");
06fadff5 4231 } else {
4232 struct ssh_rportfwd *pf;
4233
4234 /*
4235 * Ensure the remote port forwardings tree exists.
4236 */
4237 if (!ssh->rportfwds) {
4238 if (ssh->version == 1)
4239 ssh->rportfwds = newtree234(ssh_rportcmp_ssh1);
4240 else
4241 ssh->rportfwds = newtree234(ssh_rportcmp_ssh2);
4242 }
4243
4244 pf = snew(struct ssh_rportfwd);
84328ddb 4245 strncpy(pf->dhost, epf->daddr, lenof(pf->dhost)-1);
4246 pf->dhost[lenof(pf->dhost)-1] = '\0';
4247 pf->dport = epf->dport;
4248 pf->sport = epf->sport;
06fadff5 4249 if (add234(ssh->rportfwds, pf) != pf) {
4250 logeventf(ssh, "Duplicate remote port forwarding to %s:%d",
84328ddb 4251 epf->daddr, epf->dport);
06fadff5 4252 sfree(pf);
4253 } else {
4254 logeventf(ssh, "Requesting remote port %s"
84328ddb 4255 " forward to %s", sportdesc, dportdesc);
06fadff5 4256
4257 pf->sportdesc = sportdesc;
4258 sportdesc = NULL;
84328ddb 4259 epf->remote = pf;
4260 pf->pfrec = epf;
06fadff5 4261
4262 if (ssh->version == 1) {
4263 send_packet(ssh, SSH1_CMSG_PORT_FORWARD_REQUEST,
84328ddb 4264 PKT_INT, epf->sport,
4265 PKT_STR, epf->daddr,
4266 PKT_INT, epf->dport,
06fadff5 4267 PKT_END);
4268 ssh_queue_handler(ssh, SSH1_SMSG_SUCCESS,
4269 SSH1_SMSG_FAILURE,
4270 ssh_rportfwd_succfail, pf);
4271 } else {
4272 struct Packet *pktout;
4273 pktout = ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST);
4274 ssh2_pkt_addstring(pktout, "tcpip-forward");
4275 ssh2_pkt_addbool(pktout, 1);/* want reply */
84328ddb 4276 if (epf->saddr) {
4277 ssh2_pkt_addstring(pktout, epf->saddr);
5188540b 4278 } else if (cfg->rport_acceptall) {
06fadff5 4279 ssh2_pkt_addstring(pktout, "0.0.0.0");
4280 } else {
4281 ssh2_pkt_addstring(pktout, "127.0.0.1");
4282 }
84328ddb 4283 ssh2_pkt_adduint32(pktout, epf->sport);
06fadff5 4284 ssh2_pkt_send(ssh, pktout);
4285
4286 ssh_queue_handler(ssh, SSH2_MSG_REQUEST_SUCCESS,
4287 SSH2_MSG_REQUEST_FAILURE,
4288 ssh_rportfwd_succfail, pf);
4289 }
4290 }
4291 }
4292 sfree(sportdesc);
84328ddb 4293 sfree(dportdesc);
06fadff5 4294 }
06fadff5 4295}
4296
51df0ab5 4297static void ssh1_smsg_stdout_stderr_data(Ssh ssh, struct Packet *pktin)
4298{
4299 char *string;
4300 int stringlen, bufsize;
4301
4302 ssh_pkt_getstring(pktin, &string, &stringlen);
4303 if (string == NULL) {
4304 bombout(("Incoming terminal data packet was badly formed"));
4305 return;
4306 }
4307
4308 bufsize = from_backend(ssh->frontend, pktin->type == SSH1_SMSG_STDERR_DATA,
4309 string, stringlen);
4310 if (!ssh->v1_stdout_throttling && bufsize > SSH1_BUFFER_LIMIT) {
4311 ssh->v1_stdout_throttling = 1;
4312 ssh1_throttle(ssh, +1);
4313 }
4314}
4315
4316static void ssh1_smsg_x11_open(Ssh ssh, struct Packet *pktin)
4317{
4318 /* Remote side is trying to open a channel to talk to our
4319 * X-Server. Give them back a local channel number. */
4320 struct ssh_channel *c;
4321 int remoteid = ssh_pkt_getuint32(pktin);
4322
4323 logevent("Received X11 connect request");
4324 /* Refuse if X11 forwarding is disabled. */
4325 if (!ssh->X11_fwd_enabled) {
4326 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4327 PKT_INT, remoteid, PKT_END);
4328 logevent("Rejected X11 connect request");
4329 } else {
4330 c = snew(struct ssh_channel);
4331 c->ssh = ssh;
4332
4333 if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
4334 ssh->x11auth, NULL, -1, &ssh->cfg) != NULL) {
4335 logevent("Opening X11 forward connection failed");
4336 sfree(c);
4337 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4338 PKT_INT, remoteid, PKT_END);
4339 } else {
4340 logevent
4341 ("Opening X11 forward connection succeeded");
4342 c->remoteid = remoteid;
64d6ff88 4343 c->halfopen = FALSE;
51df0ab5 4344 c->localid = alloc_channel_id(ssh);
4345 c->closes = 0;
4346 c->v.v1.throttling = 0;
4347 c->type = CHAN_X11; /* identify channel type */
4348 add234(ssh->channels, c);
4349 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4350 PKT_INT, c->remoteid, PKT_INT,
4351 c->localid, PKT_END);
4352 logevent("Opened X11 forward channel");
4353 }
4354 }
4355}
4356
4357static void ssh1_smsg_agent_open(Ssh ssh, struct Packet *pktin)
4358{
4359 /* Remote side is trying to open a channel to talk to our
4360 * agent. Give them back a local channel number. */
4361 struct ssh_channel *c;
4362 int remoteid = ssh_pkt_getuint32(pktin);
4363
4364 /* Refuse if agent forwarding is disabled. */
4365 if (!ssh->agentfwd_enabled) {
4366 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4367 PKT_INT, remoteid, PKT_END);
4368 } else {
4369 c = snew(struct ssh_channel);
4370 c->ssh = ssh;
4371 c->remoteid = remoteid;
64d6ff88 4372 c->halfopen = FALSE;
51df0ab5 4373 c->localid = alloc_channel_id(ssh);
4374 c->closes = 0;
4375 c->v.v1.throttling = 0;
4376 c->type = CHAN_AGENT; /* identify channel type */
4377 c->u.a.lensofar = 0;
4378 add234(ssh->channels, c);
4379 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4380 PKT_INT, c->remoteid, PKT_INT, c->localid,
4381 PKT_END);
4382 }
4383}
4384
4385static void ssh1_msg_port_open(Ssh ssh, struct Packet *pktin)
4386{
4387 /* Remote side is trying to open a channel to talk to a
4388 * forwarded port. Give them back a local channel number. */
4389 struct ssh_channel *c;
05581745 4390 struct ssh_rportfwd pf, *pfp;
51df0ab5 4391 int remoteid;
4392 int hostsize, port;
fb983202 4393 char *host;
51df0ab5 4394 const char *e;
4395 c = snew(struct ssh_channel);
4396 c->ssh = ssh;
4397
4398 remoteid = ssh_pkt_getuint32(pktin);
4399 ssh_pkt_getstring(pktin, &host, &hostsize);
4400 port = ssh_pkt_getuint32(pktin);
4401
4402 if (hostsize >= lenof(pf.dhost))
4403 hostsize = lenof(pf.dhost)-1;
4404 memcpy(pf.dhost, host, hostsize);
4405 pf.dhost[hostsize] = '\0';
4406 pf.dport = port;
05581745 4407 pfp = find234(ssh->rportfwds, &pf, NULL);
51df0ab5 4408
05581745 4409 if (pfp == NULL) {
fb983202 4410 logeventf(ssh, "Rejected remote port open request for %s:%d",
4411 pf.dhost, port);
51df0ab5 4412 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4413 PKT_INT, remoteid, PKT_END);
4414 } else {
fb983202 4415 logeventf(ssh, "Received remote port open request for %s:%d",
4416 pf.dhost, port);
51df0ab5 4417 e = pfd_newconnect(&c->u.pfd.s, pf.dhost, port,
05581745 4418 c, &ssh->cfg, pfp->pfrec->addressfamily);
51df0ab5 4419 if (e != NULL) {
fb983202 4420 logeventf(ssh, "Port open failed: %s", e);
51df0ab5 4421 sfree(c);
4422 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_FAILURE,
4423 PKT_INT, remoteid, PKT_END);
4424 } else {
4425 c->remoteid = remoteid;
64d6ff88 4426 c->halfopen = FALSE;
51df0ab5 4427 c->localid = alloc_channel_id(ssh);
4428 c->closes = 0;
4429 c->v.v1.throttling = 0;
4430 c->type = CHAN_SOCKDATA; /* identify channel type */
4431 add234(ssh->channels, c);
4432 send_packet(ssh, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION,
4433 PKT_INT, c->remoteid, PKT_INT,
4434 c->localid, PKT_END);
4435 logevent("Forwarded port opened successfully");
4436 }
4437 }
4438}
4439
4440static void ssh1_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
4441{
4442 unsigned int remoteid = ssh_pkt_getuint32(pktin);
4443 unsigned int localid = ssh_pkt_getuint32(pktin);
4444 struct ssh_channel *c;
4445
4446 c = find234(ssh->channels, &remoteid, ssh_channelfind);
4447 if (c && c->type == CHAN_SOCKDATA_DORMANT) {
4448 c->remoteid = localid;
64d6ff88 4449 c->halfopen = FALSE;
51df0ab5 4450 c->type = CHAN_SOCKDATA;
4451 c->v.v1.throttling = 0;
4452 pfd_confirm(c->u.pfd.s);
4453 }
4454
4455 if (c && c->closes) {
4456 /*
4457 * We have a pending close on this channel,
4458 * which we decided on before the server acked
4459 * the channel open. So now we know the
4460 * remoteid, we can close it again.
4461 */
4462 send_packet(ssh, SSH1_MSG_CHANNEL_CLOSE,
4463 PKT_INT, c->remoteid, PKT_END);
4464 }
4465}
4466
4467static void ssh1_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
4468{
4469 unsigned int remoteid = ssh_pkt_getuint32(pktin);
4470 struct ssh_channel *c;
4471
4472 c = find234(ssh->channels, &remoteid, ssh_channelfind);
4473 if (c && c->type == CHAN_SOCKDATA_DORMANT) {
4474 logevent("Forwarded connection refused by server");
4475 pfd_close(c->u.pfd.s);
4476 del234(ssh->channels, c);
4477 sfree(c);
4478 }
4479}
4480
4481static void ssh1_msg_channel_close(Ssh ssh, struct Packet *pktin)
4482{
4483 /* Remote side closes a channel. */
4484 unsigned i = ssh_pkt_getuint32(pktin);
4485 struct ssh_channel *c;
4486 c = find234(ssh->channels, &i, ssh_channelfind);
64d6ff88 4487 if (c && !c->halfopen) {
51df0ab5 4488 int closetype;
4489 closetype =
4490 (pktin->type == SSH1_MSG_CHANNEL_CLOSE ? 1 : 2);
4491
4492 if ((c->closes == 0) && (c->type == CHAN_X11)) {
4493 logevent("Forwarded X11 connection terminated");
4494 assert(c->u.x11.s != NULL);
4495 x11_close(c->u.x11.s);
4496 c->u.x11.s = NULL;
4497 }
4498 if ((c->closes == 0) && (c->type == CHAN_SOCKDATA)) {
4499 logevent("Forwarded port closed");
4500 assert(c->u.pfd.s != NULL);
4501 pfd_close(c->u.pfd.s);
4502 c->u.pfd.s = NULL;
4503 }
4504
4505 c->closes |= (closetype << 2); /* seen this message */
4506 if (!(c->closes & closetype)) {
4507 send_packet(ssh, pktin->type, PKT_INT, c->remoteid,
4508 PKT_END);
4509 c->closes |= closetype; /* sent it too */
4510 }
4511
4512 if (c->closes == 15) {
4513 del234(ssh->channels, c);
4514 sfree(c);
4515 }
4516 } else {
4517 bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
4518 pktin->type == SSH1_MSG_CHANNEL_CLOSE ? "" :
4519 "_CONFIRMATION", c ? "half-open" : "nonexistent",
4520 i));
4521 }
4522}
4523
4524static void ssh1_msg_channel_data(Ssh ssh, struct Packet *pktin)
4525{
4526 /* Data sent down one of our channels. */
4527 int i = ssh_pkt_getuint32(pktin);
4528 char *p;
6d44acc9 4529 int len;
51df0ab5 4530 struct ssh_channel *c;
4531
4532 ssh_pkt_getstring(pktin, &p, &len);
4533
4534 c = find234(ssh->channels, &i, ssh_channelfind);
4535 if (c) {
4536 int bufsize = 0;
4537 switch (c->type) {
4538 case CHAN_X11:
4539 bufsize = x11_send(c->u.x11.s, p, len);
4540 break;
4541 case CHAN_SOCKDATA:
4542 bufsize = pfd_send(c->u.pfd.s, p, len);
4543 break;
4544 case CHAN_AGENT:
4545 /* Data for an agent message. Buffer it. */
4546 while (len > 0) {
4547 if (c->u.a.lensofar < 4) {
aa63ab7e 4548 unsigned int l = min(4 - c->u.a.lensofar, len);
51df0ab5 4549 memcpy(c->u.a.msglen + c->u.a.lensofar, p,
4550 l);
4551 p += l;
4552 len -= l;
4553 c->u.a.lensofar += l;
4554 }
4555 if (c->u.a.lensofar == 4) {
4556 c->u.a.totallen =
4557 4 + GET_32BIT(c->u.a.msglen);
4558 c->u.a.message = snewn(c->u.a.totallen,
4559 unsigned char);
4560 memcpy(c->u.a.message, c->u.a.msglen, 4);
4561 }
4562 if (c->u.a.lensofar >= 4 && len > 0) {
aa63ab7e 4563 unsigned int l =
51df0ab5 4564 min(c->u.a.totallen - c->u.a.lensofar,
4565 len);
4566 memcpy(c->u.a.message + c->u.a.lensofar, p,
4567 l);
4568 p += l;
4569 len -= l;
4570 c->u.a.lensofar += l;
4571 }
4572 if (c->u.a.lensofar == c->u.a.totallen) {
4573 void *reply;
4574 int replylen;
4575 if (agent_query(c->u.a.message,
4576 c->u.a.totallen,
4577 &reply, &replylen,
4578 ssh_agentf_callback, c))
4579 ssh_agentf_callback(c, reply, replylen);
4580 sfree(c->u.a.message);
4581 c->u.a.lensofar = 0;
4582 }
4583 }
4584 bufsize = 0; /* agent channels never back up */
4585 break;
4586 }
4587 if (!c->v.v1.throttling && bufsize > SSH1_BUFFER_LIMIT) {
4588 c->v.v1.throttling = 1;
4589 ssh1_throttle(ssh, +1);
4590 }
4591 }
4592}
4593
4594static void ssh1_smsg_exit_status(Ssh ssh, struct Packet *pktin)
4595{
51df0ab5 4596 ssh->exitcode = ssh_pkt_getuint32(pktin);
fb983202 4597 logeventf(ssh, "Server sent command exit status %d", ssh->exitcode);
51df0ab5 4598 send_packet(ssh, SSH1_CMSG_EXIT_CONFIRMATION, PKT_END);
4599 /*
4600 * In case `helpful' firewalls or proxies tack
4601 * extra human-readable text on the end of the
4602 * session which we might mistake for another
4603 * encrypted packet, we close the session once
4604 * we've sent EXIT_CONFIRMATION.
4605 */
9e296bfa 4606 ssh_disconnect(ssh, NULL, NULL, 0, TRUE);
51df0ab5 4607}
4608
c6ccd5c2 4609/* Helper function to deal with sending tty modes for REQUEST_PTY */
4610static void ssh1_send_ttymode(void *data, char *mode, char *val)
4611{
4612 struct Packet *pktout = (struct Packet *)data;
4613 int i = 0;
4614 unsigned int arg = 0;
4615 while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
4616 if (i == lenof(ssh_ttymodes)) return;
4617 switch (ssh_ttymodes[i].type) {
4618 case TTY_OP_CHAR:
4619 arg = ssh_tty_parse_specchar(val);
4620 break;
4621 case TTY_OP_BOOL:
4622 arg = ssh_tty_parse_boolean(val);
4623 break;
4624 }
4625 ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
4626 ssh2_pkt_addbyte(pktout, arg);
4627}
4628
4629
b09eaa88 4630static void do_ssh1_connection(Ssh ssh, unsigned char *in, int inlen,
4631 struct Packet *pktin)
32874aea 4632{
b09eaa88 4633 crBegin(ssh->do_ssh1_connection_crstate);
fb09bf1c 4634
51df0ab5 4635 ssh->packet_dispatch[SSH1_SMSG_STDOUT_DATA] =
4636 ssh->packet_dispatch[SSH1_SMSG_STDERR_DATA] =
4637 ssh1_smsg_stdout_stderr_data;
4638
4639 ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_CONFIRMATION] =
4640 ssh1_msg_channel_open_confirmation;
4641 ssh->packet_dispatch[SSH1_MSG_CHANNEL_OPEN_FAILURE] =
4642 ssh1_msg_channel_open_failure;
4643 ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE] =
4644 ssh->packet_dispatch[SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION] =
4645 ssh1_msg_channel_close;
4646 ssh->packet_dispatch[SSH1_MSG_CHANNEL_DATA] = ssh1_msg_channel_data;
4647 ssh->packet_dispatch[SSH1_SMSG_EXIT_STATUS] = ssh1_smsg_exit_status;
4648
86916870 4649 if (ssh->cfg.agentfwd && agent_exists()) {
32874aea 4650 logevent("Requesting agent forwarding");
51470298 4651 send_packet(ssh, SSH1_CMSG_AGENT_REQUEST_FORWARDING, PKT_END);
32874aea 4652 do {
4653 crReturnV;
ff3187f6 4654 } while (!pktin);
4655 if (pktin->type != SSH1_SMSG_SUCCESS
4656 && pktin->type != SSH1_SMSG_FAILURE) {
6b5cf8b4 4657 bombout(("Protocol confusion"));
7ffdbc1a 4658 crStopV;
ff3187f6 4659 } else if (pktin->type == SSH1_SMSG_FAILURE) {
32874aea 4660 logevent("Agent forwarding refused");
4661 } else {
4662 logevent("Agent forwarding enabled");
51470298 4663 ssh->agentfwd_enabled = TRUE;
51df0ab5 4664 ssh->packet_dispatch[SSH1_SMSG_AGENT_OPEN] = ssh1_smsg_agent_open;
db7d555c 4665 }
dacbd0e8 4666 }
4667
86916870 4668 if (ssh->cfg.x11_forward) {
32874aea 4669 char proto[20], data[64];
4670 logevent("Requesting X11 forwarding");
302121de 4671 ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
86916870 4672 data, sizeof(data), ssh->cfg.x11_auth);
4673 x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
f68353be 4674 /*
4675 * Note that while we blank the X authentication data here, we don't
4676 * take any special action to blank the start of an X11 channel,
4677 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
4678 * without having session blanking enabled is likely to leak your
4679 * cookie into the log.
4680 */
51470298 4681 if (ssh->v1_local_protoflags & SSH1_PROTOFLAG_SCREEN_NUMBER) {
4682 send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
f68353be 4683 PKT_STR, proto,
4684 PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER,
86916870 4685 PKT_INT, x11_get_screen_number(ssh->cfg.x11_display),
421d6835 4686 PKT_END);
32874aea 4687 } else {
51470298 4688 send_packet(ssh, SSH1_CMSG_X11_REQUEST_FORWARDING,
f68353be 4689 PKT_STR, proto,
4690 PKTT_PASSWORD, PKT_STR, data, PKTT_OTHER, PKT_END);
32874aea 4691 }
4692 do {
4693 crReturnV;
ff3187f6 4694 } while (!pktin);
4695 if (pktin->type != SSH1_SMSG_SUCCESS
4696 && pktin->type != SSH1_SMSG_FAILURE) {
6b5cf8b4 4697 bombout(("Protocol confusion"));
7ffdbc1a 4698 crStopV;
ff3187f6 4699 } else if (pktin->type == SSH1_SMSG_FAILURE) {
32874aea 4700 logevent("X11 forwarding refused");
4701 } else {
4702 logevent("X11 forwarding enabled");
51470298 4703 ssh->X11_fwd_enabled = TRUE;
51df0ab5 4704 ssh->packet_dispatch[SSH1_SMSG_X11_OPEN] = ssh1_smsg_x11_open;
9c964e85 4705 }
4706 }
4707
06fadff5 4708 ssh_setup_portfwd(ssh, &ssh->cfg);
4709 ssh->packet_dispatch[SSH1_MSG_PORT_OPEN] = ssh1_msg_port_open;
d74d141c 4710
86916870 4711 if (!ssh->cfg.nopty) {
c6ccd5c2 4712 struct Packet *pkt;
a5dd8467 4713 /* Unpick the terminal-speed string. */
4714 /* XXX perhaps we should allow no speeds to be sent. */
db219738 4715 ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
4716 sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
a5dd8467 4717 /* Send the pty request. */
c6ccd5c2 4718 pkt = ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY);
4719 ssh_pkt_addstring(pkt, ssh->cfg.termtype);
4720 ssh_pkt_adduint32(pkt, ssh->term_height);
4721 ssh_pkt_adduint32(pkt, ssh->term_width);
4722 ssh_pkt_adduint32(pkt, 0); /* width in pixels */
4723 ssh_pkt_adduint32(pkt, 0); /* height in pixels */
4724 parse_ttymodes(ssh, ssh->cfg.ttymodes,
4725 ssh1_send_ttymode, (void *)pkt);
4726 ssh_pkt_addbyte(pkt, SSH1_TTY_OP_ISPEED);
4727 ssh_pkt_adduint32(pkt, ssh->ispeed);
4728 ssh_pkt_addbyte(pkt, SSH1_TTY_OP_OSPEED);
4729 ssh_pkt_adduint32(pkt, ssh->ospeed);
4730 ssh_pkt_addbyte(pkt, SSH_TTY_OP_END);
4731 s_wrpkt(ssh, pkt);
51470298 4732 ssh->state = SSH_STATE_INTERMED;
32874aea 4733 do {
4734 crReturnV;
ff3187f6 4735 } while (!pktin);
4736 if (pktin->type != SSH1_SMSG_SUCCESS
4737 && pktin->type != SSH1_SMSG_FAILURE) {
6b5cf8b4 4738 bombout(("Protocol confusion"));
7ffdbc1a 4739 crStopV;
ff3187f6 4740 } else if (pktin->type == SSH1_SMSG_FAILURE) {
51470298 4741 c_write_str(ssh, "Server refused to allocate pty\r\n");
4742 ssh->editing = ssh->echoing = 1;
32874aea 4743 }
a5dd8467 4744 logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
db219738 4745 ssh->ospeed, ssh->ispeed);
0965bee0 4746 } else {
51470298 4747 ssh->editing = ssh->echoing = 1;
374330e2 4748 }
4749
86916870 4750 if (ssh->cfg.compression) {
51470298 4751 send_packet(ssh, SSH1_CMSG_REQUEST_COMPRESSION, PKT_INT, 6, PKT_END);
32874aea 4752 do {
4753 crReturnV;
ff3187f6 4754 } while (!pktin);
4755 if (pktin->type != SSH1_SMSG_SUCCESS
4756 && pktin->type != SSH1_SMSG_FAILURE) {
6b5cf8b4 4757 bombout(("Protocol confusion"));
7ffdbc1a 4758 crStopV;
ff3187f6 4759 } else if (pktin->type == SSH1_SMSG_FAILURE) {
51470298 4760 c_write_str(ssh, "Server refused to compress\r\n");
32874aea 4761 }
4ba9b64b 4762 logevent("Started compression");
51470298 4763 ssh->v1_compressing = TRUE;
5366aed8 4764 ssh->cs_comp_ctx = zlib_compress_init();
4765 logevent("Initialised zlib (RFC1950) compression");
4766 ssh->sc_comp_ctx = zlib_decompress_init();
4767 logevent("Initialised zlib (RFC1950) decompression");
4ba9b64b 4768 }
4769
fd5e5847 4770 /*
4771 * Start the shell or command.
4772 *
2e85c969 4773 * Special case: if the first-choice command is an SSH-2
fd5e5847 4774 * subsystem (hence not usable here) and the second choice
4775 * exists, we fall straight back to that.
4776 */
4777 {
86916870 4778 char *cmd = ssh->cfg.remote_cmd_ptr;
04c52f10 4779
4780 if (!cmd) cmd = ssh->cfg.remote_cmd;
fd5e5847 4781
86916870 4782 if (ssh->cfg.ssh_subsys && ssh->cfg.remote_cmd_ptr2) {
4783 cmd = ssh->cfg.remote_cmd_ptr2;
51470298 4784 ssh->fallback_cmd = TRUE;
fd5e5847 4785 }
4786 if (*cmd)
51470298 4787 send_packet(ssh, SSH1_CMSG_EXEC_CMD, PKT_STR, cmd, PKT_END);
fd5e5847 4788 else
51470298 4789 send_packet(ssh, SSH1_CMSG_EXEC_SHELL, PKT_END);
fd5e5847 4790 logevent("Started session");
4791 }
374330e2 4792
51470298 4793 ssh->state = SSH_STATE_SESSION;
4794 if (ssh->size_needed)
4795 ssh_size(ssh, ssh->term_width, ssh->term_height);
4796 if (ssh->eof_needed)
4797 ssh_special(ssh, TS_EOF);
374330e2 4798
b9d7bcad 4799 if (ssh->ldisc)
4800 ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
51470298 4801 ssh->send_ok = 1;
4802 ssh->channels = newtree234(ssh_channelcmp);
374330e2 4803 while (1) {
d74d141c 4804
51df0ab5 4805 /*
4806 * By this point, most incoming packets are already being
4807 * handled by the dispatch table, and we need only pay
4808 * attention to the unusual ones.
4809 */
0357890f 4810
51df0ab5 4811 crReturnV;
4812 if (pktin) {
4813 if (pktin->type == SSH1_SMSG_SUCCESS) {
972a41c8 4814 /* may be from EXEC_SHELL on some servers */
ff3187f6 4815 } else if (pktin->type == SSH1_SMSG_FAILURE) {
972a41c8 4816 /* may be from EXEC_SHELL on some servers
374330e2 4817 * if no pty is available or in other odd cases. Ignore */
374330e2 4818 } else {
ff3187f6 4819 bombout(("Strange packet received: type %d", pktin->type));
7ffdbc1a 4820 crStopV;
374330e2 4821 }
4822 } else {
8df7a775 4823 while (inlen > 0) {
4824 int len = min(inlen, 512);
9a10ecf4 4825 send_packet(ssh, SSH1_CMSG_STDIN_DATA, PKTT_DATA,
4826 PKT_INT, len, PKT_DATA, in, len,
4827 PKTT_OTHER, PKT_END);
8df7a775 4828 in += len;
4829 inlen -= len;
4830 }
374330e2 4831 }
4832 }
4833
4834 crFinishV;
4835}
4836
4837/*
2e85c969 4838 * Handle the top-level SSH-2 protocol.
b09eaa88 4839 */
4840static void ssh1_msg_debug(Ssh ssh, struct Packet *pktin)
4841{
fb983202 4842 char *msg;
b09eaa88 4843 int msglen;
4844
4845 ssh_pkt_getstring(pktin, &msg, &msglen);
fb983202 4846 logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
b09eaa88 4847}
4848
4849static void ssh1_msg_disconnect(Ssh ssh, struct Packet *pktin)
4850{
4851 /* log reason code in disconnect message */
4852 char *msg;
4853 int msglen;
4854
4855 ssh_pkt_getstring(pktin, &msg, &msglen);
4856 bombout(("Server sent disconnect message:\n\"%.*s\"", msglen, msg));
4857}
4858
409bfa77 4859static void ssh_msg_ignore(Ssh ssh, struct Packet *pktin)
b09eaa88 4860{
4861 /* Do nothing, because we're ignoring it! Duhh. */
4862}
4863
4864static void ssh1_protocol_setup(Ssh ssh)
4865{
4866 int i;
4867
4868 /*
4869 * Most messages are handled by the coroutines.
4870 */
4871 for (i = 0; i < 256; i++)
4872 ssh->packet_dispatch[i] = NULL;
4873
4874 /*
4875 * These special message types we install handlers for.
4876 */
4877 ssh->packet_dispatch[SSH1_MSG_DISCONNECT] = ssh1_msg_disconnect;
4878 ssh->packet_dispatch[SSH1_MSG_IGNORE] = ssh_msg_ignore;
4879 ssh->packet_dispatch[SSH1_MSG_DEBUG] = ssh1_msg_debug;
4880}
4881
1c1a7262 4882static void ssh1_protocol(Ssh ssh, void *vin, int inlen,
b09eaa88 4883 struct Packet *pktin)
4884{
1c1a7262 4885 unsigned char *in=(unsigned char*)vin;
b09eaa88 4886 if (ssh->state == SSH_STATE_CLOSED)
4887 return;
4888
4889 if (pktin && ssh->packet_dispatch[pktin->type]) {
4890 ssh->packet_dispatch[pktin->type](ssh, pktin);
4891 return;
4892 }
4893
4894 if (!ssh->protocol_initial_phase_done) {
4895 if (do_ssh1_login(ssh, in, inlen, pktin))
4896 ssh->protocol_initial_phase_done = TRUE;
4897 else
4898 return;
4899 }
4900
4901 do_ssh1_connection(ssh, in, inlen, pktin);
4902}
4903
4904/*
e5574168 4905 * Utility routine for decoding comma-separated strings in KEXINIT.
4906 */
32874aea 4907static int in_commasep_string(char *needle, char *haystack, int haylen)
4908{
57356d63 4909 int needlen;
4910 if (!needle || !haystack) /* protect against null pointers */
4911 return 0;
4912 needlen = strlen(needle);
e5574168 4913 while (1) {
32874aea 4914 /*
4915 * Is it at the start of the string?
4916 */
4917 if (haylen >= needlen && /* haystack is long enough */
4918 !memcmp(needle, haystack, needlen) && /* initial match */
4919 (haylen == needlen || haystack[needlen] == ',')
4920 /* either , or EOS follows */
4921 )
4922 return 1;
4923 /*
4924 * If not, search for the next comma and resume after that.
4925 * If no comma found, terminate.
4926 */
4927 while (haylen > 0 && *haystack != ',')
4928 haylen--, haystack++;
4929 if (haylen == 0)
4930 return 0;
4931 haylen--, haystack++; /* skip over comma itself */
e5574168 4932 }
4933}
4934
4935/*
b59743d5 4936 * Similar routine for checking whether we have the first string in a list.
4937 */
4938static int first_in_commasep_string(char *needle, char *haystack, int haylen)
4939{
4940 int needlen;
4941 if (!needle || !haystack) /* protect against null pointers */
4942 return 0;
4943 needlen = strlen(needle);
4944 /*
4945 * Is it at the start of the string?
4946 */
4947 if (haylen >= needlen && /* haystack is long enough */
4948 !memcmp(needle, haystack, needlen) && /* initial match */
4949 (haylen == needlen || haystack[needlen] == ',')
4950 /* either , or EOS follows */
4951 )
4952 return 1;
4953 return 0;
4954}
4955
4956
4957/*
2e85c969 4958 * SSH-2 key creation method.
d39f364a 4959 */
b672f405 4960static void ssh2_mkkey(Ssh ssh, Bignum K, unsigned char *H, char chr,
d8baa528 4961 unsigned char *keyspace)
32874aea 4962{
b672f405 4963 const struct ssh_hash *h = ssh->kex->hash;
4964 void *s;
4965 /* First hlen bytes. */
4966 s = h->init();
51470298 4967 if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
b672f405 4968 hash_mpint(h, s, K);
4969 h->bytes(s, H, h->hlen);
4970 h->bytes(s, &chr, 1);
4971 h->bytes(s, ssh->v2_session_id, ssh->v2_session_id_len);
4972 h->final(s, keyspace);
4973 /* Next hlen bytes. */
4974 s = h->init();
51470298 4975 if (!(ssh->remote_bugs & BUG_SSH2_DERIVEKEY))
b672f405 4976 hash_mpint(h, s, K);
4977 h->bytes(s, H, h->hlen);
4978 h->bytes(s, keyspace, h->hlen);
4979 h->final(s, keyspace + h->hlen);
d39f364a 4980}
4981
4982/*
2e85c969 4983 * Handle the SSH-2 transport layer.
e5574168 4984 */
1c1a7262 4985static int do_ssh2_transport(Ssh ssh, void *vin, int inlen,
ff3187f6 4986 struct Packet *pktin)
e5574168 4987{
1c1a7262 4988 unsigned char *in = (unsigned char *)vin;
51470298 4989 struct do_ssh2_transport_state {
4763c1c2 4990 int nbits, pbits, warn_kex, warn_cscipher, warn_sccipher;
51470298 4991 Bignum p, g, e, f, K;
3dc9a6a7 4992 void *our_kexinit;
4993 int our_kexinitlen;
51470298 4994 int kex_init_value, kex_reply_value;
4995 const struct ssh_mac **maclist;
4996 int nmacs;
4997 const struct ssh2_cipher *cscipher_tobe;
4998 const struct ssh2_cipher *sccipher_tobe;
4999 const struct ssh_mac *csmac_tobe;
5000 const struct ssh_mac *scmac_tobe;
5001 const struct ssh_compress *cscomp_tobe;
5002 const struct ssh_compress *sccomp_tobe;
5003 char *hostkeydata, *sigdata, *keystr, *fingerprint;
5004 int hostkeylen, siglen;
5005 void *hkey; /* actual host key */
2ccb2fc8 5006 unsigned char exchange_hash[32];
83e7d008 5007 int n_preferred_kex;
34557659 5008 const struct ssh_kexes *preferred_kex[KEX_MAX];
51470298 5009 int n_preferred_ciphers;
5010 const struct ssh2_ciphers *preferred_ciphers[CIPHER_MAX];
5011 const struct ssh_compress *preferred_comp;
e13bba36 5012 int got_session_id, activated_authconn;
ff3187f6 5013 struct Packet *pktout;
3d9449a1 5014 int dlgret;
5015 int guessok;
4763c1c2 5016 int ignorepkt;
51470298 5017 };
5018 crState(do_ssh2_transport_state);
5019
5020 crBegin(ssh->do_ssh2_transport_crstate);
5021
5022 s->cscipher_tobe = s->sccipher_tobe = NULL;
5023 s->csmac_tobe = s->scmac_tobe = NULL;
5024 s->cscomp_tobe = s->sccomp_tobe = NULL;
5025
e13bba36 5026 s->got_session_id = s->activated_authconn = FALSE;
e5574168 5027
e13bba36 5028 /*
5029 * Be prepared to work around the buggy MAC problem.
5030 */
5031 if (ssh->remote_bugs & BUG_SSH2_HMAC)
5032 s->maclist = buggymacs, s->nmacs = lenof(buggymacs);
5033 else
5034 s->maclist = macs, s->nmacs = lenof(macs);
5035
5036 begin_key_exchange:
149d2abc 5037 ssh->pkt_ctx &= ~SSH2_PKTCTX_KEX_MASK;
51470298 5038 {
e13bba36 5039 int i, j, commalist_started;
5040
51470298 5041 /*
83e7d008 5042 * Set up the preferred key exchange. (NULL => warn below here)
5043 */
5044 s->n_preferred_kex = 0;
5045 for (i = 0; i < KEX_MAX; i++) {
5046 switch (ssh->cfg.ssh_kexlist[i]) {
5047 case KEX_DHGEX:
5048 s->preferred_kex[s->n_preferred_kex++] =
5049 &ssh_diffiehellman_gex;
5050 break;
5051 case KEX_DHGROUP14:
5052 s->preferred_kex[s->n_preferred_kex++] =
5053 &ssh_diffiehellman_group14;
5054 break;
5055 case KEX_DHGROUP1:
5056 s->preferred_kex[s->n_preferred_kex++] =
5057 &ssh_diffiehellman_group1;
5058 break;
5059 case CIPHER_WARN:
5060 /* Flag for later. Don't bother if it's the last in
5061 * the list. */
5062 if (i < KEX_MAX - 1) {
5063 s->preferred_kex[s->n_preferred_kex++] = NULL;
5064 }
5065 break;
5066 }
5067 }
83e7d008 5068
83e7d008 5069 /*
51470298 5070 * Set up the preferred ciphers. (NULL => warn below here)
5071 */
5072 s->n_preferred_ciphers = 0;
5073 for (i = 0; i < CIPHER_MAX; i++) {
86916870 5074 switch (ssh->cfg.ssh_cipherlist[i]) {
51470298 5075 case CIPHER_BLOWFISH:
5076 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_blowfish;
5077 break;
5078 case CIPHER_DES:
86916870 5079 if (ssh->cfg.ssh2_des_cbc) {
51470298 5080 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_des;
5081 }
5082 break;
5083 case CIPHER_3DES:
5084 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_3des;
5085 break;
5086 case CIPHER_AES:
5087 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_aes;
5088 break;
a2add208 5089 case CIPHER_ARCFOUR:
5090 s->preferred_ciphers[s->n_preferred_ciphers++] = &ssh2_arcfour;
5091 break;
51470298 5092 case CIPHER_WARN:
5093 /* Flag for later. Don't bother if it's the last in
5094 * the list. */
5095 if (i < CIPHER_MAX - 1) {
5096 s->preferred_ciphers[s->n_preferred_ciphers++] = NULL;
5097 }
5098 break;
ca20bfcf 5099 }
ca20bfcf 5100 }
7591b9ff 5101
e13bba36 5102 /*
5103 * Set up preferred compression.
5104 */
5105 if (ssh->cfg.compression)
5106 s->preferred_comp = &ssh_zlib;
5107 else
5108 s->preferred_comp = &ssh_comp_none;
51470298 5109
5110 /*
590f6a5f 5111 * Enable queueing of outgoing auth- or connection-layer
5112 * packets while we are in the middle of a key exchange.
5113 */
5114 ssh->queueing = TRUE;
5115
5116 /*
9442dd57 5117 * Flag that KEX is in progress.
5118 */
5119 ssh->kex_in_progress = TRUE;
5120
5121 /*
51470298 5122 * Construct and send our key exchange packet.
5123 */
ff3187f6 5124 s->pktout = ssh2_pkt_init(SSH2_MSG_KEXINIT);
51470298 5125 for (i = 0; i < 16; i++)
ff3187f6 5126 ssh2_pkt_addbyte(s->pktout, (unsigned char) random_byte());
51470298 5127 /* List key exchange algorithms. */
ff3187f6 5128 ssh2_pkt_addstring_start(s->pktout);
83e7d008 5129 commalist_started = 0;
5130 for (i = 0; i < s->n_preferred_kex; i++) {
34557659 5131 const struct ssh_kexes *k = s->preferred_kex[i];
83e7d008 5132 if (!k) continue; /* warning flag */
34557659 5133 for (j = 0; j < k->nkexes; j++) {
5134 if (commalist_started)
5135 ssh2_pkt_addstring_str(s->pktout, ",");
5136 ssh2_pkt_addstring_str(s->pktout, k->list[j]->name);
5137 commalist_started = 1;
5138 }
32874aea 5139 }
51470298 5140 /* List server host key algorithms. */
ff3187f6 5141 ssh2_pkt_addstring_start(s->pktout);
51470298 5142 for (i = 0; i < lenof(hostkey_algs); i++) {
ff3187f6 5143 ssh2_pkt_addstring_str(s->pktout, hostkey_algs[i]->name);
51470298 5144 if (i < lenof(hostkey_algs) - 1)
ff3187f6 5145 ssh2_pkt_addstring_str(s->pktout, ",");
32874aea 5146 }
51470298 5147 /* List client->server encryption algorithms. */
ff3187f6 5148 ssh2_pkt_addstring_start(s->pktout);
83e7d008 5149 commalist_started = 0;
51470298 5150 for (i = 0; i < s->n_preferred_ciphers; i++) {
5151 const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5152 if (!c) continue; /* warning flag */
5153 for (j = 0; j < c->nciphers; j++) {
83e7d008 5154 if (commalist_started)
ff3187f6 5155 ssh2_pkt_addstring_str(s->pktout, ",");
5156 ssh2_pkt_addstring_str(s->pktout, c->list[j]->name);
83e7d008 5157 commalist_started = 1;
51470298 5158 }
5159 }
5160 /* List server->client encryption algorithms. */
ff3187f6 5161 ssh2_pkt_addstring_start(s->pktout);
83e7d008 5162 commalist_started = 0;
51470298 5163 for (i = 0; i < s->n_preferred_ciphers; i++) {
5164 const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5165 if (!c) continue; /* warning flag */
5166 for (j = 0; j < c->nciphers; j++) {
83e7d008 5167 if (commalist_started)
ff3187f6 5168 ssh2_pkt_addstring_str(s->pktout, ",");
5169 ssh2_pkt_addstring_str(s->pktout, c->list[j]->name);
83e7d008 5170 commalist_started = 1;
51470298 5171 }
5172 }
5173 /* List client->server MAC algorithms. */
ff3187f6 5174 ssh2_pkt_addstring_start(s->pktout);
51470298 5175 for (i = 0; i < s->nmacs; i++) {
ff3187f6 5176 ssh2_pkt_addstring_str(s->pktout, s->maclist[i]->name);
51470298 5177 if (i < s->nmacs - 1)
ff3187f6 5178 ssh2_pkt_addstring_str(s->pktout, ",");
51470298 5179 }
5180 /* List server->client MAC algorithms. */
ff3187f6 5181 ssh2_pkt_addstring_start(s->pktout);
51470298 5182 for (i = 0; i < s->nmacs; i++) {
ff3187f6 5183 ssh2_pkt_addstring_str(s->pktout, s->maclist[i]->name);
51470298 5184 if (i < s->nmacs - 1)
ff3187f6 5185 ssh2_pkt_addstring_str(s->pktout, ",");
51470298 5186 }
5187 /* List client->server compression algorithms. */
ff3187f6 5188 ssh2_pkt_addstring_start(s->pktout);
f6e0abe2 5189 assert(lenof(compressions) > 1);
ff3187f6 5190 ssh2_pkt_addstring_str(s->pktout, s->preferred_comp->name);
f6e0abe2 5191 for (i = 0; i < lenof(compressions); i++) {
5192 const struct ssh_compress *c = compressions[i];
5193 if (c != s->preferred_comp) {
ff3187f6 5194 ssh2_pkt_addstring_str(s->pktout, ",");
5195 ssh2_pkt_addstring_str(s->pktout, c->name);
f6e0abe2 5196 }
51470298 5197 }
5198 /* List server->client compression algorithms. */
ff3187f6 5199 ssh2_pkt_addstring_start(s->pktout);
f6e0abe2 5200 assert(lenof(compressions) > 1);
ff3187f6 5201 ssh2_pkt_addstring_str(s->pktout, s->preferred_comp->name);
f6e0abe2 5202 for (i = 0; i < lenof(compressions); i++) {
5203 const struct ssh_compress *c = compressions[i];
5204 if (c != s->preferred_comp) {
ff3187f6 5205 ssh2_pkt_addstring_str(s->pktout, ",");
5206 ssh2_pkt_addstring_str(s->pktout, c->name);
f6e0abe2 5207 }
51470298 5208 }
5209 /* List client->server languages. Empty list. */
ff3187f6 5210 ssh2_pkt_addstring_start(s->pktout);
51470298 5211 /* List server->client languages. Empty list. */
ff3187f6 5212 ssh2_pkt_addstring_start(s->pktout);
51470298 5213 /* First KEX packet does _not_ follow, because we're not that brave. */
ff3187f6 5214 ssh2_pkt_addbool(s->pktout, FALSE);
51470298 5215 /* Reserved. */
ff3187f6 5216 ssh2_pkt_adduint32(s->pktout, 0);
e5574168 5217 }
0db56f73 5218
3dc9a6a7 5219 s->our_kexinitlen = s->pktout->length - 5;
5220 s->our_kexinit = snewn(s->our_kexinitlen, unsigned char);
5221 memcpy(s->our_kexinit, s->pktout->data + 5, s->our_kexinitlen);
0db56f73 5222
590f6a5f 5223 ssh2_pkt_send_noqueue(ssh, s->pktout);
e5574168 5224
ff3187f6 5225 if (!pktin)
5226 crWaitUntil(pktin);
e5574168 5227
5228 /*
5229 * Now examine the other side's KEXINIT to see what we're up
5230 * to.
5231 */
51470298 5232 {
4763c1c2 5233 char *str, *preferred;
3d9449a1 5234 int i, j, len;
51470298 5235
ff3187f6 5236 if (pktin->type != SSH2_MSG_KEXINIT) {
6b5cf8b4 5237 bombout(("expected key exchange packet from server"));
7ffdbc1a 5238 crStop(0);
32874aea 5239 }
51470298 5240 ssh->kex = NULL;
5241 ssh->hostkey = NULL;
5242 s->cscipher_tobe = NULL;
5243 s->sccipher_tobe = NULL;
5244 s->csmac_tobe = NULL;
5245 s->scmac_tobe = NULL;
5246 s->cscomp_tobe = NULL;
5247 s->sccomp_tobe = NULL;
4763c1c2 5248 s->warn_kex = s->warn_cscipher = s->warn_sccipher = FALSE;
5249
ff3187f6 5250 pktin->savedpos += 16; /* skip garbage cookie */
5251 ssh_pkt_getstring(pktin, &str, &len); /* key exchange algorithms */
4763c1c2 5252
5253 preferred = NULL;
83e7d008 5254 for (i = 0; i < s->n_preferred_kex; i++) {
34557659 5255 const struct ssh_kexes *k = s->preferred_kex[i];
83e7d008 5256 if (!k) {
4763c1c2 5257 s->warn_kex = TRUE;
5258 } else {
34557659 5259 for (j = 0; j < k->nkexes; j++) {
5260 if (!preferred) preferred = k->list[j]->name;
5261 if (in_commasep_string(k->list[j]->name, str, len)) {
5262 ssh->kex = k->list[j];
5263 break;
5264 }
5265 }
83e7d008 5266 }
4763c1c2 5267 if (ssh->kex)
51470298 5268 break;
32874aea 5269 }
83e7d008 5270 if (!ssh->kex) {
5271 bombout(("Couldn't agree a key exchange algorithm (available: %s)",
5272 str ? str : "(null)"));
5273 crStop(0);
5274 }
b59743d5 5275 /*
5276 * Note that the server's guess is considered wrong if it doesn't match
5277 * the first algorithm in our list, even if it's still the algorithm
5278 * we end up using.
5279 */
4763c1c2 5280 s->guessok = first_in_commasep_string(preferred, str, len);
ff3187f6 5281 ssh_pkt_getstring(pktin, &str, &len); /* host key algorithms */
51470298 5282 for (i = 0; i < lenof(hostkey_algs); i++) {
5283 if (in_commasep_string(hostkey_algs[i]->name, str, len)) {
5284 ssh->hostkey = hostkey_algs[i];
5285 break;
5286 }
5287 }
3d9449a1 5288 s->guessok = s->guessok &&
b59743d5 5289 first_in_commasep_string(hostkey_algs[0]->name, str, len);
ff3187f6 5290 ssh_pkt_getstring(pktin, &str, &len); /* client->server cipher */
51470298 5291 for (i = 0; i < s->n_preferred_ciphers; i++) {
5292 const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5293 if (!c) {
4763c1c2 5294 s->warn_cscipher = TRUE;
51470298 5295 } else {
5296 for (j = 0; j < c->nciphers; j++) {
5297 if (in_commasep_string(c->list[j]->name, str, len)) {
5298 s->cscipher_tobe = c->list[j];
5299 break;
5300 }
ca20bfcf 5301 }
32874aea 5302 }
4763c1c2 5303 if (s->cscipher_tobe)
51470298 5304 break;
32874aea 5305 }
51470298 5306 if (!s->cscipher_tobe) {
6b5cf8b4 5307 bombout(("Couldn't agree a client-to-server cipher (available: %s)",
57356d63 5308 str ? str : "(null)"));
7ffdbc1a 5309 crStop(0);
ca20bfcf 5310 }
0ef8f407 5311
ff3187f6 5312 ssh_pkt_getstring(pktin, &str, &len); /* server->client cipher */
51470298 5313 for (i = 0; i < s->n_preferred_ciphers; i++) {
5314 const struct ssh2_ciphers *c = s->preferred_ciphers[i];
5315 if (!c) {
4763c1c2 5316 s->warn_sccipher = TRUE;
51470298 5317 } else {
5318 for (j = 0; j < c->nciphers; j++) {
5319 if (in_commasep_string(c->list[j]->name, str, len)) {
5320 s->sccipher_tobe = c->list[j];
5321 break;
5322 }
ca20bfcf 5323 }
32874aea 5324 }
4763c1c2 5325 if (s->sccipher_tobe)
51470298 5326 break;
32874aea 5327 }
51470298 5328 if (!s->sccipher_tobe) {
6b5cf8b4 5329 bombout(("Couldn't agree a server-to-client cipher (available: %s)",
57356d63 5330 str ? str : "(null)"));
7ffdbc1a 5331 crStop(0);
ca20bfcf 5332 }
0ef8f407 5333
ff3187f6 5334 ssh_pkt_getstring(pktin, &str, &len); /* client->server mac */
51470298 5335 for (i = 0; i < s->nmacs; i++) {
5336 if (in_commasep_string(s->maclist[i]->name, str, len)) {
5337 s->csmac_tobe = s->maclist[i];
5338 break;
5339 }
32874aea 5340 }
ff3187f6 5341 ssh_pkt_getstring(pktin, &str, &len); /* server->client mac */
51470298 5342 for (i = 0; i < s->nmacs; i++) {
5343 if (in_commasep_string(s->maclist[i]->name, str, len)) {
5344 s->scmac_tobe = s->maclist[i];
5345 break;
5346 }
32874aea 5347 }
ff3187f6 5348 ssh_pkt_getstring(pktin, &str, &len); /* client->server compression */
51470298 5349 for (i = 0; i < lenof(compressions) + 1; i++) {
5350 const struct ssh_compress *c =
5351 i == 0 ? s->preferred_comp : compressions[i - 1];
5352 if (in_commasep_string(c->name, str, len)) {
5353 s->cscomp_tobe = c;
5354 break;
5355 }
32874aea 5356 }
ff3187f6 5357 ssh_pkt_getstring(pktin, &str, &len); /* server->client compression */
51470298 5358 for (i = 0; i < lenof(compressions) + 1; i++) {
5359 const struct ssh_compress *c =
5360 i == 0 ? s->preferred_comp : compressions[i - 1];
5361 if (in_commasep_string(c->name, str, len)) {
5362 s->sccomp_tobe = c;
5363 break;
5364 }
32874aea 5365 }
b59743d5 5366 ssh_pkt_getstring(pktin, &str, &len); /* client->server language */
5367 ssh_pkt_getstring(pktin, &str, &len); /* server->client language */
4763c1c2 5368 s->ignorepkt = ssh2_pkt_getbool(pktin) && !s->guessok;
5369
5370 if (s->warn_kex) {
5371 ssh_set_frozen(ssh, 1);
5372 s->dlgret = askalg(ssh->frontend, "key-exchange algorithm",
5373 ssh->kex->name,
5374 ssh_dialog_callback, ssh);
5375 if (s->dlgret < 0) {
5376 do {
5377 crReturn(0);
5378 if (pktin) {
5379 bombout(("Unexpected data from server while"
5380 " waiting for user response"));
5381 crStop(0);
5382 }
5383 } while (pktin || inlen > 0);
5384 s->dlgret = ssh->user_response;
5385 }
5386 ssh_set_frozen(ssh, 0);
5387 if (s->dlgret == 0) {
9e296bfa 5388 ssh_disconnect(ssh, "User aborted at kex warning", NULL,
5389 0, TRUE);
a5a6f839 5390 crStop(0);
4763c1c2 5391 }
5392 }
5393
5394 if (s->warn_cscipher) {
5395 ssh_set_frozen(ssh, 1);
5396 s->dlgret = askalg(ssh->frontend,
5397 "client-to-server cipher",
5398 s->cscipher_tobe->name,
5399 ssh_dialog_callback, ssh);
5400 if (s->dlgret < 0) {
5401 do {
5402 crReturn(0);
5403 if (pktin) {
5404 bombout(("Unexpected data from server while"
5405 " waiting for user response"));
5406 crStop(0);
5407 }
5408 } while (pktin || inlen > 0);
5409 s->dlgret = ssh->user_response;
5410 }
5411 ssh_set_frozen(ssh, 0);
5412 if (s->dlgret == 0) {
9e296bfa 5413 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
5414 0, TRUE);
a5a6f839 5415 crStop(0);
4763c1c2 5416 }
5417 }
5418
5419 if (s->warn_sccipher) {
5420 ssh_set_frozen(ssh, 1);
5421 s->dlgret = askalg(ssh->frontend,
5422 "server-to-client cipher",
5423 s->sccipher_tobe->name,
5424 ssh_dialog_callback, ssh);
5425 if (s->dlgret < 0) {
5426 do {
5427 crReturn(0);
5428 if (pktin) {
5429 bombout(("Unexpected data from server while"
5430 " waiting for user response"));
5431 crStop(0);
5432 }
5433 } while (pktin || inlen > 0);
5434 s->dlgret = ssh->user_response;
5435 }
5436 ssh_set_frozen(ssh, 0);
5437 if (s->dlgret == 0) {
9e296bfa 5438 ssh_disconnect(ssh, "User aborted at cipher warning", NULL,
5439 0, TRUE);
a5a6f839 5440 crStop(0);
4763c1c2 5441 }
5442 }
5443
b672f405 5444 ssh->exhash = ssh->kex->hash->init();
5445 hash_string(ssh->kex->hash, ssh->exhash, ssh->v_c, strlen(ssh->v_c));
5446 hash_string(ssh->kex->hash, ssh->exhash, ssh->v_s, strlen(ssh->v_s));
5447 hash_string(ssh->kex->hash, ssh->exhash,
5448 s->our_kexinit, s->our_kexinitlen);
3dc9a6a7 5449 sfree(s->our_kexinit);
5450 if (pktin->length > 5)
b672f405 5451 hash_string(ssh->kex->hash, ssh->exhash,
5452 pktin->data + 5, pktin->length - 5);
3dc9a6a7 5453
4763c1c2 5454 if (s->ignorepkt) /* first_kex_packet_follows */
b59743d5 5455 crWaitUntil(pktin); /* Ignore packet */
e5574168 5456 }
e5574168 5457
5458 /*
7bd5a860 5459 * Work out the number of bits of key we will need from the key
5460 * exchange. We start with the maximum key length of either
5461 * cipher...
5462 */
5463 {
32874aea 5464 int csbits, scbits;
7bd5a860 5465
51470298 5466 csbits = s->cscipher_tobe->keylen;
5467 scbits = s->sccipher_tobe->keylen;
5468 s->nbits = (csbits > scbits ? csbits : scbits);
7bd5a860 5469 }
b672f405 5470 /* The keys only have hlen-bit entropy, since they're based on
5471 * a hash. So cap the key size at hlen bits. */
5472 if (s->nbits > ssh->kex->hash->hlen * 8)
5473 s->nbits = ssh->kex->hash->hlen * 8;
7bd5a860 5474
5475 /*
a92dd380 5476 * If we're doing Diffie-Hellman group exchange, start by
5477 * requesting a group.
e5574168 5478 */
d1aaf71d 5479 if (!ssh->kex->pdata) {
32874aea 5480 logevent("Doing Diffie-Hellman group exchange");
51470298 5481 ssh->pkt_ctx |= SSH2_PKTCTX_DHGEX;
32874aea 5482 /*
5483 * Work out how big a DH group we will need to allow that
5484 * much data.
7bd5a860 5485 */
51470298 5486 s->pbits = 512 << ((s->nbits - 1) / 64);
ff3187f6 5487 s->pktout = ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST);
5488 ssh2_pkt_adduint32(s->pktout, s->pbits);
590f6a5f 5489 ssh2_pkt_send_noqueue(ssh, s->pktout);
32874aea 5490
ff3187f6 5491 crWaitUntil(pktin);
5492 if (pktin->type != SSH2_MSG_KEX_DH_GEX_GROUP) {
6b5cf8b4 5493 bombout(("expected key exchange group packet from server"));
7ffdbc1a 5494 crStop(0);
32874aea 5495 }
ff3187f6 5496 s->p = ssh2_pkt_getmp(pktin);
5497 s->g = ssh2_pkt_getmp(pktin);
5498 if (!s->p || !s->g) {
5499 bombout(("unable to read mp-ints from incoming group packet"));
5500 crStop(0);
5501 }
d1aaf71d 5502 ssh->kex_ctx = dh_setup_gex(s->p, s->g);
51470298 5503 s->kex_init_value = SSH2_MSG_KEX_DH_GEX_INIT;
5504 s->kex_reply_value = SSH2_MSG_KEX_DH_GEX_REPLY;
a92dd380 5505 } else {
d1aaf71d 5506 ssh->pkt_ctx |= SSH2_PKTCTX_DHGROUP;
5507 ssh->kex_ctx = dh_setup_group(ssh->kex);
51470298 5508 s->kex_init_value = SSH2_MSG_KEXDH_INIT;
5509 s->kex_reply_value = SSH2_MSG_KEXDH_REPLY;
d1aaf71d 5510 logeventf(ssh, "Using Diffie-Hellman with standard group \"%s\"",
5511 ssh->kex->groupname);
8d5de777 5512 }
e5574168 5513
a92dd380 5514 logevent("Doing Diffie-Hellman key exchange");
e5574168 5515 /*
a92dd380 5516 * Now generate and send e for Diffie-Hellman.
e5574168 5517 */
755e0524 5518 set_busy_status(ssh->frontend, BUSY_CPU); /* this can take a while */
27cd7fc2 5519 s->e = dh_create_e(ssh->kex_ctx, s->nbits * 2);
ff3187f6 5520 s->pktout = ssh2_pkt_init(s->kex_init_value);
5521 ssh2_pkt_addmp(s->pktout, s->e);
590f6a5f 5522 ssh2_pkt_send_noqueue(ssh, s->pktout);
e5574168 5523
755e0524 5524 set_busy_status(ssh->frontend, BUSY_WAITING); /* wait for server */
ff3187f6 5525 crWaitUntil(pktin);
5526 if (pktin->type != s->kex_reply_value) {
6b5cf8b4 5527 bombout(("expected key exchange reply packet from server"));
7ffdbc1a 5528 crStop(0);
7cca0d81 5529 }
755e0524 5530 set_busy_status(ssh->frontend, BUSY_CPU); /* cogitate */
ff3187f6 5531 ssh_pkt_getstring(pktin, &s->hostkeydata, &s->hostkeylen);
5532 s->f = ssh2_pkt_getmp(pktin);
5533 if (!s->f) {
5534 bombout(("unable to parse key exchange reply packet"));
5535 crStop(0);
5536 }
5537 ssh_pkt_getstring(pktin, &s->sigdata, &s->siglen);
e5574168 5538
27cd7fc2 5539 s->K = dh_find_K(ssh->kex_ctx, s->f);
e5574168 5540
755e0524 5541 /* We assume everything from now on will be quick, and it might
5542 * involve user interaction. */
5543 set_busy_status(ssh->frontend, BUSY_NOT);
5544
b672f405 5545 hash_string(ssh->kex->hash, ssh->exhash, s->hostkeydata, s->hostkeylen);
34557659 5546 if (!ssh->kex->pdata) {
b672f405 5547 hash_uint32(ssh->kex->hash, ssh->exhash, s->pbits);
5548 hash_mpint(ssh->kex->hash, ssh->exhash, s->p);
5549 hash_mpint(ssh->kex->hash, ssh->exhash, s->g);
a92dd380 5550 }
b672f405 5551 hash_mpint(ssh->kex->hash, ssh->exhash, s->e);
5552 hash_mpint(ssh->kex->hash, ssh->exhash, s->f);
5553 hash_mpint(ssh->kex->hash, ssh->exhash, s->K);
5554 assert(ssh->kex->hash->hlen <= sizeof(s->exchange_hash));
5555 ssh->kex->hash->final(ssh->exhash, s->exchange_hash);
e5574168 5556
27cd7fc2 5557 dh_cleanup(ssh->kex_ctx);
fabd1805 5558 ssh->kex_ctx = NULL;
3709bfe9 5559
7cca0d81 5560#if 0
765c4200 5561 debug(("Exchange hash is:\n"));
b672f405 5562 dmemdump(s->exchange_hash, ssh->kex->hash->hlen);
7cca0d81 5563#endif
5564
51470298 5565 s->hkey = ssh->hostkey->newkey(s->hostkeydata, s->hostkeylen);
5566 if (!s->hkey ||
5567 !ssh->hostkey->verifysig(s->hkey, s->sigdata, s->siglen,
b672f405 5568 (char *)s->exchange_hash,
5569 ssh->kex->hash->hlen)) {
6b5cf8b4 5570 bombout(("Server's host key did not match the signature supplied"));
7ffdbc1a 5571 crStop(0);
8d5de777 5572 }
e5574168 5573
5574 /*
7cca0d81 5575 * Authenticate remote host: verify host key. (We've already
5576 * checked the signature of the exchange hash.)
e5574168 5577 */
51470298 5578 s->keystr = ssh->hostkey->fmtkey(s->hkey);
5579 s->fingerprint = ssh->hostkey->fingerprint(s->hkey);
3d9449a1 5580 ssh_set_frozen(ssh, 1);
5581 s->dlgret = verify_ssh_host_key(ssh->frontend,
5582 ssh->savedhost, ssh->savedport,
5583 ssh->hostkey->keytype, s->keystr,
5584 s->fingerprint,
5585 ssh_dialog_callback, ssh);
5586 if (s->dlgret < 0) {
5587 do {
5588 crReturn(0);
5589 if (pktin) {
5590 bombout(("Unexpected data from server while waiting"
5591 " for user host key response"));
5592 crStop(0);
5593 }
5594 } while (pktin || inlen > 0);
5595 s->dlgret = ssh->user_response;
5596 }
5597 ssh_set_frozen(ssh, 0);
5598 if (s->dlgret == 0) {
9e296bfa 5599 ssh_disconnect(ssh, "User aborted at host key verification", NULL,
5600 0, TRUE);
3d9449a1 5601 crStop(0);
5602 }
e13bba36 5603 if (!s->got_session_id) { /* don't bother logging this in rekeys */
5e0d7cb8 5604 logevent("Host key fingerprint is:");
51470298 5605 logevent(s->fingerprint);
5e0d7cb8 5606 }
51470298 5607 sfree(s->fingerprint);
5608 sfree(s->keystr);
5609 ssh->hostkey->freekey(s->hkey);
d39f364a 5610
5611 /*
9442dd57 5612 * The exchange hash from the very first key exchange is also
5613 * the session id, used in session key construction and
5614 * authentication.
5615 */
e13bba36 5616 if (!s->got_session_id) {
b672f405 5617 assert(sizeof(s->exchange_hash) <= sizeof(ssh->v2_session_id));
9442dd57 5618 memcpy(ssh->v2_session_id, s->exchange_hash,
5619 sizeof(s->exchange_hash));
b672f405 5620 ssh->v2_session_id_len = ssh->kex->hash->hlen;
6052bb76 5621 assert(ssh->v2_session_id_len <= sizeof(ssh->v2_session_id));
e13bba36 5622 s->got_session_id = TRUE;
5623 }
9442dd57 5624
5625 /*
7cca0d81 5626 * Send SSH2_MSG_NEWKEYS.
d39f364a 5627 */
ff3187f6 5628 s->pktout = ssh2_pkt_init(SSH2_MSG_NEWKEYS);
590f6a5f 5629 ssh2_pkt_send_noqueue(ssh, s->pktout);
9442dd57 5630 ssh->outgoing_data_size = 0; /* start counting from here */
5631
5632 /*
5633 * We've sent client NEWKEYS, so create and initialise
c64fe7d4 5634 * client-to-server session keys.
9442dd57 5635 */
5636 if (ssh->cs_cipher_ctx)
5637 ssh->cscipher->free_context(ssh->cs_cipher_ctx);
5638 ssh->cscipher = s->cscipher_tobe;
5639 ssh->cs_cipher_ctx = ssh->cscipher->make_context();
5640
5641 if (ssh->cs_mac_ctx)
5642 ssh->csmac->free_context(ssh->cs_mac_ctx);
5643 ssh->csmac = s->csmac_tobe;
5644 ssh->cs_mac_ctx = ssh->csmac->make_context();
5645
5646 if (ssh->cs_comp_ctx)
5647 ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
5648 ssh->cscomp = s->cscomp_tobe;
5649 ssh->cs_comp_ctx = ssh->cscomp->compress_init();
5650
5651 /*
5652 * Set IVs on client-to-server keys. Here we use the exchange
5653 * hash from the _first_ key exchange.
5654 */
5655 {
5656 unsigned char keyspace[40];
b672f405 5657 ssh2_mkkey(ssh,s->K,s->exchange_hash,'C',keyspace);
9442dd57 5658 ssh->cscipher->setkey(ssh->cs_cipher_ctx, keyspace);
b672f405 5659 ssh2_mkkey(ssh,s->K,s->exchange_hash,'A',keyspace);
9442dd57 5660 ssh->cscipher->setiv(ssh->cs_cipher_ctx, keyspace);
b672f405 5661 ssh2_mkkey(ssh,s->K,s->exchange_hash,'E',keyspace);
9442dd57 5662 ssh->csmac->setkey(ssh->cs_mac_ctx, keyspace);
5663 }
5664
5665 logeventf(ssh, "Initialised %.200s client->server encryption",
5666 ssh->cscipher->text_name);
5667 logeventf(ssh, "Initialised %.200s client->server MAC algorithm",
5668 ssh->csmac->text_name);
5669 if (ssh->cscomp->text_name)
5670 logeventf(ssh, "Initialised %s compression",
5671 ssh->cscomp->text_name);
590f6a5f 5672
5673 /*
5674 * Now our end of the key exchange is complete, we can send all
5675 * our queued higher-layer packets.
5676 */
5677 ssh->queueing = FALSE;
5678 ssh2_pkt_queuesend(ssh);
d39f364a 5679
5680 /*
8406eaf9 5681 * Expect SSH2_MSG_NEWKEYS from server.
5682 */
ff3187f6 5683 crWaitUntil(pktin);
5684 if (pktin->type != SSH2_MSG_NEWKEYS) {
6b5cf8b4 5685 bombout(("expected new-keys packet from server"));
7ffdbc1a 5686 crStop(0);
8406eaf9 5687 }
9442dd57 5688 ssh->incoming_data_size = 0; /* start counting from here */
8406eaf9 5689
5690 /*
9442dd57 5691 * We've seen server NEWKEYS, so create and initialise
5692 * server-to-client session keys.
d39f364a 5693 */
371e569c 5694 if (ssh->sc_cipher_ctx)
5695 ssh->sccipher->free_context(ssh->sc_cipher_ctx);
51470298 5696 ssh->sccipher = s->sccipher_tobe;
371e569c 5697 ssh->sc_cipher_ctx = ssh->sccipher->make_context();
e0e1a00d 5698
e0e1a00d 5699 if (ssh->sc_mac_ctx)
5700 ssh->scmac->free_context(ssh->sc_mac_ctx);
51470298 5701 ssh->scmac = s->scmac_tobe;
e0e1a00d 5702 ssh->sc_mac_ctx = ssh->scmac->make_context();
5703
5366aed8 5704 if (ssh->sc_comp_ctx)
5705 ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
51470298 5706 ssh->sccomp = s->sccomp_tobe;
5366aed8 5707 ssh->sc_comp_ctx = ssh->sccomp->decompress_init();
5708
d39f364a 5709 /*
9442dd57 5710 * Set IVs on server-to-client keys. Here we use the exchange
5711 * hash from the _first_ key exchange.
d39f364a 5712 */
51470298 5713 {
5714 unsigned char keyspace[40];
b672f405 5715 ssh2_mkkey(ssh,s->K,s->exchange_hash,'D',keyspace);
371e569c 5716 ssh->sccipher->setkey(ssh->sc_cipher_ctx, keyspace);
b672f405 5717 ssh2_mkkey(ssh,s->K,s->exchange_hash,'B',keyspace);
371e569c 5718 ssh->sccipher->setiv(ssh->sc_cipher_ctx, keyspace);
b672f405 5719 ssh2_mkkey(ssh,s->K,s->exchange_hash,'F',keyspace);
e0e1a00d 5720 ssh->scmac->setkey(ssh->sc_mac_ctx, keyspace);
51470298 5721 }
57356d63 5722 logeventf(ssh, "Initialised %.200s server->client encryption",
5723 ssh->sccipher->text_name);
6c135243 5724 logeventf(ssh, "Initialised %.200s server->client MAC algorithm",
5725 ssh->scmac->text_name);
57356d63 5726 if (ssh->sccomp->text_name)
5727 logeventf(ssh, "Initialised %s decompression",
5728 ssh->sccomp->text_name);
9442dd57 5729
5730 /*
5731 * Free key exchange data.
5732 */
679539d7 5733 freebn(s->f);
679539d7 5734 freebn(s->K);
34557659 5735 if (!ssh->kex->pdata) {
b3949e7e 5736 freebn(s->g);
5737 freebn(s->p);
5738 }
d39f364a 5739
033b4cef 5740 /*
e13bba36 5741 * Key exchange is over. Loop straight back round if we have a
5742 * deferred rekey reason.
5743 */
5744 if (ssh->deferred_rekey_reason) {
5745 logevent(ssh->deferred_rekey_reason);
5746 pktin = NULL;
5747 ssh->deferred_rekey_reason = NULL;
5748 goto begin_key_exchange;
5749 }
5750
5751 /*
5752 * Otherwise, schedule a timer for our next rekey.
9442dd57 5753 */
5754 ssh->kex_in_progress = FALSE;
e6c1536e 5755 ssh->last_rekey = GETTICKCOUNT();
d57f70af 5756 if (ssh->cfg.ssh_rekey_time != 0)
5757 ssh->next_rekey = schedule_timer(ssh->cfg.ssh_rekey_time*60*TICKSPERSEC,
5758 ssh2_timer, ssh);
e13bba36 5759
9442dd57 5760 /*
0db56f73 5761 * If this is the first key exchange phase, we must pass the
5762 * SSH2_MSG_NEWKEYS packet to the next layer, not because it
5763 * wants to see it but because it will need time to initialise
5764 * itself before it sees an actual packet. In subsequent key
5765 * exchange phases, we don't pass SSH2_MSG_NEWKEYS on, because
5766 * it would only confuse the layer above.
5767 */
e13bba36 5768 if (s->activated_authconn) {
0e3607ed 5769 crReturn(0);
0db56f73 5770 }
e13bba36 5771 s->activated_authconn = TRUE;
0db56f73 5772
5773 /*
7cca0d81 5774 * Now we're encrypting. Begin returning 1 to the protocol main
5775 * function so that other things can run on top of the
5776 * transport. If we ever see a KEXINIT, we must go back to the
5777 * start.
9442dd57 5778 *
5779 * We _also_ go back to the start if we see pktin==NULL and
5780 * inlen==-1, because this is a special signal meaning
5781 * `initiate client-driven rekey', and `in' contains a message
5782 * giving the reason for the rekey.
033b4cef 5783 */
9442dd57 5784 while (!((pktin && pktin->type == SSH2_MSG_KEXINIT) ||
5785 (!pktin && inlen == -1))) {
f382c87d 5786 wait_for_rekey:
32874aea 5787 crReturn(1);
e96adf72 5788 }
9442dd57 5789 if (pktin) {
5790 logevent("Server initiated key re-exchange");
5791 } else {
f382c87d 5792 /*
5793 * Special case: if the server bug is set that doesn't
5794 * allow rekeying, we give a different log message and
5795 * continue waiting. (If such a server _initiates_ a rekey,
5796 * we process it anyway!)
5797 */
5798 if ((ssh->remote_bugs & BUG_SSH2_REKEY)) {
5799 logeventf(ssh, "Server bug prevents key re-exchange (%s)",
5800 (char *)in);
5801 /* Reset the counters, so that at least this message doesn't
5802 * hit the event log _too_ often. */
5803 ssh->outgoing_data_size = 0;
5804 ssh->incoming_data_size = 0;
5805 if (ssh->cfg.ssh_rekey_time != 0) {
5806 ssh->next_rekey =
5807 schedule_timer(ssh->cfg.ssh_rekey_time*60*TICKSPERSEC,
5808 ssh2_timer, ssh);
5809 }
5810 goto wait_for_rekey; /* this is utterly horrid */
5811 } else {
5812 logeventf(ssh, "Initiating key re-exchange (%s)", (char *)in);
f382c87d 5813 }
9442dd57 5814 }
7cca0d81 5815 goto begin_key_exchange;
e5574168 5816
5817 crFinish(1);
5818}
5819
7cca0d81 5820/*
2e85c969 5821 * Add data to an SSH-2 channel output buffer.
783415f8 5822 */
32874aea 5823static void ssh2_add_channel_data(struct ssh_channel *c, char *buf,
5824 int len)
5825{
5471d09a 5826 bufchain_add(&c->v.v2.outbuffer, buf, len);
783415f8 5827}
5828
5829/*
2e85c969 5830 * Attempt to send data on an SSH-2 channel.
783415f8 5831 */
5471d09a 5832static int ssh2_try_send(struct ssh_channel *c)
32874aea 5833{
51470298 5834 Ssh ssh = c->ssh;
ff3187f6 5835 struct Packet *pktout;
51470298 5836
5471d09a 5837 while (c->v.v2.remwindow > 0 && bufchain_size(&c->v.v2.outbuffer) > 0) {
5838 int len;
5839 void *data;
5840 bufchain_prefix(&c->v.v2.outbuffer, &data, &len);
5841 if ((unsigned)len > c->v.v2.remwindow)
5842 len = c->v.v2.remwindow;
5843 if ((unsigned)len > c->v.v2.remmaxpkt)
5844 len = c->v.v2.remmaxpkt;
ff3187f6 5845 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA);
5846 ssh2_pkt_adduint32(pktout, c->remoteid);
5847 dont_log_data(ssh, pktout, PKTLOG_OMIT);
5848 ssh2_pkt_addstring_start(pktout);
5849 ssh2_pkt_addstring_data(pktout, data, len);
5850 end_log_omission(ssh, pktout);
5851 ssh2_pkt_send(ssh, pktout);
5471d09a 5852 bufchain_consume(&c->v.v2.outbuffer, len);
5853 c->v.v2.remwindow -= len;
5854 }
5855
5856 /*
5857 * After having sent as much data as we can, return the amount
5858 * still buffered.
5859 */
5860 return bufchain_size(&c->v.v2.outbuffer);
5861}
5862
1bfc7e93 5863static void ssh2_try_send_and_unthrottle(struct ssh_channel *c)
5864{
5865 int bufsize;
5866 if (c->closes)
5867 return; /* don't send on closing channels */
5868 bufsize = ssh2_try_send(c);
5869 if (bufsize == 0) {
5870 switch (c->type) {
5871 case CHAN_MAINSESSION:
5872 /* stdin need not receive an unthrottle
5873 * notification since it will be polled */
5874 break;
5875 case CHAN_X11:
5876 x11_unthrottle(c->u.x11.s);
5877 break;
5878 case CHAN_AGENT:
5879 /* agent sockets are request/response and need no
5880 * buffer management */
5881 break;
5882 case CHAN_SOCKDATA:
5883 pfd_unthrottle(c->u.pfd.s);
5884 break;
5885 }
5886 }
5887}
5888
5471d09a 5889/*
2e85c969 5890 * Potentially enlarge the window on an SSH-2 channel.
5471d09a 5891 */
5892static void ssh2_set_window(struct ssh_channel *c, unsigned newwin)
5893{
51470298 5894 Ssh ssh = c->ssh;
5895
6b69f42e 5896 /*
5897 * Never send WINDOW_ADJUST for a channel that the remote side
5898 * already thinks it's closed; there's no point, since it won't
5899 * be sending any more data anyway.
5900 */
5901 if (c->closes != 0)
5902 return;
5903
d252310a 5904 /*
5905 * Only send a WINDOW_ADJUST if there's significantly more window
5906 * available than the other end thinks there is. This saves us
5907 * sending a WINDOW_ADJUST for every character in a shell session.
5908 *
5909 * "Significant" is arbitrarily defined as half the window size.
5910 */
5911 if (newwin > c->v.v2.locwindow * 2) {
ff3187f6 5912 struct Packet *pktout;
5913
5914 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST);
5915 ssh2_pkt_adduint32(pktout, c->remoteid);
5916 ssh2_pkt_adduint32(pktout, newwin - c->v.v2.locwindow);
5917 ssh2_pkt_send(ssh, pktout);
5471d09a 5918 c->v.v2.locwindow = newwin;
783415f8 5919 }
5920}
5921
51df0ab5 5922static void ssh2_msg_channel_window_adjust(Ssh ssh, struct Packet *pktin)
b09eaa88 5923{
5924 unsigned i = ssh_pkt_getuint32(pktin);
5925 struct ssh_channel *c;
5926 c = find234(ssh->channels, &i, ssh_channelfind);
1bfc7e93 5927 if (c && !c->closes) {
b09eaa88 5928 c->v.v2.remwindow += ssh_pkt_getuint32(pktin);
1bfc7e93 5929 ssh2_try_send_and_unthrottle(c);
5930 }
b09eaa88 5931}
5932
51df0ab5 5933static void ssh2_msg_channel_data(Ssh ssh, struct Packet *pktin)
5934{
5935 char *data;
6d44acc9 5936 int length;
51df0ab5 5937 unsigned i = ssh_pkt_getuint32(pktin);
5938 struct ssh_channel *c;
5939 c = find234(ssh->channels, &i, ssh_channelfind);
5940 if (!c)
5941 return; /* nonexistent channel */
5942 if (pktin->type == SSH2_MSG_CHANNEL_EXTENDED_DATA &&
5943 ssh_pkt_getuint32(pktin) != SSH2_EXTENDED_DATA_STDERR)
5944 return; /* extended but not stderr */
5945 ssh_pkt_getstring(pktin, &data, &length);
5946 if (data) {
5947 int bufsize = 0;
5948 c->v.v2.locwindow -= length;
5949 switch (c->type) {
5950 case CHAN_MAINSESSION:
5951 bufsize =
5952 from_backend(ssh->frontend, pktin->type ==
5953 SSH2_MSG_CHANNEL_EXTENDED_DATA,
5954 data, length);
5955 break;
5956 case CHAN_X11:
5957 bufsize = x11_send(c->u.x11.s, data, length);
5958 break;
5959 case CHAN_SOCKDATA:
5960 bufsize = pfd_send(c->u.pfd.s, data, length);
5961 break;
5962 case CHAN_AGENT:
5963 while (length > 0) {
5964 if (c->u.a.lensofar < 4) {
aa63ab7e 5965 unsigned int l = min(4 - c->u.a.lensofar, length);
51df0ab5 5966 memcpy(c->u.a.msglen + c->u.a.lensofar,
5967 data, l);
5968 data += l;
5969 length -= l;
5970 c->u.a.lensofar += l;
5971 }
5972 if (c->u.a.lensofar == 4) {
5973 c->u.a.totallen =
5974 4 + GET_32BIT(c->u.a.msglen);
5975 c->u.a.message = snewn(c->u.a.totallen,
5976 unsigned char);
5977 memcpy(c->u.a.message, c->u.a.msglen, 4);
5978 }
5979 if (c->u.a.lensofar >= 4 && length > 0) {
aa63ab7e 5980 unsigned int l =
51df0ab5 5981 min(c->u.a.totallen - c->u.a.lensofar,
5982 length);
5983 memcpy(c->u.a.message + c->u.a.lensofar,
5984 data, l);
5985 data += l;
5986 length -= l;
5987 c->u.a.lensofar += l;
5988 }
5989 if (c->u.a.lensofar == c->u.a.totallen) {
5990 void *reply;
5991 int replylen;
5992 if (agent_query(c->u.a.message,
5993 c->u.a.totallen,
5994 &reply, &replylen,
5995 ssh_agentf_callback, c))
5996 ssh_agentf_callback(c, reply, replylen);
5997 sfree(c->u.a.message);
5998 c->u.a.lensofar = 0;
5999 }
6000 }
6001 bufsize = 0;
6002 break;
6003 }
6004 /*
6005 * If we are not buffering too much data,
6006 * enlarge the window again at the remote side.
6007 */
6008 if (bufsize < OUR_V2_WINSIZE)
6009 ssh2_set_window(c, OUR_V2_WINSIZE - bufsize);
6010 }
6011}
6012
6013static void ssh2_msg_channel_eof(Ssh ssh, struct Packet *pktin)
6014{
6015 unsigned i = ssh_pkt_getuint32(pktin);
6016 struct ssh_channel *c;
6017
6018 c = find234(ssh->channels, &i, ssh_channelfind);
6019 if (!c)
6020 return; /* nonexistent channel */
6021
6022 if (c->type == CHAN_X11) {
6023 /*
6024 * Remote EOF on an X11 channel means we should
6025 * wrap up and close the channel ourselves.
6026 */
6027 x11_close(c->u.x11.s);
6028 sshfwd_close(c);
6029 } else if (c->type == CHAN_AGENT) {
6030 sshfwd_close(c);
6031 } else if (c->type == CHAN_SOCKDATA) {
6032 pfd_close(c->u.pfd.s);
6033 sshfwd_close(c);
6034 }
6035}
6036
6037static void ssh2_msg_channel_close(Ssh ssh, struct Packet *pktin)
6038{
6039 unsigned i = ssh_pkt_getuint32(pktin);
6040 struct ssh_channel *c;
6041 struct Packet *pktout;
6042
6043 c = find234(ssh->channels, &i, ssh_channelfind);
64d6ff88 6044 if (!c || c->halfopen) {
51df0ab5 6045 bombout(("Received CHANNEL_CLOSE for %s channel %d\n",
6046 c ? "half-open" : "nonexistent", i));
6047 return;
6048 }
6049 /* Do pre-close processing on the channel. */
6050 switch (c->type) {
6051 case CHAN_MAINSESSION:
6052 ssh->mainchan = NULL;
6053 update_specials_menu(ssh->frontend);
6054 break;
6055 case CHAN_X11:
6056 if (c->u.x11.s != NULL)
6057 x11_close(c->u.x11.s);
6058 sshfwd_close(c);
6059 break;
6060 case CHAN_AGENT:
6061 sshfwd_close(c);
6062 break;
6063 case CHAN_SOCKDATA:
6064 if (c->u.pfd.s != NULL)
6065 pfd_close(c->u.pfd.s);
6066 sshfwd_close(c);
6067 break;
6068 }
6069 if (c->closes == 0) {
6070 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
6071 ssh2_pkt_adduint32(pktout, c->remoteid);
6072 ssh2_pkt_send(ssh, pktout);
6073 }
6074 del234(ssh->channels, c);
6075 bufchain_clear(&c->v.v2.outbuffer);
6076 sfree(c);
6077
6078 /*
6079 * See if that was the last channel left open.
6080 * (This is only our termination condition if we're
6081 * not running in -N mode.)
6082 */
6083 if (!ssh->cfg.ssh_no_shell && count234(ssh->channels) == 0) {
51df0ab5 6084 /*
6085 * We used to send SSH_MSG_DISCONNECT here,
6086 * because I'd believed that _every_ conforming
2e85c969 6087 * SSH-2 connection had to end with a disconnect
51df0ab5 6088 * being sent by at least one side; apparently
6089 * I was wrong and it's perfectly OK to
6090 * unceremoniously slam the connection shut
6091 * when you're done, and indeed OpenSSH feels
6092 * this is more polite than sending a
6093 * DISCONNECT. So now we don't.
6094 */
9e296bfa 6095 ssh_disconnect(ssh, "All channels closed", NULL, 0, TRUE);
51df0ab5 6096 }
6097}
6098
6099static void ssh2_msg_channel_open_confirmation(Ssh ssh, struct Packet *pktin)
6100{
6101 unsigned i = ssh_pkt_getuint32(pktin);
6102 struct ssh_channel *c;
6103 struct Packet *pktout;
6104
6105 c = find234(ssh->channels, &i, ssh_channelfind);
6106 if (!c)
6107 return; /* nonexistent channel */
6108 if (c->type != CHAN_SOCKDATA_DORMANT)
6109 return; /* dunno why they're confirming this */
6110 c->remoteid = ssh_pkt_getuint32(pktin);
64d6ff88 6111 c->halfopen = FALSE;
51df0ab5 6112 c->type = CHAN_SOCKDATA;
6113 c->v.v2.remwindow = ssh_pkt_getuint32(pktin);
6114 c->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
6115 if (c->u.pfd.s)
6116 pfd_confirm(c->u.pfd.s);
6117 if (c->closes) {
6118 /*
6119 * We have a pending close on this channel,
6120 * which we decided on before the server acked
6121 * the channel open. So now we know the
6122 * remoteid, we can close it again.
6123 */
6124 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE);
6125 ssh2_pkt_adduint32(pktout, c->remoteid);
6126 ssh2_pkt_send(ssh, pktout);
6127 }
6128}
6129
6130static void ssh2_msg_channel_open_failure(Ssh ssh, struct Packet *pktin)
6131{
6132 static const char *const reasons[] = {
6133 "<unknown reason code>",
6134 "Administratively prohibited",
6135 "Connect failed",
6136 "Unknown channel type",
6137 "Resource shortage",
6138 };
6139 unsigned i = ssh_pkt_getuint32(pktin);
6140 unsigned reason_code;
6141 char *reason_string;
6142 int reason_length;
51df0ab5 6143 struct ssh_channel *c;
6144 c = find234(ssh->channels, &i, ssh_channelfind);
6145 if (!c)
6146 return; /* nonexistent channel */
6147 if (c->type != CHAN_SOCKDATA_DORMANT)
6148 return; /* dunno why they're failing this */
6149
6150 reason_code = ssh_pkt_getuint32(pktin);
6151 if (reason_code >= lenof(reasons))
6152 reason_code = 0; /* ensure reasons[reason_code] in range */
6153 ssh_pkt_getstring(pktin, &reason_string, &reason_length);
fb983202 6154 logeventf(ssh, "Forwarded connection refused by server: %s [%.*s]",
6155 reasons[reason_code], reason_length, reason_string);
51df0ab5 6156
6157 pfd_close(c->u.pfd.s);
6158
6159 del234(ssh->channels, c);
6160 sfree(c);
6161}
6162
6163static void ssh2_msg_channel_request(Ssh ssh, struct Packet *pktin)
6164{
6165 unsigned localid;
6166 char *type;
6167 int typelen, want_reply;
6168 int reply = SSH2_MSG_CHANNEL_FAILURE; /* default */
6169 struct ssh_channel *c;
6170 struct Packet *pktout;
6171
6172 localid = ssh_pkt_getuint32(pktin);
6173 ssh_pkt_getstring(pktin, &type, &typelen);
6174 want_reply = ssh2_pkt_getbool(pktin);
6175
6176 /*
6177 * First, check that the channel exists. Otherwise,
6178 * we can instantly disconnect with a rude message.
6179 */
6180 c = find234(ssh->channels, &localid, ssh_channelfind);
6181 if (!c) {
9e296bfa 6182 char *buf = dupprintf("Received channel request for nonexistent"
6183 " channel %d", localid);
6184 ssh_disconnect(ssh, NULL, buf, SSH2_DISCONNECT_PROTOCOL_ERROR, FALSE);
6185 sfree(buf);
51df0ab5 6186 return;
6187 }
6188
6189 /*
6190 * Having got the channel number, we now look at
6191 * the request type string to see if it's something
6192 * we recognise.
6193 */
6194 if (c == ssh->mainchan) {
6195 /*
6196 * We recognise "exit-status" and "exit-signal" on
6197 * the primary channel.
6198 */
6199 if (typelen == 11 &&
6200 !memcmp(type, "exit-status", 11)) {
6201
6202 ssh->exitcode = ssh_pkt_getuint32(pktin);
6203 logeventf(ssh, "Server sent command exit status %d",
6204 ssh->exitcode);
6205 reply = SSH2_MSG_CHANNEL_SUCCESS;
6206
6207 } else if (typelen == 11 &&
6208 !memcmp(type, "exit-signal", 11)) {
6209
6210 int is_plausible = TRUE, is_int = FALSE;
6211 char *fmt_sig = "", *fmt_msg = "";
6212 char *msg;
6213 int msglen = 0, core = FALSE;
6214 /* ICK: older versions of OpenSSH (e.g. 3.4p1)
6215 * provide an `int' for the signal, despite its
6216 * having been a `string' in the drafts since at
6217 * least 2001. (Fixed in session.c 1.147.) Try to
6218 * infer which we can safely parse it as. */
6219 {
6220 unsigned char *p = pktin->body +
6221 pktin->savedpos;
6222 long len = pktin->length - pktin->savedpos;
6223 unsigned long num = GET_32BIT(p); /* what is it? */
6224 /* If it's 0, it hardly matters; assume string */
6225 if (num == 0) {
6226 is_int = FALSE;
6227 } else {
6228 int maybe_int = FALSE, maybe_str = FALSE;
6229#define CHECK_HYPOTHESIS(offset, result) \
6230 do { \
6231 long q = offset; \
6232 if (q >= 0 && q+4 <= len) { \
6233 q = q + 4 + GET_32BIT(p+q); \
6234 if (q >= 0 && q+4 <= len && \
c849ff23 6235 ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \
51df0ab5 6236 result = TRUE; \
6237 } \
6238 } while(0)
6239 CHECK_HYPOTHESIS(4+1, maybe_int);
6240 CHECK_HYPOTHESIS(4+num+1, maybe_str);
6241#undef CHECK_HYPOTHESIS
6242 if (maybe_int && !maybe_str)
6243 is_int = TRUE;
6244 else if (!maybe_int && maybe_str)
6245 is_int = FALSE;
6246 else
6247 /* Crikey. Either or neither. Panic. */
6248 is_plausible = FALSE;
6249 }
6250 }
6251 if (is_plausible) {
6252 if (is_int) {
6253 /* Old non-standard OpenSSH. */
6254 int signum = ssh_pkt_getuint32(pktin);
6255 fmt_sig = dupprintf(" %d", signum);
6256 } else {
6257 /* As per the drafts. */
6258 char *sig;
6259 int siglen;
6260 ssh_pkt_getstring(pktin, &sig, &siglen);
6261 /* Signal name isn't supposed to be blank, but
6262 * let's cope gracefully if it is. */
6263 if (siglen) {
6264 fmt_sig = dupprintf(" \"%.*s\"",
6265 siglen, sig);
6266 }
6267 }
6268 core = ssh2_pkt_getbool(pktin);
6269 ssh_pkt_getstring(pktin, &msg, &msglen);
6270 if (msglen) {
6271 fmt_msg = dupprintf(" (\"%.*s\")", msglen, msg);
6272 }
6273 /* ignore lang tag */
6274 } /* else don't attempt to parse */
6275 logeventf(ssh, "Server exited on signal%s%s%s",
6276 fmt_sig, core ? " (core dumped)" : "",
6277 fmt_msg);
6278 if (*fmt_sig) sfree(fmt_sig);
6279 if (*fmt_msg) sfree(fmt_msg);
6280 reply = SSH2_MSG_CHANNEL_SUCCESS;
6281
6282 }
6283 } else {
6284 /*
6285 * This is a channel request we don't know
6286 * about, so we now either ignore the request
6287 * or respond with CHANNEL_FAILURE, depending
6288 * on want_reply.
6289 */
6290 reply = SSH2_MSG_CHANNEL_FAILURE;
6291 }
6292 if (want_reply) {
6293 pktout = ssh2_pkt_init(reply);
6294 ssh2_pkt_adduint32(pktout, c->remoteid);
6295 ssh2_pkt_send(ssh, pktout);
6296 }
6297}
6298
6299static void ssh2_msg_global_request(Ssh ssh, struct Packet *pktin)
6300{
6301 char *type;
6302 int typelen, want_reply;
6303 struct Packet *pktout;
6304
6305 ssh_pkt_getstring(pktin, &type, &typelen);
6306 want_reply = ssh2_pkt_getbool(pktin);
6307
6308 /*
6309 * We currently don't support any global requests
6310 * at all, so we either ignore the request or
6311 * respond with REQUEST_FAILURE, depending on
6312 * want_reply.
6313 */
6314 if (want_reply) {
6315 pktout = ssh2_pkt_init(SSH2_MSG_REQUEST_FAILURE);
6316 ssh2_pkt_send(ssh, pktout);
6317 }
6318}
6319
6320static void ssh2_msg_channel_open(Ssh ssh, struct Packet *pktin)
6321{
6322 char *type;
6323 int typelen;
6324 char *peeraddr;
6325 int peeraddrlen;
6326 int peerport;
6327 char *error = NULL;
6328 struct ssh_channel *c;
6329 unsigned remid, winsize, pktsize;
6330 struct Packet *pktout;
6331
6332 ssh_pkt_getstring(pktin, &type, &typelen);
6333 c = snew(struct ssh_channel);
6334 c->ssh = ssh;
6335
6336 remid = ssh_pkt_getuint32(pktin);
6337 winsize = ssh_pkt_getuint32(pktin);
6338 pktsize = ssh_pkt_getuint32(pktin);
6339
6340 if (typelen == 3 && !memcmp(type, "x11", 3)) {
6341 char *addrstr;
6342
6343 ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
6344 addrstr = snewn(peeraddrlen+1, char);
6345 memcpy(addrstr, peeraddr, peeraddrlen);
6346 addrstr[peeraddrlen] = '\0';
6347 peerport = ssh_pkt_getuint32(pktin);
6348
6349 logeventf(ssh, "Received X11 connect request from %s:%d",
6350 addrstr, peerport);
6351
6352 if (!ssh->X11_fwd_enabled)
6353 error = "X11 forwarding is not enabled";
6354 else if (x11_init(&c->u.x11.s, ssh->cfg.x11_display, c,
6355 ssh->x11auth, addrstr, peerport,
6356 &ssh->cfg) != NULL) {
6357 error = "Unable to open an X11 connection";
6358 } else {
6359 logevent("Opening X11 forward connection succeeded");
6360 c->type = CHAN_X11;
6361 }
6362
6363 sfree(addrstr);
6364 } else if (typelen == 15 &&
6365 !memcmp(type, "forwarded-tcpip", 15)) {
6366 struct ssh_rportfwd pf, *realpf;
6367 char *dummy;
6368 int dummylen;
6369 ssh_pkt_getstring(pktin, &dummy, &dummylen);/* skip address */
6370 pf.sport = ssh_pkt_getuint32(pktin);
6371 ssh_pkt_getstring(pktin, &peeraddr, &peeraddrlen);
6372 peerport = ssh_pkt_getuint32(pktin);
6373 realpf = find234(ssh->rportfwds, &pf, NULL);
6374 logeventf(ssh, "Received remote port %d open request "
6375 "from %s:%d", pf.sport, peeraddr, peerport);
6376 if (realpf == NULL) {
6377 error = "Remote port is not recognised";
6378 } else {
6379 const char *e = pfd_newconnect(&c->u.pfd.s,
6380 realpf->dhost,
6381 realpf->dport, c,
05581745 6382 &ssh->cfg,
6383 realpf->pfrec->addressfamily);
51df0ab5 6384 logeventf(ssh, "Attempting to forward remote port to "
6385 "%s:%d", realpf->dhost, realpf->dport);
6386 if (e != NULL) {
6387 logeventf(ssh, "Port open failed: %s", e);
6388 error = "Port open failed";
6389 } else {
6390 logevent("Forwarded port opened successfully");
6391 c->type = CHAN_SOCKDATA;
6392 }
6393 }
6394 } else if (typelen == 22 &&
c49cf994 6395 !memcmp(type, "auth-agent@openssh.com", 22)) {
51df0ab5 6396 if (!ssh->agentfwd_enabled)
6397 error = "Agent forwarding is not enabled";
6398 else {
6399 c->type = CHAN_AGENT; /* identify channel type */
6400 c->u.a.lensofar = 0;
6401 }
6402 } else {
6403 error = "Unsupported channel type requested";
6404 }
6405
6406 c->remoteid = remid;
64d6ff88 6407 c->halfopen = FALSE;
51df0ab5 6408 if (error) {
6409 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE);
6410 ssh2_pkt_adduint32(pktout, c->remoteid);
6411 ssh2_pkt_adduint32(pktout, SSH2_OPEN_CONNECT_FAILED);
6412 ssh2_pkt_addstring(pktout, error);
6413 ssh2_pkt_addstring(pktout, "en"); /* language tag */
6414 ssh2_pkt_send(ssh, pktout);
6415 logeventf(ssh, "Rejected channel open: %s", error);
6416 sfree(c);
6417 } else {
6418 c->localid = alloc_channel_id(ssh);
6419 c->closes = 0;
6420 c->v.v2.locwindow = OUR_V2_WINSIZE;
6421 c->v.v2.remwindow = winsize;
6422 c->v.v2.remmaxpkt = pktsize;
6423 bufchain_init(&c->v.v2.outbuffer);
6424 add234(ssh->channels, c);
6425 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
6426 ssh2_pkt_adduint32(pktout, c->remoteid);
6427 ssh2_pkt_adduint32(pktout, c->localid);
6428 ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);
954d5c5a 6429 ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */
51df0ab5 6430 ssh2_pkt_send(ssh, pktout);
6431 }
6432}
6433
6bbce591 6434/*
6435 * Buffer banner messages for later display at some convenient point.
6436 */
6437static void ssh2_msg_userauth_banner(Ssh ssh, struct Packet *pktin)
6438{
6439 /* Arbitrary limit to prevent unbounded inflation of buffer */
6440 if (bufchain_size(&ssh->banner) <= 131072) {
6441 char *banner = NULL;
6442 int size = 0;
6443 ssh_pkt_getstring(pktin, &banner, &size);
6444 if (banner)
6445 bufchain_add(&ssh->banner, banner, size);
6446 }
6447}
6448
c6ccd5c2 6449/* Helper function to deal with sending tty modes for "pty-req" */
6450static void ssh2_send_ttymode(void *data, char *mode, char *val)
6451{
6452 struct Packet *pktout = (struct Packet *)data;
6453 int i = 0;
6454 unsigned int arg = 0;
6455 while (strcmp(mode, ssh_ttymodes[i].mode) != 0) i++;
6456 if (i == lenof(ssh_ttymodes)) return;
6457 switch (ssh_ttymodes[i].type) {
6458 case TTY_OP_CHAR:
6459 arg = ssh_tty_parse_specchar(val);
6460 break;
6461 case TTY_OP_BOOL:
6462 arg = ssh_tty_parse_boolean(val);
6463 break;
6464 }
6465 ssh2_pkt_addbyte(pktout, ssh_ttymodes[i].opcode);
6466 ssh2_pkt_adduint32(pktout, arg);
6467}
6468
783415f8 6469/*
2e85c969 6470 * Handle the SSH-2 userauth and connection layers.
7cca0d81 6471 */
ff3187f6 6472static void do_ssh2_authconn(Ssh ssh, unsigned char *in, int inlen,
6473 struct Packet *pktin)
7cca0d81 6474{
51470298 6475 struct do_ssh2_authconn_state {
6476 enum {
51470298 6477 AUTH_TYPE_NONE,
6478 AUTH_TYPE_PUBLICKEY,
6479 AUTH_TYPE_PUBLICKEY_OFFER_LOUD,
6480 AUTH_TYPE_PUBLICKEY_OFFER_QUIET,
6481 AUTH_TYPE_PASSWORD,
6482 AUTH_TYPE_KEYBOARD_INTERACTIVE,
6483 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
6484 } type;
a1a1fae4 6485 int done_service_req;
51470298 6486 int gotit, need_pw, can_pubkey, can_passwd, can_keyb_inter;
6ac3a551 6487 int tried_pubkey_config, tried_agent;
edd0cb8a 6488 int kbd_inter_refused;
51470298 6489 int we_are_in;
edd0cb8a 6490 prompts_t *cur_prompt;
6491 int num_prompts;
51470298 6492 char username[100];
6493 int got_username;
51470298 6494 void *publickey_blob;
6495 int publickey_bloblen;
edd0cb8a 6496 int publickey_encrypted;
6497 char *publickey_algorithm;
6498 char *publickey_comment;
51470298 6499 unsigned char request[5], *response, *p;
6500 int responselen;
6501 int keyi, nkeys;
6502 int authed;
6503 char *pkblob, *alg, *commentp;
6504 int pklen, alglen, commentlen;
6505 int siglen, retlen, len;
6506 char *q, *agentreq, *ret;
6507 int try_send;
73feed4f 6508 int num_env, env_left, env_ok;
ff3187f6 6509 struct Packet *pktout;
51470298 6510 };
6511 crState(do_ssh2_authconn_state);
6512
6513 crBegin(ssh->do_ssh2_authconn_crstate);
e5574168 6514
a1a1fae4 6515 s->done_service_req = FALSE;
6516 s->we_are_in = FALSE;
6517 if (!ssh->cfg.ssh_no_userauth) {
6518 /*
6519 * Request userauth protocol, and await a response to it.
6520 */
6521 s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
6522 ssh2_pkt_addstring(s->pktout, "ssh-userauth");
6523 ssh2_pkt_send(ssh, s->pktout);
6524 crWaitUntilV(pktin);
6525 if (pktin->type == SSH2_MSG_SERVICE_ACCEPT)
6526 s->done_service_req = TRUE;
6527 }
6528 if (!s->done_service_req) {
6529 /*
6530 * Request connection protocol directly, without authentication.
6531 */
6532 s->pktout = ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST);
6533 ssh2_pkt_addstring(s->pktout, "ssh-connection");
6534 ssh2_pkt_send(ssh, s->pktout);
6535 crWaitUntilV(pktin);
6536 if (pktin->type == SSH2_MSG_SERVICE_ACCEPT) {
6537 s->we_are_in = TRUE; /* no auth required */
6538 } else {
6539 bombout(("Server refused service request"));
6540 crStopV;
6541 }
8d5de777 6542 }
7cca0d81 6543
6544 /*
edd0cb8a 6545 * Misc one-time setup for authentication.
6546 */
6547 s->publickey_blob = NULL;
6548 if (!s->we_are_in) {
6549
6550 /*
6551 * Load the public half of any configured public key file
6552 * for later use.
6553 */
6554 if (!filename_is_null(ssh->cfg.keyfile)) {
6555 int keytype;
6556 logeventf(ssh, "Reading private key file \"%.150s\"",
6557 filename_to_str(&ssh->cfg.keyfile));
6558 keytype = key_type(&ssh->cfg.keyfile);
6559 if (keytype == SSH_KEYTYPE_SSH2) {
6560 const char *error;
6561 s->publickey_blob =
6562 ssh2_userkey_loadpub(&ssh->cfg.keyfile,
6563 &s->publickey_algorithm,
6564 &s->publickey_bloblen,
6565 &s->publickey_comment, &error);
6566 if (s->publickey_blob) {
6567 s->publickey_encrypted =
6568 ssh2_userkey_encrypted(&ssh->cfg.keyfile, NULL);
6569 } else {
6570 char *msgbuf;
6571 logeventf(ssh, "Unable to load private key (%s)",
6572 error);
6573 msgbuf = dupprintf("Unable to load private key file "
6574 "\"%.150s\" (%s)\r\n",
6575 filename_to_str(&ssh->cfg.keyfile),
6576 error);
6577 c_write_str(ssh, msgbuf);
6578 sfree(msgbuf);
6579 }
6580 } else {
6581 char *msgbuf;
6582 logeventf(ssh, "Unable to use this key file (%s)",
6583 key_type_to_str(keytype));
6584 msgbuf = dupprintf("Unable to use key file \"%.150s\""
6585 " (%s)\r\n",
6586 filename_to_str(&ssh->cfg.keyfile),
6587 key_type_to_str(keytype));
6588 c_write_str(ssh, msgbuf);
6589 sfree(msgbuf);
6590 s->publickey_blob = NULL;
6591 }
6592 }
6593
6594 }
6595
6596 /*
1408a877 6597 * We repeat this whole loop, including the username prompt,
6598 * until we manage a successful authentication. If the user
51470298 6599 * types the wrong _password_, they can be sent back to the
6600 * beginning to try another username, if this is configured on.
6601 * (If they specify a username in the config, they are never
6602 * asked, even if they do give a wrong password.)
1408a877 6603 *
6604 * I think this best serves the needs of
6605 *
6606 * - the people who have no configuration, no keys, and just
6607 * want to try repeated (username,password) pairs until they
6608 * type both correctly
6609 *
6610 * - people who have keys and configuration but occasionally
6611 * need to fall back to passwords
6612 *
6613 * - people with a key held in Pageant, who might not have
6614 * logged in to a particular machine before; so they want to
6615 * type a username, and then _either_ their key will be
6616 * accepted, _or_ they will type a password. If they mistype
6617 * the username they will want to be able to get back and
6618 * retype it!
7cca0d81 6619 */
51470298 6620 s->username[0] = '\0';
6621 s->got_username = FALSE;
6bbce591 6622 bufchain_init(&ssh->banner);
6623 ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] =
6624 ssh2_msg_userauth_banner;
a1a1fae4 6625 while (!s->we_are_in) {
1408a877 6626 /*
6627 * Get a username.
6628 */
86916870 6629 if (s->got_username && !ssh->cfg.change_username) {
5bb641e1 6630 /*
6631 * We got a username last time round this loop, and
6632 * with change_username turned off we don't try to get
6633 * it again.
6634 */
aa09f7d0 6635 } else if (!*ssh->cfg.username) {
edd0cb8a 6636 int ret; /* need not be kept over crReturn */
6637 s->cur_prompt = new_prompts(ssh->frontend);
6638 s->cur_prompt->to_server = TRUE;
6639 s->cur_prompt->name = dupstr("SSH login name");
6640 add_prompt(s->cur_prompt, dupstr("login as: "), TRUE,
6641 lenof(s->username));
6642 ret = get_userpass_input(s->cur_prompt, NULL, 0);
6643 while (ret < 0) {
51470298 6644 ssh->send_ok = 1;
edd0cb8a 6645 crWaitUntilV(!pktin);
6646 ret = get_userpass_input(s->cur_prompt, in, inlen);
6647 ssh->send_ok = 0;
32874aea 6648 }
edd0cb8a 6649 if (!ret) {
6650 /*
6651 * get_userpass_input() failed to get a username.
6652 * Terminate.
6653 */
6654 free_prompts(s->cur_prompt);
6655 ssh_disconnect(ssh, "No username provided", NULL, 0, TRUE);
6656 crStopV;
6657 }
6658 memcpy(s->username, s->cur_prompt->prompts[0]->result,
6659 lenof(s->username));
6660 free_prompts(s->cur_prompt);
7cca0d81 6661 } else {
57356d63 6662 char *stuff;
86916870 6663 strncpy(s->username, ssh->cfg.username, sizeof(s->username));
51470298 6664 s->username[sizeof(s->username)-1] = '\0';
65a22376 6665 if ((flags & FLAG_VERBOSE) || (flags & FLAG_INTERACTIVE)) {
57356d63 6666 stuff = dupprintf("Using username \"%s\".\r\n", s->username);
51470298 6667 c_write_str(ssh, stuff);
57356d63 6668 sfree(stuff);
7cca0d81 6669 }
6670 }
51470298 6671 s->got_username = TRUE;
7cca0d81 6672
65a22376 6673 /*
1408a877 6674 * Send an authentication request using method "none": (a)
6675 * just in case it succeeds, and (b) so that we know what
6676 * authentication methods we can usefully try next.
65a22376 6677 */
51470298 6678 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6679
ff3187f6 6680 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6681 ssh2_pkt_addstring(s->pktout, s->username);
6682 ssh2_pkt_addstring(s->pktout, "ssh-connection");/* service requested */
6683 ssh2_pkt_addstring(s->pktout, "none"); /* method */
6684 ssh2_pkt_send(ssh, s->pktout);
51470298 6685 s->type = AUTH_TYPE_NONE;
6686 s->gotit = FALSE;
6687 s->we_are_in = FALSE;
6688
6689 s->tried_pubkey_config = FALSE;
6690 s->tried_agent = FALSE;
6ac3a551 6691 s->kbd_inter_refused = FALSE;
65a22376 6692
1408a877 6693 while (1) {
6694 /*
6695 * Wait for the result of the last authentication request.
6696 */
51470298 6697 if (!s->gotit)
ff3187f6 6698 crWaitUntilV(pktin);
6bbce591 6699 /*
6700 * Now is a convenient point to spew any banner material
6701 * that we've accumulated. (This should ensure that when
6702 * we exit the auth loop, we haven't any left to deal
6703 * with.)
6704 */
6705 {
6706 int size = bufchain_size(&ssh->banner);
32874aea 6707 /*
6708 * Don't show the banner if we're operating in
6709 * non-verbose non-interactive mode. (It's probably
6710 * a script, which means nobody will read the
6711 * banner _anyway_, and moreover the printing of
6712 * the banner will screw up processing on the
6713 * output of (say) plink.)
6714 */
6bbce591 6715 if (size && (flags & (FLAG_VERBOSE | FLAG_INTERACTIVE))) {
6716 char *banner = snewn(size, char);
6717 bufchain_fetch(&ssh->banner, banner, size);
6718 c_write_untrusted(ssh, banner, size);
6719 sfree(banner);
32874aea 6720 }
6bbce591 6721 bufchain_clear(&ssh->banner);
1408a877 6722 }
ff3187f6 6723 if (pktin->type == SSH2_MSG_USERAUTH_SUCCESS) {
1408a877 6724 logevent("Access granted");
51470298 6725 s->we_are_in = TRUE;
1408a877 6726 break;
6727 }
65a22376 6728
edd0cb8a 6729 if (pktin->type == SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ) {
4c6e53e3 6730 /* FIXME: perhaps we should support this? */
6731 bombout(("PASSWD_CHANGEREQ not yet supported"));
6732 crStopV;
ff3187f6 6733 } else if (pktin->type != SSH2_MSG_USERAUTH_FAILURE) {
6b5cf8b4 6734 bombout(("Strange packet received during authentication: type %d",
ff3187f6 6735 pktin->type));
7ffdbc1a 6736 crStopV;
65a22376 6737 }
6738
51470298 6739 s->gotit = FALSE;
65a22376 6740
1408a877 6741 /*
6742 * OK, we're now sitting on a USERAUTH_FAILURE message, so
6743 * we can look at the string in it and know what we can
6744 * helpfully try next.
6745 */
ff3187f6 6746 if (pktin->type == SSH2_MSG_USERAUTH_FAILURE) {
1408a877 6747 char *methods;
6748 int methlen;
ff3187f6 6749 ssh_pkt_getstring(pktin, &methods, &methlen);
ff3187f6 6750 if (!ssh2_pkt_getbool(pktin)) {
1408a877 6751 /*
6752 * We have received an unequivocal Access
6753 * Denied. This can translate to a variety of
6754 * messages:
6755 *
6756 * - if we'd just tried "none" authentication,
6757 * it's not worth printing anything at all
6758 *
6759 * - if we'd just tried a public key _offer_,
6760 * the message should be "Server refused our
6761 * key" (or no message at all if the key
6762 * came from Pageant)
6763 *
6764 * - if we'd just tried anything else, the
6765 * message really should be "Access denied".
6766 *
6767 * Additionally, if we'd just tried password
6768 * authentication, we should break out of this
6769 * whole loop so as to go back to the username
91f57d1f 6770 * prompt (iff we're configured to allow
6771 * username change attempts).
1408a877 6772 */
51470298 6773 if (s->type == AUTH_TYPE_NONE) {
1408a877 6774 /* do nothing */
51470298 6775 } else if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD ||
6776 s->type == AUTH_TYPE_PUBLICKEY_OFFER_QUIET) {
6777 if (s->type == AUTH_TYPE_PUBLICKEY_OFFER_LOUD)
6778 c_write_str(ssh, "Server refused our key\r\n");
1408a877 6779 logevent("Server refused public key");
51470298 6780 } else if (s->type==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET) {
4bdf7c46 6781 /* server declined keyboard-interactive; ignore */
1408a877 6782 } else {
51470298 6783 c_write_str(ssh, "Access denied\r\n");
1408a877 6784 logevent("Access denied");
91f57d1f 6785 if (s->type == AUTH_TYPE_PASSWORD &&
6786 ssh->cfg.change_username) {
6c9dce7c 6787 /* XXX perhaps we should allow
6788 * keyboard-interactive to do this too? */
51470298 6789 s->we_are_in = FALSE;
1408a877 6790 break;
6791 }
6792 }
6793 } else {
51470298 6794 c_write_str(ssh, "Further authentication required\r\n");
1408a877 6795 logevent("Further authentication required");
6796 }
65a22376 6797
51470298 6798 s->can_pubkey =
32874aea 6799 in_commasep_string("publickey", methods, methlen);
51470298 6800 s->can_passwd =
32874aea 6801 in_commasep_string("password", methods, methlen);
86916870 6802 s->can_keyb_inter = ssh->cfg.try_ki_auth &&
761187b6 6803 in_commasep_string("keyboard-interactive", methods, methlen);
1408a877 6804 }
65a22376 6805
51470298 6806 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
65a22376 6807
edd0cb8a 6808 if (s->can_pubkey && agent_exists() && !s->tried_agent) {
0405e71f 6809
1983e559 6810 /*
6811 * Attempt public-key authentication using Pageant.
6812 */
1983e559 6813 void *r;
51470298 6814 s->authed = FALSE;
1983e559 6815
51470298 6816 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6817 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
00db133f 6818
51470298 6819 s->tried_agent = TRUE;
1983e559 6820
6821 logevent("Pageant is running. Requesting keys.");
6822
6823 /* Request the keys held by the agent. */
51470298 6824 PUT_32BIT(s->request, 1);
6825 s->request[4] = SSH2_AGENTC_REQUEST_IDENTITIES;
839f10db 6826 if (!agent_query(s->request, 5, &r, &s->responselen,
6827 ssh_agent_callback, ssh)) {
6828 do {
6829 crReturnV;
ff3187f6 6830 if (pktin) {
839f10db 6831 bombout(("Unexpected data from server while"
6832 " waiting for agent response"));
6833 crStopV;
6834 }
ff3187f6 6835 } while (pktin || inlen > 0);
839f10db 6836 r = ssh->agent_response;
6837 s->responselen = ssh->agent_response_len;
6838 }
51470298 6839 s->response = (unsigned char *) r;
6840 if (s->response && s->responselen >= 5 &&
6841 s->response[4] == SSH2_AGENT_IDENTITIES_ANSWER) {
6842 s->p = s->response + 5;
6843 s->nkeys = GET_32BIT(s->p);
6844 s->p += 4;
2e85c969 6845 logeventf(ssh, "Pageant has %d SSH-2 keys", s->nkeys);
51470298 6846 for (s->keyi = 0; s->keyi < s->nkeys; s->keyi++) {
2d466ffd 6847 void *vret;
1983e559 6848
fb983202 6849 logeventf(ssh, "Trying Pageant key #%d", s->keyi);
51470298 6850 s->pklen = GET_32BIT(s->p);
6851 s->p += 4;
6852 if (s->publickey_blob &&
6853 s->pklen == s->publickey_bloblen &&
6854 !memcmp(s->p, s->publickey_blob,
6855 s->publickey_bloblen)) {
396778f1 6856 logevent("This key matches configured key file");
51470298 6857 s->tried_pubkey_config = 1;
396778f1 6858 }
d8baa528 6859 s->pkblob = (char *)s->p;
51470298 6860 s->p += s->pklen;
6861 s->alglen = GET_32BIT(s->pkblob);
6862 s->alg = s->pkblob + 4;
6863 s->commentlen = GET_32BIT(s->p);
6864 s->p += 4;
d8baa528 6865 s->commentp = (char *)s->p;
51470298 6866 s->p += s->commentlen;
ff3187f6 6867 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6868 ssh2_pkt_addstring(s->pktout, s->username);
6869 ssh2_pkt_addstring(s->pktout, "ssh-connection"); /* service requested */
6870 ssh2_pkt_addstring(s->pktout, "publickey"); /* method */
6871 ssh2_pkt_addbool(s->pktout, FALSE); /* no signature included */
6872 ssh2_pkt_addstring_start(s->pktout);
6873 ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
6874 ssh2_pkt_addstring_start(s->pktout);
6875 ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
6876 ssh2_pkt_send(ssh, s->pktout);
6877
6878 crWaitUntilV(pktin);
6879 if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
1983e559 6880 logevent("Key refused");
6881 continue;
6882 }
6883
32874aea 6884 if (flags & FLAG_VERBOSE) {
51470298 6885 c_write_str(ssh, "Authenticating with "
6886 "public key \"");
6887 c_write(ssh, s->commentp, s->commentlen);
6888 c_write_str(ssh, "\" from agent\r\n");
32874aea 6889 }
1983e559 6890
6891 /*
6892 * Server is willing to accept the key.
6893 * Construct a SIGN_REQUEST.
6894 */
ff3187f6 6895 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6896 ssh2_pkt_addstring(s->pktout, s->username);
6897 ssh2_pkt_addstring(s->pktout, "ssh-connection"); /* service requested */
6898 ssh2_pkt_addstring(s->pktout, "publickey"); /* method */
6899 ssh2_pkt_addbool(s->pktout, TRUE);
6900 ssh2_pkt_addstring_start(s->pktout);
6901 ssh2_pkt_addstring_data(s->pktout, s->alg, s->alglen);
6902 ssh2_pkt_addstring_start(s->pktout);
6903 ssh2_pkt_addstring_data(s->pktout, s->pkblob, s->pklen);
6904
b672f405 6905 s->siglen = s->pktout->length - 5 + 4 +
6906 ssh->v2_session_id_len;
dda87a28 6907 if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
6908 s->siglen -= 4;
51470298 6909 s->len = 1; /* message type */
6910 s->len += 4 + s->pklen; /* key blob */
6911 s->len += 4 + s->siglen; /* data to sign */
6912 s->len += 4; /* flags */
3d88e64d 6913 s->agentreq = snewn(4 + s->len, char);
51470298 6914 PUT_32BIT(s->agentreq, s->len);
6915 s->q = s->agentreq + 4;
6916 *s->q++ = SSH2_AGENTC_SIGN_REQUEST;
6917 PUT_32BIT(s->q, s->pklen);
6918 s->q += 4;
6919 memcpy(s->q, s->pkblob, s->pklen);
6920 s->q += s->pklen;
6921 PUT_32BIT(s->q, s->siglen);
6922 s->q += 4;
1983e559 6923 /* Now the data to be signed... */
dda87a28 6924 if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
b672f405 6925 PUT_32BIT(s->q, ssh->v2_session_id_len);
dda87a28 6926 s->q += 4;
6927 }
b672f405 6928 memcpy(s->q, ssh->v2_session_id,
6929 ssh->v2_session_id_len);
6930 s->q += ssh->v2_session_id_len;
ff3187f6 6931 memcpy(s->q, s->pktout->data + 5,
6932 s->pktout->length - 5);
6933 s->q += s->pktout->length - 5;
1983e559 6934 /* And finally the (zero) flags word. */
51470298 6935 PUT_32BIT(s->q, 0);
839f10db 6936 if (!agent_query(s->agentreq, s->len + 4,
6937 &vret, &s->retlen,
6938 ssh_agent_callback, ssh)) {
6939 do {
6940 crReturnV;
ff3187f6 6941 if (pktin) {
839f10db 6942 bombout(("Unexpected data from server"
6943 " while waiting for agent"
6944 " response"));
6945 crStopV;
6946 }
ff3187f6 6947 } while (pktin || inlen > 0);
839f10db 6948 vret = ssh->agent_response;
6949 s->retlen = ssh->agent_response_len;
6950 }
51470298 6951 s->ret = vret;
6952 sfree(s->agentreq);
6953 if (s->ret) {
6954 if (s->ret[4] == SSH2_AGENT_SIGN_RESPONSE) {
1983e559 6955 logevent("Sending Pageant's response");
ff3187f6 6956 ssh2_add_sigblob(ssh, s->pktout,
6957 s->pkblob, s->pklen,
51470298 6958 s->ret + 9,
6959 GET_32BIT(s->ret + 5));
ff3187f6 6960 ssh2_pkt_send(ssh, s->pktout);
51470298 6961 s->authed = TRUE;
1983e559 6962 break;
6963 } else {
32874aea 6964 logevent
6965 ("Pageant failed to answer challenge");
51470298 6966 sfree(s->ret);
1983e559 6967 }
6968 }
6969 }
51470298 6970 if (s->authed)
1983e559 6971 continue;
6972 }
29b1d0b3 6973 sfree(s->response);
1983e559 6974
edd0cb8a 6975 } else if (s->can_pubkey && s->publickey_blob &&
6976 !s->tried_pubkey_config) {
65a22376 6977
edd0cb8a 6978 struct ssh2_userkey *key; /* not live over crReturn */
6979 char *passphrase; /* not live over crReturn */
65a22376 6980
51470298 6981 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
6982 ssh->pkt_ctx |= SSH2_PKTCTX_PUBLICKEY;
00db133f 6983
edd0cb8a 6984 s->tried_pubkey_config = TRUE;
6985
65a22376 6986 /*
1408a877 6987 * Try the public key supplied in the configuration.
6988 *
6989 * First, offer the public blob to see if the server is
6990 * willing to accept it.
65a22376 6991 */
ff3187f6 6992 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
6993 ssh2_pkt_addstring(s->pktout, s->username);
edd0cb8a 6994 ssh2_pkt_addstring(s->pktout, "ssh-connection");
6995 /* service requested */
6996 ssh2_pkt_addstring(s->pktout, "publickey"); /* method */
6997 ssh2_pkt_addbool(s->pktout, FALSE);
6998 /* no signature included */
6999 ssh2_pkt_addstring(s->pktout, s->publickey_algorithm);
7000 ssh2_pkt_addstring_start(s->pktout);
7001 ssh2_pkt_addstring_data(s->pktout,
7002 (char *)s->publickey_blob,
7003 s->publickey_bloblen);
ff3187f6 7004 ssh2_pkt_send(ssh, s->pktout);
edd0cb8a 7005 logevent("Offered public key");
ff3187f6 7006
7007 crWaitUntilV(pktin);
edd0cb8a 7008 if (pktin->type != SSH2_MSG_USERAUTH_PK_OK) {
7009 /* Key refused. Give up. */
7010 s->gotit = TRUE; /* reconsider message next loop */
7011 s->type = AUTH_TYPE_PUBLICKEY_OFFER_LOUD;
7012 continue; /* process this new message */
45068b27 7013 }
edd0cb8a 7014 logevent("Offer of public key accepted");
af659722 7015
45068b27 7016 /*
edd0cb8a 7017 * Actually attempt a serious authentication using
7018 * the key.
45068b27 7019 */
edd0cb8a 7020 if (flags & FLAG_VERBOSE) {
7021 c_write_str(ssh, "Authenticating with public key \"");
7022 c_write_str(ssh, s->publickey_comment);
7023 c_write_str(ssh, "\"\r\n");
7024 }
7025 key = NULL;
7026 while (!key) {
7027 const char *error; /* not live over crReturn */
7028 if (s->publickey_encrypted) {
7029 /*
7030 * Get a passphrase from the user.
7031 */
7032 int ret; /* need not be kept over crReturn */
7033 s->cur_prompt = new_prompts(ssh->frontend);
7034 s->cur_prompt->to_server = FALSE;
7035 s->cur_prompt->name = dupstr("SSH key passphrase");
7036 add_prompt(s->cur_prompt,
7037 dupprintf("Passphrase for key \"%.100s\": ",
7038 s->publickey_comment),
7039 FALSE, SSH_MAX_PASSWORD_LEN);
7040 ret = get_userpass_input(s->cur_prompt, NULL, 0);
7041 while (ret < 0) {
7042 ssh->send_ok = 1;
7043 crWaitUntilV(!pktin);
7044 ret = get_userpass_input(s->cur_prompt,
7045 in, inlen);
7046 ssh->send_ok = 0;
7047 }
7048 if (!ret) {
7049 /* Failed to get a passphrase. Terminate. */
7050 free_prompts(s->cur_prompt);
7051 ssh_disconnect(ssh, NULL,
7052 "Unable to authenticate",
7053 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
7054 TRUE);
7055 crStopV;
85fdbe25 7056 }
edd0cb8a 7057 passphrase =
7058 dupstr(s->cur_prompt->prompts[0]->result);
7059 free_prompts(s->cur_prompt);
45068b27 7060 } else {
edd0cb8a 7061 passphrase = NULL; /* no passphrase needed */
45068b27 7062 }
1408a877 7063
edd0cb8a 7064 /*
7065 * Try decrypting the key.
7066 */
7067 key = ssh2_load_userkey(&ssh->cfg.keyfile, passphrase,
7068 &error);
7069 if (passphrase) {
7070 /* burn the evidence */
7071 memset(passphrase, 0, strlen(passphrase));
7072 sfree(passphrase);
7073 }
7074 if (key == SSH2_WRONG_PASSPHRASE || key == NULL) {
7075 if (passphrase &&
7076 (key == SSH2_WRONG_PASSPHRASE)) {
7077 c_write_str(ssh, "Wrong passphrase\r\n");
7078 key = NULL;
7079 /* and loop again */
7080 } else {
7081 c_write_str(ssh, "Unable to load private key (");
7082 c_write_str(ssh, error);
7083 c_write_str(ssh, ")\r\n");
7084 key = NULL;
7085 break; /* try something else */
7086 }
1408a877 7087 }
65a22376 7088 }
65a22376 7089
edd0cb8a 7090 if (key) {
1dd353b5 7091 unsigned char *pkblob, *sigblob, *sigdata;
7092 int pkblob_len, sigblob_len, sigdata_len;
edd0cb8a 7093 int p;
65a22376 7094
1408a877 7095 /*
7096 * We have loaded the private key and the server
7097 * has announced that it's willing to accept it.
7098 * Hallelujah. Generate a signature and send it.
7099 */
ff3187f6 7100 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7101 ssh2_pkt_addstring(s->pktout, s->username);
edd0cb8a 7102 ssh2_pkt_addstring(s->pktout, "ssh-connection");
7103 /* service requested */
7104 ssh2_pkt_addstring(s->pktout, "publickey");
7105 /* method */
ff3187f6 7106 ssh2_pkt_addbool(s->pktout, TRUE);
edd0cb8a 7107 /* signature follows */
ff3187f6 7108 ssh2_pkt_addstring(s->pktout, key->alg->name);
edd0cb8a 7109 pkblob = key->alg->public_blob(key->data,
7110 &pkblob_len);
ff3187f6 7111 ssh2_pkt_addstring_start(s->pktout);
edd0cb8a 7112 ssh2_pkt_addstring_data(s->pktout, (char *)pkblob,
7113 pkblob_len);
1408a877 7114
7115 /*
7116 * The data to be signed is:
7117 *
7118 * string session-id
7119 *
7120 * followed by everything so far placed in the
7121 * outgoing packet.
7122 */
b672f405 7123 sigdata_len = s->pktout->length - 5 + 4 +
7124 ssh->v2_session_id_len;
edd0cb8a 7125 if (ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)
7126 sigdata_len -= 4;
92d60585 7127 sigdata = snewn(sigdata_len, unsigned char);
edd0cb8a 7128 p = 0;
7129 if (!(ssh->remote_bugs & BUG_SSH2_PK_SESSIONID)) {
7130 PUT_32BIT(sigdata+p, ssh->v2_session_id_len);
7131 p += 4;
7132 }
b672f405 7133 memcpy(sigdata+p, ssh->v2_session_id,
7134 ssh->v2_session_id_len);
7135 p += ssh->v2_session_id_len;
ff3187f6 7136 memcpy(sigdata+p, s->pktout->data + 5,
7137 s->pktout->length - 5);
edd0cb8a 7138 p += s->pktout->length - 5;
7139 assert(p == sigdata_len);
d8baa528 7140 sigblob = key->alg->sign(key->data, (char *)sigdata,
1dd353b5 7141 sigdata_len, &sigblob_len);
ff3187f6 7142 ssh2_add_sigblob(ssh, s->pktout, pkblob, pkblob_len,
1dd353b5 7143 sigblob, sigblob_len);
7144 sfree(pkblob);
7145 sfree(sigblob);
1408a877 7146 sfree(sigdata);
7147
ff3187f6 7148 ssh2_pkt_send(ssh, s->pktout);
51470298 7149 s->type = AUTH_TYPE_PUBLICKEY;
75374b2f 7150 key->alg->freekey(key->data);
1408a877 7151 }
edd0cb8a 7152
7153 } else if (s->can_keyb_inter && !s->kbd_inter_refused) {
7154
7155 /*
7156 * Keyboard-interactive authentication.
7157 */
7158 char *name, *inst, *lang;
7159 int name_len, inst_len, lang_len;
7160 int i;
7161
edd0cb8a 7162 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
7163
7164 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
7165 ssh->pkt_ctx |= SSH2_PKTCTX_KBDINTER;
7166
7167 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7168 ssh2_pkt_addstring(s->pktout, s->username);
7169 ssh2_pkt_addstring(s->pktout, "ssh-connection");
7170 /* service requested */
7171 ssh2_pkt_addstring(s->pktout, "keyboard-interactive");
7172 /* method */
7173 ssh2_pkt_addstring(s->pktout, ""); /* lang */
7174 ssh2_pkt_addstring(s->pktout, ""); /* submethods */
7175 ssh2_pkt_send(ssh, s->pktout);
7176
7177 crWaitUntilV(pktin);
7178 if (pktin->type != SSH2_MSG_USERAUTH_INFO_REQUEST) {
7179 /* Server is not willing to do keyboard-interactive
7180 * at all. Give up on it entirely. */
7181 s->gotit = TRUE;
7182 if (pktin->type == SSH2_MSG_USERAUTH_FAILURE)
7183 logevent("Keyboard-interactive authentication refused");
7184 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET;
7185 s->kbd_inter_refused = TRUE; /* don't try it again */
7186 continue;
7187 }
7188
7189 /*
7190 * We've got a fresh USERAUTH_INFO_REQUEST.
7191 * Get the preamble and start building a prompt.
7192 */
7193 ssh_pkt_getstring(pktin, &name, &name_len);
7194 ssh_pkt_getstring(pktin, &inst, &inst_len);
7195 ssh_pkt_getstring(pktin, &lang, &lang_len);
7196 s->cur_prompt = new_prompts(ssh->frontend);
7197 s->cur_prompt->to_server = TRUE;
7198 if (name_len) {
7199 /* FIXME: better prefix to distinguish from
7200 * local prompts? */
7201 s->cur_prompt->name = dupprintf("SSH server: %.*s",
7202 name_len, name);
7203 s->cur_prompt->name_reqd = TRUE;
7204 } else {
7205 s->cur_prompt->name = dupstr("SSH server authentication");
7206 s->cur_prompt->name_reqd = FALSE;
7207 }
7208 s->cur_prompt->instruction =
7209 dupprintf("Using keyboard-interactive authentication.%s%.*s",
7210 inst_len ? "\n" : "", inst_len, inst);
7211 s->cur_prompt->instr_reqd = TRUE;
7212
65a22376 7213 /*
edd0cb8a 7214 * Get the prompts from the packet.
7215 */
7216 s->num_prompts = ssh_pkt_getuint32(pktin);
7217 for (i = 0; i < s->num_prompts; i++) {
7218 char *prompt;
7219 int prompt_len;
7220 int echo;
7221 static char noprompt[] =
7222 "<server failed to send prompt>: ";
7223
7224 ssh_pkt_getstring(pktin, &prompt, &prompt_len);
7225 echo = ssh2_pkt_getbool(pktin);
7226 if (!prompt_len) {
7227 prompt = noprompt;
7228 prompt_len = lenof(noprompt)-1;
7229 }
7230 add_prompt(s->cur_prompt,
7231 dupprintf("%.*s", prompt_len, prompt),
7232 echo, SSH_MAX_PASSWORD_LEN);
7233 }
7234
7235 /*
7236 * Get the user's responses.
7237 */
7238 if (s->num_prompts) {
7239 int ret; /* not live over crReturn */
7240 ret = get_userpass_input(s->cur_prompt, NULL, 0);
7241 while (ret < 0) {
7242 ssh->send_ok = 1;
7243 crWaitUntilV(!pktin);
7244 ret = get_userpass_input(s->cur_prompt, in, inlen);
7245 ssh->send_ok = 0;
7246 }
7247 if (!ret) {
7248 /*
7249 * Failed to get responses. Terminate.
7250 */
7251 free_prompts(s->cur_prompt);
7252 ssh_disconnect(ssh, NULL, "Unable to authenticate",
7253 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
7254 TRUE);
7255 crStopV;
7256 }
7257 }
7258
7259 /*
7260 * Send the responses to the server.
7261 */
7262 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE);
7263 s->pktout->forcepad = 256;
7264 ssh2_pkt_adduint32(s->pktout, s->num_prompts);
7265 for (i=0; i < s->num_prompts; i++) {
7266 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
7267 ssh2_pkt_addstring(s->pktout,
7268 s->cur_prompt->prompts[i]->result);
7269 end_log_omission(ssh, s->pktout);
7270 }
7271 ssh2_pkt_send(ssh, s->pktout);
28f4d4f0 7272 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
edd0cb8a 7273
7274 } else if (s->can_passwd) {
7275
7276 /*
7277 * Plain old password authentication.
7278 */
7279 int ret; /* not live over crReturn */
7280
edd0cb8a 7281 ssh->pkt_ctx &= ~SSH2_PKTCTX_AUTH_MASK;
7282 ssh->pkt_ctx |= SSH2_PKTCTX_PASSWORD;
7283
7284 s->cur_prompt = new_prompts(ssh->frontend);
7285 s->cur_prompt->to_server = TRUE;
7286 s->cur_prompt->name = dupstr("SSH password");
7287 add_prompt(s->cur_prompt, dupprintf("%.90s@%.90s's password: ",
7288 s->username,
7289 ssh->savedhost),
7290 FALSE, SSH_MAX_PASSWORD_LEN);
7291
7292 ret = get_userpass_input(s->cur_prompt, NULL, 0);
7293 while (ret < 0) {
7294 ssh->send_ok = 1;
7295 crWaitUntilV(!pktin);
7296 ret = get_userpass_input(s->cur_prompt, in, inlen);
7297 ssh->send_ok = 0;
7298 }
7299 if (!ret) {
7300 /*
7301 * Failed to get responses. Terminate.
7302 */
7303 free_prompts(s->cur_prompt);
7304 ssh_disconnect(ssh, NULL, "Unable to authenticate",
7305 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
7306 TRUE);
7307 crStopV;
7308 }
7309
7310 /*
7311 * Send the password packet.
7312 *
95d2d262 7313 * We pad out the password packet to 256 bytes to make
7314 * it harder for an attacker to find the length of the
7315 * user's password.
1408a877 7316 *
95d2d262 7317 * Anyone using a password longer than 256 bytes
7318 * probably doesn't have much to worry about from
1408a877 7319 * people who find out how long their password is!
65a22376 7320 */
ff3187f6 7321 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
95d2d262 7322 s->pktout->forcepad = 256;
ff3187f6 7323 ssh2_pkt_addstring(s->pktout, s->username);
edd0cb8a 7324 ssh2_pkt_addstring(s->pktout, "ssh-connection");
7325 /* service requested */
ff3187f6 7326 ssh2_pkt_addstring(s->pktout, "password");
7327 ssh2_pkt_addbool(s->pktout, FALSE);
7328 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
edd0cb8a 7329 ssh2_pkt_addstring(s->pktout,
7330 s->cur_prompt->prompts[0]->result);
7331 free_prompts(s->cur_prompt);
ff3187f6 7332 end_log_omission(ssh, s->pktout);
95d2d262 7333 ssh2_pkt_send(ssh, s->pktout);
0d43337a 7334 logevent("Sent password");
28f4d4f0 7335 s->type = AUTH_TYPE_PASSWORD;
edd0cb8a 7336
1408a877 7337 } else {
edd0cb8a 7338
9e296bfa 7339 ssh_disconnect(ssh, NULL,
7340 "No supported authentication methods available",
7341 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
7342 FALSE);
7ffdbc1a 7343 crStopV;
edd0cb8a 7344
65a22376 7345 }
edd0cb8a 7346
65a22376 7347 }
a1a1fae4 7348 }
6bbce591 7349 ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
7cca0d81 7350
edd0cb8a 7351 /* Clear up various bits and pieces from authentication. */
7352 if (s->publickey_blob) {
7353 sfree(s->publickey_blob);
7354 sfree(s->publickey_comment);
7355 }
7356
7cca0d81 7357 /*
a1a1fae4 7358 * Now the connection protocol has started, one way or another.
7cca0d81 7359 */
7360
0ed48730 7361 ssh->channels = newtree234(ssh_channelcmp);
7362
7cca0d81 7363 /*
b09eaa88 7364 * Set up handlers for some connection protocol messages, so we
7365 * don't have to handle them repeatedly in this coroutine.
7366 */
7367 ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] =
7368 ssh2_msg_channel_window_adjust;
51df0ab5 7369 ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] =
7370 ssh2_msg_global_request;
b09eaa88 7371
7372 /*
0ed48730 7373 * Create the main session channel.
7cca0d81 7374 */
0ed48730 7375 if (!ssh->cfg.ssh_no_shell) {
7376 ssh->mainchan = snew(struct ssh_channel);
7377 ssh->mainchan->ssh = ssh;
7378 ssh->mainchan->localid = alloc_channel_id(ssh);
ff3187f6 7379 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
7380 ssh2_pkt_addstring(s->pktout, "session");
7381 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->localid);
0ed48730 7382 ssh->mainchan->v.v2.locwindow = OUR_V2_WINSIZE;
ff3187f6 7383 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->v.v2.locwindow);/* our window size */
954d5c5a 7384 ssh2_pkt_adduint32(s->pktout, OUR_V2_MAXPKT); /* our max pkt size */
ff3187f6 7385 ssh2_pkt_send(ssh, s->pktout);
7386 crWaitUntilV(pktin);
7387 if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
0ed48730 7388 bombout(("Server refused to open a session"));
7389 crStopV;
7390 /* FIXME: error data comes back in FAILURE packet */
7391 }
ff3187f6 7392 if (ssh_pkt_getuint32(pktin) != ssh->mainchan->localid) {
0ed48730 7393 bombout(("Server's channel confirmation cited wrong channel"));
7394 crStopV;
7395 }
ff3187f6 7396 ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
64d6ff88 7397 ssh->mainchan->halfopen = FALSE;
0ed48730 7398 ssh->mainchan->type = CHAN_MAINSESSION;
7399 ssh->mainchan->closes = 0;
ff3187f6 7400 ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
7401 ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
0ed48730 7402 bufchain_init(&ssh->mainchan->v.v2.outbuffer);
7403 add234(ssh->channels, ssh->mainchan);
62638676 7404 update_specials_menu(ssh->frontend);
0ed48730 7405 logevent("Opened channel for session");
7406 } else
7407 ssh->mainchan = NULL;
7cca0d81 7408
7409 /*
51df0ab5 7410 * Now we have a channel, make dispatch table entries for
7411 * general channel-based messages.
7412 */
7413 ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] =
7414 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] =
7415 ssh2_msg_channel_data;
7416 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_channel_eof;
7417 ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_channel_close;
7418 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] =
7419 ssh2_msg_channel_open_confirmation;
7420 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] =
7421 ssh2_msg_channel_open_failure;
7422 ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] =
7423 ssh2_msg_channel_request;
7424 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] =
7425 ssh2_msg_channel_open;
7426
7427 /*
783415f8 7428 * Potentially enable X11 forwarding.
7429 */
0ed48730 7430 if (ssh->mainchan && ssh->cfg.x11_forward) {
32874aea 7431 char proto[20], data[64];
7432 logevent("Requesting X11 forwarding");
302121de 7433 ssh->x11auth = x11_invent_auth(proto, sizeof(proto),
86916870 7434 data, sizeof(data), ssh->cfg.x11_auth);
7435 x11_get_real_auth(ssh->x11auth, ssh->cfg.x11_display);
ff3187f6 7436 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7437 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7438 ssh2_pkt_addstring(s->pktout, "x11-req");
7439 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7440 ssh2_pkt_addbool(s->pktout, 0); /* many connections */
7441 ssh2_pkt_addstring(s->pktout, proto);
f68353be 7442 /*
7443 * Note that while we blank the X authentication data here, we don't
7444 * take any special action to blank the start of an X11 channel,
7445 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
7446 * without having session blanking enabled is likely to leak your
7447 * cookie into the log.
7448 */
178c3872 7449 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
ff3187f6 7450 ssh2_pkt_addstring(s->pktout, data);
178c3872 7451 end_log_omission(ssh, s->pktout);
ff3187f6 7452 ssh2_pkt_adduint32(s->pktout, x11_get_screen_number(ssh->cfg.x11_display));
7453 ssh2_pkt_send(ssh, s->pktout);
32874aea 7454
b09eaa88 7455 crWaitUntilV(pktin);
32874aea 7456
ff3187f6 7457 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7458 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 7459 bombout(("Unexpected response to X11 forwarding request:"
ff3187f6 7460 " packet type %d", pktin->type));
7ffdbc1a 7461 crStopV;
32874aea 7462 }
7463 logevent("X11 forwarding refused");
7464 } else {
7465 logevent("X11 forwarding enabled");
51470298 7466 ssh->X11_fwd_enabled = TRUE;
32874aea 7467 }
783415f8 7468 }
7469
7470 /*
bc240b21 7471 * Enable port forwardings.
7472 */
06fadff5 7473 ssh_setup_portfwd(ssh, &ssh->cfg);
bc240b21 7474
7475 /*
36c2a3e9 7476 * Potentially enable agent forwarding.
7477 */
0ed48730 7478 if (ssh->mainchan && ssh->cfg.agentfwd && agent_exists()) {
32874aea 7479 logevent("Requesting OpenSSH-style agent forwarding");
ff3187f6 7480 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7481 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7482 ssh2_pkt_addstring(s->pktout, "auth-agent-req@openssh.com");
7483 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7484 ssh2_pkt_send(ssh, s->pktout);
32874aea 7485
b09eaa88 7486 crWaitUntilV(pktin);
32874aea 7487
ff3187f6 7488 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7489 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 7490 bombout(("Unexpected response to agent forwarding request:"
ff3187f6 7491 " packet type %d", pktin->type));
7ffdbc1a 7492 crStopV;
32874aea 7493 }
7494 logevent("Agent forwarding refused");
7495 } else {
7496 logevent("Agent forwarding enabled");
51470298 7497 ssh->agentfwd_enabled = TRUE;
32874aea 7498 }
36c2a3e9 7499 }
7500
7501 /*
7cca0d81 7502 * Now allocate a pty for the session.
7503 */
0ed48730 7504 if (ssh->mainchan && !ssh->cfg.nopty) {
a5dd8467 7505 /* Unpick the terminal-speed string. */
7506 /* XXX perhaps we should allow no speeds to be sent. */
db219738 7507 ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
7508 sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
a5dd8467 7509 /* Build the pty request. */
ff3187f6 7510 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7511 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
7512 ssh2_pkt_addstring(s->pktout, "pty-req");
7513 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7514 ssh2_pkt_addstring(s->pktout, ssh->cfg.termtype);
7515 ssh2_pkt_adduint32(s->pktout, ssh->term_width);
7516 ssh2_pkt_adduint32(s->pktout, ssh->term_height);
7517 ssh2_pkt_adduint32(s->pktout, 0); /* pixel width */
7518 ssh2_pkt_adduint32(s->pktout, 0); /* pixel height */
7519 ssh2_pkt_addstring_start(s->pktout);
c6ccd5c2 7520 parse_ttymodes(ssh, ssh->cfg.ttymodes,
7521 ssh2_send_ttymode, (void *)s->pktout);
7522 ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_ISPEED);
ff3187f6 7523 ssh2_pkt_adduint32(s->pktout, ssh->ispeed);
c6ccd5c2 7524 ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_OSPEED);
ff3187f6 7525 ssh2_pkt_adduint32(s->pktout, ssh->ospeed);
7526 ssh2_pkt_addstring_data(s->pktout, "\0", 1); /* TTY_OP_END */
7527 ssh2_pkt_send(ssh, s->pktout);
51470298 7528 ssh->state = SSH_STATE_INTERMED;
32874aea 7529
b09eaa88 7530 crWaitUntilV(pktin);
32874aea 7531
ff3187f6 7532 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7533 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 7534 bombout(("Unexpected response to pty request:"
ff3187f6 7535 " packet type %d", pktin->type));
7ffdbc1a 7536 crStopV;
32874aea 7537 }
51470298 7538 c_write_str(ssh, "Server refused to allocate pty\r\n");
7539 ssh->editing = ssh->echoing = 1;
32874aea 7540 } else {
a5dd8467 7541 logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
db219738 7542 ssh->ospeed, ssh->ispeed);
32874aea 7543 }
0965bee0 7544 } else {
51470298 7545 ssh->editing = ssh->echoing = 1;
7cca0d81 7546 }
7547
7548 /*
73feed4f 7549 * Send environment variables.
7550 *
7551 * Simplest thing here is to send all the requests at once, and
7552 * then wait for a whole bunch of successes or failures.
7553 */
7554 if (ssh->mainchan && *ssh->cfg.environmt) {
7555 char *e = ssh->cfg.environmt;
7556 char *var, *varend, *val;
7557
7558 s->num_env = 0;
7559
7560 while (*e) {
7561 var = e;
7562 while (*e && *e != '\t') e++;
7563 varend = e;
7564 if (*e == '\t') e++;
7565 val = e;
7566 while (*e) e++;
7567 e++;
7568
ff3187f6 7569 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7570 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
7571 ssh2_pkt_addstring(s->pktout, "env");
7572 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7573 ssh2_pkt_addstring_start(s->pktout);
7574 ssh2_pkt_addstring_data(s->pktout, var, varend-var);
7575 ssh2_pkt_addstring(s->pktout, val);
7576 ssh2_pkt_send(ssh, s->pktout);
73feed4f 7577
7578 s->num_env++;
7579 }
7580
7581 logeventf(ssh, "Sent %d environment variables", s->num_env);
7582
7583 s->env_ok = 0;
7584 s->env_left = s->num_env;
7585
7586 while (s->env_left > 0) {
b09eaa88 7587 crWaitUntilV(pktin);
73feed4f 7588
ff3187f6 7589 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7590 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
73feed4f 7591 bombout(("Unexpected response to environment request:"
ff3187f6 7592 " packet type %d", pktin->type));
73feed4f 7593 crStopV;
7594 }
7595 } else {
7596 s->env_ok++;
7597 }
7598
7599 s->env_left--;
7600 }
7601
7602 if (s->env_ok == s->num_env) {
7603 logevent("All environment variables successfully set");
7604 } else if (s->env_ok == 0) {
7605 logevent("All environment variables refused");
7606 c_write_str(ssh, "Server refused to set environment variables\r\n");
7607 } else {
7608 logeventf(ssh, "%d environment variables refused",
7609 s->num_env - s->env_ok);
7610 c_write_str(ssh, "Server refused to set all environment variables\r\n");
7611 }
7612 }
7613
7614 /*
fd5e5847 7615 * Start a shell or a remote command. We may have to attempt
7616 * this twice if the config data has provided a second choice
7617 * of command.
7cca0d81 7618 */
0ed48730 7619 if (ssh->mainchan) while (1) {
fd5e5847 7620 int subsys;
7621 char *cmd;
7622
51470298 7623 if (ssh->fallback_cmd) {
86916870 7624 subsys = ssh->cfg.ssh_subsys2;
7625 cmd = ssh->cfg.remote_cmd_ptr2;
fd5e5847 7626 } else {
86916870 7627 subsys = ssh->cfg.ssh_subsys;
7628 cmd = ssh->cfg.remote_cmd_ptr;
04c52f10 7629 if (!cmd) cmd = ssh->cfg.remote_cmd;
fd5e5847 7630 }
7631
ff3187f6 7632 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
7633 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
fd5e5847 7634 if (subsys) {
ff3187f6 7635 ssh2_pkt_addstring(s->pktout, "subsystem");
7636 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7637 ssh2_pkt_addstring(s->pktout, cmd);
fd5e5847 7638 } else if (*cmd) {
ff3187f6 7639 ssh2_pkt_addstring(s->pktout, "exec");
7640 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
7641 ssh2_pkt_addstring(s->pktout, cmd);
fd5e5847 7642 } else {
ff3187f6 7643 ssh2_pkt_addstring(s->pktout, "shell");
7644 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
32874aea 7645 }
ff3187f6 7646 ssh2_pkt_send(ssh, s->pktout);
b09eaa88 7647
7648 crWaitUntilV(pktin);
7649
ff3187f6 7650 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
7651 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 7652 bombout(("Unexpected response to shell/command request:"
ff3187f6 7653 " packet type %d", pktin->type));
7ffdbc1a 7654 crStopV;
fd5e5847 7655 }
7656 /*
7657 * We failed to start the command. If this is the
7658 * fallback command, we really are finished; if it's
7659 * not, and if the fallback command exists, try falling
7660 * back to it before complaining.
7661 */
86916870 7662 if (!ssh->fallback_cmd && ssh->cfg.remote_cmd_ptr2 != NULL) {
fd5e5847 7663 logevent("Primary command failed; attempting fallback");
51470298 7664 ssh->fallback_cmd = TRUE;
fd5e5847 7665 continue;
7666 }
6b5cf8b4 7667 bombout(("Server refused to start a shell/command"));
7ffdbc1a 7668 crStopV;
fd5e5847 7669 } else {
7670 logevent("Started a shell/command");
32874aea 7671 }
fd5e5847 7672 break;
7cca0d81 7673 }
7674
51470298 7675 ssh->state = SSH_STATE_SESSION;
7676 if (ssh->size_needed)
7677 ssh_size(ssh, ssh->term_width, ssh->term_height);
7678 if (ssh->eof_needed)
7679 ssh_special(ssh, TS_EOF);
6e48c3fe 7680
7cca0d81 7681 /*
7682 * Transfer data!
7683 */
b9d7bcad 7684 if (ssh->ldisc)
7685 ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
0ed48730 7686 if (ssh->mainchan)
7687 ssh->send_ok = 1;
7cca0d81 7688 while (1) {
e5574168 7689 crReturnV;
51470298 7690 s->try_send = FALSE;
ff3187f6 7691 if (pktin) {
2b7540a7 7692
51df0ab5 7693 /*
7694 * _All_ the connection-layer packets we expect to
7695 * receive are now handled by the dispatch table.
7696 * Anything that reaches here must be bogus.
7697 */
32874aea 7698
51df0ab5 7699 bombout(("Strange packet received: type %d", pktin->type));
7700 crStopV;
0ed48730 7701 } else if (ssh->mainchan) {
32874aea 7702 /*
7703 * We have spare data. Add it to the channel buffer.
7704 */
d8baa528 7705 ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
51470298 7706 s->try_send = TRUE;
32874aea 7707 }
51470298 7708 if (s->try_send) {
32874aea 7709 int i;
7710 struct ssh_channel *c;
7711 /*
7712 * Try to send data on all channels if we can.
7713 */
1bfc7e93 7714 for (i = 0; NULL != (c = index234(ssh->channels, i)); i++)
7715 ssh2_try_send_and_unthrottle(c);
7cca0d81 7716 }
e5574168 7717 }
7718
7719 crFinishV;
7720}
7721
7722/*
2e85c969 7723 * Handlers for SSH-2 messages that might arrive at any moment.
b09eaa88 7724 */
409bfa77 7725static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
b09eaa88 7726{
7727 /* log reason code in disconnect message */
7728 char *buf, *msg;
7729 int nowlen, reason, msglen;
7730
7731 reason = ssh_pkt_getuint32(pktin);
7732 ssh_pkt_getstring(pktin, &msg, &msglen);
7733
7734 if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
7735 buf = dupprintf("Received disconnect message (%s)",
7736 ssh2_disconnect_reasons[reason]);
7737 } else {
7738 buf = dupprintf("Received disconnect message (unknown"
7739 " type %d)", reason);
7740 }
7741 logevent(buf);
7742 sfree(buf);
7743 buf = dupprintf("Disconnection message text: %n%.*s",
7744 &nowlen, msglen, msg);
7745 logevent(buf);
7746 bombout(("Server sent disconnect message\ntype %d (%s):\n\"%s\"",
7747 reason,
7748 (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
7749 ssh2_disconnect_reasons[reason] : "unknown",
7750 buf+nowlen));
7751 sfree(buf);
7752}
7753
409bfa77 7754static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
b09eaa88 7755{
7756 /* log the debug message */
fb983202 7757 char *msg;
b09eaa88 7758 int msglen;
7759 int always_display;
7760
7761 /* XXX maybe we should actually take notice of this */
7762 always_display = ssh2_pkt_getbool(pktin);
7763 ssh_pkt_getstring(pktin, &msg, &msglen);
7764
fb983202 7765 logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
b09eaa88 7766}
7767
409bfa77 7768static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
b09eaa88 7769{
7770 struct Packet *pktout;
7771 pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
7772 ssh2_pkt_adduint32(pktout, pktin->sequence);
7773 /*
7774 * UNIMPLEMENTED messages MUST appear in the same order as the
7775 * messages they respond to. Hence, never queue them.
7776 */
7777 ssh2_pkt_send_noqueue(ssh, pktout);
7778}
7779
7780/*
2e85c969 7781 * Handle the top-level SSH-2 protocol.
7cca0d81 7782 */
b09eaa88 7783static void ssh2_protocol_setup(Ssh ssh)
7784{
7785 int i;
7786
7787 /*
7788 * Most messages cause SSH2_MSG_UNIMPLEMENTED.
7789 */
7790 for (i = 0; i < 256; i++)
7791 ssh->packet_dispatch[i] = ssh2_msg_something_unimplemented;
7792
7793 /*
7794 * Any message we actually understand, we set to NULL so that
7795 * the coroutines will get it.
7796 */
7797 ssh->packet_dispatch[SSH2_MSG_UNIMPLEMENTED] = NULL;
7798 ssh->packet_dispatch[SSH2_MSG_SERVICE_REQUEST] = NULL;
7799 ssh->packet_dispatch[SSH2_MSG_SERVICE_ACCEPT] = NULL;
7800 ssh->packet_dispatch[SSH2_MSG_KEXINIT] = NULL;
7801 ssh->packet_dispatch[SSH2_MSG_NEWKEYS] = NULL;
7802 ssh->packet_dispatch[SSH2_MSG_KEXDH_INIT] = NULL;
7803 ssh->packet_dispatch[SSH2_MSG_KEXDH_REPLY] = NULL;
7804 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = NULL; duplicate case value */
7805 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = NULL; duplicate case value */
7806 ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_INIT] = NULL;
7807 ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REPLY] = NULL;
7808 ssh->packet_dispatch[SSH2_MSG_USERAUTH_REQUEST] = NULL;
7809 ssh->packet_dispatch[SSH2_MSG_USERAUTH_FAILURE] = NULL;
7810 ssh->packet_dispatch[SSH2_MSG_USERAUTH_SUCCESS] = NULL;
7811 ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
7812 ssh->packet_dispatch[SSH2_MSG_USERAUTH_PK_OK] = NULL;
7813 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = NULL; duplicate case value */
7814 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = NULL; duplicate case value */
7815 ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_RESPONSE] = NULL;
7816 ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = NULL;
7817 ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = NULL;
7818 ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = NULL;
7819 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = NULL;
7820 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = NULL;
7821 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = NULL;
7822 ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = NULL;
7823 ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = NULL;
7824 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = NULL;
7825 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = NULL;
7826 ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = NULL;
7827 ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] = NULL;
7828 ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = NULL;
7829 ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = NULL;
7830
7831 /*
7832 * These special message types we install handlers for.
7833 */
7834 ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect;
2e85c969 7835 ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with SSH-1 */
b09eaa88 7836 ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug;
7837}
7838
9442dd57 7839static void ssh2_timer(void *ctx, long now)
7840{
7841 Ssh ssh = (Ssh)ctx;
7842
ecbb0000 7843 if (ssh->state == SSH_STATE_CLOSED)
7844 return;
7845
e6c1536e 7846 if (!ssh->kex_in_progress && ssh->cfg.ssh_rekey_time != 0 &&
9442dd57 7847 now - ssh->next_rekey >= 0) {
f382c87d 7848 do_ssh2_transport(ssh, "timeout", -1, NULL);
9442dd57 7849 }
7850}
7851
1c1a7262 7852static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
ff3187f6 7853 struct Packet *pktin)
7cca0d81 7854{
1c1a7262 7855 unsigned char *in = (unsigned char *)vin;
b09eaa88 7856 if (ssh->state == SSH_STATE_CLOSED)
7857 return;
7858
9442dd57 7859 if (pktin) {
7860 ssh->incoming_data_size += pktin->encrypted_len;
7861 if (!ssh->kex_in_progress &&
d57f70af 7862 ssh->max_data_size != 0 &&
7863 ssh->incoming_data_size > ssh->max_data_size)
f382c87d 7864 do_ssh2_transport(ssh, "too much data received", -1, NULL);
9442dd57 7865 }
7866
b09eaa88 7867 if (pktin && ssh->packet_dispatch[pktin->type]) {
7868 ssh->packet_dispatch[pktin->type](ssh, pktin);
32874aea 7869 return;
b09eaa88 7870 }
7871
7872 if (!ssh->protocol_initial_phase_done ||
7873 (pktin && pktin->type >= 20 && pktin->type < 50)) {
7874 if (do_ssh2_transport(ssh, in, inlen, pktin) &&
7875 !ssh->protocol_initial_phase_done) {
7876 ssh->protocol_initial_phase_done = TRUE;
7877 /*
7878 * Allow authconn to initialise itself.
7879 */
7880 do_ssh2_authconn(ssh, NULL, 0, NULL);
7881 }
7882 } else {
7883 do_ssh2_authconn(ssh, in, inlen, pktin);
7884 }
7cca0d81 7885}
7886
7887/*
8df7a775 7888 * Called to set up the connection.
374330e2 7889 *
7890 * Returns an error message, or NULL on success.
374330e2 7891 */
cbe2d68f 7892static const char *ssh_init(void *frontend_handle, void **backend_handle,
7893 Config *cfg,
79bf227b 7894 char *host, int port, char **realhost, int nodelay,
7895 int keepalive)
32874aea 7896{
cbe2d68f 7897 const char *p;
51470298 7898 Ssh ssh;
7899
3d88e64d 7900 ssh = snew(struct ssh_tag);
86916870 7901 ssh->cfg = *cfg; /* STRUCTURE COPY */
125105d1 7902 ssh->version = 0; /* when not ready yet */
51470298 7903 ssh->s = NULL;
7904 ssh->cipher = NULL;
371e569c 7905 ssh->v1_cipher_ctx = NULL;
0183b242 7906 ssh->crcda_ctx = NULL;
51470298 7907 ssh->cscipher = NULL;
371e569c 7908 ssh->cs_cipher_ctx = NULL;
51470298 7909 ssh->sccipher = NULL;
371e569c 7910 ssh->sc_cipher_ctx = NULL;
51470298 7911 ssh->csmac = NULL;
a8327734 7912 ssh->cs_mac_ctx = NULL;
51470298 7913 ssh->scmac = NULL;
e0e1a00d 7914 ssh->sc_mac_ctx = NULL;
51470298 7915 ssh->cscomp = NULL;
5366aed8 7916 ssh->cs_comp_ctx = NULL;
51470298 7917 ssh->sccomp = NULL;
5366aed8 7918 ssh->sc_comp_ctx = NULL;
51470298 7919 ssh->kex = NULL;
389aa499 7920 ssh->kex_ctx = NULL;
51470298 7921 ssh->hostkey = NULL;
7922 ssh->exitcode = -1;
ac934965 7923 ssh->close_expected = FALSE;
9e296bfa 7924 ssh->clean_exit = FALSE;
51470298 7925 ssh->state = SSH_STATE_PREPACKET;
7926 ssh->size_needed = FALSE;
7927 ssh->eof_needed = FALSE;
b9d7bcad 7928 ssh->ldisc = NULL;
a8327734 7929 ssh->logctx = NULL;
51470298 7930 ssh->deferred_send_data = NULL;
7931 ssh->deferred_len = 0;
7932 ssh->deferred_size = 0;
7933 ssh->fallback_cmd = 0;
7934 ssh->pkt_ctx = 0;
302121de 7935 ssh->x11auth = NULL;
be738459 7936 ssh->v1_compressing = FALSE;
51470298 7937 ssh->v2_outgoing_sequence = 0;
7938 ssh->ssh1_rdpkt_crstate = 0;
7939 ssh->ssh2_rdpkt_crstate = 0;
7940 ssh->do_ssh_init_crstate = 0;
7941 ssh->ssh_gotdata_crstate = 0;
b09eaa88 7942 ssh->do_ssh1_connection_crstate = 0;
51470298 7943 ssh->do_ssh1_login_crstate = 0;
7944 ssh->do_ssh2_transport_crstate = 0;
7945 ssh->do_ssh2_authconn_crstate = 0;
7946 ssh->do_ssh_init_state = NULL;
7947 ssh->do_ssh1_login_state = NULL;
7948 ssh->do_ssh2_transport_state = NULL;
7949 ssh->do_ssh2_authconn_state = NULL;
4320baf7 7950 ssh->v_c = NULL;
7951 ssh->v_s = NULL;
6571dbfd 7952 ssh->mainchan = NULL;
968d2d92 7953 ssh->throttled_all = 0;
7954 ssh->v1_stdout_throttling = 0;
590f6a5f 7955 ssh->queue = NULL;
7956 ssh->queuelen = ssh->queuesize = 0;
7957 ssh->queueing = FALSE;
06fadff5 7958 ssh->qhead = ssh->qtail = NULL;
e13bba36 7959 ssh->deferred_rekey_reason = NULL;
3d9449a1 7960 bufchain_init(&ssh->queued_incoming_data);
7961 ssh->frozen = FALSE;
51470298 7962
7963 *backend_handle = ssh;
32874aea 7964
8f203108 7965#ifdef MSCRYPTOAPI
32874aea 7966 if (crypto_startup() == 0)
8f203108 7967 return "Microsoft high encryption pack not installed!";
7968#endif
374330e2 7969
51470298 7970 ssh->frontend = frontend_handle;
86916870 7971 ssh->term_width = ssh->cfg.width;
7972 ssh->term_height = ssh->cfg.height;
887035a5 7973
fabd1805 7974 ssh->channels = NULL;
7975 ssh->rportfwds = NULL;
f47a5ffb 7976 ssh->portfwds = NULL;
fabd1805 7977
51470298 7978 ssh->send_ok = 0;
7979 ssh->editing = 0;
7980 ssh->echoing = 0;
7981 ssh->v1_throttle_count = 0;
7982 ssh->overall_bufsize = 0;
7983 ssh->fallback_cmd = 0;
8df7a775 7984
3648d4c5 7985 ssh->protocol = NULL;
7986
b09eaa88 7987 ssh->protocol_initial_phase_done = FALSE;
7988
39934deb 7989 ssh->pinger = NULL;
7990
9442dd57 7991 ssh->incoming_data_size = ssh->outgoing_data_size =
7992 ssh->deferred_data_size = 0L;
d57f70af 7993 ssh->max_data_size = parse_blocksize(ssh->cfg.ssh_rekey_data);
9442dd57 7994 ssh->kex_in_progress = FALSE;
7995
79bf227b 7996 p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
fb09bf1c 7997 if (p != NULL)
7998 return p;
374330e2 7999
5d17ccfc 8000 random_ref();
8001
374330e2 8002 return NULL;
8003}
8004
fabd1805 8005static void ssh_free(void *handle)
8006{
8007 Ssh ssh = (Ssh) handle;
8008 struct ssh_channel *c;
8009 struct ssh_rportfwd *pf;
8010
8011 if (ssh->v1_cipher_ctx)
8012 ssh->cipher->free_context(ssh->v1_cipher_ctx);
8013 if (ssh->cs_cipher_ctx)
8014 ssh->cscipher->free_context(ssh->cs_cipher_ctx);
8015 if (ssh->sc_cipher_ctx)
8016 ssh->sccipher->free_context(ssh->sc_cipher_ctx);
8017 if (ssh->cs_mac_ctx)
8018 ssh->csmac->free_context(ssh->cs_mac_ctx);
8019 if (ssh->sc_mac_ctx)
8020 ssh->scmac->free_context(ssh->sc_mac_ctx);
29b1d0b3 8021 if (ssh->cs_comp_ctx) {
8022 if (ssh->cscomp)
8023 ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
8024 else
8025 zlib_compress_cleanup(ssh->cs_comp_ctx);
8026 }
8027 if (ssh->sc_comp_ctx) {
8028 if (ssh->sccomp)
8029 ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
8030 else
8031 zlib_decompress_cleanup(ssh->sc_comp_ctx);
8032 }
fabd1805 8033 if (ssh->kex_ctx)
8034 dh_cleanup(ssh->kex_ctx);
8035 sfree(ssh->savedhost);
8036
590f6a5f 8037 while (ssh->queuelen-- > 0)
8038 ssh_free_packet(ssh->queue[ssh->queuelen]);
8039 sfree(ssh->queue);
8040
06fadff5 8041 while (ssh->qhead) {
8042 struct queued_handler *qh = ssh->qhead;
8043 ssh->qhead = qh->next;
8044 sfree(ssh->qhead);
8045 }
8046 ssh->qhead = ssh->qtail = NULL;
8047
fabd1805 8048 if (ssh->channels) {
8049 while ((c = delpos234(ssh->channels, 0)) != NULL) {
8050 switch (c->type) {
8051 case CHAN_X11:
8052 if (c->u.x11.s != NULL)
8053 x11_close(c->u.x11.s);
8054 break;
8055 case CHAN_SOCKDATA:
8056 if (c->u.pfd.s != NULL)
8057 pfd_close(c->u.pfd.s);
8058 break;
8059 }
8060 sfree(c);
8061 }
8062 freetree234(ssh->channels);
cdb52705 8063 ssh->channels = NULL;
fabd1805 8064 }
8065
8066 if (ssh->rportfwds) {
8067 while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
8068 sfree(pf);
8069 freetree234(ssh->rportfwds);
cdb52705 8070 ssh->rportfwds = NULL;
fabd1805 8071 }
8072 sfree(ssh->deferred_send_data);
8073 if (ssh->x11auth)
8074 x11_free_auth(ssh->x11auth);
8075 sfree(ssh->do_ssh_init_state);
8076 sfree(ssh->do_ssh1_login_state);
8077 sfree(ssh->do_ssh2_transport_state);
8078 sfree(ssh->do_ssh2_authconn_state);
4320baf7 8079 sfree(ssh->v_c);
8080 sfree(ssh->v_s);
679539d7 8081 if (ssh->crcda_ctx) {
8082 crcda_free_context(ssh->crcda_ctx);
8083 ssh->crcda_ctx = NULL;
8084 }
fabd1805 8085 if (ssh->s)
ac934965 8086 ssh_do_close(ssh, TRUE);
9442dd57 8087 expire_timer_context(ssh);
39934deb 8088 if (ssh->pinger)
8089 pinger_free(ssh->pinger);
3d9449a1 8090 bufchain_clear(&ssh->queued_incoming_data);
ee50e8b6 8091 sfree(ssh);
5d17ccfc 8092
8093 random_unref();
fabd1805 8094}
8095
374330e2 8096/*
86916870 8097 * Reconfigure the SSH backend.
86916870 8098 */
8099static void ssh_reconfig(void *handle, Config *cfg)
8100{
8101 Ssh ssh = (Ssh) handle;
e13bba36 8102 char *rekeying = NULL, rekey_mandatory = FALSE;
e6c1536e 8103 unsigned long old_max_data_size;
8104
39934deb 8105 pinger_reconfig(ssh->pinger, &ssh->cfg, cfg);
3b6606c7 8106 if (ssh->portfwds)
8107 ssh_setup_portfwd(ssh, cfg);
e6c1536e 8108
8109 if (ssh->cfg.ssh_rekey_time != cfg->ssh_rekey_time &&
8110 cfg->ssh_rekey_time != 0) {
8111 long new_next = ssh->last_rekey + cfg->ssh_rekey_time*60*TICKSPERSEC;
8112 long now = GETTICKCOUNT();
8113
8114 if (new_next - now < 0) {
f382c87d 8115 rekeying = "timeout shortened";
e6c1536e 8116 } else {
8117 ssh->next_rekey = schedule_timer(new_next - now, ssh2_timer, ssh);
8118 }
8119 }
8120
8121 old_max_data_size = ssh->max_data_size;
8122 ssh->max_data_size = parse_blocksize(cfg->ssh_rekey_data);
8123 if (old_max_data_size != ssh->max_data_size &&
8124 ssh->max_data_size != 0) {
8125 if (ssh->outgoing_data_size > ssh->max_data_size ||
8126 ssh->incoming_data_size > ssh->max_data_size)
f382c87d 8127 rekeying = "data limit lowered";
e6c1536e 8128 }
8129
e13bba36 8130 if (ssh->cfg.compression != cfg->compression) {
f382c87d 8131 rekeying = "compression setting changed";
e13bba36 8132 rekey_mandatory = TRUE;
8133 }
8134
8135 if (ssh->cfg.ssh2_des_cbc != cfg->ssh2_des_cbc ||
8136 memcmp(ssh->cfg.ssh_cipherlist, cfg->ssh_cipherlist,
8137 sizeof(ssh->cfg.ssh_cipherlist))) {
f382c87d 8138 rekeying = "cipher settings changed";
e13bba36 8139 rekey_mandatory = TRUE;
e6c1536e 8140 }
8141
86916870 8142 ssh->cfg = *cfg; /* STRUCTURE COPY */
e13bba36 8143
8144 if (rekeying) {
8145 if (!ssh->kex_in_progress) {
8146 do_ssh2_transport(ssh, rekeying, -1, NULL);
8147 } else if (rekey_mandatory) {
8148 ssh->deferred_rekey_reason = rekeying;
8149 }
8150 }
86916870 8151}
8152
8153/*
86dc445a 8154 * Called to send data down the SSH connection.
374330e2 8155 */
51470298 8156static int ssh_send(void *handle, char *buf, int len)
32874aea 8157{
51470298 8158 Ssh ssh = (Ssh) handle;
8159
8160 if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
5471d09a 8161 return 0;
374330e2 8162
d8baa528 8163 ssh->protocol(ssh, (unsigned char *)buf, len, 0);
5471d09a 8164
51470298 8165 return ssh_sendbuffer(ssh);
5471d09a 8166}
8167
8168/*
8169 * Called to query the current amount of buffered stdin data.
8170 */
51470298 8171static int ssh_sendbuffer(void *handle)
5471d09a 8172{
51470298 8173 Ssh ssh = (Ssh) handle;
5471d09a 8174 int override_value;
8175
51470298 8176 if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
5471d09a 8177 return 0;
8178
8179 /*
8180 * If the SSH socket itself has backed up, add the total backup
8181 * size on that to any individual buffer on the stdin channel.
8182 */
8183 override_value = 0;
51470298 8184 if (ssh->throttled_all)
8185 override_value = ssh->overall_bufsize;
5471d09a 8186
51470298 8187 if (ssh->version == 1) {
5471d09a 8188 return override_value;
51470298 8189 } else if (ssh->version == 2) {
8190 if (!ssh->mainchan || ssh->mainchan->closes > 0)
5471d09a 8191 return override_value;
8192 else
51470298 8193 return (override_value +
8194 bufchain_size(&ssh->mainchan->v.v2.outbuffer));
5471d09a 8195 }
8196
8197 return 0;
374330e2 8198}
8199
8200/*
6e48c3fe 8201 * Called to set the size of the window from SSH's POV.
374330e2 8202 */
51470298 8203static void ssh_size(void *handle, int width, int height)
32874aea 8204{
51470298 8205 Ssh ssh = (Ssh) handle;
ff3187f6 8206 struct Packet *pktout;
51470298 8207
8208 ssh->term_width = width;
8209 ssh->term_height = height;
f278d6f8 8210
51470298 8211 switch (ssh->state) {
374330e2 8212 case SSH_STATE_BEFORE_SIZE:
3687d221 8213 case SSH_STATE_PREPACKET:
21248260 8214 case SSH_STATE_CLOSED:
374330e2 8215 break; /* do nothing */
8216 case SSH_STATE_INTERMED:
51470298 8217 ssh->size_needed = TRUE; /* buffer for later */
374330e2 8218 break;
8219 case SSH_STATE_SESSION:
86916870 8220 if (!ssh->cfg.nopty) {
51470298 8221 if (ssh->version == 1) {
8222 send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
8223 PKT_INT, ssh->term_height,
8224 PKT_INT, ssh->term_width,
32874aea 8225 PKT_INT, 0, PKT_INT, 0, PKT_END);
0ed48730 8226 } else if (ssh->mainchan) {
ff3187f6 8227 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8228 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8229 ssh2_pkt_addstring(pktout, "window-change");
8230 ssh2_pkt_addbool(pktout, 0);
8231 ssh2_pkt_adduint32(pktout, ssh->term_width);
8232 ssh2_pkt_adduint32(pktout, ssh->term_height);
8233 ssh2_pkt_adduint32(pktout, 0);
8234 ssh2_pkt_adduint32(pktout, 0);
8235 ssh2_pkt_send(ssh, pktout);
32874aea 8236 }
8237 }
8238 break;
374330e2 8239 }
8240}
8241
8242/*
125105d1 8243 * Return a list of the special codes that make sense in this
8244 * protocol.
8245 */
8246static const struct telnet_special *ssh_get_specials(void *handle)
8247{
786ba75e 8248 static const struct telnet_special ssh1_ignore_special[] = {
8249 {"IGNORE message", TS_NOP}
8250 };
8251 static const struct telnet_special ssh2_transport_specials[] = {
62638676 8252 {"IGNORE message", TS_NOP},
9442dd57 8253 {"Repeat key exchange", TS_REKEY},
62638676 8254 };
8255 static const struct telnet_special ssh2_session_specials[] = {
6f2d0cde 8256 {NULL, TS_SEP},
8257 {"Break", TS_BRK},
786ba75e 8258 /* These are the signal names defined by draft-ietf-secsh-connect-23.
6f2d0cde 8259 * They include all the ISO C signals, but are a subset of the POSIX
8260 * required signals. */
8261 {"SIGINT (Interrupt)", TS_SIGINT},
8262 {"SIGTERM (Terminate)", TS_SIGTERM},
8263 {"SIGKILL (Kill)", TS_SIGKILL},
8264 {"SIGQUIT (Quit)", TS_SIGQUIT},
8265 {"SIGHUP (Hangup)", TS_SIGHUP},
8266 {"More signals", TS_SUBMENU},
8267 {"SIGABRT", TS_SIGABRT}, {"SIGALRM", TS_SIGALRM},
8268 {"SIGFPE", TS_SIGFPE}, {"SIGILL", TS_SIGILL},
8269 {"SIGPIPE", TS_SIGPIPE}, {"SIGSEGV", TS_SIGSEGV},
8270 {"SIGUSR1", TS_SIGUSR1}, {"SIGUSR2", TS_SIGUSR2},
8271 {NULL, TS_EXITMENU}
62638676 8272 };
8273 static const struct telnet_special specials_end[] = {
6f2d0cde 8274 {NULL, TS_EXITMENU}
62638676 8275 };
786ba75e 8276 /* XXX review this length for any changes: */
8277 static struct telnet_special ssh_specials[lenof(ssh2_transport_specials) +
62638676 8278 lenof(ssh2_session_specials) +
8279 lenof(specials_end)];
125105d1 8280 Ssh ssh = (Ssh) handle;
62638676 8281 int i = 0;
8282#define ADD_SPECIALS(name) \
8283 do { \
8284 assert((i + lenof(name)) <= lenof(ssh_specials)); \
8285 memcpy(&ssh_specials[i], name, sizeof name); \
8286 i += lenof(name); \
8287 } while(0)
125105d1 8288
8289 if (ssh->version == 1) {
62638676 8290 /* Don't bother offering IGNORE if we've decided the remote
8291 * won't cope with it, since we wouldn't bother sending it if
8292 * asked anyway. */
8293 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
786ba75e 8294 ADD_SPECIALS(ssh1_ignore_special);
125105d1 8295 } else if (ssh->version == 2) {
786ba75e 8296 ADD_SPECIALS(ssh2_transport_specials);
62638676 8297 if (ssh->mainchan)
8298 ADD_SPECIALS(ssh2_session_specials);
8299 } /* else we're not ready yet */
8300
8301 if (i) {
8302 ADD_SPECIALS(specials_end);
8303 return ssh_specials;
8304 } else {
125105d1 8305 return NULL;
62638676 8306 }
8307#undef ADD_SPECIALS
125105d1 8308}
8309
8310/*
86dc445a 8311 * Send special codes. TS_EOF is useful for `plink', so you
6abbf9e3 8312 * can send an EOF and collect resulting output (e.g. `plink
8313 * hostname sort').
374330e2 8314 */
51470298 8315static void ssh_special(void *handle, Telnet_Special code)
32874aea 8316{
51470298 8317 Ssh ssh = (Ssh) handle;
ff3187f6 8318 struct Packet *pktout;
51470298 8319
6abbf9e3 8320 if (code == TS_EOF) {
51470298 8321 if (ssh->state != SSH_STATE_SESSION) {
32874aea 8322 /*
8323 * Buffer the EOF in case we are pre-SESSION, so we can
8324 * send it as soon as we reach SESSION.
8325 */
8326 if (code == TS_EOF)
51470298 8327 ssh->eof_needed = TRUE;
32874aea 8328 return;
8329 }
51470298 8330 if (ssh->version == 1) {
8331 send_packet(ssh, SSH1_CMSG_EOF, PKT_END);
0ed48730 8332 } else if (ssh->mainchan) {
ff3187f6 8333 struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF);
8334 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8335 ssh2_pkt_send(ssh, pktout);
00a0b113 8336 ssh->send_ok = 0; /* now stop trying to read from stdin */
32874aea 8337 }
8338 logevent("Sent EOF message");
125105d1 8339 } else if (code == TS_PING || code == TS_NOP) {
51470298 8340 if (ssh->state == SSH_STATE_CLOSED
8341 || ssh->state == SSH_STATE_PREPACKET) return;
8342 if (ssh->version == 1) {
8343 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
8344 send_packet(ssh, SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
32874aea 8345 } else {
ff3187f6 8346 pktout = ssh2_pkt_init(SSH2_MSG_IGNORE);
8347 ssh2_pkt_addstring_start(pktout);
590f6a5f 8348 ssh2_pkt_send_noqueue(ssh, pktout);
32874aea 8349 }
9442dd57 8350 } else if (code == TS_REKEY) {
8351 if (!ssh->kex_in_progress && ssh->version == 2) {
f382c87d 8352 do_ssh2_transport(ssh, "at user request", -1, NULL);
9442dd57 8353 }
125105d1 8354 } else if (code == TS_BRK) {
8355 if (ssh->state == SSH_STATE_CLOSED
8356 || ssh->state == SSH_STATE_PREPACKET) return;
8357 if (ssh->version == 1) {
2e85c969 8358 logevent("Unable to send BREAK signal in SSH-1");
0ed48730 8359 } else if (ssh->mainchan) {
ff3187f6 8360 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8361 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8362 ssh2_pkt_addstring(pktout, "break");
8363 ssh2_pkt_addbool(pktout, 0);
8364 ssh2_pkt_adduint32(pktout, 0); /* default break length */
8365 ssh2_pkt_send(ssh, pktout);
125105d1 8366 }
6abbf9e3 8367 } else {
6f2d0cde 8368 /* Is is a POSIX signal? */
8369 char *signame = NULL;
8370 if (code == TS_SIGABRT) signame = "ABRT";
8371 if (code == TS_SIGALRM) signame = "ALRM";
8372 if (code == TS_SIGFPE) signame = "FPE";
8373 if (code == TS_SIGHUP) signame = "HUP";
8374 if (code == TS_SIGILL) signame = "ILL";
8375 if (code == TS_SIGINT) signame = "INT";
8376 if (code == TS_SIGKILL) signame = "KILL";
8377 if (code == TS_SIGPIPE) signame = "PIPE";
8378 if (code == TS_SIGQUIT) signame = "QUIT";
8379 if (code == TS_SIGSEGV) signame = "SEGV";
8380 if (code == TS_SIGTERM) signame = "TERM";
8381 if (code == TS_SIGUSR1) signame = "USR1";
8382 if (code == TS_SIGUSR2) signame = "USR2";
8383 /* The SSH-2 protocol does in principle support arbitrary named
8384 * signals, including signame@domain, but we don't support those. */
8385 if (signame) {
8386 /* It's a signal. */
8387 if (ssh->version == 2 && ssh->mainchan) {
ff3187f6 8388 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8389 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
8390 ssh2_pkt_addstring(pktout, "signal");
8391 ssh2_pkt_addbool(pktout, 0);
8392 ssh2_pkt_addstring(pktout, signame);
8393 ssh2_pkt_send(ssh, pktout);
6f2d0cde 8394 logeventf(ssh, "Sent signal SIG%s", signame);
8395 }
8396 } else {
8397 /* Never heard of it. Do nothing */
8398 }
6abbf9e3 8399 }
374330e2 8400}
8401
51470298 8402void *new_sock_channel(void *handle, Socket s)
d74d141c 8403{
51470298 8404 Ssh ssh = (Ssh) handle;
d74d141c 8405 struct ssh_channel *c;
3d88e64d 8406 c = snew(struct ssh_channel);
51470298 8407 c->ssh = ssh;
d74d141c 8408
8409 if (c) {
64d6ff88 8410 c->halfopen = TRUE;
51470298 8411 c->localid = alloc_channel_id(ssh);
d74d141c 8412 c->closes = 0;
bc240b21 8413 c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */
d74d141c 8414 c->u.pfd.s = s;
013dd8c0 8415 bufchain_init(&c->v.v2.outbuffer);
51470298 8416 add234(ssh->channels, c);
d74d141c 8417 }
8418 return c;
8419}
8420
5471d09a 8421/*
8422 * This is called when stdout/stderr (the entity to which
8423 * from_backend sends data) manages to clear some backlog.
8424 */
ae9ae89f 8425static void ssh_unthrottle(void *handle, int bufsize)
5471d09a 8426{
51470298 8427 Ssh ssh = (Ssh) handle;
8428 if (ssh->version == 1) {
8429 if (ssh->v1_stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
8430 ssh->v1_stdout_throttling = 0;
8431 ssh1_throttle(ssh, -1);
5471d09a 8432 }
8433 } else {
51470298 8434 if (ssh->mainchan && ssh->mainchan->closes == 0)
8435 ssh2_set_window(ssh->mainchan, OUR_V2_WINSIZE - bufsize);
5471d09a 8436 }
8437}
8438
6b78788a 8439void ssh_send_port_open(void *channel, char *hostname, int port, char *org)
d74d141c 8440{
8441 struct ssh_channel *c = (struct ssh_channel *)channel;
6b78788a 8442 Ssh ssh = c->ssh;
ff3187f6 8443 struct Packet *pktout;
d74d141c 8444
57356d63 8445 logeventf(ssh, "Opening forwarded connection to %s:%d", hostname, port);
d74d141c 8446
51470298 8447 if (ssh->version == 1) {
8448 send_packet(ssh, SSH1_MSG_PORT_OPEN,
bc240b21 8449 PKT_INT, c->localid,
8450 PKT_STR, hostname,
8451 PKT_INT, port,
31fb1866 8452 /* PKT_STR, <org:orgport>, */
bc240b21 8453 PKT_END);
8454 } else {
ff3187f6 8455 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
8456 ssh2_pkt_addstring(pktout, "direct-tcpip");
8457 ssh2_pkt_adduint32(pktout, c->localid);
5471d09a 8458 c->v.v2.locwindow = OUR_V2_WINSIZE;
ff3187f6 8459 ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);/* our window size */
954d5c5a 8460 ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */
ff3187f6 8461 ssh2_pkt_addstring(pktout, hostname);
8462 ssh2_pkt_adduint32(pktout, port);
bc240b21 8463 /*
8464 * We make up values for the originator data; partly it's
8465 * too much hassle to keep track, and partly I'm not
8466 * convinced the server should be told details like that
8467 * about my local network configuration.
8468 */
ff3187f6 8469 ssh2_pkt_addstring(pktout, "client-side-connection");
8470 ssh2_pkt_adduint32(pktout, 0);
8471 ssh2_pkt_send(ssh, pktout);
bc240b21 8472 }
d74d141c 8473}
8474
51470298 8475static Socket ssh_socket(void *handle)
32874aea 8476{
51470298 8477 Ssh ssh = (Ssh) handle;
8478 return ssh->s;
32874aea 8479}
8ccc75b0 8480
51470298 8481static int ssh_sendok(void *handle)
32874aea 8482{
51470298 8483 Ssh ssh = (Ssh) handle;
8484 return ssh->send_ok;
32874aea 8485}
fb09bf1c 8486
51470298 8487static int ssh_ldisc(void *handle, int option)
32874aea 8488{
51470298 8489 Ssh ssh = (Ssh) handle;
32874aea 8490 if (option == LD_ECHO)
51470298 8491 return ssh->echoing;
32874aea 8492 if (option == LD_EDIT)
51470298 8493 return ssh->editing;
0965bee0 8494 return FALSE;
8495}
8496
b9d7bcad 8497static void ssh_provide_ldisc(void *handle, void *ldisc)
8498{
8499 Ssh ssh = (Ssh) handle;
8500 ssh->ldisc = ldisc;
8501}
8502
a8327734 8503static void ssh_provide_logctx(void *handle, void *logctx)
8504{
8505 Ssh ssh = (Ssh) handle;
8506 ssh->logctx = logctx;
8507}
8508
51470298 8509static int ssh_return_exitcode(void *handle)
8510{
8511 Ssh ssh = (Ssh) handle;
3bb2f322 8512 if (ssh->s != NULL)
8513 return -1;
8514 else
8515 return (ssh->exitcode >= 0 ? ssh->exitcode : 0);
51470298 8516}
8517
8518/*
f89c3294 8519 * cfg_info for SSH is the currently running version of the
8520 * protocol. (1 for 1; 2 for 2; 0 for not-decided-yet.)
8521 */
8522static int ssh_cfg_info(void *handle)
8523{
8524 Ssh ssh = (Ssh) handle;
8525 return ssh->version;
8526}
8527
8528/*
51470298 8529 * Gross hack: pscp will try to start SFTP but fall back to scp1 if
8530 * that fails. This variable is the means by which scp.c can reach
8531 * into the SSH code and find out which one it got.
8532 */
8533extern int ssh_fallback_cmd(void *handle)
d8d6c7e5 8534{
51470298 8535 Ssh ssh = (Ssh) handle;
8536 return ssh->fallback_cmd;
d8d6c7e5 8537}
8538
374330e2 8539Backend ssh_backend = {
8540 ssh_init,
fabd1805 8541 ssh_free,
86916870 8542 ssh_reconfig,
374330e2 8543 ssh_send,
5471d09a 8544 ssh_sendbuffer,
374330e2 8545 ssh_size,
4017be6d 8546 ssh_special,
125105d1 8547 ssh_get_specials,
8ccc75b0 8548 ssh_socket,
d8d6c7e5 8549 ssh_return_exitcode,
97db3be4 8550 ssh_sendok,
0965bee0 8551 ssh_ldisc,
b9d7bcad 8552 ssh_provide_ldisc,
a8327734 8553 ssh_provide_logctx,
5471d09a 8554 ssh_unthrottle,
f89c3294 8555 ssh_cfg_info,
97db3be4 8556 22
bc240b21 8557};
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator