?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Raise WARNS in secure/ as high as possible and fix some resulting warnings.
[dragonfly.git] / secure / lib / libcipher / crypt.c
blobabecf0b2765a156d64bfe9274c81df24500cf69c
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
DragonFly BSD