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