1 /* crypto/des/des.h */ 2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 59 module deimos.openssl.des; 60 61 import deimos.openssl._d_util; 62 63 public import deimos.openssl.e_os2; /* OPENSSL_EXTERN, OPENSSL_NO_DES, 64 DES_LONG (via openssl/opensslconf.h */ 65 66 version (OPENSSL_NO_DES) { 67 static assert(false, "DES is disabled."); 68 } 69 70 71 extern (C): 72 nothrow: 73 74 alias ubyte[8] DES_cblock; 75 alias ubyte[8] const_DES_cblock; 76 /* With "const", gcc 2.8.1 on Solaris thinks that DES_cblock* 77 * and const_DES_cblock* are incompatible pointer types. */ 78 79 struct DES_ks 80 { 81 union ks_ 82 { 83 DES_cblock cblock; 84 /* make sure things are correct size on machines with 85 * 8 byte longs */ 86 DES_LONG[2] deslong; 87 } 88 ks_[16] ks; 89 } 90 alias DES_ks DES_key_schedule; 91 92 // #ifndef OPENSSL_DISABLE_OLD_DES_SUPPORT 93 // # ifndef OPENSSL_ENABLE_OLD_DES_SUPPORT 94 // # define OPENSSL_ENABLE_OLD_DES_SUPPORT 95 // # endif 96 // #endif 97 98 version (OPENSSL_ENABLE_OLD_DES_SUPPORT) { 99 public import deimos.openssl.des_old; 100 } 101 102 enum DES_KEY_SZ = DES_cblock.sizeof; 103 enum DES_SCHEDULE_SZ = DES_key_schedule.sizeof; 104 105 enum DES_ENCRYPT = 1; 106 enum DES_DECRYPT = 0; 107 108 enum DES_CBC_MODE = 0; 109 enum DES_PCBC_MODE = 1; 110 111 alias DES_ecb3_encrypt DES_ecb2_encrypt; 112 113 alias DES_ede3_cbc_encrypt DES_ede2_cbc_encrypt; 114 115 alias DES_ede3_cfb64_encrypt DES_ede2_cfb64_encrypt; 116 117 alias DES_ede3_ofb64_encrypt DES_ede2_ofb64_encrypt; 118 119 extern int _shadow_DES_check_key; /* defaults to false */ 120 alias _shadow_DES_check_key DES_check_key; 121 extern int _shadow_DES_rw_mode; /* defaults to DES_PCBC_MODE */ 122 alias _shadow_DES_rw_mode DES_rw_mode; 123 124 const(char)* DES_options(); 125 void DES_ecb3_encrypt(const_DES_cblock* input, DES_cblock* output, 126 DES_key_schedule* ks1,DES_key_schedule* ks2, 127 DES_key_schedule* ks3, int enc); 128 DES_LONG DES_cbc_cksum(const(ubyte)* input,DES_cblock* output, 129 c_long length,DES_key_schedule* schedule, 130 const_DES_cblock* ivec); 131 /* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ 132 void DES_cbc_encrypt(const(ubyte)* input,ubyte* output, 133 c_long length,DES_key_schedule* schedule,DES_cblock* ivec, 134 int enc); 135 void DES_ncbc_encrypt(const(ubyte)* input,ubyte* output, 136 c_long length,DES_key_schedule* schedule,DES_cblock* ivec, 137 int enc); 138 void DES_xcbc_encrypt(const(ubyte)* input,ubyte* output, 139 c_long length,DES_key_schedule* schedule,DES_cblock* ivec, 140 const_DES_cblock* inw,const_DES_cblock* outw,int enc); 141 void DES_cfb_encrypt(const(ubyte)* in_,ubyte* out_,int numbits, 142 c_long length,DES_key_schedule* schedule,DES_cblock* ivec, 143 int enc); 144 void DES_ecb_encrypt(const_DES_cblock* input,DES_cblock* output, 145 DES_key_schedule* ks,int enc); 146 147 /* This is the DES encryption function that gets called by just about 148 every other DES routine in the library. You should not use this 149 function except to implement 'modes' of DES. I say this because the 150 functions that call this routine do the conversion from 'char* ' to 151 c_long, and this needs to be done to make sure 'non-aligned' memory 152 access do not occur. The characters are loaded 'little endian'. 153 Data is a pointer to 2 c_ulong's and ks is the 154 DES_key_schedule to use. enc, is non zero specifies encryption, 155 zero if decryption. */ 156 void DES_encrypt1(DES_LONG* data,DES_key_schedule* ks, int enc); 157 158 /* This functions is the same as DES_encrypt1() except that the DES 159 initial permutation (IP) and final permutation (FP) have been left 160 out. As for DES_encrypt1(), you should not use this function. 161 It is used by the routines in the library that implement triple DES. 162 IP() DES_encrypt2() DES_encrypt2() DES_encrypt2() FP() is the same 163 as DES_encrypt1() DES_encrypt1() DES_encrypt1() except faster :-). */ 164 void DES_encrypt2(DES_LONG* data,DES_key_schedule* ks, int enc); 165 166 void DES_encrypt3(DES_LONG* data, DES_key_schedule* ks1, 167 DES_key_schedule* ks2, DES_key_schedule* ks3); 168 void DES_decrypt3(DES_LONG* data, DES_key_schedule* ks1, 169 DES_key_schedule* ks2, DES_key_schedule* ks3); 170 void DES_ede3_cbc_encrypt(const(ubyte)* input,ubyte* output, 171 c_long length, 172 DES_key_schedule* ks1,DES_key_schedule* ks2, 173 DES_key_schedule* ks3,DES_cblock* ivec,int enc); 174 void DES_ede3_cbcm_encrypt(const(ubyte)* in_,ubyte* out_, 175 c_long length, 176 DES_key_schedule* ks1,DES_key_schedule* ks2, 177 DES_key_schedule* ks3, 178 DES_cblock* ivec1,DES_cblock* ivec2, 179 int enc); 180 void DES_ede3_cfb64_encrypt(const(ubyte)* in_,ubyte* out_, 181 c_long length,DES_key_schedule* ks1, 182 DES_key_schedule* ks2,DES_key_schedule* ks3, 183 DES_cblock* ivec,int* num,int enc); 184 void DES_ede3_cfb_encrypt(const(ubyte)* in_,ubyte* out_, 185 int numbits,c_long length,DES_key_schedule* ks1, 186 DES_key_schedule* ks2,DES_key_schedule* ks3, 187 DES_cblock* ivec,int enc); 188 void DES_ede3_ofb64_encrypt(const(ubyte)* in_,ubyte* out_, 189 c_long length,DES_key_schedule* ks1, 190 DES_key_schedule* ks2,DES_key_schedule* ks3, 191 DES_cblock* ivec,int* num); 192 version (none) { 193 void DES_xwhite_in2out(const_DES_cblock* DES_key,const_DES_cblock* in_white, 194 DES_cblock* out_white); 195 } 196 197 int DES_enc_read(int fd,void* buf,int len,DES_key_schedule* sched, 198 DES_cblock* iv); 199 int DES_enc_write(int fd,const(void)* buf,int len,DES_key_schedule* sched, 200 DES_cblock* iv); 201 char* DES_fcrypt(const(char)* buf,const(char)* salt, char* ret); 202 char* DES_crypt(const(char)* buf,const(char)* salt); 203 void DES_ofb_encrypt(const(ubyte)* in_,ubyte* out_,int numbits, 204 c_long length,DES_key_schedule* schedule,DES_cblock* ivec); 205 void DES_pcbc_encrypt(const(ubyte)* input,ubyte* output, 206 c_long length,DES_key_schedule* schedule,DES_cblock* ivec, 207 int enc); 208 DES_LONG DES_quad_cksum(const(ubyte)* input,DES_cblock[] output, 209 c_long length,int out_count,DES_cblock* seed); 210 int DES_random_key(DES_cblock* ret); 211 void DES_set_odd_parity(DES_cblock* key); 212 int DES_check_key_parity(const_DES_cblock* key); 213 int DES_is_weak_key(const_DES_cblock* key); 214 /* DES_set_key (= set_key = DES_key_sched = key_sched) calls 215 * DES_set_key_checked if global variable DES_check_key is set, 216 * DES_set_key_unchecked otherwise. */ 217 int DES_set_key(const_DES_cblock* key,DES_key_schedule* schedule); 218 int DES_key_sched(const_DES_cblock* key,DES_key_schedule* schedule); 219 int DES_set_key_checked(const_DES_cblock* key,DES_key_schedule* schedule); 220 void DES_set_key_unchecked(const_DES_cblock* key,DES_key_schedule* schedule); 221 version(OPENSSL_FIPS) { 222 void private_DES_set_key_unchecked(const_DES_cblock* key,DES_key_schedule* schedule); 223 } 224 void DES_string_to_key(const(char)* str,DES_cblock* key); 225 void DES_string_to_2keys(const(char)* str,DES_cblock* key1,DES_cblock* key2); 226 void DES_cfb64_encrypt(const(ubyte)* in_,ubyte* out_,c_long length, 227 DES_key_schedule* schedule,DES_cblock* ivec,int* num, 228 int enc); 229 void DES_ofb64_encrypt(const(ubyte)* in_,ubyte* out_,c_long length, 230 DES_key_schedule* schedule,DES_cblock* ivec,int* num); 231 232 int DES_read_password(DES_cblock* key, const(char)* prompt, int verify); 233 int DES_read_2passwords(DES_cblock* key1, DES_cblock* key2, const(char)* prompt, 234 int verify); 235 236 alias DES_set_odd_parity DES_fixup_key_parity;