23 #define SSH1_MSG_DISCONNECT 1 /* 0x1 */
24 #define SSH1_SMSG_PUBLIC_KEY 2 /* 0x2 */
25 #define SSH1_CMSG_SESSION_KEY 3 /* 0x3 */
26 #define SSH1_CMSG_USER 4 /* 0x4 */
27 #define SSH1_CMSG_AUTH_RSA 6 /* 0x6 */
28 #define SSH1_SMSG_AUTH_RSA_CHALLENGE 7 /* 0x7 */
29 #define SSH1_CMSG_AUTH_RSA_RESPONSE 8 /* 0x8 */
30 #define SSH1_CMSG_AUTH_PASSWORD 9 /* 0x9 */
31 #define SSH1_CMSG_REQUEST_PTY 10 /* 0xa */
32 #define SSH1_CMSG_WINDOW_SIZE 11 /* 0xb */
33 #define SSH1_CMSG_EXEC_SHELL 12 /* 0xc */
34 #define SSH1_CMSG_EXEC_CMD 13 /* 0xd */
35 #define SSH1_SMSG_SUCCESS 14 /* 0xe */
36 #define SSH1_SMSG_FAILURE 15 /* 0xf */
37 #define SSH1_CMSG_STDIN_DATA 16 /* 0x10 */
38 #define SSH1_SMSG_STDOUT_DATA 17 /* 0x11 */
39 #define SSH1_SMSG_STDERR_DATA 18 /* 0x12 */
40 #define SSH1_CMSG_EOF 19 /* 0x13 */
41 #define SSH1_SMSG_EXIT_STATUS 20 /* 0x14 */
42 #define SSH1_MSG_CHANNEL_OPEN_CONFIRMATION 21 /* 0x15 */
43 #define SSH1_MSG_CHANNEL_OPEN_FAILURE 22 /* 0x16 */
44 #define SSH1_MSG_CHANNEL_DATA 23 /* 0x17 */
45 #define SSH1_MSG_CHANNEL_CLOSE 24 /* 0x18 */
46 #define SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION 25 /* 0x19 */
47 #define SSH1_SMSG_X11_OPEN 27 /* 0x1b */
48 #define SSH1_CMSG_PORT_FORWARD_REQUEST 28 /* 0x1c */
49 #define SSH1_MSG_PORT_OPEN 29 /* 0x1d */
50 #define SSH1_CMSG_AGENT_REQUEST_FORWARDING 30 /* 0x1e */
51 #define SSH1_SMSG_AGENT_OPEN 31 /* 0x1f */
52 #define SSH1_MSG_IGNORE 32 /* 0x20 */
53 #define SSH1_CMSG_EXIT_CONFIRMATION 33 /* 0x21 */
54 #define SSH1_CMSG_X11_REQUEST_FORWARDING 34 /* 0x22 */
55 #define SSH1_CMSG_AUTH_RHOSTS_RSA 35 /* 0x23 */
56 #define SSH1_MSG_DEBUG 36 /* 0x24 */
57 #define SSH1_CMSG_REQUEST_COMPRESSION 37 /* 0x25 */
58 #define SSH1_CMSG_AUTH_TIS 39 /* 0x27 */
59 #define SSH1_SMSG_AUTH_TIS_CHALLENGE 40 /* 0x28 */
60 #define SSH1_CMSG_AUTH_TIS_RESPONSE 41 /* 0x29 */
61 #define SSH1_CMSG_AUTH_CCARD 70 /* 0x46 */
62 #define SSH1_SMSG_AUTH_CCARD_CHALLENGE 71 /* 0x47 */
63 #define SSH1_CMSG_AUTH_CCARD_RESPONSE 72 /* 0x48 */
65 #define SSH1_AUTH_RHOSTS 1 /* 0x1 */
66 #define SSH1_AUTH_RSA 2 /* 0x2 */
67 #define SSH1_AUTH_PASSWORD 3 /* 0x3 */
68 #define SSH1_AUTH_RHOSTS_RSA 4 /* 0x4 */
69 #define SSH1_AUTH_TIS 5 /* 0x5 */
70 #define SSH1_AUTH_CCARD 16 /* 0x10 */
72 #define SSH1_PROTOFLAG_SCREEN_NUMBER 1 /* 0x1 */
73 /* Mask for protoflags we will echo back to server if seen */
74 #define SSH1_PROTOFLAGS_SUPPORTED 0 /* 0x1 */
76 #define SSH2_MSG_DISCONNECT 1 /* 0x1 */
77 #define SSH2_MSG_IGNORE 2 /* 0x2 */
78 #define SSH2_MSG_UNIMPLEMENTED 3 /* 0x3 */
79 #define SSH2_MSG_DEBUG 4 /* 0x4 */
80 #define SSH2_MSG_SERVICE_REQUEST 5 /* 0x5 */
81 #define SSH2_MSG_SERVICE_ACCEPT 6 /* 0x6 */
82 #define SSH2_MSG_KEXINIT 20 /* 0x14 */
83 #define SSH2_MSG_NEWKEYS 21 /* 0x15 */
84 #define SSH2_MSG_KEXDH_INIT 30 /* 0x1e */
85 #define SSH2_MSG_KEXDH_REPLY 31 /* 0x1f */
86 #define SSH2_MSG_KEX_DH_GEX_REQUEST 30 /* 0x1e */
87 #define SSH2_MSG_KEX_DH_GEX_GROUP 31 /* 0x1f */
88 #define SSH2_MSG_KEX_DH_GEX_INIT 32 /* 0x20 */
89 #define SSH2_MSG_KEX_DH_GEX_REPLY 33 /* 0x21 */
90 #define SSH2_MSG_KEXRSA_PUBKEY 30 /* 0x1e */
91 #define SSH2_MSG_KEXRSA_SECRET 31 /* 0x1f */
92 #define SSH2_MSG_KEXRSA_DONE 32 /* 0x20 */
93 #define SSH2_MSG_USERAUTH_REQUEST 50 /* 0x32 */
94 #define SSH2_MSG_USERAUTH_FAILURE 51 /* 0x33 */
95 #define SSH2_MSG_USERAUTH_SUCCESS 52 /* 0x34 */
96 #define SSH2_MSG_USERAUTH_BANNER 53 /* 0x35 */
97 #define SSH2_MSG_USERAUTH_PK_OK 60 /* 0x3c */
98 #define SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ 60 /* 0x3c */
99 #define SSH2_MSG_USERAUTH_INFO_REQUEST 60 /* 0x3c */
100 #define SSH2_MSG_USERAUTH_INFO_RESPONSE 61 /* 0x3d */
101 #define SSH2_MSG_GLOBAL_REQUEST 80 /* 0x50 */
102 #define SSH2_MSG_REQUEST_SUCCESS 81 /* 0x51 */
103 #define SSH2_MSG_REQUEST_FAILURE 82 /* 0x52 */
104 #define SSH2_MSG_CHANNEL_OPEN 90 /* 0x5a */
105 #define SSH2_MSG_CHANNEL_OPEN_CONFIRMATION 91 /* 0x5b */
106 #define SSH2_MSG_CHANNEL_OPEN_FAILURE 92 /* 0x5c */
107 #define SSH2_MSG_CHANNEL_WINDOW_ADJUST 93 /* 0x5d */
108 #define SSH2_MSG_CHANNEL_DATA 94 /* 0x5e */
109 #define SSH2_MSG_CHANNEL_EXTENDED_DATA 95 /* 0x5f */
110 #define SSH2_MSG_CHANNEL_EOF 96 /* 0x60 */
111 #define SSH2_MSG_CHANNEL_CLOSE 97 /* 0x61 */
112 #define SSH2_MSG_CHANNEL_REQUEST 98 /* 0x62 */
113 #define SSH2_MSG_CHANNEL_SUCCESS 99 /* 0x63 */
114 #define SSH2_MSG_CHANNEL_FAILURE 100 /* 0x64 */
117 * Packet type contexts, so that ssh2_pkt_type can correctly decode
118 * the ambiguous type numbers back into the correct type strings.
128 SSH2_PKTCTX_PUBLICKEY
,
129 SSH2_PKTCTX_PASSWORD
,
133 #define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1 /* 0x1 */
134 #define SSH2_DISCONNECT_PROTOCOL_ERROR 2 /* 0x2 */
135 #define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED 3 /* 0x3 */
136 #define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4 /* 0x4 */
137 #define SSH2_DISCONNECT_MAC_ERROR 5 /* 0x5 */
138 #define SSH2_DISCONNECT_COMPRESSION_ERROR 6 /* 0x6 */
139 #define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE 7 /* 0x7 */
140 #define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8 /* 0x8 */
141 #define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9 /* 0x9 */
142 #define SSH2_DISCONNECT_CONNECTION_LOST 10 /* 0xa */
143 #define SSH2_DISCONNECT_BY_APPLICATION 11 /* 0xb */
144 #define SSH2_DISCONNECT_TOO_MANY_CONNECTIONS 12 /* 0xc */
145 #define SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER 13 /* 0xd */
146 #define SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14 /* 0xe */
147 #define SSH2_DISCONNECT_ILLEGAL_USER_NAME 15 /* 0xf */
149 static const char *const ssh2_disconnect_reasons
[] = {
151 "host not allowed to connect",
153 "key exchange failed",
154 "host authentication failed",
157 "service not available",
158 "protocol version not supported",
159 "host key not verifiable",
162 "too many connections",
163 "auth cancelled by user",
164 "no more auth methods available",
168 #define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED 1 /* 0x1 */
169 #define SSH2_OPEN_CONNECT_FAILED 2 /* 0x2 */
170 #define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE 3 /* 0x3 */
171 #define SSH2_OPEN_RESOURCE_SHORTAGE 4 /* 0x4 */
173 #define SSH2_EXTENDED_DATA_STDERR 1 /* 0x1 */
176 * Various remote-bug flags.
178 #define BUG_CHOKES_ON_SSH1_IGNORE 1
179 #define BUG_SSH2_HMAC 2
180 #define BUG_NEEDS_SSH1_PLAIN_PASSWORD 4
181 #define BUG_CHOKES_ON_RSA 8
182 #define BUG_SSH2_RSA_PADDING 16
183 #define BUG_SSH2_DERIVEKEY 32
184 #define BUG_SSH2_REKEY 64
185 #define BUG_SSH2_PK_SESSIONID 128
188 * Codes for terminal modes.
189 * Most of these are the same in SSH-1 and SSH-2.
190 * This list is derived from RFC 4254 and
193 static const struct {
194 const char* const mode
;
196 enum { TTY_OP_CHAR
, TTY_OP_BOOL
} type
;
198 /* "V" prefix discarded for special characters relative to SSH specs */
199 { "INTR", 1, TTY_OP_CHAR
},
200 { "QUIT", 2, TTY_OP_CHAR
},
201 { "ERASE", 3, TTY_OP_CHAR
},
202 { "KILL", 4, TTY_OP_CHAR
},
203 { "EOF", 5, TTY_OP_CHAR
},
204 { "EOL", 6, TTY_OP_CHAR
},
205 { "EOL2", 7, TTY_OP_CHAR
},
206 { "START", 8, TTY_OP_CHAR
},
207 { "STOP", 9, TTY_OP_CHAR
},
208 { "SUSP", 10, TTY_OP_CHAR
},
209 { "DSUSP", 11, TTY_OP_CHAR
},
210 { "REPRINT", 12, TTY_OP_CHAR
},
211 { "WERASE", 13, TTY_OP_CHAR
},
212 { "LNEXT", 14, TTY_OP_CHAR
},
213 { "FLUSH", 15, TTY_OP_CHAR
},
214 { "SWTCH", 16, TTY_OP_CHAR
},
215 { "STATUS", 17, TTY_OP_CHAR
},
216 { "DISCARD", 18, TTY_OP_CHAR
},
217 { "IGNPAR", 30, TTY_OP_BOOL
},
218 { "PARMRK", 31, TTY_OP_BOOL
},
219 { "INPCK", 32, TTY_OP_BOOL
},
220 { "ISTRIP", 33, TTY_OP_BOOL
},
221 { "INLCR", 34, TTY_OP_BOOL
},
222 { "IGNCR", 35, TTY_OP_BOOL
},
223 { "ICRNL", 36, TTY_OP_BOOL
},
224 { "IUCLC", 37, TTY_OP_BOOL
},
225 { "IXON", 38, TTY_OP_BOOL
},
226 { "IXANY", 39, TTY_OP_BOOL
},
227 { "IXOFF", 40, TTY_OP_BOOL
},
228 { "IMAXBEL", 41, TTY_OP_BOOL
},
229 { "ISIG", 50, TTY_OP_BOOL
},
230 { "ICANON", 51, TTY_OP_BOOL
},
231 { "XCASE", 52, TTY_OP_BOOL
},
232 { "ECHO", 53, TTY_OP_BOOL
},
233 { "ECHOE", 54, TTY_OP_BOOL
},
234 { "ECHOK", 55, TTY_OP_BOOL
},
235 { "ECHONL", 56, TTY_OP_BOOL
},
236 { "NOFLSH", 57, TTY_OP_BOOL
},
237 { "TOSTOP", 58, TTY_OP_BOOL
},
238 { "IEXTEN", 59, TTY_OP_BOOL
},
239 { "ECHOCTL", 60, TTY_OP_BOOL
},
240 { "ECHOKE", 61, TTY_OP_BOOL
},
241 { "PENDIN", 62, TTY_OP_BOOL
}, /* XXX is this a real mode? */
242 { "OPOST", 70, TTY_OP_BOOL
},
243 { "OLCUC", 71, TTY_OP_BOOL
},
244 { "ONLCR", 72, TTY_OP_BOOL
},
245 { "OCRNL", 73, TTY_OP_BOOL
},
246 { "ONOCR", 74, TTY_OP_BOOL
},
247 { "ONLRET", 75, TTY_OP_BOOL
},
248 { "CS7", 90, TTY_OP_BOOL
},
249 { "CS8", 91, TTY_OP_BOOL
},
250 { "PARENB", 92, TTY_OP_BOOL
},
251 { "PARODD", 93, TTY_OP_BOOL
}
254 /* Miscellaneous other tty-related constants. */
255 #define SSH_TTY_OP_END 0
256 /* The opcodes for ISPEED/OSPEED differ between SSH-1 and SSH-2. */
257 #define SSH1_TTY_OP_ISPEED 192
258 #define SSH1_TTY_OP_OSPEED 193
259 #define SSH2_TTY_OP_ISPEED 128
260 #define SSH2_TTY_OP_OSPEED 129
262 /* Helper functions for parsing tty-related config. */
263 static unsigned int ssh_tty_parse_specchar(char *s
)
268 ret
= ctrlparse(s
, &next
);
269 if (!next
) ret
= s
[0];
271 ret
= 255; /* special value meaning "don't set" */
275 static unsigned int ssh_tty_parse_boolean(char *s
)
277 if (stricmp(s
, "yes") == 0 ||
278 stricmp(s
, "on") == 0 ||
279 stricmp(s
, "true") == 0 ||
280 stricmp(s
, "+") == 0)
282 else if (stricmp(s
, "no") == 0 ||
283 stricmp(s
, "off") == 0 ||
284 stricmp(s
, "false") == 0 ||
285 stricmp(s
, "-") == 0)
286 return 0; /* false */
288 return (atoi(s
) != 0);
291 #define translate(x) if (type == x) return #x
292 #define translatek(x,ctx) if (type == x && (pkt_kctx == ctx)) return #x
293 #define translatea(x,ctx) if (type == x && (pkt_actx == ctx)) return #x
294 static char *ssh1_pkt_type(int type
)
296 translate(SSH1_MSG_DISCONNECT
);
297 translate(SSH1_SMSG_PUBLIC_KEY
);
298 translate(SSH1_CMSG_SESSION_KEY
);
299 translate(SSH1_CMSG_USER
);
300 translate(SSH1_CMSG_AUTH_RSA
);
301 translate(SSH1_SMSG_AUTH_RSA_CHALLENGE
);
302 translate(SSH1_CMSG_AUTH_RSA_RESPONSE
);
303 translate(SSH1_CMSG_AUTH_PASSWORD
);
304 translate(SSH1_CMSG_REQUEST_PTY
);
305 translate(SSH1_CMSG_WINDOW_SIZE
);
306 translate(SSH1_CMSG_EXEC_SHELL
);
307 translate(SSH1_CMSG_EXEC_CMD
);
308 translate(SSH1_SMSG_SUCCESS
);
309 translate(SSH1_SMSG_FAILURE
);
310 translate(SSH1_CMSG_STDIN_DATA
);
311 translate(SSH1_SMSG_STDOUT_DATA
);
312 translate(SSH1_SMSG_STDERR_DATA
);
313 translate(SSH1_CMSG_EOF
);
314 translate(SSH1_SMSG_EXIT_STATUS
);
315 translate(SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
);
316 translate(SSH1_MSG_CHANNEL_OPEN_FAILURE
);
317 translate(SSH1_MSG_CHANNEL_DATA
);
318 translate(SSH1_MSG_CHANNEL_CLOSE
);
319 translate(SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
);
320 translate(SSH1_SMSG_X11_OPEN
);
321 translate(SSH1_CMSG_PORT_FORWARD_REQUEST
);
322 translate(SSH1_MSG_PORT_OPEN
);
323 translate(SSH1_CMSG_AGENT_REQUEST_FORWARDING
);
324 translate(SSH1_SMSG_AGENT_OPEN
);
325 translate(SSH1_MSG_IGNORE
);
326 translate(SSH1_CMSG_EXIT_CONFIRMATION
);
327 translate(SSH1_CMSG_X11_REQUEST_FORWARDING
);
328 translate(SSH1_CMSG_AUTH_RHOSTS_RSA
);
329 translate(SSH1_MSG_DEBUG
);
330 translate(SSH1_CMSG_REQUEST_COMPRESSION
);
331 translate(SSH1_CMSG_AUTH_TIS
);
332 translate(SSH1_SMSG_AUTH_TIS_CHALLENGE
);
333 translate(SSH1_CMSG_AUTH_TIS_RESPONSE
);
334 translate(SSH1_CMSG_AUTH_CCARD
);
335 translate(SSH1_SMSG_AUTH_CCARD_CHALLENGE
);
336 translate(SSH1_CMSG_AUTH_CCARD_RESPONSE
);
339 static char *ssh2_pkt_type(Pkt_KCtx pkt_kctx
, Pkt_ACtx pkt_actx
, int type
)
341 translate(SSH2_MSG_DISCONNECT
);
342 translate(SSH2_MSG_IGNORE
);
343 translate(SSH2_MSG_UNIMPLEMENTED
);
344 translate(SSH2_MSG_DEBUG
);
345 translate(SSH2_MSG_SERVICE_REQUEST
);
346 translate(SSH2_MSG_SERVICE_ACCEPT
);
347 translate(SSH2_MSG_KEXINIT
);
348 translate(SSH2_MSG_NEWKEYS
);
349 translatek(SSH2_MSG_KEXDH_INIT
, SSH2_PKTCTX_DHGROUP
);
350 translatek(SSH2_MSG_KEXDH_REPLY
, SSH2_PKTCTX_DHGROUP
);
351 translatek(SSH2_MSG_KEX_DH_GEX_REQUEST
, SSH2_PKTCTX_DHGEX
);
352 translatek(SSH2_MSG_KEX_DH_GEX_GROUP
, SSH2_PKTCTX_DHGEX
);
353 translatek(SSH2_MSG_KEX_DH_GEX_INIT
, SSH2_PKTCTX_DHGEX
);
354 translatek(SSH2_MSG_KEX_DH_GEX_REPLY
, SSH2_PKTCTX_DHGEX
);
355 translatek(SSH2_MSG_KEXRSA_PUBKEY
, SSH2_PKTCTX_RSAKEX
);
356 translatek(SSH2_MSG_KEXRSA_SECRET
, SSH2_PKTCTX_RSAKEX
);
357 translatek(SSH2_MSG_KEXRSA_DONE
, SSH2_PKTCTX_RSAKEX
);
358 translate(SSH2_MSG_USERAUTH_REQUEST
);
359 translate(SSH2_MSG_USERAUTH_FAILURE
);
360 translate(SSH2_MSG_USERAUTH_SUCCESS
);
361 translate(SSH2_MSG_USERAUTH_BANNER
);
362 translatea(SSH2_MSG_USERAUTH_PK_OK
, SSH2_PKTCTX_PUBLICKEY
);
363 translatea(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ
, SSH2_PKTCTX_PASSWORD
);
364 translatea(SSH2_MSG_USERAUTH_INFO_REQUEST
, SSH2_PKTCTX_KBDINTER
);
365 translatea(SSH2_MSG_USERAUTH_INFO_RESPONSE
, SSH2_PKTCTX_KBDINTER
);
366 translate(SSH2_MSG_GLOBAL_REQUEST
);
367 translate(SSH2_MSG_REQUEST_SUCCESS
);
368 translate(SSH2_MSG_REQUEST_FAILURE
);
369 translate(SSH2_MSG_CHANNEL_OPEN
);
370 translate(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
);
371 translate(SSH2_MSG_CHANNEL_OPEN_FAILURE
);
372 translate(SSH2_MSG_CHANNEL_WINDOW_ADJUST
);
373 translate(SSH2_MSG_CHANNEL_DATA
);
374 translate(SSH2_MSG_CHANNEL_EXTENDED_DATA
);
375 translate(SSH2_MSG_CHANNEL_EOF
);
376 translate(SSH2_MSG_CHANNEL_CLOSE
);
377 translate(SSH2_MSG_CHANNEL_REQUEST
);
378 translate(SSH2_MSG_CHANNEL_SUCCESS
);
379 translate(SSH2_MSG_CHANNEL_FAILURE
);
385 /* Enumeration values for fields in SSH-1 packets */
387 PKT_END
, PKT_INT
, PKT_CHAR
, PKT_DATA
, PKT_STR
, PKT_BIGNUM
,
388 /* These values are for communicating relevant semantics of
389 * fields to the packet logging code. */
390 PKTT_OTHER
, PKTT_PASSWORD
, PKTT_DATA
394 * Coroutine mechanics for the sillier bits of the code. If these
395 * macros look impenetrable to you, you might find it helpful to
398 * http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
400 * which explains the theory behind these macros.
402 * In particular, if you are getting `case expression not constant'
403 * errors when building with MS Visual Studio, this is because MS's
404 * Edit and Continue debugging feature causes their compiler to
405 * violate ANSI C. To disable Edit and Continue debugging:
407 * - right-click ssh.c in the FileView
409 * - select the C/C++ tab and the General category
410 * - under `Debug info:', select anything _other_ than `Program
411 * Database for Edit and Continue'.
413 #define crBegin(v) { int *crLine = &v; switch(v) { case 0:;
416 if (!ssh->t) ssh->t = snew(struct t); \
418 #define crFinish(z) } *crLine = 0; return (z); }
419 #define crFinishV } *crLine = 0; return; }
420 #define crReturn(z) \
422 *crLine =__LINE__; return (z); case __LINE__:;\
426 *crLine=__LINE__; return; case __LINE__:;\
428 #define crStop(z) do{ *crLine = 0; return (z); }while(0)
429 #define crStopV do{ *crLine = 0; return; }while(0)
430 #define crWaitUntil(c) do { crReturn(0); } while (!(c))
431 #define crWaitUntilV(c) do { crReturnV; } while (!(c))
433 typedef struct ssh_tag
*Ssh
;
436 static struct Packet
*ssh1_pkt_init(int pkt_type
);
437 static struct Packet
*ssh2_pkt_init(int pkt_type
);
438 static void ssh_pkt_ensure(struct Packet
*, int length
);
439 static void ssh_pkt_adddata(struct Packet
*, void *data
, int len
);
440 static void ssh_pkt_addbyte(struct Packet
*, unsigned char value
);
441 static void ssh2_pkt_addbool(struct Packet
*, unsigned char value
);
442 static void ssh_pkt_adduint32(struct Packet
*, unsigned long value
);
443 static void ssh_pkt_addstring_start(struct Packet
*);
444 static void ssh_pkt_addstring_str(struct Packet
*, char *data
);
445 static void ssh_pkt_addstring_data(struct Packet
*, char *data
, int len
);
446 static void ssh_pkt_addstring(struct Packet
*, char *data
);
447 static unsigned char *ssh2_mpint_fmt(Bignum b
, int *len
);
448 static void ssh1_pkt_addmp(struct Packet
*, Bignum b
);
449 static void ssh2_pkt_addmp(struct Packet
*, Bignum b
);
450 static int ssh2_pkt_construct(Ssh
, struct Packet
*);
451 static void ssh2_pkt_send(Ssh
, struct Packet
*);
452 static void ssh2_pkt_send_noqueue(Ssh
, struct Packet
*);
453 static int do_ssh1_login(Ssh ssh
, unsigned char *in
, int inlen
,
454 struct Packet
*pktin
);
455 static void do_ssh2_authconn(Ssh ssh
, unsigned char *in
, int inlen
,
456 struct Packet
*pktin
);
459 * Buffer management constants. There are several of these for
460 * various different purposes:
462 * - SSH1_BUFFER_LIMIT is the amount of backlog that must build up
463 * on a local data stream before we throttle the whole SSH
464 * connection (in SSH-1 only). Throttling the whole connection is
465 * pretty drastic so we set this high in the hope it won't
468 * - SSH_MAX_BACKLOG is the amount of backlog that must build up
469 * on the SSH connection itself before we defensively throttle
470 * _all_ local data streams. This is pretty drastic too (though
471 * thankfully unlikely in SSH-2 since the window mechanism should
472 * ensure that the server never has any need to throttle its end
473 * of the connection), so we set this high as well.
475 * - OUR_V2_WINSIZE is the maximum window size we present on SSH-2
478 * - OUR_V2_BIGWIN is the window size we advertise for the only
479 * channel in a simple connection. It must be <= INT_MAX.
482 #define SSH1_BUFFER_LIMIT 32768
483 #define SSH_MAX_BACKLOG 32768
484 #define OUR_V2_WINSIZE 16384
485 #define OUR_V2_BIGWIN 0x7fffffff
486 #define OUR_V2_MAXPKT 0x4000UL
488 /* Maximum length of passwords/passphrases (arbitrary) */
489 #define SSH_MAX_PASSWORD_LEN 100
491 const static struct ssh_signkey
*hostkey_algs
[] = { &ssh_rsa
, &ssh_dss
};
493 const static struct ssh_mac
*macs
[] = {
494 &ssh_hmac_sha1
, &ssh_hmac_sha1_96
, &ssh_hmac_md5
496 const static struct ssh_mac
*buggymacs
[] = {
497 &ssh_hmac_sha1_buggy
, &ssh_hmac_sha1_96_buggy
, &ssh_hmac_md5
500 static void *ssh_comp_none_init(void)
504 static void ssh_comp_none_cleanup(void *handle
)
507 static int ssh_comp_none_block(void *handle
, unsigned char *block
, int len
,
508 unsigned char **outblock
, int *outlen
)
512 static int ssh_comp_none_disable(void *handle
)
516 const static struct ssh_compress ssh_comp_none
= {
518 ssh_comp_none_init
, ssh_comp_none_cleanup
, ssh_comp_none_block
,
519 ssh_comp_none_init
, ssh_comp_none_cleanup
, ssh_comp_none_block
,
520 ssh_comp_none_disable
, NULL
522 extern const struct ssh_compress ssh_zlib
;
523 const static struct ssh_compress
*compressions
[] = {
524 &ssh_zlib
, &ssh_comp_none
527 enum { /* channel types */
532 CHAN_SOCKDATA_DORMANT
/* one the remote hasn't confirmed */
536 * little structure to keep track of outstanding WINDOW_ADJUSTs
544 * 2-3-4 tree storing channels.
547 Ssh ssh
; /* pointer back to main context */
548 unsigned remoteid
, localid
;
550 /* True if we opened this channel but server hasn't confirmed. */
553 * In SSH-1, this value contains four bits:
555 * 1 We have sent SSH1_MSG_CHANNEL_CLOSE.
556 * 2 We have sent SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
557 * 4 We have received SSH1_MSG_CHANNEL_CLOSE.
558 * 8 We have received SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION.
560 * A channel is completely finished with when all four bits are set.
564 struct ssh1_data_channel
{
567 struct ssh2_data_channel
{
569 unsigned remwindow
, remmaxpkt
;
570 /* locwindow is signed so we can cope with excess data. */
571 int locwindow
, locmaxwin
;
573 * remlocwin is the amount of local window that we think
574 * the remote end had available to it after it sent the
575 * last data packet or window adjust ack.
579 * These store the list of window adjusts that haven't
582 struct winadj
*winadj_head
, *winadj_tail
;
583 enum { THROTTLED
, UNTHROTTLING
, UNTHROTTLED
} throttle_state
;
587 struct ssh_agent_channel
{
588 unsigned char *message
;
589 unsigned char msglen
[4];
590 unsigned lensofar
, totallen
;
592 struct ssh_x11_channel
{
595 struct ssh_pfd_channel
{
602 * 2-3-4 tree storing remote->local port forwardings. SSH-1 and SSH-2
603 * use this structure in different ways, reflecting SSH-2's
604 * altogether saner approach to port forwarding.
606 * In SSH-1, you arrange a remote forwarding by sending the server
607 * the remote port number, and the local destination host:port.
608 * When a connection comes in, the server sends you back that
609 * host:port pair, and you connect to it. This is a ready-made
610 * security hole if you're not on the ball: a malicious server
611 * could send you back _any_ host:port pair, so if you trustingly
612 * connect to the address it gives you then you've just opened the
613 * entire inside of your corporate network just by connecting
614 * through it to a dodgy SSH server. Hence, we must store a list of
615 * host:port pairs we _are_ trying to forward to, and reject a
616 * connection request from the server if it's not in the list.
618 * In SSH-2, each side of the connection minds its own business and
619 * doesn't send unnecessary information to the other. You arrange a
620 * remote forwarding by sending the server just the remote port
621 * number. When a connection comes in, the server tells you which
622 * of its ports was connected to; and _you_ have to remember what
623 * local host:port pair went with that port number.
625 * Hence, in SSH-1 this structure is indexed by destination
626 * host:port pair, whereas in SSH-2 it is indexed by source port.
628 struct ssh_portfwd
; /* forward declaration */
630 struct ssh_rportfwd
{
631 unsigned sport
, dport
;
634 struct ssh_portfwd
*pfrec
;
636 #define free_rportfwd(pf) ( \
637 ((pf) ? (sfree((pf)->sportdesc)) : (void)0 ), sfree(pf) )
640 * Separately to the rportfwd tree (which is for looking up port
641 * open requests from the server), a tree of _these_ structures is
642 * used to keep track of all the currently open port forwardings,
643 * so that we can reconfigure in mid-session if the user requests
647 enum { DESTROY
, KEEP
, CREATE
} status
;
649 unsigned sport
, dport
;
652 struct ssh_rportfwd
*remote
;
656 #define free_portfwd(pf) ( \
657 ((pf) ? (sfree((pf)->saddr), sfree((pf)->daddr), \
658 sfree((pf)->sserv), sfree((pf)->dserv)) : (void)0 ), sfree(pf) )
661 long length
; /* length of `data' actually used */
662 long forcepad
; /* SSH-2: force padding to at least this length */
663 int type
; /* only used for incoming packets */
664 unsigned long sequence
; /* SSH-2 incoming sequence number */
665 unsigned char *data
; /* allocated storage */
666 unsigned char *body
; /* offset of payload within `data' */
667 long savedpos
; /* temporary index into `data' (for strings) */
668 long maxlen
; /* amount of storage allocated for `data' */
669 long encrypted_len
; /* for SSH-2 total-size counting */
672 * State associated with packet logging
676 struct logblank_t
*blanks
;
679 static void ssh1_protocol(Ssh ssh
, void *vin
, int inlen
,
680 struct Packet
*pktin
);
681 static void ssh2_protocol(Ssh ssh
, void *vin
, int inlen
,
682 struct Packet
*pktin
);
683 static void ssh1_protocol_setup(Ssh ssh
);
684 static void ssh2_protocol_setup(Ssh ssh
);
685 static void ssh_size(void *handle
, int width
, int height
);
686 static void ssh_special(void *handle
, Telnet_Special
);
687 static int ssh2_try_send(struct ssh_channel
*c
);
688 static void ssh2_add_channel_data(struct ssh_channel
*c
, char *buf
, int len
);
689 static void ssh_throttle_all(Ssh ssh
, int enable
, int bufsize
);
690 static void ssh2_set_window(struct ssh_channel
*c
, int newwin
);
691 static int ssh_sendbuffer(void *handle
);
692 static int ssh_do_close(Ssh ssh
, int notify_exit
);
693 static unsigned long ssh_pkt_getuint32(struct Packet
*pkt
);
694 static int ssh2_pkt_getbool(struct Packet
*pkt
);
695 static void ssh_pkt_getstring(struct Packet
*pkt
, char **p
, int *length
);
696 static void ssh2_timer(void *ctx
, long now
);
697 static int do_ssh2_transport(Ssh ssh
, void *vin
, int inlen
,
698 struct Packet
*pktin
);
700 struct rdpkt1_state_tag
{
701 long len
, pad
, biglen
, to_read
;
702 unsigned long realcrc
, gotcrc
;
706 struct Packet
*pktin
;
709 struct rdpkt2_state_tag
{
710 long len
, pad
, payload
, packetlen
, maclen
;
713 unsigned long incoming_sequence
;
714 struct Packet
*pktin
;
717 typedef void (*handler_fn_t
)(Ssh ssh
, struct Packet
*pktin
);
718 typedef void (*chandler_fn_t
)(Ssh ssh
, struct Packet
*pktin
, void *ctx
);
720 struct queued_handler
;
721 struct queued_handler
{
723 chandler_fn_t handler
;
725 struct queued_handler
*next
;
729 const struct plug_function_table
*fn
;
730 /* the above field _must_ be first in the structure */
740 unsigned char session_key
[32];
742 int v1_remote_protoflags
;
743 int v1_local_protoflags
;
744 int agentfwd_enabled
;
747 const struct ssh_cipher
*cipher
;
750 const struct ssh2_cipher
*cscipher
, *sccipher
;
751 void *cs_cipher_ctx
, *sc_cipher_ctx
;
752 const struct ssh_mac
*csmac
, *scmac
;
753 void *cs_mac_ctx
, *sc_mac_ctx
;
754 const struct ssh_compress
*cscomp
, *sccomp
;
755 void *cs_comp_ctx
, *sc_comp_ctx
;
756 const struct ssh_kex
*kex
;
757 const struct ssh_signkey
*hostkey
;
758 unsigned char v2_session_id
[SSH2_KEX_MAX_HASH_LEN
];
759 int v2_session_id_len
;
765 int echoing
, editing
;
769 int ospeed
, ispeed
; /* temporaries */
770 int term_width
, term_height
;
772 tree234
*channels
; /* indexed by local id */
773 struct ssh_channel
*mainchan
; /* primary session channel */
774 int ncmode
; /* is primary channel direct-tcpip? */
779 tree234
*rportfwds
, *portfwds
;
783 SSH_STATE_BEFORE_SIZE
,
789 int size_needed
, eof_needed
;
791 struct Packet
**queue
;
792 int queuelen
, queuesize
;
794 unsigned char *deferred_send_data
;
795 int deferred_len
, deferred_size
;
798 * Gross hack: pscp will try to start SFTP but fall back to
799 * scp1 if that fails. This variable is the means by which
800 * scp.c can reach into the SSH code and find out which one it
805 bufchain banner
; /* accumulates banners during do_ssh2_authconn */
813 int v1_throttle_count
;
816 int v1_stdout_throttling
;
817 unsigned long v2_outgoing_sequence
;
819 int ssh1_rdpkt_crstate
;
820 int ssh2_rdpkt_crstate
;
821 int do_ssh_init_crstate
;
822 int ssh_gotdata_crstate
;
823 int do_ssh1_login_crstate
;
824 int do_ssh1_connection_crstate
;
825 int do_ssh2_transport_crstate
;
826 int do_ssh2_authconn_crstate
;
828 void *do_ssh_init_state
;
829 void *do_ssh1_login_state
;
830 void *do_ssh2_transport_state
;
831 void *do_ssh2_authconn_state
;
833 struct rdpkt1_state_tag rdpkt1_state
;
834 struct rdpkt2_state_tag rdpkt2_state
;
836 /* SSH-1 and SSH-2 use this for different things, but both use it */
837 int protocol_initial_phase_done
;
839 void (*protocol
) (Ssh ssh
, void *vin
, int inlen
,
841 struct Packet
*(*s_rdpkt
) (Ssh ssh
, unsigned char **data
, int *datalen
);
844 * We maintain a full _copy_ of a Config structure here, not
845 * merely a pointer to it. That way, when we're passed a new
846 * one for reconfiguration, we can check the differences and
847 * potentially reconfigure port forwardings etc in mid-session.
852 * Used to transfer data back from async callbacks.
854 void *agent_response
;
855 int agent_response_len
;
859 * The SSH connection can be set as `frozen', meaning we are
860 * not currently accepting incoming data from the network. This
861 * is slightly more serious than setting the _socket_ as
862 * frozen, because we may already have had data passed to us
863 * from the network which we need to delay processing until
864 * after the freeze is lifted, so we also need a bufchain to
868 bufchain queued_incoming_data
;
871 * Dispatch table for packet types that we may have to deal
874 handler_fn_t packet_dispatch
[256];
877 * Queues of one-off handler functions for success/failure
878 * indications from a request.
880 struct queued_handler
*qhead
, *qtail
;
883 * This module deals with sending keepalives.
888 * Track incoming and outgoing data sizes and time, for
891 unsigned long incoming_data_size
, outgoing_data_size
, deferred_data_size
;
892 unsigned long max_data_size
;
894 long next_rekey
, last_rekey
;
895 char *deferred_rekey_reason
; /* points to STATIC string; don't free */
898 #define logevent(s) logevent(ssh->frontend, s)
900 /* logevent, only printf-formatted. */
901 static void logeventf(Ssh ssh
, const char *fmt
, ...)
907 buf
= dupvprintf(fmt
, ap
);
913 #define bombout(msg) \
915 char *text = dupprintf msg; \
916 ssh_do_close(ssh, FALSE); \
918 connection_fatal(ssh->frontend, "%s", text); \
922 /* Functions to leave bits out of the SSH packet log file. */
924 static void dont_log_password(Ssh ssh
, struct Packet
*pkt
, int blanktype
)
926 if (ssh
->cfg
.logomitpass
)
927 pkt
->logmode
= blanktype
;
930 static void dont_log_data(Ssh ssh
, struct Packet
*pkt
, int blanktype
)
932 if (ssh
->cfg
.logomitdata
)
933 pkt
->logmode
= blanktype
;
936 static void end_log_omission(Ssh ssh
, struct Packet
*pkt
)
938 pkt
->logmode
= PKTLOG_EMIT
;
941 /* Helper function for common bits of parsing cfg.ttymodes. */
942 static void parse_ttymodes(Ssh ssh
, char *modes
,
943 void (*do_mode
)(void *data
, char *mode
, char *val
),
947 char *t
= strchr(modes
, '\t');
948 char *m
= snewn(t
-modes
+1, char);
950 strncpy(m
, modes
, t
-modes
);
953 val
= get_ttymode(ssh
->frontend
, m
);
957 do_mode(data
, m
, val
);
960 modes
+= strlen(modes
) + 1;
964 static int ssh_channelcmp(void *av
, void *bv
)
966 struct ssh_channel
*a
= (struct ssh_channel
*) av
;
967 struct ssh_channel
*b
= (struct ssh_channel
*) bv
;
968 if (a
->localid
< b
->localid
)
970 if (a
->localid
> b
->localid
)
974 static int ssh_channelfind(void *av
, void *bv
)
976 unsigned *a
= (unsigned *) av
;
977 struct ssh_channel
*b
= (struct ssh_channel
*) bv
;
985 static int ssh_rportcmp_ssh1(void *av
, void *bv
)
987 struct ssh_rportfwd
*a
= (struct ssh_rportfwd
*) av
;
988 struct ssh_rportfwd
*b
= (struct ssh_rportfwd
*) bv
;
990 if ( (i
= strcmp(a
->dhost
, b
->dhost
)) != 0)
991 return i
< 0 ?
-1 : +1;
992 if (a
->dport
> b
->dport
)
994 if (a
->dport
< b
->dport
)
999 static int ssh_rportcmp_ssh2(void *av
, void *bv
)
1001 struct ssh_rportfwd
*a
= (struct ssh_rportfwd
*) av
;
1002 struct ssh_rportfwd
*b
= (struct ssh_rportfwd
*) bv
;
1004 if (a
->sport
> b
->sport
)
1006 if (a
->sport
< b
->sport
)
1012 * Special form of strcmp which can cope with NULL inputs. NULL is
1013 * defined to sort before even the empty string.
1015 static int nullstrcmp(const char *a
, const char *b
)
1017 if (a
== NULL
&& b
== NULL
)
1023 return strcmp(a
, b
);
1026 static int ssh_portcmp(void *av
, void *bv
)
1028 struct ssh_portfwd
*a
= (struct ssh_portfwd
*) av
;
1029 struct ssh_portfwd
*b
= (struct ssh_portfwd
*) bv
;
1031 if (a
->type
> b
->type
)
1033 if (a
->type
< b
->type
)
1035 if (a
->addressfamily
> b
->addressfamily
)
1037 if (a
->addressfamily
< b
->addressfamily
)
1039 if ( (i
= nullstrcmp(a
->saddr
, b
->saddr
)) != 0)
1040 return i
< 0 ?
-1 : +1;
1041 if (a
->sport
> b
->sport
)
1043 if (a
->sport
< b
->sport
)
1045 if (a
->type
!= 'D') {
1046 if ( (i
= nullstrcmp(a
->daddr
, b
->daddr
)) != 0)
1047 return i
< 0 ?
-1 : +1;
1048 if (a
->dport
> b
->dport
)
1050 if (a
->dport
< b
->dport
)
1056 static int alloc_channel_id(Ssh ssh
)
1058 const unsigned CHANNEL_NUMBER_OFFSET
= 256;
1059 unsigned low
, high
, mid
;
1061 struct ssh_channel
*c
;
1064 * First-fit allocation of channel numbers: always pick the
1065 * lowest unused one. To do this, binary-search using the
1066 * counted B-tree to find the largest channel ID which is in a
1067 * contiguous sequence from the beginning. (Precisely
1068 * everything in that sequence must have ID equal to its tree
1069 * index plus CHANNEL_NUMBER_OFFSET.)
1071 tsize
= count234(ssh
->channels
);
1075 while (high
- low
> 1) {
1076 mid
= (high
+ low
) / 2;
1077 c
= index234(ssh
->channels
, mid
);
1078 if (c
->localid
== mid
+ CHANNEL_NUMBER_OFFSET
)
1079 low
= mid
; /* this one is fine */
1081 high
= mid
; /* this one is past it */
1084 * Now low points to either -1, or the tree index of the
1085 * largest ID in the initial sequence.
1088 unsigned i
= low
+ 1 + CHANNEL_NUMBER_OFFSET
;
1089 assert(NULL
== find234(ssh
->channels
, &i
, ssh_channelfind
));
1091 return low
+ 1 + CHANNEL_NUMBER_OFFSET
;
1094 static void c_write_stderr(int trusted
, const char *buf
, int len
)
1097 for (i
= 0; i
< len
; i
++)
1098 if (buf
[i
] != '\r' && (trusted
|| buf
[i
] == '\n' || (buf
[i
] & 0x60)))
1099 fputc(buf
[i
], stderr
);
1102 static void c_write(Ssh ssh
, const char *buf
, int len
)
1104 if (flags
& FLAG_STDERR
)
1105 c_write_stderr(1, buf
, len
);
1107 from_backend(ssh
->frontend
, 1, buf
, len
);
1110 static void c_write_untrusted(Ssh ssh
, const char *buf
, int len
)
1112 if (flags
& FLAG_STDERR
)
1113 c_write_stderr(0, buf
, len
);
1115 from_backend_untrusted(ssh
->frontend
, buf
, len
);
1118 static void c_write_str(Ssh ssh
, const char *buf
)
1120 c_write(ssh
, buf
, strlen(buf
));
1123 static void ssh_free_packet(struct Packet
*pkt
)
1128 static struct Packet
*ssh_new_packet(void)
1130 struct Packet
*pkt
= snew(struct Packet
);
1132 pkt
->body
= pkt
->data
= NULL
;
1134 pkt
->logmode
= PKTLOG_EMIT
;
1142 * Collect incoming data in the incoming packet buffer.
1143 * Decipher and verify the packet when it is completely read.
1144 * Drop SSH1_MSG_DEBUG and SSH1_MSG_IGNORE packets.
1145 * Update the *data and *datalen variables.
1146 * Return a Packet structure when a packet is completed.
1148 static struct Packet
*ssh1_rdpkt(Ssh ssh
, unsigned char **data
, int *datalen
)
1150 struct rdpkt1_state_tag
*st
= &ssh
->rdpkt1_state
;
1152 crBegin(ssh
->ssh1_rdpkt_crstate
);
1154 st
->pktin
= ssh_new_packet();
1156 st
->pktin
->type
= 0;
1157 st
->pktin
->length
= 0;
1159 for (st
->i
= st
->len
= 0; st
->i
< 4; st
->i
++) {
1160 while ((*datalen
) == 0)
1162 st
->len
= (st
->len
<< 8) + **data
;
1163 (*data
)++, (*datalen
)--;
1166 st
->pad
= 8 - (st
->len
% 8);
1167 st
->biglen
= st
->len
+ st
->pad
;
1168 st
->pktin
->length
= st
->len
- 5;
1170 if (st
->biglen
< 0) {
1171 bombout(("Extremely large packet length from server suggests"
1172 " data stream corruption"));
1173 ssh_free_packet(st
->pktin
);
1177 st
->pktin
->maxlen
= st
->biglen
;
1178 st
->pktin
->data
= snewn(st
->biglen
+ APIEXTRA
, unsigned char);
1180 st
->to_read
= st
->biglen
;
1181 st
->p
= st
->pktin
->data
;
1182 while (st
->to_read
> 0) {
1183 st
->chunk
= st
->to_read
;
1184 while ((*datalen
) == 0)
1186 if (st
->chunk
> (*datalen
))
1187 st
->chunk
= (*datalen
);
1188 memcpy(st
->p
, *data
, st
->chunk
);
1190 *datalen
-= st
->chunk
;
1192 st
->to_read
-= st
->chunk
;
1195 if (ssh
->cipher
&& detect_attack(ssh
->crcda_ctx
, st
->pktin
->data
,
1196 st
->biglen
, NULL
)) {
1197 bombout(("Network attack (CRC compensation) detected!"));
1198 ssh_free_packet(st
->pktin
);
1203 ssh
->cipher
->decrypt(ssh
->v1_cipher_ctx
, st
->pktin
->data
, st
->biglen
);
1205 st
->realcrc
= crc32_compute(st
->pktin
->data
, st
->biglen
- 4);
1206 st
->gotcrc
= GET_32BIT(st
->pktin
->data
+ st
->biglen
- 4);
1207 if (st
->gotcrc
!= st
->realcrc
) {
1208 bombout(("Incorrect CRC received on packet"));
1209 ssh_free_packet(st
->pktin
);
1213 st
->pktin
->body
= st
->pktin
->data
+ st
->pad
+ 1;
1214 st
->pktin
->savedpos
= 0;
1216 if (ssh
->v1_compressing
) {
1217 unsigned char *decompblk
;
1219 if (!zlib_decompress_block(ssh
->sc_comp_ctx
,
1220 st
->pktin
->body
- 1, st
->pktin
->length
+ 1,
1221 &decompblk
, &decomplen
)) {
1222 bombout(("Zlib decompression encountered invalid data"));
1223 ssh_free_packet(st
->pktin
);
1227 if (st
->pktin
->maxlen
< st
->pad
+ decomplen
) {
1228 st
->pktin
->maxlen
= st
->pad
+ decomplen
;
1229 st
->pktin
->data
= sresize(st
->pktin
->data
,
1230 st
->pktin
->maxlen
+ APIEXTRA
,
1232 st
->pktin
->body
= st
->pktin
->data
+ st
->pad
+ 1;
1235 memcpy(st
->pktin
->body
- 1, decompblk
, decomplen
);
1237 st
->pktin
->length
= decomplen
- 1;
1240 st
->pktin
->type
= st
->pktin
->body
[-1];
1243 * Log incoming packet, possibly omitting sensitive fields.
1247 struct logblank_t blank
;
1248 if (ssh
->cfg
.logomitdata
) {
1249 int do_blank
= FALSE
, blank_prefix
= 0;
1250 /* "Session data" packets - omit the data field */
1251 if ((st
->pktin
->type
== SSH1_SMSG_STDOUT_DATA
) ||
1252 (st
->pktin
->type
== SSH1_SMSG_STDERR_DATA
)) {
1253 do_blank
= TRUE
; blank_prefix
= 4;
1254 } else if (st
->pktin
->type
== SSH1_MSG_CHANNEL_DATA
) {
1255 do_blank
= TRUE
; blank_prefix
= 8;
1258 blank
.offset
= blank_prefix
;
1259 blank
.len
= st
->pktin
->length
;
1260 blank
.type
= PKTLOG_OMIT
;
1264 log_packet(ssh
->logctx
,
1265 PKT_INCOMING
, st
->pktin
->type
,
1266 ssh1_pkt_type(st
->pktin
->type
),
1267 st
->pktin
->body
, st
->pktin
->length
,
1271 crFinish(st
->pktin
);
1274 static struct Packet
*ssh2_rdpkt(Ssh ssh
, unsigned char **data
, int *datalen
)
1276 struct rdpkt2_state_tag
*st
= &ssh
->rdpkt2_state
;
1278 crBegin(ssh
->ssh2_rdpkt_crstate
);
1280 st
->pktin
= ssh_new_packet();
1282 st
->pktin
->type
= 0;
1283 st
->pktin
->length
= 0;
1285 st
->cipherblk
= ssh
->sccipher
->blksize
;
1288 if (st
->cipherblk
< 8)
1291 st
->pktin
->data
= snewn(st
->cipherblk
+ APIEXTRA
, unsigned char);
1294 * Acquire and decrypt the first block of the packet. This will
1295 * contain the length and padding details.
1297 for (st
->i
= st
->len
= 0; st
->i
< st
->cipherblk
; st
->i
++) {
1298 while ((*datalen
) == 0)
1300 st
->pktin
->data
[st
->i
] = *(*data
)++;
1305 ssh
->sccipher
->decrypt(ssh
->sc_cipher_ctx
,
1306 st
->pktin
->data
, st
->cipherblk
);
1309 * Now get the length and padding figures.
1311 st
->len
= GET_32BIT(st
->pktin
->data
);
1312 st
->pad
= st
->pktin
->data
[4];
1315 * _Completely_ silly lengths should be stomped on before they
1316 * do us any more damage.
1318 if (st
->len
< 0 || st
->len
> 35000 || st
->pad
< 4 ||
1319 st
->len
- st
->pad
< 1 || (st
->len
+ 4) % st
->cipherblk
!= 0) {
1320 bombout(("Incoming packet was garbled on decryption"));
1321 ssh_free_packet(st
->pktin
);
1326 * This enables us to deduce the payload length.
1328 st
->payload
= st
->len
- st
->pad
- 1;
1330 st
->pktin
->length
= st
->payload
+ 5;
1333 * So now we can work out the total packet length.
1335 st
->packetlen
= st
->len
+ 4;
1336 st
->maclen
= ssh
->scmac ? ssh
->scmac
->len
: 0;
1339 * Allocate memory for the rest of the packet.
1341 st
->pktin
->maxlen
= st
->packetlen
+ st
->maclen
;
1342 st
->pktin
->data
= sresize(st
->pktin
->data
,
1343 st
->pktin
->maxlen
+ APIEXTRA
,
1347 * Read and decrypt the remainder of the packet.
1349 for (st
->i
= st
->cipherblk
; st
->i
< st
->packetlen
+ st
->maclen
;
1351 while ((*datalen
) == 0)
1353 st
->pktin
->data
[st
->i
] = *(*data
)++;
1356 /* Decrypt everything _except_ the MAC. */
1358 ssh
->sccipher
->decrypt(ssh
->sc_cipher_ctx
,
1359 st
->pktin
->data
+ st
->cipherblk
,
1360 st
->packetlen
- st
->cipherblk
);
1362 st
->pktin
->encrypted_len
= st
->packetlen
;
1368 && !ssh
->scmac
->verify(ssh
->sc_mac_ctx
, st
->pktin
->data
, st
->len
+ 4,
1369 st
->incoming_sequence
)) {
1370 bombout(("Incorrect MAC received on packet"));
1371 ssh_free_packet(st
->pktin
);
1375 st
->pktin
->sequence
= st
->incoming_sequence
++;
1378 * Decompress packet payload.
1381 unsigned char *newpayload
;
1384 ssh
->sccomp
->decompress(ssh
->sc_comp_ctx
,
1385 st
->pktin
->data
+ 5, st
->pktin
->length
- 5,
1386 &newpayload
, &newlen
)) {
1387 if (st
->pktin
->maxlen
< newlen
+ 5) {
1388 st
->pktin
->maxlen
= newlen
+ 5;
1389 st
->pktin
->data
= sresize(st
->pktin
->data
,
1390 st
->pktin
->maxlen
+ APIEXTRA
,
1393 st
->pktin
->length
= 5 + newlen
;
1394 memcpy(st
->pktin
->data
+ 5, newpayload
, newlen
);
1399 st
->pktin
->savedpos
= 6;
1400 st
->pktin
->body
= st
->pktin
->data
;
1401 st
->pktin
->type
= st
->pktin
->data
[5];
1404 * Log incoming packet, possibly omitting sensitive fields.
1408 struct logblank_t blank
;
1409 if (ssh
->cfg
.logomitdata
) {
1410 int do_blank
= FALSE
, blank_prefix
= 0;
1411 /* "Session data" packets - omit the data field */
1412 if (st
->pktin
->type
== SSH2_MSG_CHANNEL_DATA
) {
1413 do_blank
= TRUE
; blank_prefix
= 8;
1414 } else if (st
->pktin
->type
== SSH2_MSG_CHANNEL_EXTENDED_DATA
) {
1415 do_blank
= TRUE
; blank_prefix
= 12;
1418 blank
.offset
= blank_prefix
;
1419 blank
.len
= (st
->pktin
->length
-6) - blank_prefix
;
1420 blank
.type
= PKTLOG_OMIT
;
1424 log_packet(ssh
->logctx
, PKT_INCOMING
, st
->pktin
->type
,
1425 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
,
1427 st
->pktin
->data
+6, st
->pktin
->length
-6,
1431 crFinish(st
->pktin
);
1434 static int s_wrpkt_prepare(Ssh ssh
, struct Packet
*pkt
, int *offset_p
)
1436 int pad
, biglen
, i
, pktoffs
;
1440 * XXX various versions of SC (including 8.8.4) screw up the
1441 * register allocation in this function and use the same register
1442 * (D6) for len and as a temporary, with predictable results. The
1443 * following sledgehammer prevents this.
1450 log_packet(ssh
->logctx
, PKT_OUTGOING
, pkt
->data
[12],
1451 ssh1_pkt_type(pkt
->data
[12]),
1452 pkt
->body
, pkt
->length
- (pkt
->body
- pkt
->data
),
1453 pkt
->nblanks
, pkt
->blanks
);
1454 sfree(pkt
->blanks
); pkt
->blanks
= NULL
;
1457 if (ssh
->v1_compressing
) {
1458 unsigned char *compblk
;
1460 zlib_compress_block(ssh
->cs_comp_ctx
,
1461 pkt
->data
+ 12, pkt
->length
- 12,
1462 &compblk
, &complen
);
1463 ssh_pkt_ensure(pkt
, complen
+ 2); /* just in case it's got bigger */
1464 memcpy(pkt
->data
+ 12, compblk
, complen
);
1466 pkt
->length
= complen
+ 12;
1469 ssh_pkt_ensure(pkt
, pkt
->length
+ 4); /* space for CRC */
1471 len
= pkt
->length
- 4 - 8; /* len(type+data+CRC) */
1472 pad
= 8 - (len
% 8);
1474 biglen
= len
+ pad
; /* len(padding+type+data+CRC) */
1476 for (i
= pktoffs
; i
< 4+8; i
++)
1477 pkt
->data
[i
] = random_byte();
1478 crc
= crc32_compute(pkt
->data
+ pktoffs
+ 4, biglen
- 4); /* all ex len */
1479 PUT_32BIT(pkt
->data
+ pktoffs
+ 4 + biglen
- 4, crc
);
1480 PUT_32BIT(pkt
->data
+ pktoffs
, len
);
1483 ssh
->cipher
->encrypt(ssh
->v1_cipher_ctx
,
1484 pkt
->data
+ pktoffs
+ 4, biglen
);
1486 if (offset_p
) *offset_p
= pktoffs
;
1487 return biglen
+ 4; /* len(length+padding+type+data+CRC) */
1490 static int s_write(Ssh ssh
, void *data
, int len
)
1493 log_packet(ssh
->logctx
, PKT_OUTGOING
, -1, NULL
, data
, len
, 0, NULL
);
1494 return sk_write(ssh
->s
, (char *)data
, len
);
1497 static void s_wrpkt(Ssh ssh
, struct Packet
*pkt
)
1499 int len
, backlog
, offset
;
1500 len
= s_wrpkt_prepare(ssh
, pkt
, &offset
);
1501 backlog
= s_write(ssh
, pkt
->data
+ offset
, len
);
1502 if (backlog
> SSH_MAX_BACKLOG
)
1503 ssh_throttle_all(ssh
, 1, backlog
);
1504 ssh_free_packet(pkt
);
1507 static void s_wrpkt_defer(Ssh ssh
, struct Packet
*pkt
)
1510 len
= s_wrpkt_prepare(ssh
, pkt
, &offset
);
1511 if (ssh
->deferred_len
+ len
> ssh
->deferred_size
) {
1512 ssh
->deferred_size
= ssh
->deferred_len
+ len
+ 128;
1513 ssh
->deferred_send_data
= sresize(ssh
->deferred_send_data
,
1517 memcpy(ssh
->deferred_send_data
+ ssh
->deferred_len
,
1518 pkt
->data
+ offset
, len
);
1519 ssh
->deferred_len
+= len
;
1520 ssh_free_packet(pkt
);
1524 * Construct a SSH-1 packet with the specified contents.
1525 * (This all-at-once interface used to be the only one, but now SSH-1
1526 * packets can also be constructed incrementally.)
1528 static struct Packet
*construct_packet(Ssh ssh
, int pkttype
, va_list ap
)
1534 pkt
= ssh1_pkt_init(pkttype
);
1536 while ((argtype
= va_arg(ap
, int)) != PKT_END
) {
1537 unsigned char *argp
, argchar
;
1539 unsigned long argint
;
1542 /* Actual fields in the packet */
1544 argint
= va_arg(ap
, int);
1545 ssh_pkt_adduint32(pkt
, argint
);
1548 argchar
= (unsigned char) va_arg(ap
, int);
1549 ssh_pkt_addbyte(pkt
, argchar
);
1552 argp
= va_arg(ap
, unsigned char *);
1553 arglen
= va_arg(ap
, int);
1554 ssh_pkt_adddata(pkt
, argp
, arglen
);
1557 sargp
= va_arg(ap
, char *);
1558 ssh_pkt_addstring(pkt
, sargp
);
1561 bn
= va_arg(ap
, Bignum
);
1562 ssh1_pkt_addmp(pkt
, bn
);
1564 /* Tokens for modifications to packet logging */
1566 dont_log_password(ssh
, pkt
, PKTLOG_BLANK
);
1569 dont_log_data(ssh
, pkt
, PKTLOG_OMIT
);
1572 end_log_omission(ssh
, pkt
);
1580 static void send_packet(Ssh ssh
, int pkttype
, ...)
1584 va_start(ap
, pkttype
);
1585 pkt
= construct_packet(ssh
, pkttype
, ap
);
1590 static void defer_packet(Ssh ssh
, int pkttype
, ...)
1594 va_start(ap
, pkttype
);
1595 pkt
= construct_packet(ssh
, pkttype
, ap
);
1597 s_wrpkt_defer(ssh
, pkt
);
1600 static int ssh_versioncmp(char *a
, char *b
)
1603 unsigned long av
, bv
;
1605 av
= strtoul(a
, &ae
, 10);
1606 bv
= strtoul(b
, &be
, 10);
1608 return (av
< bv ?
-1 : +1);
1613 av
= strtoul(ae
, &ae
, 10);
1614 bv
= strtoul(be
, &be
, 10);
1616 return (av
< bv ?
-1 : +1);
1621 * Utility routines for putting an SSH-protocol `string' and
1622 * `uint32' into a hash state.
1624 static void hash_string(const struct ssh_hash
*h
, void *s
, void *str
, int len
)
1626 unsigned char lenblk
[4];
1627 PUT_32BIT(lenblk
, len
);
1628 h
->bytes(s
, lenblk
, 4);
1629 h
->bytes(s
, str
, len
);
1632 static void hash_uint32(const struct ssh_hash
*h
, void *s
, unsigned i
)
1634 unsigned char intblk
[4];
1635 PUT_32BIT(intblk
, i
);
1636 h
->bytes(s
, intblk
, 4);
1640 * Packet construction functions. Mostly shared between SSH-1 and SSH-2.
1642 static void ssh_pkt_ensure(struct Packet
*pkt
, int length
)
1644 if (pkt
->maxlen
< length
) {
1645 unsigned char *body
= pkt
->body
;
1646 int offset
= body ? body
- pkt
->data
: 0;
1647 pkt
->maxlen
= length
+ 256;
1648 pkt
->data
= sresize(pkt
->data
, pkt
->maxlen
+ APIEXTRA
, unsigned char);
1649 if (body
) pkt
->body
= pkt
->data
+ offset
;
1652 static void ssh_pkt_adddata(struct Packet
*pkt
, void *data
, int len
)
1654 if (pkt
->logmode
!= PKTLOG_EMIT
) {
1656 pkt
->blanks
= sresize(pkt
->blanks
, pkt
->nblanks
, struct logblank_t
);
1658 pkt
->blanks
[pkt
->nblanks
-1].offset
= pkt
->length
-
1659 (pkt
->body
- pkt
->data
);
1660 pkt
->blanks
[pkt
->nblanks
-1].len
= len
;
1661 pkt
->blanks
[pkt
->nblanks
-1].type
= pkt
->logmode
;
1664 ssh_pkt_ensure(pkt
, pkt
->length
);
1665 memcpy(pkt
->data
+ pkt
->length
- len
, data
, len
);
1667 static void ssh_pkt_addbyte(struct Packet
*pkt
, unsigned char byte
)
1669 ssh_pkt_adddata(pkt
, &byte
, 1);
1671 static void ssh2_pkt_addbool(struct Packet
*pkt
, unsigned char value
)
1673 ssh_pkt_adddata(pkt
, &value
, 1);
1675 static void ssh_pkt_adduint32(struct Packet
*pkt
, unsigned long value
)
1678 PUT_32BIT(x
, value
);
1679 ssh_pkt_adddata(pkt
, x
, 4);
1681 static void ssh_pkt_addstring_start(struct Packet
*pkt
)
1683 ssh_pkt_adduint32(pkt
, 0);
1684 pkt
->savedpos
= pkt
->length
;
1686 static void ssh_pkt_addstring_str(struct Packet
*pkt
, char *data
)
1688 ssh_pkt_adddata(pkt
, data
, strlen(data
));
1689 PUT_32BIT(pkt
->data
+ pkt
->savedpos
- 4, pkt
->length
- pkt
->savedpos
);
1691 static void ssh_pkt_addstring_data(struct Packet
*pkt
, char *data
, int len
)
1693 ssh_pkt_adddata(pkt
, data
, len
);
1694 PUT_32BIT(pkt
->data
+ pkt
->savedpos
- 4, pkt
->length
- pkt
->savedpos
);
1696 static void ssh_pkt_addstring(struct Packet
*pkt
, char *data
)
1698 ssh_pkt_addstring_start(pkt
);
1699 ssh_pkt_addstring_str(pkt
, data
);
1701 static void ssh1_pkt_addmp(struct Packet
*pkt
, Bignum b
)
1703 int len
= ssh1_bignum_length(b
);
1704 unsigned char *data
= snewn(len
, unsigned char);
1705 (void) ssh1_write_bignum(data
, b
);
1706 ssh_pkt_adddata(pkt
, data
, len
);
1709 static unsigned char *ssh2_mpint_fmt(Bignum b
, int *len
)
1712 int i
, n
= (bignum_bitcount(b
) + 7) / 8;
1713 p
= snewn(n
+ 1, unsigned char);
1715 for (i
= 1; i
<= n
; i
++)
1716 p
[i
] = bignum_byte(b
, n
- i
);
1718 while (i
<= n
&& p
[i
] == 0 && (p
[i
+ 1] & 0x80) == 0)
1720 memmove(p
, p
+ i
, n
+ 1 - i
);
1724 static void ssh2_pkt_addmp(struct Packet
*pkt
, Bignum b
)
1728 p
= ssh2_mpint_fmt(b
, &len
);
1729 ssh_pkt_addstring_start(pkt
);
1730 ssh_pkt_addstring_data(pkt
, (char *)p
, len
);
1734 static struct Packet
*ssh1_pkt_init(int pkt_type
)
1736 struct Packet
*pkt
= ssh_new_packet();
1737 pkt
->length
= 4 + 8; /* space for length + max padding */
1738 ssh_pkt_addbyte(pkt
, pkt_type
);
1739 pkt
->body
= pkt
->data
+ pkt
->length
;
1743 /* For legacy code (SSH-1 and -2 packet construction used to be separate) */
1744 #define ssh2_pkt_ensure(pkt, length) ssh_pkt_ensure(pkt, length)
1745 #define ssh2_pkt_adddata(pkt, data, len) ssh_pkt_adddata(pkt, data, len)
1746 #define ssh2_pkt_addbyte(pkt, byte) ssh_pkt_addbyte(pkt, byte)
1747 #define ssh2_pkt_adduint32(pkt, value) ssh_pkt_adduint32(pkt, value)
1748 #define ssh2_pkt_addstring_start(pkt) ssh_pkt_addstring_start(pkt)
1749 #define ssh2_pkt_addstring_str(pkt, data) ssh_pkt_addstring_str(pkt, data)
1750 #define ssh2_pkt_addstring_data(pkt, data, len) ssh_pkt_addstring_data(pkt, data, len)
1751 #define ssh2_pkt_addstring(pkt, data) ssh_pkt_addstring(pkt, data)
1753 static struct Packet
*ssh2_pkt_init(int pkt_type
)
1755 struct Packet
*pkt
= ssh_new_packet();
1756 pkt
->length
= 5; /* space for packet length + padding length */
1758 ssh_pkt_addbyte(pkt
, (unsigned char) pkt_type
);
1759 pkt
->body
= pkt
->data
+ pkt
->length
; /* after packet type */
1764 * Construct an SSH-2 final-form packet: compress it, encrypt it,
1765 * put the MAC on it. Final packet, ready to be sent, is stored in
1766 * pkt->data. Total length is returned.
1768 static int ssh2_pkt_construct(Ssh ssh
, struct Packet
*pkt
)
1770 int cipherblk
, maclen
, padding
, i
;
1773 log_packet(ssh
->logctx
, PKT_OUTGOING
, pkt
->data
[5],
1774 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
, pkt
->data
[5]),
1775 pkt
->body
, pkt
->length
- (pkt
->body
- pkt
->data
),
1776 pkt
->nblanks
, pkt
->blanks
);
1777 sfree(pkt
->blanks
); pkt
->blanks
= NULL
;
1781 * Compress packet payload.
1784 unsigned char *newpayload
;
1787 ssh
->cscomp
->compress(ssh
->cs_comp_ctx
, pkt
->data
+ 5,
1789 &newpayload
, &newlen
)) {
1791 ssh2_pkt_adddata(pkt
, newpayload
, newlen
);
1797 * Add padding. At least four bytes, and must also bring total
1798 * length (minus MAC) up to a multiple of the block size.
1799 * If pkt->forcepad is set, make sure the packet is at least that size
1802 cipherblk
= ssh
->cscipher ? ssh
->cscipher
->blksize
: 8; /* block size */
1803 cipherblk
= cipherblk
< 8 ?
8 : cipherblk
; /* or 8 if blksize < 8 */
1805 if (pkt
->length
+ padding
< pkt
->forcepad
)
1806 padding
= pkt
->forcepad
- pkt
->length
;
1808 (cipherblk
- (pkt
->length
+ padding
) % cipherblk
) % cipherblk
;
1809 assert(padding
<= 255);
1810 maclen
= ssh
->csmac ? ssh
->csmac
->len
: 0;
1811 ssh2_pkt_ensure(pkt
, pkt
->length
+ padding
+ maclen
);
1812 pkt
->data
[4] = padding
;
1813 for (i
= 0; i
< padding
; i
++)
1814 pkt
->data
[pkt
->length
+ i
] = random_byte();
1815 PUT_32BIT(pkt
->data
, pkt
->length
+ padding
- 4);
1817 ssh
->csmac
->generate(ssh
->cs_mac_ctx
, pkt
->data
,
1818 pkt
->length
+ padding
,
1819 ssh
->v2_outgoing_sequence
);
1820 ssh
->v2_outgoing_sequence
++; /* whether or not we MACed */
1823 ssh
->cscipher
->encrypt(ssh
->cs_cipher_ctx
,
1824 pkt
->data
, pkt
->length
+ padding
);
1826 pkt
->encrypted_len
= pkt
->length
+ padding
;
1828 /* Ready-to-send packet starts at pkt->data. We return length. */
1829 return pkt
->length
+ padding
+ maclen
;
1833 * Routines called from the main SSH code to send packets. There
1834 * are quite a few of these, because we have two separate
1835 * mechanisms for delaying the sending of packets:
1837 * - In order to send an IGNORE message and a password message in
1838 * a single fixed-length blob, we require the ability to
1839 * concatenate the encrypted forms of those two packets _into_ a
1840 * single blob and then pass it to our <network.h> transport
1841 * layer in one go. Hence, there's a deferment mechanism which
1842 * works after packet encryption.
1844 * - In order to avoid sending any connection-layer messages
1845 * during repeat key exchange, we have to queue up any such
1846 * outgoing messages _before_ they are encrypted (and in
1847 * particular before they're allocated sequence numbers), and
1848 * then send them once we've finished.
1850 * I call these mechanisms `defer' and `queue' respectively, so as
1851 * to distinguish them reasonably easily.
1853 * The functions send_noqueue() and defer_noqueue() free the packet
1854 * structure they are passed. Every outgoing packet goes through
1855 * precisely one of these functions in its life; packets passed to
1856 * ssh2_pkt_send() or ssh2_pkt_defer() either go straight to one of
1857 * these or get queued, and then when the queue is later emptied
1858 * the packets are all passed to defer_noqueue().
1860 * When using a CBC-mode cipher, it's necessary to ensure that an
1861 * attacker can't provide data to be encrypted using an IV that they
1862 * know. We ensure this by prefixing each packet that might contain
1863 * user data with an SSH_MSG_IGNORE. This is done using the deferral
1864 * mechanism, so in this case send_noqueue() ends up redirecting to
1865 * defer_noqueue(). If you don't like this inefficiency, don't use
1869 static void ssh2_pkt_defer_noqueue(Ssh
, struct Packet
*, int);
1870 static void ssh_pkt_defersend(Ssh
);
1873 * Send an SSH-2 packet immediately, without queuing or deferring.
1875 static void ssh2_pkt_send_noqueue(Ssh ssh
, struct Packet
*pkt
)
1879 if (ssh
->cscipher
!= NULL
&& (ssh
->cscipher
->flags
& SSH_CIPHER_IS_CBC
)) {
1880 /* We need to send two packets, so use the deferral mechanism. */
1881 ssh2_pkt_defer_noqueue(ssh
, pkt
, FALSE
);
1882 ssh_pkt_defersend(ssh
);
1885 len
= ssh2_pkt_construct(ssh
, pkt
);
1886 backlog
= s_write(ssh
, pkt
->data
, len
);
1887 if (backlog
> SSH_MAX_BACKLOG
)
1888 ssh_throttle_all(ssh
, 1, backlog
);
1890 ssh
->outgoing_data_size
+= pkt
->encrypted_len
;
1891 if (!ssh
->kex_in_progress
&&
1892 ssh
->max_data_size
!= 0 &&
1893 ssh
->outgoing_data_size
> ssh
->max_data_size
)
1894 do_ssh2_transport(ssh
, "too much data sent", -1, NULL
);
1896 ssh_free_packet(pkt
);
1900 * Defer an SSH-2 packet.
1902 static void ssh2_pkt_defer_noqueue(Ssh ssh
, struct Packet
*pkt
, int noignore
)
1905 if (ssh
->cscipher
!= NULL
&& (ssh
->cscipher
->flags
& SSH_CIPHER_IS_CBC
) &&
1906 ssh
->deferred_len
== 0 && !noignore
) {
1908 * Interpose an SSH_MSG_IGNORE to ensure that user data don't
1909 * get encrypted with a known IV.
1911 struct Packet
*ipkt
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
1912 ssh2_pkt_addstring_start(ipkt
);
1913 ssh2_pkt_defer_noqueue(ssh
, ipkt
, TRUE
);
1915 len
= ssh2_pkt_construct(ssh
, pkt
);
1916 if (ssh
->deferred_len
+ len
> ssh
->deferred_size
) {
1917 ssh
->deferred_size
= ssh
->deferred_len
+ len
+ 128;
1918 ssh
->deferred_send_data
= sresize(ssh
->deferred_send_data
,
1922 memcpy(ssh
->deferred_send_data
+ ssh
->deferred_len
, pkt
->data
, len
);
1923 ssh
->deferred_len
+= len
;
1924 ssh
->deferred_data_size
+= pkt
->encrypted_len
;
1925 ssh_free_packet(pkt
);
1929 * Queue an SSH-2 packet.
1931 static void ssh2_pkt_queue(Ssh ssh
, struct Packet
*pkt
)
1933 assert(ssh
->queueing
);
1935 if (ssh
->queuelen
>= ssh
->queuesize
) {
1936 ssh
->queuesize
= ssh
->queuelen
+ 32;
1937 ssh
->queue
= sresize(ssh
->queue
, ssh
->queuesize
, struct Packet
*);
1940 ssh
->queue
[ssh
->queuelen
++] = pkt
;
1944 * Either queue or send a packet, depending on whether queueing is
1947 static void ssh2_pkt_send(Ssh ssh
, struct Packet
*pkt
)
1950 ssh2_pkt_queue(ssh
, pkt
);
1952 ssh2_pkt_send_noqueue(ssh
, pkt
);
1956 * Either queue or defer a packet, depending on whether queueing is
1959 static void ssh2_pkt_defer(Ssh ssh
, struct Packet
*pkt
)
1962 ssh2_pkt_queue(ssh
, pkt
);
1964 ssh2_pkt_defer_noqueue(ssh
, pkt
, FALSE
);
1968 * Send the whole deferred data block constructed by
1969 * ssh2_pkt_defer() or SSH-1's defer_packet().
1971 * The expected use of the defer mechanism is that you call
1972 * ssh2_pkt_defer() a few times, then call ssh_pkt_defersend(). If
1973 * not currently queueing, this simply sets up deferred_send_data
1974 * and then sends it. If we _are_ currently queueing, the calls to
1975 * ssh2_pkt_defer() put the deferred packets on to the queue
1976 * instead, and therefore ssh_pkt_defersend() has no deferred data
1977 * to send. Hence, there's no need to make it conditional on
1980 static void ssh_pkt_defersend(Ssh ssh
)
1983 backlog
= s_write(ssh
, ssh
->deferred_send_data
, ssh
->deferred_len
);
1984 ssh
->deferred_len
= ssh
->deferred_size
= 0;
1985 sfree(ssh
->deferred_send_data
);
1986 ssh
->deferred_send_data
= NULL
;
1987 if (backlog
> SSH_MAX_BACKLOG
)
1988 ssh_throttle_all(ssh
, 1, backlog
);
1990 ssh
->outgoing_data_size
+= ssh
->deferred_data_size
;
1991 if (!ssh
->kex_in_progress
&&
1992 ssh
->max_data_size
!= 0 &&
1993 ssh
->outgoing_data_size
> ssh
->max_data_size
)
1994 do_ssh2_transport(ssh
, "too much data sent", -1, NULL
);
1995 ssh
->deferred_data_size
= 0;
1999 * Send a packet whose length needs to be disguised (typically
2000 * passwords or keyboard-interactive responses).
2002 static void ssh2_pkt_send_with_padding(Ssh ssh
, struct Packet
*pkt
,
2008 * The simplest way to do this is to adjust the
2009 * variable-length padding field in the outgoing packet.
2011 * Currently compiled out, because some Cisco SSH servers
2012 * don't like excessively padded packets (bah, why's it
2015 pkt
->forcepad
= padsize
;
2016 ssh2_pkt_send(ssh
, pkt
);
2021 * If we can't do that, however, an alternative approach is
2022 * to use the pkt_defer mechanism to bundle the packet
2023 * tightly together with an SSH_MSG_IGNORE such that their
2024 * combined length is a constant. So first we construct the
2025 * final form of this packet and defer its sending.
2027 ssh2_pkt_defer(ssh
, pkt
);
2030 * Now construct an SSH_MSG_IGNORE which includes a string
2031 * that's an exact multiple of the cipher block size. (If
2032 * the cipher is NULL so that the block size is
2033 * unavailable, we don't do this trick at all, because we
2034 * gain nothing by it.)
2036 if (ssh
->cscipher
) {
2039 stringlen
= (256 - ssh
->deferred_len
);
2040 stringlen
+= ssh
->cscipher
->blksize
- 1;
2041 stringlen
-= (stringlen
% ssh
->cscipher
->blksize
);
2044 * Temporarily disable actual compression, so we
2045 * can guarantee to get this string exactly the
2046 * length we want it. The compression-disabling
2047 * routine should return an integer indicating how
2048 * many bytes we should adjust our string length
2052 ssh
->cscomp
->disable_compression(ssh
->cs_comp_ctx
);
2054 pkt
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
2055 ssh2_pkt_addstring_start(pkt
);
2056 for (i
= 0; i
< stringlen
; i
++) {
2057 char c
= (char) random_byte();
2058 ssh2_pkt_addstring_data(pkt
, &c
, 1);
2060 ssh2_pkt_defer(ssh
, pkt
);
2062 ssh_pkt_defersend(ssh
);
2067 * Send all queued SSH-2 packets. We send them by means of
2068 * ssh2_pkt_defer_noqueue(), in case they included a pair of
2069 * packets that needed to be lumped together.
2071 static void ssh2_pkt_queuesend(Ssh ssh
)
2075 assert(!ssh
->queueing
);
2077 for (i
= 0; i
< ssh
->queuelen
; i
++)
2078 ssh2_pkt_defer_noqueue(ssh
, ssh
->queue
[i
], FALSE
);
2081 ssh_pkt_defersend(ssh
);
2085 void bndebug(char *string
, Bignum b
)
2089 p
= ssh2_mpint_fmt(b
, &len
);
2090 debug(("%s", string
));
2091 for (i
= 0; i
< len
; i
++)
2092 debug((" %02x", p
[i
]));
2098 static void hash_mpint(const struct ssh_hash
*h
, void *s
, Bignum b
)
2102 p
= ssh2_mpint_fmt(b
, &len
);
2103 hash_string(h
, s
, p
, len
);
2108 * Packet decode functions for both SSH-1 and SSH-2.
2110 static unsigned long ssh_pkt_getuint32(struct Packet
*pkt
)
2112 unsigned long value
;
2113 if (pkt
->length
- pkt
->savedpos
< 4)
2114 return 0; /* arrgh, no way to decline (FIXME?) */
2115 value
= GET_32BIT(pkt
->body
+ pkt
->savedpos
);
2119 static int ssh2_pkt_getbool(struct Packet
*pkt
)
2121 unsigned long value
;
2122 if (pkt
->length
- pkt
->savedpos
< 1)
2123 return 0; /* arrgh, no way to decline (FIXME?) */
2124 value
= pkt
->body
[pkt
->savedpos
] != 0;
2128 static void ssh_pkt_getstring(struct Packet
*pkt
, char **p
, int *length
)
2133 if (pkt
->length
- pkt
->savedpos
< 4)
2135 len
= GET_32BIT(pkt
->body
+ pkt
->savedpos
);
2140 if (pkt
->length
- pkt
->savedpos
< *length
)
2142 *p
= (char *)(pkt
->body
+ pkt
->savedpos
);
2143 pkt
->savedpos
+= *length
;
2145 static void *ssh_pkt_getdata(struct Packet
*pkt
, int length
)
2147 if (pkt
->length
- pkt
->savedpos
< length
)
2149 pkt
->savedpos
+= length
;
2150 return pkt
->body
+ (pkt
->savedpos
- length
);
2152 static int ssh1_pkt_getrsakey(struct Packet
*pkt
, struct RSAKey
*key
,
2153 unsigned char **keystr
)
2157 j
= makekey(pkt
->body
+ pkt
->savedpos
,
2158 pkt
->length
- pkt
->savedpos
,
2165 assert(pkt
->savedpos
< pkt
->length
);
2169 static Bignum
ssh1_pkt_getmp(struct Packet
*pkt
)
2174 j
= ssh1_read_bignum(pkt
->body
+ pkt
->savedpos
,
2175 pkt
->length
- pkt
->savedpos
, &b
);
2183 static Bignum
ssh2_pkt_getmp(struct Packet
*pkt
)
2189 ssh_pkt_getstring(pkt
, &p
, &length
);
2194 b
= bignum_from_bytes((unsigned char *)p
, length
);
2199 * Helper function to add an SSH-2 signature blob to a packet.
2200 * Expects to be shown the public key blob as well as the signature
2201 * blob. Normally works just like ssh2_pkt_addstring, but will
2202 * fiddle with the signature packet if necessary for
2203 * BUG_SSH2_RSA_PADDING.
2205 static void ssh2_add_sigblob(Ssh ssh
, struct Packet
*pkt
,
2206 void *pkblob_v
, int pkblob_len
,
2207 void *sigblob_v
, int sigblob_len
)
2209 unsigned char *pkblob
= (unsigned char *)pkblob_v
;
2210 unsigned char *sigblob
= (unsigned char *)sigblob_v
;
2212 /* dmemdump(pkblob, pkblob_len); */
2213 /* dmemdump(sigblob, sigblob_len); */
2216 * See if this is in fact an ssh-rsa signature and a buggy
2217 * server; otherwise we can just do this the easy way.
2219 if ((ssh
->remote_bugs
& BUG_SSH2_RSA_PADDING
) &&
2220 (GET_32BIT(pkblob
) == 7 && !memcmp(pkblob
+4, "ssh-rsa", 7))) {
2221 int pos
, len
, siglen
;
2224 * Find the byte length of the modulus.
2227 pos
= 4+7; /* skip over "ssh-rsa" */
2228 pos
+= 4 + GET_32BIT(pkblob
+pos
); /* skip over exponent */
2229 len
= GET_32BIT(pkblob
+pos
); /* find length of modulus */
2230 pos
+= 4; /* find modulus itself */
2231 while (len
> 0 && pkblob
[pos
] == 0)
2233 /* debug(("modulus length is %d\n", len)); */
2236 * Now find the signature integer.
2238 pos
= 4+7; /* skip over "ssh-rsa" */
2239 siglen
= GET_32BIT(sigblob
+pos
);
2240 /* debug(("signature length is %d\n", siglen)); */
2242 if (len
!= siglen
) {
2243 unsigned char newlen
[4];
2244 ssh2_pkt_addstring_start(pkt
);
2245 ssh2_pkt_addstring_data(pkt
, (char *)sigblob
, pos
);
2246 /* dmemdump(sigblob, pos); */
2247 pos
+= 4; /* point to start of actual sig */
2248 PUT_32BIT(newlen
, len
);
2249 ssh2_pkt_addstring_data(pkt
, (char *)newlen
, 4);
2250 /* dmemdump(newlen, 4); */
2252 while (len
-- > siglen
) {
2253 ssh2_pkt_addstring_data(pkt
, (char *)newlen
, 1);
2254 /* dmemdump(newlen, 1); */
2256 ssh2_pkt_addstring_data(pkt
, (char *)(sigblob
+pos
), siglen
);
2257 /* dmemdump(sigblob+pos, siglen); */
2261 /* Otherwise fall through and do it the easy way. */
2264 ssh2_pkt_addstring_start(pkt
);
2265 ssh2_pkt_addstring_data(pkt
, (char *)sigblob
, sigblob_len
);
2269 * Examine the remote side's version string and compare it against
2270 * a list of known buggy implementations.
2272 static void ssh_detect_bugs(Ssh ssh
, char *vstring
)
2274 char *imp
; /* pointer to implementation part */
2276 imp
+= strcspn(imp
, "-");
2278 imp
+= strcspn(imp
, "-");
2281 ssh
->remote_bugs
= 0;
2284 * General notes on server version strings:
2285 * - Not all servers reporting "Cisco-1.25" have all the bugs listed
2286 * here -- in particular, we've heard of one that's perfectly happy
2287 * with SSH1_MSG_IGNOREs -- but this string never seems to change,
2288 * so we can't distinguish them.
2290 if (ssh
->cfg
.sshbug_ignore1
== FORCE_ON
||
2291 (ssh
->cfg
.sshbug_ignore1
== AUTO
&&
2292 (!strcmp(imp
, "1.2.18") || !strcmp(imp
, "1.2.19") ||
2293 !strcmp(imp
, "1.2.20") || !strcmp(imp
, "1.2.21") ||
2294 !strcmp(imp
, "1.2.22") || !strcmp(imp
, "Cisco-1.25") ||
2295 !strcmp(imp
, "OSU_1.4alpha3") || !strcmp(imp
, "OSU_1.5alpha4")))) {
2297 * These versions don't support SSH1_MSG_IGNORE, so we have
2298 * to use a different defence against password length
2301 ssh
->remote_bugs
|= BUG_CHOKES_ON_SSH1_IGNORE
;
2302 logevent("We believe remote version has SSH-1 ignore bug");
2305 if (ssh
->cfg
.sshbug_plainpw1
== FORCE_ON
||
2306 (ssh
->cfg
.sshbug_plainpw1
== AUTO
&&
2307 (!strcmp(imp
, "Cisco-1.25") || !strcmp(imp
, "OSU_1.4alpha3")))) {
2309 * These versions need a plain password sent; they can't
2310 * handle having a null and a random length of data after
2313 ssh
->remote_bugs
|= BUG_NEEDS_SSH1_PLAIN_PASSWORD
;
2314 logevent("We believe remote version needs a plain SSH-1 password");
2317 if (ssh
->cfg
.sshbug_rsa1
== FORCE_ON
||
2318 (ssh
->cfg
.sshbug_rsa1
== AUTO
&&
2319 (!strcmp(imp
, "Cisco-1.25")))) {
2321 * These versions apparently have no clue whatever about
2322 * RSA authentication and will panic and die if they see
2323 * an AUTH_RSA message.
2325 ssh
->remote_bugs
|= BUG_CHOKES_ON_RSA
;
2326 logevent("We believe remote version can't handle SSH-1 RSA authentication");
2329 if (ssh
->cfg
.sshbug_hmac2
== FORCE_ON
||
2330 (ssh
->cfg
.sshbug_hmac2
== AUTO
&&
2331 !wc_match("* VShell", imp
) &&
2332 (wc_match("2.1.0*", imp
) || wc_match("2.0.*", imp
) ||
2333 wc_match("2.2.0*", imp
) || wc_match("2.3.0*", imp
) ||
2334 wc_match("2.1 *", imp
)))) {
2336 * These versions have the HMAC bug.
2338 ssh
->remote_bugs
|= BUG_SSH2_HMAC
;
2339 logevent("We believe remote version has SSH-2 HMAC bug");
2342 if (ssh
->cfg
.sshbug_derivekey2
== FORCE_ON
||
2343 (ssh
->cfg
.sshbug_derivekey2
== AUTO
&&
2344 !wc_match("* VShell", imp
) &&
2345 (wc_match("2.0.0*", imp
) || wc_match("2.0.10*", imp
) ))) {
2347 * These versions have the key-derivation bug (failing to
2348 * include the literal shared secret in the hashes that
2349 * generate the keys).
2351 ssh
->remote_bugs
|= BUG_SSH2_DERIVEKEY
;
2352 logevent("We believe remote version has SSH-2 key-derivation bug");
2355 if (ssh
->cfg
.sshbug_rsapad2
== FORCE_ON
||
2356 (ssh
->cfg
.sshbug_rsapad2
== AUTO
&&
2357 (wc_match("OpenSSH_2.[5-9]*", imp
) ||
2358 wc_match("OpenSSH_3.[0-2]*", imp
)))) {
2360 * These versions have the SSH-2 RSA padding bug.
2362 ssh
->remote_bugs
|= BUG_SSH2_RSA_PADDING
;
2363 logevent("We believe remote version has SSH-2 RSA padding bug");
2366 if (ssh
->cfg
.sshbug_pksessid2
== FORCE_ON
||
2367 (ssh
->cfg
.sshbug_pksessid2
== AUTO
&&
2368 wc_match("OpenSSH_2.[0-2]*", imp
))) {
2370 * These versions have the SSH-2 session-ID bug in
2371 * public-key authentication.
2373 ssh
->remote_bugs
|= BUG_SSH2_PK_SESSIONID
;
2374 logevent("We believe remote version has SSH-2 public-key-session-ID bug");
2377 if (ssh
->cfg
.sshbug_rekey2
== FORCE_ON
||
2378 (ssh
->cfg
.sshbug_rekey2
== AUTO
&&
2379 (wc_match("DigiSSH_2.0", imp
) ||
2380 wc_match("OpenSSH_2.[0-4]*", imp
) ||
2381 wc_match("OpenSSH_2.5.[0-3]*", imp
) ||
2382 wc_match("Sun_SSH_1.0", imp
) ||
2383 wc_match("Sun_SSH_1.0.1", imp
) ||
2384 /* All versions <= 1.2.6 (they changed their format in 1.2.7) */
2385 wc_match("WeOnlyDo-*", imp
)))) {
2387 * These versions have the SSH-2 rekey bug.
2389 ssh
->remote_bugs
|= BUG_SSH2_REKEY
;
2390 logevent("We believe remote version has SSH-2 rekey bug");
2395 * The `software version' part of an SSH version string is required
2396 * to contain no spaces or minus signs.
2398 static void ssh_fix_verstring(char *str
)
2400 /* Eat "SSH-<protoversion>-". */
2401 assert(*str
== 'S'); str
++;
2402 assert(*str
== 'S'); str
++;
2403 assert(*str
== 'H'); str
++;
2404 assert(*str
== '-'); str
++;
2405 while (*str
&& *str
!= '-') str
++;
2406 assert(*str
== '-'); str
++;
2408 /* Convert minus signs and spaces in the remaining string into
2411 if (*str
== '-' || *str
== ' ')
2418 * Send an appropriate SSH version string.
2420 static void ssh_send_verstring(Ssh ssh
, char *svers
)
2424 if (ssh
->version
== 2) {
2426 * Construct a v2 version string.
2428 verstring
= dupprintf("SSH-2.0-%s\015\012", sshver
);
2431 * Construct a v1 version string.
2433 verstring
= dupprintf("SSH-%s-%s\012",
2434 (ssh_versioncmp(svers
, "1.5") <= 0 ?
2439 ssh_fix_verstring(verstring
);
2441 if (ssh
->version
== 2) {
2444 * Record our version string.
2446 len
= strcspn(verstring
, "\015\012");
2447 ssh
->v_c
= snewn(len
+ 1, char);
2448 memcpy(ssh
->v_c
, verstring
, len
);
2452 logeventf(ssh
, "We claim version: %.*s",
2453 strcspn(verstring
, "\015\012"), verstring
);
2454 s_write(ssh
, verstring
, strlen(verstring
));
2458 static int do_ssh_init(Ssh ssh
, unsigned char c
)
2460 struct do_ssh_init_state
{
2468 crState(do_ssh_init_state
);
2470 crBegin(ssh
->do_ssh_init_crstate
);
2472 /* Search for a line beginning with the string "SSH-" in the input. */
2474 if (c
!= 'S') goto no
;
2476 if (c
!= 'S') goto no
;
2478 if (c
!= 'H') goto no
;
2480 if (c
!= '-') goto no
;
2489 s
->vstring
= snewn(s
->vstrsize
, char);
2490 strcpy(s
->vstring
, "SSH-");
2494 crReturn(1); /* get another char */
2495 if (s
->vslen
>= s
->vstrsize
- 1) {
2497 s
->vstring
= sresize(s
->vstring
, s
->vstrsize
, char);
2499 s
->vstring
[s
->vslen
++] = c
;
2502 s
->version
[s
->i
] = '\0';
2504 } else if (s
->i
< sizeof(s
->version
) - 1)
2505 s
->version
[s
->i
++] = c
;
2506 } else if (c
== '\012')
2510 ssh
->agentfwd_enabled
= FALSE
;
2511 ssh
->rdpkt2_state
.incoming_sequence
= 0;
2513 s
->vstring
[s
->vslen
] = 0;
2514 s
->vstring
[strcspn(s
->vstring
, "\015\012")] = '\0';/* remove EOL chars */
2515 logeventf(ssh
, "Server version: %s", s
->vstring
);
2516 ssh_detect_bugs(ssh
, s
->vstring
);
2519 * Decide which SSH protocol version to support.
2522 /* Anything strictly below "2.0" means protocol 1 is supported. */
2523 s
->proto1
= ssh_versioncmp(s
->version
, "2.0") < 0;
2524 /* Anything greater or equal to "1.99" means protocol 2 is supported. */
2525 s
->proto2
= ssh_versioncmp(s
->version
, "1.99") >= 0;
2527 if (ssh
->cfg
.sshprot
== 0 && !s
->proto1
) {
2528 bombout(("SSH protocol version 1 required by user but not provided by server"));
2531 if (ssh
->cfg
.sshprot
== 3 && !s
->proto2
) {
2532 bombout(("SSH protocol version 2 required by user but not provided by server"));
2536 if (s
->proto2
&& (ssh
->cfg
.sshprot
>= 2 || !s
->proto1
))
2541 logeventf(ssh
, "Using SSH protocol version %d", ssh
->version
);
2543 /* Send the version string, if we haven't already */
2544 if (ssh
->cfg
.sshprot
!= 3)
2545 ssh_send_verstring(ssh
, s
->version
);
2547 if (ssh
->version
== 2) {
2550 * Record their version string.
2552 len
= strcspn(s
->vstring
, "\015\012");
2553 ssh
->v_s
= snewn(len
+ 1, char);
2554 memcpy(ssh
->v_s
, s
->vstring
, len
);
2558 * Initialise SSH-2 protocol.
2560 ssh
->protocol
= ssh2_protocol
;
2561 ssh2_protocol_setup(ssh
);
2562 ssh
->s_rdpkt
= ssh2_rdpkt
;
2565 * Initialise SSH-1 protocol.
2567 ssh
->protocol
= ssh1_protocol
;
2568 ssh1_protocol_setup(ssh
);
2569 ssh
->s_rdpkt
= ssh1_rdpkt
;
2571 if (ssh
->version
== 2)
2572 do_ssh2_transport(ssh
, NULL
, -1, NULL
);
2574 update_specials_menu(ssh
->frontend
);
2575 ssh
->state
= SSH_STATE_BEFORE_SIZE
;
2576 ssh
->pinger
= pinger_new(&ssh
->cfg
, &ssh_backend
, ssh
);
2583 static void ssh_process_incoming_data(Ssh ssh
,
2584 unsigned char **data
, int *datalen
)
2586 struct Packet
*pktin
;
2588 pktin
= ssh
->s_rdpkt(ssh
, data
, datalen
);
2590 ssh
->protocol(ssh
, NULL
, 0, pktin
);
2591 ssh_free_packet(pktin
);
2595 static void ssh_queue_incoming_data(Ssh ssh
,
2596 unsigned char **data
, int *datalen
)
2598 bufchain_add(&ssh
->queued_incoming_data
, *data
, *datalen
);
2603 static void ssh_process_queued_incoming_data(Ssh ssh
)
2606 unsigned char *data
;
2609 while (!ssh
->frozen
&& bufchain_size(&ssh
->queued_incoming_data
)) {
2610 bufchain_prefix(&ssh
->queued_incoming_data
, &vdata
, &len
);
2614 while (!ssh
->frozen
&& len
> 0)
2615 ssh_process_incoming_data(ssh
, &data
, &len
);
2618 bufchain_consume(&ssh
->queued_incoming_data
, origlen
- len
);
2622 static void ssh_set_frozen(Ssh ssh
, int frozen
)
2625 sk_set_frozen(ssh
->s
, frozen
);
2626 ssh
->frozen
= frozen
;
2629 static void ssh_gotdata(Ssh ssh
, unsigned char *data
, int datalen
)
2631 /* Log raw data, if we're in that mode. */
2633 log_packet(ssh
->logctx
, PKT_INCOMING
, -1, NULL
, data
, datalen
,
2636 crBegin(ssh
->ssh_gotdata_crstate
);
2639 * To begin with, feed the characters one by one to the
2640 * protocol initialisation / selection function do_ssh_init().
2641 * When that returns 0, we're done with the initial greeting
2642 * exchange and can move on to packet discipline.
2645 int ret
; /* need not be kept across crReturn */
2647 crReturnV
; /* more data please */
2648 ret
= do_ssh_init(ssh
, *data
);
2656 * We emerge from that loop when the initial negotiation is
2657 * over and we have selected an s_rdpkt function. Now pass
2658 * everything to s_rdpkt, and then pass the resulting packets
2659 * to the proper protocol handler.
2663 while (bufchain_size(&ssh
->queued_incoming_data
) > 0 || datalen
> 0) {
2665 ssh_queue_incoming_data(ssh
, &data
, &datalen
);
2666 /* This uses up all data and cannot cause anything interesting
2667 * to happen; indeed, for anything to happen at all, we must
2668 * return, so break out. */
2670 } else if (bufchain_size(&ssh
->queued_incoming_data
) > 0) {
2671 /* This uses up some or all data, and may freeze the
2673 ssh_process_queued_incoming_data(ssh
);
2675 /* This uses up some or all data, and may freeze the
2677 ssh_process_incoming_data(ssh
, &data
, &datalen
);
2679 /* FIXME this is probably EBW. */
2680 if (ssh
->state
== SSH_STATE_CLOSED
)
2683 /* We're out of data. Go and get some more. */
2689 static int ssh_do_close(Ssh ssh
, int notify_exit
)
2692 struct ssh_channel
*c
;
2694 ssh
->state
= SSH_STATE_CLOSED
;
2695 expire_timer_context(ssh
);
2700 notify_remote_exit(ssh
->frontend
);
2705 * Now we must shut down any port- and X-forwarded channels going
2706 * through this connection.
2708 if (ssh
->channels
) {
2709 while (NULL
!= (c
= index234(ssh
->channels
, 0))) {
2712 x11_close(c
->u
.x11
.s
);
2715 pfd_close(c
->u
.pfd
.s
);
2718 del234(ssh
->channels
, c
); /* moving next one to index 0 */
2719 if (ssh
->version
== 2)
2720 bufchain_clear(&c
->v
.v2
.outbuffer
);
2725 * Go through port-forwardings, and close any associated
2726 * listening sockets.
2728 if (ssh
->portfwds
) {
2729 struct ssh_portfwd
*pf
;
2730 while (NULL
!= (pf
= index234(ssh
->portfwds
, 0))) {
2731 /* Dispose of any listening socket. */
2733 pfd_terminate(pf
->local
);
2734 del234(ssh
->portfwds
, pf
); /* moving next one to index 0 */
2742 static void ssh_log(Plug plug
, int type
, SockAddr addr
, int port
,
2743 const char *error_msg
, int error_code
)
2745 Ssh ssh
= (Ssh
) plug
;
2746 char addrbuf
[256], *msg
;
2748 sk_getaddr(addr
, addrbuf
, lenof(addrbuf
));
2751 msg
= dupprintf("Connecting to %s port %d", addrbuf
, port
);
2753 msg
= dupprintf("Failed to connect to %s: %s", addrbuf
, error_msg
);
2759 static int ssh_closing(Plug plug
, const char *error_msg
, int error_code
,
2762 Ssh ssh
= (Ssh
) plug
;
2763 int need_notify
= ssh_do_close(ssh
, FALSE
);
2766 if (!ssh
->close_expected
)
2767 error_msg
= "Server unexpectedly closed network connection";
2769 error_msg
= "Server closed network connection";
2772 if (ssh
->close_expected
&& ssh
->clean_exit
&& ssh
->exitcode
< 0)
2776 notify_remote_exit(ssh
->frontend
);
2779 logevent(error_msg
);
2780 if (!ssh
->close_expected
|| !ssh
->clean_exit
)
2781 connection_fatal(ssh
->frontend
, "%s", error_msg
);
2785 static int ssh_receive(Plug plug
, int urgent
, char *data
, int len
)
2787 Ssh ssh
= (Ssh
) plug
;
2788 ssh_gotdata(ssh
, (unsigned char *)data
, len
);
2789 if (ssh
->state
== SSH_STATE_CLOSED
) {
2790 ssh_do_close(ssh
, TRUE
);
2796 static void ssh_sent(Plug plug
, int bufsize
)
2798 Ssh ssh
= (Ssh
) plug
;
2800 * If the send backlog on the SSH socket itself clears, we
2801 * should unthrottle the whole world if it was throttled.
2803 if (bufsize
< SSH_MAX_BACKLOG
)
2804 ssh_throttle_all(ssh
, 0, bufsize
);
2808 * Connect to specified host and port.
2809 * Returns an error message, or NULL on success.
2810 * Also places the canonical host name into `realhost'. It must be
2811 * freed by the caller.
2813 static const char *connect_to_host(Ssh ssh
, char *host
, int port
,
2814 char **realhost
, int nodelay
, int keepalive
)
2816 static const struct plug_function_table fn_table
= {
2827 ssh
->savedhost
= snewn(1 + strlen(host
), char);
2828 strcpy(ssh
->savedhost
, host
);
2831 port
= 22; /* default ssh port */
2832 ssh
->savedport
= port
;
2837 logeventf(ssh
, "Looking up host \"%s\"%s", host
,
2838 (ssh
->cfg
.addressfamily
== ADDRTYPE_IPV4 ?
" (IPv4)" :
2839 (ssh
->cfg
.addressfamily
== ADDRTYPE_IPV6 ?
" (IPv6)" : "")));
2840 addr
= name_lookup(host
, port
, realhost
, &ssh
->cfg
,
2841 ssh
->cfg
.addressfamily
);
2842 if ((err
= sk_addr_error(addr
)) != NULL
) {
2850 ssh
->fn
= &fn_table
;
2851 ssh
->s
= new_connection(addr
, *realhost
, port
,
2852 0, 1, nodelay
, keepalive
, (Plug
) ssh
, &ssh
->cfg
);
2853 if ((err
= sk_socket_error(ssh
->s
)) != NULL
) {
2855 notify_remote_exit(ssh
->frontend
);
2860 * If the SSH version number's fixed, set it now, and if it's SSH-2,
2861 * send the version string too.
2863 if (ssh
->cfg
.sshprot
== 0)
2865 if (ssh
->cfg
.sshprot
== 3) {
2867 ssh_send_verstring(ssh
, NULL
);
2874 * Throttle or unthrottle the SSH connection.
2876 static void ssh1_throttle(Ssh ssh
, int adjust
)
2878 int old_count
= ssh
->v1_throttle_count
;
2879 ssh
->v1_throttle_count
+= adjust
;
2880 assert(ssh
->v1_throttle_count
>= 0);
2881 if (ssh
->v1_throttle_count
&& !old_count
) {
2882 ssh_set_frozen(ssh
, 1);
2883 } else if (!ssh
->v1_throttle_count
&& old_count
) {
2884 ssh_set_frozen(ssh
, 0);
2889 * Throttle or unthrottle _all_ local data streams (for when sends
2890 * on the SSH connection itself back up).
2892 static void ssh_throttle_all(Ssh ssh
, int enable
, int bufsize
)
2895 struct ssh_channel
*c
;
2897 if (enable
== ssh
->throttled_all
)
2899 ssh
->throttled_all
= enable
;
2900 ssh
->overall_bufsize
= bufsize
;
2903 for (i
= 0; NULL
!= (c
= index234(ssh
->channels
, i
)); i
++) {
2905 case CHAN_MAINSESSION
:
2907 * This is treated separately, outside the switch.
2911 x11_override_throttle(c
->u
.x11
.s
, enable
);
2914 /* Agent channels require no buffer management. */
2917 pfd_override_throttle(c
->u
.pfd
.s
, enable
);
2923 static void ssh_agent_callback(void *sshv
, void *reply
, int replylen
)
2925 Ssh ssh
= (Ssh
) sshv
;
2927 ssh
->agent_response
= reply
;
2928 ssh
->agent_response_len
= replylen
;
2930 if (ssh
->version
== 1)
2931 do_ssh1_login(ssh
, NULL
, -1, NULL
);
2933 do_ssh2_authconn(ssh
, NULL
, -1, NULL
);
2936 static void ssh_dialog_callback(void *sshv
, int ret
)
2938 Ssh ssh
= (Ssh
) sshv
;
2940 ssh
->user_response
= ret
;
2942 if (ssh
->version
== 1)
2943 do_ssh1_login(ssh
, NULL
, -1, NULL
);
2945 do_ssh2_transport(ssh
, NULL
, -1, NULL
);
2948 * This may have unfrozen the SSH connection, so do a
2951 ssh_process_queued_incoming_data(ssh
);
2954 static void ssh_agentf_callback(void *cv
, void *reply
, int replylen
)
2956 struct ssh_channel
*c
= (struct ssh_channel
*)cv
;
2958 void *sentreply
= reply
;
2961 /* Fake SSH_AGENT_FAILURE. */
2962 sentreply
= "\0\0\0\1\5";
2965 if (ssh
->version
== 2) {
2966 ssh2_add_channel_data(c
, sentreply
, replylen
);
2969 send_packet(ssh
, SSH1_MSG_CHANNEL_DATA
,
2970 PKT_INT
, c
->remoteid
,
2973 PKT_DATA
, sentreply
, replylen
,
2982 * Client-initiated disconnection. Send a DISCONNECT if `wire_reason'
2983 * non-NULL, otherwise just close the connection. `client_reason' == NULL
2984 * => log `wire_reason'.
2986 static void ssh_disconnect(Ssh ssh
, char *client_reason
, char *wire_reason
,
2987 int code
, int clean_exit
)
2991 client_reason
= wire_reason
;
2993 error
= dupprintf("Disconnected: %s", client_reason
);
2995 error
= dupstr("Disconnected");
2997 if (ssh
->version
== 1) {
2998 send_packet(ssh
, SSH1_MSG_DISCONNECT
, PKT_STR
, wire_reason
,
3000 } else if (ssh
->version
== 2) {
3001 struct Packet
*pktout
= ssh2_pkt_init(SSH2_MSG_DISCONNECT
);
3002 ssh2_pkt_adduint32(pktout
, code
);
3003 ssh2_pkt_addstring(pktout
, wire_reason
);
3004 ssh2_pkt_addstring(pktout
, "en"); /* language tag */
3005 ssh2_pkt_send_noqueue(ssh
, pktout
);
3008 ssh
->close_expected
= TRUE
;
3009 ssh
->clean_exit
= clean_exit
;
3010 ssh_closing((Plug
)ssh
, error
, 0, 0);
3015 * Handle the key exchange and user authentication phases.
3017 static int do_ssh1_login(Ssh ssh
, unsigned char *in
, int inlen
,
3018 struct Packet
*pktin
)
3021 unsigned char cookie
[8], *ptr
;
3022 struct RSAKey servkey
, hostkey
;
3023 struct MD5Context md5c
;
3024 struct do_ssh1_login_state
{
3026 unsigned char *rsabuf
, *keystr1
, *keystr2
;
3027 unsigned long supported_ciphers_mask
, supported_auths_mask
;
3028 int tried_publickey
, tried_agent
;
3029 int tis_auth_refused
, ccard_auth_refused
;
3030 unsigned char session_id
[16];
3033 void *publickey_blob
;
3034 int publickey_bloblen
;
3035 char *publickey_comment
;
3036 int publickey_encrypted
;
3037 prompts_t
*cur_prompt
;
3040 unsigned char request
[5], *response
, *p
;
3050 crState(do_ssh1_login_state
);
3052 crBegin(ssh
->do_ssh1_login_crstate
);
3057 if (pktin
->type
!= SSH1_SMSG_PUBLIC_KEY
) {
3058 bombout(("Public key packet not received"));
3062 logevent("Received public keys");
3064 ptr
= ssh_pkt_getdata(pktin
, 8);
3066 bombout(("SSH-1 public key packet stopped before random cookie"));
3069 memcpy(cookie
, ptr
, 8);
3071 if (!ssh1_pkt_getrsakey(pktin
, &servkey
, &s
->keystr1
) ||
3072 !ssh1_pkt_getrsakey(pktin
, &hostkey
, &s
->keystr2
)) {
3073 bombout(("Failed to read SSH-1 public keys from public key packet"));
3078 * Log the host key fingerprint.
3082 logevent("Host key fingerprint is:");
3083 strcpy(logmsg
, " ");
3084 hostkey
.comment
= NULL
;
3085 rsa_fingerprint(logmsg
+ strlen(logmsg
),
3086 sizeof(logmsg
) - strlen(logmsg
), &hostkey
);
3090 ssh
->v1_remote_protoflags
= ssh_pkt_getuint32(pktin
);
3091 s
->supported_ciphers_mask
= ssh_pkt_getuint32(pktin
);
3092 s
->supported_auths_mask
= ssh_pkt_getuint32(pktin
);
3093 if ((ssh
->remote_bugs
& BUG_CHOKES_ON_RSA
))
3094 s
->supported_auths_mask
&= ~(1 << SSH1_AUTH_RSA
);
3096 ssh
->v1_local_protoflags
=
3097 ssh
->v1_remote_protoflags
& SSH1_PROTOFLAGS_SUPPORTED
;
3098 ssh
->v1_local_protoflags
|= SSH1_PROTOFLAG_SCREEN_NUMBER
;
3101 MD5Update(&md5c
, s
->keystr2
, hostkey
.bytes
);
3102 MD5Update(&md5c
, s
->keystr1
, servkey
.bytes
);
3103 MD5Update(&md5c
, cookie
, 8);
3104 MD5Final(s
->session_id
, &md5c
);
3106 for (i
= 0; i
< 32; i
++)
3107 ssh
->session_key
[i
] = random_byte();
3110 * Verify that the `bits' and `bytes' parameters match.
3112 if (hostkey
.bits
> hostkey
.bytes
* 8 ||
3113 servkey
.bits
> servkey
.bytes
* 8) {
3114 bombout(("SSH-1 public keys were badly formatted"));
3118 s
->len
= (hostkey
.bytes
> servkey
.bytes ? hostkey
.bytes
: servkey
.bytes
);
3120 s
->rsabuf
= snewn(s
->len
, unsigned char);
3123 * Verify the host key.
3127 * First format the key into a string.
3129 int len
= rsastr_len(&hostkey
);
3130 char fingerprint
[100];
3131 char *keystr
= snewn(len
, char);
3132 rsastr_fmt(keystr
, &hostkey
);
3133 rsa_fingerprint(fingerprint
, sizeof(fingerprint
), &hostkey
);
3135 ssh_set_frozen(ssh
, 1);
3136 s
->dlgret
= verify_ssh_host_key(ssh
->frontend
,
3137 ssh
->savedhost
, ssh
->savedport
,
3138 "rsa", keystr
, fingerprint
,
3139 ssh_dialog_callback
, ssh
);
3141 if (s
->dlgret
< 0) {
3145 bombout(("Unexpected data from server while waiting"
3146 " for user host key response"));
3149 } while (pktin
|| inlen
> 0);
3150 s
->dlgret
= ssh
->user_response
;
3152 ssh_set_frozen(ssh
, 0);
3154 if (s
->dlgret
== 0) {
3155 ssh_disconnect(ssh
, "User aborted at host key verification",
3161 for (i
= 0; i
< 32; i
++) {
3162 s
->rsabuf
[i
] = ssh
->session_key
[i
];
3164 s
->rsabuf
[i
] ^= s
->session_id
[i
];
3167 if (hostkey
.bytes
> servkey
.bytes
) {
3168 ret
= rsaencrypt(s
->rsabuf
, 32, &servkey
);
3170 ret
= rsaencrypt(s
->rsabuf
, servkey
.bytes
, &hostkey
);
3172 ret
= rsaencrypt(s
->rsabuf
, 32, &hostkey
);
3174 ret
= rsaencrypt(s
->rsabuf
, hostkey
.bytes
, &servkey
);
3177 bombout(("SSH-1 public key encryptions failed due to bad formatting"));
3181 logevent("Encrypted session key");
3184 int cipher_chosen
= 0, warn
= 0;
3185 char *cipher_string
= NULL
;
3187 for (i
= 0; !cipher_chosen
&& i
< CIPHER_MAX
; i
++) {
3188 int next_cipher
= ssh
->cfg
.ssh_cipherlist
[i
];
3189 if (next_cipher
== CIPHER_WARN
) {
3190 /* If/when we choose a cipher, warn about it */
3192 } else if (next_cipher
== CIPHER_AES
) {
3193 /* XXX Probably don't need to mention this. */
3194 logevent("AES not supported in SSH-1, skipping");
3196 switch (next_cipher
) {
3197 case CIPHER_3DES
: s
->cipher_type
= SSH_CIPHER_3DES
;
3198 cipher_string
= "3DES"; break;
3199 case CIPHER_BLOWFISH
: s
->cipher_type
= SSH_CIPHER_BLOWFISH
;
3200 cipher_string
= "Blowfish"; break;
3201 case CIPHER_DES
: s
->cipher_type
= SSH_CIPHER_DES
;
3202 cipher_string
= "single-DES"; break;
3204 if (s
->supported_ciphers_mask
& (1 << s
->cipher_type
))
3208 if (!cipher_chosen
) {
3209 if ((s
->supported_ciphers_mask
& (1 << SSH_CIPHER_3DES
)) == 0)
3210 bombout(("Server violates SSH-1 protocol by not "
3211 "supporting 3DES encryption"));
3213 /* shouldn't happen */
3214 bombout(("No supported ciphers found"));
3218 /* Warn about chosen cipher if necessary. */
3220 ssh_set_frozen(ssh
, 1);
3221 s
->dlgret
= askalg(ssh
->frontend
, "cipher", cipher_string
,
3222 ssh_dialog_callback
, ssh
);
3223 if (s
->dlgret
< 0) {
3227 bombout(("Unexpected data from server while waiting"
3228 " for user response"));
3231 } while (pktin
|| inlen
> 0);
3232 s
->dlgret
= ssh
->user_response
;
3234 ssh_set_frozen(ssh
, 0);
3235 if (s
->dlgret
== 0) {
3236 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
3243 switch (s
->cipher_type
) {
3244 case SSH_CIPHER_3DES
:
3245 logevent("Using 3DES encryption");
3247 case SSH_CIPHER_DES
:
3248 logevent("Using single-DES encryption");
3250 case SSH_CIPHER_BLOWFISH
:
3251 logevent("Using Blowfish encryption");
3255 send_packet(ssh
, SSH1_CMSG_SESSION_KEY
,
3256 PKT_CHAR
, s
->cipher_type
,
3257 PKT_DATA
, cookie
, 8,
3258 PKT_CHAR
, (s
->len
* 8) >> 8, PKT_CHAR
, (s
->len
* 8) & 0xFF,
3259 PKT_DATA
, s
->rsabuf
, s
->len
,
3260 PKT_INT
, ssh
->v1_local_protoflags
, PKT_END
);
3262 logevent("Trying to enable encryption...");
3266 ssh
->cipher
= (s
->cipher_type
== SSH_CIPHER_BLOWFISH ?
&ssh_blowfish_ssh1
:
3267 s
->cipher_type
== SSH_CIPHER_DES ?
&ssh_des
:
3269 ssh
->v1_cipher_ctx
= ssh
->cipher
->make_context();
3270 ssh
->cipher
->sesskey(ssh
->v1_cipher_ctx
, ssh
->session_key
);
3271 logeventf(ssh
, "Initialised %s encryption", ssh
->cipher
->text_name
);
3273 ssh
->crcda_ctx
= crcda_make_context();
3274 logevent("Installing CRC compensation attack detector");
3276 if (servkey
.modulus
) {
3277 sfree(servkey
.modulus
);
3278 servkey
.modulus
= NULL
;
3280 if (servkey
.exponent
) {
3281 sfree(servkey
.exponent
);
3282 servkey
.exponent
= NULL
;
3284 if (hostkey
.modulus
) {
3285 sfree(hostkey
.modulus
);
3286 hostkey
.modulus
= NULL
;
3288 if (hostkey
.exponent
) {
3289 sfree(hostkey
.exponent
);
3290 hostkey
.exponent
= NULL
;
3294 if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
3295 bombout(("Encryption not successfully enabled"));
3299 logevent("Successfully started encryption");
3301 fflush(stdout
); /* FIXME eh? */
3303 if (!*ssh
->cfg
.username
) {
3304 int ret
; /* need not be kept over crReturn */
3305 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3306 s
->cur_prompt
->to_server
= TRUE
;
3307 s
->cur_prompt
->name
= dupstr("SSH login name");
3308 add_prompt(s
->cur_prompt
, dupstr("login as: "), TRUE
,
3309 lenof(s
->username
));
3310 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
3313 crWaitUntil(!pktin
);
3314 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
3319 * Failed to get a username. Terminate.
3321 free_prompts(s
->cur_prompt
);
3322 ssh_disconnect(ssh
, "No username provided", NULL
, 0, TRUE
);
3325 memcpy(s
->username
, s
->cur_prompt
->prompts
[0]->result
,
3326 lenof(s
->username
));
3327 free_prompts(s
->cur_prompt
);
3329 strncpy(s
->username
, ssh
->cfg
.username
, sizeof(s
->username
));
3330 s
->username
[sizeof(s
->username
)-1] = '\0';
3333 send_packet(ssh
, SSH1_CMSG_USER
, PKT_STR
, s
->username
, PKT_END
);
3335 char *userlog
= dupprintf("Sent username \"%s\"", s
->username
);
3337 if (flags
& FLAG_INTERACTIVE
&&
3338 (!((flags
& FLAG_STDERR
) && (flags
& FLAG_VERBOSE
)))) {
3339 c_write_str(ssh
, userlog
);
3340 c_write_str(ssh
, "\r\n");
3348 if ((s
->supported_auths_mask
& (1 << SSH1_AUTH_RSA
)) == 0) {
3349 /* We must not attempt PK auth. Pretend we've already tried it. */
3350 s
->tried_publickey
= s
->tried_agent
= 1;
3352 s
->tried_publickey
= s
->tried_agent
= 0;
3354 s
->tis_auth_refused
= s
->ccard_auth_refused
= 0;
3356 * Load the public half of any configured keyfile for later use.
3358 if (!filename_is_null(ssh
->cfg
.keyfile
)) {
3360 logeventf(ssh
, "Reading private key file \"%.150s\"",
3361 filename_to_str(&ssh
->cfg
.keyfile
));
3362 keytype
= key_type(&ssh
->cfg
.keyfile
);
3363 if (keytype
== SSH_KEYTYPE_SSH1
) {
3365 if (rsakey_pubblob(&ssh
->cfg
.keyfile
,
3366 &s
->publickey_blob
, &s
->publickey_bloblen
,
3367 &s
->publickey_comment
, &error
)) {
3368 s
->publickey_encrypted
= rsakey_encrypted(&ssh
->cfg
.keyfile
,
3372 logeventf(ssh
, "Unable to load private key (%s)", error
);
3373 msgbuf
= dupprintf("Unable to load private key file "
3374 "\"%.150s\" (%s)\r\n",
3375 filename_to_str(&ssh
->cfg
.keyfile
),
3377 c_write_str(ssh
, msgbuf
);
3379 s
->publickey_blob
= NULL
;
3383 logeventf(ssh
, "Unable to use this key file (%s)",
3384 key_type_to_str(keytype
));
3385 msgbuf
= dupprintf("Unable to use key file \"%.150s\""
3387 filename_to_str(&ssh
->cfg
.keyfile
),
3388 key_type_to_str(keytype
));
3389 c_write_str(ssh
, msgbuf
);
3391 s
->publickey_blob
= NULL
;
3394 s
->publickey_blob
= NULL
;
3396 while (pktin
->type
== SSH1_SMSG_FAILURE
) {
3397 s
->pwpkt_type
= SSH1_CMSG_AUTH_PASSWORD
;
3399 if (ssh
->cfg
.tryagent
&& agent_exists() && !s
->tried_agent
) {
3401 * Attempt RSA authentication using Pageant.
3407 logevent("Pageant is running. Requesting keys.");
3409 /* Request the keys held by the agent. */
3410 PUT_32BIT(s
->request
, 1);
3411 s
->request
[4] = SSH1_AGENTC_REQUEST_RSA_IDENTITIES
;
3412 if (!agent_query(s
->request
, 5, &r
, &s
->responselen
,
3413 ssh_agent_callback
, ssh
)) {
3417 bombout(("Unexpected data from server while waiting"
3418 " for agent response"));
3421 } while (pktin
|| inlen
> 0);
3422 r
= ssh
->agent_response
;
3423 s
->responselen
= ssh
->agent_response_len
;
3425 s
->response
= (unsigned char *) r
;
3426 if (s
->response
&& s
->responselen
>= 5 &&
3427 s
->response
[4] == SSH1_AGENT_RSA_IDENTITIES_ANSWER
) {
3428 s
->p
= s
->response
+ 5;
3429 s
->nkeys
= GET_32BIT(s
->p
);
3431 logeventf(ssh
, "Pageant has %d SSH-1 keys", s
->nkeys
);
3432 for (s
->keyi
= 0; s
->keyi
< s
->nkeys
; s
->keyi
++) {
3433 unsigned char *pkblob
= s
->p
;
3437 do { /* do while (0) to make breaking easy */
3438 n
= ssh1_read_bignum
3439 (s
->p
, s
->responselen
-(s
->p
-s
->response
),
3444 n
= ssh1_read_bignum
3445 (s
->p
, s
->responselen
-(s
->p
-s
->response
),
3450 if (s
->responselen
- (s
->p
-s
->response
) < 4)
3452 s
->commentlen
= GET_32BIT(s
->p
);
3454 if (s
->responselen
- (s
->p
-s
->response
) <
3457 s
->commentp
= (char *)s
->p
;
3458 s
->p
+= s
->commentlen
;
3462 logevent("Pageant key list packet was truncated");
3466 if (s
->publickey_blob
) {
3467 if (!memcmp(pkblob
, s
->publickey_blob
,
3468 s
->publickey_bloblen
)) {
3469 logeventf(ssh
, "Pageant key #%d matches "
3470 "configured key file", s
->keyi
);
3471 s
->tried_publickey
= 1;
3473 /* Skip non-configured key */
3476 logeventf(ssh
, "Trying Pageant key #%d", s
->keyi
);
3477 send_packet(ssh
, SSH1_CMSG_AUTH_RSA
,
3478 PKT_BIGNUM
, s
->key
.modulus
, PKT_END
);
3480 if (pktin
->type
!= SSH1_SMSG_AUTH_RSA_CHALLENGE
) {
3481 logevent("Key refused");
3484 logevent("Received RSA challenge");
3485 if ((s
->challenge
= ssh1_pkt_getmp(pktin
)) == NULL
) {
3486 bombout(("Server's RSA challenge was badly formatted"));
3491 char *agentreq
, *q
, *ret
;
3494 len
= 1 + 4; /* message type, bit count */
3495 len
+= ssh1_bignum_length(s
->key
.exponent
);
3496 len
+= ssh1_bignum_length(s
->key
.modulus
);
3497 len
+= ssh1_bignum_length(s
->challenge
);
3498 len
+= 16; /* session id */
3499 len
+= 4; /* response format */
3500 agentreq
= snewn(4 + len
, char);
3501 PUT_32BIT(agentreq
, len
);
3503 *q
++ = SSH1_AGENTC_RSA_CHALLENGE
;
3504 PUT_32BIT(q
, bignum_bitcount(s
->key
.modulus
));
3506 q
+= ssh1_write_bignum(q
, s
->key
.exponent
);
3507 q
+= ssh1_write_bignum(q
, s
->key
.modulus
);
3508 q
+= ssh1_write_bignum(q
, s
->challenge
);
3509 memcpy(q
, s
->session_id
, 16);
3511 PUT_32BIT(q
, 1); /* response format */
3512 if (!agent_query(agentreq
, len
+ 4, &vret
, &retlen
,
3513 ssh_agent_callback
, ssh
)) {
3518 bombout(("Unexpected data from server"
3519 " while waiting for agent"
3523 } while (pktin
|| inlen
> 0);
3524 vret
= ssh
->agent_response
;
3525 retlen
= ssh
->agent_response_len
;
3530 if (ret
[4] == SSH1_AGENT_RSA_RESPONSE
) {
3531 logevent("Sending Pageant's response");
3532 send_packet(ssh
, SSH1_CMSG_AUTH_RSA_RESPONSE
,
3533 PKT_DATA
, ret
+ 5, 16,
3537 if (pktin
->type
== SSH1_SMSG_SUCCESS
) {
3539 ("Pageant's response accepted");
3540 if (flags
& FLAG_VERBOSE
) {
3541 c_write_str(ssh
, "Authenticated using"
3543 c_write(ssh
, s
->commentp
,
3545 c_write_str(ssh
, "\" from agent\r\n");
3550 ("Pageant's response not accepted");
3553 ("Pageant failed to answer challenge");
3557 logevent("No reply received from Pageant");
3560 freebn(s
->key
.exponent
);
3561 freebn(s
->key
.modulus
);
3562 freebn(s
->challenge
);
3567 if (s
->publickey_blob
&& !s
->tried_publickey
)
3568 logevent("Configured key file not in Pageant");
3573 if (s
->publickey_blob
&& !s
->tried_publickey
) {
3575 * Try public key authentication with the specified
3578 int got_passphrase
; /* need not be kept over crReturn */
3579 if (flags
& FLAG_VERBOSE
)
3580 c_write_str(ssh
, "Trying public key authentication.\r\n");
3581 logeventf(ssh
, "Trying public key \"%s\"",
3582 filename_to_str(&ssh
->cfg
.keyfile
));
3583 s
->tried_publickey
= 1;
3584 got_passphrase
= FALSE
;
3585 while (!got_passphrase
) {
3587 * Get a passphrase, if necessary.
3589 char *passphrase
= NULL
; /* only written after crReturn */
3591 if (!s
->publickey_encrypted
) {
3592 if (flags
& FLAG_VERBOSE
)
3593 c_write_str(ssh
, "No passphrase required.\r\n");
3596 int ret
; /* need not be kept over crReturn */
3597 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3598 s
->cur_prompt
->to_server
= FALSE
;
3599 s
->cur_prompt
->name
= dupstr("SSH key passphrase");
3600 add_prompt(s
->cur_prompt
,
3601 dupprintf("Passphrase for key \"%.100s\": ",
3602 s
->publickey_comment
),
3603 FALSE
, SSH_MAX_PASSWORD_LEN
);
3604 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
3607 crWaitUntil(!pktin
);
3608 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
3612 /* Failed to get a passphrase. Terminate. */
3613 free_prompts(s
->cur_prompt
);
3614 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
3618 passphrase
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
3619 free_prompts(s
->cur_prompt
);
3622 * Try decrypting key with passphrase.
3624 ret
= loadrsakey(&ssh
->cfg
.keyfile
, &s
->key
, passphrase
,
3627 memset(passphrase
, 0, strlen(passphrase
));
3631 /* Correct passphrase. */
3632 got_passphrase
= TRUE
;
3633 } else if (ret
== 0) {
3634 c_write_str(ssh
, "Couldn't load private key from ");
3635 c_write_str(ssh
, filename_to_str(&ssh
->cfg
.keyfile
));
3636 c_write_str(ssh
, " (");
3637 c_write_str(ssh
, error
);
3638 c_write_str(ssh
, ").\r\n");
3639 got_passphrase
= FALSE
;
3640 break; /* go and try something else */
3641 } else if (ret
== -1) {
3642 c_write_str(ssh
, "Wrong passphrase.\r\n"); /* FIXME */
3643 got_passphrase
= FALSE
;
3646 assert(0 && "unexpected return from loadrsakey()");
3647 got_passphrase
= FALSE
; /* placate optimisers */
3651 if (got_passphrase
) {
3654 * Send a public key attempt.
3656 send_packet(ssh
, SSH1_CMSG_AUTH_RSA
,
3657 PKT_BIGNUM
, s
->key
.modulus
, PKT_END
);
3660 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
3661 c_write_str(ssh
, "Server refused our public key.\r\n");
3662 continue; /* go and try something else */
3664 if (pktin
->type
!= SSH1_SMSG_AUTH_RSA_CHALLENGE
) {
3665 bombout(("Bizarre response to offer of public key"));
3671 unsigned char buffer
[32];
3672 Bignum challenge
, response
;
3674 if ((challenge
= ssh1_pkt_getmp(pktin
)) == NULL
) {
3675 bombout(("Server's RSA challenge was badly formatted"));
3678 response
= rsadecrypt(challenge
, &s
->key
);
3679 freebn(s
->key
.private_exponent
);/* burn the evidence */
3681 for (i
= 0; i
< 32; i
++) {
3682 buffer
[i
] = bignum_byte(response
, 31 - i
);
3686 MD5Update(&md5c
, buffer
, 32);
3687 MD5Update(&md5c
, s
->session_id
, 16);
3688 MD5Final(buffer
, &md5c
);
3690 send_packet(ssh
, SSH1_CMSG_AUTH_RSA_RESPONSE
,
3691 PKT_DATA
, buffer
, 16, PKT_END
);
3698 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
3699 if (flags
& FLAG_VERBOSE
)
3700 c_write_str(ssh
, "Failed to authenticate with"
3701 " our public key.\r\n");
3702 continue; /* go and try something else */
3703 } else if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
3704 bombout(("Bizarre response to RSA authentication response"));
3708 break; /* we're through! */
3714 * Otherwise, try various forms of password-like authentication.
3716 s
->cur_prompt
= new_prompts(ssh
->frontend
);
3718 if (ssh
->cfg
.try_tis_auth
&&
3719 (s
->supported_auths_mask
& (1 << SSH1_AUTH_TIS
)) &&
3720 !s
->tis_auth_refused
) {
3721 s
->pwpkt_type
= SSH1_CMSG_AUTH_TIS_RESPONSE
;
3722 logevent("Requested TIS authentication");
3723 send_packet(ssh
, SSH1_CMSG_AUTH_TIS
, PKT_END
);
3725 if (pktin
->type
!= SSH1_SMSG_AUTH_TIS_CHALLENGE
) {
3726 logevent("TIS authentication declined");
3727 if (flags
& FLAG_INTERACTIVE
)
3728 c_write_str(ssh
, "TIS authentication refused.\r\n");
3729 s
->tis_auth_refused
= 1;
3734 char *instr_suf
, *prompt
;
3736 ssh_pkt_getstring(pktin
, &challenge
, &challengelen
);
3738 bombout(("TIS challenge packet was badly formed"));
3741 logevent("Received TIS challenge");
3742 s
->cur_prompt
->to_server
= TRUE
;
3743 s
->cur_prompt
->name
= dupstr("SSH TIS authentication");
3744 /* Prompt heuristic comes from OpenSSH */
3745 if (memchr(challenge
, '\n', challengelen
)) {
3746 instr_suf
= dupstr("");
3747 prompt
= dupprintf("%.*s", challengelen
, challenge
);
3749 instr_suf
= dupprintf("%.*s", challengelen
, challenge
);
3750 prompt
= dupstr("Response: ");
3752 s
->cur_prompt
->instruction
=
3753 dupprintf("Using TIS authentication.%s%s",
3754 (*instr_suf
) ?
"\n" : "",
3756 s
->cur_prompt
->instr_reqd
= TRUE
;
3757 add_prompt(s
->cur_prompt
, prompt
, FALSE
, SSH_MAX_PASSWORD_LEN
);
3761 if (ssh
->cfg
.try_tis_auth
&&
3762 (s
->supported_auths_mask
& (1 << SSH1_AUTH_CCARD
)) &&
3763 !s
->ccard_auth_refused
) {
3764 s
->pwpkt_type
= SSH1_CMSG_AUTH_CCARD_RESPONSE
;
3765 logevent("Requested CryptoCard authentication");
3766 send_packet(ssh
, SSH1_CMSG_AUTH_CCARD
, PKT_END
);
3768 if (pktin
->type
!= SSH1_SMSG_AUTH_CCARD_CHALLENGE
) {
3769 logevent("CryptoCard authentication declined");
3770 c_write_str(ssh
, "CryptoCard authentication refused.\r\n");
3771 s
->ccard_auth_refused
= 1;
3776 char *instr_suf
, *prompt
;
3778 ssh_pkt_getstring(pktin
, &challenge
, &challengelen
);
3780 bombout(("CryptoCard challenge packet was badly formed"));
3783 logevent("Received CryptoCard challenge");
3784 s
->cur_prompt
->to_server
= TRUE
;
3785 s
->cur_prompt
->name
= dupstr("SSH CryptoCard authentication");
3786 s
->cur_prompt
->name_reqd
= FALSE
;
3787 /* Prompt heuristic comes from OpenSSH */
3788 if (memchr(challenge
, '\n', challengelen
)) {
3789 instr_suf
= dupstr("");
3790 prompt
= dupprintf("%.*s", challengelen
, challenge
);
3792 instr_suf
= dupprintf("%.*s", challengelen
, challenge
);
3793 prompt
= dupstr("Response: ");
3795 s
->cur_prompt
->instruction
=
3796 dupprintf("Using CryptoCard authentication.%s%s",
3797 (*instr_suf
) ?
"\n" : "",
3799 s
->cur_prompt
->instr_reqd
= TRUE
;
3800 add_prompt(s
->cur_prompt
, prompt
, FALSE
, SSH_MAX_PASSWORD_LEN
);
3804 if (s
->pwpkt_type
== SSH1_CMSG_AUTH_PASSWORD
) {
3805 if ((s
->supported_auths_mask
& (1 << SSH1_AUTH_PASSWORD
)) == 0) {
3806 bombout(("No supported authentication methods available"));
3809 s
->cur_prompt
->to_server
= TRUE
;
3810 s
->cur_prompt
->name
= dupstr("SSH password");
3811 add_prompt(s
->cur_prompt
, dupprintf("%.90s@%.90s's password: ",
3812 s
->username
, ssh
->savedhost
),
3813 FALSE
, SSH_MAX_PASSWORD_LEN
);
3817 * Show password prompt, having first obtained it via a TIS
3818 * or CryptoCard exchange if we're doing TIS or CryptoCard
3822 int ret
; /* need not be kept over crReturn */
3823 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
3826 crWaitUntil(!pktin
);
3827 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
3832 * Failed to get a password (for example
3833 * because one was supplied on the command line
3834 * which has already failed to work). Terminate.
3836 free_prompts(s
->cur_prompt
);
3837 ssh_disconnect(ssh
, NULL
, "Unable to authenticate", 0, TRUE
);
3842 if (s
->pwpkt_type
== SSH1_CMSG_AUTH_PASSWORD
) {
3844 * Defence against traffic analysis: we send a
3845 * whole bunch of packets containing strings of
3846 * different lengths. One of these strings is the
3847 * password, in a SSH1_CMSG_AUTH_PASSWORD packet.
3848 * The others are all random data in
3849 * SSH1_MSG_IGNORE packets. This way a passive
3850 * listener can't tell which is the password, and
3851 * hence can't deduce the password length.
3853 * Anybody with a password length greater than 16
3854 * bytes is going to have enough entropy in their
3855 * password that a listener won't find it _that_
3856 * much help to know how long it is. So what we'll
3859 * - if password length < 16, we send 15 packets
3860 * containing string lengths 1 through 15
3862 * - otherwise, we let N be the nearest multiple
3863 * of 8 below the password length, and send 8
3864 * packets containing string lengths N through
3865 * N+7. This won't obscure the order of
3866 * magnitude of the password length, but it will
3867 * introduce a bit of extra uncertainty.
3869 * A few servers can't deal with SSH1_MSG_IGNORE, at
3870 * least in this context. For these servers, we need
3871 * an alternative defence. We make use of the fact
3872 * that the password is interpreted as a C string:
3873 * so we can append a NUL, then some random data.
3875 * A few servers can deal with neither SSH1_MSG_IGNORE
3876 * here _nor_ a padded password string.
3877 * For these servers we are left with no defences
3878 * against password length sniffing.
3880 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
) &&
3881 !(ssh
->remote_bugs
& BUG_NEEDS_SSH1_PLAIN_PASSWORD
)) {
3883 * The server can deal with SSH1_MSG_IGNORE, so
3884 * we can use the primary defence.
3886 int bottom
, top
, pwlen
, i
;
3889 pwlen
= strlen(s
->cur_prompt
->prompts
[0]->result
);
3891 bottom
= 0; /* zero length passwords are OK! :-) */
3894 bottom
= pwlen
& ~7;
3898 assert(pwlen
>= bottom
&& pwlen
<= top
);
3900 randomstr
= snewn(top
+ 1, char);
3902 for (i
= bottom
; i
<= top
; i
++) {
3904 defer_packet(ssh
, s
->pwpkt_type
,
3905 PKTT_PASSWORD
, PKT_STR
,
3906 s
->cur_prompt
->prompts
[0]->result
,
3907 PKTT_OTHER
, PKT_END
);
3909 for (j
= 0; j
< i
; j
++) {
3911 randomstr
[j
] = random_byte();
3912 } while (randomstr
[j
] == '\0');
3914 randomstr
[i
] = '\0';
3915 defer_packet(ssh
, SSH1_MSG_IGNORE
,
3916 PKT_STR
, randomstr
, PKT_END
);
3919 logevent("Sending password with camouflage packets");
3920 ssh_pkt_defersend(ssh
);
3923 else if (!(ssh
->remote_bugs
& BUG_NEEDS_SSH1_PLAIN_PASSWORD
)) {
3925 * The server can't deal with SSH1_MSG_IGNORE
3926 * but can deal with padded passwords, so we
3927 * can use the secondary defence.
3933 len
= strlen(s
->cur_prompt
->prompts
[0]->result
);
3934 if (len
< sizeof(string
)) {
3936 strcpy(string
, s
->cur_prompt
->prompts
[0]->result
);
3937 len
++; /* cover the zero byte */
3938 while (len
< sizeof(string
)) {
3939 string
[len
++] = (char) random_byte();
3942 ss
= s
->cur_prompt
->prompts
[0]->result
;
3944 logevent("Sending length-padded password");
3945 send_packet(ssh
, s
->pwpkt_type
, PKTT_PASSWORD
,
3946 PKT_INT
, len
, PKT_DATA
, ss
, len
,
3947 PKTT_OTHER
, PKT_END
);
3950 * The server is believed unable to cope with
3951 * any of our password camouflage methods.
3954 len
= strlen(s
->cur_prompt
->prompts
[0]->result
);
3955 logevent("Sending unpadded password");
3956 send_packet(ssh
, s
->pwpkt_type
,
3957 PKTT_PASSWORD
, PKT_INT
, len
,
3958 PKT_DATA
, s
->cur_prompt
->prompts
[0]->result
, len
,
3959 PKTT_OTHER
, PKT_END
);
3962 send_packet(ssh
, s
->pwpkt_type
, PKTT_PASSWORD
,
3963 PKT_STR
, s
->cur_prompt
->prompts
[0]->result
,
3964 PKTT_OTHER
, PKT_END
);
3966 logevent("Sent password");
3967 free_prompts(s
->cur_prompt
);
3969 if (pktin
->type
== SSH1_SMSG_FAILURE
) {
3970 if (flags
& FLAG_VERBOSE
)
3971 c_write_str(ssh
, "Access denied\r\n");
3972 logevent("Authentication refused");
3973 } else if (pktin
->type
!= SSH1_SMSG_SUCCESS
) {
3974 bombout(("Strange packet received, type %d", pktin
->type
));
3980 if (s
->publickey_blob
) {
3981 sfree(s
->publickey_blob
);
3982 sfree(s
->publickey_comment
);
3985 logevent("Authentication successful");
3990 void sshfwd_close(struct ssh_channel
*c
)
3994 if (ssh
->state
== SSH_STATE_CLOSED
)
3997 if (c
&& !c
->closes
) {
3999 * If halfopen is true, we have sent
4000 * CHANNEL_OPEN for this channel, but it hasn't even been
4001 * acknowledged by the server. So we must set a close flag
4002 * on it now, and then when the server acks the channel
4003 * open, we can close it then.
4006 if (ssh
->version
== 1) {
4007 send_packet(ssh
, SSH1_MSG_CHANNEL_CLOSE
, PKT_INT
, c
->remoteid
,
4010 struct Packet
*pktout
;
4011 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
4012 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
4013 ssh2_pkt_send(ssh
, pktout
);
4016 c
->closes
= 1; /* sent MSG_CLOSE */
4017 if (c
->type
== CHAN_X11
) {
4019 logevent("Forwarded X11 connection terminated");
4020 } else if (c
->type
== CHAN_SOCKDATA
||
4021 c
->type
== CHAN_SOCKDATA_DORMANT
) {
4023 logevent("Forwarded port closed");
4028 int sshfwd_write(struct ssh_channel
*c
, char *buf
, int len
)
4032 if (ssh
->state
== SSH_STATE_CLOSED
)
4035 if (ssh
->version
== 1) {
4036 send_packet(ssh
, SSH1_MSG_CHANNEL_DATA
,
4037 PKT_INT
, c
->remoteid
,
4038 PKT_INT
, len
, PKTT_DATA
, PKT_DATA
, buf
, len
,
4039 PKTT_OTHER
, PKT_END
);
4041 * In SSH-1 we can return 0 here - implying that forwarded
4042 * connections are never individually throttled - because
4043 * the only circumstance that can cause throttling will be
4044 * the whole SSH connection backing up, in which case
4045 * _everything_ will be throttled as a whole.
4049 ssh2_add_channel_data(c
, buf
, len
);
4050 return ssh2_try_send(c
);
4054 void sshfwd_unthrottle(struct ssh_channel
*c
, int bufsize
)
4058 if (ssh
->state
== SSH_STATE_CLOSED
)
4061 if (ssh
->version
== 1) {
4062 if (c
->v
.v1
.throttling
&& bufsize
< SSH1_BUFFER_LIMIT
) {
4063 c
->v
.v1
.throttling
= 0;
4064 ssh1_throttle(ssh
, -1);
4067 ssh2_set_window(c
, c
->v
.v2
.locmaxwin
- bufsize
);
4071 static void ssh_queueing_handler(Ssh ssh
, struct Packet
*pktin
)
4073 struct queued_handler
*qh
= ssh
->qhead
;
4077 assert(pktin
->type
== qh
->msg1
|| pktin
->type
== qh
->msg2
);
4080 assert(ssh
->packet_dispatch
[qh
->msg1
] == ssh_queueing_handler
);
4081 ssh
->packet_dispatch
[qh
->msg1
] = NULL
;
4084 assert(ssh
->packet_dispatch
[qh
->msg2
] == ssh_queueing_handler
);
4085 ssh
->packet_dispatch
[qh
->msg2
] = NULL
;
4089 ssh
->qhead
= qh
->next
;
4091 if (ssh
->qhead
->msg1
> 0) {
4092 assert(ssh
->packet_dispatch
[ssh
->qhead
->msg1
] == NULL
);
4093 ssh
->packet_dispatch
[ssh
->qhead
->msg1
] = ssh_queueing_handler
;
4095 if (ssh
->qhead
->msg2
> 0) {
4096 assert(ssh
->packet_dispatch
[ssh
->qhead
->msg2
] == NULL
);
4097 ssh
->packet_dispatch
[ssh
->qhead
->msg2
] = ssh_queueing_handler
;
4100 ssh
->qhead
= ssh
->qtail
= NULL
;
4101 ssh
->packet_dispatch
[pktin
->type
] = NULL
;
4104 qh
->handler(ssh
, pktin
, qh
->ctx
);
4109 static void ssh_queue_handler(Ssh ssh
, int msg1
, int msg2
,
4110 chandler_fn_t handler
, void *ctx
)
4112 struct queued_handler
*qh
;
4114 qh
= snew(struct queued_handler
);
4117 qh
->handler
= handler
;
4121 if (ssh
->qtail
== NULL
) {
4125 assert(ssh
->packet_dispatch
[qh
->msg1
] == NULL
);
4126 ssh
->packet_dispatch
[qh
->msg1
] = ssh_queueing_handler
;
4129 assert(ssh
->packet_dispatch
[qh
->msg2
] == NULL
);
4130 ssh
->packet_dispatch
[qh
->msg2
] = ssh_queueing_handler
;
4133 ssh
->qtail
->next
= qh
;
4138 static void ssh_rportfwd_succfail(Ssh ssh
, struct Packet
*pktin
, void *ctx
)
4140 struct ssh_rportfwd
*rpf
, *pf
= (struct ssh_rportfwd
*)ctx
;
4142 if (pktin
->type
== (ssh
->version
== 1 ? SSH1_SMSG_SUCCESS
:
4143 SSH2_MSG_REQUEST_SUCCESS
)) {
4144 logeventf(ssh
, "Remote port forwarding from %s enabled",
4147 logeventf(ssh
, "Remote port forwarding from %s refused",
4150 rpf
= del234(ssh
->rportfwds
, pf
);
4156 static void ssh_setup_portfwd(Ssh ssh
, const Config
*cfg
)
4158 const char *portfwd_strptr
= cfg
->portfwd
;
4159 struct ssh_portfwd
*epf
;
4162 if (!ssh
->portfwds
) {
4163 ssh
->portfwds
= newtree234(ssh_portcmp
);
4166 * Go through the existing port forwardings and tag them
4167 * with status==DESTROY. Any that we want to keep will be
4168 * re-enabled (status==KEEP) as we go through the
4169 * configuration and find out which bits are the same as
4172 struct ssh_portfwd
*epf
;
4174 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4175 epf
->status
= DESTROY
;
4178 while (*portfwd_strptr
) {
4179 char address_family
, type
;
4180 int sport
,dport
,sserv
,dserv
;
4181 char sports
[256], dports
[256], saddr
[256], host
[256];
4184 address_family
= 'A';
4186 if (*portfwd_strptr
== 'A' ||
4187 *portfwd_strptr
== '4' ||
4188 *portfwd_strptr
== '6')
4189 address_family
= *portfwd_strptr
++;
4190 if (*portfwd_strptr
== 'L' ||
4191 *portfwd_strptr
== 'R' ||
4192 *portfwd_strptr
== 'D')
4193 type
= *portfwd_strptr
++;
4198 while (*portfwd_strptr
&& *portfwd_strptr
!= '\t') {
4199 if (*portfwd_strptr
== ':') {
4201 * We've seen a colon in the middle of the
4202 * source port number. This means that
4203 * everything we've seen until now is the
4204 * source _address_, so we'll move it into
4205 * saddr and start sports from the beginning
4210 if (ssh
->version
== 1 && type
== 'R') {
4211 logeventf(ssh
, "SSH-1 cannot handle remote source address "
4212 "spec \"%s\"; ignoring", sports
);
4214 strcpy(saddr
, sports
);
4217 if (n
< lenof(sports
)-1) sports
[n
++] = *portfwd_strptr
++;
4221 if (*portfwd_strptr
== '\t')
4224 while (*portfwd_strptr
&& *portfwd_strptr
!= ':') {
4225 if (n
< lenof(host
)-1) host
[n
++] = *portfwd_strptr
++;
4228 if (*portfwd_strptr
== ':')
4231 while (*portfwd_strptr
) {
4232 if (n
< lenof(dports
)-1) dports
[n
++] = *portfwd_strptr
++;
4236 dport
= atoi(dports
);
4240 dport
= net_service_lookup(dports
);
4242 logeventf(ssh
, "Service lookup failed for destination"
4243 " port \"%s\"", dports
);
4247 while (*portfwd_strptr
) portfwd_strptr
++;
4251 portfwd_strptr
++; /* eat the NUL and move to next one */
4253 sport
= atoi(sports
);
4257 sport
= net_service_lookup(sports
);
4259 logeventf(ssh
, "Service lookup failed for source"
4260 " port \"%s\"", sports
);
4263 if (sport
&& dport
) {
4264 /* Set up a description of the source port. */
4265 struct ssh_portfwd
*pfrec
, *epfrec
;
4267 pfrec
= snew(struct ssh_portfwd
);
4269 pfrec
->saddr
= *saddr ?
dupstr(saddr
) : NULL
;
4270 pfrec
->sserv
= sserv ?
dupstr(sports
) : NULL
;
4271 pfrec
->sport
= sport
;
4272 pfrec
->daddr
= *host ?
dupstr(host
) : NULL
;
4273 pfrec
->dserv
= dserv ?
dupstr(dports
) : NULL
;
4274 pfrec
->dport
= dport
;
4275 pfrec
->local
= NULL
;
4276 pfrec
->remote
= NULL
;
4277 pfrec
->addressfamily
= (address_family
== '4' ? ADDRTYPE_IPV4
:
4278 address_family
== '6' ? ADDRTYPE_IPV6
:
4281 epfrec
= add234(ssh
->portfwds
, pfrec
);
4282 if (epfrec
!= pfrec
) {
4284 * We already have a port forwarding with precisely
4285 * these parameters. Hence, no need to do anything;
4286 * simply tag the existing one as KEEP.
4288 epfrec
->status
= KEEP
;
4289 free_portfwd(pfrec
);
4291 pfrec
->status
= CREATE
;
4297 * Now go through and destroy any port forwardings which were
4300 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4301 if (epf
->status
== DESTROY
) {
4304 message
= dupprintf("%s port forwarding from %s%s%d",
4305 epf
->type
== 'L' ?
"local" :
4306 epf
->type
== 'R' ?
"remote" : "dynamic",
4307 epf
->saddr ? epf
->saddr
: "",
4308 epf
->saddr ?
":" : "",
4311 if (epf
->type
!= 'D') {
4312 char *msg2
= dupprintf("%s to %s:%d", message
,
4313 epf
->daddr
, epf
->dport
);
4318 logeventf(ssh
, "Cancelling %s", message
);
4322 struct ssh_rportfwd
*rpf
= epf
->remote
;
4323 struct Packet
*pktout
;
4326 * Cancel the port forwarding at the server
4329 if (ssh
->version
== 1) {
4331 * We cannot cancel listening ports on the
4332 * server side in SSH-1! There's no message
4333 * to support it. Instead, we simply remove
4334 * the rportfwd record from the local end
4335 * so that any connections the server tries
4336 * to make on it are rejected.
4339 pktout
= ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST
);
4340 ssh2_pkt_addstring(pktout
, "cancel-tcpip-forward");
4341 ssh2_pkt_addbool(pktout
, 0);/* _don't_ want reply */
4343 ssh2_pkt_addstring(pktout
, epf
->saddr
);
4344 } else if (ssh
->cfg
.rport_acceptall
) {
4345 /* XXX: ssh->cfg.rport_acceptall may not represent
4346 * what was used to open the original connection,
4347 * since it's reconfigurable. */
4348 ssh2_pkt_addstring(pktout
, "0.0.0.0");
4350 ssh2_pkt_addstring(pktout
, "127.0.0.1");
4352 ssh2_pkt_adduint32(pktout
, epf
->sport
);
4353 ssh2_pkt_send(ssh
, pktout
);
4356 del234(ssh
->rportfwds
, rpf
);
4358 } else if (epf
->local
) {
4359 pfd_terminate(epf
->local
);
4362 delpos234(ssh
->portfwds
, i
);
4364 i
--; /* so we don't skip one in the list */
4368 * And finally, set up any new port forwardings (status==CREATE).
4370 for (i
= 0; (epf
= index234(ssh
->portfwds
, i
)) != NULL
; i
++)
4371 if (epf
->status
== CREATE
) {
4372 char *sportdesc
, *dportdesc
;
4373 sportdesc
= dupprintf("%s%s%s%s%d%s",
4374 epf
->saddr ? epf
->saddr
: "",
4375 epf
->saddr ?
":" : "",
4376 epf
->sserv ? epf
->sserv
: "",
4377 epf
->sserv ?
"(" : "",
4379 epf
->sserv ?
")" : "");
4380 if (epf
->type
== 'D') {
4383 dportdesc
= dupprintf("%s:%s%s%d%s",
4385 epf
->dserv ? epf
->dserv
: "",
4386 epf
->dserv ?
"(" : "",
4388 epf
->dserv ?
")" : "");
4391 if (epf
->type
== 'L') {
4392 const char *err
= pfd_addforward(epf
->daddr
, epf
->dport
,
4393 epf
->saddr
, epf
->sport
,
4396 epf
->addressfamily
);
4398 logeventf(ssh
, "Local %sport %s forwarding to %s%s%s",
4399 epf
->addressfamily
== ADDRTYPE_IPV4 ?
"IPv4 " :
4400 epf
->addressfamily
== ADDRTYPE_IPV6 ?
"IPv6 " : "",
4401 sportdesc
, dportdesc
,
4402 err ?
" failed: " : "", err ? err
: "");
4403 } else if (epf
->type
== 'D') {
4404 const char *err
= pfd_addforward(NULL
, -1,
4405 epf
->saddr
, epf
->sport
,
4408 epf
->addressfamily
);
4410 logeventf(ssh
, "Local %sport %s SOCKS dynamic forwarding%s%s",
4411 epf
->addressfamily
== ADDRTYPE_IPV4 ?
"IPv4 " :
4412 epf
->addressfamily
== ADDRTYPE_IPV6 ?
"IPv6 " : "",
4414 err ?
" failed: " : "", err ? err
: "");
4416 struct ssh_rportfwd
*pf
;
4419 * Ensure the remote port forwardings tree exists.
4421 if (!ssh
->rportfwds
) {
4422 if (ssh
->version
== 1)
4423 ssh
->rportfwds
= newtree234(ssh_rportcmp_ssh1
);
4425 ssh
->rportfwds
= newtree234(ssh_rportcmp_ssh2
);
4428 pf
= snew(struct ssh_rportfwd
);
4429 strncpy(pf
->dhost
, epf
->daddr
, lenof(pf
->dhost
)-1);
4430 pf
->dhost
[lenof(pf
->dhost
)-1] = '\0';
4431 pf
->dport
= epf
->dport
;
4432 pf
->sport
= epf
->sport
;
4433 if (add234(ssh
->rportfwds
, pf
) != pf
) {
4434 logeventf(ssh
, "Duplicate remote port forwarding to %s:%d",
4435 epf
->daddr
, epf
->dport
);
4438 logeventf(ssh
, "Requesting remote port %s"
4439 " forward to %s", sportdesc
, dportdesc
);
4441 pf
->sportdesc
= sportdesc
;
4446 if (ssh
->version
== 1) {
4447 send_packet(ssh
, SSH1_CMSG_PORT_FORWARD_REQUEST
,
4448 PKT_INT
, epf
->sport
,
4449 PKT_STR
, epf
->daddr
,
4450 PKT_INT
, epf
->dport
,
4452 ssh_queue_handler(ssh
, SSH1_SMSG_SUCCESS
,
4454 ssh_rportfwd_succfail
, pf
);
4456 struct Packet
*pktout
;
4457 pktout
= ssh2_pkt_init(SSH2_MSG_GLOBAL_REQUEST
);
4458 ssh2_pkt_addstring(pktout
, "tcpip-forward");
4459 ssh2_pkt_addbool(pktout
, 1);/* want reply */
4461 ssh2_pkt_addstring(pktout
, epf
->saddr
);
4462 } else if (cfg
->rport_acceptall
) {
4463 ssh2_pkt_addstring(pktout
, "0.0.0.0");
4465 ssh2_pkt_addstring(pktout
, "127.0.0.1");
4467 ssh2_pkt_adduint32(pktout
, epf
->sport
);
4468 ssh2_pkt_send(ssh
, pktout
);
4470 ssh_queue_handler(ssh
, SSH2_MSG_REQUEST_SUCCESS
,
4471 SSH2_MSG_REQUEST_FAILURE
,
4472 ssh_rportfwd_succfail
, pf
);
4481 static void ssh1_smsg_stdout_stderr_data(Ssh ssh
, struct Packet
*pktin
)
4484 int stringlen
, bufsize
;
4486 ssh_pkt_getstring(pktin
, &string
, &stringlen
);
4487 if (string
== NULL
) {
4488 bombout(("Incoming terminal data packet was badly formed"));
4492 bufsize
= from_backend(ssh
->frontend
, pktin
->type
== SSH1_SMSG_STDERR_DATA
,
4494 if (!ssh
->v1_stdout_throttling
&& bufsize
> SSH1_BUFFER_LIMIT
) {
4495 ssh
->v1_stdout_throttling
= 1;
4496 ssh1_throttle(ssh
, +1);
4500 static void ssh1_smsg_x11_open(Ssh ssh
, struct Packet
*pktin
)
4502 /* Remote side is trying to open a channel to talk to our
4503 * X-Server. Give them back a local channel number. */
4504 struct ssh_channel
*c
;
4505 int remoteid
= ssh_pkt_getuint32(pktin
);
4507 logevent("Received X11 connect request");
4508 /* Refuse if X11 forwarding is disabled. */
4509 if (!ssh
->X11_fwd_enabled
) {
4510 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4511 PKT_INT
, remoteid
, PKT_END
);
4512 logevent("Rejected X11 connect request");
4514 c
= snew(struct ssh_channel
);
4517 if (x11_init(&c
->u
.x11
.s
, ssh
->cfg
.x11_display
, c
,
4518 ssh
->x11auth
, NULL
, -1, &ssh
->cfg
) != NULL
) {
4519 logevent("Opening X11 forward connection failed");
4521 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4522 PKT_INT
, remoteid
, PKT_END
);
4525 ("Opening X11 forward connection succeeded");
4526 c
->remoteid
= remoteid
;
4527 c
->halfopen
= FALSE
;
4528 c
->localid
= alloc_channel_id(ssh
);
4530 c
->v
.v1
.throttling
= 0;
4531 c
->type
= CHAN_X11
; /* identify channel type */
4532 add234(ssh
->channels
, c
);
4533 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4534 PKT_INT
, c
->remoteid
, PKT_INT
,
4535 c
->localid
, PKT_END
);
4536 logevent("Opened X11 forward channel");
4541 static void ssh1_smsg_agent_open(Ssh ssh
, struct Packet
*pktin
)
4543 /* Remote side is trying to open a channel to talk to our
4544 * agent. Give them back a local channel number. */
4545 struct ssh_channel
*c
;
4546 int remoteid
= ssh_pkt_getuint32(pktin
);
4548 /* Refuse if agent forwarding is disabled. */
4549 if (!ssh
->agentfwd_enabled
) {
4550 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4551 PKT_INT
, remoteid
, PKT_END
);
4553 c
= snew(struct ssh_channel
);
4555 c
->remoteid
= remoteid
;
4556 c
->halfopen
= FALSE
;
4557 c
->localid
= alloc_channel_id(ssh
);
4559 c
->v
.v1
.throttling
= 0;
4560 c
->type
= CHAN_AGENT
; /* identify channel type */
4561 c
->u
.a
.lensofar
= 0;
4562 add234(ssh
->channels
, c
);
4563 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4564 PKT_INT
, c
->remoteid
, PKT_INT
, c
->localid
,
4569 static void ssh1_msg_port_open(Ssh ssh
, struct Packet
*pktin
)
4571 /* Remote side is trying to open a channel to talk to a
4572 * forwarded port. Give them back a local channel number. */
4573 struct ssh_channel
*c
;
4574 struct ssh_rportfwd pf
, *pfp
;
4579 c
= snew(struct ssh_channel
);
4582 remoteid
= ssh_pkt_getuint32(pktin
);
4583 ssh_pkt_getstring(pktin
, &host
, &hostsize
);
4584 port
= ssh_pkt_getuint32(pktin
);
4586 if (hostsize
>= lenof(pf
.dhost
))
4587 hostsize
= lenof(pf
.dhost
)-1;
4588 memcpy(pf
.dhost
, host
, hostsize
);
4589 pf
.dhost
[hostsize
] = '\0';
4591 pfp
= find234(ssh
->rportfwds
, &pf
, NULL
);
4594 logeventf(ssh
, "Rejected remote port open request for %s:%d",
4596 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4597 PKT_INT
, remoteid
, PKT_END
);
4599 logeventf(ssh
, "Received remote port open request for %s:%d",
4601 e
= pfd_newconnect(&c
->u
.pfd
.s
, pf
.dhost
, port
,
4602 c
, &ssh
->cfg
, pfp
->pfrec
->addressfamily
);
4604 logeventf(ssh
, "Port open failed: %s", e
);
4606 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_FAILURE
,
4607 PKT_INT
, remoteid
, PKT_END
);
4609 c
->remoteid
= remoteid
;
4610 c
->halfopen
= FALSE
;
4611 c
->localid
= alloc_channel_id(ssh
);
4613 c
->v
.v1
.throttling
= 0;
4614 c
->type
= CHAN_SOCKDATA
; /* identify channel type */
4615 add234(ssh
->channels
, c
);
4616 send_packet(ssh
, SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
,
4617 PKT_INT
, c
->remoteid
, PKT_INT
,
4618 c
->localid
, PKT_END
);
4619 logevent("Forwarded port opened successfully");
4624 static void ssh1_msg_channel_open_confirmation(Ssh ssh
, struct Packet
*pktin
)
4626 unsigned int remoteid
= ssh_pkt_getuint32(pktin
);
4627 unsigned int localid
= ssh_pkt_getuint32(pktin
);
4628 struct ssh_channel
*c
;
4630 c
= find234(ssh
->channels
, &remoteid
, ssh_channelfind
);
4631 if (c
&& c
->type
== CHAN_SOCKDATA_DORMANT
) {
4632 c
->remoteid
= localid
;
4633 c
->halfopen
= FALSE
;
4634 c
->type
= CHAN_SOCKDATA
;
4635 c
->v
.v1
.throttling
= 0;
4636 pfd_confirm(c
->u
.pfd
.s
);
4639 if (c
&& c
->closes
) {
4641 * We have a pending close on this channel,
4642 * which we decided on before the server acked
4643 * the channel open. So now we know the
4644 * remoteid, we can close it again.
4646 send_packet(ssh
, SSH1_MSG_CHANNEL_CLOSE
,
4647 PKT_INT
, c
->remoteid
, PKT_END
);
4651 static void ssh1_msg_channel_open_failure(Ssh ssh
, struct Packet
*pktin
)
4653 unsigned int remoteid
= ssh_pkt_getuint32(pktin
);
4654 struct ssh_channel
*c
;
4656 c
= find234(ssh
->channels
, &remoteid
, ssh_channelfind
);
4657 if (c
&& c
->type
== CHAN_SOCKDATA_DORMANT
) {
4658 logevent("Forwarded connection refused by server");
4659 pfd_close(c
->u
.pfd
.s
);
4660 del234(ssh
->channels
, c
);
4665 static void ssh1_msg_channel_close(Ssh ssh
, struct Packet
*pktin
)
4667 /* Remote side closes a channel. */
4668 unsigned i
= ssh_pkt_getuint32(pktin
);
4669 struct ssh_channel
*c
;
4670 c
= find234(ssh
->channels
, &i
, ssh_channelfind
);
4671 if (c
&& !c
->halfopen
) {
4674 (pktin
->type
== SSH1_MSG_CHANNEL_CLOSE ?
1 : 2);
4676 if ((c
->closes
== 0) && (c
->type
== CHAN_X11
)) {
4677 logevent("Forwarded X11 connection terminated");
4678 assert(c
->u
.x11
.s
!= NULL
);
4679 x11_close(c
->u
.x11
.s
);
4682 if ((c
->closes
== 0) && (c
->type
== CHAN_SOCKDATA
)) {
4683 logevent("Forwarded port closed");
4684 assert(c
->u
.pfd
.s
!= NULL
);
4685 pfd_close(c
->u
.pfd
.s
);
4689 c
->closes
|= (closetype
<< 2); /* seen this message */
4690 if (!(c
->closes
& closetype
)) {
4691 send_packet(ssh
, pktin
->type
, PKT_INT
, c
->remoteid
,
4693 c
->closes
|= closetype
; /* sent it too */
4696 if (c
->closes
== 15) {
4697 del234(ssh
->channels
, c
);
4701 bombout(("Received CHANNEL_CLOSE%s for %s channel %d\n",
4702 pktin
->type
== SSH1_MSG_CHANNEL_CLOSE ?
"" :
4703 "_CONFIRMATION", c ?
"half-open" : "nonexistent",
4708 static void ssh1_msg_channel_data(Ssh ssh
, struct Packet
*pktin
)
4710 /* Data sent down one of our channels. */
4711 int i
= ssh_pkt_getuint32(pktin
);
4714 struct ssh_channel
*c
;
4716 ssh_pkt_getstring(pktin
, &p
, &len
);
4718 c
= find234(ssh
->channels
, &i
, ssh_channelfind
);
4723 bufsize
= x11_send(c
->u
.x11
.s
, p
, len
);
4726 bufsize
= pfd_send(c
->u
.pfd
.s
, p
, len
);
4729 /* Data for an agent message. Buffer it. */
4731 if (c
->u
.a
.lensofar
< 4) {
4732 unsigned int l
= min(4 - c
->u
.a
.lensofar
, (unsigned)len
);
4733 memcpy(c
->u
.a
.msglen
+ c
->u
.a
.lensofar
, p
,
4737 c
->u
.a
.lensofar
+= l
;
4739 if (c
->u
.a
.lensofar
== 4) {
4741 4 + GET_32BIT(c
->u
.a
.msglen
);
4742 c
->u
.a
.message
= snewn(c
->u
.a
.totallen
,
4744 memcpy(c
->u
.a
.message
, c
->u
.a
.msglen
, 4);
4746 if (c
->u
.a
.lensofar
>= 4 && len
> 0) {
4748 min(c
->u
.a
.totallen
- c
->u
.a
.lensofar
,
4750 memcpy(c
->u
.a
.message
+ c
->u
.a
.lensofar
, p
,
4754 c
->u
.a
.lensofar
+= l
;
4756 if (c
->u
.a
.lensofar
== c
->u
.a
.totallen
) {
4759 if (agent_query(c
->u
.a
.message
,
4762 ssh_agentf_callback
, c
))
4763 ssh_agentf_callback(c
, reply
, replylen
);
4764 sfree(c
->u
.a
.message
);
4765 c
->u
.a
.lensofar
= 0;
4768 bufsize
= 0; /* agent channels never back up */
4771 if (!c
->v
.v1
.throttling
&& bufsize
> SSH1_BUFFER_LIMIT
) {
4772 c
->v
.v1
.throttling
= 1;
4773 ssh1_throttle(ssh
, +1);
4778 static void ssh1_smsg_exit_status(Ssh ssh
, struct Packet
*pktin
)
4780 ssh
->exitcode
= ssh_pkt_getuint32(pktin
);
4781 logeventf(ssh
, "Server sent command exit status %d", ssh
->exitcode
);
4782 send_packet(ssh
, SSH1_CMSG_EXIT_CONFIRMATION
, PKT_END
);
4784 * In case `helpful' firewalls or proxies tack
4785 * extra human-readable text on the end of the
4786 * session which we might mistake for another
4787 * encrypted packet, we close the session once
4788 * we've sent EXIT_CONFIRMATION.
4790 ssh_disconnect(ssh
, NULL
, NULL
, 0, TRUE
);
4793 /* Helper function to deal with sending tty modes for REQUEST_PTY */
4794 static void ssh1_send_ttymode(void *data
, char *mode
, char *val
)
4796 struct Packet
*pktout
= (struct Packet
*)data
;
4798 unsigned int arg
= 0;
4799 while (strcmp(mode
, ssh_ttymodes
[i
].mode
) != 0) i
++;
4800 if (i
== lenof(ssh_ttymodes
)) return;
4801 switch (ssh_ttymodes
[i
].type
) {
4803 arg
= ssh_tty_parse_specchar(val
);
4806 arg
= ssh_tty_parse_boolean(val
);
4809 ssh2_pkt_addbyte(pktout
, ssh_ttymodes
[i
].opcode
);
4810 ssh2_pkt_addbyte(pktout
, arg
);
4814 static void do_ssh1_connection(Ssh ssh
, unsigned char *in
, int inlen
,
4815 struct Packet
*pktin
)
4817 crBegin(ssh
->do_ssh1_connection_crstate
);
4819 ssh
->packet_dispatch
[SSH1_SMSG_STDOUT_DATA
] =
4820 ssh
->packet_dispatch
[SSH1_SMSG_STDERR_DATA
] =
4821 ssh1_smsg_stdout_stderr_data
;
4823 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_OPEN_CONFIRMATION
] =
4824 ssh1_msg_channel_open_confirmation
;
4825 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_OPEN_FAILURE
] =
4826 ssh1_msg_channel_open_failure
;
4827 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_CLOSE
] =
4828 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_CLOSE_CONFIRMATION
] =
4829 ssh1_msg_channel_close
;
4830 ssh
->packet_dispatch
[SSH1_MSG_CHANNEL_DATA
] = ssh1_msg_channel_data
;
4831 ssh
->packet_dispatch
[SSH1_SMSG_EXIT_STATUS
] = ssh1_smsg_exit_status
;
4833 if (ssh
->cfg
.agentfwd
&& agent_exists()) {
4834 logevent("Requesting agent forwarding");
4835 send_packet(ssh
, SSH1_CMSG_AGENT_REQUEST_FORWARDING
, PKT_END
);
4839 if (pktin
->type
!= SSH1_SMSG_SUCCESS
4840 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
4841 bombout(("Protocol confusion"));
4843 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
4844 logevent("Agent forwarding refused");
4846 logevent("Agent forwarding enabled");
4847 ssh
->agentfwd_enabled
= TRUE
;
4848 ssh
->packet_dispatch
[SSH1_SMSG_AGENT_OPEN
] = ssh1_smsg_agent_open
;
4852 if (ssh
->cfg
.x11_forward
) {
4853 char proto
[20], data
[64];
4854 logevent("Requesting X11 forwarding");
4855 ssh
->x11auth
= x11_invent_auth(proto
, sizeof(proto
),
4856 data
, sizeof(data
), ssh
->cfg
.x11_auth
);
4857 x11_get_real_auth(ssh
->x11auth
, ssh
->cfg
.x11_display
);
4859 * Note that while we blank the X authentication data here, we don't
4860 * take any special action to blank the start of an X11 channel,
4861 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
4862 * without having session blanking enabled is likely to leak your
4863 * cookie into the log.
4865 if (ssh
->v1_local_protoflags
& SSH1_PROTOFLAG_SCREEN_NUMBER
) {
4866 send_packet(ssh
, SSH1_CMSG_X11_REQUEST_FORWARDING
,
4868 PKTT_PASSWORD
, PKT_STR
, data
, PKTT_OTHER
,
4869 PKT_INT
, x11_get_screen_number(ssh
->cfg
.x11_display
),
4872 send_packet(ssh
, SSH1_CMSG_X11_REQUEST_FORWARDING
,
4874 PKTT_PASSWORD
, PKT_STR
, data
, PKTT_OTHER
, PKT_END
);
4879 if (pktin
->type
!= SSH1_SMSG_SUCCESS
4880 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
4881 bombout(("Protocol confusion"));
4883 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
4884 logevent("X11 forwarding refused");
4886 logevent("X11 forwarding enabled");
4887 ssh
->X11_fwd_enabled
= TRUE
;
4888 ssh
->packet_dispatch
[SSH1_SMSG_X11_OPEN
] = ssh1_smsg_x11_open
;
4892 ssh_setup_portfwd(ssh
, &ssh
->cfg
);
4893 ssh
->packet_dispatch
[SSH1_MSG_PORT_OPEN
] = ssh1_msg_port_open
;
4895 if (!ssh
->cfg
.nopty
) {
4897 /* Unpick the terminal-speed string. */
4898 /* XXX perhaps we should allow no speeds to be sent. */
4899 ssh
->ospeed
= 38400; ssh
->ispeed
= 38400; /* last-resort defaults */
4900 sscanf(ssh
->cfg
.termspeed
, "%d,%d", &ssh
->ospeed
, &ssh
->ispeed
);
4901 /* Send the pty request. */
4902 pkt
= ssh1_pkt_init(SSH1_CMSG_REQUEST_PTY
);
4903 ssh_pkt_addstring(pkt
, ssh
->cfg
.termtype
);
4904 ssh_pkt_adduint32(pkt
, ssh
->term_height
);
4905 ssh_pkt_adduint32(pkt
, ssh
->term_width
);
4906 ssh_pkt_adduint32(pkt
, 0); /* width in pixels */
4907 ssh_pkt_adduint32(pkt
, 0); /* height in pixels */
4908 parse_ttymodes(ssh
, ssh
->cfg
.ttymodes
,
4909 ssh1_send_ttymode
, (void *)pkt
);
4910 ssh_pkt_addbyte(pkt
, SSH1_TTY_OP_ISPEED
);
4911 ssh_pkt_adduint32(pkt
, ssh
->ispeed
);
4912 ssh_pkt_addbyte(pkt
, SSH1_TTY_OP_OSPEED
);
4913 ssh_pkt_adduint32(pkt
, ssh
->ospeed
);
4914 ssh_pkt_addbyte(pkt
, SSH_TTY_OP_END
);
4916 ssh
->state
= SSH_STATE_INTERMED
;
4920 if (pktin
->type
!= SSH1_SMSG_SUCCESS
4921 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
4922 bombout(("Protocol confusion"));
4924 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
4925 c_write_str(ssh
, "Server refused to allocate pty\r\n");
4926 ssh
->editing
= ssh
->echoing
= 1;
4928 logeventf(ssh
, "Allocated pty (ospeed %dbps, ispeed %dbps)",
4929 ssh
->ospeed
, ssh
->ispeed
);
4931 ssh
->editing
= ssh
->echoing
= 1;
4934 if (ssh
->cfg
.compression
) {
4935 send_packet(ssh
, SSH1_CMSG_REQUEST_COMPRESSION
, PKT_INT
, 6, PKT_END
);
4939 if (pktin
->type
!= SSH1_SMSG_SUCCESS
4940 && pktin
->type
!= SSH1_SMSG_FAILURE
) {
4941 bombout(("Protocol confusion"));
4943 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
4944 c_write_str(ssh
, "Server refused to compress\r\n");
4946 logevent("Started compression");
4947 ssh
->v1_compressing
= TRUE
;
4948 ssh
->cs_comp_ctx
= zlib_compress_init();
4949 logevent("Initialised zlib (RFC1950) compression");
4950 ssh
->sc_comp_ctx
= zlib_decompress_init();
4951 logevent("Initialised zlib (RFC1950) decompression");
4955 * Start the shell or command.
4957 * Special case: if the first-choice command is an SSH-2
4958 * subsystem (hence not usable here) and the second choice
4959 * exists, we fall straight back to that.
4962 char *cmd
= ssh
->cfg
.remote_cmd_ptr
;
4964 if (!cmd
) cmd
= ssh
->cfg
.remote_cmd
;
4966 if (ssh
->cfg
.ssh_subsys
&& ssh
->cfg
.remote_cmd_ptr2
) {
4967 cmd
= ssh
->cfg
.remote_cmd_ptr2
;
4968 ssh
->fallback_cmd
= TRUE
;
4971 send_packet(ssh
, SSH1_CMSG_EXEC_CMD
, PKT_STR
, cmd
, PKT_END
);
4973 send_packet(ssh
, SSH1_CMSG_EXEC_SHELL
, PKT_END
);
4974 logevent("Started session");
4977 ssh
->state
= SSH_STATE_SESSION
;
4978 if (ssh
->size_needed
)
4979 ssh_size(ssh
, ssh
->term_width
, ssh
->term_height
);
4980 if (ssh
->eof_needed
)
4981 ssh_special(ssh
, TS_EOF
);
4984 ldisc_send(ssh
->ldisc
, NULL
, 0, 0);/* cause ldisc to notice changes */
4986 ssh
->channels
= newtree234(ssh_channelcmp
);
4990 * By this point, most incoming packets are already being
4991 * handled by the dispatch table, and we need only pay
4992 * attention to the unusual ones.
4997 if (pktin
->type
== SSH1_SMSG_SUCCESS
) {
4998 /* may be from EXEC_SHELL on some servers */
4999 } else if (pktin
->type
== SSH1_SMSG_FAILURE
) {
5000 /* may be from EXEC_SHELL on some servers
5001 * if no pty is available or in other odd cases. Ignore */
5003 bombout(("Strange packet received: type %d", pktin
->type
));
5008 int len
= min(inlen
, 512);
5009 send_packet(ssh
, SSH1_CMSG_STDIN_DATA
,
5010 PKT_INT
, len
, PKTT_DATA
, PKT_DATA
, in
, len
,
5011 PKTT_OTHER
, PKT_END
);
5022 * Handle the top-level SSH-2 protocol.
5024 static void ssh1_msg_debug(Ssh ssh
, struct Packet
*pktin
)
5029 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
5030 logeventf(ssh
, "Remote debug message: %.*s", msglen
, msg
);
5033 static void ssh1_msg_disconnect(Ssh ssh
, struct Packet
*pktin
)
5035 /* log reason code in disconnect message */
5039 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
5040 bombout(("Server sent disconnect message:\n\"%.*s\"", msglen
, msg
));
5043 static void ssh_msg_ignore(Ssh ssh
, struct Packet
*pktin
)
5045 /* Do nothing, because we're ignoring it! Duhh. */
5048 static void ssh1_protocol_setup(Ssh ssh
)
5053 * Most messages are handled by the coroutines.
5055 for (i
= 0; i
< 256; i
++)
5056 ssh
->packet_dispatch
[i
] = NULL
;
5059 * These special message types we install handlers for.
5061 ssh
->packet_dispatch
[SSH1_MSG_DISCONNECT
] = ssh1_msg_disconnect
;
5062 ssh
->packet_dispatch
[SSH1_MSG_IGNORE
] = ssh_msg_ignore
;
5063 ssh
->packet_dispatch
[SSH1_MSG_DEBUG
] = ssh1_msg_debug
;
5066 static void ssh1_protocol(Ssh ssh
, void *vin
, int inlen
,
5067 struct Packet
*pktin
)
5069 unsigned char *in
=(unsigned char*)vin
;
5070 if (ssh
->state
== SSH_STATE_CLOSED
)
5073 if (pktin
&& ssh
->packet_dispatch
[pktin
->type
]) {
5074 ssh
->packet_dispatch
[pktin
->type
](ssh
, pktin
);
5078 if (!ssh
->protocol_initial_phase_done
) {
5079 if (do_ssh1_login(ssh
, in
, inlen
, pktin
))
5080 ssh
->protocol_initial_phase_done
= TRUE
;
5085 do_ssh1_connection(ssh
, in
, inlen
, pktin
);
5089 * Utility routine for decoding comma-separated strings in KEXINIT.
5091 static int in_commasep_string(char *needle
, char *haystack
, int haylen
)
5094 if (!needle
|| !haystack
) /* protect against null pointers */
5096 needlen
= strlen(needle
);
5099 * Is it at the start of the string?
5101 if (haylen
>= needlen
&& /* haystack is long enough */
5102 !memcmp(needle
, haystack
, needlen
) && /* initial match */
5103 (haylen
== needlen
|| haystack
[needlen
] == ',')
5104 /* either , or EOS follows */
5108 * If not, search for the next comma and resume after that.
5109 * If no comma found, terminate.
5111 while (haylen
> 0 && *haystack
!= ',')
5112 haylen
--, haystack
++;
5115 haylen
--, haystack
++; /* skip over comma itself */
5120 * Similar routine for checking whether we have the first string in a list.
5122 static int first_in_commasep_string(char *needle
, char *haystack
, int haylen
)
5125 if (!needle
|| !haystack
) /* protect against null pointers */
5127 needlen
= strlen(needle
);
5129 * Is it at the start of the string?
5131 if (haylen
>= needlen
&& /* haystack is long enough */
5132 !memcmp(needle
, haystack
, needlen
) && /* initial match */
5133 (haylen
== needlen
|| haystack
[needlen
] == ',')
5134 /* either , or EOS follows */
5142 * SSH-2 key creation method.
5143 * (Currently assumes 2 lots of any hash are sufficient to generate
5144 * keys/IVs for any cipher/MAC. SSH2_MKKEY_ITERS documents this assumption.)
5146 #define SSH2_MKKEY_ITERS (2)
5147 static void ssh2_mkkey(Ssh ssh
, Bignum K
, unsigned char *H
, char chr
,
5148 unsigned char *keyspace
)
5150 const struct ssh_hash
*h
= ssh
->kex
->hash
;
5152 /* First hlen bytes. */
5154 if (!(ssh
->remote_bugs
& BUG_SSH2_DERIVEKEY
))
5155 hash_mpint(h
, s
, K
);
5156 h
->bytes(s
, H
, h
->hlen
);
5157 h
->bytes(s
, &chr
, 1);
5158 h
->bytes(s
, ssh
->v2_session_id
, ssh
->v2_session_id_len
);
5159 h
->final(s
, keyspace
);
5160 /* Next hlen bytes. */
5162 if (!(ssh
->remote_bugs
& BUG_SSH2_DERIVEKEY
))
5163 hash_mpint(h
, s
, K
);
5164 h
->bytes(s
, H
, h
->hlen
);
5165 h
->bytes(s
, keyspace
, h
->hlen
);
5166 h
->final(s
, keyspace
+ h
->hlen
);
5170 * Handle the SSH-2 transport layer.
5172 static int do_ssh2_transport(Ssh ssh
, void *vin
, int inlen
,
5173 struct Packet
*pktin
)
5175 unsigned char *in
= (unsigned char *)vin
;
5176 struct do_ssh2_transport_state
{
5177 int nbits
, pbits
, warn_kex
, warn_cscipher
, warn_sccipher
;
5178 Bignum p
, g
, e
, f
, K
;
5181 int kex_init_value
, kex_reply_value
;
5182 const struct ssh_mac
**maclist
;
5184 const struct ssh2_cipher
*cscipher_tobe
;
5185 const struct ssh2_cipher
*sccipher_tobe
;
5186 const struct ssh_mac
*csmac_tobe
;
5187 const struct ssh_mac
*scmac_tobe
;
5188 const struct ssh_compress
*cscomp_tobe
;
5189 const struct ssh_compress
*sccomp_tobe
;
5190 char *hostkeydata
, *sigdata
, *rsakeydata
, *keystr
, *fingerprint
;
5191 int hostkeylen
, siglen
, rsakeylen
;
5192 void *hkey
; /* actual host key */
5193 void *rsakey
; /* for RSA kex */
5194 unsigned char exchange_hash
[SSH2_KEX_MAX_HASH_LEN
];
5195 int n_preferred_kex
;
5196 const struct ssh_kexes
*preferred_kex
[KEX_MAX
];
5197 int n_preferred_ciphers
;
5198 const struct ssh2_ciphers
*preferred_ciphers
[CIPHER_MAX
];
5199 const struct ssh_compress
*preferred_comp
;
5200 int got_session_id
, activated_authconn
;
5201 struct Packet
*pktout
;
5206 crState(do_ssh2_transport_state
);
5208 crBegin(ssh
->do_ssh2_transport_crstate
);
5210 s
->cscipher_tobe
= s
->sccipher_tobe
= NULL
;
5211 s
->csmac_tobe
= s
->scmac_tobe
= NULL
;
5212 s
->cscomp_tobe
= s
->sccomp_tobe
= NULL
;
5214 s
->got_session_id
= s
->activated_authconn
= FALSE
;
5217 * Be prepared to work around the buggy MAC problem.
5219 if (ssh
->remote_bugs
& BUG_SSH2_HMAC
)
5220 s
->maclist
= buggymacs
, s
->nmacs
= lenof(buggymacs
);
5222 s
->maclist
= macs
, s
->nmacs
= lenof(macs
);
5225 ssh
->pkt_kctx
= SSH2_PKTCTX_NOKEX
;
5227 int i
, j
, commalist_started
;
5230 * Set up the preferred key exchange. (NULL => warn below here)
5232 s
->n_preferred_kex
= 0;
5233 for (i
= 0; i
< KEX_MAX
; i
++) {
5234 switch (ssh
->cfg
.ssh_kexlist
[i
]) {
5236 s
->preferred_kex
[s
->n_preferred_kex
++] =
5237 &ssh_diffiehellman_gex
;
5240 s
->preferred_kex
[s
->n_preferred_kex
++] =
5241 &ssh_diffiehellman_group14
;
5244 s
->preferred_kex
[s
->n_preferred_kex
++] =
5245 &ssh_diffiehellman_group1
;
5248 s
->preferred_kex
[s
->n_preferred_kex
++] =
5252 /* Flag for later. Don't bother if it's the last in
5254 if (i
< KEX_MAX
- 1) {
5255 s
->preferred_kex
[s
->n_preferred_kex
++] = NULL
;
5262 * Set up the preferred ciphers. (NULL => warn below here)
5264 s
->n_preferred_ciphers
= 0;
5265 for (i
= 0; i
< CIPHER_MAX
; i
++) {
5266 switch (ssh
->cfg
.ssh_cipherlist
[i
]) {
5267 case CIPHER_BLOWFISH
:
5268 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_blowfish
;
5271 if (ssh
->cfg
.ssh2_des_cbc
) {
5272 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_des
;
5276 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_3des
;
5279 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_aes
;
5281 case CIPHER_ARCFOUR
:
5282 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = &ssh2_arcfour
;
5285 /* Flag for later. Don't bother if it's the last in
5287 if (i
< CIPHER_MAX
- 1) {
5288 s
->preferred_ciphers
[s
->n_preferred_ciphers
++] = NULL
;
5295 * Set up preferred compression.
5297 if (ssh
->cfg
.compression
)
5298 s
->preferred_comp
= &ssh_zlib
;
5300 s
->preferred_comp
= &ssh_comp_none
;
5303 * Enable queueing of outgoing auth- or connection-layer
5304 * packets while we are in the middle of a key exchange.
5306 ssh
->queueing
= TRUE
;
5309 * Flag that KEX is in progress.
5311 ssh
->kex_in_progress
= TRUE
;
5314 * Construct and send our key exchange packet.
5316 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEXINIT
);
5317 for (i
= 0; i
< 16; i
++)
5318 ssh2_pkt_addbyte(s
->pktout
, (unsigned char) random_byte());
5319 /* List key exchange algorithms. */
5320 ssh2_pkt_addstring_start(s
->pktout
);
5321 commalist_started
= 0;
5322 for (i
= 0; i
< s
->n_preferred_kex
; i
++) {
5323 const struct ssh_kexes
*k
= s
->preferred_kex
[i
];
5324 if (!k
) continue; /* warning flag */
5325 for (j
= 0; j
< k
->nkexes
; j
++) {
5326 if (commalist_started
)
5327 ssh2_pkt_addstring_str(s
->pktout
, ",");
5328 ssh2_pkt_addstring_str(s
->pktout
, k
->list
[j
]->name
);
5329 commalist_started
= 1;
5332 /* List server host key algorithms. */
5333 ssh2_pkt_addstring_start(s
->pktout
);
5334 for (i
= 0; i
< lenof(hostkey_algs
); i
++) {
5335 ssh2_pkt_addstring_str(s
->pktout
, hostkey_algs
[i
]->name
);
5336 if (i
< lenof(hostkey_algs
) - 1)
5337 ssh2_pkt_addstring_str(s
->pktout
, ",");
5339 /* List client->server encryption algorithms. */
5340 ssh2_pkt_addstring_start(s
->pktout
);
5341 commalist_started
= 0;
5342 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5343 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5344 if (!c
) continue; /* warning flag */
5345 for (j
= 0; j
< c
->nciphers
; j
++) {
5346 if (commalist_started
)
5347 ssh2_pkt_addstring_str(s
->pktout
, ",");
5348 ssh2_pkt_addstring_str(s
->pktout
, c
->list
[j
]->name
);
5349 commalist_started
= 1;
5352 /* List server->client encryption algorithms. */
5353 ssh2_pkt_addstring_start(s
->pktout
);
5354 commalist_started
= 0;
5355 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5356 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5357 if (!c
) continue; /* warning flag */
5358 for (j
= 0; j
< c
->nciphers
; j
++) {
5359 if (commalist_started
)
5360 ssh2_pkt_addstring_str(s
->pktout
, ",");
5361 ssh2_pkt_addstring_str(s
->pktout
, c
->list
[j
]->name
);
5362 commalist_started
= 1;
5365 /* List client->server MAC algorithms. */
5366 ssh2_pkt_addstring_start(s
->pktout
);
5367 for (i
= 0; i
< s
->nmacs
; i
++) {
5368 ssh2_pkt_addstring_str(s
->pktout
, s
->maclist
[i
]->name
);
5369 if (i
< s
->nmacs
- 1)
5370 ssh2_pkt_addstring_str(s
->pktout
, ",");
5372 /* List server->client MAC algorithms. */
5373 ssh2_pkt_addstring_start(s
->pktout
);
5374 for (i
= 0; i
< s
->nmacs
; i
++) {
5375 ssh2_pkt_addstring_str(s
->pktout
, s
->maclist
[i
]->name
);
5376 if (i
< s
->nmacs
- 1)
5377 ssh2_pkt_addstring_str(s
->pktout
, ",");
5379 /* List client->server compression algorithms. */
5380 ssh2_pkt_addstring_start(s
->pktout
);
5381 assert(lenof(compressions
) > 1);
5382 ssh2_pkt_addstring_str(s
->pktout
, s
->preferred_comp
->name
);
5383 for (i
= 0; i
< lenof(compressions
); i
++) {
5384 const struct ssh_compress
*c
= compressions
[i
];
5385 if (c
!= s
->preferred_comp
) {
5386 ssh2_pkt_addstring_str(s
->pktout
, ",");
5387 ssh2_pkt_addstring_str(s
->pktout
, c
->name
);
5390 /* List server->client compression algorithms. */
5391 ssh2_pkt_addstring_start(s
->pktout
);
5392 assert(lenof(compressions
) > 1);
5393 ssh2_pkt_addstring_str(s
->pktout
, s
->preferred_comp
->name
);
5394 for (i
= 0; i
< lenof(compressions
); i
++) {
5395 const struct ssh_compress
*c
= compressions
[i
];
5396 if (c
!= s
->preferred_comp
) {
5397 ssh2_pkt_addstring_str(s
->pktout
, ",");
5398 ssh2_pkt_addstring_str(s
->pktout
, c
->name
);
5401 /* List client->server languages. Empty list. */
5402 ssh2_pkt_addstring_start(s
->pktout
);
5403 /* List server->client languages. Empty list. */
5404 ssh2_pkt_addstring_start(s
->pktout
);
5405 /* First KEX packet does _not_ follow, because we're not that brave. */
5406 ssh2_pkt_addbool(s
->pktout
, FALSE
);
5408 ssh2_pkt_adduint32(s
->pktout
, 0);
5411 s
->our_kexinitlen
= s
->pktout
->length
- 5;
5412 s
->our_kexinit
= snewn(s
->our_kexinitlen
, unsigned char);
5413 memcpy(s
->our_kexinit
, s
->pktout
->data
+ 5, s
->our_kexinitlen
);
5415 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5421 * Now examine the other side's KEXINIT to see what we're up
5425 char *str
, *preferred
;
5428 if (pktin
->type
!= SSH2_MSG_KEXINIT
) {
5429 bombout(("expected key exchange packet from server"));
5433 ssh
->hostkey
= NULL
;
5434 s
->cscipher_tobe
= NULL
;
5435 s
->sccipher_tobe
= NULL
;
5436 s
->csmac_tobe
= NULL
;
5437 s
->scmac_tobe
= NULL
;
5438 s
->cscomp_tobe
= NULL
;
5439 s
->sccomp_tobe
= NULL
;
5440 s
->warn_kex
= s
->warn_cscipher
= s
->warn_sccipher
= FALSE
;
5442 pktin
->savedpos
+= 16; /* skip garbage cookie */
5443 ssh_pkt_getstring(pktin
, &str
, &len
); /* key exchange algorithms */
5446 for (i
= 0; i
< s
->n_preferred_kex
; i
++) {
5447 const struct ssh_kexes
*k
= s
->preferred_kex
[i
];
5451 for (j
= 0; j
< k
->nkexes
; j
++) {
5452 if (!preferred
) preferred
= k
->list
[j
]->name
;
5453 if (in_commasep_string(k
->list
[j
]->name
, str
, len
)) {
5454 ssh
->kex
= k
->list
[j
];
5463 bombout(("Couldn't agree a key exchange algorithm (available: %s)",
5464 str ? str
: "(null)"));
5468 * Note that the server's guess is considered wrong if it doesn't match
5469 * the first algorithm in our list, even if it's still the algorithm
5472 s
->guessok
= first_in_commasep_string(preferred
, str
, len
);
5473 ssh_pkt_getstring(pktin
, &str
, &len
); /* host key algorithms */
5474 for (i
= 0; i
< lenof(hostkey_algs
); i
++) {
5475 if (in_commasep_string(hostkey_algs
[i
]->name
, str
, len
)) {
5476 ssh
->hostkey
= hostkey_algs
[i
];
5480 s
->guessok
= s
->guessok
&&
5481 first_in_commasep_string(hostkey_algs
[0]->name
, str
, len
);
5482 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server cipher */
5483 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5484 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5486 s
->warn_cscipher
= TRUE
;
5488 for (j
= 0; j
< c
->nciphers
; j
++) {
5489 if (in_commasep_string(c
->list
[j
]->name
, str
, len
)) {
5490 s
->cscipher_tobe
= c
->list
[j
];
5495 if (s
->cscipher_tobe
)
5498 if (!s
->cscipher_tobe
) {
5499 bombout(("Couldn't agree a client-to-server cipher (available: %s)",
5500 str ? str
: "(null)"));
5504 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client cipher */
5505 for (i
= 0; i
< s
->n_preferred_ciphers
; i
++) {
5506 const struct ssh2_ciphers
*c
= s
->preferred_ciphers
[i
];
5508 s
->warn_sccipher
= TRUE
;
5510 for (j
= 0; j
< c
->nciphers
; j
++) {
5511 if (in_commasep_string(c
->list
[j
]->name
, str
, len
)) {
5512 s
->sccipher_tobe
= c
->list
[j
];
5517 if (s
->sccipher_tobe
)
5520 if (!s
->sccipher_tobe
) {
5521 bombout(("Couldn't agree a server-to-client cipher (available: %s)",
5522 str ? str
: "(null)"));
5526 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server mac */
5527 for (i
= 0; i
< s
->nmacs
; i
++) {
5528 if (in_commasep_string(s
->maclist
[i
]->name
, str
, len
)) {
5529 s
->csmac_tobe
= s
->maclist
[i
];
5533 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client mac */
5534 for (i
= 0; i
< s
->nmacs
; i
++) {
5535 if (in_commasep_string(s
->maclist
[i
]->name
, str
, len
)) {
5536 s
->scmac_tobe
= s
->maclist
[i
];
5540 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server compression */
5541 for (i
= 0; i
< lenof(compressions
) + 1; i
++) {
5542 const struct ssh_compress
*c
=
5543 i
== 0 ? s
->preferred_comp
: compressions
[i
- 1];
5544 if (in_commasep_string(c
->name
, str
, len
)) {
5549 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client compression */
5550 for (i
= 0; i
< lenof(compressions
) + 1; i
++) {
5551 const struct ssh_compress
*c
=
5552 i
== 0 ? s
->preferred_comp
: compressions
[i
- 1];
5553 if (in_commasep_string(c
->name
, str
, len
)) {
5558 ssh_pkt_getstring(pktin
, &str
, &len
); /* client->server language */
5559 ssh_pkt_getstring(pktin
, &str
, &len
); /* server->client language */
5560 s
->ignorepkt
= ssh2_pkt_getbool(pktin
) && !s
->guessok
;
5563 ssh_set_frozen(ssh
, 1);
5564 s
->dlgret
= askalg(ssh
->frontend
, "key-exchange algorithm",
5566 ssh_dialog_callback
, ssh
);
5567 if (s
->dlgret
< 0) {
5571 bombout(("Unexpected data from server while"
5572 " waiting for user response"));
5575 } while (pktin
|| inlen
> 0);
5576 s
->dlgret
= ssh
->user_response
;
5578 ssh_set_frozen(ssh
, 0);
5579 if (s
->dlgret
== 0) {
5580 ssh_disconnect(ssh
, "User aborted at kex warning", NULL
,
5586 if (s
->warn_cscipher
) {
5587 ssh_set_frozen(ssh
, 1);
5588 s
->dlgret
= askalg(ssh
->frontend
,
5589 "client-to-server cipher",
5590 s
->cscipher_tobe
->name
,
5591 ssh_dialog_callback
, ssh
);
5592 if (s
->dlgret
< 0) {
5596 bombout(("Unexpected data from server while"
5597 " waiting for user response"));
5600 } while (pktin
|| inlen
> 0);
5601 s
->dlgret
= ssh
->user_response
;
5603 ssh_set_frozen(ssh
, 0);
5604 if (s
->dlgret
== 0) {
5605 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
5611 if (s
->warn_sccipher
) {
5612 ssh_set_frozen(ssh
, 1);
5613 s
->dlgret
= askalg(ssh
->frontend
,
5614 "server-to-client cipher",
5615 s
->sccipher_tobe
->name
,
5616 ssh_dialog_callback
, ssh
);
5617 if (s
->dlgret
< 0) {
5621 bombout(("Unexpected data from server while"
5622 " waiting for user response"));
5625 } while (pktin
|| inlen
> 0);
5626 s
->dlgret
= ssh
->user_response
;
5628 ssh_set_frozen(ssh
, 0);
5629 if (s
->dlgret
== 0) {
5630 ssh_disconnect(ssh
, "User aborted at cipher warning", NULL
,
5636 ssh
->exhash
= ssh
->kex
->hash
->init();
5637 hash_string(ssh
->kex
->hash
, ssh
->exhash
, ssh
->v_c
, strlen(ssh
->v_c
));
5638 hash_string(ssh
->kex
->hash
, ssh
->exhash
, ssh
->v_s
, strlen(ssh
->v_s
));
5639 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
5640 s
->our_kexinit
, s
->our_kexinitlen
);
5641 sfree(s
->our_kexinit
);
5642 if (pktin
->length
> 5)
5643 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
5644 pktin
->data
+ 5, pktin
->length
- 5);
5646 if (s
->ignorepkt
) /* first_kex_packet_follows */
5647 crWaitUntil(pktin
); /* Ignore packet */
5650 if (ssh
->kex
->main_type
== KEXTYPE_DH
) {
5652 * Work out the number of bits of key we will need from the
5653 * key exchange. We start with the maximum key length of
5659 csbits
= s
->cscipher_tobe
->keylen
;
5660 scbits
= s
->sccipher_tobe
->keylen
;
5661 s
->nbits
= (csbits
> scbits ? csbits
: scbits
);
5663 /* The keys only have hlen-bit entropy, since they're based on
5664 * a hash. So cap the key size at hlen bits. */
5665 if (s
->nbits
> ssh
->kex
->hash
->hlen
* 8)
5666 s
->nbits
= ssh
->kex
->hash
->hlen
* 8;
5669 * If we're doing Diffie-Hellman group exchange, start by
5670 * requesting a group.
5672 if (!ssh
->kex
->pdata
) {
5673 logevent("Doing Diffie-Hellman group exchange");
5674 ssh
->pkt_kctx
= SSH2_PKTCTX_DHGEX
;
5676 * Work out how big a DH group we will need to allow that
5679 s
->pbits
= 512 << ((s
->nbits
- 1) / 64);
5680 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEX_DH_GEX_REQUEST
);
5681 ssh2_pkt_adduint32(s
->pktout
, s
->pbits
);
5682 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5685 if (pktin
->type
!= SSH2_MSG_KEX_DH_GEX_GROUP
) {
5686 bombout(("expected key exchange group packet from server"));
5689 s
->p
= ssh2_pkt_getmp(pktin
);
5690 s
->g
= ssh2_pkt_getmp(pktin
);
5691 if (!s
->p
|| !s
->g
) {
5692 bombout(("unable to read mp-ints from incoming group packet"));
5695 ssh
->kex_ctx
= dh_setup_gex(s
->p
, s
->g
);
5696 s
->kex_init_value
= SSH2_MSG_KEX_DH_GEX_INIT
;
5697 s
->kex_reply_value
= SSH2_MSG_KEX_DH_GEX_REPLY
;
5699 ssh
->pkt_kctx
= SSH2_PKTCTX_DHGROUP
;
5700 ssh
->kex_ctx
= dh_setup_group(ssh
->kex
);
5701 s
->kex_init_value
= SSH2_MSG_KEXDH_INIT
;
5702 s
->kex_reply_value
= SSH2_MSG_KEXDH_REPLY
;
5703 logeventf(ssh
, "Using Diffie-Hellman with standard group \"%s\"",
5704 ssh
->kex
->groupname
);
5707 logeventf(ssh
, "Doing Diffie-Hellman key exchange with hash %s",
5708 ssh
->kex
->hash
->text_name
);
5710 * Now generate and send e for Diffie-Hellman.
5712 set_busy_status(ssh
->frontend
, BUSY_CPU
); /* this can take a while */
5713 s
->e
= dh_create_e(ssh
->kex_ctx
, s
->nbits
* 2);
5714 s
->pktout
= ssh2_pkt_init(s
->kex_init_value
);
5715 ssh2_pkt_addmp(s
->pktout
, s
->e
);
5716 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5718 set_busy_status(ssh
->frontend
, BUSY_WAITING
); /* wait for server */
5720 if (pktin
->type
!= s
->kex_reply_value
) {
5721 bombout(("expected key exchange reply packet from server"));
5724 set_busy_status(ssh
->frontend
, BUSY_CPU
); /* cogitate */
5725 ssh_pkt_getstring(pktin
, &s
->hostkeydata
, &s
->hostkeylen
);
5726 s
->hkey
= ssh
->hostkey
->newkey(s
->hostkeydata
, s
->hostkeylen
);
5727 s
->f
= ssh2_pkt_getmp(pktin
);
5729 bombout(("unable to parse key exchange reply packet"));
5732 ssh_pkt_getstring(pktin
, &s
->sigdata
, &s
->siglen
);
5734 s
->K
= dh_find_K(ssh
->kex_ctx
, s
->f
);
5736 /* We assume everything from now on will be quick, and it might
5737 * involve user interaction. */
5738 set_busy_status(ssh
->frontend
, BUSY_NOT
);
5740 hash_string(ssh
->kex
->hash
, ssh
->exhash
, s
->hostkeydata
, s
->hostkeylen
);
5741 if (!ssh
->kex
->pdata
) {
5742 hash_uint32(ssh
->kex
->hash
, ssh
->exhash
, s
->pbits
);
5743 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->p
);
5744 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->g
);
5746 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->e
);
5747 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->f
);
5749 dh_cleanup(ssh
->kex_ctx
);
5751 if (!ssh
->kex
->pdata
) {
5756 logeventf(ssh
, "Doing RSA key exchange with hash %s",
5757 ssh
->kex
->hash
->text_name
);
5758 ssh
->pkt_kctx
= SSH2_PKTCTX_RSAKEX
;
5760 * RSA key exchange. First expect a KEXRSA_PUBKEY packet
5764 if (pktin
->type
!= SSH2_MSG_KEXRSA_PUBKEY
) {
5765 bombout(("expected RSA public key packet from server"));
5769 ssh_pkt_getstring(pktin
, &s
->hostkeydata
, &s
->hostkeylen
);
5770 hash_string(ssh
->kex
->hash
, ssh
->exhash
,
5771 s
->hostkeydata
, s
->hostkeylen
);
5772 s
->hkey
= ssh
->hostkey
->newkey(s
->hostkeydata
, s
->hostkeylen
);
5776 ssh_pkt_getstring(pktin
, &keydata
, &s
->rsakeylen
);
5777 s
->rsakeydata
= snewn(s
->rsakeylen
, char);
5778 memcpy(s
->rsakeydata
, keydata
, s
->rsakeylen
);
5781 s
->rsakey
= ssh_rsakex_newkey(s
->rsakeydata
, s
->rsakeylen
);
5783 sfree(s
->rsakeydata
);
5784 bombout(("unable to parse RSA public key from server"));
5788 hash_string(ssh
->kex
->hash
, ssh
->exhash
, s
->rsakeydata
, s
->rsakeylen
);
5791 * Next, set up a shared secret K, of precisely KLEN -
5792 * 2*HLEN - 49 bits, where KLEN is the bit length of the
5793 * RSA key modulus and HLEN is the bit length of the hash
5797 int klen
= ssh_rsakex_klen(s
->rsakey
);
5798 int nbits
= klen
- (2*ssh
->kex
->hash
->hlen
*8 + 49);
5800 unsigned char *kstr1
, *kstr2
, *outstr
;
5801 int kstr1len
, kstr2len
, outstrlen
;
5803 s
->K
= bn_power_2(nbits
- 1);
5805 for (i
= 0; i
< nbits
; i
++) {
5807 byte
= random_byte();
5809 bignum_set_bit(s
->K
, i
, (byte
>> (i
& 7)) & 1);
5813 * Encode this as an mpint.
5815 kstr1
= ssh2_mpint_fmt(s
->K
, &kstr1len
);
5816 kstr2
= snewn(kstr2len
= 4 + kstr1len
, unsigned char);
5817 PUT_32BIT(kstr2
, kstr1len
);
5818 memcpy(kstr2
+ 4, kstr1
, kstr1len
);
5821 * Encrypt it with the given RSA key.
5823 outstrlen
= (klen
+ 7) / 8;
5824 outstr
= snewn(outstrlen
, unsigned char);
5825 ssh_rsakex_encrypt(ssh
->kex
->hash
, kstr2
, kstr2len
,
5826 outstr
, outstrlen
, s
->rsakey
);
5829 * And send it off in a return packet.
5831 s
->pktout
= ssh2_pkt_init(SSH2_MSG_KEXRSA_SECRET
);
5832 ssh2_pkt_addstring_start(s
->pktout
);
5833 ssh2_pkt_addstring_data(s
->pktout
, (char *)outstr
, outstrlen
);
5834 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5836 hash_string(ssh
->kex
->hash
, ssh
->exhash
, outstr
, outstrlen
);
5843 ssh_rsakex_freekey(s
->rsakey
);
5846 if (pktin
->type
!= SSH2_MSG_KEXRSA_DONE
) {
5847 sfree(s
->rsakeydata
);
5848 bombout(("expected signature packet from server"));
5852 ssh_pkt_getstring(pktin
, &s
->sigdata
, &s
->siglen
);
5854 sfree(s
->rsakeydata
);
5857 hash_mpint(ssh
->kex
->hash
, ssh
->exhash
, s
->K
);
5858 assert(ssh
->kex
->hash
->hlen
<= sizeof(s
->exchange_hash
));
5859 ssh
->kex
->hash
->final(ssh
->exhash
, s
->exchange_hash
);
5861 ssh
->kex_ctx
= NULL
;
5864 debug(("Exchange hash is:\n"));
5865 dmemdump(s
->exchange_hash
, ssh
->kex
->hash
->hlen
);
5869 !ssh
->hostkey
->verifysig(s
->hkey
, s
->sigdata
, s
->siglen
,
5870 (char *)s
->exchange_hash
,
5871 ssh
->kex
->hash
->hlen
)) {
5872 bombout(("Server's host key did not match the signature supplied"));
5877 * Authenticate remote host: verify host key. (We've already
5878 * checked the signature of the exchange hash.)
5880 s
->keystr
= ssh
->hostkey
->fmtkey(s
->hkey
);
5881 s
->fingerprint
= ssh
->hostkey
->fingerprint(s
->hkey
);
5882 ssh_set_frozen(ssh
, 1);
5883 s
->dlgret
= verify_ssh_host_key(ssh
->frontend
,
5884 ssh
->savedhost
, ssh
->savedport
,
5885 ssh
->hostkey
->keytype
, s
->keystr
,
5887 ssh_dialog_callback
, ssh
);
5888 if (s
->dlgret
< 0) {
5892 bombout(("Unexpected data from server while waiting"
5893 " for user host key response"));
5896 } while (pktin
|| inlen
> 0);
5897 s
->dlgret
= ssh
->user_response
;
5899 ssh_set_frozen(ssh
, 0);
5900 if (s
->dlgret
== 0) {
5901 ssh_disconnect(ssh
, "User aborted at host key verification", NULL
,
5905 if (!s
->got_session_id
) { /* don't bother logging this in rekeys */
5906 logevent("Host key fingerprint is:");
5907 logevent(s
->fingerprint
);
5909 sfree(s
->fingerprint
);
5911 ssh
->hostkey
->freekey(s
->hkey
);
5914 * The exchange hash from the very first key exchange is also
5915 * the session id, used in session key construction and
5918 if (!s
->got_session_id
) {
5919 assert(sizeof(s
->exchange_hash
) <= sizeof(ssh
->v2_session_id
));
5920 memcpy(ssh
->v2_session_id
, s
->exchange_hash
,
5921 sizeof(s
->exchange_hash
));
5922 ssh
->v2_session_id_len
= ssh
->kex
->hash
->hlen
;
5923 assert(ssh
->v2_session_id_len
<= sizeof(ssh
->v2_session_id
));
5924 s
->got_session_id
= TRUE
;
5928 * Send SSH2_MSG_NEWKEYS.
5930 s
->pktout
= ssh2_pkt_init(SSH2_MSG_NEWKEYS
);
5931 ssh2_pkt_send_noqueue(ssh
, s
->pktout
);
5932 ssh
->outgoing_data_size
= 0; /* start counting from here */
5935 * We've sent client NEWKEYS, so create and initialise
5936 * client-to-server session keys.
5938 if (ssh
->cs_cipher_ctx
)
5939 ssh
->cscipher
->free_context(ssh
->cs_cipher_ctx
);
5940 ssh
->cscipher
= s
->cscipher_tobe
;
5941 ssh
->cs_cipher_ctx
= ssh
->cscipher
->make_context();
5943 if (ssh
->cs_mac_ctx
)
5944 ssh
->csmac
->free_context(ssh
->cs_mac_ctx
);
5945 ssh
->csmac
= s
->csmac_tobe
;
5946 ssh
->cs_mac_ctx
= ssh
->csmac
->make_context();
5948 if (ssh
->cs_comp_ctx
)
5949 ssh
->cscomp
->compress_cleanup(ssh
->cs_comp_ctx
);
5950 ssh
->cscomp
= s
->cscomp_tobe
;
5951 ssh
->cs_comp_ctx
= ssh
->cscomp
->compress_init();
5954 * Set IVs on client-to-server keys. Here we use the exchange
5955 * hash from the _first_ key exchange.
5958 unsigned char keyspace
[SSH2_KEX_MAX_HASH_LEN
* SSH2_MKKEY_ITERS
];
5959 assert(sizeof(keyspace
) >= ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
5960 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'C',keyspace
);
5961 assert((ssh
->cscipher
->keylen
+7) / 8 <=
5962 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
5963 ssh
->cscipher
->setkey(ssh
->cs_cipher_ctx
, keyspace
);
5964 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'A',keyspace
);
5965 assert(ssh
->cscipher
->blksize
<=
5966 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
5967 ssh
->cscipher
->setiv(ssh
->cs_cipher_ctx
, keyspace
);
5968 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'E',keyspace
);
5969 assert(ssh
->csmac
->len
<=
5970 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
5971 ssh
->csmac
->setkey(ssh
->cs_mac_ctx
, keyspace
);
5972 memset(keyspace
, 0, sizeof(keyspace
));
5975 logeventf(ssh
, "Initialised %.200s client->server encryption",
5976 ssh
->cscipher
->text_name
);
5977 logeventf(ssh
, "Initialised %.200s client->server MAC algorithm",
5978 ssh
->csmac
->text_name
);
5979 if (ssh
->cscomp
->text_name
)
5980 logeventf(ssh
, "Initialised %s compression",
5981 ssh
->cscomp
->text_name
);
5984 * Now our end of the key exchange is complete, we can send all
5985 * our queued higher-layer packets.
5987 ssh
->queueing
= FALSE
;
5988 ssh2_pkt_queuesend(ssh
);
5991 * Expect SSH2_MSG_NEWKEYS from server.
5994 if (pktin
->type
!= SSH2_MSG_NEWKEYS
) {
5995 bombout(("expected new-keys packet from server"));
5998 ssh
->incoming_data_size
= 0; /* start counting from here */
6001 * We've seen server NEWKEYS, so create and initialise
6002 * server-to-client session keys.
6004 if (ssh
->sc_cipher_ctx
)
6005 ssh
->sccipher
->free_context(ssh
->sc_cipher_ctx
);
6006 ssh
->sccipher
= s
->sccipher_tobe
;
6007 ssh
->sc_cipher_ctx
= ssh
->sccipher
->make_context();
6009 if (ssh
->sc_mac_ctx
)
6010 ssh
->scmac
->free_context(ssh
->sc_mac_ctx
);
6011 ssh
->scmac
= s
->scmac_tobe
;
6012 ssh
->sc_mac_ctx
= ssh
->scmac
->make_context();
6014 if (ssh
->sc_comp_ctx
)
6015 ssh
->sccomp
->decompress_cleanup(ssh
->sc_comp_ctx
);
6016 ssh
->sccomp
= s
->sccomp_tobe
;
6017 ssh
->sc_comp_ctx
= ssh
->sccomp
->decompress_init();
6020 * Set IVs on server-to-client keys. Here we use the exchange
6021 * hash from the _first_ key exchange.
6024 unsigned char keyspace
[SSH2_KEX_MAX_HASH_LEN
* SSH2_MKKEY_ITERS
];
6025 assert(sizeof(keyspace
) >= ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6026 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'D',keyspace
);
6027 assert((ssh
->sccipher
->keylen
+7) / 8 <=
6028 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6029 ssh
->sccipher
->setkey(ssh
->sc_cipher_ctx
, keyspace
);
6030 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'B',keyspace
);
6031 assert(ssh
->sccipher
->blksize
<=
6032 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6033 ssh
->sccipher
->setiv(ssh
->sc_cipher_ctx
, keyspace
);
6034 ssh2_mkkey(ssh
,s
->K
,s
->exchange_hash
,'F',keyspace
);
6035 assert(ssh
->scmac
->len
<=
6036 ssh
->kex
->hash
->hlen
* SSH2_MKKEY_ITERS
);
6037 ssh
->scmac
->setkey(ssh
->sc_mac_ctx
, keyspace
);
6038 memset(keyspace
, 0, sizeof(keyspace
));
6040 logeventf(ssh
, "Initialised %.200s server->client encryption",
6041 ssh
->sccipher
->text_name
);
6042 logeventf(ssh
, "Initialised %.200s server->client MAC algorithm",
6043 ssh
->scmac
->text_name
);
6044 if (ssh
->sccomp
->text_name
)
6045 logeventf(ssh
, "Initialised %s decompression",
6046 ssh
->sccomp
->text_name
);
6049 * Free shared secret.
6054 * Key exchange is over. Loop straight back round if we have a
6055 * deferred rekey reason.
6057 if (ssh
->deferred_rekey_reason
) {
6058 logevent(ssh
->deferred_rekey_reason
);
6060 ssh
->deferred_rekey_reason
= NULL
;
6061 goto begin_key_exchange
;
6065 * Otherwise, schedule a timer for our next rekey.
6067 ssh
->kex_in_progress
= FALSE
;
6068 ssh
->last_rekey
= GETTICKCOUNT();
6069 if (ssh
->cfg
.ssh_rekey_time
!= 0)
6070 ssh
->next_rekey
= schedule_timer(ssh
->cfg
.ssh_rekey_time
*60*TICKSPERSEC
,
6074 * If this is the first key exchange phase, we must pass the
6075 * SSH2_MSG_NEWKEYS packet to the next layer, not because it
6076 * wants to see it but because it will need time to initialise
6077 * itself before it sees an actual packet. In subsequent key
6078 * exchange phases, we don't pass SSH2_MSG_NEWKEYS on, because
6079 * it would only confuse the layer above.
6081 if (s
->activated_authconn
) {
6084 s
->activated_authconn
= TRUE
;
6087 * Now we're encrypting. Begin returning 1 to the protocol main
6088 * function so that other things can run on top of the
6089 * transport. If we ever see a KEXINIT, we must go back to the
6092 * We _also_ go back to the start if we see pktin==NULL and
6093 * inlen==-1, because this is a special signal meaning
6094 * `initiate client-driven rekey', and `in' contains a message
6095 * giving the reason for the rekey.
6097 while (!((pktin
&& pktin
->type
== SSH2_MSG_KEXINIT
) ||
6098 (!pktin
&& inlen
== -1))) {
6103 logevent("Server initiated key re-exchange");
6106 * Special case: if the server bug is set that doesn't
6107 * allow rekeying, we give a different log message and
6108 * continue waiting. (If such a server _initiates_ a rekey,
6109 * we process it anyway!)
6111 if ((ssh
->remote_bugs
& BUG_SSH2_REKEY
)) {
6112 logeventf(ssh
, "Server bug prevents key re-exchange (%s)",
6114 /* Reset the counters, so that at least this message doesn't
6115 * hit the event log _too_ often. */
6116 ssh
->outgoing_data_size
= 0;
6117 ssh
->incoming_data_size
= 0;
6118 if (ssh
->cfg
.ssh_rekey_time
!= 0) {
6120 schedule_timer(ssh
->cfg
.ssh_rekey_time
*60*TICKSPERSEC
,
6123 goto wait_for_rekey
; /* this is utterly horrid */
6125 logeventf(ssh
, "Initiating key re-exchange (%s)", (char *)in
);
6128 goto begin_key_exchange
;
6134 * Add data to an SSH-2 channel output buffer.
6136 static void ssh2_add_channel_data(struct ssh_channel
*c
, char *buf
,
6139 bufchain_add(&c
->v
.v2
.outbuffer
, buf
, len
);
6143 * Attempt to send data on an SSH-2 channel.
6145 static int ssh2_try_send(struct ssh_channel
*c
)
6148 struct Packet
*pktout
;
6150 while (c
->v
.v2
.remwindow
> 0 && bufchain_size(&c
->v
.v2
.outbuffer
) > 0) {
6153 bufchain_prefix(&c
->v
.v2
.outbuffer
, &data
, &len
);
6154 if ((unsigned)len
> c
->v
.v2
.remwindow
)
6155 len
= c
->v
.v2
.remwindow
;
6156 if ((unsigned)len
> c
->v
.v2
.remmaxpkt
)
6157 len
= c
->v
.v2
.remmaxpkt
;
6158 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_DATA
);
6159 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6160 ssh2_pkt_addstring_start(pktout
);
6161 dont_log_data(ssh
, pktout
, PKTLOG_OMIT
);
6162 ssh2_pkt_addstring_data(pktout
, data
, len
);
6163 end_log_omission(ssh
, pktout
);
6164 ssh2_pkt_send(ssh
, pktout
);
6165 bufchain_consume(&c
->v
.v2
.outbuffer
, len
);
6166 c
->v
.v2
.remwindow
-= len
;
6170 * After having sent as much data as we can, return the amount
6173 return bufchain_size(&c
->v
.v2
.outbuffer
);
6176 static void ssh2_try_send_and_unthrottle(struct ssh_channel
*c
)
6180 return; /* don't send on closing channels */
6181 bufsize
= ssh2_try_send(c
);
6184 case CHAN_MAINSESSION
:
6185 /* stdin need not receive an unthrottle
6186 * notification since it will be polled */
6189 x11_unthrottle(c
->u
.x11
.s
);
6192 /* agent sockets are request/response and need no
6193 * buffer management */
6196 pfd_unthrottle(c
->u
.pfd
.s
);
6203 * Potentially enlarge the window on an SSH-2 channel.
6205 static void ssh2_set_window(struct ssh_channel
*c
, int newwin
)
6210 * Never send WINDOW_ADJUST for a channel that the remote side
6211 * already thinks it's closed; there's no point, since it won't
6212 * be sending any more data anyway.
6218 * Only send a WINDOW_ADJUST if there's significantly more window
6219 * available than the other end thinks there is. This saves us
6220 * sending a WINDOW_ADJUST for every character in a shell session.
6222 * "Significant" is arbitrarily defined as half the window size.
6224 if (newwin
/ 2 >= c
->v
.v2
.locwindow
) {
6225 struct Packet
*pktout
;
6229 * In order to keep track of how much window the client
6230 * actually has available, we'd like it to acknowledge each
6231 * WINDOW_ADJUST. We can't do that directly, so we accompany
6232 * it with a CHANNEL_REQUEST that has to be acknowledged.
6234 * This is only necessary if we're opening the window wide.
6235 * If we're not, then throughput is being constrained by
6236 * something other than the maximum window size anyway.
6238 * We also only send this if the main channel has finished its
6239 * initial CHANNEL_REQUESTs and installed the default
6240 * CHANNEL_FAILURE handler, so as not to risk giving it
6241 * unexpected CHANNEL_FAILUREs.
6243 if (newwin
== c
->v
.v2
.locmaxwin
&&
6244 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
]) {
6245 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
6246 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6247 ssh2_pkt_addstring(pktout
, "winadj@putty.projects.tartarus.org");
6248 ssh2_pkt_addbool(pktout
, TRUE
);
6249 ssh2_pkt_send(ssh
, pktout
);
6252 * CHANNEL_FAILURE doesn't come with any indication of
6253 * what message caused it, so we have to keep track of the
6254 * outstanding CHANNEL_REQUESTs ourselves.
6256 wa
= snew(struct winadj
);
6257 wa
->size
= newwin
- c
->v
.v2
.locwindow
;
6259 if (!c
->v
.v2
.winadj_head
)
6260 c
->v
.v2
.winadj_head
= wa
;
6262 c
->v
.v2
.winadj_tail
->next
= wa
;
6263 c
->v
.v2
.winadj_tail
= wa
;
6264 if (c
->v
.v2
.throttle_state
!= UNTHROTTLED
)
6265 c
->v
.v2
.throttle_state
= UNTHROTTLING
;
6267 /* Pretend the WINDOW_ADJUST was acked immediately. */
6268 c
->v
.v2
.remlocwin
= newwin
;
6269 c
->v
.v2
.throttle_state
= THROTTLED
;
6271 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_WINDOW_ADJUST
);
6272 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6273 ssh2_pkt_adduint32(pktout
, newwin
- c
->v
.v2
.locwindow
);
6274 ssh2_pkt_send(ssh
, pktout
);
6275 c
->v
.v2
.locwindow
= newwin
;
6280 * Find the channel associated with a message. If there's no channel,
6281 * or it's not properly open, make a noise about it and return NULL.
6283 static struct ssh_channel
*ssh2_channel_msg(Ssh ssh
, struct Packet
*pktin
)
6285 unsigned localid
= ssh_pkt_getuint32(pktin
);
6286 struct ssh_channel
*c
;
6288 c
= find234(ssh
->channels
, &localid
, ssh_channelfind
);
6290 (c
->halfopen
&& pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
&&
6291 pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_FAILURE
)) {
6292 char *buf
= dupprintf("Received %s for %s channel %u",
6293 ssh2_pkt_type(ssh
->pkt_kctx
, ssh
->pkt_actx
,
6295 c ?
"half-open" : "nonexistent", localid
);
6296 ssh_disconnect(ssh
, NULL
, buf
, SSH2_DISCONNECT_PROTOCOL_ERROR
, FALSE
);
6303 static void ssh2_msg_channel_failure(Ssh ssh
, struct Packet
*pktin
)
6306 * The only time this should get called is for "winadj@putty"
6307 * messages sent above. All other channel requests are either
6308 * sent with want_reply false or are sent before this handler gets
6311 struct ssh_channel
*c
;
6314 c
= ssh2_channel_msg(ssh
, pktin
);
6317 wa
= c
->v
.v2
.winadj_head
;
6319 logevent("excess SSH_MSG_CHANNEL_FAILURE");
6321 c
->v
.v2
.winadj_head
= wa
->next
;
6322 c
->v
.v2
.remlocwin
+= wa
->size
;
6325 * winadj messages are only sent when the window is fully open,
6326 * so if we get an ack of one, we know any pending unthrottle
6329 if (c
->v
.v2
.throttle_state
== UNTHROTTLING
)
6330 c
->v
.v2
.throttle_state
= UNTHROTTLED
;
6334 static void ssh2_msg_channel_window_adjust(Ssh ssh
, struct Packet
*pktin
)
6336 struct ssh_channel
*c
;
6337 c
= ssh2_channel_msg(ssh
, pktin
);
6341 c
->v
.v2
.remwindow
+= ssh_pkt_getuint32(pktin
);
6342 ssh2_try_send_and_unthrottle(c
);
6346 static void ssh2_msg_channel_data(Ssh ssh
, struct Packet
*pktin
)
6350 struct ssh_channel
*c
;
6351 c
= ssh2_channel_msg(ssh
, pktin
);
6354 if (pktin
->type
== SSH2_MSG_CHANNEL_EXTENDED_DATA
&&
6355 ssh_pkt_getuint32(pktin
) != SSH2_EXTENDED_DATA_STDERR
)
6356 return; /* extended but not stderr */
6357 ssh_pkt_getstring(pktin
, &data
, &length
);
6360 c
->v
.v2
.locwindow
-= length
;
6361 c
->v
.v2
.remlocwin
-= length
;
6363 case CHAN_MAINSESSION
:
6365 from_backend(ssh
->frontend
, pktin
->type
==
6366 SSH2_MSG_CHANNEL_EXTENDED_DATA
,
6370 bufsize
= x11_send(c
->u
.x11
.s
, data
, length
);
6373 bufsize
= pfd_send(c
->u
.pfd
.s
, data
, length
);
6376 while (length
> 0) {
6377 if (c
->u
.a
.lensofar
< 4) {
6378 unsigned int l
= min(4 - c
->u
.a
.lensofar
,
6380 memcpy(c
->u
.a
.msglen
+ c
->u
.a
.lensofar
,
6384 c
->u
.a
.lensofar
+= l
;
6386 if (c
->u
.a
.lensofar
== 4) {
6388 4 + GET_32BIT(c
->u
.a
.msglen
);
6389 c
->u
.a
.message
= snewn(c
->u
.a
.totallen
,
6391 memcpy(c
->u
.a
.message
, c
->u
.a
.msglen
, 4);
6393 if (c
->u
.a
.lensofar
>= 4 && length
> 0) {
6395 min(c
->u
.a
.totallen
- c
->u
.a
.lensofar
,
6397 memcpy(c
->u
.a
.message
+ c
->u
.a
.lensofar
,
6401 c
->u
.a
.lensofar
+= l
;
6403 if (c
->u
.a
.lensofar
== c
->u
.a
.totallen
) {
6406 if (agent_query(c
->u
.a
.message
,
6409 ssh_agentf_callback
, c
))
6410 ssh_agentf_callback(c
, reply
, replylen
);
6411 sfree(c
->u
.a
.message
);
6412 c
->u
.a
.lensofar
= 0;
6419 * If it looks like the remote end hit the end of its window,
6420 * and we didn't want it to do that, think about using a
6423 if (c
->v
.v2
.remlocwin
<= 0 && c
->v
.v2
.throttle_state
== UNTHROTTLED
&&
6424 c
->v
.v2
.locmaxwin
< 0x40000000)
6425 c
->v
.v2
.locmaxwin
+= OUR_V2_WINSIZE
;
6427 * If we are not buffering too much data,
6428 * enlarge the window again at the remote side.
6429 * If we are buffering too much, we may still
6430 * need to adjust the window if the server's
6433 ssh2_set_window(c
, bufsize
< c
->v
.v2
.locmaxwin ?
6434 c
->v
.v2
.locmaxwin
- bufsize
: 0);
6438 static void ssh2_msg_channel_eof(Ssh ssh
, struct Packet
*pktin
)
6440 struct ssh_channel
*c
;
6442 c
= ssh2_channel_msg(ssh
, pktin
);
6446 if (c
->type
== CHAN_X11
) {
6448 * Remote EOF on an X11 channel means we should
6449 * wrap up and close the channel ourselves.
6451 x11_close(c
->u
.x11
.s
);
6453 } else if (c
->type
== CHAN_AGENT
) {
6455 } else if (c
->type
== CHAN_SOCKDATA
) {
6456 pfd_close(c
->u
.pfd
.s
);
6461 static void ssh2_msg_channel_close(Ssh ssh
, struct Packet
*pktin
)
6463 struct ssh_channel
*c
;
6464 struct Packet
*pktout
;
6466 c
= ssh2_channel_msg(ssh
, pktin
);
6469 /* Do pre-close processing on the channel. */
6471 case CHAN_MAINSESSION
:
6472 ssh
->mainchan
= NULL
;
6473 update_specials_menu(ssh
->frontend
);
6476 if (c
->u
.x11
.s
!= NULL
)
6477 x11_close(c
->u
.x11
.s
);
6484 if (c
->u
.pfd
.s
!= NULL
)
6485 pfd_close(c
->u
.pfd
.s
);
6489 if (c
->closes
== 0) {
6490 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
6491 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6492 ssh2_pkt_send(ssh
, pktout
);
6494 del234(ssh
->channels
, c
);
6495 bufchain_clear(&c
->v
.v2
.outbuffer
);
6499 * See if that was the last channel left open.
6500 * (This is only our termination condition if we're
6501 * not running in -N mode.)
6503 if (!ssh
->cfg
.ssh_no_shell
&& count234(ssh
->channels
) == 0) {
6505 * We used to send SSH_MSG_DISCONNECT here,
6506 * because I'd believed that _every_ conforming
6507 * SSH-2 connection had to end with a disconnect
6508 * being sent by at least one side; apparently
6509 * I was wrong and it's perfectly OK to
6510 * unceremoniously slam the connection shut
6511 * when you're done, and indeed OpenSSH feels
6512 * this is more polite than sending a
6513 * DISCONNECT. So now we don't.
6515 ssh_disconnect(ssh
, "All channels closed", NULL
, 0, TRUE
);
6519 static void ssh2_msg_channel_open_confirmation(Ssh ssh
, struct Packet
*pktin
)
6521 struct ssh_channel
*c
;
6522 struct Packet
*pktout
;
6524 c
= ssh2_channel_msg(ssh
, pktin
);
6527 if (c
->type
!= CHAN_SOCKDATA_DORMANT
)
6528 return; /* dunno why they're confirming this */
6529 c
->remoteid
= ssh_pkt_getuint32(pktin
);
6530 c
->halfopen
= FALSE
;
6531 c
->type
= CHAN_SOCKDATA
;
6532 c
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
6533 c
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
6535 pfd_confirm(c
->u
.pfd
.s
);
6538 * We have a pending close on this channel,
6539 * which we decided on before the server acked
6540 * the channel open. So now we know the
6541 * remoteid, we can close it again.
6543 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_CLOSE
);
6544 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6545 ssh2_pkt_send(ssh
, pktout
);
6549 static void ssh2_msg_channel_open_failure(Ssh ssh
, struct Packet
*pktin
)
6551 static const char *const reasons
[] = {
6552 "<unknown reason code>",
6553 "Administratively prohibited",
6555 "Unknown channel type",
6556 "Resource shortage",
6558 unsigned reason_code
;
6559 char *reason_string
;
6561 struct ssh_channel
*c
;
6562 c
= ssh2_channel_msg(ssh
, pktin
);
6565 if (c
->type
!= CHAN_SOCKDATA_DORMANT
)
6566 return; /* dunno why they're failing this */
6568 reason_code
= ssh_pkt_getuint32(pktin
);
6569 if (reason_code
>= lenof(reasons
))
6570 reason_code
= 0; /* ensure reasons[reason_code] in range */
6571 ssh_pkt_getstring(pktin
, &reason_string
, &reason_length
);
6572 logeventf(ssh
, "Forwarded connection refused by server: %s [%.*s]",
6573 reasons
[reason_code
], reason_length
, reason_string
);
6575 pfd_close(c
->u
.pfd
.s
);
6577 del234(ssh
->channels
, c
);
6581 static void ssh2_msg_channel_request(Ssh ssh
, struct Packet
*pktin
)
6584 int typelen
, want_reply
;
6585 int reply
= SSH2_MSG_CHANNEL_FAILURE
; /* default */
6586 struct ssh_channel
*c
;
6587 struct Packet
*pktout
;
6589 c
= ssh2_channel_msg(ssh
, pktin
);
6592 ssh_pkt_getstring(pktin
, &type
, &typelen
);
6593 want_reply
= ssh2_pkt_getbool(pktin
);
6596 * Having got the channel number, we now look at
6597 * the request type string to see if it's something
6600 if (c
== ssh
->mainchan
) {
6602 * We recognise "exit-status" and "exit-signal" on
6603 * the primary channel.
6605 if (typelen
== 11 &&
6606 !memcmp(type
, "exit-status", 11)) {
6608 ssh
->exitcode
= ssh_pkt_getuint32(pktin
);
6609 logeventf(ssh
, "Server sent command exit status %d",
6611 reply
= SSH2_MSG_CHANNEL_SUCCESS
;
6613 } else if (typelen
== 11 &&
6614 !memcmp(type
, "exit-signal", 11)) {
6616 int is_plausible
= TRUE
, is_int
= FALSE
;
6617 char *fmt_sig
= "", *fmt_msg
= "";
6619 int msglen
= 0, core
= FALSE
;
6620 /* ICK: older versions of OpenSSH (e.g. 3.4p1)
6621 * provide an `int' for the signal, despite its
6622 * having been a `string' in the drafts since at
6623 * least 2001. (Fixed in session.c 1.147.) Try to
6624 * infer which we can safely parse it as. */
6626 unsigned char *p
= pktin
->body
+
6628 long len
= pktin
->length
- pktin
->savedpos
;
6629 unsigned long num
= GET_32BIT(p
); /* what is it? */
6630 /* If it's 0, it hardly matters; assume string */
6634 int maybe_int
= FALSE
, maybe_str
= FALSE
;
6635 #define CHECK_HYPOTHESIS(offset, result) \
6638 if (q >= 0 && q+4 <= len) { \
6639 q = q + 4 + GET_32BIT(p+q); \
6640 if (q >= 0 && q+4 <= len && \
6641 ((q = q + 4 + GET_32BIT(p+q))!= 0) && q == len) \
6645 CHECK_HYPOTHESIS(4+1, maybe_int
);
6646 CHECK_HYPOTHESIS(4+num
+1, maybe_str
);
6647 #undef CHECK_HYPOTHESIS
6648 if (maybe_int
&& !maybe_str
)
6650 else if (!maybe_int
&& maybe_str
)
6653 /* Crikey. Either or neither. Panic. */
6654 is_plausible
= FALSE
;
6657 ssh
->exitcode
= 128; /* means `unknown signal' */
6660 /* Old non-standard OpenSSH. */
6661 int signum
= ssh_pkt_getuint32(pktin
);
6662 fmt_sig
= dupprintf(" %d", signum
);
6663 ssh
->exitcode
= 128 + signum
;
6665 /* As per the drafts. */
6668 ssh_pkt_getstring(pktin
, &sig
, &siglen
);
6669 /* Signal name isn't supposed to be blank, but
6670 * let's cope gracefully if it is. */
6672 fmt_sig
= dupprintf(" \"%.*s\"",
6677 * Really hideous method of translating the
6678 * signal description back into a locally
6679 * meaningful number.
6684 #define TRANSLATE_SIGNAL(s) \
6685 else if (siglen == lenof(#s)-1 && !memcmp(sig, #s, siglen)) \
6686 ssh->exitcode = 128 + SIG ## s
6688 TRANSLATE_SIGNAL(ABRT
);
6691 TRANSLATE_SIGNAL(ALRM
);
6694 TRANSLATE_SIGNAL(FPE
);
6697 TRANSLATE_SIGNAL(HUP
);
6700 TRANSLATE_SIGNAL(ILL
);
6703 TRANSLATE_SIGNAL(INT
);
6706 TRANSLATE_SIGNAL(KILL
);
6709 TRANSLATE_SIGNAL(PIPE
);
6712 TRANSLATE_SIGNAL(QUIT
);
6715 TRANSLATE_SIGNAL(SEGV
);
6718 TRANSLATE_SIGNAL(TERM
);
6721 TRANSLATE_SIGNAL(USR1
);
6724 TRANSLATE_SIGNAL(USR2
);
6726 #undef TRANSLATE_SIGNAL
6728 ssh
->exitcode
= 128;
6730 core
= ssh2_pkt_getbool(pktin
);
6731 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
6733 fmt_msg
= dupprintf(" (\"%.*s\")", msglen
, msg
);
6735 /* ignore lang tag */
6736 } /* else don't attempt to parse */
6737 logeventf(ssh
, "Server exited on signal%s%s%s",
6738 fmt_sig
, core ?
" (core dumped)" : "",
6740 if (*fmt_sig
) sfree(fmt_sig
);
6741 if (*fmt_msg
) sfree(fmt_msg
);
6742 reply
= SSH2_MSG_CHANNEL_SUCCESS
;
6747 * This is a channel request we don't know
6748 * about, so we now either ignore the request
6749 * or respond with CHANNEL_FAILURE, depending
6752 reply
= SSH2_MSG_CHANNEL_FAILURE
;
6755 pktout
= ssh2_pkt_init(reply
);
6756 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6757 ssh2_pkt_send(ssh
, pktout
);
6761 static void ssh2_msg_global_request(Ssh ssh
, struct Packet
*pktin
)
6764 int typelen
, want_reply
;
6765 struct Packet
*pktout
;
6767 ssh_pkt_getstring(pktin
, &type
, &typelen
);
6768 want_reply
= ssh2_pkt_getbool(pktin
);
6771 * We currently don't support any global requests
6772 * at all, so we either ignore the request or
6773 * respond with REQUEST_FAILURE, depending on
6777 pktout
= ssh2_pkt_init(SSH2_MSG_REQUEST_FAILURE
);
6778 ssh2_pkt_send(ssh
, pktout
);
6782 static void ssh2_msg_channel_open(Ssh ssh
, struct Packet
*pktin
)
6790 struct ssh_channel
*c
;
6791 unsigned remid
, winsize
, pktsize
;
6792 struct Packet
*pktout
;
6794 ssh_pkt_getstring(pktin
, &type
, &typelen
);
6795 c
= snew(struct ssh_channel
);
6798 remid
= ssh_pkt_getuint32(pktin
);
6799 winsize
= ssh_pkt_getuint32(pktin
);
6800 pktsize
= ssh_pkt_getuint32(pktin
);
6802 if (typelen
== 3 && !memcmp(type
, "x11", 3)) {
6805 ssh_pkt_getstring(pktin
, &peeraddr
, &peeraddrlen
);
6806 addrstr
= snewn(peeraddrlen
+1, char);
6807 memcpy(addrstr
, peeraddr
, peeraddrlen
);
6808 addrstr
[peeraddrlen
] = '\0';
6809 peerport
= ssh_pkt_getuint32(pktin
);
6811 logeventf(ssh
, "Received X11 connect request from %s:%d",
6814 if (!ssh
->X11_fwd_enabled
)
6815 error
= "X11 forwarding is not enabled";
6816 else if (x11_init(&c
->u
.x11
.s
, ssh
->cfg
.x11_display
, c
,
6817 ssh
->x11auth
, addrstr
, peerport
,
6818 &ssh
->cfg
) != NULL
) {
6819 error
= "Unable to open an X11 connection";
6821 logevent("Opening X11 forward connection succeeded");
6826 } else if (typelen
== 15 &&
6827 !memcmp(type
, "forwarded-tcpip", 15)) {
6828 struct ssh_rportfwd pf
, *realpf
;
6831 ssh_pkt_getstring(pktin
, &dummy
, &dummylen
);/* skip address */
6832 pf
.sport
= ssh_pkt_getuint32(pktin
);
6833 ssh_pkt_getstring(pktin
, &peeraddr
, &peeraddrlen
);
6834 peerport
= ssh_pkt_getuint32(pktin
);
6835 realpf
= find234(ssh
->rportfwds
, &pf
, NULL
);
6836 logeventf(ssh
, "Received remote port %d open request "
6837 "from %s:%d", pf
.sport
, peeraddr
, peerport
);
6838 if (realpf
== NULL
) {
6839 error
= "Remote port is not recognised";
6841 const char *e
= pfd_newconnect(&c
->u
.pfd
.s
,
6845 realpf
->pfrec
->addressfamily
);
6846 logeventf(ssh
, "Attempting to forward remote port to "
6847 "%s:%d", realpf
->dhost
, realpf
->dport
);
6849 logeventf(ssh
, "Port open failed: %s", e
);
6850 error
= "Port open failed";
6852 logevent("Forwarded port opened successfully");
6853 c
->type
= CHAN_SOCKDATA
;
6856 } else if (typelen
== 22 &&
6857 !memcmp(type
, "auth-agent@openssh.com", 22)) {
6858 if (!ssh
->agentfwd_enabled
)
6859 error
= "Agent forwarding is not enabled";
6861 c
->type
= CHAN_AGENT
; /* identify channel type */
6862 c
->u
.a
.lensofar
= 0;
6865 error
= "Unsupported channel type requested";
6868 c
->remoteid
= remid
;
6869 c
->halfopen
= FALSE
;
6871 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_FAILURE
);
6872 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6873 ssh2_pkt_adduint32(pktout
, SSH2_OPEN_CONNECT_FAILED
);
6874 ssh2_pkt_addstring(pktout
, error
);
6875 ssh2_pkt_addstring(pktout
, "en"); /* language tag */
6876 ssh2_pkt_send(ssh
, pktout
);
6877 logeventf(ssh
, "Rejected channel open: %s", error
);
6880 c
->localid
= alloc_channel_id(ssh
);
6882 c
->v
.v2
.locwindow
= c
->v
.v2
.locmaxwin
= OUR_V2_WINSIZE
;
6883 c
->v
.v2
.remwindow
= winsize
;
6884 c
->v
.v2
.remmaxpkt
= pktsize
;
6885 c
->v
.v2
.remlocwin
= OUR_V2_WINSIZE
;
6886 c
->v
.v2
.winadj_head
= c
->v
.v2
.winadj_tail
= NULL
;
6887 c
->v
.v2
.throttle_state
= UNTHROTTLED
;
6888 bufchain_init(&c
->v
.v2
.outbuffer
);
6889 add234(ssh
->channels
, c
);
6890 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
);
6891 ssh2_pkt_adduint32(pktout
, c
->remoteid
);
6892 ssh2_pkt_adduint32(pktout
, c
->localid
);
6893 ssh2_pkt_adduint32(pktout
, c
->v
.v2
.locwindow
);
6894 ssh2_pkt_adduint32(pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
6895 ssh2_pkt_send(ssh
, pktout
);
6900 * Buffer banner messages for later display at some convenient point.
6902 static void ssh2_msg_userauth_banner(Ssh ssh
, struct Packet
*pktin
)
6904 /* Arbitrary limit to prevent unbounded inflation of buffer */
6905 if (bufchain_size(&ssh
->banner
) <= 131072) {
6906 char *banner
= NULL
;
6908 ssh_pkt_getstring(pktin
, &banner
, &size
);
6910 bufchain_add(&ssh
->banner
, banner
, size
);
6914 /* Helper function to deal with sending tty modes for "pty-req" */
6915 static void ssh2_send_ttymode(void *data
, char *mode
, char *val
)
6917 struct Packet
*pktout
= (struct Packet
*)data
;
6919 unsigned int arg
= 0;
6920 while (strcmp(mode
, ssh_ttymodes
[i
].mode
) != 0) i
++;
6921 if (i
== lenof(ssh_ttymodes
)) return;
6922 switch (ssh_ttymodes
[i
].type
) {
6924 arg
= ssh_tty_parse_specchar(val
);
6927 arg
= ssh_tty_parse_boolean(val
);
6930 ssh2_pkt_addbyte(pktout
, ssh_ttymodes
[i
].opcode
);
6931 ssh2_pkt_adduint32(pktout
, arg
);
6935 * Handle the SSH-2 userauth and connection layers.
6937 static void do_ssh2_authconn(Ssh ssh
, unsigned char *in
, int inlen
,
6938 struct Packet
*pktin
)
6940 struct do_ssh2_authconn_state
{
6943 AUTH_TYPE_PUBLICKEY
,
6944 AUTH_TYPE_PUBLICKEY_OFFER_LOUD
,
6945 AUTH_TYPE_PUBLICKEY_OFFER_QUIET
,
6947 AUTH_TYPE_KEYBOARD_INTERACTIVE
,
6948 AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
6950 int done_service_req
;
6951 int gotit
, need_pw
, can_pubkey
, can_passwd
, can_keyb_inter
;
6952 int tried_pubkey_config
, done_agent
;
6953 int kbd_inter_refused
;
6955 prompts_t
*cur_prompt
;
6960 void *publickey_blob
;
6961 int publickey_bloblen
;
6962 int publickey_encrypted
;
6963 char *publickey_algorithm
;
6964 char *publickey_comment
;
6965 unsigned char agent_request
[5], *agent_response
, *agentp
;
6966 int agent_responselen
;
6967 unsigned char *pkblob_in_agent
;
6969 char *pkblob
, *alg
, *commentp
;
6970 int pklen
, alglen
, commentlen
;
6971 int siglen
, retlen
, len
;
6972 char *q
, *agentreq
, *ret
;
6974 int num_env
, env_left
, env_ok
;
6975 struct Packet
*pktout
;
6977 crState(do_ssh2_authconn_state
);
6979 crBegin(ssh
->do_ssh2_authconn_crstate
);
6981 s
->done_service_req
= FALSE
;
6982 s
->we_are_in
= FALSE
;
6983 if (!ssh
->cfg
.ssh_no_userauth
) {
6985 * Request userauth protocol, and await a response to it.
6987 s
->pktout
= ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST
);
6988 ssh2_pkt_addstring(s
->pktout
, "ssh-userauth");
6989 ssh2_pkt_send(ssh
, s
->pktout
);
6990 crWaitUntilV(pktin
);
6991 if (pktin
->type
== SSH2_MSG_SERVICE_ACCEPT
)
6992 s
->done_service_req
= TRUE
;
6994 if (!s
->done_service_req
) {
6996 * Request connection protocol directly, without authentication.
6998 s
->pktout
= ssh2_pkt_init(SSH2_MSG_SERVICE_REQUEST
);
6999 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7000 ssh2_pkt_send(ssh
, s
->pktout
);
7001 crWaitUntilV(pktin
);
7002 if (pktin
->type
== SSH2_MSG_SERVICE_ACCEPT
) {
7003 s
->we_are_in
= TRUE
; /* no auth required */
7005 bombout(("Server refused service request"));
7010 /* Arrange to be able to deal with any BANNERs that come in.
7011 * (We do this now as packets may come in during the next bit.) */
7012 bufchain_init(&ssh
->banner
);
7013 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] =
7014 ssh2_msg_userauth_banner
;
7017 * Misc one-time setup for authentication.
7019 s
->publickey_blob
= NULL
;
7020 if (!s
->we_are_in
) {
7023 * Load the public half of any configured public key file
7026 if (!filename_is_null(ssh
->cfg
.keyfile
)) {
7028 logeventf(ssh
, "Reading private key file \"%.150s\"",
7029 filename_to_str(&ssh
->cfg
.keyfile
));
7030 keytype
= key_type(&ssh
->cfg
.keyfile
);
7031 if (keytype
== SSH_KEYTYPE_SSH2
) {
7034 ssh2_userkey_loadpub(&ssh
->cfg
.keyfile
,
7035 &s
->publickey_algorithm
,
7036 &s
->publickey_bloblen
,
7037 &s
->publickey_comment
, &error
);
7038 if (s
->publickey_blob
) {
7039 s
->publickey_encrypted
=
7040 ssh2_userkey_encrypted(&ssh
->cfg
.keyfile
, NULL
);
7043 logeventf(ssh
, "Unable to load private key (%s)",
7045 msgbuf
= dupprintf("Unable to load private key file "
7046 "\"%.150s\" (%s)\r\n",
7047 filename_to_str(&ssh
->cfg
.keyfile
),
7049 c_write_str(ssh
, msgbuf
);
7054 logeventf(ssh
, "Unable to use this key file (%s)",
7055 key_type_to_str(keytype
));
7056 msgbuf
= dupprintf("Unable to use key file \"%.150s\""
7058 filename_to_str(&ssh
->cfg
.keyfile
),
7059 key_type_to_str(keytype
));
7060 c_write_str(ssh
, msgbuf
);
7062 s
->publickey_blob
= NULL
;
7067 * Find out about any keys Pageant has (but if there's a
7068 * public key configured, filter out all others).
7071 s
->agent_response
= NULL
;
7072 s
->pkblob_in_agent
= NULL
;
7073 if (ssh
->cfg
.tryagent
&& agent_exists()) {
7077 logevent("Pageant is running. Requesting keys.");
7079 /* Request the keys held by the agent. */
7080 PUT_32BIT(s
->agent_request
, 1);
7081 s
->agent_request
[4] = SSH2_AGENTC_REQUEST_IDENTITIES
;
7082 if (!agent_query(s
->agent_request
, 5, &r
, &s
->agent_responselen
,
7083 ssh_agent_callback
, ssh
)) {
7087 bombout(("Unexpected data from server while"
7088 " waiting for agent response"));
7091 } while (pktin
|| inlen
> 0);
7092 r
= ssh
->agent_response
;
7093 s
->agent_responselen
= ssh
->agent_response_len
;
7095 s
->agent_response
= (unsigned char *) r
;
7096 if (s
->agent_response
&& s
->agent_responselen
>= 5 &&
7097 s
->agent_response
[4] == SSH2_AGENT_IDENTITIES_ANSWER
) {
7100 p
= s
->agent_response
+ 5;
7101 s
->nkeys
= GET_32BIT(p
);
7103 logeventf(ssh
, "Pageant has %d SSH-2 keys", s
->nkeys
);
7104 if (s
->publickey_blob
) {
7105 /* See if configured key is in agent. */
7106 for (keyi
= 0; keyi
< s
->nkeys
; keyi
++) {
7107 s
->pklen
= GET_32BIT(p
);
7108 if (s
->pklen
== s
->publickey_bloblen
&&
7109 !memcmp(p
+4, s
->publickey_blob
,
7110 s
->publickey_bloblen
)) {
7111 logeventf(ssh
, "Pageant key #%d matches "
7112 "configured key file", keyi
);
7114 s
->pkblob_in_agent
= p
;
7118 p
+= GET_32BIT(p
) + 4; /* comment */
7120 if (!s
->pkblob_in_agent
) {
7121 logevent("Configured key file not in Pageant");
7131 * We repeat this whole loop, including the username prompt,
7132 * until we manage a successful authentication. If the user
7133 * types the wrong _password_, they can be sent back to the
7134 * beginning to try another username, if this is configured on.
7135 * (If they specify a username in the config, they are never
7136 * asked, even if they do give a wrong password.)
7138 * I think this best serves the needs of
7140 * - the people who have no configuration, no keys, and just
7141 * want to try repeated (username,password) pairs until they
7142 * type both correctly
7144 * - people who have keys and configuration but occasionally
7145 * need to fall back to passwords
7147 * - people with a key held in Pageant, who might not have
7148 * logged in to a particular machine before; so they want to
7149 * type a username, and then _either_ their key will be
7150 * accepted, _or_ they will type a password. If they mistype
7151 * the username they will want to be able to get back and
7154 s
->username
[0] = '\0';
7155 s
->got_username
= FALSE
;
7156 while (!s
->we_are_in
) {
7160 if (s
->got_username
&& !ssh
->cfg
.change_username
) {
7162 * We got a username last time round this loop, and
7163 * with change_username turned off we don't try to get
7166 } else if (!*ssh
->cfg
.username
) {
7167 int ret
; /* need not be kept over crReturn */
7168 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7169 s
->cur_prompt
->to_server
= TRUE
;
7170 s
->cur_prompt
->name
= dupstr("SSH login name");
7171 add_prompt(s
->cur_prompt
, dupstr("login as: "), TRUE
,
7172 lenof(s
->username
));
7173 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7176 crWaitUntilV(!pktin
);
7177 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
7182 * get_userpass_input() failed to get a username.
7185 free_prompts(s
->cur_prompt
);
7186 ssh_disconnect(ssh
, "No username provided", NULL
, 0, TRUE
);
7189 memcpy(s
->username
, s
->cur_prompt
->prompts
[0]->result
,
7190 lenof(s
->username
));
7191 free_prompts(s
->cur_prompt
);
7194 strncpy(s
->username
, ssh
->cfg
.username
, sizeof(s
->username
));
7195 s
->username
[sizeof(s
->username
)-1] = '\0';
7196 if ((flags
& FLAG_VERBOSE
) || (flags
& FLAG_INTERACTIVE
)) {
7197 stuff
= dupprintf("Using username \"%s\".\r\n", s
->username
);
7198 c_write_str(ssh
, stuff
);
7202 s
->got_username
= TRUE
;
7205 * Send an authentication request using method "none": (a)
7206 * just in case it succeeds, and (b) so that we know what
7207 * authentication methods we can usefully try next.
7209 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
7211 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7212 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7213 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");/* service requested */
7214 ssh2_pkt_addstring(s
->pktout
, "none"); /* method */
7215 ssh2_pkt_send(ssh
, s
->pktout
);
7216 s
->type
= AUTH_TYPE_NONE
;
7218 s
->we_are_in
= FALSE
;
7220 s
->tried_pubkey_config
= FALSE
;
7221 s
->kbd_inter_refused
= FALSE
;
7223 /* Reset agent request state. */
7224 s
->done_agent
= FALSE
;
7225 if (s
->agent_response
) {
7226 if (s
->pkblob_in_agent
) {
7227 s
->agentp
= s
->pkblob_in_agent
;
7229 s
->agentp
= s
->agent_response
+ 5 + 4;
7236 * Wait for the result of the last authentication request.
7239 crWaitUntilV(pktin
);
7241 * Now is a convenient point to spew any banner material
7242 * that we've accumulated. (This should ensure that when
7243 * we exit the auth loop, we haven't any left to deal
7247 int size
= bufchain_size(&ssh
->banner
);
7249 * Don't show the banner if we're operating in
7250 * non-verbose non-interactive mode. (It's probably
7251 * a script, which means nobody will read the
7252 * banner _anyway_, and moreover the printing of
7253 * the banner will screw up processing on the
7254 * output of (say) plink.)
7256 if (size
&& (flags
& (FLAG_VERBOSE
| FLAG_INTERACTIVE
))) {
7257 char *banner
= snewn(size
, char);
7258 bufchain_fetch(&ssh
->banner
, banner
, size
);
7259 c_write_untrusted(ssh
, banner
, size
);
7262 bufchain_clear(&ssh
->banner
);
7264 if (pktin
->type
== SSH2_MSG_USERAUTH_SUCCESS
) {
7265 logevent("Access granted");
7266 s
->we_are_in
= TRUE
;
7270 if (pktin
->type
!= SSH2_MSG_USERAUTH_FAILURE
) {
7271 bombout(("Strange packet received during authentication: "
7272 "type %d", pktin
->type
));
7279 * OK, we're now sitting on a USERAUTH_FAILURE message, so
7280 * we can look at the string in it and know what we can
7281 * helpfully try next.
7283 if (pktin
->type
== SSH2_MSG_USERAUTH_FAILURE
) {
7286 ssh_pkt_getstring(pktin
, &methods
, &methlen
);
7287 if (!ssh2_pkt_getbool(pktin
)) {
7289 * We have received an unequivocal Access
7290 * Denied. This can translate to a variety of
7293 * - if we'd just tried "none" authentication,
7294 * it's not worth printing anything at all
7296 * - if we'd just tried a public key _offer_,
7297 * the message should be "Server refused our
7298 * key" (or no message at all if the key
7299 * came from Pageant)
7301 * - if we'd just tried anything else, the
7302 * message really should be "Access denied".
7304 * Additionally, if we'd just tried password
7305 * authentication, we should break out of this
7306 * whole loop so as to go back to the username
7307 * prompt (iff we're configured to allow
7308 * username change attempts).
7310 if (s
->type
== AUTH_TYPE_NONE
) {
7312 } else if (s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_LOUD
||
7313 s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_QUIET
) {
7314 if (s
->type
== AUTH_TYPE_PUBLICKEY_OFFER_LOUD
)
7315 c_write_str(ssh
, "Server refused our key\r\n");
7316 logevent("Server refused public key");
7317 } else if (s
->type
==AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
) {
7318 /* server declined keyboard-interactive; ignore */
7320 c_write_str(ssh
, "Access denied\r\n");
7321 logevent("Access denied");
7322 if (s
->type
== AUTH_TYPE_PASSWORD
&&
7323 ssh
->cfg
.change_username
) {
7324 /* XXX perhaps we should allow
7325 * keyboard-interactive to do this too? */
7326 s
->we_are_in
= FALSE
;
7331 c_write_str(ssh
, "Further authentication required\r\n");
7332 logevent("Further authentication required");
7336 in_commasep_string("publickey", methods
, methlen
);
7338 in_commasep_string("password", methods
, methlen
);
7339 s
->can_keyb_inter
= ssh
->cfg
.try_ki_auth
&&
7340 in_commasep_string("keyboard-interactive", methods
, methlen
);
7343 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
7345 if (s
->can_pubkey
&& !s
->done_agent
&& s
->nkeys
) {
7348 * Attempt public-key authentication using a key from Pageant.
7351 ssh
->pkt_actx
= SSH2_PKTCTX_PUBLICKEY
;
7353 logeventf(ssh
, "Trying Pageant key #%d", s
->keyi
);
7355 /* Unpack key from agent response */
7356 s
->pklen
= GET_32BIT(s
->agentp
);
7358 s
->pkblob
= (char *)s
->agentp
;
7359 s
->agentp
+= s
->pklen
;
7360 s
->alglen
= GET_32BIT(s
->pkblob
);
7361 s
->alg
= s
->pkblob
+ 4;
7362 s
->commentlen
= GET_32BIT(s
->agentp
);
7364 s
->commentp
= (char *)s
->agentp
;
7365 s
->agentp
+= s
->commentlen
;
7366 /* s->agentp now points at next key, if any */
7368 /* See if server will accept it */
7369 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7370 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7371 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7372 /* service requested */
7373 ssh2_pkt_addstring(s
->pktout
, "publickey");
7375 ssh2_pkt_addbool(s
->pktout
, FALSE
); /* no signature included */
7376 ssh2_pkt_addstring_start(s
->pktout
);
7377 ssh2_pkt_addstring_data(s
->pktout
, s
->alg
, s
->alglen
);
7378 ssh2_pkt_addstring_start(s
->pktout
);
7379 ssh2_pkt_addstring_data(s
->pktout
, s
->pkblob
, s
->pklen
);
7380 ssh2_pkt_send(ssh
, s
->pktout
);
7381 s
->type
= AUTH_TYPE_PUBLICKEY_OFFER_QUIET
;
7383 crWaitUntilV(pktin
);
7384 if (pktin
->type
!= SSH2_MSG_USERAUTH_PK_OK
) {
7386 /* Offer of key refused. */
7393 if (flags
& FLAG_VERBOSE
) {
7394 c_write_str(ssh
, "Authenticating with "
7396 c_write(ssh
, s
->commentp
, s
->commentlen
);
7397 c_write_str(ssh
, "\" from agent\r\n");
7401 * Server is willing to accept the key.
7402 * Construct a SIGN_REQUEST.
7404 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7405 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7406 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7407 /* service requested */
7408 ssh2_pkt_addstring(s
->pktout
, "publickey");
7410 ssh2_pkt_addbool(s
->pktout
, TRUE
); /* signature included */
7411 ssh2_pkt_addstring_start(s
->pktout
);
7412 ssh2_pkt_addstring_data(s
->pktout
, s
->alg
, s
->alglen
);
7413 ssh2_pkt_addstring_start(s
->pktout
);
7414 ssh2_pkt_addstring_data(s
->pktout
, s
->pkblob
, s
->pklen
);
7416 /* Ask agent for signature. */
7417 s
->siglen
= s
->pktout
->length
- 5 + 4 +
7418 ssh
->v2_session_id_len
;
7419 if (ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)
7421 s
->len
= 1; /* message type */
7422 s
->len
+= 4 + s
->pklen
; /* key blob */
7423 s
->len
+= 4 + s
->siglen
; /* data to sign */
7424 s
->len
+= 4; /* flags */
7425 s
->agentreq
= snewn(4 + s
->len
, char);
7426 PUT_32BIT(s
->agentreq
, s
->len
);
7427 s
->q
= s
->agentreq
+ 4;
7428 *s
->q
++ = SSH2_AGENTC_SIGN_REQUEST
;
7429 PUT_32BIT(s
->q
, s
->pklen
);
7431 memcpy(s
->q
, s
->pkblob
, s
->pklen
);
7433 PUT_32BIT(s
->q
, s
->siglen
);
7435 /* Now the data to be signed... */
7436 if (!(ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)) {
7437 PUT_32BIT(s
->q
, ssh
->v2_session_id_len
);
7440 memcpy(s
->q
, ssh
->v2_session_id
,
7441 ssh
->v2_session_id_len
);
7442 s
->q
+= ssh
->v2_session_id_len
;
7443 memcpy(s
->q
, s
->pktout
->data
+ 5,
7444 s
->pktout
->length
- 5);
7445 s
->q
+= s
->pktout
->length
- 5;
7446 /* And finally the (zero) flags word. */
7448 if (!agent_query(s
->agentreq
, s
->len
+ 4,
7450 ssh_agent_callback
, ssh
)) {
7454 bombout(("Unexpected data from server"
7455 " while waiting for agent"
7459 } while (pktin
|| inlen
> 0);
7460 vret
= ssh
->agent_response
;
7461 s
->retlen
= ssh
->agent_response_len
;
7466 if (s
->ret
[4] == SSH2_AGENT_SIGN_RESPONSE
) {
7467 logevent("Sending Pageant's response");
7468 ssh2_add_sigblob(ssh
, s
->pktout
,
7469 s
->pkblob
, s
->pklen
,
7471 GET_32BIT(s
->ret
+ 5));
7472 ssh2_pkt_send(ssh
, s
->pktout
);
7473 s
->type
= AUTH_TYPE_PUBLICKEY
;
7475 /* FIXME: less drastic response */
7476 bombout(("Pageant failed to answer challenge"));
7482 /* Do we have any keys left to try? */
7483 if (s
->pkblob_in_agent
) {
7484 s
->done_agent
= TRUE
;
7485 s
->tried_pubkey_config
= TRUE
;
7488 if (s
->keyi
>= s
->nkeys
)
7489 s
->done_agent
= TRUE
;
7492 } else if (s
->can_pubkey
&& s
->publickey_blob
&&
7493 !s
->tried_pubkey_config
) {
7495 struct ssh2_userkey
*key
; /* not live over crReturn */
7496 char *passphrase
; /* not live over crReturn */
7498 ssh
->pkt_actx
= SSH2_PKTCTX_PUBLICKEY
;
7500 s
->tried_pubkey_config
= TRUE
;
7503 * Try the public key supplied in the configuration.
7505 * First, offer the public blob to see if the server is
7506 * willing to accept it.
7508 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7509 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7510 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7511 /* service requested */
7512 ssh2_pkt_addstring(s
->pktout
, "publickey"); /* method */
7513 ssh2_pkt_addbool(s
->pktout
, FALSE
);
7514 /* no signature included */
7515 ssh2_pkt_addstring(s
->pktout
, s
->publickey_algorithm
);
7516 ssh2_pkt_addstring_start(s
->pktout
);
7517 ssh2_pkt_addstring_data(s
->pktout
,
7518 (char *)s
->publickey_blob
,
7519 s
->publickey_bloblen
);
7520 ssh2_pkt_send(ssh
, s
->pktout
);
7521 logevent("Offered public key");
7523 crWaitUntilV(pktin
);
7524 if (pktin
->type
!= SSH2_MSG_USERAUTH_PK_OK
) {
7525 /* Key refused. Give up. */
7526 s
->gotit
= TRUE
; /* reconsider message next loop */
7527 s
->type
= AUTH_TYPE_PUBLICKEY_OFFER_LOUD
;
7528 continue; /* process this new message */
7530 logevent("Offer of public key accepted");
7533 * Actually attempt a serious authentication using
7536 if (flags
& FLAG_VERBOSE
) {
7537 c_write_str(ssh
, "Authenticating with public key \"");
7538 c_write_str(ssh
, s
->publickey_comment
);
7539 c_write_str(ssh
, "\"\r\n");
7543 const char *error
; /* not live over crReturn */
7544 if (s
->publickey_encrypted
) {
7546 * Get a passphrase from the user.
7548 int ret
; /* need not be kept over crReturn */
7549 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7550 s
->cur_prompt
->to_server
= FALSE
;
7551 s
->cur_prompt
->name
= dupstr("SSH key passphrase");
7552 add_prompt(s
->cur_prompt
,
7553 dupprintf("Passphrase for key \"%.100s\": ",
7554 s
->publickey_comment
),
7555 FALSE
, SSH_MAX_PASSWORD_LEN
);
7556 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7559 crWaitUntilV(!pktin
);
7560 ret
= get_userpass_input(s
->cur_prompt
,
7565 /* Failed to get a passphrase. Terminate. */
7566 free_prompts(s
->cur_prompt
);
7567 ssh_disconnect(ssh
, NULL
,
7568 "Unable to authenticate",
7569 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
7574 dupstr(s
->cur_prompt
->prompts
[0]->result
);
7575 free_prompts(s
->cur_prompt
);
7577 passphrase
= NULL
; /* no passphrase needed */
7581 * Try decrypting the key.
7583 key
= ssh2_load_userkey(&ssh
->cfg
.keyfile
, passphrase
,
7586 /* burn the evidence */
7587 memset(passphrase
, 0, strlen(passphrase
));
7590 if (key
== SSH2_WRONG_PASSPHRASE
|| key
== NULL
) {
7592 (key
== SSH2_WRONG_PASSPHRASE
)) {
7593 c_write_str(ssh
, "Wrong passphrase\r\n");
7595 /* and loop again */
7597 c_write_str(ssh
, "Unable to load private key (");
7598 c_write_str(ssh
, error
);
7599 c_write_str(ssh
, ")\r\n");
7601 break; /* try something else */
7607 unsigned char *pkblob
, *sigblob
, *sigdata
;
7608 int pkblob_len
, sigblob_len
, sigdata_len
;
7612 * We have loaded the private key and the server
7613 * has announced that it's willing to accept it.
7614 * Hallelujah. Generate a signature and send it.
7616 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7617 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7618 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7619 /* service requested */
7620 ssh2_pkt_addstring(s
->pktout
, "publickey");
7622 ssh2_pkt_addbool(s
->pktout
, TRUE
);
7623 /* signature follows */
7624 ssh2_pkt_addstring(s
->pktout
, key
->alg
->name
);
7625 pkblob
= key
->alg
->public_blob(key
->data
,
7627 ssh2_pkt_addstring_start(s
->pktout
);
7628 ssh2_pkt_addstring_data(s
->pktout
, (char *)pkblob
,
7632 * The data to be signed is:
7636 * followed by everything so far placed in the
7639 sigdata_len
= s
->pktout
->length
- 5 + 4 +
7640 ssh
->v2_session_id_len
;
7641 if (ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)
7643 sigdata
= snewn(sigdata_len
, unsigned char);
7645 if (!(ssh
->remote_bugs
& BUG_SSH2_PK_SESSIONID
)) {
7646 PUT_32BIT(sigdata
+p
, ssh
->v2_session_id_len
);
7649 memcpy(sigdata
+p
, ssh
->v2_session_id
,
7650 ssh
->v2_session_id_len
);
7651 p
+= ssh
->v2_session_id_len
;
7652 memcpy(sigdata
+p
, s
->pktout
->data
+ 5,
7653 s
->pktout
->length
- 5);
7654 p
+= s
->pktout
->length
- 5;
7655 assert(p
== sigdata_len
);
7656 sigblob
= key
->alg
->sign(key
->data
, (char *)sigdata
,
7657 sigdata_len
, &sigblob_len
);
7658 ssh2_add_sigblob(ssh
, s
->pktout
, pkblob
, pkblob_len
,
7659 sigblob
, sigblob_len
);
7664 ssh2_pkt_send(ssh
, s
->pktout
);
7665 s
->type
= AUTH_TYPE_PUBLICKEY
;
7666 key
->alg
->freekey(key
->data
);
7669 } else if (s
->can_keyb_inter
&& !s
->kbd_inter_refused
) {
7672 * Keyboard-interactive authentication.
7675 s
->type
= AUTH_TYPE_KEYBOARD_INTERACTIVE
;
7677 ssh
->pkt_actx
= SSH2_PKTCTX_KBDINTER
;
7679 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7680 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7681 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7682 /* service requested */
7683 ssh2_pkt_addstring(s
->pktout
, "keyboard-interactive");
7685 ssh2_pkt_addstring(s
->pktout
, ""); /* lang */
7686 ssh2_pkt_addstring(s
->pktout
, ""); /* submethods */
7687 ssh2_pkt_send(ssh
, s
->pktout
);
7689 crWaitUntilV(pktin
);
7690 if (pktin
->type
!= SSH2_MSG_USERAUTH_INFO_REQUEST
) {
7691 /* Server is not willing to do keyboard-interactive
7692 * at all (or, bizarrely but legally, accepts the
7693 * user without actually issuing any prompts).
7694 * Give up on it entirely. */
7696 if (pktin
->type
== SSH2_MSG_USERAUTH_FAILURE
)
7697 logevent("Keyboard-interactive authentication refused");
7698 s
->type
= AUTH_TYPE_KEYBOARD_INTERACTIVE_QUIET
;
7699 s
->kbd_inter_refused
= TRUE
; /* don't try it again */
7704 * Loop while the server continues to send INFO_REQUESTs.
7706 while (pktin
->type
== SSH2_MSG_USERAUTH_INFO_REQUEST
) {
7708 char *name
, *inst
, *lang
;
7709 int name_len
, inst_len
, lang_len
;
7713 * We've got a fresh USERAUTH_INFO_REQUEST.
7714 * Get the preamble and start building a prompt.
7716 ssh_pkt_getstring(pktin
, &name
, &name_len
);
7717 ssh_pkt_getstring(pktin
, &inst
, &inst_len
);
7718 ssh_pkt_getstring(pktin
, &lang
, &lang_len
);
7719 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7720 s
->cur_prompt
->to_server
= TRUE
;
7722 /* FIXME: better prefix to distinguish from
7724 s
->cur_prompt
->name
=
7725 dupprintf("SSH server: %.*s", name_len
, name
);
7726 s
->cur_prompt
->name_reqd
= TRUE
;
7728 s
->cur_prompt
->name
=
7729 dupstr("SSH server authentication");
7730 s
->cur_prompt
->name_reqd
= FALSE
;
7732 /* FIXME: ugly to print "Using..." in prompt _every_
7733 * time round. Can this be done more subtly? */
7734 s
->cur_prompt
->instruction
=
7735 dupprintf("Using keyboard-interactive authentication.%s%.*s",
7736 inst_len ?
"\n" : "", inst_len
, inst
);
7737 s
->cur_prompt
->instr_reqd
= TRUE
;
7740 * Get the prompts from the packet.
7742 s
->num_prompts
= ssh_pkt_getuint32(pktin
);
7743 for (i
= 0; i
< s
->num_prompts
; i
++) {
7747 static char noprompt
[] =
7748 "<server failed to send prompt>: ";
7750 ssh_pkt_getstring(pktin
, &prompt
, &prompt_len
);
7751 echo
= ssh2_pkt_getbool(pktin
);
7754 prompt_len
= lenof(noprompt
)-1;
7756 add_prompt(s
->cur_prompt
,
7757 dupprintf("%.*s", prompt_len
, prompt
),
7758 echo
, SSH_MAX_PASSWORD_LEN
);
7762 * Get the user's responses.
7764 if (s
->num_prompts
) {
7765 int ret
; /* not live over crReturn */
7766 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7769 crWaitUntilV(!pktin
);
7770 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
7775 * Failed to get responses. Terminate.
7777 free_prompts(s
->cur_prompt
);
7778 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
7779 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
7786 * Send the responses to the server.
7788 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_INFO_RESPONSE
);
7789 ssh2_pkt_adduint32(s
->pktout
, s
->num_prompts
);
7790 for (i
=0; i
< s
->num_prompts
; i
++) {
7791 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
7792 ssh2_pkt_addstring(s
->pktout
,
7793 s
->cur_prompt
->prompts
[i
]->result
);
7794 end_log_omission(ssh
, s
->pktout
);
7796 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
7799 * Get the next packet in case it's another
7802 crWaitUntilV(pktin
);
7807 * We should have SUCCESS or FAILURE now.
7811 } else if (s
->can_passwd
) {
7814 * Plain old password authentication.
7816 int ret
; /* not live over crReturn */
7817 int changereq_first_time
; /* not live over crReturn */
7819 ssh
->pkt_actx
= SSH2_PKTCTX_PASSWORD
;
7821 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7822 s
->cur_prompt
->to_server
= TRUE
;
7823 s
->cur_prompt
->name
= dupstr("SSH password");
7824 add_prompt(s
->cur_prompt
, dupprintf("%.90s@%.90s's password: ",
7827 FALSE
, SSH_MAX_PASSWORD_LEN
);
7829 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7832 crWaitUntilV(!pktin
);
7833 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
7838 * Failed to get responses. Terminate.
7840 free_prompts(s
->cur_prompt
);
7841 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
7842 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
7847 * Squirrel away the password. (We may need it later if
7848 * asked to change it.)
7850 s
->password
= dupstr(s
->cur_prompt
->prompts
[0]->result
);
7851 free_prompts(s
->cur_prompt
);
7854 * Send the password packet.
7856 * We pad out the password packet to 256 bytes to make
7857 * it harder for an attacker to find the length of the
7860 * Anyone using a password longer than 256 bytes
7861 * probably doesn't have much to worry about from
7862 * people who find out how long their password is!
7864 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7865 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7866 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7867 /* service requested */
7868 ssh2_pkt_addstring(s
->pktout
, "password");
7869 ssh2_pkt_addbool(s
->pktout
, FALSE
);
7870 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
7871 ssh2_pkt_addstring(s
->pktout
, s
->password
);
7872 end_log_omission(ssh
, s
->pktout
);
7873 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
7874 logevent("Sent password");
7875 s
->type
= AUTH_TYPE_PASSWORD
;
7878 * Wait for next packet, in case it's a password change
7881 crWaitUntilV(pktin
);
7882 changereq_first_time
= TRUE
;
7884 while (pktin
->type
== SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ
) {
7887 * We're being asked for a new password
7888 * (perhaps not for the first time).
7889 * Loop until the server accepts it.
7892 int got_new
= FALSE
; /* not live over crReturn */
7893 char *prompt
; /* not live over crReturn */
7894 int prompt_len
; /* not live over crReturn */
7898 if (changereq_first_time
)
7899 msg
= "Server requested password change";
7901 msg
= "Server rejected new password";
7903 c_write_str(ssh
, msg
);
7904 c_write_str(ssh
, "\r\n");
7907 ssh_pkt_getstring(pktin
, &prompt
, &prompt_len
);
7909 s
->cur_prompt
= new_prompts(ssh
->frontend
);
7910 s
->cur_prompt
->to_server
= TRUE
;
7911 s
->cur_prompt
->name
= dupstr("New SSH password");
7912 s
->cur_prompt
->instruction
=
7913 dupprintf("%.*s", prompt_len
, prompt
);
7914 s
->cur_prompt
->instr_reqd
= TRUE
;
7916 * There's no explicit requirement in the protocol
7917 * for the "old" passwords in the original and
7918 * password-change messages to be the same, and
7919 * apparently some Cisco kit supports password change
7920 * by the user entering a blank password originally
7921 * and the real password subsequently, so,
7922 * reluctantly, we prompt for the old password again.
7924 * (On the other hand, some servers don't even bother
7925 * to check this field.)
7927 add_prompt(s
->cur_prompt
,
7928 dupstr("Current password (blank for previously entered password): "),
7929 FALSE
, SSH_MAX_PASSWORD_LEN
);
7930 add_prompt(s
->cur_prompt
, dupstr("Enter new password: "),
7931 FALSE
, SSH_MAX_PASSWORD_LEN
);
7932 add_prompt(s
->cur_prompt
, dupstr("Confirm new password: "),
7933 FALSE
, SSH_MAX_PASSWORD_LEN
);
7936 * Loop until the user manages to enter the same
7941 ret
= get_userpass_input(s
->cur_prompt
, NULL
, 0);
7944 crWaitUntilV(!pktin
);
7945 ret
= get_userpass_input(s
->cur_prompt
, in
, inlen
);
7950 * Failed to get responses. Terminate.
7952 /* burn the evidence */
7953 free_prompts(s
->cur_prompt
);
7954 memset(s
->password
, 0, strlen(s
->password
));
7956 ssh_disconnect(ssh
, NULL
, "Unable to authenticate",
7957 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER
,
7963 * If the user specified a new original password
7964 * (IYSWIM), overwrite any previously specified
7966 * (A side effect is that the user doesn't have to
7967 * re-enter it if they louse up the new password.)
7969 if (s
->cur_prompt
->prompts
[0]->result
[0]) {
7970 memset(s
->password
, 0, strlen(s
->password
));
7971 /* burn the evidence */
7974 dupstr(s
->cur_prompt
->prompts
[0]->result
);
7978 * Check the two new passwords match.
7980 got_new
= (strcmp(s
->cur_prompt
->prompts
[1]->result
,
7981 s
->cur_prompt
->prompts
[2]->result
)
7984 /* They don't. Silly user. */
7985 c_write_str(ssh
, "Passwords do not match\r\n");
7990 * Send the new password (along with the old one).
7991 * (see above for padding rationale)
7993 s
->pktout
= ssh2_pkt_init(SSH2_MSG_USERAUTH_REQUEST
);
7994 ssh2_pkt_addstring(s
->pktout
, s
->username
);
7995 ssh2_pkt_addstring(s
->pktout
, "ssh-connection");
7996 /* service requested */
7997 ssh2_pkt_addstring(s
->pktout
, "password");
7998 ssh2_pkt_addbool(s
->pktout
, TRUE
);
7999 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
8000 ssh2_pkt_addstring(s
->pktout
, s
->password
);
8001 ssh2_pkt_addstring(s
->pktout
,
8002 s
->cur_prompt
->prompts
[1]->result
);
8003 free_prompts(s
->cur_prompt
);
8004 end_log_omission(ssh
, s
->pktout
);
8005 ssh2_pkt_send_with_padding(ssh
, s
->pktout
, 256);
8006 logevent("Sent new password");
8009 * Now see what the server has to say about it.
8010 * (If it's CHANGEREQ again, it's not happy with the
8013 crWaitUntilV(pktin
);
8014 changereq_first_time
= FALSE
;
8019 * We need to reexamine the current pktin at the top
8020 * of the loop. Either:
8021 * - we weren't asked to change password at all, in
8022 * which case it's a SUCCESS or FAILURE with the
8024 * - we sent a new password, and the server was
8025 * either OK with it (SUCCESS or FAILURE w/partial
8026 * success) or unhappy with the _old_ password
8027 * (FAILURE w/o partial success)
8028 * In any of these cases, we go back to the top of
8029 * the loop and start again.
8034 * We don't need the old password any more, in any
8035 * case. Burn the evidence.
8037 memset(s
->password
, 0, strlen(s
->password
));
8042 ssh_disconnect(ssh
, NULL
,
8043 "No supported authentication methods available",
8044 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE
,
8052 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] = NULL
;
8054 /* Clear up various bits and pieces from authentication. */
8055 if (s
->publickey_blob
) {
8056 sfree(s
->publickey_blob
);
8057 sfree(s
->publickey_comment
);
8059 if (s
->agent_response
)
8060 sfree(s
->agent_response
);
8063 * Now the connection protocol has started, one way or another.
8066 ssh
->channels
= newtree234(ssh_channelcmp
);
8069 * Set up handlers for some connection protocol messages, so we
8070 * don't have to handle them repeatedly in this coroutine.
8072 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_WINDOW_ADJUST
] =
8073 ssh2_msg_channel_window_adjust
;
8074 ssh
->packet_dispatch
[SSH2_MSG_GLOBAL_REQUEST
] =
8075 ssh2_msg_global_request
;
8078 * Create the main session channel.
8080 if (ssh
->cfg
.ssh_no_shell
) {
8081 ssh
->mainchan
= NULL
;
8082 } else if (*ssh
->cfg
.ssh_nc_host
) {
8084 * Just start a direct-tcpip channel and use it as the main
8087 ssh
->mainchan
= snew(struct ssh_channel
);
8088 ssh
->mainchan
->ssh
= ssh
;
8089 ssh
->mainchan
->localid
= alloc_channel_id(ssh
);
8091 "Opening direct-tcpip channel to %s:%d in place of session",
8092 ssh
->cfg
.ssh_nc_host
, ssh
->cfg
.ssh_nc_port
);
8093 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
8094 ssh2_pkt_addstring(s
->pktout
, "direct-tcpip");
8095 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->localid
);
8096 ssh
->mainchan
->v
.v2
.locwindow
= ssh
->mainchan
->v
.v2
.locmaxwin
=
8097 ssh
->mainchan
->v
.v2
.remlocwin
=
8098 ssh
->cfg
.ssh_simple ? OUR_V2_BIGWIN
: OUR_V2_WINSIZE
;
8099 ssh
->mainchan
->v
.v2
.winadj_head
= NULL
;
8100 ssh
->mainchan
->v
.v2
.winadj_tail
= NULL
;
8101 ssh
->mainchan
->v
.v2
.throttle_state
= UNTHROTTLED
;
8102 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->v
.v2
.locwindow
);/* our window size */
8103 ssh2_pkt_adduint32(s
->pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
8104 ssh2_pkt_addstring(s
->pktout
, ssh
->cfg
.ssh_nc_host
);
8105 ssh2_pkt_adduint32(s
->pktout
, ssh
->cfg
.ssh_nc_port
);
8107 * There's nothing meaningful to put in the originator
8108 * fields, but some servers insist on syntactically correct
8111 ssh2_pkt_addstring(s
->pktout
, "0.0.0.0");
8112 ssh2_pkt_adduint32(s
->pktout
, 0);
8113 ssh2_pkt_send(ssh
, s
->pktout
);
8115 crWaitUntilV(pktin
);
8116 if (pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
) {
8117 bombout(("Server refused to open a direct-tcpip channel"));
8119 /* FIXME: error data comes back in FAILURE packet */
8121 if (ssh_pkt_getuint32(pktin
) != ssh
->mainchan
->localid
) {
8122 bombout(("Server's channel confirmation cited wrong channel"));
8125 ssh
->mainchan
->remoteid
= ssh_pkt_getuint32(pktin
);
8126 ssh
->mainchan
->halfopen
= FALSE
;
8127 ssh
->mainchan
->type
= CHAN_MAINSESSION
;
8128 ssh
->mainchan
->closes
= 0;
8129 ssh
->mainchan
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
8130 ssh
->mainchan
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
8131 bufchain_init(&ssh
->mainchan
->v
.v2
.outbuffer
);
8132 add234(ssh
->channels
, ssh
->mainchan
);
8133 update_specials_menu(ssh
->frontend
);
8134 logevent("Opened direct-tcpip channel");
8137 ssh
->mainchan
= snew(struct ssh_channel
);
8138 ssh
->mainchan
->ssh
= ssh
;
8139 ssh
->mainchan
->localid
= alloc_channel_id(ssh
);
8140 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
8141 ssh2_pkt_addstring(s
->pktout
, "session");
8142 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->localid
);
8143 ssh
->mainchan
->v
.v2
.locwindow
= ssh
->mainchan
->v
.v2
.locmaxwin
=
8144 ssh
->mainchan
->v
.v2
.remlocwin
=
8145 ssh
->cfg
.ssh_simple ? OUR_V2_BIGWIN
: OUR_V2_WINSIZE
;
8146 ssh
->mainchan
->v
.v2
.winadj_head
= NULL
;
8147 ssh
->mainchan
->v
.v2
.winadj_tail
= NULL
;
8148 ssh
->mainchan
->v
.v2
.throttle_state
= UNTHROTTLED
;
8149 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->v
.v2
.locwindow
);/* our window size */
8150 ssh2_pkt_adduint32(s
->pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
8151 ssh2_pkt_send(ssh
, s
->pktout
);
8152 crWaitUntilV(pktin
);
8153 if (pktin
->type
!= SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
) {
8154 bombout(("Server refused to open a session"));
8156 /* FIXME: error data comes back in FAILURE packet */
8158 if (ssh_pkt_getuint32(pktin
) != ssh
->mainchan
->localid
) {
8159 bombout(("Server's channel confirmation cited wrong channel"));
8162 ssh
->mainchan
->remoteid
= ssh_pkt_getuint32(pktin
);
8163 ssh
->mainchan
->halfopen
= FALSE
;
8164 ssh
->mainchan
->type
= CHAN_MAINSESSION
;
8165 ssh
->mainchan
->closes
= 0;
8166 ssh
->mainchan
->v
.v2
.remwindow
= ssh_pkt_getuint32(pktin
);
8167 ssh
->mainchan
->v
.v2
.remmaxpkt
= ssh_pkt_getuint32(pktin
);
8168 bufchain_init(&ssh
->mainchan
->v
.v2
.outbuffer
);
8169 add234(ssh
->channels
, ssh
->mainchan
);
8170 update_specials_menu(ssh
->frontend
);
8171 logevent("Opened channel for session");
8172 ssh
->ncmode
= FALSE
;
8176 * Now we have a channel, make dispatch table entries for
8177 * general channel-based messages.
8179 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_DATA
] =
8180 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EXTENDED_DATA
] =
8181 ssh2_msg_channel_data
;
8182 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EOF
] = ssh2_msg_channel_eof
;
8183 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_CLOSE
] = ssh2_msg_channel_close
;
8184 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
] =
8185 ssh2_msg_channel_open_confirmation
;
8186 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_FAILURE
] =
8187 ssh2_msg_channel_open_failure
;
8188 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_REQUEST
] =
8189 ssh2_msg_channel_request
;
8190 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN
] =
8191 ssh2_msg_channel_open
;
8193 if (ssh
->cfg
.ssh_simple
) {
8195 * This message indicates to the server that we promise
8196 * not to try to run any other channel in parallel with
8197 * this one, so it's safe for it to advertise a very large
8198 * window and leave the flow control to TCP.
8200 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8201 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
8202 ssh2_pkt_addstring(s
->pktout
, "simple@putty.projects.tartarus.org");
8203 ssh2_pkt_addbool(s
->pktout
, 0); /* no reply */
8204 ssh2_pkt_send(ssh
, s
->pktout
);
8208 * Potentially enable X11 forwarding.
8210 if (ssh
->mainchan
&& !ssh
->ncmode
&& ssh
->cfg
.x11_forward
) {
8211 char proto
[20], data
[64];
8212 logevent("Requesting X11 forwarding");
8213 ssh
->x11auth
= x11_invent_auth(proto
, sizeof(proto
),
8214 data
, sizeof(data
), ssh
->cfg
.x11_auth
);
8215 x11_get_real_auth(ssh
->x11auth
, ssh
->cfg
.x11_display
);
8216 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8217 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
8218 ssh2_pkt_addstring(s
->pktout
, "x11-req");
8219 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8220 ssh2_pkt_addbool(s
->pktout
, 0); /* many connections */
8221 ssh2_pkt_addstring(s
->pktout
, proto
);
8223 * Note that while we blank the X authentication data here, we don't
8224 * take any special action to blank the start of an X11 channel,
8225 * so using MIT-MAGIC-COOKIE-1 and actually opening an X connection
8226 * without having session blanking enabled is likely to leak your
8227 * cookie into the log.
8229 dont_log_password(ssh
, s
->pktout
, PKTLOG_BLANK
);
8230 ssh2_pkt_addstring(s
->pktout
, data
);
8231 end_log_omission(ssh
, s
->pktout
);
8232 ssh2_pkt_adduint32(s
->pktout
, x11_get_screen_number(ssh
->cfg
.x11_display
));
8233 ssh2_pkt_send(ssh
, s
->pktout
);
8235 crWaitUntilV(pktin
);
8237 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
8238 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
8239 bombout(("Unexpected response to X11 forwarding request:"
8240 " packet type %d", pktin
->type
));
8243 logevent("X11 forwarding refused");
8245 logevent("X11 forwarding enabled");
8246 ssh
->X11_fwd_enabled
= TRUE
;
8251 * Enable port forwardings.
8253 ssh_setup_portfwd(ssh
, &ssh
->cfg
);
8256 * Potentially enable agent forwarding.
8258 if (ssh
->mainchan
&& !ssh
->ncmode
&& ssh
->cfg
.agentfwd
&& agent_exists()) {
8259 logevent("Requesting OpenSSH-style agent forwarding");
8260 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8261 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
8262 ssh2_pkt_addstring(s
->pktout
, "auth-agent-req@openssh.com");
8263 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8264 ssh2_pkt_send(ssh
, s
->pktout
);
8266 crWaitUntilV(pktin
);
8268 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
8269 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
8270 bombout(("Unexpected response to agent forwarding request:"
8271 " packet type %d", pktin
->type
));
8274 logevent("Agent forwarding refused");
8276 logevent("Agent forwarding enabled");
8277 ssh
->agentfwd_enabled
= TRUE
;
8282 * Now allocate a pty for the session.
8284 if (ssh
->mainchan
&& !ssh
->ncmode
&& !ssh
->cfg
.nopty
) {
8285 /* Unpick the terminal-speed string. */
8286 /* XXX perhaps we should allow no speeds to be sent. */
8287 ssh
->ospeed
= 38400; ssh
->ispeed
= 38400; /* last-resort defaults */
8288 sscanf(ssh
->cfg
.termspeed
, "%d,%d", &ssh
->ospeed
, &ssh
->ispeed
);
8289 /* Build the pty request. */
8290 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8291 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
); /* recipient channel */
8292 ssh2_pkt_addstring(s
->pktout
, "pty-req");
8293 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8294 ssh2_pkt_addstring(s
->pktout
, ssh
->cfg
.termtype
);
8295 ssh2_pkt_adduint32(s
->pktout
, ssh
->term_width
);
8296 ssh2_pkt_adduint32(s
->pktout
, ssh
->term_height
);
8297 ssh2_pkt_adduint32(s
->pktout
, 0); /* pixel width */
8298 ssh2_pkt_adduint32(s
->pktout
, 0); /* pixel height */
8299 ssh2_pkt_addstring_start(s
->pktout
);
8300 parse_ttymodes(ssh
, ssh
->cfg
.ttymodes
,
8301 ssh2_send_ttymode
, (void *)s
->pktout
);
8302 ssh2_pkt_addbyte(s
->pktout
, SSH2_TTY_OP_ISPEED
);
8303 ssh2_pkt_adduint32(s
->pktout
, ssh
->ispeed
);
8304 ssh2_pkt_addbyte(s
->pktout
, SSH2_TTY_OP_OSPEED
);
8305 ssh2_pkt_adduint32(s
->pktout
, ssh
->ospeed
);
8306 ssh2_pkt_addstring_data(s
->pktout
, "\0", 1); /* TTY_OP_END */
8307 ssh2_pkt_send(ssh
, s
->pktout
);
8308 ssh
->state
= SSH_STATE_INTERMED
;
8310 crWaitUntilV(pktin
);
8312 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
8313 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
8314 bombout(("Unexpected response to pty request:"
8315 " packet type %d", pktin
->type
));
8318 c_write_str(ssh
, "Server refused to allocate pty\r\n");
8319 ssh
->editing
= ssh
->echoing
= 1;
8321 logeventf(ssh
, "Allocated pty (ospeed %dbps, ispeed %dbps)",
8322 ssh
->ospeed
, ssh
->ispeed
);
8325 ssh
->editing
= ssh
->echoing
= 1;
8329 * Send environment variables.
8331 * Simplest thing here is to send all the requests at once, and
8332 * then wait for a whole bunch of successes or failures.
8334 if (ssh
->mainchan
&& !ssh
->ncmode
&& *ssh
->cfg
.environmt
) {
8335 char *e
= ssh
->cfg
.environmt
;
8336 char *var
, *varend
, *val
;
8342 while (*e
&& *e
!= '\t') e
++;
8344 if (*e
== '\t') e
++;
8349 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8350 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
);
8351 ssh2_pkt_addstring(s
->pktout
, "env");
8352 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8353 ssh2_pkt_addstring_start(s
->pktout
);
8354 ssh2_pkt_addstring_data(s
->pktout
, var
, varend
-var
);
8355 ssh2_pkt_addstring(s
->pktout
, val
);
8356 ssh2_pkt_send(ssh
, s
->pktout
);
8361 logeventf(ssh
, "Sent %d environment variables", s
->num_env
);
8364 s
->env_left
= s
->num_env
;
8366 while (s
->env_left
> 0) {
8367 crWaitUntilV(pktin
);
8369 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
8370 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
8371 bombout(("Unexpected response to environment request:"
8372 " packet type %d", pktin
->type
));
8382 if (s
->env_ok
== s
->num_env
) {
8383 logevent("All environment variables successfully set");
8384 } else if (s
->env_ok
== 0) {
8385 logevent("All environment variables refused");
8386 c_write_str(ssh
, "Server refused to set environment variables\r\n");
8388 logeventf(ssh
, "%d environment variables refused",
8389 s
->num_env
- s
->env_ok
);
8390 c_write_str(ssh
, "Server refused to set all environment variables\r\n");
8395 * Start a shell or a remote command. We may have to attempt
8396 * this twice if the config data has provided a second choice
8399 if (ssh
->mainchan
&& !ssh
->ncmode
) while (1) {
8403 if (ssh
->fallback_cmd
) {
8404 subsys
= ssh
->cfg
.ssh_subsys2
;
8405 cmd
= ssh
->cfg
.remote_cmd_ptr2
;
8407 subsys
= ssh
->cfg
.ssh_subsys
;
8408 cmd
= ssh
->cfg
.remote_cmd_ptr
;
8409 if (!cmd
) cmd
= ssh
->cfg
.remote_cmd
;
8412 s
->pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
8413 ssh2_pkt_adduint32(s
->pktout
, ssh
->mainchan
->remoteid
); /* recipient channel */
8415 ssh2_pkt_addstring(s
->pktout
, "subsystem");
8416 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8417 ssh2_pkt_addstring(s
->pktout
, cmd
);
8419 ssh2_pkt_addstring(s
->pktout
, "exec");
8420 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8421 ssh2_pkt_addstring(s
->pktout
, cmd
);
8423 ssh2_pkt_addstring(s
->pktout
, "shell");
8424 ssh2_pkt_addbool(s
->pktout
, 1); /* want reply */
8426 ssh2_pkt_send(ssh
, s
->pktout
);
8428 crWaitUntilV(pktin
);
8430 if (pktin
->type
!= SSH2_MSG_CHANNEL_SUCCESS
) {
8431 if (pktin
->type
!= SSH2_MSG_CHANNEL_FAILURE
) {
8432 bombout(("Unexpected response to shell/command request:"
8433 " packet type %d", pktin
->type
));
8437 * We failed to start the command. If this is the
8438 * fallback command, we really are finished; if it's
8439 * not, and if the fallback command exists, try falling
8440 * back to it before complaining.
8442 if (!ssh
->fallback_cmd
&& ssh
->cfg
.remote_cmd_ptr2
!= NULL
) {
8443 logevent("Primary command failed; attempting fallback");
8444 ssh
->fallback_cmd
= TRUE
;
8447 bombout(("Server refused to start a shell/command"));
8450 logevent("Started a shell/command");
8455 ssh
->state
= SSH_STATE_SESSION
;
8456 if (ssh
->size_needed
)
8457 ssh_size(ssh
, ssh
->term_width
, ssh
->term_height
);
8458 if (ssh
->eof_needed
)
8459 ssh_special(ssh
, TS_EOF
);
8462 * All the initial channel requests are done, so install the default
8465 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
] = ssh2_msg_channel_failure
;
8471 ldisc_send(ssh
->ldisc
, NULL
, 0, 0);/* cause ldisc to notice changes */
8476 s
->try_send
= FALSE
;
8480 * _All_ the connection-layer packets we expect to
8481 * receive are now handled by the dispatch table.
8482 * Anything that reaches here must be bogus.
8485 bombout(("Strange packet received: type %d", pktin
->type
));
8487 } else if (ssh
->mainchan
) {
8489 * We have spare data. Add it to the channel buffer.
8491 ssh2_add_channel_data(ssh
->mainchan
, (char *)in
, inlen
);
8496 struct ssh_channel
*c
;
8498 * Try to send data on all channels if we can.
8500 for (i
= 0; NULL
!= (c
= index234(ssh
->channels
, i
)); i
++)
8501 ssh2_try_send_and_unthrottle(c
);
8509 * Handlers for SSH-2 messages that might arrive at any moment.
8511 static void ssh2_msg_disconnect(Ssh ssh
, struct Packet
*pktin
)
8513 /* log reason code in disconnect message */
8515 int nowlen
, reason
, msglen
;
8517 reason
= ssh_pkt_getuint32(pktin
);
8518 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
8520 if (reason
> 0 && reason
< lenof(ssh2_disconnect_reasons
)) {
8521 buf
= dupprintf("Received disconnect message (%s)",
8522 ssh2_disconnect_reasons
[reason
]);
8524 buf
= dupprintf("Received disconnect message (unknown"
8525 " type %d)", reason
);
8529 buf
= dupprintf("Disconnection message text: %n%.*s",
8530 &nowlen
, msglen
, msg
);
8532 bombout(("Server sent disconnect message\ntype %d (%s):\n\"%s\"",
8534 (reason
> 0 && reason
< lenof(ssh2_disconnect_reasons
)) ?
8535 ssh2_disconnect_reasons
[reason
] : "unknown",
8540 static void ssh2_msg_debug(Ssh ssh
, struct Packet
*pktin
)
8542 /* log the debug message */
8547 /* XXX maybe we should actually take notice of this */
8548 always_display
= ssh2_pkt_getbool(pktin
);
8549 ssh_pkt_getstring(pktin
, &msg
, &msglen
);
8551 logeventf(ssh
, "Remote debug message: %.*s", msglen
, msg
);
8554 static void ssh2_msg_something_unimplemented(Ssh ssh
, struct Packet
*pktin
)
8556 struct Packet
*pktout
;
8557 pktout
= ssh2_pkt_init(SSH2_MSG_UNIMPLEMENTED
);
8558 ssh2_pkt_adduint32(pktout
, pktin
->sequence
);
8560 * UNIMPLEMENTED messages MUST appear in the same order as the
8561 * messages they respond to. Hence, never queue them.
8563 ssh2_pkt_send_noqueue(ssh
, pktout
);
8567 * Handle the top-level SSH-2 protocol.
8569 static void ssh2_protocol_setup(Ssh ssh
)
8574 * Most messages cause SSH2_MSG_UNIMPLEMENTED.
8576 for (i
= 0; i
< 256; i
++)
8577 ssh
->packet_dispatch
[i
] = ssh2_msg_something_unimplemented
;
8580 * Any message we actually understand, we set to NULL so that
8581 * the coroutines will get it.
8583 ssh
->packet_dispatch
[SSH2_MSG_UNIMPLEMENTED
] = NULL
;
8584 ssh
->packet_dispatch
[SSH2_MSG_SERVICE_REQUEST
] = NULL
;
8585 ssh
->packet_dispatch
[SSH2_MSG_SERVICE_ACCEPT
] = NULL
;
8586 ssh
->packet_dispatch
[SSH2_MSG_KEXINIT
] = NULL
;
8587 ssh
->packet_dispatch
[SSH2_MSG_NEWKEYS
] = NULL
;
8588 ssh
->packet_dispatch
[SSH2_MSG_KEXDH_INIT
] = NULL
;
8589 ssh
->packet_dispatch
[SSH2_MSG_KEXDH_REPLY
] = NULL
;
8590 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_REQUEST] = NULL; duplicate case value */
8591 /* ssh->packet_dispatch[SSH2_MSG_KEX_DH_GEX_GROUP] = NULL; duplicate case value */
8592 ssh
->packet_dispatch
[SSH2_MSG_KEX_DH_GEX_INIT
] = NULL
;
8593 ssh
->packet_dispatch
[SSH2_MSG_KEX_DH_GEX_REPLY
] = NULL
;
8594 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_REQUEST
] = NULL
;
8595 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_FAILURE
] = NULL
;
8596 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_SUCCESS
] = NULL
;
8597 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_BANNER
] = NULL
;
8598 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_PK_OK
] = NULL
;
8599 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ] = NULL; duplicate case value */
8600 /* ssh->packet_dispatch[SSH2_MSG_USERAUTH_INFO_REQUEST] = NULL; duplicate case value */
8601 ssh
->packet_dispatch
[SSH2_MSG_USERAUTH_INFO_RESPONSE
] = NULL
;
8602 ssh
->packet_dispatch
[SSH2_MSG_GLOBAL_REQUEST
] = NULL
;
8603 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_SUCCESS
] = NULL
;
8604 ssh
->packet_dispatch
[SSH2_MSG_REQUEST_FAILURE
] = NULL
;
8605 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN
] = NULL
;
8606 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_CONFIRMATION
] = NULL
;
8607 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_OPEN_FAILURE
] = NULL
;
8608 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_WINDOW_ADJUST
] = NULL
;
8609 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_DATA
] = NULL
;
8610 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EXTENDED_DATA
] = NULL
;
8611 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_EOF
] = NULL
;
8612 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_CLOSE
] = NULL
;
8613 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_REQUEST
] = NULL
;
8614 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_SUCCESS
] = NULL
;
8615 ssh
->packet_dispatch
[SSH2_MSG_CHANNEL_FAILURE
] = NULL
;
8618 * These special message types we install handlers for.
8620 ssh
->packet_dispatch
[SSH2_MSG_DISCONNECT
] = ssh2_msg_disconnect
;
8621 ssh
->packet_dispatch
[SSH2_MSG_IGNORE
] = ssh_msg_ignore
; /* shared with SSH-1 */
8622 ssh
->packet_dispatch
[SSH2_MSG_DEBUG
] = ssh2_msg_debug
;
8625 static void ssh2_timer(void *ctx
, long now
)
8629 if (ssh
->state
== SSH_STATE_CLOSED
)
8632 if (!ssh
->kex_in_progress
&& ssh
->cfg
.ssh_rekey_time
!= 0 &&
8633 now
- ssh
->next_rekey
>= 0) {
8634 do_ssh2_transport(ssh
, "timeout", -1, NULL
);
8638 static void ssh2_protocol(Ssh ssh
, void *vin
, int inlen
,
8639 struct Packet
*pktin
)
8641 unsigned char *in
= (unsigned char *)vin
;
8642 if (ssh
->state
== SSH_STATE_CLOSED
)
8646 ssh
->incoming_data_size
+= pktin
->encrypted_len
;
8647 if (!ssh
->kex_in_progress
&&
8648 ssh
->max_data_size
!= 0 &&
8649 ssh
->incoming_data_size
> ssh
->max_data_size
)
8650 do_ssh2_transport(ssh
, "too much data received", -1, NULL
);
8653 if (pktin
&& ssh
->packet_dispatch
[pktin
->type
]) {
8654 ssh
->packet_dispatch
[pktin
->type
](ssh
, pktin
);
8658 if (!ssh
->protocol_initial_phase_done
||
8659 (pktin
&& pktin
->type
>= 20 && pktin
->type
< 50)) {
8660 if (do_ssh2_transport(ssh
, in
, inlen
, pktin
) &&
8661 !ssh
->protocol_initial_phase_done
) {
8662 ssh
->protocol_initial_phase_done
= TRUE
;
8664 * Allow authconn to initialise itself.
8666 do_ssh2_authconn(ssh
, NULL
, 0, NULL
);
8669 do_ssh2_authconn(ssh
, in
, inlen
, pktin
);
8674 * Called to set up the connection.
8676 * Returns an error message, or NULL on success.
8678 static const char *ssh_init(void *frontend_handle
, void **backend_handle
,
8680 char *host
, int port
, char **realhost
, int nodelay
,
8686 ssh
= snew(struct ssh_tag
);
8687 ssh
->cfg
= *cfg
; /* STRUCTURE COPY */
8688 ssh
->version
= 0; /* when not ready yet */
8691 ssh
->v1_cipher_ctx
= NULL
;
8692 ssh
->crcda_ctx
= NULL
;
8693 ssh
->cscipher
= NULL
;
8694 ssh
->cs_cipher_ctx
= NULL
;
8695 ssh
->sccipher
= NULL
;
8696 ssh
->sc_cipher_ctx
= NULL
;
8698 ssh
->cs_mac_ctx
= NULL
;
8700 ssh
->sc_mac_ctx
= NULL
;
8702 ssh
->cs_comp_ctx
= NULL
;
8704 ssh
->sc_comp_ctx
= NULL
;
8706 ssh
->kex_ctx
= NULL
;
8707 ssh
->hostkey
= NULL
;
8709 ssh
->close_expected
= FALSE
;
8710 ssh
->clean_exit
= FALSE
;
8711 ssh
->state
= SSH_STATE_PREPACKET
;
8712 ssh
->size_needed
= FALSE
;
8713 ssh
->eof_needed
= FALSE
;
8716 ssh
->deferred_send_data
= NULL
;
8717 ssh
->deferred_len
= 0;
8718 ssh
->deferred_size
= 0;
8719 ssh
->fallback_cmd
= 0;
8720 ssh
->pkt_kctx
= SSH2_PKTCTX_NOKEX
;
8721 ssh
->pkt_actx
= SSH2_PKTCTX_NOAUTH
;
8722 ssh
->x11auth
= NULL
;
8723 ssh
->v1_compressing
= FALSE
;
8724 ssh
->v2_outgoing_sequence
= 0;
8725 ssh
->ssh1_rdpkt_crstate
= 0;
8726 ssh
->ssh2_rdpkt_crstate
= 0;
8727 ssh
->do_ssh_init_crstate
= 0;
8728 ssh
->ssh_gotdata_crstate
= 0;
8729 ssh
->do_ssh1_connection_crstate
= 0;
8730 ssh
->do_ssh1_login_crstate
= 0;
8731 ssh
->do_ssh2_transport_crstate
= 0;
8732 ssh
->do_ssh2_authconn_crstate
= 0;
8733 ssh
->do_ssh_init_state
= NULL
;
8734 ssh
->do_ssh1_login_state
= NULL
;
8735 ssh
->do_ssh2_transport_state
= NULL
;
8736 ssh
->do_ssh2_authconn_state
= NULL
;
8739 ssh
->mainchan
= NULL
;
8740 ssh
->throttled_all
= 0;
8741 ssh
->v1_stdout_throttling
= 0;
8743 ssh
->queuelen
= ssh
->queuesize
= 0;
8744 ssh
->queueing
= FALSE
;
8745 ssh
->qhead
= ssh
->qtail
= NULL
;
8746 ssh
->deferred_rekey_reason
= NULL
;
8747 bufchain_init(&ssh
->queued_incoming_data
);
8748 ssh
->frozen
= FALSE
;
8750 *backend_handle
= ssh
;
8753 if (crypto_startup() == 0)
8754 return "Microsoft high encryption pack not installed!";
8757 ssh
->frontend
= frontend_handle
;
8758 ssh
->term_width
= ssh
->cfg
.width
;
8759 ssh
->term_height
= ssh
->cfg
.height
;
8761 ssh
->channels
= NULL
;
8762 ssh
->rportfwds
= NULL
;
8763 ssh
->portfwds
= NULL
;
8768 ssh
->v1_throttle_count
= 0;
8769 ssh
->overall_bufsize
= 0;
8770 ssh
->fallback_cmd
= 0;
8772 ssh
->protocol
= NULL
;
8774 ssh
->protocol_initial_phase_done
= FALSE
;
8778 ssh
->incoming_data_size
= ssh
->outgoing_data_size
=
8779 ssh
->deferred_data_size
= 0L;
8780 ssh
->max_data_size
= parse_blocksize(ssh
->cfg
.ssh_rekey_data
);
8781 ssh
->kex_in_progress
= FALSE
;
8783 p
= connect_to_host(ssh
, host
, port
, realhost
, nodelay
, keepalive
);
8792 static void ssh_free(void *handle
)
8794 Ssh ssh
= (Ssh
) handle
;
8795 struct ssh_channel
*c
;
8796 struct ssh_rportfwd
*pf
;
8798 if (ssh
->v1_cipher_ctx
)
8799 ssh
->cipher
->free_context(ssh
->v1_cipher_ctx
);
8800 if (ssh
->cs_cipher_ctx
)
8801 ssh
->cscipher
->free_context(ssh
->cs_cipher_ctx
);
8802 if (ssh
->sc_cipher_ctx
)
8803 ssh
->sccipher
->free_context(ssh
->sc_cipher_ctx
);
8804 if (ssh
->cs_mac_ctx
)
8805 ssh
->csmac
->free_context(ssh
->cs_mac_ctx
);
8806 if (ssh
->sc_mac_ctx
)
8807 ssh
->scmac
->free_context(ssh
->sc_mac_ctx
);
8808 if (ssh
->cs_comp_ctx
) {
8810 ssh
->cscomp
->compress_cleanup(ssh
->cs_comp_ctx
);
8812 zlib_compress_cleanup(ssh
->cs_comp_ctx
);
8814 if (ssh
->sc_comp_ctx
) {
8816 ssh
->sccomp
->decompress_cleanup(ssh
->sc_comp_ctx
);
8818 zlib_decompress_cleanup(ssh
->sc_comp_ctx
);
8821 dh_cleanup(ssh
->kex_ctx
);
8822 sfree(ssh
->savedhost
);
8824 while (ssh
->queuelen
-- > 0)
8825 ssh_free_packet(ssh
->queue
[ssh
->queuelen
]);
8828 while (ssh
->qhead
) {
8829 struct queued_handler
*qh
= ssh
->qhead
;
8830 ssh
->qhead
= qh
->next
;
8833 ssh
->qhead
= ssh
->qtail
= NULL
;
8835 if (ssh
->channels
) {
8836 while ((c
= delpos234(ssh
->channels
, 0)) != NULL
) {
8839 if (c
->u
.x11
.s
!= NULL
)
8840 x11_close(c
->u
.x11
.s
);
8843 if (c
->u
.pfd
.s
!= NULL
)
8844 pfd_close(c
->u
.pfd
.s
);
8849 freetree234(ssh
->channels
);
8850 ssh
->channels
= NULL
;
8853 if (ssh
->rportfwds
) {
8854 while ((pf
= delpos234(ssh
->rportfwds
, 0)) != NULL
)
8856 freetree234(ssh
->rportfwds
);
8857 ssh
->rportfwds
= NULL
;
8859 sfree(ssh
->deferred_send_data
);
8861 x11_free_auth(ssh
->x11auth
);
8862 sfree(ssh
->do_ssh_init_state
);
8863 sfree(ssh
->do_ssh1_login_state
);
8864 sfree(ssh
->do_ssh2_transport_state
);
8865 sfree(ssh
->do_ssh2_authconn_state
);
8868 if (ssh
->crcda_ctx
) {
8869 crcda_free_context(ssh
->crcda_ctx
);
8870 ssh
->crcda_ctx
= NULL
;
8873 ssh_do_close(ssh
, TRUE
);
8874 expire_timer_context(ssh
);
8876 pinger_free(ssh
->pinger
);
8877 bufchain_clear(&ssh
->queued_incoming_data
);
8884 * Reconfigure the SSH backend.
8886 static void ssh_reconfig(void *handle
, Config
*cfg
)
8888 Ssh ssh
= (Ssh
) handle
;
8889 char *rekeying
= NULL
, rekey_mandatory
= FALSE
;
8890 unsigned long old_max_data_size
;
8892 pinger_reconfig(ssh
->pinger
, &ssh
->cfg
, cfg
);
8894 ssh_setup_portfwd(ssh
, cfg
);
8896 if (ssh
->cfg
.ssh_rekey_time
!= cfg
->ssh_rekey_time
&&
8897 cfg
->ssh_rekey_time
!= 0) {
8898 long new_next
= ssh
->last_rekey
+ cfg
->ssh_rekey_time
*60*TICKSPERSEC
;
8899 long now
= GETTICKCOUNT();
8901 if (new_next
- now
< 0) {
8902 rekeying
= "timeout shortened";
8904 ssh
->next_rekey
= schedule_timer(new_next
- now
, ssh2_timer
, ssh
);
8908 old_max_data_size
= ssh
->max_data_size
;
8909 ssh
->max_data_size
= parse_blocksize(cfg
->ssh_rekey_data
);
8910 if (old_max_data_size
!= ssh
->max_data_size
&&
8911 ssh
->max_data_size
!= 0) {
8912 if (ssh
->outgoing_data_size
> ssh
->max_data_size
||
8913 ssh
->incoming_data_size
> ssh
->max_data_size
)
8914 rekeying
= "data limit lowered";
8917 if (ssh
->cfg
.compression
!= cfg
->compression
) {
8918 rekeying
= "compression setting changed";
8919 rekey_mandatory
= TRUE
;
8922 if (ssh
->cfg
.ssh2_des_cbc
!= cfg
->ssh2_des_cbc
||
8923 memcmp(ssh
->cfg
.ssh_cipherlist
, cfg
->ssh_cipherlist
,
8924 sizeof(ssh
->cfg
.ssh_cipherlist
))) {
8925 rekeying
= "cipher settings changed";
8926 rekey_mandatory
= TRUE
;
8929 ssh
->cfg
= *cfg
; /* STRUCTURE COPY */
8932 if (!ssh
->kex_in_progress
) {
8933 do_ssh2_transport(ssh
, rekeying
, -1, NULL
);
8934 } else if (rekey_mandatory
) {
8935 ssh
->deferred_rekey_reason
= rekeying
;
8941 * Called to send data down the SSH connection.
8943 static int ssh_send(void *handle
, char *buf
, int len
)
8945 Ssh ssh
= (Ssh
) handle
;
8947 if (ssh
== NULL
|| ssh
->s
== NULL
|| ssh
->protocol
== NULL
)
8950 ssh
->protocol(ssh
, (unsigned char *)buf
, len
, 0);
8952 return ssh_sendbuffer(ssh
);
8956 * Called to query the current amount of buffered stdin data.
8958 static int ssh_sendbuffer(void *handle
)
8960 Ssh ssh
= (Ssh
) handle
;
8963 if (ssh
== NULL
|| ssh
->s
== NULL
|| ssh
->protocol
== NULL
)
8967 * If the SSH socket itself has backed up, add the total backup
8968 * size on that to any individual buffer on the stdin channel.
8971 if (ssh
->throttled_all
)
8972 override_value
= ssh
->overall_bufsize
;
8974 if (ssh
->version
== 1) {
8975 return override_value
;
8976 } else if (ssh
->version
== 2) {
8977 if (!ssh
->mainchan
|| ssh
->mainchan
->closes
> 0)
8978 return override_value
;
8980 return (override_value
+
8981 bufchain_size(&ssh
->mainchan
->v
.v2
.outbuffer
));
8988 * Called to set the size of the window from SSH's POV.
8990 static void ssh_size(void *handle
, int width
, int height
)
8992 Ssh ssh
= (Ssh
) handle
;
8993 struct Packet
*pktout
;
8995 ssh
->term_width
= width
;
8996 ssh
->term_height
= height
;
8998 switch (ssh
->state
) {
8999 case SSH_STATE_BEFORE_SIZE
:
9000 case SSH_STATE_PREPACKET
:
9001 case SSH_STATE_CLOSED
:
9002 break; /* do nothing */
9003 case SSH_STATE_INTERMED
:
9004 ssh
->size_needed
= TRUE
; /* buffer for later */
9006 case SSH_STATE_SESSION
:
9007 if (!ssh
->cfg
.nopty
) {
9008 if (ssh
->version
== 1) {
9009 send_packet(ssh
, SSH1_CMSG_WINDOW_SIZE
,
9010 PKT_INT
, ssh
->term_height
,
9011 PKT_INT
, ssh
->term_width
,
9012 PKT_INT
, 0, PKT_INT
, 0, PKT_END
);
9013 } else if (ssh
->mainchan
) {
9014 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9015 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
9016 ssh2_pkt_addstring(pktout
, "window-change");
9017 ssh2_pkt_addbool(pktout
, 0);
9018 ssh2_pkt_adduint32(pktout
, ssh
->term_width
);
9019 ssh2_pkt_adduint32(pktout
, ssh
->term_height
);
9020 ssh2_pkt_adduint32(pktout
, 0);
9021 ssh2_pkt_adduint32(pktout
, 0);
9022 ssh2_pkt_send(ssh
, pktout
);
9030 * Return a list of the special codes that make sense in this
9033 static const struct telnet_special
*ssh_get_specials(void *handle
)
9035 static const struct telnet_special ssh1_ignore_special
[] = {
9036 {"IGNORE message", TS_NOP
}
9038 static const struct telnet_special ssh2_transport_specials
[] = {
9039 {"IGNORE message", TS_NOP
},
9040 {"Repeat key exchange", TS_REKEY
},
9042 static const struct telnet_special ssh2_session_specials
[] = {
9045 /* These are the signal names defined by draft-ietf-secsh-connect-23.
9046 * They include all the ISO C signals, but are a subset of the POSIX
9047 * required signals. */
9048 {"SIGINT (Interrupt)", TS_SIGINT
},
9049 {"SIGTERM (Terminate)", TS_SIGTERM
},
9050 {"SIGKILL (Kill)", TS_SIGKILL
},
9051 {"SIGQUIT (Quit)", TS_SIGQUIT
},
9052 {"SIGHUP (Hangup)", TS_SIGHUP
},
9053 {"More signals", TS_SUBMENU
},
9054 {"SIGABRT", TS_SIGABRT
}, {"SIGALRM", TS_SIGALRM
},
9055 {"SIGFPE", TS_SIGFPE
}, {"SIGILL", TS_SIGILL
},
9056 {"SIGPIPE", TS_SIGPIPE
}, {"SIGSEGV", TS_SIGSEGV
},
9057 {"SIGUSR1", TS_SIGUSR1
}, {"SIGUSR2", TS_SIGUSR2
},
9060 static const struct telnet_special specials_end
[] = {
9063 /* XXX review this length for any changes: */
9064 static struct telnet_special ssh_specials
[lenof(ssh2_transport_specials
) +
9065 lenof(ssh2_session_specials
) +
9066 lenof(specials_end
)];
9067 Ssh ssh
= (Ssh
) handle
;
9069 #define ADD_SPECIALS(name) \
9071 assert((i + lenof(name)) <= lenof(ssh_specials)); \
9072 memcpy(&ssh_specials[i], name, sizeof name); \
9076 if (ssh
->version
== 1) {
9077 /* Don't bother offering IGNORE if we've decided the remote
9078 * won't cope with it, since we wouldn't bother sending it if
9080 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
))
9081 ADD_SPECIALS(ssh1_ignore_special
);
9082 } else if (ssh
->version
== 2) {
9083 ADD_SPECIALS(ssh2_transport_specials
);
9085 ADD_SPECIALS(ssh2_session_specials
);
9086 } /* else we're not ready yet */
9089 ADD_SPECIALS(specials_end
);
9090 return ssh_specials
;
9098 * Send special codes. TS_EOF is useful for `plink', so you
9099 * can send an EOF and collect resulting output (e.g. `plink
9102 static void ssh_special(void *handle
, Telnet_Special code
)
9104 Ssh ssh
= (Ssh
) handle
;
9105 struct Packet
*pktout
;
9107 if (code
== TS_EOF
) {
9108 if (ssh
->state
!= SSH_STATE_SESSION
) {
9110 * Buffer the EOF in case we are pre-SESSION, so we can
9111 * send it as soon as we reach SESSION.
9114 ssh
->eof_needed
= TRUE
;
9117 if (ssh
->version
== 1) {
9118 send_packet(ssh
, SSH1_CMSG_EOF
, PKT_END
);
9119 } else if (ssh
->mainchan
) {
9120 struct Packet
*pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_EOF
);
9121 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
9122 ssh2_pkt_send(ssh
, pktout
);
9123 ssh
->send_ok
= 0; /* now stop trying to read from stdin */
9125 logevent("Sent EOF message");
9126 } else if (code
== TS_PING
|| code
== TS_NOP
) {
9127 if (ssh
->state
== SSH_STATE_CLOSED
9128 || ssh
->state
== SSH_STATE_PREPACKET
) return;
9129 if (ssh
->version
== 1) {
9130 if (!(ssh
->remote_bugs
& BUG_CHOKES_ON_SSH1_IGNORE
))
9131 send_packet(ssh
, SSH1_MSG_IGNORE
, PKT_STR
, "", PKT_END
);
9133 pktout
= ssh2_pkt_init(SSH2_MSG_IGNORE
);
9134 ssh2_pkt_addstring_start(pktout
);
9135 ssh2_pkt_send_noqueue(ssh
, pktout
);
9137 } else if (code
== TS_REKEY
) {
9138 if (!ssh
->kex_in_progress
&& ssh
->version
== 2) {
9139 do_ssh2_transport(ssh
, "at user request", -1, NULL
);
9141 } else if (code
== TS_BRK
) {
9142 if (ssh
->state
== SSH_STATE_CLOSED
9143 || ssh
->state
== SSH_STATE_PREPACKET
) return;
9144 if (ssh
->version
== 1) {
9145 logevent("Unable to send BREAK signal in SSH-1");
9146 } else if (ssh
->mainchan
) {
9147 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9148 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
9149 ssh2_pkt_addstring(pktout
, "break");
9150 ssh2_pkt_addbool(pktout
, 0);
9151 ssh2_pkt_adduint32(pktout
, 0); /* default break length */
9152 ssh2_pkt_send(ssh
, pktout
);
9155 /* Is is a POSIX signal? */
9156 char *signame
= NULL
;
9157 if (code
== TS_SIGABRT
) signame
= "ABRT";
9158 if (code
== TS_SIGALRM
) signame
= "ALRM";
9159 if (code
== TS_SIGFPE
) signame
= "FPE";
9160 if (code
== TS_SIGHUP
) signame
= "HUP";
9161 if (code
== TS_SIGILL
) signame
= "ILL";
9162 if (code
== TS_SIGINT
) signame
= "INT";
9163 if (code
== TS_SIGKILL
) signame
= "KILL";
9164 if (code
== TS_SIGPIPE
) signame
= "PIPE";
9165 if (code
== TS_SIGQUIT
) signame
= "QUIT";
9166 if (code
== TS_SIGSEGV
) signame
= "SEGV";
9167 if (code
== TS_SIGTERM
) signame
= "TERM";
9168 if (code
== TS_SIGUSR1
) signame
= "USR1";
9169 if (code
== TS_SIGUSR2
) signame
= "USR2";
9170 /* The SSH-2 protocol does in principle support arbitrary named
9171 * signals, including signame@domain, but we don't support those. */
9173 /* It's a signal. */
9174 if (ssh
->version
== 2 && ssh
->mainchan
) {
9175 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_REQUEST
);
9176 ssh2_pkt_adduint32(pktout
, ssh
->mainchan
->remoteid
);
9177 ssh2_pkt_addstring(pktout
, "signal");
9178 ssh2_pkt_addbool(pktout
, 0);
9179 ssh2_pkt_addstring(pktout
, signame
);
9180 ssh2_pkt_send(ssh
, pktout
);
9181 logeventf(ssh
, "Sent signal SIG%s", signame
);
9184 /* Never heard of it. Do nothing */
9189 void *new_sock_channel(void *handle
, Socket s
)
9191 Ssh ssh
= (Ssh
) handle
;
9192 struct ssh_channel
*c
;
9193 c
= snew(struct ssh_channel
);
9198 c
->localid
= alloc_channel_id(ssh
);
9200 c
->type
= CHAN_SOCKDATA_DORMANT
;/* identify channel type */
9202 bufchain_init(&c
->v
.v2
.outbuffer
);
9203 add234(ssh
->channels
, c
);
9209 * This is called when stdout/stderr (the entity to which
9210 * from_backend sends data) manages to clear some backlog.
9212 static void ssh_unthrottle(void *handle
, int bufsize
)
9214 Ssh ssh
= (Ssh
) handle
;
9215 if (ssh
->version
== 1) {
9216 if (ssh
->v1_stdout_throttling
&& bufsize
< SSH1_BUFFER_LIMIT
) {
9217 ssh
->v1_stdout_throttling
= 0;
9218 ssh1_throttle(ssh
, -1);
9222 ssh2_set_window(ssh
->mainchan
,
9223 ssh
->mainchan
->v
.v2
.locmaxwin
- bufsize
);
9227 void ssh_send_port_open(void *channel
, char *hostname
, int port
, char *org
)
9229 struct ssh_channel
*c
= (struct ssh_channel
*)channel
;
9231 struct Packet
*pktout
;
9233 logeventf(ssh
, "Opening forwarded connection to %s:%d", hostname
, port
);
9235 if (ssh
->version
== 1) {
9236 send_packet(ssh
, SSH1_MSG_PORT_OPEN
,
9237 PKT_INT
, c
->localid
,
9240 /* PKT_STR, <org:orgport>, */
9243 pktout
= ssh2_pkt_init(SSH2_MSG_CHANNEL_OPEN
);
9244 ssh2_pkt_addstring(pktout
, "direct-tcpip");
9245 ssh2_pkt_adduint32(pktout
, c
->localid
);
9246 c
->v
.v2
.locwindow
= c
->v
.v2
.locmaxwin
= OUR_V2_WINSIZE
;
9247 c
->v
.v2
.remlocwin
= OUR_V2_WINSIZE
;
9248 c
->v
.v2
.winadj_head
= c
->v
.v2
.winadj_head
= NULL
;
9249 c
->v
.v2
.throttle_state
= UNTHROTTLED
;
9250 ssh2_pkt_adduint32(pktout
, c
->v
.v2
.locwindow
);/* our window size */
9251 ssh2_pkt_adduint32(pktout
, OUR_V2_MAXPKT
); /* our max pkt size */
9252 ssh2_pkt_addstring(pktout
, hostname
);
9253 ssh2_pkt_adduint32(pktout
, port
);
9255 * We make up values for the originator data; partly it's
9256 * too much hassle to keep track, and partly I'm not
9257 * convinced the server should be told details like that
9258 * about my local network configuration.
9259 * The "originator IP address" is syntactically a numeric
9260 * IP address, and some servers (e.g., Tectia) get upset
9261 * if it doesn't match this syntax.
9263 ssh2_pkt_addstring(pktout
, "0.0.0.0");
9264 ssh2_pkt_adduint32(pktout
, 0);
9265 ssh2_pkt_send(ssh
, pktout
);
9269 static int ssh_connected(void *handle
)
9271 Ssh ssh
= (Ssh
) handle
;
9272 return ssh
->s
!= NULL
;
9275 static int ssh_sendok(void *handle
)
9277 Ssh ssh
= (Ssh
) handle
;
9278 return ssh
->send_ok
;
9281 static int ssh_ldisc(void *handle
, int option
)
9283 Ssh ssh
= (Ssh
) handle
;
9284 if (option
== LD_ECHO
)
9285 return ssh
->echoing
;
9286 if (option
== LD_EDIT
)
9287 return ssh
->editing
;
9291 static void ssh_provide_ldisc(void *handle
, void *ldisc
)
9293 Ssh ssh
= (Ssh
) handle
;
9297 static void ssh_provide_logctx(void *handle
, void *logctx
)
9299 Ssh ssh
= (Ssh
) handle
;
9300 ssh
->logctx
= logctx
;
9303 static int ssh_return_exitcode(void *handle
)
9305 Ssh ssh
= (Ssh
) handle
;
9309 return (ssh
->exitcode
>= 0 ? ssh
->exitcode
: INT_MAX
);
9313 * cfg_info for SSH is the currently running version of the
9314 * protocol. (1 for 1; 2 for 2; 0 for not-decided-yet.)
9316 static int ssh_cfg_info(void *handle
)
9318 Ssh ssh
= (Ssh
) handle
;
9319 return ssh
->version
;
9323 * Gross hack: pscp will try to start SFTP but fall back to scp1 if
9324 * that fails. This variable is the means by which scp.c can reach
9325 * into the SSH code and find out which one it got.
9327 extern int ssh_fallback_cmd(void *handle
)
9329 Ssh ssh
= (Ssh
) handle
;
9330 return ssh
->fallback_cmd
;
9333 Backend ssh_backend
= {
9343 ssh_return_exitcode
,