source: rtems/cpukit/telnetd/des.c @ 80f7732

4.104.11
Last change on this file since 80f7732 was 80f7732, checked in by Ralf Corsepius <ralf.corsepius@…>, on Dec 2, 2009 at 9:48:25 AM

Whitespace removal.

  • Property mode set to 100644
File size: 23.3 KB
Line 
1/*
2 * FreeSec: libcrypt for NetBSD
3 *
4 * Copyright (c) 1994 David Burren
5 * All rights reserved.
6 *
7 * Ported to RTEMS and made reentrant by Till Straumann, 9/2003
8 *
9 * Adapted for FreeBSD-2.0 by Geoffrey M. Rehmet
10 *      this file should now *only* export crypt(), in order to make
11 *      binaries of libcrypt exportable from the USA
12 *
13 * Adapted for FreeBSD-4.0 by Mark R V Murray
14 *      this file should now *only* export crypt_des(), in order to make
15 *      a module that can be optionally included in libcrypt.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 *    notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 *    notice, this list of conditions and the following disclaimer in the
24 *    documentation and/or other materials provided with the distribution.
25 * 3. Neither the name of the author nor the names of other contributors
26 *    may be used to endorse or promote products derived from this software
27 *    without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39 * SUCH DAMAGE.
40 *
41 * This is an original implementation of the DES and the crypt(3) interfaces
42 * by David Burren <davidb@werj.com.au>.
43 *
44 * An excellent reference on the underlying algorithm (and related
45 * algorithms) is:
46 *
47 *      B. Schneier, Applied Cryptography: protocols, algorithms,
48 *      and source code in C, John Wiley & Sons, 1994.
49 *
50 * Note that in that book's description of DES the lookups for the initial,
51 * pbox, and final permutations are inverted (this has been brought to the
52 * attention of the author).  A list of errata for this book has been
53 * posted to the sci.crypt newsgroup by the author and is available for FTP.
54 *
55 * ARCHITECTURE ASSUMPTIONS:
56 *      It is assumed that the 8-byte arrays passed by reference can be
57 *      addressed as arrays of u_int32_t's (ie. the CPU is not picky about
58 *      alignment).
59 */
60
61#define __FORCE_GLIBC
62#include <sys/cdefs.h>
63#include <sys/types.h>
64#include <sys/param.h>
65#include <netinet/in.h>
66#ifndef __rtems__
67#include <pwd.h>
68#include <string.h>
69#include <crypt.h>
70#endif
71#include <stdlib.h>
72
73#define REENTRANT
74/* Re-entrantify me -- all this junk needs to be in
75 * struct crypt_data to make this really reentrant... */
76
77/* TS; not really - only the stuff in Des_Context */
78static struct fixed1 {
79u_char  inv_key_perm[64];
80u_char  inv_comp_perm[56];
81u_char  u_sbox[8][64];
82u_char  un_pbox[32];
83} des1_f;
84static struct fixed2 {
85u_int32_t ip_maskl[8][256], ip_maskr[8][256];
86} des2_f;
87static struct fixed3 {
88u_int32_t fp_maskl[8][256], fp_maskr[8][256];
89} des3_f;
90static struct fixed4 {
91u_int32_t key_perm_maskl[8][128], key_perm_maskr[8][128];
92u_int32_t comp_maskl[8][128], comp_maskr[8][128];
93} des4_f;
94
95#define inv_key_perm des1_f.inv_key_perm
96#define inv_comp_perm des1_f.inv_comp_perm
97#define u_sbox des1_f.u_sbox
98#define un_pbox des1_f.un_pbox
99#define ip_maskl des2_f.ip_maskl
100#define ip_maskr des2_f.ip_maskr
101#define fp_maskl des3_f.fp_maskl
102#define fp_maskr des3_f.fp_maskr
103#define key_perm_maskl des4_f.key_perm_maskl
104#define key_perm_maskr des4_f.key_perm_maskr
105#define comp_maskl des4_f.comp_maskl
106#define comp_maskr des4_f.comp_maskr
107
108/* These need to be maintained per-process */
109struct Des_Context {
110u_int32_t en_keysl[16], en_keysr[16];
111u_int32_t de_keysl[16], de_keysr[16];
112u_int32_t saltbits;
113u_int32_t old_salt;
114u_int32_t old_rawkey0, old_rawkey1;
115};
116
117#ifndef REENTRANT
118static struct Des_Context single;
119#endif
120
121#define en_keysl des_ctx->en_keysl
122#define en_keysr des_ctx->en_keysr
123#define de_keysl des_ctx->de_keysl
124#define de_keysr des_ctx->de_keysr
125#define saltbits des_ctx->saltbits
126#define old_salt des_ctx->old_salt
127#define old_rawkey0 des_ctx->old_rawkey0
128#define old_rawkey1 des_ctx->old_rawkey1
129
130/* Static stuff that stays resident and doesn't change after
131 * being initialized, and therefore doesn't need to be made
132 * reentrant. */
133static u_char   init_perm[64], final_perm[64];
134static u_char   m_sbox[4][4096];
135static u_int32_t psbox[4][256];
136
137
138
139
140/* A pile of data */
141static const u_char     ascii64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
142
143static const u_char     IP[64] = {
144  58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12,  4,
145  62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16,  8,
146  57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11,  3,
147  61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15,  7
148};
149
150static const u_char     key_perm[56] = {
151  57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
152  10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
153  63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
154  14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
155};
156
157static const u_char     key_shifts[16] = {
158  1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
159};
160
161static const u_char     comp_perm[48] = {
162  14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
163  23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
164  41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
165  44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
166};
167
168/*
169 *      No E box is used, as it's replaced by some ANDs, shifts, and ORs.
170 */
171
172static const u_char     sbox[8][64] = {
173  {
174    14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
175     0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
176     4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
177    15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
178  },
179  {
180    15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
181     3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
182     0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
183    13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
184  },
185  {
186    10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
187    13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
188    13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
189     1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
190  },
191  {
192     7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
193    13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
194    10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
195     3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
196  },
197  {
198     2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
199    14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
200     4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
201    11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
202  },
203  {
204    12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
205    10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
206     9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
207     4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
208  },
209  {
210     4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
211    13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
212     1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
213     6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
214  },
215  {
216    13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
217     1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
218     7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
219     2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
220  }
221};
222
223static const u_char     pbox[32] = {
224  16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
225   2,  8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
226};
227
228static const u_int32_t bits32[32] =
229{
230  0x80000000, 0x40000000, 0x20000000, 0x10000000,
231  0x08000000, 0x04000000, 0x02000000, 0x01000000,
232  0x00800000, 0x00400000, 0x00200000, 0x00100000,
233  0x00080000, 0x00040000, 0x00020000, 0x00010000,
234  0x00008000, 0x00004000, 0x00002000, 0x00001000,
235  0x00000800, 0x00000400, 0x00000200, 0x00000100,
236  0x00000080, 0x00000040, 0x00000020, 0x00000010,
237  0x00000008, 0x00000004, 0x00000002, 0x00000001
238};
239
240static const u_char     bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
241static const u_int32_t *bits28, *bits24;
242
243
244static int
245ascii_to_bin(char ch)
246{
247  if (ch > 'z')
248    return(0);
249  if (ch >= 'a')
250    return(ch - 'a' + 38);
251  if (ch > 'Z')
252    return(0);
253  if (ch >= 'A')
254    return(ch - 'A' + 12);
255  if (ch > '9')
256    return(0);
257  if (ch >= '.')
258    return(ch - '.');
259  return(0);
260}
261
262struct Des_Context *
263des_ctx_init(void)
264{
265struct Des_Context *des_ctx;
266#ifdef REENTRANT
267  des_ctx = malloc(sizeof(*des_ctx));
268#else
269  des_ctx = &single;
270#endif
271  old_rawkey0 = old_rawkey1 = 0L;
272  saltbits = 0L;
273  old_salt = 0L;
274
275  return des_ctx;
276}
277
278static void
279des_init(void)
280{
281  int   i, j, b, k, inbit, obit;
282  u_int32_t     *p, *il, *ir, *fl, *fr;
283  static int des_initialised = 0;
284
285  if (des_initialised==1)
286      return;
287
288#ifndef REENTRANT
289  des_ctx_init();
290#endif
291
292  bits24 = (bits28 = bits32 + 4) + 4;
293
294  /*
295   * Invert the S-boxes, reordering the input bits.
296   */
297  for (i = 0; i < 8; i++)
298    for (j = 0; j < 64; j++) {
299      b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
300      u_sbox[i][j] = sbox[i][b];
301    }
302
303  /*
304   * Convert the inverted S-boxes into 4 arrays of 8 bits.
305   * Each will handle 12 bits of the S-box input.
306   */
307  for (b = 0; b < 4; b++)
308    for (i = 0; i < 64; i++)
309      for (j = 0; j < 64; j++)
310        m_sbox[b][(i << 6) | j] =
311          (u_char)((u_sbox[(b << 1)][i] << 4) |
312          u_sbox[(b << 1) + 1][j]);
313
314  /*
315   * Set up the initial & final permutations into a useful form, and
316   * initialise the inverted key permutation.
317   */
318  for (i = 0; i < 64; i++) {
319    init_perm[final_perm[i] = IP[i] - 1] = (u_char)i;
320    inv_key_perm[i] = 255;
321  }
322
323  /*
324   * Invert the key permutation and initialise the inverted key
325   * compression permutation.
326   */
327  for (i = 0; i < 56; i++) {
328    inv_key_perm[key_perm[i] - 1] = (u_char)i;
329    inv_comp_perm[i] = 255;
330  }
331
332  /*
333   * Invert the key compression permutation.
334   */
335  for (i = 0; i < 48; i++) {
336    inv_comp_perm[comp_perm[i] - 1] = (u_char)i;
337  }
338
339  /*
340   * Set up the OR-mask arrays for the initial and final permutations,
341   * and for the key initial and compression permutations.
342   */
343  for (k = 0; k < 8; k++) {
344    for (i = 0; i < 256; i++) {
345      *(il = &ip_maskl[k][i]) = 0L;
346      *(ir = &ip_maskr[k][i]) = 0L;
347      *(fl = &fp_maskl[k][i]) = 0L;
348      *(fr = &fp_maskr[k][i]) = 0L;
349      for (j = 0; j < 8; j++) {
350        inbit = 8 * k + j;
351        if (i & bits8[j]) {
352          if ((obit = init_perm[inbit]) < 32)
353            *il |= bits32[obit];
354          else
355            *ir |= bits32[obit-32];
356          if ((obit = final_perm[inbit]) < 32)
357            *fl |= bits32[obit];
358          else
359            *fr |= bits32[obit - 32];
360        }
361      }
362    }
363    for (i = 0; i < 128; i++) {
364      *(il = &key_perm_maskl[k][i]) = 0L;
365      *(ir = &key_perm_maskr[k][i]) = 0L;
366      for (j = 0; j < 7; j++) {
367        inbit = 8 * k + j;
368        if (i & bits8[j + 1]) {
369          if ((obit = inv_key_perm[inbit]) == 255)
370            continue;
371          if (obit < 28)
372            *il |= bits28[obit];
373          else
374            *ir |= bits28[obit - 28];
375        }
376      }
377      *(il = &comp_maskl[k][i]) = 0L;
378      *(ir = &comp_maskr[k][i]) = 0L;
379      for (j = 0; j < 7; j++) {
380        inbit = 7 * k + j;
381        if (i & bits8[j + 1]) {
382          if ((obit=inv_comp_perm[inbit]) == 255)
383            continue;
384          if (obit < 24)
385            *il |= bits24[obit];
386          else
387            *ir |= bits24[obit - 24];
388        }
389      }
390    }
391  }
392
393  /*
394   * Invert the P-box permutation, and convert into OR-masks for
395   * handling the output of the S-box arrays setup above.
396   */
397  for (i = 0; i < 32; i++)
398    un_pbox[pbox[i] - 1] = (u_char)i;
399
400  for (b = 0; b < 4; b++)
401    for (i = 0; i < 256; i++) {
402      *(p = &psbox[b][i]) = 0L;
403      for (j = 0; j < 8; j++) {
404        if (i & bits8[j])
405          *p |= bits32[un_pbox[8 * b + j]];
406      }
407    }
408
409  des_initialised = 1;
410}
411
412
413static void
414setup_salt(long salt, struct Des_Context *des_ctx)
415{
416  u_int32_t     obit, saltbit;
417  int   i;
418
419  if (salt == old_salt)
420    return;
421  old_salt = salt;
422
423  saltbits = 0L;
424  saltbit = 1;
425  obit = 0x800000;
426  for (i = 0; i < 24; i++) {
427    if (salt & saltbit)
428      saltbits |= obit;
429    saltbit <<= 1;
430    obit >>= 1;
431  }
432}
433
434
435static int
436des_setkey(const char *key, struct Des_Context *des_ctx)
437{
438  u_int32_t     k0, k1, rawkey0, rawkey1;
439  int           shifts, round;
440
441  des_init();
442
443  rawkey0 = ntohl(*(const u_int32_t *) key);
444  rawkey1 = ntohl(*(const u_int32_t *) (key + 4));
445
446  if ((rawkey0 | rawkey1)
447      && rawkey0 == old_rawkey0
448      && rawkey1 == old_rawkey1) {
449    /*
450     * Already setup for this key.
451     * This optimisation fails on a zero key (which is weak and
452     * has bad parity anyway) in order to simplify the starting
453     * conditions.
454     */
455    return(0);
456  }
457  old_rawkey0 = rawkey0;
458  old_rawkey1 = rawkey1;
459
460  /*
461   *    Do key permutation and split into two 28-bit subkeys.
462   */
463  k0 = key_perm_maskl[0][rawkey0 >> 25]
464     | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
465     | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
466     | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
467     | key_perm_maskl[4][rawkey1 >> 25]
468     | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
469     | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
470     | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
471  k1 = key_perm_maskr[0][rawkey0 >> 25]
472     | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
473     | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
474     | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
475     | key_perm_maskr[4][rawkey1 >> 25]
476     | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
477     | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
478     | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
479  /*
480   *    Rotate subkeys and do compression permutation.
481   */
482  shifts = 0;
483  for (round = 0; round < 16; round++) {
484    u_int32_t   t0, t1;
485
486    shifts += key_shifts[round];
487
488    t0 = (k0 << shifts) | (k0 >> (28 - shifts));
489    t1 = (k1 << shifts) | (k1 >> (28 - shifts));
490
491    de_keysl[15 - round] =
492    en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
493        | comp_maskl[1][(t0 >> 14) & 0x7f]
494        | comp_maskl[2][(t0 >> 7) & 0x7f]
495        | comp_maskl[3][t0 & 0x7f]
496        | comp_maskl[4][(t1 >> 21) & 0x7f]
497        | comp_maskl[5][(t1 >> 14) & 0x7f]
498        | comp_maskl[6][(t1 >> 7) & 0x7f]
499        | comp_maskl[7][t1 & 0x7f];
500
501    de_keysr[15 - round] =
502    en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
503        | comp_maskr[1][(t0 >> 14) & 0x7f]
504        | comp_maskr[2][(t0 >> 7) & 0x7f]
505        | comp_maskr[3][t0 & 0x7f]
506        | comp_maskr[4][(t1 >> 21) & 0x7f]
507        | comp_maskr[5][(t1 >> 14) & 0x7f]
508        | comp_maskr[6][(t1 >> 7) & 0x7f]
509        | comp_maskr[7][t1 & 0x7f];
510  }
511  return(0);
512}
513
514
515static int
516do_des( u_int32_t l_in, u_int32_t r_in, u_int32_t *l_out, u_int32_t *r_out, int count, struct Des_Context *des_ctx)
517{
518  /*
519   *    l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
520   */
521  u_int32_t     l, r, *kl, *kr, *kl1, *kr1;
522  u_int32_t     f, r48l, r48r;
523  int           round;
524
525  if (count == 0) {
526    return(1);
527  } else if (count > 0) {
528    /*
529     * Encrypting
530     */
531    kl1 = en_keysl;
532    kr1 = en_keysr;
533  } else {
534    /*
535     * Decrypting
536     */
537    count = -count;
538    kl1 = de_keysl;
539    kr1 = de_keysr;
540  }
541
542  /*
543   *    Do initial permutation (IP).
544   */
545  l = ip_maskl[0][l_in >> 24]
546    | ip_maskl[1][(l_in >> 16) & 0xff]
547    | ip_maskl[2][(l_in >> 8) & 0xff]
548    | ip_maskl[3][l_in & 0xff]
549    | ip_maskl[4][r_in >> 24]
550    | ip_maskl[5][(r_in >> 16) & 0xff]
551    | ip_maskl[6][(r_in >> 8) & 0xff]
552    | ip_maskl[7][r_in & 0xff];
553  r = ip_maskr[0][l_in >> 24]
554    | ip_maskr[1][(l_in >> 16) & 0xff]
555    | ip_maskr[2][(l_in >> 8) & 0xff]
556    | ip_maskr[3][l_in & 0xff]
557    | ip_maskr[4][r_in >> 24]
558    | ip_maskr[5][(r_in >> 16) & 0xff]
559    | ip_maskr[6][(r_in >> 8) & 0xff]
560    | ip_maskr[7][r_in & 0xff];
561
562  while (count--) {
563    /*
564     * Do each round.
565     */
566    kl = kl1;
567    kr = kr1;
568    round = 16;
569    while (round--) {
570      /*
571       * Expand R to 48 bits (simulate the E-box).
572       */
573      r48l      = ((r & 0x00000001) << 23)
574        | ((r & 0xf8000000) >> 9)
575        | ((r & 0x1f800000) >> 11)
576        | ((r & 0x01f80000) >> 13)
577        | ((r & 0x001f8000) >> 15);
578
579      r48r      = ((r & 0x0001f800) << 7)
580        | ((r & 0x00001f80) << 5)
581        | ((r & 0x000001f8) << 3)
582        | ((r & 0x0000001f) << 1)
583        | ((r & 0x80000000) >> 31);
584      /*
585       * Do salting for crypt() and friends, and
586       * XOR with the permuted key.
587       */
588      f = (r48l ^ r48r) & saltbits;
589      r48l ^= f ^ *kl++;
590      r48r ^= f ^ *kr++;
591      /*
592       * Do sbox lookups (which shrink it back to 32 bits)
593       * and do the pbox permutation at the same time.
594       */
595      f = psbox[0][m_sbox[0][r48l >> 12]]
596        | psbox[1][m_sbox[1][r48l & 0xfff]]
597        | psbox[2][m_sbox[2][r48r >> 12]]
598        | psbox[3][m_sbox[3][r48r & 0xfff]];
599      /*
600       * Now that we've permuted things, complete f().
601       */
602      f ^= l;
603      l = r;
604      r = f;
605    }
606    r = l;
607    l = f;
608  }
609  /*
610   * Do final permutation (inverse of IP).
611   */
612  *l_out        = fp_maskl[0][l >> 24]
613    | fp_maskl[1][(l >> 16) & 0xff]
614    | fp_maskl[2][(l >> 8) & 0xff]
615    | fp_maskl[3][l & 0xff]
616    | fp_maskl[4][r >> 24]
617    | fp_maskl[5][(r >> 16) & 0xff]
618    | fp_maskl[6][(r >> 8) & 0xff]
619    | fp_maskl[7][r & 0xff];
620  *r_out        = fp_maskr[0][l >> 24]
621    | fp_maskr[1][(l >> 16) & 0xff]
622    | fp_maskr[2][(l >> 8) & 0xff]
623    | fp_maskr[3][l & 0xff]
624    | fp_maskr[4][r >> 24]
625    | fp_maskr[5][(r >> 16) & 0xff]
626    | fp_maskr[6][(r >> 8) & 0xff]
627    | fp_maskr[7][r & 0xff];
628  return(0);
629}
630
631
632#if 0
633static int
634des_cipher(const char *in, char *out, u_int32_t salt, int count)
635{
636  u_int32_t     l_out, r_out, rawl, rawr;
637  int           retval;
638  union {
639    u_int32_t   *ui32;
640    const char  *c;
641  } trans;
642
643  des_init();
644
645  setup_salt(salt);
646
647  trans.c = in;
648  rawl = ntohl(*trans.ui32++);
649  rawr = ntohl(*trans.ui32);
650
651  retval = do_des(rawl, rawr, &l_out, &r_out, count);
652
653  trans.c = out;
654  *trans.ui32++ = htonl(l_out);
655  *trans.ui32 = htonl(r_out);
656  return(retval);
657}
658#endif
659
660
661#ifndef REENTRANT
662void
663setkey(const char *key)
664{
665  int   i, j;
666  u_int32_t     packed_keys[2];
667  u_char        *p;
668
669  p = (u_char *) packed_keys;
670
671  for (i = 0; i < 8; i++) {
672    p[i] = 0;
673    for (j = 0; j < 8; j++)
674      if (*key++ & 1)
675        p[i] |= bits8[j];
676  }
677  des_setkey(p, &single);
678}
679#endif
680
681
682#ifndef REENTRANT
683void
684encrypt(char *block, int flag)
685{
686  u_int32_t     io[2];
687  u_char        *p;
688  int   i, j;
689
690  des_init();
691
692  setup_salt(0L, &single);
693  p = block;
694  for (i = 0; i < 2; i++) {
695    io[i] = 0L;
696    for (j = 0; j < 32; j++)
697      if (*p++ & 1)
698        io[i] |= bits32[j];
699  }
700  do_des(io[0], io[1], io, io + 1, flag ? -1 : 1, &single);
701  for (i = 0; i < 2; i++)
702    for (j = 0; j < 32; j++)
703      block[(i << 5) | j] = (io[i] & bits32[j]) ? 1 : 0;
704}
705
706#endif
707
708char *
709__des_crypt_r(const char *key, const char *setting, char *output, int sz)
710{
711  char *rval = 0;
712  struct Des_Context *des_ctx;
713  u_int32_t     count, salt, l, r0, r1, keybuf[2];
714  u_char                *p, *q;
715
716  if (sz < 21)
717    return NULL;
718
719  des_init();
720  des_ctx = des_ctx_init();
721
722  /*
723   * Copy the key, shifting each character up by one bit
724   * and padding with zeros.
725   */
726  q = (u_char *)keybuf;
727  while (q - (u_char *)keybuf - 8) {
728    *q++ = *key << 1;
729    if (*(q - 1))
730      key++;
731  }
732  if (des_setkey((char *)keybuf, des_ctx))
733    goto bailout;
734
735#if 0
736  if (*setting == _PASSWORD_EFMT1) {
737    int         i;
738    /*
739     * "new"-style:
740     *  setting - underscore, 4 bytes of count, 4 bytes of salt
741     *  key - unlimited characters
742     */
743    for (i = 1, count = 0L; i < 5; i++)
744      count |= ascii_to_bin(setting[i]) << ((i - 1) * 6);
745
746    for (i = 5, salt = 0L; i < 9; i++)
747      salt |= ascii_to_bin(setting[i]) << ((i - 5) * 6);
748
749    while (*key) {
750      /*
751       * Encrypt the key with itself.
752       */
753      if (des_cipher((char *)keybuf, (char *)keybuf, 0L, 1))
754        goto bailout;
755      /*
756       * And XOR with the next 8 characters of the key.
757       */
758      q = (u_char *)keybuf;
759      while (q - (u_char *)keybuf - 8 && *key)
760        *q++ ^= *key++ << 1;
761
762      if (des_setkey((char *)keybuf))
763        goto bailout;
764    }
765    strncpy(output, setting, 9);
766
767    /*
768     * Double check that we weren't given a short setting.
769     * If we were, the above code will probably have created
770     * wierd values for count and salt, but we don't really care.
771     * Just make sure the output string doesn't have an extra
772     * NUL in it.
773     */
774    output[9] = '\0';
775    p = (u_char *)output + strlen(output);
776  } else
777#endif
778  {
779    /*
780     * "old"-style:
781     *  setting - 2 bytes of salt
782     *  key - up to 8 characters
783     */
784    count = 25;
785
786    salt = (ascii_to_bin(setting[1]) << 6)
787         |  ascii_to_bin(setting[0]);
788
789    output[0] = setting[0];
790    /*
791     * If the encrypted password that the salt was extracted from
792     * is only 1 character long, the salt will be corrupted.  We
793     * need to ensure that the output string doesn't have an extra
794     * NUL in it!
795     */
796    output[1] = setting[1] ? setting[1] : output[0];
797
798    p = (u_char *)output + 2;
799  }
800  setup_salt(salt, des_ctx);
801  /*
802   * Do it.
803   */
804  if (do_des(0L, 0L, &r0, &r1, (int)count, des_ctx))
805    goto bailout;
806  /*
807   * Now encode the result...
808   */
809  l = (r0 >> 8);
810  *p++ = ascii64[(l >> 18) & 0x3f];
811  *p++ = ascii64[(l >> 12) & 0x3f];
812  *p++ = ascii64[(l >> 6) & 0x3f];
813  *p++ = ascii64[l & 0x3f];
814
815  l = (r0 << 16) | ((r1 >> 16) & 0xffff);
816  *p++ = ascii64[(l >> 18) & 0x3f];
817  *p++ = ascii64[(l >> 12) & 0x3f];
818  *p++ = ascii64[(l >> 6) & 0x3f];
819  *p++ = ascii64[l & 0x3f];
820
821  l = r1 << 2;
822  *p++ = ascii64[(l >> 12) & 0x3f];
823  *p++ = ascii64[(l >> 6) & 0x3f];
824  *p++ = ascii64[l & 0x3f];
825  *p = 0;
826
827  rval = output;
828bailout:
829  free(des_ctx);
830  return rval;
831}
832
833char *
834__des_crypt(const char *key, const char *setting)
835{
836  static char   output[21];
837  return __des_crypt_r(key, setting, output, sizeof(output));
838}
839
840
841#ifdef DEBUG
842
843void
844des_snap(void **pf, void **pd)
845{
846  uint8* pfc;
847  *pf = malloc(sizeof(struct fixed1) + sizeof(struct fixed2) + sizeof(struct fixed3) + sizeof(struct fixed4));
848  pfc = *pf;
849  memcpy(pfc, &des1_f, sizeof(des1_f));
850  pfc += sizeof(des1_f);
851  memcpy(pfc, &des2_f, sizeof(des2_f));
852  pfc += sizeof(des2_f);
853  memcpy(pfc, &des3_f, sizeof(des3_f));
854  pfc += sizeof(des3_f);
855  memcpy(pfc, &des4_f, sizeof(des4_f));
856//      *pd = malloc(sizeof(struct Des_Context));
857//      memcpy(*pd, &des_ctx, sizeof(des_ctx));
858}
859
860void
861des_check(void *pf, void *pd)
862{
863  uint8* pfc1, pfc2, pfc3, pfc4;
864  pfc1 = pf;
865  pfc2 = pfc1 + sizeof(des1_f);
866  pfc3 = pfc2 + sizeof(des2_f);
867  pfc4 = pfc3 + sizeof(des3_f);
868  printf("Fixed: do%s differ"/*", Context: do%s differ"*/"\n",
869         (memcmp(pfc1, &des1_f, sizeof(des1_f)) ||
870          memcmp(pfc2, &des2_f, sizeof(des2_f)) ||
871          memcmp(pfc3, &des4_f, sizeof(des3_f)) ||
872          memcmp(pfc4, &des4_f, sizeof(des4_f))) ? "" : "nt");
873}
874
875#endif
Note: See TracBrowser for help on using the repository browser.