fgms 0.11.8
The
FlightGear MultiPlayer Server
project
crypt-win.c
Go to the documentation of this file.
1 /* @(#)crypt.c 4.1 (Berkeley) 12/21/80 */
2 /*
3  * This program implements the
4  * Proposed Federal Information Processing
5  * Data Encryption Standard.
6  * See Federal Register, March 17, 1975 (40FR12134)
7  */
8 
9 /*
10  * Initial permutation,
11  */
12 static char IP[] = {
13  58,50,42,34,26,18,10, 2,
14  60,52,44,36,28,20,12, 4,
15  62,54,46,38,30,22,14, 6,
16  64,56,48,40,32,24,16, 8,
17  57,49,41,33,25,17, 9, 1,
18  59,51,43,35,27,19,11, 3,
19  61,53,45,37,29,21,13, 5,
20  63,55,47,39,31,23,15, 7,
21 };
22 
23 /*
24  * Final permutation, FP = IP^(-1)
25  */
26 static char FP[] = {
27  40, 8,48,16,56,24,64,32,
28  39, 7,47,15,55,23,63,31,
29  38, 6,46,14,54,22,62,30,
30  37, 5,45,13,53,21,61,29,
31  36, 4,44,12,52,20,60,28,
32  35, 3,43,11,51,19,59,27,
33  34, 2,42,10,50,18,58,26,
34  33, 1,41, 9,49,17,57,25,
35 };
36 
37 /*
38  * Permuted-choice 1 from the key bits
39  * to yield C and D.
40  * Note that bits 8,16... are left out:
41  * They are intended for a parity check.
42  */
43 static char PC1_C[] = {
44  57,49,41,33,25,17, 9,
45  1,58,50,42,34,26,18,
46  10, 2,59,51,43,35,27,
47  19,11, 3,60,52,44,36,
48 };
49 
50 static char PC1_D[] = {
51  63,55,47,39,31,23,15,
52  7,62,54,46,38,30,22,
53  14, 6,61,53,45,37,29,
54  21,13, 5,28,20,12, 4,
55 };
56 
57 /*
58  * Sequence of shifts used for the key schedule.
59 */
60 static char shifts[] = {
61  1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
62 };
63 
64 /*
65  * Permuted-choice 2, to pick out the bits from
66  * the CD array that generate the key schedule.
67  */
68 static char PC2_C[] = {
69  14,17,11,24, 1, 5,
70  3,28,15, 6,21,10,
71  23,19,12, 4,26, 8,
72  16, 7,27,20,13, 2,
73 };
74 
75 static char PC2_D[] = {
76  41,52,31,37,47,55,
77  30,40,51,45,33,48,
78  44,49,39,56,34,53,
79  46,42,50,36,29,32,
80 };
81 
82 /*
83  * The C and D arrays used to calculate the key schedule.
84  */
85 
86 static char C[28];
87 static char D[28];
88 /*
89  * The key schedule.
90  * Generated from the key.
91  */
92 static char KS[16][48];
93 
94 /*
95  * Set up the key schedule from the key.
96  */
97 
98 setkey(key)
99 char *key;
100 {
101  register i, j, k;
102  int t;
103 
104  /*
105  * First, generate C and D by permuting
106  * the key. The low order bit of each
107  * 8-bit char is not used, so C and D are only 28
108  * bits apiece.
109  */
110  for (i=0; i<28; i++) {
111  C[i] = key[PC1_C[i]-1];
112  D[i] = key[PC1_D[i]-1];
113  }
114  /*
115  * To generate Ki, rotate C and D according
116  * to schedule and pick up a permutation
117  * using PC2.
118  */
119  for (i=0; i<16; i++) {
120  /*
121  * rotate.
122  */
123  for (k=0; k<shifts[i]; k++) {
124  t = C[0];
125  for (j=0; j<28-1; j++)
126  C[j] = C[j+1];
127  C[27] = t;
128  t = D[0];
129  for (j=0; j<28-1; j++)
130  D[j] = D[j+1];
131  D[27] = t;
132  }
133  /*
134  * get Ki. Note C and D are concatenated.
135  */
136  for (j=0; j<24; j++) {
137  KS[i][j] = C[PC2_C[j]-1];
138  KS[i][j+24] = D[PC2_D[j]-28-1];
139  }
140  }
141 }
142 
143 /*
144  * The E bit-selection table.
145  */
146 static char E[48];
147 static char e[] = {
148  32, 1, 2, 3, 4, 5,
149  4, 5, 6, 7, 8, 9,
150  8, 9,10,11,12,13,
151  12,13,14,15,16,17,
152  16,17,18,19,20,21,
153  20,21,22,23,24,25,
154  24,25,26,27,28,29,
155  28,29,30,31,32, 1,
156 };
157 
158 /*
159  * The 8 selection functions.
160  * For some reason, they give a 0-origin
161  * index, unlike everything else.
162  */
163 static char S[8][64] = {
164  14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
165  0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
166  4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
167  15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
168 
169  15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
170  3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
171  0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
172  13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
173 
174  10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
175  13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
176  13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
177  1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
178 
179  7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
180  13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
181  10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
182  3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
183 
184  2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
185  14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
186  4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
187  11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
188 
189  12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
190  10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
191  9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
192  4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
193 
194  4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
195  13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
196  1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
197  6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
198 
199  13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
200  1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
201  7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
202  2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
203 };
204 
205 /*
206  * P is a permutation on the selected combination
207  * of the current L and key.
208  */
209 static char P[] = {
210  16, 7,20,21,
211  29,12,28,17,
212  1,15,23,26,
213  5,18,31,10,
214  2, 8,24,14,
215  32,27, 3, 9,
216  19,13,30, 6,
217  22,11, 4,25,
218 };
219 
220 /*
221  * The current block, divided into 2 halves.
222  */
223 static char L[32], R[32];
224 static char tempL[32];
225 static char f[32];
226 
227 /*
228  * The combination of the key and the input, before selection.
229  */
230 static char preS[48];
231 
232 /*
233  * The payoff: encrypt a block.
234  */
235 
236 encrypt(block, edflag)
237 char *block;
238 {
239  int i, ii;
240  register t, j, k;
241 
242  /*
243  * First, permute the bits in the input
244  */
245  for (j=0; j<64; j++)
246  L[j] = block[IP[j]-1];
247  /*
248  * Perform an encryption operation 16 times.
249  */
250  for (ii=0; ii<16; ii++) {
251  /*
252  * Set direction
253  */
254  if (edflag)
255  i = 15-ii;
256  else
257  i = ii;
258  /*
259  * Save the R array,
260  * which will be the new L.
261  */
262  for (j=0; j<32; j++)
263  tempL[j] = R[j];
264  /*
265  * Expand R to 48 bits using the E selector;
266  * exclusive-or with the current key bits.
267  */
268  for (j=0; j<48; j++)
269  preS[j] = R[E[j]-1] ^ KS[i][j];
270  /*
271  * The pre-select bits are now considered
272  * in 8 groups of 6 bits each.
273  * The 8 selection functions map these
274  * 6-bit quantities into 4-bit quantities
275  * and the results permuted
276  * to make an f(R, K).
277  * The indexing into the selection functions
278  * is peculiar; it could be simplified by
279  * rewriting the tables.
280  */
281  for (j=0; j<8; j++) {
282  t = 6*j;
283  k = S[j][(preS[t+0]<<5)+
284  (preS[t+1]<<3)+
285  (preS[t+2]<<2)+
286  (preS[t+3]<<1)+
287  (preS[t+4]<<0)+
288  (preS[t+5]<<4)];
289  t = 4*j;
290  f[t+0] = (k>>3)&01;
291  f[t+1] = (k>>2)&01;
292  f[t+2] = (k>>1)&01;
293  f[t+3] = (k>>0)&01;
294  }
295  /*
296  * The new R is L ^ f(R, K).
297  * The f here has to be permuted first, though.
298  */
299  for (j=0; j<32; j++)
300  R[j] = L[j] ^ f[P[j]-1];
301  /*
302  * Finally, the new L (the original R)
303  * is copied back.
304  */
305  for (j=0; j<32; j++)
306  L[j] = tempL[j];
307  }
308  /*
309  * The output L and R are reversed.
310  */
311  for (j=0; j<32; j++) {
312  t = L[j];
313  L[j] = R[j];
314  R[j] = t;
315  }
316  /*
317  * The final output
318  * gets the inverse permutation of the very original.
319  */
320  for (j=0; j<64; j++)
321  block[j] = L[FP[j]-1];
322 }
323 
324 char *
325 crypt(pw,salt)
326 char *pw;
327 char *salt;
328 {
329  register i, j, c;
330  int temp;
331  static char block[66], iobuf[16];
332  for(i=0; i<66; i++)
333  block[i] = 0;
334  for(i=0; (c= *pw) && i<64; pw++){
335  for(j=0; j<7; j++, i++)
336  block[i] = (c>>(6-j)) & 01;
337  i++;
338  }
339 
340  setkey(block);
341 
342  for(i=0; i<66; i++)
343  block[i] = 0;
344 
345  for(i=0;i<48;i++)
346  E[i] = e[i];
347 
348  for(i=0;i<2;i++){
349  c = *salt++;
350  iobuf[i] = c;
351  if(c>'Z') c -= 6;
352  if(c>'9') c -= 7;
353  c -= '.';
354  for(j=0;j<6;j++){
355  if((c>>j) & 01){
356  temp = E[6*i+j];
357  E[6*i+j] = E[6*i+j+24];
358  E[6*i+j+24] = temp;
359  }
360  }
361  }
362 
363  for(i=0; i<25; i++)
364  encrypt(block,0);
365 
366  for(i=0; i<11; i++){
367  c = 0;
368  for(j=0; j<6; j++){
369  c <<= 1;
370  c |= block[6*i+j];
371  }
372  c += '.';
373  if(c>'9') c += 7;
374  if(c>'Z') c += 6;
375  iobuf[i+2] = c;
376  }
377  iobuf[i+2] = 0;
378  if(iobuf[1]==0)
379  iobuf[1] = iobuf[0];
380  return(iobuf);
381 }
static char PC1_D[]
Definition: crypt-win.c:50
static char L[32]
Definition: crypt-win.c:223
static char preS[48]
Definition: crypt-win.c:230
static char D[28]
Definition: crypt-win.c:87
char * crypt(char *pw, char *salt)
Definition: crypt-win.c:325
static char f[32]
Definition: crypt-win.c:225
encrypt(char *block, edflag)
Definition: crypt-win.c:236
static char E[48]
Definition: crypt-win.c:146
static char shifts[]
Definition: crypt-win.c:60
static char PC2_C[]
Definition: crypt-win.c:68
static char FP[]
Definition: crypt-win.c:26
static char P[]
Definition: crypt-win.c:209
static char KS[16][48]
Definition: crypt-win.c:92
static char PC2_D[]
Definition: crypt-win.c:75
static char C[28]
Definition: crypt-win.c:86
static char tempL[32]
Definition: crypt-win.c:224
setkey(char *key)
Definition: crypt-win.c:98
static char PC1_C[]
Definition: crypt-win.c:43
static char R[32]
Definition: crypt-win.c:223
static char e[]
Definition: crypt-win.c:147
static char S[8][64]
Definition: crypt-win.c:163
static char IP[]
Definition: crypt-win.c:12