projects / u / mdw / putty / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Treat lines starting with '#' as comments in PSFTP.
[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
7808 int micoffset;
7809 Ssh_gss_buf mic;
7810 s->type = AUTH_TYPE_GSSAPI;
7811 s->tried_gssapi = TRUE;
7812 s->gotit = TRUE;
7813 ssh->pkt_actx = SSH2_PKTCTX_GSSAPI;
7814
7815 /* Sending USERAUTH_REQUEST with "gssapi-with-mic" method */
7816 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7817 ssh2_pkt_addstring(s->pktout, s->username);
7818 ssh2_pkt_addstring(s->pktout, "ssh-connection");
7819 ssh2_pkt_addstring(s->pktout, "gssapi-with-mic");
7820
7821 /* add mechanism info */
7822 ssh_gss_indicate_mech(&s->gss_buf);
7823
7824 /* number of GSSAPI mechanisms */
7825 ssh2_pkt_adduint32(s->pktout,1);
7826
7827 /* length of OID + 2 */
7828 ssh2_pkt_adduint32(s->pktout, s->gss_buf.len + 2);
7829 ssh2_pkt_addbyte(s->pktout, SSH2_GSS_OIDTYPE);
7830
7831 /* length of OID */
7832 ssh2_pkt_addbyte(s->pktout, (unsigned char) s->gss_buf.len);
7833
7834 ssh_pkt_adddata(s->pktout, s->gss_buf.data, s->gss_buf.len);
7835 ssh2_pkt_send(ssh, s->pktout);
7836 crWaitUntilV(pktin);
7837 if (pktin->type != SSH2_MSG_USERAUTH_GSSAPI_RESPONSE) {
7838 logevent("GSSAPI authentication request refused");
7839 continue;
7840 }
7841
7842 /* check returned packet ... */
7843
7844 ssh_pkt_getstring(pktin,&s->gss_rcvtok.data,&s->gss_rcvtok.len);
7845 if (s->gss_rcvtok.len != s->gss_buf.len + 2 ||
7846 s->gss_rcvtok.data[0] != SSH2_GSS_OIDTYPE ||
7847 s->gss_rcvtok.data[1] != s->gss_buf.len ||
7848 memcmp(s->gss_rcvtok.data+2,s->gss_buf.data,s->gss_buf.len) ) {
7849 logevent("GSSAPI authentication - wrong response from server");
7850 continue;
7851 }
7852
7853 /* now start running */
7854 s->gss_stat = ssh_gss_import_name(ssh->fullhostname,
7855 &s->gss_srv_name);
7856 if (s->gss_stat != SSH_GSS_OK) {
7857 if (s->gss_stat == SSH_GSS_BAD_HOST_NAME)
7858 logevent("GSSAPI import name failed - Bad service name");
7859 else
7860 logevent("GSSAPI import name failed");
7861 continue;
7862 }
7863
7864 /* fetch TGT into GSS engine */
7865 s->gss_stat = ssh_gss_acquire_cred(&s->gss_ctx);
7866
7867 if (s->gss_stat != SSH_GSS_OK) {
7868 logevent("GSSAPI authentication failed to get credentials");
7869 ssh_gss_release_name(&s->gss_srv_name);
7870 continue;
7871 }
7872
7873 /* initial tokens are empty */
7874 s->gss_rcvtok.len = s->gss_sndtok.len = 0;
7875 s->gss_rcvtok.data = s->gss_sndtok.data = NULL;
7876
7877 /* now enter the loop */
7878 do {
7879 s->gss_stat = ssh_gss_init_sec_context(&s->gss_ctx,
7880 s->gss_srv_name,
7881 ssh->cfg.gssapifwd,
7882 &s->gss_rcvtok,
7883 &s->gss_sndtok);
7884
7885 if (s->gss_stat!=SSH_GSS_S_COMPLETE &&
7886 s->gss_stat!=SSH_GSS_S_CONTINUE_NEEDED) {
7887 logevent("GSSAPI authentication initialisation failed");
7888
7889 if (ssh_gss_display_status(s->gss_ctx,&s->gss_buf) == SSH_GSS_OK) {
7890 logevent(s->gss_buf.data);
7891 sfree(s->gss_buf.data);
7892 }
7893
7894 break;
7895 }
7896 logevent("GSSAPI authentication initialised");
7897
7898 /* Client and server now exchange tokens until GSSAPI
7899 * no longer says CONTINUE_NEEDED */
7900
7901 if (s->gss_sndtok.len != 0) {
7902 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
7903 ssh_pkt_addstring_start(s->pktout);
7904 ssh_pkt_addstring_data(s->pktout,s->gss_sndtok.data,s->gss_sndtok.len);
7905 ssh2_pkt_send(ssh, s->pktout);
7906 ssh_gss_free_tok(&s->gss_sndtok);
7907 }
7908
7909 if (s->gss_stat == SSH_GSS_S_CONTINUE_NEEDED) {
7910 crWaitUntilV(pktin);
7911 if (pktin->type != SSH2_MSG_USERAUTH_GSSAPI_TOKEN) {
7912 logevent("GSSAPI authentication - bad server response");
7913 s->gss_stat = SSH_GSS_FAILURE;
7914 break;
7915 }
7916 ssh_pkt_getstring(pktin,&s->gss_rcvtok.data,&s->gss_rcvtok.len);
7917 }
7918 } while (s-> gss_stat == SSH_GSS_S_CONTINUE_NEEDED);
7919
7920 if (s->gss_stat != SSH_GSS_OK) {
7921 ssh_gss_release_name(&s->gss_srv_name);
7922 ssh_gss_release_cred(&s->gss_ctx);
7923 continue;
7924 }
7925 logevent("GSSAPI authentication loop finished OK");
7926
7927 /* Now send the MIC */
7928
7929 s->pktout = ssh2_pkt_init(0);
7930 micoffset = s->pktout->length;
7931 ssh_pkt_addstring_start(s->pktout);
7932 ssh_pkt_addstring_data(s->pktout, (char *)ssh->v2_session_id, ssh->v2_session_id_len);
7933 ssh_pkt_addbyte(s->pktout, SSH2_MSG_USERAUTH_REQUEST);
7934 ssh_pkt_addstring(s->pktout, s->username);
7935 ssh_pkt_addstring(s->pktout, "ssh-connection");
7936 ssh_pkt_addstring(s->pktout, "gssapi-with-mic");
7937
7938 s->gss_buf.data = (char *)s->pktout->data + micoffset;
7939 s->gss_buf.len = s->pktout->length - micoffset;
7940
7941 ssh_gss_get_mic(s->gss_ctx, &s->gss_buf, &mic);
7942 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_MIC);
7943 ssh_pkt_addstring_start(s->pktout);
7944 ssh_pkt_addstring_data(s->pktout, mic.data, mic.len);
7945 ssh2_pkt_send(ssh, s->pktout);
7946 ssh_gss_free_mic(&mic);
7947
7948 s->gotit = FALSE;
7949
7950 ssh_gss_release_name(&s->gss_srv_name);
7951 ssh_gss_release_cred(&s->gss_ctx);
7952 continue;
7953#endif
edd0cb8a 7954 } else if (s->can_keyb_inter && !s->kbd_inter_refused) {
7955
7956 /*
7957 * Keyboard-interactive authentication.
7958 */
edd0cb8a 7959
edd0cb8a 7960 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE;
7961
acab36bc 7962 ssh->pkt_actx = SSH2_PKTCTX_KBDINTER;
edd0cb8a 7963
7964 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
7965 ssh2_pkt_addstring(s->pktout, s->username);
7966 ssh2_pkt_addstring(s->pktout, "ssh-connection");
7967 /* service requested */
7968 ssh2_pkt_addstring(s->pktout, "keyboard-interactive");
7969 /* method */
7970 ssh2_pkt_addstring(s->pktout, ""); /* lang */
7971 ssh2_pkt_addstring(s->pktout, ""); /* submethods */
7972 ssh2_pkt_send(ssh, s->pktout);
7973
7974 crWaitUntilV(pktin);
7975 if (pktin->type != SSH2_MSG_USERAUTH_INFO_REQUEST) {
7976 /* Server is not willing to do keyboard-interactive
b8e3173d 7977 * at all (or, bizarrely but legally, accepts the
7978 * user without actually issuing any prompts).
7979 * Give up on it entirely. */
edd0cb8a 7980 s->gotit = TRUE;
7981 if (pktin->type == SSH2_MSG_USERAUTH_FAILURE)
7982 logevent("Keyboard-interactive authentication refused");
7983 s->type = AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET;
7984 s->kbd_inter_refused = TRUE; /* don't try it again */
7985 continue;
7986 }
7987
7988 /*
b8e3173d 7989 * Loop while the server continues to send INFO_REQUESTs.
edd0cb8a 7990 */
b8e3173d 7991 while (pktin->type == SSH2_MSG_USERAUTH_INFO_REQUEST) {
edd0cb8a 7992
b8e3173d 7993 char *name, *inst, *lang;
7994 int name_len, inst_len, lang_len;
7995 int i;
7996
7997 /*
7998 * We've got a fresh USERAUTH_INFO_REQUEST.
7999 * Get the preamble and start building a prompt.
8000 */
8001 ssh_pkt_getstring(pktin, &name, &name_len);
8002 ssh_pkt_getstring(pktin, &inst, &inst_len);
8003 ssh_pkt_getstring(pktin, &lang, &lang_len);
8004 s->cur_prompt = new_prompts(ssh->frontend);
8005 s->cur_prompt->to_server = TRUE;
8006 if (name_len) {
8007 /* FIXME: better prefix to distinguish from
8008 * local prompts? */
8009 s->cur_prompt->name =
8010 dupprintf("SSH server: %.*s", name_len, name);
8011 s->cur_prompt->name_reqd = TRUE;
8012 } else {
8013 s->cur_prompt->name =
8014 dupstr("SSH server authentication");
8015 s->cur_prompt->name_reqd = FALSE;
edd0cb8a 8016 }
b8e3173d 8017 /* FIXME: ugly to print "Using..." in prompt _every_
8018 * time round. Can this be done more subtly? */
8019 s->cur_prompt->instruction =
8020 dupprintf("Using keyboard-interactive authentication.%s%.*s",
8021 inst_len ? "\n" : "", inst_len, inst);
8022 s->cur_prompt->instr_reqd = TRUE;
edd0cb8a 8023
b8e3173d 8024 /*
9ea10e78 8025 * Get any prompt(s) from the packet.
b8e3173d 8026 */
8027 s->num_prompts = ssh_pkt_getuint32(pktin);
8028 for (i = 0; i < s->num_prompts; i++) {
8029 char *prompt;
8030 int prompt_len;
8031 int echo;
8032 static char noprompt[] =
8033 "<server failed to send prompt>: ";
8034
8035 ssh_pkt_getstring(pktin, &prompt, &prompt_len);
8036 echo = ssh2_pkt_getbool(pktin);
8037 if (!prompt_len) {
8038 prompt = noprompt;
8039 prompt_len = lenof(noprompt)-1;
8040 }
8041 add_prompt(s->cur_prompt,
8042 dupprintf("%.*s", prompt_len, prompt),
8043 echo, SSH_MAX_PASSWORD_LEN);
edd0cb8a 8044 }
b8e3173d 8045
8046 /*
9ea10e78 8047 * Display any instructions, and get the user's
8048 * response(s).
b8e3173d 8049 */
9ea10e78 8050 {
b8e3173d 8051 int ret; /* not live over crReturn */
8052 ret = get_userpass_input(s->cur_prompt, NULL, 0);
8053 while (ret < 0) {
8054 ssh->send_ok = 1;
8055 crWaitUntilV(!pktin);
8056 ret = get_userpass_input(s->cur_prompt, in, inlen);
8057 ssh->send_ok = 0;
8058 }
8059 if (!ret) {
8060 /*
8061 * Failed to get responses. Terminate.
8062 */
8063 free_prompts(s->cur_prompt);
8064 ssh_disconnect(ssh, NULL, "Unable to authenticate",
8065 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
8066 TRUE);
8067 crStopV;
8068 }
edd0cb8a 8069 }
b8e3173d 8070
8071 /*
9ea10e78 8072 * Send the response(s) to the server.
b8e3173d 8073 */
8074 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE);
b8e3173d 8075 ssh2_pkt_adduint32(s->pktout, s->num_prompts);
8076 for (i=0; i < s->num_prompts; i++) {
8077 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
8078 ssh2_pkt_addstring(s->pktout,
8079 s->cur_prompt->prompts[i]->result);
8080 end_log_omission(ssh, s->pktout);
8081 }
18524056 8082 ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
b8e3173d 8083
8084 /*
8085 * Get the next packet in case it's another
8086 * INFO_REQUEST.
8087 */
8088 crWaitUntilV(pktin);
8089
edd0cb8a 8090 }
8091
8092 /*
b8e3173d 8093 * We should have SUCCESS or FAILURE now.
edd0cb8a 8094 */
b8e3173d 8095 s->gotit = TRUE;
edd0cb8a 8096
8097 } else if (s->can_passwd) {
8098
8099 /*
8100 * Plain old password authentication.
8101 */
8102 int ret; /* not live over crReturn */
e955d348 8103 int changereq_first_time; /* not live over crReturn */
edd0cb8a 8104
acab36bc 8105 ssh->pkt_actx = SSH2_PKTCTX_PASSWORD;
edd0cb8a 8106
8107 s->cur_prompt = new_prompts(ssh->frontend);
8108 s->cur_prompt->to_server = TRUE;
8109 s->cur_prompt->name = dupstr("SSH password");
8110 add_prompt(s->cur_prompt, dupprintf("%.90s@%.90s's password: ",
8111 s->username,
8112 ssh->savedhost),
8113 FALSE, SSH_MAX_PASSWORD_LEN);
8114
8115 ret = get_userpass_input(s->cur_prompt, NULL, 0);
8116 while (ret < 0) {
8117 ssh->send_ok = 1;
8118 crWaitUntilV(!pktin);
8119 ret = get_userpass_input(s->cur_prompt, in, inlen);
8120 ssh->send_ok = 0;
8121 }
8122 if (!ret) {
8123 /*
8124 * Failed to get responses. Terminate.
8125 */
8126 free_prompts(s->cur_prompt);
8127 ssh_disconnect(ssh, NULL, "Unable to authenticate",
8128 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
8129 TRUE);
8130 crStopV;
8131 }
e955d348 8132 /*
8133 * Squirrel away the password. (We may need it later if
8134 * asked to change it.)
8135 */
8136 s->password = dupstr(s->cur_prompt->prompts[0]->result);
8137 free_prompts(s->cur_prompt);
edd0cb8a 8138
8139 /*
8140 * Send the password packet.
8141 *
95d2d262 8142 * We pad out the password packet to 256 bytes to make
8143 * it harder for an attacker to find the length of the
8144 * user's password.
1408a877 8145 *
95d2d262 8146 * Anyone using a password longer than 256 bytes
8147 * probably doesn't have much to worry about from
1408a877 8148 * people who find out how long their password is!
65a22376 8149 */
ff3187f6 8150 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
8151 ssh2_pkt_addstring(s->pktout, s->username);
edd0cb8a 8152 ssh2_pkt_addstring(s->pktout, "ssh-connection");
8153 /* service requested */
ff3187f6 8154 ssh2_pkt_addstring(s->pktout, "password");
8155 ssh2_pkt_addbool(s->pktout, FALSE);
8156 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
e955d348 8157 ssh2_pkt_addstring(s->pktout, s->password);
ff3187f6 8158 end_log_omission(ssh, s->pktout);
18524056 8159 ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
0d43337a 8160 logevent("Sent password");
28f4d4f0 8161 s->type = AUTH_TYPE_PASSWORD;
edd0cb8a 8162
e955d348 8163 /*
8164 * Wait for next packet, in case it's a password change
8165 * request.
8166 */
8167 crWaitUntilV(pktin);
8168 changereq_first_time = TRUE;
8169
8170 while (pktin->type == SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ) {
8171
8172 /*
8173 * We're being asked for a new password
8174 * (perhaps not for the first time).
8175 * Loop until the server accepts it.
8176 */
8177
8178 int got_new = FALSE; /* not live over crReturn */
8179 char *prompt; /* not live over crReturn */
8180 int prompt_len; /* not live over crReturn */
8181
8182 {
8183 char *msg;
8184 if (changereq_first_time)
8185 msg = "Server requested password change";
8186 else
8187 msg = "Server rejected new password";
8188 logevent(msg);
8189 c_write_str(ssh, msg);
8190 c_write_str(ssh, "\r\n");
8191 }
8192
8193 ssh_pkt_getstring(pktin, &prompt, &prompt_len);
8194
8195 s->cur_prompt = new_prompts(ssh->frontend);
8196 s->cur_prompt->to_server = TRUE;
8197 s->cur_prompt->name = dupstr("New SSH password");
8198 s->cur_prompt->instruction =
8199 dupprintf("%.*s", prompt_len, prompt);
8200 s->cur_prompt->instr_reqd = TRUE;
d9add7bc 8201 /*
8202 * There's no explicit requirement in the protocol
8203 * for the "old" passwords in the original and
8204 * password-change messages to be the same, and
8205 * apparently some Cisco kit supports password change
8206 * by the user entering a blank password originally
8207 * and the real password subsequently, so,
8208 * reluctantly, we prompt for the old password again.
8209 *
8210 * (On the other hand, some servers don't even bother
8211 * to check this field.)
8212 */
8213 add_prompt(s->cur_prompt,
8214 dupstr("Current password (blank for previously entered password): "),
8215 FALSE, SSH_MAX_PASSWORD_LEN);
e955d348 8216 add_prompt(s->cur_prompt, dupstr("Enter new password: "),
8217 FALSE, SSH_MAX_PASSWORD_LEN);
8218 add_prompt(s->cur_prompt, dupstr("Confirm new password: "),
8219 FALSE, SSH_MAX_PASSWORD_LEN);
8220
8221 /*
8222 * Loop until the user manages to enter the same
8223 * password twice.
8224 */
8225 while (!got_new) {
8226
8227 ret = get_userpass_input(s->cur_prompt, NULL, 0);
8228 while (ret < 0) {
8229 ssh->send_ok = 1;
8230 crWaitUntilV(!pktin);
8231 ret = get_userpass_input(s->cur_prompt, in, inlen);
8232 ssh->send_ok = 0;
8233 }
8234 if (!ret) {
8235 /*
8236 * Failed to get responses. Terminate.
8237 */
8238 /* burn the evidence */
8239 free_prompts(s->cur_prompt);
8240 memset(s->password, 0, strlen(s->password));
8241 sfree(s->password);
8242 ssh_disconnect(ssh, NULL, "Unable to authenticate",
8243 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
8244 TRUE);
8245 crStopV;
8246 }
8247
8248 /*
d9add7bc 8249 * If the user specified a new original password
8250 * (IYSWIM), overwrite any previously specified
8251 * one.
8252 * (A side effect is that the user doesn't have to
8253 * re-enter it if they louse up the new password.)
8254 */
8255 if (s->cur_prompt->prompts[0]->result[0]) {
8256 memset(s->password, 0, strlen(s->password));
8257 /* burn the evidence */
8258 sfree(s->password);
8259 s->password =
8260 dupstr(s->cur_prompt->prompts[0]->result);
8261 }
8262
8263 /*
8264 * Check the two new passwords match.
e955d348 8265 */
d9add7bc 8266 got_new = (strcmp(s->cur_prompt->prompts[1]->result,
8267 s->cur_prompt->prompts[2]->result)
e955d348 8268 == 0);
8269 if (!got_new)
8270 /* They don't. Silly user. */
8271 c_write_str(ssh, "Passwords do not match\r\n");
8272
8273 }
8274
8275 /*
8276 * Send the new password (along with the old one).
8277 * (see above for padding rationale)
8278 */
8279 s->pktout = ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST);
e955d348 8280 ssh2_pkt_addstring(s->pktout, s->username);
8281 ssh2_pkt_addstring(s->pktout, "ssh-connection");
8282 /* service requested */
8283 ssh2_pkt_addstring(s->pktout, "password");
8284 ssh2_pkt_addbool(s->pktout, TRUE);
8285 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
8286 ssh2_pkt_addstring(s->pktout, s->password);
8287 ssh2_pkt_addstring(s->pktout,
d9add7bc 8288 s->cur_prompt->prompts[1]->result);
e955d348 8289 free_prompts(s->cur_prompt);
8290 end_log_omission(ssh, s->pktout);
18524056 8291 ssh2_pkt_send_with_padding(ssh, s->pktout, 256);
e955d348 8292 logevent("Sent new password");
8293
8294 /*
8295 * Now see what the server has to say about it.
8296 * (If it's CHANGEREQ again, it's not happy with the
8297 * new password.)
8298 */
8299 crWaitUntilV(pktin);
8300 changereq_first_time = FALSE;
8301
8302 }
8303
8304 /*
8305 * We need to reexamine the current pktin at the top
8306 * of the loop. Either:
8307 * - we weren't asked to change password at all, in
8308 * which case it's a SUCCESS or FAILURE with the
8309 * usual meaning
8310 * - we sent a new password, and the server was
8311 * either OK with it (SUCCESS or FAILURE w/partial
8312 * success) or unhappy with the _old_ password
8313 * (FAILURE w/o partial success)
8314 * In any of these cases, we go back to the top of
8315 * the loop and start again.
8316 */
8317 s->gotit = TRUE;
8318
8319 /*
8320 * We don't need the old password any more, in any
8321 * case. Burn the evidence.
8322 */
8323 memset(s->password, 0, strlen(s->password));
8324 sfree(s->password);
8325
1408a877 8326 } else {
edd0cb8a 8327
9e296bfa 8328 ssh_disconnect(ssh, NULL,
8329 "No supported authentication methods available",
8330 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
8331 FALSE);
7ffdbc1a 8332 crStopV;
edd0cb8a 8333
65a22376 8334 }
edd0cb8a 8335
65a22376 8336 }
a1a1fae4 8337 }
6bbce591 8338 ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
7cca0d81 8339
edd0cb8a 8340 /* Clear up various bits and pieces from authentication. */
8341 if (s->publickey_blob) {
8342 sfree(s->publickey_blob);
8343 sfree(s->publickey_comment);
8344 }
94cd7c3a 8345 if (s->agent_response)
8346 sfree(s->agent_response);
edd0cb8a 8347
7cca0d81 8348 /*
a1a1fae4 8349 * Now the connection protocol has started, one way or another.
7cca0d81 8350 */
8351
0ed48730 8352 ssh->channels = newtree234(ssh_channelcmp);
8353
7cca0d81 8354 /*
b09eaa88 8355 * Set up handlers for some connection protocol messages, so we
8356 * don't have to handle them repeatedly in this coroutine.
8357 */
8358 ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] =
8359 ssh2_msg_channel_window_adjust;
51df0ab5 8360 ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] =
8361 ssh2_msg_global_request;
b09eaa88 8362
8363 /*
0ed48730 8364 * Create the main session channel.
7cca0d81 8365 */
feb02b4e 8366 if (ssh->cfg.ssh_no_shell) {
8367 ssh->mainchan = NULL;
8368 } else if (*ssh->cfg.ssh_nc_host) {
8369 /*
8370 * Just start a direct-tcpip channel and use it as the main
8371 * channel.
8372 */
8373 ssh->mainchan = snew(struct ssh_channel);
8374 ssh->mainchan->ssh = ssh;
94bdfe40 8375 ssh2_channel_init(ssh->mainchan);
23828b7e 8376 logeventf(ssh,
8377 "Opening direct-tcpip channel to %s:%d in place of session",
8378 ssh->cfg.ssh_nc_host, ssh->cfg.ssh_nc_port);
feb02b4e 8379 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
8380 ssh2_pkt_addstring(s->pktout, "direct-tcpip");
8381 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->localid);
feb02b4e 8382 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->v.v2.locwindow);/* our window size */
8383 ssh2_pkt_adduint32(s->pktout, OUR_V2_MAXPKT); /* our max pkt size */
8384 ssh2_pkt_addstring(s->pktout, ssh->cfg.ssh_nc_host);
8385 ssh2_pkt_adduint32(s->pktout, ssh->cfg.ssh_nc_port);
8386 /*
23828b7e 8387 * There's nothing meaningful to put in the originator
8388 * fields, but some servers insist on syntactically correct
8389 * information.
feb02b4e 8390 */
8391 ssh2_pkt_addstring(s->pktout, "0.0.0.0");
8392 ssh2_pkt_adduint32(s->pktout, 0);
8393 ssh2_pkt_send(ssh, s->pktout);
8394
8395 crWaitUntilV(pktin);
8396 if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
8397 bombout(("Server refused to open a direct-tcpip channel"));
8398 crStopV;
8399 /* FIXME: error data comes back in FAILURE packet */
8400 }
8401 if (ssh_pkt_getuint32(pktin) != ssh->mainchan->localid) {
8402 bombout(("Server's channel confirmation cited wrong channel"));
8403 crStopV;
8404 }
8405 ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
8406 ssh->mainchan->halfopen = FALSE;
8407 ssh->mainchan->type = CHAN_MAINSESSION;
feb02b4e 8408 ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
8409 ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
feb02b4e 8410 add234(ssh->channels, ssh->mainchan);
8411 update_specials_menu(ssh->frontend);
23828b7e 8412 logevent("Opened direct-tcpip channel");
feb02b4e 8413 ssh->ncmode = TRUE;
8414 } else {
0ed48730 8415 ssh->mainchan = snew(struct ssh_channel);
8416 ssh->mainchan->ssh = ssh;
94bdfe40 8417 ssh2_channel_init(ssh->mainchan);
ff3187f6 8418 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
8419 ssh2_pkt_addstring(s->pktout, "session");
8420 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->localid);
ff3187f6 8421 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->v.v2.locwindow);/* our window size */
954d5c5a 8422 ssh2_pkt_adduint32(s->pktout, OUR_V2_MAXPKT); /* our max pkt size */
ff3187f6 8423 ssh2_pkt_send(ssh, s->pktout);
8424 crWaitUntilV(pktin);
8425 if (pktin->type != SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) {
0ed48730 8426 bombout(("Server refused to open a session"));
8427 crStopV;
8428 /* FIXME: error data comes back in FAILURE packet */
8429 }
ff3187f6 8430 if (ssh_pkt_getuint32(pktin) != ssh->mainchan->localid) {
0ed48730 8431 bombout(("Server's channel confirmation cited wrong channel"));
8432 crStopV;
8433 }
ff3187f6 8434 ssh->mainchan->remoteid = ssh_pkt_getuint32(pktin);
64d6ff88 8435 ssh->mainchan->halfopen = FALSE;
0ed48730 8436 ssh->mainchan->type = CHAN_MAINSESSION;
ff3187f6 8437 ssh->mainchan->v.v2.remwindow = ssh_pkt_getuint32(pktin);
8438 ssh->mainchan->v.v2.remmaxpkt = ssh_pkt_getuint32(pktin);
0ed48730 8439 add234(ssh->channels, ssh->mainchan);
62638676 8440 update_specials_menu(ssh->frontend);
0ed48730 8441 logevent("Opened channel for session");
feb02b4e 8442 ssh->ncmode = FALSE;
8443 }
7cca0d81 8444
8445 /*
51df0ab5 8446 * Now we have a channel, make dispatch table entries for
8447 * general channel-based messages.
8448 */
8449 ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] =
8450 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] =
8451 ssh2_msg_channel_data;
8452 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = ssh2_msg_channel_eof;
8453 ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = ssh2_msg_channel_close;
8454 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] =
8455 ssh2_msg_channel_open_confirmation;
8456 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] =
8457 ssh2_msg_channel_open_failure;
8458 ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] =
8459 ssh2_msg_channel_request;
8460 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] =
8461 ssh2_msg_channel_open;
8462
3361b80a 8463 if (ssh->cfg.ssh_simple) {
8464 /*
8465 * This message indicates to the server that we promise
8466 * not to try to run any other channel in parallel with
8467 * this one, so it's safe for it to advertise a very large
8468 * window and leave the flow control to TCP.
8469 */
8470 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8471 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
8472 ssh2_pkt_addstring(s->pktout, "simple@putty.projects.tartarus.org");
8473 ssh2_pkt_addbool(s->pktout, 0); /* no reply */
8474 ssh2_pkt_send(ssh, s->pktout);
8475 }
8476
51df0ab5 8477 /*
783415f8 8478 * Potentially enable X11 forwarding.
8479 */
feb02b4e 8480 if (ssh->mainchan && !ssh->ncmode && ssh->cfg.x11_forward) {
32874aea 8481 logevent("Requesting X11 forwarding");
8def70c3 8482 ssh->x11disp = x11_setup_display(ssh->cfg.x11_display,
8483 ssh->cfg.x11_auth, &ssh->cfg);
ff3187f6 8484 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8485 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
8486 ssh2_pkt_addstring(s->pktout, "x11-req");
8487 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8488 ssh2_pkt_addbool(s->pktout, 0); /* many connections */
8def70c3 8489 ssh2_pkt_addstring(s->pktout, ssh->x11disp->remoteauthprotoname);
f68353be 8490 /*
8491 * Note that while we blank the X authentication data here, we don't
8492 * take any special action to blank the start of an X11 channel,
8493 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
8494 * without having session blanking enabled is likely to leak your
8495 * cookie into the log.
8496 */
178c3872 8497 dont_log_password(ssh, s->pktout, PKTLOG_BLANK);
8def70c3 8498 ssh2_pkt_addstring(s->pktout, ssh->x11disp->remoteauthdatastring);
178c3872 8499 end_log_omission(ssh, s->pktout);
8def70c3 8500 ssh2_pkt_adduint32(s->pktout, ssh->x11disp->screennum);
ff3187f6 8501 ssh2_pkt_send(ssh, s->pktout);
32874aea 8502
b09eaa88 8503 crWaitUntilV(pktin);
32874aea 8504
ff3187f6 8505 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
8506 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 8507 bombout(("Unexpected response to X11 forwarding request:"
ff3187f6 8508 " packet type %d", pktin->type));
7ffdbc1a 8509 crStopV;
32874aea 8510 }
8511 logevent("X11 forwarding refused");
8512 } else {
8513 logevent("X11 forwarding enabled");
51470298 8514 ssh->X11_fwd_enabled = TRUE;
32874aea 8515 }
783415f8 8516 }
8517
8518 /*
bc240b21 8519 * Enable port forwardings.
8520 */
06fadff5 8521 ssh_setup_portfwd(ssh, &ssh->cfg);
bc240b21 8522
8523 /*
36c2a3e9 8524 * Potentially enable agent forwarding.
8525 */
feb02b4e 8526 if (ssh->mainchan && !ssh->ncmode && ssh->cfg.agentfwd && agent_exists()) {
32874aea 8527 logevent("Requesting OpenSSH-style agent forwarding");
ff3187f6 8528 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8529 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
8530 ssh2_pkt_addstring(s->pktout, "auth-agent-req@openssh.com");
8531 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8532 ssh2_pkt_send(ssh, s->pktout);
32874aea 8533
b09eaa88 8534 crWaitUntilV(pktin);
32874aea 8535
ff3187f6 8536 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
8537 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 8538 bombout(("Unexpected response to agent forwarding request:"
ff3187f6 8539 " packet type %d", pktin->type));
7ffdbc1a 8540 crStopV;
32874aea 8541 }
8542 logevent("Agent forwarding refused");
8543 } else {
8544 logevent("Agent forwarding enabled");
51470298 8545 ssh->agentfwd_enabled = TRUE;
32874aea 8546 }
36c2a3e9 8547 }
8548
8549 /*
7cca0d81 8550 * Now allocate a pty for the session.
8551 */
feb02b4e 8552 if (ssh->mainchan && !ssh->ncmode && !ssh->cfg.nopty) {
a5dd8467 8553 /* Unpick the terminal-speed string. */
8554 /* XXX perhaps we should allow no speeds to be sent. */
db219738 8555 ssh->ospeed = 38400; ssh->ispeed = 38400; /* last-resort defaults */
8556 sscanf(ssh->cfg.termspeed, "%d,%d", &ssh->ospeed, &ssh->ispeed);
a5dd8467 8557 /* Build the pty request. */
ff3187f6 8558 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8559 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
8560 ssh2_pkt_addstring(s->pktout, "pty-req");
8561 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8562 ssh2_pkt_addstring(s->pktout, ssh->cfg.termtype);
8563 ssh2_pkt_adduint32(s->pktout, ssh->term_width);
8564 ssh2_pkt_adduint32(s->pktout, ssh->term_height);
8565 ssh2_pkt_adduint32(s->pktout, 0); /* pixel width */
8566 ssh2_pkt_adduint32(s->pktout, 0); /* pixel height */
8567 ssh2_pkt_addstring_start(s->pktout);
c6ccd5c2 8568 parse_ttymodes(ssh, ssh->cfg.ttymodes,
8569 ssh2_send_ttymode, (void *)s->pktout);
8570 ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_ISPEED);
ff3187f6 8571 ssh2_pkt_adduint32(s->pktout, ssh->ispeed);
c6ccd5c2 8572 ssh2_pkt_addbyte(s->pktout, SSH2_TTY_OP_OSPEED);
ff3187f6 8573 ssh2_pkt_adduint32(s->pktout, ssh->ospeed);
8574 ssh2_pkt_addstring_data(s->pktout, "\0", 1); /* TTY_OP_END */
8575 ssh2_pkt_send(ssh, s->pktout);
51470298 8576 ssh->state = SSH_STATE_INTERMED;
32874aea 8577
b09eaa88 8578 crWaitUntilV(pktin);
32874aea 8579
ff3187f6 8580 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
8581 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 8582 bombout(("Unexpected response to pty request:"
ff3187f6 8583 " packet type %d", pktin->type));
7ffdbc1a 8584 crStopV;
32874aea 8585 }
51470298 8586 c_write_str(ssh, "Server refused to allocate pty\r\n");
8587 ssh->editing = ssh->echoing = 1;
32874aea 8588 } else {
a5dd8467 8589 logeventf(ssh, "Allocated pty (ospeed %dbps, ispeed %dbps)",
db219738 8590 ssh->ospeed, ssh->ispeed);
32874aea 8591 }
0965bee0 8592 } else {
51470298 8593 ssh->editing = ssh->echoing = 1;
7cca0d81 8594 }
8595
8596 /*
73feed4f 8597 * Send environment variables.
8598 *
8599 * Simplest thing here is to send all the requests at once, and
8600 * then wait for a whole bunch of successes or failures.
8601 */
feb02b4e 8602 if (ssh->mainchan && !ssh->ncmode && *ssh->cfg.environmt) {
73feed4f 8603 char *e = ssh->cfg.environmt;
8604 char *var, *varend, *val;
8605
8606 s->num_env = 0;
8607
8608 while (*e) {
8609 var = e;
8610 while (*e && *e != '\t') e++;
8611 varend = e;
8612 if (*e == '\t') e++;
8613 val = e;
8614 while (*e) e++;
8615 e++;
8616
ff3187f6 8617 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8618 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid);
8619 ssh2_pkt_addstring(s->pktout, "env");
8620 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8621 ssh2_pkt_addstring_start(s->pktout);
8622 ssh2_pkt_addstring_data(s->pktout, var, varend-var);
8623 ssh2_pkt_addstring(s->pktout, val);
8624 ssh2_pkt_send(ssh, s->pktout);
73feed4f 8625
8626 s->num_env++;
8627 }
8628
8629 logeventf(ssh, "Sent %d environment variables", s->num_env);
8630
8631 s->env_ok = 0;
8632 s->env_left = s->num_env;
8633
8634 while (s->env_left > 0) {
b09eaa88 8635 crWaitUntilV(pktin);
73feed4f 8636
ff3187f6 8637 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
8638 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
73feed4f 8639 bombout(("Unexpected response to environment request:"
ff3187f6 8640 " packet type %d", pktin->type));
73feed4f 8641 crStopV;
8642 }
8643 } else {
8644 s->env_ok++;
8645 }
8646
8647 s->env_left--;
8648 }
8649
8650 if (s->env_ok == s->num_env) {
8651 logevent("All environment variables successfully set");
8652 } else if (s->env_ok == 0) {
8653 logevent("All environment variables refused");
8654 c_write_str(ssh, "Server refused to set environment variables\r\n");
8655 } else {
8656 logeventf(ssh, "%d environment variables refused",
8657 s->num_env - s->env_ok);
8658 c_write_str(ssh, "Server refused to set all environment variables\r\n");
8659 }
8660 }
8661
8662 /*
fd5e5847 8663 * Start a shell or a remote command. We may have to attempt
8664 * this twice if the config data has provided a second choice
8665 * of command.
7cca0d81 8666 */
feb02b4e 8667 if (ssh->mainchan && !ssh->ncmode) while (1) {
fd5e5847 8668 int subsys;
8669 char *cmd;
8670
51470298 8671 if (ssh->fallback_cmd) {
86916870 8672 subsys = ssh->cfg.ssh_subsys2;
8673 cmd = ssh->cfg.remote_cmd_ptr2;
fd5e5847 8674 } else {
86916870 8675 subsys = ssh->cfg.ssh_subsys;
8676 cmd = ssh->cfg.remote_cmd_ptr;
04c52f10 8677 if (!cmd) cmd = ssh->cfg.remote_cmd;
fd5e5847 8678 }
8679
ff3187f6 8680 s->pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
8681 ssh2_pkt_adduint32(s->pktout, ssh->mainchan->remoteid); /* recipient channel */
fd5e5847 8682 if (subsys) {
ff3187f6 8683 ssh2_pkt_addstring(s->pktout, "subsystem");
8684 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8685 ssh2_pkt_addstring(s->pktout, cmd);
fd5e5847 8686 } else if (*cmd) {
ff3187f6 8687 ssh2_pkt_addstring(s->pktout, "exec");
8688 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
8689 ssh2_pkt_addstring(s->pktout, cmd);
fd5e5847 8690 } else {
ff3187f6 8691 ssh2_pkt_addstring(s->pktout, "shell");
8692 ssh2_pkt_addbool(s->pktout, 1); /* want reply */
32874aea 8693 }
ff3187f6 8694 ssh2_pkt_send(ssh, s->pktout);
b09eaa88 8695
8696 crWaitUntilV(pktin);
8697
ff3187f6 8698 if (pktin->type != SSH2_MSG_CHANNEL_SUCCESS) {
8699 if (pktin->type != SSH2_MSG_CHANNEL_FAILURE) {
6b5cf8b4 8700 bombout(("Unexpected response to shell/command request:"
ff3187f6 8701 " packet type %d", pktin->type));
7ffdbc1a 8702 crStopV;
fd5e5847 8703 }
8704 /*
8705 * We failed to start the command. If this is the
8706 * fallback command, we really are finished; if it's
8707 * not, and if the fallback command exists, try falling
8708 * back to it before complaining.
8709 */
86916870 8710 if (!ssh->fallback_cmd && ssh->cfg.remote_cmd_ptr2 != NULL) {
fd5e5847 8711 logevent("Primary command failed; attempting fallback");
51470298 8712 ssh->fallback_cmd = TRUE;
fd5e5847 8713 continue;
8714 }
6b5cf8b4 8715 bombout(("Server refused to start a shell/command"));
7ffdbc1a 8716 crStopV;
fd5e5847 8717 } else {
8718 logevent("Started a shell/command");
32874aea 8719 }
fd5e5847 8720 break;
7cca0d81 8721 }
8722
51470298 8723 ssh->state = SSH_STATE_SESSION;
8724 if (ssh->size_needed)
8725 ssh_size(ssh, ssh->term_width, ssh->term_height);
8726 if (ssh->eof_needed)
8727 ssh_special(ssh, TS_EOF);
6e48c3fe 8728
7cca0d81 8729 /*
0e443c99 8730 * All the initial channel requests are done, so install the default
8731 * failure handler.
8732 */
837d6ba6 8733 ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = ssh2_msg_channel_success;
0e443c99 8734 ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = ssh2_msg_channel_failure;
8735
8736 /*
7cca0d81 8737 * Transfer data!
8738 */
b9d7bcad 8739 if (ssh->ldisc)
8740 ldisc_send(ssh->ldisc, NULL, 0, 0);/* cause ldisc to notice changes */
0ed48730 8741 if (ssh->mainchan)
8742 ssh->send_ok = 1;
7cca0d81 8743 while (1) {
e5574168 8744 crReturnV;
51470298 8745 s->try_send = FALSE;
ff3187f6 8746 if (pktin) {
2b7540a7 8747
51df0ab5 8748 /*
8749 * _All_ the connection-layer packets we expect to
8750 * receive are now handled by the dispatch table.
8751 * Anything that reaches here must be bogus.
8752 */
32874aea 8753
51df0ab5 8754 bombout(("Strange packet received: type %d", pktin->type));
8755 crStopV;
0ed48730 8756 } else if (ssh->mainchan) {
32874aea 8757 /*
8758 * We have spare data. Add it to the channel buffer.
8759 */
d8baa528 8760 ssh2_add_channel_data(ssh->mainchan, (char *)in, inlen);
51470298 8761 s->try_send = TRUE;
32874aea 8762 }
51470298 8763 if (s->try_send) {
32874aea 8764 int i;
8765 struct ssh_channel *c;
8766 /*
8767 * Try to send data on all channels if we can.
8768 */
1bfc7e93 8769 for (i = 0; NULL != (c = index234(ssh->channels, i)); i++)
8770 ssh2_try_send_and_unthrottle(c);
7cca0d81 8771 }
e5574168 8772 }
8773
8774 crFinishV;
8775}
8776
8777/*
2e85c969 8778 * Handlers for SSH-2 messages that might arrive at any moment.
b09eaa88 8779 */
409bfa77 8780static void ssh2_msg_disconnect(Ssh ssh, struct Packet *pktin)
b09eaa88 8781{
8782 /* log reason code in disconnect message */
8783 char *buf, *msg;
60860bc3 8784 int reason, msglen;
b09eaa88 8785
8786 reason = ssh_pkt_getuint32(pktin);
8787 ssh_pkt_getstring(pktin, &msg, &msglen);
8788
8789 if (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) {
8790 buf = dupprintf("Received disconnect message (%s)",
8791 ssh2_disconnect_reasons[reason]);
8792 } else {
8793 buf = dupprintf("Received disconnect message (unknown"
8794 " type %d)", reason);
8795 }
8796 logevent(buf);
8797 sfree(buf);
60860bc3 8798 buf = dupprintf("Disconnection message text: %.*s",
8799 msglen, msg);
b09eaa88 8800 logevent(buf);
60860bc3 8801 bombout(("Server sent disconnect message\ntype %d (%s):\n\"%.*s\"",
b09eaa88 8802 reason,
8803 (reason > 0 && reason < lenof(ssh2_disconnect_reasons)) ?
8804 ssh2_disconnect_reasons[reason] : "unknown",
60860bc3 8805 msglen, msg));
b09eaa88 8806 sfree(buf);
8807}
8808
409bfa77 8809static void ssh2_msg_debug(Ssh ssh, struct Packet *pktin)
b09eaa88 8810{
8811 /* log the debug message */
fb983202 8812 char *msg;
b09eaa88 8813 int msglen;
8814 int always_display;
8815
8816 /* XXX maybe we should actually take notice of this */
8817 always_display = ssh2_pkt_getbool(pktin);
8818 ssh_pkt_getstring(pktin, &msg, &msglen);
8819
fb983202 8820 logeventf(ssh, "Remote debug message: %.*s", msglen, msg);
b09eaa88 8821}
8822
409bfa77 8823static void ssh2_msg_something_unimplemented(Ssh ssh, struct Packet *pktin)
b09eaa88 8824{
8825 struct Packet *pktout;
8826 pktout = ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED);
8827 ssh2_pkt_adduint32(pktout, pktin->sequence);
8828 /*
8829 * UNIMPLEMENTED messages MUST appear in the same order as the
8830 * messages they respond to. Hence, never queue them.
8831 */
8832 ssh2_pkt_send_noqueue(ssh, pktout);
8833}
8834
8835/*
2e85c969 8836 * Handle the top-level SSH-2 protocol.
7cca0d81 8837 */
b09eaa88 8838static void ssh2_protocol_setup(Ssh ssh)
8839{
8840 int i;
8841
8842 /*
8843 * Most messages cause SSH2_MSG_UNIMPLEMENTED.
8844 */
8845 for (i = 0; i < 256; i++)
8846 ssh->packet_dispatch[i] = ssh2_msg_something_unimplemented;
8847
8848 /*
8849 * Any message we actually understand, we set to NULL so that
8850 * the coroutines will get it.
8851 */
8852 ssh->packet_dispatch[SSH2_MSG_UNIMPLEMENTED] = NULL;
8853 ssh->packet_dispatch[SSH2_MSG_SERVICE_REQUEST] = NULL;
8854 ssh->packet_dispatch[SSH2_MSG_SERVICE_ACCEPT] = NULL;
8855 ssh->packet_dispatch[SSH2_MSG_KEXINIT] = NULL;
8856 ssh->packet_dispatch[SSH2_MSG_NEWKEYS] = NULL;
8857 ssh->packet_dispatch[SSH2_MSG_KEXDH_INIT] = NULL;
8858 ssh->packet_dispatch[SSH2_MSG_KEXDH_REPLY] = NULL;
8859 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = NULL; duplicate case value */
8860 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = NULL; duplicate case value */
8861 ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_INIT] = NULL;
8862 ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REPLY] = NULL;
8863 ssh->packet_dispatch[SSH2_MSG_USERAUTH_REQUEST] = NULL;
8864 ssh->packet_dispatch[SSH2_MSG_USERAUTH_FAILURE] = NULL;
8865 ssh->packet_dispatch[SSH2_MSG_USERAUTH_SUCCESS] = NULL;
8866 ssh->packet_dispatch[SSH2_MSG_USERAUTH_BANNER] = NULL;
8867 ssh->packet_dispatch[SSH2_MSG_USERAUTH_PK_OK] = NULL;
8868 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = NULL; duplicate case value */
8869 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = NULL; duplicate case value */
8870 ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_RESPONSE] = NULL;
8871 ssh->packet_dispatch[SSH2_MSG_GLOBAL_REQUEST] = NULL;
8872 ssh->packet_dispatch[SSH2_MSG_REQUEST_SUCCESS] = NULL;
8873 ssh->packet_dispatch[SSH2_MSG_REQUEST_FAILURE] = NULL;
8874 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN] = NULL;
8875 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION] = NULL;
8876 ssh->packet_dispatch[SSH2_MSG_CHANNEL_OPEN_FAILURE] = NULL;
8877 ssh->packet_dispatch[SSH2_MSG_CHANNEL_WINDOW_ADJUST] = NULL;
8878 ssh->packet_dispatch[SSH2_MSG_CHANNEL_DATA] = NULL;
8879 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EXTENDED_DATA] = NULL;
8880 ssh->packet_dispatch[SSH2_MSG_CHANNEL_EOF] = NULL;
8881 ssh->packet_dispatch[SSH2_MSG_CHANNEL_CLOSE] = NULL;
8882 ssh->packet_dispatch[SSH2_MSG_CHANNEL_REQUEST] = NULL;
8883 ssh->packet_dispatch[SSH2_MSG_CHANNEL_SUCCESS] = NULL;
8884 ssh->packet_dispatch[SSH2_MSG_CHANNEL_FAILURE] = NULL;
8885
8886 /*
8887 * These special message types we install handlers for.
8888 */
8889 ssh->packet_dispatch[SSH2_MSG_DISCONNECT] = ssh2_msg_disconnect;
2e85c969 8890 ssh->packet_dispatch[SSH2_MSG_IGNORE] = ssh_msg_ignore; /* shared with SSH-1 */
b09eaa88 8891 ssh->packet_dispatch[SSH2_MSG_DEBUG] = ssh2_msg_debug;
8892}
8893
9442dd57 8894static void ssh2_timer(void *ctx, long now)
8895{
8896 Ssh ssh = (Ssh)ctx;
8897
ecbb0000 8898 if (ssh->state == SSH_STATE_CLOSED)
8899 return;
8900
e6c1536e 8901 if (!ssh->kex_in_progress && ssh->cfg.ssh_rekey_time != 0 &&
9442dd57 8902 now - ssh->next_rekey >= 0) {
f382c87d 8903 do_ssh2_transport(ssh, "timeout", -1, NULL);
9442dd57 8904 }
8905}
8906
1c1a7262 8907static void ssh2_protocol(Ssh ssh, void *vin, int inlen,
ff3187f6 8908 struct Packet *pktin)
7cca0d81 8909{
1c1a7262 8910 unsigned char *in = (unsigned char *)vin;
b09eaa88 8911 if (ssh->state == SSH_STATE_CLOSED)
8912 return;
8913
9442dd57 8914 if (pktin) {
8915 ssh->incoming_data_size += pktin->encrypted_len;
8916 if (!ssh->kex_in_progress &&
d57f70af 8917 ssh->max_data_size != 0 &&
8918 ssh->incoming_data_size > ssh->max_data_size)
f382c87d 8919 do_ssh2_transport(ssh, "too much data received", -1, NULL);
9442dd57 8920 }
8921
b09eaa88 8922 if (pktin && ssh->packet_dispatch[pktin->type]) {
8923 ssh->packet_dispatch[pktin->type](ssh, pktin);
32874aea 8924 return;
b09eaa88 8925 }
8926
8927 if (!ssh->protocol_initial_phase_done ||
8928 (pktin && pktin->type >= 20 && pktin->type < 50)) {
8929 if (do_ssh2_transport(ssh, in, inlen, pktin) &&
8930 !ssh->protocol_initial_phase_done) {
8931 ssh->protocol_initial_phase_done = TRUE;
8932 /*
8933 * Allow authconn to initialise itself.
8934 */
8935 do_ssh2_authconn(ssh, NULL, 0, NULL);
8936 }
8937 } else {
8938 do_ssh2_authconn(ssh, in, inlen, pktin);
8939 }
7cca0d81 8940}
8941
8942/*
8df7a775 8943 * Called to set up the connection.
374330e2 8944 *
8945 * Returns an error message, or NULL on success.
374330e2 8946 */
cbe2d68f 8947static const char *ssh_init(void *frontend_handle, void **backend_handle,
8948 Config *cfg,
79bf227b 8949 char *host, int port, char **realhost, int nodelay,
8950 int keepalive)
32874aea 8951{
cbe2d68f 8952 const char *p;
51470298 8953 Ssh ssh;
8954
3d88e64d 8955 ssh = snew(struct ssh_tag);
86916870 8956 ssh->cfg = *cfg; /* STRUCTURE COPY */
125105d1 8957 ssh->version = 0; /* when not ready yet */
51470298 8958 ssh->s = NULL;
8959 ssh->cipher = NULL;
371e569c 8960 ssh->v1_cipher_ctx = NULL;
0183b242 8961 ssh->crcda_ctx = NULL;
51470298 8962 ssh->cscipher = NULL;
371e569c 8963 ssh->cs_cipher_ctx = NULL;
51470298 8964 ssh->sccipher = NULL;
371e569c 8965 ssh->sc_cipher_ctx = NULL;
51470298 8966 ssh->csmac = NULL;
a8327734 8967 ssh->cs_mac_ctx = NULL;
51470298 8968 ssh->scmac = NULL;
e0e1a00d 8969 ssh->sc_mac_ctx = NULL;
51470298 8970 ssh->cscomp = NULL;
5366aed8 8971 ssh->cs_comp_ctx = NULL;
51470298 8972 ssh->sccomp = NULL;
5366aed8 8973 ssh->sc_comp_ctx = NULL;
51470298 8974 ssh->kex = NULL;
389aa499 8975 ssh->kex_ctx = NULL;
51470298 8976 ssh->hostkey = NULL;
8977 ssh->exitcode = -1;
ac934965 8978 ssh->close_expected = FALSE;
9e296bfa 8979 ssh->clean_exit = FALSE;
51470298 8980 ssh->state = SSH_STATE_PREPACKET;
8981 ssh->size_needed = FALSE;
8982 ssh->eof_needed = FALSE;
b9d7bcad 8983 ssh->ldisc = NULL;
a8327734 8984 ssh->logctx = NULL;
51470298 8985 ssh->deferred_send_data = NULL;
8986 ssh->deferred_len = 0;
8987 ssh->deferred_size = 0;
8988 ssh->fallback_cmd = 0;
acab36bc 8989 ssh->pkt_kctx = SSH2_PKTCTX_NOKEX;
8990 ssh->pkt_actx = SSH2_PKTCTX_NOAUTH;
8def70c3 8991 ssh->x11disp = NULL;
be738459 8992 ssh->v1_compressing = FALSE;
51470298 8993 ssh->v2_outgoing_sequence = 0;
8994 ssh->ssh1_rdpkt_crstate = 0;
8995 ssh->ssh2_rdpkt_crstate = 0;
8996 ssh->do_ssh_init_crstate = 0;
8997 ssh->ssh_gotdata_crstate = 0;
b09eaa88 8998 ssh->do_ssh1_connection_crstate = 0;
51470298 8999 ssh->do_ssh1_login_crstate = 0;
9000 ssh->do_ssh2_transport_crstate = 0;
9001 ssh->do_ssh2_authconn_crstate = 0;
9002 ssh->do_ssh_init_state = NULL;
9003 ssh->do_ssh1_login_state = NULL;
9004 ssh->do_ssh2_transport_state = NULL;
9005 ssh->do_ssh2_authconn_state = NULL;
4320baf7 9006 ssh->v_c = NULL;
9007 ssh->v_s = NULL;
6571dbfd 9008 ssh->mainchan = NULL;
968d2d92 9009 ssh->throttled_all = 0;
9010 ssh->v1_stdout_throttling = 0;
590f6a5f 9011 ssh->queue = NULL;
9012 ssh->queuelen = ssh->queuesize = 0;
9013 ssh->queueing = FALSE;
06fadff5 9014 ssh->qhead = ssh->qtail = NULL;
e13bba36 9015 ssh->deferred_rekey_reason = NULL;
3d9449a1 9016 bufchain_init(&ssh->queued_incoming_data);
9017 ssh->frozen = FALSE;
51470298 9018
9019 *backend_handle = ssh;
32874aea 9020
8f203108 9021#ifdef MSCRYPTOAPI
32874aea 9022 if (crypto_startup() == 0)
8f203108 9023 return "Microsoft high encryption pack not installed!";
9024#endif
374330e2 9025
51470298 9026 ssh->frontend = frontend_handle;
86916870 9027 ssh->term_width = ssh->cfg.width;
9028 ssh->term_height = ssh->cfg.height;
887035a5 9029
fabd1805 9030 ssh->channels = NULL;
9031 ssh->rportfwds = NULL;
f47a5ffb 9032 ssh->portfwds = NULL;
fabd1805 9033
51470298 9034 ssh->send_ok = 0;
9035 ssh->editing = 0;
9036 ssh->echoing = 0;
ff68564b 9037 ssh->conn_throttle_count = 0;
51470298 9038 ssh->overall_bufsize = 0;
9039 ssh->fallback_cmd = 0;
8df7a775 9040
3648d4c5 9041 ssh->protocol = NULL;
9042
b09eaa88 9043 ssh->protocol_initial_phase_done = FALSE;
9044
39934deb 9045 ssh->pinger = NULL;
9046
9442dd57 9047 ssh->incoming_data_size = ssh->outgoing_data_size =
9048 ssh->deferred_data_size = 0L;
d57f70af 9049 ssh->max_data_size = parse_blocksize(ssh->cfg.ssh_rekey_data);
9442dd57 9050 ssh->kex_in_progress = FALSE;
9051
79bf227b 9052 p = connect_to_host(ssh, host, port, realhost, nodelay, keepalive);
fb09bf1c 9053 if (p != NULL)
9054 return p;
374330e2 9055
5d17ccfc 9056 random_ref();
9057
374330e2 9058 return NULL;
9059}
9060
fabd1805 9061static void ssh_free(void *handle)
9062{
9063 Ssh ssh = (Ssh) handle;
9064 struct ssh_channel *c;
9065 struct ssh_rportfwd *pf;
9066
9067 if (ssh->v1_cipher_ctx)
9068 ssh->cipher->free_context(ssh->v1_cipher_ctx);
9069 if (ssh->cs_cipher_ctx)
9070 ssh->cscipher->free_context(ssh->cs_cipher_ctx);
9071 if (ssh->sc_cipher_ctx)
9072 ssh->sccipher->free_context(ssh->sc_cipher_ctx);
9073 if (ssh->cs_mac_ctx)
9074 ssh->csmac->free_context(ssh->cs_mac_ctx);
9075 if (ssh->sc_mac_ctx)
9076 ssh->scmac->free_context(ssh->sc_mac_ctx);
29b1d0b3 9077 if (ssh->cs_comp_ctx) {
9078 if (ssh->cscomp)
9079 ssh->cscomp->compress_cleanup(ssh->cs_comp_ctx);
9080 else
9081 zlib_compress_cleanup(ssh->cs_comp_ctx);
9082 }
9083 if (ssh->sc_comp_ctx) {
9084 if (ssh->sccomp)
9085 ssh->sccomp->decompress_cleanup(ssh->sc_comp_ctx);
9086 else
9087 zlib_decompress_cleanup(ssh->sc_comp_ctx);
9088 }
fabd1805 9089 if (ssh->kex_ctx)
9090 dh_cleanup(ssh->kex_ctx);
9091 sfree(ssh->savedhost);
9092
590f6a5f 9093 while (ssh->queuelen-- > 0)
9094 ssh_free_packet(ssh->queue[ssh->queuelen]);
9095 sfree(ssh->queue);
9096
06fadff5 9097 while (ssh->qhead) {
9098 struct queued_handler *qh = ssh->qhead;
9099 ssh->qhead = qh->next;
9100 sfree(ssh->qhead);
9101 }
9102 ssh->qhead = ssh->qtail = NULL;
9103
fabd1805 9104 if (ssh->channels) {
9105 while ((c = delpos234(ssh->channels, 0)) != NULL) {
9106 switch (c->type) {
9107 case CHAN_X11:
9108 if (c->u.x11.s != NULL)
9109 x11_close(c->u.x11.s);
9110 break;
9111 case CHAN_SOCKDATA:
9112 if (c->u.pfd.s != NULL)
9113 pfd_close(c->u.pfd.s);
9114 break;
9115 }
9116 sfree(c);
9117 }
9118 freetree234(ssh->channels);
cdb52705 9119 ssh->channels = NULL;
fabd1805 9120 }
9121
9122 if (ssh->rportfwds) {
9123 while ((pf = delpos234(ssh->rportfwds, 0)) != NULL)
9124 sfree(pf);
9125 freetree234(ssh->rportfwds);
cdb52705 9126 ssh->rportfwds = NULL;
fabd1805 9127 }
9128 sfree(ssh->deferred_send_data);
8def70c3 9129 if (ssh->x11disp)
9130 x11_free_display(ssh->x11disp);
fabd1805 9131 sfree(ssh->do_ssh_init_state);
9132 sfree(ssh->do_ssh1_login_state);
9133 sfree(ssh->do_ssh2_transport_state);
9134 sfree(ssh->do_ssh2_authconn_state);
4320baf7 9135 sfree(ssh->v_c);
9136 sfree(ssh->v_s);
42af6a67 9137 sfree(ssh->fullhostname);
679539d7 9138 if (ssh->crcda_ctx) {
9139 crcda_free_context(ssh->crcda_ctx);
9140 ssh->crcda_ctx = NULL;
9141 }
fabd1805 9142 if (ssh->s)
ac934965 9143 ssh_do_close(ssh, TRUE);
9442dd57 9144 expire_timer_context(ssh);
39934deb 9145 if (ssh->pinger)
9146 pinger_free(ssh->pinger);
3d9449a1 9147 bufchain_clear(&ssh->queued_incoming_data);
ee50e8b6 9148 sfree(ssh);
5d17ccfc 9149
9150 random_unref();
fabd1805 9151}
9152
374330e2 9153/*
86916870 9154 * Reconfigure the SSH backend.
86916870 9155 */
9156static void ssh_reconfig(void *handle, Config *cfg)
9157{
9158 Ssh ssh = (Ssh) handle;
e13bba36 9159 char *rekeying = NULL, rekey_mandatory = FALSE;
e6c1536e 9160 unsigned long old_max_data_size;
9161
39934deb 9162 pinger_reconfig(ssh->pinger, &ssh->cfg, cfg);
3b6606c7 9163 if (ssh->portfwds)
9164 ssh_setup_portfwd(ssh, cfg);
e6c1536e 9165
9166 if (ssh->cfg.ssh_rekey_time != cfg->ssh_rekey_time &&
9167 cfg->ssh_rekey_time != 0) {
9168 long new_next = ssh->last_rekey + cfg->ssh_rekey_time*60*TICKSPERSEC;
9169 long now = GETTICKCOUNT();
9170
9171 if (new_next - now < 0) {
f382c87d 9172 rekeying = "timeout shortened";
e6c1536e 9173 } else {
9174 ssh->next_rekey = schedule_timer(new_next - now, ssh2_timer, ssh);
9175 }
9176 }
9177
9178 old_max_data_size = ssh->max_data_size;
9179 ssh->max_data_size = parse_blocksize(cfg->ssh_rekey_data);
9180 if (old_max_data_size != ssh->max_data_size &&
9181 ssh->max_data_size != 0) {
9182 if (ssh->outgoing_data_size > ssh->max_data_size ||
9183 ssh->incoming_data_size > ssh->max_data_size)
f382c87d 9184 rekeying = "data limit lowered";
e6c1536e 9185 }
9186
e13bba36 9187 if (ssh->cfg.compression != cfg->compression) {
f382c87d 9188 rekeying = "compression setting changed";
e13bba36 9189 rekey_mandatory = TRUE;
9190 }
9191
9192 if (ssh->cfg.ssh2_des_cbc != cfg->ssh2_des_cbc ||
9193 memcmp(ssh->cfg.ssh_cipherlist, cfg->ssh_cipherlist,
9194 sizeof(ssh->cfg.ssh_cipherlist))) {
f382c87d 9195 rekeying = "cipher settings changed";
e13bba36 9196 rekey_mandatory = TRUE;
e6c1536e 9197 }
9198
86916870 9199 ssh->cfg = *cfg; /* STRUCTURE COPY */
e13bba36 9200
9201 if (rekeying) {
9202 if (!ssh->kex_in_progress) {
9203 do_ssh2_transport(ssh, rekeying, -1, NULL);
9204 } else if (rekey_mandatory) {
9205 ssh->deferred_rekey_reason = rekeying;
9206 }
9207 }
86916870 9208}
9209
9210/*
86dc445a 9211 * Called to send data down the SSH connection.
374330e2 9212 */
51470298 9213static int ssh_send(void *handle, char *buf, int len)
32874aea 9214{
51470298 9215 Ssh ssh = (Ssh) handle;
9216
9217 if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
5471d09a 9218 return 0;
374330e2 9219
d8baa528 9220 ssh->protocol(ssh, (unsigned char *)buf, len, 0);
5471d09a 9221
51470298 9222 return ssh_sendbuffer(ssh);
5471d09a 9223}
9224
9225/*
9226 * Called to query the current amount of buffered stdin data.
9227 */
51470298 9228static int ssh_sendbuffer(void *handle)
5471d09a 9229{
51470298 9230 Ssh ssh = (Ssh) handle;
5471d09a 9231 int override_value;
9232
51470298 9233 if (ssh == NULL || ssh->s == NULL || ssh->protocol == NULL)
5471d09a 9234 return 0;
9235
9236 /*
9237 * If the SSH socket itself has backed up, add the total backup
9238 * size on that to any individual buffer on the stdin channel.
9239 */
9240 override_value = 0;
51470298 9241 if (ssh->throttled_all)
9242 override_value = ssh->overall_bufsize;
5471d09a 9243
51470298 9244 if (ssh->version == 1) {
5471d09a 9245 return override_value;
51470298 9246 } else if (ssh->version == 2) {
9247 if (!ssh->mainchan || ssh->mainchan->closes > 0)
5471d09a 9248 return override_value;
9249 else
51470298 9250 return (override_value +
9251 bufchain_size(&ssh->mainchan->v.v2.outbuffer));
5471d09a 9252 }
9253
9254 return 0;
374330e2 9255}
9256
9257/*
6e48c3fe 9258 * Called to set the size of the window from SSH's POV.
374330e2 9259 */
51470298 9260static void ssh_size(void *handle, int width, int height)
32874aea 9261{
51470298 9262 Ssh ssh = (Ssh) handle;
ff3187f6 9263 struct Packet *pktout;
51470298 9264
9265 ssh->term_width = width;
9266 ssh->term_height = height;
f278d6f8 9267
51470298 9268 switch (ssh->state) {
374330e2 9269 case SSH_STATE_BEFORE_SIZE:
3687d221 9270 case SSH_STATE_PREPACKET:
21248260 9271 case SSH_STATE_CLOSED:
374330e2 9272 break; /* do nothing */
9273 case SSH_STATE_INTERMED:
51470298 9274 ssh->size_needed = TRUE; /* buffer for later */
374330e2 9275 break;
9276 case SSH_STATE_SESSION:
86916870 9277 if (!ssh->cfg.nopty) {
51470298 9278 if (ssh->version == 1) {
9279 send_packet(ssh, SSH1_CMSG_WINDOW_SIZE,
9280 PKT_INT, ssh->term_height,
9281 PKT_INT, ssh->term_width,
32874aea 9282 PKT_INT, 0, PKT_INT, 0, PKT_END);
0ed48730 9283 } else if (ssh->mainchan) {
ff3187f6 9284 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
9285 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
9286 ssh2_pkt_addstring(pktout, "window-change");
9287 ssh2_pkt_addbool(pktout, 0);
9288 ssh2_pkt_adduint32(pktout, ssh->term_width);
9289 ssh2_pkt_adduint32(pktout, ssh->term_height);
9290 ssh2_pkt_adduint32(pktout, 0);
9291 ssh2_pkt_adduint32(pktout, 0);
9292 ssh2_pkt_send(ssh, pktout);
32874aea 9293 }
9294 }
9295 break;
374330e2 9296 }
9297}
9298
9299/*
125105d1 9300 * Return a list of the special codes that make sense in this
9301 * protocol.
9302 */
9303static const struct telnet_special *ssh_get_specials(void *handle)
9304{
786ba75e 9305 static const struct telnet_special ssh1_ignore_special[] = {
9306 {"IGNORE message", TS_NOP}
9307 };
9308 static const struct telnet_special ssh2_transport_specials[] = {
62638676 9309 {"IGNORE message", TS_NOP},
9442dd57 9310 {"Repeat key exchange", TS_REKEY},
62638676 9311 };
9312 static const struct telnet_special ssh2_session_specials[] = {
6f2d0cde 9313 {NULL, TS_SEP},
9314 {"Break", TS_BRK},
bccbeb71 9315 /* These are the signal names defined by RFC 4254.
6f2d0cde 9316 * They include all the ISO C signals, but are a subset of the POSIX
9317 * required signals. */
9318 {"SIGINT (Interrupt)", TS_SIGINT},
9319 {"SIGTERM (Terminate)", TS_SIGTERM},
9320 {"SIGKILL (Kill)", TS_SIGKILL},
9321 {"SIGQUIT (Quit)", TS_SIGQUIT},
9322 {"SIGHUP (Hangup)", TS_SIGHUP},
9323 {"More signals", TS_SUBMENU},
9324 {"SIGABRT", TS_SIGABRT}, {"SIGALRM", TS_SIGALRM},
9325 {"SIGFPE", TS_SIGFPE}, {"SIGILL", TS_SIGILL},
9326 {"SIGPIPE", TS_SIGPIPE}, {"SIGSEGV", TS_SIGSEGV},
9327 {"SIGUSR1", TS_SIGUSR1}, {"SIGUSR2", TS_SIGUSR2},
9328 {NULL, TS_EXITMENU}
62638676 9329 };
9330 static const struct telnet_special specials_end[] = {
6f2d0cde 9331 {NULL, TS_EXITMENU}
62638676 9332 };
786ba75e 9333 /* XXX review this length for any changes: */
9334 static struct telnet_special ssh_specials[lenof(ssh2_transport_specials) +
62638676 9335 lenof(ssh2_session_specials) +
9336 lenof(specials_end)];
125105d1 9337 Ssh ssh = (Ssh) handle;
62638676 9338 int i = 0;
9339#define ADD_SPECIALS(name) \
9340 do { \
9341 assert((i + lenof(name)) <= lenof(ssh_specials)); \
9342 memcpy(&ssh_specials[i], name, sizeof name); \
9343 i += lenof(name); \
9344 } while(0)
125105d1 9345
9346 if (ssh->version == 1) {
62638676 9347 /* Don't bother offering IGNORE if we've decided the remote
9348 * won't cope with it, since we wouldn't bother sending it if
9349 * asked anyway. */
9350 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
786ba75e 9351 ADD_SPECIALS(ssh1_ignore_special);
125105d1 9352 } else if (ssh->version == 2) {
786ba75e 9353 ADD_SPECIALS(ssh2_transport_specials);
62638676 9354 if (ssh->mainchan)
9355 ADD_SPECIALS(ssh2_session_specials);
9356 } /* else we're not ready yet */
9357
9358 if (i) {
9359 ADD_SPECIALS(specials_end);
9360 return ssh_specials;
9361 } else {
125105d1 9362 return NULL;
62638676 9363 }
9364#undef ADD_SPECIALS
125105d1 9365}
9366
9367/*
86dc445a 9368 * Send special codes. TS_EOF is useful for `plink', so you
6abbf9e3 9369 * can send an EOF and collect resulting output (e.g. `plink
9370 * hostname sort').
374330e2 9371 */
51470298 9372static void ssh_special(void *handle, Telnet_Special code)
32874aea 9373{
51470298 9374 Ssh ssh = (Ssh) handle;
ff3187f6 9375 struct Packet *pktout;
51470298 9376
6abbf9e3 9377 if (code == TS_EOF) {
51470298 9378 if (ssh->state != SSH_STATE_SESSION) {
32874aea 9379 /*
9380 * Buffer the EOF in case we are pre-SESSION, so we can
9381 * send it as soon as we reach SESSION.
9382 */
9383 if (code == TS_EOF)
51470298 9384 ssh->eof_needed = TRUE;
32874aea 9385 return;
9386 }
51470298 9387 if (ssh->version == 1) {
9388 send_packet(ssh, SSH1_CMSG_EOF, PKT_END);
0ed48730 9389 } else if (ssh->mainchan) {
ff3187f6 9390 struct Packet *pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF);
9391 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
9392 ssh2_pkt_send(ssh, pktout);
00a0b113 9393 ssh->send_ok = 0; /* now stop trying to read from stdin */
32874aea 9394 }
9395 logevent("Sent EOF message");
125105d1 9396 } else if (code == TS_PING || code == TS_NOP) {
51470298 9397 if (ssh->state == SSH_STATE_CLOSED
9398 || ssh->state == SSH_STATE_PREPACKET) return;
9399 if (ssh->version == 1) {
9400 if (!(ssh->remote_bugs & BUG_CHOKES_ON_SSH1_IGNORE))
9401 send_packet(ssh, SSH1_MSG_IGNORE, PKT_STR, "", PKT_END);
32874aea 9402 } else {
ff3187f6 9403 pktout = ssh2_pkt_init(SSH2_MSG_IGNORE);
9404 ssh2_pkt_addstring_start(pktout);
590f6a5f 9405 ssh2_pkt_send_noqueue(ssh, pktout);
32874aea 9406 }
9442dd57 9407 } else if (code == TS_REKEY) {
9408 if (!ssh->kex_in_progress && ssh->version == 2) {
f382c87d 9409 do_ssh2_transport(ssh, "at user request", -1, NULL);
9442dd57 9410 }
125105d1 9411 } else if (code == TS_BRK) {
9412 if (ssh->state == SSH_STATE_CLOSED
9413 || ssh->state == SSH_STATE_PREPACKET) return;
9414 if (ssh->version == 1) {
2e85c969 9415 logevent("Unable to send BREAK signal in SSH-1");
0ed48730 9416 } else if (ssh->mainchan) {
ff3187f6 9417 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
9418 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
9419 ssh2_pkt_addstring(pktout, "break");
9420 ssh2_pkt_addbool(pktout, 0);
9421 ssh2_pkt_adduint32(pktout, 0); /* default break length */
9422 ssh2_pkt_send(ssh, pktout);
125105d1 9423 }
6abbf9e3 9424 } else {
6f2d0cde 9425 /* Is is a POSIX signal? */
9426 char *signame = NULL;
9427 if (code == TS_SIGABRT) signame = "ABRT";
9428 if (code == TS_SIGALRM) signame = "ALRM";
9429 if (code == TS_SIGFPE) signame = "FPE";
9430 if (code == TS_SIGHUP) signame = "HUP";
9431 if (code == TS_SIGILL) signame = "ILL";
9432 if (code == TS_SIGINT) signame = "INT";
9433 if (code == TS_SIGKILL) signame = "KILL";
9434 if (code == TS_SIGPIPE) signame = "PIPE";
9435 if (code == TS_SIGQUIT) signame = "QUIT";
9436 if (code == TS_SIGSEGV) signame = "SEGV";
9437 if (code == TS_SIGTERM) signame = "TERM";
9438 if (code == TS_SIGUSR1) signame = "USR1";
9439 if (code == TS_SIGUSR2) signame = "USR2";
9440 /* The SSH-2 protocol does in principle support arbitrary named
9441 * signals, including signame@domain, but we don't support those. */
9442 if (signame) {
9443 /* It's a signal. */
9444 if (ssh->version == 2 && ssh->mainchan) {
ff3187f6 9445 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST);
9446 ssh2_pkt_adduint32(pktout, ssh->mainchan->remoteid);
9447 ssh2_pkt_addstring(pktout, "signal");
9448 ssh2_pkt_addbool(pktout, 0);
9449 ssh2_pkt_addstring(pktout, signame);
9450 ssh2_pkt_send(ssh, pktout);
6f2d0cde 9451 logeventf(ssh, "Sent signal SIG%s", signame);
9452 }
9453 } else {
9454 /* Never heard of it. Do nothing */
9455 }
6abbf9e3 9456 }
374330e2 9457}
9458
51470298 9459void *new_sock_channel(void *handle, Socket s)
d74d141c 9460{
51470298 9461 Ssh ssh = (Ssh) handle;
d74d141c 9462 struct ssh_channel *c;
3d88e64d 9463 c = snew(struct ssh_channel);
d74d141c 9464
70c0cbe1 9465 c->ssh = ssh;
9466 ssh2_channel_init(c);
9467 c->halfopen = TRUE;
9468 c->type = CHAN_SOCKDATA_DORMANT;/* identify channel type */
9469 c->u.pfd.s = s;
9470 add234(ssh->channels, c);
d74d141c 9471 return c;
9472}
9473
5471d09a 9474/*
9475 * This is called when stdout/stderr (the entity to which
9476 * from_backend sends data) manages to clear some backlog.
9477 */
ae9ae89f 9478static void ssh_unthrottle(void *handle, int bufsize)
5471d09a 9479{
51470298 9480 Ssh ssh = (Ssh) handle;
ff68564b 9481 int buflimit;
9482
51470298 9483 if (ssh->version == 1) {
9484 if (ssh->v1_stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
9485 ssh->v1_stdout_throttling = 0;
ff68564b 9486 ssh_throttle_conn(ssh, -1);
5471d09a 9487 }
9488 } else {
ff68564b 9489 if (ssh->mainchan) {
ab87bf1d 9490 ssh2_set_window(ssh->mainchan,
ff68564b 9491 bufsize < ssh->mainchan->v.v2.locmaxwin ?
9492 ssh->mainchan->v.v2.locmaxwin - bufsize : 0);
9493 if (ssh->cfg.ssh_simple)
9494 buflimit = 0;
9495 else
9496 buflimit = ssh->mainchan->v.v2.locmaxwin;
9497 if (ssh->mainchan->throttling_conn && bufsize <= buflimit) {
9498 ssh->mainchan->throttling_conn = 0;
9499 ssh_throttle_conn(ssh, -1);
9500 }
9501 }
5471d09a 9502 }
9503}
9504
6b78788a 9505void ssh_send_port_open(void *channel, char *hostname, int port, char *org)
d74d141c 9506{
9507 struct ssh_channel *c = (struct ssh_channel *)channel;
6b78788a 9508 Ssh ssh = c->ssh;
ff3187f6 9509 struct Packet *pktout;
d74d141c 9510
57356d63 9511 logeventf(ssh, "Opening forwarded connection to %s:%d", hostname, port);
d74d141c 9512
51470298 9513 if (ssh->version == 1) {
9514 send_packet(ssh, SSH1_MSG_PORT_OPEN,
bc240b21 9515 PKT_INT, c->localid,
9516 PKT_STR, hostname,
9517 PKT_INT, port,
31fb1866 9518 /* PKT_STR, <org:orgport>, */
bc240b21 9519 PKT_END);
9520 } else {
ff3187f6 9521 pktout = ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN);
9522 ssh2_pkt_addstring(pktout, "direct-tcpip");
9523 ssh2_pkt_adduint32(pktout, c->localid);
ff3187f6 9524 ssh2_pkt_adduint32(pktout, c->v.v2.locwindow);/* our window size */
954d5c5a 9525 ssh2_pkt_adduint32(pktout, OUR_V2_MAXPKT); /* our max pkt size */
ff3187f6 9526 ssh2_pkt_addstring(pktout, hostname);
9527 ssh2_pkt_adduint32(pktout, port);
bc240b21 9528 /*
9529 * We make up values for the originator data; partly it's
9530 * too much hassle to keep track, and partly I'm not
9531 * convinced the server should be told details like that
9532 * about my local network configuration.
1f182589 9533 * The "originator IP address" is syntactically a numeric
9534 * IP address, and some servers (e.g., Tectia) get upset
9535 * if it doesn't match this syntax.
bc240b21 9536 */
1f182589 9537 ssh2_pkt_addstring(pktout, "0.0.0.0");
ff3187f6 9538 ssh2_pkt_adduint32(pktout, 0);
9539 ssh2_pkt_send(ssh, pktout);
bc240b21 9540 }
d74d141c 9541}
9542
6226c939 9543static int ssh_connected(void *handle)
32874aea 9544{
51470298 9545 Ssh ssh = (Ssh) handle;
6226c939 9546 return ssh->s != NULL;
32874aea 9547}
8ccc75b0 9548
51470298 9549static int ssh_sendok(void *handle)
32874aea 9550{
51470298 9551 Ssh ssh = (Ssh) handle;
9552 return ssh->send_ok;
32874aea 9553}
fb09bf1c 9554
51470298 9555static int ssh_ldisc(void *handle, int option)
32874aea 9556{
51470298 9557 Ssh ssh = (Ssh) handle;
32874aea 9558 if (option == LD_ECHO)
51470298 9559 return ssh->echoing;
32874aea 9560 if (option == LD_EDIT)
51470298 9561 return ssh->editing;
0965bee0 9562 return FALSE;
9563}
9564
b9d7bcad 9565static void ssh_provide_ldisc(void *handle, void *ldisc)
9566{
9567 Ssh ssh = (Ssh) handle;
9568 ssh->ldisc = ldisc;
9569}
9570
a8327734 9571static void ssh_provide_logctx(void *handle, void *logctx)
9572{
9573 Ssh ssh = (Ssh) handle;
9574 ssh->logctx = logctx;
9575}
9576
51470298 9577static int ssh_return_exitcode(void *handle)
9578{
9579 Ssh ssh = (Ssh) handle;
3bb2f322 9580 if (ssh->s != NULL)
9581 return -1;
9582 else
3c112d53 9583 return (ssh->exitcode >= 0 ? ssh->exitcode : INT_MAX);
51470298 9584}
9585
9586/*
f89c3294 9587 * cfg_info for SSH is the currently running version of the
9588 * protocol. (1 for 1; 2 for 2; 0 for not-decided-yet.)
9589 */
9590static int ssh_cfg_info(void *handle)
9591{
9592 Ssh ssh = (Ssh) handle;
9593 return ssh->version;
9594}
9595
9596/*
51470298 9597 * Gross hack: pscp will try to start SFTP but fall back to scp1 if
9598 * that fails. This variable is the means by which scp.c can reach
9599 * into the SSH code and find out which one it got.
9600 */
9601extern int ssh_fallback_cmd(void *handle)
d8d6c7e5 9602{
51470298 9603 Ssh ssh = (Ssh) handle;
9604 return ssh->fallback_cmd;
d8d6c7e5 9605}
9606
374330e2 9607Backend ssh_backend = {
9608 ssh_init,
fabd1805 9609 ssh_free,
86916870 9610 ssh_reconfig,
374330e2 9611 ssh_send,
5471d09a 9612 ssh_sendbuffer,
374330e2 9613 ssh_size,
4017be6d 9614 ssh_special,
125105d1 9615 ssh_get_specials,
6226c939 9616 ssh_connected,
d8d6c7e5 9617 ssh_return_exitcode,
97db3be4 9618 ssh_sendok,
0965bee0 9619 ssh_ldisc,
b9d7bcad 9620 ssh_provide_ldisc,
a8327734 9621 ssh_provide_logctx,
5471d09a 9622 ssh_unthrottle,
f89c3294 9623 ssh_cfg_info,
9e164d82 9624 "ssh",
9625 PROT_SSH,
97db3be4 9626 22
bc240b21 9627};
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator