home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / N / TCPIP / NETKIT-B.05 / NETKIT-B / NetKit-B-0.05 / libtelnet / krb_des.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-17  |  13.6 KB  |  559 lines
  1. /*-
  2.  * Copyright (c) 1991 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. /*static char sccsid[] = "from: @(#)krb_des.c    5.1 (Berkeley) 2/28/91";*/
  36. static char rcsid[] = "$Id: krb_des.c,v 1.2 1993/08/01 18:32:31 mycroft Exp $";
  37. #endif /* not lint */
  38.  
  39. /*
  40.  * Copyright (C) 1990 by the Massachusetts Institute of Technology
  41.  *
  42.  * Export of this software from the United States of America is assumed
  43.  * to require a specific license from the United States Government.
  44.  * It is the responsibility of any person or organization contemplating
  45.  * export to obtain such a license before exporting.
  46.  *
  47.  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  48.  * distribute this software and its documentation for any purpose and
  49.  * without fee is hereby granted, provided that the above copyright
  50.  * notice appear in all copies and that both that copyright notice and
  51.  * this permission notice appear in supporting documentation, and that
  52.  * the name of M.I.T. not be used in advertising or publicity pertaining
  53.  * to distribution of the software without specific, written prior
  54.  * permission.  M.I.T. makes no representations about the suitability of
  55.  * this software for any purpose.  It is provided "as is" without express
  56.  * or implied warranty.
  57.  */
  58.  
  59. #if    defined(AUTHENTICATE) && defined(ENCRYPT) && defined(KRBDES_ENCRYPT)
  60. #include <arpa/telnet.h>
  61. #include <stdio.h>
  62. #ifdef    __STDC__
  63. #include <stdlib.h>
  64. #endif
  65.  
  66. #include "encrypt.h"
  67. #include "key-proto.h"
  68. #include "misc-proto.h"
  69.  
  70. extern encrypt_debug_mode;
  71.  
  72. static Block krbdes_key = { 0 };
  73. static Schedule krbdes_sched = { 0 };
  74. static Block input_feed = { 0 };
  75. static Block output_feed = { 0 };
  76. static Block temp_feed = { 0 };
  77.  
  78. static unsigned char str_feed[64] = { IAC, SB, TELOPT_ENCRYPT,
  79.                       ENCRYPT_IS,
  80.                       ENCTYPE_KRBDES, };
  81.  
  82.     void
  83. krbdes_init(server)
  84.     int server;
  85. {
  86.     bzero((void *)krbdes_key, sizeof(Block));
  87.     bzero((void *)krbdes_sched, sizeof(Schedule));
  88.     bzero((void *)input_feed, sizeof(Block));
  89.     bzero((void *)output_feed, sizeof(Block));
  90. }
  91.  
  92. #define    KRBDES_FEED_INIT    1
  93. #define    KRBDES_FEED_VRFY    2
  94. #define    KRBDES_FEED_FAIL    3
  95. #define    KRBDES_FEED_OK        4
  96. #define    KRBDES_FEED_VRFY_FAIL    5
  97.  
  98. /*
  99.  * Returns:
  100.  *    -1: some error.  Negotiation is done, encryption not ready.
  101.  *     0: Successful, initial negotiation all done.
  102.  *     1: successful, negotiation not done yet.
  103.  *     2: Not yet.  Other things (like getting the key from
  104.  *        Kerberos) have to happen before we can continue.
  105.  */
  106.  
  107.  
  108. #define    NOT_YET        2
  109. #define    IN_PROGRESS    1
  110. #define    SUCCESS        0
  111. #define    FAILED        -1
  112.  
  113. int state[2] = { NOT_YET, NOT_YET };
  114. #define    ENCRYPT_STATE 0
  115. #define    DECRYPT_STATE 1
  116.  
  117. /*
  118.  * This is where we keep track of the fact that there has been a
  119.  * call to krbdes_start(), but we haven't gotten a valid key from
  120.  * kerberos, so that when (if) it does come in, we can continue with
  121.  * the initial encryption startup.
  122.  */
  123. static int need_start;
  124.  
  125.     int
  126. krbdes_start(dir, server)
  127.     int dir;
  128.     int server;
  129. { 
  130.     Block b;
  131.     int x;
  132.     unsigned char *p;
  133.  
  134.     switch (dir) {
  135.     case DIR_DECRYPT:
  136.         /*
  137.          * This is simply a request to have the other side
  138.          * start output (our input).  He will negotiate a
  139.          * feed so we need not look for it.
  140.          */
  141.         if (!VALIDKEY(krbdes_key))
  142.             return(state[DECRYPT_STATE]);
  143.         if (state[DECRYPT_STATE] == NOT_YET)
  144.             state[DECRYPT_STATE] = IN_PROGRESS;
  145.         return(state[DECRYPT_STATE]);
  146.  
  147.     case DIR_ENCRYPT:
  148.         if (!VALIDKEY(krbdes_key)) {
  149.             need_start = 1;
  150.             return(state[ENCRYPT_STATE]);
  151.         }
  152.         if (state[ENCRYPT_STATE] == IN_PROGRESS)
  153.             return(IN_PROGRESS);
  154.         if (VALIDKEY(output_feed))
  155.             return(SUCCESS);
  156.         if (encrypt_debug_mode)
  157.             printf("Creating new feed\r\n");
  158.         /*
  159.          * Create a random feed and send it over encrypted.
  160.          * The other side will decrypt it, xor in 'KRBDES'
  161.          * and then recrypt it and send it back.
  162.          */
  163.         des_new_random_key(temp_feed);
  164.         des_ecb_encrypt(temp_feed, b, krbdes_sched, 1);
  165.         str_feed[3] = ENCRYPT_IS;
  166.         p = str_feed + 5;
  167.         *p++ = KRBDES_FEED_INIT;
  168.         for (x = 0; x < sizeof(Block); ++x) {
  169.             if ((*p++ = b[x]) == IAC)
  170.                 *p++ = IAC;
  171.         }
  172.         *p++ = IAC;
  173.         *p++ = SE;
  174.         printsub('>', &str_feed[2], p - &str_feed[2]);
  175.         net_write(str_feed, p - str_feed);
  176.         temp_feed[0] ^= 'K';
  177.         temp_feed[1] ^= 'R';
  178.         temp_feed[2] ^= 'B';
  179.         temp_feed[3] ^= 'D';
  180.         temp_feed[4] ^= 'E';
  181.         temp_feed[5] ^= 'S';
  182.         state[ENCRYPT_STATE] = IN_PROGRESS;
  183.         return(IN_PROGRESS);
  184.     default:
  185.         return(FAILED);
  186.     }
  187. }
  188.  
  189. /*
  190.  * Returns:
  191.  *    -1: some error.  Negotiation is done, encryption not ready.
  192.  *     0: Successful, initial negotiation all done.
  193.  *     1: successful, negotiation not done yet.
  194.  */
  195.  
  196.     int
  197. krbdes_is(data, cnt)
  198.     unsigned char *data;
  199.     int cnt;
  200. {
  201.     int x;
  202.     unsigned char *p;
  203.     unsigned char *why = 0;
  204.     Block b;
  205.  
  206.     if (cnt-- < 1) {
  207.         why = (unsigned char *)"Bad IS suboption";
  208.         goto failure;
  209.     }
  210.  
  211.     switch (*data++) {
  212.     case KRBDES_FEED_INIT:
  213.         if (cnt != sizeof(Block)) {
  214.             if (encrypt_debug_mode)
  215.                 printf("Use Feed failed on size\r\n");
  216.             why = (unsigned char *)"Bad block size";
  217.             goto failure;
  218.         }
  219.         if (!VALIDKEY(krbdes_key)) {
  220.             if (encrypt_debug_mode)
  221.                 printf("Use Feed failed on key\r\n");
  222.             why = (unsigned char *)"Invalid key";
  223.             goto failure;
  224.         }
  225.         if (encrypt_debug_mode)
  226.             printf("Have a Use Feed\r\n");
  227.  
  228.         bcopy((void *)data, (void *)b, sizeof(Block));
  229.         des_ecb_encrypt(b, input_feed, krbdes_sched, 0);
  230.  
  231.         input_feed[0] ^= 'K';
  232.         input_feed[1] ^= 'R';
  233.         input_feed[2] ^= 'B';
  234.         input_feed[3] ^= 'D';
  235.         input_feed[4] ^= 'E';
  236.         input_feed[5] ^= 'S';
  237.  
  238.         des_ecb_encrypt(input_feed, b, krbdes_sched, 1);
  239.         str_feed[3] = ENCRYPT_REPLY;
  240.         p = str_feed + 5;
  241.         *p++ = KRBDES_FEED_VRFY;
  242.         for (x = 0; x < sizeof(Block); ++x) {
  243.             if ((*p++ = b[x]) == IAC)
  244.                 *p++ = IAC;
  245.         }
  246.         *p++ = IAC;
  247.         *p++ = SE;
  248.         printsub('>', &str_feed[2], p - &str_feed[2]);
  249.         net_write(str_feed, p - str_feed);
  250.         if (encrypt_debug_mode)
  251.             printf("Initializing Decrypt stream\r\n");
  252.         key_stream_init(krbdes_key, input_feed, DIR_DECRYPT);
  253.         state[DECRYPT_STATE] = IN_PROGRESS;
  254.         return(IN_PROGRESS);
  255.  
  256.     case KRBDES_FEED_OK:
  257.         state[DECRYPT_STATE] = SUCCESS;
  258.         return(SUCCESS);
  259.  
  260.     case KRBDES_FEED_FAIL:
  261.         state[DECRYPT_STATE] = FAILED;
  262.         return(FAILED);
  263.  
  264.     default:
  265.         if (encrypt_debug_mode) {
  266.             printf("Unknown option type: %d\r\n", data[-1]);
  267.             printd(data, cnt);
  268.             printf("\r\n");
  269.         }
  270.         why = (unsigned char *)"Unknown sub-suboption";
  271.     failure:
  272.         /*
  273.          * We failed.  Send an empty KRBDES_FEED_VRFY option
  274.          * to the other side so it will know that things
  275.          * failed.
  276.          */
  277.         str_feed[3] = ENCRYPT_REPLY;
  278.         p = str_feed + 5;
  279.         *p++ = KRBDES_FEED_VRFY_FAIL;
  280.         if (why) {
  281.             while (*why) {
  282.                 if ((*p++ = *why++) == IAC)
  283.                     *p++ = IAC;
  284.             }
  285.         }
  286.         *p++ = IAC;
  287.         *p++ = SE;
  288.         printsub('>', &str_feed[2], p - &str_feed[2]);
  289.         net_write(str_feed, p - str_feed);
  290.         state[DECRYPT_STATE] = FAILED;
  291.         return(FAILED);
  292.     }
  293. }
  294.  
  295. /*
  296.  * Returns:
  297.  *    -1: some error.  Negotiation is done, encryption not ready.
  298.  *     0: Successful, initial negotiation all done.
  299.  *     1: successful, negotiation not done yet.
  300.  */
  301.  
  302.     int
  303. krbdes_reply(data, cnt)
  304.     unsigned char *data;
  305.     int cnt;
  306. {
  307.     int x;
  308.     unsigned char *p;
  309.     unsigned char *why = 0;
  310.     Block b;
  311.  
  312.     if (cnt-- < 1) {
  313.         why = (unsigned char *)"Bad REPLY suboption";
  314.         goto failure;
  315.     }
  316.  
  317.     switch (*data++) {
  318.     case KRBDES_FEED_VRFY:
  319.         if (cnt != sizeof(Block)) {
  320.             if (encrypt_debug_mode)
  321.                 printf("Have Feed failed on size\r\n");
  322.             why = (unsigned char *)"Bad block size";
  323.             goto failure;
  324.         }
  325.         if (!VALIDKEY(krbdes_key)) {
  326.             if (encrypt_debug_mode)
  327.                 printf("Have Feed failed on key\r\n");
  328.             why = (unsigned char *)"Invalid key";
  329.             goto failure;
  330.         }
  331.         if (encrypt_debug_mode)
  332.             printf("Have a Test Feed\r\n");
  333.  
  334.         bcopy((void *)data, (void *)b, sizeof(Block));
  335.         des_ecb_encrypt(b, output_feed, krbdes_sched, 0);
  336.         if (!SAMEKEY(output_feed, temp_feed)) {
  337.             if (encrypt_debug_mode)
  338.                 printf("Have Feed failed on challange\r\n");
  339.             bzero((void *)output_feed, sizeof(Block));
  340.             why = (unsigned char*)"Challange decrypt failed";
  341.             goto failure;
  342.         }
  343.         if (encrypt_debug_mode)
  344.             printf("Initializing Encrypt stream\r\n");
  345.         key_stream_init(krbdes_key, output_feed, DIR_ENCRYPT);
  346.  
  347.         str_feed[3] = ENCRYPT_IS;
  348.         p = str_feed + 5;
  349.         *p++ = KRBDES_FEED_OK;
  350.         *p++ = IAC;
  351.         *p++ = SE;
  352.         printsub('>', &str_feed[2], p - &str_feed[2]);
  353.         net_write(str_feed, p - str_feed);
  354.         state[ENCRYPT_STATE] = SUCCESS;
  355.         return(SUCCESS);
  356.  
  357.     default:
  358.         if (encrypt_debug_mode) {
  359.             printf("Unknown option type: %d\r\n", data[-1]);
  360.             printd(data, cnt);
  361.             printf("\r\n");
  362.         }
  363.         why = (unsigned char *)"Unknown sub-suboption";
  364.     failure:
  365.         str_feed[3] = ENCRYPT_IS;
  366.         p = str_feed + 5;
  367.         *p++ = KRBDES_FEED_FAIL;
  368.         if (why) {
  369.             while (*why) {
  370.                 if ((*p++ = *why++) == IAC)
  371.                     *p++ = IAC;
  372.             }
  373.         }
  374.         *p++ = IAC;
  375.         *p++ = SE;
  376.         printsub('>', &str_feed[2], p - &str_feed[2]);
  377.         net_write(str_feed, p - str_feed);
  378.         state[ENCRYPT_STATE] = FAILED;
  379.         return(FAILED);
  380.     }
  381. }
  382.  
  383.     void
  384. krbdes_encrypt(s, c)
  385.     unsigned char *s;
  386.     int c;
  387. {
  388.     while (c-- > 0) {
  389.         *s = key_stream(DIR_ENCRYPT, *s);
  390.         ++s;
  391.     }
  392. }
  393.  
  394.     int
  395. krbdes_decrypt(c)
  396.     int c;
  397. {
  398.     return(key_stream(DIR_DECRYPT, c));
  399. #ifdef    ndef
  400.  
  401.     if (c == -1) {
  402.         ++use;
  403.         return(0);
  404.     }
  405.     if (use) {
  406.         use = 0;
  407.     } else {
  408.         last = key_stream(DIR_DECRYPT, c);
  409.     }
  410.  
  411.     return(last ^ c);
  412. #endif
  413. }
  414.  
  415.     void
  416. krbdes_session(key, server)
  417.     Session_Key *key;
  418.     int server;
  419. {
  420.     static once = 1;
  421.  
  422.     if (!key || key->type != SK_DES) {
  423.         if (encrypt_debug_mode)
  424.             printf("Can't set krbdes's session key (%d != %d)\r\n",
  425.                 key ? key->type : -1, SK_DES);
  426.         return;
  427.     }
  428.     bcopy((void *)key->data, (void *)krbdes_key, sizeof(Block));
  429.     if (once) {
  430.         des_set_random_generator_seed(krbdes_key);
  431.         once = 0;
  432.     }
  433.     des_key_sched(krbdes_key, krbdes_sched);
  434.     /*
  435.      * Now look to see if krbdes_start() was was waiting for
  436.      * the key to show up.  If so, go ahead an call it now
  437.      * that we have the key.
  438.      */
  439.     if (need_start) {
  440.         krbdes_start(DIR_ENCRYPT, server);
  441.         need_start = 0;
  442.     }
  443. }
  444.  
  445.     void
  446. krbdes_printsub(data, cnt, buf, buflen)
  447.     unsigned char *data, *buf;
  448.     int cnt, buflen;
  449. {
  450.     char lbuf[32];
  451.     register int i;
  452.     char *cp;
  453.  
  454.     buf[buflen-1] = '\0';        /* make sure it's NULL terminated */
  455.     buflen -= 1;
  456.  
  457.     switch(data[2]) {
  458.     case KRBDES_FEED_OK:
  459.         cp = "FEED_OK";
  460.         goto common1;
  461.     case KRBDES_FEED_FAIL:
  462.         cp = "FEED_FAIL";
  463.     common1:
  464.         for (; (buflen > 0) && (*buf = *cp++); buf++)
  465.             buflen--;
  466.         if (cnt > 3) {
  467.             if (buflen <= 0)
  468.                 break;
  469.             *buf++ = ' ';
  470.             if (--buflen <= 0)
  471.                 break;
  472.             *buf++ = '"';
  473.             for (i = 3; i < cnt && buflen > 0; i++, buflen--)
  474.                 *buf++ = data[i];
  475.             if (buflen <= 0)
  476.                 break;
  477.             *buf++ = '"';
  478.             --buflen;
  479.         }
  480.         if (buflen <= 0)
  481.             break;
  482.         *buf++ = '\0';
  483.         break;
  484.         
  485.     case KRBDES_FEED_INIT:
  486.         cp = "FEED_INIT ";
  487.         goto common2;
  488.  
  489.     case KRBDES_FEED_VRFY:
  490.         cp = "FEED_VRFY ";
  491.         goto common2;
  492.  
  493.     default:
  494.         sprintf(lbuf, " %d (unknown)", data[2]);
  495.         cp = lbuf;
  496.     common2:
  497.         for (; (buflen > 0) && (*buf = *cp++); buf++)
  498.             buflen--;
  499.         for (i = 3; i < cnt; i++) {
  500.             sprintf(lbuf, " %d", data[i]);
  501.             for (cp = lbuf; (buflen > 0) && (*buf = *cp++); buf++)
  502.                 buflen--;
  503.         }
  504.         break;
  505.     }
  506. }
  507.  
  508. static    Block stream_output[2];
  509. static    Block stream_feed[2];
  510. static    Schedule stream_sched[2];
  511. static    int stream_index[2];
  512.  
  513.     void
  514. key_stream_init(key, seed, dir)
  515.     Block key;
  516.     Block seed;
  517.     int dir;
  518. {
  519.     des_key_sched(key, stream_sched[--dir]);
  520.     bcopy((void *)seed, (void *)stream_output[dir], sizeof(Block));
  521.     stream_index[dir] = sizeof(Block);
  522. }
  523.  
  524.     unsigned char
  525. key_stream(dir, data)
  526.     int dir;
  527.     int data;    /* data de/encrypting */
  528. {
  529.     int index;
  530.  
  531.     if (data == -1) {
  532.         /* Backpeddle */
  533.         if (stream_index[--dir])
  534.             --stream_index[dir];
  535.         return(0);
  536.     }
  537.     if ((index = stream_index[--dir]++) == sizeof(Block)) {
  538.         Block b;
  539.         des_ecb_encrypt(stream_output[dir],
  540.                 b,
  541.                 stream_sched[dir], 1);
  542.         bcopy((void *)b, (void *)stream_feed[dir], sizeof(Block));
  543.         stream_index[dir] = 1;    /* Next time will be 1 */
  544.         index = 0;        /* But now use 0 */
  545.     }
  546.  
  547.     /*
  548.      * On encryption, we store (feed ^ data) which is cypher
  549.      * On decryption we store (data) which is cypher
  550.      */
  551.     if (dir == DIR_DECRYPT)
  552.         return(stream_output[dir][index] =
  553.                 (stream_feed[dir][index] ^ data));
  554.     else
  555.         return((stream_output[dir][index] = data) ^
  556.                   stream_feed[dir][index]);
  557. }
  558. #endif
  559.