← Back to branch summary

~ubuntu-branches/debian/lenny/italc/lenny

« back to all changes in this revision

Viewing changes to ica/win32/src/d3des_w32.c

  • Committer: Bazaar Package Importer
  • Author(s): Patrick Winnertz
  • Date: 2008-06-17 13:46:54 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20080617134654-2y5m7ki93r5c1ysf
Tags: upstream-1.0.9~rc3
Import upstream version 1.0.9~rc3

Show diffs side-by-side

added added

removed removed

Lines of Context:
ica/win32/src/d3des_w32.c
 
1
/*
 
2
 * This is D3DES (V5.09) by Richard Outerbridge with the double and
 
3
 * triple-length support removed for use in VNC.  Also the bytebit[] array
 
4
 * has been reversed so that the most significant bit in each byte of the
 
5
 * key is ignored, not the least significant.
 
6
 *
 
7
 * These changes are 
 
8
 * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
 
9
 *
 
10
 * This software is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
13
 */
 
14
 
 
15
/* D3DES (V5.09) -
 
16
 *
 
17
 * A portable, public domain, version of the Data Encryption Standard.
 
18
 *
 
19
 * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
 
20
 * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
 
21
 * code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
 
22
 * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
 
23
 * for humouring me on.
 
24
 *
 
25
 * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
 
26
 * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
 
27
 */
 
28
 
 
29
#include "d3des.h"
 
30
 
 
31
static void scrunch(unsigned char *, unsigned long *);
 
32
static void unscrun(unsigned long *, unsigned char *);
 
33
static void desfunc(unsigned long *, unsigned long *);
 
34
static void cookey(unsigned long *);
 
35
 
 
36
static unsigned long KnL[32] = { 0L };
 
37
static unsigned long KnR[32] = { 0L };
 
38
static unsigned long Kn3[32] = { 0L };
 
39
static unsigned char Df_Key[24] = {
 
40
        0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
 
41
        0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10,
 
42
        0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67 };
 
43
 
 
44
static unsigned short bytebit[8]        = {
 
45
        01, 02, 04, 010, 020, 040, 0100, 0200 };
 
46
 
 
47
static unsigned long bigbyte[24] = {
 
48
        0x800000L,      0x400000L,      0x200000L,      0x100000L,
 
49
        0x80000L,       0x40000L,       0x20000L,       0x10000L,
 
50
        0x8000L,        0x4000L,        0x2000L,        0x1000L,
 
51
        0x800L,         0x400L,         0x200L,         0x100L,
 
52
        0x80L,          0x40L,          0x20L,          0x10L,
 
53
        0x8L,           0x4L,           0x2L,           0x1L    };
 
54
 
 
55
/* Use the key schedule specified in the Standard (ANSI X3.92-1981). */
 
56
 
 
57
static unsigned char pc1[56] = {
 
58
        56, 48, 40, 32, 24, 16,  8,      0, 57, 49, 41, 33, 25, 17,
 
59
         9,  1, 58, 50, 42, 34, 26,     18, 10,  2, 59, 51, 43, 35,
 
60
        62, 54, 46, 38, 30, 22, 14,      6, 61, 53, 45, 37, 29, 21,
 
61
        13,  5, 60, 52, 44, 36, 28,     20, 12,  4, 27, 19, 11,  3 };
 
62
 
 
63
static unsigned char totrot[16] = {
 
64
        1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
 
65
 
 
66
static unsigned char pc2[48] = {
 
67
        13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
 
68
        22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
 
69
        40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
 
70
        43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
 
71
 
 
72
void deskey(key, edf)   /* Thanks to James Gillogly & Phil Karn! */
 
73
unsigned char *key;
 
74
int edf;
 
75
{
 
76
        register int i, j, l, m, n;
 
77
        unsigned char pc1m[56], pcr[56];
 
78
        unsigned long kn[32];
 
79
 
 
80
        for ( j = 0; j < 56; j++ ) {
 
81
                l = pc1[j];
 
82
                m = l & 07;
 
83
                pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
 
84
                }
 
85
        for( i = 0; i < 16; i++ ) {
 
86
                if( edf == DE1 ) m = (15 - i) << 1;
 
87
                else m = i << 1;
 
88
                n = m + 1;
 
89
                kn[m] = kn[n] = 0L;
 
90
                for( j = 0; j < 28; j++ ) {
 
91
                        l = j + totrot[i];
 
92
                        if( l < 28 ) pcr[j] = pc1m[l];
 
93
                        else pcr[j] = pc1m[l - 28];
 
94
                        }
 
95
                for( j = 28; j < 56; j++ ) {
 
96
                    l = j + totrot[i];
 
97
                    if( l < 56 ) pcr[j] = pc1m[l];
 
98
                    else pcr[j] = pc1m[l - 28];
 
99
                    }
 
100
                for( j = 0; j < 24; j++ ) {
 
101
                        if( pcr[pc2[j]] ) kn[m] |= bigbyte[j];
 
102
                        if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j];
 
103
                        }
 
104
                }
 
105
        cookey(kn);
 
106
        return;
 
107
        }
 
108
 
 
109
static void cookey(raw1)
 
110
register unsigned long *raw1;
 
111
{
 
112
        register unsigned long *cook, *raw0;
 
113
        unsigned long dough[32];
 
114
        register int i;
 
115
 
 
116
        cook = dough;
 
117
        for( i = 0; i < 16; i++, raw1++ ) {
 
118
                raw0 = raw1++;
 
119
                *cook    = (*raw0 & 0x00fc0000L) << 6;
 
120
                *cook   |= (*raw0 & 0x00000fc0L) << 10;
 
121
                *cook   |= (*raw1 & 0x00fc0000L) >> 10;
 
122
                *cook++ |= (*raw1 & 0x00000fc0L) >> 6;
 
123
                *cook    = (*raw0 & 0x0003f000L) << 12;
 
124
                *cook   |= (*raw0 & 0x0000003fL) << 16;
 
125
                *cook   |= (*raw1 & 0x0003f000L) >> 4;
 
126
                *cook++ |= (*raw1 & 0x0000003fL);
 
127
                }
 
128
        usekey(dough);
 
129
        return;
 
130
        }
 
131
 
 
132
void cpkey(into)
 
133
register unsigned long *into;
 
134
{
 
135
        register unsigned long *from, *endp;
 
136
 
 
137
        from = KnL, endp = &KnL[32];
 
138
        while( from < endp ) *into++ = *from++;
 
139
        return;
 
140
        }
 
141
 
 
142
void usekey(from)
 
143
register unsigned long *from;
 
144
{
 
145
        register unsigned long *to, *endp;
 
146
 
 
147
        to = KnL, endp = &KnL[32];
 
148
        while( to < endp ) *to++ = *from++;
 
149
        return;
 
150
        }
 
151
 
 
152
void des(inblock, outblock)
 
153
unsigned char *inblock, *outblock;
 
154
{
 
155
        unsigned long work[2];
 
156
 
 
157
        scrunch(inblock, work);
 
158
        desfunc(work, KnL);
 
159
        unscrun(work, outblock);
 
160
        return;
 
161
        }
 
162
 
 
163
static void scrunch(outof, into)
 
164
register unsigned char *outof;
 
165
register unsigned long *into;
 
166
{
 
167
        *into    = (*outof++ & 0xffL) << 24;
 
168
        *into   |= (*outof++ & 0xffL) << 16;
 
169
        *into   |= (*outof++ & 0xffL) << 8;
 
170
        *into++ |= (*outof++ & 0xffL);
 
171
        *into    = (*outof++ & 0xffL) << 24;
 
172
        *into   |= (*outof++ & 0xffL) << 16;
 
173
        *into   |= (*outof++ & 0xffL) << 8;
 
174
        *into   |= (*outof   & 0xffL);
 
175
        return;
 
176
        }
 
177
 
 
178
static void unscrun(outof, into)
 
179
register unsigned long *outof;
 
180
register unsigned char *into;
 
181
{
 
182
        *into++ = (unsigned char)((*outof >> 24) & 0xffL);
 
183
        *into++ = (unsigned char)((*outof >> 16) & 0xffL);
 
184
        *into++ = (unsigned char)((*outof >>  8) & 0xffL);
 
185
        *into++ = (unsigned char)( *outof++          & 0xffL);
 
186
        *into++ = (unsigned char)((*outof >> 24) & 0xffL);
 
187
        *into++ = (unsigned char)((*outof >> 16) & 0xffL);
 
188
        *into++ = (unsigned char)((*outof >>  8) & 0xffL);
 
189
        *into   = (unsigned char)( *outof            & 0xffL);
 
190
        return;
 
191
        }
 
192
 
 
193
static unsigned long SP1[64] = {
 
194
        0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
 
195
        0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
 
196
        0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
 
197
        0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
 
198
        0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
 
199
        0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
 
200
        0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
 
201
        0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
 
202
        0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
 
203
        0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
 
204
        0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
 
205
        0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
 
206
        0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
 
207
        0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
 
208
        0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
 
209
        0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };
 
210
 
 
211
static unsigned long SP2[64] = {
 
212
        0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
 
213
        0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
 
214
        0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
 
215
        0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
 
216
        0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
 
217
        0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
 
218
        0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
 
219
        0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
 
220
        0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
 
221
        0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
 
222
        0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
 
223
        0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
 
224
        0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
 
225
        0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
 
226
        0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
 
227
        0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };
 
228
 
 
229
static unsigned long SP3[64] = {
 
230
        0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
 
231
        0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
 
232
        0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
 
233
        0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
 
234
        0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
 
235
        0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
 
236
        0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
 
237
        0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
 
238
        0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
 
239
        0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
 
240
        0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
 
241
        0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
 
242
        0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
 
243
        0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
 
244
        0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
 
245
        0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };
 
246
 
 
247
static unsigned long SP4[64] = {
 
248
        0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
 
249
        0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
 
250
        0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
 
251
        0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
 
252
        0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
 
253
        0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
 
254
        0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
 
255
        0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
 
256
        0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
 
257
        0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
 
258
        0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
 
259
        0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
 
260
        0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
 
261
        0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
 
262
        0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
 
263
        0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };
 
264
 
 
265
static unsigned long SP5[64] = {
 
266
        0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
 
267
        0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
 
268
        0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
 
269
        0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
 
270
        0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
 
271
        0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
 
272
        0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
 
273
        0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
 
274
        0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
 
275
        0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
 
276
        0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
 
277
        0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
 
278
        0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
 
279
        0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
 
280
        0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
 
281
        0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };
 
282
 
 
283
static unsigned long SP6[64] = {
 
284
        0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
 
285
        0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
 
286
        0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
 
287
        0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
 
288
        0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
 
289
        0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
 
290
        0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
 
291
        0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
 
292
        0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
 
293
        0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
 
294
        0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
 
295
        0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
 
296
        0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
 
297
        0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
 
298
        0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
 
299
        0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };
 
300
 
 
301
static unsigned long SP7[64] = {
 
302
        0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
 
303
        0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
 
304
        0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
 
305
        0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
 
306
        0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
 
307
        0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
 
308
        0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
 
309
        0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
 
310
        0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
 
311
        0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
 
312
        0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
 
313
        0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
 
314
        0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
 
315
        0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
 
316
        0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
 
317
        0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
 
318
 
 
319
static unsigned long SP8[64] = {
 
320
        0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
 
321
        0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
 
322
        0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
 
323
        0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
 
324
        0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
 
325
        0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
 
326
        0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
 
327
        0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
 
328
        0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
 
329
        0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
 
330
        0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
 
331
        0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
 
332
        0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
 
333
        0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
 
334
        0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
 
335
        0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
 
336
 
 
337
static void desfunc(block, keys)
 
338
register unsigned long *block, *keys;
 
339
{
 
340
        register unsigned long fval, work, right, leftt;
 
341
        register int round;
 
342
 
 
343
        leftt = block[0];
 
344
        right = block[1];
 
345
        work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
 
346
        right ^= work;
 
347
        leftt ^= (work << 4);
 
348
        work = ((leftt >> 16) ^ right) & 0x0000ffffL;
 
349
        right ^= work;
 
350
        leftt ^= (work << 16);
 
351
        work = ((right >> 2) ^ leftt) & 0x33333333L;
 
352
        leftt ^= work;
 
353
        right ^= (work << 2);
 
354
        work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
 
355
        leftt ^= work;
 
356
        right ^= (work << 8);
 
357
        right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
 
358
        work = (leftt ^ right) & 0xaaaaaaaaL;
 
359
        leftt ^= work;
 
360
        right ^= work;
 
361
        leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;
 
362
 
 
363
        for( round = 0; round < 8; round++ ) {
 
364
                work  = (right << 28) | (right >> 4);
 
365
                work ^= *keys++;
 
366
                fval  = SP7[ work                & 0x3fL];
 
367
                fval |= SP5[(work >>  8) & 0x3fL];
 
368
                fval |= SP3[(work >> 16) & 0x3fL];
 
369
                fval |= SP1[(work >> 24) & 0x3fL];
 
370
                work  = right ^ *keys++;
 
371
                fval |= SP8[ work                & 0x3fL];
 
372
                fval |= SP6[(work >>  8) & 0x3fL];
 
373
                fval |= SP4[(work >> 16) & 0x3fL];
 
374
                fval |= SP2[(work >> 24) & 0x3fL];
 
375
                leftt ^= fval;
 
376
                work  = (leftt << 28) | (leftt >> 4);
 
377
                work ^= *keys++;
 
378
                fval  = SP7[ work                & 0x3fL];
 
379
                fval |= SP5[(work >>  8) & 0x3fL];
 
380
                fval |= SP3[(work >> 16) & 0x3fL];
 
381
                fval |= SP1[(work >> 24) & 0x3fL];
 
382
                work  = leftt ^ *keys++;
 
383
                fval |= SP8[ work                & 0x3fL];
 
384
                fval |= SP6[(work >>  8) & 0x3fL];
 
385
                fval |= SP4[(work >> 16) & 0x3fL];
 
386
                fval |= SP2[(work >> 24) & 0x3fL];
 
387
                right ^= fval;
 
388
                }
 
389
 
 
390
        right = (right << 31) | (right >> 1);
 
391
        work = (leftt ^ right) & 0xaaaaaaaaL;
 
392
        leftt ^= work;
 
393
        right ^= work;
 
394
        leftt = (leftt << 31) | (leftt >> 1);
 
395
        work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
 
396
        right ^= work;
 
397
        leftt ^= (work << 8);
 
398
        work = ((leftt >> 2) ^ right) & 0x33333333L;
 
399
        right ^= work;
 
400
        leftt ^= (work << 2);
 
401
        work = ((right >> 16) ^ leftt) & 0x0000ffffL;
 
402
        leftt ^= work;
 
403
        right ^= (work << 16);
 
404
        work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
 
405
        leftt ^= work;
 
406
        right ^= (work << 4);
 
407
        *block++ = right;
 
408
        *block = leftt;
 
409
        return;
 
410
        }
 
411
 
 
412
/* Validation sets:
 
413
 *
 
414
 * Single-length key, single-length plaintext -
 
415
 * Key    : 0123 4567 89ab cdef
 
416
 * Plain  : 0123 4567 89ab cde7
 
417
 * Cipher : c957 4425 6a5e d31d
 
418
 *
 
419
 * Double-length key, single-length plaintext -
 
420
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
 
421
 * Plain  : 0123 4567 89ab cde7
 
422
 * Cipher : 7f1d 0a77 826b 8aff
 
423
 *
 
424
 * Double-length key, double-length plaintext -
 
425
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
 
426
 * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
 
427
 * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
 
428
 *
 
429
 * Triple-length key, single-length plaintext -
 
430
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
 
431
 * Plain  : 0123 4567 89ab cde7
 
432
 * Cipher : de0b 7c06 ae5e 0ed5
 
433
 *
 
434
 * Triple-length key, double-length plaintext -
 
435
 * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
 
436
 * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
 
437
 * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
 
438
 *
 
439
 * d3des V5.0a rwo 9208.07 18:44 Graven Imagery
 
440
 **********************************************************************/