?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ac(8): Staticize and raise WARNS to 6.
[dragonfly.git] / lib / libcrypt / crypt-des.c
blobb2426b54ca89a483cc6d995e64fd09aba3675e84
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 * $FreeBSD: src/secure/lib/libcrypt/crypt-des.c,v 1.12 1999/09/20 12:39:20 markm Exp $
40 *
41 * This is an original implementation of the DES and the crypt(3) interfaces
42 * by David Burren <davidb@werj.com.au>.
43 *
44 * An excellent reference on the underlying algorithm (and related
45 * algorithms) is:
46 *
47 * B. Schneier, Applied Cryptography: protocols, algorithms,
48 * and source code in C, John Wiley & Sons, 1994.
49 *
50 * Note that in that book's description of DES the lookups for the initial,
51 * pbox, and final permutations are inverted (this has been brought to the
52 * attention of the author). A list of errata for this book has been
53 * posted to the sci.crypt newsgroup by the author and is available for FTP.
54 *
55 * ARCHITECTURE ASSUMPTIONS:
56 * It is assumed that the 8-byte arrays passed by reference can be
57 * addressed as arrays of u_int32_t's (ie. the CPU is not picky about
58 * alignment).
59 */
60 #include <sys/types.h>
61 #include <sys/param.h>
62 #include <pwd.h>
63 #include <string.h>
64 #include "crypt.h"
65
66 /* We can't always assume gcc */
67 #ifdef __GNUC__
68 #define INLINE inline
69 #endif
70
71
72 static u_char IP[64] = {
73 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
74 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
75 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
76 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
77 };
78
79 static u_char inv_key_perm[64];
80 static u_char u_key_perm[56];
81 static u_char key_perm[56] = {
82 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
83 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
84 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
85 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
86 };
87
88 static u_char key_shifts[16] = {
89 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
90 };
91
92 static u_char inv_comp_perm[56];
93 static u_char comp_perm[48] = {
94 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
95 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
96 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
97 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
98 };
99
100 /*
101 * No E box is used, as it's replaced by some ANDs, shifts, and ORs.
102 */
103
104 static u_char u_sbox[8][64];
105 static u_char sbox[8][64] = {
106 {
107 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
108 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
109 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
110 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13
111 },
112 {
113 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
114 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
115 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
116 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9
117 },
118 {
119 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
120 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
121 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
122 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12
123 },
124 {
125 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
126 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
127 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
128 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14
129 },
130 {
131 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
132 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
133 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
134 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3
135 },
136 {
137 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
138 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
139 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
140 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13
141 },
142 {
143 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
144 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
145 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
146 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12
147 },
148 {
149 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
150 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
151 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
152 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
153 }
154 };
155
156 static u_char un_pbox[32];
157 static u_char pbox[32] = {
158 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
159 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
160 };
161
162 static u_int32_t bits32[32] =
163 {
164 0x80000000, 0x40000000, 0x20000000, 0x10000000,
165 0x08000000, 0x04000000, 0x02000000, 0x01000000,
166 0x00800000, 0x00400000, 0x00200000, 0x00100000,
167 0x00080000, 0x00040000, 0x00020000, 0x00010000,
168 0x00008000, 0x00004000, 0x00002000, 0x00001000,
169 0x00000800, 0x00000400, 0x00000200, 0x00000100,
170 0x00000080, 0x00000040, 0x00000020, 0x00000010,
171 0x00000008, 0x00000004, 0x00000002, 0x00000001
172 };
173
174 static u_char bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
175
176 static u_int32_t saltbits;
177 static long old_salt;
178 static u_int32_t *bits28, *bits24;
179 static u_char init_perm[64], final_perm[64];
180 static u_int32_t en_keysl[16], en_keysr[16];
181 static u_int32_t de_keysl[16], de_keysr[16];
182 static int des_initialised = 0;
183 static u_char m_sbox[4][4096];
184 static u_int32_t psbox[4][256];
185 static u_int32_t ip_maskl[8][256], ip_maskr[8][256];
186 static u_int32_t fp_maskl[8][256], fp_maskr[8][256];
187 static u_int32_t key_perm_maskl[8][128], key_perm_maskr[8][128];
188 static u_int32_t comp_maskl[8][128], comp_maskr[8][128];
189 static u_int32_t old_rawkey0, old_rawkey1;
190
191 static u_char ascii64[] =
192 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
193 /* 0000000000111111111122222222223333333333444444444455555555556666 */
194 /* 0123456789012345678901234567890123456789012345678901234567890123 */
195
196 static INLINE int
197 ascii_to_bin(char ch)
198 {
199 if (ch > 'z')
200 return(0);
201 if (ch >= 'a')
202 return(ch - 'a' + 38);
203 if (ch > 'Z')
204 return(0);
205 if (ch >= 'A')
206 return(ch - 'A' + 12);
207 if (ch > '9')
208 return(0);
209 if (ch >= '.')
210 return(ch - '.');
211 return(0);
212 }
213
214 static void
215 des_init(void)
216 {
217 int i, j, b, k, inbit, obit;
218 u_int32_t *p, *il, *ir, *fl, *fr;
219
220 old_rawkey0 = old_rawkey1 = 0L;
221 saltbits = 0L;
222 old_salt = 0L;
223 bits24 = (bits28 = bits32 + 4) + 4;
224
225 /*
226 * Invert the S-boxes, reordering the input bits.
227 */
228 for (i = 0; i < 8; i++)
229 for (j = 0; j < 64; j++) {
230 b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
231 u_sbox[i][j] = sbox[i][b];
232 }
233
234 /*
235 * Convert the inverted S-boxes into 4 arrays of 8 bits.
236 * Each will handle 12 bits of the S-box input.
237 */
238 for (b = 0; b < 4; b++)
239 for (i = 0; i < 64; i++)
240 for (j = 0; j < 64; j++)
241 m_sbox[b][(i << 6) | j] =
242 (u_sbox[(b << 1)][i] << 4) |
243 u_sbox[(b << 1) + 1][j];
244
245 /*
246 * Set up the initial & final permutations into a useful form, and
247 * initialise the inverted key permutation.
248 */
249 for (i = 0; i < 64; i++) {
250 init_perm[final_perm[i] = IP[i] - 1] = i;
251 inv_key_perm[i] = 255;
252 }
253
254 /*
255 * Invert the key permutation and initialise the inverted key
256 * compression permutation.
257 */
258 for (i = 0; i < 56; i++) {
259 u_key_perm[i] = key_perm[i] - 1;
260 inv_key_perm[key_perm[i] - 1] = i;
261 inv_comp_perm[i] = 255;
262 }
263
264 /*
265 * Invert the key compression permutation.
266 */
267 for (i = 0; i < 48; i++) {
268 inv_comp_perm[comp_perm[i] - 1] = i;
269 }
270
271 /*
272 * Set up the OR-mask arrays for the initial and final permutations,
273 * and for the key initial and compression permutations.
274 */
275 for (k = 0; k < 8; k++) {
276 for (i = 0; i < 256; i++) {
277 *(il = &ip_maskl[k][i]) = 0L;
278 *(ir = &ip_maskr[k][i]) = 0L;
279 *(fl = &fp_maskl[k][i]) = 0L;
280 *(fr = &fp_maskr[k][i]) = 0L;
281 for (j = 0; j < 8; j++) {
282 inbit = 8 * k + j;
283 if (i & bits8[j]) {
284 if ((obit = init_perm[inbit]) < 32)
285 *il |= bits32[obit];
286 else
287 *ir |= bits32[obit-32];
288 if ((obit = final_perm[inbit]) < 32)
289 *fl |= bits32[obit];
290 else
291 *fr |= bits32[obit - 32];
292 }
293 }
294 }
295 for (i = 0; i < 128; i++) {
296 *(il = &key_perm_maskl[k][i]) = 0L;
297 *(ir = &key_perm_maskr[k][i]) = 0L;
298 for (j = 0; j < 7; j++) {
299 inbit = 8 * k + j;
300 if (i & bits8[j + 1]) {
301 if ((obit = inv_key_perm[inbit]) == 255)
302 continue;
303 if (obit < 28)
304 *il |= bits28[obit];
305 else
306 *ir |= bits28[obit - 28];
307 }
308 }
309 *(il = &comp_maskl[k][i]) = 0L;
310 *(ir = &comp_maskr[k][i]) = 0L;
311 for (j = 0; j < 7; j++) {
312 inbit = 7 * k + j;
313 if (i & bits8[j + 1]) {
314 if ((obit=inv_comp_perm[inbit]) == 255)
315 continue;
316 if (obit < 24)
317 *il |= bits24[obit];
318 else
319 *ir |= bits24[obit - 24];
320 }
321 }
322 }
323 }
324
325 /*
326 * Invert the P-box permutation, and convert into OR-masks for
327 * handling the output of the S-box arrays setup above.
328 */
329 for (i = 0; i < 32; i++)
330 un_pbox[pbox[i] - 1] = i;
331
332 for (b = 0; b < 4; b++)
333 for (i = 0; i < 256; i++) {
334 *(p = &psbox[b][i]) = 0L;
335 for (j = 0; j < 8; j++) {
336 if (i & bits8[j])
337 *p |= bits32[un_pbox[8 * b + j]];
338 }
339 }
340
341 des_initialised = 1;
342 }
343
344 static void
345 setup_salt(long salt)
346 {
347 u_int32_t obit, saltbit;
348 int i;
349
350 if (salt == old_salt)
351 return;
352 old_salt = salt;
353
354 saltbits = 0L;
355 saltbit = 1;
356 obit = 0x800000;
357 for (i = 0; i < 24; i++) {
358 if (salt & saltbit)
359 saltbits |= obit;
360 saltbit <<= 1;
361 obit >>= 1;
362 }
363 }
364
365 static int
366 des_setkey(const char *key)
367 {
368 u_int32_t k0, k1, rawkey0, rawkey1;
369 int shifts, round;
370
371 if (!des_initialised)
372 des_init();
373
374 rawkey0 = ntohl(*(u_int32_t *) key);
375 rawkey1 = ntohl(*(u_int32_t *) (key + 4));
376
377 if ((rawkey0 | rawkey1)
378 && rawkey0 == old_rawkey0
379 && rawkey1 == old_rawkey1) {
380 /*
381 * Already setup for this key.
382 * This optimisation fails on a zero key (which is weak and
383 * has bad parity anyway) in order to simplify the starting
384 * conditions.
385 */
386 return(0);
387 }
388 old_rawkey0 = rawkey0;
389 old_rawkey1 = rawkey1;
390
391 /*
392 * Do key permutation and split into two 28-bit subkeys.
393 */
394 k0 = key_perm_maskl[0][rawkey0 >> 25]
395 | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
396 | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
397 | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
398 | key_perm_maskl[4][rawkey1 >> 25]
399 | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
400 | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
401 | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
402 k1 = key_perm_maskr[0][rawkey0 >> 25]
403 | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
404 | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
405 | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
406 | key_perm_maskr[4][rawkey1 >> 25]
407 | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
408 | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
409 | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
410 /*
411 * Rotate subkeys and do compression permutation.
412 */
413 shifts = 0;
414 for (round = 0; round < 16; round++) {
415 u_int32_t t0, t1;
416
417 shifts += key_shifts[round];
418
419 t0 = (k0 << shifts) | (k0 >> (28 - shifts));
420 t1 = (k1 << shifts) | (k1 >> (28 - shifts));
421
422 de_keysl[15 - round] =
423 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
424 | comp_maskl[1][(t0 >> 14) & 0x7f]
425 | comp_maskl[2][(t0 >> 7) & 0x7f]
426 | comp_maskl[3][t0 & 0x7f]
427 | comp_maskl[4][(t1 >> 21) & 0x7f]
428 | comp_maskl[5][(t1 >> 14) & 0x7f]
429 | comp_maskl[6][(t1 >> 7) & 0x7f]
430 | comp_maskl[7][t1 & 0x7f];
431
432 de_keysr[15 - round] =
433 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
434 | comp_maskr[1][(t0 >> 14) & 0x7f]
435 | comp_maskr[2][(t0 >> 7) & 0x7f]
436 | comp_maskr[3][t0 & 0x7f]
437 | comp_maskr[4][(t1 >> 21) & 0x7f]
438 | comp_maskr[5][(t1 >> 14) & 0x7f]
439 | comp_maskr[6][(t1 >> 7) & 0x7f]
440 | comp_maskr[7][t1 & 0x7f];
441 }
442 return(0);
443 }
444
445 static int
446 do_des( u_int32_t l_in, u_int32_t r_in, u_int32_t *l_out, u_int32_t *r_out, int count)
447 {
448 /*
449 * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
450 */
451 u_int32_t l, r, *kl, *kr, *kl1, *kr1;
452 u_int32_t f, r48l, r48r;
453 int round;
454
455 if (count == 0) {
456 return(1);
457 } else if (count > 0) {
458 /*
459 * Encrypting
460 */
461 kl1 = en_keysl;
462 kr1 = en_keysr;
463 } else {
464 /*
465 * Decrypting
466 */
467 count = -count;
468 kl1 = de_keysl;
469 kr1 = de_keysr;
470 }
471
472 /*
473 * Do initial permutation (IP).
474 */
475 l = ip_maskl[0][l_in >> 24]
476 | ip_maskl[1][(l_in >> 16) & 0xff]
477 | ip_maskl[2][(l_in >> 8) & 0xff]
478 | ip_maskl[3][l_in & 0xff]
479 | ip_maskl[4][r_in >> 24]
480 | ip_maskl[5][(r_in >> 16) & 0xff]
481 | ip_maskl[6][(r_in >> 8) & 0xff]
482 | ip_maskl[7][r_in & 0xff];
483 r = ip_maskr[0][l_in >> 24]
484 | ip_maskr[1][(l_in >> 16) & 0xff]
485 | ip_maskr[2][(l_in >> 8) & 0xff]
486 | ip_maskr[3][l_in & 0xff]
487 | ip_maskr[4][r_in >> 24]
488 | ip_maskr[5][(r_in >> 16) & 0xff]
489 | ip_maskr[6][(r_in >> 8) & 0xff]
490 | ip_maskr[7][r_in & 0xff];
491
492 while (count--) {
493 /*
494 * Do each round.
495 */
496 kl = kl1;
497 kr = kr1;
498 round = 16;
499 while (round--) {
500 /*
501 * Expand R to 48 bits (simulate the E-box).
502 */
503 r48l = ((r & 0x00000001) << 23)
504 | ((r & 0xf8000000) >> 9)
505 | ((r & 0x1f800000) >> 11)
506 | ((r & 0x01f80000) >> 13)
507 | ((r & 0x001f8000) >> 15);
508
509 r48r = ((r & 0x0001f800) << 7)
510 | ((r & 0x00001f80) << 5)
511 | ((r & 0x000001f8) << 3)
512 | ((r & 0x0000001f) << 1)
513 | ((r & 0x80000000) >> 31);
514 /*
515 * Do salting for crypt() and friends, and
516 * XOR with the permuted key.
517 */
518 f = (r48l ^ r48r) & saltbits;
519 r48l ^= f ^ *kl++;
520 r48r ^= f ^ *kr++;
521 /*
522 * Do sbox lookups (which shrink it back to 32 bits)
523 * and do the pbox permutation at the same time.
524 */
525 f = psbox[0][m_sbox[0][r48l >> 12]]
526 | psbox[1][m_sbox[1][r48l & 0xfff]]
527 | psbox[2][m_sbox[2][r48r >> 12]]
528 | psbox[3][m_sbox[3][r48r & 0xfff]];
529 /*
530 * Now that we've permuted things, complete f().
531 */
532 f ^= l;
533 l = r;
534 r = f;
535 }
536 r = l;
537 l = f;
538 }
539 /*
540 * Do final permutation (inverse of IP).
541 */
542 *l_out = fp_maskl[0][l >> 24]
543 | fp_maskl[1][(l >> 16) & 0xff]
544 | fp_maskl[2][(l >> 8) & 0xff]
545 | fp_maskl[3][l & 0xff]
546 | fp_maskl[4][r >> 24]
547 | fp_maskl[5][(r >> 16) & 0xff]
548 | fp_maskl[6][(r >> 8) & 0xff]
549 | fp_maskl[7][r & 0xff];
550 *r_out = fp_maskr[0][l >> 24]
551 | fp_maskr[1][(l >> 16) & 0xff]
552 | fp_maskr[2][(l >> 8) & 0xff]
553 | fp_maskr[3][l & 0xff]
554 | fp_maskr[4][r >> 24]
555 | fp_maskr[5][(r >> 16) & 0xff]
556 | fp_maskr[6][(r >> 8) & 0xff]
557 | fp_maskr[7][r & 0xff];
558 return(0);
559 }
560
561 static int
562 des_cipher(const char *in, char *out, long salt, int count)
563 {
564 const uint32_t *in32;
565 uint32_t l_out, r_out, rawl, rawr, *out32;
566 int retval;
567
568 if (!des_initialised)
569 des_init();
570
571 setup_salt(salt);
572
573 in32 = (const uint32_t *)in;
574 out32 = (uint32_t *)out;
575
576 rawl = ntohl(*in32++);
577 rawr = ntohl(*in32);
578
579 retval = do_des(rawl, rawr, &l_out, &r_out, count);
580
581 *out32++ = htonl(l_out);
582 *out32 = htonl(r_out);
583 return(retval);
584 }
585
586 char *
587 crypt_des(const char *key, const char *setting)
588 {
589 int i;
590 u_int32_t count, salt, l, r0, r1, keybuf[2];
591 u_char *p, *q;
592 static u_char output[21];
593
594 if (!des_initialised)
595 des_init();
596
597
598 /*
599 * Copy the key, shifting each character up by one bit
600 * and padding with zeros.
601 */
602 q = (u_char *) keybuf;
603 while (q - (u_char *) keybuf - 8) {
604 *q++ = *key << 1;
605 if (*key != '\0')
606 key++;
607 }
608 if (des_setkey((u_char *) keybuf))
609 return(NULL);
610
611 if (*setting == _PASSWORD_EFMT1) {
612 /*
613 * "new"-style:
614 * setting - underscore, 4 bytes of count, 4 bytes of salt
615 * key - unlimited characters
616 */
617 for (i = 1, count = 0L; i < 5; i++)
618 count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
619
620 for (i = 5, salt = 0L; i < 9; i++)
621 salt |= ascii_to_bin(setting[i]) << (i - 5) * 6;
622
623 while (*key) {
624 /*
625 * Encrypt the key with itself.
626 */
627 if (des_cipher((u_char*)keybuf, (u_char*)keybuf, 0L, 1))
628 return(NULL);
629 /*
630 * And XOR with the next 8 characters of the key.
631 */
632 q = (u_char *) keybuf;
633 while (q - (u_char *) keybuf - 8 && *key)
634 *q++ ^= *key++ << 1;
635
636 if (des_setkey((u_char *) keybuf))
637 return(NULL);
638 }
639 strncpy(output, setting, 9);
640
641 /*
642 * Double check that we weren't given a short setting.
643 * If we were, the above code will probably have created
644 * weird values for count and salt, but we don't really care.
645 * Just make sure the output string doesn't have an extra
646 * NUL in it.
647 */
648 output[9] = '\0';
649 p = output + strlen(output);
650 } else {
651 /*
652 * "old"-style:
653 * setting - 2 bytes of salt
654 * key - up to 8 characters
655 */
656 count = 25;
657
658 salt = (ascii_to_bin(setting[1]) << 6)
659 | ascii_to_bin(setting[0]);
660
661 output[0] = setting[0];
662 /*
663 * If the encrypted password that the salt was extracted from
664 * is only 1 character long, the salt will be corrupted. We
665 * need to ensure that the output string doesn't have an extra
666 * NUL in it!
667 */
668 output[1] = setting[1] ? setting[1] : output[0];
669
670 p = output + 2;
671 }
672 setup_salt(salt);
673 /*
674 * Do it.
675 */
676 if (do_des(0L, 0L, &r0, &r1, count))
677 return(NULL);
678 /*
679 * Now encode the result...
680 */
681 l = (r0 >> 8);
682 *p++ = ascii64[(l >> 18) & 0x3f];
683 *p++ = ascii64[(l >> 12) & 0x3f];
684 *p++ = ascii64[(l >> 6) & 0x3f];
685 *p++ = ascii64[l & 0x3f];
686
687 l = (r0 << 16) | ((r1 >> 16) & 0xffff);
688 *p++ = ascii64[(l >> 18) & 0x3f];
689 *p++ = ascii64[(l >> 12) & 0x3f];
690 *p++ = ascii64[(l >> 6) & 0x3f];
691 *p++ = ascii64[l & 0x3f];
692
693 l = r1 << 2;
694 *p++ = ascii64[(l >> 12) & 0x3f];
695 *p++ = ascii64[(l >> 6) & 0x3f];
696 *p++ = ascii64[l & 0x3f];
697 *p = 0;
698
699 return(output);
700 }
DragonFly BSD