Mercurial > hg > early-roguelike

comparison xrogue/xcrypt.c @ 133:e6179860cb76

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