Mercurial > hg > early-roguelike

comparison arogue5/xcrypt.c @ 63:0ed67132cf10

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