rlogin.tproj/des_rw.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23 /*-
  24  * Copyright (c) 1989, 1993
  25  *      The Regents of the University of California.  All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. All advertising materials mentioning features or use of this software
  36  *    must display the following acknowledgement:
  37  *      This product includes software developed by the University of
  38  *      California, Berkeley and its contributors.
  39  * 4. Neither the name of the University nor the names of its contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  */
  55
  56 #ifndef lint
  57 static char sccsid[] = "@(#)des_rw.c    8.1 (Berkeley) 6/6/93";
  58 #endif /* not lint */
  59
  60 #ifdef CRYPT
  61 #ifdef KERBEROS
  62 #include <sys/param.h>
  63
  64 #include <kerberosIV/des.h>
  65 #include <kerberosIV/krb.h>
  66
  67 #include <stdlib.h>
  68 #include <string.h>
  69 #include <time.h>
  70 #include <unistd.h>
  71
  72 static unsigned char    des_inbuf[10240], storage[10240], *store_ptr;
  73 static bit_64           *key;
  74 static u_char           *key_schedule;
  75
  76 /* XXX these should be in a kerberos include file */
  77 int     krb_net_read __P((int, char *, int));
  78 #ifdef notdef
  79 /* XXX too hard to make this work */
  80 int     des_pcbc_encrypt __P((des_cblock *, des_cblock *, long,
  81             des_key_schedule, des_cblock *, int));
  82 #endif
  83
  84 /*
  85  * NB: These routines will not function properly if NBIO
  86  *      is set
  87  */
  88
  89 /*
  90  * des_set_key
  91  *
  92  * Set des encryption/decryption key for use by the des_read and
  93  * des_write routines
  94  *
  95  * The inkey parameter is actually the DES initial vector,
  96  * and the insched is the DES Key unwrapped for faster decryption
  97  */
  98
  99 void
 100 des_set_key(inkey, insched)
 101         bit_64          *inkey;
 102         u_char          *insched;
 103 {
 104         key = inkey;
 105         key_schedule = insched;
 106 }
 107
 108 void
 109 des_clear_key()
 110 {
 111         bzero((char *) key, sizeof(C_Block));
 112         bzero((char *) key_schedule, sizeof(Key_schedule));
 113 }
 114
 115
 116 int
 117 des_read(fd, buf, len)
 118         int fd;
 119         register char *buf;
 120         int len;
 121 {
 122         int nreturned = 0;
 123         long net_len, rd_len;
 124         int nstored = 0;
 125
 126         if (nstored >= len) {
 127                 (void) bcopy(store_ptr, buf, len);
 128                 store_ptr += len;
 129                 nstored -= len;
 130                 return(len);
 131         } else if (nstored) {
 132                 (void) bcopy(store_ptr, buf, nstored);
 133                 nreturned += nstored;
 134                 buf += nstored;
 135                 len -= nstored;
 136                 nstored = 0;
 137         }
 138
 139         if (krb_net_read(fd, (char *)&net_len, sizeof(net_len)) !=
 140             sizeof(net_len)) {
 141                 /* XXX can't read enough, pipe
 142                    must have closed */
 143                 return(0);
 144         }
 145         net_len = ntohl(net_len);
 146         if (net_len <= 0 || net_len > sizeof(des_inbuf)) {
 147                 /* preposterous length; assume out-of-sync; only
 148                    recourse is to close connection, so return 0 */
 149                 return(0);
 150         }
 151         /* the writer tells us how much real data we are getting, but
 152            we need to read the pad bytes (8-byte boundary) */
 153         rd_len = roundup(net_len, 8);
 154         if (krb_net_read(fd, (char *)des_inbuf, rd_len) != rd_len) {
 155                 /* pipe must have closed, return 0 */
 156                 return(0);
 157         }
 158         (void) des_pcbc_encrypt(des_inbuf,      /* inbuf */
 159                             storage,            /* outbuf */
 160                             net_len,            /* length */
 161                             key_schedule,       /* DES key */
 162                             key,                /* IV */
 163                             DECRYPT);           /* direction */
 164
 165         if(net_len < 8)
 166                 store_ptr = storage + 8 - net_len;
 167         else
 168                 store_ptr = storage;
 169
 170         nstored = net_len;
 171         if (nstored > len) {
 172                 (void) bcopy(store_ptr, buf, len);
 173                 nreturned += len;
 174                 store_ptr += len;
 175                 nstored -= len;
 176         } else {
 177                 (void) bcopy(store_ptr, buf, nstored);
 178                 nreturned += nstored;
 179                 nstored = 0;
 180         }
 181
 182         return(nreturned);
 183 }
 184
 185 static  unsigned char des_outbuf[10240];        /* > longest write */
 186
 187 int
 188 des_write(fd, buf, len)
 189         int fd;
 190         char *buf;
 191         int len;
 192 {
 193         static  int     seeded = 0;
 194         static  char    garbage_buf[8];
 195         long net_len, garbage;
 196
 197         if(len < 8) {
 198                 if(!seeded) {
 199                         seeded = 1;
 200                         srandom((int) time((long *)0));
 201                 }
 202                 garbage = random();
 203                 /* insert random garbage */
 204                 (void) bcopy(&garbage, garbage_buf, MIN(sizeof(long),8));
 205                 /* this "right-justifies" the data in the buffer */
 206                 (void) bcopy(buf, garbage_buf + 8 - len, len);
 207         }
 208         /* pcbc_encrypt outputs in 8-byte (64 bit) increments */
 209
 210         (void) des_pcbc_encrypt((len < 8) ? garbage_buf : buf,
 211                             des_outbuf,
 212                             (len < 8) ? 8 : len,
 213                             key_schedule,       /* DES key */
 214                             key,                /* IV */
 215                             ENCRYPT);
 216
 217         /* tell the other end the real amount, but send an 8-byte padded
 218            packet */
 219         net_len = htonl(len);
 220         (void) write(fd, &net_len, sizeof(net_len));
 221         (void) write(fd, des_outbuf, roundup(len,8));
 222         return(len);
 223 }
 224 #endif /* KERBEROS */
 225 #endif /* CRYPT */