Mercurial > hg > early-roguelike

comparison rogue3/xcrypt.c @ 0:527e2150eaf0

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