Raise WARNS in secure/ as high as possible and fix some resulting warnings.
[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.3 2005/05/21 10:31:08 corecode 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 inline int
184 ascii_to_bin(char ch)
185 {
186         if (ch > 'z')
187                 return(0);
188         if (ch >= 'a')
189                 return(ch - 'a' + 38);
190         if (ch > 'Z')
191                 return(0);
192         if (ch >= 'A')
193                 return(ch - 'A' + 12);
194         if (ch > '9')
195                 return(0);
196         if (ch >= '.')
197                 return(ch - '.');
198         return(0);
199 }
200
201 \f
202 static void
203 des_init()
204 {
205         int     i, j, b, k, inbit, obit;
206         u_long  *p, *il, *ir, *fl, *fr;
207
208         old_rawkey0 = old_rawkey1 = 0L;
209         saltbits = 0L;
210         old_salt = 0L;
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                 u_key_perm[i] = key_perm[i] - 1;
248                 inv_key_perm[key_perm[i] - 1] = i;
249                 inv_comp_perm[i] = 255;
250         }
251
252         /*
253          * Invert the key compression permutation.
254          */
255         for (i = 0; i < 48; i++) {
256                 inv_comp_perm[comp_perm[i] - 1] = i;
257         }
258
259         /*
260          * Set up the OR-mask arrays for the initial and final permutations,
261          * and for the key initial and compression permutations.
262          */
263         for (k = 0; k < 8; k++) {
264                 for (i = 0; i < 256; i++) {
265                         *(il = &ip_maskl[k][i]) = 0L;
266                         *(ir = &ip_maskr[k][i]) = 0L;
267                         *(fl = &fp_maskl[k][i]) = 0L;
268                         *(fr = &fp_maskr[k][i]) = 0L;
269                         for (j = 0; j < 8; j++) {
270                                 inbit = 8 * k + j;
271                                 if (i & bits8[j]) {
272                                         if ((obit = init_perm[inbit]) < 32)
273                                                 *il |= bits32[obit];
274                                         else
275                                                 *ir |= bits32[obit-32];
276                                         if ((obit = final_perm[inbit]) < 32)
277                                                 *fl |= bits32[obit];
278                                         else
279                                                 *fr |= bits32[obit - 32];
280                                 }
281                         }
282                 }
283                 for (i = 0; i < 128; i++) {
284                         *(il = &key_perm_maskl[k][i]) = 0L;
285                         *(ir = &key_perm_maskr[k][i]) = 0L;
286                         for (j = 0; j < 7; j++) {
287                                 inbit = 8 * k + j;
288                                 if (i & bits8[j + 1]) {
289                                         if ((obit = inv_key_perm[inbit]) == 255)
290                                                 continue;
291                                         if (obit < 28)
292                                                 *il |= bits28[obit];
293                                         else
294                                                 *ir |= bits28[obit - 28];
295                                 }
296                         }
297                         *(il = &comp_maskl[k][i]) = 0L;
298                         *(ir = &comp_maskr[k][i]) = 0L;
299                         for (j = 0; j < 7; j++) {
300                                 inbit = 7 * k + j;
301                                 if (i & bits8[j + 1]) {
302                                         if ((obit=inv_comp_perm[inbit]) == 255)
303                                                 continue;
304                                         if (obit < 24)
305                                                 *il |= bits24[obit];
306                                         else
307                                                 *ir |= bits24[obit - 24];
308                                 }
309                         }
310                 }
311         }
312
313         /*
314          * Invert the P-box permutation, and convert into OR-masks for
315          * handling the output of the S-box arrays setup above.
316          */
317         for (i = 0; i < 32; i++)
318                 un_pbox[pbox[i] - 1] = i;
319
320         for (b = 0; b < 4; b++)
321                 for (i = 0; i < 256; i++) {
322                         *(p = &psbox[b][i]) = 0L;
323                         for (j = 0; j < 8; j++) {
324                                 if (i & bits8[j])
325                                         *p |= bits32[un_pbox[8 * b + j]];
326                         }
327                 }
328
329         des_initialised = 1;
330 }
331
332 \f
333 static void
334 setup_salt(long salt)
335 {
336         u_long  obit, saltbit;
337         int     i;
338
339         if (salt == old_salt)
340                 return;
341         old_salt = salt;
342
343         saltbits = 0L;
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 \f
355 int
356 des_setkey(const char *key)
357 {
358         u_long  k0, k1, rawkey0, rawkey1;
359         int     shifts, round;
360
361         if (!des_initialised)
362                 des_init();
363
364         rawkey0 = ntohl(*(u_long *) key);
365         rawkey1 = ntohl(*(u_long *) (key + 4));
366
367         if ((rawkey0 | rawkey1)
368             && rawkey0 == old_rawkey0
369             && rawkey1 == old_rawkey1) {
370                 /*
371                  * Already setup for this key.
372                  * This optimisation fails on a zero key (which is weak and
373                  * has bad parity anyway) in order to simplify the starting
374                  * conditions.
375                  */
376                 return(0);
377         }
378         old_rawkey0 = rawkey0;
379         old_rawkey1 = rawkey1;
380
381         /*
382          *      Do key permutation and split into two 28-bit subkeys.
383          */
384         k0 = key_perm_maskl[0][rawkey0 >> 25]
385            | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
386            | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
387            | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
388            | key_perm_maskl[4][rawkey1 >> 25]
389            | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
390            | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
391            | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
392         k1 = key_perm_maskr[0][rawkey0 >> 25]
393            | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
394            | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
395            | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
396            | key_perm_maskr[4][rawkey1 >> 25]
397            | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
398            | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
399            | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
400         /*
401          *      Rotate subkeys and do compression permutation.
402          */
403         shifts = 0;
404         for (round = 0; round < 16; round++) {
405                 u_long  t0, t1;
406
407                 shifts += key_shifts[round];
408
409                 t0 = (k0 << shifts) | (k0 >> (28 - shifts));
410                 t1 = (k1 << shifts) | (k1 >> (28 - shifts));
411
412                 de_keysl[15 - round] =
413                 en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
414                                 | comp_maskl[1][(t0 >> 14) & 0x7f]
415                                 | comp_maskl[2][(t0 >> 7) & 0x7f]
416                                 | comp_maskl[3][t0 & 0x7f]
417                                 | comp_maskl[4][(t1 >> 21) & 0x7f]
418                                 | comp_maskl[5][(t1 >> 14) & 0x7f]
419                                 | comp_maskl[6][(t1 >> 7) & 0x7f]
420                                 | comp_maskl[7][t1 & 0x7f];
421
422                 de_keysr[15 - round] =
423                 en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
424                                 | comp_maskr[1][(t0 >> 14) & 0x7f]
425                                 | comp_maskr[2][(t0 >> 7) & 0x7f]
426                                 | comp_maskr[3][t0 & 0x7f]
427                                 | comp_maskr[4][(t1 >> 21) & 0x7f]
428                                 | comp_maskr[5][(t1 >> 14) & 0x7f]
429                                 | comp_maskr[6][(t1 >> 7) & 0x7f]
430                                 | comp_maskr[7][t1 & 0x7f];
431         }
432         return(0);
433 }
434
435 \f
436 static int
437 do_des( u_long l_in, u_long r_in, u_long *l_out, u_long *r_out, int count)
438 {
439         /*
440          *      l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
441          */
442         u_long  l, r, *kl, *kr, *kl1, *kr1;
443         u_long  f, 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 \f
553 int
554 des_cipher(const char *in, char *out, long salt, int count)
555 {
556         u_long  l_out, r_out, rawl, rawr;
557         int     retval;
558
559         if (!des_initialised)
560                 des_init();
561
562         setup_salt(salt);
563
564         rawl = ntohl(*((u_long *) in));
565         rawr = ntohl(*(((u_long *) in) + 1));
566
567         retval = do_des(rawl, rawr, &l_out, &r_out, count);
568
569         *((u_long *) out) = htonl(l_out);
570         *(((u_long *) out) + 1) = htonl(r_out);
571         return(retval);
572 }
573
574 \f
575 int
576 setkey(char *key)
577 {
578         int     i, j;
579         u_long  packed_keys[2];
580         u_char  *p;
581
582         p = (u_char *) packed_keys;
583
584         for (i = 0; i < 8; i++) {
585                 p[i] = 0;
586                 for (j = 0; j < 8; j++)
587                         if (*key++ & 1)
588                                 p[i] |= bits8[j];
589         }
590         return(des_setkey(p));
591 }
592
593
594 int
595 encrypt(char *block, int flag)
596 {
597         u_long  io[2];
598         u_char  *p;
599         int     i, j, retval;
600
601         if (!des_initialised)
602                 des_init();
603
604         setup_salt(0L);
605         p = block;
606         for (i = 0; i < 2; i++) {
607                 io[i] = 0L;
608                 for (j = 0; j < 32; j++)
609                         if (*p++ & 1)
610                                 io[i] |= bits32[j];
611         }
612         retval = do_des(io[0], io[1], io, io + 1, flag ? -1 : 1);
613         for (i = 0; i < 2; i++)
614                 for (j = 0; j < 32; j++)
615                         block[(i << 5) | j] = (io[i] & bits32[j]) ? 1 : 0;
616         return(retval);
617 }
618