home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ck_crp.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  168KB  |  5,623 lines
  1. char *ckcrpv = "Encryption Engine, 9.0.117, 19 Mar 2010";
  2. /*
  3.   C K _ C R P . C  -  Cryptography for C-Kermit"
  4.  
  5.   Copyright (C) 1998, 2010,
  6.     Trustees of Columbia University in the City of New York.
  7.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  8.     copyright text in the ckcmai.c module for disclaimer and permissions.
  9.  
  10.   Author:
  11.   Jeffrey E Altman (jaltman@secure-endpoints.com)
  12.   Secure Endpoints Inc., New York City
  13. */
  14.  
  15. #define CK_CRP_C
  16. #ifdef CK_DES
  17. #ifdef CK_SSL
  18. #ifndef LIBDES
  19. #define LIBDES
  20. #endif /* LIBDES */
  21. #endif /* CK_SSL */
  22. #endif /* CK_DES */
  23.  
  24. #ifdef CRYPT_DLL
  25. #define CK_AUTHENTICATION
  26. #define CK_ENCRYPTION
  27. #define CK_DES
  28. #define CK_CAST
  29. #ifndef LIBDES
  30. #define LIBDES
  31. #endif /* LIBDES */
  32.  
  33. #define TELCMDS                         /* to define name array */
  34. #define TELOPTS                         /* to define name array */
  35. #define ENCRYPT_NAMES
  36. #endif /* CRYPT_DLL */
  37.  
  38. #include "ckcsym.h"
  39. #include "ckcdeb.h"
  40. #include "ckcnet.h"
  41.  
  42. #ifdef DEBUG
  43. #undef DEBUG
  44. #endif /* DEBUG */
  45.  
  46. #ifdef CK_AUTHENTICATION
  47. #ifdef CK_ENCRYPTION
  48. #define ENCRYPTION
  49. #ifdef CK_DES
  50. #define DES_ENCRYPTION
  51. #endif /* CK_DES */
  52. #ifdef  CK_CAST
  53. #define CAST_ENCRYPTION
  54. #endif /* CK_CAST */
  55. #ifdef COMMENT
  56. #define CAST_EXPORT_ENCRYPTION
  57. #endif /* COMMENT */
  58. #endif /* CK_ENCRYPTION */
  59. #endif /* CK_AUTHENTICATION */
  60.  
  61. #ifdef CK_ENCRYPTION
  62.  
  63. #include "ckucmd.h"                     /* For struct keytab definition */
  64. #include "ckuath.h"
  65. #include "ckuat2.h"
  66. #ifdef MIT_CURRENT
  67. #include <krb5.h>
  68. #endif /* MIT_CURRENT */
  69.  
  70. #include <stdlib.h>
  71. #include <string.h>
  72. #ifdef OS2
  73. #include <stdarg.h>
  74. #ifdef OS2ONLY
  75. #include <os2.h>
  76. #endif /* OS2ONLY */
  77. #include "ckosyn.h"
  78. #else /* OS2 */
  79. static char * tmpstring = NULL;
  80. #endif /* OS2 */
  81.  
  82. #ifndef CAST_OR_EXPORT
  83. #ifdef CAST_ENCRYPTION
  84. #define CAST_OR_EXPORT
  85. #endif /* CAST_ENCRYPTION */
  86. #ifdef CAST_EXPORT_ENCRYPTION
  87. #define CAST_OR_EXPORT
  88. #endif /* CAST_EXPORT_ENCRYPTION */
  89. #endif /* CAST_OR_EXPORT */
  90.  
  91. #ifdef MACOSX
  92. #undef LIBDES
  93. #endif /* MACOSX */
  94.  
  95. #ifdef CRYPT_DLL
  96. int cmd_quoting = 0;
  97.  
  98. #ifndef TELOPT_MACRO
  99. int
  100. telopt_index(opt) int opt; {
  101.     if ( opt >= 0 && opt <= TELOPT_SEND_URL )
  102.         return(opt);
  103.     else if ( opt >= TELOPT_PRAGMA_LOGON && opt <= TELOPT_PRAGMA_HEARTBEAT )
  104.         return(opt-89);
  105.     else
  106.         return(NTELOPTS);
  107. }
  108.  
  109. int
  110. telopt_ok(opt) int opt; {
  111.     return((opt >= TELOPT_BINARY && opt <= TELOPT_SEND_URL) ||
  112.         (opt >= TELOPT_PRAGMA_LOGON && opt <= TELOPT_PRAGMA_HEARTBEAT));
  113. }
  114.  
  115. CHAR *
  116. telopt(opt) int opt; {
  117.     if ( telopt_ok(opt) )
  118.         return(telopts[telopt_index(opt)]);
  119.     else
  120.         return("UNKNOWN");
  121. }
  122. #endif /* TELOPT_MACRO */
  123.  
  124. static int (*p_ttol)(char *,int)=NULL;
  125. static int (*p_dodebug)(int,char *,char *,CK_OFF_T)=NULL;
  126. static int (*p_dohexdump)(char *,char *,int)=NULL;
  127. static void (*p_tn_debug)(char *)=NULL;
  128. static int (*p_vscrnprintf)(char *, ...)=NULL;
  129. static void * p_k5_context=NULL;
  130. static unsigned long (*p_reqtelmutex)(unsigned long)=NULL;
  131. static unsigned long (*p_reltelmutex)(void)=NULL;
  132.  
  133. unsigned long
  134. RequestTelnetMutex(unsigned long x)
  135. {
  136.     if ( p_reqtelmutex )
  137.         return p_reqtelmutex(x);
  138.     return 0;
  139. }
  140.  
  141. unsigned long
  142. ReleaseTelnetMutex(void)
  143. {
  144.     if ( p_reltelmutex )
  145.         return p_reltelmutex();
  146.     return 0;
  147. }
  148.  
  149. int
  150. ttol(char * s, int n)
  151. {
  152.     if ( p_ttol )
  153.         return(p_ttol(s,n));
  154.     else
  155.         return(-1);
  156. }
  157.  
  158. int
  159. dodebug(int flag, char * s1, char * s2, CK_OFF_T n)
  160. {
  161.     if ( p_dodebug )
  162.         return(p_dodebug(flag,s1,s2,n));
  163.     else
  164.         return(-1);
  165. }
  166.  
  167. int
  168. dohexdump( char * s1, char * s2, int n )
  169. {
  170.     if ( p_dohexdump )
  171.         p_dohexdump(s1,s2,n);
  172.     return(0);
  173. }
  174.  
  175. void
  176. tn_debug( char * s )
  177. {
  178.     if ( p_tn_debug )
  179.         p_tn_debug(s);
  180. }
  181.  
  182. static char myprtfstr[4096];
  183. int
  184. Vscrnprintf(const char * format, ...) {
  185.     int i, len, rc=0;
  186.     char *cp;
  187.     va_list ap;
  188.  
  189.     va_start(ap, format);
  190. #ifdef NT
  191.     rc = _vsnprintf(myprtfstr, sizeof(myprtfstr)-1, format, ap);
  192. #else /* NT */
  193.     rc = vsprintf(myprtfstr, format, ap);
  194. #endif /* NT */
  195.     va_end(ap);
  196.  
  197.     if ( p_vscrnprintf )
  198.         return(p_vscrnprintf(myprtfstr));
  199.     else
  200.         return(-1);
  201. }
  202.  
  203. int
  204. #ifdef CK_ANSIC
  205. tn_hex(CHAR * buf, int buflen, CHAR * data, int datalen)
  206. #else /* CK_ANSIC */
  207. tn_hex(buf, buflen, data, datalen)
  208.     CHAR * buf;
  209.     int buflen;
  210.     CHAR * data;
  211.     int datalen;
  212. #endif /* CK_ANSIC */
  213. {
  214.     int i = 0, j = 0, k = 0;
  215.     CHAR tmp[8];
  216. #ifdef COMMENT
  217.     int was_hex = 1;
  218.  
  219.     for (k=0; k < datalen; k++) {
  220.         if (data[k] < 32 || data[k] >= 127) {
  221.             sprintf(tmp,"%s%02X ",was_hex?"":"\" ",data[k]);
  222.             was_hex = 1;
  223.         } else {
  224.             sprintf(tmp,"%s%c",was_hex?"\"":"",data[k]);
  225.             was_hex = 0;
  226.         }
  227.         ckstrncat(buf,tmp,buflen);
  228.     }
  229.     if (!was_hex)
  230.         ckstrncat(buf,"\" ",buflen);
  231. #else /* COMMENT */
  232.     if (datalen <= 0 || data == NULL)
  233.         return(0);
  234.  
  235.     for (i = 0; i < datalen; i++) {
  236.         ckstrncat(buf,"\r\n  ",buflen);
  237.         for (j = 0 ; (j < 16); j++) {
  238.             if ((i + j) < datalen)
  239.               sprintf(tmp,
  240.                       "%s%02x ",
  241.                       (j == 8 ? "| " : ""),
  242.                       (CHAR) data[i + j]
  243.                       );
  244.             else
  245.               sprintf(tmp,
  246.                       "%s   ",
  247.                       (j == 8 ? "| " : "")
  248.                       );
  249.             ckstrncat(buf,tmp,buflen);
  250.         }
  251.         ckstrncat(buf," ",buflen);
  252.         for (k = 0; (k < 16) && ((i + k) < datalen); k++) {
  253.             sprintf(tmp,
  254.                      "%s%c",
  255.                      (k == 8 ? " " : ""),
  256.                      isprint(data[i + k]) ? data[i + k] : '.'
  257.                      );
  258.             ckstrncat(buf,tmp,buflen);
  259.         }
  260.         i += j - 1;
  261.     } /* end for */
  262.     ckstrncat(buf,"\r\n  ",buflen);
  263. #endif /* COMMENT */
  264.     return(strlen(buf));
  265. }
  266.  
  267. #ifdef COMMENT
  268. #define ttol        dll_ttol
  269. #define dodebug     dll_dodebug
  270. #define dohexdump   dll_dohexdump
  271. #define tn_debug    dll_tn_debug
  272. #define Vscrnprintf dll_vscrnprintf
  273. #endif /* COMMENT */
  274.  
  275. char tn_msg[TN_MSG_LEN], hexbuf[TN_MSG_LEN];   /* from ckcnet.c */
  276. int deblog=1, debses=1, tn_deb=1;
  277. #else /* CRYPT_DLL */
  278. extern char tn_msg[], hexbuf[];         /* from ckcnet.c */
  279. extern int deblog, debses, tn_deb;
  280. #ifdef MIT_CURRENT
  281. extern krb5_context k5_context;
  282. #endif /* MIT_CURRENT */
  283. #endif /* CRYPT_DLL */
  284.  
  285. #ifdef LIBDES
  286. #ifdef MACOSX
  287. #define des_new_random_key            ck_des_new_random_key
  288. #define des_set_random_generator_seed ck_des_set_random_generator_seed
  289. #define des_key_sched                 ck_des_key_sched
  290. #define des_ecb_encrypt               ck_des_ecb_encrypt
  291. #define des_string_to_key             ck_des_string_to_key
  292. #define des_fixup_key_parity          ck_des_fixup_key_parity
  293. #endif /* MACOSX */
  294. #ifndef UNIX
  295. #define des_new_random_key            des_random_key
  296. #define des_set_random_generator_seed des_random_seed
  297. #endif /* UNIX */
  298. #define des_fixup_key_parity          des_set_odd_parity
  299. #ifdef OPENSSL_097
  300. #define OPENSSL_ENABLE_OLD_DES_SUPPORT
  301. #include <openssl/des.h>
  302. #endif /* OPENSSL_097 */
  303. #else /* LIBDES */
  304. #ifdef UNIX
  305. #define des_set_random_generator_seed(x) des_init_random_number_generator(x)
  306. #endif /* UNIX */
  307. #ifdef OS2
  308. #define des_new_random_key            ck_des_new_random_key
  309. #define des_set_random_generator_seed ck_des_set_random_generator_seed
  310. #define des_key_sched                 ck_des_key_sched
  311. #define des_ecb_encrypt               ck_des_ecb_encrypt
  312. #define des_string_to_key             ck_des_string_to_key
  313. #define des_fixup_key_parity          ck_des_fixup_key_parity
  314. #endif /* OS2 */
  315. #endif /* LIBDES */
  316.  
  317. #ifdef CK_DES
  318. /* This code comes from Eric Young's libdes package and is not part   */
  319. /* of the standard MIT DES library that is part of Kerberos. However, */
  320. /* it is extremely useful.  So we add it here.                        */
  321.  
  322.  
  323. /* Weak and semi week keys as take from
  324.  * %A D.W. Davies
  325.  * %A W.L. Price
  326.  * %T Security for Computer Networks
  327.  * %I John Wiley & Sons
  328.  * %D 1984
  329.  * Many thanks to smb@ulysses.att.com (Steven Bellovin) for the reference
  330.  * (and actual cblock values).
  331.  */
  332. #define NUM_WEAK_KEY    16
  333. static Block weak_keys[NUM_WEAK_KEY]={
  334.         /* weak keys */
  335.         {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
  336.         {0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE},
  337.         {0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F},
  338.         {0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0},
  339.         /* semi-weak keys */
  340.         {0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE},
  341.         {0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01},
  342.         {0x1F,0xE0,0x1F,0xE0,0x0E,0xF1,0x0E,0xF1},
  343.         {0xE0,0x1F,0xE0,0x1F,0xF1,0x0E,0xF1,0x0E},
  344.         {0x01,0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1},
  345.         {0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1,0x01},
  346.         {0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E,0xFE},
  347.         {0xFE,0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E},
  348.         {0x01,0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E},
  349.         {0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E,0x01},
  350.         {0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
  351.         {0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1}};
  352.  
  353. int
  354. ck_des_is_weak_key(key)
  355. Block key;
  356. {
  357.     int i;
  358.  
  359.     for (i=0; i<NUM_WEAK_KEY; i++) {
  360.         /* Added == 0 to comparision, I obviously don't run
  361.         * this section very often :-(, thanks to
  362.         * engineering@MorningStar.Com for the fix
  363.         * eay 93/06/29
  364.         * Another problem, I was comparing only the first 4
  365.         * bytes, 97/03/18 */
  366.         if (memcmp(weak_keys[i],key,sizeof(Block)) == 0)
  367.             return(1);
  368.     }
  369.     return(0);
  370. }
  371.  
  372. #ifdef UNIX
  373. #ifdef LIBDES
  374. #ifndef MACOSX
  375. /* These functions are not part of Eric Young's DES library */
  376. /* _unix_time_gmt_unixsec                                  */
  377. /* _des_set_random_generator_seed                          */
  378. /* _des_fixup_key_parity   (added in 0.9.5)                */
  379. /* _des_new_random_key                                     */
  380. #include <sys/time.h>
  381.  
  382. unsigned long
  383. unix_time_gmt_unixsec (usecptr)
  384.     unsigned long  *usecptr;
  385. {
  386.     struct timeval  now;
  387.  
  388.     (void) gettimeofday (&now, (struct timezone *)0);
  389.     if (usecptr)
  390.         *usecptr = now.tv_usec;
  391.     return now.tv_sec;
  392. }
  393.  
  394. void
  395. des_set_random_generator_seed(Block B)
  396. {
  397.     des_random_seed(B);
  398.     return;
  399. }
  400.  
  401. #ifdef COMMENT
  402. /* added to openssl in 0.9.5 */
  403. void
  404. des_fixup_key_parity(Block B)
  405. {
  406.     des_set_odd_parity(B);
  407.     return;
  408. }
  409. #endif /* COMMENT */
  410. int
  411. des_new_random_key(Block B)
  412. {
  413.     int rc=0;
  414.     /* WARNING:
  415.        This might need to have the "rc = " removed because this
  416.        is VOID in later, and maybe even all, versions.
  417.     */       
  418.     rc = des_random_key(B);
  419.     return(rc);
  420. }
  421.  
  422. #endif /* MACOSX */
  423. #endif /* LIBDES */
  424. #endif /* UNIX */
  425. #endif /* CK_DES */
  426.  
  427. /*
  428.  * Copyright (c) 1991, 1993
  429.  *      The Regents of the University of California.  All rights reserved.
  430.  *
  431.  * Redistribution and use in source and binary forms, with or without
  432.  * modification, are permitted provided that the following conditions
  433.  * are met:
  434.  * 1. Redistributions of source code must retain the above copyright
  435.  *    notice, this list of conditions and the following disclaimer.
  436.  * 2. Redistributions in binary form must reproduce the above copyright
  437.  *    notice, this list of conditions and the following disclaimer in the
  438.  *    documentation and/or other materials provided with the distribution.
  439.  * 3. All advertising materials mentioning features or use of this software
  440.  *    must display the following acknowledgement:
  441.  *      This product includes software developed by the University of
  442.  *      California, Berkeley and its contributors.
  443.  * 4. Neither the name of the University nor the names of its contributors
  444.  *    may be used to endorse or promote products derived from this software
  445.  *    without specific prior written permission.
  446.  *
  447.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  448.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  449.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  450.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  451.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  452.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  453.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  454.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  455.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  456.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  457.  * SUCH DAMAGE.
  458.  */
  459.  
  460. /* based on @(#)encrypt.c       8.1 (Berkeley) 6/4/93 */
  461.  
  462. /*
  463.  * Copyright (C) 1990 by the Massachusetts Institute of Technology
  464.  *
  465.  * Export of this software from the United States of America may
  466.  * require a specific license from the United States Government.
  467.  * It is the responsibility of any person or organization contemplating
  468.  * export to obtain such a license before exporting.
  469.  *
  470.  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  471.  * distribute this software and its documentation for any purpose and
  472.  * without fee is hereby granted, provided that the above copyright
  473.  * notice appear in all copies and that both that copyright notice and
  474.  * this permission notice appear in supporting documentation, and that
  475.  * the name of M.I.T. not be used in advertising or publicity pertaining
  476.  * to distribution of the software without specific, written prior
  477.  * permission.  M.I.T. makes no representations about the suitability of
  478.  * this software for any purpose.  It is provided "as is" without express
  479.  * or implied warranty.
  480.  */
  481.  
  482. #include <stdio.h>
  483.  
  484. /*
  485.  * These function pointers point to the current routines
  486.  * for encrypting and decrypting data.
  487.  */
  488. /* NOTE: These next two might need to have the "static " removed */
  489.  
  490. static VOID     (*encrypt_output) P((unsigned char *, int));
  491. static int      (*decrypt_input) P((int));
  492.  
  493. #ifdef DEBUG
  494. static int encrypt_debug_mode = 1;
  495. static int encrypt_verbose = 1;
  496. #else
  497. static int encrypt_verbose = 1;
  498. static int encrypt_debug_mode = 0;
  499. #endif
  500.  
  501. static char dbgbuf [16384];
  502.  
  503. static int decrypt_mode = 0;
  504. static int encrypt_mode = 0;
  505. static int autoencrypt = 1;
  506. static int autodecrypt = 1;
  507. static int havesessionkey = 0;
  508.  
  509. static kstream EncryptKSGlobalHack = NULL;
  510. static int     EncryptType = ENCTYPE_ANY;
  511.  
  512. #define typemask(x)     ((x) > 0 ? 1 << ((x)-1) : 0)
  513.  
  514. static long i_support_encrypt =
  515.         typemask(ENCTYPE_DES_CFB64) | typemask(ENCTYPE_DES_OFB64);
  516. static long i_support_decrypt =
  517.         typemask(ENCTYPE_DES_CFB64) | typemask(ENCTYPE_DES_OFB64);
  518. static long i_wont_support_encrypt = 0;
  519. static long i_wont_support_decrypt = 0;
  520. #define I_SUPPORT_ENCRYPT       (i_support_encrypt & ~i_wont_support_encrypt)
  521. #define I_SUPPORT_DECRYPT       (i_support_decrypt & ~i_wont_support_decrypt)
  522.  
  523. static long remote_supports_encrypt = 0;
  524. static long remote_supports_decrypt = 0;
  525.  
  526. /* Make sure that this list is in order of algorithm strength     */
  527. /* as it determines the search order for selecting specific       */
  528. /* encryption choices.  All CFB modes must come before OFB modes. */
  529. static Encryptions encryptions[] = {
  530. #ifdef DES_ENCRYPTION
  531.     { "DES3_CFB64",
  532.           ENCTYPE_DES3_CFB64,
  533.           des3_cfb64_encrypt,
  534.           des3_cfb64_decrypt,
  535.           des3_cfb64_init,
  536.           des3_cfb64_start,
  537.           des3_cfb64_is,
  538.           des3_cfb64_reply,
  539.           des3_cfb64_session,
  540.           des3_cfb64_keyid,
  541.           NULL },
  542. #endif /* DES_ENCRYPTION */
  543. #ifdef CAST_ENCRYPTION
  544. #ifndef CAST_EXPORT_ENCRYPTION
  545.     { "CAST128_CFB64",  ENCTYPE_CAST128_CFB64,
  546.           cast_cfb64_encrypt,
  547.           cast_cfb64_decrypt,
  548.           cast_cfb64_init,
  549.           cast_cfb64_start,
  550.           cast_cfb64_is,
  551.           cast_cfb64_reply,
  552.           cast_cfb64_session,
  553.           cast_cfb64_keyid,
  554.           NULL },
  555. #endif
  556. #endif
  557. #ifdef DES_ENCRYPTION
  558.     { "DES_CFB64",
  559.           ENCTYPE_DES_CFB64,
  560.           cfb64_encrypt,
  561.           cfb64_decrypt,
  562.           cfb64_init,
  563.           cfb64_start,
  564.           cfb64_is,
  565.           cfb64_reply,
  566.           cfb64_session,
  567.           cfb64_keyid,
  568.           NULL },
  569. #endif  /* DES_ENCRYPTION */
  570. #if defined (CAST_EXPORT_ENCRYPTION) || defined(CAST_ENCRYPTION)
  571.     { "CAST5_40_CFB64", ENCTYPE_CAST5_40_CFB64,
  572.           castexp_cfb64_encrypt,
  573.           castexp_cfb64_decrypt,
  574.           castexp_cfb64_init,
  575.           castexp_cfb64_start,
  576.           castexp_cfb64_is,
  577.           castexp_cfb64_reply,
  578.           castexp_cfb64_session,
  579.           castexp_cfb64_keyid,
  580.           NULL },
  581. #endif /* CAST_ENCRYPTION */
  582. #ifdef DES_ENCRYPTION
  583.     { "DES3_OFB64",
  584.           ENCTYPE_DES3_OFB64,
  585.           des3_ofb64_encrypt,
  586.           des3_ofb64_decrypt,
  587.           des3_ofb64_init,
  588.           des3_ofb64_start,
  589.           des3_ofb64_is,
  590.           des3_ofb64_reply,
  591.           des3_ofb64_session,
  592.           des3_ofb64_keyid,
  593.           NULL },
  594. #endif /* DES_ENCRYPTION */
  595. #ifdef CAST_ENCRYPTION
  596. #ifndef CAST_EXPORT_ENCRYPTION
  597.     { "CAST128_OFB64",  ENCTYPE_CAST128_OFB64,
  598.           cast_ofb64_encrypt,
  599.           cast_ofb64_decrypt,
  600.           cast_ofb64_init,
  601.           cast_ofb64_start,
  602.           cast_ofb64_is,
  603.           cast_ofb64_reply,
  604.           cast_ofb64_session,
  605.           cast_ofb64_keyid,
  606.           NULL },
  607. #endif
  608. #endif
  609. #ifdef DES_ENCRYPTION
  610.     { "DES_OFB64",
  611.           ENCTYPE_DES_OFB64,
  612.           ofb64_encrypt,
  613.           ofb64_decrypt,
  614.           ofb64_init,
  615.           ofb64_start,
  616.           ofb64_is,
  617.           ofb64_reply,
  618.           ofb64_session,
  619.           ofb64_keyid,
  620.           NULL },
  621. #endif  /* DES_ENCRYPTION */
  622. #if defined (CAST_EXPORT_ENCRYPTION) || defined(CAST_ENCRYPTION)
  623.     { "CAST5_40_OFB64", ENCTYPE_CAST5_40_OFB64,
  624.           castexp_ofb64_encrypt,
  625.           castexp_ofb64_decrypt,
  626.           castexp_ofb64_init,
  627.           castexp_ofb64_start,
  628.           castexp_ofb64_is,
  629.           castexp_ofb64_reply,
  630.           castexp_ofb64_session,
  631.           castexp_ofb64_keyid,
  632.           NULL },
  633. #endif /* CAST_ENCRYPTION */
  634.     { 0,0,0,0,0,0,0,0,0,0,0  }
  635. };
  636.  
  637. int
  638. get_crypt_table( struct keytab ** pTable, int * pN )
  639. {
  640.     int i=0,n=0;
  641.  
  642.     if ( *pTable )
  643.     {
  644.         for ( i=0 ; i < *pN ; i++ )
  645.             free( (*pTable)[i].kwd ) ;
  646.         free ( *pTable )  ;
  647.     }
  648.     *pTable = NULL;
  649.     *pN = 0;
  650.  
  651.     /* How many encryption types do we have? */
  652.     while ( encryptions[n].name )
  653.         n++;
  654.  
  655.     if ( n )
  656.     {
  657.         *pTable = malloc( sizeof(struct keytab) * (n+2) ) ;
  658.         if ( !(*pTable) )
  659.             return(0);
  660.  
  661. #ifdef OS2
  662.         (*pTable)[0].kwd =strdup("automatic");
  663. #else /* OS2 */
  664.         makestr(&tmpstring,"automatic");
  665.         (*pTable)[0].kwd = tmpstring;
  666.         tmpstring = NULL;
  667. #endif /* OS2 */
  668.         (*pTable)[0].kwval = ENCTYPE_ANY;
  669.         (*pTable)[0].flgs = 0;
  670. #ifdef OS2
  671.         (*pTable)[1].kwd =strdup("none");
  672. #else /* OS2 */
  673.         makestr(&tmpstring,"none");
  674.         (*pTable)[1].kwd = tmpstring;
  675.         tmpstring = NULL;
  676. #endif /* OS2 */
  677.         (*pTable)[1].kwval = 999;
  678.         (*pTable)[1].flgs = 0;
  679.         (*pN) = 2;
  680.  
  681.         for ( i=0 ; i < n ; i++ ) {
  682.             char * newstr = NULL, * p;
  683.             int newval = encryptions[i].type;
  684.             int j = 0, len = 0;
  685.  
  686. #ifdef OS2
  687.             newstr = strdup(encryptions[i].name);
  688.             strlwr(newstr);
  689. #else /* OS2 */
  690.             makestr(&tmpstring,encryptions[i].name);
  691.             newstr = tmpstring;
  692.             tmpstring = NULL;
  693.             for (p = newstr; *p; p++) if (isupper(*p)) *p = tolower(*p);
  694. #endif /* OS2 */
  695.  
  696.             for (j = 0; j < (*pN); j++) {
  697.                 int tempval = 0;
  698.                 char * tempstr = NULL;
  699.  
  700.                 if ( strcmp( (*pTable)[j].kwd, newstr ) > 0 )
  701.                 {
  702.                     tempval = (*pTable)[j].kwval;
  703.                     tempstr = (*pTable)[j].kwd;
  704.                     (*pTable)[j].kwd = newstr ;
  705.                     (*pTable)[j].kwval = newval;
  706.                     newval = tempval;
  707.                     newstr = tempstr;
  708.                     (*pTable)[j].flgs = 0;
  709.                 }
  710.             }
  711.             (*pTable)[*pN].kwd = newstr ;
  712.             (*pTable)[*pN].kwval = newval;
  713.             (*pTable)[*pN].flgs = 0 ;
  714.             (*pN)++ ;
  715.         }
  716.     } else {
  717.         *pTable = malloc( sizeof(struct keytab) * 2 ) ;
  718.         if ( !(*pTable) )
  719.             return(0);
  720.  
  721. #ifdef OS2
  722.         (*pTable)[0].kwd =strdup("automatic");
  723. #else /* OS2 */
  724.         makestr(&tmpstring,"automatic");
  725.         (*pTable)[0].kwd = tmpstring;
  726.         tmpstring = NULL;
  727. #endif /* OS2 */
  728.         (*pTable)[0].kwval = ENCTYPE_ANY;
  729.         (*pTable)[0].flgs = 0;
  730. #ifdef OS2
  731.         (*pTable)[1].kwd =strdup("none");
  732. #else /* OS2 */
  733.         makestr(&tmpstring,"none");
  734.         (*pTable)[1].kwd = tmpstring;
  735.         tmpstring = NULL;
  736. #endif /* OS2 */
  737.         (*pTable)[1].kwval = 999;
  738.         (*pTable)[1].flgs = 0;
  739.         (*pN) = 2;
  740.     }
  741.     return(*pN);
  742. }
  743.  
  744. static unsigned char str_send[64] = { IAC, SB, TELOPT_ENCRYPTION,
  745.                                       ENCRYPT_SUPPORT };
  746. static unsigned char str_suplen = 0;
  747. static unsigned char str_start[72] = { IAC, SB, TELOPT_ENCRYPTION };
  748. static unsigned char str_end[] = { IAC, SB, TELOPT_ENCRYPTION, 0, IAC, SE };
  749.  
  750. _PROTOTYP(int  encrypt_request_end, (VOID));
  751. _PROTOTYP(int  encrypt_request_start, (VOID));
  752. _PROTOTYP(int  encrypt_enc_keyid, (unsigned char *, int));
  753. _PROTOTYP(int  encrypt_dec_keyid, (unsigned char *, int));
  754. _PROTOTYP(int  encrypt_support, (unsigned char *, int));
  755. _PROTOTYP(int  encrypt_start, (unsigned char *, int));
  756. _PROTOTYP(int  encrypt_end, (VOID));
  757.  
  758. _PROTOTYP(int encrypt_ks_stream,(struct kstream_data_block *, /* output */
  759.                                    struct kstream_data_block *)); /* input */
  760.  
  761. _PROTOTYP(int decrypt_ks_stream,(struct kstream_data_block *, /* output */
  762.                                    struct kstream_data_block *)); /* input */
  763.  
  764. int
  765. #ifdef CK_ANSIC
  766. encrypt_ks_stream(struct kstream_data_block *i,
  767.                   struct kstream_data_block *o)
  768. #else
  769. encrypt_ks_stream(i,o)
  770.     struct kstream_data_block *i; struct kstream_data_block *o;
  771. #endif
  772. {
  773.     /*
  774.     * this is really quite bogus, since it does an in-place encryption...
  775.     */
  776.     if (encrypt_output) {
  777.         encrypt_output(i->ptr, i->length);
  778.         return 1;
  779.     }
  780.     return 0;
  781. }
  782.  
  783.  
  784. int
  785. #ifdef CK_ANSIC
  786. decrypt_ks_stream(struct kstream_data_block *i,
  787.                   struct kstream_data_block *o)
  788. #else
  789. decrypt_ks_stream(i,o)
  790.     struct kstream_data_block *i; struct kstream_data_block *o;
  791. #endif
  792. {
  793.     unsigned int len;
  794.   /*
  795.    * this is really quite bogus, since it does an in-place decryption...
  796.    */
  797.     if (decrypt_input) {
  798.         for (len = 0 ; len < i->length ; len++)
  799.             ((unsigned char *)i->ptr)[len]
  800.                 = decrypt_input(((unsigned char *)i->ptr)[len]);
  801.         return 1;
  802.     }
  803.     return 0;
  804. }
  805.  
  806. int
  807. #ifdef CK_ANSIC
  808. decrypt_ks_hack(unsigned char *buf, int cnt)
  809. #else
  810. decrypt_ks_hack(buf,cnt) unsigned char *buf; int cnt;
  811. #endif
  812. {
  813.     int len;
  814.   /*
  815.    * this is really quite bogus, since it does an in-place decryption...
  816.    */
  817.     for (len = 0 ; len < cnt ; len++)
  818.         buf[len] = decrypt_input(buf[len]);
  819.  
  820. #ifdef DEBUG
  821.     ckhexdump("decrypt ks hack", buf, cnt);
  822. #endif
  823.     return 1;
  824. }
  825.  
  826.  
  827. /*
  828.  * parsedat[0] == the suboption we might be negotiating,
  829.  */
  830. int
  831. #ifdef CK_ANSIC
  832. encrypt_parse(unsigned char *parsedat, int end_sub)
  833. #else
  834. encrypt_parse(parsedat,end_sub) unsigned char *parsedat; int end_sub;
  835. #endif
  836. {
  837.     int rc = 0;
  838.  
  839.     switch(parsedat[1]) {
  840.     case ENCRYPT_START:
  841.         rc = encrypt_start(parsedat + 2, end_sub - 2);
  842.         break;
  843.     case ENCRYPT_END:
  844.         rc = encrypt_end();
  845.         break;
  846.     case ENCRYPT_SUPPORT:
  847.         rc = encrypt_support(parsedat + 2, end_sub - 2);
  848.         break;
  849.     case ENCRYPT_REQSTART:
  850.         rc = encrypt_request_start();
  851.         break;
  852.     case ENCRYPT_REQEND:
  853.         /*
  854.         * We can always send an REQEND so that we cannot
  855.         * get stuck encrypting.  We should only get this
  856.         * if we have been able to get in the correct mode
  857.         * anyhow.
  858.         */
  859.         rc = encrypt_request_end();
  860.         break;
  861.     case ENCRYPT_IS:
  862.         rc = encrypt_is(parsedat + 2, end_sub - 2);
  863.         break;
  864.     case ENCRYPT_REPLY:
  865.         rc = encrypt_reply(parsedat + 2, end_sub - 2);
  866.         break;
  867.     case ENCRYPT_ENC_KEYID:
  868.         rc = encrypt_enc_keyid(parsedat + 2, end_sub - 2);
  869.         break;
  870.     case ENCRYPT_DEC_KEYID:
  871.         rc = encrypt_dec_keyid(parsedat + 2, end_sub - 2);
  872.         break;
  873.     default:
  874.         rc = -1;
  875.         break;
  876.     }
  877.     return(rc);
  878. }
  879.  
  880. /* XXX */
  881. Encryptions *
  882. #ifdef CK_ANSIC
  883. findencryption(int type)
  884. #else
  885. findencryption(type) int type;
  886. #endif
  887. {
  888.     Encryptions *ep = encryptions;
  889.  
  890.     if (!(I_SUPPORT_ENCRYPT & remote_supports_decrypt & typemask(type)))
  891.         return(0);
  892.     while (ep->type && ep->type != type)
  893.         ++ep;
  894.     return(ep->type ? ep : 0);
  895. }
  896.  
  897. Encryptions *
  898. #ifdef CK_ANSIC
  899. finddecryption(int type)
  900. #else
  901. finddecryption(type) int type;
  902. #endif
  903. {
  904.     Encryptions *ep = encryptions;
  905.  
  906.     if (!(I_SUPPORT_DECRYPT & remote_supports_encrypt & typemask(type)))
  907.         return(0);
  908.     while (ep->type && ep->type != type)
  909.         ++ep;
  910.     return(ep->type ? ep : 0);
  911. }
  912.  
  913. #define MAXKEYLEN 64
  914.  
  915. static struct key_info {
  916.     unsigned char keyid[MAXKEYLEN];
  917.     int keylen;
  918.     int dir;
  919.     int *modep;
  920.     Encryptions *(*getcrypt)();
  921. } ki[2] = {
  922.     { { 0 }, 0, DIR_ENCRYPT, &encrypt_mode, findencryption },
  923.     { { 0 }, 0, DIR_DECRYPT, &decrypt_mode, finddecryption },
  924. };
  925.  
  926. VOID
  927. #ifdef CK_ANSIC
  928. encrypt_init(kstream iks, int type)
  929. #else
  930. encrypt_init(iks, type) kstream iks; int type;
  931. #endif
  932. {
  933.     Encryptions *ep = encryptions;
  934.  
  935.     i_support_encrypt = i_support_decrypt = 0;
  936.     remote_supports_encrypt = remote_supports_decrypt = 0;
  937.     i_wont_support_encrypt = i_wont_support_decrypt = 0;
  938.     encrypt_mode = 0;
  939.     decrypt_mode = 0;
  940.     encrypt_output = NULL;
  941.     decrypt_input = NULL;
  942.     ki[0].keylen = 0;
  943.     memset(ki[0].keyid,0,MAXKEYLEN);
  944.     ki[1].keylen = 0;
  945.     memset(ki[1].keyid,0,MAXKEYLEN);
  946.     havesessionkey = 0;
  947.     autoencrypt = 1;
  948.     autodecrypt = 1;
  949.  
  950.     EncryptKSGlobalHack = iks;
  951.     EncryptType = type;
  952.  
  953.     str_send[0] = IAC;
  954.     str_send[1] = SB;
  955.     str_send[2] = TELOPT_ENCRYPTION;
  956.     str_send[3] = ENCRYPT_SUPPORT;
  957.     str_suplen = 4;
  958.  
  959.     while (ep->type) {
  960.         if ( EncryptType == ENCTYPE_ANY ||
  961.              EncryptType == ep->type ) {
  962. #ifdef DEBUG
  963.             if (encrypt_debug_mode) {
  964.                 sprintf(dbgbuf, ">>>I will support %s\n",
  965.                          ENCTYPE_NAME(ep->type));       /* safe */
  966.                 debug(F110,"encrypt_init",dbgbuf,0);
  967.             }
  968. #endif
  969.             i_support_encrypt |= typemask(ep->type);
  970.             i_support_decrypt |= typemask(ep->type);
  971.             if ((i_wont_support_decrypt & typemask(ep->type)) == 0)
  972.                 if ((str_send[str_suplen++] = ep->type) == IAC)
  973.                     str_send[str_suplen++] = IAC;
  974.         }
  975.         if (ep->init)
  976.             (*ep->init)(0);
  977.         ++ep;
  978.     }
  979.     str_send[str_suplen++] = IAC;
  980.     str_send[str_suplen++] = SE;
  981. }
  982.  
  983. VOID
  984. #ifdef CK_ANSIC
  985. encrypt_send_support(VOID)
  986. #else
  987. encrypt_send_support()
  988. #endif
  989. {
  990.     Encryptions *ep = encryptions;
  991.  
  992. #ifdef CK_SSL
  993.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  994.         return;
  995. #endif /* CK_SSL */
  996.  
  997.     str_send[0] = IAC;
  998.     str_send[1] = SB;
  999.     str_send[2] = TELOPT_ENCRYPTION;
  1000.     str_send[3] = ENCRYPT_SUPPORT;
  1001.     str_suplen = 4;
  1002.  
  1003.     while (ep->type) {
  1004.         if ( EncryptType == ENCTYPE_ANY ||
  1005.              EncryptType == ep->type ) {
  1006. #ifdef DEBUG
  1007.             if (encrypt_debug_mode) {
  1008.                 sprintf(dbgbuf, ">>>I will support %s\n",
  1009.                          ENCTYPE_NAME(ep->type));               /* safe */
  1010.                 debug(F110,"encrypt_send_support",dbgbuf,0);
  1011.             }
  1012. #endif
  1013.             if ((i_wont_support_decrypt & typemask(ep->type)) == 0)
  1014.                 if ((str_send[str_suplen++] = ep->type) == IAC)
  1015.                     str_send[str_suplen++] = IAC;
  1016.         }
  1017.         ++ep;
  1018.     }
  1019.     str_send[str_suplen++] = IAC;
  1020.     str_send[str_suplen++] = SE;
  1021.  
  1022.     /*
  1023.     * If the user has requested that decryption start
  1024.     * immediatly, then send a "REQUEST START" before
  1025.     * we negotiate the type.
  1026.     */
  1027.     if (autodecrypt)
  1028.         encrypt_send_request_start();
  1029.  
  1030.     if (deblog || tn_deb || debses) {
  1031.         int i;
  1032.         sprintf(tn_msg,"TELNET SENT SB %s SUPPORT ",
  1033.                  TELOPT(TELOPT_ENCRYPTION));                    /* safe */
  1034.         for ( i=4;i<str_suplen-2;i++ ) {
  1035.             if ( str_send[i] == IAC ) {
  1036.                 ckstrncat(tn_msg,"IAC ",TN_MSG_LEN);
  1037.                 i++;
  1038.             }
  1039.             ckstrncat(tn_msg,ENCTYPE_NAME(str_send[i]),TN_MSG_LEN);
  1040.             ckstrncat(tn_msg," ",TN_MSG_LEN);
  1041.         }
  1042.         ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  1043.         debug(F100,tn_msg,"",0);
  1044.         if (tn_deb || debses) tn_debug(tn_msg);
  1045.     }
  1046. #ifdef OS2
  1047.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1048. #endif
  1049.     ttol(str_send, str_suplen);
  1050. #ifdef OS2
  1051.     ReleaseTelnetMutex();
  1052. #endif
  1053.  
  1054.     str_suplen = 0;
  1055. }
  1056.  
  1057. /*
  1058.  * Called when ENCRYPT SUPPORT is received.
  1059.  */
  1060. int
  1061. #ifdef CK_ANSIC
  1062. encrypt_support(unsigned char *_typelist, int _cnt)
  1063. #else
  1064. encrypt_support(_typelist, _cnt) unsigned char * _typelist; int _cnt;
  1065. #endif
  1066. {
  1067.     register int type, use_type = 0;
  1068.     unsigned char * typelist = _typelist;
  1069.     int cnt = _cnt;
  1070.     Encryptions *ep;
  1071.  
  1072.     debug(F111,"encrypt_support","cnt",cnt);
  1073.  
  1074.   /*
  1075.    * Forget anything the other side has previously told us.
  1076.    */
  1077.     remote_supports_decrypt = 0;
  1078.  
  1079.     while (cnt-- > 0) {
  1080.     debug(F101,"XXX cnt","",cnt);
  1081.         type = *typelist++;
  1082.     debug(F101,"XXX type","",type);
  1083.     debug(F101,"XXX ENCTYPE_ANY","",ENCTYPE_ANY);
  1084.         if ( EncryptType == ENCTYPE_ANY ||
  1085.              EncryptType == type ) {
  1086. #ifdef DEBUG
  1087.             if (encrypt_debug_mode) {
  1088.                 sprintf(dbgbuf, ">>>Remote supports %s (%d)\n",
  1089.                          ENCTYPE_NAME(type), type);             /* safe */
  1090.                 debug(F110,"encrypt_support",dbgbuf,0);
  1091.             }
  1092. #endif
  1093.             if ((type < ENCTYPE_CNT) &&
  1094.                  (I_SUPPORT_ENCRYPT & typemask(type))) {
  1095.                 remote_supports_decrypt |= typemask(type);
  1096.                 if (use_type == 0)
  1097.                     use_type = type;
  1098.             }
  1099.         }
  1100.     }
  1101.     debug(F101,"XXX use_type","",use_type);
  1102.     if (use_type) {
  1103.         ep = findencryption(use_type);
  1104.         if (!ep) {
  1105.             debug(F111,"encrypt_support","findencryption == NULL",use_type);
  1106.             return(-1);
  1107.         }
  1108.     debug(F100,"XXX ep not NULL","",0);
  1109.         type = ep->start ? (*ep->start)(DIR_ENCRYPT, 0) : 0;
  1110.     debug(F101,"XXX new type","",type);
  1111. #ifdef DEBUG
  1112.         if (encrypt_debug_mode) {
  1113.             sprintf(dbgbuf, ">>>(*ep->start)() %s returned %d (%s)\n",
  1114.                      ENCTYPE_NAME(use_type), type,
  1115.                      ENCRYPT_NAME(type));                       /* safe */
  1116.             debug(F110,"encrypt_support",dbgbuf,0);
  1117.         }
  1118. #endif
  1119.         if (type < 0) {
  1120.             debug(F111,"encrypt_support","type < 0",type);
  1121.             return(-1);
  1122.         }
  1123.         encrypt_mode = use_type;
  1124.         if (type == 0)
  1125.             encrypt_start_output(use_type);
  1126.         debug(F111,"encrypt_support","success",type);
  1127.         return(0);
  1128.     }
  1129.     debug(F111,"encrypt_support","failed",use_type);
  1130.     return(-1);
  1131. }
  1132.  
  1133. int
  1134. #ifdef CK_ANSIC
  1135. encrypt_is(unsigned char *data, int cnt)
  1136. #else
  1137. encrypt_is(data, cnt) unsigned char *data; int cnt;
  1138. #endif /* CK_ANSIC */
  1139. {
  1140.     Encryptions *ep;
  1141.     register int type, ret;
  1142.  
  1143.     if (--cnt < 0)
  1144.         return(-1);
  1145.     type = *data++;
  1146.     if (type < ENCTYPE_CNT)
  1147.         remote_supports_encrypt |= typemask(type);
  1148.     if (!(ep = finddecryption(type))) {
  1149. #ifdef DEBUG
  1150.         if (encrypt_debug_mode) {
  1151.             sprintf(dbgbuf, ">>>encrypt_is:  "
  1152.                      "Can't find type %s (%d) for initial negotiation\n",
  1153.                      ENCTYPE_NAME_OK(type)
  1154.                      ? ENCTYPE_NAME(type) : "(unknown)",
  1155.                      type);                                     /* safe */
  1156.             debug(F110,"encrypt_is",dbgbuf,0);
  1157.         }
  1158. #endif
  1159.         return(-1);
  1160.     }
  1161.     if (!ep->is) {
  1162. #ifdef DEBUG
  1163.         if (encrypt_debug_mode) {
  1164.             sprintf(dbgbuf, ">>>encrypt_is:  "
  1165.                      "No initial negotiation needed for type %s (%d)\n",
  1166.                      ENCTYPE_NAME_OK(type)
  1167.                      ? ENCTYPE_NAME(type) : "(unknown)",
  1168.                      type);                                     /* safe */
  1169.             debug(F110,"encrypt_is",dbgbuf,0);
  1170.         }
  1171. #endif
  1172.         ret = 0;
  1173.     } else {
  1174.         ret = (*ep->is)(data, cnt);
  1175. #ifdef DEBUG
  1176.         if (encrypt_debug_mode) {
  1177.             sprintf(dbgbuf, "encrypt_is:  "
  1178.                      "(*ep->is)(%x, %d) returned %s(%d)\n", data, cnt,
  1179.                      (ret < 0) ? "FAIL " :
  1180.                      (ret == 0) ? "SUCCESS " : "MORE_TO_DO ", ret); /* safe */
  1181.             debug(F110,"encrypt_is",dbgbuf,0);
  1182.         }
  1183. #endif
  1184.     }
  1185.     if (ret < 0) {
  1186.         autodecrypt = 0;
  1187.         return(-1);
  1188.     } else {
  1189.         decrypt_mode = type;
  1190.         if (ret == 0 && autodecrypt) {
  1191.             encrypt_send_request_start();
  1192.         }
  1193.     }
  1194.     return(0);
  1195. }
  1196.  
  1197. int
  1198. #ifdef CK_ANSIC
  1199. encrypt_reply(unsigned char *data, int cnt)
  1200. #else
  1201. encrypt_reply(data, cnt) unsigned char *data; int cnt;
  1202. #endif
  1203. {
  1204.     Encryptions *ep;
  1205.     register int ret, type;
  1206.  
  1207.     if (--cnt < 0)
  1208.         return(-1);
  1209.     type = *data++;
  1210.     if (!(ep = findencryption(type))) {
  1211. #ifdef DEBUG
  1212.         if (encrypt_debug_mode) {
  1213.             sprintf(dbgbuf,
  1214.                     ">>>Can't find type %s (%d) for initial negotiation\n",
  1215.                      ENCTYPE_NAME_OK(type)
  1216.                      ? ENCTYPE_NAME(type) : "(unknown)",
  1217.                      type);                                     /* safe */
  1218.             debug(F110,"encrypt_reply",dbgbuf,0);
  1219.         }
  1220. #endif
  1221.         return(-1);
  1222.     }
  1223.     if (!ep->reply) {
  1224. #ifdef DEBUG
  1225.         if (encrypt_debug_mode) {
  1226.       sprintf(dbgbuf, ">>>No initial negotiation needed for type %s (%d)\n",
  1227.                ENCTYPE_NAME_OK(type)
  1228.                ? ENCTYPE_NAME(type) : "(unknown)",
  1229.                type);                                           /* safe */
  1230.             debug(F110,"encrypt_reply",dbgbuf,0);
  1231.         }
  1232. #endif
  1233.         ret = 0;
  1234.     } else {
  1235.         ret = (*ep->reply)(data, cnt);
  1236. #ifdef DEBUG
  1237.         if (encrypt_debug_mode) {
  1238.             sprintf(dbgbuf, "(*ep->reply)(%x, %d) returned %s(%d)\n",
  1239.                      data, cnt,
  1240.                      (ret < 0) ? "FAIL " :
  1241.                      (ret == 0) ? "SUCCESS " : "MORE_TO_DO ", ret); /* safe */
  1242.             debug(F110,"encrypt_reply",dbgbuf,0);
  1243.         }
  1244. #endif
  1245.     }
  1246. #ifdef DEBUG
  1247.     if (encrypt_debug_mode) {
  1248.         sprintf(dbgbuf, ">>>encrypt_reply returned %d\n", ret); /* safe */
  1249.         debug(F110,"encrypt_reply",dbgbuf,0);
  1250.     }
  1251. #endif
  1252.     if (ret < 0) {
  1253.         autoencrypt = 0;
  1254.         return(-1);
  1255.     } else {
  1256.         encrypt_mode = type;
  1257.         if (ret == 0 && autoencrypt)
  1258.             encrypt_start_output(type);
  1259.     }
  1260.     return(0);
  1261. }
  1262.  
  1263. /*
  1264.  * Called when a ENCRYPT START command is received.
  1265.  */
  1266. int
  1267. #ifdef CK_ANSIC
  1268. encrypt_start(unsigned char *data, int cnt)
  1269. #else
  1270. encrypt_start(data, cnt) unsigned char *data; int cnt;
  1271. #endif
  1272. {
  1273.     Encryptions *ep;
  1274.  
  1275.     if (!decrypt_mode) {
  1276.         /*
  1277.         * Something is wrong.  We should not get a START
  1278.         * command without having already picked our
  1279.         * decryption scheme.  Send a REQUEST-END to
  1280.         * attempt to clear the channel...
  1281.         */
  1282.         encrypt_send_request_end();
  1283.         printf("Authentication error!\n%s\n",
  1284.                 "Warning, Cannot decrypt input stream!!!");
  1285.         return(-1);
  1286.     }
  1287.  
  1288.     if (ep = finddecryption(decrypt_mode)) {
  1289.         if ( decrypt_input != ep->input ) {
  1290.             decrypt_input = ep->input;
  1291.             EncryptKSGlobalHack->decrypt = decrypt_ks_stream;
  1292.             EncryptKSGlobalHack->decrypt_type = ep->type;
  1293.  
  1294.             if (encrypt_verbose) {
  1295.                 sprintf(dbgbuf, "Input is now decrypted with type %s",
  1296.                          ENCTYPE_NAME(decrypt_mode));           /* safe */
  1297.                 debug(F110,"encrypt_start",dbgbuf,0);
  1298.                 printf("%s\n",dbgbuf);
  1299.             }
  1300. #ifdef DEBUG
  1301.             if (encrypt_debug_mode) {
  1302.                 sprintf(dbgbuf, ">>>Start to decrypt input with type %s",
  1303.                          ENCTYPE_NAME(decrypt_mode));           /* safe */
  1304.                 debug(F110,"ck_crp",dbgbuf,0);
  1305.             }
  1306. #endif
  1307.         }
  1308.     } else {
  1309.         char buf[1024];
  1310.         sprintf(buf, "Warning, Cannot decrypt type %s (%d)!!!",
  1311.                   ENCTYPE_NAME_OK(decrypt_mode)
  1312.                   ? ENCTYPE_NAME(decrypt_mode) : "(unknown)",
  1313.                   decrypt_mode);                                /* safe */
  1314.         printf("Authentication error!\n%s\n",buf);
  1315.         encrypt_send_request_end();
  1316.         return(-1);
  1317.     }
  1318.     return(0);
  1319. }
  1320.  
  1321. int
  1322. #ifdef CK_ANSIC
  1323. encrypt_dont_support(int type)
  1324. #else
  1325. encrypt_dont_support(type) int type;
  1326. #endif
  1327. {
  1328.     i_wont_support_encrypt |= typemask(type);
  1329.     i_wont_support_decrypt |= typemask(type);
  1330.     return(0);
  1331. }
  1332.  
  1333. int
  1334. #ifdef CK_ANSIC
  1335. encrypt_session_key(Session_Key *key, int server)
  1336. #else
  1337. encrypt_session_key(key, server) Session_Key *key; int server;
  1338. #endif
  1339. {
  1340.     Encryptions *ep = encryptions;
  1341.  
  1342.     if (havesessionkey)
  1343.         return(0);
  1344.  
  1345.     havesessionkey = 1;
  1346.  
  1347.     while (ep->type) {
  1348.         debug(F111,"encrypt_session_key",ep->name,ep->type);
  1349.         if (ep->session) {
  1350.             if ((*ep->session)(key, server) < 0) {
  1351.                 i_wont_support_encrypt |= typemask(ep->type);
  1352.                 i_wont_support_decrypt |= typemask(ep->type);
  1353.             }
  1354.         }
  1355.         ++ep;
  1356.     }
  1357.     debug(F111,"encrypt_session_key (done)",ep->name,ep->type);
  1358.     return(0);
  1359. }
  1360.  
  1361. /*
  1362.  * Called when ENCRYPT END is received.
  1363.  */
  1364. int
  1365. #ifdef CK_ANSIC
  1366. encrypt_end(VOID)
  1367. #else
  1368. encrypt_end()
  1369. #endif
  1370. {
  1371.     decrypt_input = NULL;
  1372.     EncryptKSGlobalHack->decrypt = NULL;
  1373.     EncryptKSGlobalHack->decrypt_type = ENCTYPE_ANY;
  1374. #ifdef DEBUG
  1375.     if (encrypt_debug_mode) {
  1376.         sprintf(dbgbuf, ">>>Input is back to clear text");      /* safe */
  1377.         debug(F110,"encrypt_end",dbgbuf,0);
  1378.     }
  1379. #endif
  1380.     if (encrypt_verbose) {
  1381.         sprintf(dbgbuf, "Input is now clear text");             /* safe */
  1382.         debug(F110,"encrypt_end",dbgbuf,0);
  1383.         printf("%s\n",dbgbuf);
  1384.     }
  1385.     return(0);
  1386. }
  1387.  
  1388. /*
  1389.  * Called when ENCRYPT REQUEST-END is received.
  1390.  */
  1391. int
  1392. #ifdef CK_ANSIC
  1393. encrypt_request_end(VOID)
  1394. #else
  1395. encrypt_request_end()
  1396. #endif
  1397. {
  1398.     encrypt_send_end();
  1399.     return(0);
  1400. }
  1401.  
  1402. /*
  1403.  * Called when ENCRYPT REQUEST-START is received.  If we receive
  1404.  * this before a type is picked, then that indicates that the
  1405.  * other side wants us to start encrypting data as soon as we
  1406.  * can.
  1407.  */
  1408. int
  1409. #ifdef CK_ANSIC
  1410. encrypt_request_start(VOID)
  1411. #else
  1412. encrypt_request_start()
  1413. #endif
  1414. {
  1415.     if (encrypt_mode != 0)
  1416.         encrypt_start_output(encrypt_mode);
  1417.     return(0);
  1418. }
  1419.  
  1420. static unsigned char str_keyid[(MAXKEYLEN*2)+5] = {
  1421.     IAC, SB, TELOPT_ENCRYPTION
  1422. };
  1423. _PROTOTYP(int encrypt_keyid,(struct key_info *,unsigned char *,int));
  1424.  
  1425. int
  1426. #ifdef CK_ANSIC
  1427. encrypt_enc_keyid(unsigned char *keyid, int len)
  1428. #else
  1429. encrypt_enc_keyid(keyid, len) unsigned char *keyid; int len;
  1430. #endif
  1431. {
  1432.     return(encrypt_keyid(&ki[1], keyid, len));
  1433. }
  1434.  
  1435. int
  1436. #ifdef CK_ANSIC
  1437. encrypt_dec_keyid(unsigned char *keyid, int len)
  1438. #else
  1439. encrypt_dec_keyid(keyid, len) unsigned char *keyid; int len;
  1440. #endif /* CK_ANSIC */
  1441. {
  1442.     return(encrypt_keyid(&ki[0], keyid, len));
  1443. }
  1444.  
  1445. int
  1446. #ifdef CK_ANSIC
  1447. encrypt_keyid(struct key_info *kp, unsigned char *keyid, int len)
  1448. #else
  1449. encrypt_keyid(kp, keyid, len)
  1450.     struct key_info *kp; unsigned char *keyid; int len;
  1451. #endif
  1452. {
  1453.     Encryptions *ep;
  1454.     int dir = kp->dir;
  1455.     register int ret = 0;
  1456.  
  1457.     if (!(ep = (*kp->getcrypt)(*kp->modep))) {
  1458.         if (len == 0)
  1459.             return(-1);
  1460.         kp->keylen = 0;
  1461.     } else if (len == 0 || len > MAXKEYLEN) {
  1462.         /*
  1463.         * Empty option or Key too long, indicates a failure.
  1464.         */
  1465.         if (kp->keylen == 0)
  1466.             return(-1);
  1467.         kp->keylen = 0;
  1468.         if (ep->keyid)
  1469.             (void)(*ep->keyid)(dir, kp->keyid, &kp->keylen);
  1470.  
  1471.     } else if ((len != kp->keylen) || (memcmp(keyid, kp->keyid, len) != 0)) {
  1472.         /*
  1473.         * Length or contents are different
  1474.         */
  1475.         kp->keylen = len;
  1476.         memcpy(kp->keyid, keyid, len);          /* length < MAXKEYLEN */
  1477.         if (ep->keyid)
  1478.             (void)(*ep->keyid)(dir, kp->keyid, &kp->keylen);
  1479.     } else {
  1480.         if (ep->keyid)
  1481.             ret = (*ep->keyid)(dir, kp->keyid, &kp->keylen);
  1482.         if ((ret == 0) && (dir == DIR_ENCRYPT) && autoencrypt)
  1483.             encrypt_start_output(*kp->modep);
  1484.         return(0);
  1485.     }
  1486.  
  1487.     encrypt_send_keyid(dir, kp->keyid, kp->keylen, 0);
  1488.     return(0);
  1489. }
  1490.  
  1491. int
  1492. #ifdef CK_ANSIC
  1493. encrypt_send_keyid(int dir, unsigned char *keyid, int keylen, int saveit)
  1494. #else
  1495. encrypt_send_keyid(dir, keyid, keylen, saveit)
  1496.      int dir; unsigned char *keyid; int keylen; int saveit;
  1497. #endif
  1498. {
  1499.     unsigned char *strp;
  1500.  
  1501. #ifdef CK_SSL
  1502.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  1503.         return(0);
  1504. #endif /* CK_SSL */
  1505.  
  1506.     str_keyid[3] = (dir == DIR_ENCRYPT)
  1507.         ? ENCRYPT_ENC_KEYID : ENCRYPT_DEC_KEYID;
  1508.     if (saveit && keylen <= MAXKEYLEN) {
  1509.         struct key_info *kp = &ki[(dir == DIR_ENCRYPT) ? 0 : 1];
  1510.         memcpy(kp->keyid, keyid, keylen);
  1511.         kp->keylen = keylen;
  1512.     }
  1513.  
  1514.     for (strp = &str_keyid[4]; keylen > 0; --keylen) {
  1515.         if ((*strp++ = *keyid++) == IAC)
  1516.             *strp++ = IAC;
  1517.     }
  1518.     *strp++ = IAC;
  1519.     *strp++ = SE;
  1520.  
  1521.     if (deblog || tn_deb || debses) {
  1522.         int i;
  1523.         sprintf(tn_msg,"TELNET SENT SB %s %s ",
  1524.                  TELOPT(TELOPT_ENCRYPTION),
  1525.                  (dir == DIR_ENCRYPT) ? "ENC-KEYID" : "DEC-KEYID"); /* safe */
  1526.         tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&str_keyid[4],strp-str_keyid-2-4);
  1527.         ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  1528.         debug(F100,tn_msg,"",0);
  1529.         if (tn_deb || debses) tn_debug(tn_msg);
  1530.     }
  1531. #ifdef OS2
  1532.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1533. #endif
  1534.     ttol(str_keyid, strp - str_keyid);
  1535. #ifdef OS2
  1536.     ReleaseTelnetMutex();
  1537. #endif
  1538.     return(0);
  1539. }
  1540.  
  1541. VOID
  1542. #ifdef CK_ANSIC
  1543. encrypt_auto(int on)
  1544. #else
  1545. encrypt_auto(on) int on;
  1546. #endif
  1547. {
  1548.     if (on < 0)
  1549.         autoencrypt ^= 1;
  1550.     else
  1551.         autoencrypt = on ? 1 : 0;
  1552. }
  1553.  
  1554. VOID
  1555. #ifdef CK_ANSIC
  1556. decrypt_auto(int on)
  1557. #else
  1558. decrypt_auto(on) int on;
  1559. #endif
  1560. {
  1561.     if (on < 0)
  1562.         autodecrypt ^= 1;
  1563.     else
  1564.         autodecrypt = on ? 1 : 0;
  1565. }
  1566.  
  1567. VOID
  1568. #ifdef CK_ANSIC
  1569. encrypt_start_output(int type)
  1570. #else
  1571. encrypt_start_output(type) int type;
  1572. #endif
  1573. {
  1574.     Encryptions *ep;
  1575.     register unsigned char *p;
  1576.     register int i;
  1577.  
  1578. #ifdef CK_SSL
  1579.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  1580.         return;
  1581. #endif /* CK_SSL */
  1582.  
  1583.     if (!(ep = findencryption(type))) {
  1584. #ifdef DEBUG
  1585.         if (encrypt_debug_mode) {
  1586.             sprintf(dbgbuf, ">>>Can't encrypt with type %s (%d)\n",
  1587.                      ENCTYPE_NAME_OK(type)
  1588.                      ? ENCTYPE_NAME(type) : "(unknown)",
  1589.                      type);                                     /* safe */
  1590.             debug(F110,"encrypt_start_output",dbgbuf,0);
  1591.         }
  1592. #endif
  1593.         return;
  1594.     }
  1595.     if (ep->start) {
  1596.         i = (*ep->start)(DIR_ENCRYPT, 0);
  1597. #ifdef DEBUG
  1598.         if (encrypt_debug_mode) {
  1599.             sprintf(dbgbuf, ">>>Encrypt start: %s (%d) %s\n",
  1600.                      (i < 0) ? "failed" :
  1601.                      "initial negotiation in progress",
  1602.                      i, ENCTYPE_NAME(type));                    /* safe */
  1603.             debug(F110,"encrypt_start_output",dbgbuf,0);
  1604.         }
  1605. #endif
  1606.         if (i)
  1607.             return;
  1608.     }
  1609.  
  1610.     if ( encrypt_output != ep->output ) {
  1611.         p = str_start;
  1612.         *p++ = IAC;
  1613.         *p++ = SB;
  1614.         *p++ = TELOPT_ENCRYPTION;
  1615.         *p++ = ENCRYPT_START;
  1616.         for (i = 0; i < ki[0].keylen; ++i) {
  1617.             if (( *p++ = ki[0].keyid[i]) == IAC)
  1618.                 *p++ = IAC;
  1619.         }
  1620.         *p++ = IAC;
  1621.         *p++ = SE;
  1622.  
  1623.         if (deblog || tn_deb || debses) {
  1624.             int i;
  1625.             sprintf(tn_msg,"TELNET SENT SB %s START ",
  1626.                      TELOPT(TELOPT_ENCRYPTION));                /* safe */
  1627.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&str_start[4],p-str_start-2-4);
  1628.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  1629.             debug(F100,tn_msg,"",0);
  1630.             if (tn_deb || debses) tn_debug(tn_msg);
  1631.         }
  1632. #ifdef OS2
  1633.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1634. #endif
  1635.         ttol(str_start, p - str_start);
  1636. #ifdef OS2
  1637.         ReleaseTelnetMutex();
  1638. #endif
  1639.  
  1640.   /*
  1641.    * If we are already encrypting in some mode, then
  1642.    * encrypt the ring (which includes our request) in
  1643.    * the old mode, mark it all as "clear text" and then
  1644.    * switch to the new mode.
  1645.    */
  1646.         encrypt_output = ep->output;
  1647.         EncryptKSGlobalHack->encrypt = encrypt_ks_stream;
  1648.         EncryptKSGlobalHack->encrypt_type = type;
  1649.         encrypt_mode = type;
  1650. #ifdef DEBUG
  1651.         if (encrypt_debug_mode) {
  1652.             sprintf(dbgbuf, ">>>Started to encrypt output with type %s",
  1653.                      ENCTYPE_NAME(type));                       /* safe */
  1654.             debug(F110,"encrypt_start_output",dbgbuf,0);
  1655.         }
  1656. #endif
  1657.         if (encrypt_verbose) {
  1658.             sprintf(dbgbuf, "Output is now encrypted with type %s",
  1659.                      ENCTYPE_NAME(type));                       /* safe */
  1660.             debug(F110,"encrypt_start_output",dbgbuf,0);
  1661.             printf("%s\n",dbgbuf);
  1662.         }
  1663.     }
  1664. }
  1665.  
  1666. VOID
  1667. #ifdef CK_ANSIC
  1668. encrypt_send_end(VOID)
  1669. #else
  1670. encrypt_send_end()
  1671. #endif
  1672. {
  1673. #ifdef CK_SSL
  1674.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  1675.         return;
  1676. #endif /* CK_SSL */
  1677.  
  1678.     if (!encrypt_output)
  1679.         return;
  1680.  
  1681.     str_end[0] = IAC;
  1682.     str_end[1] = SB;
  1683.     str_end[2] = TELOPT_ENCRYPTION;
  1684.     str_end[3] = ENCRYPT_END;
  1685.     str_end[4] = IAC;
  1686.     str_end[5] = SE;
  1687.  
  1688.     if (deblog || tn_deb || debses) {
  1689.         int i;
  1690.         sprintf(tn_msg,"TELNET SENT SB %s END IAC SE",
  1691.                  TELOPT(TELOPT_ENCRYPTION));                    /* safe */
  1692.         debug(F100,tn_msg,"",0);
  1693.         if (tn_deb || debses) tn_debug(tn_msg);
  1694.     }
  1695. #ifdef OS2
  1696.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1697. #endif
  1698.     ttol(str_end, sizeof(str_end));
  1699. #ifdef OS2
  1700.     ReleaseTelnetMutex();
  1701. #endif
  1702.  
  1703.     encrypt_output = 0;
  1704.     EncryptKSGlobalHack->encrypt = NULL;
  1705.     EncryptKSGlobalHack->encrypt_type = ENCTYPE_ANY;
  1706. #ifdef DEBUG
  1707.     if (encrypt_debug_mode) {
  1708.         sprintf(dbgbuf, ">>>Output is back to clear text");     /* safe */
  1709.         debug(F110,"encrypt_send_end",dbgbuf,0);
  1710.     }
  1711. #endif
  1712.     if (encrypt_verbose) {
  1713.         sprintf(dbgbuf, "Output is now clear text");            /* safe */
  1714.         debug(F110,"encrypt_send_end",dbgbuf,0);
  1715.         printf("%s\n",dbgbuf);
  1716.     }
  1717. }
  1718.  
  1719. VOID
  1720. #ifdef CK_ANSIC
  1721. encrypt_send_request_start(VOID)
  1722. #else
  1723. encrypt_send_request_start()
  1724. #endif
  1725. {
  1726.     register unsigned char *p;
  1727.     register int i;
  1728.  
  1729. #ifdef CK_SSL
  1730.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  1731.         return;
  1732. #endif /* CK_SSL */
  1733.  
  1734.     p = str_start;
  1735.     *p++ = IAC;
  1736.     *p++ = SB;
  1737.     *p++ = TELOPT_ENCRYPTION;
  1738.     *p++ = ENCRYPT_REQSTART;
  1739.     for (i = 0; i < ki[1].keylen; ++i) {
  1740.         if (( *p++ = ki[1].keyid[i]) == IAC)
  1741.             *p++ = IAC;
  1742.     }
  1743.     *p++ = IAC;
  1744.     *p++ = SE;
  1745.  
  1746.     if (deblog || tn_deb || debses) {
  1747.         int i;
  1748.         sprintf(tn_msg,"TELNET SENT SB %s REQUEST-START ",
  1749.                  TELOPT(TELOPT_ENCRYPTION));                    /* safe */
  1750.         tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&str_start[4],p-str_start-2-4);
  1751.         ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  1752.         debug(F100,tn_msg,"",0);
  1753.         if (tn_deb || debses) tn_debug(tn_msg);
  1754.     }
  1755. #ifdef OS2
  1756.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1757. #endif
  1758.     ttol(str_start, p - str_start);
  1759. #ifdef OS2
  1760.     ReleaseTelnetMutex();
  1761. #endif
  1762.  
  1763.     if (encrypt_debug_mode) {
  1764.         sprintf(dbgbuf, ">>>Request input to be encrypted\n");  /* safe */
  1765.         debug(F110,"encrypt_send_request_start",dbgbuf,0);
  1766.     }
  1767. }
  1768.  
  1769. VOID
  1770. #ifdef CK_ANSIC
  1771. encrypt_send_request_end(VOID)
  1772. #else
  1773. encrypt_send_request_end()
  1774. #endif
  1775. {
  1776. #ifdef CK_SSL
  1777.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  1778.         return;
  1779. #endif /* CK_SSL */
  1780.  
  1781.     str_end[0] = IAC;
  1782.     str_end[1] = SB;
  1783.     str_end[2] = TELOPT_ENCRYPTION;
  1784.     str_end[3] = ENCRYPT_REQEND;
  1785.     str_end[4] = IAC;
  1786.     str_end[5] = SE;
  1787.  
  1788.     if (deblog || tn_deb || debses) {
  1789.         int i;
  1790.         sprintf(tn_msg,"TELNET SENT SB %s REQEND IAC SE",
  1791.                  TELOPT(TELOPT_ENCRYPTION));                    /* safe */
  1792.         debug(F100,tn_msg,"",0);
  1793.         if (tn_deb || debses) tn_debug(tn_msg);
  1794.     }
  1795. #ifdef OS2
  1796.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1797. #endif
  1798.     ttol(str_end, sizeof(str_end));
  1799. #ifdef OS2
  1800.     ReleaseTelnetMutex();
  1801. #endif
  1802.  
  1803.     if (encrypt_debug_mode) {
  1804.         sprintf(dbgbuf, ">>>Request input to be clear text\n"); /* safe */
  1805.         debug(F110,"encrypt_send_request_end",dbgbuf,0);
  1806.     }
  1807. }
  1808.  
  1809. int
  1810. #ifdef CK_ANSIC
  1811. encrypt_is_encrypting(VOID)
  1812. #else
  1813. encrypt_is_encrypting()
  1814. #endif
  1815. {
  1816.     if (encrypt_output)
  1817.         return 1;
  1818.     return 0;
  1819. }
  1820.  
  1821. int
  1822. #ifdef CK_ANSIC
  1823. encrypt_is_decrypting(VOID)
  1824. #else
  1825. encrypt_is_decrypting()
  1826. #endif
  1827. {
  1828.     if (decrypt_input)
  1829.         return 1;
  1830.     return 0;
  1831. }
  1832.  
  1833. #ifdef DEBUG
  1834. void
  1835. encrypt_debug(mode)
  1836.      int mode;
  1837. {
  1838.     encrypt_debug_mode = mode;
  1839. }
  1840. #endif
  1841.  
  1842. #ifdef CK_DES
  1843. /*-
  1844.  * Copyright (c) 1991, 1993
  1845.  *      The Regents of the University of California.  All rights reserved.
  1846.  *
  1847.  * Redistribution and use in source and binary forms, with or without
  1848.  * modification, are permitted provided that the following conditions
  1849.  * are met:
  1850.  * 1. Redistributions of source code must retain the above copyright
  1851.  *    notice, this list of conditions and the following disclaimer.
  1852.  * 2. Redistributions in binary form must reproduce the above copyright
  1853.  *    notice, this list of conditions and the following disclaimer in the
  1854.  *    documentation and/or other materials provided with the distribution.
  1855.  * 3. All advertising materials mentioning features or use of this software
  1856.  *    must display the following acknowledgement:
  1857.  *      This product includes software developed by the University of
  1858.  *      California, Berkeley and its contributors.
  1859.  * 4. Neither the name of the University nor the names of its contributors
  1860.  *    may be used to endorse or promote products derived from this software
  1861.  *    without specific prior written permission.
  1862.  *
  1863.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  1864.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  1865.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  1866.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  1867.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  1868.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  1869.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  1870.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  1871.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  1872.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  1873.  * SUCH DAMAGE.
  1874.  */
  1875.  
  1876. /* based on @(#)enc_des.c       8.1 (Berkeley) 6/4/93 */
  1877.  
  1878. #define CFB     0
  1879. #define OFB     1
  1880.  
  1881. #define NO_SEND_IV      1
  1882. #define NO_RECV_IV      2
  1883. #define NO_KEYID        4
  1884. #define IN_PROGRESS     (NO_SEND_IV|NO_RECV_IV|NO_KEYID)
  1885. #define SUCCESS         0
  1886. #define xFAILED         -1
  1887.  
  1888. Schedule test_sched;
  1889.  
  1890. struct des_stinfo {
  1891.     Block               str_output;
  1892.     Block               str_feed;
  1893.     Block               str_iv;
  1894.     Block               str_ikey;
  1895. #ifdef MIT_CURRENT
  1896.     unsigned char       str_keybytes[8];
  1897.     krb5_keyblock       str_key;
  1898. #else /* MIT_CURRENT */
  1899.     Schedule            str_sched;
  1900.     int                 str_index;
  1901. #endif /* MIT_CURRENT */
  1902.     int                 str_flagshift;
  1903. };
  1904.  
  1905. struct des_fb {
  1906. #ifndef MIT_CURRENT
  1907.     Block krbdes_key;
  1908.     Schedule krbdes_sched;
  1909. #endif /* MIT_CURRENT */
  1910.     Block temp_feed;
  1911.     unsigned char fb_feed[64];
  1912.     int need_start;
  1913.     int state[2];
  1914.     int keyid[2];
  1915.     int once;
  1916. #ifdef MIT_CURRENT
  1917.     int validkey;
  1918. #endif /* MIT_CURRENT */
  1919.     struct des_stinfo  streams[2];
  1920. };
  1921. static struct des_fb des_fb[2];
  1922.  
  1923. struct des3_stinfo {
  1924.     Block               str_output;
  1925.     Block               str_feed;
  1926.     Block               str_iv;
  1927.     Block               str_ikey[3];
  1928.     Schedule            str_sched[3];
  1929.     int                 str_index;
  1930.     int                 str_flagshift;
  1931. };
  1932.  
  1933. struct des3_fb {
  1934. #ifndef MIT_CURRENT
  1935.     Block krbdes_key[3];
  1936.     Schedule krbdes_sched[3];
  1937. #endif /* MIT_CURRENT */
  1938.     Block temp_feed;
  1939.     unsigned char fb_feed[64];
  1940.     int need_start;
  1941.     int state[2];
  1942.     int keyid[2];
  1943.     int once;
  1944. #ifdef MIT_CURRENT
  1945.     int validkey;
  1946. #endif /* MIT_CURRENT */
  1947.     struct des3_stinfo streams[2];
  1948. };
  1949. static struct des3_fb des3_fb[2];
  1950.  
  1951. struct keyidlist {
  1952.     char        *keyid;
  1953.     int keyidlen;
  1954.     char        *key;
  1955.     int keylen;
  1956.     int flags;
  1957. } keyidlist [] = {
  1958.     { "\0", 1, 0, 0, 0 },               /* default key of zero */
  1959.     { 0, 0, 0, 0, 0 }
  1960. };
  1961.  
  1962. #define KEYFLAG_MASK    03
  1963.  
  1964. #define KEYFLAG_NOINIT  00
  1965. #define KEYFLAG_INIT    01
  1966. #define KEYFLAG_OK      02
  1967. #define KEYFLAG_BAD     03
  1968.  
  1969. #define KEYFLAG_SHIFT   2
  1970.  
  1971. #define SHIFT_VAL(a,b)  (KEYFLAG_SHIFT*((a)+((b)*2)))
  1972.  
  1973. #define FB64_IV         1
  1974. #define FB64_IV_OK      2
  1975. #define FB64_IV_BAD     3
  1976. #define FB64_CHALLENGE  4
  1977. #define FB64_RESPONSE   5
  1978.  
  1979. void fb64_stream_iv P((Block, struct des_stinfo *));
  1980. void fb64_init P((struct des_fb *));
  1981. static int fb64_start P((struct des_fb *, int, int));
  1982. int fb64_is P((unsigned char *, int, struct des_fb *));
  1983. int fb64_reply P((unsigned char *, int, struct des_fb *));
  1984. static int fb64_session P((Session_Key *, int, struct des_fb *));
  1985. void fb64_stream_key P((Block, struct des_stinfo *));
  1986. int fb64_keyid P((int, unsigned char *, int *, struct des_fb *));
  1987.  
  1988. #ifdef MIT_CURRENT
  1989. static void
  1990. #ifdef CK_ANSIC
  1991. ecb_encrypt(struct des_stinfo *stp, Block in, Block out)
  1992. #else /* CKANSIC */
  1993. ecb_encrypt(stp, in, out)
  1994.     struct des_stinfo *stp;
  1995.     Block in;
  1996.     Block out;
  1997. #endif /* CK_ANSIC */
  1998. {
  1999.     krb5_error_code code;
  2000.     krb5_data din;
  2001.     krb5_enc_data dout;
  2002.  
  2003.     din.length = 8;
  2004.     din.data = in;
  2005.  
  2006.     dout.ciphertext.length = 8;
  2007.     dout.ciphertext.data = out;
  2008.     dout.enctype = ENCTYPE_UNKNOWN;
  2009.  
  2010. #ifdef CRYPT_DLL
  2011.     code = krb5_c_encrypt(*p_k5_context, &stp->str_key, 0, 0,
  2012.                            &din, &dout);
  2013. #else /* CRYPT_DLL */
  2014.     code = krb5_c_encrypt(k5_context, &stp->str_key, 0, 0,
  2015.                            &din, &dout);
  2016. #endif /* CRYPT_DLL */
  2017.     /* XXX I'm not sure what to do if this fails */
  2018.     if (code)
  2019.         com_err("libtelnet", code, "encrypting stream data");
  2020. }
  2021. #endif /* MIT_CURRENT */
  2022.  
  2023. void
  2024. cfb64_init(server)
  2025.     int server;
  2026. {
  2027.     fb64_init(&des_fb[CFB]);
  2028.     des_fb[CFB].fb_feed[4] = ENCTYPE_DES_CFB64;
  2029.     des_fb[CFB].streams[0].str_flagshift = SHIFT_VAL(0, CFB);
  2030.     des_fb[CFB].streams[1].str_flagshift = SHIFT_VAL(1, CFB);
  2031. }
  2032.  
  2033. void
  2034. ofb64_init(server)
  2035.     int server;
  2036. {
  2037.     fb64_init(&des_fb[OFB]);
  2038.     des_fb[OFB].fb_feed[4] = ENCTYPE_DES_OFB64;
  2039.     des_fb[CFB].streams[0].str_flagshift = SHIFT_VAL(0, OFB);
  2040.     des_fb[CFB].streams[1].str_flagshift = SHIFT_VAL(1, OFB);
  2041. }
  2042.  
  2043. void
  2044. fb64_init(fbp)
  2045.     register struct des_fb *fbp;
  2046. {
  2047.     memset((void *)fbp, 0, sizeof(*fbp));
  2048.     fbp->state[0] = fbp->state[1] = xFAILED;
  2049.     fbp->fb_feed[0] = IAC;
  2050.     fbp->fb_feed[1] = SB;
  2051.     fbp->fb_feed[2] = TELOPT_ENCRYPTION;
  2052.     fbp->fb_feed[3] = ENCRYPT_IS;
  2053. }
  2054.  
  2055. /*
  2056.  * Returns:
  2057.  *      -1: some error.  Negotiation is done, encryption not ready.
  2058.  *       0: Successful, initial negotiation all done.
  2059.  *       1: successful, negotiation not done yet.
  2060.  *       2: Not yet.  Other things (like getting the key from
  2061.  *          Kerberos) have to happen before we can continue.
  2062.  */
  2063. int
  2064. cfb64_start(dir, server)
  2065.     int dir;
  2066.     int server;
  2067. {
  2068.     return(fb64_start(&des_fb[CFB], dir, server));
  2069. }
  2070. int
  2071. ofb64_start(dir, server)
  2072.     int dir;
  2073.     int server;
  2074. {
  2075.     return(fb64_start(&des_fb[OFB], dir, server));
  2076. }
  2077.  
  2078. static int
  2079. fb64_start(fbp, dir, server)
  2080.     struct des_fb *fbp;
  2081.     int dir;
  2082.     int server;
  2083. {
  2084.     int x;
  2085.     unsigned char *p;
  2086.     register int state;
  2087.  
  2088.     switch (dir) {
  2089.     case DIR_DECRYPT:
  2090.         /*
  2091.         * This is simply a request to have the other side
  2092.         * start output (our input).  He will negotiate an
  2093.         * IV so we need not look for it.
  2094.         */
  2095.         state = fbp->state[dir-1];
  2096.         if (state == xFAILED)
  2097.             state = IN_PROGRESS;
  2098.         break;
  2099.  
  2100.     case DIR_ENCRYPT:
  2101.         state = fbp->state[dir-1];
  2102.         if (state == xFAILED)
  2103.             state = IN_PROGRESS;
  2104.         else if ((state & NO_SEND_IV) == 0)
  2105.             break;
  2106.  
  2107. #ifdef MIT_CURRENT
  2108.         if (!fbp->validkey) {
  2109.             fbp->need_start = 1;
  2110.             break;
  2111.         }
  2112. #else /* MIT_CURRENT */
  2113.         if (!VALIDKEY(fbp->krbdes_key)) {
  2114.             fbp->need_start = 1;
  2115.             break;
  2116.         }
  2117. #endif /* MIT_CURRENT */
  2118.         state &= ~NO_SEND_IV;
  2119.         state |= NO_RECV_IV;
  2120.         /*
  2121.         * Create a random feed and send it over.
  2122.         */
  2123. #ifdef MIT_CURRENT
  2124.         {
  2125.             krb5_data d;
  2126.             krb5_error_code code;
  2127.  
  2128.             d.data = fbp->temp_feed;
  2129.             d.length = sizeof(fbp->temp_feed);
  2130.  
  2131. #ifdef CRYPT_DLL
  2132.             if (code = krb5_c_random_make_octets(*p_k5_context,&d))
  2133.                 return(xFAILED);
  2134. #else /* CRYPT_DLL */
  2135.             if (code = krb5_c_random_make_octets(k5_context,&d))
  2136.                 return(xFAILED);
  2137. #endif /* CRYPT_DLL */
  2138.         }
  2139.  
  2140. #else /* MIT_CURRENT */
  2141.         des_new_random_key(fbp->temp_feed);
  2142.         des_ecb_encrypt(fbp->temp_feed, fbp->temp_feed,
  2143.                          fbp->krbdes_sched, 1);
  2144. #endif /* MIT_CURRENT */
  2145.         p = fbp->fb_feed + 3;
  2146.         *p++ = ENCRYPT_IS;
  2147.         p++;
  2148.         *p++ = FB64_IV;
  2149.         for (x = 0; x < sizeof(Block); ++x) {
  2150.             if (( *p++ = fbp->temp_feed[x]) == IAC)
  2151.                 *p++ = IAC;
  2152.         }
  2153.         *p++ = IAC;
  2154.         *p++ = SE;
  2155.  
  2156.         if (deblog || tn_deb || debses) {
  2157.             int i;
  2158.             sprintf(tn_msg,
  2159.                      "TELNET SENT SB %s IS %s FB64_IV ",
  2160.                      TELOPT(fbp->fb_feed[2]),
  2161.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  2162.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  2163.         (p-fbp->fb_feed)-2-6);
  2164.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  2165.             debug(F100,tn_msg,"",0);
  2166.             if (tn_deb || debses) tn_debug(tn_msg);
  2167.         }
  2168. #ifdef OS2
  2169.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  2170. #endif
  2171.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  2172. #ifdef OS2
  2173.         ReleaseTelnetMutex();
  2174. #endif
  2175.         break;
  2176.     default:
  2177.         return(xFAILED);
  2178.     }
  2179.     return(fbp->state[dir-1] = state);
  2180. }
  2181.  
  2182. /*
  2183.  * Returns:
  2184.  *      -1: some error.  Negotiation is done, encryption not ready.
  2185.  *       0: Successful, initial negotiation all done.
  2186.  *       1: successful, negotiation not done yet.
  2187.  */
  2188. int
  2189. cfb64_is(data, cnt)
  2190.     unsigned char *data;
  2191.     int cnt;
  2192. {
  2193.     return(fb64_is(data, cnt, &des_fb[CFB]));
  2194. }
  2195.  
  2196. int
  2197. ofb64_is(data, cnt)
  2198.     unsigned char *data;
  2199.     int cnt;
  2200. {
  2201.     return(fb64_is(data, cnt, &des_fb[OFB]));
  2202. }
  2203.  
  2204. int
  2205. fb64_is(data, cnt, fbp)
  2206.     unsigned char *data;
  2207.     int cnt;
  2208.     struct des_fb *fbp;
  2209. {
  2210.     unsigned char *p;
  2211.     register int state = fbp->state[DIR_DECRYPT-1];
  2212.  
  2213.     if (cnt-- < 1)
  2214.         goto failure;
  2215.  
  2216. #ifdef CK_SSL
  2217.     if (!TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  2218. #endif /* CK_SSL */
  2219.     switch (*data++) {
  2220.     case FB64_IV:
  2221.         if (cnt != sizeof(Block)) {
  2222. #ifdef DEBUG
  2223.             if (encrypt_debug_mode)
  2224.                 printf("CFB64: initial vector failed on size\r\n");
  2225. #endif
  2226.             state = xFAILED;
  2227.             goto failure;
  2228.         }
  2229.  
  2230. #ifdef DEBUG
  2231.         if (encrypt_debug_mode) {
  2232.             printf("CFB64: initial vector received\r\n");
  2233.             printf("Initializing Decrypt stream\r\n");
  2234.         }
  2235. #endif
  2236.         fb64_stream_iv((void *)data, &fbp->streams[DIR_DECRYPT-1]);
  2237.  
  2238.         p = fbp->fb_feed + 3;
  2239.         *p++ = ENCRYPT_REPLY;
  2240.         p++;
  2241.         *p++ = FB64_IV_OK;
  2242.         *p++ = IAC;
  2243.         *p++ = SE;
  2244.  
  2245.         if (deblog || tn_deb || debses) {
  2246.             int i;
  2247.             sprintf(tn_msg,
  2248.                      "TELNET SENT SB %s REPLY %s FB64_IV_OK ",
  2249.                      TELOPT(fbp->fb_feed[2]),
  2250.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  2251.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  2252.         (p-fbp->fb_feed)-2-6);
  2253.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  2254.             debug(F100,tn_msg,"",0);
  2255.             if (tn_deb || debses) tn_debug(tn_msg);
  2256.         }
  2257. #ifdef OS2
  2258.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  2259. #endif
  2260.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  2261. #ifdef OS2
  2262.         ReleaseTelnetMutex();
  2263. #endif
  2264.         state = IN_PROGRESS;
  2265.         break;
  2266.  
  2267.     default:
  2268. #if 0
  2269.         if (encrypt_debug_mode) {
  2270.             printf("Unknown option type: %d\r\n", *(data-1));
  2271.             printf("\r\n");
  2272.         }
  2273. #endif
  2274.         /* FALL THROUGH */
  2275.       failure:
  2276.         /*
  2277.         * We failed.  Send an FB64_IV_BAD option
  2278.         * to the other side so it will know that
  2279.         * things failed.
  2280.         */
  2281.         p = fbp->fb_feed + 3;
  2282.         *p++ = ENCRYPT_REPLY;
  2283.         p++;
  2284.         *p++ = FB64_IV_BAD;
  2285.         *p++ = IAC;
  2286.         *p++ = SE;
  2287.  
  2288.         if (deblog || tn_deb || debses) {
  2289.             int i;
  2290.             sprintf(tn_msg,
  2291.                      "TELNET SENT SB %s REPLY %s FB64_IV_BAD ",
  2292.                      TELOPT(fbp->fb_feed[2]),
  2293.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  2294.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  2295.         (p-fbp->fb_feed)-2-6);
  2296.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  2297.             debug(F100,tn_msg,"",0);
  2298.             if (tn_deb || debses) tn_debug(tn_msg);
  2299.         }
  2300. #ifdef OS2
  2301.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  2302. #endif
  2303.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  2304. #ifdef OS2
  2305.         ReleaseTelnetMutex();
  2306. #endif
  2307.         break;
  2308.     }
  2309.     return(fbp->state[DIR_DECRYPT-1] = state);
  2310. }
  2311.  
  2312. /*
  2313.  * Returns:
  2314.  *      -1: some error.  Negotiation is done, encryption not ready.
  2315.  *       0: Successful, initial negotiation all done.
  2316.  *       1: successful, negotiation not done yet.
  2317.  */
  2318. int
  2319. cfb64_reply(data, cnt)
  2320.     unsigned char *data;
  2321.     int cnt;
  2322. {
  2323.     return(fb64_reply(data, cnt, &des_fb[CFB]));
  2324. }
  2325. int
  2326. ofb64_reply(data, cnt)
  2327.     unsigned char *data;
  2328.     int cnt;
  2329. {
  2330.     return(fb64_reply(data, cnt, &des_fb[OFB]));
  2331. }
  2332.  
  2333.  
  2334. int
  2335. fb64_reply(data, cnt, fbp)
  2336.     unsigned char *data;
  2337.     int cnt;
  2338.     struct des_fb *fbp;
  2339. {
  2340.     register int state = fbp->state[DIR_ENCRYPT-1];
  2341.  
  2342.     if (cnt-- < 1)
  2343.         goto failure;
  2344.  
  2345.     switch (*data++) {
  2346.     case FB64_IV_OK:
  2347.         fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  2348.         if (state == xFAILED)
  2349.             state = IN_PROGRESS;
  2350.         state &= ~NO_RECV_IV;
  2351.         encrypt_send_keyid(DIR_ENCRYPT, (unsigned char *)"\0", 1, 1);
  2352.         break;
  2353.  
  2354.     case FB64_IV_BAD:
  2355.         memset(fbp->temp_feed, 0, sizeof(Block));
  2356.         fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  2357.         state = xFAILED;
  2358.         break;
  2359.  
  2360.     default:
  2361. #if 0
  2362.         if (encrypt_debug_mode) {
  2363.             printf("Unknown option type: %d\r\n", data[-1]);
  2364.             printf("\r\n");
  2365.         }
  2366. #endif
  2367.         /* FALL THROUGH */
  2368.       failure:
  2369.         state = xFAILED;
  2370.         break;
  2371.     }
  2372.     return(fbp->state[DIR_ENCRYPT-1] = state);
  2373. }
  2374.  
  2375. int
  2376. cfb64_session(key, server)
  2377.     Session_Key *key;
  2378.     int server;
  2379. {
  2380.     return(fb64_session(key, server, &des_fb[CFB]));
  2381. }
  2382.  
  2383. int
  2384. ofb64_session(key, server)
  2385.     Session_Key *key;
  2386.     int server;
  2387. {
  2388.     return(fb64_session(key, server, &des_fb[OFB]));
  2389. }
  2390.  
  2391. static int
  2392. fb64_session(key, server, fbp)
  2393.     Session_Key *key;
  2394.     int server;
  2395.     struct des_fb *fbp;
  2396. {
  2397.     int rc=0;
  2398.     int use2keys;
  2399.     struct des_stinfo * s_stream;
  2400.     struct des_stinfo * c_stream;
  2401.  
  2402.     if(server) {
  2403.         s_stream = &fbp->streams[DIR_ENCRYPT-1];
  2404.         c_stream = &fbp->streams[DIR_DECRYPT-1];
  2405.     }
  2406.     else {
  2407.         s_stream = &fbp->streams[DIR_DECRYPT-1];
  2408.         c_stream = &fbp->streams[DIR_ENCRYPT-1];
  2409.     }
  2410.  
  2411.     if (!key || key->length < sizeof(Block)) {
  2412.         CHAR buf[80];
  2413.         sprintf((char *)buf,"Can't set DES session key (%d < %d)",
  2414.                 key ? key->length : 0, sizeof(Block));          /* safe */
  2415. #ifdef DEBUG
  2416.         if (encrypt_debug_mode)
  2417.             printf("%s\r\n",buf);
  2418. #endif
  2419.         debug(F110,"fb64_session",buf,0);
  2420.         return(-1);
  2421.     }
  2422.     use2keys = (key->type == SK_DES ||
  2423.                  key->length < 2 * sizeof(Block)) ? 0 : 1;
  2424. #ifdef MIT_CURRENT
  2425.     if(use2keys) {
  2426.         memcpy((void *) fbp->keybytes,
  2427.                  (void *) (key->data + sizeof(Block)), sizeof(Block));
  2428.         des_fixup_key_parity(fbp->);
  2429.         fb64_stream_key(fbp->krbdes_key, s_stream);
  2430.     }
  2431.  
  2432.     memcpy((void *)fbp->krbdes_key, (void *)key->data, sizeof(Block));
  2433.     if (key->type != SK_DES)
  2434.         des_fixup_key_parity(fbp->krbdes_key);
  2435.  
  2436.     if(!use2keys)
  2437.         fb64_stream_key(fbp->krbdes_key, s_stream);
  2438.     fb64_stream_key(fbp->krbdes_key, c_stream);
  2439.     fbp->validkey = 1;
  2440.  
  2441.     fb64_stream_key(key->data, &fbp->streams[DIR_ENCRYPT-1]);
  2442.     fb64_stream_key(key->data, &fbp->streams[DIR_DECRYPT-1]);
  2443. #else /* MIT_CURRENT */
  2444.     if(use2keys) {
  2445.         memcpy((void *) fbp->krbdes_key,
  2446.                  (void *) (key->data + sizeof(Block)), sizeof(Block));
  2447.         des_fixup_key_parity(fbp->krbdes_key);
  2448.         fb64_stream_key(fbp->krbdes_key, s_stream);
  2449.     }
  2450.  
  2451.     memcpy((void *)fbp->krbdes_key, (void *)key->data, sizeof(Block));
  2452.     if (key->type != SK_DES)
  2453.         des_fixup_key_parity(fbp->krbdes_key);
  2454.  
  2455.     if(!use2keys)
  2456.         fb64_stream_key(fbp->krbdes_key, s_stream);
  2457.     fb64_stream_key(fbp->krbdes_key, c_stream);
  2458.  
  2459.     if (fbp->once == 0) {
  2460.         des_set_random_generator_seed(fbp->krbdes_key);
  2461.         fbp->once = 1;
  2462.     }
  2463.  
  2464.     memset(fbp->krbdes_sched,0,sizeof(Schedule));
  2465.     ckhexdump("fb64_session_key",fbp->krbdes_key,8);
  2466.  
  2467.     rc = des_key_sched(fbp->krbdes_key, fbp->krbdes_sched);
  2468.     if ( rc == -1 ) {
  2469.         printf("?Invalid DES key specified for encryption\n");
  2470.         debug(F110,"fb64_session_key",
  2471.                "invalid DES Key specified for encryption",0);
  2472.     } else if ( rc == -2 ) {
  2473.         printf("?Weak DES key specified for encryption\n");
  2474.         debug(F110,"fb64_session_key",
  2475.                "weak DES Key specified for encryption",0);
  2476.     } else if ( rc != 0 ) {
  2477.         printf("?Key Schedule not created by encryption\n");
  2478.         debug(F110,"fb64_session_key",
  2479.                "Key Schedule not created by encryption",0);
  2480.     }
  2481.  
  2482.     ckhexdump("fb64_session_key schedule",fbp->krbdes_sched,8*16);
  2483. #endif /* MIT_CURRENT */
  2484.     /*
  2485.     * Now look to see if krbdes_start() was was waiting for
  2486.     * the key to show up.  If so, go ahead an call it now
  2487.     * that we have the key.
  2488.     */
  2489.     if (fbp->need_start) {
  2490.         fbp->need_start = 0;
  2491.         fb64_start(fbp, DIR_ENCRYPT, server);
  2492.     }
  2493.     return(0);
  2494. }
  2495.  
  2496. /*
  2497.  * We only accept a keyid of 0.  If we get a keyid of
  2498.  * 0, then mark the state as SUCCESS.
  2499.  */
  2500. int
  2501. cfb64_keyid(dir, kp, lenp)
  2502.     int dir, *lenp;
  2503.     unsigned char *kp;
  2504. {
  2505.     return(fb64_keyid(dir, kp, lenp, &des_fb[CFB]));
  2506. }
  2507.  
  2508. int
  2509. ofb64_keyid(dir, kp, lenp)
  2510.     int dir, *lenp;
  2511.     unsigned char *kp;
  2512. {
  2513.     return(fb64_keyid(dir, kp, lenp, &des_fb[OFB]));
  2514. }
  2515.  
  2516. int
  2517. fb64_keyid(dir, kp, lenp, fbp)
  2518.     int dir, *lenp;
  2519.     unsigned char *kp;
  2520.     struct des_fb *fbp;
  2521. {
  2522.     register int state = fbp->state[dir-1];
  2523.  
  2524.     if (*lenp != 1 || (*kp != '\0')) {
  2525.         *lenp = 0;
  2526.         return(state);
  2527.     }
  2528.  
  2529.     if (state == xFAILED)
  2530.         state = IN_PROGRESS;
  2531.  
  2532.     state &= ~NO_KEYID;
  2533.  
  2534.     return(fbp->state[dir-1] = state);
  2535. }
  2536.  
  2537. #if 0
  2538. void
  2539. fb64_printsub(data, cnt, buf, buflen, type)
  2540.     unsigned char *data, *buf, *type;
  2541.     int cnt, buflen;
  2542. {
  2543.     char lbuf[64];
  2544.     register int i;
  2545.     char *cp;
  2546.  
  2547.     buf[buflen-1] = '\0';               /* make sure it's NULL terminated */
  2548.     buflen -= 1;
  2549.  
  2550.     switch(data[2]) {
  2551.     case FB64_IV:
  2552.         sprintf(lbuf, "%s_IV", type);
  2553.         cp = lbuf;
  2554.         goto common;
  2555.  
  2556.     case FB64_IV_OK:
  2557.         sprintf(lbuf, "%s_IV_OK", type);
  2558.         cp = lbuf;
  2559.         goto common;
  2560.  
  2561.     case FB64_IV_BAD:
  2562.         sprintf(lbuf, "%s_IV_BAD", type);
  2563.         cp = lbuf;
  2564.         goto common;
  2565.  
  2566.     case FB64_CHALLENGE:
  2567.         sprintf(lbuf, "%s_CHALLENGE", type);
  2568.         cp = lbuf;
  2569.         goto common;
  2570.  
  2571.     case FB64_RESPONSE:
  2572.         sprintf(lbuf, "%s_RESPONSE", type);
  2573.         cp = lbuf;
  2574.         goto common;
  2575.  
  2576.     default:
  2577.         sprintf(lbuf, " %d (unknown)", data[2]);
  2578.         cp = lbuf;
  2579.       common:
  2580.         for (; (buflen > 0) && (*buf = *cp++); buf++)
  2581.             buflen--;
  2582.         for (i = 3; i < cnt; i++) {
  2583.             sprintf(lbuf, " %d", data[i]);
  2584.             for (cp = lbuf; (buflen > 0) && (*buf = *cp++); buf++)
  2585.                 buflen--;
  2586.         }
  2587.         break;
  2588.     }
  2589. }
  2590.  
  2591. void
  2592. cfb64_printsub(data, cnt, buf, buflen)
  2593.     unsigned char *data, *buf;
  2594.     int cnt, buflen;
  2595. {
  2596.     fb64_printsub(data, cnt, buf, buflen, "CFB64");
  2597. }
  2598.  
  2599. void
  2600. ofb64_printsub(data, cnt, buf, buflen)
  2601.     unsigned char *data, *buf;
  2602.     int cnt, buflen;
  2603. {
  2604.     fb64_printsub(data, cnt, buf, buflen, "OFB64");
  2605. }
  2606. #endif
  2607.  
  2608. void
  2609. fb64_stream_iv(seed, stp)
  2610.     Block seed;
  2611.     register struct des_stinfo *stp;
  2612. {
  2613.     int rc=0;
  2614.  
  2615.     memcpy(stp->str_iv,     seed, sizeof(Block));
  2616.     memcpy(stp->str_output, seed, sizeof(Block));
  2617.  
  2618.     memset(stp->str_sched,0,sizeof(Schedule));
  2619.  
  2620.     ckhexdump("fb64_stream_iv",stp->str_ikey,8);
  2621.  
  2622. #ifndef MIT_CURRENT
  2623.     rc = des_key_sched(stp->str_ikey, stp->str_sched);
  2624.     if ( rc == -1 ) {
  2625.         printf("?Invalid DES key specified for encryption\r\n");
  2626.         debug(F110,"fb64_stream_iv",
  2627.                "invalid DES Key specified for encryption",0);
  2628.     } else if ( rc == -2 ) {
  2629.         printf("?Weak DES key specified for encryption\r\n");
  2630.         debug(F110,"fb64_stream_iv",
  2631.                "weak DES Key specified for encryption",0);
  2632.     } else if ( rc != 0 ) {
  2633.         printf("?Key Schedule not created by encryption\r\n");
  2634.         debug(F110,"fb64_stream_iv",
  2635.                "Key Schedule not created by encryption",0);
  2636.     }
  2637.     ckhexdump("fb64_stream_iv schedule",stp->str_sched,8*16);
  2638. #endif /* MIT_CURRENT */
  2639.  
  2640.     stp->str_index = sizeof(Block);
  2641. }
  2642.  
  2643. void
  2644. fb64_stream_key(key, stp)
  2645.     Block key;
  2646.     register struct des_stinfo *stp;
  2647. {
  2648.     int rc = 0;
  2649.  
  2650. #ifdef MIT_CURRENT
  2651.     memcpy(stp->str_keybytes, key, sizeof(Block));
  2652.     stp->str_key.length = 8;
  2653.     stp->str_key.contents = stp->str_keybytes;
  2654.     /* the original version of this code uses des ecb mode, but
  2655.     it only ever does one block at a time.  cbc with a zero iv
  2656.     is identical */
  2657.     stp->str_key.enctype = ENCTYPE_DES_CBC_RAW;
  2658. #else /* MIT_CURRENT */
  2659.     memcpy(stp->str_ikey, key, sizeof(Block));
  2660.  
  2661.     memset(stp->str_sched,0,sizeof(Schedule));
  2662.  
  2663.     ckhexdump("fb64_stream_key",key,8);
  2664.  
  2665.     rc = des_key_sched(key, stp->str_sched);
  2666.     if ( rc == -1 ) {
  2667.         printf("?Invalid DES key specified for encryption\r\n");
  2668.         debug(F110,"fb64_stream_key",
  2669.                "invalid DES Key specified for encryption",0);
  2670.     } else if ( rc == -2 ) {
  2671.         printf("?Weak DES key specified for encryption\r\n");
  2672.         debug(F110,"fb64_stream_key",
  2673.                "weak DES Key specified for encryption",0);
  2674.     } else if ( rc != 0 ) {
  2675.         printf("?Key Schedule not created by encryption\r\n");
  2676.         debug(F110,"fb64_stream_key",
  2677.                "Key Schedule not created by encryption",0);
  2678.     }
  2679.     ckhexdump("fb64_stream_key schedule",stp->str_sched,8*16);
  2680. #endif /* MIT_CURRENT */
  2681.  
  2682.     memcpy(stp->str_output, stp->str_iv, sizeof(Block));
  2683.  
  2684.     stp->str_index = sizeof(Block);
  2685. }
  2686.  
  2687. /*
  2688.  * DES 64 bit Cipher Feedback
  2689.  *
  2690.  *     key --->+-----+
  2691.  *          +->| DES |--+
  2692.  *          |  +-----+  |
  2693.  *          |           v
  2694.  *  INPUT --(--------->(+)+---> DATA
  2695.  *          |             |
  2696.  *          +-------------+
  2697.  *
  2698.  *
  2699.  * Given:
  2700.  *      iV: Initial vector, 64 bits (8 bytes) long.
  2701.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  2702.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  2703.  *
  2704.  *      V0 = DES(iV, key)
  2705.  *      On = Dn ^ Vn
  2706.  *      V(n+1) = DES(On, key)
  2707.  */
  2708.  
  2709. void
  2710. cfb64_encrypt(s, c)
  2711.     register unsigned char *s;
  2712.     int c;
  2713. {
  2714.     register struct des_stinfo *stp = &des_fb[CFB].streams[DIR_ENCRYPT-1];
  2715.     register int index;
  2716.  
  2717.     index = stp->str_index;
  2718.     while (c-- > 0) {
  2719.         if (index == sizeof(Block)) {
  2720.             Block b;
  2721. #ifdef MIT_CURRENT
  2722.             ecb_encrypt(stp, stp->str_output, b);
  2723. #else /* MIT_CURRENT */
  2724.             des_ecb_encrypt(stp->str_output, b, stp->str_sched, 1);
  2725. #endif /* MIT_CURRENT */
  2726.             memcpy(stp->str_feed,b,sizeof(Block));
  2727.             index = 0;
  2728.         }
  2729.  
  2730.         /* On encryption, we store (feed ^ data) which is cypher */
  2731.         *s = stp->str_output[index] = (stp->str_feed[index] ^ *s);
  2732.         s++;
  2733.         index++;
  2734.     }
  2735.     stp->str_index = index;
  2736. }
  2737.  
  2738. int
  2739. cfb64_decrypt(data)
  2740.     int data;
  2741. {
  2742.     register struct des_stinfo *stp = &des_fb[CFB].streams[DIR_DECRYPT-1];
  2743.     int index;
  2744.  
  2745.     if (data == -1) {
  2746.         /*
  2747.         * Back up one byte.  It is assumed that we will
  2748.         * never back up more than one byte.  If we do, this
  2749.         * may or may not work.
  2750.         */
  2751.         if (stp->str_index)
  2752.             --stp->str_index;
  2753.         return(0);
  2754.     }
  2755.  
  2756.     index = stp->str_index++;
  2757.     if (index == sizeof(Block)) {
  2758.         Block b;
  2759. #ifdef MIT_CURRENT
  2760.         ecb_encrypt(stp, stp->str_output, b);
  2761. #else /* MIT_CURRENT */
  2762.         des_ecb_encrypt(stp->str_output, b, stp->str_sched, 1);
  2763. #endif /* MIT_CURRENT */
  2764.         memcpy(stp->str_feed, b, sizeof(Block));
  2765.         stp->str_index = 1;     /* Next time will be 1 */
  2766.         index = 0;              /* But now use 0 */
  2767.     }
  2768.  
  2769.     /* On decryption we store (data) which is cypher. */
  2770.     stp->str_output[index] = data;
  2771.     return(data ^ stp->str_feed[index]);
  2772. }
  2773.  
  2774. /*
  2775.  * DES 64 bit Output Feedback
  2776.  *
  2777.  * key --->+-----+
  2778.  *      +->| DES |--+
  2779.  *      |  +-----+  |
  2780.  *      +-----------+
  2781.  *                  v
  2782.  *  INPUT -------->(+) ----> DATA
  2783.  *
  2784.  * Given:
  2785.  *      iV: Initial vector, 64 bits (8 bytes) long.
  2786.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  2787.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  2788.  *
  2789.  *      V0 = DES(iV, key)
  2790.  *      V(n+1) = DES(Vn, key)
  2791.  *      On = Dn ^ Vn
  2792.  */
  2793. void
  2794. ofb64_encrypt(s, c)
  2795.     register unsigned char *s;
  2796.     int c;
  2797. {
  2798.     register struct des_stinfo *stp = &des_fb[OFB].streams[DIR_ENCRYPT-1];
  2799.     register int index;
  2800.  
  2801.     index = stp->str_index;
  2802.     while (c-- > 0) {
  2803.         if (index == sizeof(Block)) {
  2804.             Block b;
  2805. #ifdef MIT_CURRENT
  2806.             ecb_encrypt(stp, stp->str_feed, b);
  2807. #else /* MIT_CURRENT */
  2808.             des_ecb_encrypt(stp->str_feed, b, stp->str_sched, 1);
  2809. #endif /* MIT_CURRENT */
  2810.             memcpy(stp->str_feed,b,sizeof(Block));
  2811.             index = 0;
  2812.         }
  2813.         *s++ ^= stp->str_feed[index];
  2814.         index++;
  2815.     }
  2816.     stp->str_index = index;
  2817. }
  2818.  
  2819. int
  2820. ofb64_decrypt(data)
  2821.     int data;
  2822. {
  2823.     register struct des_stinfo *stp = &des_fb[OFB].streams[DIR_DECRYPT-1];
  2824.     int index;
  2825.  
  2826.     if (data == -1) {
  2827.         /*
  2828.         * Back up one byte.  It is assumed that we will
  2829.         * never back up more than one byte.  If we do, this
  2830.         * may or may not work.
  2831.         */
  2832.         if (stp->str_index)
  2833.             --stp->str_index;
  2834.         return(0);
  2835.     }
  2836.  
  2837.     index = stp->str_index++;
  2838.     if (index == sizeof(Block)) {
  2839.         Block b;
  2840. #ifdef MIT_CURRENT
  2841.         ecb_encrypt(stp, stp->str_feed, b);
  2842. #else /* MIT_CURRENT */
  2843.         des_ecb_encrypt(stp->str_feed, b, stp->str_sched, 1);
  2844. #endif /* MIT_CURRENT */
  2845.         memcpy(stp->str_feed, b, sizeof(Block));
  2846.         stp->str_index = 1;     /* Next time will be 1 */
  2847.         index = 0;              /* But now use 0 */
  2848.     }
  2849.  
  2850.     return(data ^ stp->str_feed[index]);
  2851. }
  2852.  
  2853.  
  2854. void des3_fb64_stream_iv P((Block, struct des3_stinfo *));
  2855. void des3_fb64_init P((struct des3_fb *));
  2856. static int des3_fb64_start P((struct des3_fb *, int, int));
  2857. int des3_fb64_is P((unsigned char *, int, struct des3_fb *));
  2858. int des3_fb64_reply P((unsigned char *, int, struct des3_fb *));
  2859. static int des3_fb64_session P((Session_Key *, int, struct des3_fb *));
  2860. void des3_fb64_stream_key P((Block *, struct des3_stinfo *));
  2861. int des3_fb64_keyid P((int, unsigned char *, int *, struct des3_fb *));
  2862.  
  2863. void
  2864. des3_cfb64_init(server)
  2865.     int server;
  2866. {
  2867.     des3_fb64_init(&des3_fb[CFB]);
  2868.     des3_fb[CFB].fb_feed[4] = ENCTYPE_DES3_CFB64;
  2869.     des3_fb[CFB].streams[0].str_flagshift = SHIFT_VAL(0, CFB);
  2870.     des3_fb[CFB].streams[1].str_flagshift = SHIFT_VAL(1, CFB);
  2871. }
  2872.  
  2873. void
  2874. des3_ofb64_init(server)
  2875.     int server;
  2876. {
  2877.     des3_fb64_init(&des3_fb[OFB]);
  2878.     des3_fb[OFB].fb_feed[4] = ENCTYPE_DES3_OFB64;
  2879.     des3_fb[CFB].streams[0].str_flagshift = SHIFT_VAL(0, OFB);
  2880.     des3_fb[CFB].streams[1].str_flagshift = SHIFT_VAL(1, OFB);
  2881. }
  2882.  
  2883. void
  2884. des3_fb64_init(fbp)
  2885.     register struct des3_fb *fbp;
  2886. {
  2887.     memset((void *)fbp, 0, sizeof(*fbp));
  2888.     fbp->state[0] = fbp->state[1] = xFAILED;
  2889.     fbp->fb_feed[0] = IAC;
  2890.     fbp->fb_feed[1] = SB;
  2891.     fbp->fb_feed[2] = TELOPT_ENCRYPTION;
  2892.     fbp->fb_feed[3] = ENCRYPT_IS;
  2893. }
  2894.  
  2895. /*
  2896.  * Returns:
  2897.  *      -1: some error.  Negotiation is done, encryption not ready.
  2898.  *       0: Successful, initial negotiation all done.
  2899.  *       1: successful, negotiation not done yet.
  2900.  *       2: Not yet.  Other things (like getting the key from
  2901.  *          Kerberos) have to happen before we can continue.
  2902.  */
  2903. int
  2904. des3_cfb64_start(dir, server)
  2905.     int dir;
  2906.     int server;
  2907. {
  2908.     return(des3_fb64_start(&des3_fb[CFB], dir, server));
  2909. }
  2910. int
  2911. des3_ofb64_start(dir, server)
  2912.     int dir;
  2913.     int server;
  2914. {
  2915.     return(des3_fb64_start(&des3_fb[OFB], dir, server));
  2916. }
  2917.  
  2918. static int
  2919. des3_fb64_start(fbp, dir, server)
  2920.     struct des3_fb *fbp;
  2921.     int dir;
  2922.     int server;
  2923. {
  2924.     int x;
  2925.     unsigned char *p;
  2926.     register int state;
  2927.  
  2928.     switch (dir) {
  2929.     case DIR_DECRYPT:
  2930.         /*
  2931.         * This is simply a request to have the other side
  2932.         * start output (our input).  He will negotiate an
  2933.         * IV so we need not look for it.
  2934.         */
  2935.         state = fbp->state[dir-1];
  2936.         if (state == xFAILED)
  2937.             state = IN_PROGRESS;
  2938.         break;
  2939.  
  2940.     case DIR_ENCRYPT:
  2941.         state = fbp->state[dir-1];
  2942.         if (state == xFAILED)
  2943.             state = IN_PROGRESS;
  2944.         else if ((state & NO_SEND_IV) == 0)
  2945.             break;
  2946.  
  2947.         if (!VALIDKEY(fbp->krbdes_key[0]) ||
  2948.             !VALIDKEY(fbp->krbdes_key[1]) ||
  2949.             !VALIDKEY(fbp->krbdes_key[2]) ) {
  2950.             fbp->need_start = 1;
  2951.             break;
  2952.         }
  2953.         state &= ~NO_SEND_IV;
  2954.         state |= NO_RECV_IV;
  2955.         /*
  2956.         * Create a random feed and send it over.
  2957.         */
  2958.         des_new_random_key(fbp->temp_feed);
  2959. #ifdef LIBDES
  2960.         des_ecb3_encrypt(fbp->temp_feed, fbp->temp_feed,
  2961.                          fbp->krbdes_sched[0],
  2962.                          fbp->krbdes_sched[1],
  2963.                          fbp->krbdes_sched[2],
  2964.                          1);
  2965. #else /* LIBDES */
  2966.         des_ecb_encrypt(fbp->temp_feed, fbp->temp_feed,
  2967.                          fbp->krbdes_sched[0], 1);
  2968.         des_ecb_encrypt(fbp->temp_feed, fbp->temp_feed,
  2969.                          fbp->krbdes_sched[1], 0);
  2970.         des_ecb_encrypt(fbp->temp_feed, fbp->temp_feed,
  2971.                          fbp->krbdes_sched[2], 1);
  2972. #endif /* LIBDES */
  2973.  
  2974.         p = fbp->fb_feed + 3;
  2975.         *p++ = ENCRYPT_IS;
  2976.         p++;
  2977.         *p++ = FB64_IV;
  2978.         for (x = 0; x < sizeof(Block); ++x) {
  2979.             if (( *p++ = fbp->temp_feed[x]) == IAC)
  2980.                 *p++ = IAC;
  2981.         }
  2982.         *p++ = IAC;
  2983.         *p++ = SE;
  2984.  
  2985.         if (deblog || tn_deb || debses) {
  2986.             int i;
  2987.             sprintf(tn_msg,
  2988.                      "TELNET SENT SB %s IS %s FB64_IV ",
  2989.                      TELOPT(fbp->fb_feed[2]),
  2990.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  2991.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  2992.         (p-fbp->fb_feed)-2-6);
  2993.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  2994.             debug(F100,tn_msg,"",0);
  2995.             if (tn_deb || debses) tn_debug(tn_msg);
  2996.         }
  2997. #ifdef OS2
  2998.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  2999. #endif
  3000.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  3001. #ifdef OS2
  3002.         ReleaseTelnetMutex();
  3003. #endif
  3004.         break;
  3005.     default:
  3006.         return(xFAILED);
  3007.     }
  3008.     return(fbp->state[dir-1] = state);
  3009. }
  3010.  
  3011. /*
  3012.  * Returns:
  3013.  *      -1: some error.  Negotiation is done, encryption not ready.
  3014.  *       0: Successful, initial negotiation all done.
  3015.  *       1: successful, negotiation not done yet.
  3016.  */
  3017. int
  3018. des3_cfb64_is(data, cnt)
  3019.     unsigned char *data;
  3020.     int cnt;
  3021. {
  3022.     return(des3_fb64_is(data, cnt, &des3_fb[CFB]));
  3023. }
  3024.  
  3025. int
  3026. des3_ofb64_is(data, cnt)
  3027.     unsigned char *data;
  3028.     int cnt;
  3029. {
  3030.     return(des3_fb64_is(data, cnt, &des3_fb[OFB]));
  3031. }
  3032.  
  3033. int
  3034. des3_fb64_is(data, cnt, fbp)
  3035.     unsigned char *data;
  3036.     int cnt;
  3037.     struct des3_fb *fbp;
  3038. {
  3039.     unsigned char *p;
  3040.     register int state = fbp->state[DIR_DECRYPT-1];
  3041.  
  3042.     if (cnt-- < 1)
  3043.         goto failure;
  3044.  
  3045. #ifdef CK_SSL
  3046.     if (!TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  3047. #endif /* CK_SSL */
  3048.     switch (*data++) {
  3049.     case FB64_IV:
  3050.         if (cnt != sizeof(Block)) {
  3051. #ifdef DEBUG
  3052.             if (encrypt_debug_mode)
  3053.                 printf("DES3_FB64: initial vector failed on size\r\n");
  3054. #endif
  3055.             state = xFAILED;
  3056.             goto failure;
  3057.         }
  3058.  
  3059. #ifdef DEBUG
  3060.         if (encrypt_debug_mode) {
  3061.             printf("DES3_FB64: initial vector received\r\n");
  3062.             printf("Initializing Decrypt stream\r\n");
  3063.         }
  3064. #endif
  3065.         des3_fb64_stream_iv((void *)data, &fbp->streams[DIR_DECRYPT-1]);
  3066.  
  3067.         p = fbp->fb_feed + 3;
  3068.         *p++ = ENCRYPT_REPLY;
  3069.         p++;
  3070.         *p++ = FB64_IV_OK;
  3071.         *p++ = IAC;
  3072.         *p++ = SE;
  3073.  
  3074.         if (deblog || tn_deb || debses) {
  3075.             int i;
  3076.             sprintf(tn_msg,
  3077.                      "TELNET SENT SB %s REPLY %s FB64_IV_OK ",
  3078.                      TELOPT(fbp->fb_feed[2]),
  3079.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  3080.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  3081.         (p-fbp->fb_feed)-2-6);
  3082.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  3083.             debug(F100,tn_msg,"",0);
  3084.             if (tn_deb || debses) tn_debug(tn_msg);
  3085.         }
  3086. #ifdef OS2
  3087.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  3088. #endif
  3089.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  3090. #ifdef OS2
  3091.         ReleaseTelnetMutex();
  3092. #endif
  3093.         state = IN_PROGRESS;
  3094.         break;
  3095.  
  3096.     default:
  3097. #if 0
  3098.         if (encrypt_debug_mode) {
  3099.             printf("Unknown option type: %d\r\n", *(data-1));
  3100.             printf("\r\n");
  3101.         }
  3102. #endif
  3103.         /* FALL THROUGH */
  3104.       failure:
  3105.         /*
  3106.         * We failed.  Send an FB64_IV_BAD option
  3107.         * to the other side so it will know that
  3108.         * things failed.
  3109.         */
  3110.         p = fbp->fb_feed + 3;
  3111.         *p++ = ENCRYPT_REPLY;
  3112.         p++;
  3113.         *p++ = FB64_IV_BAD;
  3114.         *p++ = IAC;
  3115.         *p++ = SE;
  3116.  
  3117.         if (deblog || tn_deb || debses) {
  3118.             int i;
  3119.             sprintf(tn_msg,
  3120.                      "TELNET SENT SB %s REPLY %s FB64_IV_BAD ",
  3121.                      TELOPT(fbp->fb_feed[2]),
  3122.                      enctype_names[fbp->fb_feed[4]]); /* safe */
  3123.             tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&fbp->fb_feed[6],
  3124.         (p-fbp->fb_feed)-2-6);
  3125.             ckstrncat(tn_msg,"IAC SE",TN_MSG_LEN);
  3126.             debug(F100,tn_msg,"",0);
  3127.             if (tn_deb || debses) tn_debug(tn_msg);
  3128.         }
  3129. #ifdef OS2
  3130.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  3131. #endif
  3132.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  3133. #ifdef OS2
  3134.         ReleaseTelnetMutex();
  3135. #endif
  3136.         break;
  3137.     }
  3138.     return(fbp->state[DIR_DECRYPT-1] = state);
  3139. }
  3140.  
  3141. /*
  3142.  * Returns:
  3143.  *      -1: some error.  Negotiation is done, encryption not ready.
  3144.  *       0: Successful, initial negotiation all done.
  3145.  *       1: successful, negotiation not done yet.
  3146.  */
  3147. int
  3148. des3_cfb64_reply(data, cnt)
  3149.     unsigned char *data;
  3150.     int cnt;
  3151. {
  3152.     return(des3_fb64_reply(data, cnt, &des3_fb[CFB]));
  3153. }
  3154. int
  3155. des3_ofb64_reply(data, cnt)
  3156.     unsigned char *data;
  3157.     int cnt;
  3158. {
  3159.     return(des3_fb64_reply(data, cnt, &des3_fb[OFB]));
  3160. }
  3161.  
  3162.  
  3163. int
  3164. des3_fb64_reply(data, cnt, fbp)
  3165.     unsigned char *data;
  3166.     int cnt;
  3167.     struct des3_fb *fbp;
  3168. {
  3169.     register int state = fbp->state[DIR_ENCRYPT-1];
  3170.  
  3171.     if (cnt-- < 1)
  3172.         goto failure;
  3173.  
  3174.     switch (*data++) {
  3175.     case FB64_IV_OK:
  3176.         des3_fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  3177.         if (state == xFAILED)
  3178.             state = IN_PROGRESS;
  3179.         state &= ~NO_RECV_IV;
  3180.         encrypt_send_keyid(DIR_ENCRYPT, (unsigned char *)"\0", 1, 1);
  3181.         break;
  3182.  
  3183.     case FB64_IV_BAD:
  3184.         memset(fbp->temp_feed, 0, sizeof(Block));
  3185.         des3_fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  3186.         state = xFAILED;
  3187.         break;
  3188.  
  3189.     default:
  3190. #if 0
  3191.         if (encrypt_debug_mode) {
  3192.             printf("Unknown option type: %d\r\n", data[-1]);
  3193.             printf("\r\n");
  3194.         }
  3195. #endif
  3196.         /* FALL THROUGH */
  3197.       failure:
  3198.         state = xFAILED;
  3199.         break;
  3200.     }
  3201.     return(fbp->state[DIR_ENCRYPT-1] = state);
  3202. }
  3203.  
  3204. int
  3205. des3_cfb64_session(key, server)
  3206.     Session_Key *key;
  3207.     int server;
  3208. {
  3209.     return(des3_fb64_session(key, server, &des3_fb[CFB]));
  3210. }
  3211.  
  3212. int
  3213. des3_ofb64_session(key, server)
  3214.     Session_Key *key;
  3215.     int server;
  3216. {
  3217.     return(des3_fb64_session(key, server, &des3_fb[OFB]));
  3218. }
  3219.  
  3220. static int
  3221. des3_fb64_session(key, server, fbp)
  3222.     Session_Key *key;
  3223.     int server;
  3224.     struct des3_fb *fbp;
  3225. {
  3226.     int rc=0,i=0;
  3227.     int keys2use=0;
  3228.     struct des3_stinfo * s_stream;
  3229.     struct des3_stinfo * c_stream;
  3230.  
  3231.     if(server) {
  3232.         s_stream = &fbp->streams[DIR_ENCRYPT-1];
  3233.         c_stream = &fbp->streams[DIR_DECRYPT-1];
  3234.     }
  3235.     else {
  3236.         s_stream = &fbp->streams[DIR_DECRYPT-1];
  3237.         c_stream = &fbp->streams[DIR_ENCRYPT-1];
  3238.     }
  3239.  
  3240.     keys2use = key->length / sizeof(Block);
  3241.     if (!key || (key->type == SK_DES) || (keys2use < 2)) {
  3242.         CHAR buf[80];
  3243.         sprintf((char *)buf,"Can't set 3DES session key (%d < %d)",
  3244.                 key ? key->length : 0, 2 * (int)sizeof(Block));    /* safe */
  3245. #ifdef DEBUG
  3246.         if (encrypt_debug_mode)
  3247.             printf("%s\r\n",buf);
  3248. #endif
  3249.         debug(F110,"des3_fb64_session",buf,0);
  3250.         return(-1);
  3251.     }
  3252.  
  3253.     debug(F111,"des3_fb64_session","keys2use",keys2use);
  3254.     /* Compute the first set of keys / key order */
  3255.     switch ( keys2use ) {
  3256.     case 2:
  3257.         memcpy((void *)fbp->krbdes_key[0], (void *)key->data, sizeof(Block));
  3258.         memcpy((void *) fbp->krbdes_key[1],(void *)(key->data + sizeof(Block)),
  3259.                  sizeof(Block));
  3260.         memcpy((void *)fbp->krbdes_key[2], (void *)key->data, sizeof(Block));
  3261.         break;
  3262.     case 3:
  3263.     default:
  3264.         memcpy((void *)fbp->krbdes_key[0], (void *)key->data, sizeof(Block));
  3265.         memcpy((void *) fbp->krbdes_key[1],(void *)(key->data + sizeof(Block)),
  3266.                  sizeof(Block));
  3267.         memcpy((void *) fbp->krbdes_key[2],
  3268.                  (void *) (key->data + 2*sizeof(Block)), sizeof(Block));
  3269.         break;
  3270.     }
  3271.     ckhexdump("des3_session_key key->data",key->data,sizeof(Block));
  3272.     ckhexdump("des3_session_key fbp->krbdes_key[0]",
  3273.             fbp->krbdes_key[0],
  3274.             sizeof(Block)
  3275.             );
  3276.     if (fbp->once == 0) {
  3277.         des_set_random_generator_seed(fbp->krbdes_key[0]);
  3278.         fbp->once = 1;
  3279.     }
  3280.  
  3281.     for ( i=0;i<3;i++ )
  3282.         des_fixup_key_parity(fbp->krbdes_key[i]);
  3283.     des3_fb64_stream_key(fbp->krbdes_key, s_stream);
  3284.  
  3285.  
  3286.     /* Compute the second set of keys / key order */
  3287.     switch ( keys2use ) {
  3288.     case 2:
  3289.         memcpy((void *) fbp->krbdes_key[0],(void *)(key->data + sizeof(Block)),
  3290.                  sizeof(Block));
  3291.         memcpy((void *)fbp->krbdes_key[1], (void *)key->data, sizeof(Block));
  3292.         memcpy((void *) fbp->krbdes_key[2],(void *)(key->data + sizeof(Block)),
  3293.                  sizeof(Block));
  3294.         break;
  3295.     case 3:
  3296.         memcpy((void *) fbp->krbdes_key[0],(void *)(key->data + sizeof(Block)),
  3297.                  sizeof(Block));
  3298.         memcpy((void *) fbp->krbdes_key[1],
  3299.                  (void *) (key->data + 2*sizeof(Block)), sizeof(Block));
  3300.         memcpy((void *)fbp->krbdes_key[2], (void *)key->data, sizeof(Block));
  3301.         break;
  3302.     case 4:
  3303.         memcpy((void *) fbp->krbdes_key[0],(void *)(key->data + sizeof(Block)),
  3304.                  sizeof(Block));
  3305.         memcpy((void *) fbp->krbdes_key[1],
  3306.                  (void *) (key->data + 3*sizeof(Block)), sizeof(Block));
  3307.         memcpy((void *)fbp->krbdes_key[2], (void *)key->data, sizeof(Block));
  3308.         break;
  3309.     case 5:
  3310.         memcpy((void *) fbp->krbdes_key[0],(void *)(key->data + sizeof(Block)),
  3311.                  sizeof(Block));
  3312.         memcpy((void *) fbp->krbdes_key[1],
  3313.                  (void *) (key->data + 3*sizeof(Block)), sizeof(Block));
  3314.         memcpy((void *)fbp->krbdes_key[2],
  3315.                  (void *)(key->data + 4*sizeof(Block)), sizeof(Block));
  3316.         break;
  3317.     case 6:
  3318.         memcpy((void *) fbp->krbdes_key[0],
  3319.                  (void *) (key->data + 3*sizeof(Block)), sizeof(Block));
  3320.         memcpy((void *)fbp->krbdes_key[1],
  3321.                  (void *)(key->data + 4*sizeof(Block)), sizeof(Block));
  3322.         memcpy((void *) fbp->krbdes_key[2],
  3323.                  (void *) (key->data + 5 *sizeof(Block)),  sizeof(Block));
  3324.         break;
  3325.     }
  3326.  
  3327.     for ( i=0;i<3;i++ )
  3328.         des_fixup_key_parity(fbp->krbdes_key[i]);
  3329.     des3_fb64_stream_key(fbp->krbdes_key, c_stream);
  3330.  
  3331.     /* now use the second set of keys to build the default Key Schedule */
  3332.     /* which is used for generating the IV.                             */
  3333.     for ( i=0;i<3;i++ ) {
  3334.         memset(fbp->krbdes_sched[i],0,sizeof(Schedule));
  3335.  
  3336.         rc = des_key_sched(fbp->krbdes_key[i], fbp->krbdes_sched[i]);
  3337.         if ( rc == -1 ) {
  3338.             printf("?Invalid DES key specified for encryption [DES3,%s]\r\n",
  3339.                     server?"server":"client");
  3340.             debug(F110,"des3_fb64_stream_iv",
  3341.                    "invalid DES Key specified for encryption",0);
  3342.         } else if ( rc == -2 ) {
  3343.             printf("?Weak DES key specified for encryption\r\n");
  3344.             debug(F110,"des3_fb64_stream_iv",
  3345.                    "weak DES Key specified for encryption",0);
  3346.         } else if ( rc != 0 ) {
  3347.             printf("?Key Schedule not created by encryption\r\n");
  3348.             debug(F110,"des3_fb64_stream_iv",
  3349.                    "Key Schedule not created by encryption",0);
  3350.         }
  3351.         ckhexdump("des3_fb64_session_key schedule",fbp->krbdes_sched[i],8*16);
  3352.     }
  3353.     /*
  3354.     * Now look to see if krbdes_start() was was waiting for
  3355.     * the key to show up.  If so, go ahead an call it now
  3356.     * that we have the key.
  3357.     */
  3358.     if (fbp->need_start) {
  3359.         fbp->need_start = 0;
  3360.         des3_fb64_start(fbp, DIR_ENCRYPT, server);
  3361.     }
  3362.     return(0);
  3363. }
  3364.  
  3365. /*
  3366.  * We only accept a keyid of 0.  If we get a keyid of
  3367.  * 0, then mark the state as SUCCESS.
  3368.  */
  3369. int
  3370. des3_cfb64_keyid(dir, kp, lenp)
  3371.     int dir, *lenp;
  3372.     unsigned char *kp;
  3373. {
  3374.     return(des3_fb64_keyid(dir, kp, lenp, &des3_fb[CFB]));
  3375. }
  3376.  
  3377. int
  3378. des3_ofb64_keyid(dir, kp, lenp)
  3379.     int dir, *lenp;
  3380.     unsigned char *kp;
  3381. {
  3382.     return(des3_fb64_keyid(dir, kp, lenp, &des3_fb[OFB]));
  3383. }
  3384.  
  3385. int
  3386. des3_fb64_keyid(dir, kp, lenp, fbp)
  3387.     int dir, *lenp;
  3388.     unsigned char *kp;
  3389.     struct des3_fb *fbp;
  3390. {
  3391.     register int state = fbp->state[dir-1];
  3392.  
  3393.     if (*lenp != 1 || (*kp != '\0')) {
  3394.         *lenp = 0;
  3395.         return(state);
  3396.     }
  3397.  
  3398.     if (state == xFAILED)
  3399.         state = IN_PROGRESS;
  3400.  
  3401.     state &= ~NO_KEYID;
  3402.  
  3403.     return(fbp->state[dir-1] = state);
  3404. }
  3405.  
  3406. #if 0
  3407. void
  3408. des3_fb64_printsub(data, cnt, buf, buflen, type)
  3409.     unsigned char *data, *buf, *type;
  3410.     int cnt, buflen;
  3411. {
  3412.     char lbuf[64];
  3413.     register int i;
  3414.     char *cp;
  3415.  
  3416.     buf[buflen-1] = '\0';               /* make sure it's NULL terminated */
  3417.     buflen -= 1;
  3418.  
  3419.     switch(data[2]) {
  3420.     case FB64_IV:
  3421.         sprintf(lbuf, "%s_IV", type);
  3422.         cp = lbuf;
  3423.         goto common;
  3424.  
  3425.     case FB64_IV_OK:
  3426.         sprintf(lbuf, "%s_IV_OK", type);
  3427.         cp = lbuf;
  3428.         goto common;
  3429.  
  3430.     case FB64_IV_BAD:
  3431.         sprintf(lbuf, "%s_IV_BAD", type);
  3432.         cp = lbuf;
  3433.         goto common;
  3434.  
  3435.     case FB64_CHALLENGE:
  3436.         sprintf(lbuf, "%s_CHALLENGE", type);
  3437.         cp = lbuf;
  3438.         goto common;
  3439.  
  3440.     case FB64_RESPONSE:
  3441.         sprintf(lbuf, "%s_RESPONSE", type);
  3442.         cp = lbuf;
  3443.         goto common;
  3444.  
  3445.     default:
  3446.         sprintf(lbuf, " %d (unknown)", data[2]);
  3447.         cp = lbuf;
  3448.       common:
  3449.         for (; (buflen > 0) && (*buf = *cp++); buf++)
  3450.             buflen--;
  3451.         for (i = 3; i < cnt; i++) {
  3452.             sprintf(lbuf, " %d", data[i]);
  3453.             for (cp = lbuf; (buflen > 0) && (*buf = *cp++); buf++)
  3454.                 buflen--;
  3455.         }
  3456.         break;
  3457.     }
  3458. }
  3459.  
  3460. void
  3461. des3_cfb64_printsub(data, cnt, buf, buflen)
  3462.     unsigned char *data, *buf;
  3463.     int cnt, buflen;
  3464. {
  3465.     des3_fb64_printsub(data, cnt, buf, buflen, "CFB64");
  3466. }
  3467.  
  3468. void
  3469. des3_ofb64_printsub(data, cnt, buf, buflen)
  3470.     unsigned char *data, *buf;
  3471.     int cnt, buflen;
  3472. {
  3473.     des3_fb64_printsub(data, cnt, buf, buflen, "OFB64");
  3474. }
  3475. #endif
  3476.  
  3477. void
  3478. des3_fb64_stream_iv(seed, stp)
  3479.     Block seed;
  3480.     register struct des3_stinfo *stp;
  3481. {
  3482.     int rc=0, i = 0;;
  3483.  
  3484.     memcpy(stp->str_iv,     seed, sizeof(Block));
  3485.     memcpy(stp->str_output, seed, sizeof(Block));
  3486.     for ( i=0;i<3;i++ ) {
  3487.         memset(stp->str_sched[i],0,sizeof(Schedule));
  3488.  
  3489.         ckhexdump("des3_fb64_stream_iv",stp->str_ikey[i],8);
  3490.  
  3491.         rc = des_key_sched(stp->str_ikey[i], stp->str_sched[i]);
  3492.         if ( rc == -1 ) {
  3493.             printf("?Invalid DES key specified for encryption [DES3 iv]\r\n");
  3494.             debug(F110,"des3_fb64_stream_iv",
  3495.                    "invalid DES Key specified for encryption",0);
  3496.         } else if ( rc == -2 ) {
  3497.             printf("?Weak DES key specified for encryption\r\n");
  3498.             debug(F110,"des3_fb64_stream_iv",
  3499.                    "weak DES Key specified for encryption",0);
  3500.         } else if ( rc != 0 ) {
  3501.             printf("?Key Schedule not created by encryption\r\n");
  3502.             debug(F110,"des3_fb64_stream_iv",
  3503.                    "Key Schedule not created by encryption",0);
  3504.         }
  3505.         ckhexdump("des3_fb64_stream_iv schedule",stp->str_sched[i],8*16);
  3506.     }
  3507.     stp->str_index = sizeof(Block);
  3508. }
  3509.  
  3510. void
  3511. des3_fb64_stream_key(key, stp)
  3512.     Block * key;
  3513.     register struct des3_stinfo *stp;
  3514. {
  3515.     int rc = 0, i = 0;
  3516.  
  3517.     for ( i=0;i<3;i++ ) {
  3518.         memcpy(stp->str_ikey[i], key[i], sizeof(Block));
  3519.  
  3520.         memset(stp->str_sched[i],0,sizeof(Schedule));
  3521.  
  3522.         ckhexdump("des3_fb64_stream_key",key[i],8);
  3523.  
  3524.         rc = des_key_sched(key[i], stp->str_sched[i]);
  3525.         if ( rc == -1 ) {
  3526.             printf("?Invalid DES key specified for encryption [DES3 key]\r\n");
  3527.             debug(F110,"des3_fb64_stream_key",
  3528.                    "invalid DES Key specified for encryption",0);
  3529.         } else if ( rc == -2 ) {
  3530.             printf("?Weak DES key specified for encryption\r\n");
  3531.             debug(F110,"des3_fb64_stream_key",
  3532.                    "weak DES Key specified for encryption",0);
  3533.         } else if ( rc != 0 ) {
  3534.             printf("?Key Schedule not created by encryption\r\n");
  3535.             debug(F110,"des3_fb64_stream_key",
  3536.                    "Key Schedule not created by encryption",0);
  3537.         }
  3538.         ckhexdump("des3_fb64_stream_key schedule",stp->str_sched[i],8*16);
  3539.     }
  3540.  
  3541.     memcpy(stp->str_output, stp->str_iv, sizeof(Block));
  3542.     stp->str_index = sizeof(Block);
  3543. }
  3544.  
  3545. /*
  3546.  * DES3 64 bit Cipher Feedback
  3547.  *
  3548.  *                key1       key2       key3
  3549.  *                 |          |          |
  3550.  *                 v          v          v
  3551.  *             +-------+  +-------+  +-------+
  3552.  *          +->| DES-e |->| DES-d |->| DES-e |-- +
  3553.  *          |  +-------+  +-------+  +-------+   |
  3554.  *          |                                    v
  3555.  *  INPUT --(-------------------------------->(+)+---> DATA
  3556.  *          |                                    |
  3557.  *          +------------------------------------+
  3558.  *
  3559.  *
  3560.  * Given:
  3561.  *      iV: Initial vector, 64 bits (8 bytes) long.
  3562.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  3563.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  3564.  *
  3565.  *      V0 = DES-e(DES-d(DES-e(iV, key1),key2),key3)
  3566.  *      On = Dn ^ Vn
  3567.  *      V(n+1) = DES-e(DES-d(DES-e(On, key1),key2),key3)
  3568.  */
  3569.  
  3570. void
  3571. des3_cfb64_encrypt(s, c)
  3572.     register unsigned char *s;
  3573.     int c;
  3574. {
  3575.     register struct des3_stinfo *stp = &des3_fb[CFB].streams[DIR_ENCRYPT-1];
  3576.     register int index;
  3577.  
  3578.     index = stp->str_index;
  3579.     while (c-- > 0) {
  3580.         if (index == sizeof(Block)) {
  3581.             Block b;
  3582. #ifdef LIBDES
  3583.             des_ecb3_encrypt(stp->str_output, b, stp->str_sched[0],
  3584.                               stp->str_sched[1], stp->str_sched[2], 1);
  3585. #else /* LIBDES */
  3586.             des_ecb_encrypt(stp->str_output, b,
  3587.                              stp->str_sched[0], 1);
  3588.             des_ecb_encrypt(stp->str_output, b,
  3589.                              stp->str_sched[1], 0);
  3590.             des_ecb_encrypt(stp->str_output, b,
  3591.                              stp->str_sched[2], 1);
  3592. #endif /* LIBDES */
  3593.             memcpy(stp->str_feed,b,sizeof(Block));
  3594.             index = 0;
  3595.         }
  3596.  
  3597.         /* On encryption, we store (feed ^ data) which is cypher */
  3598.         *s = stp->str_output[index] = (stp->str_feed[index] ^ *s);
  3599.         s++;
  3600.         index++;
  3601.     }
  3602.     stp->str_index = index;
  3603. }
  3604.  
  3605. int
  3606. des3_cfb64_decrypt(data)
  3607.     int data;
  3608. {
  3609.     register struct des3_stinfo *stp = &des3_fb[CFB].streams[DIR_DECRYPT-1];
  3610.     int index;
  3611.  
  3612.     if (data == -1) {
  3613.         /*
  3614.         * Back up one byte.  It is assumed that we will
  3615.         * never back up more than one byte.  If we do, this
  3616.         * may or may not work.
  3617.         */
  3618.         if (stp->str_index)
  3619.             --stp->str_index;
  3620.         return(0);
  3621.     }
  3622.  
  3623.     index = stp->str_index++;
  3624.     if (index == sizeof(Block)) {
  3625.         Block b;
  3626. #ifdef LIBDES
  3627.         des_ecb3_encrypt(stp->str_output, b, stp->str_sched[0],
  3628.                           stp->str_sched[1], stp->str_sched[2], 1);
  3629. #else /* LIBDES */
  3630.             des_ecb_encrypt(stp->str_output, b,
  3631.                              stp->str_sched[0], 1);
  3632.             des_ecb_encrypt(stp->str_output, b,
  3633.                              stp->str_sched[1], 0);
  3634.             des_ecb_encrypt(stp->str_output, b,
  3635.                              stp->str_sched[2], 1);
  3636. #endif /* LIBDES */
  3637.         memcpy(stp->str_feed, b, sizeof(Block));
  3638.         stp->str_index = 1;     /* Next time will be 1 */
  3639.         index = 0;              /* But now use 0 */
  3640.     }
  3641.  
  3642.     /* On decryption we store (data) which is cypher. */
  3643.     stp->str_output[index] = data;
  3644.     return(data ^ stp->str_feed[index]);
  3645. }
  3646.  
  3647. /*
  3648.  * DES3 64 bit Output Feedback
  3649.  *
  3650.  *
  3651.  *                key1       key2       key3
  3652.  *                 |          |          |
  3653.  *                 v          v          v
  3654.  *             +-------+  +-------+  +-------+
  3655.  *          +->| DES-e |->| DES-d |->| DES-e |-- +
  3656.  *          |  +-------+  +-------+  +-------+   |
  3657.  *          +------------------------------------+
  3658.  *                                               v
  3659.  *  INPUT ------------------------------------->(+) ----> DATA
  3660.  *
  3661.  * Given:
  3662.  *      iV: Initial vector, 64 bits (8 bytes) long.
  3663.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  3664.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  3665.  *
  3666.  *      V0 = DES-e(DES-d(DES-e(iV, key1),key2),key3)
  3667.  *      V(n+1) = DES-e(DES-d(DES-e(Vn, key1),key2),key3)
  3668.  *      On = Dn ^ Vn
  3669.  */
  3670. void
  3671. des3_ofb64_encrypt(s, c)
  3672.     register unsigned char *s;
  3673.     int c;
  3674. {
  3675.     register struct des3_stinfo *stp = &des3_fb[OFB].streams[DIR_ENCRYPT-1];
  3676.     register int index;
  3677.  
  3678.     index = stp->str_index;
  3679.     while (c-- > 0) {
  3680.         if (index == sizeof(Block)) {
  3681.             Block b;
  3682. #ifdef LIBDES
  3683.             des_ecb3_encrypt(stp->str_feed, b, stp->str_sched[0],
  3684.                              stp->str_sched[1], stp->str_sched[2], 1);
  3685. #else /* LIBDES */
  3686.             des_ecb_encrypt(stp->str_output, b,
  3687.                              stp->str_sched[0], 1);
  3688.             des_ecb_encrypt(stp->str_output, b,
  3689.                              stp->str_sched[1], 0);
  3690.             des_ecb_encrypt(stp->str_output, b,
  3691.                              stp->str_sched[2], 1);
  3692. #endif /* LIBDES */
  3693.             memcpy(stp->str_feed,b,sizeof(Block));
  3694.             index = 0;
  3695.         }
  3696.         *s++ ^= stp->str_feed[index];
  3697.         index++;
  3698.     }
  3699.     stp->str_index = index;
  3700. }
  3701.  
  3702. int
  3703. des3_ofb64_decrypt(data)
  3704.     int data;
  3705. {
  3706.     register struct des3_stinfo *stp = &des3_fb[OFB].streams[DIR_DECRYPT-1];
  3707.     int index;
  3708.  
  3709.     if (data == -1) {
  3710.         /*
  3711.         * Back up one byte.  It is assumed that we will
  3712.         * never back up more than one byte.  If we do, this
  3713.         * may or may not work.
  3714.         */
  3715.         if (stp->str_index)
  3716.             --stp->str_index;
  3717.         return(0);
  3718.     }
  3719.  
  3720.     index = stp->str_index++;
  3721.     if (index == sizeof(Block)) {
  3722.         Block b;
  3723. #ifdef LIBDES
  3724.         des_ecb3_encrypt(stp->str_feed, b, stp->str_sched[0],
  3725.                           stp->str_sched[1], stp->str_sched[2], 1);
  3726. #else /* LIBDES */
  3727.             des_ecb_encrypt(stp->str_output, b,
  3728.                              stp->str_sched[0], 1);
  3729.             des_ecb_encrypt(stp->str_output, b,
  3730.                              stp->str_sched[1], 0);
  3731.             des_ecb_encrypt(stp->str_output, b,
  3732.                              stp->str_sched[2], 1);
  3733. #endif /* LIBDES */
  3734.         memcpy(stp->str_feed, b, sizeof(Block));
  3735.         stp->str_index = 1;     /* Next time will be 1 */
  3736.         index = 0;              /* But now use 0 */
  3737.     }
  3738.  
  3739.     return(data ^ stp->str_feed[index]);
  3740. }
  3741. #endif /* CK_DES */
  3742.  
  3743. #ifdef CK_CAST
  3744. /*-
  3745.  * Copyright (c) 1991, 1993
  3746.  *      The Regents of the University of California.  All rights reserved.
  3747.  *
  3748.  * Redistribution and use in source and binary forms, with or without
  3749.  * modification, are permitted provided that the following conditions
  3750.  * are met:
  3751.  * 1. Redistributions of source code must retain the above copyright
  3752.  *    notice, this list of conditions and the following disclaimer.
  3753.  * 2. Redistributions in binary form must reproduce the above copyright
  3754.  *    notice, this list of conditions and the following disclaimer in the
  3755.  *    documentation and/or other materials provided with the distribution.
  3756.  * 3. All advertising materials mentioning features or use of this software
  3757.  *    must display the following acknowledgement:
  3758.  *      This product includes software developed by the University of
  3759.  *      California, Berkeley and its contributors.
  3760.  * 4. Neither the name of the University nor the names of its contributors
  3761.  *    may be used to endorse or promote products derived from this software
  3762.  *    without specific prior written permission.
  3763.  *
  3764.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  3765.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  3766.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  3767.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  3768.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  3769.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  3770.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  3771.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  3772.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  3773.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  3774.  * SUCH DAMAGE.
  3775.  */
  3776.  
  3777. /*
  3778.  * Copyright (c) 1997 Stanford University
  3779.  *
  3780.  * Permission to use, copy, modify, distribute, and sell this software and
  3781.  * its documentation for any purpose is hereby granted without fee, provided
  3782.  * that the above copyright notices and this permission notice appear in
  3783.  * all copies of the software and related documentation.
  3784.  *
  3785.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  3786.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  3787.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  3788.  *
  3789.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  3790.  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
  3791.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
  3792.  * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
  3793.  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  3794.  */
  3795.  
  3796. #include <stdio.h>
  3797. #ifdef  __STDC__
  3798. #include <stdlib.h>
  3799. #endif
  3800.  
  3801. /*
  3802.  * cast.h
  3803.  * Author: Tom Wu
  3804.  *
  3805.  * Type and function declarations for CAST.
  3806.  */
  3807.  
  3808. #ifndef _CAST_H_
  3809. #define _CAST_H_
  3810.  
  3811. #ifndef P
  3812. #ifdef __STDC__
  3813. #define P(x) x
  3814. #else
  3815. #define P(x) ()
  3816. #endif /* __STDC__ */
  3817. #endif /* P */
  3818.  
  3819. #ifndef LITTLE_ENDIAN
  3820. #ifndef BIG_ENDIAN
  3821. #ifndef WORDS_BIGENDIAN
  3822. #define LITTLE_ENDIAN 1
  3823. #endif /* WORDS_BIGENDIAN */
  3824. #endif /* BIG_ENDIAN */
  3825. #endif /* LITTLE_ENDIAN */
  3826.  
  3827. typedef unsigned int uint32;    /* Must be 32 bits */
  3828. typedef uint32 * uint32p;
  3829. typedef unsigned char uint8;
  3830. typedef uint8 * uint8p;
  3831.  
  3832. typedef struct {
  3833.   struct CastSubkeyPair {
  3834.     uint32 Km;
  3835.     uint32 Kr;
  3836.   } K[16];
  3837.   int ksize;
  3838. } CastKeySched;
  3839.  
  3840. /*
  3841.  * cast*_key_sched(schedule, key)
  3842.  *
  3843.  * Initializes the CAST key schedule "schedule" according to the given key.
  3844.  * The different setup routines accept different length keys:
  3845.  *
  3846.  *   ck_cast5_40_key_sched: 40-bit/5-byte (12 round) keys
  3847.  *   ck_cast5_64_key_sched: 64-bit/8-byte (12 round) keys
  3848.  *   ck_cast5_80_key_sched: 80-bit/10-byte (12 round) keys
  3849.  *   ck_cast128_key_sched: 128-bit/16-byte (16 round) keys
  3850.  */
  3851.  
  3852. extern void ck_cast5_40_key_sched P((CastKeySched *, uint8 *));
  3853. extern void ck_cast5_64_key_sched P((CastKeySched *, uint8 *));
  3854. extern void ck_cast5_80_key_sched P((CastKeySched *, uint8 *));
  3855. extern void  ck_cast128_key_sched P((CastKeySched *, uint8 *));
  3856.  
  3857. /*
  3858.  * ck_cast_ecb_encrypt(output, input, schedule, mode)
  3859.  * ck_cast_ecb_crypt(data, schedule, mode)
  3860.  *
  3861.  * Encrypts the 64-bit "input" according to the CAST key schedule
  3862.  * "schedule" and places the result in "output".  If "mode" is 0,
  3863.  * ck_cast_ecb_encrypt will encrypt, otherwise it will decrypt.
  3864.  * "Output" and "input" can point to the same memory, in which case
  3865.  * en/decryption will be performed in place.
  3866.  *
  3867.  * ck_cast_ecb_crypt accepts input in the form of an array of two
  3868.  * 32-bit words and performs encryption/decryption in place.
  3869.  */
  3870.  
  3871. extern void ck_cast_ecb_encrypt P((uint8 *, uint8 *, CastKeySched *, int));
  3872. extern void ck_cast_ecb_crypt P((uint32 *, CastKeySched *, int));
  3873.  
  3874. #endif /* CAST_H */
  3875.  
  3876. extern encrypt_debug_mode;
  3877.  
  3878. #define CFB_40  0
  3879. #define OFB_40  1
  3880. #ifdef CAST_EXPORT_ENCRYPTION
  3881. #define FB_CNT  2
  3882. #else
  3883. #define CFB_128 2
  3884. #define OFB_128 3
  3885. #define FB_CNT  4
  3886. #endif
  3887.  
  3888. #define NO_SEND_IV      1
  3889. #define NO_RECV_IV      2
  3890. #define NO_KEYID        4
  3891. #define IN_PROGRESS     (NO_SEND_IV|NO_RECV_IV|NO_KEYID)
  3892. #define SUCCESS         0
  3893. #define cFAILED         -1
  3894.  
  3895.  
  3896. struct cast_fb {
  3897.         Block temp_feed;
  3898.         unsigned char fb_feed[64];
  3899.         int key_isset;
  3900.         int need_start;
  3901.         int state[2];
  3902.         struct cast_stinfo {
  3903.                 Block           str_output;
  3904.                 Block           str_feed;
  3905.                 Block           str_iv;
  3906.                 CastKeySched    str_sched;
  3907.                 int             str_index;
  3908.         } streams[2];
  3909. };
  3910.  
  3911. static struct cast_fb cast_fb[FB_CNT];
  3912.  
  3913. #define FB64_IV         1
  3914. #define FB64_IV_OK      2
  3915. #define FB64_IV_BAD     3
  3916.  
  3917.  
  3918. static void cast_fb64_stream_iv P((Block, struct cast_stinfo *));
  3919. static void cast_fb64_init P((struct cast_fb *));
  3920. static int cast_fb64_start P((struct cast_fb *, int, int));
  3921. static int cast_fb64_is P((unsigned char *, int, struct cast_fb *));
  3922. static int cast_fb64_reply P((unsigned char *, int, struct cast_fb *));
  3923. static int cast_fb64_session P((Session_Key *, int, struct cast_fb *, int));
  3924. static void cast_fb64_stream_key P((Block, struct cast_stinfo *, int));
  3925. static int cast_fb64_keyid P((int, unsigned char *, int *, struct cast_fb *));
  3926. static void _cast_cfb64_encrypt P((unsigned char *,int, struct cast_stinfo *));
  3927. static int _cast_cfb64_decrypt P((int, struct cast_stinfo *));
  3928. static void _cast_ofb64_encrypt P((unsigned char *,int, struct cast_stinfo *));
  3929. static int _cast_ofb64_decrypt P((int, struct cast_stinfo *));
  3930.  
  3931. #ifndef CAST_EXPORT_ENCRYPTION
  3932. void
  3933. cast_cfb64_init(server)
  3934.         int server;
  3935. {
  3936.         cast_fb64_init(&cast_fb[CFB_128]);
  3937.         cast_fb[CFB_128].fb_feed[4] = ENCTYPE_CAST128_CFB64;
  3938. }
  3939.  
  3940. void
  3941. cast_ofb64_init(server)
  3942.         int server;
  3943. {
  3944.         cast_fb64_init(&cast_fb[OFB_128]);
  3945.         cast_fb[OFB_128].fb_feed[4] = ENCTYPE_CAST128_OFB64;
  3946. }
  3947. #endif
  3948.  
  3949. void
  3950. castexp_cfb64_init(server)
  3951.         int server;
  3952. {
  3953.         cast_fb64_init(&cast_fb[CFB_40]);
  3954.         cast_fb[CFB_40].fb_feed[4] = ENCTYPE_CAST5_40_CFB64;
  3955. }
  3956.  
  3957. void
  3958. castexp_ofb64_init(server)
  3959.         int server;
  3960. {
  3961.         cast_fb64_init(&cast_fb[OFB_40]);
  3962.         cast_fb[OFB_40].fb_feed[4] = ENCTYPE_CAST5_40_OFB64;
  3963. }
  3964.  
  3965. static void
  3966. cast_fb64_init(fbp)
  3967.     register struct cast_fb *fbp;
  3968. {
  3969.     memset((void *)fbp, 0, sizeof(*fbp));
  3970.     fbp->key_isset = 0;
  3971.     fbp->state[0] = fbp->state[1] = cFAILED;
  3972.     fbp->fb_feed[0] = IAC;
  3973.     fbp->fb_feed[1] = SB;
  3974.     fbp->fb_feed[2] = TELOPT_ENCRYPTION;
  3975.     fbp->fb_feed[3] = ENCRYPT_IS;
  3976. }
  3977.  
  3978. /*
  3979.  * Returns:
  3980.  *      -1: some error.  Negotiation is done, encryption not ready.
  3981.  *       0: Successful, initial negotiation all done.
  3982.  *       1: successful, negotiation not done yet.
  3983.  *       2: Not yet.  Other things (like getting the key from
  3984.  *          Kerberos) have to happen before we can continue.
  3985.  */
  3986. #ifndef CAST_EXPORT_ENCRYPTION
  3987. int
  3988. cast_cfb64_start(dir, server)
  3989.     int dir;
  3990.     int server;
  3991. {
  3992.     return(cast_fb64_start(&cast_fb[CFB_128], dir, server));
  3993. }
  3994.  
  3995. int
  3996. cast_ofb64_start(dir, server)
  3997.     int dir;
  3998.     int server;
  3999. {
  4000.     return(cast_fb64_start(&cast_fb[OFB_128], dir, server));
  4001. }
  4002. #endif
  4003.  
  4004. int
  4005. castexp_cfb64_start(dir, server)
  4006.     int dir;
  4007.     int server;
  4008. {
  4009.     return(cast_fb64_start(&cast_fb[CFB_40], dir, server));
  4010. }
  4011.  
  4012. int
  4013. castexp_ofb64_start(dir, server)
  4014.     int dir;
  4015.     int server;
  4016. {
  4017.     return(cast_fb64_start(&cast_fb[OFB_40], dir, server));
  4018. }
  4019.  
  4020. static int
  4021. cast_fb64_start(fbp, dir, server)
  4022.     struct cast_fb *fbp;
  4023.     int dir;
  4024.     int server;
  4025. {
  4026.     Block b;
  4027.     int x;
  4028.     unsigned char *p;
  4029.     register int state;
  4030.  
  4031.     switch (dir) {
  4032.     case DIR_DECRYPT:
  4033.         /*
  4034.          * This is simply a request to have the other side
  4035.          * start output (our input).  He will negotiate an
  4036.          * IV so we need not look for it.
  4037.          */
  4038.         state = fbp->state[dir-1];
  4039.         if (state == cFAILED)
  4040.             state = IN_PROGRESS;
  4041.         break;
  4042.  
  4043.     case DIR_ENCRYPT:
  4044.         state = fbp->state[dir-1];
  4045.         if (state == cFAILED)
  4046.             state = IN_PROGRESS;
  4047.         else if ((state & NO_SEND_IV) == 0)
  4048.             break;
  4049.  
  4050.         if (!fbp->key_isset) {
  4051.             fbp->need_start = 1;
  4052.             break;
  4053.         }
  4054.         state &= ~NO_SEND_IV;
  4055.         state |= NO_RECV_IV;
  4056. #ifdef DEBUG
  4057.         if (encrypt_debug_mode)
  4058.             printf("Creating new feed\r\n");
  4059. #endif
  4060.         /*
  4061.          * Create a random feed and send it over.
  4062.          */
  4063.         ck_cast_ecb_encrypt(fbp->temp_feed, fbp->temp_feed,
  4064.                           &fbp->streams[dir-1].str_sched, 0);
  4065.  
  4066.         p = fbp->fb_feed + 3;
  4067.         *p++ = ENCRYPT_IS;
  4068.         p++;
  4069.         *p++ = FB64_IV;
  4070.         for (x = 0; x < sizeof(Block); ++x) {
  4071.             if ((*p++ = fbp->temp_feed[x]) == IAC)
  4072.                 *p++ = IAC;
  4073.         }
  4074.         *p++ = IAC;
  4075.         *p++ = SE;
  4076.  
  4077.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  4078.         break;
  4079.     default:
  4080.         return(cFAILED);
  4081.     }
  4082.     return(fbp->state[dir-1] = state);
  4083. }
  4084.  
  4085. /*
  4086.  * Returns:
  4087.  *      -1: some error.  Negotiation is done, encryption not ready.
  4088.  *       0: Successful, initial negotiation all done.
  4089.  *       1: successful, negotiation not done yet.
  4090.  */
  4091. #ifndef CAST_EXPORT_ENCRYPTION
  4092. int
  4093. cast_cfb64_is(data, cnt)
  4094.     unsigned char *data;
  4095.     int cnt;
  4096. {
  4097.     return(cast_fb64_is(data, cnt, &cast_fb[CFB_128]));
  4098. }
  4099.  
  4100. int
  4101. cast_ofb64_is(data, cnt)
  4102.     unsigned char *data;
  4103.     int cnt;
  4104. {
  4105.     return(cast_fb64_is(data, cnt, &cast_fb[OFB_128]));
  4106. }
  4107. #endif
  4108.  
  4109. int
  4110. castexp_cfb64_is(data, cnt)
  4111.     unsigned char *data;
  4112.     int cnt;
  4113. {
  4114.     return(cast_fb64_is(data, cnt, &cast_fb[CFB_40]));
  4115. }
  4116.  
  4117. int
  4118. castexp_ofb64_is(data, cnt)
  4119.     unsigned char *data;
  4120.     int cnt;
  4121. {
  4122.     return(cast_fb64_is(data, cnt, &cast_fb[OFB_40]));
  4123. }
  4124.  
  4125. static int
  4126. cast_fb64_is(data, cnt, fbp)
  4127.     unsigned char *data;
  4128.     int cnt;
  4129.     struct cast_fb *fbp;
  4130. {
  4131.     int x;
  4132.     unsigned char *p;
  4133.     Block b;
  4134.     register int state = fbp->state[DIR_DECRYPT-1];
  4135.  
  4136.     if (cnt-- < 1)
  4137.         goto failure;
  4138.  
  4139. #ifdef CK_SSL
  4140.     if (!TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  4141. #endif /* CK_SSL */
  4142.     switch (*data++) {
  4143.     case FB64_IV:
  4144.         if (cnt != sizeof(Block)) {
  4145. #ifdef DEBUG
  4146.             if (encrypt_debug_mode)
  4147.                 printf("FB64: initial vector failed on size\r\n");
  4148. #endif
  4149.             state = cFAILED;
  4150.             goto failure;
  4151.         }
  4152. #ifdef DEBUG
  4153.         if (encrypt_debug_mode)
  4154.             printf("FB64: initial vector received\r\n");
  4155.  
  4156.         if (encrypt_debug_mode)
  4157.             printf("Initializing Decrypt stream\r\n");
  4158. #endif
  4159.         cast_fb64_stream_iv((void *)data, &fbp->streams[DIR_DECRYPT-1]);
  4160.  
  4161.         p = fbp->fb_feed + 3;
  4162.         *p++ = ENCRYPT_REPLY;
  4163.         p++;
  4164.         *p++ = FB64_IV_OK;
  4165.         *p++ = IAC;
  4166.         *p++ = SE;
  4167.  
  4168.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  4169.         state = IN_PROGRESS;
  4170.         break;
  4171.  
  4172.     default:
  4173.         /* unknown option type */
  4174.         /* FALL THROUGH */
  4175.       failure:
  4176.         /*
  4177.         * We failed.  Send an FB64_IV_BAD option
  4178.         * to the other side so it will know that
  4179.         * things failed.
  4180.         */
  4181.         p = fbp->fb_feed + 3;
  4182.         *p++ = ENCRYPT_REPLY;
  4183.         p++;
  4184.         *p++ = FB64_IV_BAD;
  4185.         *p++ = IAC;
  4186.         *p++ = SE;
  4187.  
  4188.         ttol(fbp->fb_feed, p - fbp->fb_feed);
  4189.         break;
  4190.     }
  4191.     return(fbp->state[DIR_DECRYPT-1] = state);
  4192. }
  4193.  
  4194. /*
  4195.  * Returns:
  4196.  *      -1: some error.  Negotiation is done, encryption not ready.
  4197.  *       0: Successful, initial negotiation all done.
  4198.  *       1: successful, negotiation not done yet.
  4199.  */
  4200. #ifndef CAST_EXPORT_ENCRYPTION
  4201. int
  4202. cast_cfb64_reply(data, cnt)
  4203.     unsigned char *data;
  4204.     int cnt;
  4205. {
  4206.     return(cast_fb64_reply(data, cnt, &cast_fb[CFB_128]));
  4207. }
  4208.  
  4209. int
  4210. cast_ofb64_reply(data, cnt)
  4211.     unsigned char *data;
  4212.     int cnt;
  4213. {
  4214.     return(cast_fb64_reply(data, cnt, &cast_fb[OFB_128]));
  4215. }
  4216. #endif
  4217.  
  4218. int
  4219. castexp_cfb64_reply(data, cnt)
  4220.     unsigned char *data;
  4221.     int cnt;
  4222. {
  4223.     return(cast_fb64_reply(data, cnt, &cast_fb[CFB_40]));
  4224. }
  4225.  
  4226. int
  4227. castexp_ofb64_reply(data, cnt)
  4228.     unsigned char *data;
  4229.     int cnt;
  4230. {
  4231.     return(cast_fb64_reply(data, cnt, &cast_fb[OFB_40]));
  4232. }
  4233.  
  4234. static int
  4235. cast_fb64_reply(data, cnt, fbp)
  4236.     unsigned char *data;
  4237.     int cnt;
  4238.     struct cast_fb *fbp;
  4239. {
  4240.     int x;
  4241.     unsigned char *p;
  4242.     Block b;
  4243.     register int state = fbp->state[DIR_ENCRYPT-1];
  4244.  
  4245.     if (cnt-- < 1)
  4246.         goto failure;
  4247.  
  4248.     switch (*data++) {
  4249.     case FB64_IV_OK:
  4250.         cast_fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  4251.         if (state == cFAILED)
  4252.             state = IN_PROGRESS;
  4253.         state &= ~NO_RECV_IV;
  4254.         encrypt_send_keyid(DIR_ENCRYPT, (unsigned char *)"\0", 1, 1);
  4255.         break;
  4256.  
  4257.     case FB64_IV_BAD:
  4258.         memset(fbp->temp_feed, 0, sizeof(Block));
  4259.         cast_fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
  4260.         state = cFAILED;
  4261.         break;
  4262.  
  4263.     default:
  4264. #if 0
  4265.         if (encrypt_debug_mode) {
  4266.             printf("Unknown option type: %d\r\n", data[-1]);
  4267.             printd(data, cnt);
  4268.             printf("\r\n");
  4269.         }
  4270. #endif
  4271.         /* FALL THROUGH */
  4272.       failure:
  4273.         state = cFAILED;
  4274.         break;
  4275.     }
  4276.     return(fbp->state[DIR_ENCRYPT-1] = state);
  4277. }
  4278.  
  4279. #ifndef CAST_EXPORT_ENCRYPTION
  4280. int
  4281. cast_cfb64_session(key, server)
  4282.     Session_Key *key;
  4283.     int server;
  4284. {
  4285.     return(cast_fb64_session(key, server, &cast_fb[CFB_128], 1));
  4286. }
  4287.  
  4288. int
  4289. cast_ofb64_session(key, server)
  4290.     Session_Key *key;
  4291.     int server;
  4292. {
  4293.     return(cast_fb64_session(key, server, &cast_fb[OFB_128], 1));
  4294. }
  4295. #endif
  4296.  
  4297. int
  4298. castexp_cfb64_session(key, server)
  4299.     Session_Key *key;
  4300.     int server;
  4301. {
  4302.     return(cast_fb64_session(key, server, &cast_fb[CFB_40], 0));
  4303. }
  4304.  
  4305. int
  4306. castexp_ofb64_session(key, server)
  4307.     Session_Key *key;
  4308.     int server;
  4309. {
  4310.     return(cast_fb64_session(key, server, &cast_fb[OFB_40], 0));
  4311. }
  4312.  
  4313. #define CAST128_KEYLEN  16      /* 128 bits */
  4314. #define CAST5_40_KEYLEN  5      /*  40 bits */
  4315.  
  4316. static int
  4317. cast_fb64_session(key, server, fbp, fs)
  4318.     Session_Key *key;
  4319.     int server;
  4320.     struct cast_fb *fbp;
  4321.     int fs;
  4322. {
  4323.     int klen;
  4324.     unsigned char * kptr;
  4325.  
  4326.     if(fs)
  4327.         klen = CAST128_KEYLEN;
  4328.     else
  4329.         klen = CAST5_40_KEYLEN;
  4330.  
  4331.     if (!key || key->length < klen) {
  4332.         CHAR buf[80];
  4333.         sprintf((char *)buf,"Can't set CAST session key (%d < %d)",
  4334.                 key ? key->length : 0, klen);                   /* safe */
  4335. #ifdef DEBUG
  4336.         if (encrypt_debug_mode)
  4337.             printf("%s\r\n",buf);
  4338. #endif
  4339.         debug(F110,"cast_fb64_session",buf,0);
  4340.         return(cFAILED);
  4341.     }
  4342.     if(key->length < 2 * klen)
  4343.         kptr = key->data;
  4344.     else
  4345.         kptr = key->data + klen;
  4346.  
  4347.     if(server) {
  4348.         cast_fb64_stream_key(kptr, &fbp->streams[DIR_ENCRYPT-1], fs);
  4349.         cast_fb64_stream_key(key->data, &fbp->streams[DIR_DECRYPT-1], fs);
  4350.     }
  4351.     else {
  4352.         cast_fb64_stream_key(kptr, &fbp->streams[DIR_DECRYPT-1], fs);
  4353.         cast_fb64_stream_key(key->data, &fbp->streams[DIR_ENCRYPT-1], fs);
  4354.     }
  4355.  
  4356.     /* Stuff leftovers into the feed */
  4357.     if(key->length >= 2 * klen + sizeof(Block))
  4358.         memcpy(fbp->temp_feed, key->data + 2 * klen, sizeof(Block));
  4359.     else {
  4360. #ifdef COMMENT
  4361.         /* This is a better way of erasing the password */
  4362.         /* but we do not want to link in libsrp         */
  4363.         t_random(fbp->temp_feed, sizeof(Block));
  4364. #else
  4365.         memset(fbp->temp_feed, 0, sizeof(Block));
  4366. #endif
  4367.     }
  4368.  
  4369.     fbp->key_isset = 1;
  4370.     /*
  4371.     * Now look to see if cast_fb64_start() was was waiting for
  4372.     * the key to show up.  If so, go ahead an call it now
  4373.     * that we have the key.
  4374.     */
  4375.     if (fbp->need_start) {
  4376.         fbp->need_start = 0;
  4377.         cast_fb64_start(fbp, DIR_ENCRYPT, server);
  4378.     }
  4379.     return(0);
  4380. }
  4381.  
  4382. /*
  4383.  * We only accept a keyid of 0.  If we get a keyid of
  4384.  * 0, then mark the state as SUCCESS.
  4385.  */
  4386. #ifndef CAST_EXPORT_ENCRYPTION
  4387. int
  4388. cast_cfb64_keyid(dir, kp, lenp)
  4389.     int dir, *lenp;
  4390.     unsigned char *kp;
  4391. {
  4392.     return(cast_fb64_keyid(dir, kp, lenp, &cast_fb[CFB_128]));
  4393. }
  4394.  
  4395. int
  4396. cast_ofb64_keyid(dir, kp, lenp)
  4397.     int dir, *lenp;
  4398.     unsigned char *kp;
  4399. {
  4400.     return(cast_fb64_keyid(dir, kp, lenp, &cast_fb[OFB_128]));
  4401. }
  4402. #endif
  4403.  
  4404. int
  4405. castexp_cfb64_keyid(dir, kp, lenp)
  4406.     int dir, *lenp;
  4407.     unsigned char *kp;
  4408. {
  4409.     return(cast_fb64_keyid(dir, kp, lenp, &cast_fb[CFB_40]));
  4410. }
  4411.  
  4412. int
  4413. castexp_ofb64_keyid(dir, kp, lenp)
  4414.     int dir, *lenp;
  4415.     unsigned char *kp;
  4416. {
  4417.     return(cast_fb64_keyid(dir, kp, lenp, &cast_fb[OFB_40]));
  4418. }
  4419.  
  4420. static int
  4421. cast_fb64_keyid(dir, kp, lenp, fbp)
  4422.     int dir, *lenp;
  4423.     unsigned char *kp;
  4424.     struct cast_fb *fbp;
  4425. {
  4426.     register int state = fbp->state[dir-1];
  4427.  
  4428.     if (*lenp != 1 || (*kp != '\0')) {
  4429.         *lenp = 0;
  4430.         return(state);
  4431.     }
  4432.  
  4433.     if (state == cFAILED)
  4434.         state = IN_PROGRESS;
  4435.  
  4436.     state &= ~NO_KEYID;
  4437.  
  4438.     return(fbp->state[dir-1] = state);
  4439. }
  4440.  
  4441. static void
  4442. cast_fb64_printsub(data, cnt, buf, buflen, type)
  4443.     unsigned char *data, *buf, *type;
  4444.     int cnt, buflen;
  4445. {
  4446.     char lbuf[64];
  4447.     register int i;
  4448.     char *cp;
  4449.  
  4450.     buf[buflen-1] = '\0';               /* make sure it's NULL terminated */
  4451.     buflen -= 1;
  4452.  
  4453.     switch(data[2]) {
  4454.     case FB64_IV:
  4455.         sprintf(lbuf, "%s_IV", type);
  4456.         cp = lbuf;
  4457.         goto common;
  4458.  
  4459.     case FB64_IV_OK:
  4460.         sprintf(lbuf, "%s_IV_OK", type);
  4461.         cp = lbuf;
  4462.         goto common;
  4463.  
  4464.     case FB64_IV_BAD:
  4465.         sprintf(lbuf, "%s_IV_BAD", type);
  4466.         cp = lbuf;
  4467.         goto common;
  4468.  
  4469.     default:
  4470.         sprintf(lbuf, " %d (unknown)", data[2]);
  4471.         cp = lbuf;
  4472.       common:
  4473.         for (; (buflen > 0) && (*buf = *cp++); buf++)
  4474.             buflen--;
  4475.         for (i = 3; i < cnt; i++) {
  4476.             sprintf(lbuf, " %d", data[i]);
  4477.             for (cp = lbuf; (buflen > 0) && (*buf = *cp++); buf++)
  4478.                 buflen--;
  4479.         }
  4480.         break;
  4481.     }
  4482. }
  4483.  
  4484. void
  4485. cast_cfb64_printsub(data, cnt, buf, buflen)
  4486.     unsigned char *data, *buf;
  4487.     int cnt, buflen;
  4488. {
  4489.     cast_fb64_printsub(data, cnt, buf, buflen, "CFB64");
  4490. }
  4491.  
  4492. void
  4493. cast_ofb64_printsub(data, cnt, buf, buflen)
  4494.     unsigned char *data, *buf;
  4495.     int cnt, buflen;
  4496. {
  4497.     cast_fb64_printsub(data, cnt, buf, buflen, "OFB64");
  4498. }
  4499.  
  4500. static void
  4501. cast_fb64_stream_iv(seed, stp)
  4502.     Block seed;
  4503.     register struct cast_stinfo *stp;
  4504. {
  4505.     memcpy((void *)stp->str_iv, (void *)seed, sizeof(Block));
  4506.     memcpy((void *)stp->str_output, (void *)seed, sizeof(Block));
  4507.  
  4508.     stp->str_index = sizeof(Block);
  4509. }
  4510.  
  4511. static void
  4512. cast_fb64_stream_key(key, stp, fs)
  4513.     unsigned char * key;
  4514.     register struct cast_stinfo *stp;
  4515.     int fs;
  4516. {
  4517. #ifndef CAST_EXPORT_ENCRYPTION
  4518.     if(fs)
  4519.         ck_cast128_key_sched(&stp->str_sched, key);
  4520.     else
  4521. #endif
  4522.         ck_cast5_40_key_sched(&stp->str_sched, key);
  4523.  
  4524.     memcpy((void *)stp->str_output, (void *)stp->str_iv, sizeof(Block));
  4525.  
  4526.     stp->str_index = sizeof(Block);
  4527. }
  4528.  
  4529. /*
  4530.  * CAST 64 bit Cipher Feedback
  4531.  *
  4532.  *     key --->+------+
  4533.  *          +->| CAST |--+
  4534.  *          |  +------+  |
  4535.  *          |            v
  4536.  *  INPUT --(---------->(+)+---> DATA
  4537.  *          |              |
  4538.  *          +--------------+
  4539.  *
  4540.  *
  4541.  * Given:
  4542.  *      iV: Initial vector, 64 bits (8 bytes) long.
  4543.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  4544.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  4545.  *
  4546.  *      V0 = CAST(iV, key)
  4547.  *      On = Dn ^ Vn
  4548.  *      V(n+1) = CAST(On, key)
  4549.  */
  4550. #ifndef CAST_EXPORT_ENCRYPTION
  4551. void
  4552. cast_cfb64_encrypt(s, c)
  4553.         register unsigned char *s;
  4554.         int c;
  4555. {
  4556.     _cast_cfb64_encrypt(s, c, &cast_fb[CFB_128].streams[DIR_ENCRYPT-1]);
  4557. }
  4558. #endif
  4559.  
  4560. void
  4561. castexp_cfb64_encrypt(s, c)
  4562.     register unsigned char *s;
  4563.     int c;
  4564. {
  4565.     _cast_cfb64_encrypt(s, c, &cast_fb[CFB_40].streams[DIR_ENCRYPT-1]);
  4566. }
  4567.  
  4568. static void
  4569. _cast_cfb64_encrypt(s, c, stp)
  4570.     register unsigned char *s;
  4571.     int c;
  4572.     register struct cast_stinfo *stp;
  4573. {
  4574.     register int index;
  4575.  
  4576.     index = stp->str_index;
  4577.     while (c-- > 0) {
  4578.         if (index == sizeof(Block)) {
  4579.             Block b;
  4580.             ck_cast_ecb_encrypt(b, stp->str_output, &stp->str_sched, 0);
  4581.             memcpy((void *)stp->str_feed, (void *)b, sizeof(Block));
  4582.             index = 0;
  4583.         }
  4584.  
  4585.         /* On encryption, we store (feed ^ data) which is cypher */
  4586.         *s = stp->str_output[index] = (stp->str_feed[index] ^ *s);
  4587.         s++;
  4588.         index++;
  4589.     }
  4590.     stp->str_index = index;
  4591. }
  4592.  
  4593. #ifndef CAST_EXPORT_ENCRYPTION
  4594. int
  4595. cast_cfb64_decrypt(data)
  4596.     int data;
  4597. {
  4598.     return _cast_cfb64_decrypt(data, &cast_fb[CFB_128].streams[DIR_DECRYPT-1]);
  4599. }
  4600. #endif
  4601.  
  4602. int
  4603. castexp_cfb64_decrypt(data)
  4604.     int data;
  4605. {
  4606.     return _cast_cfb64_decrypt(data, &cast_fb[CFB_40].streams[DIR_DECRYPT-1]);
  4607. }
  4608.  
  4609. static int
  4610. _cast_cfb64_decrypt(data, stp)
  4611.     int data;
  4612.     register struct cast_stinfo *stp;
  4613. {
  4614.     int index;
  4615.  
  4616.     if (data == -1) {
  4617.         /*
  4618.         * Back up one byte.  It is assumed that we will
  4619.         * never back up more than one byte.  If we do, this
  4620.         * may or may not work.
  4621.         */
  4622.         if (stp->str_index)
  4623.             --stp->str_index;
  4624.         return(0);
  4625.     }
  4626.  
  4627.     index = stp->str_index++;
  4628.     if (index == sizeof(Block)) {
  4629.         Block b;
  4630.         ck_cast_ecb_encrypt(b, stp->str_output, &stp->str_sched, 0);
  4631.         memcpy((void *)stp->str_feed, (void *)b, sizeof(Block));
  4632.         stp->str_index = 1;     /* Next time will be 1 */
  4633.         index = 0;              /* But now use 0 */
  4634.     }
  4635.  
  4636.     /* On decryption we store (data) which is cypher. */
  4637.     stp->str_output[index] = data;
  4638.     return(data ^ stp->str_feed[index]);
  4639. }
  4640.  
  4641. /*
  4642.  * CAST 64 bit Output Feedback
  4643.  *
  4644.  * key --->+------+
  4645.  *      +->| CAST |--+
  4646.  *      |  +------+  |
  4647.  *      +------------+
  4648.  *                   v
  4649.  *  INPUT --------->(+) ----> DATA
  4650.  *
  4651.  * Given:
  4652.  *      iV: Initial vector, 64 bits (8 bytes) long.
  4653.  *      Dn: the nth chunk of 64 bits (8 bytes) of data to encrypt (decrypt).
  4654.  *      On: the nth chunk of 64 bits (8 bytes) of encrypted (decrypted) output.
  4655.  *
  4656.  *      V0 = CAST(iV, key)
  4657.  *      V(n+1) = CAST(Vn, key)
  4658.  *      On = Dn ^ Vn
  4659.  */
  4660. #ifndef CAST_EXPORT_ENCRYPTION
  4661. void
  4662. cast_ofb64_encrypt(s, c)
  4663.     register unsigned char *s;
  4664.     int c;
  4665. {
  4666.     _cast_ofb64_encrypt(s, c, &cast_fb[OFB_128].streams[DIR_ENCRYPT-1]);
  4667. }
  4668. #endif
  4669.  
  4670. void
  4671. castexp_ofb64_encrypt(s, c)
  4672.     register unsigned char *s;
  4673.     int c;
  4674. {
  4675.   _cast_ofb64_encrypt(s, c, &cast_fb[OFB_40].streams[DIR_ENCRYPT-1]);
  4676. }
  4677.  
  4678. static void
  4679. _cast_ofb64_encrypt(s, c, stp)
  4680.     register unsigned char *s;
  4681.     int c;
  4682.     register struct cast_stinfo *stp;
  4683. {
  4684.     register int index;
  4685.  
  4686.     index = stp->str_index;
  4687.     while (c-- > 0) {
  4688.         if (index == sizeof(Block)) {
  4689.             Block b;
  4690.             ck_cast_ecb_encrypt(b, stp->str_feed, &stp->str_sched, 0);
  4691.             memcpy((void *)stp->str_feed, (void *)b, sizeof(Block));
  4692.             index = 0;
  4693.         }
  4694.         *s++ ^= stp->str_feed[index];
  4695.         index++;
  4696.     }
  4697.     stp->str_index = index;
  4698. }
  4699.  
  4700. #ifndef CAST_EXPORT_ENCRYPTION
  4701. int
  4702. cast_ofb64_decrypt(data)
  4703.     int data;
  4704. {
  4705.     return _cast_ofb64_decrypt(data, &cast_fb[OFB_128].streams[DIR_DECRYPT-1]);
  4706. }
  4707. #endif
  4708.  
  4709. int
  4710. castexp_ofb64_decrypt(data)
  4711.     int data;
  4712. {
  4713.     return _cast_ofb64_decrypt(data, &cast_fb[OFB_40].streams[DIR_DECRYPT-1]);
  4714. }
  4715.  
  4716. static int
  4717. _cast_ofb64_decrypt(data, stp)
  4718.     int data;
  4719.     register struct cast_stinfo *stp;
  4720. {
  4721.     int index;
  4722.  
  4723.     if (data == -1) {
  4724.         /*
  4725.         * Back up one byte.  It is assumed that we will
  4726.         * never back up more than one byte.  If we do, this
  4727.         * may or may not work.
  4728.         */
  4729.         if (stp->str_index)
  4730.             --stp->str_index;
  4731.         return(0);
  4732.     }
  4733.  
  4734.     index = stp->str_index++;
  4735.     if (index == sizeof(Block)) {
  4736.         Block b;
  4737.         ck_cast_ecb_encrypt(b, stp->str_feed, &stp->str_sched, 0);
  4738.         memcpy((void *)stp->str_feed, (void *)b, sizeof(Block));
  4739.         stp->str_index = 1;     /* Next time will be 1 */
  4740.         index = 0;              /* But now use 0 */
  4741.     }
  4742.  
  4743.     return(data ^ stp->str_feed[index]);
  4744. }
  4745.  
  4746. /*
  4747.  * Copyright (c) 1997 Stanford University
  4748.  *
  4749.  * Permission to use, copy, modify, distribute, and sell this software and
  4750.  * its documentation for any purpose is hereby granted without fee, provided
  4751.  * that the above copyright notices and this permission notice appear in
  4752.  * all copies of the software and related documentation.
  4753.  *
  4754.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  4755.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  4756.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  4757.  *
  4758.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  4759.  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
  4760.  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
  4761.  * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
  4762.  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  4763.  */
  4764.  
  4765. /*
  4766.  * cast.c
  4767.  * Author: Tom Wu
  4768.  *
  4769.  * An implementation of the CAST-128 encryption algorithm, as
  4770.  * specified in RFC 2144.
  4771.  */
  4772.  
  4773. /* The first four S-boxes are for encryption/decryption */
  4774.  
  4775. static uint32 S1[] = {
  4776.   0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f, 0x9c004dd3,
  4777.   0x6003e540, 0xcf9fc949, 0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675,
  4778.   0x6e63a0e0, 0x15c361d2, 0xc2e7661d, 0x22d4ff8e, 0x28683b6f, 0xc07fd059,
  4779.   0xff2379c8, 0x775f50e2, 0x43c340d3, 0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,
  4780.   0xa1c9e0d6, 0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1, 0xaa54166b,
  4781.   0x22568e3a, 0xa2d341d0, 0x66db40c8, 0xa784392f, 0x004dff2f, 0x2db9d2de,
  4782.   0x97943fac, 0x4a97c1d8, 0x527644b7, 0xb5f437a7, 0xb82cbaef, 0xd751d159,
  4783.   0x6ff7f0ed, 0x5a097a1f, 0x827b68d0, 0x90ecf52e, 0x22b0c054, 0xbc8e5935,
  4784.   0x4b6d2f7f, 0x50bb64a2, 0xd2664910, 0xbee5812d, 0xb7332290, 0xe93b159f,
  4785.   0xb48ee411, 0x4bff345d, 0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165,
  4786.   0xd5b1caad, 0xa1ac2dae, 0xa2d4b76d, 0xc19b0c50, 0x882240f2, 0x0c6e4f38,
  4787.   0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f, 0xc59c5319, 0xb949e354, 0xb04669fe,
  4788.   0xb1b6ab8a, 0xc71358dd, 0x6385c545, 0x110f935d, 0x57538ad5, 0x6a390493,
  4789.   0xe63d37e0, 0x2a54f6b3, 0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a,
  4790.   0x29f9d4d5, 0xf61b1891, 0xbb72275e, 0xaa508167, 0x38901091, 0xc6b505eb,
  4791.   0x84c7cb8c, 0x2ad75a0f, 0x874a1427, 0xa2d1936b, 0x2ad286af, 0xaa56d291,
  4792.   0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9, 0x6c00b32d, 0x73e2bb14,
  4793.   0xa0bebc3c, 0x54623779, 0x64459eab, 0x3f328b82, 0x7718cf82, 0x59a2cea6,
  4794.   0x04ee002e, 0x89fe78e6, 0x3fab0950, 0x325ff6c2, 0x81383f05, 0x6963c5c8,
  4795.   0x76cb5ad6, 0xd49974c9, 0xca180dcf, 0x380782d5, 0xc7fa5cf6, 0x8ac31511,
  4796.   0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241, 0x051ef495,
  4797.   0xaa573b04, 0x4a805d8d, 0x548300d0, 0x00322a3c, 0xbf64cddf, 0xba57a68e,
  4798.   0x75c6372b, 0x50afd341, 0xa7c13275, 0x915a0bf5, 0x6b54bfab, 0x2b0b1426,
  4799.   0xab4cc9d7, 0x449ccd82, 0xf7fbf265, 0xab85c5f3, 0x1b55db94, 0xaad4e324,
  4800.   0xcfa4bd3f, 0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3, 0xd5bd9e98,
  4801.   0xe31231b2, 0x2ad5ad6c, 0x954329de, 0xadbe4528, 0xd8710f69, 0xaa51c90f,
  4802.   0xaa786bf6, 0x22513f1e, 0xaa51a79b, 0x2ad344cc,0x7b5a41f0, 0xd37cfbad,
  4803.   0x1b069505, 0x41ece491, 0xb4c332e6, 0x032268d4, 0xc9600acc, 0xce387e6d,
  4804.   0xbf6bb16c, 0x6a70fb78, 0x0d03d9c9, 0xd4df39de, 0xe01063da, 0x4736f464,
  4805.   0x5ad328d8, 0xb347cc96, 0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a,
  4806.   0xe11f0abc, 0xbfc5fe4a, 0xa70aec10, 0xac39570a,0x3f04442f, 0x6188b153,
  4807.   0xe0397a2e, 0x5727cb79, 0x9ceb418f, 0x1cacd68d, 0x2ad37c96, 0x0175cb9d,
  4808.   0xc69dff09, 0xc75b65f0, 0xd9db40d8, 0xec0e7779, 0x4744ead4, 0xb11c3274,
  4809.   0xdd24cb9e, 0x7e1c54bd, 0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755,
  4810.   0xd47c27af, 0x51c85f4d, 0x56907596, 0xa5bb15e6,0x580304f0, 0xca042cf1,
  4811.   0x011a37ea, 0x8dbfaadb, 0x35ba3e4a, 0x3526ffa0, 0xc37b4d09, 0xbc306ed9,
  4812.   0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0, 0x7c63b2cf, 0x700b45e1,
  4813.   0xd5ea50f1, 0x85a92872, 0xaf1fbda7, 0xd4234870, 0xa7870bf3, 0x2d3b4d79,
  4814.   0x42e04198, 0x0cd0ede7, 0x26470db8, 0xf881814c,0x474d6ad7, 0x7c0c5e5c,
  4815.   0xd1231959, 0x381b7298, 0xf5d2f4db, 0xab838653, 0x6e2f1e23, 0x83719c9e,
  4816.   0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c, 0xe1e696ff,
  4817.   0xb141ab08, 0x7cca89b9, 0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d,
  4818.   0x427b169c, 0x5ac9f049, 0xdd8f0f00, 0x5c8165bf
  4819. };
  4820.  
  4821. static uint32 S2[] = {
  4822.   0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a, 0xeec5207a,
  4823.   0x55889c94, 0x72fc0651, 0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba,
  4824.   0x99c430ef, 0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3, 0xa0b52f7b, 0x59e83605,
  4825.   0xee15b094, 0xe9ffd909, 0xdc440086, 0xef944459, 0xba83ccb3, 0xe0c3cdfb,
  4826.   0xd1da4181, 0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb, 0xe4e7ef5b,
  4827.   0x25a1ff41, 0xe180f806, 0x1fc41080, 0x179bee7a, 0xd37ac6a9, 0xfe5830a4,
  4828.   0x98de8b7f, 0x77e83f4e, 0x79929269, 0x24fa9f7b, 0xe113c85b, 0xacc40083,
  4829.   0xd7503525, 0xf7ea615f, 0x62143154, 0x0d554b63, 0x5d681121, 0xc866c359,
  4830.   0x3d63cf73, 0xcee234c0, 0xd4d87e87, 0x5c672b21, 0x071f6181, 0x39f7627f,
  4831.   0x361e3084, 0xe4eb573b, 0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d,
  4832.   0x2701f50c, 0x99847ab4, 0xa0e3df79, 0xba6cf38c, 0x10843094, 0x2537a95e,
  4833.   0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a, 0x8f458c74, 0xd9e0a227, 0x4ec73a34,
  4834.   0xfc884f69, 0x3e4de8df, 0xef0e0088, 0x3559648d, 0x8a45388c, 0x1d804366,
  4835.   0x721d9bfd, 0xa58684bb, 0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4,
  4836.   0xce280ae1, 0x27e19ba5, 0xd5a6c252, 0xe49754bd, 0xc5d655dd, 0xeb667064,
  4837.   0x77840b4d, 0xa1b6a801, 0x84db26a9, 0xe0b56714, 0x21f043b7, 0xe5d05860,
  4838.   0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755, 0xb5625dbf, 0x68561be6,
  4839.   0x83ca6b94, 0x2d6ed23b, 0xeccf01db, 0xa6d3d0ba, 0xb6803d5c, 0xaf77a709,
  4840.   0x33b4a34c, 0x397bc8d6, 0x5ee22b95, 0x5f0e5304, 0x81ed6f61, 0x20e74364,
  4841.   0xb45e1378, 0xde18639b, 0x881ca122, 0xb96726d1, 0x8049a7e8, 0x22b7da7b,
  4842.   0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402, 0x1ba4fe5b,
  4843.   0xa4b09f6b, 0x1ca815cf, 0xa20c3005, 0x8871df63, 0xb9de2fcb, 0x0cc6c9e9,
  4844.   0x0beeff53, 0xe3214517, 0xb4542835, 0x9f63293c, 0xee41e729, 0x6e1d2d7c,
  4845.   0x50045286, 0x1e6685f3, 0xf33401c6, 0x30a22c95, 0x31a70850, 0x60930f13,
  4846.   0x73f98417, 0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6, 0xa02b1741,
  4847.   0x7cbad9a2, 0x2180036f, 0x50d99c08, 0xcb3f4861, 0xc26bd765, 0x64a3f6ab,
  4848.   0x80342676, 0x25a75e7b, 0xe4e6d1fc, 0x20c710e6, 0xcdf0b680, 0x17844d3b,
  4849.   0x31eef84d, 0x7e0824e4, 0x2ccb49eb, 0x846a3bae, 0x8ff77888, 0xee5d60f6,
  4850.   0x7af75673, 0x2fdd5cdb, 0xa11631c1, 0x30f66f43, 0xb3faec54, 0x157fd7fa,
  4851.   0xef8579cc, 0xd152de58, 0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8,
  4852.   0x99319ad5, 0xc242fa0f, 0xa7e3ebb0, 0xc68e4906, 0xb8da230c, 0x80823028,
  4853.   0xdcdef3c8, 0xd35fb171, 0x088a1bc8, 0xbec0c560, 0x61a3c9e8, 0xbca8f54d,
  4854.   0xc72feffa, 0x22822e99, 0x82c570b4, 0xd8d94e89, 0x8b1c34bc, 0x301e16e6,
  4855.   0x273be979, 0xb0ffeaa6, 0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b,
  4856.   0x43daf65a, 0xf7e19798, 0x7619b72f, 0x8f1c9ba4, 0xdc8637a0, 0x16a7d3b1,
  4857.   0x9fc393b7, 0xa7136eeb, 0xc6bcc63e, 0x1a513742, 0xef6828bc, 0x520365d6,
  4858.   0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e, 0xdb92f2fb, 0x5eea29cb,
  4859.   0x145892f5, 0x91584f7f, 0x5483697b, 0x2667a8cc, 0x85196048, 0x8c4bacea,
  4860.   0x833860d4, 0x0d23e0f9, 0x6c387e8a, 0x0ae6d249, 0xb284600c, 0xd835731d,
  4861.   0xdcb1c647, 0xac4c56ea, 0x3ebd81b3, 0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
  4862.   0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589, 0xa345415e,
  4863.   0x5c038323, 0x3e5d3bb9, 0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef,
  4864.   0x7160a539, 0x73bfbe70, 0x83877605, 0x4523ecf1
  4865. };
  4866.  
  4867. static uint32 S3[] = {
  4868.   0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff, 0x369fe44b,
  4869.   0x8c1fc644, 0xaececa90, 0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae,
  4870.   0x920e8806, 0xf0ad0548, 0xe13c8d83, 0x927010d5, 0x11107d9f, 0x07647db9,
  4871.   0xb2e3e4d4, 0x3d4f285e, 0xb9afa820, 0xfade82e0, 0xa067268b, 0x8272792e,
  4872.   0x553fb2c0, 0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee, 0x825b1bfd,
  4873.   0x9255c5ed, 0x1257a240, 0x4e1a8302, 0xbae07fff, 0x528246e7, 0x8e57140e,
  4874.   0x3373f7bf, 0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5, 0xa8c01db7, 0x579fc264,
  4875.   0x67094f31, 0xf2bd3f5f, 0x40fff7c1, 0x1fb78dfc, 0x8e6bd2c1, 0x437be59b,
  4876.   0x99b03dbf, 0xb5dbc64b, 0x638dc0e6, 0x55819d99, 0xa197c81c, 0x4a012d6e,
  4877.   0xc5884a28, 0xccc36f71, 0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f,
  4878.   0x2f7fe850, 0xd7c07f7e, 0x02507fbf, 0x5afb9a04, 0xa747d2d0, 0x1651192e,
  4879.   0xaf70bf3e, 0x58c31380, 0x5f98302e, 0x727cc3c4, 0x0a0fb402, 0x0f7fef82,
  4880.   0x8c96fdad, 0x5d2c2aae, 0x8ee99a49, 0x50da88b8, 0x8427f4a0, 0x1eac5790,
  4881.   0x796fb449, 0x8252dc15, 0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504,
  4882.   0xfa5d7403, 0xe83ec305, 0x4f91751a, 0x925669c2, 0x23efe941, 0xa903f12e,
  4883.   0x60270df2, 0x0276e4b6, 0x94fd6574, 0x927985b2, 0x8276dbcb, 0x02778176,
  4884.   0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e, 0x842f7d83, 0x340ce5c8,
  4885.   0x96bbb682, 0x93b4b148, 0xef303cab, 0x984faf28, 0x779faf9b, 0x92dc560d,
  4886.   0x224d1e20, 0x8437aa88, 0x7d29dc96, 0x2756d3dc, 0x8b907cee, 0xb51fd240,
  4887.   0xe7c07ce3, 0xe566b4a1, 0xc3e9615e, 0x3cf8209d, 0x6094d1e3, 0xcd9ca341,
  4888.   0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9, 0xbda8229c,
  4889.   0x127dadaa, 0x438a074e, 0x1f97c090, 0x081bdb8a, 0x93a07ebe, 0xb938ca15,
  4890.   0x97b03cff, 0x3dc2c0f8, 0x8d1ab2ec, 0x64380e51, 0x68cc7bfb, 0xd90f2788,
  4891.   0x12490181, 0x5de5ffd4, 0xdd7ef86a, 0x76a2e214, 0xb9a40368, 0x925d958f,
  4892.   0x4b39fffa, 0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623, 0x193cbcfa,
  4893.   0x27627545, 0x825cf47a, 0x61bd8ba0, 0xd11e42d1, 0xcead04f4, 0x127ea392,
  4894.   0x10428db7, 0x8272a972, 0x9270c4a8, 0x127de50b, 0x285ba1c8, 0x3c62f44f,
  4895.   0x35c0eaa5, 0xe805d231, 0x428929fb, 0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b,
  4896.   0x1f081fab, 0x108618ae, 0xfcfd086d, 0xf9ff2889, 0x694bcc11, 0x236a5cae,
  4897.   0x12deca4d, 0x2c3f8cc5, 0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67,
  4898.   0x494a488c, 0xb9b6a80c, 0x5c8f82bc, 0x89d36b45, 0x3a609437, 0xec00c9a9,
  4899.   0x44715253, 0x0a874b49, 0xd773bc40, 0x7c34671c, 0x02717ef6, 0x4feb5536,
  4900.   0xa2d02fff, 0xd2bf60c4, 0xd43f03c0, 0x50b4ef6d, 0x07478cd1, 0x006e1888,
  4901.   0xa2e53f55, 0xb9e6d4bc, 0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d,
  4902.   0x72f87b33, 0xabcc4f33, 0x7688c55d, 0x7b00a6b0, 0x947b0001, 0x570075d2,
  4903.   0xf9bb88f8, 0x8942019e, 0x4264a5ff, 0x856302e0, 0x72dbd92b, 0xee971b69,
  4904.   0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767, 0xcf1febd2, 0x61efc8c2,
  4905.   0xf1ac2571, 0xcc8239c2, 0x67214cb8, 0xb1e583d1, 0xb7dc3e62, 0x7f10bdce,
  4906.   0xf90a5c38, 0x0ff0443d, 0x606e6dc6, 0x60543a49, 0x5727c148, 0x2be98a1d,
  4907.   0x8ab41738, 0x20e1be24, 0xaf96da0f, 0x68458425, 0x99833be5, 0x600d457d,
  4908.   0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31, 0x9c305a00,
  4909.   0x52bce688, 0x1b03588a, 0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5,
  4910.   0xdfef4636, 0xa133c501, 0xe9d3531c, 0xee353783
  4911. };
  4912.  
  4913. static uint32 S4[] = {
  4914.   0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb, 0x64ad8c57,
  4915.   0x85510443, 0xfa020ed1, 0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120,
  4916.   0xfd059d43, 0x6497b7b1, 0xf3641f63, 0x241e4adf, 0x28147f5f, 0x4fa2b8cd,
  4917.   0xc9430040, 0x0cc32220, 0xfdd30b30, 0xc0a5374f, 0x1d2d00d9, 0x24147b15,
  4918.   0xee4d111a, 0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f, 0x0c13fefe,
  4919.   0x081b08ca, 0x05170121, 0x80530100, 0xe83e5efe, 0xac9af4f8, 0x7fe72701,
  4920.   0xd2b8ee5f, 0x06df4261, 0xbb9e9b8a, 0x7293ea25, 0xce84ffdf, 0xf5718801,
  4921.   0x3dd64b04, 0xa26f263b, 0x7ed48400, 0x547eebe6, 0x446d4ca0, 0x6cf3d6f5,
  4922.   0x2649abdf, 0xaea0c7f5, 0x36338cc1, 0x503f7e93, 0xd3772061, 0x11b638e1,
  4923.   0x72500e03, 0xf80eb2bb, 0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746,
  4924.   0xc9335400, 0x6920318f, 0x081dbb99, 0xffc304a5, 0x4d351805, 0x7f3d5ce3,
  4925.   0xa6c866c6, 0x5d5bcca9, 0xdaec6fea, 0x9f926f91, 0x9f46222f, 0x3991467d,
  4926.   0xa5bf6d8e, 0x1143c44f, 0x43958302, 0xd0214eeb, 0x022083b8, 0x3fb6180c,
  4927.   0x18f8931e, 0x281658e6, 0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c,
  4928.   0xf32d0a25, 0x79098b02, 0xe4eabb81, 0x28123b23, 0x69dead38, 0x1574ca16,
  4929.   0xdf871b62, 0x211c40b7, 0xa51a9ef9, 0x0014377b, 0x041e8ac8, 0x09114003,
  4930.   0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340, 0x557be8de, 0x00eae4a7,
  4931.   0x0ce5c2ec, 0x4db4bba6, 0xe756bdff, 0xdd3369ac, 0xec17b035, 0x06572327,
  4932.   0x99afc8b0, 0x56c8c391, 0x6b65811c, 0x5e146119, 0x6e85cb75, 0xbe07c002,
  4933.   0xc2325577, 0x893ff4ec, 0x5bbfc92d, 0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,
  4934.   0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a, 0xeca1d7c7,
  4935.   0x041afa32, 0x1d16625a, 0x6701902c, 0x9b757a54, 0x31d477f7, 0x9126b031,
  4936.   0x36cc6fdb, 0xc70b8b46, 0xd9e66a48, 0x56e55a79, 0x026a4ceb, 0x52437eff,
  4937.   0x2f8f76b4, 0x0df980a5, 0x8674cde3, 0xedda04eb, 0x17a9be04, 0x2c18f4df,
  4938.   0xb7747f9d, 0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254, 0xe5b6a035,
  4939.   0x213d42f6, 0x2c1c7c26, 0x61c2f50f, 0x6552daf9, 0xd2c231f8, 0x25130f69,
  4940.   0xd8167fa2, 0x0418f2c8, 0x001a96a6, 0x0d1526ab, 0x63315c21, 0x5e0a72ec,
  4941.   0x49bafefd, 0x187908d9, 0x8d0dbd86, 0x311170a7, 0x3e9b640c, 0xcc3e10d7,
  4942.   0xd5cad3b6, 0x0caec388, 0xf73001e1, 0x6c728aff, 0x71eae2a1, 0x1f9af36e,
  4943.   0xcfcbd12f, 0xc1de8417, 0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3,
  4944.   0xb1c52fca, 0xb4be31cd, 0xd8782806, 0x12a3a4e2, 0x6f7de532, 0x58fd7eb6,
  4945.   0xd01ee900, 0x24adffc2, 0xf4990fc5, 0x9711aac5, 0x001d7b95, 0x82e5e7d2,
  4946.   0x109873f6, 0x00613096, 0xc32d9521, 0xada121ff, 0x29908415, 0x7fbb977f,
  4947.   0xaf9eb3db, 0x29c9ed2a, 0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091,
  4948.   0xd49e2ce7, 0x0ce454a9, 0xd60acd86, 0x015f1919, 0x77079103, 0xdea03af6,
  4949.   0x78a8565e, 0xdee356df, 0x21f05cbe, 0x8b75e387, 0xb3c50651, 0xb8a5c3ef,
  4950.   0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf, 0xafe67afb, 0xf470c4b2,
  4951.   0xf3e0eb5b, 0xd6cc9876, 0x39e4460c, 0x1fda8538, 0x1987832f, 0xca007367,
  4952.   0xa99144f8, 0x296b299e, 0x492fc295, 0x9266beab, 0xb5676e69, 0x9bd3ddda,
  4953.   0xdf7e052f, 0xdb25701c, 0x1b5e51ee, 0xf65324e6, 0x6afce36c, 0x0316cc04,
  4954.   0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979, 0x932bcdf6,
  4955.   0xb657c34d, 0x4edfd282, 0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e,
  4956.   0x13ecf0b0, 0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2
  4957. };
  4958.  
  4959. /* Encrypt/decrypt one 64-bit block of data */
  4960.  
  4961. void
  4962. ck_cast_ecb_encrypt(out, in, sched, mode)
  4963.     uint8p out;
  4964.     uint8p in;
  4965.     CastKeySched * sched;
  4966.     int mode;           /* zero means encrypt */
  4967. {
  4968.     uint32 t[2];
  4969.  
  4970. #ifdef LITTLE_ENDIAN
  4971.     t[0] = (in[0] << 24) | (in[1] << 16) | (in[2] << 8) | in[3];
  4972.     t[1] = (in[4] << 24) | (in[5] << 16) | (in[6] << 8) | in[7];
  4973. #else
  4974.     t[0] = *(uint32p) in;
  4975.     t[1] = *(uint32p) (in + 4);
  4976. #endif
  4977.  
  4978.     ck_cast_ecb_crypt(t, sched, mode);
  4979.  
  4980. #ifdef LITTLE_ENDIAN
  4981.     out[0] = (t[0] >> 24) & 0xff;
  4982.     out[1] = (t[0] >> 16) & 0xff;
  4983.     out[2] = (t[0] >> 8) & 0xff;
  4984.     out[3] = t[0] & 0xff;
  4985.     out[4] = (t[1] >> 24) & 0xff;
  4986.     out[5] = (t[1] >> 16) & 0xff;
  4987.     out[6] = (t[1] >> 8) & 0xff;
  4988.     out[7] = t[1] & 0xff;
  4989. #else
  4990.     *(uint32p) out = t[0];
  4991.     *(uint32p) (out + 4) = t[1];
  4992. #endif
  4993. }
  4994.  
  4995. void
  4996. ck_cast_ecb_crypt(data, sched, mode)
  4997.     uint32p data;
  4998.     CastKeySched * sched;
  4999.     int mode;
  5000. {
  5001.     register uint32 L, R, temp;
  5002.     register struct CastSubkeyPair * kp;
  5003.     register uint8p Ia, Ib, Ic, Id;
  5004.     uint32 I;
  5005.  
  5006. #ifdef LITTLE_ENDIAN
  5007.     Id = (uint8p) &I;
  5008.     Ic = Id + 1;
  5009.     Ib = Ic + 1;
  5010.     Ia = Ib + 1;
  5011. #else
  5012.     Ia = (uint8p) &I;
  5013.     Ib = Ia + 1;
  5014.     Ic = Ib + 1;
  5015.     Id = Ic + 1;
  5016. #endif
  5017.  
  5018.     L = data[0];
  5019.     R = data[1];
  5020.  
  5021. #define type0(left,right)       \
  5022.       temp = kp->Km + right;\
  5023.       I = (temp << kp->Kr) | (temp >> (32 - kp->Kr));\
  5024.       left ^= ((S1[*Ia] ^ S2[*Ib]) - S3[*Ic]) + S4[*Id];
  5025.  
  5026. #define type1(left,right)       \
  5027.       temp = kp->Km ^ right;\
  5028.       I = (temp << kp->Kr) | (temp >> (32 - kp->Kr));\
  5029.       left ^= ((S1[*Ia] - S2[*Ib]) + S3[*Ic]) ^ S4[*Id];
  5030.  
  5031. #define type2(left,right)       \
  5032.       temp = kp->Km - right;\
  5033.       I = (temp << kp->Kr) | (temp >> (32 - kp->Kr));\
  5034.       left ^= ((S1[*Ia] + S2[*Ib]) ^ S3[*Ic]) - S4[*Id];
  5035.  
  5036.     if(mode) {
  5037. #ifndef CAST_EXPORT_ENCRYPTION
  5038.         if(sched->ksize > 10) {
  5039.             kp = &sched->K[15];
  5040.             type0(L, R); --kp;
  5041.             type2(R, L); --kp;
  5042.             type1(L, R); --kp;
  5043.             type0(R, L); --kp;
  5044.         }
  5045.         else
  5046. #endif
  5047.         kp = &sched->K[11];
  5048.         type2(L, R); --kp;
  5049.         type1(R, L); --kp;
  5050.         type0(L, R); --kp;
  5051.         type2(R, L); --kp;
  5052.         type1(L, R); --kp;
  5053.         type0(R, L); --kp;
  5054.         type2(L, R); --kp;
  5055.         type1(R, L); --kp;
  5056.         type0(L, R); --kp;
  5057.         type2(R, L); --kp;
  5058.         type1(L, R); --kp;
  5059.         type0(R, L);
  5060.     }
  5061.     else {
  5062.         kp = &sched->K[0];
  5063.         type0(L, R); ++kp;
  5064.         type1(R, L); ++kp;
  5065.         type2(L, R); ++kp;
  5066.         type0(R, L); ++kp;
  5067.         type1(L, R); ++kp;
  5068.         type2(R, L); ++kp;
  5069.         type0(L, R); ++kp;
  5070.         type1(R, L); ++kp;
  5071.         type2(L, R); ++kp;
  5072.         type0(R, L); ++kp;
  5073.         type1(L, R); ++kp;
  5074.         type2(R, L); ++kp;
  5075. #ifndef CAST_EXPORT_ENCRYPTION
  5076.         if(sched->ksize > 10) {
  5077.             type0(L, R); ++kp;
  5078.             type1(R, L); ++kp;
  5079.             type2(L, R); ++kp;
  5080.             type0(R, L);
  5081.         }
  5082. #endif
  5083.     }
  5084.  
  5085.     data[0] = R;
  5086.     data[1] = L;
  5087. }
  5088.  
  5089. /* The last four S-boxes are for key schedule setup */
  5090.  
  5091. static uint32 S5[] = {
  5092.   0x7ec90c04, 0x2c6e74b9, 0x9b0e66df, 0xa6337911, 0xb86a7fff, 0x1dd358f5,
  5093.   0x44dd9d44, 0x1731167f, 0x08fbf1fa, 0xe7f511cc, 0xd2051b00, 0x735aba00,
  5094.   0x2ab722d8, 0x386381cb, 0xacf6243a, 0x69befd7a, 0xe6a2e77f, 0xf0c720cd,
  5095.   0xc4494816, 0xccf5c180, 0x38851640, 0x15b0a848, 0xe68b18cb, 0x4caadeff,
  5096.   0x5f480a01, 0x0412b2aa, 0x259814fc, 0x41d0efe2, 0x4e40b48d, 0x248eb6fb,
  5097.   0x8dba1cfe, 0x41a99b02, 0x1a550a04, 0xba8f65cb, 0x7251f4e7, 0x95a51725,
  5098.   0xc106ecd7, 0x97a5980a, 0xc539b9aa, 0x4d79fe6a, 0xf2f3f763, 0x68af8040,
  5099.   0xed0c9e56, 0x11b4958b, 0xe1eb5a88, 0x8709e6b0, 0xd7e07156, 0x4e29fea7,
  5100.   0x6366e52d, 0x02d1c000, 0xc4ac8e05, 0x9377f571, 0x0c05372a, 0x578535f2,
  5101.   0x2261be02, 0xd642a0c9, 0xdf13a280, 0x74b55bd2, 0x682199c0, 0xd421e5ec,
  5102.   0x53fb3ce8, 0xc8adedb3, 0x28a87fc9, 0x3d959981, 0x5c1ff900, 0xfe38d399,
  5103.   0x0c4eff0b, 0x062407ea, 0xaa2f4fb1, 0x4fb96976, 0x90c79505, 0xb0a8a774,
  5104.   0xef55a1ff, 0xe59ca2c2, 0xa6b62d27, 0xe66a4263, 0xdf65001f, 0x0ec50966,
  5105.   0xdfdd55bc, 0x29de0655, 0x911e739a, 0x17af8975, 0x32c7911c, 0x89f89468,
  5106.   0x0d01e980, 0x524755f4, 0x03b63cc9, 0x0cc844b2, 0xbcf3f0aa, 0x87ac36e9,
  5107.   0xe53a7426, 0x01b3d82b, 0x1a9e7449, 0x64ee2d7e, 0xcddbb1da, 0x01c94910,
  5108.   0xb868bf80, 0x0d26f3fd, 0x9342ede7, 0x04a5c284, 0x636737b6, 0x50f5b616,
  5109.   0xf24766e3, 0x8eca36c1, 0x136e05db, 0xfef18391, 0xfb887a37, 0xd6e7f7d4,
  5110.   0xc7fb7dc9, 0x3063fcdf, 0xb6f589de, 0xec2941da, 0x26e46695, 0xb7566419,
  5111.   0xf654efc5, 0xd08d58b7, 0x48925401, 0xc1bacb7f, 0xe5ff550f, 0xb6083049,
  5112.   0x5bb5d0e8, 0x87d72e5a, 0xab6a6ee1, 0x223a66ce, 0xc62bf3cd, 0x9e0885f9,
  5113.   0x68cb3e47, 0x086c010f, 0xa21de820, 0xd18b69de, 0xf3f65777, 0xfa02c3f6,
  5114.   0x407edac3, 0xcbb3d550, 0x1793084d, 0xb0d70eba, 0x0ab378d5, 0xd951fb0c,
  5115.   0xded7da56, 0x4124bbe4, 0x94ca0b56, 0x0f5755d1, 0xe0e1e56e, 0x6184b5be,
  5116.   0x580a249f, 0x94f74bc0, 0xe327888e, 0x9f7b5561, 0xc3dc0280, 0x05687715,
  5117.   0x646c6bd7, 0x44904db3, 0x66b4f0a3, 0xc0f1648a, 0x697ed5af, 0x49e92ff6,
  5118.   0x309e374f, 0x2cb6356a, 0x85808573, 0x4991f840, 0x76f0ae02, 0x083be84d,
  5119.   0x28421c9a, 0x44489406, 0x736e4cb8, 0xc1092910, 0x8bc95fc6, 0x7d869cf4,
  5120.   0x134f616f, 0x2e77118d, 0xb31b2be1, 0xaa90b472, 0x3ca5d717, 0x7d161bba,
  5121.   0x9cad9010, 0xaf462ba2, 0x9fe459d2, 0x45d34559, 0xd9f2da13, 0xdbc65487,
  5122.   0xf3e4f94e, 0x176d486f, 0x097c13ea, 0x631da5c7, 0x445f7382, 0x175683f4,
  5123.   0xcdc66a97, 0x70be0288, 0xb3cdcf72, 0x6e5dd2f3, 0x20936079, 0x459b80a5,
  5124.   0xbe60e2db, 0xa9c23101, 0xeba5315c, 0x224e42f2, 0x1c5c1572, 0xf6721b2c,
  5125.   0x1ad2fff3, 0x8c25404e, 0x324ed72f, 0x4067b7fd, 0x0523138e, 0x5ca3bc78,
  5126.   0xdc0fd66e, 0x75922283, 0x784d6b17, 0x58ebb16e, 0x44094f85, 0x3f481d87,
  5127.   0xfcfeae7b, 0x77b5ff76, 0x8c2302bf, 0xaaf47556, 0x5f46b02a, 0x2b092801,
  5128.   0x3d38f5f7, 0x0ca81f36, 0x52af4a8a, 0x66d5e7c0, 0xdf3b0874, 0x95055110,
  5129.   0x1b5ad7a8, 0xf61ed5ad, 0x6cf6e479, 0x20758184, 0xd0cefa65, 0x88f7be58,
  5130.   0x4a046826, 0x0ff6f8f3, 0xa09c7f70, 0x5346aba0, 0x5ce96c28, 0xe176eda3,
  5131.   0x6bac307f, 0x376829d2, 0x85360fa9, 0x17e3fe2a, 0x24b79767, 0xf5a96b20,
  5132.   0xd6cd2595, 0x68ff1ebf, 0x7555442c, 0xf19f06be, 0xf9e0659a, 0xeeb9491d,
  5133.   0x34010718, 0xbb30cab8, 0xe822fe15, 0x88570983, 0x750e6249, 0xda627e55,
  5134.   0x5e76ffa8, 0xb1534546, 0x6d47de08, 0xefe9e7d4
  5135. };
  5136.  
  5137. static uint32 S6[] = {
  5138.   0xf6fa8f9d, 0x2cac6ce1, 0x4ca34867, 0xe2337f7c, 0x95db08e7, 0x016843b4,
  5139.   0xeced5cbc, 0x325553ac, 0xbf9f0960, 0xdfa1e2ed, 0x83f0579d, 0x63ed86b9,
  5140.   0x1ab6a6b8, 0xde5ebe39, 0xf38ff732, 0x8989b138, 0x33f14961, 0xc01937bd,
  5141.   0xf506c6da, 0xe4625e7e, 0xa308ea99, 0x4e23e33c, 0x79cbd7cc, 0x48a14367,
  5142.   0xa3149619, 0xfec94bd5, 0xa114174a, 0xeaa01866, 0xa084db2d, 0x09a8486f,
  5143.   0xa888614a, 0x2900af98, 0x01665991, 0xe1992863, 0xc8f30c60, 0x2e78ef3c,
  5144.   0xd0d51932, 0xcf0fec14, 0xf7ca07d2, 0xd0a82072, 0xfd41197e, 0x9305a6b0,
  5145.   0xe86be3da, 0x74bed3cd, 0x372da53c, 0x4c7f4448, 0xdab5d440, 0x6dba0ec3,
  5146.   0x083919a7, 0x9fbaeed9, 0x49dbcfb0, 0x4e670c53, 0x5c3d9c01, 0x64bdb941,
  5147.   0x2c0e636a, 0xba7dd9cd, 0xea6f7388, 0xe70bc762, 0x35f29adb, 0x5c4cdd8d,
  5148.   0xf0d48d8c, 0xb88153e2, 0x08a19866, 0x1ae2eac8, 0x284caf89, 0xaa928223,
  5149.   0x9334be53, 0x3b3a21bf, 0x16434be3, 0x9aea3906, 0xefe8c36e, 0xf890cdd9,
  5150.   0x80226dae, 0xc340a4a3, 0xdf7e9c09, 0xa694a807, 0x5b7c5ecc, 0x221db3a6,
  5151.   0x9a69a02f, 0x68818a54, 0xceb2296f, 0x53c0843a, 0xfe893655, 0x25bfe68a,
  5152.   0xb4628abc, 0xcf222ebf, 0x25ac6f48, 0xa9a99387, 0x53bddb65, 0xe76ffbe7,
  5153.   0xe967fd78, 0x0ba93563, 0x8e342bc1, 0xe8a11be9, 0x4980740d, 0xc8087dfc,
  5154.   0x8de4bf99, 0xa11101a0, 0x7fd37975, 0xda5a26c0, 0xe81f994f, 0x9528cd89,
  5155.   0xfd339fed, 0xb87834bf, 0x5f04456d, 0x22258698, 0xc9c4c83b, 0x2dc156be,
  5156.   0x4f628daa, 0x57f55ec5, 0xe2220abe, 0xd2916ebf, 0x4ec75b95, 0x24f2c3c0,
  5157.   0x42d15d99, 0xcd0d7fa0, 0x7b6e27ff, 0xa8dc8af0, 0x7345c106, 0xf41e232f,
  5158.   0x35162386, 0xe6ea8926, 0x3333b094, 0x157ec6f2, 0x372b74af, 0x692573e4,
  5159.   0xe9a9d848, 0xf3160289, 0x3a62ef1d, 0xa787e238, 0xf3a5f676, 0x74364853,
  5160.   0x20951063, 0x4576698d, 0xb6fad407, 0x592af950, 0x36f73523, 0x4cfb6e87,
  5161.   0x7da4cec0, 0x6c152daa, 0xcb0396a8, 0xc50dfe5d, 0xfcd707ab, 0x0921c42f,
  5162.   0x89dff0bb, 0x5fe2be78, 0x448f4f33, 0x754613c9, 0x2b05d08d, 0x48b9d585,
  5163.   0xdc049441, 0xc8098f9b, 0x7dede786, 0xc39a3373, 0x42410005, 0x6a091751,
  5164.   0x0ef3c8a6, 0x890072d6, 0x28207682, 0xa9a9f7be, 0xbf32679d, 0xd45b5b75,
  5165.   0xb353fd00, 0xcbb0e358, 0x830f220a, 0x1f8fb214, 0xd372cf08, 0xcc3c4a13,
  5166.   0x8cf63166, 0x061c87be, 0x88c98f88, 0x6062e397, 0x47cf8e7a, 0xb6c85283,
  5167.   0x3cc2acfb, 0x3fc06976, 0x4e8f0252, 0x64d8314d, 0xda3870e3, 0x1e665459,
  5168.   0xc10908f0, 0x513021a5, 0x6c5b68b7, 0x822f8aa0, 0x3007cd3e, 0x74719eef,
  5169.   0xdc872681, 0x073340d4, 0x7e432fd9, 0x0c5ec241, 0x8809286c, 0xf592d891,
  5170.   0x08a930f6, 0x957ef305, 0xb7fbffbd, 0xc266e96f, 0x6fe4ac98, 0xb173ecc0,
  5171.   0xbc60b42a, 0x953498da, 0xfba1ae12, 0x2d4bd736, 0x0f25faab, 0xa4f3fceb,
  5172.   0xe2969123, 0x257f0c3d, 0x9348af49, 0x361400bc, 0xe8816f4a, 0x3814f200,
  5173.   0xa3f94043, 0x9c7a54c2, 0xbc704f57, 0xda41e7f9, 0xc25ad33a, 0x54f4a084,
  5174.   0xb17f5505, 0x59357cbe, 0xedbd15c8, 0x7f97c5ab, 0xba5ac7b5, 0xb6f6deaf,
  5175.   0x3a479c3a, 0x5302da25, 0x653d7e6a, 0x54268d49, 0x51a477ea, 0x5017d55b,
  5176.   0xd7d25d88, 0x44136c76, 0x0404a8c8, 0xb8e5a121, 0xb81a928a, 0x60ed5869,
  5177.   0x97c55b96, 0xeaec991b, 0x29935913, 0x01fdb7f1, 0x088e8dfa, 0x9ab6f6f5,
  5178.   0x3b4cbf9f, 0x4a5de3ab, 0xe6051d35, 0xa0e1d855, 0xd36b4cf1, 0xf544edeb,
  5179.   0xb0e93524, 0xbebb8fbd, 0xa2d762cf, 0x49c92f54, 0x38b5f331, 0x7128a454,
  5180.   0x48392905, 0xa65b1db8, 0x851c97bd, 0xd675cf2f
  5181. };
  5182.  
  5183. static uint32 S7[] = {
  5184.   0x85e04019, 0x332bf567, 0x662dbfff, 0xcfc65693, 0x2a8d7f6f, 0xab9bc912,
  5185.   0xde6008a1, 0x2028da1f, 0x0227bce7, 0x4d642916, 0x18fac300, 0x50f18b82,
  5186.   0x2cb2cb11, 0xb232e75c, 0x4b3695f2, 0xb28707de, 0xa05fbcf6, 0xcd4181e9,
  5187.   0xe150210c, 0xe24ef1bd, 0xb168c381, 0xfde4e789, 0x5c79b0d8, 0x1e8bfd43,
  5188.   0x4d495001, 0x38be4341, 0x913cee1d, 0x92a79c3f, 0x089766be, 0xbaeeadf4,
  5189.   0x1286becf, 0xb6eacb19, 0x2660c200, 0x7565bde4, 0x64241f7a, 0x8248dca9,
  5190.   0xc3b3ad66, 0x28136086, 0x0bd8dfa8, 0x356d1cf2, 0x107789be, 0xb3b2e9ce,
  5191.   0x0502aa8f, 0x0bc0351e, 0x166bf52a, 0xeb12ff82, 0xe3486911, 0xd34d7516,
  5192.   0x4e7b3aff, 0x5f43671b, 0x9cf6e037, 0x4981ac83, 0x334266ce, 0x8c9341b7,
  5193.   0xd0d854c0, 0xcb3a6c88, 0x47bc2829, 0x4725ba37, 0xa66ad22b, 0x7ad61f1e,
  5194.   0x0c5cbafa, 0x4437f107, 0xb6e79962, 0x42d2d816, 0x0a961288, 0xe1a5c06e,
  5195.   0x13749e67, 0x72fc081a, 0xb1d139f7, 0xf9583745, 0xcf19df58, 0xbec3f756,
  5196.   0xc06eba30, 0x07211b24, 0x45c28829, 0xc95e317f, 0xbc8ec511, 0x38bc46e9,
  5197.   0xc6e6fa14, 0xbae8584a, 0xad4ebc46, 0x468f508b, 0x7829435f, 0xf124183b,
  5198.   0x821dba9f, 0xaff60ff4, 0xea2c4e6d, 0x16e39264, 0x92544a8b, 0x009b4fc3,
  5199.   0xaba68ced, 0x9ac96f78, 0x06a5b79a, 0xb2856e6e, 0x1aec3ca9, 0xbe838688,
  5200.   0x0e0804e9, 0x55f1be56, 0xe7e5363b, 0xb3a1f25d, 0xf7debb85, 0x61fe033c,
  5201.   0x16746233, 0x3c034c28, 0xda6d0c74, 0x79aac56c, 0x3ce4e1ad, 0x51f0c802,
  5202.   0x98f8f35a, 0x1626a49f, 0xeed82b29, 0x1d382fe3, 0x0c4fb99a, 0xbb325778,
  5203.   0x3ec6d97b, 0x6e77a6a9, 0xcb658b5c, 0xd45230c7, 0x2bd1408b, 0x60c03eb7,
  5204.   0xb9068d78, 0xa33754f4, 0xf430c87d, 0xc8a71302, 0xb96d8c32, 0xebd4e7be,
  5205.   0xbe8b9d2d, 0x7979fb06, 0xe7225308, 0x8b75cf77, 0x11ef8da4, 0xe083c858,
  5206.   0x8d6b786f, 0x5a6317a6, 0xfa5cf7a0, 0x5dda0033, 0xf28ebfb0, 0xf5b9c310,
  5207.   0xa0eac280, 0x08b9767a, 0xa3d9d2b0, 0x79d34217, 0x021a718d, 0x9ac6336a,
  5208.   0x2711fd60, 0x438050e3, 0x069908a8, 0x3d7fedc4, 0x826d2bef, 0x4eeb8476,
  5209.   0x488dcf25, 0x36c9d566, 0x28e74e41, 0xc2610aca, 0x3d49a9cf, 0xbae3b9df,
  5210.   0xb65f8de6, 0x92aeaf64, 0x3ac7d5e6, 0x9ea80509, 0xf22b017d, 0xa4173f70,
  5211.   0xdd1e16c3, 0x15e0d7f9, 0x50b1b887, 0x2b9f4fd5, 0x625aba82, 0x6a017962,
  5212.   0x2ec01b9c, 0x15488aa9, 0xd716e740, 0x40055a2c, 0x93d29a22, 0xe32dbf9a,
  5213.   0x058745b9, 0x3453dc1e, 0xd699296e, 0x496cff6f, 0x1c9f4986, 0xdfe2ed07,
  5214.   0xb87242d1, 0x19de7eae, 0x053e561a, 0x15ad6f8c, 0x66626c1c, 0x7154c24c,
  5215.   0xea082b2a, 0x93eb2939, 0x17dcb0f0, 0x58d4f2ae, 0x9ea294fb, 0x52cf564c,
  5216.   0x9883fe66, 0x2ec40581, 0x763953c3, 0x01d6692e, 0xd3a0c108, 0xa1e7160e,
  5217.   0xe4f2dfa6, 0x693ed285, 0x74904698, 0x4c2b0edd, 0x4f757656, 0x5d393378,
  5218.   0xa132234f, 0x3d321c5d, 0xc3f5e194, 0x4b269301, 0xc79f022f, 0x3c997e7e,
  5219.   0x5e4f9504, 0x3ffafbbd, 0x76f7ad0e, 0x296693f4, 0x3d1fce6f, 0xc61e45be,
  5220.   0xd3b5ab34, 0xf72bf9b7, 0x1b0434c0, 0x4e72b567, 0x5592a33d, 0xb5229301,
  5221.   0xcfd2a87f, 0x60aeb767, 0x1814386b, 0x30bcc33d, 0x38a0c07d, 0xfd1606f2,
  5222.   0xc363519b, 0x589dd390, 0x5479f8e6, 0x1cb8d647, 0x97fd61a9, 0xea7759f4,
  5223.   0x2d57539d, 0x569a58cf, 0xe84e63ad, 0x462e1b78, 0x6580f87e, 0xf3817914,
  5224.   0x91da55f4, 0x40a230f3, 0xd1988f35, 0xb6e318d2, 0x3ffa50bc, 0x3d40f021,
  5225.   0xc3c0bdae, 0x4958c24c, 0x518f36b2, 0x84b1d370, 0x0fedce83, 0x878ddada,
  5226.   0xf2a279c7, 0x94e01be8, 0x90716f4b, 0x954b8aa3
  5227. };
  5228.  
  5229. static uint32 S8[] = {
  5230.   0xe216300d, 0xbbddfffc, 0xa7ebdabd, 0x35648095, 0x7789f8b7, 0xe6c1121b,
  5231.   0x0e241600, 0x052ce8b5, 0x11a9cfb0, 0xe5952f11, 0xece7990a, 0x9386d174,
  5232.   0x2a42931c, 0x76e38111, 0xb12def3a, 0x37ddddfc, 0xde9adeb1, 0x0a0cc32c,
  5233.   0xbe197029, 0x84a00940, 0xbb243a0f, 0xb4d137cf, 0xb44e79f0, 0x049eedfd,
  5234.   0x0b15a15d, 0x480d3168, 0x8bbbde5a, 0x669ded42, 0xc7ece831, 0x3f8f95e7,
  5235.   0x72df191b, 0x7580330d, 0x94074251, 0x5c7dcdfa, 0xabbe6d63, 0xaa402164,
  5236.   0xb301d40a, 0x02e7d1ca, 0x53571dae, 0x7a3182a2, 0x12a8ddec, 0xfdaa335d,
  5237.   0x176f43e8, 0x71fb46d4, 0x38129022, 0xce949ad4, 0xb84769ad, 0x965bd862,
  5238.   0x82f3d055, 0x66fb9767, 0x15b80b4e, 0x1d5b47a0, 0x4cfde06f, 0xc28ec4b8,
  5239.   0x57e8726e, 0x647a78fc, 0x99865d44, 0x608bd593, 0x6c200e03, 0x39dc5ff6,
  5240.   0x5d0b00a3, 0xae63aff2, 0x7e8bd632, 0x70108c0c, 0xbbd35049, 0x2998df04,
  5241.   0x980cf42a, 0x9b6df491, 0x9e7edd53, 0x06918548, 0x58cb7e07, 0x3b74ef2e,
  5242.   0x522fffb1, 0xd24708cc, 0x1c7e27cd, 0xa4eb215b, 0x3cf1d2e2, 0x19b47a38,
  5243.   0x424f7618, 0x35856039, 0x9d17dee7, 0x27eb35e6, 0xc9aff67b, 0x36baf5b8,
  5244.   0x09c467cd, 0xc18910b1, 0xe11dbf7b, 0x06cd1af8, 0x7170c608, 0x2d5e3354,
  5245.   0xd4de495a, 0x64c6d006, 0xbcc0c62c, 0x3dd00db3, 0x708f8f34, 0x77d51b42,
  5246.   0x264f620f, 0x24b8d2bf, 0x15c1b79e, 0x46a52564, 0xf8d7e54e, 0x3e378160,
  5247.   0x7895cda5, 0x859c15a5, 0xe6459788, 0xc37bc75f, 0xdb07ba0c, 0x0676a3ab,
  5248.   0x7f229b1e, 0x31842e7b, 0x24259fd7, 0xf8bef472, 0x835ffcb8, 0x6df4c1f2,
  5249.   0x96f5b195, 0xfd0af0fc, 0xb0fe134c, 0xe2506d3d, 0x4f9b12ea, 0xf215f225,
  5250.   0xa223736f, 0x9fb4c428, 0x25d04979, 0x34c713f8, 0xc4618187, 0xea7a6e98,
  5251.   0x7cd16efc, 0x1436876c, 0xf1544107, 0xbedeee14, 0x56e9af27, 0xa04aa441,
  5252.   0x3cf7c899, 0x92ecbae6, 0xdd67016d, 0x151682eb, 0xa842eedf, 0xfdba60b4,
  5253.   0xf1907b75, 0x20e3030f, 0x24d8c29e, 0xe139673b, 0xefa63fb8, 0x71873054,
  5254.   0xb6f2cf3b, 0x9f326442, 0xcb15a4cc, 0xb01a4504, 0xf1e47d8d, 0x844a1be5,
  5255.   0xbae7dfdc, 0x42cbda70, 0xcd7dae0a, 0x57e85b7a, 0xd53f5af6, 0x20cf4d8c,
  5256.   0xcea4d428, 0x79d130a4, 0x3486ebfb, 0x33d3cddc, 0x77853b53, 0x37effcb5,
  5257.   0xc5068778, 0xe580b3e6, 0x4e68b8f4, 0xc5c8b37e, 0x0d809ea2, 0x398feb7c,
  5258.   0x132a4f94, 0x43b7950e, 0x2fee7d1c, 0x223613bd, 0xdd06caa2, 0x37df932b,
  5259.   0xc4248289, 0xacf3ebc3, 0x5715f6b7, 0xef3478dd, 0xf267616f, 0xc148cbe4,
  5260.   0x9052815e, 0x5e410fab, 0xb48a2465, 0x2eda7fa4, 0xe87b40e4, 0xe98ea084,
  5261.   0x5889e9e1, 0xefd390fc, 0xdd07d35b, 0xdb485694, 0x38d7e5b2, 0x57720101,
  5262.   0x730edebc, 0x5b643113, 0x94917e4f, 0x503c2fba, 0x646f1282, 0x7523d24a,
  5263.   0xe0779695, 0xf9c17a8f, 0x7a5b2121, 0xd187b896, 0x29263a4d, 0xba510cdf,
  5264.   0x81f47c9f, 0xad1163ed, 0xea7b5965, 0x1a00726e, 0x11403092, 0x00da6d77,
  5265.   0x4a0cdd61, 0xad1f4603, 0x605bdfb0, 0x9eedc364, 0x22ebe6a8, 0xcee7d28a,
  5266.   0xa0e736a0, 0x5564a6b9, 0x10853209, 0xc7eb8f37, 0x2de705ca, 0x8951570f,
  5267.   0xdf09822b, 0xbd691a6c, 0xaa12e4f2, 0x87451c0f, 0xe0f6a27a, 0x3ada4819,
  5268.   0x4cf1764f, 0x0d771c2b, 0x67cdb156, 0x350d8384, 0x5938fa0f, 0x42399ef3,
  5269.   0x36997b07, 0x0e84093d, 0x4aa93e61, 0x8360d87b, 0x1fa98b0c, 0x1149382c,
  5270.   0xe97625a5, 0x0614d1b7, 0x0e25244b, 0x0c768347, 0x589e8d82, 0x0d2059d1,
  5271.   0xa466bb1e, 0xf8da0a82, 0x04f19130, 0xba6e4ec0, 0x99265164, 0x1ee7230d,
  5272.   0x50b2ad80, 0xeaee6801, 0x8db2a283, 0xea8bf59e
  5273. };
  5274.  
  5275. /* Initialize a key schedule from a 128-bit key */
  5276.  
  5277. static void
  5278. cast_key_sched(sched, key)
  5279.      CastKeySched * sched;
  5280.      uint8p key;
  5281. {
  5282.     uint8p x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xA, xB, xC, xD, xE, xF;
  5283.     uint8p z0, z1, z2, z3, z4, z5, z6, z7, z8, z9, zA, zB, zC, zD, zE, zF;
  5284.     uint32 X03, X47, X8B, XCF, Z03, Z47, Z8B, ZCF;
  5285.  
  5286. #ifdef LITTLE_ENDIAN
  5287.     x3 = (uint8p) &X03;  x2 = x3 + 1;  x1 = x2 + 1;  x0 = x1 + 1;
  5288.     x7 = (uint8p) &X47;  x6 = x7 + 1;  x5 = x6 + 1;  x4 = x5 + 1;
  5289.     xB = (uint8p) &X8B;  xA = xB + 1;  x9 = xA + 1;  x8 = x9 + 1;
  5290.     xF = (uint8p) &XCF;  xE = xF + 1;  xD = xE + 1;  xC = xD + 1;
  5291.     z3 = (uint8p) &Z03;  z2 = z3 + 1;  z1 = z2 + 1;  z0 = z1 + 1;
  5292.     z7 = (uint8p) &Z47;  z6 = z7 + 1;  z5 = z6 + 1;  z4 = z5 + 1;
  5293.     zB = (uint8p) &Z8B;  zA = zB + 1;  z9 = zA + 1;  z8 = z9 + 1;
  5294.     zF = (uint8p) &ZCF;  zE = zF + 1;  zD = zE + 1;  zC = zD + 1;
  5295. #else
  5296.     x0 = (uint8p) &X03;  x1 = x0 + 1;  x2 = x1 + 1;  x3 = x2 + 1;
  5297.     x4 = (uint8p) &X47;  x5 = x4 + 1;  x6 = x5 + 1;  x7 = x6 + 1;
  5298.     x8 = (uint8p) &X8B;  x9 = x8 + 1;  xA = x9 + 1;  xB = xA + 1;
  5299.     xC = (uint8p) &XCF;  xD = xC + 1;  xE = xD + 1;  xF = xE + 1;
  5300.     z0 = (uint8p) &Z03;  z1 = z0 + 1;  z2 = z1 + 1;  z3 = z2 + 1;
  5301.     z4 = (uint8p) &Z47;  z5 = z4 + 1;  z6 = z5 + 1;  z7 = z6 + 1;
  5302.     z8 = (uint8p) &Z8B;  z9 = z8 + 1;  zA = z9 + 1;  zB = zA + 1;
  5303.     zC = (uint8p) &ZCF;  zD = zC + 1;  zE = zD + 1;  zF = zE + 1;
  5304. #endif
  5305.  
  5306. #ifdef LITTLE_ENDIAN
  5307.     *x0 = key[0];
  5308.     *x1 = key[1];
  5309.     *x2 = key[2];
  5310.     *x3 = key[3];
  5311.     *x4 = key[4];
  5312.     *x5 = key[5];
  5313.     *x6 = key[6];
  5314.     *x7 = key[7];
  5315.     *x8 = key[8];
  5316.     *x9 = key[9];
  5317.     *xA = key[10];
  5318.     *xB = key[11];
  5319.     *xC = key[12];
  5320.     *xD = key[13];
  5321.     *xE = key[14];
  5322.     *xF = key[15];
  5323. #else
  5324.     X03 = *(uint32p) key;
  5325.     X47 = *(uint32p) (key + 4);
  5326.     X8B = *(uint32p) (key + 8);
  5327.     XCF = *(uint32p) (key + 12);
  5328. #endif
  5329.  
  5330.   /* First half of key schedule */
  5331.  
  5332.     Z03 = X03 ^ S5[*xD] ^ S6[*xF] ^ S7[*xC] ^ S8[*xE] ^ S7[*x8];
  5333.     Z47 = X8B ^ S5[*z0] ^ S6[*z2] ^ S7[*z1] ^ S8[*z3] ^ S8[*xA];
  5334.     Z8B = XCF ^ S5[*z7] ^ S6[*z6] ^ S7[*z5] ^ S8[*z4] ^ S5[*x9];
  5335.     ZCF = X47 ^ S5[*zA] ^ S6[*z9] ^ S7[*zB] ^ S8[*z8] ^ S6[*xB];
  5336.  
  5337.     sched->K[0].Km = S5[*z8] ^ S6[*z9] ^ S7[*z7] ^ S8[*z6] ^ S5[*z2];
  5338.     sched->K[1].Km = S5[*zA] ^ S6[*zB] ^ S7[*z5] ^ S8[*z4] ^ S6[*z6];
  5339.     sched->K[2].Km = S5[*zC] ^ S6[*zD] ^ S7[*z3] ^ S8[*z2] ^ S7[*z9];
  5340.     sched->K[3].Km = S5[*zE] ^ S6[*zF] ^ S7[*z1] ^ S8[*z0] ^ S8[*zC];
  5341.  
  5342.     X03 = Z8B ^ S5[*z5] ^ S6[*z7] ^ S7[*z4] ^ S8[*z6] ^ S7[*z0];
  5343.     X47 = Z03 ^ S5[*x0] ^ S6[*x2] ^ S7[*x1] ^ S8[*x3] ^ S8[*z2];
  5344.     X8B = Z47 ^ S5[*x7] ^ S6[*x6] ^ S7[*x5] ^ S8[*x4] ^ S5[*z1];
  5345.     XCF = ZCF ^ S5[*xA] ^ S6[*x9] ^ S7[*xB] ^ S8[*x8] ^ S6[*z3];
  5346.  
  5347.     sched->K[4].Km = S5[*x3] ^ S6[*x2] ^ S7[*xC] ^ S8[*xD] ^ S5[*x8];
  5348.     sched->K[5].Km = S5[*x1] ^ S6[*x0] ^ S7[*xE] ^ S8[*xF] ^ S6[*xD];
  5349.     sched->K[6].Km = S5[*x7] ^ S6[*x6] ^ S7[*x8] ^ S8[*x9] ^ S7[*x3];
  5350.     sched->K[7].Km = S5[*x5] ^ S6[*x4] ^ S7[*xA] ^ S8[*xB] ^ S8[*x7];
  5351.  
  5352.     Z03 = X03 ^ S5[*xD] ^ S6[*xF] ^ S7[*xC] ^ S8[*xE] ^ S7[*x8];
  5353.     Z47 = X8B ^ S5[*z0] ^ S6[*z2] ^ S7[*z1] ^ S8[*z3] ^ S8[*xA];
  5354.     Z8B = XCF ^ S5[*z7] ^ S6[*z6] ^ S7[*z5] ^ S8[*z4] ^ S5[*x9];
  5355.     ZCF = X47 ^ S5[*zA] ^ S6[*z9] ^ S7[*zB] ^ S8[*z8] ^ S6[*xB];
  5356.  
  5357.     sched->K[8].Km = S5[*z3] ^ S6[*z2] ^ S7[*zC] ^ S8[*zD] ^ S5[*z9];
  5358.     sched->K[9].Km = S5[*z1] ^ S6[*z0] ^ S7[*zE] ^ S8[*zF] ^ S6[*zC];
  5359.     sched->K[10].Km = S5[*z7] ^ S6[*z6] ^ S7[*z8] ^ S8[*z9] ^ S7[*z2];
  5360.     sched->K[11].Km = S5[*z5] ^ S6[*z4] ^ S7[*zA] ^ S8[*zB] ^ S8[*z6];
  5361.  
  5362.     X03 = Z8B ^ S5[*z5] ^ S6[*z7] ^ S7[*z4] ^ S8[*z6] ^ S7[*z0];
  5363.     X47 = Z03 ^ S5[*x0] ^ S6[*x2] ^ S7[*x1] ^ S8[*x3] ^ S8[*z2];
  5364.     X8B = Z47 ^ S5[*x7] ^ S6[*x6] ^ S7[*x5] ^ S8[*x4] ^ S5[*z1];
  5365.     XCF = ZCF ^ S5[*xA] ^ S6[*x9] ^ S7[*xB] ^ S8[*x8] ^ S6[*z3];
  5366.  
  5367.     sched->K[12].Km = S5[*x8] ^ S6[*x9] ^ S7[*x7] ^ S8[*x6] ^ S5[*x3];
  5368.     sched->K[13].Km = S5[*xA] ^ S6[*xB] ^ S7[*x5] ^ S8[*x4] ^ S6[*x7];
  5369.     sched->K[14].Km = S5[*xC] ^ S6[*xD] ^ S7[*x3] ^ S8[*x2] ^ S7[*x8];
  5370.     sched->K[15].Km = S5[*xE] ^ S6[*xF] ^ S7[*x1] ^ S8[*x0] ^ S8[*xD];
  5371.  
  5372.   /* Second half of key schedule - just like first half */
  5373.  
  5374.     Z03 = X03 ^ S5[*xD] ^ S6[*xF] ^ S7[*xC] ^ S8[*xE] ^ S7[*x8];
  5375.     Z47 = X8B ^ S5[*z0] ^ S6[*z2] ^ S7[*z1] ^ S8[*z3] ^ S8[*xA];
  5376.     Z8B = XCF ^ S5[*z7] ^ S6[*z6] ^ S7[*z5] ^ S8[*z4] ^ S5[*x9];
  5377.     ZCF = X47 ^ S5[*zA] ^ S6[*z9] ^ S7[*zB] ^ S8[*z8] ^ S6[*xB];
  5378.  
  5379.     sched->K[0].Kr = (S5[*z8] ^ S6[*z9] ^ S7[*z7] ^ S8[*z6] ^ S5[*z2]) & 0x1f;
  5380.     sched->K[1].Kr = (S5[*zA] ^ S6[*zB] ^ S7[*z5] ^ S8[*z4] ^ S6[*z6]) & 0x1f;
  5381.     sched->K[2].Kr = (S5[*zC] ^ S6[*zD] ^ S7[*z3] ^ S8[*z2] ^ S7[*z9]) & 0x1f;
  5382.     sched->K[3].Kr = (S5[*zE] ^ S6[*zF] ^ S7[*z1] ^ S8[*z0] ^ S8[*zC]) & 0x1f;
  5383.  
  5384.     X03 = Z8B ^ S5[*z5] ^ S6[*z7] ^ S7[*z4] ^ S8[*z6] ^ S7[*z0];
  5385.     X47 = Z03 ^ S5[*x0] ^ S6[*x2] ^ S7[*x1] ^ S8[*x3] ^ S8[*z2];
  5386.     X8B = Z47 ^ S5[*x7] ^ S6[*x6] ^ S7[*x5] ^ S8[*x4] ^ S5[*z1];
  5387.     XCF = ZCF ^ S5[*xA] ^ S6[*x9] ^ S7[*xB] ^ S8[*x8] ^ S6[*z3];
  5388.  
  5389.     sched->K[4].Kr = (S5[*x3] ^ S6[*x2] ^ S7[*xC] ^ S8[*xD] ^ S5[*x8]) & 0x1f;
  5390.     sched->K[5].Kr = (S5[*x1] ^ S6[*x0] ^ S7[*xE] ^ S8[*xF] ^ S6[*xD]) & 0x1f;
  5391.     sched->K[6].Kr = (S5[*x7] ^ S6[*x6] ^ S7[*x8] ^ S8[*x9] ^ S7[*x3]) & 0x1f;
  5392.     sched->K[7].Kr = (S5[*x5] ^ S6[*x4] ^ S7[*xA] ^ S8[*xB] ^ S8[*x7]) & 0x1f;
  5393.  
  5394.     Z03 = X03 ^ S5[*xD] ^ S6[*xF] ^ S7[*xC] ^ S8[*xE] ^ S7[*x8];
  5395.     Z47 = X8B ^ S5[*z0] ^ S6[*z2] ^ S7[*z1] ^ S8[*z3] ^ S8[*xA];
  5396.     Z8B = XCF ^ S5[*z7] ^ S6[*z6] ^ S7[*z5] ^ S8[*z4] ^ S5[*x9];
  5397.     ZCF = X47 ^ S5[*zA] ^ S6[*z9] ^ S7[*zB] ^ S8[*z8] ^ S6[*xB];
  5398.  
  5399.     sched->K[8].Kr = (S5[*z3] ^ S6[*z2] ^ S7[*zC] ^ S8[*zD] ^ S5[*z9]) & 0x1f;
  5400.     sched->K[9].Kr = (S5[*z1] ^ S6[*z0] ^ S7[*zE] ^ S8[*zF] ^ S6[*zC]) & 0x1f;
  5401.     sched->K[10].Kr = (S5[*z7] ^ S6[*z6] ^ S7[*z8] ^ S8[*z9] ^ S7[*z2]) & 0x1f;
  5402.     sched->K[11].Kr = (S5[*z5] ^ S6[*z4] ^ S7[*zA] ^ S8[*zB] ^ S8[*z6]) & 0x1f;
  5403.  
  5404.     X03 = Z8B ^ S5[*z5] ^ S6[*z7] ^ S7[*z4] ^ S8[*z6] ^ S7[*z0];
  5405.     X47 = Z03 ^ S5[*x0] ^ S6[*x2] ^ S7[*x1] ^ S8[*x3] ^ S8[*z2];
  5406.     X8B = Z47 ^ S5[*x7] ^ S6[*x6] ^ S7[*x5] ^ S8[*x4] ^ S5[*z1];
  5407.     XCF = ZCF ^ S5[*xA] ^ S6[*x9] ^ S7[*xB] ^ S8[*x8] ^ S6[*z3];
  5408.  
  5409.     sched->K[12].Kr = (S5[*x8] ^ S6[*x9] ^ S7[*x7] ^ S8[*x6] ^ S5[*x3]) & 0x1f;
  5410.     sched->K[13].Kr = (S5[*xA] ^ S6[*xB] ^ S7[*x5] ^ S8[*x4] ^ S6[*x7]) & 0x1f;
  5411.     sched->K[14].Kr = (S5[*xC] ^ S6[*xD] ^ S7[*x3] ^ S8[*x2] ^ S7[*x8]) & 0x1f;
  5412.     sched->K[15].Kr = (S5[*xE] ^ S6[*xF] ^ S7[*x1] ^ S8[*x0] ^ S8[*xD]) & 0x1f;
  5413. }
  5414.  
  5415. /* Initialize with a full-strength 128-bit key */
  5416.  
  5417. #ifndef CAST_EXPORT_ENCRYPTION
  5418. void
  5419. ck_cast128_key_sched(sched, key)
  5420.     CastKeySched * sched;
  5421.     uint8 * key;
  5422. {
  5423.     sched->ksize = 16;
  5424.     cast_key_sched(sched, key);
  5425. }
  5426. #endif
  5427.  
  5428. /* Handle reduced-keysize variants */
  5429.  
  5430. static void
  5431. cast5_key_sched(sched, key, sz)
  5432.     CastKeySched * sched;
  5433.     uint8 * key;
  5434.     int sz;
  5435. {
  5436.     uint8 buf[16];
  5437.  
  5438.     sched->ksize = sz;
  5439.     memset(buf, 0, sizeof(buf));
  5440.     memcpy(buf, key, sz);
  5441.     cast_key_sched(sched, buf);
  5442. }
  5443.  
  5444. /* 40, 64, and 80-bit keys - all use 12 rounds */
  5445.  
  5446. void
  5447. ck_cast5_40_key_sched(sched, key)
  5448.     CastKeySched * sched;
  5449.     uint8 * key;
  5450. {
  5451.     cast5_key_sched(sched, key, 5);
  5452. }
  5453.  
  5454. #ifndef CAST_EXPORT_ENCRYPTION
  5455. void
  5456. ck_cast5_64_key_sched(sched, key)
  5457.      CastKeySched * sched;
  5458.      uint8 * key;
  5459. {
  5460.     cast5_key_sched(sched, key, 8);
  5461. }
  5462.  
  5463. void
  5464. ck_cast5_80_key_sched(sched, key)
  5465.      CastKeySched * sched;
  5466.      uint8 * key;
  5467. {
  5468.     cast5_key_sched(sched, key, 10);
  5469. }
  5470. #endif /* CAST_EXPORT_ENCRYPTION */
  5471. #endif /* CK_CAST */
  5472.  
  5473. #ifdef CRYPT_DLL
  5474. static char *
  5475. ck_crypt_dll_version()
  5476. {
  5477.     return(ckcrpv);
  5478. }
  5479.  
  5480. int
  5481. crypt_dll_init( struct _crypt_dll_init * init )
  5482. {
  5483. #ifdef LIBDES
  5484.     extern int des_check_key;
  5485.     extern void libdes_dll_init(struct _crypt_dll_init *);
  5486.     des_check_key = 1;
  5487. #endif /* LIBDES */
  5488.  
  5489.     if ( init->version >= 1 ) {
  5490.         p_ttol = init->p_ttol;
  5491.         p_dodebug = init->p_dodebug;
  5492.         p_dohexdump = init->p_dohexdump;
  5493.         p_tn_debug = init->p_tn_debug;
  5494.         p_vscrnprintf = init->p_vscrnprintf;
  5495.         if ( init->version == 1 )
  5496.             return(1);
  5497.     }
  5498.     if ( init->version >= 2 ) {
  5499.         /* This is a k5_context but we don't want to include krb5.h */
  5500.         p_k5_context = (void *) init->p_k5_context;
  5501.         if ( init->version == 2 )
  5502.             return(1);
  5503.     }
  5504.     if ( init->version >= 3 ) {
  5505.         init->p_install_funcs("encrypt_parse",encrypt_parse);
  5506.         init->p_install_funcs("encrypt_init",encrypt_init);
  5507.         init->p_install_funcs("encrypt_session_key",encrypt_session_key);
  5508.         init->p_install_funcs("encrypt_send_request_start",
  5509.                               encrypt_send_request_start
  5510.                               );
  5511.         init->p_install_funcs("encrypt_request_start",encrypt_request_start);
  5512.         init->p_install_funcs("encrypt_send_request_end",
  5513.                               encrypt_send_request_end
  5514.                               );
  5515.         init->p_install_funcs("encrypt_request_end",encrypt_request_end);
  5516.         init->p_install_funcs("encrypt_send_end",encrypt_send_end);
  5517.         init->p_install_funcs("encrypt_send_support",encrypt_send_support);
  5518.         init->p_install_funcs("encrypt_is_encrypting",encrypt_is_encrypting);
  5519.         init->p_install_funcs("encrypt_is_decrypting",encrypt_is_decrypting);
  5520.         init->p_install_funcs("get_crypt_table",get_crypt_table);
  5521.         init->p_install_funcs("des_is_weak_key",ck_des_is_weak_key);
  5522.         libdes_dll_init(init);
  5523.         if (init->version == 3)
  5524.           return(1);
  5525.     }
  5526.     if ( init->version >= 4 ) {
  5527.         init->p_install_funcs("crypt_dll_version",ck_crypt_dll_version);
  5528.         if (init->version == 4)
  5529.           return(1);
  5530.     }
  5531.  
  5532.     if ( init->version >= 5 ) {
  5533.         p_reqtelmutex = init->p_reqtelmutex;
  5534.         p_reltelmutex = init->p_reltelmutex;
  5535.         if (init->version == 5)
  5536.           return(1);
  5537.     }
  5538.  
  5539.     if ( init->version >= 6 ) {
  5540.         init->p_install_funcs("encrypt_dont_support",encrypt_dont_support);
  5541.         if ( init->version == 6 )
  5542.             return(1);
  5543.         /* when adding new versions; migrate the next two lines */
  5544.         init->version = 6;
  5545.         return(1);
  5546.     }
  5547.     return(0);
  5548. }
  5549.  
  5550. #undef malloc
  5551. #undef realloc
  5552. #undef free
  5553. #undef strdup
  5554.  
  5555. static void
  5556. fatal(char *msg) {
  5557.     if (!msg) msg = "";
  5558.  
  5559.     printf(msg);
  5560.     exit(1);        /* Exit indicating failure */
  5561. }
  5562.  
  5563. void *
  5564. kmalloc(size_t size)
  5565. {
  5566.     void *ptr;
  5567.  
  5568.     if (size == 0) {
  5569.         fatal("kmalloc: zero size");
  5570.     }
  5571.     ptr = malloc(size);
  5572.     if (ptr == NULL) {
  5573.         fatal("kmalloc: out of memory");
  5574.     }
  5575.     return ptr;
  5576. }
  5577.  
  5578. void *
  5579. krealloc(void *ptr, size_t new_size)
  5580. {
  5581.     void *new_ptr;
  5582.  
  5583.     if (new_size == 0) {
  5584.         fatal("krealloc: zero size");
  5585.     }
  5586.     if (ptr == NULL)
  5587.         new_ptr = malloc(new_size);
  5588.     else
  5589.         new_ptr = realloc(ptr, new_size);
  5590.     if (new_ptr == NULL) {
  5591.         fatal("krealloc: out of memory");
  5592.     }
  5593.     return new_ptr;
  5594. }
  5595.  
  5596. void
  5597. kfree(void *ptr)
  5598. {
  5599.     if (ptr == NULL) {
  5600.         printf("kfree: NULL pointer given as argument");
  5601.         return;
  5602.     }
  5603.     free(ptr);
  5604. }
  5605.  
  5606. char *
  5607. kstrdup(const char *str)
  5608. {
  5609.     size_t len;
  5610.     char *cp;
  5611.  
  5612.     if (str == NULL) {
  5613.         fatal("kstrdup: NULL pointer given as argument");
  5614.     }
  5615.     len = strlen(str) + 1;
  5616.     cp = kmalloc(len);
  5617.     if (cp)
  5618.         memcpy(cp, str, len);
  5619.     return cp;
  5620. }
  5621. #endif /* CRYPT_DLL */
  5622. #endif /* CK_ENCRYPTION */
  5623.