crypto/des/des_old.c

   1 /* crypto/des/des_comp.c -*- mode:C; c-file-style: "eay" -*- */
   2 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
   3  * project 2001.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    openssl-core@openssl.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <openssl/des_old.h>
  60
  61 const char *des_options(void)
  62         {
  63         return DES_options();
  64         }
  65 void des_ecb3_encrypt(des_cblock *input,des_cblock *output,
  66         des_key_schedule ks1,des_key_schedule ks2,
  67         des_key_schedule ks3, int enc)
  68         {
  69         DES_ecb3_encrypt((const_DES_cblock *)input, output,
  70                 (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
  71                 (DES_key_schedule *)ks3, enc);
  72         }
  73 DES_LONG des_cbc_cksum(des_cblock *input,des_cblock *output,
  74         long length,des_key_schedule schedule,des_cblock *ivec)
  75         {
  76         return DES_cbc_cksum((unsigned char *)input, output, length,
  77                 (DES_key_schedule *)schedule, ivec);
  78         }
  79 void des_cbc_encrypt(des_cblock *input,des_cblock *output,long length,
  80         des_key_schedule schedule,des_cblock *ivec,int enc)
  81         {
  82         DES_cbc_encrypt((unsigned char *)input, (unsigned char *)output,
  83                 length, (DES_key_schedule *)schedule, ivec, enc);
  84         }
  85 void des_ncbc_encrypt(des_cblock *input,des_cblock *output,long length,
  86         des_key_schedule schedule,des_cblock *ivec,int enc)
  87         {
  88         DES_ncbc_encrypt((unsigned char *)input, (unsigned char *)output,
  89                 length, (DES_key_schedule *)schedule, ivec, enc);
  90         }
  91 void des_xcbc_encrypt(des_cblock *input,des_cblock *output,long length,
  92         des_key_schedule schedule,des_cblock *ivec,
  93         des_cblock *inw,des_cblock *outw,int enc)
  94         {
  95         DES_xcbc_encrypt((unsigned char *)input, (unsigned char *)output,
  96                 length, (DES_key_schedule *)schedule, ivec, inw, outw, enc);
  97         }
  98 void des_cfb_encrypt(unsigned char *in,unsigned char *out,int numbits,
  99         long length,des_key_schedule schedule,des_cblock *ivec,int enc)
 100         {
 101         DES_cfb_encrypt(in, out, numbits, length,
 102                 (DES_key_schedule *)schedule, ivec, enc);
 103         }
 104 void des_ecb_encrypt(des_cblock *input,des_cblock *output,
 105         des_key_schedule ks,int enc)
 106         {
 107         DES_ecb_encrypt(input, output, (DES_key_schedule *)ks, enc);
 108         }
 109 void des_encrypt(DES_LONG *data,des_key_schedule ks, int enc)
 110         {
 111         DES_encrypt1(data, (DES_key_schedule *)ks, enc);
 112         }
 113 void des_encrypt2(DES_LONG *data,des_key_schedule ks, int enc)
 114         {
 115         DES_encrypt2(data, (DES_key_schedule *)ks, enc);
 116         }
 117 void des_encrypt3(DES_LONG *data, des_key_schedule ks1,
 118         des_key_schedule ks2, des_key_schedule ks3)
 119         {
 120         DES_encrypt3(data, (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
 121                 (DES_key_schedule *)ks3);
 122         }
 123 void des_decrypt3(DES_LONG *data, des_key_schedule ks1,
 124         des_key_schedule ks2, des_key_schedule ks3)
 125         {
 126         DES_decrypt3(data, (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
 127                 (DES_key_schedule *)ks3);
 128         }
 129 void des_ede3_cbc_encrypt(des_cblock *input, des_cblock *output,
 130         long length, des_key_schedule ks1, des_key_schedule ks2,
 131         des_key_schedule ks3, des_cblock *ivec, int enc)
 132         {
 133         DES_ede3_cbc_encrypt((unsigned char *)input, (unsigned char *)output,
 134                 length, (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
 135                 (DES_key_schedule *)ks3, ivec, enc);
 136         }
 137 void des_ede3_cfb64_encrypt(unsigned char *in, unsigned char *out,
 138         long length, des_key_schedule ks1, des_key_schedule ks2,
 139         des_key_schedule ks3, des_cblock *ivec, int *num, int enc)
 140         {
 141         DES_ede3_cfb64_encrypt(in, out, length,
 142                 (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
 143                 (DES_key_schedule *)ks3, ivec, num, enc);
 144         }
 145 void des_ede3_ofb64_encrypt(unsigned char *in, unsigned char *out,
 146         long length, des_key_schedule ks1, des_key_schedule ks2,
 147         des_key_schedule ks3, des_cblock *ivec, int *num)
 148         {
 149         DES_ede3_ofb64_encrypt(in, out, length,
 150                 (DES_key_schedule *)ks1, (DES_key_schedule *)ks2,
 151                 (DES_key_schedule *)ks3, ivec, num);
 152         }
 153
 154 void des_xwhite_in2out(des_cblock (*des_key), des_cblock (*in_white),
 155         des_cblock (*out_white))
 156         {
 157         DES_xwhite_in2out(des_key, in_white, out_white);
 158         }
 159
 160 int des_enc_read(int fd,char *buf,int len,des_key_schedule sched,
 161         des_cblock *iv)
 162         {
 163         return DES_enc_read(fd, buf, len, (DES_key_schedule *)sched, iv);
 164         }
 165 int des_enc_write(int fd,char *buf,int len,des_key_schedule sched,
 166         des_cblock *iv)
 167         {
 168         return DES_enc_write(fd, buf, len, (DES_key_schedule *)sched, iv);
 169         }
 170 char *des_fcrypt(const char *buf,const char *salt, char *ret)
 171         {
 172         return DES_fcrypt(buf, salt, ret);
 173         }
 174 char *des_crypt(const char *buf,const char *salt)
 175         {
 176         return DES_crypt(buf, salt);
 177         }
 178 #if !defined(PERL5) && !defined(__FreeBSD__) && !defined(NeXT)
 179 char *crypt(const char *buf,const char *salt)
 180         {
 181         return DES_crypt(buf, salt);
 182         }
 183 #endif
 184 void des_ofb_encrypt(unsigned char *in,unsigned char *out,
 185         int numbits,long length,des_key_schedule schedule,des_cblock *ivec)
 186         {
 187         DES_ofb_encrypt(in, out, numbits, length, (DES_key_schedule *)schedule,
 188                 ivec);
 189         }
 190 void des_pcbc_encrypt(des_cblock *input,des_cblock *output,long length,
 191         des_key_schedule schedule,des_cblock *ivec,int enc)
 192         {
 193         DES_pcbc_encrypt((unsigned char *)input, (unsigned char *)output,
 194                 length, (DES_key_schedule *)schedule, ivec, enc);
 195         }
 196 DES_LONG des_quad_cksum(des_cblock *input,des_cblock *output,
 197         long length,int out_count,des_cblock *seed)
 198         {
 199         return DES_quad_cksum((unsigned char *)input, output, length,
 200                 out_count, seed);
 201         }
 202 void des_random_seed(des_cblock key)
 203         {
 204         DES_random_seed((DES_cblock *)key);
 205         }
 206 void des_random_key(des_cblock ret)
 207         {
 208         DES_random_key((DES_cblock *)ret);
 209         }
 210 void des_set_odd_parity(des_cblock *key)
 211         {
 212         DES_set_odd_parity(key);
 213         }
 214 int des_is_weak_key(des_cblock *key)
 215         {
 216         return DES_is_weak_key(key);
 217         }
 218 int des_set_key(des_cblock *key,des_key_schedule schedule)
 219         {
 220         return DES_set_key(key, (DES_key_schedule *)schedule);
 221         }
 222 int des_key_sched(des_cblock *key,des_key_schedule schedule)
 223         {
 224         return DES_key_sched(key, (DES_key_schedule *)schedule);
 225         }
 226 void des_string_to_key(char *str,des_cblock *key)
 227         {
 228         DES_string_to_key(str, key);
 229         }
 230 void des_string_to_2keys(char *str,des_cblock *key1,des_cblock *key2)
 231         {
 232         DES_string_to_2keys(str, key1, key2);
 233         }
 234 void des_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
 235         des_key_schedule schedule, des_cblock *ivec, int *num, int enc)
 236         {
 237         DES_cfb64_encrypt(in, out, length, (DES_key_schedule *)schedule,
 238                 ivec, num, enc);
 239         }
 240 void des_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
 241         des_key_schedule schedule, des_cblock *ivec, int *num)
 242         {
 243         DES_ofb64_encrypt(in, out, length, (DES_key_schedule *)schedule,
 244                 ivec, num);
 245         }