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