Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/ssh.h

Contents of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/ssh.h

Parent Directory Parent Directory | Revision Log Revision Log

Revision 9210 - (show annotations) (download) (as text)
Sat Apr 17 08:36:59 2021 UTC (2 years, 10 months ago) by nmaya
File MIME type: text/x-chdr
File size: 21752 byte(s) 
ファイルを分割・コードを移動・関数名を整理・新しい OpenSSH からインポート

- OpenSSH からインポート
  cipher-3des1.c from OpenSSH-7.5p1
  ssherr.c from OpenSSH-8.5p1
  ssherr.h from OpenSSH-8.5p1
1 /*
2 * Copyright (c) 1998-2001, Robert O'Callahan
3 * (C) 2004- TeraTerm Project
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 This code is copyright (C) 1998-1999 Robert O'Callahan.
32 See LICENSE.TXT for the license.
33 */
34
35 #ifndef __SSH_H
36 #define __SSH_H
37
38 #include "zlib.h"
39 #include <openssl/evp.h>
40
41 #include "buffer.h"
42 #include "config.h"
43 #include "cipher.h"
44 #include "hostkey.h"
45 #include "mac.h"
46 #include "comp.h"
47 #include <sys/types.h>
48 #include <sys/stat.h>
49
50 #define DEBUG_PRINT_TO_FILE(base, msg, len) { \
51 static int count = 0; \
52 debug_print(count + base, msg, len); \
53 count++; \
54 }
55
56 // from OpenSSH
57 extern const EVP_CIPHER *evp_aes_128_ctr(void);
58 extern const EVP_CIPHER *evp_des3_ctr(void);
59 extern const EVP_CIPHER *evp_bf_ctr(void);
60 extern const EVP_CIPHER *evp_cast5_ctr(void);
61 extern const EVP_CIPHER *evp_camellia_128_ctr(void);
62
63 /* Some of this code has been adapted from Ian Goldberg's Pilot SSH */
64
65 typedef enum {
66 SSH_MSG_NONE, SSH_MSG_DISCONNECT, SSH_SMSG_PUBLIC_KEY, //2
67 SSH_CMSG_SESSION_KEY, SSH_CMSG_USER, SSH_CMSG_AUTH_RHOSTS, // 5
68 SSH_CMSG_AUTH_RSA, SSH_SMSG_AUTH_RSA_CHALLENGE,
69 SSH_CMSG_AUTH_RSA_RESPONSE, SSH_CMSG_AUTH_PASSWORD,
70 SSH_CMSG_REQUEST_PTY, // 10
71 SSH_CMSG_WINDOW_SIZE, SSH_CMSG_EXEC_SHELL,
72 SSH_CMSG_EXEC_CMD, SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE,
73 SSH_CMSG_STDIN_DATA, SSH_SMSG_STDOUT_DATA, SSH_SMSG_STDERR_DATA,
74 SSH_CMSG_EOF, SSH_SMSG_EXITSTATUS,
75 SSH_MSG_CHANNEL_OPEN_CONFIRMATION, SSH_MSG_CHANNEL_OPEN_FAILURE,
76 SSH_MSG_CHANNEL_DATA, SSH_MSG_CHANNEL_INPUT_EOF,
77 SSH_MSG_CHANNEL_OUTPUT_CLOSED, SSH_MSG_OBSOLETED0,
78 SSH_SMSG_X11_OPEN, SSH_CMSG_PORT_FORWARD_REQUEST, SSH_MSG_PORT_OPEN,
79 SSH_CMSG_AGENT_REQUEST_FORWARDING, SSH_SMSG_AGENT_OPEN,
80 SSH_MSG_IGNORE, SSH_CMSG_EXIT_CONFIRMATION,
81 SSH_CMSG_X11_REQUEST_FORWARDING, SSH_CMSG_AUTH_RHOSTS_RSA,
82 SSH_MSG_DEBUG, SSH_CMSG_REQUEST_COMPRESSION,
83 SSH_CMSG_MAX_PACKET_SIZE, SSH_CMSG_AUTH_TIS,
84 SSH_SMSG_AUTH_TIS_CHALLENGE, SSH_CMSG_AUTH_TIS_RESPONSE,
85 SSH_CMSG_AUTH_KERBEROS, SSH_SMSG_AUTH_KERBEROS_RESPONSE
86 } SSHMessage;
87
88 typedef enum {
89 SSH_AUTH_NONE, SSH_AUTH_RHOSTS, SSH_AUTH_RSA, SSH_AUTH_PASSWORD,
90 SSH_AUTH_RHOSTS_RSA, SSH_AUTH_TIS, SSH_AUTH_KERBEROS,
91 SSH_AUTH_PAGEANT = 16,
92 SSH_AUTH_MAX = SSH_AUTH_PAGEANT,
93 } SSHAuthMethod;
94
95 typedef enum {
96 SSH_GENERIC_AUTHENTICATION, SSH_TIS_AUTHENTICATION
97 } SSHAuthMode;
98
99 #define SSH_PROTOFLAG_SCREEN_NUMBER 1
100 #define SSH_PROTOFLAG_HOST_IN_FWD_OPEN 2
101
102 enum channel_type {
103 TYPE_SHELL, TYPE_PORTFWD, TYPE_SCP, TYPE_SFTP, TYPE_AGENT, TYPE_SUBSYSTEM_GEN,
104 };
105
106 // for SSH1
107 #define SSH_MAX_SEND_PACKET_SIZE 250000
108
109 // for SSH2
110 /* default window/packet sizes for tcp/x11-fwd-channel */
111 // changed CHAN_SES_WINDOW_DEFAULT from 32KB to 128KB. (2007.10.29 maya)
112 #define CHAN_SES_PACKET_DEFAULT (32*1024)
113 #define CHAN_SES_WINDOW_DEFAULT (4*CHAN_SES_PACKET_DEFAULT)
114 #define CHAN_TCP_PACKET_DEFAULT (32*1024)
115 #define CHAN_TCP_WINDOW_DEFAULT (4*CHAN_TCP_PACKET_DEFAULT)
116 #if 0 // unused
117 #define CHAN_X11_PACKET_DEFAULT (16*1024)
118 #define CHAN_X11_WINDOW_DEFAULT (4*CHAN_X11_PACKET_DEFAULT)
119 #endif
120
121
122 /* SSH2 constants */
123 #define SSH_CHANNEL_INVALID -1
124
125 /* SSH2 messages */
126 typedef enum {
127 // Transport layer protocol
128 // 1..19 Transport layer generic (RFC 4253)
129 SSH2_MSG_DISCONNECT = 1,
130 SSH2_MSG_IGNORE = 2,
131 SSH2_MSG_UNIMPLEMENTED = 3,
132 SSH2_MSG_DEBUG = 4,
133 SSH2_MSG_SERVICE_REQUEST = 5,
134 SSH2_MSG_SERVICE_ACCEPT = 6,
135
136 // 20..29 Algorithm negotiation (RFC 4253)
137 SSH2_MSG_KEXINIT = 20,
138 SSH2_MSG_NEWKEYS = 21,
139
140 // 30..49 Key excahnge method specific
141 // Diffie-Hellman Key Exchange (RFC 4253)
142 SSH2_MSG_KEXDH_INIT = 30,
143 SSH2_MSG_KEXDH_REPLY = 31,
144
145 // RFC 4419 - Diffie-Hellman Group Exchange for the Secure Shell (SSH) Transport Layer Protocol
146 SSH2_MSG_KEX_DH_GEX_GROUP = 31,
147 SSH2_MSG_KEX_DH_GEX_INIT = 32,
148 SSH2_MSG_KEX_DH_GEX_REPLY = 33,
149 SSH2_MSG_KEX_DH_GEX_REQUEST = 34,
150
151 // RFC 5656 - Elliptic Curve Algorithm Integration in the Secure Shell Transport Layer
152 SSH2_MSG_KEX_ECDH_INIT = 30,
153 SSH2_MSG_KEX_ECDH_REPLY = 31,
154
155 // User authentication protocol
156 // 50..59 User authentication generic (RFC 4252)
157 SSH2_MSG_USERAUTH_REQUEST = 50,
158 SSH2_MSG_USERAUTH_FAILURE = 51,
159 SSH2_MSG_USERAUTH_SUCCESS = 52,
160 SSH2_MSG_USERAUTH_BANNER = 53,
161
162 // Public key authentication (RFC 4252)
163 SSH2_MSG_USERAUTH_PK_OK = 60,
164
165 // Password authentication (RFC 4252)
166 SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ = 60,
167
168 // RFC 4256 - Generic Message Exchange Authentication for the Secure Shell Protocol (SSH)
169 // Keyboard-interactive authentication
170 SSH2_MSG_USERAUTH_INFO_REQUEST = 60,
171 SSH2_MSG_USERAUTH_INFO_RESPONSE = 61,
172
173 // Connection protocol
174 // 80..89 Connection protocol generic (RFC 4254)
175 SSH2_MSG_GLOBAL_REQUEST = 80,
176 SSH2_MSG_REQUEST_SUCCESS = 81,
177 SSH2_MSG_REQUEST_FAILURE = 82,
178
179 // 90..127 Channel related messages (RFC 4254)
180 SSH2_MSG_CHANNEL_OPEN = 90,
181 SSH2_MSG_CHANNEL_OPEN_CONFIRMATION = 91,
182 SSH2_MSG_CHANNEL_OPEN_FAILURE = 92,
183 SSH2_MSG_CHANNEL_WINDOW_ADJUST = 93,
184 SSH2_MSG_CHANNEL_DATA = 94,
185 SSH2_MSG_CHANNEL_EXTENDED_DATA = 95,
186 SSH2_MSG_CHANNEL_EOF = 96,
187 SSH2_MSG_CHANNEL_CLOSE = 97,
188 SSH2_MSG_CHANNEL_REQUEST = 98,
189 SSH2_MSG_CHANNEL_SUCCESS = 99,
190 SSH2_MSG_CHANNEL_FAILURE = 100
191
192 // Reserved for client protocols
193 // 128..191 Reserved
194
195 // Local extensions:
196 // 192..255 Local extensions
197
198 } SSH2Message;
199
200 /* SSH2 miscellaneous constants */
201 typedef enum {
202 SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT = 1,
203 SSH2_DISCONNECT_PROTOCOL_ERROR,
204 SSH2_DISCONNECT_KEY_EXCHANGE_FAILED,
205 SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED,
206 SSH2_DISCONNECT_MAC_ERROR,
207 SSH2_DISCONNECT_COMPRESSION_ERROR,
208 SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE,
209 SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED,
210 SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE,
211 SSH2_DISCONNECT_CONNECTION_LOST,
212 SSH2_DISCONNECT_BY_APPLICATION,
213 SSH2_DISCONNECT_TOO_MANY_CONNECTIONS,
214 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
215 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
216 SSH2_DISCONNECT_ILLEGAL_USER_NAME
217 } SSH2DisconnectMessage;
218
219 typedef enum {
220 SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED = 1,
221 SSH2_OPEN_CONNECT_FAILED,
222 SSH2_OPEN_UNKNOWN_CHANNEL_TYPE,
223 SSH2_OPEN_RESOURCE_SHORTAGE
224 } SSH2ChannelFailReason;
225
226 // Terminal Modes
227 typedef enum {
228 SSH2_TTY_OP_END = 0,
229 SSH2_TTY_KEY_VINTR = 1,
230 SSH2_TTY_KEY_VQUIT = 2,
231 SSH2_TTY_KEY_VERASE = 3,
232 SSH2_TTY_KEY_VKILL = 4,
233 SSH2_TTY_KEY_VEOF = 5,
234 SSH2_TTY_KEY_VEOL = 6,
235 SSH2_TTY_KEY_VEOL2 = 7,
236 SSH2_TTY_KEY_VSTART = 8,
237 SSH2_TTY_KEY_VSTOP = 9,
238 SSH2_TTY_KEY_VSUSP = 10,
239 SSH2_TTY_KEY_VDSUSP = 11,
240 SSH2_TTY_KEY_VREPRINT = 12,
241 SSH2_TTY_KEY_VWERASE = 13,
242 SSH2_TTY_KEY_VLNEXT = 14,
243 SSH2_TTY_KEY_VFLUSH = 15,
244 SSH2_TTY_KEY_VSWTCH = 16,
245 SSH2_TTY_KEY_VSTATUS = 17,
246 SSH2_TTY_KEY_VDISCARD = 18,
247 SSH2_TTY_OP_IGNPAR = 30,
248 SSH2_TTY_OP_PARMRK = 31,
249 SSH2_TTY_OP_INPCK = 32,
250 SSH2_TTY_OP_ISTRIP = 33,
251 SSH2_TTY_OP_INLCR = 34,
252 SSH2_TTY_OP_IGNCR = 35,
253 SSH2_TTY_OP_ICRNL = 36,
254 SSH2_TTY_OP_IUCLC = 37,
255 SSH2_TTY_OP_IXON = 38,
256 SSH2_TTY_OP_IXANY = 39,
257 SSH2_TTY_OP_IXOFF = 40,
258 SSH2_TTY_OP_IMAXBEL = 41,
259 SSH2_TTY_OP_ISIG = 50,
260 SSH2_TTY_OP_ICANON = 51,
261 SSH2_TTY_OP_XCASE = 52,
262 SSH2_TTY_OP_ECHO = 53,
263 SSH2_TTY_OP_ECHOE = 54,
264 SSH2_TTY_OP_ECHOK = 55,
265 SSH2_TTY_OP_ECHONL = 56,
266 SSH2_TTY_OP_NOFLSH = 57,
267 SSH2_TTY_OP_TOSTOP = 58,
268 SSH2_TTY_OP_IEXTEN = 59,
269 SSH2_TTY_OP_ECHOCTL = 60,
270 SSH2_TTY_OP_ECHOKE = 61,
271 SSH2_TTY_OP_PENDIN = 62,
272 SSH2_TTY_OP_OPOST = 70,
273 SSH2_TTY_OP_OLCUC = 71,
274 SSH2_TTY_OP_ONLCR = 72,
275 SSH2_TTY_OP_OCRNL = 73,
276 SSH2_TTY_OP_ONOCR = 74,
277 SSH2_TTY_OP_ONLRET = 75,
278 SSH2_TTY_OP_CS7 = 90,
279 SSH2_TTY_OP_CS8 = 91,
280 SSH2_TTY_OP_PARENB = 92,
281 SSH2_TTY_OP_PARODD = 93,
282 SSH2_TTY_OP_ISPEED = 128,
283 SSH2_TTY_OP_OSPEED = 129
284 } SSH2TTYMode;
285
286
287 #define isFixedLengthKey(type) ((type) >= KEY_DSA && (type) <= KEY_ED25519)
288
289 /* Minimum modulus size (n) for RSA keys. */
290 #define SSH_RSA_MINIMUM_MODULUS_SIZE 768
291
292 #define SSH_KEYGEN_DEFAULT_BITS 2048
293 #define SSH_RSA_MINIMUM_KEY_SIZE 768
294 #define SSH_DSA_MINIMUM_KEY_SIZE 1024
295
296 #define SSH_KEYGEN_MINIMUM_ROUNDS 1
297 #define SSH_KEYGEN_MAXIMUM_ROUNDS INT_MAX
298
299
300 struct Enc {
301 u_char *key;
302 u_char *iv;
303 unsigned int key_len;
304 unsigned int block_size;
305 unsigned int iv_len;
306 unsigned int auth_len;
307 };
308
309 struct Mac {
310 char *name;
311 int enabled;
312 const EVP_MD *md;
313 unsigned int mac_len;
314 u_char *key;
315 unsigned int key_len;
316 int etm;
317 };
318
319 struct Comp {
320 int type;
321 int enabled;
322 char *name;
323 };
324
325 typedef struct {
326 struct Enc enc;
327 struct Mac mac;
328 struct Comp comp;
329 } SSHKeys;
330
331 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
332
333 enum kex_modes {
334 MODE_IN,
335 MODE_OUT,
336 MODE_MAX
337 };
338
339
340 // �z�X�g�L�[(SSH1, SSH2����)���f�[�^�\�� (2006.3.21 yutaka)
341 typedef struct Key {
342 // host key type
343 ssh_keytype type;
344 // SSH2 RSA
345 RSA *rsa;
346 // SSH2 DSA
347 DSA *dsa;
348 // SSH2 ECDSA
349 EC_KEY *ecdsa;
350 // SSH1 RSA
351 int bits;
352 unsigned char *exp;
353 unsigned char *mod;
354 // SSH2 ED25519
355 unsigned char *ed25519_sk;
356 unsigned char *ed25519_pk;
357 int bcrypt_kdf;
358 } Key;
359
360
361 enum scp_dir {
362 TOREMOTE, FROMREMOTE,
363 };
364
365 /* The packet handler returns TRUE to keep the handler in place,
366 FALSE to remove the handler. */
367 typedef BOOL (* SSHPacketHandler)(PTInstVar pvar);
368
369 typedef struct _SSHPacketHandlerItem SSHPacketHandlerItem;
370 struct _SSHPacketHandlerItem {
371 SSHPacketHandler handler;
372 /* Circular list of handlers for given message */
373 SSHPacketHandlerItem *next_for_message;
374 SSHPacketHandlerItem *last_for_message;
375 /* Circular list of handlers in set */
376 SSHPacketHandlerItem *next_in_set;
377 int active_for_message;
378 };
379
380 typedef struct {
381 char *hostname;
382
383 int server_protocol_flags;
384 char *server_ID;
385
386 /* This buffer is used to hold the outgoing data, and encrypted in-place
387 here if necessary. */
388 unsigned char *outbuf;
389 long outbuflen;
390 /* This buffer is used by the SSH protocol processing to store uncompressed
391 packet data for compression. User data is never streamed through here;
392 it is compressed directly from the user's buffer. */
393 unsigned char *precompress_outbuf;
394 long precompress_outbuflen;
395 /* this is the length of the packet data, including the type header */
396 long outgoing_packet_len;
397
398 /* This buffer is used by the SSH protocol processing to store decompressed
399 packet data. User data is never streamed through here; it is decompressed
400 directly to the user's buffer. */
401 unsigned char *postdecompress_inbuf;
402 long postdecompress_inbuflen;
403
404 unsigned char *payload;
405 long payload_grabbed;
406 long payloadlen;
407 long payload_datastart;
408 long payload_datalen;
409
410 uint32 receiver_sequence_number;
411 uint32 sender_sequence_number;
412
413 z_stream compress_stream;
414 z_stream decompress_stream;
415 BOOL compressing;
416 BOOL decompressing;
417 int compression_level;
418
419 SSHPacketHandlerItem *packet_handlers[256];
420 int status_flags;
421
422 int win_cols;
423 int win_rows;
424
425 unsigned short tcpport;
426 } SSHState;
427
428 #define STATUS_DONT_SEND_USER_NAME 0x01
429 #define STATUS_EXPECTING_COMPRESSION_RESPONSE 0x02
430 #define STATUS_DONT_SEND_CREDENTIALS 0x04
431 #define STATUS_HOST_OK 0x08
432 #define STATUS_INTERACTIVE 0x10
433 #define STATUS_IN_PARTIAL_ID_STRING 0x20
434
435 void SSH_init(PTInstVar pvar);
436 void SSH_open(PTInstVar pvar);
437 void SSH_notify_disconnecting(PTInstVar pvar, char *reason);
438 /* SSH_handle_server_ID returns TRUE iff a valid ID string has been
439 received. If it returns FALSE, we need to keep looking for another
440 ID string. */
441 BOOL SSH_handle_server_ID(PTInstVar pvar, char *ID, int ID_len);
442 /* SSH_handle_packet requires NO PAYLOAD on entry.
443 'len' is the size of the packet: payload + padding (+ CRC for SSHv1)
444 'padding' is the size of the padding.
445 'data' points to the start of the packet data (the length field)
446 */
447 void SSH1_handle_packet(PTInstVar pvar, char *data, unsigned int len, unsigned int padding);
448 void SSH2_handle_packet(PTInstVar pvar, char *data, unsigned int len, unsigned int aadlen, unsigned int authlen);
449 void SSH_notify_win_size(PTInstVar pvar, int cols, int rows);
450 void SSH_notify_user_name(PTInstVar pvar);
451 void SSH_notify_cred(PTInstVar pvar);
452 void SSH_notify_host_OK(PTInstVar pvar);
453 void SSH_send(PTInstVar pvar, unsigned char const *buf, unsigned int buflen);
454 /* SSH_extract_payload returns number of bytes extracted */
455 int SSH_extract_payload(PTInstVar pvar, unsigned char *dest, int len);
456 void SSH_end(PTInstVar pvar);
457
458 void SSH_get_server_ID_info(PTInstVar pvar, char *dest, int len);
459 void SSH_get_protocol_version_info(PTInstVar pvar, char *dest, int len);
460 void SSH_get_compression_info(PTInstVar pvar, char *dest, int len);
461 void SSH_get_mac_info(PTInstVar pvar, char *dest, int len);
462
463 /* len must be <= SSH_MAX_SEND_PACKET_SIZE */
464 void SSH_channel_send(PTInstVar pvar, int channel_num,
465 uint32 remote_channel_num,
466 unsigned char *buf, int len, int retry);
467 void SSH_fail_channel_open(PTInstVar pvar, uint32 remote_channel_num);
468 void SSH_confirm_channel_open(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num);
469 void SSH_channel_output_eof(PTInstVar pvar, uint32 remote_channel_num);
470 void SSH_channel_input_eof(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num);
471 void SSH_request_forwarding(PTInstVar pvar, char *bind_address, int from_server_port,
472 char *to_local_host, int to_local_port);
473 void SSH_cancel_request_forwarding(PTInstVar pvar, char *bind_address, int from_server_port, int reply);
474 void SSH_request_X11_forwarding(PTInstVar pvar,
475 char *auth_protocol, unsigned char *auth_data, int auth_data_len, int screen_num);
476 void SSH_open_channel(PTInstVar pvar, uint32 local_channel_num,
477 char *to_remote_host, int to_remote_port,
478 char *originator, unsigned short originator_port);
479
480 int SSH_start_scp(PTInstVar pvar, char *sendfile, char *dstfile);
481 int SSH_scp_sending_status(void);
482 int SSH_start_scp_receive(PTInstVar pvar, char *filename);
483 int SSH_scp_transaction(PTInstVar pvar, char *sendfile, char *dstfile, enum scp_dir direction);
484 int SSH_sftp_transaction(PTInstVar pvar);
485
486 /* auxiliary SSH2 interfaces for pkt.c */
487 unsigned int SSH_get_min_packet_size(PTInstVar pvar);
488 /* data is guaranteed to be at least SSH_get_min_packet_size bytes long
489 at least 5 bytes must be decrypted */
490 void SSH_predecrypt_packet(PTInstVar pvar, char *data);
491 unsigned int SSH_get_clear_MAC_size(PTInstVar pvar);
492 unsigned int SSH_get_authdata_size(PTInstVar pvar, int direction);
493
494 #define SSH_is_any_payload(pvar) ((pvar)->ssh_state.payload_datalen > 0)
495 #define SSH_get_host_name(pvar) ((pvar)->ssh_state.hostname)
496 #define SSH_get_compression_level(pvar) ((pvar)->ssh_state.compressing ? (pvar)->ts_SSH_CompressionLevel : 0)
497
498 void SSH2_send_kexinit(PTInstVar pvar);
499 BOOL do_SSH2_userauth(PTInstVar pvar);
500 BOOL do_SSH2_authrequest(PTInstVar pvar);
501 void debug_print(int no, char *msg, int len);
502 void ssh_heartbeat_lock_initialize(void);
503 void ssh_heartbeat_lock_finalize(void);
504 void ssh_heartbeat_lock(void);
505 void ssh_heartbeat_unlock(void);
506 void halt_ssh_heartbeat_thread(PTInstVar pvar);
507 void ssh2_channel_free(void);
508 BOOL handle_SSH2_userauth_msg60(PTInstVar pvar);
509 BOOL handle_SSH2_userauth_inforeq(PTInstVar pvar);
510 BOOL handle_SSH2_userauth_pkok(PTInstVar pvar);
511 BOOL handle_SSH2_userauth_passwd_changereq(PTInstVar pvar);
512 int SSH_notify_break_signal(PTInstVar pvar);
513
514 ///
515 enum scp_state {
516 SCP_INIT, SCP_TIMESTAMP, SCP_FILEINFO, SCP_DATA, SCP_CLOSING,
517 };
518
519 typedef struct bufchain {
520 buffer_t *msg;
521 struct bufchain *next;
522 } bufchain_t;
523
524 typedef struct PacketList {
525 char *buf;
526 unsigned int buflen;
527 struct PacketList *next;
528 } PacketList_t;
529
530 typedef struct scp {
531 enum scp_dir dir; // transfer direction
532 enum scp_state state; // SCP state
533 char localfile[MAX_PATH]; // local filename
534 char localfilefull[MAX_PATH]; // local filename fullpath
535 char remotefile[MAX_PATH]; // remote filename
536 FILE *localfp; // file pointer for local file
537 struct __stat64 filestat; // file status information
538 HWND progress_window;
539 HANDLE thread;
540 unsigned int thread_id;
541 PTInstVar pvar;
542 // for receiving file
543 long long filetotalsize;
544 long long filercvsize;
545 DWORD filemtime;
546 DWORD fileatime;
547 PacketList_t *pktlist_head;
548 PacketList_t *pktlist_tail;
549 } scp_t;
550
551 enum sftp_state {
552 SFTP_INIT, SFTP_CONNECTED, SFTP_REALPATH,
553 };
554
555 typedef struct sftp {
556 enum sftp_state state;
557 HWND console_window;
558 unsigned int transfer_buflen;
559 unsigned int num_requests;
560 unsigned int version;
561 unsigned int msg_id;
562 #define SFTP_EXT_POSIX_RENAME 0x00000001
563 #define SFTP_EXT_STATVFS 0x00000002
564 #define SFTP_EXT_FSTATVFS 0x00000004
565 #define SFTP_EXT_HARDLINK 0x00000008
566 unsigned int exts;
567 unsigned long long limit_kbps;
568 //struct bwlimit bwlimit_in, bwlimit_out;
569 char path[1024];
570 } sftp_t;
571
572 typedef struct channel {
573 int used;
574 int self_id;
575 int remote_id;
576 unsigned int local_window;
577 unsigned int local_window_max;
578 unsigned int local_consumed;
579 unsigned int local_maxpacket;
580 unsigned int remote_window;
581 unsigned int remote_maxpacket;
582 enum channel_type type;
583 int local_num;
584 bufchain_t *bufchain;
585 unsigned long bufchain_amount;
586 BOOL bufchain_recv_suspended;
587 scp_t scp;
588 buffer_t *agent_msg;
589 int agent_request_len;
590 sftp_t sftp;
591 #define SSH_CHANNEL_STATE_CLOSE_SENT 0x00000001
592 unsigned int state;
593 } Channel_t;
594
595 unsigned char *begin_send_packet(PTInstVar pvar, int type, int len);
596 void finish_send_packet_special(PTInstVar pvar, int skip_compress);
597 void SSH2_send_channel_data(PTInstVar pvar, Channel_t *c, unsigned char *buf, unsigned int buflen, int retry);
598 Channel_t* ssh2_local_channel_lookup(int local_num);
599 void normalize_generic_order(char *buf, char default_strings[], int default_strings_len);
600 void choose_SSH2_proposal(char* server_proposal, char* my_proposal,char* dest, int dest_len);
601
602 #define finish_send_packet(pvar) finish_send_packet_special((pvar), 0)
603 #define get_payload_uint32(pvar, offset) get_uint32_MSBfirst((pvar)->ssh_state.payload + (offset))
604 #define get_uint32(buf) get_uint32_MSBfirst((buf))
605 #define set_uint32(buf, v) set_uint32_MSBfirst((buf), (v))
606 #define get_mpint_len(pvar, offset) ((get_ushort16_MSBfirst((pvar)->ssh_state.payload + (offset)) + 7) >> 3)
607 #define get_ushort16(buf) get_ushort16_MSBfirst((buf))
608 ///
609
610 /* Global request confirmation callbacks */
611 typedef void global_confirm_cb(PTInstVar pvar, int type, unsigned int seq, void *ctx);
612 void client_register_global_confirm(global_confirm_cb *cb, void *ctx);
613
614 /* Global request success/failure callbacks */
615 struct global_confirm {
616 global_confirm_cb *cb;
617 void *ctx;
618 int ref_count;
619 };
620
621 /*
622 * SSH bottom half after known_hosts
623 */
624 enum ssh_kex_known_hosts {
625 NONE_KNOWN_HOSTS = 0,
626 SSH1_PUBLIC_KEY_KNOWN_HOSTS,
627 SSH2_DH_KEX_REPLY_KNOWN_HOSTS,
628 SSH2_DH_GEX_REPLY_KNOWN_HOSTS,
629 SSH2_ECDH_KEX_REPLY_KNOWN_HOSTS,
630 };
631
632 typedef struct bottom_half_known_hosts {
633 enum ssh_kex_known_hosts kex_type;
634
635 unsigned char *payload;
636 int payload_len;
637 UINT_PTR payload_offset;
638
639 BOOL SSH2_MSG_NEWKEYS_received;
640 } bottom_half_known_hosts_t;
641
642 void handle_SSH2_canel_reply_after_known_hosts(PTInstVar pvar);
643
644 BOOL handle_server_public_key_after_known_hosts(PTInstVar pvar);
645 BOOL handle_SSH2_dh_kex_reply_after_known_hosts(PTInstVar pvar);
646 BOOL handle_SSH2_dh_gex_reply_after_known_hosts(PTInstVar pvar);
647 BOOL handle_SSH2_ecdh_kex_reply_after_known_hosts(PTInstVar pvar);
648
649 #endif /* __SSH_H */
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help