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 9208 - (show annotations) (download) (as text)
Sat Apr 17 06:15:51 2021 UTC (2 years, 11 months ago) by nmaya
File MIME type: text/x-chdr
File size: 33499 byte(s) 
create a branch for chacha20-poly1305

from 4-stable
planned to merge to 4-stable and trunk
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 <sys/types.h>
44 #include <sys/stat.h>
45
46 #define DEBUG_PRINT_TO_FILE(base, msg, len) { \
47 static int count = 0; \
48 debug_print(count + base, msg, len); \
49 count++; \
50 }
51
52 // from OpenSSH
53 extern const EVP_CIPHER *evp_aes_128_ctr(void);
54 extern const EVP_CIPHER *evp_des3_ctr(void);
55 extern const EVP_CIPHER *evp_bf_ctr(void);
56 extern const EVP_CIPHER *evp_cast5_ctr(void);
57 extern const EVP_CIPHER *evp_camellia_128_ctr(void);
58
59 /* Some of this code has been adapted from Ian Goldberg's Pilot SSH */
60
61 typedef enum {
62 SSH_MSG_NONE, SSH_MSG_DISCONNECT, SSH_SMSG_PUBLIC_KEY, //2
63 SSH_CMSG_SESSION_KEY, SSH_CMSG_USER, SSH_CMSG_AUTH_RHOSTS, // 5
64 SSH_CMSG_AUTH_RSA, SSH_SMSG_AUTH_RSA_CHALLENGE,
65 SSH_CMSG_AUTH_RSA_RESPONSE, SSH_CMSG_AUTH_PASSWORD,
66 SSH_CMSG_REQUEST_PTY, // 10
67 SSH_CMSG_WINDOW_SIZE, SSH_CMSG_EXEC_SHELL,
68 SSH_CMSG_EXEC_CMD, SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE,
69 SSH_CMSG_STDIN_DATA, SSH_SMSG_STDOUT_DATA, SSH_SMSG_STDERR_DATA,
70 SSH_CMSG_EOF, SSH_SMSG_EXITSTATUS,
71 SSH_MSG_CHANNEL_OPEN_CONFIRMATION, SSH_MSG_CHANNEL_OPEN_FAILURE,
72 SSH_MSG_CHANNEL_DATA, SSH_MSG_CHANNEL_INPUT_EOF,
73 SSH_MSG_CHANNEL_OUTPUT_CLOSED, SSH_MSG_OBSOLETED0,
74 SSH_SMSG_X11_OPEN, SSH_CMSG_PORT_FORWARD_REQUEST, SSH_MSG_PORT_OPEN,
75 SSH_CMSG_AGENT_REQUEST_FORWARDING, SSH_SMSG_AGENT_OPEN,
76 SSH_MSG_IGNORE, SSH_CMSG_EXIT_CONFIRMATION,
77 SSH_CMSG_X11_REQUEST_FORWARDING, SSH_CMSG_AUTH_RHOSTS_RSA,
78 SSH_MSG_DEBUG, SSH_CMSG_REQUEST_COMPRESSION,
79 SSH_CMSG_MAX_PACKET_SIZE, SSH_CMSG_AUTH_TIS,
80 SSH_SMSG_AUTH_TIS_CHALLENGE, SSH_CMSG_AUTH_TIS_RESPONSE,
81 SSH_CMSG_AUTH_KERBEROS, SSH_SMSG_AUTH_KERBEROS_RESPONSE
82 } SSHMessage;
83
84 typedef enum {
85 // SSH1
86 SSH_CIPHER_NONE, SSH_CIPHER_IDEA, SSH_CIPHER_DES, SSH_CIPHER_3DES,
87 SSH_CIPHER_TSS, SSH_CIPHER_RC4, SSH_CIPHER_BLOWFISH,
88 // SSH2
89 SSH2_CIPHER_3DES_CBC, SSH2_CIPHER_AES128_CBC,
90 SSH2_CIPHER_AES192_CBC, SSH2_CIPHER_AES256_CBC,
91 SSH2_CIPHER_BLOWFISH_CBC, SSH2_CIPHER_AES128_CTR,
92 SSH2_CIPHER_AES192_CTR, SSH2_CIPHER_AES256_CTR,
93 SSH2_CIPHER_ARCFOUR, SSH2_CIPHER_ARCFOUR128, SSH2_CIPHER_ARCFOUR256,
94 SSH2_CIPHER_CAST128_CBC,
95 SSH2_CIPHER_3DES_CTR, SSH2_CIPHER_BLOWFISH_CTR, SSH2_CIPHER_CAST128_CTR,
96 SSH2_CIPHER_CAMELLIA128_CBC, SSH2_CIPHER_CAMELLIA192_CBC, SSH2_CIPHER_CAMELLIA256_CBC,
97 SSH2_CIPHER_CAMELLIA128_CTR, SSH2_CIPHER_CAMELLIA192_CTR, SSH2_CIPHER_CAMELLIA256_CTR,
98 SSH2_CIPHER_AES128_GCM, SSH2_CIPHER_AES256_GCM,
99 SSH_CIPHER_MAX = SSH2_CIPHER_AES256_GCM,
100 } SSHCipherId;
101
102 typedef enum {
103 SSH_AUTH_NONE, SSH_AUTH_RHOSTS, SSH_AUTH_RSA, SSH_AUTH_PASSWORD,
104 SSH_AUTH_RHOSTS_RSA, SSH_AUTH_TIS, SSH_AUTH_KERBEROS,
105 SSH_AUTH_PAGEANT = 16,
106 SSH_AUTH_MAX = SSH_AUTH_PAGEANT,
107 } SSHAuthMethod;
108
109 typedef enum {
110 SSH_GENERIC_AUTHENTICATION, SSH_TIS_AUTHENTICATION
111 } SSHAuthMode;
112
113 #define SSH_PROTOFLAG_SCREEN_NUMBER 1
114 #define SSH_PROTOFLAG_HOST_IN_FWD_OPEN 2
115
116 enum channel_type {
117 TYPE_SHELL, TYPE_PORTFWD, TYPE_SCP, TYPE_SFTP, TYPE_AGENT, TYPE_SUBSYSTEM_GEN,
118 };
119
120 // for SSH1
121 #define SSH_MAX_SEND_PACKET_SIZE 250000
122
123 // for SSH2
124 /* default window/packet sizes for tcp/x11-fwd-channel */
125 // changed CHAN_SES_WINDOW_DEFAULT from 32KB to 128KB. (2007.10.29 maya)
126 #define CHAN_SES_PACKET_DEFAULT (32*1024)
127 #define CHAN_SES_WINDOW_DEFAULT (4*CHAN_SES_PACKET_DEFAULT)
128 #define CHAN_TCP_PACKET_DEFAULT (32*1024)
129 #define CHAN_TCP_WINDOW_DEFAULT (4*CHAN_TCP_PACKET_DEFAULT)
130 #if 0 // unused
131 #define CHAN_X11_PACKET_DEFAULT (16*1024)
132 #define CHAN_X11_WINDOW_DEFAULT (4*CHAN_X11_PACKET_DEFAULT)
133 #endif
134
135
136 /* SSH2 constants */
137 #define SSH_CHANNEL_INVALID -1
138
139 /* SSH2 messages */
140 typedef enum {
141 // Transport layer protocol
142 // 1..19 Transport layer generic (RFC 4253)
143 SSH2_MSG_DISCONNECT = 1,
144 SSH2_MSG_IGNORE = 2,
145 SSH2_MSG_UNIMPLEMENTED = 3,
146 SSH2_MSG_DEBUG = 4,
147 SSH2_MSG_SERVICE_REQUEST = 5,
148 SSH2_MSG_SERVICE_ACCEPT = 6,
149
150 // 20..29 Algorithm negotiation (RFC 4253)
151 SSH2_MSG_KEXINIT = 20,
152 SSH2_MSG_NEWKEYS = 21,
153
154 // 30..49 Key excahnge method specific
155 // Diffie-Hellman Key Exchange (RFC 4253)
156 SSH2_MSG_KEXDH_INIT = 30,
157 SSH2_MSG_KEXDH_REPLY = 31,
158
159 // RFC 4419 - Diffie-Hellman Group Exchange for the Secure Shell (SSH) Transport Layer Protocol
160 SSH2_MSG_KEX_DH_GEX_GROUP = 31,
161 SSH2_MSG_KEX_DH_GEX_INIT = 32,
162 SSH2_MSG_KEX_DH_GEX_REPLY = 33,
163 SSH2_MSG_KEX_DH_GEX_REQUEST = 34,
164
165 // RFC 5656 - Elliptic Curve Algorithm Integration in the Secure Shell Transport Layer
166 SSH2_MSG_KEX_ECDH_INIT = 30,
167 SSH2_MSG_KEX_ECDH_REPLY = 31,
168
169 // User authentication protocol
170 // 50..59 User authentication generic (RFC 4252)
171 SSH2_MSG_USERAUTH_REQUEST = 50,
172 SSH2_MSG_USERAUTH_FAILURE = 51,
173 SSH2_MSG_USERAUTH_SUCCESS = 52,
174 SSH2_MSG_USERAUTH_BANNER = 53,
175
176 // Public key authentication (RFC 4252)
177 SSH2_MSG_USERAUTH_PK_OK = 60,
178
179 // Password authentication (RFC 4252)
180 SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ = 60,
181
182 // RFC 4256 - Generic Message Exchange Authentication for the Secure Shell Protocol (SSH)
183 // Keyboard-interactive authentication
184 SSH2_MSG_USERAUTH_INFO_REQUEST = 60,
185 SSH2_MSG_USERAUTH_INFO_RESPONSE = 61,
186
187 // Connection protocol
188 // 80..89 Connection protocol generic (RFC 4254)
189 SSH2_MSG_GLOBAL_REQUEST = 80,
190 SSH2_MSG_REQUEST_SUCCESS = 81,
191 SSH2_MSG_REQUEST_FAILURE = 82,
192
193 // 90..127 Channel related messages (RFC 4254)
194 SSH2_MSG_CHANNEL_OPEN = 90,
195 SSH2_MSG_CHANNEL_OPEN_CONFIRMATION = 91,
196 SSH2_MSG_CHANNEL_OPEN_FAILURE = 92,
197 SSH2_MSG_CHANNEL_WINDOW_ADJUST = 93,
198 SSH2_MSG_CHANNEL_DATA = 94,
199 SSH2_MSG_CHANNEL_EXTENDED_DATA = 95,
200 SSH2_MSG_CHANNEL_EOF = 96,
201 SSH2_MSG_CHANNEL_CLOSE = 97,
202 SSH2_MSG_CHANNEL_REQUEST = 98,
203 SSH2_MSG_CHANNEL_SUCCESS = 99,
204 SSH2_MSG_CHANNEL_FAILURE = 100
205
206 // Reserved for client protocols
207 // 128..191 Reserved
208
209 // Local extensions:
210 // 192..255 Local extensions
211
212 } SSH2Message;
213
214 /* SSH2 miscellaneous constants */
215 typedef enum {
216 SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT = 1,
217 SSH2_DISCONNECT_PROTOCOL_ERROR,
218 SSH2_DISCONNECT_KEY_EXCHANGE_FAILED,
219 SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED,
220 SSH2_DISCONNECT_MAC_ERROR,
221 SSH2_DISCONNECT_COMPRESSION_ERROR,
222 SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE,
223 SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED,
224 SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE,
225 SSH2_DISCONNECT_CONNECTION_LOST,
226 SSH2_DISCONNECT_BY_APPLICATION,
227 SSH2_DISCONNECT_TOO_MANY_CONNECTIONS,
228 SSH2_DISCONNECT_AUTH_CANCELLED_BY_USER,
229 SSH2_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE,
230 SSH2_DISCONNECT_ILLEGAL_USER_NAME
231 } SSH2DisconnectMessage;
232
233 typedef enum {
234 SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED = 1,
235 SSH2_OPEN_CONNECT_FAILED,
236 SSH2_OPEN_UNKNOWN_CHANNEL_TYPE,
237 SSH2_OPEN_RESOURCE_SHORTAGE
238 } SSH2ChannelFailReason;
239
240 // Terminal Modes
241 typedef enum {
242 SSH2_TTY_OP_END = 0,
243 SSH2_TTY_KEY_VINTR = 1,
244 SSH2_TTY_KEY_VQUIT = 2,
245 SSH2_TTY_KEY_VERASE = 3,
246 SSH2_TTY_KEY_VKILL = 4,
247 SSH2_TTY_KEY_VEOF = 5,
248 SSH2_TTY_KEY_VEOL = 6,
249 SSH2_TTY_KEY_VEOL2 = 7,
250 SSH2_TTY_KEY_VSTART = 8,
251 SSH2_TTY_KEY_VSTOP = 9,
252 SSH2_TTY_KEY_VSUSP = 10,
253 SSH2_TTY_KEY_VDSUSP = 11,
254 SSH2_TTY_KEY_VREPRINT = 12,
255 SSH2_TTY_KEY_VWERASE = 13,
256 SSH2_TTY_KEY_VLNEXT = 14,
257 SSH2_TTY_KEY_VFLUSH = 15,
258 SSH2_TTY_KEY_VSWTCH = 16,
259 SSH2_TTY_KEY_VSTATUS = 17,
260 SSH2_TTY_KEY_VDISCARD = 18,
261 SSH2_TTY_OP_IGNPAR = 30,
262 SSH2_TTY_OP_PARMRK = 31,
263 SSH2_TTY_OP_INPCK = 32,
264 SSH2_TTY_OP_ISTRIP = 33,
265 SSH2_TTY_OP_INLCR = 34,
266 SSH2_TTY_OP_IGNCR = 35,
267 SSH2_TTY_OP_ICRNL = 36,
268 SSH2_TTY_OP_IUCLC = 37,
269 SSH2_TTY_OP_IXON = 38,
270 SSH2_TTY_OP_IXANY = 39,
271 SSH2_TTY_OP_IXOFF = 40,
272 SSH2_TTY_OP_IMAXBEL = 41,
273 SSH2_TTY_OP_ISIG = 50,
274 SSH2_TTY_OP_ICANON = 51,
275 SSH2_TTY_OP_XCASE = 52,
276 SSH2_TTY_OP_ECHO = 53,
277 SSH2_TTY_OP_ECHOE = 54,
278 SSH2_TTY_OP_ECHOK = 55,
279 SSH2_TTY_OP_ECHONL = 56,
280 SSH2_TTY_OP_NOFLSH = 57,
281 SSH2_TTY_OP_TOSTOP = 58,
282 SSH2_TTY_OP_IEXTEN = 59,
283 SSH2_TTY_OP_ECHOCTL = 60,
284 SSH2_TTY_OP_ECHOKE = 61,
285 SSH2_TTY_OP_PENDIN = 62,
286 SSH2_TTY_OP_OPOST = 70,
287 SSH2_TTY_OP_OLCUC = 71,
288 SSH2_TTY_OP_ONLCR = 72,
289 SSH2_TTY_OP_OCRNL = 73,
290 SSH2_TTY_OP_ONOCR = 74,
291 SSH2_TTY_OP_ONLRET = 75,
292 SSH2_TTY_OP_CS7 = 90,
293 SSH2_TTY_OP_CS8 = 91,
294 SSH2_TTY_OP_PARENB = 92,
295 SSH2_TTY_OP_PARODD = 93,
296 SSH2_TTY_OP_ISPEED = 128,
297 SSH2_TTY_OP_OSPEED = 129
298 } SSH2TTYMode;
299
300
301 // �N���C�A���g�����T�[�o������������
302 enum kex_init_proposals {
303 PROPOSAL_KEX_ALGS,
304 PROPOSAL_SERVER_HOST_KEY_ALGS,
305 PROPOSAL_ENC_ALGS_CTOS,
306 PROPOSAL_ENC_ALGS_STOC,
307 PROPOSAL_MAC_ALGS_CTOS,
308 PROPOSAL_MAC_ALGS_STOC,
309 PROPOSAL_COMP_ALGS_CTOS,
310 PROPOSAL_COMP_ALGS_STOC,
311 PROPOSAL_LANG_CTOS,
312 PROPOSAL_LANG_STOC,
313 PROPOSAL_MAX
314 };
315
316 #define KEX_DEFAULT_KEX ""
317 #define KEX_DEFAULT_PK_ALG ""
318 #define KEX_DEFAULT_ENCRYPT ""
319 #define KEX_DEFAULT_MAC ""
320 #define KEX_DEFAULT_COMP ""
321 #define KEX_DEFAULT_LANG ""
322
323 static char *myproposal[PROPOSAL_MAX] = {
324 KEX_DEFAULT_KEX,
325 KEX_DEFAULT_PK_ALG,
326 KEX_DEFAULT_ENCRYPT,
327 KEX_DEFAULT_ENCRYPT,
328 KEX_DEFAULT_MAC,
329 KEX_DEFAULT_MAC,
330 KEX_DEFAULT_COMP,
331 KEX_DEFAULT_COMP,
332 KEX_DEFAULT_LANG,
333 KEX_DEFAULT_LANG,
334 };
335
336
337 typedef enum {
338 KEY_NONE,
339 KEY_RSA1,
340 KEY_RSA,
341 KEY_DSA,
342 KEY_ECDSA256,
343 KEY_ECDSA384,
344 KEY_ECDSA521,
345 KEY_ED25519,
346 KEY_UNSPEC,
347 KEY_MAX = KEY_UNSPEC,
348 } ssh_keytype;
349 #define isFixedLengthKey(type) ((type) >= KEY_DSA && (type) <= KEY_ED25519)
350
351 typedef struct ssh2_host_key {
352 ssh_keytype type;
353 char *name;
354 } ssh2_host_key_t;
355
356 static ssh2_host_key_t ssh2_host_key[] = {
357 {KEY_RSA1, "ssh-rsa1"}, // for SSH1 only
358 {KEY_RSA, "ssh-rsa"}, // RFC4253
359 {KEY_DSA, "ssh-dss"}, // RFC4253
360 {KEY_ECDSA256, "ecdsa-sha2-nistp256"}, // RFC5656
361 {KEY_ECDSA384, "ecdsa-sha2-nistp384"}, // RFC5656
362 {KEY_ECDSA521, "ecdsa-sha2-nistp521"}, // RFC5656
363 {KEY_ED25519, "ssh-ed25519"}, // draft-bjh21-ssh-ed25519-02
364 {KEY_UNSPEC, "ssh-unknown"},
365 {KEY_NONE, NULL},
366 };
367
368 /* Minimum modulus size (n) for RSA keys. */
369 #define SSH_RSA_MINIMUM_MODULUS_SIZE 768
370
371 #define SSH_KEYGEN_DEFAULT_BITS 2048
372 #define SSH_RSA_MINIMUM_KEY_SIZE 768
373 #define SSH_DSA_MINIMUM_KEY_SIZE 1024
374
375 #define SSH_KEYGEN_MINIMUM_ROUNDS 1
376 #define SSH_KEYGEN_MAXIMUM_ROUNDS INT_MAX
377
378
379 typedef struct ssh2_cipher {
380 SSHCipherId id;
381 char *name;
382 int block_size;
383 int key_len;
384 int discard_len;
385 int iv_len;
386 int auth_len;
387 const EVP_CIPHER *(*func)(void);
388 } SSH2Cipher;
389
390 static SSH2Cipher ssh2_ciphers[] = {
391 {SSH2_CIPHER_3DES_CBC, "3des-cbc", 8, 24, 0, 0, 0, EVP_des_ede3_cbc}, // RFC4253
392 {SSH2_CIPHER_AES128_CBC, "aes128-cbc", 16, 16, 0, 0, 0, EVP_aes_128_cbc}, // RFC4253
393 {SSH2_CIPHER_AES192_CBC, "aes192-cbc", 16, 24, 0, 0, 0, EVP_aes_192_cbc}, // RFC4253
394 {SSH2_CIPHER_AES256_CBC, "aes256-cbc", 16, 32, 0, 0, 0, EVP_aes_256_cbc}, // RFC4253
395 {SSH2_CIPHER_BLOWFISH_CBC, "blowfish-cbc", 8, 16, 0, 0, 0, EVP_bf_cbc}, // RFC4253
396 {SSH2_CIPHER_AES128_CTR, "aes128-ctr", 16, 16, 0, 0, 0, evp_aes_128_ctr}, // RFC4344
397 {SSH2_CIPHER_AES192_CTR, "aes192-ctr", 16, 24, 0, 0, 0, evp_aes_128_ctr}, // RFC4344
398 {SSH2_CIPHER_AES256_CTR, "aes256-ctr", 16, 32, 0, 0, 0, evp_aes_128_ctr}, // RFC4344
399 {SSH2_CIPHER_ARCFOUR, "arcfour", 8, 16, 0, 0, 0, EVP_rc4}, // RFC4253
400 {SSH2_CIPHER_ARCFOUR128, "arcfour128", 8, 16, 1536, 0, 0, EVP_rc4}, // RFC4345
401 {SSH2_CIPHER_ARCFOUR256, "arcfour256", 8, 32, 1536, 0, 0, EVP_rc4}, // RFC4345
402 {SSH2_CIPHER_CAST128_CBC, "cast128-cbc", 8, 16, 0, 0, 0, EVP_cast5_cbc}, // RFC4253
403 {SSH2_CIPHER_3DES_CTR, "3des-ctr", 8, 24, 0, 0, 0, evp_des3_ctr}, // RFC4344
404 {SSH2_CIPHER_BLOWFISH_CTR, "blowfish-ctr", 8, 32, 0, 0, 0, evp_bf_ctr}, // RFC4344
405 {SSH2_CIPHER_CAST128_CTR, "cast128-ctr", 8, 16, 0, 0, 0, evp_cast5_ctr}, // RFC4344
406 {SSH2_CIPHER_CAMELLIA128_CBC, "camellia128-cbc", 16, 16, 0, 0, 0, EVP_camellia_128_cbc}, // draft-kanno-secsh-camellia-02
407 {SSH2_CIPHER_CAMELLIA192_CBC, "camellia192-cbc", 16, 24, 0, 0, 0, EVP_camellia_192_cbc}, // draft-kanno-secsh-camellia-02
408 {SSH2_CIPHER_CAMELLIA256_CBC, "camellia256-cbc", 16, 32, 0, 0, 0, EVP_camellia_256_cbc}, // draft-kanno-secsh-camellia-02
409 {SSH2_CIPHER_CAMELLIA128_CTR, "camellia128-ctr", 16, 16, 0, 0, 0, evp_camellia_128_ctr}, // draft-kanno-secsh-camellia-02
410 {SSH2_CIPHER_CAMELLIA192_CTR, "camellia192-ctr", 16, 24, 0, 0, 0, evp_camellia_128_ctr}, // draft-kanno-secsh-camellia-02
411 {SSH2_CIPHER_CAMELLIA256_CTR, "camellia256-ctr", 16, 32, 0, 0, 0, evp_camellia_128_ctr}, // draft-kanno-secsh-camellia-02
412 #ifdef WITH_CAMELLIA_PRIVATE
413 {SSH2_CIPHER_CAMELLIA128_CBC, "camellia128-cbc@openssh.org", 16, 16, 0, 0, 0, EVP_camellia_128_cbc},
414 {SSH2_CIPHER_CAMELLIA192_CBC, "camellia192-cbc@openssh.org", 16, 24, 0, 0, 0, EVP_camellia_192_cbc},
415 {SSH2_CIPHER_CAMELLIA256_CBC, "camellia256-cbc@openssh.org", 16, 32, 0, 0, 0, EVP_camellia_256_cbc},
416 {SSH2_CIPHER_CAMELLIA128_CTR, "camellia128-ctr@openssh.org", 16, 16, 0, 0, 0, evp_camellia_128_ctr},
417 {SSH2_CIPHER_CAMELLIA192_CTR, "camellia192-ctr@openssh.org", 16, 24, 0, 0, 0, evp_camellia_128_ctr},
418 {SSH2_CIPHER_CAMELLIA256_CTR, "camellia256-ctr@openssh.org", 16, 32, 0, 0, 0, evp_camellia_128_ctr},
419 #endif // WITH_CAMELLIA_PRIVATE
420 {SSH2_CIPHER_AES128_GCM, "aes128-gcm@openssh.com", 16, 16, 0, 12, 16, EVP_aes_128_gcm}, // not RFC5647, PROTOCOL of OpenSSH
421 {SSH2_CIPHER_AES256_GCM, "aes256-gcm@openssh.com", 16, 32, 0, 12, 16, EVP_aes_256_gcm}, // not RFC5647, PROTOCOL of OpenSSH
422 {SSH_CIPHER_NONE, NULL, 0, 0, 0, 0, 0, NULL},
423 };
424
425
426 typedef enum {
427 KEX_DH_NONE, /* disabled line */
428 KEX_DH_GRP1_SHA1,
429 KEX_DH_GRP14_SHA1,
430 KEX_DH_GEX_SHA1,
431 KEX_DH_GEX_SHA256,
432 KEX_ECDH_SHA2_256,
433 KEX_ECDH_SHA2_384,
434 KEX_ECDH_SHA2_521,
435 KEX_DH_GRP14_SHA256,
436 KEX_DH_GRP16_SHA512,
437 KEX_DH_GRP18_SHA512,
438 KEX_DH_UNKNOWN,
439 KEX_DH_MAX = KEX_DH_UNKNOWN,
440 } kex_algorithm;
441
442 typedef struct ssh2_kex_algorithm {
443 kex_algorithm kextype;
444 char *name;
445 const EVP_MD *(*evp_md)(void);
446 } ssh2_kex_algorithm_t;
447
448 static ssh2_kex_algorithm_t ssh2_kex_algorithms[] = {
449 {KEX_DH_GRP1_SHA1, "diffie-hellman-group1-sha1", EVP_sha1}, // RFC4253
450 {KEX_DH_GRP14_SHA1, "diffie-hellman-group14-sha1", EVP_sha1}, // RFC4253
451 {KEX_DH_GEX_SHA1, "diffie-hellman-group-exchange-sha1", EVP_sha1}, // RFC4419
452 {KEX_DH_GEX_SHA256, "diffie-hellman-group-exchange-sha256", EVP_sha256}, // RFC4419
453 {KEX_ECDH_SHA2_256, "ecdh-sha2-nistp256", EVP_sha256}, // RFC5656
454 {KEX_ECDH_SHA2_384, "ecdh-sha2-nistp384", EVP_sha384}, // RFC5656
455 {KEX_ECDH_SHA2_521, "ecdh-sha2-nistp521", EVP_sha512}, // RFC5656
456 {KEX_DH_GRP14_SHA256, "diffie-hellman-group14-sha256", EVP_sha256}, // RFC8268
457 {KEX_DH_GRP16_SHA512, "diffie-hellman-group16-sha512", EVP_sha512}, // RFC8268
458 {KEX_DH_GRP18_SHA512, "diffie-hellman-group18-sha512", EVP_sha512}, // RFC8268
459 {KEX_DH_NONE , NULL, NULL},
460 };
461
462
463 typedef enum {
464 HMAC_NONE, /* disabled line */
465 HMAC_SHA1,
466 HMAC_MD5,
467 HMAC_SHA1_96,
468 HMAC_MD5_96,
469 HMAC_RIPEMD160,
470 HMAC_SHA2_256,
471 HMAC_SHA2_256_96,
472 HMAC_SHA2_512,
473 HMAC_SHA2_512_96,
474 HMAC_SHA1_EtM,
475 HMAC_MD5_EtM,
476 HMAC_SHA1_96_EtM,
477 HMAC_MD5_96_EtM,
478 HMAC_RIPEMD160_EtM,
479 HMAC_SHA2_256_EtM,
480 HMAC_SHA2_512_EtM,
481 HMAC_IMPLICIT,
482 HMAC_UNKNOWN,
483 HMAC_MAX = HMAC_UNKNOWN,
484 } SSH2MacId;
485
486 typedef struct ssh2_mac {
487 SSH2MacId id;
488 char *name;
489 const EVP_MD *(*evp_md)(void);
490 int truncatebits;
491 int etm;
492 } SSH2Mac;
493
494 static SSH2Mac ssh2_macs[] = {
495 {HMAC_SHA1, "hmac-sha1", EVP_sha1, 0, 0}, // RFC4253
496 {HMAC_MD5, "hmac-md5", EVP_md5, 0, 0}, // RFC4253
497 {HMAC_SHA1_96, "hmac-sha1-96", EVP_sha1, 96, 0}, // RFC4253
498 {HMAC_MD5_96, "hmac-md5-96", EVP_md5, 96, 0}, // RFC4253
499 {HMAC_RIPEMD160, "hmac-ripemd160@openssh.com", EVP_ripemd160, 0, 0},
500 {HMAC_SHA2_256, "hmac-sha2-256", EVP_sha256, 0, 0}, // RFC6668
501 // {HMAC_SHA2_256_96, "hmac-sha2-256-96", EVP_sha256, 96, 0}, // draft-dbider-sha2-mac-for-ssh-05, deleted at 06
502 {HMAC_SHA2_512, "hmac-sha2-512", EVP_sha512, 0, 0}, // RFC6668
503 // {HMAC_SHA2_512_96, "hmac-sha2-512-96", EVP_sha512, 96, 0}, // draft-dbider-sha2-mac-for-ssh-05, deleted at 06
504 {HMAC_SHA1_EtM, "hmac-sha1-etm@openssh.com", EVP_sha1, 0, 1},
505 {HMAC_MD5_EtM, "hmac-md5-etm@openssh.com", EVP_md5, 0, 1},
506 {HMAC_SHA1_96_EtM, "hmac-sha1-96-etm@openssh.com", EVP_sha1, 96, 1},
507 {HMAC_MD5_96_EtM, "hmac-md5-96-etm@openssh.com", EVP_md5, 96, 1},
508 {HMAC_RIPEMD160_EtM,"hmac-ripemd160-etm@openssh.com",EVP_ripemd160, 0, 1},
509 {HMAC_SHA2_256_EtM, "hmac-sha2-256-etm@openssh.com", EVP_sha256, 0, 1},
510 {HMAC_SHA2_512_EtM, "hmac-sha2-512-etm@openssh.com", EVP_sha512, 0, 1},
511 {HMAC_IMPLICIT, "<implicit>", EVP_md_null, 0, 0}, // for AEAD cipher
512 {HMAC_NONE, NULL, NULL, 0, 0},
513 };
514
515
516 typedef enum {
517 COMP_NONE, /* disabled line */
518 COMP_NOCOMP,
519 COMP_ZLIB,
520 COMP_DELAYED,
521 COMP_UNKNOWN,
522 COMP_MAX = COMP_UNKNOWN,
523 } compression_type;
524
525 typedef struct ssh2_comp {
526 compression_type type;
527 char *name;
528 } ssh2_comp_t;
529
530 static ssh2_comp_t ssh2_comps[] = {
531 {COMP_NOCOMP, "none"}, // RFC4253
532 {COMP_ZLIB, "zlib"}, // RFC4253
533 {COMP_DELAYED, "zlib@openssh.com"},
534 {COMP_NONE, NULL},
535 };
536
537
538 struct Enc {
539 u_char *key;
540 u_char *iv;
541 unsigned int key_len;
542 unsigned int block_size;
543 unsigned int iv_len;
544 unsigned int auth_len;
545 };
546
547 struct Mac {
548 char *name;
549 int enabled;
550 const EVP_MD *md;
551 unsigned int mac_len;
552 u_char *key;
553 unsigned int key_len;
554 int etm;
555 };
556
557 struct Comp {
558 int type;
559 int enabled;
560 char *name;
561 };
562
563 typedef struct {
564 struct Enc enc;
565 struct Mac mac;
566 struct Comp comp;
567 } SSHKeys;
568
569 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
570
571 enum kex_modes {
572 MODE_IN,
573 MODE_OUT,
574 MODE_MAX
575 };
576
577
578 // �z�X�g�L�[(SSH1, SSH2����)���f�[�^�\�� (2006.3.21 yutaka)
579 typedef struct Key {
580 // host key type
581 ssh_keytype type;
582 // SSH2 RSA
583 RSA *rsa;
584 // SSH2 DSA
585 DSA *dsa;
586 // SSH2 ECDSA
587 EC_KEY *ecdsa;
588 // SSH1 RSA
589 int bits;
590 unsigned char *exp;
591 unsigned char *mod;
592 // SSH2 ED25519
593 unsigned char *ed25519_sk;
594 unsigned char *ed25519_pk;
595 int bcrypt_kdf;
596 } Key;
597
598 // fingerprint������
599 enum fp_rep {
600 SSH_FP_DEFAULT = 0,
601 SSH_FP_HEX,
602 SSH_FP_BASE64,
603 SSH_FP_BUBBLEBABBLE,
604 SSH_FP_RANDOMART
605 };
606 /*
607 enum fp_type {
608 SSH_FP_MD5,
609 SSH_FP_SHA1,
610 SSH_FP_SHA256
611 };
612 */
613 typedef enum {
614 SSH_DIGEST_MD5,
615 SSH_DIGEST_RIPEMD160,
616 SSH_DIGEST_SHA1,
617 SSH_DIGEST_SHA256,
618 SSH_DIGEST_SHA384,
619 SSH_DIGEST_SHA512,
620 SSH_DIGEST_MAX,
621 } digest_algorithm;
622
623 typedef struct ssh_digest {
624 digest_algorithm id;
625 char *name;
626 } ssh_digest_t;
627
628 /* NB. Indexed directly by algorithm number */
629 static ssh_digest_t ssh_digests[] = {
630 { SSH_DIGEST_MD5, "MD5" },
631 { SSH_DIGEST_RIPEMD160, "RIPEMD160" },
632 { SSH_DIGEST_SHA1, "SHA1" },
633 { SSH_DIGEST_SHA256, "SHA256" },
634 { SSH_DIGEST_SHA384, "SHA384" },
635 { SSH_DIGEST_SHA512, "SHA512" },
636 { SSH_DIGEST_MAX, NULL },
637 };
638
639 enum scp_dir {
640 TOREMOTE, FROMREMOTE,
641 };
642
643 /* The packet handler returns TRUE to keep the handler in place,
644 FALSE to remove the handler. */
645 typedef BOOL (* SSHPacketHandler)(PTInstVar pvar);
646
647 typedef struct _SSHPacketHandlerItem SSHPacketHandlerItem;
648 struct _SSHPacketHandlerItem {
649 SSHPacketHandler handler;
650 /* Circular list of handlers for given message */
651 SSHPacketHandlerItem *next_for_message;
652 SSHPacketHandlerItem *last_for_message;
653 /* Circular list of handlers in set */
654 SSHPacketHandlerItem *next_in_set;
655 int active_for_message;
656 };
657
658 typedef struct {
659 char *hostname;
660
661 int server_protocol_flags;
662 char *server_ID;
663
664 /* This buffer is used to hold the outgoing data, and encrypted in-place
665 here if necessary. */
666 unsigned char *outbuf;
667 long outbuflen;
668 /* This buffer is used by the SSH protocol processing to store uncompressed
669 packet data for compression. User data is never streamed through here;
670 it is compressed directly from the user's buffer. */
671 unsigned char *precompress_outbuf;
672 long precompress_outbuflen;
673 /* this is the length of the packet data, including the type header */
674 long outgoing_packet_len;
675
676 /* This buffer is used by the SSH protocol processing to store decompressed
677 packet data. User data is never streamed through here; it is decompressed
678 directly to the user's buffer. */
679 unsigned char *postdecompress_inbuf;
680 long postdecompress_inbuflen;
681
682 unsigned char *payload;
683 long payload_grabbed;
684 long payloadlen;
685 long payload_datastart;
686 long payload_datalen;
687
688 uint32 receiver_sequence_number;
689 uint32 sender_sequence_number;
690
691 z_stream compress_stream;
692 z_stream decompress_stream;
693 BOOL compressing;
694 BOOL decompressing;
695 int compression_level;
696
697 SSHPacketHandlerItem *packet_handlers[256];
698 int status_flags;
699
700 int win_cols;
701 int win_rows;
702
703 unsigned short tcpport;
704 } SSHState;
705
706 #define STATUS_DONT_SEND_USER_NAME 0x01
707 #define STATUS_EXPECTING_COMPRESSION_RESPONSE 0x02
708 #define STATUS_DONT_SEND_CREDENTIALS 0x04
709 #define STATUS_HOST_OK 0x08
710 #define STATUS_INTERACTIVE 0x10
711 #define STATUS_IN_PARTIAL_ID_STRING 0x20
712
713 void SSH_init(PTInstVar pvar);
714 void SSH_open(PTInstVar pvar);
715 void SSH_notify_disconnecting(PTInstVar pvar, char *reason);
716 /* SSH_handle_server_ID returns TRUE iff a valid ID string has been
717 received. If it returns FALSE, we need to keep looking for another
718 ID string. */
719 BOOL SSH_handle_server_ID(PTInstVar pvar, char *ID, int ID_len);
720 /* SSH_handle_packet requires NO PAYLOAD on entry.
721 'len' is the size of the packet: payload + padding (+ CRC for SSHv1)
722 'padding' is the size of the padding.
723 'data' points to the start of the packet data (the length field)
724 */
725 void SSH1_handle_packet(PTInstVar pvar, char *data, unsigned int len, unsigned int padding);
726 void SSH2_handle_packet(PTInstVar pvar, char *data, unsigned int len, unsigned int aadlen, unsigned int authlen);
727 void SSH_notify_win_size(PTInstVar pvar, int cols, int rows);
728 void SSH_notify_user_name(PTInstVar pvar);
729 void SSH_notify_cred(PTInstVar pvar);
730 void SSH_notify_host_OK(PTInstVar pvar);
731 void SSH_send(PTInstVar pvar, unsigned char const *buf, unsigned int buflen);
732 /* SSH_extract_payload returns number of bytes extracted */
733 int SSH_extract_payload(PTInstVar pvar, unsigned char *dest, int len);
734 void SSH_end(PTInstVar pvar);
735
736 void SSH_get_server_ID_info(PTInstVar pvar, char *dest, int len);
737 void SSH_get_protocol_version_info(PTInstVar pvar, char *dest, int len);
738 void SSH_get_compression_info(PTInstVar pvar, char *dest, int len);
739 void SSH_get_mac_info(PTInstVar pvar, char *dest, int len);
740
741 /* len must be <= SSH_MAX_SEND_PACKET_SIZE */
742 void SSH_channel_send(PTInstVar pvar, int channel_num,
743 uint32 remote_channel_num,
744 unsigned char *buf, int len, int retry);
745 void SSH_fail_channel_open(PTInstVar pvar, uint32 remote_channel_num);
746 void SSH_confirm_channel_open(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num);
747 void SSH_channel_output_eof(PTInstVar pvar, uint32 remote_channel_num);
748 void SSH_channel_input_eof(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num);
749 void SSH_request_forwarding(PTInstVar pvar, char *bind_address, int from_server_port,
750 char *to_local_host, int to_local_port);
751 void SSH_cancel_request_forwarding(PTInstVar pvar, char *bind_address, int from_server_port, int reply);
752 void SSH_request_X11_forwarding(PTInstVar pvar,
753 char *auth_protocol, unsigned char *auth_data, int auth_data_len, int screen_num);
754 void SSH_open_channel(PTInstVar pvar, uint32 local_channel_num,
755 char *to_remote_host, int to_remote_port,
756 char *originator, unsigned short originator_port);
757
758 int SSH_start_scp(PTInstVar pvar, char *sendfile, char *dstfile);
759 int SSH_scp_sending_status(void);
760 int SSH_start_scp_receive(PTInstVar pvar, char *filename);
761 int SSH_scp_transaction(PTInstVar pvar, char *sendfile, char *dstfile, enum scp_dir direction);
762 int SSH_sftp_transaction(PTInstVar pvar);
763
764 /* auxiliary SSH2 interfaces for pkt.c */
765 unsigned int SSH_get_min_packet_size(PTInstVar pvar);
766 /* data is guaranteed to be at least SSH_get_min_packet_size bytes long
767 at least 5 bytes must be decrypted */
768 void SSH_predecrypt_packet(PTInstVar pvar, char *data);
769 unsigned int SSH_get_clear_MAC_size(PTInstVar pvar);
770 unsigned int SSH_get_authdata_size(PTInstVar pvar, int direction);
771
772 #define SSH_is_any_payload(pvar) ((pvar)->ssh_state.payload_datalen > 0)
773 #define SSH_get_host_name(pvar) ((pvar)->ssh_state.hostname)
774 #define SSH_get_compression_level(pvar) ((pvar)->ssh_state.compressing ? (pvar)->ts_SSH_CompressionLevel : 0)
775
776 void SSH2_send_kexinit(PTInstVar pvar);
777 BOOL do_SSH2_userauth(PTInstVar pvar);
778 BOOL do_SSH2_authrequest(PTInstVar pvar);
779 void debug_print(int no, char *msg, int len);
780 int get_cipher_block_size(SSH2Cipher *cipher);
781 int get_cipher_key_len(SSH2Cipher *cipher);
782 int get_cipher_iv_len(SSH2Cipher *cipher);
783 int get_cipher_auth_len(SSH2Cipher *cipher);
784 SSH2Cipher *get_cipher_by_name(char *name);
785 char* get_kex_algorithm_name(kex_algorithm kextype);
786 const EVP_CIPHER* get_cipher_EVP_CIPHER(SSH2Cipher *cipher);
787 const EVP_MD* get_kex_algorithm_EVP_MD(kex_algorithm kextype);
788 SSH2Mac *get_ssh2_mac(SSH2MacId id);
789 char* get_ssh2_mac_name(SSH2Mac *mac);
790 char* get_ssh2_mac_name_by_id(SSH2MacId id);
791 const EVP_MD* get_ssh2_mac_EVP_MD(SSH2Mac *mac);
792 int get_ssh2_mac_truncatebits(SSH2Mac *mac);
793 char* get_ssh2_comp_name(compression_type type);
794 char* get_ssh_keytype_name(ssh_keytype type);
795 char* get_digest_algorithm_name(digest_algorithm id);
796 int get_cipher_discard_len(SSH2Cipher *cipher);
797 void ssh_heartbeat_lock_initialize(void);
798 void ssh_heartbeat_lock_finalize(void);
799 void ssh_heartbeat_lock(void);
800 void ssh_heartbeat_unlock(void);
801 void halt_ssh_heartbeat_thread(PTInstVar pvar);
802 void ssh2_channel_free(void);
803 BOOL handle_SSH2_userauth_msg60(PTInstVar pvar);
804 BOOL handle_SSH2_userauth_inforeq(PTInstVar pvar);
805 BOOL handle_SSH2_userauth_pkok(PTInstVar pvar);
806 BOOL handle_SSH2_userauth_passwd_changereq(PTInstVar pvar);
807 void SSH2_update_compression_myproposal(PTInstVar pvar);
808 void SSH2_update_cipher_myproposal(PTInstVar pvar);
809 void SSH2_update_kex_myproposal(PTInstVar pvar);
810 void SSH2_update_host_key_myproposal(PTInstVar pvar);
811 void SSH2_update_hmac_myproposal(PTInstVar pvar);
812 int SSH_notify_break_signal(PTInstVar pvar);
813
814 ///
815 enum scp_state {
816 SCP_INIT, SCP_TIMESTAMP, SCP_FILEINFO, SCP_DATA, SCP_CLOSING,
817 };
818
819 typedef struct bufchain {
820 buffer_t *msg;
821 struct bufchain *next;
822 } bufchain_t;
823
824 typedef struct PacketList {
825 char *buf;
826 unsigned int buflen;
827 struct PacketList *next;
828 } PacketList_t;
829
830 typedef struct scp {
831 enum scp_dir dir; // transfer direction
832 enum scp_state state; // SCP state
833 char localfile[MAX_PATH]; // local filename
834 char localfilefull[MAX_PATH]; // local filename fullpath
835 char remotefile[MAX_PATH]; // remote filename
836 FILE *localfp; // file pointer for local file
837 struct __stat64 filestat; // file status information
838 HWND progress_window;
839 HANDLE thread;
840 unsigned int thread_id;
841 PTInstVar pvar;
842 // for receiving file
843 long long filetotalsize;
844 long long filercvsize;
845 DWORD filemtime;
846 DWORD fileatime;
847 PacketList_t *pktlist_head;
848 PacketList_t *pktlist_tail;
849 } scp_t;
850
851 enum sftp_state {
852 SFTP_INIT, SFTP_CONNECTED, SFTP_REALPATH,
853 };
854
855 typedef struct sftp {
856 enum sftp_state state;
857 HWND console_window;
858 unsigned int transfer_buflen;
859 unsigned int num_requests;
860 unsigned int version;
861 unsigned int msg_id;
862 #define SFTP_EXT_POSIX_RENAME 0x00000001
863 #define SFTP_EXT_STATVFS 0x00000002
864 #define SFTP_EXT_FSTATVFS 0x00000004
865 #define SFTP_EXT_HARDLINK 0x00000008
866 unsigned int exts;
867 unsigned long long limit_kbps;
868 //struct bwlimit bwlimit_in, bwlimit_out;
869 char path[1024];
870 } sftp_t;
871
872 typedef struct channel {
873 int used;
874 int self_id;
875 int remote_id;
876 unsigned int local_window;
877 unsigned int local_window_max;
878 unsigned int local_consumed;
879 unsigned int local_maxpacket;
880 unsigned int remote_window;
881 unsigned int remote_maxpacket;
882 enum channel_type type;
883 int local_num;
884 bufchain_t *bufchain;
885 unsigned long bufchain_amount;
886 BOOL bufchain_recv_suspended;
887 scp_t scp;
888 buffer_t *agent_msg;
889 int agent_request_len;
890 sftp_t sftp;
891 #define SSH_CHANNEL_STATE_CLOSE_SENT 0x00000001
892 unsigned int state;
893 } Channel_t;
894
895 unsigned char *begin_send_packet(PTInstVar pvar, int type, int len);
896 void finish_send_packet_special(PTInstVar pvar, int skip_compress);
897 void SSH2_send_channel_data(PTInstVar pvar, Channel_t *c, unsigned char *buf, unsigned int buflen, int retry);
898 Channel_t* ssh2_local_channel_lookup(int local_num);
899
900 #define finish_send_packet(pvar) finish_send_packet_special((pvar), 0)
901 #define get_payload_uint32(pvar, offset) get_uint32_MSBfirst((pvar)->ssh_state.payload + (offset))
902 #define get_uint32(buf) get_uint32_MSBfirst((buf))
903 #define set_uint32(buf, v) set_uint32_MSBfirst((buf), (v))
904 #define get_mpint_len(pvar, offset) ((get_ushort16_MSBfirst((pvar)->ssh_state.payload + (offset)) + 7) >> 3)
905 #define get_ushort16(buf) get_ushort16_MSBfirst((buf))
906 ///
907
908 /* Global request confirmation callbacks */
909 typedef void global_confirm_cb(PTInstVar pvar, int type, unsigned int seq, void *ctx);
910 void client_register_global_confirm(global_confirm_cb *cb, void *ctx);
911
912 /* Global request success/failure callbacks */
913 struct global_confirm {
914 global_confirm_cb *cb;
915 void *ctx;
916 int ref_count;
917 };
918
919 /*
920 * SSH bottom half after known_hosts
921 */
922 enum ssh_kex_known_hosts {
923 NONE_KNOWN_HOSTS = 0,
924 SSH1_PUBLIC_KEY_KNOWN_HOSTS,
925 SSH2_DH_KEX_REPLY_KNOWN_HOSTS,
926 SSH2_DH_GEX_REPLY_KNOWN_HOSTS,
927 SSH2_ECDH_KEX_REPLY_KNOWN_HOSTS,
928 };
929
930 typedef struct bottom_half_known_hosts {
931 enum ssh_kex_known_hosts kex_type;
932
933 unsigned char *payload;
934 int payload_len;
935 UINT_PTR payload_offset;
936
937 BOOL SSH2_MSG_NEWKEYS_received;
938 } bottom_half_known_hosts_t;
939
940 void handle_SSH2_canel_reply_after_known_hosts(PTInstVar pvar);
941
942 BOOL handle_server_public_key_after_known_hosts(PTInstVar pvar);
943 BOOL handle_SSH2_dh_kex_reply_after_known_hosts(PTInstVar pvar);
944 BOOL handle_SSH2_dh_gex_reply_after_known_hosts(PTInstVar pvar);
945 BOOL handle_SSH2_ecdh_kex_reply_after_known_hosts(PTInstVar pvar);
946
947 #endif
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help