1 /*- 2 * Copyright (c) 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)encrypt.c 8.2 (Berkeley) 5/30/95 34 * $FreeBSD: src/crypto/telnet/libtelnet/encrypt.c,v 1.3.2.2 2002/04/13 10:59:07 markm Exp $ 35 */ 36 37 /* 38 * Copyright (C) 1990 by the Massachusetts Institute of Technology 39 * 40 * Export of this software from the United States of America is assumed 41 * to require a specific license from the United States Government. 42 * It is the responsibility of any person or organization contemplating 43 * export to obtain such a license before exporting. 44 * 45 * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and 46 * distribute this software and its documentation for any purpose and 47 * without fee is hereby granted, provided that the above copyright 48 * notice appear in all copies and that both that copyright notice and 49 * this permission notice appear in supporting documentation, and that 50 * the name of M.I.T. not be used in advertising or publicity pertaining 51 * to distribution of the software without specific, written prior 52 * permission. M.I.T. makes no representations about the suitability of 53 * this software for any purpose. It is provided "as is" without express 54 * or implied warranty. 55 */ 56 57 #ifdef ENCRYPTION 58 59 #define ENCRYPT_NAMES 60 #include <arpa/telnet.h> 61 #include <stdio.h> 62 #include <stdlib.h> 63 #include <string.h> 64 65 #include "encrypt.h" 66 #include "misc.h" 67 68 /* 69 * These functions pointers point to the current routines 70 * for encrypting and decrypting data. 71 */ 72 void (*encrypt_output)(unsigned char *, int); 73 int (*decrypt_input)(int); 74 75 int EncryptType(char *type, char *mode); 76 int EncryptStart(char *mode); 77 int EncryptStop(char *mode); 78 int EncryptStartInput(void); 79 int EncryptStartOutput(void); 80 int EncryptStopInput(void); 81 int EncryptStopOutput(void); 82 83 int encrypt_debug_mode = 0; 84 static int decrypt_mode = 0; 85 static int encrypt_mode = 0; 86 static int encrypt_verbose = 0; 87 static int autoencrypt = 0; 88 static int autodecrypt = 0; 89 static int havesessionkey = 0; 90 static int Server = 0; 91 static const char *Name = "Noname"; 92 93 #define typemask(x) ((x) > 0 ? 1 << ((x)-1) : 0) 94 95 static long i_support_encrypt = 0 96 | typemask(ENCTYPE_DES_CFB64) | typemask(ENCTYPE_DES_OFB64) 97 |0; 98 static long i_support_decrypt = 0 99 | typemask(ENCTYPE_DES_CFB64) | typemask(ENCTYPE_DES_OFB64) 100 |0; 101 102 static long i_wont_support_encrypt = 0; 103 static long i_wont_support_decrypt = 0; 104 #define I_SUPPORT_ENCRYPT (i_support_encrypt & ~i_wont_support_encrypt) 105 #define I_SUPPORT_DECRYPT (i_support_decrypt & ~i_wont_support_decrypt) 106 107 static long remote_supports_encrypt = 0; 108 static long remote_supports_decrypt = 0; 109 110 static Encryptions encryptions[] = { 111 { "DES_CFB64", ENCTYPE_DES_CFB64, 112 cfb64_encrypt, 113 cfb64_decrypt, 114 cfb64_init, 115 cfb64_start, 116 cfb64_is, 117 cfb64_reply, 118 cfb64_session, 119 cfb64_keyid, 120 cfb64_printsub }, 121 { "DES_OFB64", ENCTYPE_DES_OFB64, 122 ofb64_encrypt, 123 ofb64_decrypt, 124 ofb64_init, 125 ofb64_start, 126 ofb64_is, 127 ofb64_reply, 128 ofb64_session, 129 ofb64_keyid, 130 ofb64_printsub }, 131 { NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 132 }; 133 134 static unsigned char str_send[64] = { IAC, SB, TELOPT_ENCRYPT, 135 ENCRYPT_SUPPORT }; 136 static unsigned char str_suplen = 0; 137 static unsigned char str_start[72] = { IAC, SB, TELOPT_ENCRYPT }; 138 static unsigned char str_end[] = { IAC, SB, TELOPT_ENCRYPT, 0, IAC, SE }; 139 140 Encryptions * 141 findencryption(int type) 142 { 143 Encryptions *ep = encryptions; 144 145 if (!(I_SUPPORT_ENCRYPT & remote_supports_decrypt & (unsigned)typemask(type))) 146 return(0); 147 while (ep->type && ep->type != type) 148 ++ep; 149 return(ep->type ? ep : 0); 150 } 151 152 static Encryptions * 153 finddecryption(int type) 154 { 155 Encryptions *ep = encryptions; 156 157 if (!(I_SUPPORT_DECRYPT & remote_supports_encrypt & (unsigned)typemask(type))) 158 return(0); 159 while (ep->type && ep->type != type) 160 ++ep; 161 return(ep->type ? ep : 0); 162 } 163 164 #define MAXKEYLEN 64 165 166 static struct key_info { 167 unsigned char keyid[MAXKEYLEN]; 168 int keylen; 169 int dir; 170 int *modep; 171 Encryptions *(*getcrypt)(int); 172 } ki[2] = { 173 { { 0 }, 0, DIR_ENCRYPT, &encrypt_mode, findencryption }, 174 { { 0 }, 0, DIR_DECRYPT, &decrypt_mode, finddecryption }, 175 }; 176 177 static void encrypt_keyid(struct key_info *kp, unsigned char *keyid, int len); 178 179 void 180 encrypt_init(const char *name, int server) 181 { 182 Encryptions *ep = encryptions; 183 184 Name = name; 185 Server = server; 186 i_support_encrypt = i_support_decrypt = 0; 187 remote_supports_encrypt = remote_supports_decrypt = 0; 188 encrypt_mode = 0; 189 decrypt_mode = 0; 190 encrypt_output = NULL; 191 decrypt_input = NULL; 192 193 str_suplen = 4; 194 195 while (ep->type) { 196 if (encrypt_debug_mode) 197 printf(">>>%s: I will support %s\r\n", 198 Name, ENCTYPE_NAME(ep->type)); 199 i_support_encrypt |= typemask(ep->type); 200 i_support_decrypt |= typemask(ep->type); 201 if ((i_wont_support_decrypt & typemask(ep->type)) == 0) 202 if ((str_send[str_suplen++] = ep->type) == IAC) 203 str_send[str_suplen++] = IAC; 204 if (ep->init) 205 (*ep->init)(Server); 206 ++ep; 207 } 208 str_send[str_suplen++] = IAC; 209 str_send[str_suplen++] = SE; 210 } 211 212 static void 213 encrypt_list_types(void) 214 { 215 Encryptions *ep = encryptions; 216 217 printf("Valid encryption types:\n"); 218 while (ep->type) { 219 printf("\t%s (%d)\r\n", ENCTYPE_NAME(ep->type), ep->type); 220 ++ep; 221 } 222 } 223 224 int 225 EncryptEnable(char *type, char *mode) 226 { 227 if (isprefix(type, "help") || isprefix(type, "?")) { 228 printf("Usage: encrypt enable <type> [input|output]\n"); 229 encrypt_list_types(); 230 return(0); 231 } 232 if (EncryptType(type, mode)) 233 return(EncryptStart(mode)); 234 return(0); 235 } 236 237 int 238 EncryptDisable(char *type, char *mode) 239 { 240 Encryptions *ep; 241 int ret = 0; 242 243 if (isprefix(type, "help") || isprefix(type, "?")) { 244 printf("Usage: encrypt disable <type> [input|output]\n"); 245 encrypt_list_types(); 246 } else if ((ep = (Encryptions *)genget(type, (char **)encryptions, 247 sizeof(Encryptions))) == NULL) { 248 printf("%s: invalid encryption type\n", type); 249 } else if (Ambiguous((char **)ep)) { 250 printf("Ambiguous type '%s'\n", type); 251 } else { 252 if ((mode == NULL) || (isprefix(mode, "input") ? 1 : 0)) { 253 if (decrypt_mode == ep->type) 254 EncryptStopInput(); 255 i_wont_support_decrypt |= typemask(ep->type); 256 ret = 1; 257 } 258 if ((mode == NULL) || (isprefix(mode, "output"))) { 259 if (encrypt_mode == ep->type) 260 EncryptStopOutput(); 261 i_wont_support_encrypt |= typemask(ep->type); 262 ret = 1; 263 } 264 if (ret == 0) 265 printf("%s: invalid encryption mode\n", mode); 266 } 267 return(ret); 268 } 269 270 int 271 EncryptType(char *type, char *mode) 272 { 273 Encryptions *ep; 274 int ret = 0; 275 276 if (isprefix(type, "help") || isprefix(type, "?")) { 277 printf("Usage: encrypt type <type> [input|output]\n"); 278 encrypt_list_types(); 279 } else if ((ep = (Encryptions *)genget(type, (char **)encryptions, 280 sizeof(Encryptions))) == NULL) { 281 printf("%s: invalid encryption type\n", type); 282 } else if (Ambiguous((char **)ep)) { 283 printf("Ambiguous type '%s'\n", type); 284 } else { 285 if ((mode == NULL) || isprefix(mode, "input")) { 286 decrypt_mode = ep->type; 287 i_wont_support_decrypt &= ~typemask(ep->type); 288 ret = 1; 289 } 290 if ((mode == NULL) || isprefix(mode, "output")) { 291 encrypt_mode = ep->type; 292 i_wont_support_encrypt &= ~typemask(ep->type); 293 ret = 1; 294 } 295 if (ret == 0) 296 printf("%s: invalid encryption mode\n", mode); 297 } 298 return(ret); 299 } 300 301 int 302 EncryptStart(char *mode) 303 { 304 int ret = 0; 305 if (mode) { 306 if (isprefix(mode, "input")) 307 return(EncryptStartInput()); 308 if (isprefix(mode, "output")) 309 return(EncryptStartOutput()); 310 if (isprefix(mode, "help") || isprefix(mode, "?")) { 311 printf("Usage: encrypt start [input|output]\n"); 312 return(0); 313 } 314 printf("%s: invalid encryption mode 'encrypt start ?' for help\n", mode); 315 return(0); 316 } 317 ret += EncryptStartInput(); 318 ret += EncryptStartOutput(); 319 return(ret); 320 } 321 322 int 323 EncryptStartInput(void) 324 { 325 if (decrypt_mode) { 326 encrypt_send_request_start(); 327 return(1); 328 } 329 printf("No previous decryption mode, decryption not enabled\r\n"); 330 return(0); 331 } 332 333 int 334 EncryptStartOutput(void) 335 { 336 if (encrypt_mode) { 337 encrypt_start_output(encrypt_mode); 338 return(1); 339 } 340 printf("No previous encryption mode, encryption not enabled\r\n"); 341 return(0); 342 } 343 344 int 345 EncryptStop(char *mode) 346 { 347 int ret = 0; 348 if (mode) { 349 if (isprefix(mode, "input")) 350 return(EncryptStopInput()); 351 if (isprefix(mode, "output")) 352 return(EncryptStopOutput()); 353 if (isprefix(mode, "help") || isprefix(mode, "?")) { 354 printf("Usage: encrypt stop [input|output]\n"); 355 return(0); 356 } 357 printf("%s: invalid encryption mode 'encrypt stop ?' for help\n", mode); 358 return(0); 359 } 360 ret += EncryptStopInput(); 361 ret += EncryptStopOutput(); 362 return(ret); 363 } 364 365 int 366 EncryptStopInput(void) 367 { 368 encrypt_send_request_end(); 369 return(1); 370 } 371 372 int 373 EncryptStopOutput(void) 374 { 375 encrypt_send_end(); 376 return(1); 377 } 378 379 void 380 encrypt_display(void) 381 { 382 if (encrypt_output) 383 printf("Currently encrypting output with %s\r\n", 384 ENCTYPE_NAME(encrypt_mode)); 385 if (decrypt_input) 386 printf("Currently decrypting input with %s\r\n", 387 ENCTYPE_NAME(decrypt_mode)); 388 } 389 390 int 391 EncryptStatus(void) 392 { 393 if (encrypt_output) 394 printf("Currently encrypting output with %s\r\n", 395 ENCTYPE_NAME(encrypt_mode)); 396 else if (encrypt_mode) { 397 printf("Currently output is clear text.\r\n"); 398 printf("Last encryption mode was %s\r\n", 399 ENCTYPE_NAME(encrypt_mode)); 400 } 401 if (decrypt_input) { 402 printf("Currently decrypting input with %s\r\n", 403 ENCTYPE_NAME(decrypt_mode)); 404 } else if (decrypt_mode) { 405 printf("Currently input is clear text.\r\n"); 406 printf("Last decryption mode was %s\r\n", 407 ENCTYPE_NAME(decrypt_mode)); 408 } 409 return 1; 410 } 411 412 void 413 encrypt_send_support(void) 414 { 415 if (str_suplen) { 416 /* 417 * If the user has requested that decryption start 418 * immediatly, then send a "REQUEST START" before 419 * we negotiate the type. 420 */ 421 if (!Server && autodecrypt) 422 encrypt_send_request_start(); 423 net_write(str_send, str_suplen); 424 printsub('>', &str_send[2], str_suplen - 2); 425 str_suplen = 0; 426 } 427 } 428 429 int 430 EncryptDebug(int on) 431 { 432 if (on < 0) 433 encrypt_debug_mode ^= 1; 434 else 435 encrypt_debug_mode = on; 436 printf("Encryption debugging %s\r\n", 437 encrypt_debug_mode ? "enabled" : "disabled"); 438 return(1); 439 } 440 441 int 442 EncryptVerbose(int on) 443 { 444 if (on < 0) 445 encrypt_verbose ^= 1; 446 else 447 encrypt_verbose = on; 448 printf("Encryption %s verbose\r\n", 449 encrypt_verbose ? "is" : "is not"); 450 return(1); 451 } 452 453 int 454 EncryptAutoEnc(int on) 455 { 456 encrypt_auto(on); 457 printf("Automatic encryption of output is %s\r\n", 458 autoencrypt ? "enabled" : "disabled"); 459 return(1); 460 } 461 462 int 463 EncryptAutoDec(int on) 464 { 465 decrypt_auto(on); 466 printf("Automatic decryption of input is %s\r\n", 467 autodecrypt ? "enabled" : "disabled"); 468 return(1); 469 } 470 471 /* 472 * Called when ENCRYPT SUPPORT is received. 473 */ 474 void 475 encrypt_support(unsigned char *typelist, int cnt) 476 { 477 int type, use_type = 0; 478 Encryptions *ep; 479 480 /* 481 * Forget anything the other side has previously told us. 482 */ 483 remote_supports_decrypt = 0; 484 485 while (cnt-- > 0) { 486 type = *typelist++; 487 if (encrypt_debug_mode) 488 printf(">>>%s: He is supporting %s (%d)\r\n", 489 Name, 490 ENCTYPE_NAME(type), type); 491 if ((type < ENCTYPE_CNT) && 492 (I_SUPPORT_ENCRYPT & typemask(type))) { 493 remote_supports_decrypt |= typemask(type); 494 if (use_type == 0) 495 use_type = type; 496 } 497 } 498 if (use_type) { 499 ep = findencryption(use_type); 500 if (!ep) 501 return; 502 type = ep->start ? (*ep->start)(DIR_ENCRYPT, Server) : 0; 503 if (encrypt_debug_mode) 504 printf(">>>%s: (*ep->start)() returned %d\r\n", 505 Name, type); 506 if (type < 0) 507 return; 508 encrypt_mode = use_type; 509 if (type == 0) 510 encrypt_start_output(use_type); 511 } 512 } 513 514 void 515 encrypt_is(unsigned char *data, int cnt) 516 { 517 Encryptions *ep; 518 int type, ret; 519 520 if (--cnt < 0) 521 return; 522 type = *data++; 523 if (type < ENCTYPE_CNT) 524 remote_supports_encrypt |= typemask(type); 525 if (!(ep = finddecryption(type))) { 526 if (encrypt_debug_mode) 527 printf(">>>%s: Can't find type %s (%d) for initial negotiation\r\n", 528 Name, 529 ENCTYPE_NAME_OK(type) 530 ? ENCTYPE_NAME(type) : "(unknown)", 531 type); 532 return; 533 } 534 if (!ep->is) { 535 if (encrypt_debug_mode) 536 printf(">>>%s: No initial negotiation needed for type %s (%d)\r\n", 537 Name, 538 ENCTYPE_NAME_OK(type) 539 ? ENCTYPE_NAME(type) : "(unknown)", 540 type); 541 ret = 0; 542 } else { 543 ret = (*ep->is)(data, cnt); 544 if (encrypt_debug_mode) 545 printf("(*ep->is)(%p, %d) returned %s(%d)\n", data, cnt, 546 (ret < 0) ? "FAIL " : 547 (ret == 0) ? "SUCCESS " : "MORE_TO_DO ", ret); 548 } 549 if (ret < 0) { 550 autodecrypt = 0; 551 } else { 552 decrypt_mode = type; 553 if (ret == 0 && autodecrypt) 554 encrypt_send_request_start(); 555 } 556 } 557 558 void 559 encrypt_reply(unsigned char *data, int cnt) 560 { 561 Encryptions *ep; 562 int ret, type; 563 564 if (--cnt < 0) 565 return; 566 type = *data++; 567 if (!(ep = findencryption(type))) { 568 if (encrypt_debug_mode) 569 printf(">>>%s: Can't find type %s (%d) for initial negotiation\r\n", 570 Name, 571 ENCTYPE_NAME_OK(type) 572 ? ENCTYPE_NAME(type) : "(unknown)", 573 type); 574 return; 575 } 576 if (!ep->reply) { 577 if (encrypt_debug_mode) 578 printf(">>>%s: No initial negotiation needed for type %s (%d)\r\n", 579 Name, 580 ENCTYPE_NAME_OK(type) 581 ? ENCTYPE_NAME(type) : "(unknown)", 582 type); 583 ret = 0; 584 } else { 585 ret = (*ep->reply)(data, cnt); 586 if (encrypt_debug_mode) 587 printf("(*ep->reply)(%p, %d) returned %s(%d)\n", 588 data, cnt, 589 (ret < 0) ? "FAIL " : 590 (ret == 0) ? "SUCCESS " : "MORE_TO_DO ", ret); 591 } 592 if (encrypt_debug_mode) 593 printf(">>>%s: encrypt_reply returned %d\n", Name, ret); 594 if (ret < 0) { 595 autoencrypt = 0; 596 } else { 597 encrypt_mode = type; 598 if (ret == 0 && autoencrypt) 599 encrypt_start_output(type); 600 } 601 } 602 603 /* 604 * Called when a ENCRYPT START command is received. 605 */ 606 void 607 encrypt_start(unsigned char *data __unused, int cnt __unused) 608 { 609 Encryptions *ep; 610 611 if (!decrypt_mode) { 612 /* 613 * Something is wrong. We should not get a START 614 * command without having already picked our 615 * decryption scheme. Send a REQUEST-END to 616 * attempt to clear the channel... 617 */ 618 printf("%s: Warning, Cannot decrypt input stream!!!\r\n", Name); 619 encrypt_send_request_end(); 620 return; 621 } 622 623 if ((ep = finddecryption(decrypt_mode))) { 624 decrypt_input = ep->input; 625 if (encrypt_verbose) 626 printf("[ Input is now decrypted with type %s ]\r\n", 627 ENCTYPE_NAME(decrypt_mode)); 628 if (encrypt_debug_mode) 629 printf(">>>%s: Start to decrypt input with type %s\r\n", 630 Name, ENCTYPE_NAME(decrypt_mode)); 631 } else { 632 printf("%s: Warning, Cannot decrypt type %s (%d)!!!\r\n", 633 Name, 634 ENCTYPE_NAME_OK(decrypt_mode) 635 ? ENCTYPE_NAME(decrypt_mode) 636 : "(unknown)", 637 decrypt_mode); 638 encrypt_send_request_end(); 639 } 640 } 641 642 void 643 encrypt_session_key( Session_Key *key, int server) 644 { 645 Encryptions *ep = encryptions; 646 647 havesessionkey = 1; 648 649 while (ep->type) { 650 if (ep->session) 651 (*ep->session)(key, server); 652 ++ep; 653 } 654 } 655 656 /* 657 * Called when ENCRYPT END is received. 658 */ 659 void 660 encrypt_end(void) 661 { 662 decrypt_input = NULL; 663 if (encrypt_debug_mode) 664 printf(">>>%s: Input is back to clear text\r\n", Name); 665 if (encrypt_verbose) 666 printf("[ Input is now clear text ]\r\n"); 667 } 668 669 /* 670 * Called when ENCRYPT REQUEST-END is received. 671 */ 672 void 673 encrypt_request_end(void) 674 { 675 encrypt_send_end(); 676 } 677 678 /* 679 * Called when ENCRYPT REQUEST-START is received. If we receive 680 * this before a type is picked, then that indicates that the 681 * other side wants us to start encrypting data as soon as we 682 * can. 683 */ 684 void 685 encrypt_request_start(unsigned char *data __unused, int cnt __unused) 686 { 687 if (encrypt_mode == 0) { 688 if (Server) 689 autoencrypt = 1; 690 return; 691 } 692 encrypt_start_output(encrypt_mode); 693 } 694 695 static unsigned char str_keyid[(MAXKEYLEN*2)+5] = { IAC, SB, TELOPT_ENCRYPT }; 696 697 void 698 encrypt_enc_keyid(unsigned char *keyid, int len) 699 { 700 encrypt_keyid(&ki[1], keyid, len); 701 } 702 703 void 704 encrypt_dec_keyid(unsigned char *keyid, int len) 705 { 706 encrypt_keyid(&ki[0], keyid, len); 707 } 708 709 void 710 encrypt_keyid(struct key_info *kp, unsigned char *keyid, int len) 711 { 712 Encryptions *ep; 713 int dir = kp->dir; 714 int ret = 0; 715 716 if (len > MAXKEYLEN) 717 len = MAXKEYLEN; 718 719 if (!(ep = (*kp->getcrypt)(*kp->modep))) { 720 if (len == 0) 721 return; 722 kp->keylen = 0; 723 } else if (len == 0) { 724 /* 725 * Empty option, indicates a failure. 726 */ 727 if (kp->keylen == 0) 728 return; 729 kp->keylen = 0; 730 if (ep->keyid) 731 (void)(*ep->keyid)(dir, kp->keyid, &kp->keylen); 732 733 } else if ((len != kp->keylen) || 734 (memcmp(keyid, kp->keyid, len) != 0)) { 735 /* 736 * Length or contents are different 737 */ 738 kp->keylen = len; 739 memmove(kp->keyid, keyid, len); 740 if (ep->keyid) 741 (void)(*ep->keyid)(dir, kp->keyid, &kp->keylen); 742 } else { 743 if (ep->keyid) 744 ret = (*ep->keyid)(dir, kp->keyid, &kp->keylen); 745 if ((ret == 0) && (dir == DIR_ENCRYPT) && autoencrypt) 746 encrypt_start_output(*kp->modep); 747 return; 748 } 749 750 encrypt_send_keyid(dir, kp->keyid, kp->keylen, 0); 751 } 752 753 void 754 encrypt_send_keyid(int dir, const char *keyid, int keylen, int saveit) 755 { 756 unsigned char *strp; 757 758 str_keyid[3] = (dir == DIR_ENCRYPT) 759 ? ENCRYPT_ENC_KEYID : ENCRYPT_DEC_KEYID; 760 if (saveit) { 761 struct key_info *kp = &ki[(dir == DIR_ENCRYPT) ? 0 : 1]; 762 memmove(kp->keyid, keyid, keylen); 763 kp->keylen = keylen; 764 } 765 766 for (strp = &str_keyid[4]; keylen > 0; --keylen) { 767 if ((*strp++ = *keyid++) == IAC) 768 *strp++ = IAC; 769 } 770 *strp++ = IAC; 771 *strp++ = SE; 772 net_write(str_keyid, strp - str_keyid); 773 printsub('>', &str_keyid[2], strp - str_keyid - 2); 774 } 775 776 void 777 encrypt_auto(int on) 778 { 779 if (on < 0) 780 autoencrypt ^= 1; 781 else 782 autoencrypt = on ? 1 : 0; 783 } 784 785 void 786 decrypt_auto(int on) 787 { 788 if (on < 0) 789 autodecrypt ^= 1; 790 else 791 autodecrypt = on ? 1 : 0; 792 } 793 794 void 795 encrypt_start_output(int type) 796 { 797 Encryptions *ep; 798 unsigned char *p; 799 int i; 800 801 if (!(ep = findencryption(type))) { 802 if (encrypt_debug_mode) { 803 printf(">>>%s: Can't encrypt with type %s (%d)\r\n", 804 Name, 805 ENCTYPE_NAME_OK(type) 806 ? ENCTYPE_NAME(type) : "(unknown)", 807 type); 808 } 809 return; 810 } 811 if (ep->start) { 812 i = (*ep->start)(DIR_ENCRYPT, Server); 813 if (encrypt_debug_mode) { 814 printf(">>>%s: Encrypt start: %s (%d) %s\r\n", 815 Name, 816 (i < 0) ? "failed" : 817 "initial negotiation in progress", 818 i, ENCTYPE_NAME(type)); 819 } 820 if (i) 821 return; 822 } 823 p = str_start + 3; 824 *p++ = ENCRYPT_START; 825 for (i = 0; i < ki[0].keylen; ++i) { 826 if ((*p++ = ki[0].keyid[i]) == IAC) 827 *p++ = IAC; 828 } 829 *p++ = IAC; 830 *p++ = SE; 831 net_write(str_start, p - str_start); 832 net_encrypt(); 833 printsub('>', &str_start[2], p - &str_start[2]); 834 /* 835 * If we are already encrypting in some mode, then 836 * encrypt the ring (which includes our request) in 837 * the old mode, mark it all as "clear text" and then 838 * switch to the new mode. 839 */ 840 encrypt_output = ep->output; 841 encrypt_mode = type; 842 if (encrypt_debug_mode) 843 printf(">>>%s: Started to encrypt output with type %s\r\n", 844 Name, ENCTYPE_NAME(type)); 845 if (encrypt_verbose) 846 printf("[ Output is now encrypted with type %s ]\r\n", 847 ENCTYPE_NAME(type)); 848 } 849 850 void 851 encrypt_send_end(void) 852 { 853 if (!encrypt_output) 854 return; 855 856 str_end[3] = ENCRYPT_END; 857 net_write(str_end, sizeof(str_end)); 858 net_encrypt(); 859 printsub('>', &str_end[2], sizeof(str_end) - 2); 860 /* 861 * Encrypt the output buffer now because it will not be done by 862 * netflush... 863 */ 864 encrypt_output = NULL; 865 if (encrypt_debug_mode) 866 printf(">>>%s: Output is back to clear text\r\n", Name); 867 if (encrypt_verbose) 868 printf("[ Output is now clear text ]\r\n"); 869 } 870 871 void 872 encrypt_send_request_start(void) 873 { 874 unsigned char *p; 875 int i; 876 877 p = &str_start[3]; 878 *p++ = ENCRYPT_REQSTART; 879 for (i = 0; i < ki[1].keylen; ++i) { 880 if ((*p++ = ki[1].keyid[i]) == IAC) 881 *p++ = IAC; 882 } 883 *p++ = IAC; 884 *p++ = SE; 885 net_write(str_start, p - str_start); 886 printsub('>', &str_start[2], p - &str_start[2]); 887 if (encrypt_debug_mode) 888 printf(">>>%s: Request input to be encrypted\r\n", Name); 889 } 890 891 void 892 encrypt_send_request_end(void) 893 { 894 str_end[3] = ENCRYPT_REQEND; 895 net_write(str_end, sizeof(str_end)); 896 printsub('>', &str_end[2], sizeof(str_end) - 2); 897 898 if (encrypt_debug_mode) 899 printf(">>>%s: Request input to be clear text\r\n", Name); 900 } 901 902 void 903 encrypt_wait(void) 904 { 905 if (encrypt_debug_mode) 906 printf(">>>%s: in encrypt_wait\r\n", Name); 907 if (!havesessionkey || !(I_SUPPORT_ENCRYPT & remote_supports_decrypt)) 908 return; 909 while (autoencrypt && !encrypt_output) 910 if (telnet_spin()) 911 return; 912 } 913 914 void 915 encrypt_gen_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen) 916 { 917 char tbuf[16], *cp; 918 919 cnt -= 2; 920 data += 2; 921 buf[buflen-1] = '\0'; 922 buf[buflen-2] = '*'; 923 buflen -= 2;; 924 for (; cnt > 0; cnt--, data++) { 925 sprintf(tbuf, " %d", *data); 926 for (cp = tbuf; *cp && buflen > 0; --buflen) 927 *buf++ = *cp++; 928 if (buflen <= 0) 929 return; 930 } 931 *buf = '\0'; 932 } 933 934 void 935 encrypt_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen) 936 { 937 Encryptions *ep; 938 int type = data[1]; 939 940 for (ep = encryptions; ep->type && ep->type != type; ep++) 941 ; 942 943 if (ep->printsub) 944 (*ep->printsub)(data, cnt, buf, buflen); 945 else 946 encrypt_gen_printsub(data, cnt, buf, buflen); 947 } 948 #endif /* ENCRYPTION */ 949