Mercurial > hg > early-roguelike

comparison rogue5/xcrypt.c @ 33:f502bf60e6e4

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