1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com) 2 * All rights reserved. 3 * 4 * This package is an SSL implementation written 5 * by Eric Young (eay (at) cryptsoft.com). 6 * The implementation was written so as to conform with Netscapes SSL. 7 * 8 * This library is free for commercial and non-commercial use as long as 9 * the following conditions are aheared to. The following conditions 10 * apply to all code found in this distribution, be it the RC4, RSA, 11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 12 * included with this distribution is covered by the same copyright terms 13 * except that the holder is Tim Hudson (tjh (at) cryptsoft.com). 14 * 15 * Copyright remains Eric Young's, and as such any Copyright notices in 16 * the code are not to be removed. 17 * If this package is used in a product, Eric Young should be given attribution 18 * as the author of the parts of the library used. 19 * This can be in the form of a textual message at program startup or 20 * in documentation (online or textual) provided with the package. 21 * 22 * Redistribution and use in source and binary forms, with or without 23 * modification, are permitted provided that the following conditions 24 * are met: 25 * 1. Redistributions of source code must retain the copyright 26 * notice, this list of conditions and the following disclaimer. 27 * 2. Redistributions in binary form must reproduce the above copyright 28 * notice, this list of conditions and the following disclaimer in the 29 * documentation and/or other materials provided with the distribution. 30 * 3. All advertising materials mentioning features or use of this software 31 * must display the following acknowledgement: 32 * "This product includes cryptographic software written by 33 * Eric Young (eay (at) cryptsoft.com)" 34 * The word 'cryptographic' can be left out if the rouines from the library 35 * being used are not cryptographic related :-). 36 * 4. If you include any Windows specific code (or a derivative thereof) from 37 * the apps directory (application code) you must include an acknowledgement: 38 * "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 50 * SUCH DAMAGE. 51 * 52 * The licence and distribution terms for any publically available version or 53 * derivative of this code cannot be changed. i.e. this code cannot simply be 54 * copied and put under another distribution licence 55 * [including the GNU Public Licence.]. */ 56 57 #include <openssl/cast.h> 58 59 #if defined(OPENSSL_WINDOWS) 60 OPENSSL_MSVC_PRAGMA(warning(push, 3)) 61 #include <intrin.h> 62 OPENSSL_MSVC_PRAGMA(warning(pop)) 63 #endif 64 65 #include "internal.h" 66 #include "../macros.h" 67 68 69 void CAST_ecb_encrypt(const uint8_t *in, uint8_t *out, const CAST_KEY *ks, 70 int enc) { 71 uint32_t d[2]; 72 73 n2l(in, d[0]); 74 n2l(in, d[1]); 75 if (enc) { 76 CAST_encrypt(d, ks); 77 } else { 78 CAST_decrypt(d, ks); 79 } 80 l2n(d[0], out); 81 l2n(d[1], out); 82 } 83 84 #if defined(OPENSSL_WINDOWS) && defined(_MSC_VER) 85 #define ROTL(a, n) (_lrotl(a, n)) 86 #else 87 #define ROTL(a, n) ((((a) << (n)) | ((a) >> ((-(n))&31))) & 0xffffffffL) 88 #endif 89 90 #define E_CAST(n, key, L, R, OP1, OP2, OP3) \ 91 { \ 92 uint32_t a, b, c, d; \ 93 t = (key[n * 2] OP1 R) & 0xffffffff; \ 94 t = ROTL(t, (key[n * 2 + 1])); \ 95 a = CAST_S_table0[(t >> 8) & 0xff]; \ 96 b = CAST_S_table1[(t)&0xff]; \ 97 c = CAST_S_table2[(t >> 24) & 0xff]; \ 98 d = CAST_S_table3[(t >> 16) & 0xff]; \ 99 L ^= (((((a OP2 b)&0xffffffffL)OP3 c) & 0xffffffffL)OP1 d) & 0xffffffffL; \ 100 } 101 102 void CAST_encrypt(uint32_t *data, const CAST_KEY *key) { 103 uint32_t l, r, t; 104 const uint32_t *k; 105 106 k = &key->data[0]; 107 l = data[0]; 108 r = data[1]; 109 110 E_CAST(0, k, l, r, +, ^, -); 111 E_CAST(1, k, r, l, ^, -, +); 112 E_CAST(2, k, l, r, -, +, ^); 113 E_CAST(3, k, r, l, +, ^, -); 114 E_CAST(4, k, l, r, ^, -, +); 115 E_CAST(5, k, r, l, -, +, ^); 116 E_CAST(6, k, l, r, +, ^, -); 117 E_CAST(7, k, r, l, ^, -, +); 118 E_CAST(8, k, l, r, -, +, ^); 119 E_CAST(9, k, r, l, +, ^, -); 120 E_CAST(10, k, l, r, ^, -, +); 121 E_CAST(11, k, r, l, -, +, ^); 122 123 if (!key->short_key) { 124 E_CAST(12, k, l, r, +, ^, -); 125 E_CAST(13, k, r, l, ^, -, +); 126 E_CAST(14, k, l, r, -, +, ^); 127 E_CAST(15, k, r, l, +, ^, -); 128 } 129 130 data[1] = l & 0xffffffffL; 131 data[0] = r & 0xffffffffL; 132 } 133 134 void CAST_decrypt(uint32_t *data, const CAST_KEY *key) { 135 uint32_t l, r, t; 136 const uint32_t *k; 137 138 k = &key->data[0]; 139 l = data[0]; 140 r = data[1]; 141 142 if (!key->short_key) { 143 E_CAST(15, k, l, r, +, ^, -); 144 E_CAST(14, k, r, l, -, +, ^); 145 E_CAST(13, k, l, r, ^, -, +); 146 E_CAST(12, k, r, l, +, ^, -); 147 } 148 149 E_CAST(11, k, l, r, -, +, ^); 150 E_CAST(10, k, r, l, ^, -, +); 151 E_CAST(9, k, l, r, +, ^, -); 152 E_CAST(8, k, r, l, -, +, ^); 153 E_CAST(7, k, l, r, ^, -, +); 154 E_CAST(6, k, r, l, +, ^, -); 155 E_CAST(5, k, l, r, -, +, ^); 156 E_CAST(4, k, r, l, ^, -, +); 157 E_CAST(3, k, l, r, +, ^, -); 158 E_CAST(2, k, r, l, -, +, ^); 159 E_CAST(1, k, l, r, ^, -, +); 160 E_CAST(0, k, r, l, +, ^, -); 161 162 data[1] = l & 0xffffffffL; 163 data[0] = r & 0xffffffffL; 164 } 165 166 void CAST_cbc_encrypt(const uint8_t *in, uint8_t *out, long length, 167 const CAST_KEY *ks, uint8_t *iv, int enc) { 168 uint32_t tin0, tin1; 169 uint32_t tout0, tout1, xor0, xor1; 170 long l = length; 171 uint32_t tin[2]; 172 173 if (enc) { 174 n2l(iv, tout0); 175 n2l(iv, tout1); 176 iv -= 8; 177 for (l -= 8; l >= 0; l -= 8) { 178 n2l(in, tin0); 179 n2l(in, tin1); 180 tin0 ^= tout0; 181 tin1 ^= tout1; 182 tin[0] = tin0; 183 tin[1] = tin1; 184 CAST_encrypt(tin, ks); 185 tout0 = tin[0]; 186 tout1 = tin[1]; 187 l2n(tout0, out); 188 l2n(tout1, out); 189 } 190 if (l != -8) { 191 n2ln(in, tin0, tin1, l + 8); 192 tin0 ^= tout0; 193 tin1 ^= tout1; 194 tin[0] = tin0; 195 tin[1] = tin1; 196 CAST_encrypt(tin, ks); 197 tout0 = tin[0]; 198 tout1 = tin[1]; 199 l2n(tout0, out); 200 l2n(tout1, out); 201 } 202 l2n(tout0, iv); 203 l2n(tout1, iv); 204 } else { 205 n2l(iv, xor0); 206 n2l(iv, xor1); 207 iv -= 8; 208 for (l -= 8; l >= 0; l -= 8) { 209 n2l(in, tin0); 210 n2l(in, tin1); 211 tin[0] = tin0; 212 tin[1] = tin1; 213 CAST_decrypt(tin, ks); 214 tout0 = tin[0] ^ xor0; 215 tout1 = tin[1] ^ xor1; 216 l2n(tout0, out); 217 l2n(tout1, out); 218 xor0 = tin0; 219 xor1 = tin1; 220 } 221 if (l != -8) { 222 n2l(in, tin0); 223 n2l(in, tin1); 224 tin[0] = tin0; 225 tin[1] = tin1; 226 CAST_decrypt(tin, ks); 227 tout0 = tin[0] ^ xor0; 228 tout1 = tin[1] ^ xor1; 229 l2nn(tout0, tout1, out, l + 8); 230 xor0 = tin0; 231 xor1 = tin1; 232 } 233 l2n(xor0, iv); 234 l2n(xor1, iv); 235 } 236 tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0; 237 tin[0] = tin[1] = 0; 238 } 239 240 #define CAST_exp(l, A, a, n) \ 241 A[n / 4] = l; \ 242 a[n + 3] = (l)&0xff; \ 243 a[n + 2] = (l >> 8) & 0xff; \ 244 a[n + 1] = (l >> 16) & 0xff; \ 245 a[n + 0] = (l >> 24) & 0xff; 246 #define S4 CAST_S_table4 247 #define S5 CAST_S_table5 248 #define S6 CAST_S_table6 249 #define S7 CAST_S_table7 250 251 void CAST_set_key(CAST_KEY *key, size_t len, const uint8_t *data) { 252 uint32_t x[16]; 253 uint32_t z[16]; 254 uint32_t k[32]; 255 uint32_t X[4], Z[4]; 256 uint32_t l, *K; 257 size_t i; 258 259 for (i = 0; i < 16; i++) { 260 x[i] = 0; 261 } 262 263 if (len > 16) { 264 len = 16; 265 } 266 267 for (i = 0; i < len; i++) { 268 x[i] = data[i]; 269 } 270 271 if (len <= 10) { 272 key->short_key = 1; 273 } else { 274 key->short_key = 0; 275 } 276 277 K = &k[0]; 278 X[0] = ((x[0] << 24) | (x[1] << 16) | (x[2] << 8) | x[3]) & 0xffffffffL; 279 X[1] = ((x[4] << 24) | (x[5] << 16) | (x[6] << 8) | x[7]) & 0xffffffffL; 280 X[2] = ((x[8] << 24) | (x[9] << 16) | (x[10] << 8) | x[11]) & 0xffffffffL; 281 X[3] = ((x[12] << 24) | (x[13] << 16) | (x[14] << 8) | x[15]) & 0xffffffffL; 282 283 for (;;) { 284 l = X[0] ^ S4[x[13]] ^ S5[x[15]] ^ S6[x[12]] ^ S7[x[14]] ^ S6[x[8]]; 285 CAST_exp(l, Z, z, 0); 286 l = X[2] ^ S4[z[0]] ^ S5[z[2]] ^ S6[z[1]] ^ S7[z[3]] ^ S7[x[10]]; 287 CAST_exp(l, Z, z, 4); 288 l = X[3] ^ S4[z[7]] ^ S5[z[6]] ^ S6[z[5]] ^ S7[z[4]] ^ S4[x[9]]; 289 CAST_exp(l, Z, z, 8); 290 l = X[1] ^ S4[z[10]] ^ S5[z[9]] ^ S6[z[11]] ^ S7[z[8]] ^ S5[x[11]]; 291 CAST_exp(l, Z, z, 12); 292 293 K[0] = S4[z[8]] ^ S5[z[9]] ^ S6[z[7]] ^ S7[z[6]] ^ S4[z[2]]; 294 K[1] = S4[z[10]] ^ S5[z[11]] ^ S6[z[5]] ^ S7[z[4]] ^ S5[z[6]]; 295 K[2] = S4[z[12]] ^ S5[z[13]] ^ S6[z[3]] ^ S7[z[2]] ^ S6[z[9]]; 296 K[3] = S4[z[14]] ^ S5[z[15]] ^ S6[z[1]] ^ S7[z[0]] ^ S7[z[12]]; 297 298 l = Z[2] ^ S4[z[5]] ^ S5[z[7]] ^ S6[z[4]] ^ S7[z[6]] ^ S6[z[0]]; 299 CAST_exp(l, X, x, 0); 300 l = Z[0] ^ S4[x[0]] ^ S5[x[2]] ^ S6[x[1]] ^ S7[x[3]] ^ S7[z[2]]; 301 CAST_exp(l, X, x, 4); 302 l = Z[1] ^ S4[x[7]] ^ S5[x[6]] ^ S6[x[5]] ^ S7[x[4]] ^ S4[z[1]]; 303 CAST_exp(l, X, x, 8); 304 l = Z[3] ^ S4[x[10]] ^ S5[x[9]] ^ S6[x[11]] ^ S7[x[8]] ^ S5[z[3]]; 305 CAST_exp(l, X, x, 12); 306 307 K[4] = S4[x[3]] ^ S5[x[2]] ^ S6[x[12]] ^ S7[x[13]] ^ S4[x[8]]; 308 K[5] = S4[x[1]] ^ S5[x[0]] ^ S6[x[14]] ^ S7[x[15]] ^ S5[x[13]]; 309 K[6] = S4[x[7]] ^ S5[x[6]] ^ S6[x[8]] ^ S7[x[9]] ^ S6[x[3]]; 310 K[7] = S4[x[5]] ^ S5[x[4]] ^ S6[x[10]] ^ S7[x[11]] ^ S7[x[7]]; 311 312 l = X[0] ^ S4[x[13]] ^ S5[x[15]] ^ S6[x[12]] ^ S7[x[14]] ^ S6[x[8]]; 313 CAST_exp(l, Z, z, 0); 314 l = X[2] ^ S4[z[0]] ^ S5[z[2]] ^ S6[z[1]] ^ S7[z[3]] ^ S7[x[10]]; 315 CAST_exp(l, Z, z, 4); 316 l = X[3] ^ S4[z[7]] ^ S5[z[6]] ^ S6[z[5]] ^ S7[z[4]] ^ S4[x[9]]; 317 CAST_exp(l, Z, z, 8); 318 l = X[1] ^ S4[z[10]] ^ S5[z[9]] ^ S6[z[11]] ^ S7[z[8]] ^ S5[x[11]]; 319 CAST_exp(l, Z, z, 12); 320 321 K[8] = S4[z[3]] ^ S5[z[2]] ^ S6[z[12]] ^ S7[z[13]] ^ S4[z[9]]; 322 K[9] = S4[z[1]] ^ S5[z[0]] ^ S6[z[14]] ^ S7[z[15]] ^ S5[z[12]]; 323 K[10] = S4[z[7]] ^ S5[z[6]] ^ S6[z[8]] ^ S7[z[9]] ^ S6[z[2]]; 324 K[11] = S4[z[5]] ^ S5[z[4]] ^ S6[z[10]] ^ S7[z[11]] ^ S7[z[6]]; 325 326 l = Z[2] ^ S4[z[5]] ^ S5[z[7]] ^ S6[z[4]] ^ S7[z[6]] ^ S6[z[0]]; 327 CAST_exp(l, X, x, 0); 328 l = Z[0] ^ S4[x[0]] ^ S5[x[2]] ^ S6[x[1]] ^ S7[x[3]] ^ S7[z[2]]; 329 CAST_exp(l, X, x, 4); 330 l = Z[1] ^ S4[x[7]] ^ S5[x[6]] ^ S6[x[5]] ^ S7[x[4]] ^ S4[z[1]]; 331 CAST_exp(l, X, x, 8); 332 l = Z[3] ^ S4[x[10]] ^ S5[x[9]] ^ S6[x[11]] ^ S7[x[8]] ^ S5[z[3]]; 333 CAST_exp(l, X, x, 12); 334 335 K[12] = S4[x[8]] ^ S5[x[9]] ^ S6[x[7]] ^ S7[x[6]] ^ S4[x[3]]; 336 K[13] = S4[x[10]] ^ S5[x[11]] ^ S6[x[5]] ^ S7[x[4]] ^ S5[x[7]]; 337 K[14] = S4[x[12]] ^ S5[x[13]] ^ S6[x[3]] ^ S7[x[2]] ^ S6[x[8]]; 338 K[15] = S4[x[14]] ^ S5[x[15]] ^ S6[x[1]] ^ S7[x[0]] ^ S7[x[13]]; 339 if (K != k) { 340 break; 341 } 342 K += 16; 343 } 344 345 for (i = 0; i < 16; i++) { 346 key->data[i * 2] = k[i]; 347 key->data[i * 2 + 1] = ((k[i + 16]) + 16) & 0x1f; 348 } 349 } 350 351 // The input and output encrypted as though 64bit cfb mode is being used. The 352 // extra state information to record how much of the 64bit block we have used 353 // is contained in *num. 354 void CAST_cfb64_encrypt(const uint8_t *in, uint8_t *out, long length, 355 const CAST_KEY *schedule, uint8_t *ivec, int *num, 356 int enc) { 357 uint32_t v0, v1, t; 358 int n = *num; 359 long l = length; 360 uint32_t ti[2]; 361 uint8_t *iv, c, cc; 362 363 iv = ivec; 364 if (enc) { 365 while (l--) { 366 if (n == 0) { 367 n2l(iv, v0); 368 ti[0] = v0; 369 n2l(iv, v1); 370 ti[1] = v1; 371 CAST_encrypt((uint32_t *)ti, schedule); 372 iv = ivec; 373 t = ti[0]; 374 l2n(t, iv); 375 t = ti[1]; 376 l2n(t, iv); 377 iv = ivec; 378 } 379 c = *(in++) ^ iv[n]; 380 *(out++) = c; 381 iv[n] = c; 382 n = (n + 1) & 0x07; 383 } 384 } else { 385 while (l--) { 386 if (n == 0) { 387 n2l(iv, v0); 388 ti[0] = v0; 389 n2l(iv, v1); 390 ti[1] = v1; 391 CAST_encrypt((uint32_t *)ti, schedule); 392 iv = ivec; 393 t = ti[0]; 394 l2n(t, iv); 395 t = ti[1]; 396 l2n(t, iv); 397 iv = ivec; 398 } 399 cc = *(in++); 400 c = iv[n]; 401 iv[n] = cc; 402 *(out++) = c ^ cc; 403 n = (n + 1) & 0x07; 404 } 405 } 406 v0 = v1 = ti[0] = ti[1] = t = c = cc = 0; 407 *num = n; 408 } 409
