?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NFE - Change default RX ring size from 128 -> 256, Adjust moderation timer.
[dragonfly.git] / secure / lib / libcipher / crypt.c
blob13488cb4998cf0a7d6e7b151a0b8d342d7fdffa9
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 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) + 1));
572
573 retval = do_des(rawl, rawr, &l_out, &r_out, count);
574
575 *((u_long *) out) = htonl(l_out);
576 *(((u_long *) out) + 1) = 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
DragonFly BSD