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