rlogin.tproj/des_rw.c

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