Fix mtrace stack overflow bug
[kopensolaris-gnu/glibc.git] / crypt / crypt_util.c
1 /*
2  * UFC-crypt: ultra fast crypt(3) implementation
3  *
4  * Copyright (C) 1991, 92, 93, 96, 97, 98, 2000 Free Software Foundation, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; see the file COPYING.LIB.  If not,
18  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  *
21  * @(#)crypt_util.c     2.56 12/20/96
22  *
23  * Support routines
24  *
25  */
26
27 #ifdef DEBUG
28 #include <stdio.h>
29 #endif
30 #include <string.h>
31
32 #ifndef STATIC
33 #define STATIC static
34 #endif
35
36 #ifndef DOS
37 #include "ufc-crypt.h"
38 #else
39 /*
40  * Thanks to greg%wind@plains.NoDak.edu (Greg W. Wettstein)
41  * for DOS patches
42  */
43 #include "pl.h"
44 #include "ufc.h"
45 #endif
46 #include "crypt.h"
47 #include "crypt-private.h"
48
49 /* Prototypes for local functions.  */
50 #if __STDC__ - 0
51 #ifndef __GNU_LIBRARY__
52 void _ufc_clearmem (char *start, int cnt);
53 void _ufc_copymem (char *from, char *to, int cnt);
54 #endif
55 #ifdef _UFC_32_
56 STATIC void shuffle_sb (long32 *k, ufc_long saltbits);
57 #else
58 STATIC void shuffle_sb (long64 *k, ufc_long saltbits);
59 #endif
60 #endif
61
62
63 /*
64  * Permutation done once on the 56 bit
65  *  key derived from the original 8 byte ASCII key.
66  */
67 static const int pc1[56] = {
68   57, 49, 41, 33, 25, 17,  9,  1, 58, 50, 42, 34, 26, 18,
69   10,  2, 59, 51, 43, 35, 27, 19, 11,  3, 60, 52, 44, 36,
70   63, 55, 47, 39, 31, 23, 15,  7, 62, 54, 46, 38, 30, 22,
71   14,  6, 61, 53, 45, 37, 29, 21, 13,  5, 28, 20, 12,  4
72 };
73
74 /*
75  * How much to rotate each 28 bit half of the pc1 permutated
76  *  56 bit key before using pc2 to give the i' key
77  */
78 static const int rots[16] = {
79   1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
80 };
81
82 /*
83  * Permutation giving the key
84  * of the i' DES round
85  */
86 static const int pc2[48] = {
87   14, 17, 11, 24,  1,  5,  3, 28, 15,  6, 21, 10,
88   23, 19, 12,  4, 26,  8, 16,  7, 27, 20, 13,  2,
89   41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
90   44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
91 };
92
93 /*
94  * The E expansion table which selects
95  * bits from the 32 bit intermediate result.
96  */
97 static const int esel[48] = {
98   32,  1,  2,  3,  4,  5,  4,  5,  6,  7,  8,  9,
99    8,  9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
100   16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
101   24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32,  1
102 };
103
104 /*
105  * Permutation done on the
106  * result of sbox lookups
107  */
108 static const int perm32[32] = {
109   16,  7, 20, 21, 29, 12, 28, 17,  1, 15, 23, 26,  5, 18, 31, 10,
110   2,   8, 24, 14, 32, 27,  3,  9, 19, 13, 30,  6, 22, 11,  4, 25
111 };
112
113 /*
114  * The sboxes
115  */
116 static const int sbox[8][4][16]= {
117         { { 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7 },
118           {  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8 },
119           {  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0 },
120           { 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13 }
121         },
122
123         { { 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10 },
124           {  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5 },
125           {  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15 },
126           { 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9 }
127         },
128
129         { { 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8 },
130           { 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1 },
131           { 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7 },
132           {  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12 }
133         },
134
135         { {  7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15 },
136           { 13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9 },
137           { 10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4 },
138           {  3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14 }
139         },
140
141         { {  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9 },
142           { 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6 },
143           {  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14 },
144           { 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3 }
145         },
146
147         { { 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11 },
148           { 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8 },
149           {  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6 },
150           {  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13 }
151         },
152
153         { {  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1 },
154           { 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6 },
155           {  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2 },
156           {  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12 }
157         },
158
159         { { 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7 },
160           {  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2 },
161           {  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8 },
162           {  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11 }
163         }
164 };
165
166 /*
167  * This is the initial
168  * permutation matrix
169  */
170 static const int initial_perm[64] = {
171   58, 50, 42, 34, 26, 18, 10,  2, 60, 52, 44, 36, 28, 20, 12, 4,
172   62, 54, 46, 38, 30, 22, 14,  6, 64, 56, 48, 40, 32, 24, 16, 8,
173   57, 49, 41, 33, 25, 17,  9,  1, 59, 51, 43, 35, 27, 19, 11, 3,
174   61, 53, 45, 37, 29, 21, 13,  5, 63, 55, 47, 39, 31, 23, 15, 7
175 };
176
177 /*
178  * This is the final
179  * permutation matrix
180  */
181 static const int final_perm[64] = {
182   40,  8, 48, 16, 56, 24, 64, 32, 39,  7, 47, 15, 55, 23, 63, 31,
183   38,  6, 46, 14, 54, 22, 62, 30, 37,  5, 45, 13, 53, 21, 61, 29,
184   36,  4, 44, 12, 52, 20, 60, 28, 35,  3, 43, 11, 51, 19, 59, 27,
185   34,  2, 42, 10, 50, 18, 58, 26, 33,  1, 41,  9, 49, 17, 57, 25
186 };
187
188 #define ascii_to_bin(c) ((c)>='a'?(c-59):(c)>='A'?((c)-53):(c)-'.')
189 #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
190
191 static const ufc_long BITMASK[24] = {
192   0x40000000, 0x20000000, 0x10000000, 0x08000000, 0x04000000, 0x02000000,
193   0x01000000, 0x00800000, 0x00400000, 0x00200000, 0x00100000, 0x00080000,
194   0x00004000, 0x00002000, 0x00001000, 0x00000800, 0x00000400, 0x00000200,
195   0x00000100, 0x00000080, 0x00000040, 0x00000020, 0x00000010, 0x00000008
196 };
197
198 static const unsigned char bytemask[8]  = {
199   0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
200 };
201
202 static const ufc_long longmask[32] = {
203   0x80000000, 0x40000000, 0x20000000, 0x10000000,
204   0x08000000, 0x04000000, 0x02000000, 0x01000000,
205   0x00800000, 0x00400000, 0x00200000, 0x00100000,
206   0x00080000, 0x00040000, 0x00020000, 0x00010000,
207   0x00008000, 0x00004000, 0x00002000, 0x00001000,
208   0x00000800, 0x00000400, 0x00000200, 0x00000100,
209   0x00000080, 0x00000040, 0x00000020, 0x00000010,
210   0x00000008, 0x00000004, 0x00000002, 0x00000001
211 };
212
213 /*
214  * do_pc1: permform pc1 permutation in the key schedule generation.
215  *
216  * The first   index is the byte number in the 8 byte ASCII key
217  *  -  second    -      -    the two 28 bits halfs of the result
218  *  -  third     -   selects the 7 bits actually used of each byte
219  *
220  * The result is kept with 28 bit per 32 bit with the 4 most significant
221  * bits zero.
222  */
223 static ufc_long do_pc1[8][2][128];
224
225 /*
226  * do_pc2: permform pc2 permutation in the key schedule generation.
227  *
228  * The first   index is the septet number in the two 28 bit intermediate values
229  *  -  second    -    -  -  septet values
230  *
231  * Knowledge of the structure of the pc2 permutation is used.
232  *
233  * The result is kept with 28 bit per 32 bit with the 4 most significant
234  * bits zero.
235  */
236 static ufc_long do_pc2[8][128];
237
238 /*
239  * eperm32tab: do 32 bit permutation and E selection
240  *
241  * The first index is the byte number in the 32 bit value to be permuted
242  *  -  second  -   is the value of this byte
243  *  -  third   -   selects the two 32 bit values
244  *
245  * The table is used and generated internally in init_des to speed it up
246  */
247 static ufc_long eperm32tab[4][256][2];
248
249 /*
250  * efp: undo an extra e selection and do final
251  *      permutation giving the DES result.
252  *
253  *      Invoked 6 bit a time on two 48 bit values
254  *      giving two 32 bit longs.
255  */
256 static ufc_long efp[16][64][2];
257
258 /*
259  * For use by the old, non-reentrant routines
260  * (crypt/encrypt/setkey)
261  */
262 struct crypt_data _ufc_foobar;
263
264 #ifdef __GNU_LIBRARY__
265 #include <bits/libc-lock.h>
266
267 __libc_lock_define_initialized (static, _ufc_tables_lock)
268 #endif
269
270 #ifdef DEBUG
271
272 void
273 _ufc_prbits(a, n)
274      ufc_long *a;
275      int n;
276 {
277   ufc_long i, j, t, tmp;
278   n /= 8;
279   for(i = 0; i < n; i++) {
280     tmp=0;
281     for(j = 0; j < 8; j++) {
282       t=8*i+j;
283       tmp|=(a[t/24] & BITMASK[t % 24])?bytemask[j]:0;
284     }
285     (void)printf("%02x ",tmp);
286   }
287   printf(" ");
288 }
289
290 static void
291 _ufc_set_bits(v, b)
292      ufc_long v;
293      ufc_long *b;
294 {
295   ufc_long i;
296   *b = 0;
297   for(i = 0; i < 24; i++) {
298     if(v & longmask[8 + i])
299       *b |= BITMASK[i];
300   }
301 }
302
303 #endif
304
305 #ifndef __GNU_LIBRARY__
306 /*
307  * Silly rewrites of 'bzero'/'memset'. I do so
308  * because some machines don't have
309  * bzero and some don't have memset.
310  */
311
312 void
313 _ufc_clearmem(start, cnt)
314      char *start;
315      int cnt;
316 {
317   while(cnt--)
318     *start++ = '\0';
319 }
320
321 void
322 _ufc_copymem(from, to, cnt)
323      char *from, *to;
324      int cnt;
325 {
326   while(cnt--)
327     *to++ = *from++;
328 }
329 #else
330 #define _ufc_clearmem(start, cnt)   memset(start, 0, cnt)
331 #define _ufc_copymem(from, to, cnt) memcpy(to, from, cnt)
332 #endif
333
334 /* lookup a 6 bit value in sbox */
335
336 #define s_lookup(i,s) sbox[(i)][(((s)>>4) & 0x2)|((s) & 0x1)][((s)>>1) & 0xf];
337
338 /*
339  * Initialize unit - may be invoked directly
340  * by fcrypt users.
341  */
342
343 void
344 __init_des_r(__data)
345      struct crypt_data * __restrict __data;
346 {
347   int comes_from_bit;
348   int bit, sg;
349   ufc_long j;
350   ufc_long mask1, mask2;
351   int e_inverse[64];
352   static volatile int small_tables_initialized = 0;
353
354 #ifdef _UFC_32_
355   long32 *sb[4];
356   sb[0] = (long32*)__data->sb0; sb[1] = (long32*)__data->sb1;
357   sb[2] = (long32*)__data->sb2; sb[3] = (long32*)__data->sb3;
358 #endif
359 #ifdef _UFC_64_
360   long64 *sb[4];
361   sb[0] = (long64*)__data->sb0; sb[1] = (long64*)__data->sb1;
362   sb[2] = (long64*)__data->sb2; sb[3] = (long64*)__data->sb3;
363 #endif
364
365   if(small_tables_initialized == 0) {
366 #ifdef __GNU_LIBRARY__
367     __libc_lock_lock (_ufc_tables_lock);
368     if(small_tables_initialized)
369       goto small_tables_done;
370 #endif
371
372     /*
373      * Create the do_pc1 table used
374      * to affect pc1 permutation
375      * when generating keys
376      */
377     _ufc_clearmem((char*)do_pc1, (int)sizeof(do_pc1));
378     for(bit = 0; bit < 56; bit++) {
379       comes_from_bit  = pc1[bit] - 1;
380       mask1 = bytemask[comes_from_bit % 8 + 1];
381       mask2 = longmask[bit % 28 + 4];
382       for(j = 0; j < 128; j++) {
383         if(j & mask1)
384           do_pc1[comes_from_bit / 8][bit / 28][j] |= mask2;
385       }
386     }
387
388     /*
389      * Create the do_pc2 table used
390      * to affect pc2 permutation when
391      * generating keys
392      */
393     _ufc_clearmem((char*)do_pc2, (int)sizeof(do_pc2));
394     for(bit = 0; bit < 48; bit++) {
395       comes_from_bit  = pc2[bit] - 1;
396       mask1 = bytemask[comes_from_bit % 7 + 1];
397       mask2 = BITMASK[bit % 24];
398       for(j = 0; j < 128; j++) {
399         if(j & mask1)
400           do_pc2[comes_from_bit / 7][j] |= mask2;
401       }
402     }
403
404     /*
405      * Now generate the table used to do combined
406      * 32 bit permutation and e expansion
407      *
408      * We use it because we have to permute 16384 32 bit
409      * longs into 48 bit in order to initialize sb.
410      *
411      * Looping 48 rounds per permutation becomes
412      * just too slow...
413      *
414      */
415
416     _ufc_clearmem((char*)eperm32tab, (int)sizeof(eperm32tab));
417     for(bit = 0; bit < 48; bit++) {
418       ufc_long mask1,comes_from;
419       comes_from = perm32[esel[bit]-1]-1;
420       mask1      = bytemask[comes_from % 8];
421       for(j = 256; j--;) {
422         if(j & mask1)
423           eperm32tab[comes_from / 8][j][bit / 24] |= BITMASK[bit % 24];
424       }
425     }
426
427     /*
428      * Create an inverse matrix for esel telling
429      * where to plug out bits if undoing it
430      */
431     for(bit=48; bit--;) {
432       e_inverse[esel[bit] - 1     ] = bit;
433       e_inverse[esel[bit] - 1 + 32] = bit + 48;
434     }
435
436     /*
437      * create efp: the matrix used to
438      * undo the E expansion and effect final permutation
439      */
440     _ufc_clearmem((char*)efp, (int)sizeof efp);
441     for(bit = 0; bit < 64; bit++) {
442       int o_bit, o_long;
443       ufc_long word_value, mask1, mask2;
444       int comes_from_f_bit, comes_from_e_bit;
445       int comes_from_word, bit_within_word;
446
447       /* See where bit i belongs in the two 32 bit long's */
448       o_long = bit / 32; /* 0..1  */
449       o_bit  = bit % 32; /* 0..31 */
450
451       /*
452        * And find a bit in the e permutated value setting this bit.
453        *
454        * Note: the e selection may have selected the same bit several
455        * times. By the initialization of e_inverse, we only look
456        * for one specific instance.
457        */
458       comes_from_f_bit = final_perm[bit] - 1;         /* 0..63 */
459       comes_from_e_bit = e_inverse[comes_from_f_bit]; /* 0..95 */
460       comes_from_word  = comes_from_e_bit / 6;        /* 0..15 */
461       bit_within_word  = comes_from_e_bit % 6;        /* 0..5  */
462
463       mask1 = longmask[bit_within_word + 26];
464       mask2 = longmask[o_bit];
465
466       for(word_value = 64; word_value--;) {
467         if(word_value & mask1)
468           efp[comes_from_word][word_value][o_long] |= mask2;
469       }
470     }
471     small_tables_initialized = 1;
472 #ifdef __GNU_LIBRARY__
473 small_tables_done:
474     __libc_lock_unlock(_ufc_tables_lock);
475 #endif
476   }
477
478   /*
479    * Create the sb tables:
480    *
481    * For each 12 bit segment of an 48 bit intermediate
482    * result, the sb table precomputes the two 4 bit
483    * values of the sbox lookups done with the two 6
484    * bit halves, shifts them to their proper place,
485    * sends them through perm32 and finally E expands
486    * them so that they are ready for the next
487    * DES round.
488    *
489    */
490
491   _ufc_clearmem((char*)__data->sb0, (int)sizeof(__data->sb0));
492   _ufc_clearmem((char*)__data->sb1, (int)sizeof(__data->sb1));
493   _ufc_clearmem((char*)__data->sb2, (int)sizeof(__data->sb2));
494   _ufc_clearmem((char*)__data->sb3, (int)sizeof(__data->sb3));
495
496   for(sg = 0; sg < 4; sg++) {
497     int j1, j2;
498     int s1, s2;
499
500     for(j1 = 0; j1 < 64; j1++) {
501       s1 = s_lookup(2 * sg, j1);
502       for(j2 = 0; j2 < 64; j2++) {
503         ufc_long to_permute, inx;
504
505         s2         = s_lookup(2 * sg + 1, j2);
506         to_permute = (((ufc_long)s1 << 4)  |
507                       (ufc_long)s2) << (24 - 8 * (ufc_long)sg);
508
509 #ifdef _UFC_32_
510         inx = ((j1 << 6)  | j2) << 1;
511         sb[sg][inx  ]  = eperm32tab[0][(to_permute >> 24) & 0xff][0];
512         sb[sg][inx+1]  = eperm32tab[0][(to_permute >> 24) & 0xff][1];
513         sb[sg][inx  ] |= eperm32tab[1][(to_permute >> 16) & 0xff][0];
514         sb[sg][inx+1] |= eperm32tab[1][(to_permute >> 16) & 0xff][1];
515         sb[sg][inx  ] |= eperm32tab[2][(to_permute >>  8) & 0xff][0];
516         sb[sg][inx+1] |= eperm32tab[2][(to_permute >>  8) & 0xff][1];
517         sb[sg][inx  ] |= eperm32tab[3][(to_permute)       & 0xff][0];
518         sb[sg][inx+1] |= eperm32tab[3][(to_permute)       & 0xff][1];
519 #endif
520 #ifdef _UFC_64_
521         inx = ((j1 << 6)  | j2);
522         sb[sg][inx]  =
523           ((long64)eperm32tab[0][(to_permute >> 24) & 0xff][0] << 32) |
524            (long64)eperm32tab[0][(to_permute >> 24) & 0xff][1];
525         sb[sg][inx] |=
526           ((long64)eperm32tab[1][(to_permute >> 16) & 0xff][0] << 32) |
527            (long64)eperm32tab[1][(to_permute >> 16) & 0xff][1];
528         sb[sg][inx] |=
529           ((long64)eperm32tab[2][(to_permute >>  8) & 0xff][0] << 32) |
530            (long64)eperm32tab[2][(to_permute >>  8) & 0xff][1];
531         sb[sg][inx] |=
532           ((long64)eperm32tab[3][(to_permute)       & 0xff][0] << 32) |
533            (long64)eperm32tab[3][(to_permute)       & 0xff][1];
534 #endif
535       }
536     }
537   }
538
539   __data->current_saltbits = 0;
540   __data->current_salt[0] = 0;
541   __data->current_salt[1] = 0;
542   __data->initialized++;
543 }
544
545 void
546 __init_des()
547 {
548   __init_des_r(&_ufc_foobar);
549 }
550
551 /*
552  * Process the elements of the sb table permuting the
553  * bits swapped in the expansion by the current salt.
554  */
555
556 #ifdef _UFC_32_
557 STATIC void
558 shuffle_sb(k, saltbits)
559      long32 *k;
560      ufc_long saltbits;
561 {
562   ufc_long j;
563   long32 x;
564   for(j=4096; j--;) {
565     x = (k[0] ^ k[1]) & (long32)saltbits;
566     *k++ ^= x;
567     *k++ ^= x;
568   }
569 }
570 #endif
571
572 #ifdef _UFC_64_
573 STATIC void
574 shuffle_sb(k, saltbits)
575      long64 *k;
576      ufc_long saltbits;
577 {
578   ufc_long j;
579   long64 x;
580   for(j=4096; j--;) {
581     x = ((*k >> 32) ^ *k) & (long64)saltbits;
582     *k++ ^= (x << 32) | x;
583   }
584 }
585 #endif
586
587 /*
588  * Setup the unit for a new salt
589  * Hopefully we'll not see a new salt in each crypt call.
590  */
591
592 void
593 _ufc_setup_salt_r(s, __data)
594      __const char *s;
595      struct crypt_data * __restrict __data;
596 {
597   ufc_long i, j, saltbits;
598
599   if(__data->initialized == 0)
600     __init_des_r(__data);
601
602   if(s[0] == __data->current_salt[0] && s[1] == __data->current_salt[1])
603     return;
604   __data->current_salt[0] = s[0]; __data->current_salt[1] = s[1];
605
606   /*
607    * This is the only crypt change to DES:
608    * entries are swapped in the expansion table
609    * according to the bits set in the salt.
610    */
611   saltbits = 0;
612   for(i = 0; i < 2; i++) {
613     long c=ascii_to_bin(s[i]);
614     for(j = 0; j < 6; j++) {
615       if((c >> j) & 0x1)
616         saltbits |= BITMASK[6 * i + j];
617     }
618   }
619
620   /*
621    * Permute the sb table values
622    * to reflect the changed e
623    * selection table
624    */
625 #ifdef _UFC_32_
626 #define LONGG long32*
627 #endif
628 #ifdef _UFC_64_
629 #define LONGG long64*
630 #endif
631
632   shuffle_sb((LONGG)__data->sb0, __data->current_saltbits ^ saltbits);
633   shuffle_sb((LONGG)__data->sb1, __data->current_saltbits ^ saltbits);
634   shuffle_sb((LONGG)__data->sb2, __data->current_saltbits ^ saltbits);
635   shuffle_sb((LONGG)__data->sb3, __data->current_saltbits ^ saltbits);
636
637   __data->current_saltbits = saltbits;
638 }
639
640 void
641 _ufc_mk_keytab_r(key, __data)
642      const char *key;
643      struct crypt_data * __restrict __data;
644 {
645   ufc_long v1, v2, *k1;
646   int i;
647 #ifdef _UFC_32_
648   long32 v, *k2;
649   k2 = (long32*)__data->keysched;
650 #endif
651 #ifdef _UFC_64_
652   long64 v, *k2;
653   k2 = (long64*)__data->keysched;
654 #endif
655
656   v1 = v2 = 0; k1 = &do_pc1[0][0][0];
657   for(i = 8; i--;) {
658     v1 |= k1[*key   & 0x7f]; k1 += 128;
659     v2 |= k1[*key++ & 0x7f]; k1 += 128;
660   }
661
662   for(i = 0; i < 16; i++) {
663     k1 = &do_pc2[0][0];
664
665     v1 = (v1 << rots[i]) | (v1 >> (28 - rots[i]));
666     v  = k1[(v1 >> 21) & 0x7f]; k1 += 128;
667     v |= k1[(v1 >> 14) & 0x7f]; k1 += 128;
668     v |= k1[(v1 >>  7) & 0x7f]; k1 += 128;
669     v |= k1[(v1      ) & 0x7f]; k1 += 128;
670
671 #ifdef _UFC_32_
672     *k2++ = (v | 0x00008000);
673     v = 0;
674 #endif
675 #ifdef _UFC_64_
676     v = (v << 32);
677 #endif
678
679     v2 = (v2 << rots[i]) | (v2 >> (28 - rots[i]));
680     v |= k1[(v2 >> 21) & 0x7f]; k1 += 128;
681     v |= k1[(v2 >> 14) & 0x7f]; k1 += 128;
682     v |= k1[(v2 >>  7) & 0x7f]; k1 += 128;
683     v |= k1[(v2      ) & 0x7f];
684
685 #ifdef _UFC_32_
686     *k2++ = (v | 0x00008000);
687 #endif
688 #ifdef _UFC_64_
689     *k2++ = v | 0x0000800000008000l;
690 #endif
691   }
692
693   __data->direction = 0;
694 }
695
696 /*
697  * Undo an extra E selection and do final permutations
698  */
699
700 void
701 _ufc_dofinalperm_r(res, __data)
702      ufc_long *res;
703      struct crypt_data * __restrict __data;
704 {
705   ufc_long v1, v2, x;
706   ufc_long l1,l2,r1,r2;
707
708   l1 = res[0]; l2 = res[1];
709   r1 = res[2]; r2 = res[3];
710
711   x = (l1 ^ l2) & __data->current_saltbits; l1 ^= x; l2 ^= x;
712   x = (r1 ^ r2) & __data->current_saltbits; r1 ^= x; r2 ^= x;
713
714   v1=v2=0; l1 >>= 3; l2 >>= 3; r1 >>= 3; r2 >>= 3;
715
716   v1 |= efp[15][ r2         & 0x3f][0]; v2 |= efp[15][ r2 & 0x3f][1];
717   v1 |= efp[14][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[14][ r2 & 0x3f][1];
718   v1 |= efp[13][(r2 >>= 10) & 0x3f][0]; v2 |= efp[13][ r2 & 0x3f][1];
719   v1 |= efp[12][(r2 >>= 6)  & 0x3f][0]; v2 |= efp[12][ r2 & 0x3f][1];
720
721   v1 |= efp[11][ r1         & 0x3f][0]; v2 |= efp[11][ r1 & 0x3f][1];
722   v1 |= efp[10][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[10][ r1 & 0x3f][1];
723   v1 |= efp[ 9][(r1 >>= 10) & 0x3f][0]; v2 |= efp[ 9][ r1 & 0x3f][1];
724   v1 |= efp[ 8][(r1 >>= 6)  & 0x3f][0]; v2 |= efp[ 8][ r1 & 0x3f][1];
725
726   v1 |= efp[ 7][ l2         & 0x3f][0]; v2 |= efp[ 7][ l2 & 0x3f][1];
727   v1 |= efp[ 6][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 6][ l2 & 0x3f][1];
728   v1 |= efp[ 5][(l2 >>= 10) & 0x3f][0]; v2 |= efp[ 5][ l2 & 0x3f][1];
729   v1 |= efp[ 4][(l2 >>= 6)  & 0x3f][0]; v2 |= efp[ 4][ l2 & 0x3f][1];
730
731   v1 |= efp[ 3][ l1         & 0x3f][0]; v2 |= efp[ 3][ l1 & 0x3f][1];
732   v1 |= efp[ 2][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 2][ l1 & 0x3f][1];
733   v1 |= efp[ 1][(l1 >>= 10) & 0x3f][0]; v2 |= efp[ 1][ l1 & 0x3f][1];
734   v1 |= efp[ 0][(l1 >>= 6)  & 0x3f][0]; v2 |= efp[ 0][ l1 & 0x3f][1];
735
736   res[0] = v1; res[1] = v2;
737 }
738
739 /*
740  * crypt only: convert from 64 bit to 11 bit ASCII
741  * prefixing with the salt
742  */
743
744 void
745 _ufc_output_conversion_r(v1, v2, salt, __data)
746      ufc_long v1, v2;
747      __const char *salt;
748      struct crypt_data * __restrict __data;
749 {
750   int i, s, shf;
751
752   __data->crypt_3_buf[0] = salt[0];
753   __data->crypt_3_buf[1] = salt[1] ? salt[1] : salt[0];
754
755   for(i = 0; i < 5; i++) {
756     shf = (26 - 6 * i); /* to cope with MSC compiler bug */
757     __data->crypt_3_buf[i + 2] = bin_to_ascii((v1 >> shf) & 0x3f);
758   }
759
760   s  = (v2 & 0xf) << 2;
761   v2 = (v2 >> 2) | ((v1 & 0x3) << 30);
762
763   for(i = 5; i < 10; i++) {
764     shf = (56 - 6 * i);
765     __data->crypt_3_buf[i + 2] = bin_to_ascii((v2 >> shf) & 0x3f);
766   }
767
768   __data->crypt_3_buf[12] = bin_to_ascii(s);
769   __data->crypt_3_buf[13] = 0;
770 }
771
772
773 /*
774  * UNIX encrypt function. Takes a bitvector
775  * represented by one byte per bit and
776  * encrypt/decrypt according to edflag
777  */
778
779 void
780 __encrypt_r(__block, __edflag, __data)
781      char *__block;
782      int __edflag;
783      struct crypt_data * __restrict __data;
784 {
785   ufc_long l1, l2, r1, r2, res[4];
786   int i;
787 #ifdef _UFC_32_
788   long32 *kt;
789   kt = (long32*)__data->keysched;
790 #endif
791 #ifdef _UFC_64_
792   long64 *kt;
793   kt = (long64*)__data->keysched;
794 #endif
795
796   /*
797    * Undo any salt changes to E expansion
798    */
799   _ufc_setup_salt_r("..", __data);
800
801   /*
802    * Reverse key table if
803    * changing operation (encrypt/decrypt)
804    */
805   if((__edflag == 0) != (__data->direction == 0)) {
806     for(i = 0; i < 8; i++) {
807 #ifdef _UFC_32_
808       long32 x;
809       x = kt[2 * (15-i)];
810       kt[2 * (15-i)] = kt[2 * i];
811       kt[2 * i] = x;
812
813       x = kt[2 * (15-i) + 1];
814       kt[2 * (15-i) + 1] = kt[2 * i + 1];
815       kt[2 * i + 1] = x;
816 #endif
817 #ifdef _UFC_64_
818       long64 x;
819       x = kt[15-i];
820       kt[15-i] = kt[i];
821       kt[i] = x;
822 #endif
823       }
824     __data->direction = __edflag;
825   }
826
827   /*
828    * Do initial permutation + E expansion
829    */
830   i = 0;
831   for(l1 = 0; i < 24; i++) {
832     if(__block[initial_perm[esel[i]-1]-1])
833       l1 |= BITMASK[i];
834   }
835   for(l2 = 0; i < 48; i++) {
836     if(__block[initial_perm[esel[i]-1]-1])
837       l2 |= BITMASK[i-24];
838   }
839
840   i = 0;
841   for(r1 = 0; i < 24; i++) {
842     if(__block[initial_perm[esel[i]-1+32]-1])
843       r1 |= BITMASK[i];
844   }
845   for(r2 = 0; i < 48; i++) {
846     if(__block[initial_perm[esel[i]-1+32]-1])
847       r2 |= BITMASK[i-24];
848   }
849
850   /*
851    * Do DES inner loops + final conversion
852    */
853   res[0] = l1; res[1] = l2;
854   res[2] = r1; res[3] = r2;
855   _ufc_doit_r((ufc_long)1, __data, &res[0]);
856
857   /*
858    * Do final permutations
859    */
860   _ufc_dofinalperm_r(res, __data);
861
862   /*
863    * And convert to bit array
864    */
865   l1 = res[0]; r1 = res[1];
866   for(i = 0; i < 32; i++) {
867     *__block++ = (l1 & longmask[i]) != 0;
868   }
869   for(i = 0; i < 32; i++) {
870     *__block++ = (r1 & longmask[i]) != 0;
871   }
872 }
873 weak_alias (__encrypt_r, encrypt_r)
874
875 void
876 encrypt(__block, __edflag)
877      char *__block;
878      int __edflag;
879 {
880   __encrypt_r(__block, __edflag, &_ufc_foobar);
881 }
882
883
884 /*
885  * UNIX setkey function. Take a 64 bit DES
886  * key and setup the machinery.
887  */
888
889 void
890 __setkey_r(__key, __data)
891      __const char *__key;
892      struct crypt_data * __restrict __data;
893 {
894   int i,j;
895   unsigned char c;
896   unsigned char ktab[8];
897
898   _ufc_setup_salt_r("..", __data); /* be sure we're initialized */
899
900   for(i = 0; i < 8; i++) {
901     for(j = 0, c = 0; j < 8; j++)
902       c = c << 1 | *__key++;
903     ktab[i] = c >> 1;
904   }
905   _ufc_mk_keytab_r((char *) ktab, __data);
906 }
907 weak_alias (__setkey_r, setkey_r)
908
909 void
910 setkey(__key)
911      __const char *__key;
912 {
913   __setkey_r(__key, &_ufc_foobar);
914 }