bsd/crypto/des/des_ecb.c

   1 /*      $FreeBSD: src/sys/crypto/des/des_ecb.c,v 1.1.2.2 2001/07/03 11:01:31 ume Exp $  */
   2 /*      $KAME: des_ecb.c,v 1.5 2000/11/06 13:58:08 itojun Exp $ */
   3
   4 /* crypto/des/ecb_enc.c */
   5 /* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
   6  * All rights reserved.
   7  *
   8  * This file is part of an SSL implementation written
   9  * by Eric Young (eay@mincom.oz.au).
  10  * The implementation was written so as to conform with Netscapes SSL
  11  * specification.  This library and applications are
  12  * FREE FOR COMMERCIAL AND NON-COMMERCIAL USE
  13  * as long as the following conditions are aheared to.
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.  If this code is used in a product,
  17  * Eric Young should be given attribution as the author of the parts used.
  18  * This can be in the form of a textual message at program startup or
  19  * in documentation (online or textual) provided with the package.
  20  *
  21  * Redistribution and use in source and binary forms, with or without
  22  * modification, are permitted provided that the following conditions
  23  * are met:
  24  * 1. Redistributions of source code must retain the copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  * 2. Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in the
  28  *    documentation and/or other materials provided with the distribution.
  29  * 3. All advertising materials mentioning features or use of this software
  30  *    must display the following acknowledgement:
  31  *    This product includes software developed by Eric Young (eay@mincom.oz.au)
  32  *
  33  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  34  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  35  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  36  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  37  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  38  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  39  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  41  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  42  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  43  * SUCH DAMAGE.
  44  *
  45  * The licence and distribution terms for any publically available version or
  46  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  47  * copied and put under another distribution licence
  48  * [including the GNU Public Licence.]
  49  */
  50
  51 #include <sys/param.h>
  52 #include <sys/systm.h>
  53 #include <crypto/des/des_locl.h>
  54 #include <crypto/des/spr.h>
  55
  56 char *libdes_version="libdes v 3.24 - 20-Apr-1996 - eay";
  57 char *DES_version="DES part of SSLeay 0.6.4 30-Aug-1996";
  58
  59 char *des_options()
  60         {
  61 #ifdef DES_PTR
  62         if (sizeof(DES_LONG) != sizeof(long))
  63                 return("des(ptr,int)");
  64         else
  65                 return("des(ptr,long)");
  66 #else
  67         if (sizeof(DES_LONG) != sizeof(long))
  68                 return("des(idx,int)");
  69         else
  70                 return("des(idx,long)");
  71 #endif
  72         }
  73
  74
  75 void des_ecb_encrypt(input, output, ks, encrypt)
  76 des_cblock (*input);
  77 des_cblock (*output);
  78 des_key_schedule ks;
  79 int encrypt;
  80         {
  81         register DES_LONG l;
  82         register unsigned char *in,*out;
  83         DES_LONG ll[2];
  84
  85         in=(unsigned char *)input;
  86         out=(unsigned char *)output;
  87         c2l(in,l); ll[0]=l;
  88         c2l(in,l); ll[1]=l;
  89         des_encrypt(ll,ks,encrypt);
  90         l=ll[0]; l2c(l,out);
  91         l=ll[1]; l2c(l,out);
  92         l=ll[0]=ll[1]=0;
  93         }
  94
  95 void des_encrypt(data, ks, encrypt)
  96 DES_LONG *data;
  97 des_key_schedule ks;
  98 int encrypt;
  99         {
 100         register DES_LONG l,r,t,u;
 101 #ifdef DES_PTR
 102         register unsigned char *des_SP=(unsigned char *)des_SPtrans;
 103 #endif
 104 #ifdef undef
 105         union fudge {
 106                 DES_LONG  l;
 107                 unsigned short s[2];
 108                 unsigned char  c[4];
 109                 } U,T;
 110 #endif
 111         register int i;
 112         register DES_LONG *s;
 113
 114         u=data[0];
 115         r=data[1];
 116
 117         IP(u,r);
 118         /* Things have been modified so that the initial rotate is
 119          * done outside the loop.  This required the
 120          * des_SPtrans values in sp.h to be rotated 1 bit to the right.
 121          * One perl script later and things have a 5% speed up on a sparc2.
 122          * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
 123          * for pointing this out. */
 124         l=(r<<1)|(r>>31);
 125         r=(u<<1)|(u>>31);
 126
 127         /* clear the top bits on machines with 8byte longs */
 128         l&=0xffffffffL;
 129         r&=0xffffffffL;
 130
 131         s=(DES_LONG *)ks;
 132         /* I don't know if it is worth the effort of loop unrolling the
 133          * inner loop
 134          */
 135         if (encrypt)
 136                 {
 137                 for (i=0; i<32; i+=8)
 138                         {
 139                         D_ENCRYPT(l,r,i+0); /*  1 */
 140                         D_ENCRYPT(r,l,i+2); /*  2 */
 141                         D_ENCRYPT(l,r,i+4); /*  3 */
 142                         D_ENCRYPT(r,l,i+6); /*  4 */
 143                         }
 144                 }
 145         else
 146                 {
 147                 for (i=30; i>0; i-=8)
 148                         {
 149                         D_ENCRYPT(l,r,i-0); /* 16 */
 150                         D_ENCRYPT(r,l,i-2); /* 15 */
 151                         D_ENCRYPT(l,r,i-4); /* 14 */
 152                         D_ENCRYPT(r,l,i-6); /* 13 */
 153                         }
 154                 }
 155         l=(l>>1)|(l<<31);
 156         r=(r>>1)|(r<<31);
 157         /* clear the top bits on machines with 8byte longs */
 158         l&=0xffffffffL;
 159         r&=0xffffffffL;
 160
 161         FP(r,l);
 162         data[0]=l;
 163         data[1]=r;
 164         l=r=t=u=0;
 165         }
 166
 167 void des_encrypt2(data, ks, encrypt)
 168 DES_LONG *data;
 169 des_key_schedule ks;
 170 int encrypt;
 171         {
 172         register DES_LONG l,r,t,u;
 173 #ifdef DES_PTR
 174         register unsigned char *des_SP=(unsigned char *)des_SPtrans;
 175 #endif
 176 #ifdef undef
 177         union fudge {
 178                 DES_LONG  l;
 179                 unsigned short s[2];
 180                 unsigned char  c[4];
 181                 } U,T;
 182 #endif
 183         register int i;
 184         register DES_LONG *s;
 185
 186         u=data[0];
 187         r=data[1];
 188
 189         /* Things have been modified so that the initial rotate is
 190          * done outside the loop.  This required the
 191          * des_SPtrans values in sp.h to be rotated 1 bit to the right.
 192          * One perl script later and things have a 5% speed up on a sparc2.
 193          * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
 194          * for pointing this out. */
 195         l=(r<<1)|(r>>31);
 196         r=(u<<1)|(u>>31);
 197
 198         /* clear the top bits on machines with 8byte longs */
 199         l&=0xffffffffL;
 200         r&=0xffffffffL;
 201
 202         s=(DES_LONG *)ks;
 203         /* I don't know if it is worth the effort of loop unrolling the
 204          * inner loop */
 205         if (encrypt)
 206                 {
 207                 for (i=0; i<32; i+=8)
 208                         {
 209                         D_ENCRYPT(l,r,i+0); /*  1 */
 210                         D_ENCRYPT(r,l,i+2); /*  2 */
 211                         D_ENCRYPT(l,r,i+4); /*  3 */
 212                         D_ENCRYPT(r,l,i+6); /*  4 */
 213                         }
 214                 }
 215         else
 216                 {
 217                 for (i=30; i>0; i-=8)
 218                         {
 219                         D_ENCRYPT(l,r,i-0); /* 16 */
 220                         D_ENCRYPT(r,l,i-2); /* 15 */
 221                         D_ENCRYPT(l,r,i-4); /* 14 */
 222                         D_ENCRYPT(r,l,i-6); /* 13 */
 223                         }
 224                 }
 225         l=(l>>1)|(l<<31);
 226         r=(r>>1)|(r<<31);
 227         /* clear the top bits on machines with 8byte longs */
 228         l&=0xffffffffL;
 229         r&=0xffffffffL;
 230
 231         data[0]=l;
 232         data[1]=r;
 233         l=r=t=u=0;
 234         }