des.c (17547B)
1 /* 2 * FreeSec: libcrypt for NetBSD 3 * 4 * Copyright (c) 1994 David Burren 5 * All rights reserved. 6 * 7 * Adapted for FreeBSD-2.0 by Geoffrey M. Rehmet 8 * this file should now *only* export crypt(), in order to make 9 * binaries of libcrypt exportable from the USA 10 * 11 * Adapted for FreeBSD-4.0 by Mark R V Murray 12 * this file should now *only* export crypt_des(), in order to make 13 * a module that can be optionally included in libcrypt. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 3. Neither the name of the author nor the names of other contributors 24 * may be used to endorse or promote products derived from this software 25 * without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 30 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 37 * SUCH DAMAGE. 38 * 39 * This is an original implementation of the DES and the crypt(3) interfaces 40 * by David Burren <davidb@werj.com.au>. 41 * 42 * An excellent reference on the underlying algorithm (and related 43 * algorithms) is: 44 * 45 * B. Schneier, Applied Cryptography: protocols, algorithms, 46 * and source code in C, John Wiley & Sons, 1994. 47 * 48 * Note that in that book's description of DES the lookups for the initial, 49 * pbox, and final permutations are inverted (this has been brought to the 50 * attention of the author). A list of errata for this book has been 51 * posted to the sci.crypt newsgroup by the author and is available for FTP. 52 * 53 * ARCHITECTURE ASSUMPTIONS: 54 * It is assumed that the 8-byte arrays passed by reference can be 55 * addressed as arrays of uint32_t's (ie. the CPU is not picky about 56 * alignment). 57 */ 58 59 #include <arpa/inet.h> 60 #include <stdint.h> 61 #include <string.h> 62 #include "des.h" 63 64 static uint8_t IP[64] = { 65 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 66 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 67 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 68 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7, 69 }; 70 71 static uint8_t inv_key_perm[64]; 72 static uint8_t key_perm[56] = { 73 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 74 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 75 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 76 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4, 77 }; 78 79 static uint8_t key_shifts[16] = { 80 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 81 }; 82 83 static uint8_t inv_comp_perm[56]; 84 static uint8_t comp_perm[48] = { 85 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 86 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 87 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 88 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32, 89 }; 90 91 /* No E box is used, as it's replaced by some ANDs, shifts, and ORs. */ 92 93 static uint8_t u_sbox[8][64]; 94 static uint8_t sbox[8][64] = { 95 { 96 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 97 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 98 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, 99 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13, 100 }, 101 { 102 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 103 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 104 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, 105 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9, 106 }, 107 { 108 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 109 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 110 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, 111 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12, 112 }, 113 { 114 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 115 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 116 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, 117 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14, 118 }, 119 { 120 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 121 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 122 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, 123 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3, 124 }, 125 { 126 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 127 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 128 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, 129 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13, 130 }, 131 { 132 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 133 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 134 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, 135 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12, 136 }, 137 { 138 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 139 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 140 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, 141 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11, 142 } 143 }; 144 145 static uint8_t un_pbox[32]; 146 static uint8_t pbox[32] = { 147 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, 148 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25 149 }; 150 151 static uint32_t bits32[32] = { 152 0x80000000, 0x40000000, 0x20000000, 0x10000000, 153 0x08000000, 0x04000000, 0x02000000, 0x01000000, 154 0x00800000, 0x00400000, 0x00200000, 0x00100000, 155 0x00080000, 0x00040000, 0x00020000, 0x00010000, 156 0x00008000, 0x00004000, 0x00002000, 0x00001000, 157 0x00000800, 0x00000400, 0x00000200, 0x00000100, 158 0x00000080, 0x00000040, 0x00000020, 0x00000010, 159 0x00000008, 0x00000004, 0x00000002, 0x00000001 160 }; 161 162 static uint8_t bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; 163 164 static uint32_t saltbits; 165 static uint32_t old_salt; 166 static uint32_t *bits28, *bits24; 167 static uint8_t init_perm[64], final_perm[64]; 168 static uint32_t en_keysl[16], en_keysr[16]; 169 static uint32_t de_keysl[16], de_keysr[16]; 170 static int des_initialised = 0; 171 static uint8_t m_sbox[4][4096]; 172 static uint32_t psbox[4][256]; 173 static uint32_t ip_maskl[8][256], ip_maskr[8][256]; 174 static uint32_t fp_maskl[8][256], fp_maskr[8][256]; 175 static uint32_t key_perm_maskl[8][128], key_perm_maskr[8][128]; 176 static uint32_t comp_maskl[8][128], comp_maskr[8][128]; 177 static uint32_t old_rawkey0, old_rawkey1; 178 179 static uint8_t ascii64[] = 180 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 181 /* 0000000000111111111122222222223333333333444444444455555555556666 */ 182 /* 0123456789012345678901234567890123456789012345678901234567890123 */ 183 184 static inline int 185 ascii_to_bin(char ch) 186 { 187 if (ch > 'z') 188 return 0; 189 if (ch >= 'a') 190 return ch - 'a' + 38; 191 if (ch > 'Z') 192 return 0; 193 if (ch >= 'A') 194 return ch - 'A' + 12; 195 if (ch > '9') 196 return 0; 197 if (ch >= '.') 198 return ch - '.'; 199 return 0; 200 } 201 202 static void 203 des_init(void) 204 { 205 int i, j, b, k, inbit, obit; 206 uint32_t *p, *il, *ir, *fl, *fr; 207 208 old_rawkey0 = old_rawkey1 = 0L; 209 saltbits = 0L; 210 old_salt = 0L; 211 bits24 = (bits28 = bits32 + 4) + 4; 212 213 /* Invert the S-boxes, reordering the input bits. */ 214 for (i = 0; i < 8; i++) 215 for (j = 0; j < 64; j++) { 216 b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf); 217 u_sbox[i][j] = sbox[i][b]; 218 } 219 220 /* 221 * Convert the inverted S-boxes into 4 arrays of 8 bits. 222 * Each will handle 12 bits of the S-box input. 223 */ 224 for (b = 0; b < 4; b++) 225 for (i = 0; i < 64; i++) 226 for (j = 0; j < 64; j++) 227 m_sbox[b][(i << 6) | j] = 228 (uint8_t)((u_sbox[(b << 1)][i] << 4) | 229 u_sbox[(b << 1) + 1][j]); 230 231 /* 232 * Set up the initial & final permutations into a useful form, and 233 * initialise the inverted key permutation. 234 */ 235 for (i = 0; i < 64; i++) { 236 init_perm[final_perm[i] = IP[i] - 1] = (uint8_t)i; 237 inv_key_perm[i] = 255; 238 } 239 240 /* 241 * Invert the key permutation and initialise the inverted key 242 * compression permutation. 243 */ 244 for (i = 0; i < 56; i++) { 245 inv_key_perm[key_perm[i] - 1] = (uint8_t)i; 246 inv_comp_perm[i] = 255; 247 } 248 249 /* Invert the key compression permutation. */ 250 for (i = 0; i < 48; i++) { 251 inv_comp_perm[comp_perm[i] - 1] = (uint8_t)i; 252 } 253 254 /* 255 * Set up the OR-mask arrays for the initial and final permutations, 256 * and for the key initial and compression permutations. 257 */ 258 for (k = 0; k < 8; k++) { 259 for (i = 0; i < 256; i++) { 260 *(il = &ip_maskl[k][i]) = 0L; 261 *(ir = &ip_maskr[k][i]) = 0L; 262 *(fl = &fp_maskl[k][i]) = 0L; 263 *(fr = &fp_maskr[k][i]) = 0L; 264 for (j = 0; j < 8; j++) { 265 inbit = 8 * k + j; 266 if (i & bits8[j]) { 267 if ((obit = init_perm[inbit]) < 32) 268 *il |= bits32[obit]; 269 else 270 *ir |= bits32[obit-32]; 271 272 if ((obit = final_perm[inbit]) < 32) 273 *fl |= bits32[obit]; 274 else 275 *fr |= bits32[obit - 32]; 276 } 277 } 278 } 279 for (i = 0; i < 128; i++) { 280 *(il = &key_perm_maskl[k][i]) = 0L; 281 *(ir = &key_perm_maskr[k][i]) = 0L; 282 for (j = 0; j < 7; j++) { 283 inbit = 8 * k + j; 284 if (i & bits8[j + 1]) { 285 if ((obit = inv_key_perm[inbit]) == 255) 286 continue; 287 288 if (obit < 28) 289 *il |= bits28[obit]; 290 else 291 *ir |= bits28[obit - 28]; 292 } 293 } 294 295 *(il = &comp_maskl[k][i]) = 0L; 296 *(ir = &comp_maskr[k][i]) = 0L; 297 298 for (j = 0; j < 7; j++) { 299 inbit = 7 * k + j; 300 if (i & bits8[j + 1]) { 301 if ((obit=inv_comp_perm[inbit]) == 255) 302 continue; 303 304 if (obit < 24) 305 *il |= bits24[obit]; 306 else 307 *ir |= bits24[obit - 24]; 308 } 309 } 310 } 311 } 312 313 /* 314 * Invert the P-box permutation, and convert into OR-masks for 315 * handling the output of the S-box arrays setup above. 316 */ 317 for (i = 0; i < 32; i++) 318 un_pbox[pbox[i] - 1] = (uint8_t) i; 319 320 for (b = 0; b < 4; b++) 321 for (i = 0; i < 256; i++) { 322 *(p = &psbox[b][i]) = 0L; 323 for (j = 0; j < 8; j++) { 324 if (i & bits8[j]) 325 *p |= bits32[un_pbox[8 * b + j]]; 326 } 327 } 328 329 des_initialised = 1; 330 } 331 332 static void 333 setup_salt(uint32_t salt) 334 { 335 uint32_t obit, saltbit; 336 337 if (salt == old_salt) 338 return; 339 old_salt = salt; 340 341 saltbits = 0L; 342 saltbit = 1; 343 obit = 0x800000; 344 for (int i = 0; i < 24; i++) { 345 if (salt & saltbit) 346 saltbits |= obit; 347 saltbit <<= 1; 348 obit >>= 1; 349 } 350 } 351 352 static int 353 des_setkey(const char *key) 354 { 355 uint32_t k0, k1, rawkey0, rawkey1; 356 int shifts, round; 357 358 if (!des_initialised) 359 des_init(); 360 361 rawkey0 = ntohl(*(const uint32_t *) key); 362 rawkey1 = ntohl(*(const uint32_t *) (key + 4)); 363 364 if ((rawkey0 | rawkey1) 365 && rawkey0 == old_rawkey0 366 && rawkey1 == old_rawkey1) { 367 /* 368 * Already setup for this key. 369 * This optimisation fails on a zero key (which is weak and 370 * has bad parity anyway) in order to simplify the starting 371 * conditions. 372 */ 373 return 0; 374 } 375 old_rawkey0 = rawkey0; 376 old_rawkey1 = rawkey1; 377 378 /* 379 * Do key permutation and split into two 28-bit subkeys. 380 */ 381 k0 = key_perm_maskl[0][rawkey0 >> 25] 382 | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f] 383 | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f] 384 | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f] 385 | key_perm_maskl[4][rawkey1 >> 25] 386 | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f] 387 | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f] 388 | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f]; 389 k1 = key_perm_maskr[0][rawkey0 >> 25] 390 | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f] 391 | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f] 392 | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f] 393 | key_perm_maskr[4][rawkey1 >> 25] 394 | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f] 395 | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f] 396 | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f]; 397 /* 398 * Rotate subkeys and do compression permutation. 399 */ 400 shifts = 0; 401 for (round = 0; round < 16; round++) { 402 uint32_t t0, t1; 403 404 shifts += key_shifts[round]; 405 406 t0 = (k0 << shifts) | (k0 >> (28 - shifts)); 407 t1 = (k1 << shifts) | (k1 >> (28 - shifts)); 408 409 de_keysl[15 - round] = 410 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f] 411 | comp_maskl[1][(t0 >> 14) & 0x7f] 412 | comp_maskl[2][(t0 >> 7) & 0x7f] 413 | comp_maskl[3][t0 & 0x7f] 414 | comp_maskl[4][(t1 >> 21) & 0x7f] 415 | comp_maskl[5][(t1 >> 14) & 0x7f] 416 | comp_maskl[6][(t1 >> 7) & 0x7f] 417 | comp_maskl[7][t1 & 0x7f]; 418 419 de_keysr[15 - round] = 420 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f] 421 | comp_maskr[1][(t0 >> 14) & 0x7f] 422 | comp_maskr[2][(t0 >> 7) & 0x7f] 423 | comp_maskr[3][t0 & 0x7f] 424 | comp_maskr[4][(t1 >> 21) & 0x7f] 425 | comp_maskr[5][(t1 >> 14) & 0x7f] 426 | comp_maskr[6][(t1 >> 7) & 0x7f] 427 | comp_maskr[7][t1 & 0x7f]; 428 } 429 return 0; 430 } 431 432 static int 433 do_des(uint32_t l_in, uint32_t r_in, uint32_t *l_out, uint32_t *r_out, int count) 434 { 435 /* l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format. */ 436 uint32_t l, r, *kl, *kr, *kl1, *kr1; 437 uint32_t f, r48l, r48r; 438 int round; 439 440 if (count == 0) { 441 return 1; 442 } else if (count > 0) { 443 /* 444 * Encrypting 445 */ 446 kl1 = en_keysl; 447 kr1 = en_keysr; 448 } else { 449 /* 450 * Decrypting 451 */ 452 count = -count; 453 kl1 = de_keysl; 454 kr1 = de_keysr; 455 } 456 457 /* Do initial permutation (IP) */ 458 l = ip_maskl[0][l_in >> 24] 459 | ip_maskl[1][(l_in >> 16) & 0xff] 460 | ip_maskl[2][(l_in >> 8) & 0xff] 461 | ip_maskl[3][l_in & 0xff] 462 | ip_maskl[4][r_in >> 24] 463 | ip_maskl[5][(r_in >> 16) & 0xff] 464 | ip_maskl[6][(r_in >> 8) & 0xff] 465 | ip_maskl[7][r_in & 0xff]; 466 467 r = ip_maskr[0][l_in >> 24] 468 | ip_maskr[1][(l_in >> 16) & 0xff] 469 | ip_maskr[2][(l_in >> 8) & 0xff] 470 | ip_maskr[3][l_in & 0xff] 471 | ip_maskr[4][r_in >> 24] 472 | ip_maskr[5][(r_in >> 16) & 0xff] 473 | ip_maskr[6][(r_in >> 8) & 0xff] 474 | ip_maskr[7][r_in & 0xff]; 475 476 while (count--) { 477 /* Do each round */ 478 kl = kl1; 479 kr = kr1; 480 round = 16; 481 while (round--) { 482 /* Expand R to 48 bits (simulate the E-box) */ 483 r48l = ((r & 0x00000001) << 23) 484 | ((r & 0xf8000000) >> 9) 485 | ((r & 0x1f800000) >> 11) 486 | ((r & 0x01f80000) >> 13) 487 | ((r & 0x001f8000) >> 15); 488 489 r48r = ((r & 0x0001f800) << 7) 490 | ((r & 0x00001f80) << 5) 491 | ((r & 0x000001f8) << 3) 492 | ((r & 0x0000001f) << 1) 493 | ((r & 0x80000000) >> 31); 494 495 /* 496 * Do salting for crypt() and friends, 497 * and XOR with the permuted key. 498 */ 499 f = (r48l ^ r48r) & saltbits; 500 r48l ^= f ^ *kl++; 501 r48r ^= f ^ *kr++; 502 503 /* 504 * Do sbox lookups (which shrink it back to 32 bits) 505 * and do the pbox permutation at the same time. 506 */ 507 f = psbox[0][m_sbox[0][r48l >> 12]] 508 | psbox[1][m_sbox[1][r48l & 0xfff]] 509 | psbox[2][m_sbox[2][r48r >> 12]] 510 | psbox[3][m_sbox[3][r48r & 0xfff]]; 511 512 /* Now that we've permuted things, complete f() */ 513 f ^= l; 514 l = r; 515 r = f; 516 } 517 r = l; 518 l = f; 519 } 520 521 /* Do final permutation (inverse of IP) */ 522 *l_out = fp_maskl[0][l >> 24] 523 | fp_maskl[1][(l >> 16) & 0xff] 524 | fp_maskl[2][(l >> 8) & 0xff] 525 | fp_maskl[3][l & 0xff] 526 | fp_maskl[4][r >> 24] 527 | fp_maskl[5][(r >> 16) & 0xff] 528 | fp_maskl[6][(r >> 8) & 0xff] 529 | fp_maskl[7][r & 0xff]; 530 *r_out = fp_maskr[0][l >> 24] 531 | fp_maskr[1][(l >> 16) & 0xff] 532 | fp_maskr[2][(l >> 8) & 0xff] 533 | fp_maskr[3][l & 0xff] 534 | fp_maskr[4][r >> 24] 535 | fp_maskr[5][(r >> 16) & 0xff] 536 | fp_maskr[6][(r >> 8) & 0xff] 537 | fp_maskr[7][r & 0xff]; 538 539 return 0; 540 } 541 542 int 543 des(const char *key, const char *setting, char buffer[DES_BUFFER_SIZE]) 544 { 545 uint32_t count, salt, l, r0, r1, keybuf[2]; 546 uint8_t *q; 547 548 if (!des_initialised) 549 des_init(); 550 551 /* 552 * Copy the key, shifting each character up by one bit 553 * and padding with zeros. 554 */ 555 q = (uint8_t *) keybuf; 556 while (q - (uint8_t *) keybuf - 8) { 557 *q++ = *key << 1; 558 if (*key != '\0') 559 key++; 560 } 561 if (des_setkey((char *) keybuf)) 562 return -1; 563 564 /* 565 * "old"-style des: 566 * setting - 2 bytes of salt 567 * key - up to 8 characters 568 */ 569 count = 25; 570 571 salt = (ascii_to_bin(setting[1]) << 6) 572 | ascii_to_bin(setting[0]); 573 574 *buffer++ = setting[0]; 575 /* 576 * If the encrypted password that the salt was extracted from 577 * is only 1 character long, the salt will be corrupted. We 578 * need to ensure that the output string doesn't have an extra 579 * NUL in it! 580 */ 581 *buffer++ = setting[1] ? setting[1] : setting[0]; 582 583 setup_salt(salt); 584 585 /* Do it */ 586 if (do_des(0L, 0L, &r0, &r1, (int) count)) 587 return -1; 588 589 /* Now encode the result... */ 590 l = (r0 >> 8); 591 *buffer++ = ascii64[(l >> 18) & 0x3f]; 592 *buffer++ = ascii64[(l >> 12) & 0x3f]; 593 *buffer++ = ascii64[(l >> 6) & 0x3f]; 594 *buffer++ = ascii64[l & 0x3f]; 595 596 l = (r0 << 16) | ((r1 >> 16) & 0xffff); 597 *buffer++ = ascii64[(l >> 18) & 0x3f]; 598 *buffer++ = ascii64[(l >> 12) & 0x3f]; 599 *buffer++ = ascii64[(l >> 6) & 0x3f]; 600 *buffer++ = ascii64[l & 0x3f]; 601 602 l = r1 << 2; 603 *buffer++ = ascii64[(l >> 12) & 0x3f]; 604 *buffer++ = ascii64[(l >> 6) & 0x3f]; 605 *buffer++ = ascii64[l & 0x3f]; 606 *buffer = '\0'; 607 608 return 0; 609 }