1 /* 2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include <openssl/crypto.h> 11 #include "des_locl.h" 12 #include "spr.h" 13 14 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc) 15 { 16 register DES_LONG l, r, t, u; 17 register DES_LONG *s; 18 19 r = data[0]; 20 l = data[1]; 21 22 IP(r, l); 23 /* 24 * Things have been modified so that the initial rotate is done outside 25 * the loop. This required the DES_SPtrans values in sp.h to be rotated 26 * 1 bit to the right. One perl script later and things have a 5% speed 27 * up on a sparc2. Thanks to Richard Outerbridge for pointing this out. 28 */ 29 /* clear the top bits on machines with 8byte longs */ 30 /* shift left by 2 */ 31 r = ROTATE(r, 29) & 0xffffffffL; 32 l = ROTATE(l, 29) & 0xffffffffL; 33 34 s = ks->ks->deslong; 35 /* 36 * I don't know if it is worth the effort of loop unrolling the inner 37 * loop 38 */ 39 if (enc) { 40 D_ENCRYPT(l, r, 0); /* 1 */ 41 D_ENCRYPT(r, l, 2); /* 2 */ 42 D_ENCRYPT(l, r, 4); /* 3 */ 43 D_ENCRYPT(r, l, 6); /* 4 */ 44 D_ENCRYPT(l, r, 8); /* 5 */ 45 D_ENCRYPT(r, l, 10); /* 6 */ 46 D_ENCRYPT(l, r, 12); /* 7 */ 47 D_ENCRYPT(r, l, 14); /* 8 */ 48 D_ENCRYPT(l, r, 16); /* 9 */ 49 D_ENCRYPT(r, l, 18); /* 10 */ 50 D_ENCRYPT(l, r, 20); /* 11 */ 51 D_ENCRYPT(r, l, 22); /* 12 */ 52 D_ENCRYPT(l, r, 24); /* 13 */ 53 D_ENCRYPT(r, l, 26); /* 14 */ 54 D_ENCRYPT(l, r, 28); /* 15 */ 55 D_ENCRYPT(r, l, 30); /* 16 */ 56 } else { 57 D_ENCRYPT(l, r, 30); /* 16 */ 58 D_ENCRYPT(r, l, 28); /* 15 */ 59 D_ENCRYPT(l, r, 26); /* 14 */ 60 D_ENCRYPT(r, l, 24); /* 13 */ 61 D_ENCRYPT(l, r, 22); /* 12 */ 62 D_ENCRYPT(r, l, 20); /* 11 */ 63 D_ENCRYPT(l, r, 18); /* 10 */ 64 D_ENCRYPT(r, l, 16); /* 9 */ 65 D_ENCRYPT(l, r, 14); /* 8 */ 66 D_ENCRYPT(r, l, 12); /* 7 */ 67 D_ENCRYPT(l, r, 10); /* 6 */ 68 D_ENCRYPT(r, l, 8); /* 5 */ 69 D_ENCRYPT(l, r, 6); /* 4 */ 70 D_ENCRYPT(r, l, 4); /* 3 */ 71 D_ENCRYPT(l, r, 2); /* 2 */ 72 D_ENCRYPT(r, l, 0); /* 1 */ 73 } 74 75 /* rotate and clear the top bits on machines with 8byte longs */ 76 l = ROTATE(l, 3) & 0xffffffffL; 77 r = ROTATE(r, 3) & 0xffffffffL; 78 79 FP(r, l); 80 data[0] = l; 81 data[1] = r; 82 l = r = t = u = 0; 83 } 84 85 void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc) 86 { 87 register DES_LONG l, r, t, u; 88 register DES_LONG *s; 89 90 r = data[0]; 91 l = data[1]; 92 93 /* 94 * Things have been modified so that the initial rotate is done outside 95 * the loop. This required the DES_SPtrans values in sp.h to be rotated 96 * 1 bit to the right. One perl script later and things have a 5% speed 97 * up on a sparc2. Thanks to Richard Outerbridge for pointing this out. 98 */ 99 /* clear the top bits on machines with 8byte longs */ 100 r = ROTATE(r, 29) & 0xffffffffL; 101 l = ROTATE(l, 29) & 0xffffffffL; 102 103 s = ks->ks->deslong; 104 /* 105 * I don't know if it is worth the effort of loop unrolling the inner 106 * loop 107 */ 108 if (enc) { 109 D_ENCRYPT(l, r, 0); /* 1 */ 110 D_ENCRYPT(r, l, 2); /* 2 */ 111 D_ENCRYPT(l, r, 4); /* 3 */ 112 D_ENCRYPT(r, l, 6); /* 4 */ 113 D_ENCRYPT(l, r, 8); /* 5 */ 114 D_ENCRYPT(r, l, 10); /* 6 */ 115 D_ENCRYPT(l, r, 12); /* 7 */ 116 D_ENCRYPT(r, l, 14); /* 8 */ 117 D_ENCRYPT(l, r, 16); /* 9 */ 118 D_ENCRYPT(r, l, 18); /* 10 */ 119 D_ENCRYPT(l, r, 20); /* 11 */ 120 D_ENCRYPT(r, l, 22); /* 12 */ 121 D_ENCRYPT(l, r, 24); /* 13 */ 122 D_ENCRYPT(r, l, 26); /* 14 */ 123 D_ENCRYPT(l, r, 28); /* 15 */ 124 D_ENCRYPT(r, l, 30); /* 16 */ 125 } else { 126 D_ENCRYPT(l, r, 30); /* 16 */ 127 D_ENCRYPT(r, l, 28); /* 15 */ 128 D_ENCRYPT(l, r, 26); /* 14 */ 129 D_ENCRYPT(r, l, 24); /* 13 */ 130 D_ENCRYPT(l, r, 22); /* 12 */ 131 D_ENCRYPT(r, l, 20); /* 11 */ 132 D_ENCRYPT(l, r, 18); /* 10 */ 133 D_ENCRYPT(r, l, 16); /* 9 */ 134 D_ENCRYPT(l, r, 14); /* 8 */ 135 D_ENCRYPT(r, l, 12); /* 7 */ 136 D_ENCRYPT(l, r, 10); /* 6 */ 137 D_ENCRYPT(r, l, 8); /* 5 */ 138 D_ENCRYPT(l, r, 6); /* 4 */ 139 D_ENCRYPT(r, l, 4); /* 3 */ 140 D_ENCRYPT(l, r, 2); /* 2 */ 141 D_ENCRYPT(r, l, 0); /* 1 */ 142 } 143 /* rotate and clear the top bits on machines with 8byte longs */ 144 data[0] = ROTATE(l, 3) & 0xffffffffL; 145 data[1] = ROTATE(r, 3) & 0xffffffffL; 146 l = r = t = u = 0; 147 } 148 149 void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, 150 DES_key_schedule *ks2, DES_key_schedule *ks3) 151 { 152 register DES_LONG l, r; 153 154 l = data[0]; 155 r = data[1]; 156 IP(l, r); 157 data[0] = l; 158 data[1] = r; 159 DES_encrypt2((DES_LONG *)data, ks1, DES_ENCRYPT); 160 DES_encrypt2((DES_LONG *)data, ks2, DES_DECRYPT); 161 DES_encrypt2((DES_LONG *)data, ks3, DES_ENCRYPT); 162 l = data[0]; 163 r = data[1]; 164 FP(r, l); 165 data[0] = l; 166 data[1] = r; 167 } 168 169 void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, 170 DES_key_schedule *ks2, DES_key_schedule *ks3) 171 { 172 register DES_LONG l, r; 173 174 l = data[0]; 175 r = data[1]; 176 IP(l, r); 177 data[0] = l; 178 data[1] = r; 179 DES_encrypt2((DES_LONG *)data, ks3, DES_DECRYPT); 180 DES_encrypt2((DES_LONG *)data, ks2, DES_ENCRYPT); 181 DES_encrypt2((DES_LONG *)data, ks1, DES_DECRYPT); 182 l = data[0]; 183 r = data[1]; 184 FP(r, l); 185 data[0] = l; 186 data[1] = r; 187 } 188 189 #ifndef DES_DEFAULT_OPTIONS 190 191 # undef CBC_ENC_C__DONT_UPDATE_IV 192 # include "ncbc_enc.c" /* DES_ncbc_encrypt */ 193 194 void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output, 195 long length, DES_key_schedule *ks1, 196 DES_key_schedule *ks2, DES_key_schedule *ks3, 197 DES_cblock *ivec, int enc) 198 { 199 register DES_LONG tin0, tin1; 200 register DES_LONG tout0, tout1, xor0, xor1; 201 register const unsigned char *in; 202 unsigned char *out; 203 register long l = length; 204 DES_LONG tin[2]; 205 unsigned char *iv; 206 207 in = input; 208 out = output; 209 iv = &(*ivec)[0]; 210 211 if (enc) { 212 c2l(iv, tout0); 213 c2l(iv, tout1); 214 for (l -= 8; l >= 0; l -= 8) { 215 c2l(in, tin0); 216 c2l(in, tin1); 217 tin0 ^= tout0; 218 tin1 ^= tout1; 219 220 tin[0] = tin0; 221 tin[1] = tin1; 222 DES_encrypt3((DES_LONG *)tin, ks1, ks2, ks3); 223 tout0 = tin[0]; 224 tout1 = tin[1]; 225 226 l2c(tout0, out); 227 l2c(tout1, out); 228 } 229 if (l != -8) { 230 c2ln(in, tin0, tin1, l + 8); 231 tin0 ^= tout0; 232 tin1 ^= tout1; 233 234 tin[0] = tin0; 235 tin[1] = tin1; 236 DES_encrypt3((DES_LONG *)tin, ks1, ks2, ks3); 237 tout0 = tin[0]; 238 tout1 = tin[1]; 239 240 l2c(tout0, out); 241 l2c(tout1, out); 242 } 243 iv = &(*ivec)[0]; 244 l2c(tout0, iv); 245 l2c(tout1, iv); 246 } else { 247 register DES_LONG t0, t1; 248 249 c2l(iv, xor0); 250 c2l(iv, xor1); 251 for (l -= 8; l >= 0; l -= 8) { 252 c2l(in, tin0); 253 c2l(in, tin1); 254 255 t0 = tin0; 256 t1 = tin1; 257 258 tin[0] = tin0; 259 tin[1] = tin1; 260 DES_decrypt3((DES_LONG *)tin, ks1, ks2, ks3); 261 tout0 = tin[0]; 262 tout1 = tin[1]; 263 264 tout0 ^= xor0; 265 tout1 ^= xor1; 266 l2c(tout0, out); 267 l2c(tout1, out); 268 xor0 = t0; 269 xor1 = t1; 270 } 271 if (l != -8) { 272 c2l(in, tin0); 273 c2l(in, tin1); 274 275 t0 = tin0; 276 t1 = tin1; 277 278 tin[0] = tin0; 279 tin[1] = tin1; 280 DES_decrypt3((DES_LONG *)tin, ks1, ks2, ks3); 281 tout0 = tin[0]; 282 tout1 = tin[1]; 283 284 tout0 ^= xor0; 285 tout1 ^= xor1; 286 l2cn(tout0, tout1, out, l + 8); 287 xor0 = t0; 288 xor1 = t1; 289 } 290 291 iv = &(*ivec)[0]; 292 l2c(xor0, iv); 293 l2c(xor1, iv); 294 } 295 tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0; 296 tin[0] = tin[1] = 0; 297 } 298 299 #endif /* DES_DEFAULT_OPTIONS */ 300