27 #define SSH1_MSG_DISCONNECT 1 /* 0x1 */
28 #define SSH1_SMSG_PUBLIC_KEY 2 /* 0x2 */
29 #define SSH1_CMSG_SESSION_KEY 3 /* 0x3 */
30 #define SSH1_CMSG_USER 4 /* 0x4 */
31 #define SSH1_CMSG_AUTH_RSA 6 /* 0x6 */
32 #define SSH1_SMSG_AUTH_RSA_CHALLENGE 7 /* 0x7 */
33 #define SSH1_CMSG_AUTH_RSA_RESPONSE 8 /* 0x8 */
34 #define SSH1_CMSG_AUTH_PASSWORD 9 /* 0x9 */
35 #define SSH1_CMSG_REQUEST_PTY 10 /* 0xa */
36 #define SSH1_CMSG_WINDOW_SIZE 11 /* 0xb */
37 #define SSH1_CMSG_EXEC_SHELL 12 /* 0xc */
38 #define SSH1_CMSG_EXEC_CMD 13 /* 0xd */
39 #define SSH1_SMSG_SUCCESS 14 /* 0xe */
40 #define SSH1_SMSG_FAILURE 15 /* 0xf */
41 #define SSH1_CMSG_STDIN_DATA 16 /* 0x10 */
42 #define SSH1_SMSG_STDOUT_DATA 17 /* 0x11 */
43 #define SSH1_SMSG_STDERR_DATA 18 /* 0x12 */
44 #define SSH1_CMSG_EOF 19 /* 0x13 */
45 #define SSH1_SMSG_EXIT_STATUS 20 /* 0x14 */
46 #define SSH1_MSG_CHANNEL_OPEN_CONFIRMATION 21 /* 0x15 */
47 #define SSH1_MSG_CHANNEL_OPEN_FAILURE 22 /* 0x16 */
48 #define SSH1_MSG_CHANNEL_DATA 23 /* 0x17 */
49 #define SSH1_MSG_CHANNEL_CLOSE 24 /* 0x18 */
50 #define SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION 25 /* 0x19 */
51 #define SSH1_SMSG_X11_OPEN 27 /* 0x1b */
52 #define SSH1_CMSG_PORT_FORWARD_REQUEST 28 /* 0x1c */
53 #define SSH1_MSG_PORT_OPEN 29 /* 0x1d */
54 #define SSH1_CMSG_AGENT_REQUEST_FORWARDING 30 /* 0x1e */
55 #define SSH1_SMSG_AGENT_OPEN 31 /* 0x1f */
56 #define SSH1_MSG_IGNORE 32 /* 0x20 */
57 #define SSH1_CMSG_EXIT_CONFIRMATION 33 /* 0x21 */
58 #define SSH1_CMSG_X11_REQUEST_FORWARDING 34 /* 0x22 */
59 #define SSH1_CMSG_AUTH_RHOSTS_RSA 35 /* 0x23 */
60 #define SSH1_MSG_DEBUG 36 /* 0x24 */
61 #define SSH1_CMSG_REQUEST_COMPRESSION 37 /* 0x25 */
62 #define SSH1_CMSG_AUTH_TIS 39 /* 0x27 */
63 #define SSH1_SMSG_AUTH_TIS_CHALLENGE 40 /* 0x28 */
64 #define SSH1_CMSG_AUTH_TIS_RESPONSE 41 /* 0x29 */
65 #define SSH1_CMSG_AUTH_CCARD 70 /* 0x46 */
66 #define SSH1_SMSG_AUTH_CCARD_CHALLENGE 71 /* 0x47 */
67 #define SSH1_CMSG_AUTH_CCARD_RESPONSE 72 /* 0x48 */
69 #define SSH1_AUTH_RHOSTS 1 /* 0x1 */
70 #define SSH1_AUTH_RSA 2 /* 0x2 */
71 #define SSH1_AUTH_PASSWORD 3 /* 0x3 */
72 #define SSH1_AUTH_RHOSTS_RSA 4 /* 0x4 */
73 #define SSH1_AUTH_TIS 5 /* 0x5 */
74 #define SSH1_AUTH_CCARD 16 /* 0x10 */
76 #define SSH1_PROTOFLAG_SCREEN_NUMBER 1 /* 0x1 */
77 /* Mask for protoflags we will echo back to server if seen */
78 #define SSH1_PROTOFLAGS_SUPPORTED 0 /* 0x1 */
80 #define SSH2_MSG_DISCONNECT 1 /* 0x1 */
81 #define SSH2_MSG_IGNORE 2 /* 0x2 */
82 #define SSH2_MSG_UNIMPLEMENTED 3 /* 0x3 */
83 #define SSH2_MSG_DEBUG 4 /* 0x4 */
84 #define SSH2_MSG_SERVICE_REQUEST 5 /* 0x5 */
85 #define SSH2_MSG_SERVICE_ACCEPT 6 /* 0x6 */
86 #define SSH2_MSG_KEXINIT 20 /* 0x14 */
87 #define SSH2_MSG_NEWKEYS 21 /* 0x15 */
88 #define SSH2_MSG_KEXDH_INIT 30 /* 0x1e */
89 #define SSH2_MSG_KEXDH_REPLY 31 /* 0x1f */
90 #define SSH2_MSG_KEX_DH_GEX_REQUEST 30 /* 0x1e */
91 #define SSH2_MSG_KEX_DH_GEX_GROUP 31 /* 0x1f */
92 #define SSH2_MSG_KEX_DH_GEX_INIT 32 /* 0x20 */
93 #define SSH2_MSG_KEX_DH_GEX_REPLY 33 /* 0x21 */
94 #define SSH2_MSG_KEXRSA_PUBKEY 30 /* 0x1e */
95 #define SSH2_MSG_KEXRSA_SECRET 31 /* 0x1f */
96 #define SSH2_MSG_KEXRSA_DONE 32 /* 0x20 */
97 #define SSH2_MSG_USERAUTH_REQUEST 50 /* 0x32 */
98 #define SSH2_MSG_USERAUTH_FAILURE 51 /* 0x33 */
99 #define SSH2_MSG_USERAUTH_SUCCESS 52 /* 0x34 */
100 #define SSH2_MSG_USERAUTH_BANNER 53 /* 0x35 */
101 #define SSH2_MSG_USERAUTH_PK_OK 60 /* 0x3c */
102 #define SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ 60 /* 0x3c */
103 #define SSH2_MSG_USERAUTH_INFO_REQUEST 60 /* 0x3c */
104 #define SSH2_MSG_USERAUTH_INFO_RESPONSE 61 /* 0x3d */
105 #define SSH2_MSG_GLOBAL_REQUEST 80 /* 0x50 */
106 #define SSH2_MSG_REQUEST_SUCCESS 81 /* 0x51 */
107 #define SSH2_MSG_REQUEST_FAILURE 82 /* 0x52 */
108 #define SSH2_MSG_CHANNEL_OPEN 90 /* 0x5a */
109 #define SSH2_MSG_CHANNEL_OPEN_CONFIRMATION 91 /* 0x5b */
110 #define SSH2_MSG_CHANNEL_OPEN_FAILURE 92 /* 0x5c */
111 #define SSH2_MSG_CHANNEL_WINDOW_ADJUST 93 /* 0x5d */
112 #define SSH2_MSG_CHANNEL_DATA 94 /* 0x5e */
113 #define SSH2_MSG_CHANNEL_EXTENDED_DATA 95 /* 0x5f */
114 #define SSH2_MSG_CHANNEL_EOF 96 /* 0x60 */
115 #define SSH2_MSG_CHANNEL_CLOSE 97 /* 0x61 */
116 #define SSH2_MSG_CHANNEL_REQUEST 98 /* 0x62 */
117 #define SSH2_MSG_CHANNEL_SUCCESS 99 /* 0x63 */
118 #define SSH2_MSG_CHANNEL_FAILURE 100 /* 0x64 */
119 #define SSH2_MSG_USERAUTH_GSSAPI_RESPONSE 60
120 #define SSH2_MSG_USERAUTH_GSSAPI_TOKEN 61
121 #define SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE 63
122 #define SSH2_MSG_USERAUTH_GSSAPI_ERROR 64
123 #define SSH2_MSG_USERAUTH_GSSAPI_ERRTOK 65
124 #define SSH2_MSG_USERAUTH_GSSAPI_MIC 66
127 * Packet type contexts, so that ssh2_pkt_type can correctly decode
128 * the ambiguous type numbers back into the correct type strings.
138 SSH2_PKTCTX_PUBLICKEY
,
139 SSH2_PKTCTX_PASSWORD
,
144 #define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1 /* 0x1 */
145 #define SSH2_DISCONNECT_PROTOCOL_ERROR 2 /* 0x2 */
146 #define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED 3 /* 0x3 */
147 #define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4 /* 0x4 */
148 #define SSH2_DISCONNECT_MAC_ERROR 5 /* 0x5 */
149 #define SSH2_DISCONNECT_COMPRESSION_ERROR 6 /* 0x6 */
150 #define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE 7 /* 0x7 */
151 #define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8 /* 0x8 */
152 #define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9 /* 0x9 */
153 #define SSH2_DISCONNECT_CONNECTION_LOST 10 /* 0xa */
154 #define SSH2_DISCONNECT_BY_APPLICATION 11 /* 0xb */
155 #define SSH2_DISCONNECT_TOO_MANY_CONNECTIONS 12 /* 0xc */
156 #define SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER 13 /* 0xd */
157 #define SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14 /* 0xe */
158 #define SSH2_DISCONNECT_ILLEGAL_USER_NAME 15 /* 0xf */
160 static const char *const ssh2_disconnect_reasons
[] = {
162 "host not allowed to connect",
164 "key exchange failed",
165 "host authentication failed",
168 "service not available",
169 "protocol version not supported",
170 "host key not verifiable",
173 "too many connections",
174 "auth cancelled by user",
175 "no more auth methods available",
179 #define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED 1 /* 0x1 */
180 #define SSH2_OPEN_CONNECT_FAILED 2 /* 0x2 */
181 #define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE 3 /* 0x3 */
182 #define SSH2_OPEN_RESOURCE_SHORTAGE 4 /* 0x4 */
184 #define SSH2_EXTENDED_DATA_STDERR 1 /* 0x1 */
187 * Various remote-bug flags.
189 #define BUG_CHOKES_ON_SSH1_IGNORE 1
190 #define BUG_SSH2_HMAC 2
191 #define BUG_NEEDS_SSH1_PLAIN_PASSWORD 4
192 #define BUG_CHOKES_ON_RSA 8
193 #define BUG_SSH2_RSA_PADDING 16
194 #define BUG_SSH2_DERIVEKEY 32
195 #define BUG_SSH2_REKEY 64
196 #define BUG_SSH2_PK_SESSIONID 128
197 #define BUG_SSH2_MAXPKT 256
198 #define BUG_CHOKES_ON_SSH2_IGNORE 512
199 #define BUG_CHOKES_ON_WINADJ 1024
202 * Codes for terminal modes.
203 * Most of these are the same in SSH-1 and SSH-2.
204 * This list is derived from RFC 4254 and
207 static const struct {
208 const char* const mode
;
210 enum { TTY_OP_CHAR
, TTY_OP_BOOL
} type
;
212 /* "V" prefix discarded for special characters relative to SSH specs */
213 { "INTR", 1, TTY_OP_CHAR
},
214 { "QUIT", 2, TTY_OP_CHAR
},
215 { "ERASE", 3, TTY_OP_CHAR
},
216 { "KILL", 4, TTY_OP_CHAR
},
217 { "EOF", 5, TTY_OP_CHAR
},
218 { "EOL", 6, TTY_OP_CHAR
},
219 { "EOL2", 7, TTY_OP_CHAR
},
220 { "START", 8, TTY_OP_CHAR
},
221 { "STOP", 9, TTY_OP_CHAR
},
222 { "SUSP", 10, TTY_OP_CHAR
},
223 { "DSUSP", 11, TTY_OP_CHAR
},
224 { "REPRINT", 12, TTY_OP_CHAR
},
225 { "WERASE", 13, TTY_OP_CHAR
},
226 { "LNEXT", 14, TTY_OP_CHAR
},
227 { "FLUSH", 15, TTY_OP_CHAR
},
228 { "SWTCH", 16, TTY_OP_CHAR
},
229 { "STATUS", 17, TTY_OP_CHAR
},
230 { "DISCARD", 18, TTY_OP_CHAR
},
231 { "IGNPAR", 30, TTY_OP_BOOL
},
232 { "PARMRK", 31, TTY_OP_BOOL
},
233 { "INPCK", 32, TTY_OP_BOOL
},
234 { "ISTRIP", 33, TTY_OP_BOOL
},
235 { "INLCR", 34, TTY_OP_BOOL
},
236 { "IGNCR", 35, TTY_OP_BOOL
},
237 { "ICRNL", 36, TTY_OP_BOOL
},
238 { "IUCLC", 37, TTY_OP_BOOL
},
239 { "IXON", 38, TTY_OP_BOOL
},
240 { "IXANY", 39, TTY_OP_BOOL
},
241 { "IXOFF", 40, TTY_OP_BOOL
},
242 { "IMAXBEL", 41, TTY_OP_BOOL
},
243 { "ISIG", 50, TTY_OP_BOOL
},
244 { "ICANON", 51, TTY_OP_BOOL
},
245 { "XCASE", 52, TTY_OP_BOOL
},
246 { "ECHO", 53, TTY_OP_BOOL
},
247 { "ECHOE", 54, TTY_OP_BOOL
},
248 { "ECHOK", 55, TTY_OP_BOOL
},
249 { "ECHONL", 56, TTY_OP_BOOL
},
250 { "NOFLSH", 57, TTY_OP_BOOL
},
251 { "TOSTOP", 58, TTY_OP_BOOL
},
252 { "IEXTEN", 59, TTY_OP_BOOL
},
253 { "ECHOCTL", 60, TTY_OP_BOOL
},
254 { "ECHOKE", 61, TTY_OP_BOOL
},
255 { "PENDIN", 62, TTY_OP_BOOL
}, /* XXX is this a real mode? */
256 { "OPOST", 70, TTY_OP_BOOL
},
257 { "OLCUC", 71, TTY_OP_BOOL
},
258 { "ONLCR", 72, TTY_OP_BOOL
},
259 { "OCRNL", 73, TTY_OP_BOOL
},
260 { "ONOCR", 74, TTY_OP_BOOL
},
261 { "ONLRET", 75, TTY_OP_BOOL
},
262 { "CS7", 90, TTY_OP_BOOL
},
263 { "CS8", 91, TTY_OP_BOOL
},
264 { "PARENB", 92, TTY_OP_BOOL
},
265 { "PARODD", 93, TTY_OP_BOOL
}
268 /* Miscellaneous other tty-related constants. */
269 #define SSH_TTY_OP_END 0
270 /* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */
271 #define SSH1_TTY_OP_ISPEED 192
272 #define SSH1_TTY_OP_OSPEED 193
273 #define SSH2_TTY_OP_ISPEED 128
274 #define SSH2_TTY_OP_OSPEED 129
276 /* Helper functions for parsing tty-related config. */
277 static unsigned int ssh_tty_parse_specchar(char *s
)
282 ret
= ctrlparse(s
, &next
);
283 if (!next
) ret
= s
[0];
285 ret
= 255; /* special value meaning "don't set" */
289 static unsigned int ssh_tty_parse_boolean(char *s
)
291 if (stricmp(s
, "yes") == 0 ||
292 stricmp(s
, "on") == 0 ||
293 stricmp(s
, "true") == 0 ||
294 stricmp(s
, "+") == 0)
296 else if (stricmp(s
, "no") == 0 ||
297 stricmp(s
, "off") == 0 ||
298 stricmp(s
, "false") == 0 ||
299 stricmp(s
, "-") == 0)
300 return 0; /* false */
302 return (atoi(s
) != 0);
305 #define translate(x) if (type == x) return #x
306 #define translatek(x,ctx) if (type == x && (pkt_kctx == ctx)) return #x
307 #define translatea(x,ctx) if (type == x && (pkt_actx == ctx)) return #x
308 static char *ssh1_pkt_type(int type
)
310 translate(SSH1_MSG_DISCONNECT
);
311 translate(SSH1_SMSG_PUBLIC_KEY
);
312 translate(SSH1_CMSG_SESSION_KEY
);
313 translate(SSH1_CMSG_USER
);
314 translate(SSH1_CMSG_AUTH_RSA
);
315 translate(SSH1_SMSG_AUTH_RSA_CHALLENGE
);
316 translate(SSH1_CMSG_AUTH_RSA_RESPONSE
);
317 translate(SSH1_CMSG_AUTH_PASSWORD
);
318 translate(SSH1_CMSG_REQUEST_PTY
);
319 translate(SSH1_CMSG_WINDOW_SIZE
);
320 translate(SSH1_CMSG_EXEC_SHELL
);
321 translate(SSH1_CMSG_EXEC_CMD
);
322 translate(SSH1_SMSG_SUCCESS
);
323 translate(SSH1_SMSG_FAILURE
);
324 translate(SSH1_CMSG_STDIN_DATA
);
325 translate(SSH1_SMSG_STDOUT_DATA
);
326 translate(SSH1_SMSG_STDERR_DATA
);
327 translate(SSH1_CMSG_EOF
);
328 translate(SSH1_SMSG_EXIT_STATUS
);
329 translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
);
330 translate(SSH1_MSG_CHANNEL_OPEN_FAILURE
);
331 translate(SSH1_MSG_CHANNEL_DATA
);
332 translate(SSH1_MSG_CHANNEL_CLOSE
);
333 translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
);
334 translate(SSH1_SMSG_X11_OPEN
);
335 translate(SSH1_CMSG_PORT_FORWARD_REQUEST
);
336 translate(SSH1_MSG_PORT_OPEN
);
337 translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING
);
338 translate(SSH1_SMSG_AGENT_OPEN
);
339 translate(SSH1_MSG_IGNORE
);
340 translate(SSH1_CMSG_EXIT_CONFIRMATION
);
341 translate(SSH1_CMSG_X11_REQUEST_FORWARDING
);
342 translate(SSH1_CMSG_AUTH_RHOSTS_RSA
);
343 translate(SSH1_MSG_DEBUG
);
344 translate(SSH1_CMSG_REQUEST_COMPRESSION
);
345 translate(SSH1_CMSG_AUTH_TIS
);
346 translate(SSH1_SMSG_AUTH_TIS_CHALLENGE
);
347 translate(SSH1_CMSG_AUTH_TIS_RESPONSE
);
348 translate(SSH1_CMSG_AUTH_CCARD
);
349 translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE
);
350 translate(SSH1_CMSG_AUTH_CCARD_RESPONSE
);
353 static char *ssh2_pkt_type(Pkt_KCtx pkt_kctx
, Pkt_ACtx pkt_actx
, int type
)
355 translatea(SSH2_MSG_USERAUTH_GSSAPI_RESPONSE
,SSH2_PKTCTX_GSSAPI
);
356 translatea(SSH2_MSG_USERAUTH_GSSAPI_TOKEN
,SSH2_PKTCTX_GSSAPI
);
357 translatea(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE
,SSH2_PKTCTX_GSSAPI
);
358 translatea(SSH2_MSG_USERAUTH_GSSAPI_ERROR
,SSH2_PKTCTX_GSSAPI
);
359 translatea(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK
,SSH2_PKTCTX_GSSAPI
);
360 translatea(SSH2_MSG_USERAUTH_GSSAPI_MIC
, SSH2_PKTCTX_GSSAPI
);
361 translate(SSH2_MSG_DISCONNECT
);
362 translate(SSH2_MSG_IGNORE
);
363 translate(SSH2_MSG_UNIMPLEMENTED
);
364 translate(SSH2_MSG_DEBUG
);
365 translate(SSH2_MSG_SERVICE_REQUEST
);
366 translate(SSH2_MSG_SERVICE_ACCEPT
);
367 translate(SSH2_MSG_KEXINIT
);
368 translate(SSH2_MSG_NEWKEYS
);
369 translatek(SSH2_MSG_KEXDH_INIT
, SSH2_PKTCTX_DHGROUP
);
370 translatek(SSH2_MSG_KEXDH_REPLY
, SSH2_PKTCTX_DHGROUP
);
371 translatek(SSH2_MSG_KEX_DH_GEX_REQUEST
, SSH2_PKTCTX_DHGEX
);
372 translatek(SSH2_MSG_KEX_DH_GEX_GROUP
, SSH2_PKTCTX_DHGEX
);
373 translatek(SSH2_MSG_KEX_DH_GEX_INIT
, SSH2_PKTCTX_DHGEX
);
374 translatek(SSH2_MSG_KEX_DH_GEX_REPLY
, SSH2_PKTCTX_DHGEX
);
375 translatek(SSH2_MSG_KEXRSA_PUBKEY
, SSH2_PKTCTX_RSAKEX
);
376 translatek(SSH2_MSG_KEXRSA_SECRET
, SSH2_PKTCTX_RSAKEX
);
377 translatek(SSH2_MSG_KEXRSA_DONE
, SSH2_PKTCTX_RSAKEX
);
378 translate(SSH2_MSG_USERAUTH_REQUEST
);
379 translate(SSH2_MSG_USERAUTH_FAILURE
);
380 translate(SSH2_MSG_USERAUTH_SUCCESS
);
381 translate(SSH2_MSG_USERAUTH_BANNER
);
382 translatea(SSH2_MSG_USERAUTH_PK_OK
, SSH2_PKTCTX_PUBLICKEY
);
383 translatea(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ
, SSH2_PKTCTX_PASSWORD
);
384 translatea(SSH2_MSG_USERAUTH_INFO_REQUEST
, SSH2_PKTCTX_KBDINTER
);
385 translatea(SSH2_MSG_USERAUTH_INFO_RESPONSE
, SSH2_PKTCTX_KBDINTER
);
386 translate(SSH2_MSG_GLOBAL_REQUEST
);
387 translate(SSH2_MSG_REQUEST_SUCCESS
);
388 translate(SSH2_MSG_REQUEST_FAILURE
);
389 translate(SSH2_MSG_CHANNEL_OPEN
);
390 translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
);
391 translate(SSH2_MSG_CHANNEL_OPEN_FAILURE
);
392 translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST
);
393 translate(SSH2_MSG_CHANNEL_DATA
);
394 translate(SSH2_MSG_CHANNEL_EXTENDED_DATA
);
395 translate(SSH2_MSG_CHANNEL_EOF
);
396 translate(SSH2_MSG_CHANNEL_CLOSE
);
397 translate(SSH2_MSG_CHANNEL_REQUEST
);
398 translate(SSH2_MSG_CHANNEL_SUCCESS
);
399 translate(SSH2_MSG_CHANNEL_FAILURE
);
405 /* Enumeration values for fields in SSH-1 packets */
407 PKT_END
, PKT_INT
, PKT_CHAR
, PKT_DATA
, PKT_STR
, PKT_BIGNUM
,
408 /* These values are for communicating relevant semantics of
409 * fields to the packet logging code. */
410 PKTT_OTHER
, PKTT_PASSWORD
, PKTT_DATA
414 * Coroutine mechanics for the sillier bits of the code. If these
415 * macros look impenetrable to you, you might find it helpful to
418 * http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
420 * which explains the theory behind these macros.
422 * In particular, if you are getting `case expression not constant'
423 * errors when building with MS Visual Studio, this is because MS's
424 * Edit and Continue debugging feature causes their compiler to
425 * violate ANSI C. To disable Edit and Continue debugging:
427 * - right-click ssh.c in the FileView
429 * - select the C/C++ tab and the General category
430 * - under `Debug info:', select anything _other_ than `Program
431 * Database for Edit and Continue'.
433 #define crBegin(v) { int *crLine = &v; switch(v) { case 0:;
434 #define crBeginState crBegin(s->crLine)
435 #define crStateP(t, v) \
437 if (!(v)) { s = (v) = snew(struct t); s->crLine = 0; } \
439 #define crState(t) crStateP(t, ssh->t)
440 #define crFinish(z) } *crLine = 0; return (z); }
441 #define crFinishV } *crLine = 0; return; }
442 #define crReturn(z) \
444 *crLine =__LINE__; return (z); case __LINE__:;\
448 *crLine=__LINE__; return; case __LINE__:;\
450 #define crStop(z) do{ *crLine = 0; return (z); }while(0)
451 #define crStopV do{ *crLine = 0; return; }while(0)
452 #define crWaitUntil(c) do { crReturn(0); } while (!(c))
453 #define crWaitUntilV(c) do { crReturnV; } while (!(c))
455 typedef struct ssh_tag
*Ssh
;
458 static struct Packet
*ssh1_pkt_init(int pkt_type
);
459 static struct Packet
*ssh2_pkt_init(int pkt_type
);
460 static void ssh_pkt_ensure(struct Packet
*, int length
);
461 static void ssh_pkt_adddata(struct Packet
*, void *data
, int len
);
462 static void ssh_pkt_addbyte(struct Packet
*, unsigned char value
);
463 static void ssh2_pkt_addbool(struct Packet
*, unsigned char value
);
464 static void ssh_pkt_adduint32(struct Packet
*, unsigned long value
);
465 static void ssh_pkt_addstring_start(struct Packet
*);
466 static void ssh_pkt_addstring_str(struct Packet
*, char *data
);
467 static void ssh_pkt_addstring_data(struct Packet
*, char *data
, int len
);
468 static void ssh_pkt_addstring(struct Packet
*, char *data
);
469 static unsigned char *ssh2_mpint_fmt(Bignum b
, int *len
);
470 static void ssh1_pkt_addmp(struct Packet
*, Bignum b
);
471 static void ssh2_pkt_addmp(struct Packet
*, Bignum b
);
472 static int ssh2_pkt_construct(Ssh
, struct Packet
*);
473 static void ssh2_pkt_send(Ssh
, struct Packet
*);
474 static void ssh2_pkt_send_noqueue(Ssh
, struct Packet
*);
475 static int do_ssh1_login(Ssh ssh
, unsigned char *in
, int inlen
,
476 struct Packet
*pktin
);
477 static void do_ssh2_authconn(Ssh ssh
, unsigned char *in
, int inlen
,
478 struct Packet
*pktin
);
479 static void ssh2_channel_check_close(struct ssh_channel
*c
);
480 static void ssh_channel_destroy(struct ssh_channel
*c
);
483 * Buffer management constants. There are several of these for
484 * various different purposes:
486 * - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
487 * on a local data stream before we throttle the whole SSH
488 * connection (in SSH-1 only). Throttling the whole connection is
489 * pretty drastic so we set this high in the hope it won't
492 * - SSH_MAX_BACKLOG is the amount of backlog that must build up
493 * on the SSH connection itself before we defensively throttle
494 * _all_ local data streams. This is pretty drastic too (though
495 * thankfully unlikely in SSH-2 since the window mechanism should
496 * ensure that the server never has any need to throttle its end
497 * of the connection), so we set this high as well.
499 * - OUR_V2_WINSIZE is the maximum window size we present on SSH-2
502 * - OUR_V2_BIGWIN is the window size we advertise for the only
503 * channel in a simple connection. It must be <= INT_MAX.
505 * - OUR_V2_MAXPKT is the official "maximum packet size" we send
506 * to the remote side. This actually has nothing to do with the
507 * size of the _packet_, but is instead a limit on the amount
508 * of data we're willing to receive in a single SSH2 channel
511 * - OUR_V2_PACKETLIMIT is actually the maximum size of SSH
512 * _packet_ we're prepared to cope with. It must be a multiple
513 * of the cipher block size, and must be at least 35000.
516 #define SSH1_BUFFER_LIMIT 32768
517 #define SSH_MAX_BACKLOG 32768
518 #define OUR_V2_WINSIZE 16384
519 #define OUR_V2_BIGWIN 0x7fffffff
520 #define OUR_V2_MAXPKT 0x4000UL
521 #define OUR_V2_PACKETLIMIT 0x9000UL
523 const static struct ssh_signkey
*hostkey_algs
[] = { &ssh_rsa
, &ssh_dss
};
525 const static struct ssh_mac
*macs
[] = {
526 &ssh_hmac_sha1
, &ssh_hmac_sha1_96
, &ssh_hmac_md5
528 const static struct ssh_mac
*buggymacs
[] = {
529 &ssh_hmac_sha1_buggy
, &ssh_hmac_sha1_96_buggy
, &ssh_hmac_md5
532 static void *ssh_comp_none_init(void)
536 static void ssh_comp_none_cleanup(void *handle
)
539 static int ssh_comp_none_block(void *handle
, unsigned char *block
, int len
,
540 unsigned char **outblock
, int *outlen
)
544 static int ssh_comp_none_disable(void *handle
)
548 const static struct ssh_compress ssh_comp_none
= {
550 ssh_comp_none_init
, ssh_comp_none_cleanup
, ssh_comp_none_block
,
551 ssh_comp_none_init
, ssh_comp_none_cleanup
, ssh_comp_none_block
,
552 ssh_comp_none_disable
, NULL
554 extern const struct ssh_compress ssh_zlib
;
555 const static struct ssh_compress
*compressions
[] = {
556 &ssh_zlib
, &ssh_comp_none
559 enum { /* channel types */
564 CHAN_SOCKDATA_DORMANT
, /* one the remote hasn't confirmed */
566 * CHAN_ZOMBIE is used to indicate a channel for which we've
567 * already destroyed the local data source: for instance, if a
568 * forwarded port experiences a socket error on the local side, we
569 * immediately destroy its local socket and turn the SSH channel
575 typedef void (*handler_fn_t
)(Ssh ssh
, struct Packet
*pktin
);
576 typedef void (*chandler_fn_t
)(Ssh ssh
, struct Packet
*pktin
, void *ctx
);
577 typedef void (*cchandler_fn_t
)(struct ssh_channel
*, struct Packet
*, void *);
580 * Each channel has a queue of outstanding CHANNEL_REQUESTS and their
583 struct outstanding_channel_request
{
584 cchandler_fn_t handler
;
586 struct outstanding_channel_request
*next
;
590 * little structure to keep track of outstanding WINDOW_ADJUSTs
598 * 2-3-4 tree storing channels.
601 Ssh ssh
; /* pointer back to main context */
602 unsigned remoteid
, localid
;
604 /* True if we opened this channel but server hasn't confirmed. */
607 * In SSH-1, this value contains four bits:
609 * 1 We have sent SSH1_MSG_CHANNEL_CLOSE.
610 * 2 We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
611 * 4 We have received SSH1_MSG_CHANNEL_CLOSE.
612 * 8 We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
614 * A channel is completely finished with when all four bits are set.
616 * In SSH-2, the four bits mean:
618 * 1 We have sent SSH2_MSG_CHANNEL_EOF.
619 * 2 We have sent SSH2_MSG_CHANNEL_CLOSE.
620 * 4 We have received SSH2_MSG_CHANNEL_EOF.
621 * 8 We have received SSH2_MSG_CHANNEL_CLOSE.
623 * A channel is completely finished with when we have both sent
624 * and received CLOSE.
626 * The symbolic constants below use the SSH-2 terminology, which
627 * is a bit confusing in SSH-1, but we have to use _something_.
629 #define CLOSES_SENT_EOF 1
630 #define CLOSES_SENT_CLOSE 2
631 #define CLOSES_RCVD_EOF 4
632 #define CLOSES_RCVD_CLOSE 8
636 * This flag indicates that an EOF is pending on the outgoing side
637 * of the channel: that is, wherever we're getting the data for
638 * this channel has sent us some data followed by EOF. We can't
639 * actually send the EOF until we've finished sending the data, so
640 * we set this flag instead to remind us to do so once our buffer
646 * True if this channel is causing the underlying connection to be
651 struct ssh2_data_channel
{
653 unsigned remwindow
, remmaxpkt
;
654 /* locwindow is signed so we can cope with excess data. */
655 int locwindow
, locmaxwin
;
657 * remlocwin is the amount of local window that we think
658 * the remote end had available to it after it sent the
659 * last data packet or window adjust ack.
663 * These store the list of channel requests that haven't
666 struct outstanding_channel_request
*chanreq_head
, *chanreq_tail
;
667 enum { THROTTLED
, UNTHROTTLING
, UNTHROTTLED
} throttle_state
;
671 struct ssh_agent_channel
{
672 unsigned char *message
;
673 unsigned char msglen
[4];
674 unsigned lensofar
, totallen
;
676 struct ssh_x11_channel
{
679 struct ssh_pfd_channel
{
686 * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2
687 * use this structure in different ways, reflecting SSH-2's
688 * altogether saner approach to port forwarding.
690 * In SSH-1, you arrange a remote forwarding by sending the server
691 * the remote port number, and the local destination host:port.
692 * When a connection comes in, the server sends you back that
693 * host:port pair, and you connect to it. This is a ready-made
694 * security hole if you're not on the ball: a malicious server
695 * could send you back _any_ host:port pair, so if you trustingly
696 * connect to the address it gives you then you've just opened the
697 * entire inside of your corporate network just by connecting
698 * through it to a dodgy SSH server. Hence, we must store a list of
699 * host:port pairs we _are_ trying to forward to, and reject a
700 * connection request from the server if it's not in the list.
702 * In SSH-2, each side of the connection minds its own business and
703 * doesn't send unnecessary information to the other. You arrange a
704 * remote forwarding by sending the server just the remote port
705 * number. When a connection comes in, the server tells you which
706 * of its ports was connected to; and _you_ have to remember what
707 * local host:port pair went with that port number.
709 * Hence, in SSH-1 this structure is indexed by destination
710 * host:port pair, whereas in SSH-2 it is indexed by source port.
712 struct ssh_portfwd
; /* forward declaration */
714 struct ssh_rportfwd
{
715 unsigned sport
, dport
;
718 struct ssh_portfwd
*pfrec
;
720 #define free_rportfwd(pf) ( \
721 ((pf) ? (sfree((pf)->sportdesc)) : (void)0 ), sfree(pf) )
724 * Separately to the rportfwd tree (which is for looking up port
725 * open requests from the server), a tree of _these_ structures is
726 * used to keep track of all the currently open port forwardings,
727 * so that we can reconfigure in mid-session if the user requests
731 enum { DESTROY
, KEEP
, CREATE
} status
;
733 unsigned sport
, dport
;
736 struct ssh_rportfwd
*remote
;
740 #define free_portfwd(pf) ( \
741 ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr), \
742 sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) )
745 long length
; /* length of `data' actually used */
746 long forcepad
; /* SSH-2: force padding to at least this length */
747 int type
; /* only used for incoming packets */
748 unsigned long sequence
; /* SSH-2 incoming sequence number */
749 unsigned char *data
; /* allocated storage */
750 unsigned char *body
; /* offset of payload within `data' */
751 long savedpos
; /* temporary index into `data' (for strings) */
752 long maxlen
; /* amount of storage allocated for `data' */
753 long encrypted_len
; /* for SSH-2 total-size counting */
756 * State associated with packet logging
760 struct logblank_t
*blanks
;
763 static void ssh1_protocol(Ssh ssh
, void *vin
, int inlen
,
764 struct Packet
*pktin
);
765 static void ssh2_protocol(Ssh ssh
, void *vin
, int inlen
,
766 struct Packet
*pktin
);
767 static void ssh1_protocol_setup(Ssh ssh
);
768 static void ssh2_protocol_setup(Ssh ssh
);
769 static void ssh_size(void *handle
, int width
, int height
);
770 static void ssh_special(void *handle
, Telnet_Special
);
771 static int ssh2_try_send(struct ssh_channel
*c
);
772 static void ssh2_add_channel_data(struct ssh_channel
*c
, char *buf
, int len
);
773 static void ssh_throttle_all(Ssh ssh
, int enable
, int bufsize
);
774 static void ssh2_set_window(struct ssh_channel
*c
, int newwin
);
775 static int ssh_sendbuffer(void *handle
);
776 static int ssh_do_close(Ssh ssh
, int notify_exit
);
777 static unsigned long ssh_pkt_getuint32(struct Packet
*pkt
);
778 static int ssh2_pkt_getbool(struct Packet
*pkt
);
779 static void ssh_pkt_getstring(struct Packet
*pkt
, char **p
, int *length
);
780 static void ssh2_timer(void *ctx
, long now
);
781 static int do_ssh2_transport(Ssh ssh
, void *vin
, int inlen
,
782 struct Packet
*pktin
);
783 static void ssh2_msg_unexpected(Ssh ssh
, struct Packet
*pktin
);
785 struct rdpkt1_state_tag
{
786 long len
, pad
, biglen
, to_read
;
787 unsigned long realcrc
, gotcrc
;
791 struct Packet
*pktin
;
794 struct rdpkt2_state_tag
{
795 long len
, pad
, payload
, packetlen
, maclen
;
798 unsigned long incoming_sequence
;
799 struct Packet
*pktin
;
802 struct queued_handler
;
803 struct queued_handler
{
805 chandler_fn_t handler
;
807 struct queued_handler
*next
;
811 const struct plug_function_table
*fn
;
812 /* the above field _must_ be first in the structure */
822 unsigned char session_key
[32];
824 int v1_remote_protoflags
;
825 int v1_local_protoflags
;
826 int agentfwd_enabled
;
829 const struct ssh_cipher
*cipher
;
832 const struct ssh2_cipher
*cscipher
, *sccipher
;
833 void *cs_cipher_ctx
, *sc_cipher_ctx
;
834 const struct ssh_mac
*csmac
, *scmac
;
835 void *cs_mac_ctx
, *sc_mac_ctx
;
836 const struct ssh_compress
*cscomp
, *sccomp
;
837 void *cs_comp_ctx
, *sc_comp_ctx
;
838 const struct ssh_kex
*kex
;
839 const struct ssh_signkey
*hostkey
;
840 unsigned char v2_session_id
[SSH2_KEX_MAX_HASH_LEN
];
841 int v2_session_id_len
;
847 int echoing
, editing
;
851 int ospeed
, ispeed
; /* temporaries */
852 int term_width
, term_height
;
854 tree234
*channels
; /* indexed by local id */
855 struct ssh_channel
*mainchan
; /* primary session channel */
856 int ncmode
; /* is primary channel direct-tcpip? */
861 tree234
*rportfwds
, *portfwds
;
865 SSH_STATE_BEFORE_SIZE
,
871 int size_needed
, eof_needed
;
872 int sent_console_eof
;
873 int got_pty
; /* affects EOF behaviour on main channel */
875 struct Packet
**queue
;
876 int queuelen
, queuesize
;
878 unsigned char *deferred_send_data
;
879 int deferred_len
, deferred_size
;
882 * Gross hack: pscp will try to start SFTP but fall back to
883 * scp1 if that fails. This variable is the means by which
884 * scp.c can reach into the SSH code and find out which one it
889 bufchain banner
; /* accumulates banners during do_ssh2_authconn */
894 struct X11Display
*x11disp
;
897 int conn_throttle_count
;
900 int v1_stdout_throttling
;
901 unsigned long v2_outgoing_sequence
;
903 int ssh1_rdpkt_crstate
;
904 int ssh2_rdpkt_crstate
;
905 int ssh_gotdata_crstate
;
906 int do_ssh1_connection_crstate
;
908 void *do_ssh_init_state
;
909 void *do_ssh1_login_state
;
910 void *do_ssh2_transport_state
;
911 void *do_ssh2_authconn_state
;
913 struct rdpkt1_state_tag rdpkt1_state
;
914 struct rdpkt2_state_tag rdpkt2_state
;
916 /* SSH-1 and SSH-2 use this for different things, but both use it */
917 int protocol_initial_phase_done
;
919 void (*protocol
) (Ssh ssh
, void *vin
, int inlen
,
921 struct Packet
*(*s_rdpkt
) (Ssh ssh
, unsigned char **data
, int *datalen
);
924 * We maintain our own copy of a Conf structure here. That way,
925 * when we're passed a new one for reconfiguration, we can check
926 * the differences and potentially reconfigure port forwardings
927 * etc in mid-session.
932 * Values cached out of conf so as to avoid the tree234 lookup
933 * cost every time they're used.
938 * Dynamically allocated username string created during SSH
939 * login. Stored in here rather than in the coroutine state so
940 * that it'll be reliably freed if we shut down the SSH session
941 * at some unexpected moment.
946 * Used to transfer data back from async callbacks.
948 void *agent_response
;
949 int agent_response_len
;
953 * The SSH connection can be set as `frozen', meaning we are
954 * not currently accepting incoming data from the network. This
955 * is slightly more serious than setting the _socket_ as
956 * frozen, because we may already have had data passed to us
957 * from the network which we need to delay processing until
958 * after the freeze is lifted, so we also need a bufchain to
962 bufchain queued_incoming_data
;
965 * Dispatch table for packet types that we may have to deal
968 handler_fn_t packet_dispatch
[256];
971 * Queues of one-off handler functions for success/failure
972 * indications from a request.
974 struct queued_handler
*qhead
, *qtail
;
975 handler_fn_t q_saved_handler1
, q_saved_handler2
;
978 * This module deals with sending keepalives.
983 * Track incoming and outgoing data sizes and time, for
986 unsigned long incoming_data_size
, outgoing_data_size
, deferred_data_size
;
987 unsigned long max_data_size
;
989 long next_rekey
, last_rekey
;
990 char *deferred_rekey_reason
; /* points to STATIC string; don't free */
993 * Fully qualified host name, which we need if doing GSSAPI.
999 * GSSAPI libraries for this session.
1001 struct ssh_gss_liblist
*gsslibs
;
1005 #define logevent(s) logevent(ssh->frontend, s)
1007 /* logevent, only printf-formatted. */
1008 static void logeventf(Ssh ssh
, const char *fmt
, ...)
1014 buf
= dupvprintf(fmt
, ap
);
1020 #define bombout(msg) \
1022 char *text = dupprintf msg; \
1023 ssh_do_close(ssh, FALSE); \
1025 connection_fatal(ssh->frontend, "%s", text); \
1029 /* Functions to leave bits out of the SSH packet log file. */
1031 static void dont_log_password(Ssh ssh
, struct Packet
*pkt
, int blanktype
)
1033 if (conf_get_int(ssh
->conf
, CONF_logomitpass
))
1034 pkt
->logmode
= blanktype
;
1037 static void dont_log_data(Ssh ssh
, struct Packet
*pkt
, int blanktype
)
1039 if (ssh
->logomitdata
)
1040 pkt
->logmode
= blanktype
;
1043 static void end_log_omission(Ssh ssh
, struct Packet
*pkt
)
1045 pkt
->logmode
= PKTLOG_EMIT
;
1048 /* Helper function for common bits of parsing ttymodes. */
1049 static void parse_ttymodes(Ssh ssh
,
1050 void (*do_mode
)(void *data
, char *mode
, char *val
),
1055 for (val
= conf_get_str_strs(ssh
->conf
, CONF_ttymodes
, NULL
, &key
);
1057 val
= conf_get_str_strs(ssh
->conf
, CONF_ttymodes
, key
, &key
)) {
1059 * val[0] is either 'V', indicating that an explicit value
1060 * follows it, or 'A' indicating that we should pass the
1061 * value through from the local environment via get_ttymode.
1064 val
= get_ttymode(ssh
->frontend
, key
);
1066 val
++; /* skip the 'V' */
1068 do_mode(data
, key
, val
);
1072 static int ssh_channelcmp(void *av
, void *bv
)
1074 struct ssh_channel
*a
= (struct ssh_channel
*) av
;
1075 struct ssh_channel
*b
= (struct ssh_channel
*) bv
;
1076 if (a
->localid
< b
->localid
)
1078 if (a
->localid
> b
->localid
)
1082 static int ssh_channelfind(void *av
, void *bv
)
1084 unsigned *a
= (unsigned *) av
;
1085 struct ssh_channel
*b
= (struct ssh_channel
*) bv
;
1086 if (*a
< b
->localid
)
1088 if (*a
> b
->localid
)
1093 static int ssh_rportcmp_ssh1(void *av
, void *bv
)
1095 struct ssh_rportfwd
*a
= (struct ssh_rportfwd
*) av
;
1096 struct ssh_rportfwd
*b
= (struct ssh_rportfwd
*) bv
;
1098 if ( (i
= strcmp(a
->dhost
, b
->dhost
)) != 0)
1099 return i
< 0 ?
-1 : +1;
1100 if (a
->dport
> b
->dport
)
1102 if (a
->dport
< b
->dport
)
1107 static int ssh_rportcmp_ssh2(void *av
, void *bv
)
1109 struct ssh_rportfwd
*a
= (struct ssh_rportfwd
*) av
;
1110 struct ssh_rportfwd
*b
= (struct ssh_rportfwd
*) bv
;
1112 if (a
->sport
> b
->sport
)
1114 if (a
->sport
< b
->sport
)
1120 * Special form of strcmp which can cope with NULL inputs. NULL is
1121 * defined to sort before even the empty string.
1123 static int nullstrcmp(const char *a
, const char *b
)
1125 if (a
== NULL
&& b
== NULL
)
1131 return strcmp(a
, b
);
1134 static int ssh_portcmp(void *av
, void *bv
)
1136 struct ssh_portfwd
*a
= (struct ssh_portfwd
*) av
;
1137 struct ssh_portfwd
*b
= (struct ssh_portfwd
*) bv
;
1139 if (a
->type
> b
->type
)
1141 if (a
->type
< b
->type
)
1143 if (a
->addressfamily
> b
->addressfamily
)
1145 if (a
->addressfamily
< b
->addressfamily
)
1147 if ( (i
= nullstrcmp(a
->saddr
, b
->saddr
)) != 0)
1148 return i
< 0 ?
-1 : +1;
1149 if (a
->sport
> b
->sport
)
1151 if (a
->sport
< b
->sport
)
1153 if (a
->type
!= 'D') {
1154 if ( (i
= nullstrcmp(a
->daddr
, b
->daddr
)) != 0)
1155 return i
< 0 ?
-1 : +1;
1156 if (a
->dport
> b
->dport
)
1158 if (a
->dport
< b
->dport
)
1164 static int alloc_channel_id(Ssh ssh
)
1166 const unsigned CHANNEL_NUMBER_OFFSET
= 256;
1167 unsigned low
, high
, mid
;
1169 struct ssh_channel
*c
;
1172 * First-fit allocation of channel numbers: always pick the
1173 * lowest unused one. To do this, binary-search using the
1174 * counted B-tree to find the largest channel ID which is in a
1175 * contiguous sequence from the beginning. (Precisely
1176 * everything in that sequence must have ID equal to its tree
1177 * index plus CHANNEL_NUMBER_OFFSET.)
1179 tsize
= count234(ssh
->channels
);
1183 while (high
- low
> 1) {
1184 mid
= (high
+ low
) / 2;
1185 c
= index234(ssh
->channels
, mid
);
1186 if (c
->localid
== mid
+ CHANNEL_NUMBER_OFFSET
)
1187 low
= mid
; /* this one is fine */
1189 high
= mid
; /* this one is past it */
1192 * Now low points to either -1, or the tree index of the
1193 * largest ID in the initial sequence.
1196 unsigned i
= low
+ 1 + CHANNEL_NUMBER_OFFSET
;
1197 assert(NULL
== find234(ssh
->channels
, &i
, ssh_channelfind
));
1199 return low
+ 1 + CHANNEL_NUMBER_OFFSET
;
1202 static void c_write_stderr(int trusted
, const char *buf
, int len
)
1205 for (i
= 0; i
< len
; i
++)
1206 if (buf
[i
] != '\r' && (trusted
|| buf
[i
] == '\n' || (buf
[i
] & 0x60)))
1207 fputc(buf
[i
], stderr
);
1210 static void c_write(Ssh ssh
, const char *buf
, int len
)
1212 if (flags
& FLAG_STDERR
)
1213 c_write_stderr(1, buf
, len
);
1215 from_backend(ssh
->frontend
, 1, buf
, len
);
1218 static void c_write_untrusted(Ssh ssh
, const char *buf
, int len
)
1220 if (flags
& FLAG_STDERR
)
1221 c_write_stderr(0, buf
, len
);
1223 from_backend_untrusted(ssh
->frontend
, buf
, len
);
1226 static void c_write_str(Ssh ssh
, const char *buf
)
1228 c_write(ssh
, buf
, strlen(buf
));
1231 static void ssh_free_packet(struct Packet
*pkt
)
1236 static struct Packet
*ssh_new_packet(void)
1238 struct Packet
*pkt
= snew(struct Packet
);
1240 pkt
->body
= pkt
->data
= NULL
;
1242 pkt
->logmode
= PKTLOG_EMIT
;
1250 * Collect incoming data in the incoming packet buffer.
1251 * Decipher and verify the packet when it is completely read.
1252 * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
1253 * Update the *data and *datalen variables.
1254 * Return a Packet structure when a packet is completed.
1256 static struct Packet
*ssh1_rdpkt(Ssh ssh
, unsigned char **data
, int *datalen
)
1258 struct rdpkt1_state_tag
*st
= &ssh
->rdpkt1_state
;
1260 crBegin(ssh
->ssh1_rdpkt_crstate
);
1262 st
->pktin
= ssh_new_packet();
1264 st
->pktin
->type
= 0;
1265 st
->pktin
->length
= 0;
1267 for (st
->i
= st
->len
= 0; st
->i
< 4; st
->i
++) {
1268 while ((*datalen
) == 0)
1270 st
->len
= (st
->len
<< 8) + **data
;
1271 (*data
)++, (*datalen
)--;
1274 st
->pad
= 8 - (st
->len
% 8);
1275 st
->biglen
= st
->len
+ st
->pad
;
1276 st
->pktin
->length
= st
->len
- 5;
1278 if (st
->biglen
< 0) {
1279 bombout(("Extremely large packet length from server suggests"
1280 " data stream corruption"));
1281 ssh_free_packet(st
->pktin
);
1285 st
->pktin
->maxlen
= st
->biglen
;
1286 st
->pktin
->data
= snewn(st
->biglen
+ APIEXTRA
, unsigned char);
1288 st
->to_read
= st
->biglen
;
1289 st
->p
= st
->pktin
->data
;
1290 while (st
->to_read
> 0) {
1291 st
->chunk
= st
->to_read
;
1292 while ((*datalen
) == 0)
1294 if (st
->chunk
> (*datalen
))
1295 st
->chunk
= (*datalen
);
1296 memcpy(st
->p
, *data
, st
->chunk
);
1298 *datalen
-= st
->chunk
;
1300 st
->to_read
-= st
->chunk
;
1303 if (ssh
->cipher
&& detect_attack(ssh
->crcda_ctx
, st
->pktin
->data
,
1304 st
->biglen
, NULL
)) {
1305 bombout(("Network attack (CRC compensation) detected!"));
1306 ssh_free_packet(st
->pktin
);
1311 ssh
->cipher
->decrypt(ssh
->v1_cipher_ctx
, st
->pktin
->data
, st
->biglen
);
1313 st
->realcrc
= crc32_compute(st
->pktin
->data
, st
->biglen
- 4);
1314 st
->gotcrc
= GET_32BIT(st
->pktin
->data
+ st
->biglen
- 4);
1315 if (st
->gotcrc
!= st
->realcrc
) {
1316 bombout(("Incorrect CRC received on packet"));
1317 ssh_free_packet(st
->pktin
);
1321 st
->pktin
->body
= st
->pktin
->data
+ st
->pad
+ 1;
1322 st
->pktin
->savedpos
= 0;
1324 if (ssh
->v1_compressing
) {
1325 unsigned char *decompblk
;
1327 if (!zlib_decompress_block(ssh
->sc_comp_ctx
,
1328 st
->pktin
->body
- 1, st
->pktin
->length
+ 1,
1329 &decompblk
, &decomplen
)) {
1330 bombout(("Zlib decompression encountered invalid data"));
1331 ssh_free_packet(st
->pktin
);
1335 if (st
->pktin
->maxlen
< st
->pad
+ decomplen
) {
1336 st
->pktin
->maxlen
= st
->pad
+ decomplen
;
1337 st
->pktin
->data
= sresize(st
->pktin
->data
,
1338 st
->pktin
->maxlen
+ APIEXTRA
,
1340 st
->pktin
->body
= st
->pktin
->data
+ st
->pad
+ 1;
1343 memcpy(st
->pktin
->body
- 1, decompblk
, decomplen
);
1345 st
->pktin
->length
= decomplen
- 1;
1348 st
->pktin
->type
= st
->pktin
->body
[-1];
1351 * Log incoming packet, possibly omitting sensitive fields.
1355 struct logblank_t blank
;
1356 if (ssh
->logomitdata
) {
1357 int do_blank
= FALSE
, blank_prefix
= 0;
1358 /* "Session data" packets - omit the data field */
1359 if ((st
->pktin
->type
== SSH1_SMSG_STDOUT_DATA
) ||
1360 (st
->pktin
->type
== SSH1_SMSG_STDERR_DATA
)) {
1361 do_blank
= TRUE
; blank_prefix
= 4;
1362 } else if (st
->pktin
->type
== SSH1_MSG_CHANNEL_DATA
) {
1363 do_blank
= TRUE
; blank_prefix
= 8;
1366 blank
.offset
= blank_prefix
;
1367 blank
.len
= st
->pktin
->length
;
1368 blank
.type
= PKTLOG_OMIT
;
1372 log_packet(ssh
->logctx
,
1373 PKT_INCOMING
, st
->pktin
->type
,
1374 ssh1_pkt_type(st
->pktin
->type
),
1375 st
->pktin
->body
, st
->pktin
->length
,
1376 nblanks
, &blank
, NULL
);
1379 crFinish(st
->pktin
);
1382 static struct Packet
*ssh2_rdpkt(Ssh ssh
, unsigned char **data
, int *datalen
)
1384 struct rdpkt2_state_tag
*st
= &ssh
->rdpkt2_state
;
1386 crBegin(ssh
->ssh2_rdpkt_crstate
);
1388 st
->pktin
= ssh_new_packet();
1390 st
->pktin
->type
= 0;
1391 st
->pktin
->length
= 0;
1393 st
->cipherblk
= ssh
->sccipher
->blksize
;
1396 if (st
->cipherblk
< 8)
1398 st
->maclen
= ssh
->scmac ? ssh
->scmac
->len
: 0;
1400 if (ssh
->sccipher
&& (ssh
->sccipher
->flags
& SSH_CIPHER_IS_CBC
) &&
1403 * When dealing with a CBC-mode cipher, we want to avoid the
1404 * possibility of an attacker's tweaking the ciphertext stream
1405 * so as to cause us to feed the same block to the block
1406 * cipher more than once and thus leak information
1407 * (VU#958563). The way we do this is not to take any
1408 * decisions on the basis of anything we've decrypted until
1409 * we've verified it with a MAC. That includes the packet
1410 * length, so we just read data and check the MAC repeatedly,
1411 * and when the MAC passes, see if the length we've got is
1415 /* May as well allocate the whole lot now. */
1416 st
->pktin
->data
= snewn(OUR_V2_PACKETLIMIT
+ st
->maclen
+ APIEXTRA
,
1419 /* Read an amount corresponding to the MAC. */
1420 for (st
->i
= 0; st
->i
< st
->maclen
; st
->i
++) {
1421 while ((*datalen
) == 0)
1423 st
->pktin
->data
[st
->i
] = *(*data
)++;
1429 unsigned char seq
[4];
1430 ssh
->scmac
->start(ssh
->sc_mac_ctx
);
1431 PUT_32BIT(seq
, st
->incoming_sequence
);
1432 ssh
->scmac
->bytes(ssh
->sc_mac_ctx
, seq
, 4);
1435 for (;;) { /* Once around this loop per cipher block. */
1436 /* Read another cipher-block's worth, and tack it onto the end. */
1437 for (st
->i
= 0; st
->i
< st
->cipherblk
; st
->i
++) {
1438 while ((*datalen
) == 0)
1440 st
->pktin
->data
[st
->packetlen
+st
->maclen
+st
->i
] = *(*data
)++;
1443 /* Decrypt one more block (a little further back in the stream). */
1444 ssh
->sccipher
->decrypt(ssh
->sc_cipher_ctx
,
1445 st
->pktin
->data
+ st
->packetlen
,
1447 /* Feed that block to the MAC. */
1448 ssh
->scmac
->bytes(ssh
->sc_mac_ctx
,
1449 st
->pktin
->data
+ st
->packetlen
, st
->cipherblk
);
1450 st
->packetlen
+= st
->cipherblk
;
1451 /* See if that gives us a valid packet. */
1452 if (ssh
->scmac
->verresult(ssh
->sc_mac_ctx
,
1453 st
->pktin
->data
+ st
->packetlen
) &&
1454 (st
->len
= GET_32BIT(st
->pktin
->data
)) + 4 == st
->packetlen
)
1456 if (st
->packetlen
>= OUR_V2_PACKETLIMIT
) {
1457 bombout(("No valid incoming packet found"));
1458 ssh_free_packet(st
->pktin
);
1462 st
->pktin
->maxlen
= st
->packetlen
+ st
->maclen
;
1463 st
->pktin
->data
= sresize(st
->pktin
->data
,
1464 st
->pktin
->maxlen
+ APIEXTRA
,
1467 st
->pktin
->data
= snewn(st
->cipherblk
+ APIEXTRA
, unsigned char);
1470 * Acquire and decrypt the first block of the packet. This will
1471 * contain the length and padding details.
1473 for (st
->i
= st
->len
= 0; st
->i
< st
->cipherblk
; st
->i
++) {
1474 while ((*datalen
) == 0)
1476 st
->pktin
->data
[st
->i
] = *(*data
)++;
1481 ssh
->sccipher
->decrypt(ssh
->sc_cipher_ctx
,
1482 st
->pktin
->data
, st
->cipherblk
);
1485 * Now get the length figure.
1487 st
->len
= GET_32BIT(st
->pktin
->data
);
1490 * _Completely_ silly lengths should be stomped on before they
1491 * do us any more damage.
1493 if (st
->len
< 0 || st
->len
> OUR_V2_PACKETLIMIT
||
1494 (st
->len
+ 4) % st
->cipherblk
!= 0) {
1495 bombout(("Incoming packet was garbled on decryption"));
1496 ssh_free_packet(st
->pktin
);
1501 * So now we can work out the total packet length.
1503 st
->packetlen
= st
->len
+ 4;
1506 * Allocate memory for the rest of the packet.
1508 st
->pktin
->maxlen
= st
->packetlen
+ st
->maclen
;
1509 st
->pktin
->data
= sresize(st
->pktin
->data
,
1510 st
->pktin
->maxlen
+ APIEXTRA
,
1514 * Read and decrypt the remainder of the packet.
1516 for (st
->i
= st
->cipherblk
; st
->i
< st
->packetlen
+ st
->maclen
;
1518 while ((*datalen
) == 0)
1520 st
->pktin
->data
[st
->i
] = *(*data
)++;
1523 /* Decrypt everything _except_ the MAC. */
1525 ssh
->sccipher
->decrypt(ssh
->sc_cipher_ctx
,
1526 st
->pktin
->data
+ st
->cipherblk
,
1527 st
->packetlen
- st
->cipherblk
);
1533 && !ssh
->scmac
->verify(ssh
->sc_mac_ctx
, st
->pktin
->data
,
1534 st
->len
+ 4, st
->incoming_sequence
)) {
1535 bombout(("Incorrect MAC received on packet"));
1536 ssh_free_packet(st
->pktin
);
1540 /* Get and sanity-check the amount of random padding. */
1541 st
->pad
= st
->pktin
->data
[4];
1542 if (st
->pad
< 4 || st
->len
- st
->pad
< 1) {
1543 bombout(("Invalid padding length on received packet"));
1544 ssh_free_packet(st
->pktin
);
1548 * This enables us to deduce the payload length.
1550 st
->payload
= st
->len
- st
->pad
- 1;
1552 st
->pktin
->length
= st
->payload
+ 5;
1553 st
->pktin
->encrypted_len
= st
->packetlen
;
1555 st
->pktin
->sequence
= st
->incoming_sequence
++;
1558 * Decompress packet payload.
1561 unsigned char *newpayload
;
1564 ssh
->sccomp
->decompress(ssh
->sc_comp_ctx
,
1565 st
->pktin
->data
+ 5, st
->pktin
->length
- 5,
1566 &newpayload
, &newlen
)) {
1567 if (st
->pktin
->maxlen
< newlen
+ 5) {
1568 st
->pktin
->maxlen
= newlen
+ 5;
1569 st
->pktin
->data
= sresize(st
->pktin
->data
,
1570 st
->pktin
->maxlen
+ APIEXTRA
,
1573 st
->pktin
->length
= 5 + newlen
;
1574 memcpy(st
->pktin
->data
+ 5, newpayload
, newlen
);
1579 st
->pktin
->savedpos
= 6;
1580 st
->pktin
->body
= st
->pktin
->data
;
1581 st
->pktin
->type
= st
->pktin
->data
[5];
1584 * Log incoming packet, possibly omitting sensitive fields.
1588 struct logblank_t blank
;
1589 if (ssh
->logomitdata
) {
1590 int do_blank
= FALSE
, blank_prefix
= 0;
1591 /* "Session data" packets - omit the data field */
1592 if (st
->pktin
->type
== SSH2_MSG_CHANNEL_DATA
) {
1593 do_blank
= TRUE
; blank_prefix
= 8;
1594 } else if (st
->pktin
->type
== SSH2_MSG_CHANNEL_EXTENDED_DATA
) {
1595 do_blank
= TRUE
; blank_prefix
= 12;
1598 blank
.offset
= blank_prefix
;
1599 blank
.len
= (st
->pktin
->length
-6) - blank_prefix
;
1600 blank
.type
= PKTLOG_OMIT
;
1604 log_packet(ssh
->logctx
, PKT_INCOMING
, st
->pktin
->type
,
1605 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
,
1607 st
->pktin
->data
+6, st
->pktin
->length
-6,
1608 nblanks
, &blank
, &st
->pktin
->sequence
);
1611 crFinish(st
->pktin
);
1614 static int s_wrpkt_prepare(Ssh ssh
, struct Packet
*pkt
, int *offset_p
)
1616 int pad
, biglen
, i
, pktoffs
;
1620 * XXX various versions of SC (including 8.8.4) screw up the
1621 * register allocation in this function and use the same register
1622 * (D6) for len and as a temporary, with predictable results. The
1623 * following sledgehammer prevents this.
1630 log_packet(ssh
->logctx
, PKT_OUTGOING
, pkt
->data
[12],
1631 ssh1_pkt_type(pkt
->data
[12]),
1632 pkt
->body
, pkt
->length
- (pkt
->body
- pkt
->data
),
1633 pkt
->nblanks
, pkt
->blanks
, NULL
);
1634 sfree(pkt
->blanks
); pkt
->blanks
= NULL
;
1637 if (ssh
->v1_compressing
) {
1638 unsigned char *compblk
;
1640 zlib_compress_block(ssh
->cs_comp_ctx
,
1641 pkt
->data
+ 12, pkt
->length
- 12,
1642 &compblk
, &complen
);
1643 ssh_pkt_ensure(pkt
, complen
+ 2); /* just in case it's got bigger */
1644 memcpy(pkt
->data
+ 12, compblk
, complen
);
1646 pkt
->length
= complen
+ 12;
1649 ssh_pkt_ensure(pkt
, pkt
->length
+ 4); /* space for CRC */
1651 len
= pkt
->length
- 4 - 8; /* len(type+data+CRC) */
1652 pad
= 8 - (len
% 8);
1654 biglen
= len
+ pad
; /* len(padding+type+data+CRC) */
1656 for (i
= pktoffs
; i
< 4+8; i
++)
1657 pkt
->data
[i
] = random_byte();
1658 crc
= crc32_compute(pkt
->data
+ pktoffs
+ 4, biglen
- 4); /* all ex len */
1659 PUT_32BIT(pkt
->data
+ pktoffs
+ 4 + biglen
- 4, crc
);
1660 PUT_32BIT(pkt
->data
+ pktoffs
, len
);
1663 ssh
->cipher
->encrypt(ssh
->v1_cipher_ctx
,
1664 pkt
->data
+ pktoffs
+ 4, biglen
);
1666 if (offset_p
) *offset_p
= pktoffs
;
1667 return biglen
+ 4; /* len(length+padding+type+data+CRC) */
1670 static int s_write(Ssh ssh
, void *data
, int len
)
1673 log_packet(ssh
->logctx
, PKT_OUTGOING
, -1, NULL
, data
, len
,
1675 return sk_write(ssh
->s
, (char *)data
, len
);
1678 static void s_wrpkt(Ssh ssh
, struct Packet
*pkt
)
1680 int len
, backlog
, offset
;
1681 len
= s_wrpkt_prepare(ssh
, pkt
, &offset
);
1682 backlog
= s_write(ssh
, pkt
->data
+ offset
, len
);
1683 if (backlog
> SSH_MAX_BACKLOG
)
1684 ssh_throttle_all(ssh
, 1, backlog
);
1685 ssh_free_packet(pkt
);
1688 static void s_wrpkt_defer(Ssh ssh
, struct Packet
*pkt
)
1691 len
= s_wrpkt_prepare(ssh
, pkt
, &offset
);
1692 if (ssh
->deferred_len
+ len
> ssh
->deferred_size
) {
1693 ssh
->deferred_size
= ssh
->deferred_len
+ len
+ 128;
1694 ssh
->deferred_send_data
= sresize(ssh
->deferred_send_data
,
1698 memcpy(ssh
->deferred_send_data
+ ssh
->deferred_len
,
1699 pkt
->data
+ offset
, len
);
1700 ssh
->deferred_len
+= len
;
1701 ssh_free_packet(pkt
);
1705 * Construct a SSH-1 packet with the specified contents.
1706 * (This all-at-once interface used to be the only one, but now SSH-1
1707 * packets can also be constructed incrementally.)
1709 static struct Packet
*construct_packet(Ssh ssh
, int pkttype
, va_list ap
)
1715 pkt
= ssh1_pkt_init(pkttype
);
1717 while ((argtype
= va_arg(ap
, int)) != PKT_END
) {
1718 unsigned char *argp
, argchar
;
1720 unsigned long argint
;
1723 /* Actual fields in the packet */
1725 argint
= va_arg(ap
, int);
1726 ssh_pkt_adduint32(pkt
, argint
);
1729 argchar
= (unsigned char) va_arg(ap
, int);
1730 ssh_pkt_addbyte(pkt
, argchar
);
1733 argp
= va_arg(ap
, unsigned char *);
1734 arglen
= va_arg(ap
, int);
1735 ssh_pkt_adddata(pkt
, argp
, arglen
);
1738 sargp
= va_arg(ap
, char *);
1739 ssh_pkt_addstring(pkt
, sargp
);
1742 bn
= va_arg(ap
, Bignum
);
1743 ssh1_pkt_addmp(pkt
, bn
);
1745 /* Tokens for modifications to packet logging */
1747 dont_log_password(ssh
, pkt
, PKTLOG_BLANK
);
1750 dont_log_data(ssh
, pkt
, PKTLOG_OMIT
);
1753 end_log_omission(ssh
, pkt
);
1761 static void send_packet(Ssh ssh
, int pkttype
, ...)
1765 va_start(ap
, pkttype
);
1766 pkt
= construct_packet(ssh
, pkttype
, ap
);
1771 static void defer_packet(Ssh ssh
, int pkttype
, ...)
1775 va_start(ap
, pkttype
);
1776 pkt
= construct_packet(ssh
, pkttype
, ap
);
1778 s_wrpkt_defer(ssh
, pkt
);
1781 static int ssh_versioncmp(char *a
, char *b
)
1784 unsigned long av
, bv
;
1786 av
= strtoul(a
, &ae
, 10);
1787 bv
= strtoul(b
, &be
, 10);
1789 return (av
< bv ?
-1 : +1);
1794 av
= strtoul(ae
, &ae
, 10);
1795 bv
= strtoul(be
, &be
, 10);
1797 return (av
< bv ?
-1 : +1);
1802 * Utility routines for putting an SSH-protocol `string' and
1803 * `uint32' into a hash state.
1805 static void hash_string(const struct ssh_hash
*h
, void *s
, void *str
, int len
)
1807 unsigned char lenblk
[4];
1808 PUT_32BIT(lenblk
, len
);
1809 h
->bytes(s
, lenblk
, 4);
1810 h
->bytes(s
, str
, len
);
1813 static void hash_uint32(const struct ssh_hash
*h
, void *s
, unsigned i
)
1815 unsigned char intblk
[4];
1816 PUT_32BIT(intblk
, i
);
1817 h
->bytes(s
, intblk
, 4);
1821 * Packet construction functions. Mostly shared between SSH-1 and SSH-2.
1823 static void ssh_pkt_ensure(struct Packet
*pkt
, int length
)
1825 if (pkt
->maxlen
< length
) {
1826 unsigned char *body
= pkt
->body
;
1827 int offset
= body ? body
- pkt
->data
: 0;
1828 pkt
->maxlen
= length
+ 256;
1829 pkt
->data
= sresize(pkt
->data
, pkt
->maxlen
+ APIEXTRA
, unsigned char);
1830 if (body
) pkt
->body
= pkt
->data
+ offset
;
1833 static void ssh_pkt_adddata(struct Packet
*pkt
, void *data
, int len
)
1835 if (pkt
->logmode
!= PKTLOG_EMIT
) {
1837 pkt
->blanks
= sresize(pkt
->blanks
, pkt
->nblanks
, struct logblank_t
);
1839 pkt
->blanks
[pkt
->nblanks
-1].offset
= pkt
->length
-
1840 (pkt
->body
- pkt
->data
);
1841 pkt
->blanks
[pkt
->nblanks
-1].len
= len
;
1842 pkt
->blanks
[pkt
->nblanks
-1].type
= pkt
->logmode
;
1845 ssh_pkt_ensure(pkt
, pkt
->length
);
1846 memcpy(pkt
->data
+ pkt
->length
- len
, data
, len
);
1848 static void ssh_pkt_addbyte(struct Packet
*pkt
, unsigned char byte
)
1850 ssh_pkt_adddata(pkt
, &byte
, 1);
1852 static void ssh2_pkt_addbool(struct Packet
*pkt
, unsigned char value
)
1854 ssh_pkt_adddata(pkt
, &value
, 1);
1856 static void ssh_pkt_adduint32(struct Packet
*pkt
, unsigned long value
)
1859 PUT_32BIT(x
, value
);
1860 ssh_pkt_adddata(pkt
, x
, 4);
1862 static void ssh_pkt_addstring_start(struct Packet
*pkt
)
1864 ssh_pkt_adduint32(pkt
, 0);
1865 pkt
->savedpos
= pkt
->length
;
1867 static void ssh_pkt_addstring_str(struct Packet
*pkt
, char *data
)
1869 ssh_pkt_adddata(pkt
, data
, strlen(data
));
1870 PUT_32BIT(pkt
->data
+ pkt
->savedpos
- 4, pkt
->length
- pkt
->savedpos
);
1872 static void ssh_pkt_addstring_data(struct Packet
*pkt
, char *data
, int len
)
1874 ssh_pkt_adddata(pkt
, data
, len
);
1875 PUT_32BIT(pkt
->data
+ pkt
->savedpos
- 4, pkt
->length
- pkt
->savedpos
);
1877 static void ssh_pkt_addstring(struct Packet
*pkt
, char *data
)
1879 ssh_pkt_addstring_start(pkt
);
1880 ssh_pkt_addstring_str(pkt
, data
);
1882 static void ssh1_pkt_addmp(struct Packet
*pkt
, Bignum b
)
1884 int len
= ssh1_bignum_length(b
);
1885 unsigned char *data
= snewn(len
, unsigned char);
1886 (void) ssh1_write_bignum(data
, b
);
1887 ssh_pkt_adddata(pkt
, data
, len
);
1890 static unsigned char *ssh2_mpint_fmt(Bignum b
, int *len
)
1893 int i
, n
= (bignum_bitcount(b
) + 7) / 8;
1894 p
= snewn(n
+ 1, unsigned char);
1896 for (i
= 1; i
<= n
; i
++)
1897 p
[i
] = bignum_byte(b
, n
- i
);
1899 while (i
<= n
&& p
[i
] == 0 && (p
[i
+ 1] & 0x80) == 0)
1901 memmove(p
, p
+ i
, n
+ 1 - i
);
1905 static void ssh2_pkt_addmp(struct Packet
*pkt
, Bignum b
)
1909 p
= ssh2_mpint_fmt(b
, &len
);
1910 ssh_pkt_addstring_start(pkt
);
1911 ssh_pkt_addstring_data(pkt
, (char *)p
, len
);
1915 static struct Packet
*ssh1_pkt_init(int pkt_type
)
1917 struct Packet
*pkt
= ssh_new_packet();
1918 pkt
->length
= 4 + 8; /* space for length + max padding */
1919 ssh_pkt_addbyte(pkt
, pkt_type
);
1920 pkt
->body
= pkt
->data
+ pkt
->length
;
1924 /* For legacy code (SSH-1 and -2 packet construction used to be separate) */
1925 #define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length)
1926 #define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len)
1927 #define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte)
1928 #define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value)
1929 #define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt)
1930 #define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data)
1931 #define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len)
1932 #define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data)
1934 static struct Packet
*ssh2_pkt_init(int pkt_type
)
1936 struct Packet
*pkt
= ssh_new_packet();
1937 pkt
->length
= 5; /* space for packet length + padding length */
1939 ssh_pkt_addbyte(pkt
, (unsigned char) pkt_type
);
1940 pkt
->body
= pkt
->data
+ pkt
->length
; /* after packet type */
1945 * Construct an SSH-2 final-form packet: compress it, encrypt it,
1946 * put the MAC on it. Final packet, ready to be sent, is stored in
1947 * pkt->data. Total length is returned.
1949 static int ssh2_pkt_construct(Ssh ssh
, struct Packet
*pkt
)
1951 int cipherblk
, maclen
, padding
, i
;
1954 log_packet(ssh
->logctx
, PKT_OUTGOING
, pkt
->data
[5],
1955 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
, pkt
->data
[5]),
1956 pkt
->body
, pkt
->length
- (pkt
->body
- pkt
->data
),
1957 pkt
->nblanks
, pkt
->blanks
, &ssh
->v2_outgoing_sequence
);
1958 sfree(pkt
->blanks
); pkt
->blanks
= NULL
;
1962 * Compress packet payload.
1965 unsigned char *newpayload
;
1968 ssh
->cscomp
->compress(ssh
->cs_comp_ctx
, pkt
->data
+ 5,
1970 &newpayload
, &newlen
)) {
1972 ssh2_pkt_adddata(pkt
, newpayload
, newlen
);
1978 * Add padding. At least four bytes, and must also bring total
1979 * length (minus MAC) up to a multiple of the block size.
1980 * If pkt->forcepad is set, make sure the packet is at least that size
1983 cipherblk
= ssh
->cscipher ? ssh
->cscipher
->blksize
: 8; /* block size */
1984 cipherblk
= cipherblk
< 8 ?
8 : cipherblk
; /* or 8 if blksize < 8 */
1986 if (pkt
->length
+ padding
< pkt
->forcepad
)
1987 padding
= pkt
->forcepad
- pkt
->length
;
1989 (cipherblk
- (pkt
->length
+ padding
) % cipherblk
) % cipherblk
;
1990 assert(padding
<= 255);
1991 maclen
= ssh
->csmac ? ssh
->csmac
->len
: 0;
1992 ssh2_pkt_ensure(pkt
, pkt
->length
+ padding
+ maclen
);
1993 pkt
->data
[4] = padding
;
1994 for (i
= 0; i
< padding
; i
++)
1995 pkt
->data
[pkt
->length
+ i
] = random_byte();
1996 PUT_32BIT(pkt
->data
, pkt
->length
+ padding
- 4);
1998 ssh
->csmac
->generate(ssh
->cs_mac_ctx
, pkt
->data
,
1999 pkt
->length
+ padding
,
2000 ssh
->v2_outgoing_sequence
);
2001 ssh
->v2_outgoing_sequence
++; /* whether or not we MACed */
2004 ssh
->cscipher
->encrypt(ssh
->cs_cipher_ctx
,
2005 pkt
->data
, pkt
->length
+ padding
);
2007 pkt
->encrypted_len
= pkt
->length
+ padding
;
2009 /* Ready-to-send packet starts at pkt->data. We return length. */
2010 return pkt
->length
+ padding
+ maclen
;
2014 * Routines called from the main SSH code to send packets. There
2015 * are quite a few of these, because we have two separate
2016 * mechanisms for delaying the sending of packets:
2018 * - In order to send an IGNORE message and a password message in
2019 * a single fixed-length blob, we require the ability to
2020 * concatenate the encrypted forms of those two packets _into_ a
2021 * single blob and then pass it to our <network.h> transport
2022 * layer in one go. Hence, there's a deferment mechanism which
2023 * works after packet encryption.
2025 * - In order to avoid sending any connection-layer messages
2026 * during repeat key exchange, we have to queue up any such
2027 * outgoing messages _before_ they are encrypted (and in
2028 * particular before they're allocated sequence numbers), and
2029 * then send them once we've finished.
2031 * I call these mechanisms `defer' and `queue' respectively, so as
2032 * to distinguish them reasonably easily.
2034 * The functions send_noqueue() and defer_noqueue() free the packet
2035 * structure they are passed. Every outgoing packet goes through
2036 * precisely one of these functions in its life; packets passed to
2037 * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of
2038 * these or get queued, and then when the queue is later emptied
2039 * the packets are all passed to defer_noqueue().
2041 * When using a CBC-mode cipher, it's necessary to ensure that an
2042 * attacker can't provide data to be encrypted using an IV that they
2043 * know. We ensure this by prefixing each packet that might contain
2044 * user data with an SSH_MSG_IGNORE. This is done using the deferral
2045 * mechanism, so in this case send_noqueue() ends up redirecting to
2046 * defer_noqueue(). If you don't like this inefficiency, don't use
2050 static void ssh2_pkt_defer_noqueue(Ssh
, struct Packet
*, int);
2051 static void ssh_pkt_defersend(Ssh
);
2054 * Send an SSH-2 packet immediately, without queuing or deferring.
2056 static void ssh2_pkt_send_noqueue(Ssh ssh
, struct Packet
*pkt
)
2060 if (ssh
->cscipher
!= NULL
&& (ssh
->cscipher
->flags
& SSH_CIPHER_IS_CBC
)) {
2061 /* We need to send two packets, so use the deferral mechanism. */
2062 ssh2_pkt_defer_noqueue(ssh
, pkt
, FALSE
);
2063 ssh_pkt_defersend(ssh
);
2066 len
= ssh2_pkt_construct(ssh
, pkt
);
2067 backlog
= s_write(ssh
, pkt
->data
, len
);
2068 if (backlog
> SSH_MAX_BACKLOG
)
2069 ssh_throttle_all(ssh
, 1, backlog
);
2071 ssh
->outgoing_data_size
+= pkt
->encrypted_len
;
2072 if (!ssh
->kex_in_progress
&&
2073 ssh
->max_data_size
!= 0 &&
2074 ssh
->outgoing_data_size
> ssh
->max_data_size
)
2075 do_ssh2_transport(ssh
, "too much data sent", -1, NULL
);
2077 ssh_free_packet(pkt
);
2081 * Defer an SSH-2 packet.
2083 static void ssh2_pkt_defer_noqueue(Ssh ssh
, struct Packet
*pkt
, int noignore
)
2086 if (ssh
->cscipher
!= NULL
&& (ssh
->cscipher
->flags
& SSH_CIPHER_IS_CBC
) &&
2087 ssh
->deferred_len
== 0 && !noignore
&&
2088 !(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH2_IGNORE
)) {
2090 * Interpose an SSH_MSG_IGNORE to ensure that user data don't
2091 * get encrypted with a known IV.
2093 struct Packet
*ipkt
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
2094 ssh2_pkt_addstring_start(ipkt
);
2095 ssh2_pkt_defer_noqueue(ssh
, ipkt
, TRUE
);
2097 len
= ssh2_pkt_construct(ssh
, pkt
);
2098 if (ssh
->deferred_len
+ len
> ssh
->deferred_size
) {
2099 ssh
->deferred_size
= ssh
->deferred_len
+ len
+ 128;
2100 ssh
->deferred_send_data
= sresize(ssh
->deferred_send_data
,
2104 memcpy(ssh
->deferred_send_data
+ ssh
->deferred_len
, pkt
->data
, len
);
2105 ssh
->deferred_len
+= len
;
2106 ssh
->deferred_data_size
+= pkt
->encrypted_len
;
2107 ssh_free_packet(pkt
);
2111 * Queue an SSH-2 packet.
2113 static void ssh2_pkt_queue(Ssh ssh
, struct Packet
*pkt
)
2115 assert(ssh
->queueing
);
2117 if (ssh
->queuelen
>= ssh
->queuesize
) {
2118 ssh
->queuesize
= ssh
->queuelen
+ 32;
2119 ssh
->queue
= sresize(ssh
->queue
, ssh
->queuesize
, struct Packet
*);
2122 ssh
->queue
[ssh
->queuelen
++] = pkt
;
2126 * Either queue or send a packet, depending on whether queueing is
2129 static void ssh2_pkt_send(Ssh ssh
, struct Packet
*pkt
)
2132 ssh2_pkt_queue(ssh
, pkt
);
2134 ssh2_pkt_send_noqueue(ssh
, pkt
);
2138 * Either queue or defer a packet, depending on whether queueing is
2141 static void ssh2_pkt_defer(Ssh ssh
, struct Packet
*pkt
)
2144 ssh2_pkt_queue(ssh
, pkt
);
2146 ssh2_pkt_defer_noqueue(ssh
, pkt
, FALSE
);
2150 * Send the whole deferred data block constructed by
2151 * ssh2_pkt_defer() or SSH-1's defer_packet().
2153 * The expected use of the defer mechanism is that you call
2154 * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If
2155 * not currently queueing, this simply sets up deferred_send_data
2156 * and then sends it. If we _are_ currently queueing, the calls to
2157 * ssh2_pkt_defer() put the deferred packets on to the queue
2158 * instead, and therefore ssh_pkt_defersend() has no deferred data
2159 * to send. Hence, there's no need to make it conditional on
2162 static void ssh_pkt_defersend(Ssh ssh
)
2165 backlog
= s_write(ssh
, ssh
->deferred_send_data
, ssh
->deferred_len
);
2166 ssh
->deferred_len
= ssh
->deferred_size
= 0;
2167 sfree(ssh
->deferred_send_data
);
2168 ssh
->deferred_send_data
= NULL
;
2169 if (backlog
> SSH_MAX_BACKLOG
)
2170 ssh_throttle_all(ssh
, 1, backlog
);
2172 ssh
->outgoing_data_size
+= ssh
->deferred_data_size
;
2173 if (!ssh
->kex_in_progress
&&
2174 ssh
->max_data_size
!= 0 &&
2175 ssh
->outgoing_data_size
> ssh
->max_data_size
)
2176 do_ssh2_transport(ssh
, "too much data sent", -1, NULL
);
2177 ssh
->deferred_data_size
= 0;
2181 * Send a packet whose length needs to be disguised (typically
2182 * passwords or keyboard-interactive responses).
2184 static void ssh2_pkt_send_with_padding(Ssh ssh
, struct Packet
*pkt
,
2190 * The simplest way to do this is to adjust the
2191 * variable-length padding field in the outgoing packet.
2193 * Currently compiled out, because some Cisco SSH servers
2194 * don't like excessively padded packets (bah, why's it
2197 pkt
->forcepad
= padsize
;
2198 ssh2_pkt_send(ssh
, pkt
);
2203 * If we can't do that, however, an alternative approach is
2204 * to use the pkt_defer mechanism to bundle the packet
2205 * tightly together with an SSH_MSG_IGNORE such that their
2206 * combined length is a constant. So first we construct the
2207 * final form of this packet and defer its sending.
2209 ssh2_pkt_defer(ssh
, pkt
);
2212 * Now construct an SSH_MSG_IGNORE which includes a string
2213 * that's an exact multiple of the cipher block size. (If
2214 * the cipher is NULL so that the block size is
2215 * unavailable, we don't do this trick at all, because we
2216 * gain nothing by it.)
2218 if (ssh
->cscipher
&&
2219 !(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH2_IGNORE
)) {
2222 stringlen
= (256 - ssh
->deferred_len
);
2223 stringlen
+= ssh
->cscipher
->blksize
- 1;
2224 stringlen
-= (stringlen
% ssh
->cscipher
->blksize
);
2227 * Temporarily disable actual compression, so we
2228 * can guarantee to get this string exactly the
2229 * length we want it. The compression-disabling
2230 * routine should return an integer indicating how
2231 * many bytes we should adjust our string length
2235 ssh
->cscomp
->disable_compression(ssh
->cs_comp_ctx
);
2237 pkt
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
2238 ssh2_pkt_addstring_start(pkt
);
2239 for (i
= 0; i
< stringlen
; i
++) {
2240 char c
= (char) random_byte();
2241 ssh2_pkt_addstring_data(pkt
, &c
, 1);
2243 ssh2_pkt_defer(ssh
, pkt
);
2245 ssh_pkt_defersend(ssh
);
2250 * Send all queued SSH-2 packets. We send them by means of
2251 * ssh2_pkt_defer_noqueue(), in case they included a pair of
2252 * packets that needed to be lumped together.
2254 static void ssh2_pkt_queuesend(Ssh ssh
)
2258 assert(!ssh
->queueing
);
2260 for (i
= 0; i
< ssh
->queuelen
; i
++)
2261 ssh2_pkt_defer_noqueue(ssh
, ssh
->queue
[i
], FALSE
);
2264 ssh_pkt_defersend(ssh
);
2268 void bndebug(char *string
, Bignum b
)
2272 p
= ssh2_mpint_fmt(b
, &len
);
2273 debug(("%s", string
));
2274 for (i
= 0; i
< len
; i
++)
2275 debug((" %02x", p
[i
]));
2281 static void hash_mpint(const struct ssh_hash
*h
, void *s
, Bignum b
)
2285 p
= ssh2_mpint_fmt(b
, &len
);
2286 hash_string(h
, s
, p
, len
);
2291 * Packet decode functions for both SSH-1 and SSH-2.
2293 static unsigned long ssh_pkt_getuint32(struct Packet
*pkt
)
2295 unsigned long value
;
2296 if (pkt
->length
- pkt
->savedpos
< 4)
2297 return 0; /* arrgh, no way to decline (FIXME?) */
2298 value
= GET_32BIT(pkt
->body
+ pkt
->savedpos
);
2302 static int ssh2_pkt_getbool(struct Packet
*pkt
)
2304 unsigned long value
;
2305 if (pkt
->length
- pkt
->savedpos
< 1)
2306 return 0; /* arrgh, no way to decline (FIXME?) */
2307 value
= pkt
->body
[pkt
->savedpos
] != 0;
2311 static void ssh_pkt_getstring(struct Packet
*pkt
, char **p
, int *length
)
2316 if (pkt
->length
- pkt
->savedpos
< 4)
2318 len
= GET_32BIT(pkt
->body
+ pkt
->savedpos
);
2323 if (pkt
->length
- pkt
->savedpos
< *length
)
2325 *p
= (char *)(pkt
->body
+ pkt
->savedpos
);
2326 pkt
->savedpos
+= *length
;
2328 static void *ssh_pkt_getdata(struct Packet
*pkt
, int length
)
2330 if (pkt
->length
- pkt
->savedpos
< length
)
2332 pkt
->savedpos
+= length
;
2333 return pkt
->body
+ (pkt
->savedpos
- length
);
2335 static int ssh1_pkt_getrsakey(struct Packet
*pkt
, struct RSAKey
*key
,
2336 unsigned char **keystr
)
2340 j
= makekey(pkt
->body
+ pkt
->savedpos
,
2341 pkt
->length
- pkt
->savedpos
,
2348 assert(pkt
->savedpos
< pkt
->length
);
2352 static Bignum
ssh1_pkt_getmp(struct Packet
*pkt
)
2357 j
= ssh1_read_bignum(pkt
->body
+ pkt
->savedpos
,
2358 pkt
->length
- pkt
->savedpos
, &b
);
2366 static Bignum
ssh2_pkt_getmp(struct Packet
*pkt
)
2372 ssh_pkt_getstring(pkt
, &p
, &length
);
2377 b
= bignum_from_bytes((unsigned char *)p
, length
);
2382 * Helper function to add an SSH-2 signature blob to a packet.
2383 * Expects to be shown the public key blob as well as the signature
2384 * blob. Normally works just like ssh2_pkt_addstring, but will
2385 * fiddle with the signature packet if necessary for
2386 * BUG_SSH2_RSA_PADDING.
2388 static void ssh2_add_sigblob(Ssh ssh
, struct Packet
*pkt
,
2389 void *pkblob_v
, int pkblob_len
,
2390 void *sigblob_v
, int sigblob_len
)
2392 unsigned char *pkblob
= (unsigned char *)pkblob_v
;
2393 unsigned char *sigblob
= (unsigned char *)sigblob_v
;
2395 /* dmemdump(pkblob, pkblob_len); */
2396 /* dmemdump(sigblob, sigblob_len); */
2399 * See if this is in fact an ssh-rsa signature and a buggy
2400 * server; otherwise we can just do this the easy way.
2402 if ((ssh
->remote_bugs
& BUG_SSH2_RSA_PADDING
) &&
2403 (GET_32BIT(pkblob
) == 7 && !memcmp(pkblob
+4, "ssh-rsa", 7))) {
2404 int pos
, len
, siglen
;
2407 * Find the byte length of the modulus.
2410 pos
= 4+7; /* skip over "ssh-rsa" */
2411 pos
+= 4 + GET_32BIT(pkblob
+pos
); /* skip over exponent */
2412 len
= GET_32BIT(pkblob
+pos
); /* find length of modulus */
2413 pos
+= 4; /* find modulus itself */
2414 while (len
> 0 && pkblob
[pos
] == 0)
2416 /* debug(("modulus length is %d\n", len)); */
2419 * Now find the signature integer.
2421 pos
= 4+7; /* skip over "ssh-rsa" */
2422 siglen
= GET_32BIT(sigblob
+pos
);
2423 /* debug(("signature length is %d\n", siglen)); */
2425 if (len
!= siglen
) {
2426 unsigned char newlen
[4];
2427 ssh2_pkt_addstring_start(pkt
);
2428 ssh2_pkt_addstring_data(pkt
, (char *)sigblob
, pos
);
2429 /* dmemdump(sigblob, pos); */
2430 pos
+= 4; /* point to start of actual sig */
2431 PUT_32BIT(newlen
, len
);
2432 ssh2_pkt_addstring_data(pkt
, (char *)newlen
, 4);
2433 /* dmemdump(newlen, 4); */
2435 while (len
-- > siglen
) {
2436 ssh2_pkt_addstring_data(pkt
, (char *)newlen
, 1);
2437 /* dmemdump(newlen, 1); */
2439 ssh2_pkt_addstring_data(pkt
, (char *)(sigblob
+pos
), siglen
);
2440 /* dmemdump(sigblob+pos, siglen); */
2444 /* Otherwise fall through and do it the easy way. */
2447 ssh2_pkt_addstring_start(pkt
);
2448 ssh2_pkt_addstring_data(pkt
, (char *)sigblob
, sigblob_len
);
2452 * Examine the remote side's version string and compare it against
2453 * a list of known buggy implementations.
2455 static void ssh_detect_bugs(Ssh ssh
, char *vstring
)
2457 char *imp
; /* pointer to implementation part */
2459 imp
+= strcspn(imp
, "-");
2461 imp
+= strcspn(imp
, "-");
2464 ssh
->remote_bugs
= 0;
2467 * General notes on server version strings:
2468 * - Not all servers reporting "Cisco-1.25" have all the bugs listed
2469 * here -- in particular, we've heard of one that's perfectly happy
2470 * with SSH1_MSG_IGNOREs -- but this string never seems to change,
2471 * so we can't distinguish them.
2473 if (conf_get_int(ssh
->conf
, CONF_sshbug_ignore1
) == FORCE_ON
||
2474 (conf_get_int(ssh
->conf
, CONF_sshbug_ignore1
) == AUTO
&&
2475 (!strcmp(imp
, "1.2.18") || !strcmp(imp
, "1.2.19") ||
2476 !strcmp(imp
, "1.2.20") || !strcmp(imp
, "1.2.21") ||
2477 !strcmp(imp
, "1.2.22") || !strcmp(imp
, "Cisco-1.25") ||
2478 !strcmp(imp
, "OSU_1.4alpha3") || !strcmp(imp
, "OSU_1.5alpha4")))) {
2480 * These versions don't support SSH1_MSG_IGNORE, so we have
2481 * to use a different defence against password length
2484 ssh
->remote_bugs
|= BUG_CHOKES_ON_SSH1_IGNORE
;
2485 logevent("We believe remote version has SSH-1 ignore bug");
2488 if (conf_get_int(ssh
->conf
, CONF_sshbug_plainpw1
) == FORCE_ON
||
2489 (conf_get_int(ssh
->conf
, CONF_sshbug_plainpw1
) == AUTO
&&
2490 (!strcmp(imp
, "Cisco-1.25") || !strcmp(imp
, "OSU_1.4alpha3")))) {
2492 * These versions need a plain password sent; they can't
2493 * handle having a null and a random length of data after
2496 ssh
->remote_bugs
|= BUG_NEEDS_SSH1_PLAIN_PASSWORD
;
2497 logevent("We believe remote version needs a plain SSH-1 password");
2500 if (conf_get_int(ssh
->conf
, CONF_sshbug_rsa1
) == FORCE_ON
||
2501 (conf_get_int(ssh
->conf
, CONF_sshbug_rsa1
) == AUTO
&&
2502 (!strcmp(imp
, "Cisco-1.25")))) {
2504 * These versions apparently have no clue whatever about
2505 * RSA authentication and will panic and die if they see
2506 * an AUTH_RSA message.
2508 ssh
->remote_bugs
|= BUG_CHOKES_ON_RSA
;
2509 logevent("We believe remote version can't handle SSH-1 RSA authentication");
2512 if (conf_get_int(ssh
->conf
, CONF_sshbug_hmac2
) == FORCE_ON
||
2513 (conf_get_int(ssh
->conf
, CONF_sshbug_hmac2
) == AUTO
&&
2514 !wc_match("* VShell", imp
) &&
2515 (wc_match("2.1.0*", imp
) || wc_match("2.0.*", imp
) ||
2516 wc_match("2.2.0*", imp
) || wc_match("2.3.0*", imp
) ||
2517 wc_match("2.1 *", imp
)))) {
2519 * These versions have the HMAC bug.
2521 ssh
->remote_bugs
|= BUG_SSH2_HMAC
;
2522 logevent("We believe remote version has SSH-2 HMAC bug");
2525 if (conf_get_int(ssh
->conf
, CONF_sshbug_derivekey2
) == FORCE_ON
||
2526 (conf_get_int(ssh
->conf
, CONF_sshbug_derivekey2
) == AUTO
&&
2527 !wc_match("* VShell", imp
) &&
2528 (wc_match("2.0.0*", imp
) || wc_match("2.0.10*", imp
) ))) {
2530 * These versions have the key-derivation bug (failing to
2531 * include the literal shared secret in the hashes that
2532 * generate the keys).
2534 ssh
->remote_bugs
|= BUG_SSH2_DERIVEKEY
;
2535 logevent("We believe remote version has SSH-2 key-derivation bug");
2538 if (conf_get_int(ssh
->conf
, CONF_sshbug_rsapad2
) == FORCE_ON
||
2539 (conf_get_int(ssh
->conf
, CONF_sshbug_rsapad2
) == AUTO
&&
2540 (wc_match("OpenSSH_2.[5-9]*", imp
) ||
2541 wc_match("OpenSSH_3.[0-2]*", imp
)))) {
2543 * These versions have the SSH-2 RSA padding bug.
2545 ssh
->remote_bugs
|= BUG_SSH2_RSA_PADDING
;
2546 logevent("We believe remote version has SSH-2 RSA padding bug");
2549 if (conf_get_int(ssh
->conf
, CONF_sshbug_pksessid2
) == FORCE_ON
||
2550 (conf_get_int(ssh
->conf
, CONF_sshbug_pksessid2
) == AUTO
&&
2551 wc_match("OpenSSH_2.[0-2]*", imp
))) {
2553 * These versions have the SSH-2 session-ID bug in
2554 * public-key authentication.
2556 ssh
->remote_bugs
|= BUG_SSH2_PK_SESSIONID
;
2557 logevent("We believe remote version has SSH-2 public-key-session-ID bug");
2560 if (conf_get_int(ssh
->conf
, CONF_sshbug_rekey2
) == FORCE_ON
||
2561 (conf_get_int(ssh
->conf
, CONF_sshbug_rekey2
) == AUTO
&&
2562 (wc_match("DigiSSH_2.0", imp
) ||
2563 wc_match("OpenSSH_2.[0-4]*", imp
) ||
2564 wc_match("OpenSSH_2.5.[0-3]*", imp
) ||
2565 wc_match("Sun_SSH_1.0", imp
) ||
2566 wc_match("Sun_SSH_1.0.1", imp
) ||
2567 /* All versions <= 1.2.6 (they changed their format in 1.2.7) */
2568 wc_match("WeOnlyDo-*", imp
)))) {
2570 * These versions have the SSH-2 rekey bug.
2572 ssh
->remote_bugs
|= BUG_SSH2_REKEY
;
2573 logevent("We believe remote version has SSH-2 rekey bug");
2576 if (conf_get_int(ssh
->conf
, CONF_sshbug_maxpkt2
) == FORCE_ON
||
2577 (conf_get_int(ssh
->conf
, CONF_sshbug_maxpkt2
) == AUTO
&&
2578 (wc_match("1.36_sshlib GlobalSCAPE", imp
) ||
2579 wc_match("1.36 sshlib: GlobalScape", imp
)))) {
2581 * This version ignores our makpkt and needs to be throttled.
2583 ssh
->remote_bugs
|= BUG_SSH2_MAXPKT
;
2584 logevent("We believe remote version ignores SSH-2 maximum packet size");
2587 if (conf_get_int(ssh
->conf
, CONF_sshbug_ignore2
) == FORCE_ON
) {
2589 * Servers that don't support SSH2_MSG_IGNORE. Currently,
2590 * none detected automatically.
2592 ssh
->remote_bugs
|= BUG_CHOKES_ON_SSH2_IGNORE
;
2593 logevent("We believe remote version has SSH-2 ignore bug");
2596 if (conf_get_int(ssh
->conf
, CONF_sshbug_winadj
) == FORCE_ON
) {
2598 * Servers that don't support our winadj request for one
2599 * reason or another. Currently, none detected automatically.
2601 ssh
->remote_bugs
|= BUG_CHOKES_ON_WINADJ
;
2602 logevent("We believe remote version has winadj bug");
2607 * The `software version' part of an SSH version string is required
2608 * to contain no spaces or minus signs.
2610 static void ssh_fix_verstring(char *str
)
2612 /* Eat "SSH-<protoversion>-". */
2613 assert(*str
== 'S'); str
++;
2614 assert(*str
== 'S'); str
++;
2615 assert(*str
== 'H'); str
++;
2616 assert(*str
== '-'); str
++;
2617 while (*str
&& *str
!= '-') str
++;
2618 assert(*str
== '-'); str
++;
2620 /* Convert minus signs and spaces in the remaining string into
2623 if (*str
== '-' || *str
== ' ')
2630 * Send an appropriate SSH version string.
2632 static void ssh_send_verstring(Ssh ssh
, char *svers
)
2636 if (ssh
->version
== 2) {
2638 * Construct a v2 version string.
2640 verstring
= dupprintf("SSH-2.0-%s\015\012", sshver
);
2643 * Construct a v1 version string.
2645 verstring
= dupprintf("SSH-%s-%s\012",
2646 (ssh_versioncmp(svers
, "1.5") <= 0 ?
2651 ssh_fix_verstring(verstring
);
2653 if (ssh
->version
== 2) {
2656 * Record our version string.
2658 len
= strcspn(verstring
, "\015\012");
2659 ssh
->v_c
= snewn(len
+ 1, char);
2660 memcpy(ssh
->v_c
, verstring
, len
);
2664 logeventf(ssh
, "We claim version: %.*s",
2665 strcspn(verstring
, "\015\012"), verstring
);
2666 s_write(ssh
, verstring
, strlen(verstring
));
2670 static int do_ssh_init(Ssh ssh
, unsigned char c
)
2672 struct do_ssh_init_state
{
2681 crState(do_ssh_init_state
);
2685 /* Search for a line beginning with the string "SSH-" in the input. */
2687 if (c
!= 'S') goto no
;
2689 if (c
!= 'S') goto no
;
2691 if (c
!= 'H') goto no
;
2693 if (c
!= '-') goto no
;
2702 s
->vstring
= snewn(s
->vstrsize
, char);
2703 strcpy(s
->vstring
, "SSH-");
2707 crReturn(1); /* get another char */
2708 if (s
->vslen
>= s
->vstrsize
- 1) {
2710 s
->vstring
= sresize(s
->vstring
, s
->vstrsize
, char);
2712 s
->vstring
[s
->vslen
++] = c
;
2715 s
->version
[s
->i
] = '\0';
2717 } else if (s
->i
< sizeof(s
->version
) - 1)
2718 s
->version
[s
->i
++] = c
;
2719 } else if (c
== '\012')
2723 ssh
->agentfwd_enabled
= FALSE
;
2724 ssh
->rdpkt2_state
.incoming_sequence
= 0;
2726 s
->vstring
[s
->vslen
] = 0;
2727 s
->vstring
[strcspn(s
->vstring
, "\015\012")] = '\0';/* remove EOL chars */
2728 logeventf(ssh
, "Server version: %s", s
->vstring
);
2729 ssh_detect_bugs(ssh
, s
->vstring
);
2732 * Decide which SSH protocol version to support.
2735 /* Anything strictly below "2.0" means protocol 1 is supported. */
2736 s
->proto1
= ssh_versioncmp(s
->version
, "2.0") < 0;
2737 /* Anything greater or equal to "1.99" means protocol 2 is supported. */
2738 s
->proto2
= ssh_versioncmp(s
->version
, "1.99") >= 0;
2740 if (conf_get_int(ssh
->conf
, CONF_sshprot
) == 0 && !s
->proto1
) {
2741 bombout(("SSH protocol version 1 required by user but not provided by server"));
2744 if (conf_get_int(ssh
->conf
, CONF_sshprot
) == 3 && !s
->proto2
) {
2745 bombout(("SSH protocol version 2 required by user but not provided by server"));
2749 if (s
->proto2
&& (conf_get_int(ssh
->conf
, CONF_sshprot
) >= 2 || !s
->proto1
))
2754 logeventf(ssh
, "Using SSH protocol version %d", ssh
->version
);
2756 /* Send the version string, if we haven't already */
2757 if (conf_get_int(ssh
->conf
, CONF_sshprot
) != 3)
2758 ssh_send_verstring(ssh
, s
->version
);
2760 if (ssh
->version
== 2) {
2763 * Record their version string.
2765 len
= strcspn(s
->vstring
, "\015\012");
2766 ssh
->v_s
= snewn(len
+ 1, char);
2767 memcpy(ssh
->v_s
, s
->vstring
, len
);
2771 * Initialise SSH-2 protocol.
2773 ssh
->protocol
= ssh2_protocol
;
2774 ssh2_protocol_setup(ssh
);
2775 ssh
->s_rdpkt
= ssh2_rdpkt
;
2778 * Initialise SSH-1 protocol.
2780 ssh
->protocol
= ssh1_protocol
;
2781 ssh1_protocol_setup(ssh
);
2782 ssh
->s_rdpkt
= ssh1_rdpkt
;
2784 if (ssh
->version
== 2)
2785 do_ssh2_transport(ssh
, NULL
, -1, NULL
);
2787 update_specials_menu(ssh
->frontend
);
2788 ssh
->state
= SSH_STATE_BEFORE_SIZE
;
2789 ssh
->pinger
= pinger_new(ssh
->conf
, &ssh_backend
, ssh
);
2796 static void ssh_process_incoming_data(Ssh ssh
,
2797 unsigned char **data
, int *datalen
)
2799 struct Packet
*pktin
;
2801 pktin
= ssh
->s_rdpkt(ssh
, data
, datalen
);
2803 ssh
->protocol(ssh
, NULL
, 0, pktin
);
2804 ssh_free_packet(pktin
);
2808 static void ssh_queue_incoming_data(Ssh ssh
,
2809 unsigned char **data
, int *datalen
)
2811 bufchain_add(&ssh
->queued_incoming_data
, *data
, *datalen
);
2816 static void ssh_process_queued_incoming_data(Ssh ssh
)
2819 unsigned char *data
;
2822 while (!ssh
->frozen
&& bufchain_size(&ssh
->queued_incoming_data
)) {
2823 bufchain_prefix(&ssh
->queued_incoming_data
, &vdata
, &len
);
2827 while (!ssh
->frozen
&& len
> 0)
2828 ssh_process_incoming_data(ssh
, &data
, &len
);
2831 bufchain_consume(&ssh
->queued_incoming_data
, origlen
- len
);
2835 static void ssh_set_frozen(Ssh ssh
, int frozen
)
2838 sk_set_frozen(ssh
->s
, frozen
);
2839 ssh
->frozen
= frozen
;
2842 static void ssh_gotdata(Ssh ssh
, unsigned char *data
, int datalen
)
2844 /* Log raw data, if we're in that mode. */
2846 log_packet(ssh
->logctx
, PKT_INCOMING
, -1, NULL
, data
, datalen
,
2849 crBegin(ssh
->ssh_gotdata_crstate
);
2852 * To begin with, feed the characters one by one to the
2853 * protocol initialisation / selection function do_ssh_init().
2854 * When that returns 0, we're done with the initial greeting
2855 * exchange and can move on to packet discipline.
2858 int ret
; /* need not be kept across crReturn */
2860 crReturnV
; /* more data please */
2861 ret
= do_ssh_init(ssh
, *data
);
2869 * We emerge from that loop when the initial negotiation is
2870 * over and we have selected an s_rdpkt function. Now pass
2871 * everything to s_rdpkt, and then pass the resulting packets
2872 * to the proper protocol handler.
2876 while (bufchain_size(&ssh
->queued_incoming_data
) > 0 || datalen
> 0) {
2878 ssh_queue_incoming_data(ssh
, &data
, &datalen
);
2879 /* This uses up all data and cannot cause anything interesting
2880 * to happen; indeed, for anything to happen at all, we must
2881 * return, so break out. */
2883 } else if (bufchain_size(&ssh
->queued_incoming_data
) > 0) {
2884 /* This uses up some or all data, and may freeze the
2886 ssh_process_queued_incoming_data(ssh
);
2888 /* This uses up some or all data, and may freeze the
2890 ssh_process_incoming_data(ssh
, &data
, &datalen
);
2892 /* FIXME this is probably EBW. */
2893 if (ssh
->state
== SSH_STATE_CLOSED
)
2896 /* We're out of data. Go and get some more. */
2902 static int ssh_do_close(Ssh ssh
, int notify_exit
)
2905 struct ssh_channel
*c
;
2907 ssh
->state
= SSH_STATE_CLOSED
;
2908 expire_timer_context(ssh
);
2913 notify_remote_exit(ssh
->frontend
);
2918 * Now we must shut down any port- and X-forwarded channels going
2919 * through this connection.
2921 if (ssh
->channels
) {
2922 while (NULL
!= (c
= index234(ssh
->channels
, 0))) {
2925 x11_close(c
->u
.x11
.s
);
2928 case CHAN_SOCKDATA_DORMANT
:
2929 pfd_close(c
->u
.pfd
.s
);
2932 del234(ssh
->channels
, c
); /* moving next one to index 0 */
2933 if (ssh
->version
== 2)
2934 bufchain_clear(&c
->v
.v2
.outbuffer
);
2939 * Go through port-forwardings, and close any associated
2940 * listening sockets.
2942 if (ssh
->portfwds
) {
2943 struct ssh_portfwd
*pf
;
2944 while (NULL
!= (pf
= index234(ssh
->portfwds
, 0))) {
2945 /* Dispose of any listening socket. */
2947 pfd_terminate(pf
->local
);
2948 del234(ssh
->portfwds
, pf
); /* moving next one to index 0 */
2951 freetree234(ssh
->portfwds
);
2952 ssh
->portfwds
= NULL
;
2958 static void ssh_log(Plug plug
, int type
, SockAddr addr
, int port
,
2959 const char *error_msg
, int error_code
)
2961 Ssh ssh
= (Ssh
) plug
;
2962 char addrbuf
[256], *msg
;
2964 sk_getaddr(addr
, addrbuf
, lenof(addrbuf
));
2967 msg
= dupprintf("Connecting to %s port %d", addrbuf
, port
);
2969 msg
= dupprintf("Failed to connect to %s: %s", addrbuf
, error_msg
);
2975 static int ssh_closing(Plug plug
, const char *error_msg
, int error_code
,
2978 Ssh ssh
= (Ssh
) plug
;
2979 int need_notify
= ssh_do_close(ssh
, FALSE
);
2982 if (!ssh
->close_expected
)
2983 error_msg
= "Server unexpectedly closed network connection";
2985 error_msg
= "Server closed network connection";
2988 if (ssh
->close_expected
&& ssh
->clean_exit
&& ssh
->exitcode
< 0)
2992 notify_remote_exit(ssh
->frontend
);
2995 logevent(error_msg
);
2996 if (!ssh
->close_expected
|| !ssh
->clean_exit
)
2997 connection_fatal(ssh
->frontend
, "%s", error_msg
);
3001 static int ssh_receive(Plug plug
, int urgent
, char *data
, int len
)
3003 Ssh ssh
= (Ssh
) plug
;
3004 ssh_gotdata(ssh
, (unsigned char *)data
, len
);
3005 if (ssh
->state
== SSH_STATE_CLOSED
) {
3006 ssh_do_close(ssh
, TRUE
);
3012 static void ssh_sent(Plug plug
, int bufsize
)
3014 Ssh ssh
= (Ssh
) plug
;
3016 * If the send backlog on the SSH socket itself clears, we
3017 * should unthrottle the whole world if it was throttled.
3019 if (bufsize
< SSH_MAX_BACKLOG
)
3020 ssh_throttle_all(ssh
, 0, bufsize
);
3024 * Connect to specified host and port.
3025 * Returns an error message, or NULL on success.
3026 * Also places the canonical host name into `realhost'. It must be
3027 * freed by the caller.
3029 static const char *connect_to_host(Ssh ssh
, char *host
, int port
,
3030 char **realhost
, int nodelay
, int keepalive
)
3032 static const struct plug_function_table fn_table
= {
3043 int addressfamily
, sshprot
;
3045 loghost
= conf_get_str(ssh
->conf
, CONF_loghost
);
3049 ssh
->savedhost
= dupstr(loghost
);
3050 ssh
->savedport
= 22; /* default ssh port */
3053 * A colon suffix on savedhost also lets us affect
3056 * (FIXME: do something about IPv6 address literals here.)
3058 colon
= strrchr(ssh
->savedhost
, ':');
3062 ssh
->savedport
= atoi(colon
);
3065 ssh
->savedhost
= dupstr(host
);
3067 port
= 22; /* default ssh port */
3068 ssh
->savedport
= port
;
3074 addressfamily
= conf_get_int(ssh
->conf
, CONF_addressfamily
);
3075 logeventf(ssh
, "Looking up host \"%s\"%s", host
,
3076 (addressfamily
== ADDRTYPE_IPV4 ?
" (IPv4)" :
3077 (addressfamily
== ADDRTYPE_IPV6 ?
" (IPv6)" : "")));
3078 addr
= name_lookup(host
, port
, realhost
, ssh
->conf
, addressfamily
);
3079 if ((err
= sk_addr_error(addr
)) != NULL
) {
3083 ssh
->fullhostname
= dupstr(*realhost
); /* save in case of GSSAPI */
3088 ssh
->fn
= &fn_table
;
3089 ssh
->s
= new_connection(addr
, *realhost
, port
,
3090 0, 1, nodelay
, keepalive
, (Plug
) ssh
, ssh
->conf
);
3091 if ((err
= sk_socket_error(ssh
->s
)) != NULL
) {
3093 notify_remote_exit(ssh
->frontend
);
3098 * If the SSH version number's fixed, set it now, and if it's SSH-2,
3099 * send the version string too.
3101 sshprot
= conf_get_int(ssh
->conf
, CONF_sshprot
);
3106 ssh_send_verstring(ssh
, NULL
);
3110 * loghost, if configured, overrides realhost.
3114 *realhost
= dupstr(loghost
);
3121 * Throttle or unthrottle the SSH connection.
3123 static void ssh_throttle_conn(Ssh ssh
, int adjust
)
3125 int old_count
= ssh
->conn_throttle_count
;
3126 ssh
->conn_throttle_count
+= adjust
;
3127 assert(ssh
->conn_throttle_count
>= 0);
3128 if (ssh
->conn_throttle_count
&& !old_count
) {
3129 ssh_set_frozen(ssh
, 1);
3130 } else if (!ssh
->conn_throttle_count
&& old_count
) {
3131 ssh_set_frozen(ssh
, 0);
3136 * Throttle or unthrottle _all_ local data streams (for when sends
3137 * on the SSH connection itself back up).
3139 static void ssh_throttle_all(Ssh ssh
, int enable
, int bufsize
)
3142 struct ssh_channel
*c
;
3144 if (enable
== ssh
->throttled_all
)
3146 ssh
->throttled_all
= enable
;
3147 ssh
->overall_bufsize
= bufsize
;
3150 for (i
= 0; NULL
!= (c
= index234(ssh
->channels
, i
)); i
++) {
3152 case CHAN_MAINSESSION
:
3154 * This is treated separately, outside the switch.
3158 x11_override_throttle(c
->u
.x11
.s
, enable
);
3161 /* Agent channels require no buffer management. */
3164 pfd_override_throttle(c
->u
.pfd
.s
, enable
);
3170 static void ssh_agent_callback(void *sshv
, void *reply
, int replylen
)
3172 Ssh ssh
= (Ssh
) sshv
;
3174 ssh
->agent_response
= reply
;
3175 ssh
->agent_response_len
= replylen
;
3177 if (ssh
->version
== 1)
3178 do_ssh1_login(ssh
, NULL
, -1, NULL
);
3180 do_ssh2_authconn(ssh
, NULL
, -1, NULL
);
3183 static void ssh_dialog_callback(void *sshv
, int ret
)
3185 Ssh ssh
= (Ssh
) sshv
;
3187 ssh
->user_response
= ret
;
3189 if (ssh
->version
== 1)
3190 do_ssh1_login(ssh
, NULL
, -1, NULL
);
3192 do_ssh2_transport(ssh
, NULL
, -1, NULL
);
3195 * This may have unfrozen the SSH connection, so do a
3198 ssh_process_queued_incoming_data(ssh
);
3201 static void ssh_agentf_callback(void *cv
, void *reply
, int replylen
)
3203 struct ssh_channel
*c
= (struct ssh_channel
*)cv
;
3205 void *sentreply
= reply
;
3208 /* Fake SSH_AGENT_FAILURE. */
3209 sentreply
= "\0\0\0\1\5";
3212 if (ssh
->version
== 2) {
3213 ssh2_add_channel_data(c
, sentreply
, replylen
);
3216 send_packet(ssh
, SSH1_MSG_CHANNEL_DATA
,
3217 PKT_INT
, c
->remoteid
,
3220 PKT_DATA
, sentreply
, replylen
,
3229 * Client-initiated disconnection. Send a DISCONNECT if `wire_reason'
3230 * non-NULL, otherwise just close the connection. `client_reason' == NULL
3231 * => log `wire_reason'.
3233 static void ssh_disconnect(Ssh ssh
, char *client_reason
, char *wire_reason
,
3234 int code
, int clean_exit
)
3238 client_reason
= wire_reason
;
3240 error
= dupprintf("Disconnected: %s", client_reason
);
3242 error
= dupstr("Disconnected");
3244 if (ssh
->version
== 1) {
3245 send_packet(ssh
, SSH1_MSG_DISCONNECT
, PKT_STR
, wire_reason
,
3247 } else if (ssh
->version
== 2) {
3248 struct Packet
*pktout
= ssh2_pkt_init(SSH2_MSG_DISCONNECT
);
3249 ssh2_pkt_adduint32(pktout
, code
);
3250 ssh2_pkt_addstring(pktout
, wire_reason
);
3251 ssh2_pkt_addstring(pktout
, "en"); /* language tag */
3252 ssh2_pkt_send_noqueue(ssh
, pktout
);
3255 ssh
->close_expected
= TRUE
;
3256 ssh
->clean_exit
= clean_exit
;
3257 ssh_closing((Plug
)ssh
, error
, 0, 0);
3262 * Handle the key exchange and user authentication phases.
3264 static int do_ssh1_login(Ssh ssh
, unsigned char *in
, int inlen
,
3265 struct Packet
*pktin
)
3268 unsigned char cookie
[8], *ptr
;
3269 struct RSAKey servkey
, hostkey
;
3270 struct MD5Context md5c
;
3271 struct do_ssh1_login_state
{
3274 unsigned char *rsabuf
, *keystr1
, *keystr2
;
3275 unsigned long supported_ciphers_mask
, supported_auths_mask
;
3276 int tried_publickey
, tried_agent
;
3277 int tis_auth_refused
, ccard_auth_refused
;
3278 unsigned char session_id
[16];
3280 void *publickey_blob
;
3281 int publickey_bloblen
;
3282 char *publickey_comment
;
3283 int publickey_encrypted
;
3284 prompts_t
*cur_prompt
;
3287 unsigned char request
[5], *response
, *p
;
3298 crState(do_ssh1_login_state
);
3305 if (pktin
->type
!= SSH1_SMSG_PUBLIC_KEY
) {
3306 bombout(("Public key packet not received"));
3310 logevent("Received public keys");
3312 ptr
= ssh_pkt_getdata(pktin
, 8);
3314 bombout(("SSH-1 public key packet stopped before random cookie"));
3317 memcpy(cookie
, ptr
, 8);
3319 if (!ssh1_pkt_getrsakey(pktin
, &servkey
, &s
->keystr1
) ||
3320 !ssh1_pkt_getrsakey(pktin
, &hostkey
, &s
->keystr2
)) {
3321 bombout(("Failed to read SSH-1 public keys from public key packet"));
3326 * Log the host key fingerprint.
3330 logevent("Host key fingerprint is:");
3331 strcpy(logmsg
, " ");
3332 hostkey
.comment
= NULL
;
3333 rsa_fingerprint(logmsg
+ strlen(logmsg
),
3334 sizeof(logmsg
) - strlen(logmsg
), &hostkey
);
3338 ssh
->v1_remote_protoflags
= ssh_pkt_getuint32(pktin
);
3339 s
->supported_ciphers_mask
= ssh_pkt_getuint32(pktin
);
3340 s
->supported_auths_mask
= ssh_pkt_getuint32(pktin
);
3341 if ((ssh
->remote_bugs
& BUG_CHOKES_ON_RSA
))
3342 s
->supported_auths_mask
&= ~(1 << SSH1_AUTH_RSA
);
3344 ssh
->v1_local_protoflags
=
3345 ssh
->v1_remote_protoflags
& SSH1_PROTOFLAGS_SUPPORTED
;
3346 ssh
->v1_local_protoflags
|= SSH1_PROTOFLAG_SCREEN_NUMBER
;
3349 MD5Update(&md5c
, s
->keystr2
, hostkey
.bytes
);
3350 MD5Update(&md5c
, s
->keystr1
, servkey
.bytes
);
3351 MD5Update(&md5c
, cookie
, 8);
3352 MD5Final(s
->session_id
, &md5c
);
3354 for (i
= 0; i
< 32; i
++)
3355 ssh
->session_key
[i
] = random_byte();
3358 * Verify that the `bits' and `bytes' parameters match.
3360 if (hostkey
.bits
> hostkey
.bytes
* 8 ||
3361 servkey
.bits
> servkey
.bytes
* 8) {
3362 bombout(("SSH-1 public keys were badly formatted"));
3366 s
->len
= (hostkey
.bytes
> servkey
.bytes ? hostkey
.bytes
: servkey
.bytes
);
3368 s
->rsabuf
= snewn(s
->len
, unsigned char);
3371 * Verify the host key.
3375 * First format the key into a string.
3377 int len
= rsastr_len(&hostkey
);
3378 char fingerprint
[100];
3379 char *keystr
= snewn(len
, char);
3380 rsastr_fmt(keystr
, &hostkey
);
3381 rsa_fingerprint(fingerprint
, sizeof(fingerprint
), &hostkey
);
3383 ssh_set_frozen(ssh
, 1);
3384 s
->dlgret
= verify_ssh_host_key(ssh
->frontend
,
3385 ssh
->savedhost
, ssh
->savedport
,
3386 "rsa", keystr
, fingerprint
,
3387 ssh_dialog_callback
, ssh
);
3389 if (s
->dlgret
< 0) {
3393 bombout(("Unexpected data from server while waiting"
3394 " for user host key response"));
3397 } while (pktin
|| inlen
> 0);
3398 s
->dlgret
= ssh
->user_response
;
3400 ssh_set_frozen(ssh
, 0);
3402 if (s
->dlgret
== 0) {
3403 ssh_disconnect(ssh
, "User aborted at host key verification",
3409 for (i
= 0; i
< 32; i
++) {
3410 s
->rsabuf
[i
] = ssh
->session_key
[i
];
3412 s
->rsabuf
[i
] ^= s
->session_id
[i
];
3415 if (hostkey
.bytes
> servkey
.bytes
) {
3416 ret
= rsaencrypt(s
->rsabuf
, 32, &servkey
);
3418 ret
= rsaencrypt(s
->rsabuf
, servkey
.bytes
, &hostkey
);
3420 ret
= rsaencrypt(s
->rsabuf
, 32, &hostkey
);
3422 ret
= rsaencrypt(s
->rsabuf
, hostkey
.bytes
, &servkey
);
3425 bombout(("SSH-1 public key encryptions failed due to bad formatting"));
3429 logevent("Encrypted session key");
3432 int cipher_chosen
= 0, warn
= 0;
3433 char *cipher_string
= NULL
;
3435 for (i
= 0; !cipher_chosen
&& i
< CIPHER_MAX
; i
++) {
3436 int next_cipher
= conf_get_int_int(ssh
->conf
,
3437 CONF_ssh_cipherlist
, i
);
3438 if (next_cipher
== CIPHER_WARN
) {
3439 /* If/when we choose a cipher, warn about it */
3441 } else if (next_cipher
== CIPHER_AES
) {
3442 /* XXX Probably don't need to mention this. */
3443 logevent("AES not supported in SSH-1, skipping");
3445 switch (next_cipher
) {
3446 case CIPHER_3DES
: s
->cipher_type
= SSH_CIPHER_3DES
;
3447 cipher_string
= "3DES"; break;
3448 case CIPHER_BLOWFISH
: s
->cipher_type
= SSH_CIPHER_BLOWFISH
;
3449 cipher_string
= "Blowfish"; break;
3450 case CIPHER_DES
: s
->cipher_type
= SSH_CIPHER_DES
;
3451 cipher_string
= "single-DES"; break;
3453 if (s
->supported_ciphers_mask
& (1 << s
->cipher_type
))
3457 if (!cipher_chosen
) {
3458 if ((s
->supported_ciphers_mask
& (1 << SSH_CIPHER_3DES
)) == 0)
3459 bombout(("Server violates SSH-1 protocol by not "
3460 "supporting 3DES encryption"));
3462 /* shouldn't happen */
3463 bombout(("No supported ciphers found"));
3467 /* Warn about chosen cipher if necessary. */
3469 ssh_set_frozen(ssh
, 1);
3470 s
->dlgret
= askalg(ssh
->frontend
, "cipher", cipher_string
,
3471 ssh_dialog_callback
, ssh
);
3472 if (s
->dlgret
< 0) {
3476 bombout(("Unexpected data from server while waiting"
3477 " for user response"));
3480 } while (pktin
|| inlen
> 0);
3481 s
->dlgret
= ssh
->user_response
;
3483 ssh_set_frozen(ssh
, 0);
3484 if (s
->dlgret
== 0) {
3485 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
3492 switch (s
->cipher_type
) {
3493 case SSH_CIPHER_3DES
:
3494 logevent("Using 3DES encryption");
3496 case SSH_CIPHER_DES
:
3497 logevent("Using single-DES encryption");
3499 case SSH_CIPHER_BLOWFISH
:
3500 logevent("Using Blowfish encryption");
3504 send_packet(ssh
, SSH1_CMSG_SESSION_KEY
,
3505 PKT_CHAR
, s
->cipher_type
,
3506 PKT_DATA
, cookie
, 8,
3507 PKT_CHAR
, (s
->len
* 8) >> 8, PKT_CHAR
, (s
->len
* 8) & 0xFF,
3508 PKT_DATA
, s
->rsabuf
, s
->len
,
3509 PKT_INT
, ssh
->v1_local_protoflags
, PKT_END
);
3511 logevent("Trying to enable encryption...");
3515 ssh
->cipher
= (s
->cipher_type
== SSH_CIPHER_BLOWFISH ?
&ssh_blowfish_ssh1
:
3516 s
->cipher_type
== SSH_CIPHER_DES ?
&ssh_des
:
3518 ssh
->v1_cipher_ctx
= ssh
->cipher
->make_context();
3519 ssh
->cipher
->sesskey(ssh
->v1_cipher_ctx
, ssh
->session_key
);
3520 logeventf(ssh
, "Initialised %s encryption", ssh
->cipher
->text_name
);
3522 ssh
->crcda_ctx
= crcda_make_context();
3523 logevent("Installing CRC compensation attack detector");
3525 if (servkey
.modulus
) {
3526 sfree(servkey
.modulus
);
3527 servkey
.modulus
= NULL
;
3529 if (servkey
.exponent
) {
3530 sfree(servkey
.exponent
);
3531 servkey
.exponent
= NULL
;
3533 if (hostkey
.modulus
) {
3534 sfree(hostkey
.modulus
);
3535 hostkey
.modulus
= NULL
;
3537 if (hostkey
.exponent
) {
3538 sfree(hostkey
.exponent
);
3539 hostkey
.exponent
= NULL
;
3543 if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
3544 bombout(("Encryption not successfully enabled"));
3548 logevent("Successfully started encryption");
3550 fflush(stdout
); /* FIXME eh? */
3552 if ((ssh
->username
= get_remote_username(ssh
->conf
)) == NULL
) {
3553 int ret
; /* need not be kept over crReturn */
3554 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3555 s
->cur_prompt
->to_server
= TRUE
;
3556 s
->cur_prompt
->name
= dupstr("SSH login name");
3557 add_prompt(s
->cur_prompt
, dupstr("login as: "), TRUE
);
3558 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
3561 crWaitUntil(!pktin
);
3562 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
3567 * Failed to get a username. Terminate.
3569 free_prompts(s
->cur_prompt
);
3570 ssh_disconnect(ssh
, "No username provided", NULL
, 0, TRUE
);
3573 ssh
->username
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
3574 free_prompts(s
->cur_prompt
);
3577 send_packet(ssh
, SSH1_CMSG_USER
, PKT_STR
, ssh
->username
, PKT_END
);
3579 char *userlog
= dupprintf("Sent username \"%s\"", ssh
->username
);
3581 if (flags
& FLAG_INTERACTIVE
&&
3582 (!((flags
& FLAG_STDERR
) && (flags
& FLAG_VERBOSE
)))) {
3583 c_write_str(ssh
, userlog
);
3584 c_write_str(ssh
, "\r\n");
3592 if ((s
->supported_auths_mask
& (1 << SSH1_AUTH_RSA
)) == 0) {
3593 /* We must not attempt PK auth. Pretend we've already tried it. */
3594 s
->tried_publickey
= s
->tried_agent
= 1;
3596 s
->tried_publickey
= s
->tried_agent
= 0;
3598 s
->tis_auth_refused
= s
->ccard_auth_refused
= 0;
3600 * Load the public half of any configured keyfile for later use.
3602 s
->keyfile
= conf_get_filename(ssh
->conf
, CONF_keyfile
);
3603 if (!filename_is_null(s
->keyfile
)) {
3605 logeventf(ssh
, "Reading private key file \"%.150s\"",
3606 filename_to_str(s
->keyfile
));
3607 keytype
= key_type(s
->keyfile
);
3608 if (keytype
== SSH_KEYTYPE_SSH1
) {
3610 if (rsakey_pubblob(s
->keyfile
,
3611 &s
->publickey_blob
, &s
->publickey_bloblen
,
3612 &s
->publickey_comment
, &error
)) {
3613 s
->publickey_encrypted
= rsakey_encrypted(s
->keyfile
,
3617 logeventf(ssh
, "Unable to load private key (%s)", error
);
3618 msgbuf
= dupprintf("Unable to load private key file "
3619 "\"%.150s\" (%s)\r\n",
3620 filename_to_str(s
->keyfile
),
3622 c_write_str(ssh
, msgbuf
);
3624 s
->publickey_blob
= NULL
;
3628 logeventf(ssh
, "Unable to use this key file (%s)",
3629 key_type_to_str(keytype
));
3630 msgbuf
= dupprintf("Unable to use key file \"%.150s\""
3632 filename_to_str(s
->keyfile
),
3633 key_type_to_str(keytype
));
3634 c_write_str(ssh
, msgbuf
);
3636 s
->publickey_blob
= NULL
;
3639 s
->publickey_blob
= NULL
;
3641 while (pktin
->type
== SSH1_SMSG_FAILURE
) {
3642 s
->pwpkt_type
= SSH1_CMSG_AUTH_PASSWORD
;
3644 if (conf_get_int(ssh
->conf
, CONF_tryagent
) && agent_exists() && !s
->tried_agent
) {
3646 * Attempt RSA authentication using Pageant.
3652 logevent("Pageant is running. Requesting keys.");
3654 /* Request the keys held by the agent. */
3655 PUT_32BIT(s
->request
, 1);
3656 s
->request
[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES
;
3657 if (!agent_query(s
->request
, 5, &r
, &s
->responselen
,
3658 ssh_agent_callback
, ssh
)) {
3662 bombout(("Unexpected data from server while waiting"
3663 " for agent response"));
3666 } while (pktin
|| inlen
> 0);
3667 r
= ssh
->agent_response
;
3668 s
->responselen
= ssh
->agent_response_len
;
3670 s
->response
= (unsigned char *) r
;
3671 if (s
->response
&& s
->responselen
>= 5 &&
3672 s
->response
[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER
) {
3673 s
->p
= s
->response
+ 5;
3674 s
->nkeys
= GET_32BIT(s
->p
);
3676 logeventf(ssh
, "Pageant has %d SSH-1 keys", s
->nkeys
);
3677 for (s
->keyi
= 0; s
->keyi
< s
->nkeys
; s
->keyi
++) {
3678 unsigned char *pkblob
= s
->p
;
3682 do { /* do while (0) to make breaking easy */
3683 n
= ssh1_read_bignum
3684 (s
->p
, s
->responselen
-(s
->p
-s
->response
),
3689 n
= ssh1_read_bignum
3690 (s
->p
, s
->responselen
-(s
->p
-s
->response
),
3695 if (s
->responselen
- (s
->p
-s
->response
) < 4)
3697 s
->commentlen
= GET_32BIT(s
->p
);
3699 if (s
->responselen
- (s
->p
-s
->response
) <
3702 s
->commentp
= (char *)s
->p
;
3703 s
->p
+= s
->commentlen
;
3707 logevent("Pageant key list packet was truncated");
3711 if (s
->publickey_blob
) {
3712 if (!memcmp(pkblob
, s
->publickey_blob
,
3713 s
->publickey_bloblen
)) {
3714 logeventf(ssh
, "Pageant key #%d matches "
3715 "configured key file", s
->keyi
);
3716 s
->tried_publickey
= 1;
3718 /* Skip non-configured key */
3721 logeventf(ssh
, "Trying Pageant key #%d", s
->keyi
);
3722 send_packet(ssh
, SSH1_CMSG_AUTH_RSA
,
3723 PKT_BIGNUM
, s
->key
.modulus
, PKT_END
);
3725 if (pktin
->type
!= SSH1_SMSG_AUTH_RSA_CHALLENGE
) {
3726 logevent("Key refused");
3729 logevent("Received RSA challenge");
3730 if ((s
->challenge
= ssh1_pkt_getmp(pktin
)) == NULL
) {
3731 bombout(("Server's RSA challenge was badly formatted"));
3736 char *agentreq
, *q
, *ret
;
3739 len
= 1 + 4; /* message type, bit count */
3740 len
+= ssh1_bignum_length(s
->key
.exponent
);
3741 len
+= ssh1_bignum_length(s
->key
.modulus
);
3742 len
+= ssh1_bignum_length(s
->challenge
);
3743 len
+= 16; /* session id */
3744 len
+= 4; /* response format */
3745 agentreq
= snewn(4 + len
, char);
3746 PUT_32BIT(agentreq
, len
);
3748 *q
++ = SSH1_AGENTC_RSA_CHALLENGE
;
3749 PUT_32BIT(q
, bignum_bitcount(s
->key
.modulus
));
3751 q
+= ssh1_write_bignum(q
, s
->key
.exponent
);
3752 q
+= ssh1_write_bignum(q
, s
->key
.modulus
);
3753 q
+= ssh1_write_bignum(q
, s
->challenge
);
3754 memcpy(q
, s
->session_id
, 16);
3756 PUT_32BIT(q
, 1); /* response format */
3757 if (!agent_query(agentreq
, len
+ 4, &vret
, &retlen
,
3758 ssh_agent_callback
, ssh
)) {
3763 bombout(("Unexpected data from server"
3764 " while waiting for agent"
3768 } while (pktin
|| inlen
> 0);
3769 vret
= ssh
->agent_response
;
3770 retlen
= ssh
->agent_response_len
;
3775 if (ret
[4] == SSH1_AGENT_RSA_RESPONSE
) {
3776 logevent("Sending Pageant's response");
3777 send_packet(ssh
, SSH1_CMSG_AUTH_RSA_RESPONSE
,
3778 PKT_DATA
, ret
+ 5, 16,
3782 if (pktin
->type
== SSH1_SMSG_SUCCESS
) {
3784 ("Pageant's response accepted");
3785 if (flags
& FLAG_VERBOSE
) {
3786 c_write_str(ssh
, "Authenticated using"
3788 c_write(ssh
, s
->commentp
,
3790 c_write_str(ssh
, "\" from agent\r\n");
3795 ("Pageant's response not accepted");
3798 ("Pageant failed to answer challenge");
3802 logevent("No reply received from Pageant");
3805 freebn(s
->key
.exponent
);
3806 freebn(s
->key
.modulus
);
3807 freebn(s
->challenge
);
3812 if (s
->publickey_blob
&& !s
->tried_publickey
)
3813 logevent("Configured key file not in Pageant");
3815 logevent("Failed to get reply from Pageant");
3820 if (s
->publickey_blob
&& !s
->tried_publickey
) {
3822 * Try public key authentication with the specified
3825 int got_passphrase
; /* need not be kept over crReturn */
3826 if (flags
& FLAG_VERBOSE
)
3827 c_write_str(ssh
, "Trying public key authentication.\r\n");
3828 s
->keyfile
= conf_get_filename(ssh
->conf
, CONF_keyfile
);
3829 logeventf(ssh
, "Trying public key \"%s\"",
3830 filename_to_str(s
->keyfile
));
3831 s
->tried_publickey
= 1;
3832 got_passphrase
= FALSE
;
3833 while (!got_passphrase
) {
3835 * Get a passphrase, if necessary.
3837 char *passphrase
= NULL
; /* only written after crReturn */
3839 if (!s
->publickey_encrypted
) {
3840 if (flags
& FLAG_VERBOSE
)
3841 c_write_str(ssh
, "No passphrase required.\r\n");
3844 int ret
; /* need not be kept over crReturn */
3845 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3846 s
->cur_prompt
->to_server
= FALSE
;
3847 s
->cur_prompt
->name
= dupstr("SSH key passphrase");
3848 add_prompt(s
->cur_prompt
,
3849 dupprintf("Passphrase for key \"%.100s\": ",
3850 s
->publickey_comment
), FALSE
);
3851 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
3854 crWaitUntil(!pktin
);
3855 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
3859 /* Failed to get a passphrase. Terminate. */
3860 free_prompts(s
->cur_prompt
);
3861 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
3865 passphrase
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
3866 free_prompts(s
->cur_prompt
);
3869 * Try decrypting key with passphrase.
3871 s
->keyfile
= conf_get_filename(ssh
->conf
, CONF_keyfile
);
3872 ret
= loadrsakey(s
->keyfile
, &s
->key
, passphrase
,
3875 smemclr(passphrase
, strlen(passphrase
));
3879 /* Correct passphrase. */
3880 got_passphrase
= TRUE
;
3881 } else if (ret
== 0) {
3882 c_write_str(ssh
, "Couldn't load private key from ");
3883 c_write_str(ssh
, filename_to_str(s
->keyfile
));
3884 c_write_str(ssh
, " (");
3885 c_write_str(ssh
, error
);
3886 c_write_str(ssh
, ").\r\n");
3887 got_passphrase
= FALSE
;
3888 break; /* go and try something else */
3889 } else if (ret
== -1) {
3890 c_write_str(ssh
, "Wrong passphrase.\r\n"); /* FIXME */
3891 got_passphrase
= FALSE
;
3894 assert(0 && "unexpected return from loadrsakey()");
3895 got_passphrase
= FALSE
; /* placate optimisers */
3899 if (got_passphrase
) {
3902 * Send a public key attempt.
3904 send_packet(ssh
, SSH1_CMSG_AUTH_RSA
,
3905 PKT_BIGNUM
, s
->key
.modulus
, PKT_END
);
3908 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
3909 c_write_str(ssh
, "Server refused our public key.\r\n");
3910 continue; /* go and try something else */
3912 if (pktin
->type
!= SSH1_SMSG_AUTH_RSA_CHALLENGE
) {
3913 bombout(("Bizarre response to offer of public key"));
3919 unsigned char buffer
[32];
3920 Bignum challenge
, response
;
3922 if ((challenge
= ssh1_pkt_getmp(pktin
)) == NULL
) {
3923 bombout(("Server's RSA challenge was badly formatted"));
3926 response
= rsadecrypt(challenge
, &s
->key
);
3927 freebn(s
->key
.private_exponent
);/* burn the evidence */
3929 for (i
= 0; i
< 32; i
++) {
3930 buffer
[i
] = bignum_byte(response
, 31 - i
);
3934 MD5Update(&md5c
, buffer
, 32);
3935 MD5Update(&md5c
, s
->session_id
, 16);
3936 MD5Final(buffer
, &md5c
);
3938 send_packet(ssh
, SSH1_CMSG_AUTH_RSA_RESPONSE
,
3939 PKT_DATA
, buffer
, 16, PKT_END
);
3946 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
3947 if (flags
& FLAG_VERBOSE
)
3948 c_write_str(ssh
, "Failed to authenticate with"
3949 " our public key.\r\n");
3950 continue; /* go and try something else */
3951 } else if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
3952 bombout(("Bizarre response to RSA authentication response"));
3956 break; /* we're through! */
3962 * Otherwise, try various forms of password-like authentication.
3964 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3966 if (conf_get_int(ssh
->conf
, CONF_try_tis_auth
) &&
3967 (s
->supported_auths_mask
& (1 << SSH1_AUTH_TIS
)) &&
3968 !s
->tis_auth_refused
) {
3969 s
->pwpkt_type
= SSH1_CMSG_AUTH_TIS_RESPONSE
;
3970 logevent("Requested TIS authentication");
3971 send_packet(ssh
, SSH1_CMSG_AUTH_TIS
, PKT_END
);
3973 if (pktin
->type
!= SSH1_SMSG_AUTH_TIS_CHALLENGE
) {
3974 logevent("TIS authentication declined");
3975 if (flags
& FLAG_INTERACTIVE
)
3976 c_write_str(ssh
, "TIS authentication refused.\r\n");
3977 s
->tis_auth_refused
= 1;
3982 char *instr_suf
, *prompt
;
3984 ssh_pkt_getstring(pktin
, &challenge
, &challengelen
);
3986 bombout(("TIS challenge packet was badly formed"));
3989 logevent("Received TIS challenge");
3990 s
->cur_prompt
->to_server
= TRUE
;
3991 s
->cur_prompt
->name
= dupstr("SSH TIS authentication");
3992 /* Prompt heuristic comes from OpenSSH */
3993 if (memchr(challenge
, '\n', challengelen
)) {
3994 instr_suf
= dupstr("");
3995 prompt
= dupprintf("%.*s", challengelen
, challenge
);
3997 instr_suf
= dupprintf("%.*s", challengelen
, challenge
);
3998 prompt
= dupstr("Response: ");
4000 s
->cur_prompt
->instruction
=
4001 dupprintf("Using TIS authentication.%s%s",
4002 (*instr_suf
) ?
"\n" : "",
4004 s
->cur_prompt
->instr_reqd
= TRUE
;
4005 add_prompt(s
->cur_prompt
, prompt
, FALSE
);
4009 if (conf_get_int(ssh
->conf
, CONF_try_tis_auth
) &&
4010 (s
->supported_auths_mask
& (1 << SSH1_AUTH_CCARD
)) &&
4011 !s
->ccard_auth_refused
) {
4012 s
->pwpkt_type
= SSH1_CMSG_AUTH_CCARD_RESPONSE
;
4013 logevent("Requested CryptoCard authentication");
4014 send_packet(ssh
, SSH1_CMSG_AUTH_CCARD
, PKT_END
);
4016 if (pktin
->type
!= SSH1_SMSG_AUTH_CCARD_CHALLENGE
) {
4017 logevent("CryptoCard authentication declined");
4018 c_write_str(ssh
, "CryptoCard authentication refused.\r\n");
4019 s
->ccard_auth_refused
= 1;
4024 char *instr_suf
, *prompt
;
4026 ssh_pkt_getstring(pktin
, &challenge
, &challengelen
);
4028 bombout(("CryptoCard challenge packet was badly formed"));
4031 logevent("Received CryptoCard challenge");
4032 s
->cur_prompt
->to_server
= TRUE
;
4033 s
->cur_prompt
->name
= dupstr("SSH CryptoCard authentication");
4034 s
->cur_prompt
->name_reqd
= FALSE
;
4035 /* Prompt heuristic comes from OpenSSH */
4036 if (memchr(challenge
, '\n', challengelen
)) {
4037 instr_suf
= dupstr("");
4038 prompt
= dupprintf("%.*s", challengelen
, challenge
);
4040 instr_suf
= dupprintf("%.*s", challengelen
, challenge
);
4041 prompt
= dupstr("Response: ");
4043 s
->cur_prompt
->instruction
=
4044 dupprintf("Using CryptoCard authentication.%s%s",
4045 (*instr_suf
) ?
"\n" : "",
4047 s
->cur_prompt
->instr_reqd
= TRUE
;
4048 add_prompt(s
->cur_prompt
, prompt
, FALSE
);
4052 if (s
->pwpkt_type
== SSH1_CMSG_AUTH_PASSWORD
) {
4053 if ((s
->supported_auths_mask
& (1 << SSH1_AUTH_PASSWORD
)) == 0) {
4054 bombout(("No supported authentication methods available"));
4057 s
->cur_prompt
->to_server
= TRUE
;
4058 s
->cur_prompt
->name
= dupstr("SSH password");
4059 add_prompt(s
->cur_prompt
, dupprintf("%s@%s's password: ",
4060 ssh
->username
, ssh
->savedhost
),
4065 * Show password prompt, having first obtained it via a TIS
4066 * or CryptoCard exchange if we're doing TIS or CryptoCard
4070 int ret
; /* need not be kept over crReturn */
4071 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
4074 crWaitUntil(!pktin
);
4075 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
4080 * Failed to get a password (for example
4081 * because one was supplied on the command line
4082 * which has already failed to work). Terminate.
4084 free_prompts(s
->cur_prompt
);
4085 ssh_disconnect(ssh
, NULL
, "Unable to authenticate", 0, TRUE
);
4090 if (s
->pwpkt_type
== SSH1_CMSG_AUTH_PASSWORD
) {
4092 * Defence against traffic analysis: we send a
4093 * whole bunch of packets containing strings of
4094 * different lengths. One of these strings is the
4095 * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
4096 * The others are all random data in
4097 * SSH1_MSG_IGNORE packets. This way a passive
4098 * listener can't tell which is the password, and
4099 * hence can't deduce the password length.
4101 * Anybody with a password length greater than 16
4102 * bytes is going to have enough entropy in their
4103 * password that a listener won't find it _that_
4104 * much help to know how long it is. So what we'll
4107 * - if password length < 16, we send 15 packets
4108 * containing string lengths 1 through 15
4110 * - otherwise, we let N be the nearest multiple
4111 * of 8 below the password length, and send 8
4112 * packets containing string lengths N through
4113 * N+7. This won't obscure the order of
4114 * magnitude of the password length, but it will
4115 * introduce a bit of extra uncertainty.
4117 * A few servers can't deal with SSH1_MSG_IGNORE, at
4118 * least in this context. For these servers, we need
4119 * an alternative defence. We make use of the fact
4120 * that the password is interpreted as a C string:
4121 * so we can append a NUL, then some random data.
4123 * A few servers can deal with neither SSH1_MSG_IGNORE
4124 * here _nor_ a padded password string.
4125 * For these servers we are left with no defences
4126 * against password length sniffing.
4128 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
) &&
4129 !(ssh
->remote_bugs
& BUG_NEEDS_SSH1_PLAIN_PASSWORD
)) {
4131 * The server can deal with SSH1_MSG_IGNORE, so
4132 * we can use the primary defence.
4134 int bottom
, top
, pwlen
, i
;
4137 pwlen
= strlen(s
->cur_prompt
->prompts
[0]->result
);
4139 bottom
= 0; /* zero length passwords are OK! :-) */
4142 bottom
= pwlen
& ~7;
4146 assert(pwlen
>= bottom
&& pwlen
<= top
);
4148 randomstr
= snewn(top
+ 1, char);
4150 for (i
= bottom
; i
<= top
; i
++) {
4152 defer_packet(ssh
, s
->pwpkt_type
,
4153 PKTT_PASSWORD
, PKT_STR
,
4154 s
->cur_prompt
->prompts
[0]->result
,
4155 PKTT_OTHER
, PKT_END
);
4157 for (j
= 0; j
< i
; j
++) {
4159 randomstr
[j
] = random_byte();
4160 } while (randomstr
[j
] == '\0');
4162 randomstr
[i
] = '\0';
4163 defer_packet(ssh
, SSH1_MSG_IGNORE
,
4164 PKT_STR
, randomstr
, PKT_END
);
4167 logevent("Sending password with camouflage packets");
4168 ssh_pkt_defersend(ssh
);
4171 else if (!(ssh
->remote_bugs
& BUG_NEEDS_SSH1_PLAIN_PASSWORD
)) {
4173 * The server can't deal with SSH1_MSG_IGNORE
4174 * but can deal with padded passwords, so we
4175 * can use the secondary defence.
4181 len
= strlen(s
->cur_prompt
->prompts
[0]->result
);
4182 if (len
< sizeof(string
)) {
4184 strcpy(string
, s
->cur_prompt
->prompts
[0]->result
);
4185 len
++; /* cover the zero byte */
4186 while (len
< sizeof(string
)) {
4187 string
[len
++] = (char) random_byte();
4190 ss
= s
->cur_prompt
->prompts
[0]->result
;
4192 logevent("Sending length-padded password");
4193 send_packet(ssh
, s
->pwpkt_type
, PKTT_PASSWORD
,
4194 PKT_INT
, len
, PKT_DATA
, ss
, len
,
4195 PKTT_OTHER
, PKT_END
);
4198 * The server is believed unable to cope with
4199 * any of our password camouflage methods.
4202 len
= strlen(s
->cur_prompt
->prompts
[0]->result
);
4203 logevent("Sending unpadded password");
4204 send_packet(ssh
, s
->pwpkt_type
,
4205 PKTT_PASSWORD
, PKT_INT
, len
,
4206 PKT_DATA
, s
->cur_prompt
->prompts
[0]->result
, len
,
4207 PKTT_OTHER
, PKT_END
);
4210 send_packet(ssh
, s
->pwpkt_type
, PKTT_PASSWORD
,
4211 PKT_STR
, s
->cur_prompt
->prompts
[0]->result
,
4212 PKTT_OTHER
, PKT_END
);
4214 logevent("Sent password");
4215 free_prompts(s
->cur_prompt
);
4217 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
4218 if (flags
& FLAG_VERBOSE
)
4219 c_write_str(ssh
, "Access denied\r\n");
4220 logevent("Authentication refused");
4221 } else if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
4222 bombout(("Strange packet received, type %d", pktin
->type
));
4228 if (s
->publickey_blob
) {
4229 sfree(s
->publickey_blob
);
4230 sfree(s
->publickey_comment
);
4233 logevent("Authentication successful");
4238 static void ssh_channel_try_eof(struct ssh_channel
*c
)
4241 assert(c
->pending_eof
); /* precondition for calling us */
4243 return; /* can't close: not even opened yet */
4244 if (ssh
->version
== 2 && bufchain_size(&c
->v
.v2
.outbuffer
) > 0)
4245 return; /* can't send EOF: pending outgoing data */
4247 if (ssh
->version
== 1) {
4248 send_packet(ssh
, SSH1_MSG_CHANNEL_CLOSE
, PKT_INT
, c
->remoteid
,
4250 c
->closes
|= CLOSES_SENT_EOF
;
4252 struct Packet
*pktout
;
4253 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF
);
4254 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
4255 ssh2_pkt_send(ssh
, pktout
);
4256 c
->closes
|= CLOSES_SENT_EOF
;
4257 if (!((CLOSES_SENT_EOF
| CLOSES_RCVD_EOF
) & ~c
->closes
)) {
4259 * Also send MSG_CLOSE.
4261 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
4262 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
4263 ssh2_pkt_send(ssh
, pktout
);
4264 c
->closes
|= CLOSES_SENT_CLOSE
;
4267 c
->pending_eof
= FALSE
; /* we've sent it now */
4270 void sshfwd_write_eof(struct ssh_channel
*c
)
4274 if (ssh
->state
== SSH_STATE_CLOSED
)
4277 if (c
->closes
& CLOSES_SENT_EOF
)
4280 c
->pending_eof
= TRUE
;
4281 ssh_channel_try_eof(c
);
4284 void sshfwd_unclean_close(struct ssh_channel
*c
)
4287 struct Packet
*pktout
;
4289 if (ssh
->state
== SSH_STATE_CLOSED
)
4292 if (!(c
->closes
& CLOSES_SENT_CLOSE
)) {
4293 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
4294 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
4295 ssh2_pkt_send(ssh
, pktout
);
4296 c
->closes
|= CLOSES_SENT_EOF
| CLOSES_SENT_CLOSE
;
4301 x11_close(c
->u
.x11
.s
);
4304 case CHAN_SOCKDATA_DORMANT
:
4305 pfd_close(c
->u
.pfd
.s
);
4308 c
->type
= CHAN_ZOMBIE
;
4310 ssh2_channel_check_close(c
);
4313 int sshfwd_write(struct ssh_channel
*c
, char *buf
, int len
)
4317 if (ssh
->state
== SSH_STATE_CLOSED
)
4320 if (ssh
->version
== 1) {
4321 send_packet(ssh
, SSH1_MSG_CHANNEL_DATA
,
4322 PKT_INT
, c
->remoteid
,
4323 PKT_INT
, len
, PKTT_DATA
, PKT_DATA
, buf
, len
,
4324 PKTT_OTHER
, PKT_END
);
4326 * In SSH-1 we can return 0 here - implying that forwarded
4327 * connections are never individually throttled - because
4328 * the only circumstance that can cause throttling will be
4329 * the whole SSH connection backing up, in which case
4330 * _everything_ will be throttled as a whole.
4334 ssh2_add_channel_data(c
, buf
, len
);
4335 return ssh2_try_send(c
);
4339 void sshfwd_unthrottle(struct ssh_channel
*c
, int bufsize
)
4344 if (ssh
->state
== SSH_STATE_CLOSED
)
4347 if (ssh
->version
== 1) {
4348 buflimit
= SSH1_BUFFER_LIMIT
;
4350 buflimit
= c
->v
.v2
.locmaxwin
;
4351 ssh2_set_window(c
, bufsize
< buflimit ? buflimit
- bufsize
: 0);
4353 if (c
->throttling_conn
&& bufsize
<= buflimit
) {
4354 c
->throttling_conn
= 0;
4355 ssh_throttle_conn(ssh
, -1);
4359 static void ssh_queueing_handler(Ssh ssh
, struct Packet
*pktin
)
4361 struct queued_handler
*qh
= ssh
->qhead
;
4365 assert(pktin
->type
== qh
->msg1
|| pktin
->type
== qh
->msg2
);
4368 assert(ssh
->packet_dispatch
[qh
->msg1
] == ssh_queueing_handler
);
4369 ssh
->packet_dispatch
[qh
->msg1
] = ssh
->q_saved_handler1
;
4372 assert(ssh
->packet_dispatch
[qh
->msg2
] == ssh_queueing_handler
);
4373 ssh
->packet_dispatch
[qh
->msg2
] = ssh
->q_saved_handler2
;
4377 ssh
->qhead
= qh
->next
;
4379 if (ssh
->qhead
->msg1
> 0) {
4380 ssh
->q_saved_handler1
= ssh
->packet_dispatch
[ssh
->qhead
->msg1
];
4381 ssh
->packet_dispatch
[ssh
->qhead
->msg1
] = ssh_queueing_handler
;
4383 if (ssh
->qhead
->msg2
> 0) {
4384 ssh
->q_saved_handler2
= ssh
->packet_dispatch
[ssh
->qhead
->msg2
];
4385 ssh
->packet_dispatch
[ssh
->qhead
->msg2
] = ssh_queueing_handler
;
4388 ssh
->qhead
= ssh
->qtail
= NULL
;
4391 qh
->handler(ssh
, pktin
, qh
->ctx
);
4396 static void ssh_queue_handler(Ssh ssh
, int msg1
, int msg2
,
4397 chandler_fn_t handler
, void *ctx
)
4399 struct queued_handler
*qh
;
4401 qh
= snew(struct queued_handler
);
4404 qh
->handler
= handler
;
4408 if (ssh
->qtail
== NULL
) {
4412 ssh
->q_saved_handler1
= ssh
->packet_dispatch
[ssh
->qhead
->msg1
];
4413 ssh
->packet_dispatch
[qh
->msg1
] = ssh_queueing_handler
;
4416 ssh
->q_saved_handler2
= ssh
->packet_dispatch
[ssh
->qhead
->msg2
];
4417 ssh
->packet_dispatch
[qh
->msg2
] = ssh_queueing_handler
;
4420 ssh
->qtail
->next
= qh
;
4425 static void ssh_rportfwd_succfail(Ssh ssh
, struct Packet
*pktin
, void *ctx
)
4427 struct ssh_rportfwd
*rpf
, *pf
= (struct ssh_rportfwd
*)ctx
;
4429 if (pktin
->type
== (ssh
->version
== 1 ? SSH1_SMSG_SUCCESS
:
4430 SSH2_MSG_REQUEST_SUCCESS
)) {
4431 logeventf(ssh
, "Remote port forwarding from %s enabled",
4434 logeventf(ssh
, "Remote port forwarding from %s refused",
4437 rpf
= del234(ssh
->rportfwds
, pf
);
4439 pf
->pfrec
->remote
= NULL
;
4444 static void ssh_setup_portfwd(Ssh ssh
, Conf
*conf
)
4446 struct ssh_portfwd
*epf
;
4450 if (!ssh
->portfwds
) {
4451 ssh
->portfwds
= newtree234(ssh_portcmp
);
4454 * Go through the existing port forwardings and tag them
4455 * with status==DESTROY. Any that we want to keep will be
4456 * re-enabled (status==KEEP) as we go through the
4457 * configuration and find out which bits are the same as
4460 struct ssh_portfwd
*epf
;
4462 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4463 epf
->status
= DESTROY
;
4466 for (val
= conf_get_str_strs(conf
, CONF_portfwd
, NULL
, &key
);
4468 val
= conf_get_str_strs(conf
, CONF_portfwd
, key
, &key
)) {
4469 char *kp
, *kp2
, *vp
, *vp2
;
4470 char address_family
, type
;
4471 int sport
,dport
,sserv
,dserv
;
4472 char *sports
, *dports
, *saddr
, *host
;
4476 address_family
= 'A';
4478 if (*kp
== 'A' || *kp
== '4' || *kp
== '6')
4479 address_family
= *kp
++;
4480 if (*kp
== 'L' || *kp
== 'R')
4483 if ((kp2
= strchr(kp
, ':')) != NULL
) {
4485 * There's a colon in the middle of the source port
4486 * string, which means that the part before it is
4487 * actually a source address.
4489 saddr
= dupprintf("%.*s", (int)(kp2
- kp
), kp
);
4495 sport
= atoi(sports
);
4499 sport
= net_service_lookup(sports
);
4501 logeventf(ssh
, "Service lookup failed for source"
4502 " port \"%s\"", sports
);
4506 if (type
== 'L' && !strcmp(val
, "D")) {
4507 /* dynamic forwarding */
4514 /* ordinary forwarding */
4516 vp2
= vp
+ strcspn(vp
, ":");
4517 host
= dupprintf("%.*s", (int)(vp2
- vp
), vp
);
4521 dport
= atoi(dports
);
4525 dport
= net_service_lookup(dports
);
4527 logeventf(ssh
, "Service lookup failed for destination"
4528 " port \"%s\"", dports
);
4533 if (sport
&& dport
) {
4534 /* Set up a description of the source port. */
4535 struct ssh_portfwd
*pfrec
, *epfrec
;
4537 pfrec
= snew(struct ssh_portfwd
);
4539 pfrec
->saddr
= saddr
;
4540 pfrec
->sserv
= sserv ?
dupstr(sports
) : NULL
;
4541 pfrec
->sport
= sport
;
4542 pfrec
->daddr
= host
;
4543 pfrec
->dserv
= dserv ?
dupstr(dports
) : NULL
;
4544 pfrec
->dport
= dport
;
4545 pfrec
->local
= NULL
;
4546 pfrec
->remote
= NULL
;
4547 pfrec
->addressfamily
= (address_family
== '4' ? ADDRTYPE_IPV4
:
4548 address_family
== '6' ? ADDRTYPE_IPV6
:
4551 epfrec
= add234(ssh
->portfwds
, pfrec
);
4552 if (epfrec
!= pfrec
) {
4553 if (epfrec
->status
== DESTROY
) {
4555 * We already have a port forwarding up and running
4556 * with precisely these parameters. Hence, no need
4557 * to do anything; simply re-tag the existing one
4560 epfrec
->status
= KEEP
;
4563 * Anything else indicates that there was a duplicate
4564 * in our input, which we'll silently ignore.
4566 free_portfwd(pfrec
);
4568 pfrec
->status
= CREATE
;
4577 * Now go through and destroy any port forwardings which were
4580 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4581 if (epf
->status
== DESTROY
) {
4584 message
= dupprintf("%s port forwarding from %s%s%d",
4585 epf
->type
== 'L' ?
"local" :
4586 epf
->type
== 'R' ?
"remote" : "dynamic",
4587 epf
->saddr ? epf
->saddr
: "",
4588 epf
->saddr ?
":" : "",
4591 if (epf
->type
!= 'D') {
4592 char *msg2
= dupprintf("%s to %s:%d", message
,
4593 epf
->daddr
, epf
->dport
);
4598 logeventf(ssh
, "Cancelling %s", message
);
4601 /* epf->remote or epf->local may be NULL if setting up a
4602 * forwarding failed. */
4604 struct ssh_rportfwd
*rpf
= epf
->remote
;
4605 struct Packet
*pktout
;
4608 * Cancel the port forwarding at the server
4611 if (ssh
->version
== 1) {
4613 * We cannot cancel listening ports on the
4614 * server side in SSH-1! There's no message
4615 * to support it. Instead, we simply remove
4616 * the rportfwd record from the local end
4617 * so that any connections the server tries
4618 * to make on it are rejected.
4621 pktout
= ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST
);
4622 ssh2_pkt_addstring(pktout
, "cancel-tcpip-forward");
4623 ssh2_pkt_addbool(pktout
, 0);/* _don't_ want reply */
4625 ssh2_pkt_addstring(pktout
, epf
->saddr
);
4626 } else if (conf_get_int(conf
, CONF_rport_acceptall
)) {
4627 /* XXX: rport_acceptall may not represent
4628 * what was used to open the original connection,
4629 * since it's reconfigurable. */
4630 ssh2_pkt_addstring(pktout
, "0.0.0.0");
4632 ssh2_pkt_addstring(pktout
, "127.0.0.1");
4634 ssh2_pkt_adduint32(pktout
, epf
->sport
);
4635 ssh2_pkt_send(ssh
, pktout
);
4638 del234(ssh
->rportfwds
, rpf
);
4640 } else if (epf
->local
) {
4641 pfd_terminate(epf
->local
);
4644 delpos234(ssh
->portfwds
, i
);
4646 i
--; /* so we don't skip one in the list */
4650 * And finally, set up any new port forwardings (status==CREATE).
4652 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4653 if (epf
->status
== CREATE
) {
4654 char *sportdesc
, *dportdesc
;
4655 sportdesc
= dupprintf("%s%s%s%s%d%s",
4656 epf
->saddr ? epf
->saddr
: "",
4657 epf
->saddr ?
":" : "",
4658 epf
->sserv ? epf
->sserv
: "",
4659 epf
->sserv ?
"(" : "",
4661 epf
->sserv ?
")" : "");
4662 if (epf
->type
== 'D') {
4665 dportdesc
= dupprintf("%s:%s%s%d%s",
4667 epf
->dserv ? epf
->dserv
: "",
4668 epf
->dserv ?
"(" : "",
4670 epf
->dserv ?
")" : "");
4673 if (epf
->type
== 'L') {
4674 const char *err
= pfd_addforward(epf
->daddr
, epf
->dport
,
4675 epf
->saddr
, epf
->sport
,
4678 epf
->addressfamily
);
4680 logeventf(ssh
, "Local %sport %s forwarding to %s%s%s",
4681 epf
->addressfamily
== ADDRTYPE_IPV4 ?
"IPv4 " :
4682 epf
->addressfamily
== ADDRTYPE_IPV6 ?
"IPv6 " : "",
4683 sportdesc
, dportdesc
,
4684 err ?
" failed: " : "", err ? err
: "");
4685 } else if (epf
->type
== 'D') {
4686 const char *err
= pfd_addforward(NULL
, -1,
4687 epf
->saddr
, epf
->sport
,
4690 epf
->addressfamily
);
4692 logeventf(ssh
, "Local %sport %s SOCKS dynamic forwarding%s%s",
4693 epf
->addressfamily
== ADDRTYPE_IPV4 ?
"IPv4 " :
4694 epf
->addressfamily
== ADDRTYPE_IPV6 ?
"IPv6 " : "",
4696 err ?
" failed: " : "", err ? err
: "");
4698 struct ssh_rportfwd
*pf
;
4701 * Ensure the remote port forwardings tree exists.
4703 if (!ssh
->rportfwds
) {
4704 if (ssh
->version
== 1)
4705 ssh
->rportfwds
= newtree234(ssh_rportcmp_ssh1
);
4707 ssh
->rportfwds
= newtree234(ssh_rportcmp_ssh2
);
4710 pf
= snew(struct ssh_rportfwd
);
4711 strncpy(pf
->dhost
, epf
->daddr
, lenof(pf
->dhost
)-1);
4712 pf
->dhost
[lenof(pf
->dhost
)-1] = '\0';
4713 pf
->dport
= epf
->dport
;
4714 pf
->sport
= epf
->sport
;
4715 if (add234(ssh
->rportfwds
, pf
) != pf
) {
4716 logeventf(ssh
, "Duplicate remote port forwarding to %s:%d",
4717 epf
->daddr
, epf
->dport
);
4720 logeventf(ssh
, "Requesting remote port %s"
4721 " forward to %s", sportdesc
, dportdesc
);
4723 pf
->sportdesc
= sportdesc
;
4728 if (ssh
->version
== 1) {
4729 send_packet(ssh
, SSH1_CMSG_PORT_FORWARD_REQUEST
,
4730 PKT_INT
, epf
->sport
,
4731 PKT_STR
, epf
->daddr
,
4732 PKT_INT
, epf
->dport
,
4734 ssh_queue_handler(ssh
, SSH1_SMSG_SUCCESS
,
4736 ssh_rportfwd_succfail
, pf
);
4738 struct Packet
*pktout
;
4739 pktout
= ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST
);
4740 ssh2_pkt_addstring(pktout
, "tcpip-forward");
4741 ssh2_pkt_addbool(pktout
, 1);/* want reply */
4743 ssh2_pkt_addstring(pktout
, epf
->saddr
);
4744 } else if (conf_get_int(conf
, CONF_rport_acceptall
)) {
4745 ssh2_pkt_addstring(pktout
, "0.0.0.0");
4747 ssh2_pkt_addstring(pktout
, "127.0.0.1");
4749 ssh2_pkt_adduint32(pktout
, epf
->sport
);
4750 ssh2_pkt_send(ssh
, pktout
);
4752 ssh_queue_handler(ssh
, SSH2_MSG_REQUEST_SUCCESS
,
4753 SSH2_MSG_REQUEST_FAILURE
,
4754 ssh_rportfwd_succfail
, pf
);
4763 static void ssh1_smsg_stdout_stderr_data(Ssh ssh
, struct Packet
*pktin
)
4766 int stringlen
, bufsize
;
4768 ssh_pkt_getstring(pktin
, &string
, &stringlen
);
4769 if (string
== NULL
) {
4770 bombout(("Incoming terminal data packet was badly formed"));
4774 bufsize
= from_backend(ssh
->frontend
, pktin
->type
== SSH1_SMSG_STDERR_DATA
,
4776 if (!ssh
->v1_stdout_throttling
&& bufsize
> SSH1_BUFFER_LIMIT
) {
4777 ssh
->v1_stdout_throttling
= 1;
4778 ssh_throttle_conn(ssh
, +1);
4782 static void ssh1_smsg_x11_open(Ssh ssh
, struct Packet
*pktin
)
4784 /* Remote side is trying to open a channel to talk to our
4785 * X-Server. Give them back a local channel number. */
4786 struct ssh_channel
*c
;
4787 int remoteid
= ssh_pkt_getuint32(pktin
);
4789 logevent("Received X11 connect request");
4790 /* Refuse if X11 forwarding is disabled. */
4791 if (!ssh
->X11_fwd_enabled
) {
4792 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4793 PKT_INT
, remoteid
, PKT_END
);
4794 logevent("Rejected X11 connect request");
4796 c
= snew(struct ssh_channel
);
4799 if (x11_init(&c
->u
.x11
.s
, ssh
->x11disp
, c
,
4800 NULL
, -1, ssh
->conf
) != NULL
) {
4801 logevent("Opening X11 forward connection failed");
4803 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4804 PKT_INT
, remoteid
, PKT_END
);
4807 ("Opening X11 forward connection succeeded");
4808 c
->remoteid
= remoteid
;
4809 c
->halfopen
= FALSE
;
4810 c
->localid
= alloc_channel_id(ssh
);
4812 c
->pending_eof
= FALSE
;
4813 c
->throttling_conn
= 0;
4814 c
->type
= CHAN_X11
; /* identify channel type */
4815 add234(ssh
->channels
, c
);
4816 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4817 PKT_INT
, c
->remoteid
, PKT_INT
,
4818 c
->localid
, PKT_END
);
4819 logevent("Opened X11 forward channel");
4824 static void ssh1_smsg_agent_open(Ssh ssh
, struct Packet
*pktin
)
4826 /* Remote side is trying to open a channel to talk to our
4827 * agent. Give them back a local channel number. */
4828 struct ssh_channel
*c
;
4829 int remoteid
= ssh_pkt_getuint32(pktin
);
4831 /* Refuse if agent forwarding is disabled. */
4832 if (!ssh
->agentfwd_enabled
) {
4833 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4834 PKT_INT
, remoteid
, PKT_END
);
4836 c
= snew(struct ssh_channel
);
4838 c
->remoteid
= remoteid
;
4839 c
->halfopen
= FALSE
;
4840 c
->localid
= alloc_channel_id(ssh
);
4842 c
->pending_eof
= FALSE
;
4843 c
->throttling_conn
= 0;
4844 c
->type
= CHAN_AGENT
; /* identify channel type */
4845 c
->u
.a
.lensofar
= 0;
4846 c
->u
.a
.message
= NULL
;
4847 add234(ssh
->channels
, c
);
4848 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4849 PKT_INT
, c
->remoteid
, PKT_INT
, c
->localid
,
4854 static void ssh1_msg_port_open(Ssh ssh
, struct Packet
*pktin
)
4856 /* Remote side is trying to open a channel to talk to a
4857 * forwarded port. Give them back a local channel number. */
4858 struct ssh_channel
*c
;
4859 struct ssh_rportfwd pf
, *pfp
;
4864 c
= snew(struct ssh_channel
);
4867 remoteid
= ssh_pkt_getuint32(pktin
);
4868 ssh_pkt_getstring(pktin
, &host
, &hostsize
);
4869 port
= ssh_pkt_getuint32(pktin
);
4871 if (hostsize
>= lenof(pf
.dhost
))
4872 hostsize
= lenof(pf
.dhost
)-1;
4873 memcpy(pf
.dhost
, host
, hostsize
);
4874 pf
.dhost
[hostsize
] = '\0';
4876 pfp
= find234(ssh
->rportfwds
, &pf
, NULL
);
4879 logeventf(ssh
, "Rejected remote port open request for %s:%d",
4881 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4882 PKT_INT
, remoteid
, PKT_END
);
4884 logeventf(ssh
, "Received remote port open request for %s:%d",
4886 e
= pfd_newconnect(&c
->u
.pfd
.s
, pf
.dhost
, port
,
4887 c
, ssh
->conf
, pfp
->pfrec
->addressfamily
);
4889 logeventf(ssh
, "Port open failed: %s", e
);
4891 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4892 PKT_INT
, remoteid
, PKT_END
);
4894 c
->remoteid
= remoteid
;
4895 c
->halfopen
= FALSE
;
4896 c
->localid
= alloc_channel_id(ssh
);
4898 c
->pending_eof
= FALSE
;
4899 c
->throttling_conn
= 0;
4900 c
->type
= CHAN_SOCKDATA
; /* identify channel type */
4901 add234(ssh
->channels
, c
);
4902 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4903 PKT_INT
, c
->remoteid
, PKT_INT
,
4904 c
->localid
, PKT_END
);
4905 logevent("Forwarded port opened successfully");
4910 static void ssh1_msg_channel_open_confirmation(Ssh ssh
, struct Packet
*pktin
)
4912 unsigned int remoteid
= ssh_pkt_getuint32(pktin
);
4913 unsigned int localid
= ssh_pkt_getuint32(pktin
);
4914 struct ssh_channel
*c
;
4916 c
= find234(ssh
->channels
, &remoteid
, ssh_channelfind
);
4917 if (c
&& c
->type
== CHAN_SOCKDATA_DORMANT
) {
4918 c
->remoteid
= localid
;
4919 c
->halfopen
= FALSE
;
4920 c
->type
= CHAN_SOCKDATA
;
4921 c
->throttling_conn
= 0;
4922 pfd_confirm(c
->u
.pfd
.s
);
4925 if (c
&& c
->pending_eof
) {
4927 * We have a pending close on this channel,
4928 * which we decided on before the server acked
4929 * the channel open. So now we know the
4930 * remoteid, we can close it again.
4932 ssh_channel_try_eof(c
);
4936 static void ssh1_msg_channel_open_failure(Ssh ssh
, struct Packet
*pktin
)
4938 unsigned int remoteid
= ssh_pkt_getuint32(pktin
);
4939 struct ssh_channel
*c
;
4941 c
= find234(ssh
->channels
, &remoteid
, ssh_channelfind
);
4942 if (c
&& c
->type
== CHAN_SOCKDATA_DORMANT
) {
4943 logevent("Forwarded connection refused by server");
4944 pfd_close(c
->u
.pfd
.s
);
4945 del234(ssh
->channels
, c
);
4950 static void ssh1_msg_channel_close(Ssh ssh
, struct Packet
*pktin
)
4952 /* Remote side closes a channel. */
4953 unsigned i
= ssh_pkt_getuint32(pktin
);
4954 struct ssh_channel
*c
;
4955 c
= find234(ssh
->channels
, &i
, ssh_channelfind
);
4956 if (c
&& !c
->halfopen
) {
4958 if (pktin
->type
== SSH1_MSG_CHANNEL_CLOSE
&&
4959 !(c
->closes
& CLOSES_RCVD_EOF
)) {
4961 * Received CHANNEL_CLOSE, which we translate into
4964 int send_close
= FALSE
;
4966 c
->closes
|= CLOSES_RCVD_EOF
;
4971 x11_send_eof(c
->u
.x11
.s
);
4977 pfd_send_eof(c
->u
.pfd
.s
);
4986 if (send_close
&& !(c
->closes
& CLOSES_SENT_EOF
)) {
4987 send_packet(ssh
, SSH1_MSG_CHANNEL_CLOSE
, PKT_INT
, c
->remoteid
,
4989 c
->closes
|= CLOSES_SENT_EOF
;
4993 if (pktin
->type
== SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
&&
4994 !(c
->closes
& CLOSES_RCVD_CLOSE
)) {
4996 if (!(c
->closes
& CLOSES_SENT_EOF
)) {
4997 bombout(("Received CHANNEL_CLOSE_CONFIRMATION for channel %d"
4998 " for which we never sent CHANNEL_CLOSE\n", i
));
5001 c
->closes
|= CLOSES_RCVD_CLOSE
;
5004 if (!((CLOSES_SENT_EOF
| CLOSES_RCVD_EOF
) & ~c
->closes
) &&
5005 !(c
->closes
& CLOSES_SENT_CLOSE
)) {
5006 send_packet(ssh
, SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
,
5007 PKT_INT
, c
->remoteid
, PKT_END
);
5008 c
->closes
|= CLOSES_SENT_CLOSE
;
5011 if (!((CLOSES_SENT_CLOSE
| CLOSES_RCVD_CLOSE
) & ~c
->closes
))
5012 ssh_channel_destroy(c
);
5014 bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
5015 pktin
->type
== SSH1_MSG_CHANNEL_CLOSE ?
"" :
5016 "_CONFIRMATION", c ?
"half-open" : "nonexistent",
5021 static void ssh1_msg_channel_data(Ssh ssh
, struct Packet
*pktin
)
5023 /* Data sent down one of our channels. */
5024 int i
= ssh_pkt_getuint32(pktin
);
5027 struct ssh_channel
*c
;
5029 ssh_pkt_getstring(pktin
, &p
, &len
);
5031 c
= find234(ssh
->channels
, &i
, ssh_channelfind
);
5036 bufsize
= x11_send(c
->u
.x11
.s
, p
, len
);
5039 bufsize
= pfd_send(c
->u
.pfd
.s
, p
, len
);
5042 /* Data for an agent message. Buffer it. */
5044 if (c
->u
.a
.lensofar
< 4) {
5045 unsigned int l
= min(4 - c
->u
.a
.lensofar
, (unsigned)len
);
5046 memcpy(c
->u
.a
.msglen
+ c
->u
.a
.lensofar
, p
,
5050 c
->u
.a
.lensofar
+= l
;
5052 if (c
->u
.a
.lensofar
== 4) {
5054 4 + GET_32BIT(c
->u
.a
.msglen
);
5055 c
->u
.a
.message
= snewn(c
->u
.a
.totallen
,
5057 memcpy(c
->u
.a
.message
, c
->u
.a
.msglen
, 4);
5059 if (c
->u
.a
.lensofar
>= 4 && len
> 0) {
5061 min(c
->u
.a
.totallen
- c
->u
.a
.lensofar
,
5063 memcpy(c
->u
.a
.message
+ c
->u
.a
.lensofar
, p
,
5067 c
->u
.a
.lensofar
+= l
;
5069 if (c
->u
.a
.lensofar
== c
->u
.a
.totallen
) {
5072 if (agent_query(c
->u
.a
.message
,
5075 ssh_agentf_callback
, c
))
5076 ssh_agentf_callback(c
, reply
, replylen
);
5077 sfree(c
->u
.a
.message
);
5078 c
->u
.a
.lensofar
= 0;
5081 bufsize
= 0; /* agent channels never back up */
5084 if (!c
->throttling_conn
&& bufsize
> SSH1_BUFFER_LIMIT
) {
5085 c
->throttling_conn
= 1;
5086 ssh_throttle_conn(ssh
, +1);
5091 static void ssh1_smsg_exit_status(Ssh ssh
, struct Packet
*pktin
)
5093 ssh
->exitcode
= ssh_pkt_getuint32(pktin
);
5094 logeventf(ssh
, "Server sent command exit status %d", ssh
->exitcode
);
5095 send_packet(ssh
, SSH1_CMSG_EXIT_CONFIRMATION
, PKT_END
);
5097 * In case `helpful' firewalls or proxies tack
5098 * extra human-readable text on the end of the
5099 * session which we might mistake for another
5100 * encrypted packet, we close the session once
5101 * we've sent EXIT_CONFIRMATION.
5103 ssh_disconnect(ssh
, NULL
, NULL
, 0, TRUE
);
5106 /* Helper function to deal with sending tty modes for REQUEST_PTY */
5107 static void ssh1_send_ttymode(void *data
, char *mode
, char *val
)
5109 struct Packet
*pktout
= (struct Packet
*)data
;
5111 unsigned int arg
= 0;
5112 while (strcmp(mode
, ssh_ttymodes
[i
].mode
) != 0) i
++;
5113 if (i
== lenof(ssh_ttymodes
)) return;
5114 switch (ssh_ttymodes
[i
].type
) {
5116 arg
= ssh_tty_parse_specchar(val
);
5119 arg
= ssh_tty_parse_boolean(val
);
5122 ssh2_pkt_addbyte(pktout
, ssh_ttymodes
[i
].opcode
);
5123 ssh2_pkt_addbyte(pktout
, arg
);
5127 static void do_ssh1_connection(Ssh ssh
, unsigned char *in
, int inlen
,
5128 struct Packet
*pktin
)
5130 crBegin(ssh
->do_ssh1_connection_crstate
);
5132 ssh
->packet_dispatch
[SSH1_SMSG_STDOUT_DATA
] =
5133 ssh
->packet_dispatch
[SSH1_SMSG_STDERR_DATA
] =
5134 ssh1_smsg_stdout_stderr_data
;
5136 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
] =
5137 ssh1_msg_channel_open_confirmation
;
5138 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_OPEN_FAILURE
] =
5139 ssh1_msg_channel_open_failure
;
5140 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_CLOSE
] =
5141 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
] =
5142 ssh1_msg_channel_close
;
5143 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_DATA
] = ssh1_msg_channel_data
;
5144 ssh
->packet_dispatch
[SSH1_SMSG_EXIT_STATUS
] = ssh1_smsg_exit_status
;
5146 if (conf_get_int(ssh
->conf
, CONF_agentfwd
) && agent_exists()) {
5147 logevent("Requesting agent forwarding");
5148 send_packet(ssh
, SSH1_CMSG_AGENT_REQUEST_FORWARDING
, PKT_END
);
5152 if (pktin
->type
!= SSH1_SMSG_SUCCESS
5153 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
5154 bombout(("Protocol confusion"));
5156 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5157 logevent("Agent forwarding refused");
5159 logevent("Agent forwarding enabled");
5160 ssh
->agentfwd_enabled
= TRUE
;
5161 ssh
->packet_dispatch
[SSH1_SMSG_AGENT_OPEN
] = ssh1_smsg_agent_open
;
5165 if (conf_get_int(ssh
->conf
, CONF_x11_forward
) &&
5166 (ssh
->x11disp
= x11_setup_display(conf_get_str(ssh
->conf
, CONF_x11_display
),
5167 conf_get_int(ssh
->conf
, CONF_x11_auth
), ssh
->conf
))) {
5168 logevent("Requesting X11 forwarding");
5170 * Note that while we blank the X authentication data here, we don't
5171 * take any special action to blank the start of an X11 channel,
5172 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
5173 * without having session blanking enabled is likely to leak your
5174 * cookie into the log.
5176 if (ssh
->v1_local_protoflags
& SSH1_PROTOFLAG_SCREEN_NUMBER
) {
5177 send_packet(ssh
, SSH1_CMSG_X11_REQUEST_FORWARDING
,
5178 PKT_STR
, ssh
->x11disp
->remoteauthprotoname
,
5180 PKT_STR
, ssh
->x11disp
->remoteauthdatastring
,
5182 PKT_INT
, ssh
->x11disp
->screennum
,
5185 send_packet(ssh
, SSH1_CMSG_X11_REQUEST_FORWARDING
,
5186 PKT_STR
, ssh
->x11disp
->remoteauthprotoname
,
5188 PKT_STR
, ssh
->x11disp
->remoteauthdatastring
,
5195 if (pktin
->type
!= SSH1_SMSG_SUCCESS
5196 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
5197 bombout(("Protocol confusion"));
5199 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5200 logevent("X11 forwarding refused");
5202 logevent("X11 forwarding enabled");
5203 ssh
->X11_fwd_enabled
= TRUE
;
5204 ssh
->packet_dispatch
[SSH1_SMSG_X11_OPEN
] = ssh1_smsg_x11_open
;
5208 ssh_setup_portfwd(ssh
, ssh
->conf
);
5209 ssh
->packet_dispatch
[SSH1_MSG_PORT_OPEN
] = ssh1_msg_port_open
;
5211 if (!conf_get_int(ssh
->conf
, CONF_nopty
)) {
5213 /* Unpick the terminal-speed string. */
5214 /* XXX perhaps we should allow no speeds to be sent. */
5215 ssh
->ospeed
= 38400; ssh
->ispeed
= 38400; /* last-resort defaults */
5216 sscanf(conf_get_str(ssh
->conf
, CONF_termspeed
), "%d,%d", &ssh
->ospeed
, &ssh
->ispeed
);
5217 /* Send the pty request. */
5218 pkt
= ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY
);
5219 ssh_pkt_addstring(pkt
, conf_get_str(ssh
->conf
, CONF_termtype
));
5220 ssh_pkt_adduint32(pkt
, ssh
->term_height
);
5221 ssh_pkt_adduint32(pkt
, ssh
->term_width
);
5222 ssh_pkt_adduint32(pkt
, 0); /* width in pixels */
5223 ssh_pkt_adduint32(pkt
, 0); /* height in pixels */
5224 parse_ttymodes(ssh
, ssh1_send_ttymode
, (void *)pkt
);
5225 ssh_pkt_addbyte(pkt
, SSH1_TTY_OP_ISPEED
);
5226 ssh_pkt_adduint32(pkt
, ssh
->ispeed
);
5227 ssh_pkt_addbyte(pkt
, SSH1_TTY_OP_OSPEED
);
5228 ssh_pkt_adduint32(pkt
, ssh
->ospeed
);
5229 ssh_pkt_addbyte(pkt
, SSH_TTY_OP_END
);
5231 ssh
->state
= SSH_STATE_INTERMED
;
5235 if (pktin
->type
!= SSH1_SMSG_SUCCESS
5236 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
5237 bombout(("Protocol confusion"));
5239 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5240 c_write_str(ssh
, "Server refused to allocate pty\r\n");
5241 ssh
->editing
= ssh
->echoing
= 1;
5243 logeventf(ssh
, "Allocated pty (ospeed %dbps, ispeed %dbps)",
5244 ssh
->ospeed
, ssh
->ispeed
);
5245 ssh
->got_pty
= TRUE
;
5248 ssh
->editing
= ssh
->echoing
= 1;
5251 if (conf_get_int(ssh
->conf
, CONF_compression
)) {
5252 send_packet(ssh
, SSH1_CMSG_REQUEST_COMPRESSION
, PKT_INT
, 6, PKT_END
);
5256 if (pktin
->type
!= SSH1_SMSG_SUCCESS
5257 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
5258 bombout(("Protocol confusion"));
5260 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5261 c_write_str(ssh
, "Server refused to compress\r\n");
5263 logevent("Started compression");
5264 ssh
->v1_compressing
= TRUE
;
5265 ssh
->cs_comp_ctx
= zlib_compress_init();
5266 logevent("Initialised zlib (RFC1950) compression");
5267 ssh
->sc_comp_ctx
= zlib_decompress_init();
5268 logevent("Initialised zlib (RFC1950) decompression");
5272 * Start the shell or command.
5274 * Special case: if the first-choice command is an SSH-2
5275 * subsystem (hence not usable here) and the second choice
5276 * exists, we fall straight back to that.
5279 char *cmd
= conf_get_str(ssh
->conf
, CONF_remote_cmd
);
5281 if (conf_get_int(ssh
->conf
, CONF_ssh_subsys
) &&
5282 conf_get_str(ssh
->conf
, CONF_remote_cmd2
)) {
5283 cmd
= conf_get_str(ssh
->conf
, CONF_remote_cmd2
);
5284 ssh
->fallback_cmd
= TRUE
;
5287 send_packet(ssh
, SSH1_CMSG_EXEC_CMD
, PKT_STR
, cmd
, PKT_END
);
5289 send_packet(ssh
, SSH1_CMSG_EXEC_SHELL
, PKT_END
);
5290 logevent("Started session");
5293 ssh
->state
= SSH_STATE_SESSION
;
5294 if (ssh
->size_needed
)
5295 ssh_size(ssh
, ssh
->term_width
, ssh
->term_height
);
5296 if (ssh
->eof_needed
)
5297 ssh_special(ssh
, TS_EOF
);
5300 ldisc_send(ssh
->ldisc
, NULL
, 0, 0);/* cause ldisc to notice changes */
5302 ssh
->channels
= newtree234(ssh_channelcmp
);
5306 * By this point, most incoming packets are already being
5307 * handled by the dispatch table, and we need only pay
5308 * attention to the unusual ones.
5313 if (pktin
->type
== SSH1_SMSG_SUCCESS
) {
5314 /* may be from EXEC_SHELL on some servers */
5315 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5316 /* may be from EXEC_SHELL on some servers
5317 * if no pty is available or in other odd cases. Ignore */
5319 bombout(("Strange packet received: type %d", pktin
->type
));
5324 int len
= min(inlen
, 512);
5325 send_packet(ssh
, SSH1_CMSG_STDIN_DATA
,
5326 PKT_INT
, len
, PKTT_DATA
, PKT_DATA
, in
, len
,
5327 PKTT_OTHER
, PKT_END
);
5338 * Handle the top-level SSH-2 protocol.
5340 static void ssh1_msg_debug(Ssh ssh
, struct Packet
*pktin
)
5345 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
5346 logeventf(ssh
, "Remote debug message: %.*s", msglen
, msg
);
5349 static void ssh1_msg_disconnect(Ssh ssh
, struct Packet
*pktin
)
5351 /* log reason code in disconnect message */
5355 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
5356 bombout(("Server sent disconnect message:\n\"%.*s\"", msglen
, msg
));
5359 static void ssh_msg_ignore(Ssh ssh
, struct Packet
*pktin
)
5361 /* Do nothing, because we're ignoring it! Duhh. */
5364 static void ssh1_protocol_setup(Ssh ssh
)
5369 * Most messages are handled by the coroutines.
5371 for (i
= 0; i
< 256; i
++)
5372 ssh
->packet_dispatch
[i
] = NULL
;
5375 * These special message types we install handlers for.
5377 ssh
->packet_dispatch
[SSH1_MSG_DISCONNECT
] = ssh1_msg_disconnect
;
5378 ssh
->packet_dispatch
[SSH1_MSG_IGNORE
] = ssh_msg_ignore
;
5379 ssh
->packet_dispatch
[SSH1_MSG_DEBUG
] = ssh1_msg_debug
;
5382 static void ssh1_protocol(Ssh ssh
, void *vin
, int inlen
,
5383 struct Packet
*pktin
)
5385 unsigned char *in
=(unsigned char*)vin
;
5386 if (ssh
->state
== SSH_STATE_CLOSED
)
5389 if (pktin
&& ssh
->packet_dispatch
[pktin
->type
]) {
5390 ssh
->packet_dispatch
[pktin
->type
](ssh
, pktin
);
5394 if (!ssh
->protocol_initial_phase_done
) {
5395 if (do_ssh1_login(ssh
, in
, inlen
, pktin
))
5396 ssh
->protocol_initial_phase_done
= TRUE
;
5401 do_ssh1_connection(ssh
, in
, inlen
, pktin
);
5405 * Utility routine for decoding comma-separated strings in KEXINIT.
5407 static int in_commasep_string(char *needle
, char *haystack
, int haylen
)
5410 if (!needle
|| !haystack
) /* protect against null pointers */
5412 needlen
= strlen(needle
);
5415 * Is it at the start of the string?
5417 if (haylen
>= needlen
&& /* haystack is long enough */
5418 !memcmp(needle
, haystack
, needlen
) && /* initial match */
5419 (haylen
== needlen
|| haystack
[needlen
] == ',')
5420 /* either , or EOS follows */
5424 * If not, search for the next comma and resume after that.
5425 * If no comma found, terminate.
5427 while (haylen
> 0 && *haystack
!= ',')
5428 haylen
--, haystack
++;
5431 haylen
--, haystack
++; /* skip over comma itself */
5436 * Similar routine for checking whether we have the first string in a list.
5438 static int first_in_commasep_string(char *needle
, char *haystack
, int haylen
)
5441 if (!needle
|| !haystack
) /* protect against null pointers */
5443 needlen
= strlen(needle
);
5445 * Is it at the start of the string?
5447 if (haylen
>= needlen
&& /* haystack is long enough */
5448 !memcmp(needle
, haystack
, needlen
) && /* initial match */
5449 (haylen
== needlen
|| haystack
[needlen
] == ',')
5450 /* either , or EOS follows */
5458 * SSH-2 key creation method.
5459 * (Currently assumes 2 lots of any hash are sufficient to generate
5460 * keys/IVs for any cipher/MAC. SSH2_MKKEY_ITERS documents this assumption.)
5462 #define SSH2_MKKEY_ITERS (2)
5463 static void ssh2_mkkey(Ssh ssh
, Bignum K
, unsigned char *H
, char chr
,
5464 unsigned char *keyspace
)
5466 const struct ssh_hash
*h
= ssh
->kex
->hash
;
5468 /* First hlen bytes. */
5470 if (!(ssh
->remote_bugs
& BUG_SSH2_DERIVEKEY
))
5471 hash_mpint(h
, s
, K
);
5472 h
->bytes(s
, H
, h
->hlen
);
5473 h
->bytes(s
, &chr
, 1);
5474 h
->bytes(s
, ssh
->v2_session_id
, ssh
->v2_session_id_len
);
5475 h
->final(s
, keyspace
);
5476 /* Next hlen bytes. */
5478 if (!(ssh
->remote_bugs
& BUG_SSH2_DERIVEKEY
))
5479 hash_mpint(h
, s
, K
);
5480 h
->bytes(s
, H
, h
->hlen
);
5481 h
->bytes(s
, keyspace
, h
->hlen
);
5482 h
->final(s
, keyspace
+ h
->hlen
);
5486 * Handle the SSH-2 transport layer.
5488 static int do_ssh2_transport(Ssh ssh
, void *vin
, int inlen
,
5489 struct Packet
*pktin
)
5491 unsigned char *in
= (unsigned char *)vin
;
5492 struct do_ssh2_transport_state
{
5494 int nbits
, pbits
, warn_kex
, warn_cscipher
, warn_sccipher
;
5495 Bignum p
, g
, e
, f
, K
;
5498 int kex_init_value
, kex_reply_value
;
5499 const struct ssh_mac
**maclist
;
5501 const struct ssh2_cipher
*cscipher_tobe
;
5502 const struct ssh2_cipher
*sccipher_tobe
;
5503 const struct ssh_mac
*csmac_tobe
;
5504 const struct ssh_mac
*scmac_tobe
;
5505 const struct ssh_compress
*cscomp_tobe
;
5506 const struct ssh_compress
*sccomp_tobe
;
5507 char *hostkeydata
, *sigdata
, *rsakeydata
, *keystr
, *fingerprint
;
5508 int hostkeylen
, siglen
, rsakeylen
;
5509 void *hkey
; /* actual host key */
5510 void *rsakey
; /* for RSA kex */
5511 unsigned char exchange_hash
[SSH2_KEX_MAX_HASH_LEN
];
5512 int n_preferred_kex
;
5513 const struct ssh_kexes
*preferred_kex
[KEX_MAX
];
5514 int n_preferred_ciphers
;
5515 const struct ssh2_ciphers
*preferred_ciphers
[CIPHER_MAX
];
5516 const struct ssh_compress
*preferred_comp
;
5517 int userauth_succeeded
; /* for delayed compression */
5518 int pending_compression
;
5519 int got_session_id
, activated_authconn
;
5520 struct Packet
*pktout
;
5525 crState(do_ssh2_transport_state
);
5529 s
->cscipher_tobe
= s
->sccipher_tobe
= NULL
;
5530 s
->csmac_tobe
= s
->scmac_tobe
= NULL
;
5531 s
->cscomp_tobe
= s
->sccomp_tobe
= NULL
;
5533 s
->got_session_id
= s
->activated_authconn
= FALSE
;
5534 s
->userauth_succeeded
= FALSE
;
5535 s
->pending_compression
= FALSE
;
5538 * Be prepared to work around the buggy MAC problem.
5540 if (ssh
->remote_bugs
& BUG_SSH2_HMAC
)
5541 s
->maclist
= buggymacs
, s
->nmacs
= lenof(buggymacs
);
5543 s
->maclist
= macs
, s
->nmacs
= lenof(macs
);
5546 ssh
->pkt_kctx
= SSH2_PKTCTX_NOKEX
;
5548 int i
, j
, k
, commalist_started
;
5551 * Set up the preferred key exchange. (NULL => warn below here)
5553 s
->n_preferred_kex
= 0;
5554 for (i
= 0; i
< KEX_MAX
; i
++) {
5555 switch (conf_get_int_int(ssh
->conf
, CONF_ssh_kexlist
, i
)) {
5557 s
->preferred_kex
[s
->n_preferred_kex
++] =
5558 &ssh_diffiehellman_gex
;
5561 s
->preferred_kex
[s
->n_preferred_kex
++] =
5562 &ssh_diffiehellman_group14
;
5565 s
->preferred_kex
[s
->n_preferred_kex
++] =
5566 &ssh_diffiehellman_group1
;
5569 s
->preferred_kex
[s
->n_preferred_kex
++] =
5573 /* Flag for later. Don't bother if it's the last in
5575 if (i
< KEX_MAX
- 1) {
5576 s
->preferred_kex
[s
->n_preferred_kex
++] = NULL
;
5583 * Set up the preferred ciphers. (NULL => warn below here)
5585 s
->n_preferred_ciphers
= 0;
5586 for (i
= 0; i
< CIPHER_MAX
; i
++) {
5587 switch (conf_get_int_int(ssh
->conf
, CONF_ssh_cipherlist
, i
)) {
5588 case CIPHER_BLOWFISH
:
5589 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_blowfish
;
5592 if (conf_get_int(ssh
->conf
, CONF_ssh2_des_cbc
)) {
5593 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_des
;
5597 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_3des
;
5600 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_aes
;
5602 case CIPHER_ARCFOUR
:
5603 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_arcfour
;
5606 /* Flag for later. Don't bother if it's the last in
5608 if (i
< CIPHER_MAX
- 1) {
5609 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = NULL
;
5616 * Set up preferred compression.
5618 if (conf_get_int(ssh
->conf
, CONF_compression
))
5619 s
->preferred_comp
= &ssh_zlib
;
5621 s
->preferred_comp
= &ssh_comp_none
;
5624 * Enable queueing of outgoing auth- or connection-layer
5625 * packets while we are in the middle of a key exchange.
5627 ssh
->queueing
= TRUE
;
5630 * Flag that KEX is in progress.
5632 ssh
->kex_in_progress
= TRUE
;
5635 * Construct and send our key exchange packet.
5637 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEXINIT
);
5638 for (i
= 0; i
< 16; i
++)
5639 ssh2_pkt_addbyte(s
->pktout
, (unsigned char) random_byte());
5640 /* List key exchange algorithms. */
5641 ssh2_pkt_addstring_start(s
->pktout
);
5642 commalist_started
= 0;
5643 for (i
= 0; i
< s
->n_preferred_kex
; i
++) {
5644 const struct ssh_kexes
*k
= s
->preferred_kex
[i
];
5645 if (!k
) continue; /* warning flag */
5646 for (j
= 0; j
< k
->nkexes
; j
++) {
5647 if (commalist_started
)
5648 ssh2_pkt_addstring_str(s
->pktout
, ",");
5649 ssh2_pkt_addstring_str(s
->pktout
, k
->list
[j
]->name
);
5650 commalist_started
= 1;
5653 /* List server host key algorithms. */
5654 ssh2_pkt_addstring_start(s
->pktout
);
5655 for (i
= 0; i
< lenof(hostkey_algs
); i
++) {
5656 ssh2_pkt_addstring_str(s
->pktout
, hostkey_algs
[i
]->name
);
5657 if (i
< lenof(hostkey_algs
) - 1)
5658 ssh2_pkt_addstring_str(s
->pktout
, ",");
5660 /* List encryption algorithms (client->server then server->client). */
5661 for (k
= 0; k
< 2; k
++) {
5662 ssh2_pkt_addstring_start(s
->pktout
);
5663 commalist_started
= 0;
5664 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5665 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5666 if (!c
) continue; /* warning flag */
5667 for (j
= 0; j
< c
->nciphers
; j
++) {
5668 if (commalist_started
)
5669 ssh2_pkt_addstring_str(s
->pktout
, ",");
5670 ssh2_pkt_addstring_str(s
->pktout
, c
->list
[j
]->name
);
5671 commalist_started
= 1;
5675 /* List MAC algorithms (client->server then server->client). */
5676 for (j
= 0; j
< 2; j
++) {
5677 ssh2_pkt_addstring_start(s
->pktout
);
5678 for (i
= 0; i
< s
->nmacs
; i
++) {
5679 ssh2_pkt_addstring_str(s
->pktout
, s
->maclist
[i
]->name
);
5680 if (i
< s
->nmacs
- 1)
5681 ssh2_pkt_addstring_str(s
->pktout
, ",");
5684 /* List client->server compression algorithms,
5685 * then server->client compression algorithms. (We use the
5686 * same set twice.) */
5687 for (j
= 0; j
< 2; j
++) {
5688 ssh2_pkt_addstring_start(s
->pktout
);
5689 assert(lenof(compressions
) > 1);
5690 /* Prefer non-delayed versions */
5691 ssh2_pkt_addstring_str(s
->pktout
, s
->preferred_comp
->name
);
5692 /* We don't even list delayed versions of algorithms until
5693 * they're allowed to be used, to avoid a race. See the end of
5695 if (s
->userauth_succeeded
&& s
->preferred_comp
->delayed_name
) {
5696 ssh2_pkt_addstring_str(s
->pktout
, ",");
5697 ssh2_pkt_addstring_str(s
->pktout
,
5698 s
->preferred_comp
->delayed_name
);
5700 for (i
= 0; i
< lenof(compressions
); i
++) {
5701 const struct ssh_compress
*c
= compressions
[i
];
5702 if (c
!= s
->preferred_comp
) {
5703 ssh2_pkt_addstring_str(s
->pktout
, ",");
5704 ssh2_pkt_addstring_str(s
->pktout
, c
->name
);
5705 if (s
->userauth_succeeded
&& c
->delayed_name
) {
5706 ssh2_pkt_addstring_str(s
->pktout
, ",");
5707 ssh2_pkt_addstring_str(s
->pktout
, c
->delayed_name
);
5712 /* List client->server languages. Empty list. */
5713 ssh2_pkt_addstring_start(s
->pktout
);
5714 /* List server->client languages. Empty list. */
5715 ssh2_pkt_addstring_start(s
->pktout
);
5716 /* First KEX packet does _not_ follow, because we're not that brave. */
5717 ssh2_pkt_addbool(s
->pktout
, FALSE
);
5719 ssh2_pkt_adduint32(s
->pktout
, 0);
5722 s
->our_kexinitlen
= s
->pktout
->length
- 5;
5723 s
->our_kexinit
= snewn(s
->our_kexinitlen
, unsigned char);
5724 memcpy(s
->our_kexinit
, s
->pktout
->data
+ 5, s
->our_kexinitlen
);
5726 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5732 * Now examine the other side's KEXINIT to see what we're up
5736 char *str
, *preferred
;
5739 if (pktin
->type
!= SSH2_MSG_KEXINIT
) {
5740 bombout(("expected key exchange packet from server"));
5744 ssh
->hostkey
= NULL
;
5745 s
->cscipher_tobe
= NULL
;
5746 s
->sccipher_tobe
= NULL
;
5747 s
->csmac_tobe
= NULL
;
5748 s
->scmac_tobe
= NULL
;
5749 s
->cscomp_tobe
= NULL
;
5750 s
->sccomp_tobe
= NULL
;
5751 s
->warn_kex
= s
->warn_cscipher
= s
->warn_sccipher
= FALSE
;
5753 pktin
->savedpos
+= 16; /* skip garbage cookie */
5754 ssh_pkt_getstring(pktin
, &str
, &len
); /* key exchange algorithms */
5757 for (i
= 0; i
< s
->n_preferred_kex
; i
++) {
5758 const struct ssh_kexes
*k
= s
->preferred_kex
[i
];
5762 for (j
= 0; j
< k
->nkexes
; j
++) {
5763 if (!preferred
) preferred
= k
->list
[j
]->name
;
5764 if (in_commasep_string(k
->list
[j
]->name
, str
, len
)) {
5765 ssh
->kex
= k
->list
[j
];
5774 bombout(("Couldn't agree a key exchange algorithm (available: %s)",
5775 str ? str
: "(null)"));
5779 * Note that the server's guess is considered wrong if it doesn't match
5780 * the first algorithm in our list, even if it's still the algorithm
5783 s
->guessok
= first_in_commasep_string(preferred
, str
, len
);
5784 ssh_pkt_getstring(pktin
, &str
, &len
); /* host key algorithms */
5785 for (i
= 0; i
< lenof(hostkey_algs
); i
++) {
5786 if (in_commasep_string(hostkey_algs
[i
]->name
, str
, len
)) {
5787 ssh
->hostkey
= hostkey_algs
[i
];
5791 if (!ssh
->hostkey
) {
5792 bombout(("Couldn't agree a host key algorithm (available: %s)",
5793 str ? str
: "(null)"));
5797 s
->guessok
= s
->guessok
&&
5798 first_in_commasep_string(hostkey_algs
[0]->name
, str
, len
);
5799 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server cipher */
5800 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5801 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5803 s
->warn_cscipher
= TRUE
;
5805 for (j
= 0; j
< c
->nciphers
; j
++) {
5806 if (in_commasep_string(c
->list
[j
]->name
, str
, len
)) {
5807 s
->cscipher_tobe
= c
->list
[j
];
5812 if (s
->cscipher_tobe
)
5815 if (!s
->cscipher_tobe
) {
5816 bombout(("Couldn't agree a client-to-server cipher (available: %s)",
5817 str ? str
: "(null)"));
5821 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client cipher */
5822 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5823 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5825 s
->warn_sccipher
= TRUE
;
5827 for (j
= 0; j
< c
->nciphers
; j
++) {
5828 if (in_commasep_string(c
->list
[j
]->name
, str
, len
)) {
5829 s
->sccipher_tobe
= c
->list
[j
];
5834 if (s
->sccipher_tobe
)
5837 if (!s
->sccipher_tobe
) {
5838 bombout(("Couldn't agree a server-to-client cipher (available: %s)",
5839 str ? str
: "(null)"));
5843 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server mac */
5844 for (i
= 0; i
< s
->nmacs
; i
++) {
5845 if (in_commasep_string(s
->maclist
[i
]->name
, str
, len
)) {
5846 s
->csmac_tobe
= s
->maclist
[i
];
5850 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client mac */
5851 for (i
= 0; i
< s
->nmacs
; i
++) {
5852 if (in_commasep_string(s
->maclist
[i
]->name
, str
, len
)) {
5853 s
->scmac_tobe
= s
->maclist
[i
];
5857 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server compression */
5858 for (i
= 0; i
< lenof(compressions
) + 1; i
++) {
5859 const struct ssh_compress
*c
=
5860 i
== 0 ? s
->preferred_comp
: compressions
[i
- 1];
5861 if (in_commasep_string(c
->name
, str
, len
)) {
5864 } else if (in_commasep_string(c
->delayed_name
, str
, len
)) {
5865 if (s
->userauth_succeeded
) {
5869 s
->pending_compression
= TRUE
; /* try this later */
5873 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client compression */
5874 for (i
= 0; i
< lenof(compressions
) + 1; i
++) {
5875 const struct ssh_compress
*c
=
5876 i
== 0 ? s
->preferred_comp
: compressions
[i
- 1];
5877 if (in_commasep_string(c
->name
, str
, len
)) {
5880 } else if (in_commasep_string(c
->delayed_name
, str
, len
)) {
5881 if (s
->userauth_succeeded
) {
5885 s
->pending_compression
= TRUE
; /* try this later */
5889 if (s
->pending_compression
) {
5890 logevent("Server supports delayed compression; "
5891 "will try this later");
5893 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server language */
5894 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client language */
5895 s
->ignorepkt
= ssh2_pkt_getbool(pktin
) && !s
->guessok
;
5898 ssh_set_frozen(ssh
, 1);
5899 s
->dlgret
= askalg(ssh
->frontend
, "key-exchange algorithm",
5901 ssh_dialog_callback
, ssh
);
5902 if (s
->dlgret
< 0) {
5906 bombout(("Unexpected data from server while"
5907 " waiting for user response"));
5910 } while (pktin
|| inlen
> 0);
5911 s
->dlgret
= ssh
->user_response
;
5913 ssh_set_frozen(ssh
, 0);
5914 if (s
->dlgret
== 0) {
5915 ssh_disconnect(ssh
, "User aborted at kex warning", NULL
,
5921 if (s
->warn_cscipher
) {
5922 ssh_set_frozen(ssh
, 1);
5923 s
->dlgret
= askalg(ssh
->frontend
,
5924 "client-to-server cipher",
5925 s
->cscipher_tobe
->name
,
5926 ssh_dialog_callback
, ssh
);
5927 if (s
->dlgret
< 0) {
5931 bombout(("Unexpected data from server while"
5932 " waiting for user response"));
5935 } while (pktin
|| inlen
> 0);
5936 s
->dlgret
= ssh
->user_response
;
5938 ssh_set_frozen(ssh
, 0);
5939 if (s
->dlgret
== 0) {
5940 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
5946 if (s
->warn_sccipher
) {
5947 ssh_set_frozen(ssh
, 1);
5948 s
->dlgret
= askalg(ssh
->frontend
,
5949 "server-to-client cipher",
5950 s
->sccipher_tobe
->name
,
5951 ssh_dialog_callback
, ssh
);
5952 if (s
->dlgret
< 0) {
5956 bombout(("Unexpected data from server while"
5957 " waiting for user response"));
5960 } while (pktin
|| inlen
> 0);
5961 s
->dlgret
= ssh
->user_response
;
5963 ssh_set_frozen(ssh
, 0);
5964 if (s
->dlgret
== 0) {
5965 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
5971 ssh
->exhash
= ssh
->kex
->hash
->init();
5972 hash_string(ssh
->kex
->hash
, ssh
->exhash
, ssh
->v_c
, strlen(ssh
->v_c
));
5973 hash_string(ssh
->kex
->hash
, ssh
->exhash
, ssh
->v_s
, strlen(ssh
->v_s
));
5974 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
5975 s
->our_kexinit
, s
->our_kexinitlen
);
5976 sfree(s
->our_kexinit
);
5977 if (pktin
->length
> 5)
5978 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
5979 pktin
->data
+ 5, pktin
->length
- 5);
5981 if (s
->ignorepkt
) /* first_kex_packet_follows */
5982 crWaitUntil(pktin
); /* Ignore packet */
5985 if (ssh
->kex
->main_type
== KEXTYPE_DH
) {
5987 * Work out the number of bits of key we will need from the
5988 * key exchange. We start with the maximum key length of
5994 csbits
= s
->cscipher_tobe
->keylen
;
5995 scbits
= s
->sccipher_tobe
->keylen
;
5996 s
->nbits
= (csbits
> scbits ? csbits
: scbits
);
5998 /* The keys only have hlen-bit entropy, since they're based on
5999 * a hash. So cap the key size at hlen bits. */
6000 if (s
->nbits
> ssh
->kex
->hash
->hlen
* 8)
6001 s
->nbits
= ssh
->kex
->hash
->hlen
* 8;
6004 * If we're doing Diffie-Hellman group exchange, start by
6005 * requesting a group.
6007 if (!ssh
->kex
->pdata
) {
6008 logevent("Doing Diffie-Hellman group exchange");
6009 ssh
->pkt_kctx
= SSH2_PKTCTX_DHGEX
;
6011 * Work out how big a DH group we will need to allow that
6014 s
->pbits
= 512 << ((s
->nbits
- 1) / 64);
6015 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST
);
6016 ssh2_pkt_adduint32(s
->pktout
, s
->pbits
);
6017 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
6020 if (pktin
->type
!= SSH2_MSG_KEX_DH_GEX_GROUP
) {
6021 bombout(("expected key exchange group packet from server"));
6024 s
->p
= ssh2_pkt_getmp(pktin
);
6025 s
->g
= ssh2_pkt_getmp(pktin
);
6026 if (!s
->p
|| !s
->g
) {
6027 bombout(("unable to read mp-ints from incoming group packet"));
6030 ssh
->kex_ctx
= dh_setup_gex(s
->p
, s
->g
);
6031 s
->kex_init_value
= SSH2_MSG_KEX_DH_GEX_INIT
;
6032 s
->kex_reply_value
= SSH2_MSG_KEX_DH_GEX_REPLY
;
6034 ssh
->pkt_kctx
= SSH2_PKTCTX_DHGROUP
;
6035 ssh
->kex_ctx
= dh_setup_group(ssh
->kex
);
6036 s
->kex_init_value
= SSH2_MSG_KEXDH_INIT
;
6037 s
->kex_reply_value
= SSH2_MSG_KEXDH_REPLY
;
6038 logeventf(ssh
, "Using Diffie-Hellman with standard group \"%s\"",
6039 ssh
->kex
->groupname
);
6042 logeventf(ssh
, "Doing Diffie-Hellman key exchange with hash %s",
6043 ssh
->kex
->hash
->text_name
);
6045 * Now generate and send e for Diffie-Hellman.
6047 set_busy_status(ssh
->frontend
, BUSY_CPU
); /* this can take a while */
6048 s
->e
= dh_create_e(ssh
->kex_ctx
, s
->nbits
* 2);
6049 s
->pktout
= ssh2_pkt_init(s
->kex_init_value
);
6050 ssh2_pkt_addmp(s
->pktout
, s
->e
);
6051 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
6053 set_busy_status(ssh
->frontend
, BUSY_WAITING
); /* wait for server */
6055 if (pktin
->type
!= s
->kex_reply_value
) {
6056 bombout(("expected key exchange reply packet from server"));
6059 set_busy_status(ssh
->frontend
, BUSY_CPU
); /* cogitate */
6060 ssh_pkt_getstring(pktin
, &s
->hostkeydata
, &s
->hostkeylen
);
6061 s
->hkey
= ssh
->hostkey
->newkey(s
->hostkeydata
, s
->hostkeylen
);
6062 s
->f
= ssh2_pkt_getmp(pktin
);
6064 bombout(("unable to parse key exchange reply packet"));
6067 ssh_pkt_getstring(pktin
, &s
->sigdata
, &s
->siglen
);
6069 s
->K
= dh_find_K(ssh
->kex_ctx
, s
->f
);
6071 /* We assume everything from now on will be quick, and it might
6072 * involve user interaction. */
6073 set_busy_status(ssh
->frontend
, BUSY_NOT
);
6075 hash_string(ssh
->kex
->hash
, ssh
->exhash
, s
->hostkeydata
, s
->hostkeylen
);
6076 if (!ssh
->kex
->pdata
) {
6077 hash_uint32(ssh
->kex
->hash
, ssh
->exhash
, s
->pbits
);
6078 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->p
);
6079 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->g
);
6081 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->e
);
6082 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->f
);
6084 dh_cleanup(ssh
->kex_ctx
);
6086 if (!ssh
->kex
->pdata
) {
6091 logeventf(ssh
, "Doing RSA key exchange with hash %s",
6092 ssh
->kex
->hash
->text_name
);
6093 ssh
->pkt_kctx
= SSH2_PKTCTX_RSAKEX
;
6095 * RSA key exchange. First expect a KEXRSA_PUBKEY packet
6099 if (pktin
->type
!= SSH2_MSG_KEXRSA_PUBKEY
) {
6100 bombout(("expected RSA public key packet from server"));
6104 ssh_pkt_getstring(pktin
, &s
->hostkeydata
, &s
->hostkeylen
);
6105 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
6106 s
->hostkeydata
, s
->hostkeylen
);
6107 s
->hkey
= ssh
->hostkey
->newkey(s
->hostkeydata
, s
->hostkeylen
);
6111 ssh_pkt_getstring(pktin
, &keydata
, &s
->rsakeylen
);
6112 s
->rsakeydata
= snewn(s
->rsakeylen
, char);
6113 memcpy(s
->rsakeydata
, keydata
, s
->rsakeylen
);
6116 s
->rsakey
= ssh_rsakex_newkey(s
->rsakeydata
, s
->rsakeylen
);
6118 sfree(s
->rsakeydata
);
6119 bombout(("unable to parse RSA public key from server"));
6123 hash_string(ssh
->kex
->hash
, ssh
->exhash
, s
->rsakeydata
, s
->rsakeylen
);
6126 * Next, set up a shared secret K, of precisely KLEN -
6127 * 2*HLEN - 49 bits, where KLEN is the bit length of the
6128 * RSA key modulus and HLEN is the bit length of the hash
6132 int klen
= ssh_rsakex_klen(s
->rsakey
);
6133 int nbits
= klen
- (2*ssh
->kex
->hash
->hlen
*8 + 49);
6135 unsigned char *kstr1
, *kstr2
, *outstr
;
6136 int kstr1len
, kstr2len
, outstrlen
;
6138 s
->K
= bn_power_2(nbits
- 1);
6140 for (i
= 0; i
< nbits
; i
++) {
6142 byte
= random_byte();
6144 bignum_set_bit(s
->K
, i
, (byte
>> (i
& 7)) & 1);
6148 * Encode this as an mpint.
6150 kstr1
= ssh2_mpint_fmt(s
->K
, &kstr1len
);
6151 kstr2
= snewn(kstr2len
= 4 + kstr1len
, unsigned char);
6152 PUT_32BIT(kstr2
, kstr1len
);
6153 memcpy(kstr2
+ 4, kstr1
, kstr1len
);
6156 * Encrypt it with the given RSA key.
6158 outstrlen
= (klen
+ 7) / 8;
6159 outstr
= snewn(outstrlen
, unsigned char);
6160 ssh_rsakex_encrypt(ssh
->kex
->hash
, kstr2
, kstr2len
,
6161 outstr
, outstrlen
, s
->rsakey
);
6164 * And send it off in a return packet.
6166 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEXRSA_SECRET
);
6167 ssh2_pkt_addstring_start(s
->pktout
);
6168 ssh2_pkt_addstring_data(s
->pktout
, (char *)outstr
, outstrlen
);
6169 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
6171 hash_string(ssh
->kex
->hash
, ssh
->exhash
, outstr
, outstrlen
);
6178 ssh_rsakex_freekey(s
->rsakey
);
6181 if (pktin
->type
!= SSH2_MSG_KEXRSA_DONE
) {
6182 sfree(s
->rsakeydata
);
6183 bombout(("expected signature packet from server"));
6187 ssh_pkt_getstring(pktin
, &s
->sigdata
, &s
->siglen
);
6189 sfree(s
->rsakeydata
);
6192 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->K
);
6193 assert(ssh
->kex
->hash
->hlen
<= sizeof(s
->exchange_hash
));
6194 ssh
->kex
->hash
->final(ssh
->exhash
, s
->exchange_hash
);
6196 ssh
->kex_ctx
= NULL
;
6199 debug(("Exchange hash is:\n"));
6200 dmemdump(s
->exchange_hash
, ssh
->kex
->hash
->hlen
);
6204 !ssh
->hostkey
->verifysig(s
->hkey
, s
->sigdata
, s
->siglen
,
6205 (char *)s
->exchange_hash
,
6206 ssh
->kex
->hash
->hlen
)) {
6207 bombout(("Server's host key did not match the signature supplied"));
6212 * Authenticate remote host: verify host key. (We've already
6213 * checked the signature of the exchange hash.)
6215 s
->keystr
= ssh
->hostkey
->fmtkey(s
->hkey
);
6216 s
->fingerprint
= ssh
->hostkey
->fingerprint(s
->hkey
);
6217 ssh_set_frozen(ssh
, 1);
6218 s
->dlgret
= verify_ssh_host_key(ssh
->frontend
,
6219 ssh
->savedhost
, ssh
->savedport
,
6220 ssh
->hostkey
->keytype
, s
->keystr
,
6222 ssh_dialog_callback
, ssh
);
6223 if (s
->dlgret
< 0) {
6227 bombout(("Unexpected data from server while waiting"
6228 " for user host key response"));
6231 } while (pktin
|| inlen
> 0);
6232 s
->dlgret
= ssh
->user_response
;
6234 ssh_set_frozen(ssh
, 0);
6235 if (s
->dlgret
== 0) {
6236 ssh_disconnect(ssh
, "User aborted at host key verification", NULL
,
6240 if (!s
->got_session_id
) { /* don't bother logging this in rekeys */
6241 logevent("Host key fingerprint is:");
6242 logevent(s
->fingerprint
);
6244 sfree(s
->fingerprint
);
6246 ssh
->hostkey
->freekey(s
->hkey
);
6249 * The exchange hash from the very first key exchange is also
6250 * the session id, used in session key construction and
6253 if (!s
->got_session_id
) {
6254 assert(sizeof(s
->exchange_hash
) <= sizeof(ssh
->v2_session_id
));
6255 memcpy(ssh
->v2_session_id
, s
->exchange_hash
,
6256 sizeof(s
->exchange_hash
));
6257 ssh
->v2_session_id_len
= ssh
->kex
->hash
->hlen
;
6258 assert(ssh
->v2_session_id_len
<= sizeof(ssh
->v2_session_id
));
6259 s
->got_session_id
= TRUE
;
6263 * Send SSH2_MSG_NEWKEYS.
6265 s
->pktout
= ssh2_pkt_init(SSH2_MSG_NEWKEYS
);
6266 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
6267 ssh
->outgoing_data_size
= 0; /* start counting from here */
6270 * We've sent client NEWKEYS, so create and initialise
6271 * client-to-server session keys.
6273 if (ssh
->cs_cipher_ctx
)
6274 ssh
->cscipher
->free_context(ssh
->cs_cipher_ctx
);
6275 ssh
->cscipher
= s
->cscipher_tobe
;
6276 ssh
->cs_cipher_ctx
= ssh
->cscipher
->make_context();
6278 if (ssh
->cs_mac_ctx
)
6279 ssh
->csmac
->free_context(ssh
->cs_mac_ctx
);
6280 ssh
->csmac
= s
->csmac_tobe
;
6281 ssh
->cs_mac_ctx
= ssh
->csmac
->make_context();
6283 if (ssh
->cs_comp_ctx
)
6284 ssh
->cscomp
->compress_cleanup(ssh
->cs_comp_ctx
);
6285 ssh
->cscomp
= s
->cscomp_tobe
;
6286 ssh
->cs_comp_ctx
= ssh
->cscomp
->compress_init();
6289 * Set IVs on client-to-server keys. Here we use the exchange
6290 * hash from the _first_ key exchange.
6293 unsigned char keyspace
[SSH2_KEX_MAX_HASH_LEN
* SSH2_MKKEY_ITERS
];
6294 assert(sizeof(keyspace
) >= ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6295 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'C',keyspace
);
6296 assert((ssh
->cscipher
->keylen
+7) / 8 <=
6297 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6298 ssh
->cscipher
->setkey(ssh
->cs_cipher_ctx
, keyspace
);
6299 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'A',keyspace
);
6300 assert(ssh
->cscipher
->blksize
<=
6301 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6302 ssh
->cscipher
->setiv(ssh
->cs_cipher_ctx
, keyspace
);
6303 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'E',keyspace
);
6304 assert(ssh
->csmac
->len
<=
6305 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6306 ssh
->csmac
->setkey(ssh
->cs_mac_ctx
, keyspace
);
6307 smemclr(keyspace
, sizeof(keyspace
));
6310 logeventf(ssh
, "Initialised %.200s client->server encryption",
6311 ssh
->cscipher
->text_name
);
6312 logeventf(ssh
, "Initialised %.200s client->server MAC algorithm",
6313 ssh
->csmac
->text_name
);
6314 if (ssh
->cscomp
->text_name
)
6315 logeventf(ssh
, "Initialised %s compression",
6316 ssh
->cscomp
->text_name
);
6319 * Now our end of the key exchange is complete, we can send all
6320 * our queued higher-layer packets.
6322 ssh
->queueing
= FALSE
;
6323 ssh2_pkt_queuesend(ssh
);
6326 * Expect SSH2_MSG_NEWKEYS from server.
6329 if (pktin
->type
!= SSH2_MSG_NEWKEYS
) {
6330 bombout(("expected new-keys packet from server"));
6333 ssh
->incoming_data_size
= 0; /* start counting from here */
6336 * We've seen server NEWKEYS, so create and initialise
6337 * server-to-client session keys.
6339 if (ssh
->sc_cipher_ctx
)
6340 ssh
->sccipher
->free_context(ssh
->sc_cipher_ctx
);
6341 ssh
->sccipher
= s
->sccipher_tobe
;
6342 ssh
->sc_cipher_ctx
= ssh
->sccipher
->make_context();
6344 if (ssh
->sc_mac_ctx
)
6345 ssh
->scmac
->free_context(ssh
->sc_mac_ctx
);
6346 ssh
->scmac
= s
->scmac_tobe
;
6347 ssh
->sc_mac_ctx
= ssh
->scmac
->make_context();
6349 if (ssh
->sc_comp_ctx
)
6350 ssh
->sccomp
->decompress_cleanup(ssh
->sc_comp_ctx
);
6351 ssh
->sccomp
= s
->sccomp_tobe
;
6352 ssh
->sc_comp_ctx
= ssh
->sccomp
->decompress_init();
6355 * Set IVs on server-to-client keys. Here we use the exchange
6356 * hash from the _first_ key exchange.
6359 unsigned char keyspace
[SSH2_KEX_MAX_HASH_LEN
* SSH2_MKKEY_ITERS
];
6360 assert(sizeof(keyspace
) >= ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6361 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'D',keyspace
);
6362 assert((ssh
->sccipher
->keylen
+7) / 8 <=
6363 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6364 ssh
->sccipher
->setkey(ssh
->sc_cipher_ctx
, keyspace
);
6365 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'B',keyspace
);
6366 assert(ssh
->sccipher
->blksize
<=
6367 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6368 ssh
->sccipher
->setiv(ssh
->sc_cipher_ctx
, keyspace
);
6369 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'F',keyspace
);
6370 assert(ssh
->scmac
->len
<=
6371 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6372 ssh
->scmac
->setkey(ssh
->sc_mac_ctx
, keyspace
);
6373 smemclr(keyspace
, sizeof(keyspace
));
6375 logeventf(ssh
, "Initialised %.200s server->client encryption",
6376 ssh
->sccipher
->text_name
);
6377 logeventf(ssh
, "Initialised %.200s server->client MAC algorithm",
6378 ssh
->scmac
->text_name
);
6379 if (ssh
->sccomp
->text_name
)
6380 logeventf(ssh
, "Initialised %s decompression",
6381 ssh
->sccomp
->text_name
);
6384 * Free shared secret.
6389 * Key exchange is over. Loop straight back round if we have a
6390 * deferred rekey reason.
6392 if (ssh
->deferred_rekey_reason
) {
6393 logevent(ssh
->deferred_rekey_reason
);
6395 ssh
->deferred_rekey_reason
= NULL
;
6396 goto begin_key_exchange
;
6400 * Otherwise, schedule a timer for our next rekey.
6402 ssh
->kex_in_progress
= FALSE
;
6403 ssh
->last_rekey
= GETTICKCOUNT();
6404 if (conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
) != 0)
6405 ssh
->next_rekey
= schedule_timer(conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
)*60*TICKSPERSEC
,
6409 * Now we're encrypting. Begin returning 1 to the protocol main
6410 * function so that other things can run on top of the
6411 * transport. If we ever see a KEXINIT, we must go back to the
6414 * We _also_ go back to the start if we see pktin==NULL and
6415 * inlen negative, because this is a special signal meaning
6416 * `initiate client-driven rekey', and `in' contains a message
6417 * giving the reason for the rekey.
6419 * inlen==-1 means always initiate a rekey;
6420 * inlen==-2 means that userauth has completed successfully and
6421 * we should consider rekeying (for delayed compression).
6423 while (!((pktin
&& pktin
->type
== SSH2_MSG_KEXINIT
) ||
6424 (!pktin
&& inlen
< 0))) {
6426 if (!ssh
->protocol_initial_phase_done
) {
6427 ssh
->protocol_initial_phase_done
= TRUE
;
6429 * Allow authconn to initialise itself.
6431 do_ssh2_authconn(ssh
, NULL
, 0, NULL
);
6436 logevent("Server initiated key re-exchange");
6440 * authconn has seen a USERAUTH_SUCCEEDED. Time to enable
6441 * delayed compression, if it's available.
6443 * draft-miller-secsh-compression-delayed-00 says that you
6444 * negotiate delayed compression in the first key exchange, and
6445 * both sides start compressing when the server has sent
6446 * USERAUTH_SUCCESS. This has a race condition -- the server
6447 * can't know when the client has seen it, and thus which incoming
6448 * packets it should treat as compressed.
6450 * Instead, we do the initial key exchange without offering the
6451 * delayed methods, but note if the server offers them; when we
6452 * get here, if a delayed method was available that was higher
6453 * on our list than what we got, we initiate a rekey in which we
6454 * _do_ list the delayed methods (and hopefully get it as a
6455 * result). Subsequent rekeys will do the same.
6457 assert(!s
->userauth_succeeded
); /* should only happen once */
6458 s
->userauth_succeeded
= TRUE
;
6459 if (!s
->pending_compression
)
6460 /* Can't see any point rekeying. */
6461 goto wait_for_rekey
; /* this is utterly horrid */
6462 /* else fall through to rekey... */
6463 s
->pending_compression
= FALSE
;
6466 * Now we've decided to rekey.
6468 * Special case: if the server bug is set that doesn't
6469 * allow rekeying, we give a different log message and
6470 * continue waiting. (If such a server _initiates_ a rekey,
6471 * we process it anyway!)
6473 if ((ssh
->remote_bugs
& BUG_SSH2_REKEY
)) {
6474 logeventf(ssh
, "Server bug prevents key re-exchange (%s)",
6476 /* Reset the counters, so that at least this message doesn't
6477 * hit the event log _too_ often. */
6478 ssh
->outgoing_data_size
= 0;
6479 ssh
->incoming_data_size
= 0;
6480 if (conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
) != 0) {
6482 schedule_timer(conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
)*60*TICKSPERSEC
,
6485 goto wait_for_rekey
; /* this is still utterly horrid */
6487 logeventf(ssh
, "Initiating key re-exchange (%s)", (char *)in
);
6490 goto begin_key_exchange
;
6496 * Add data to an SSH-2 channel output buffer.
6498 static void ssh2_add_channel_data(struct ssh_channel
*c
, char *buf
,
6501 bufchain_add(&c
->v
.v2
.outbuffer
, buf
, len
);
6505 * Attempt to send data on an SSH-2 channel.
6507 static int ssh2_try_send(struct ssh_channel
*c
)
6510 struct Packet
*pktout
;
6513 while (c
->v
.v2
.remwindow
> 0 && bufchain_size(&c
->v
.v2
.outbuffer
) > 0) {
6516 bufchain_prefix(&c
->v
.v2
.outbuffer
, &data
, &len
);
6517 if ((unsigned)len
> c
->v
.v2
.remwindow
)
6518 len
= c
->v
.v2
.remwindow
;
6519 if ((unsigned)len
> c
->v
.v2
.remmaxpkt
)
6520 len
= c
->v
.v2
.remmaxpkt
;
6521 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA
);
6522 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6523 ssh2_pkt_addstring_start(pktout
);
6524 dont_log_data(ssh
, pktout
, PKTLOG_OMIT
);
6525 ssh2_pkt_addstring_data(pktout
, data
, len
);
6526 end_log_omission(ssh
, pktout
);
6527 ssh2_pkt_send(ssh
, pktout
);
6528 bufchain_consume(&c
->v
.v2
.outbuffer
, len
);
6529 c
->v
.v2
.remwindow
-= len
;
6533 * After having sent as much data as we can, return the amount
6536 ret
= bufchain_size(&c
->v
.v2
.outbuffer
);
6539 * And if there's no data pending but we need to send an EOF, send
6542 if (!ret
&& c
->pending_eof
)
6543 ssh_channel_try_eof(c
);
6548 static void ssh2_try_send_and_unthrottle(Ssh ssh
, struct ssh_channel
*c
)
6551 if (c
->closes
& CLOSES_SENT_EOF
)
6552 return; /* don't send on channels we've EOFed */
6553 bufsize
= ssh2_try_send(c
);
6556 case CHAN_MAINSESSION
:
6557 /* stdin need not receive an unthrottle
6558 * notification since it will be polled */
6561 x11_unthrottle(c
->u
.x11
.s
);
6564 /* agent sockets are request/response and need no
6565 * buffer management */
6568 pfd_unthrottle(c
->u
.pfd
.s
);
6575 * Set up most of a new ssh_channel for SSH-2.
6577 static void ssh2_channel_init(struct ssh_channel
*c
)
6580 c
->localid
= alloc_channel_id(ssh
);
6582 c
->pending_eof
= FALSE
;
6583 c
->throttling_conn
= FALSE
;
6584 c
->v
.v2
.locwindow
= c
->v
.v2
.locmaxwin
= c
->v
.v2
.remlocwin
=
6585 conf_get_int(ssh
->conf
, CONF_ssh_simple
) ? OUR_V2_BIGWIN
: OUR_V2_WINSIZE
;
6586 c
->v
.v2
.chanreq_head
= NULL
;
6587 c
->v
.v2
.throttle_state
= UNTHROTTLED
;
6588 bufchain_init(&c
->v
.v2
.outbuffer
);
6592 * CHANNEL_FAILURE doesn't come with any indication of what message
6593 * caused it, so we have to keep track of the outstanding
6594 * CHANNEL_REQUESTs ourselves.
6596 static void ssh2_queue_chanreq_handler(struct ssh_channel
*c
,
6597 cchandler_fn_t handler
, void *ctx
)
6599 struct outstanding_channel_request
*ocr
=
6600 snew(struct outstanding_channel_request
);
6602 ocr
->handler
= handler
;
6605 if (!c
->v
.v2
.chanreq_head
)
6606 c
->v
.v2
.chanreq_head
= ocr
;
6608 c
->v
.v2
.chanreq_tail
->next
= ocr
;
6609 c
->v
.v2
.chanreq_tail
= ocr
;
6613 * Potentially enlarge the window on an SSH-2 channel.
6615 static void ssh2_handle_winadj_response(struct ssh_channel
*, struct Packet
*,
6617 static void ssh2_set_window(struct ssh_channel
*c
, int newwin
)
6622 * Never send WINDOW_ADJUST for a channel that the remote side has
6623 * already sent EOF on; there's no point, since it won't be
6624 * sending any more data anyway. Ditto if _we've_ already sent
6627 if (c
->closes
& (CLOSES_RCVD_EOF
| CLOSES_SENT_CLOSE
))
6631 * If the remote end has a habit of ignoring maxpkt, limit the
6632 * window so that it has no choice (assuming it doesn't ignore the
6635 if ((ssh
->remote_bugs
& BUG_SSH2_MAXPKT
) && newwin
> OUR_V2_MAXPKT
)
6636 newwin
= OUR_V2_MAXPKT
;
6639 * Only send a WINDOW_ADJUST if there's significantly more window
6640 * available than the other end thinks there is. This saves us
6641 * sending a WINDOW_ADJUST for every character in a shell session.
6643 * "Significant" is arbitrarily defined as half the window size.
6645 if (newwin
/ 2 >= c
->v
.v2
.locwindow
) {
6646 struct Packet
*pktout
;
6650 * In order to keep track of how much window the client
6651 * actually has available, we'd like it to acknowledge each
6652 * WINDOW_ADJUST. We can't do that directly, so we accompany
6653 * it with a CHANNEL_REQUEST that has to be acknowledged.
6655 * This is only necessary if we're opening the window wide.
6656 * If we're not, then throughput is being constrained by
6657 * something other than the maximum window size anyway.
6659 if (newwin
== c
->v
.v2
.locmaxwin
&&
6660 !(ssh
->remote_bugs
& BUG_CHOKES_ON_WINADJ
)) {
6661 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
6662 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6663 ssh2_pkt_addstring(pktout
, "winadj@putty.projects.tartarus.org");
6664 ssh2_pkt_addbool(pktout
, TRUE
);
6665 ssh2_pkt_send(ssh
, pktout
);
6667 up
= snew(unsigned);
6668 *up
= newwin
- c
->v
.v2
.locwindow
;
6669 ssh2_queue_chanreq_handler(c
, ssh2_handle_winadj_response
, up
);
6670 if (c
->v
.v2
.throttle_state
!= UNTHROTTLED
)
6671 c
->v
.v2
.throttle_state
= UNTHROTTLING
;
6673 /* Pretend the WINDOW_ADJUST was acked immediately. */
6674 c
->v
.v2
.remlocwin
= newwin
;
6675 c
->v
.v2
.throttle_state
= THROTTLED
;
6677 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST
);
6678 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6679 ssh2_pkt_adduint32(pktout
, newwin
- c
->v
.v2
.locwindow
);
6680 ssh2_pkt_send(ssh
, pktout
);
6681 c
->v
.v2
.locwindow
= newwin
;
6686 * Find the channel associated with a message. If there's no channel,
6687 * or it's not properly open, make a noise about it and return NULL.
6689 static struct ssh_channel
*ssh2_channel_msg(Ssh ssh
, struct Packet
*pktin
)
6691 unsigned localid
= ssh_pkt_getuint32(pktin
);
6692 struct ssh_channel
*c
;
6694 c
= find234(ssh
->channels
, &localid
, ssh_channelfind
);
6696 (c
->halfopen
&& pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
&&
6697 pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_FAILURE
)) {
6698 char *buf
= dupprintf("Received %s for %s channel %u",
6699 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
,
6701 c ?
"half-open" : "nonexistent", localid
);
6702 ssh_disconnect(ssh
, NULL
, buf
, SSH2_DISCONNECT_PROTOCOL_ERROR
, FALSE
);
6709 static void ssh2_handle_winadj_response(struct ssh_channel
*c
,
6710 struct Packet
*pktin
, void *ctx
)
6712 unsigned *sizep
= ctx
;
6715 * Winadj responses should always be failures. However, at least
6716 * one server ("boks_sshd") is known to return SUCCESS for channel
6717 * requests it's never heard of, such as "winadj@putty". Raised
6718 * with foxt.com as bug 090916-090424, but for the sake of a quiet
6719 * life, we don't worry about what kind of response we got.
6722 c
->v
.v2
.remlocwin
+= *sizep
;
6725 * winadj messages are only sent when the window is fully open, so
6726 * if we get an ack of one, we know any pending unthrottle is
6729 if (c
->v
.v2
.throttle_state
== UNTHROTTLING
)
6730 c
->v
.v2
.throttle_state
= UNTHROTTLED
;
6733 static void ssh2_msg_channel_response(Ssh ssh
, struct Packet
*pktin
)
6735 struct ssh_channel
*c
= ssh2_channel_msg(ssh
, pktin
);
6736 struct outstanding_channel_request
*ocr
;
6739 ocr
= c
->v
.v2
.chanreq_head
;
6741 ssh2_msg_unexpected(ssh
, pktin
);
6744 ocr
->handler(c
, pktin
, ocr
->ctx
);
6745 c
->v
.v2
.chanreq_head
= ocr
->next
;
6748 * We may now initiate channel-closing procedures, if that
6749 * CHANNEL_REQUEST was the last thing outstanding before we send
6752 ssh2_channel_check_close(c
);
6755 static void ssh2_msg_channel_window_adjust(Ssh ssh
, struct Packet
*pktin
)
6757 struct ssh_channel
*c
;
6758 c
= ssh2_channel_msg(ssh
, pktin
);
6761 if (!(c
->closes
& CLOSES_SENT_EOF
)) {
6762 c
->v
.v2
.remwindow
+= ssh_pkt_getuint32(pktin
);
6763 ssh2_try_send_and_unthrottle(ssh
, c
);
6767 static void ssh2_msg_channel_data(Ssh ssh
, struct Packet
*pktin
)
6771 struct ssh_channel
*c
;
6772 c
= ssh2_channel_msg(ssh
, pktin
);
6775 if (pktin
->type
== SSH2_MSG_CHANNEL_EXTENDED_DATA
&&
6776 ssh_pkt_getuint32(pktin
) != SSH2_EXTENDED_DATA_STDERR
)
6777 return; /* extended but not stderr */
6778 ssh_pkt_getstring(pktin
, &data
, &length
);
6781 c
->v
.v2
.locwindow
-= length
;
6782 c
->v
.v2
.remlocwin
-= length
;
6784 case CHAN_MAINSESSION
:
6786 from_backend(ssh
->frontend
, pktin
->type
==
6787 SSH2_MSG_CHANNEL_EXTENDED_DATA
,
6791 bufsize
= x11_send(c
->u
.x11
.s
, data
, length
);
6794 bufsize
= pfd_send(c
->u
.pfd
.s
, data
, length
);
6797 while (length
> 0) {
6798 if (c
->u
.a
.lensofar
< 4) {
6799 unsigned int l
= min(4 - c
->u
.a
.lensofar
,
6801 memcpy(c
->u
.a
.msglen
+ c
->u
.a
.lensofar
,
6805 c
->u
.a
.lensofar
+= l
;
6807 if (c
->u
.a
.lensofar
== 4) {
6809 4 + GET_32BIT(c
->u
.a
.msglen
);
6810 c
->u
.a
.message
= snewn(c
->u
.a
.totallen
,
6812 memcpy(c
->u
.a
.message
, c
->u
.a
.msglen
, 4);
6814 if (c
->u
.a
.lensofar
>= 4 && length
> 0) {
6816 min(c
->u
.a
.totallen
- c
->u
.a
.lensofar
,
6818 memcpy(c
->u
.a
.message
+ c
->u
.a
.lensofar
,
6822 c
->u
.a
.lensofar
+= l
;
6824 if (c
->u
.a
.lensofar
== c
->u
.a
.totallen
) {
6827 if (agent_query(c
->u
.a
.message
,
6830 ssh_agentf_callback
, c
))
6831 ssh_agentf_callback(c
, reply
, replylen
);
6832 sfree(c
->u
.a
.message
);
6833 c
->u
.a
.message
= NULL
;
6834 c
->u
.a
.lensofar
= 0;
6841 * If it looks like the remote end hit the end of its window,
6842 * and we didn't want it to do that, think about using a
6845 if (c
->v
.v2
.remlocwin
<= 0 && c
->v
.v2
.throttle_state
== UNTHROTTLED
&&
6846 c
->v
.v2
.locmaxwin
< 0x40000000)
6847 c
->v
.v2
.locmaxwin
+= OUR_V2_WINSIZE
;
6849 * If we are not buffering too much data,
6850 * enlarge the window again at the remote side.
6851 * If we are buffering too much, we may still
6852 * need to adjust the window if the server's
6855 ssh2_set_window(c
, bufsize
< c
->v
.v2
.locmaxwin ?
6856 c
->v
.v2
.locmaxwin
- bufsize
: 0);
6858 * If we're either buffering way too much data, or if we're
6859 * buffering anything at all and we're in "simple" mode,
6860 * throttle the whole channel.
6862 if ((bufsize
> c
->v
.v2
.locmaxwin
||
6863 (conf_get_int(ssh
->conf
, CONF_ssh_simple
) && bufsize
> 0)) &&
6864 !c
->throttling_conn
) {
6865 c
->throttling_conn
= 1;
6866 ssh_throttle_conn(ssh
, +1);
6871 static void ssh_channel_destroy(struct ssh_channel
*c
)
6876 case CHAN_MAINSESSION
:
6877 ssh
->mainchan
= NULL
;
6878 update_specials_menu(ssh
->frontend
);
6881 if (c
->u
.x11
.s
!= NULL
)
6882 x11_close(c
->u
.x11
.s
);
6883 logevent("Forwarded X11 connection terminated");
6886 sfree(c
->u
.a
.message
);
6889 if (c
->u
.pfd
.s
!= NULL
)
6890 pfd_close(c
->u
.pfd
.s
);
6891 logevent("Forwarded port closed");
6895 del234(ssh
->channels
, c
);
6896 if (ssh
->version
== 2)
6897 bufchain_clear(&c
->v
.v2
.outbuffer
);
6901 * See if that was the last channel left open.
6902 * (This is only our termination condition if we're
6903 * not running in -N mode.)
6905 if (ssh
->version
== 2 &&
6906 !conf_get_int(ssh
->conf
, CONF_ssh_no_shell
) &&
6907 count234(ssh
->channels
) == 0) {
6909 * We used to send SSH_MSG_DISCONNECT here,
6910 * because I'd believed that _every_ conforming
6911 * SSH-2 connection had to end with a disconnect
6912 * being sent by at least one side; apparently
6913 * I was wrong and it's perfectly OK to
6914 * unceremoniously slam the connection shut
6915 * when you're done, and indeed OpenSSH feels
6916 * this is more polite than sending a
6917 * DISCONNECT. So now we don't.
6919 ssh_disconnect(ssh
, "All channels closed", NULL
, 0, TRUE
);
6923 static void ssh2_channel_check_close(struct ssh_channel
*c
)
6926 struct Packet
*pktout
;
6928 if ((c
->closes
& (CLOSES_SENT_EOF
| CLOSES_RCVD_EOF
| CLOSES_SENT_CLOSE
))
6929 == (CLOSES_SENT_EOF
| CLOSES_RCVD_EOF
) && !c
->v
.v2
.chanreq_head
) {
6931 * We have both sent and received EOF, and we have no
6932 * outstanding winadj channel requests, which means the
6933 * channel is in final wind-up. But we haven't sent CLOSE, so
6936 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
6937 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6938 ssh2_pkt_send(ssh
, pktout
);
6939 c
->closes
|= CLOSES_SENT_CLOSE
;
6942 if (!((CLOSES_SENT_CLOSE
| CLOSES_RCVD_CLOSE
) & ~c
->closes
)) {
6944 * We have both sent and received CLOSE, which means we're
6945 * completely done with the channel.
6947 ssh_channel_destroy(c
);
6951 static void ssh2_channel_got_eof(struct ssh_channel
*c
)
6953 if (c
->closes
& CLOSES_RCVD_EOF
)
6954 return; /* already seen EOF */
6955 c
->closes
|= CLOSES_RCVD_EOF
;
6957 if (c
->type
== CHAN_X11
) {
6958 x11_send_eof(c
->u
.x11
.s
);
6959 } else if (c
->type
== CHAN_AGENT
) {
6960 /* Manufacture an outgoing EOF in response to the incoming one. */
6961 sshfwd_write_eof(c
);
6962 } else if (c
->type
== CHAN_SOCKDATA
) {
6963 pfd_send_eof(c
->u
.pfd
.s
);
6964 } else if (c
->type
== CHAN_MAINSESSION
) {
6967 if (!ssh
->sent_console_eof
&&
6968 (from_backend_eof(ssh
->frontend
) || ssh
->got_pty
)) {
6970 * Either from_backend_eof told us that the front end
6971 * wants us to close the outgoing side of the connection
6972 * as soon as we see EOF from the far end, or else we've
6973 * unilaterally decided to do that because we've allocated
6974 * a remote pty and hence EOF isn't a particularly
6975 * meaningful concept.
6977 sshfwd_write_eof(c
);
6979 ssh
->sent_console_eof
= TRUE
;
6982 ssh2_channel_check_close(c
);
6985 static void ssh2_msg_channel_eof(Ssh ssh
, struct Packet
*pktin
)
6987 struct ssh_channel
*c
;
6989 c
= ssh2_channel_msg(ssh
, pktin
);
6992 ssh2_channel_got_eof(c
);
6995 static void ssh2_msg_channel_close(Ssh ssh
, struct Packet
*pktin
)
6997 struct ssh_channel
*c
;
6999 c
= ssh2_channel_msg(ssh
, pktin
);
7004 * When we receive CLOSE on a channel, we assume it comes with an
7005 * implied EOF if we haven't seen EOF yet.
7007 ssh2_channel_got_eof(c
);
7010 * And we also send an outgoing EOF, if we haven't already, on the
7011 * assumption that CLOSE is a pretty forceful announcement that
7012 * the remote side is doing away with the entire channel. (If it
7013 * had wanted to send us EOF and continue receiving data from us,
7014 * it would have just sent CHANNEL_EOF.)
7016 if (!(c
->closes
& CLOSES_SENT_EOF
)) {
7018 * Make sure we don't read any more from whatever our local
7019 * data source is for this channel.
7022 case CHAN_MAINSESSION
:
7023 ssh
->send_ok
= 0; /* stop trying to read from stdin */
7026 x11_override_throttle(c
->u
.x11
.s
, 1);
7029 pfd_override_throttle(c
->u
.pfd
.s
, 1);
7034 * Send outgoing EOF.
7036 sshfwd_write_eof(c
);
7040 * Now process the actual close.
7042 if (!(c
->closes
& CLOSES_RCVD_CLOSE
)) {
7043 c
->closes
|= CLOSES_RCVD_CLOSE
;
7044 ssh2_channel_check_close(c
);
7048 static void ssh2_msg_channel_open_confirmation(Ssh ssh
, struct Packet
*pktin
)
7050 struct ssh_channel
*c
;
7052 c
= ssh2_channel_msg(ssh
, pktin
);
7055 if (c
->type
!= CHAN_SOCKDATA_DORMANT
)
7056 return; /* dunno why they're confirming this */
7057 c
->remoteid
= ssh_pkt_getuint32(pktin
);
7058 c
->halfopen
= FALSE
;
7059 c
->type
= CHAN_SOCKDATA
;
7060 c
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
7061 c
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
7063 pfd_confirm(c
->u
.pfd
.s
);
7065 ssh_channel_try_eof(c
);
7068 static void ssh2_msg_channel_open_failure(Ssh ssh
, struct Packet
*pktin
)
7070 static const char *const reasons
[] = {
7071 "<unknown reason code>",
7072 "Administratively prohibited",
7074 "Unknown channel type",
7075 "Resource shortage",
7077 unsigned reason_code
;
7078 char *reason_string
;
7080 struct ssh_channel
*c
;
7081 c
= ssh2_channel_msg(ssh
, pktin
);
7084 if (c
->type
!= CHAN_SOCKDATA_DORMANT
)
7085 return; /* dunno why they're failing this */
7087 reason_code
= ssh_pkt_getuint32(pktin
);
7088 if (reason_code
>= lenof(reasons
))
7089 reason_code
= 0; /* ensure reasons[reason_code] in range */
7090 ssh_pkt_getstring(pktin
, &reason_string
, &reason_length
);
7091 logeventf(ssh
, "Forwarded connection refused by server: %s [%.*s]",
7092 reasons
[reason_code
], reason_length
, reason_string
);
7094 pfd_close(c
->u
.pfd
.s
);
7096 del234(ssh
->channels
, c
);
7100 static void ssh2_msg_channel_request(Ssh ssh
, struct Packet
*pktin
)
7103 int typelen
, want_reply
;
7104 int reply
= SSH2_MSG_CHANNEL_FAILURE
; /* default */
7105 struct ssh_channel
*c
;
7106 struct Packet
*pktout
;
7108 c
= ssh2_channel_msg(ssh
, pktin
);
7111 ssh_pkt_getstring(pktin
, &type
, &typelen
);
7112 want_reply
= ssh2_pkt_getbool(pktin
);
7115 * Having got the channel number, we now look at
7116 * the request type string to see if it's something
7119 if (c
== ssh
->mainchan
) {
7121 * We recognise "exit-status" and "exit-signal" on
7122 * the primary channel.
7124 if (typelen
== 11 &&
7125 !memcmp(type
, "exit-status", 11)) {
7127 ssh
->exitcode
= ssh_pkt_getuint32(pktin
);
7128 logeventf(ssh
, "Server sent command exit status %d",
7130 reply
= SSH2_MSG_CHANNEL_SUCCESS
;
7132 } else if (typelen
== 11 &&
7133 !memcmp(type
, "exit-signal", 11)) {
7135 int is_plausible
= TRUE
, is_int
= FALSE
;
7136 char *fmt_sig
= "", *fmt_msg
= "";
7138 int msglen
= 0, core
= FALSE
;
7139 /* ICK: older versions of OpenSSH (e.g. 3.4p1)
7140 * provide an `int' for the signal, despite its
7141 * having been a `string' in the drafts of RFC 4254 since at
7142 * least 2001. (Fixed in session.c 1.147.) Try to
7143 * infer which we can safely parse it as. */
7145 unsigned char *p
= pktin
->body
+
7147 long len
= pktin
->length
- pktin
->savedpos
;
7148 unsigned long num
= GET_32BIT(p
); /* what is it? */
7149 /* If it's 0, it hardly matters; assume string */
7153 int maybe_int
= FALSE
, maybe_str
= FALSE
;
7154 #define CHECK_HYPOTHESIS(offset, result) \
7157 if (q >= 0 && q+4 <= len) { \
7158 q = q + 4 + GET_32BIT(p+q); \
7159 if (q >= 0 && q+4 <= len && \
7160 ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \
7164 CHECK_HYPOTHESIS(4+1, maybe_int
);
7165 CHECK_HYPOTHESIS(4+num
+1, maybe_str
);
7166 #undef CHECK_HYPOTHESIS
7167 if (maybe_int
&& !maybe_str
)
7169 else if (!maybe_int
&& maybe_str
)
7172 /* Crikey. Either or neither. Panic. */
7173 is_plausible
= FALSE
;
7176 ssh
->exitcode
= 128; /* means `unknown signal' */
7179 /* Old non-standard OpenSSH. */
7180 int signum
= ssh_pkt_getuint32(pktin
);
7181 fmt_sig
= dupprintf(" %d", signum
);
7182 ssh
->exitcode
= 128 + signum
;
7184 /* As per RFC 4254. */
7187 ssh_pkt_getstring(pktin
, &sig
, &siglen
);
7188 /* Signal name isn't supposed to be blank, but
7189 * let's cope gracefully if it is. */
7191 fmt_sig
= dupprintf(" \"%.*s\"",
7196 * Really hideous method of translating the
7197 * signal description back into a locally
7198 * meaningful number.
7203 #define TRANSLATE_SIGNAL(s) \
7204 else if (siglen == lenof(#s)-1 && !memcmp(sig, #s, siglen)) \
7205 ssh->exitcode = 128 + SIG ## s
7207 TRANSLATE_SIGNAL(ABRT
);
7210 TRANSLATE_SIGNAL(ALRM
);
7213 TRANSLATE_SIGNAL(FPE
);
7216 TRANSLATE_SIGNAL(HUP
);
7219 TRANSLATE_SIGNAL(ILL
);
7222 TRANSLATE_SIGNAL(INT
);
7225 TRANSLATE_SIGNAL(KILL
);
7228 TRANSLATE_SIGNAL(PIPE
);
7231 TRANSLATE_SIGNAL(QUIT
);
7234 TRANSLATE_SIGNAL(SEGV
);
7237 TRANSLATE_SIGNAL(TERM
);
7240 TRANSLATE_SIGNAL(USR1
);
7243 TRANSLATE_SIGNAL(USR2
);
7245 #undef TRANSLATE_SIGNAL
7247 ssh
->exitcode
= 128;
7249 core
= ssh2_pkt_getbool(pktin
);
7250 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
7252 fmt_msg
= dupprintf(" (\"%.*s\")", msglen
, msg
);
7254 /* ignore lang tag */
7255 } /* else don't attempt to parse */
7256 logeventf(ssh
, "Server exited on signal%s%s%s",
7257 fmt_sig
, core ?
" (core dumped)" : "",
7259 if (*fmt_sig
) sfree(fmt_sig
);
7260 if (*fmt_msg
) sfree(fmt_msg
);
7261 reply
= SSH2_MSG_CHANNEL_SUCCESS
;
7266 * This is a channel request we don't know
7267 * about, so we now either ignore the request
7268 * or respond with CHANNEL_FAILURE, depending
7271 reply
= SSH2_MSG_CHANNEL_FAILURE
;
7274 pktout
= ssh2_pkt_init(reply
);
7275 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
7276 ssh2_pkt_send(ssh
, pktout
);
7280 static void ssh2_msg_global_request(Ssh ssh
, struct Packet
*pktin
)
7283 int typelen
, want_reply
;
7284 struct Packet
*pktout
;
7286 ssh_pkt_getstring(pktin
, &type
, &typelen
);
7287 want_reply
= ssh2_pkt_getbool(pktin
);
7290 * We currently don't support any global requests
7291 * at all, so we either ignore the request or
7292 * respond with REQUEST_FAILURE, depending on
7296 pktout
= ssh2_pkt_init(SSH2_MSG_REQUEST_FAILURE
);
7297 ssh2_pkt_send(ssh
, pktout
);
7301 static void ssh2_msg_channel_open(Ssh ssh
, struct Packet
*pktin
)
7309 struct ssh_channel
*c
;
7310 unsigned remid
, winsize
, pktsize
;
7311 struct Packet
*pktout
;
7313 ssh_pkt_getstring(pktin
, &type
, &typelen
);
7314 c
= snew(struct ssh_channel
);
7317 remid
= ssh_pkt_getuint32(pktin
);
7318 winsize
= ssh_pkt_getuint32(pktin
);
7319 pktsize
= ssh_pkt_getuint32(pktin
);
7321 if (typelen
== 3 && !memcmp(type
, "x11", 3)) {
7325 ssh_pkt_getstring(pktin
, &peeraddr
, &peeraddrlen
);
7326 addrstr
= snewn(peeraddrlen
+1, char);
7327 memcpy(addrstr
, peeraddr
, peeraddrlen
);
7328 addrstr
[peeraddrlen
] = '\0';
7329 peerport
= ssh_pkt_getuint32(pktin
);
7331 logeventf(ssh
, "Received X11 connect request from %s:%d",
7334 if (!ssh
->X11_fwd_enabled
)
7335 error
= "X11 forwarding is not enabled";
7336 else if ((x11err
= x11_init(&c
->u
.x11
.s
, ssh
->x11disp
, c
,
7337 addrstr
, peerport
, ssh
->conf
)) != NULL
) {
7338 logeventf(ssh
, "Local X11 connection failed: %s", x11err
);
7339 error
= "Unable to open an X11 connection";
7341 logevent("Opening X11 forward connection succeeded");
7346 } else if (typelen
== 15 &&
7347 !memcmp(type
, "forwarded-tcpip", 15)) {
7348 struct ssh_rportfwd pf
, *realpf
;
7351 ssh_pkt_getstring(pktin
, &dummy
, &dummylen
);/* skip address */
7352 pf
.sport
= ssh_pkt_getuint32(pktin
);
7353 ssh_pkt_getstring(pktin
, &peeraddr
, &peeraddrlen
);
7354 peerport
= ssh_pkt_getuint32(pktin
);
7355 realpf
= find234(ssh
->rportfwds
, &pf
, NULL
);
7356 logeventf(ssh
, "Received remote port %d open request "
7357 "from %s:%d", pf
.sport
, peeraddr
, peerport
);
7358 if (realpf
== NULL
) {
7359 error
= "Remote port is not recognised";
7361 const char *e
= pfd_newconnect(&c
->u
.pfd
.s
,
7365 realpf
->pfrec
->addressfamily
);
7366 logeventf(ssh
, "Attempting to forward remote port to "
7367 "%s:%d", realpf
->dhost
, realpf
->dport
);
7369 logeventf(ssh
, "Port open failed: %s", e
);
7370 error
= "Port open failed";
7372 logevent("Forwarded port opened successfully");
7373 c
->type
= CHAN_SOCKDATA
;
7376 } else if (typelen
== 22 &&
7377 !memcmp(type
, "auth-agent@openssh.com", 22)) {
7378 if (!ssh
->agentfwd_enabled
)
7379 error
= "Agent forwarding is not enabled";
7381 c
->type
= CHAN_AGENT
; /* identify channel type */
7382 c
->u
.a
.lensofar
= 0;
7385 error
= "Unsupported channel type requested";
7388 c
->remoteid
= remid
;
7389 c
->halfopen
= FALSE
;
7391 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE
);
7392 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
7393 ssh2_pkt_adduint32(pktout
, SSH2_OPEN_CONNECT_FAILED
);
7394 ssh2_pkt_addstring(pktout
, error
);
7395 ssh2_pkt_addstring(pktout
, "en"); /* language tag */
7396 ssh2_pkt_send(ssh
, pktout
);
7397 logeventf(ssh
, "Rejected channel open: %s", error
);
7400 ssh2_channel_init(c
);
7401 c
->v
.v2
.remwindow
= winsize
;
7402 c
->v
.v2
.remmaxpkt
= pktsize
;
7403 add234(ssh
->channels
, c
);
7404 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
);
7405 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
7406 ssh2_pkt_adduint32(pktout
, c
->localid
);
7407 ssh2_pkt_adduint32(pktout
, c
->v
.v2
.locwindow
);
7408 ssh2_pkt_adduint32(pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
7409 ssh2_pkt_send(ssh
, pktout
);
7414 * Buffer banner messages for later display at some convenient point,
7415 * if we're going to display them.
7417 static void ssh2_msg_userauth_banner(Ssh ssh
, struct Packet
*pktin
)
7419 /* Arbitrary limit to prevent unbounded inflation of buffer */
7420 if (conf_get_int(ssh
->conf
, CONF_ssh_show_banner
) &&
7421 bufchain_size(&ssh
->banner
) <= 131072) {
7422 char *banner
= NULL
;
7424 ssh_pkt_getstring(pktin
, &banner
, &size
);
7426 bufchain_add(&ssh
->banner
, banner
, size
);
7430 /* Helper function to deal with sending tty modes for "pty-req" */
7431 static void ssh2_send_ttymode(void *data
, char *mode
, char *val
)
7433 struct Packet
*pktout
= (struct Packet
*)data
;
7435 unsigned int arg
= 0;
7436 while (strcmp(mode
, ssh_ttymodes
[i
].mode
) != 0) i
++;
7437 if (i
== lenof(ssh_ttymodes
)) return;
7438 switch (ssh_ttymodes
[i
].type
) {
7440 arg
= ssh_tty_parse_specchar(val
);
7443 arg
= ssh_tty_parse_boolean(val
);
7446 ssh2_pkt_addbyte(pktout
, ssh_ttymodes
[i
].opcode
);
7447 ssh2_pkt_adduint32(pktout
, arg
);
7451 * Handle the SSH-2 userauth and connection layers.
7453 static void ssh2_msg_authconn(Ssh ssh
, struct Packet
*pktin
)
7455 do_ssh2_authconn(ssh
, NULL
, 0, pktin
);
7458 static void do_ssh2_authconn(Ssh ssh
, unsigned char *in
, int inlen
,
7459 struct Packet
*pktin
)
7461 struct do_ssh2_authconn_state
{
7465 AUTH_TYPE_PUBLICKEY
,
7466 AUTH_TYPE_PUBLICKEY_OFFER_LOUD
,
7467 AUTH_TYPE_PUBLICKEY_OFFER_QUIET
,
7469 AUTH_TYPE_GSSAPI
, /* always QUIET */
7470 AUTH_TYPE_KEYBOARD_INTERACTIVE
,
7471 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
7473 int done_service_req
;
7474 int gotit
, need_pw
, can_pubkey
, can_passwd
, can_keyb_inter
;
7475 int tried_pubkey_config
, done_agent
;
7480 int kbd_inter_refused
;
7481 int we_are_in
, userauth_success
;
7482 prompts_t
*cur_prompt
;
7487 void *publickey_blob
;
7488 int publickey_bloblen
;
7489 int publickey_encrypted
;
7490 char *publickey_algorithm
;
7491 char *publickey_comment
;
7492 unsigned char agent_request
[5], *agent_response
, *agentp
;
7493 int agent_responselen
;
7494 unsigned char *pkblob_in_agent
;
7496 char *pkblob
, *alg
, *commentp
;
7497 int pklen
, alglen
, commentlen
;
7498 int siglen
, retlen
, len
;
7499 char *q
, *agentreq
, *ret
;
7502 int requested_agent
;
7504 int num_env
, env_left
, env_ok
;
7505 struct Packet
*pktout
;
7508 struct ssh_gss_library
*gsslib
;
7509 Ssh_gss_ctx gss_ctx
;
7510 Ssh_gss_buf gss_buf
;
7511 Ssh_gss_buf gss_rcvtok
, gss_sndtok
;
7512 Ssh_gss_name gss_srv_name
;
7513 Ssh_gss_stat gss_stat
;
7516 crState(do_ssh2_authconn_state
);
7520 /* Register as a handler for all the messages this coroutine handles. */
7521 ssh
->packet_dispatch
[SSH2_MSG_SERVICE_ACCEPT
] = ssh2_msg_authconn
;
7522 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_REQUEST
] = ssh2_msg_authconn
;
7523 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_FAILURE
] = ssh2_msg_authconn
;
7524 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_SUCCESS
] = ssh2_msg_authconn
;
7525 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] = ssh2_msg_authconn
;
7526 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_PK_OK
] = ssh2_msg_authconn
;
7527 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = ssh2_msg_authconn; duplicate case value */
7528 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = ssh2_msg_authconn; duplicate case value */
7529 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_INFO_RESPONSE
] = ssh2_msg_authconn
;
7530 ssh
->packet_dispatch
[SSH2_MSG_GLOBAL_REQUEST
] = ssh2_msg_authconn
;
7531 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_SUCCESS
] = ssh2_msg_authconn
;
7532 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_FAILURE
] = ssh2_msg_authconn
;
7533 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN
] = ssh2_msg_authconn
;
7534 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
] = ssh2_msg_authconn
;
7535 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_FAILURE
] = ssh2_msg_authconn
;
7536 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_WINDOW_ADJUST
] = ssh2_msg_authconn
;
7537 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_DATA
] = ssh2_msg_authconn
;
7538 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EXTENDED_DATA
] = ssh2_msg_authconn
;
7539 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EOF
] = ssh2_msg_authconn
;
7540 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_CLOSE
] = ssh2_msg_authconn
;
7541 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_REQUEST
] = ssh2_msg_authconn
;
7542 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_SUCCESS
] = ssh2_msg_authconn
;
7543 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
] = ssh2_msg_authconn
;
7545 s
->done_service_req
= FALSE
;
7546 s
->we_are_in
= s
->userauth_success
= FALSE
;
7548 s
->tried_gssapi
= FALSE
;
7551 if (!conf_get_int(ssh
->conf
, CONF_ssh_no_userauth
)) {
7553 * Request userauth protocol, and await a response to it.
7555 s
->pktout
= ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST
);
7556 ssh2_pkt_addstring(s
->pktout
, "ssh-userauth");
7557 ssh2_pkt_send(ssh
, s
->pktout
);
7558 crWaitUntilV(pktin
);
7559 if (pktin
->type
== SSH2_MSG_SERVICE_ACCEPT
)
7560 s
->done_service_req
= TRUE
;
7562 if (!s
->done_service_req
) {
7564 * Request connection protocol directly, without authentication.
7566 s
->pktout
= ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST
);
7567 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7568 ssh2_pkt_send(ssh
, s
->pktout
);
7569 crWaitUntilV(pktin
);
7570 if (pktin
->type
== SSH2_MSG_SERVICE_ACCEPT
) {
7571 s
->we_are_in
= TRUE
; /* no auth required */
7573 bombout(("Server refused service request"));
7578 /* Arrange to be able to deal with any BANNERs that come in.
7579 * (We do this now as packets may come in during the next bit.) */
7580 bufchain_init(&ssh
->banner
);
7581 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] =
7582 ssh2_msg_userauth_banner
;
7585 * Misc one-time setup for authentication.
7587 s
->publickey_blob
= NULL
;
7588 if (!s
->we_are_in
) {
7591 * Load the public half of any configured public key file
7594 s
->keyfile
= conf_get_filename(ssh
->conf
, CONF_keyfile
);
7595 if (!filename_is_null(s
->keyfile
)) {
7597 logeventf(ssh
, "Reading private key file \"%.150s\"",
7598 filename_to_str(s
->keyfile
));
7599 keytype
= key_type(s
->keyfile
);
7600 if (keytype
== SSH_KEYTYPE_SSH2
) {
7603 ssh2_userkey_loadpub(s
->keyfile
,
7604 &s
->publickey_algorithm
,
7605 &s
->publickey_bloblen
,
7606 &s
->publickey_comment
, &error
);
7607 if (s
->publickey_blob
) {
7608 s
->publickey_encrypted
=
7609 ssh2_userkey_encrypted(s
->keyfile
, NULL
);
7612 logeventf(ssh
, "Unable to load private key (%s)",
7614 msgbuf
= dupprintf("Unable to load private key file "
7615 "\"%.150s\" (%s)\r\n",
7616 filename_to_str(s
->keyfile
),
7618 c_write_str(ssh
, msgbuf
);
7623 logeventf(ssh
, "Unable to use this key file (%s)",
7624 key_type_to_str(keytype
));
7625 msgbuf
= dupprintf("Unable to use key file \"%.150s\""
7627 filename_to_str(s
->keyfile
),
7628 key_type_to_str(keytype
));
7629 c_write_str(ssh
, msgbuf
);
7631 s
->publickey_blob
= NULL
;
7636 * Find out about any keys Pageant has (but if there's a
7637 * public key configured, filter out all others).
7640 s
->agent_response
= NULL
;
7641 s
->pkblob_in_agent
= NULL
;
7642 if (conf_get_int(ssh
->conf
, CONF_tryagent
) && agent_exists()) {
7646 logevent("Pageant is running. Requesting keys.");
7648 /* Request the keys held by the agent. */
7649 PUT_32BIT(s
->agent_request
, 1);
7650 s
->agent_request
[4] = SSH2_AGENTC_REQUEST_IDENTITIES
;
7651 if (!agent_query(s
->agent_request
, 5, &r
, &s
->agent_responselen
,
7652 ssh_agent_callback
, ssh
)) {
7656 bombout(("Unexpected data from server while"
7657 " waiting for agent response"));
7660 } while (pktin
|| inlen
> 0);
7661 r
= ssh
->agent_response
;
7662 s
->agent_responselen
= ssh
->agent_response_len
;
7664 s
->agent_response
= (unsigned char *) r
;
7665 if (s
->agent_response
&& s
->agent_responselen
>= 5 &&
7666 s
->agent_response
[4] == SSH2_AGENT_IDENTITIES_ANSWER
) {
7669 p
= s
->agent_response
+ 5;
7670 s
->nkeys
= GET_32BIT(p
);
7672 logeventf(ssh
, "Pageant has %d SSH-2 keys", s
->nkeys
);
7673 if (s
->publickey_blob
) {
7674 /* See if configured key is in agent. */
7675 for (keyi
= 0; keyi
< s
->nkeys
; keyi
++) {
7676 s
->pklen
= GET_32BIT(p
);
7677 if (s
->pklen
== s
->publickey_bloblen
&&
7678 !memcmp(p
+4, s
->publickey_blob
,
7679 s
->publickey_bloblen
)) {
7680 logeventf(ssh
, "Pageant key #%d matches "
7681 "configured key file", keyi
);
7683 s
->pkblob_in_agent
= p
;
7687 p
+= GET_32BIT(p
) + 4; /* comment */
7689 if (!s
->pkblob_in_agent
) {
7690 logevent("Configured key file not in Pageant");
7695 logevent("Failed to get reply from Pageant");
7702 * We repeat this whole loop, including the username prompt,
7703 * until we manage a successful authentication. If the user
7704 * types the wrong _password_, they can be sent back to the
7705 * beginning to try another username, if this is configured on.
7706 * (If they specify a username in the config, they are never
7707 * asked, even if they do give a wrong password.)
7709 * I think this best serves the needs of
7711 * - the people who have no configuration, no keys, and just
7712 * want to try repeated (username,password) pairs until they
7713 * type both correctly
7715 * - people who have keys and configuration but occasionally
7716 * need to fall back to passwords
7718 * - people with a key held in Pageant, who might not have
7719 * logged in to a particular machine before; so they want to
7720 * type a username, and then _either_ their key will be
7721 * accepted, _or_ they will type a password. If they mistype
7722 * the username they will want to be able to get back and
7725 s
->got_username
= FALSE
;
7726 while (!s
->we_are_in
) {
7730 if (s
->got_username
&& !conf_get_int(ssh
->conf
, CONF_change_username
)) {
7732 * We got a username last time round this loop, and
7733 * with change_username turned off we don't try to get
7736 } else if ((ssh
->username
= get_remote_username(ssh
->conf
)) == NULL
) {
7737 int ret
; /* need not be kept over crReturn */
7738 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7739 s
->cur_prompt
->to_server
= TRUE
;
7740 s
->cur_prompt
->name
= dupstr("SSH login name");
7741 add_prompt(s
->cur_prompt
, dupstr("login as: "), TRUE
);
7742 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7745 crWaitUntilV(!pktin
);
7746 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
7751 * get_userpass_input() failed to get a username.
7754 free_prompts(s
->cur_prompt
);
7755 ssh_disconnect(ssh
, "No username provided", NULL
, 0, TRUE
);
7758 ssh
->username
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
7759 free_prompts(s
->cur_prompt
);
7762 if ((flags
& FLAG_VERBOSE
) || (flags
& FLAG_INTERACTIVE
)) {
7763 stuff
= dupprintf("Using username \"%s\".\r\n", ssh
->username
);
7764 c_write_str(ssh
, stuff
);
7768 s
->got_username
= TRUE
;
7771 * Send an authentication request using method "none": (a)
7772 * just in case it succeeds, and (b) so that we know what
7773 * authentication methods we can usefully try next.
7775 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
7777 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7778 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
7779 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");/* service requested */
7780 ssh2_pkt_addstring(s
->pktout
, "none"); /* method */
7781 ssh2_pkt_send(ssh
, s
->pktout
);
7782 s
->type
= AUTH_TYPE_NONE
;
7784 s
->we_are_in
= FALSE
;
7786 s
->tried_pubkey_config
= FALSE
;
7787 s
->kbd_inter_refused
= FALSE
;
7789 /* Reset agent request state. */
7790 s
->done_agent
= FALSE
;
7791 if (s
->agent_response
) {
7792 if (s
->pkblob_in_agent
) {
7793 s
->agentp
= s
->pkblob_in_agent
;
7795 s
->agentp
= s
->agent_response
+ 5 + 4;
7801 char *methods
= NULL
;
7805 * Wait for the result of the last authentication request.
7808 crWaitUntilV(pktin
);
7810 * Now is a convenient point to spew any banner material
7811 * that we've accumulated. (This should ensure that when
7812 * we exit the auth loop, we haven't any left to deal
7816 int size
= bufchain_size(&ssh
->banner
);
7818 * Don't show the banner if we're operating in
7819 * non-verbose non-interactive mode. (It's probably
7820 * a script, which means nobody will read the
7821 * banner _anyway_, and moreover the printing of
7822 * the banner will screw up processing on the
7823 * output of (say) plink.)
7825 if (size
&& (flags
& (FLAG_VERBOSE
| FLAG_INTERACTIVE
))) {
7826 char *banner
= snewn(size
, char);
7827 bufchain_fetch(&ssh
->banner
, banner
, size
);
7828 c_write_untrusted(ssh
, banner
, size
);
7831 bufchain_clear(&ssh
->banner
);
7833 if (pktin
->type
== SSH2_MSG_USERAUTH_SUCCESS
) {
7834 logevent("Access granted");
7835 s
->we_are_in
= s
->userauth_success
= TRUE
;
7839 if (pktin
->type
!= SSH2_MSG_USERAUTH_FAILURE
&& s
->type
!= AUTH_TYPE_GSSAPI
) {
7840 bombout(("Strange packet received during authentication: "
7841 "type %d", pktin
->type
));
7848 * OK, we're now sitting on a USERAUTH_FAILURE message, so
7849 * we can look at the string in it and know what we can
7850 * helpfully try next.
7852 if (pktin
->type
== SSH2_MSG_USERAUTH_FAILURE
) {
7853 ssh_pkt_getstring(pktin
, &methods
, &methlen
);
7854 if (!ssh2_pkt_getbool(pktin
)) {
7856 * We have received an unequivocal Access
7857 * Denied. This can translate to a variety of
7858 * messages, or no message at all.
7860 * For forms of authentication which are attempted
7861 * implicitly, by which I mean without printing
7862 * anything in the window indicating that we're
7863 * trying them, we should never print 'Access
7866 * If we do print a message saying that we're
7867 * attempting some kind of authentication, it's OK
7868 * to print a followup message saying it failed -
7869 * but the message may sometimes be more specific
7870 * than simply 'Access denied'.
7872 * Additionally, if we'd just tried password
7873 * authentication, we should break out of this
7874 * whole loop so as to go back to the username
7875 * prompt (iff we're configured to allow
7876 * username change attempts).
7878 if (s
->type
== AUTH_TYPE_NONE
) {
7880 } else if (s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_LOUD
||
7881 s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_QUIET
) {
7882 if (s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_LOUD
)
7883 c_write_str(ssh
, "Server refused our key\r\n");
7884 logevent("Server refused our key");
7885 } else if (s
->type
== AUTH_TYPE_PUBLICKEY
) {
7886 /* This _shouldn't_ happen except by a
7887 * protocol bug causing client and server to
7888 * disagree on what is a correct signature. */
7889 c_write_str(ssh
, "Server refused public-key signature"
7890 " despite accepting key!\r\n");
7891 logevent("Server refused public-key signature"
7892 " despite accepting key!");
7893 } else if (s
->type
==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
) {
7894 /* quiet, so no c_write */
7895 logevent("Server refused keyboard-interactive authentication");
7896 } else if (s
->type
==AUTH_TYPE_GSSAPI
) {
7897 /* always quiet, so no c_write */
7898 /* also, the code down in the GSSAPI block has
7899 * already logged this in the Event Log */
7900 } else if (s
->type
== AUTH_TYPE_KEYBOARD_INTERACTIVE
) {
7901 logevent("Keyboard-interactive authentication failed");
7902 c_write_str(ssh
, "Access denied\r\n");
7904 assert(s
->type
== AUTH_TYPE_PASSWORD
);
7905 logevent("Password authentication failed");
7906 c_write_str(ssh
, "Access denied\r\n");
7908 if (conf_get_int(ssh
->conf
, CONF_change_username
)) {
7909 /* XXX perhaps we should allow
7910 * keyboard-interactive to do this too? */
7911 s
->we_are_in
= FALSE
;
7916 c_write_str(ssh
, "Further authentication required\r\n");
7917 logevent("Further authentication required");
7921 in_commasep_string("publickey", methods
, methlen
);
7923 in_commasep_string("password", methods
, methlen
);
7924 s
->can_keyb_inter
= conf_get_int(ssh
->conf
, CONF_try_ki_auth
) &&
7925 in_commasep_string("keyboard-interactive", methods
, methlen
);
7928 ssh
->gsslibs
= ssh_gss_setup(ssh
->conf
);
7929 s
->can_gssapi
= conf_get_int(ssh
->conf
, CONF_try_gssapi_auth
) &&
7930 in_commasep_string("gssapi-with-mic", methods
, methlen
) &&
7931 ssh
->gsslibs
->nlibraries
> 0;
7935 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
7937 if (s
->can_pubkey
&& !s
->done_agent
&& s
->nkeys
) {
7940 * Attempt public-key authentication using a key from Pageant.
7943 ssh
->pkt_actx
= SSH2_PKTCTX_PUBLICKEY
;
7945 logeventf(ssh
, "Trying Pageant key #%d", s
->keyi
);
7947 /* Unpack key from agent response */
7948 s
->pklen
= GET_32BIT(s
->agentp
);
7950 s
->pkblob
= (char *)s
->agentp
;
7951 s
->agentp
+= s
->pklen
;
7952 s
->alglen
= GET_32BIT(s
->pkblob
);
7953 s
->alg
= s
->pkblob
+ 4;
7954 s
->commentlen
= GET_32BIT(s
->agentp
);
7956 s
->commentp
= (char *)s
->agentp
;
7957 s
->agentp
+= s
->commentlen
;
7958 /* s->agentp now points at next key, if any */
7960 /* See if server will accept it */
7961 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7962 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
7963 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7964 /* service requested */
7965 ssh2_pkt_addstring(s
->pktout
, "publickey");
7967 ssh2_pkt_addbool(s
->pktout
, FALSE
); /* no signature included */
7968 ssh2_pkt_addstring_start(s
->pktout
);
7969 ssh2_pkt_addstring_data(s
->pktout
, s
->alg
, s
->alglen
);
7970 ssh2_pkt_addstring_start(s
->pktout
);
7971 ssh2_pkt_addstring_data(s
->pktout
, s
->pkblob
, s
->pklen
);
7972 ssh2_pkt_send(ssh
, s
->pktout
);
7973 s
->type
= AUTH_TYPE_PUBLICKEY_OFFER_QUIET
;
7975 crWaitUntilV(pktin
);
7976 if (pktin
->type
!= SSH2_MSG_USERAUTH_PK_OK
) {
7978 /* Offer of key refused. */
7985 if (flags
& FLAG_VERBOSE
) {
7986 c_write_str(ssh
, "Authenticating with "
7988 c_write(ssh
, s
->commentp
, s
->commentlen
);
7989 c_write_str(ssh
, "\" from agent\r\n");
7993 * Server is willing to accept the key.
7994 * Construct a SIGN_REQUEST.
7996 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7997 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
7998 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7999 /* service requested */
8000 ssh2_pkt_addstring(s
->pktout
, "publickey");
8002 ssh2_pkt_addbool(s
->pktout
, TRUE
); /* signature included */
8003 ssh2_pkt_addstring_start(s
->pktout
);
8004 ssh2_pkt_addstring_data(s
->pktout
, s
->alg
, s
->alglen
);
8005 ssh2_pkt_addstring_start(s
->pktout
);
8006 ssh2_pkt_addstring_data(s
->pktout
, s
->pkblob
, s
->pklen
);
8008 /* Ask agent for signature. */
8009 s
->siglen
= s
->pktout
->length
- 5 + 4 +
8010 ssh
->v2_session_id_len
;
8011 if (ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)
8013 s
->len
= 1; /* message type */
8014 s
->len
+= 4 + s
->pklen
; /* key blob */
8015 s
->len
+= 4 + s
->siglen
; /* data to sign */
8016 s
->len
+= 4; /* flags */
8017 s
->agentreq
= snewn(4 + s
->len
, char);
8018 PUT_32BIT(s
->agentreq
, s
->len
);
8019 s
->q
= s
->agentreq
+ 4;
8020 *s
->q
++ = SSH2_AGENTC_SIGN_REQUEST
;
8021 PUT_32BIT(s
->q
, s
->pklen
);
8023 memcpy(s
->q
, s
->pkblob
, s
->pklen
);
8025 PUT_32BIT(s
->q
, s
->siglen
);
8027 /* Now the data to be signed... */
8028 if (!(ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)) {
8029 PUT_32BIT(s
->q
, ssh
->v2_session_id_len
);
8032 memcpy(s
->q
, ssh
->v2_session_id
,
8033 ssh
->v2_session_id_len
);
8034 s
->q
+= ssh
->v2_session_id_len
;
8035 memcpy(s
->q
, s
->pktout
->data
+ 5,
8036 s
->pktout
->length
- 5);
8037 s
->q
+= s
->pktout
->length
- 5;
8038 /* And finally the (zero) flags word. */
8040 if (!agent_query(s
->agentreq
, s
->len
+ 4,
8042 ssh_agent_callback
, ssh
)) {
8046 bombout(("Unexpected data from server"
8047 " while waiting for agent"
8051 } while (pktin
|| inlen
> 0);
8052 vret
= ssh
->agent_response
;
8053 s
->retlen
= ssh
->agent_response_len
;
8058 if (s
->ret
[4] == SSH2_AGENT_SIGN_RESPONSE
) {
8059 logevent("Sending Pageant's response");
8060 ssh2_add_sigblob(ssh
, s
->pktout
,
8061 s
->pkblob
, s
->pklen
,
8063 GET_32BIT(s
->ret
+ 5));
8064 ssh2_pkt_send(ssh
, s
->pktout
);
8065 s
->type
= AUTH_TYPE_PUBLICKEY
;
8067 /* FIXME: less drastic response */
8068 bombout(("Pageant failed to answer challenge"));
8074 /* Do we have any keys left to try? */
8075 if (s
->pkblob_in_agent
) {
8076 s
->done_agent
= TRUE
;
8077 s
->tried_pubkey_config
= TRUE
;
8080 if (s
->keyi
>= s
->nkeys
)
8081 s
->done_agent
= TRUE
;
8084 } else if (s
->can_pubkey
&& s
->publickey_blob
&&
8085 !s
->tried_pubkey_config
) {
8087 struct ssh2_userkey
*key
; /* not live over crReturn */
8088 char *passphrase
; /* not live over crReturn */
8090 ssh
->pkt_actx
= SSH2_PKTCTX_PUBLICKEY
;
8092 s
->tried_pubkey_config
= TRUE
;
8095 * Try the public key supplied in the configuration.
8097 * First, offer the public blob to see if the server is
8098 * willing to accept it.
8100 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8101 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8102 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8103 /* service requested */
8104 ssh2_pkt_addstring(s
->pktout
, "publickey"); /* method */
8105 ssh2_pkt_addbool(s
->pktout
, FALSE
);
8106 /* no signature included */
8107 ssh2_pkt_addstring(s
->pktout
, s
->publickey_algorithm
);
8108 ssh2_pkt_addstring_start(s
->pktout
);
8109 ssh2_pkt_addstring_data(s
->pktout
,
8110 (char *)s
->publickey_blob
,
8111 s
->publickey_bloblen
);
8112 ssh2_pkt_send(ssh
, s
->pktout
);
8113 logevent("Offered public key");
8115 crWaitUntilV(pktin
);
8116 if (pktin
->type
!= SSH2_MSG_USERAUTH_PK_OK
) {
8117 /* Key refused. Give up. */
8118 s
->gotit
= TRUE
; /* reconsider message next loop */
8119 s
->type
= AUTH_TYPE_PUBLICKEY_OFFER_LOUD
;
8120 continue; /* process this new message */
8122 logevent("Offer of public key accepted");
8125 * Actually attempt a serious authentication using
8128 if (flags
& FLAG_VERBOSE
) {
8129 c_write_str(ssh
, "Authenticating with public key \"");
8130 c_write_str(ssh
, s
->publickey_comment
);
8131 c_write_str(ssh
, "\"\r\n");
8135 const char *error
; /* not live over crReturn */
8136 if (s
->publickey_encrypted
) {
8138 * Get a passphrase from the user.
8140 int ret
; /* need not be kept over crReturn */
8141 s
->cur_prompt
= new_prompts(ssh
->frontend
);
8142 s
->cur_prompt
->to_server
= FALSE
;
8143 s
->cur_prompt
->name
= dupstr("SSH key passphrase");
8144 add_prompt(s
->cur_prompt
,
8145 dupprintf("Passphrase for key \"%.100s\": ",
8146 s
->publickey_comment
),
8148 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
8151 crWaitUntilV(!pktin
);
8152 ret
= get_userpass_input(s
->cur_prompt
,
8157 /* Failed to get a passphrase. Terminate. */
8158 free_prompts(s
->cur_prompt
);
8159 ssh_disconnect(ssh
, NULL
,
8160 "Unable to authenticate",
8161 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
8166 dupstr(s
->cur_prompt
->prompts
[0]->result
);
8167 free_prompts(s
->cur_prompt
);
8169 passphrase
= NULL
; /* no passphrase needed */
8173 * Try decrypting the key.
8175 s
->keyfile
= conf_get_filename(ssh
->conf
, CONF_keyfile
);
8176 key
= ssh2_load_userkey(s
->keyfile
, passphrase
, &error
);
8178 /* burn the evidence */
8179 smemclr(passphrase
, strlen(passphrase
));
8182 if (key
== SSH2_WRONG_PASSPHRASE
|| key
== NULL
) {
8184 (key
== SSH2_WRONG_PASSPHRASE
)) {
8185 c_write_str(ssh
, "Wrong passphrase\r\n");
8187 /* and loop again */
8189 c_write_str(ssh
, "Unable to load private key (");
8190 c_write_str(ssh
, error
);
8191 c_write_str(ssh
, ")\r\n");
8193 break; /* try something else */
8199 unsigned char *pkblob
, *sigblob
, *sigdata
;
8200 int pkblob_len
, sigblob_len
, sigdata_len
;
8204 * We have loaded the private key and the server
8205 * has announced that it's willing to accept it.
8206 * Hallelujah. Generate a signature and send it.
8208 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8209 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8210 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8211 /* service requested */
8212 ssh2_pkt_addstring(s
->pktout
, "publickey");
8214 ssh2_pkt_addbool(s
->pktout
, TRUE
);
8215 /* signature follows */
8216 ssh2_pkt_addstring(s
->pktout
, key
->alg
->name
);
8217 pkblob
= key
->alg
->public_blob(key
->data
,
8219 ssh2_pkt_addstring_start(s
->pktout
);
8220 ssh2_pkt_addstring_data(s
->pktout
, (char *)pkblob
,
8224 * The data to be signed is:
8228 * followed by everything so far placed in the
8231 sigdata_len
= s
->pktout
->length
- 5 + 4 +
8232 ssh
->v2_session_id_len
;
8233 if (ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)
8235 sigdata
= snewn(sigdata_len
, unsigned char);
8237 if (!(ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)) {
8238 PUT_32BIT(sigdata
+p
, ssh
->v2_session_id_len
);
8241 memcpy(sigdata
+p
, ssh
->v2_session_id
,
8242 ssh
->v2_session_id_len
);
8243 p
+= ssh
->v2_session_id_len
;
8244 memcpy(sigdata
+p
, s
->pktout
->data
+ 5,
8245 s
->pktout
->length
- 5);
8246 p
+= s
->pktout
->length
- 5;
8247 assert(p
== sigdata_len
);
8248 sigblob
= key
->alg
->sign(key
->data
, (char *)sigdata
,
8249 sigdata_len
, &sigblob_len
);
8250 ssh2_add_sigblob(ssh
, s
->pktout
, pkblob
, pkblob_len
,
8251 sigblob
, sigblob_len
);
8256 ssh2_pkt_send(ssh
, s
->pktout
);
8257 logevent("Sent public key signature");
8258 s
->type
= AUTH_TYPE_PUBLICKEY
;
8259 key
->alg
->freekey(key
->data
);
8263 } else if (s
->can_gssapi
&& !s
->tried_gssapi
) {
8265 /* GSSAPI Authentication */
8270 s
->type
= AUTH_TYPE_GSSAPI
;
8271 s
->tried_gssapi
= TRUE
;
8273 ssh
->pkt_actx
= SSH2_PKTCTX_GSSAPI
;
8276 * Pick the highest GSS library on the preference
8282 for (i
= 0; i
< ngsslibs
; i
++) {
8283 int want_id
= conf_get_int_int(ssh
->conf
,
8284 CONF_ssh_gsslist
, i
);
8285 for (j
= 0; j
< ssh
->gsslibs
->nlibraries
; j
++)
8286 if (ssh
->gsslibs
->libraries
[j
].id
== want_id
) {
8287 s
->gsslib
= &ssh
->gsslibs
->libraries
[j
];
8288 goto got_gsslib
; /* double break */
8293 * We always expect to have found something in
8294 * the above loop: we only came here if there
8295 * was at least one viable GSS library, and the
8296 * preference list should always mention
8297 * everything and only change the order.
8302 if (s
->gsslib
->gsslogmsg
)
8303 logevent(s
->gsslib
->gsslogmsg
);
8305 /* Sending USERAUTH_REQUEST with "gssapi-with-mic" method */
8306 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8307 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8308 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8309 ssh2_pkt_addstring(s
->pktout
, "gssapi-with-mic");
8310 logevent("Attempting GSSAPI authentication");
8312 /* add mechanism info */
8313 s
->gsslib
->indicate_mech(s
->gsslib
, &s
->gss_buf
);
8315 /* number of GSSAPI mechanisms */
8316 ssh2_pkt_adduint32(s
->pktout
,1);
8318 /* length of OID + 2 */
8319 ssh2_pkt_adduint32(s
->pktout
, s
->gss_buf
.length
+ 2);
8320 ssh2_pkt_addbyte(s
->pktout
, SSH2_GSS_OIDTYPE
);
8323 ssh2_pkt_addbyte(s
->pktout
, (unsigned char) s
->gss_buf
.length
);
8325 ssh_pkt_adddata(s
->pktout
, s
->gss_buf
.value
,
8327 ssh2_pkt_send(ssh
, s
->pktout
);
8328 crWaitUntilV(pktin
);
8329 if (pktin
->type
!= SSH2_MSG_USERAUTH_GSSAPI_RESPONSE
) {
8330 logevent("GSSAPI authentication request refused");
8334 /* check returned packet ... */
8336 ssh_pkt_getstring(pktin
, &data
, &len
);
8337 s
->gss_rcvtok
.value
= data
;
8338 s
->gss_rcvtok
.length
= len
;
8339 if (s
->gss_rcvtok
.length
!= s
->gss_buf
.length
+ 2 ||
8340 ((char *)s
->gss_rcvtok
.value
)[0] != SSH2_GSS_OIDTYPE
||
8341 ((char *)s
->gss_rcvtok
.value
)[1] != s
->gss_buf
.length
||
8342 memcmp((char *)s
->gss_rcvtok
.value
+ 2,
8343 s
->gss_buf
.value
,s
->gss_buf
.length
) ) {
8344 logevent("GSSAPI authentication - wrong response from server");
8348 /* now start running */
8349 s
->gss_stat
= s
->gsslib
->import_name(s
->gsslib
,
8352 if (s
->gss_stat
!= SSH_GSS_OK
) {
8353 if (s
->gss_stat
== SSH_GSS_BAD_HOST_NAME
)
8354 logevent("GSSAPI import name failed - Bad service name");
8356 logevent("GSSAPI import name failed");
8360 /* fetch TGT into GSS engine */
8361 s
->gss_stat
= s
->gsslib
->acquire_cred(s
->gsslib
, &s
->gss_ctx
);
8363 if (s
->gss_stat
!= SSH_GSS_OK
) {
8364 logevent("GSSAPI authentication failed to get credentials");
8365 s
->gsslib
->release_name(s
->gsslib
, &s
->gss_srv_name
);
8369 /* initial tokens are empty */
8370 SSH_GSS_CLEAR_BUF(&s
->gss_rcvtok
);
8371 SSH_GSS_CLEAR_BUF(&s
->gss_sndtok
);
8373 /* now enter the loop */
8375 s
->gss_stat
= s
->gsslib
->init_sec_context
8379 conf_get_int(ssh
->conf
, CONF_gssapifwd
),
8383 if (s
->gss_stat
!=SSH_GSS_S_COMPLETE
&&
8384 s
->gss_stat
!=SSH_GSS_S_CONTINUE_NEEDED
) {
8385 logevent("GSSAPI authentication initialisation failed");
8387 if (s
->gsslib
->display_status(s
->gsslib
, s
->gss_ctx
,
8388 &s
->gss_buf
) == SSH_GSS_OK
) {
8389 logevent(s
->gss_buf
.value
);
8390 sfree(s
->gss_buf
.value
);
8395 logevent("GSSAPI authentication initialised");
8397 /* Client and server now exchange tokens until GSSAPI
8398 * no longer says CONTINUE_NEEDED */
8400 if (s
->gss_sndtok
.length
!= 0) {
8401 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_TOKEN
);
8402 ssh_pkt_addstring_start(s
->pktout
);
8403 ssh_pkt_addstring_data(s
->pktout
,s
->gss_sndtok
.value
,s
->gss_sndtok
.length
);
8404 ssh2_pkt_send(ssh
, s
->pktout
);
8405 s
->gsslib
->free_tok(s
->gsslib
, &s
->gss_sndtok
);
8408 if (s
->gss_stat
== SSH_GSS_S_CONTINUE_NEEDED
) {
8409 crWaitUntilV(pktin
);
8410 if (pktin
->type
!= SSH2_MSG_USERAUTH_GSSAPI_TOKEN
) {
8411 logevent("GSSAPI authentication - bad server response");
8412 s
->gss_stat
= SSH_GSS_FAILURE
;
8415 ssh_pkt_getstring(pktin
, &data
, &len
);
8416 s
->gss_rcvtok
.value
= data
;
8417 s
->gss_rcvtok
.length
= len
;
8419 } while (s
-> gss_stat
== SSH_GSS_S_CONTINUE_NEEDED
);
8421 if (s
->gss_stat
!= SSH_GSS_OK
) {
8422 s
->gsslib
->release_name(s
->gsslib
, &s
->gss_srv_name
);
8423 s
->gsslib
->release_cred(s
->gsslib
, &s
->gss_ctx
);
8426 logevent("GSSAPI authentication loop finished OK");
8428 /* Now send the MIC */
8430 s
->pktout
= ssh2_pkt_init(0);
8431 micoffset
= s
->pktout
->length
;
8432 ssh_pkt_addstring_start(s
->pktout
);
8433 ssh_pkt_addstring_data(s
->pktout
, (char *)ssh
->v2_session_id
, ssh
->v2_session_id_len
);
8434 ssh_pkt_addbyte(s
->pktout
, SSH2_MSG_USERAUTH_REQUEST
);
8435 ssh_pkt_addstring(s
->pktout
, ssh
->username
);
8436 ssh_pkt_addstring(s
->pktout
, "ssh-connection");
8437 ssh_pkt_addstring(s
->pktout
, "gssapi-with-mic");
8439 s
->gss_buf
.value
= (char *)s
->pktout
->data
+ micoffset
;
8440 s
->gss_buf
.length
= s
->pktout
->length
- micoffset
;
8442 s
->gsslib
->get_mic(s
->gsslib
, s
->gss_ctx
, &s
->gss_buf
, &mic
);
8443 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_GSSAPI_MIC
);
8444 ssh_pkt_addstring_start(s
->pktout
);
8445 ssh_pkt_addstring_data(s
->pktout
, mic
.value
, mic
.length
);
8446 ssh2_pkt_send(ssh
, s
->pktout
);
8447 s
->gsslib
->free_mic(s
->gsslib
, &mic
);
8451 s
->gsslib
->release_name(s
->gsslib
, &s
->gss_srv_name
);
8452 s
->gsslib
->release_cred(s
->gsslib
, &s
->gss_ctx
);
8455 } else if (s
->can_keyb_inter
&& !s
->kbd_inter_refused
) {
8458 * Keyboard-interactive authentication.
8461 s
->type
= AUTH_TYPE_KEYBOARD_INTERACTIVE
;
8463 ssh
->pkt_actx
= SSH2_PKTCTX_KBDINTER
;
8465 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8466 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8467 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8468 /* service requested */
8469 ssh2_pkt_addstring(s
->pktout
, "keyboard-interactive");
8471 ssh2_pkt_addstring(s
->pktout
, ""); /* lang */
8472 ssh2_pkt_addstring(s
->pktout
, ""); /* submethods */
8473 ssh2_pkt_send(ssh
, s
->pktout
);
8475 logevent("Attempting keyboard-interactive authentication");
8477 crWaitUntilV(pktin
);
8478 if (pktin
->type
!= SSH2_MSG_USERAUTH_INFO_REQUEST
) {
8479 /* Server is not willing to do keyboard-interactive
8480 * at all (or, bizarrely but legally, accepts the
8481 * user without actually issuing any prompts).
8482 * Give up on it entirely. */
8484 s
->type
= AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
;
8485 s
->kbd_inter_refused
= TRUE
; /* don't try it again */
8490 * Loop while the server continues to send INFO_REQUESTs.
8492 while (pktin
->type
== SSH2_MSG_USERAUTH_INFO_REQUEST
) {
8494 char *name
, *inst
, *lang
;
8495 int name_len
, inst_len
, lang_len
;
8499 * We've got a fresh USERAUTH_INFO_REQUEST.
8500 * Get the preamble and start building a prompt.
8502 ssh_pkt_getstring(pktin
, &name
, &name_len
);
8503 ssh_pkt_getstring(pktin
, &inst
, &inst_len
);
8504 ssh_pkt_getstring(pktin
, &lang
, &lang_len
);
8505 s
->cur_prompt
= new_prompts(ssh
->frontend
);
8506 s
->cur_prompt
->to_server
= TRUE
;
8509 * Get any prompt(s) from the packet.
8511 s
->num_prompts
= ssh_pkt_getuint32(pktin
);
8512 for (i
= 0; i
< s
->num_prompts
; i
++) {
8516 static char noprompt
[] =
8517 "<server failed to send prompt>: ";
8519 ssh_pkt_getstring(pktin
, &prompt
, &prompt_len
);
8520 echo
= ssh2_pkt_getbool(pktin
);
8523 prompt_len
= lenof(noprompt
)-1;
8525 add_prompt(s
->cur_prompt
,
8526 dupprintf("%.*s", prompt_len
, prompt
),
8531 /* FIXME: better prefix to distinguish from
8533 s
->cur_prompt
->name
=
8534 dupprintf("SSH server: %.*s", name_len
, name
);
8535 s
->cur_prompt
->name_reqd
= TRUE
;
8537 s
->cur_prompt
->name
=
8538 dupstr("SSH server authentication");
8539 s
->cur_prompt
->name_reqd
= FALSE
;
8541 /* We add a prefix to try to make it clear that a prompt
8542 * has come from the server.
8543 * FIXME: ugly to print "Using..." in prompt _every_
8544 * time round. Can this be done more subtly? */
8545 /* Special case: for reasons best known to themselves,
8546 * some servers send k-i requests with no prompts and
8547 * nothing to display. Keep quiet in this case. */
8548 if (s
->num_prompts
|| name_len
|| inst_len
) {
8549 s
->cur_prompt
->instruction
=
8550 dupprintf("Using keyboard-interactive authentication.%s%.*s",
8551 inst_len ?
"\n" : "", inst_len
, inst
);
8552 s
->cur_prompt
->instr_reqd
= TRUE
;
8554 s
->cur_prompt
->instr_reqd
= FALSE
;
8558 * Display any instructions, and get the user's
8562 int ret
; /* not live over crReturn */
8563 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
8566 crWaitUntilV(!pktin
);
8567 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
8572 * Failed to get responses. Terminate.
8574 free_prompts(s
->cur_prompt
);
8575 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
8576 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
8583 * Send the response(s) to the server.
8585 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE
);
8586 ssh2_pkt_adduint32(s
->pktout
, s
->num_prompts
);
8587 for (i
=0; i
< s
->num_prompts
; i
++) {
8588 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
8589 ssh2_pkt_addstring(s
->pktout
,
8590 s
->cur_prompt
->prompts
[i
]->result
);
8591 end_log_omission(ssh
, s
->pktout
);
8593 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
8596 * Free the prompts structure from this iteration.
8597 * If there's another, a new one will be allocated
8598 * when we return to the top of this while loop.
8600 free_prompts(s
->cur_prompt
);
8603 * Get the next packet in case it's another
8606 crWaitUntilV(pktin
);
8611 * We should have SUCCESS or FAILURE now.
8615 } else if (s
->can_passwd
) {
8618 * Plain old password authentication.
8620 int ret
; /* not live over crReturn */
8621 int changereq_first_time
; /* not live over crReturn */
8623 ssh
->pkt_actx
= SSH2_PKTCTX_PASSWORD
;
8625 s
->cur_prompt
= new_prompts(ssh
->frontend
);
8626 s
->cur_prompt
->to_server
= TRUE
;
8627 s
->cur_prompt
->name
= dupstr("SSH password");
8628 add_prompt(s
->cur_prompt
, dupprintf("%s@%s's password: ",
8633 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
8636 crWaitUntilV(!pktin
);
8637 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
8642 * Failed to get responses. Terminate.
8644 free_prompts(s
->cur_prompt
);
8645 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
8646 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
8651 * Squirrel away the password. (We may need it later if
8652 * asked to change it.)
8654 s
->password
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
8655 free_prompts(s
->cur_prompt
);
8658 * Send the password packet.
8660 * We pad out the password packet to 256 bytes to make
8661 * it harder for an attacker to find the length of the
8664 * Anyone using a password longer than 256 bytes
8665 * probably doesn't have much to worry about from
8666 * people who find out how long their password is!
8668 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8669 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8670 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8671 /* service requested */
8672 ssh2_pkt_addstring(s
->pktout
, "password");
8673 ssh2_pkt_addbool(s
->pktout
, FALSE
);
8674 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
8675 ssh2_pkt_addstring(s
->pktout
, s
->password
);
8676 end_log_omission(ssh
, s
->pktout
);
8677 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
8678 logevent("Sent password");
8679 s
->type
= AUTH_TYPE_PASSWORD
;
8682 * Wait for next packet, in case it's a password change
8685 crWaitUntilV(pktin
);
8686 changereq_first_time
= TRUE
;
8688 while (pktin
->type
== SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ
) {
8691 * We're being asked for a new password
8692 * (perhaps not for the first time).
8693 * Loop until the server accepts it.
8696 int got_new
= FALSE
; /* not live over crReturn */
8697 char *prompt
; /* not live over crReturn */
8698 int prompt_len
; /* not live over crReturn */
8702 if (changereq_first_time
)
8703 msg
= "Server requested password change";
8705 msg
= "Server rejected new password";
8707 c_write_str(ssh
, msg
);
8708 c_write_str(ssh
, "\r\n");
8711 ssh_pkt_getstring(pktin
, &prompt
, &prompt_len
);
8713 s
->cur_prompt
= new_prompts(ssh
->frontend
);
8714 s
->cur_prompt
->to_server
= TRUE
;
8715 s
->cur_prompt
->name
= dupstr("New SSH password");
8716 s
->cur_prompt
->instruction
=
8717 dupprintf("%.*s", prompt_len
, prompt
);
8718 s
->cur_prompt
->instr_reqd
= TRUE
;
8720 * There's no explicit requirement in the protocol
8721 * for the "old" passwords in the original and
8722 * password-change messages to be the same, and
8723 * apparently some Cisco kit supports password change
8724 * by the user entering a blank password originally
8725 * and the real password subsequently, so,
8726 * reluctantly, we prompt for the old password again.
8728 * (On the other hand, some servers don't even bother
8729 * to check this field.)
8731 add_prompt(s
->cur_prompt
,
8732 dupstr("Current password (blank for previously entered password): "),
8734 add_prompt(s
->cur_prompt
, dupstr("Enter new password: "),
8736 add_prompt(s
->cur_prompt
, dupstr("Confirm new password: "),
8740 * Loop until the user manages to enter the same
8745 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
8748 crWaitUntilV(!pktin
);
8749 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
8754 * Failed to get responses. Terminate.
8756 /* burn the evidence */
8757 free_prompts(s
->cur_prompt
);
8758 smemclr(s
->password
, strlen(s
->password
));
8760 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
8761 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
8767 * If the user specified a new original password
8768 * (IYSWIM), overwrite any previously specified
8770 * (A side effect is that the user doesn't have to
8771 * re-enter it if they louse up the new password.)
8773 if (s
->cur_prompt
->prompts
[0]->result
[0]) {
8774 smemclr(s
->password
, strlen(s
->password
));
8775 /* burn the evidence */
8778 dupstr(s
->cur_prompt
->prompts
[0]->result
);
8782 * Check the two new passwords match.
8784 got_new
= (strcmp(s
->cur_prompt
->prompts
[1]->result
,
8785 s
->cur_prompt
->prompts
[2]->result
)
8788 /* They don't. Silly user. */
8789 c_write_str(ssh
, "Passwords do not match\r\n");
8794 * Send the new password (along with the old one).
8795 * (see above for padding rationale)
8797 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
8798 ssh2_pkt_addstring(s
->pktout
, ssh
->username
);
8799 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
8800 /* service requested */
8801 ssh2_pkt_addstring(s
->pktout
, "password");
8802 ssh2_pkt_addbool(s
->pktout
, TRUE
);
8803 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
8804 ssh2_pkt_addstring(s
->pktout
, s
->password
);
8805 ssh2_pkt_addstring(s
->pktout
,
8806 s
->cur_prompt
->prompts
[1]->result
);
8807 free_prompts(s
->cur_prompt
);
8808 end_log_omission(ssh
, s
->pktout
);
8809 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
8810 logevent("Sent new password");
8813 * Now see what the server has to say about it.
8814 * (If it's CHANGEREQ again, it's not happy with the
8817 crWaitUntilV(pktin
);
8818 changereq_first_time
= FALSE
;
8823 * We need to reexamine the current pktin at the top
8824 * of the loop. Either:
8825 * - we weren't asked to change password at all, in
8826 * which case it's a SUCCESS or FAILURE with the
8828 * - we sent a new password, and the server was
8829 * either OK with it (SUCCESS or FAILURE w/partial
8830 * success) or unhappy with the _old_ password
8831 * (FAILURE w/o partial success)
8832 * In any of these cases, we go back to the top of
8833 * the loop and start again.
8838 * We don't need the old password any more, in any
8839 * case. Burn the evidence.
8841 smemclr(s
->password
, strlen(s
->password
));
8845 char *str
= dupprintf("No supported authentication methods available"
8846 " (server sent: %.*s)",
8849 ssh_disconnect(ssh
, str
,
8850 "No supported authentication methods available",
8851 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE
,
8861 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] = NULL
;
8863 /* Clear up various bits and pieces from authentication. */
8864 if (s
->publickey_blob
) {
8865 sfree(s
->publickey_blob
);
8866 sfree(s
->publickey_comment
);
8868 if (s
->agent_response
)
8869 sfree(s
->agent_response
);
8871 if (s
->userauth_success
) {
8873 * We've just received USERAUTH_SUCCESS, and we haven't sent any
8874 * packets since. Signal the transport layer to consider enacting
8875 * delayed compression.
8877 * (Relying on we_are_in is not sufficient, as
8878 * draft-miller-secsh-compression-delayed is quite clear that it
8879 * triggers on USERAUTH_SUCCESS specifically, and we_are_in can
8880 * become set for other reasons.)
8882 do_ssh2_transport(ssh
, "enabling delayed compression", -2, NULL
);
8886 * Now the connection protocol has started, one way or another.
8889 ssh
->channels
= newtree234(ssh_channelcmp
);
8892 * Set up handlers for some connection protocol messages, so we
8893 * don't have to handle them repeatedly in this coroutine.
8895 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_WINDOW_ADJUST
] =
8896 ssh2_msg_channel_window_adjust
;
8897 ssh
->packet_dispatch
[SSH2_MSG_GLOBAL_REQUEST
] =
8898 ssh2_msg_global_request
;
8901 * Create the main session channel.
8903 if (conf_get_int(ssh
->conf
, CONF_ssh_no_shell
)) {
8904 ssh
->mainchan
= NULL
;
8905 } else if (*conf_get_str(ssh
->conf
, CONF_ssh_nc_host
)) {
8907 * Just start a direct-tcpip channel and use it as the main
8910 ssh
->mainchan
= snew(struct ssh_channel
);
8911 ssh
->mainchan
->ssh
= ssh
;
8912 ssh2_channel_init(ssh
->mainchan
);
8914 "Opening direct-tcpip channel to %s:%d in place of session",
8915 conf_get_str(ssh
->conf
, CONF_ssh_nc_host
),
8916 conf_get_int(ssh
->conf
, CONF_ssh_nc_port
));
8917 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
8918 ssh2_pkt_addstring(s
->pktout
, "direct-tcpip");
8919 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->localid
);
8920 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->v
.v2
.locwindow
);/* our window size */
8921 ssh2_pkt_adduint32(s
->pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
8922 ssh2_pkt_addstring(s
->pktout
, conf_get_str(ssh
->conf
, CONF_ssh_nc_host
));
8923 ssh2_pkt_adduint32(s
->pktout
, conf_get_int(ssh
->conf
, CONF_ssh_nc_port
));
8925 * There's nothing meaningful to put in the originator
8926 * fields, but some servers insist on syntactically correct
8929 ssh2_pkt_addstring(s
->pktout
, "0.0.0.0");
8930 ssh2_pkt_adduint32(s
->pktout
, 0);
8931 ssh2_pkt_send(ssh
, s
->pktout
);
8933 crWaitUntilV(pktin
);
8934 if (pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
) {
8935 bombout(("Server refused to open a direct-tcpip channel"));
8937 /* FIXME: error data comes back in FAILURE packet */
8939 if (ssh_pkt_getuint32(pktin
) != ssh
->mainchan
->localid
) {
8940 bombout(("Server's channel confirmation cited wrong channel"));
8943 ssh
->mainchan
->remoteid
= ssh_pkt_getuint32(pktin
);
8944 ssh
->mainchan
->halfopen
= FALSE
;
8945 ssh
->mainchan
->type
= CHAN_MAINSESSION
;
8946 ssh
->mainchan
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
8947 ssh
->mainchan
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
8948 add234(ssh
->channels
, ssh
->mainchan
);
8949 update_specials_menu(ssh
->frontend
);
8950 logevent("Opened direct-tcpip channel");
8953 ssh
->mainchan
= snew(struct ssh_channel
);
8954 ssh
->mainchan
->ssh
= ssh
;
8955 ssh2_channel_init(ssh
->mainchan
);
8956 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
8957 ssh2_pkt_addstring(s
->pktout
, "session");
8958 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->localid
);
8959 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->v
.v2
.locwindow
);/* our window size */
8960 ssh2_pkt_adduint32(s
->pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
8961 ssh2_pkt_send(ssh
, s
->pktout
);
8962 crWaitUntilV(pktin
);
8963 if (pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
) {
8964 bombout(("Server refused to open a session"));
8966 /* FIXME: error data comes back in FAILURE packet */
8968 if (ssh_pkt_getuint32(pktin
) != ssh
->mainchan
->localid
) {
8969 bombout(("Server's channel confirmation cited wrong channel"));
8972 ssh
->mainchan
->remoteid
= ssh_pkt_getuint32(pktin
);
8973 ssh
->mainchan
->halfopen
= FALSE
;
8974 ssh
->mainchan
->type
= CHAN_MAINSESSION
;
8975 ssh
->mainchan
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
8976 ssh
->mainchan
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
8977 add234(ssh
->channels
, ssh
->mainchan
);
8978 update_specials_menu(ssh
->frontend
);
8979 logevent("Opened channel for session");
8980 ssh
->ncmode
= FALSE
;
8984 * Now we have a channel, make dispatch table entries for
8985 * general channel-based messages.
8987 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_DATA
] =
8988 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EXTENDED_DATA
] =
8989 ssh2_msg_channel_data
;
8990 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EOF
] = ssh2_msg_channel_eof
;
8991 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_CLOSE
] = ssh2_msg_channel_close
;
8992 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
] =
8993 ssh2_msg_channel_open_confirmation
;
8994 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_FAILURE
] =
8995 ssh2_msg_channel_open_failure
;
8996 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_REQUEST
] =
8997 ssh2_msg_channel_request
;
8998 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN
] =
8999 ssh2_msg_channel_open
;
9001 if (ssh
->mainchan
&& conf_get_int(ssh
->conf
, CONF_ssh_simple
)) {
9003 * This message indicates to the server that we promise
9004 * not to try to run any other channel in parallel with
9005 * this one, so it's safe for it to advertise a very large
9006 * window and leave the flow control to TCP.
9008 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9009 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
9010 ssh2_pkt_addstring(s
->pktout
, "simple@putty.projects.tartarus.org");
9011 ssh2_pkt_addbool(s
->pktout
, 0); /* no reply */
9012 ssh2_pkt_send(ssh
, s
->pktout
);
9016 * Enable port forwardings.
9018 ssh_setup_portfwd(ssh
, ssh
->conf
);
9021 * Send the CHANNEL_REQUESTS for the main channel. We send them all
9022 * and then start looking for responses, so it's important that the
9023 * sending and receiving code below it is kept in sync.
9027 * Potentially enable X11 forwarding.
9029 if (ssh
->mainchan
&& !ssh
->ncmode
&& conf_get_int(ssh
->conf
, CONF_x11_forward
) &&
9030 (ssh
->x11disp
= x11_setup_display(conf_get_str(ssh
->conf
, CONF_x11_display
),
9031 conf_get_int(ssh
->conf
, CONF_x11_auth
), ssh
->conf
))) {
9032 logevent("Requesting X11 forwarding");
9033 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9034 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
9035 ssh2_pkt_addstring(s
->pktout
, "x11-req");
9036 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9037 ssh2_pkt_addbool(s
->pktout
, 0); /* many connections */
9038 ssh2_pkt_addstring(s
->pktout
, ssh
->x11disp
->remoteauthprotoname
);
9040 * Note that while we blank the X authentication data here, we don't
9041 * take any special action to blank the start of an X11 channel,
9042 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
9043 * without having session blanking enabled is likely to leak your
9044 * cookie into the log.
9046 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
9047 ssh2_pkt_addstring(s
->pktout
, ssh
->x11disp
->remoteauthdatastring
);
9048 end_log_omission(ssh
, s
->pktout
);
9049 ssh2_pkt_adduint32(s
->pktout
, ssh
->x11disp
->screennum
);
9050 ssh2_pkt_send(ssh
, s
->pktout
);
9051 s
->requested_x11
= TRUE
;
9053 s
->requested_x11
= FALSE
;
9056 * Potentially enable agent forwarding.
9058 if (ssh
->mainchan
&& !ssh
->ncmode
&& conf_get_int(ssh
->conf
, CONF_agentfwd
) && agent_exists()) {
9059 logevent("Requesting OpenSSH-style agent forwarding");
9060 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9061 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
9062 ssh2_pkt_addstring(s
->pktout
, "auth-agent-req@openssh.com");
9063 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9064 ssh2_pkt_send(ssh
, s
->pktout
);
9065 s
->requested_agent
= TRUE
;
9067 s
->requested_agent
= FALSE
;
9070 * Now allocate a pty for the session.
9072 if (ssh
->mainchan
&& !ssh
->ncmode
&& !conf_get_int(ssh
->conf
, CONF_nopty
)) {
9073 /* Unpick the terminal-speed string. */
9074 /* XXX perhaps we should allow no speeds to be sent. */
9075 ssh
->ospeed
= 38400; ssh
->ispeed
= 38400; /* last-resort defaults */
9076 sscanf(conf_get_str(ssh
->conf
, CONF_termspeed
), "%d,%d", &ssh
->ospeed
, &ssh
->ispeed
);
9077 /* Build the pty request. */
9078 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9079 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
); /* recipient channel */
9080 ssh2_pkt_addstring(s
->pktout
, "pty-req");
9081 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9082 ssh2_pkt_addstring(s
->pktout
, conf_get_str(ssh
->conf
, CONF_termtype
));
9083 ssh2_pkt_adduint32(s
->pktout
, ssh
->term_width
);
9084 ssh2_pkt_adduint32(s
->pktout
, ssh
->term_height
);
9085 ssh2_pkt_adduint32(s
->pktout
, 0); /* pixel width */
9086 ssh2_pkt_adduint32(s
->pktout
, 0); /* pixel height */
9087 ssh2_pkt_addstring_start(s
->pktout
);
9088 parse_ttymodes(ssh
, ssh2_send_ttymode
, (void *)s
->pktout
);
9089 ssh2_pkt_addbyte(s
->pktout
, SSH2_TTY_OP_ISPEED
);
9090 ssh2_pkt_adduint32(s
->pktout
, ssh
->ispeed
);
9091 ssh2_pkt_addbyte(s
->pktout
, SSH2_TTY_OP_OSPEED
);
9092 ssh2_pkt_adduint32(s
->pktout
, ssh
->ospeed
);
9093 ssh2_pkt_addstring_data(s
->pktout
, "\0", 1); /* TTY_OP_END */
9094 ssh2_pkt_send(ssh
, s
->pktout
);
9095 ssh
->state
= SSH_STATE_INTERMED
;
9096 s
->requested_tty
= TRUE
;
9098 s
->requested_tty
= FALSE
;
9101 * Send environment variables.
9103 * Simplest thing here is to send all the requests at once, and
9104 * then wait for a whole bunch of successes or failures.
9107 if (ssh
->mainchan
&& !ssh
->ncmode
) {
9110 for (val
= conf_get_str_strs(ssh
->conf
, CONF_environmt
, NULL
, &key
);
9112 val
= conf_get_str_strs(ssh
->conf
, CONF_environmt
, key
, &key
)) {
9113 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9114 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
9115 ssh2_pkt_addstring(s
->pktout
, "env");
9116 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9117 ssh2_pkt_addstring(s
->pktout
, key
);
9118 ssh2_pkt_addstring(s
->pktout
, val
);
9119 ssh2_pkt_send(ssh
, s
->pktout
);
9124 logeventf(ssh
, "Sent %d environment variables", s
->num_env
);
9128 * All CHANNEL_REQUESTs sent. Now collect up the replies. These
9129 * must be in precisely the same order as the requests.
9132 if (s
->requested_x11
) {
9133 crWaitUntilV(pktin
);
9135 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
9136 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
9137 bombout(("Unexpected response to X11 forwarding request:"
9138 " packet type %d", pktin
->type
));
9141 logevent("X11 forwarding refused");
9143 logevent("X11 forwarding enabled");
9144 ssh
->X11_fwd_enabled
= TRUE
;
9148 if (s
->requested_agent
) {
9149 crWaitUntilV(pktin
);
9151 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
9152 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
9153 bombout(("Unexpected response to agent forwarding request:"
9154 " packet type %d", pktin
->type
));
9157 logevent("Agent forwarding refused");
9159 logevent("Agent forwarding enabled");
9160 ssh
->agentfwd_enabled
= TRUE
;
9164 if (s
->requested_tty
) {
9165 crWaitUntilV(pktin
);
9167 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
9168 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
9169 bombout(("Unexpected response to pty request:"
9170 " packet type %d", pktin
->type
));
9173 c_write_str(ssh
, "Server refused to allocate pty\r\n");
9174 ssh
->editing
= ssh
->echoing
= 1;
9176 logeventf(ssh
, "Allocated pty (ospeed %dbps, ispeed %dbps)",
9177 ssh
->ospeed
, ssh
->ispeed
);
9178 ssh
->got_pty
= TRUE
;
9181 ssh
->editing
= ssh
->echoing
= 1;
9186 s
->env_left
= s
->num_env
;
9188 while (s
->env_left
> 0) {
9189 crWaitUntilV(pktin
);
9191 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
9192 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
9193 bombout(("Unexpected response to environment request:"
9194 " packet type %d", pktin
->type
));
9204 if (s
->env_ok
== s
->num_env
) {
9205 logevent("All environment variables successfully set");
9206 } else if (s
->env_ok
== 0) {
9207 logevent("All environment variables refused");
9208 c_write_str(ssh
, "Server refused to set environment variables\r\n");
9210 logeventf(ssh
, "%d environment variables refused",
9211 s
->num_env
- s
->env_ok
);
9212 c_write_str(ssh
, "Server refused to set all environment variables\r\n");
9217 * Start a shell or a remote command. We may have to attempt
9218 * this twice if the config data has provided a second choice
9221 if (ssh
->mainchan
&& !ssh
->ncmode
) while (1) {
9225 if (ssh
->fallback_cmd
) {
9226 subsys
= conf_get_int(ssh
->conf
, CONF_ssh_subsys2
);
9227 cmd
= conf_get_str(ssh
->conf
, CONF_remote_cmd2
);
9229 subsys
= conf_get_int(ssh
->conf
, CONF_ssh_subsys
);
9230 cmd
= conf_get_str(ssh
->conf
, CONF_remote_cmd
);
9233 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9234 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
); /* recipient channel */
9236 ssh2_pkt_addstring(s
->pktout
, "subsystem");
9237 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9238 ssh2_pkt_addstring(s
->pktout
, cmd
);
9240 ssh2_pkt_addstring(s
->pktout
, "exec");
9241 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9242 ssh2_pkt_addstring(s
->pktout
, cmd
);
9244 ssh2_pkt_addstring(s
->pktout
, "shell");
9245 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
9247 ssh2_pkt_send(ssh
, s
->pktout
);
9249 crWaitUntilV(pktin
);
9251 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
9252 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
9253 bombout(("Unexpected response to shell/command request:"
9254 " packet type %d", pktin
->type
));
9258 * We failed to start the command. If this is the
9259 * fallback command, we really are finished; if it's
9260 * not, and if the fallback command exists, try falling
9261 * back to it before complaining.
9263 if (!ssh
->fallback_cmd
&&
9264 *conf_get_str(ssh
->conf
, CONF_remote_cmd2
)) {
9265 logevent("Primary command failed; attempting fallback");
9266 ssh
->fallback_cmd
= TRUE
;
9269 bombout(("Server refused to start a shell/command"));
9272 logevent("Started a shell/command");
9277 ssh
->state
= SSH_STATE_SESSION
;
9278 if (ssh
->size_needed
)
9279 ssh_size(ssh
, ssh
->term_width
, ssh
->term_height
);
9280 if (ssh
->eof_needed
)
9281 ssh_special(ssh
, TS_EOF
);
9284 * All the initial channel requests are done, so install the default
9287 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_SUCCESS
] = ssh2_msg_channel_response
;
9288 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
] = ssh2_msg_channel_response
;
9294 ldisc_send(ssh
->ldisc
, NULL
, 0, 0);/* cause ldisc to notice changes */
9299 s
->try_send
= FALSE
;
9303 * _All_ the connection-layer packets we expect to
9304 * receive are now handled by the dispatch table.
9305 * Anything that reaches here must be bogus.
9308 bombout(("Strange packet received: type %d", pktin
->type
));
9310 } else if (ssh
->mainchan
) {
9312 * We have spare data. Add it to the channel buffer.
9314 ssh2_add_channel_data(ssh
->mainchan
, (char *)in
, inlen
);
9319 struct ssh_channel
*c
;
9321 * Try to send data on all channels if we can.
9323 for (i
= 0; NULL
!= (c
= index234(ssh
->channels
, i
)); i
++)
9324 ssh2_try_send_and_unthrottle(ssh
, c
);
9332 * Handlers for SSH-2 messages that might arrive at any moment.
9334 static void ssh2_msg_disconnect(Ssh ssh
, struct Packet
*pktin
)
9336 /* log reason code in disconnect message */
9340 reason
= ssh_pkt_getuint32(pktin
);
9341 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
9343 if (reason
> 0 && reason
< lenof(ssh2_disconnect_reasons
)) {
9344 buf
= dupprintf("Received disconnect message (%s)",
9345 ssh2_disconnect_reasons
[reason
]);
9347 buf
= dupprintf("Received disconnect message (unknown"
9348 " type %d)", reason
);
9352 buf
= dupprintf("Disconnection message text: %.*s",
9355 bombout(("Server sent disconnect message\ntype %d (%s):\n\"%.*s\"",
9357 (reason
> 0 && reason
< lenof(ssh2_disconnect_reasons
)) ?
9358 ssh2_disconnect_reasons
[reason
] : "unknown",
9363 static void ssh2_msg_debug(Ssh ssh
, struct Packet
*pktin
)
9365 /* log the debug message */
9369 /* XXX maybe we should actually take notice of the return value */
9370 ssh2_pkt_getbool(pktin
);
9371 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
9373 logeventf(ssh
, "Remote debug message: %.*s", msglen
, msg
);
9376 static void ssh2_msg_transport(Ssh ssh
, struct Packet
*pktin
)
9378 do_ssh2_transport(ssh
, NULL
, 0, pktin
);
9382 * Called if we receive a packet that isn't allowed by the protocol.
9383 * This only applies to packets whose meaning PuTTY understands.
9384 * Entirely unknown packets are handled below.
9386 static void ssh2_msg_unexpected(Ssh ssh
, struct Packet
*pktin
)
9388 char *buf
= dupprintf("Server protocol violation: unexpected %s packet",
9389 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
,
9391 ssh_disconnect(ssh
, NULL
, buf
, SSH2_DISCONNECT_PROTOCOL_ERROR
, FALSE
);
9395 static void ssh2_msg_something_unimplemented(Ssh ssh
, struct Packet
*pktin
)
9397 struct Packet
*pktout
;
9398 pktout
= ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED
);
9399 ssh2_pkt_adduint32(pktout
, pktin
->sequence
);
9401 * UNIMPLEMENTED messages MUST appear in the same order as the
9402 * messages they respond to. Hence, never queue them.
9404 ssh2_pkt_send_noqueue(ssh
, pktout
);
9408 * Handle the top-level SSH-2 protocol.
9410 static void ssh2_protocol_setup(Ssh ssh
)
9415 * Most messages cause SSH2_MSG_UNIMPLEMENTED.
9417 for (i
= 0; i
< 256; i
++)
9418 ssh
->packet_dispatch
[i
] = ssh2_msg_something_unimplemented
;
9421 * Initially, we only accept transport messages (and a few generic
9422 * ones). do_ssh2_authconn will add more when it starts.
9423 * Messages that are understood but not currently acceptable go to
9424 * ssh2_msg_unexpected.
9426 ssh
->packet_dispatch
[SSH2_MSG_UNIMPLEMENTED
] = ssh2_msg_unexpected
;
9427 ssh
->packet_dispatch
[SSH2_MSG_SERVICE_REQUEST
] = ssh2_msg_unexpected
;
9428 ssh
->packet_dispatch
[SSH2_MSG_SERVICE_ACCEPT
] = ssh2_msg_unexpected
;
9429 ssh
->packet_dispatch
[SSH2_MSG_KEXINIT
] = ssh2_msg_transport
;
9430 ssh
->packet_dispatch
[SSH2_MSG_NEWKEYS
] = ssh2_msg_transport
;
9431 ssh
->packet_dispatch
[SSH2_MSG_KEXDH_INIT
] = ssh2_msg_transport
;
9432 ssh
->packet_dispatch
[SSH2_MSG_KEXDH_REPLY
] = ssh2_msg_transport
;
9433 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = ssh2_msg_transport; duplicate case value */
9434 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = ssh2_msg_transport; duplicate case value */
9435 ssh
->packet_dispatch
[SSH2_MSG_KEX_DH_GEX_INIT
] = ssh2_msg_transport
;
9436 ssh
->packet_dispatch
[SSH2_MSG_KEX_DH_GEX_REPLY
] = ssh2_msg_transport
;
9437 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_REQUEST
] = ssh2_msg_unexpected
;
9438 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_FAILURE
] = ssh2_msg_unexpected
;
9439 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_SUCCESS
] = ssh2_msg_unexpected
;
9440 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] = ssh2_msg_unexpected
;
9441 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_PK_OK
] = ssh2_msg_unexpected
;
9442 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = ssh2_msg_unexpected; duplicate case value */
9443 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = ssh2_msg_unexpected; duplicate case value */
9444 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_INFO_RESPONSE
] = ssh2_msg_unexpected
;
9445 ssh
->packet_dispatch
[SSH2_MSG_GLOBAL_REQUEST
] = ssh2_msg_unexpected
;
9446 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_SUCCESS
] = ssh2_msg_unexpected
;
9447 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_FAILURE
] = ssh2_msg_unexpected
;
9448 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN
] = ssh2_msg_unexpected
;
9449 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
] = ssh2_msg_unexpected
;
9450 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_FAILURE
] = ssh2_msg_unexpected
;
9451 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_WINDOW_ADJUST
] = ssh2_msg_unexpected
;
9452 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_DATA
] = ssh2_msg_unexpected
;
9453 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EXTENDED_DATA
] = ssh2_msg_unexpected
;
9454 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EOF
] = ssh2_msg_unexpected
;
9455 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_CLOSE
] = ssh2_msg_unexpected
;
9456 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_REQUEST
] = ssh2_msg_unexpected
;
9457 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_SUCCESS
] = ssh2_msg_unexpected
;
9458 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
] = ssh2_msg_unexpected
;
9461 * These messages have a special handler from the start.
9463 ssh
->packet_dispatch
[SSH2_MSG_DISCONNECT
] = ssh2_msg_disconnect
;
9464 ssh
->packet_dispatch
[SSH2_MSG_IGNORE
] = ssh_msg_ignore
; /* shared with SSH-1 */
9465 ssh
->packet_dispatch
[SSH2_MSG_DEBUG
] = ssh2_msg_debug
;
9468 static void ssh2_timer(void *ctx
, long now
)
9472 if (ssh
->state
== SSH_STATE_CLOSED
)
9475 if (!ssh
->kex_in_progress
&& conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
) != 0 &&
9476 now
- ssh
->next_rekey
>= 0) {
9477 do_ssh2_transport(ssh
, "timeout", -1, NULL
);
9481 static void ssh2_protocol(Ssh ssh
, void *vin
, int inlen
,
9482 struct Packet
*pktin
)
9484 unsigned char *in
= (unsigned char *)vin
;
9485 if (ssh
->state
== SSH_STATE_CLOSED
)
9489 ssh
->incoming_data_size
+= pktin
->encrypted_len
;
9490 if (!ssh
->kex_in_progress
&&
9491 ssh
->max_data_size
!= 0 &&
9492 ssh
->incoming_data_size
> ssh
->max_data_size
)
9493 do_ssh2_transport(ssh
, "too much data received", -1, NULL
);
9497 ssh
->packet_dispatch
[pktin
->type
](ssh
, pktin
);
9498 else if (!ssh
->protocol_initial_phase_done
)
9499 do_ssh2_transport(ssh
, in
, inlen
, pktin
);
9501 do_ssh2_authconn(ssh
, in
, inlen
, pktin
);
9504 static void ssh_cache_conf_values(Ssh ssh
)
9506 ssh
->logomitdata
= conf_get_int(ssh
->conf
, CONF_logomitdata
);
9510 * Called to set up the connection.
9512 * Returns an error message, or NULL on success.
9514 static const char *ssh_init(void *frontend_handle
, void **backend_handle
,
9515 Conf
*conf
, char *host
, int port
, char **realhost
,
9516 int nodelay
, int keepalive
)
9521 ssh
= snew(struct ssh_tag
);
9522 ssh
->conf
= conf_copy(conf
);
9523 ssh_cache_conf_values(ssh
);
9524 ssh
->version
= 0; /* when not ready yet */
9527 ssh
->v1_cipher_ctx
= NULL
;
9528 ssh
->crcda_ctx
= NULL
;
9529 ssh
->cscipher
= NULL
;
9530 ssh
->cs_cipher_ctx
= NULL
;
9531 ssh
->sccipher
= NULL
;
9532 ssh
->sc_cipher_ctx
= NULL
;
9534 ssh
->cs_mac_ctx
= NULL
;
9536 ssh
->sc_mac_ctx
= NULL
;
9538 ssh
->cs_comp_ctx
= NULL
;
9540 ssh
->sc_comp_ctx
= NULL
;
9542 ssh
->kex_ctx
= NULL
;
9543 ssh
->hostkey
= NULL
;
9545 ssh
->close_expected
= FALSE
;
9546 ssh
->clean_exit
= FALSE
;
9547 ssh
->state
= SSH_STATE_PREPACKET
;
9548 ssh
->size_needed
= FALSE
;
9549 ssh
->eof_needed
= FALSE
;
9552 ssh
->deferred_send_data
= NULL
;
9553 ssh
->deferred_len
= 0;
9554 ssh
->deferred_size
= 0;
9555 ssh
->fallback_cmd
= 0;
9556 ssh
->pkt_kctx
= SSH2_PKTCTX_NOKEX
;
9557 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
9558 ssh
->x11disp
= NULL
;
9559 ssh
->v1_compressing
= FALSE
;
9560 ssh
->v2_outgoing_sequence
= 0;
9561 ssh
->ssh1_rdpkt_crstate
= 0;
9562 ssh
->ssh2_rdpkt_crstate
= 0;
9563 ssh
->ssh_gotdata_crstate
= 0;
9564 ssh
->do_ssh1_connection_crstate
= 0;
9565 ssh
->do_ssh_init_state
= NULL
;
9566 ssh
->do_ssh1_login_state
= NULL
;
9567 ssh
->do_ssh2_transport_state
= NULL
;
9568 ssh
->do_ssh2_authconn_state
= NULL
;
9571 ssh
->mainchan
= NULL
;
9572 ssh
->throttled_all
= 0;
9573 ssh
->v1_stdout_throttling
= 0;
9575 ssh
->queuelen
= ssh
->queuesize
= 0;
9576 ssh
->queueing
= FALSE
;
9577 ssh
->qhead
= ssh
->qtail
= NULL
;
9578 ssh
->deferred_rekey_reason
= NULL
;
9579 bufchain_init(&ssh
->queued_incoming_data
);
9580 ssh
->frozen
= FALSE
;
9581 ssh
->username
= NULL
;
9582 ssh
->sent_console_eof
= FALSE
;
9583 ssh
->got_pty
= FALSE
;
9585 *backend_handle
= ssh
;
9588 if (crypto_startup() == 0)
9589 return "Microsoft high encryption pack not installed!";
9592 ssh
->frontend
= frontend_handle
;
9593 ssh
->term_width
= conf_get_int(ssh
->conf
, CONF_width
);
9594 ssh
->term_height
= conf_get_int(ssh
->conf
, CONF_height
);
9596 ssh
->channels
= NULL
;
9597 ssh
->rportfwds
= NULL
;
9598 ssh
->portfwds
= NULL
;
9603 ssh
->conn_throttle_count
= 0;
9604 ssh
->overall_bufsize
= 0;
9605 ssh
->fallback_cmd
= 0;
9607 ssh
->protocol
= NULL
;
9609 ssh
->protocol_initial_phase_done
= FALSE
;
9613 ssh
->incoming_data_size
= ssh
->outgoing_data_size
=
9614 ssh
->deferred_data_size
= 0L;
9615 ssh
->max_data_size
= parse_blocksize(conf_get_str(ssh
->conf
,
9616 CONF_ssh_rekey_data
));
9617 ssh
->kex_in_progress
= FALSE
;
9620 ssh
->gsslibs
= NULL
;
9623 p
= connect_to_host(ssh
, host
, port
, realhost
, nodelay
, keepalive
);
9632 static void ssh_free(void *handle
)
9634 Ssh ssh
= (Ssh
) handle
;
9635 struct ssh_channel
*c
;
9636 struct ssh_rportfwd
*pf
;
9638 if (ssh
->v1_cipher_ctx
)
9639 ssh
->cipher
->free_context(ssh
->v1_cipher_ctx
);
9640 if (ssh
->cs_cipher_ctx
)
9641 ssh
->cscipher
->free_context(ssh
->cs_cipher_ctx
);
9642 if (ssh
->sc_cipher_ctx
)
9643 ssh
->sccipher
->free_context(ssh
->sc_cipher_ctx
);
9644 if (ssh
->cs_mac_ctx
)
9645 ssh
->csmac
->free_context(ssh
->cs_mac_ctx
);
9646 if (ssh
->sc_mac_ctx
)
9647 ssh
->scmac
->free_context(ssh
->sc_mac_ctx
);
9648 if (ssh
->cs_comp_ctx
) {
9650 ssh
->cscomp
->compress_cleanup(ssh
->cs_comp_ctx
);
9652 zlib_compress_cleanup(ssh
->cs_comp_ctx
);
9654 if (ssh
->sc_comp_ctx
) {
9656 ssh
->sccomp
->decompress_cleanup(ssh
->sc_comp_ctx
);
9658 zlib_decompress_cleanup(ssh
->sc_comp_ctx
);
9661 dh_cleanup(ssh
->kex_ctx
);
9662 sfree(ssh
->savedhost
);
9664 while (ssh
->queuelen
-- > 0)
9665 ssh_free_packet(ssh
->queue
[ssh
->queuelen
]);
9668 while (ssh
->qhead
) {
9669 struct queued_handler
*qh
= ssh
->qhead
;
9670 ssh
->qhead
= qh
->next
;
9673 ssh
->qhead
= ssh
->qtail
= NULL
;
9675 if (ssh
->channels
) {
9676 while ((c
= delpos234(ssh
->channels
, 0)) != NULL
) {
9679 if (c
->u
.x11
.s
!= NULL
)
9680 x11_close(c
->u
.x11
.s
);
9683 case CHAN_SOCKDATA_DORMANT
:
9684 if (c
->u
.pfd
.s
!= NULL
)
9685 pfd_close(c
->u
.pfd
.s
);
9690 freetree234(ssh
->channels
);
9691 ssh
->channels
= NULL
;
9694 if (ssh
->rportfwds
) {
9695 while ((pf
= delpos234(ssh
->rportfwds
, 0)) != NULL
)
9697 freetree234(ssh
->rportfwds
);
9698 ssh
->rportfwds
= NULL
;
9700 sfree(ssh
->deferred_send_data
);
9702 x11_free_display(ssh
->x11disp
);
9703 sfree(ssh
->do_ssh_init_state
);
9704 sfree(ssh
->do_ssh1_login_state
);
9705 sfree(ssh
->do_ssh2_transport_state
);
9706 sfree(ssh
->do_ssh2_authconn_state
);
9709 sfree(ssh
->fullhostname
);
9710 if (ssh
->crcda_ctx
) {
9711 crcda_free_context(ssh
->crcda_ctx
);
9712 ssh
->crcda_ctx
= NULL
;
9715 ssh_do_close(ssh
, TRUE
);
9716 expire_timer_context(ssh
);
9718 pinger_free(ssh
->pinger
);
9719 bufchain_clear(&ssh
->queued_incoming_data
);
9720 sfree(ssh
->username
);
9721 conf_free(ssh
->conf
);
9724 ssh_gss_cleanup(ssh
->gsslibs
);
9732 * Reconfigure the SSH backend.
9734 static void ssh_reconfig(void *handle
, Conf
*conf
)
9736 Ssh ssh
= (Ssh
) handle
;
9737 char *rekeying
= NULL
, rekey_mandatory
= FALSE
;
9738 unsigned long old_max_data_size
;
9741 pinger_reconfig(ssh
->pinger
, ssh
->conf
, conf
);
9743 ssh_setup_portfwd(ssh
, conf
);
9745 rekey_time
= conf_get_int(conf
, CONF_ssh_rekey_time
);
9746 if (conf_get_int(ssh
->conf
, CONF_ssh_rekey_time
) != rekey_time
&&
9748 long new_next
= ssh
->last_rekey
+ rekey_time
*60*TICKSPERSEC
;
9749 long now
= GETTICKCOUNT();
9751 if (new_next
- now
< 0) {
9752 rekeying
= "timeout shortened";
9754 ssh
->next_rekey
= schedule_timer(new_next
- now
, ssh2_timer
, ssh
);
9758 old_max_data_size
= ssh
->max_data_size
;
9759 ssh
->max_data_size
= parse_blocksize(conf_get_str(ssh
->conf
,
9760 CONF_ssh_rekey_data
));
9761 if (old_max_data_size
!= ssh
->max_data_size
&&
9762 ssh
->max_data_size
!= 0) {
9763 if (ssh
->outgoing_data_size
> ssh
->max_data_size
||
9764 ssh
->incoming_data_size
> ssh
->max_data_size
)
9765 rekeying
= "data limit lowered";
9768 if (conf_get_int(ssh
->conf
, CONF_compression
) !=
9769 conf_get_int(conf
, CONF_compression
)) {
9770 rekeying
= "compression setting changed";
9771 rekey_mandatory
= TRUE
;
9774 for (i
= 0; i
< CIPHER_MAX
; i
++)
9775 if (conf_get_int_int(ssh
->conf
, CONF_ssh_cipherlist
, i
) !=
9776 conf_get_int_int(conf
, CONF_ssh_cipherlist
, i
)) {
9777 rekeying
= "cipher settings changed";
9778 rekey_mandatory
= TRUE
;
9780 if (conf_get_int(ssh
->conf
, CONF_ssh2_des_cbc
) !=
9781 conf_get_int(conf
, CONF_ssh2_des_cbc
)) {
9782 rekeying
= "cipher settings changed";
9783 rekey_mandatory
= TRUE
;
9786 conf_free(ssh
->conf
);
9787 ssh
->conf
= conf_copy(conf
);
9788 ssh_cache_conf_values(ssh
);
9791 if (!ssh
->kex_in_progress
) {
9792 do_ssh2_transport(ssh
, rekeying
, -1, NULL
);
9793 } else if (rekey_mandatory
) {
9794 ssh
->deferred_rekey_reason
= rekeying
;
9800 * Called to send data down the SSH connection.
9802 static int ssh_send(void *handle
, char *buf
, int len
)
9804 Ssh ssh
= (Ssh
) handle
;
9806 if (ssh
== NULL
|| ssh
->s
== NULL
|| ssh
->protocol
== NULL
)
9809 ssh
->protocol(ssh
, (unsigned char *)buf
, len
, 0);
9811 return ssh_sendbuffer(ssh
);
9815 * Called to query the current amount of buffered stdin data.
9817 static int ssh_sendbuffer(void *handle
)
9819 Ssh ssh
= (Ssh
) handle
;
9822 if (ssh
== NULL
|| ssh
->s
== NULL
|| ssh
->protocol
== NULL
)
9826 * If the SSH socket itself has backed up, add the total backup
9827 * size on that to any individual buffer on the stdin channel.
9830 if (ssh
->throttled_all
)
9831 override_value
= ssh
->overall_bufsize
;
9833 if (ssh
->version
== 1) {
9834 return override_value
;
9835 } else if (ssh
->version
== 2) {
9837 return override_value
;
9839 return (override_value
+
9840 bufchain_size(&ssh
->mainchan
->v
.v2
.outbuffer
));
9847 * Called to set the size of the window from SSH's POV.
9849 static void ssh_size(void *handle
, int width
, int height
)
9851 Ssh ssh
= (Ssh
) handle
;
9852 struct Packet
*pktout
;
9854 ssh
->term_width
= width
;
9855 ssh
->term_height
= height
;
9857 switch (ssh
->state
) {
9858 case SSH_STATE_BEFORE_SIZE
:
9859 case SSH_STATE_PREPACKET
:
9860 case SSH_STATE_CLOSED
:
9861 break; /* do nothing */
9862 case SSH_STATE_INTERMED
:
9863 ssh
->size_needed
= TRUE
; /* buffer for later */
9865 case SSH_STATE_SESSION
:
9866 if (!conf_get_int(ssh
->conf
, CONF_nopty
)) {
9867 if (ssh
->version
== 1) {
9868 send_packet(ssh
, SSH1_CMSG_WINDOW_SIZE
,
9869 PKT_INT
, ssh
->term_height
,
9870 PKT_INT
, ssh
->term_width
,
9871 PKT_INT
, 0, PKT_INT
, 0, PKT_END
);
9872 } else if (ssh
->mainchan
) {
9873 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9874 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
9875 ssh2_pkt_addstring(pktout
, "window-change");
9876 ssh2_pkt_addbool(pktout
, 0);
9877 ssh2_pkt_adduint32(pktout
, ssh
->term_width
);
9878 ssh2_pkt_adduint32(pktout
, ssh
->term_height
);
9879 ssh2_pkt_adduint32(pktout
, 0);
9880 ssh2_pkt_adduint32(pktout
, 0);
9881 ssh2_pkt_send(ssh
, pktout
);
9889 * Return a list of the special codes that make sense in this
9892 static const struct telnet_special
*ssh_get_specials(void *handle
)
9894 static const struct telnet_special ssh1_ignore_special
[] = {
9895 {"IGNORE message", TS_NOP
}
9897 static const struct telnet_special ssh2_ignore_special
[] = {
9898 {"IGNORE message", TS_NOP
},
9900 static const struct telnet_special ssh2_rekey_special
[] = {
9901 {"Repeat key exchange", TS_REKEY
},
9903 static const struct telnet_special ssh2_session_specials
[] = {
9906 /* These are the signal names defined by RFC 4254.
9907 * They include all the ISO C signals, but are a subset of the POSIX
9908 * required signals. */
9909 {"SIGINT (Interrupt)", TS_SIGINT
},
9910 {"SIGTERM (Terminate)", TS_SIGTERM
},
9911 {"SIGKILL (Kill)", TS_SIGKILL
},
9912 {"SIGQUIT (Quit)", TS_SIGQUIT
},
9913 {"SIGHUP (Hangup)", TS_SIGHUP
},
9914 {"More signals", TS_SUBMENU
},
9915 {"SIGABRT", TS_SIGABRT
}, {"SIGALRM", TS_SIGALRM
},
9916 {"SIGFPE", TS_SIGFPE
}, {"SIGILL", TS_SIGILL
},
9917 {"SIGPIPE", TS_SIGPIPE
}, {"SIGSEGV", TS_SIGSEGV
},
9918 {"SIGUSR1", TS_SIGUSR1
}, {"SIGUSR2", TS_SIGUSR2
},
9921 static const struct telnet_special specials_end
[] = {
9924 /* XXX review this length for any changes: */
9925 static struct telnet_special ssh_specials
[lenof(ssh2_ignore_special
) +
9926 lenof(ssh2_rekey_special
) +
9927 lenof(ssh2_session_specials
) +
9928 lenof(specials_end
)];
9929 Ssh ssh
= (Ssh
) handle
;
9931 #define ADD_SPECIALS(name) \
9933 assert((i + lenof(name)) <= lenof(ssh_specials)); \
9934 memcpy(&ssh_specials[i], name, sizeof name); \
9938 if (ssh
->version
== 1) {
9939 /* Don't bother offering IGNORE if we've decided the remote
9940 * won't cope with it, since we wouldn't bother sending it if
9942 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
))
9943 ADD_SPECIALS(ssh1_ignore_special
);
9944 } else if (ssh
->version
== 2) {
9945 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH2_IGNORE
))
9946 ADD_SPECIALS(ssh2_ignore_special
);
9947 if (!(ssh
->remote_bugs
& BUG_SSH2_REKEY
))
9948 ADD_SPECIALS(ssh2_rekey_special
);
9950 ADD_SPECIALS(ssh2_session_specials
);
9951 } /* else we're not ready yet */
9954 ADD_SPECIALS(specials_end
);
9955 return ssh_specials
;
9963 * Send special codes. TS_EOF is useful for `plink', so you
9964 * can send an EOF and collect resulting output (e.g. `plink
9967 static void ssh_special(void *handle
, Telnet_Special code
)
9969 Ssh ssh
= (Ssh
) handle
;
9970 struct Packet
*pktout
;
9972 if (code
== TS_EOF
) {
9973 if (ssh
->state
!= SSH_STATE_SESSION
) {
9975 * Buffer the EOF in case we are pre-SESSION, so we can
9976 * send it as soon as we reach SESSION.
9979 ssh
->eof_needed
= TRUE
;
9982 if (ssh
->version
== 1) {
9983 send_packet(ssh
, SSH1_CMSG_EOF
, PKT_END
);
9984 } else if (ssh
->mainchan
) {
9985 sshfwd_write_eof(ssh
->mainchan
);
9986 ssh
->send_ok
= 0; /* now stop trying to read from stdin */
9988 logevent("Sent EOF message");
9989 } else if (code
== TS_PING
|| code
== TS_NOP
) {
9990 if (ssh
->state
== SSH_STATE_CLOSED
9991 || ssh
->state
== SSH_STATE_PREPACKET
) return;
9992 if (ssh
->version
== 1) {
9993 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
))
9994 send_packet(ssh
, SSH1_MSG_IGNORE
, PKT_STR
, "", PKT_END
);
9996 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH2_IGNORE
)) {
9997 pktout
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
9998 ssh2_pkt_addstring_start(pktout
);
9999 ssh2_pkt_send_noqueue(ssh
, pktout
);
10002 } else if (code
== TS_REKEY
) {
10003 if (!ssh
->kex_in_progress
&& ssh
->version
== 2) {
10004 do_ssh2_transport(ssh
, "at user request", -1, NULL
);
10006 } else if (code
== TS_BRK
) {
10007 if (ssh
->state
== SSH_STATE_CLOSED
10008 || ssh
->state
== SSH_STATE_PREPACKET
) return;
10009 if (ssh
->version
== 1) {
10010 logevent("Unable to send BREAK signal in SSH-1");
10011 } else if (ssh
->mainchan
) {
10012 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
10013 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
10014 ssh2_pkt_addstring(pktout
, "break");
10015 ssh2_pkt_addbool(pktout
, 0);
10016 ssh2_pkt_adduint32(pktout
, 0); /* default break length */
10017 ssh2_pkt_send(ssh
, pktout
);
10020 /* Is is a POSIX signal? */
10021 char *signame
= NULL
;
10022 if (code
== TS_SIGABRT
) signame
= "ABRT";
10023 if (code
== TS_SIGALRM
) signame
= "ALRM";
10024 if (code
== TS_SIGFPE
) signame
= "FPE";
10025 if (code
== TS_SIGHUP
) signame
= "HUP";
10026 if (code
== TS_SIGILL
) signame
= "ILL";
10027 if (code
== TS_SIGINT
) signame
= "INT";
10028 if (code
== TS_SIGKILL
) signame
= "KILL";
10029 if (code
== TS_SIGPIPE
) signame
= "PIPE";
10030 if (code
== TS_SIGQUIT
) signame
= "QUIT";
10031 if (code
== TS_SIGSEGV
) signame
= "SEGV";
10032 if (code
== TS_SIGTERM
) signame
= "TERM";
10033 if (code
== TS_SIGUSR1
) signame
= "USR1";
10034 if (code
== TS_SIGUSR2
) signame
= "USR2";
10035 /* The SSH-2 protocol does in principle support arbitrary named
10036 * signals, including signame@domain, but we don't support those. */
10038 /* It's a signal. */
10039 if (ssh
->version
== 2 && ssh
->mainchan
) {
10040 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
10041 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
10042 ssh2_pkt_addstring(pktout
, "signal");
10043 ssh2_pkt_addbool(pktout
, 0);
10044 ssh2_pkt_addstring(pktout
, signame
);
10045 ssh2_pkt_send(ssh
, pktout
);
10046 logeventf(ssh
, "Sent signal SIG%s", signame
);
10049 /* Never heard of it. Do nothing */
10054 void *new_sock_channel(void *handle
, Socket s
)
10056 Ssh ssh
= (Ssh
) handle
;
10057 struct ssh_channel
*c
;
10058 c
= snew(struct ssh_channel
);
10061 ssh2_channel_init(c
);
10062 c
->halfopen
= TRUE
;
10063 c
->type
= CHAN_SOCKDATA_DORMANT
;/* identify channel type */
10065 add234(ssh
->channels
, c
);
10070 * This is called when stdout/stderr (the entity to which
10071 * from_backend sends data) manages to clear some backlog.
10073 static void ssh_unthrottle(void *handle
, int bufsize
)
10075 Ssh ssh
= (Ssh
) handle
;
10078 if (ssh
->version
== 1) {
10079 if (ssh
->v1_stdout_throttling
&& bufsize
< SSH1_BUFFER_LIMIT
) {
10080 ssh
->v1_stdout_throttling
= 0;
10081 ssh_throttle_conn(ssh
, -1);
10084 if (ssh
->mainchan
) {
10085 ssh2_set_window(ssh
->mainchan
,
10086 bufsize
< ssh
->mainchan
->v
.v2
.locmaxwin ?
10087 ssh
->mainchan
->v
.v2
.locmaxwin
- bufsize
: 0);
10088 if (conf_get_int(ssh
->conf
, CONF_ssh_simple
))
10091 buflimit
= ssh
->mainchan
->v
.v2
.locmaxwin
;
10092 if (ssh
->mainchan
->throttling_conn
&& bufsize
<= buflimit
) {
10093 ssh
->mainchan
->throttling_conn
= 0;
10094 ssh_throttle_conn(ssh
, -1);
10100 * Now process any SSH connection data that was stashed in our
10101 * queue while we were frozen.
10103 ssh_process_queued_incoming_data(ssh
);
10106 void ssh_send_port_open(void *channel
, char *hostname
, int port
, char *org
)
10108 struct ssh_channel
*c
= (struct ssh_channel
*)channel
;
10110 struct Packet
*pktout
;
10112 logeventf(ssh
, "Opening forwarded connection to %s:%d", hostname
, port
);
10114 if (ssh
->version
== 1) {
10115 send_packet(ssh
, SSH1_MSG_PORT_OPEN
,
10116 PKT_INT
, c
->localid
,
10119 /* PKT_STR, <org:orgport>, */
10122 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
10123 ssh2_pkt_addstring(pktout
, "direct-tcpip");
10124 ssh2_pkt_adduint32(pktout
, c
->localid
);
10125 ssh2_pkt_adduint32(pktout
, c
->v
.v2
.locwindow
);/* our window size */
10126 ssh2_pkt_adduint32(pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
10127 ssh2_pkt_addstring(pktout
, hostname
);
10128 ssh2_pkt_adduint32(pktout
, port
);
10130 * We make up values for the originator data; partly it's
10131 * too much hassle to keep track, and partly I'm not
10132 * convinced the server should be told details like that
10133 * about my local network configuration.
10134 * The "originator IP address" is syntactically a numeric
10135 * IP address, and some servers (e.g., Tectia) get upset
10136 * if it doesn't match this syntax.
10138 ssh2_pkt_addstring(pktout
, "0.0.0.0");
10139 ssh2_pkt_adduint32(pktout
, 0);
10140 ssh2_pkt_send(ssh
, pktout
);
10144 static int ssh_connected(void *handle
)
10146 Ssh ssh
= (Ssh
) handle
;
10147 return ssh
->s
!= NULL
;
10150 static int ssh_sendok(void *handle
)
10152 Ssh ssh
= (Ssh
) handle
;
10153 return ssh
->send_ok
;
10156 static int ssh_ldisc(void *handle
, int option
)
10158 Ssh ssh
= (Ssh
) handle
;
10159 if (option
== LD_ECHO
)
10160 return ssh
->echoing
;
10161 if (option
== LD_EDIT
)
10162 return ssh
->editing
;
10166 static void ssh_provide_ldisc(void *handle
, void *ldisc
)
10168 Ssh ssh
= (Ssh
) handle
;
10169 ssh
->ldisc
= ldisc
;
10172 static void ssh_provide_logctx(void *handle
, void *logctx
)
10174 Ssh ssh
= (Ssh
) handle
;
10175 ssh
->logctx
= logctx
;
10178 static int ssh_return_exitcode(void *handle
)
10180 Ssh ssh
= (Ssh
) handle
;
10181 if (ssh
->s
!= NULL
)
10184 return (ssh
->exitcode
>= 0 ? ssh
->exitcode
: INT_MAX
);
10188 * cfg_info for SSH is the currently running version of the
10189 * protocol. (1 for 1; 2 for 2; 0 for not-decided-yet.)
10191 static int ssh_cfg_info(void *handle
)
10193 Ssh ssh
= (Ssh
) handle
;
10194 return ssh
->version
;
10198 * Gross hack: pscp will try to start SFTP but fall back to scp1 if
10199 * that fails. This variable is the means by which scp.c can reach
10200 * into the SSH code and find out which one it got.
10202 extern int ssh_fallback_cmd(void *handle
)
10204 Ssh ssh
= (Ssh
) handle
;
10205 return ssh
->fallback_cmd
;
10208 Backend ssh_backend
= {
10218 ssh_return_exitcode
,
10222 ssh_provide_logctx
,