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