lib/libtelnet/encrypt.c

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