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 6984 - (show annotations) (download) (as text)
Sat Nov 25 15:26:39 2017 UTC (6 years, 4 months ago) by doda
Original Path: trunk/ttssh2/ttxssh/ssh.h
File MIME type: text/x-chdr
File size: 31635 byte(s) 
ssh の暗号方式関連のコード整理

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