| 1 |
/* |
| 2 |
Copyright (c) 1998-2001, Robert O'Callahan |
| 3 |
All rights reserved. |
| 4 |
|
| 5 |
Redistribution and use in source and binary forms, with or without modification, |
| 6 |
are permitted provided that the following conditions are met: |
| 7 |
|
| 8 |
Redistributions of source code must retain the above copyright notice, this list of |
| 9 |
conditions and the following disclaimer. |
| 10 |
|
| 11 |
Redistributions in binary form must reproduce the above copyright notice, this list |
| 12 |
of conditions and the following disclaimer in the documentation and/or other materials |
| 13 |
provided with the distribution. |
| 14 |
|
| 15 |
The name of Robert O'Callahan may not be used to endorse or promote products derived from |
| 16 |
this software without specific prior written permission. |
| 17 |
|
| 18 |
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND |
| 19 |
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 20 |
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL |
| 21 |
THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| 22 |
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 23 |
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 24 |
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| 25 |
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| 26 |
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 |
*/ |
| 28 |
|
| 29 |
/* |
| 30 |
This code is copyright (C) 1998-1999 Robert O'Callahan. |
| 31 |
See LICENSE.TXT for the license. |
| 32 |
*/ |
| 33 |
|
| 34 |
#ifndef __SSH_H |
| 35 |
#define __SSH_H |
| 36 |
|
| 37 |
#include "zlib.h" |
| 38 |
#include <openssl/evp.h> |
| 39 |
|
| 40 |
#include "buffer.h" |
| 41 |
|
| 42 |
#define DEBUG_PRINT_TO_FILE(base, msg, len) { \ |
| 43 |
static int count = 0; \ |
| 44 |
debug_print(count + base, msg, len); \ |
| 45 |
count++; \ |
| 46 |
} |
| 47 |
|
| 48 |
// from OpenSSH |
| 49 |
extern const EVP_CIPHER *evp_aes_128_ctr(void); |
| 50 |
extern const EVP_CIPHER *evp_des3_ctr(void); |
| 51 |
extern const EVP_CIPHER *evp_bf_ctr(void); |
| 52 |
extern const EVP_CIPHER *evp_cast5_ctr(void); |
| 53 |
|
| 54 |
// yutaka |
| 55 |
#define SSH2_USE |
| 56 |
|
| 57 |
// HMAC-SHA2 draft |
| 58 |
// http://www.ietf.org/id/draft-dbider-sha2-mac-for-ssh-00.txt |
| 59 |
#undef HMAC_SHA2_DRAFT |
| 60 |
|
| 61 |
|
| 62 |
/* Some of this code has been adapted from Ian Goldberg's Pilot SSH */ |
| 63 |
|
| 64 |
typedef enum { |
| 65 |
SSH_MSG_NONE, SSH_MSG_DISCONNECT, SSH_SMSG_PUBLIC_KEY, //2 |
| 66 |
SSH_CMSG_SESSION_KEY, SSH_CMSG_USER, SSH_CMSG_AUTH_RHOSTS, // 5 |
| 67 |
SSH_CMSG_AUTH_RSA, SSH_SMSG_AUTH_RSA_CHALLENGE, |
| 68 |
SSH_CMSG_AUTH_RSA_RESPONSE, SSH_CMSG_AUTH_PASSWORD, |
| 69 |
SSH_CMSG_REQUEST_PTY, // 10 |
| 70 |
SSH_CMSG_WINDOW_SIZE, SSH_CMSG_EXEC_SHELL, |
| 71 |
SSH_CMSG_EXEC_CMD, SSH_SMSG_SUCCESS, SSH_SMSG_FAILURE, |
| 72 |
SSH_CMSG_STDIN_DATA, SSH_SMSG_STDOUT_DATA, SSH_SMSG_STDERR_DATA, |
| 73 |
SSH_CMSG_EOF, SSH_SMSG_EXITSTATUS, |
| 74 |
SSH_MSG_CHANNEL_OPEN_CONFIRMATION, SSH_MSG_CHANNEL_OPEN_FAILURE, |
| 75 |
SSH_MSG_CHANNEL_DATA, SSH_MSG_CHANNEL_INPUT_EOF, |
| 76 |
SSH_MSG_CHANNEL_OUTPUT_CLOSED, SSH_MSG_OBSOLETED0, |
| 77 |
SSH_SMSG_X11_OPEN, SSH_CMSG_PORT_FORWARD_REQUEST, SSH_MSG_PORT_OPEN, |
| 78 |
SSH_CMSG_AGENT_REQUEST_FORWARDING, SSH_SMSG_AGENT_OPEN, |
| 79 |
SSH_MSG_IGNORE, SSH_CMSG_EXIT_CONFIRMATION, |
| 80 |
SSH_CMSG_X11_REQUEST_FORWARDING, SSH_CMSG_AUTH_RHOSTS_RSA, |
| 81 |
SSH_MSG_DEBUG, SSH_CMSG_REQUEST_COMPRESSION, |
| 82 |
SSH_CMSG_MAX_PACKET_SIZE, SSH_CMSG_AUTH_TIS, |
| 83 |
SSH_SMSG_AUTH_TIS_CHALLENGE, SSH_CMSG_AUTH_TIS_RESPONSE, |
| 84 |
SSH_CMSG_AUTH_KERBEROS, SSH_SMSG_AUTH_KERBEROS_RESPONSE |
| 85 |
} SSHMessage; |
| 86 |
|
| 87 |
typedef enum { |
| 88 |
SSH_CIPHER_NONE, SSH_CIPHER_IDEA, SSH_CIPHER_DES, SSH_CIPHER_3DES, |
| 89 |
SSH_CIPHER_TSS, SSH_CIPHER_RC4, SSH_CIPHER_BLOWFISH, |
| 90 |
// for SSH2 |
| 91 |
SSH2_CIPHER_3DES_CBC, SSH2_CIPHER_AES128_CBC, |
| 92 |
SSH2_CIPHER_AES192_CBC, SSH2_CIPHER_AES256_CBC, |
| 93 |
SSH2_CIPHER_BLOWFISH_CBC, SSH2_CIPHER_AES128_CTR, |
| 94 |
SSH2_CIPHER_AES192_CTR, SSH2_CIPHER_AES256_CTR, |
| 95 |
SSH2_CIPHER_ARCFOUR, SSH2_CIPHER_ARCFOUR128, SSH2_CIPHER_ARCFOUR256, |
| 96 |
SSH2_CIPHER_CAST128_CBC, |
| 97 |
SSH2_CIPHER_3DES_CTR, SSH2_CIPHER_BLOWFISH_CTR, SSH2_CIPHER_CAST128_CTR, |
| 98 |
SSH_CIPHER_MAX = SSH2_CIPHER_CAST128_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, |
| 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 |
#define SSH2_MSG_DISCONNECT 1 |
| 139 |
#define SSH2_MSG_IGNORE 2 |
| 140 |
#define SSH2_MSG_UNIMPLEMENTED 3 |
| 141 |
#define SSH2_MSG_DEBUG 4 |
| 142 |
#define SSH2_MSG_SERVICE_REQUEST 5 |
| 143 |
#define SSH2_MSG_SERVICE_ACCEPT 6 |
| 144 |
|
| 145 |
#define SSH2_MSG_KEXINIT 20 |
| 146 |
#define SSH2_MSG_NEWKEYS 21 |
| 147 |
|
| 148 |
#define SSH2_MSG_KEXDH_INIT 30 |
| 149 |
#define SSH2_MSG_KEXDH_REPLY 31 |
| 150 |
|
| 151 |
#define SSH2_MSG_KEX_DH_GEX_GROUP 31 |
| 152 |
#define SSH2_MSG_KEX_DH_GEX_INIT 32 |
| 153 |
#define SSH2_MSG_KEX_DH_GEX_REPLY 33 |
| 154 |
#define SSH2_MSG_KEX_DH_GEX_REQUEST 34 |
| 155 |
|
| 156 |
#define SSH2_MSG_KEX_ECDH_INIT 30 |
| 157 |
#define SSH2_MSG_KEX_ECDH_REPLY 31 |
| 158 |
|
| 159 |
#define SSH2_MSG_USERAUTH_REQUEST 50 |
| 160 |
#define SSH2_MSG_USERAUTH_FAILURE 51 |
| 161 |
#define SSH2_MSG_USERAUTH_SUCCESS 52 |
| 162 |
#define SSH2_MSG_USERAUTH_BANNER 53 |
| 163 |
|
| 164 |
#define SSH2_MSG_USERAUTH_PK_OK 60 |
| 165 |
#define SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ 60 |
| 166 |
#define SSH2_MSG_USERAUTH_INFO_REQUEST 60 |
| 167 |
#define SSH2_MSG_USERAUTH_INFO_RESPONSE 61 |
| 168 |
|
| 169 |
#define SSH2_MSG_GLOBAL_REQUEST 80 |
| 170 |
#define SSH2_MSG_REQUEST_SUCCESS 81 |
| 171 |
#define SSH2_MSG_REQUEST_FAILURE 82 |
| 172 |
#define SSH2_MSG_CHANNEL_OPEN 90 |
| 173 |
#define SSH2_MSG_CHANNEL_OPEN_CONFIRMATION 91 |
| 174 |
#define SSH2_MSG_CHANNEL_OPEN_FAILURE 92 |
| 175 |
#define SSH2_MSG_CHANNEL_WINDOW_ADJUST 93 |
| 176 |
#define SSH2_MSG_CHANNEL_DATA 94 |
| 177 |
#define SSH2_MSG_CHANNEL_EXTENDED_DATA 95 |
| 178 |
#define SSH2_MSG_CHANNEL_EOF 96 |
| 179 |
#define SSH2_MSG_CHANNEL_CLOSE 97 |
| 180 |
#define SSH2_MSG_CHANNEL_REQUEST 98 |
| 181 |
#define SSH2_MSG_CHANNEL_SUCCESS 99 |
| 182 |
#define SSH2_MSG_CHANNEL_FAILURE 100 |
| 183 |
|
| 184 |
/* SSH2 miscellaneous constants */ |
| 185 |
#define SSH2_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1 |
| 186 |
#define SSH2_DISCONNECT_PROTOCOL_ERROR 2 |
| 187 |
#define SSH2_DISCONNECT_KEY_EXCHANGE_FAILED 3 |
| 188 |
#define SSH2_DISCONNECT_HOST_AUTHENTICATION_FAILED 4 |
| 189 |
#define SSH2_DISCONNECT_MAC_ERROR 5 |
| 190 |
#define SSH2_DISCONNECT_COMPRESSION_ERROR 6 |
| 191 |
#define SSH2_DISCONNECT_SERVICE_NOT_AVAILABLE 7 |
| 192 |
#define SSH2_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8 |
| 193 |
#define SSH2_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9 |
| 194 |
#define SSH2_DISCONNECT_CONNECTION_LOST 10 |
| 195 |
#define SSH2_DISCONNECT_BY_APPLICATION 11 |
| 196 |
|
| 197 |
#define SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED 1 |
| 198 |
#define SSH2_OPEN_CONNECT_FAILED 2 |
| 199 |
#define SSH2_OPEN_UNKNOWN_CHANNEL_TYPE 3 |
| 200 |
#define SSH2_OPEN_RESOURCE_SHORTAGE 4 |
| 201 |
|
| 202 |
|
| 203 |
// �N���C�A���g�����T�[�o������������ |
| 204 |
enum kex_init_proposals { |
| 205 |
PROPOSAL_KEX_ALGS, |
| 206 |
PROPOSAL_SERVER_HOST_KEY_ALGS, |
| 207 |
PROPOSAL_ENC_ALGS_CTOS, |
| 208 |
PROPOSAL_ENC_ALGS_STOC, |
| 209 |
PROPOSAL_MAC_ALGS_CTOS, |
| 210 |
PROPOSAL_MAC_ALGS_STOC, |
| 211 |
PROPOSAL_COMP_ALGS_CTOS, |
| 212 |
PROPOSAL_COMP_ALGS_STOC, |
| 213 |
PROPOSAL_LANG_CTOS, |
| 214 |
PROPOSAL_LANG_STOC, |
| 215 |
PROPOSAL_MAX |
| 216 |
}; |
| 217 |
|
| 218 |
#define KEX_DEFAULT_KEX "" |
| 219 |
#define KEX_DEFAULT_PK_ALG "" |
| 220 |
#define KEX_DEFAULT_ENCRYPT "" |
| 221 |
#define KEX_DEFAULT_MAC "" |
| 222 |
#define KEX_DEFAULT_COMP "" |
| 223 |
#define KEX_DEFAULT_LANG "" |
| 224 |
|
| 225 |
static char *myproposal[PROPOSAL_MAX] = { |
| 226 |
KEX_DEFAULT_KEX, |
| 227 |
KEX_DEFAULT_PK_ALG, |
| 228 |
KEX_DEFAULT_ENCRYPT, |
| 229 |
KEX_DEFAULT_ENCRYPT, |
| 230 |
KEX_DEFAULT_MAC, |
| 231 |
KEX_DEFAULT_MAC, |
| 232 |
KEX_DEFAULT_COMP, |
| 233 |
KEX_DEFAULT_COMP, |
| 234 |
KEX_DEFAULT_LANG, |
| 235 |
KEX_DEFAULT_LANG, |
| 236 |
}; |
| 237 |
|
| 238 |
|
| 239 |
typedef enum { |
| 240 |
KEY_NONE, |
| 241 |
KEY_RSA1, |
| 242 |
KEY_RSA, |
| 243 |
KEY_DSA, |
| 244 |
KEY_ECDSA256, |
| 245 |
KEY_ECDSA384, |
| 246 |
KEY_ECDSA521, |
| 247 |
KEY_UNSPEC, |
| 248 |
KEY_MAX = KEY_UNSPEC, |
| 249 |
} ssh_keytype; |
| 250 |
#define isECDSAkey(type) ((type) >= KEY_ECDSA256 && (type) <= KEY_ECDSA521) |
| 251 |
|
| 252 |
typedef struct ssh2_host_key { |
| 253 |
ssh_keytype type; |
| 254 |
char *name; |
| 255 |
} ssh2_host_key_t; |
| 256 |
|
| 257 |
static ssh2_host_key_t ssh2_host_key[] = { |
| 258 |
{KEY_RSA1, "ssh-rsa1"}, // for SSH1 only |
| 259 |
{KEY_RSA, "ssh-rsa"}, |
| 260 |
{KEY_DSA, "ssh-dss"}, |
| 261 |
{KEY_ECDSA256, "ecdsa-sha2-nistp256"}, |
| 262 |
{KEY_ECDSA384, "ecdsa-sha2-nistp384"}, |
| 263 |
{KEY_ECDSA521, "ecdsa-sha2-nistp521"}, |
| 264 |
{KEY_UNSPEC, "ssh-unknown"}, |
| 265 |
{KEY_NONE, NULL}, |
| 266 |
}; |
| 267 |
|
| 268 |
/* Minimum modulus size (n) for RSA keys. */ |
| 269 |
#define SSH_RSA_MINIMUM_MODULUS_SIZE 768 |
| 270 |
|
| 271 |
#define SSH_KEYGEN_DEFAULT_BITS 2048 |
| 272 |
#define SSH_RSA_MINIMUM_KEY_SIZE 768 |
| 273 |
#define SSH_DSA_MINIMUM_KEY_SIZE 1024 |
| 274 |
|
| 275 |
|
| 276 |
typedef struct ssh2_cipher { |
| 277 |
SSHCipher cipher; |
| 278 |
char *name; |
| 279 |
int block_size; |
| 280 |
int key_len; |
| 281 |
int discard_len; |
| 282 |
const EVP_CIPHER *(*func)(void); |
| 283 |
} ssh2_cipher_t; |
| 284 |
|
| 285 |
static ssh2_cipher_t ssh2_ciphers[] = { |
| 286 |
{SSH2_CIPHER_3DES_CBC, "3des-cbc", 8, 24, 0, EVP_des_ede3_cbc}, |
| 287 |
{SSH2_CIPHER_AES128_CBC, "aes128-cbc", 16, 16, 0, EVP_aes_128_cbc}, |
| 288 |
{SSH2_CIPHER_AES192_CBC, "aes192-cbc", 16, 24, 0, EVP_aes_192_cbc}, |
| 289 |
{SSH2_CIPHER_AES256_CBC, "aes256-cbc", 16, 32, 0, EVP_aes_256_cbc}, |
| 290 |
{SSH2_CIPHER_BLOWFISH_CBC, "blowfish-cbc", 8, 16, 0, EVP_bf_cbc}, |
| 291 |
{SSH2_CIPHER_AES128_CTR, "aes128-ctr", 16, 16, 0, evp_aes_128_ctr}, |
| 292 |
{SSH2_CIPHER_AES192_CTR, "aes192-ctr", 16, 24, 0, evp_aes_128_ctr}, |
| 293 |
{SSH2_CIPHER_AES256_CTR, "aes256-ctr", 16, 32, 0, evp_aes_128_ctr}, |
| 294 |
{SSH2_CIPHER_ARCFOUR, "arcfour", 8, 16, 0, EVP_rc4}, |
| 295 |
{SSH2_CIPHER_ARCFOUR128, "arcfour128", 8, 16, 1536, EVP_rc4}, |
| 296 |
{SSH2_CIPHER_ARCFOUR256, "arcfour256", 8, 32, 1536, EVP_rc4}, |
| 297 |
{SSH2_CIPHER_CAST128_CBC, "cast128-cbc", 8, 16, 0, EVP_cast5_cbc}, |
| 298 |
{SSH2_CIPHER_3DES_CTR, "3des-ctr", 8, 24, 0, evp_des3_ctr}, |
| 299 |
{SSH2_CIPHER_BLOWFISH_CTR, "blowfish-ctr", 8, 16, 0, evp_bf_ctr}, |
| 300 |
{SSH2_CIPHER_CAST128_CTR, "cast128-ctr", 8, 16, 0, evp_cast5_ctr}, |
| 301 |
{SSH_CIPHER_NONE, NULL, 0, 0, 0, NULL}, |
| 302 |
}; |
| 303 |
|
| 304 |
|
| 305 |
typedef enum { |
| 306 |
KEX_DH_NONE, /* disabled line */ |
| 307 |
KEX_DH_GRP1_SHA1, |
| 308 |
KEX_DH_GRP14_SHA1, |
| 309 |
KEX_DH_GEX_SHA1, |
| 310 |
KEX_DH_GEX_SHA256, |
| 311 |
KEX_ECDH_SHA2_256, |
| 312 |
KEX_ECDH_SHA2_384, |
| 313 |
KEX_ECDH_SHA2_521, |
| 314 |
KEX_DH_UNKNOWN, |
| 315 |
KEX_DH_MAX = KEX_DH_UNKNOWN, |
| 316 |
} kex_algorithm; |
| 317 |
|
| 318 |
typedef struct ssh2_kex_algorithm { |
| 319 |
kex_algorithm kextype; |
| 320 |
char *name; |
| 321 |
const EVP_MD *(*evp_md)(void); |
| 322 |
} ssh2_kex_algorithm_t; |
| 323 |
|
| 324 |
static ssh2_kex_algorithm_t ssh2_kex_algorithms[] = { |
| 325 |
{KEX_DH_GRP1_SHA1, "diffie-hellman-group1-sha1", EVP_sha1}, |
| 326 |
{KEX_DH_GRP14_SHA1, "diffie-hellman-group14-sha1", EVP_sha1}, |
| 327 |
{KEX_DH_GEX_SHA1, "diffie-hellman-group-exchange-sha1", EVP_sha1}, |
| 328 |
{KEX_DH_GEX_SHA256, "diffie-hellman-group-exchange-sha256", EVP_sha256}, |
| 329 |
{KEX_ECDH_SHA2_256, "ecdh-sha2-nistp256", EVP_sha256}, |
| 330 |
{KEX_ECDH_SHA2_384, "ecdh-sha2-nistp384", EVP_sha384}, |
| 331 |
{KEX_ECDH_SHA2_521, "ecdh-sha2-nistp521", EVP_sha512}, |
| 332 |
{KEX_DH_NONE , NULL, NULL}, |
| 333 |
}; |
| 334 |
|
| 335 |
|
| 336 |
typedef enum { |
| 337 |
HMAC_NONE, /* disabled line */ |
| 338 |
HMAC_SHA1, |
| 339 |
HMAC_MD5, |
| 340 |
HMAC_SHA1_96, |
| 341 |
HMAC_MD5_96, |
| 342 |
HMAC_RIPEMD160, |
| 343 |
#ifdef HMAC_SHA2_DRAFT // HMAC-SHA2 support |
| 344 |
HMAC_SHA2_256, |
| 345 |
HMAC_SHA2_256_96, |
| 346 |
HMAC_SHA2_512, |
| 347 |
HMAC_SHA2_512_96, |
| 348 |
#endif // HMAC-SHA2 support |
| 349 |
HMAC_UNKNOWN, |
| 350 |
HMAC_MAX = HMAC_UNKNOWN, |
| 351 |
} hmac_type; |
| 352 |
|
| 353 |
typedef struct ssh2_mac { |
| 354 |
hmac_type type; |
| 355 |
char *name; |
| 356 |
const EVP_MD *(*evp_md)(void); |
| 357 |
int truncatebits; |
| 358 |
} ssh2_mac_t; |
| 359 |
|
| 360 |
static ssh2_mac_t ssh2_macs[] = { |
| 361 |
{HMAC_SHA1, "hmac-sha1", EVP_sha1, 0}, |
| 362 |
{HMAC_MD5, "hmac-md5", EVP_md5, 0}, |
| 363 |
{HMAC_SHA1_96, "hmac-sha1-96", EVP_sha1, 96}, |
| 364 |
{HMAC_MD5_96, "hmac-md5-96", EVP_md5, 96}, |
| 365 |
{HMAC_RIPEMD160, "hmac-ripemd160@openssh.com", EVP_ripemd160, 0}, |
| 366 |
#if HMAC_SHA2_DRAFT // HMAC-SHA2 support |
| 367 |
{HMAC_SHA2_256, "hmac-sha2-256", EVP_sha256, 0}, |
| 368 |
{HMAC_SHA2_256_96, "hmac-sha2-256-96", EVP_sha256, 96}, |
| 369 |
{HMAC_SHA2_512, "hmac-sha2-512", EVP_sha512, 0}, |
| 370 |
{HMAC_SHA2_512_96, "hmac-sha2-512-96", EVP_sha512, 96}, |
| 371 |
#endif // HMAC-SHA2 support |
| 372 |
{HMAC_NONE, NULL, NULL, 0}, |
| 373 |
}; |
| 374 |
|
| 375 |
|
| 376 |
typedef enum { |
| 377 |
COMP_NONE, /* disabled line */ |
| 378 |
COMP_NOCOMP, |
| 379 |
COMP_ZLIB, |
| 380 |
COMP_DELAYED, |
| 381 |
COMP_UNKNOWN, |
| 382 |
COMP_MAX = COMP_UNKNOWN, |
| 383 |
} compression_type; |
| 384 |
|
| 385 |
typedef struct ssh2_comp { |
| 386 |
compression_type type; |
| 387 |
char *name; |
| 388 |
} ssh2_comp_t; |
| 389 |
|
| 390 |
static ssh2_comp_t ssh2_comps[] = { |
| 391 |
{COMP_NOCOMP, "none"}, |
| 392 |
{COMP_ZLIB, "zlib"}, |
| 393 |
{COMP_DELAYED, "zlib@openssh.com"}, |
| 394 |
{COMP_NONE, NULL}, |
| 395 |
}; |
| 396 |
|
| 397 |
|
| 398 |
struct Enc { |
| 399 |
u_char *key; |
| 400 |
u_char *iv; |
| 401 |
unsigned int key_len; |
| 402 |
unsigned int block_size; |
| 403 |
}; |
| 404 |
|
| 405 |
struct Mac { |
| 406 |
char *name; |
| 407 |
int enabled; |
| 408 |
const EVP_MD *md; |
| 409 |
int mac_len; |
| 410 |
u_char *key; |
| 411 |
int key_len; |
| 412 |
}; |
| 413 |
|
| 414 |
struct Comp { |
| 415 |
int type; |
| 416 |
int enabled; |
| 417 |
char *name; |
| 418 |
}; |
| 419 |
|
| 420 |
typedef struct { |
| 421 |
struct Enc enc; |
| 422 |
struct Mac mac; |
| 423 |
struct Comp comp; |
| 424 |
} Newkeys; |
| 425 |
|
| 426 |
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) |
| 427 |
|
| 428 |
enum kex_modes { |
| 429 |
MODE_IN, |
| 430 |
MODE_OUT, |
| 431 |
MODE_MAX |
| 432 |
}; |
| 433 |
|
| 434 |
|
| 435 |
// �z�X�g�L�[(SSH1, SSH2����)���f�[�^�\�� (2006.3.21 yutaka) |
| 436 |
typedef struct Key { |
| 437 |
// host key type |
| 438 |
ssh_keytype type; |
| 439 |
// SSH2 RSA |
| 440 |
RSA *rsa; |
| 441 |
// SSH2 DSA |
| 442 |
DSA *dsa; |
| 443 |
// SSH2 ECDSA |
| 444 |
EC_KEY *ecdsa; |
| 445 |
// SSH1 RSA |
| 446 |
int bits; |
| 447 |
unsigned char *exp; |
| 448 |
unsigned char *mod; |
| 449 |
} Key; |
| 450 |
|
| 451 |
// fingerprint������ |
| 452 |
enum fp_rep { |
| 453 |
SSH_FP_HEX, |
| 454 |
SSH_FP_BUBBLEBABBLE, |
| 455 |
SSH_FP_RANDOMART |
| 456 |
}; |
| 457 |
|
| 458 |
enum scp_dir { |
| 459 |
TOREMOTE, FROMREMOTE, |
| 460 |
}; |
| 461 |
|
| 462 |
/* The packet handler returns TRUE to keep the handler in place, |
| 463 |
FALSE to remove the handler. */ |
| 464 |
typedef BOOL (* SSHPacketHandler)(PTInstVar pvar); |
| 465 |
|
| 466 |
typedef struct _SSHPacketHandlerItem SSHPacketHandlerItem; |
| 467 |
struct _SSHPacketHandlerItem { |
| 468 |
SSHPacketHandler handler; |
| 469 |
/* Circular list of handlers for given message */ |
| 470 |
SSHPacketHandlerItem FAR * next_for_message; |
| 471 |
SSHPacketHandlerItem FAR * last_for_message; |
| 472 |
/* Circular list of handlers in set */ |
| 473 |
SSHPacketHandlerItem FAR * next_in_set; |
| 474 |
int active_for_message; |
| 475 |
}; |
| 476 |
|
| 477 |
typedef struct { |
| 478 |
char FAR * hostname; |
| 479 |
|
| 480 |
int server_protocol_flags; |
| 481 |
char FAR * server_ID; |
| 482 |
|
| 483 |
/* This buffer is used to hold the outgoing data, and encrypted in-place |
| 484 |
here if necessary. */ |
| 485 |
unsigned char FAR * outbuf; |
| 486 |
long outbuflen; |
| 487 |
/* This buffer is used by the SSH protocol processing to store uncompressed |
| 488 |
packet data for compression. User data is never streamed through here; |
| 489 |
it is compressed directly from the user's buffer. */ |
| 490 |
unsigned char FAR * precompress_outbuf; |
| 491 |
long precompress_outbuflen; |
| 492 |
/* this is the length of the packet data, including the type header */ |
| 493 |
long outgoing_packet_len; |
| 494 |
|
| 495 |
/* This buffer is used by the SSH protocol processing to store decompressed |
| 496 |
packet data. User data is never streamed through here; it is decompressed |
| 497 |
directly to the user's buffer. */ |
| 498 |
unsigned char FAR * postdecompress_inbuf; |
| 499 |
long postdecompress_inbuflen; |
| 500 |
|
| 501 |
unsigned char FAR * payload; |
| 502 |
long payload_grabbed; |
| 503 |
long payloadlen; |
| 504 |
long payload_datastart; |
| 505 |
long payload_datalen; |
| 506 |
|
| 507 |
uint32 receiver_sequence_number; |
| 508 |
uint32 sender_sequence_number; |
| 509 |
|
| 510 |
z_stream compress_stream; |
| 511 |
z_stream decompress_stream; |
| 512 |
BOOL compressing; |
| 513 |
BOOL decompressing; |
| 514 |
int compression_level; |
| 515 |
|
| 516 |
SSHPacketHandlerItem FAR * packet_handlers[256]; |
| 517 |
int status_flags; |
| 518 |
|
| 519 |
int win_cols; |
| 520 |
int win_rows; |
| 521 |
|
| 522 |
unsigned short tcpport; |
| 523 |
} SSHState; |
| 524 |
|
| 525 |
#define STATUS_DONT_SEND_USER_NAME 0x01 |
| 526 |
#define STATUS_EXPECTING_COMPRESSION_RESPONSE 0x02 |
| 527 |
#define STATUS_DONT_SEND_CREDENTIALS 0x04 |
| 528 |
#define STATUS_HOST_OK 0x08 |
| 529 |
#define STATUS_INTERACTIVE 0x10 |
| 530 |
#define STATUS_IN_PARTIAL_ID_STRING 0x20 |
| 531 |
|
| 532 |
void SSH_init(PTInstVar pvar); |
| 533 |
void SSH_open(PTInstVar pvar); |
| 534 |
void SSH_notify_disconnecting(PTInstVar pvar, char FAR * reason); |
| 535 |
/* SSH_handle_server_ID returns TRUE iff a valid ID string has been |
| 536 |
received. If it returns FALSE, we need to keep looking for another |
| 537 |
ID string. */ |
| 538 |
BOOL SSH_handle_server_ID(PTInstVar pvar, char FAR * ID, int ID_len); |
| 539 |
/* SSH_handle_packet requires NO PAYLOAD on entry. |
| 540 |
'len' is the size of the packet: payload + padding (+ CRC for SSHv1) |
| 541 |
'padding' is the size of the padding. |
| 542 |
'data' points to the start of the packet data (the length field) |
| 543 |
*/ |
| 544 |
void SSH_handle_packet(PTInstVar pvar, char FAR * data, int len, int padding); |
| 545 |
void SSH_notify_win_size(PTInstVar pvar, int cols, int rows); |
| 546 |
void SSH_notify_user_name(PTInstVar pvar); |
| 547 |
void SSH_notify_cred(PTInstVar pvar); |
| 548 |
void SSH_notify_host_OK(PTInstVar pvar); |
| 549 |
void SSH_send(PTInstVar pvar, unsigned char const FAR * buf, unsigned int buflen); |
| 550 |
/* SSH_extract_payload returns number of bytes extracted */ |
| 551 |
int SSH_extract_payload(PTInstVar pvar, unsigned char FAR * dest, int len); |
| 552 |
void SSH_end(PTInstVar pvar); |
| 553 |
|
| 554 |
void SSH_get_server_ID_info(PTInstVar pvar, char FAR * dest, int len); |
| 555 |
void SSH_get_protocol_version_info(PTInstVar pvar, char FAR * dest, int len); |
| 556 |
void SSH_get_compression_info(PTInstVar pvar, char FAR * dest, int len); |
| 557 |
|
| 558 |
/* len must be <= SSH_MAX_SEND_PACKET_SIZE */ |
| 559 |
void SSH_channel_send(PTInstVar pvar, int channel_num, |
| 560 |
uint32 remote_channel_num, |
| 561 |
unsigned char FAR * buf, int len); |
| 562 |
void SSH_fail_channel_open(PTInstVar pvar, uint32 remote_channel_num); |
| 563 |
void SSH_confirm_channel_open(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num); |
| 564 |
void SSH_channel_output_eof(PTInstVar pvar, uint32 remote_channel_num); |
| 565 |
void SSH_channel_input_eof(PTInstVar pvar, uint32 remote_channel_num, uint32 local_channel_num); |
| 566 |
void SSH_request_forwarding(PTInstVar pvar, char FAR * bind_address, int from_server_port, |
| 567 |
char FAR * to_local_host, int to_local_port); |
| 568 |
void SSH_request_X11_forwarding(PTInstVar pvar, |
| 569 |
char FAR * auth_protocol, unsigned char FAR * auth_data, int auth_data_len, int screen_num); |
| 570 |
void SSH_open_channel(PTInstVar pvar, uint32 local_channel_num, |
| 571 |
char FAR * to_remote_host, int to_remote_port, |
| 572 |
char FAR * originator, unsigned short originator_port); |
| 573 |
|
| 574 |
int SSH_start_scp(PTInstVar pvar, char *sendfile, char *dstfile); |
| 575 |
int SSH_start_scp_receive(PTInstVar pvar, char *filename); |
| 576 |
int SSH_scp_transaction(PTInstVar pvar, char *sendfile, char *dstfile, enum scp_dir direction); |
| 577 |
int SSH_sftp_transaction(PTInstVar pvar); |
| 578 |
|
| 579 |
/* auxiliary SSH2 interfaces for pkt.c */ |
| 580 |
int SSH_get_min_packet_size(PTInstVar pvar); |
| 581 |
/* data is guaranteed to be at least SSH_get_min_packet_size bytes long |
| 582 |
at least 5 bytes must be decrypted */ |
| 583 |
void SSH_predecrpyt_packet(PTInstVar pvar, char FAR * data); |
| 584 |
int SSH_get_clear_MAC_size(PTInstVar pvar); |
| 585 |
|
| 586 |
#define SSH_is_any_payload(pvar) ((pvar)->ssh_state.payload_datalen > 0) |
| 587 |
#define SSH_get_host_name(pvar) ((pvar)->ssh_state.hostname) |
| 588 |
#define SSH_get_compression_level(pvar) ((pvar)->ssh_state.compressing ? (pvar)->ts_SSH_CompressionLevel : 0) |
| 589 |
|
| 590 |
void SSH2_send_kexinit(PTInstVar pvar); |
| 591 |
BOOL do_SSH2_userauth(PTInstVar pvar); |
| 592 |
BOOL do_SSH2_authrequest(PTInstVar pvar); |
| 593 |
void debug_print(int no, char *msg, int len); |
| 594 |
int get_cipher_block_size(SSHCipher cipher); |
| 595 |
int get_cipher_key_len(SSHCipher cipher); |
| 596 |
char* get_kex_algorithm_name(kex_algorithm kextype); |
| 597 |
const EVP_CIPHER* get_cipher_EVP_CIPHER(SSHCipher cipher); |
| 598 |
const EVP_MD* get_kex_algorithm_EVP_MD(kex_algorithm kextype); |
| 599 |
char* get_ssh2_mac_name(hmac_type type); |
| 600 |
const EVP_MD* get_ssh2_mac_EVP_MD(hmac_type type); |
| 601 |
int get_ssh2_mac_truncatebits(hmac_type type); |
| 602 |
char* get_ssh2_comp_name(compression_type type); |
| 603 |
char* get_ssh_keytype_name(ssh_keytype type); |
| 604 |
int get_cipher_discard_len(SSHCipher cipher); |
| 605 |
void ssh_heartbeat_lock_initialize(void); |
| 606 |
void ssh_heartbeat_lock_finalize(void); |
| 607 |
void ssh_heartbeat_lock(void); |
| 608 |
void ssh_heartbeat_unlock(void); |
| 609 |
void halt_ssh_heartbeat_thread(PTInstVar pvar); |
| 610 |
void ssh2_channel_free(void); |
| 611 |
BOOL handle_SSH2_userauth_inforeq(PTInstVar pvar); |
| 612 |
BOOL handle_SSH2_userauth_passwd_changereq(PTInstVar pvar); |
| 613 |
void SSH2_update_compression_myproposal(PTInstVar pvar); |
| 614 |
void SSH2_update_cipher_myproposal(PTInstVar pvar); |
| 615 |
void SSH2_update_kex_myproposal(PTInstVar pvar); |
| 616 |
void SSH2_update_host_key_myproposal(PTInstVar pvar); |
| 617 |
void SSH2_update_hmac_myproposal(PTInstVar pvar); |
| 618 |
int SSH_notify_break_signal(PTInstVar pvar); |
| 619 |
|
| 620 |
#endif |
Tera Term
Parent Directory
Revision Log