source: trunk/NativeCryptography/DES/des_locl.h @ 1191

Last change on this file since 1191 was 1191, checked in by Sven Rech, 12 years ago

faster bruteforce implementation for des

File size: 13.2 KB
Line 
1/* crypto/des/des_locl.h */
2/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to.  The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 *    notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 *    notice, this list of conditions and the following disclaimer in the
30 *    documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 *    must display the following acknowledgement:
33 *    "This product includes cryptographic software written by
34 *     Eric Young (eay@cryptsoft.com)"
35 *    The word 'cryptographic' can be left out if the rouines from the library
36 *    being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 *    the apps directory (application code) you must include an acknowledgement:
39 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed.  i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58
59/*Note: Modified by Sven Rech for Cryptool2 */
60
61#ifndef HEADER_DES_LOCL_H
62#define HEADER_DES_LOCL_H
63
64#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16)
65#ifndef OPENSSL_SYS_MSDOS
66#define OPENSSL_SYS_MSDOS
67#endif
68#endif
69
70#include <stdio.h>
71#include <stdlib.h>
72
73#include <math.h>
74
75#include "des.h"
76
77#ifdef OPENSSL_SYS_MSDOS                /* Visual C++ 2.1 (Windows NT/95) */
78#include <stdlib.h>
79#include <errno.h>
80#include <time.h>
81#include <io.h>
82#endif
83
84#if defined(__STDC__) || defined(OPENSSL_SYS_VMS) || defined(M_XENIX) || defined(OPENSSL_SYS_MSDOS)
85#include <string.h>
86#endif
87
88#ifdef OPENSSL_BUILD_SHLIBCRYPTO
89# undef OPENSSL_EXTERN
90# define OPENSSL_EXTERN OPENSSL_EXPORT
91#endif
92
93#define ITERATIONS 16
94#define HALF_ITERATIONS 8
95
96/* used in des_read and des_write */
97#define MAXWRITE        (1024*16)
98#define BSIZE           (MAXWRITE+4)
99
100#define c2l(c,l)        (l =((DES_LONG)(*((c)++)))    , \
101                         l|=((DES_LONG)(*((c)++)))<< 8L, \
102                         l|=((DES_LONG)(*((c)++)))<<16L, \
103                         l|=((DES_LONG)(*((c)++)))<<24L)
104
105/* NOTE - c is not incremented as per c2l */
106#define c2ln(c,l1,l2,n) { \
107                        c+=n; \
108                        l1=l2=0; \
109                        switch (n) { \
110                        case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \
111                        case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \
112                        case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \
113                        case 5: l2|=((DES_LONG)(*(--(c))));     \
114                        case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \
115                        case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \
116                        case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \
117                        case 1: l1|=((DES_LONG)(*(--(c))));     \
118                                } \
119                        }
120
121#define l2c(l,c)        (*((c)++)=(unsigned char)(((l)     )&0xff), \
122                         *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
123                         *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
124                         *((c)++)=(unsigned char)(((l)>>24L)&0xff))
125
126/* replacements for htonl and ntohl since I have no idea what to do
127 * when faced with machines with 8 byte longs. */
128#define HDRSIZE 4
129
130#define n2l(c,l)        (l =((DES_LONG)(*((c)++)))<<24L, \
131                         l|=((DES_LONG)(*((c)++)))<<16L, \
132                         l|=((DES_LONG)(*((c)++)))<< 8L, \
133                         l|=((DES_LONG)(*((c)++))))
134
135#define l2n(l,c)        (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \
136                         *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
137                         *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
138                         *((c)++)=(unsigned char)(((l)     )&0xff))
139
140/* NOTE - c is not incremented as per l2c */
141#define l2cn(l1,l2,c,n) { \
142                        c+=n; \
143                        switch (n) { \
144                        case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \
145                        case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \
146                        case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \
147                        case 5: *(--(c))=(unsigned char)(((l2)     )&0xff); \
148                        case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \
149                        case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \
150                        case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \
151                        case 1: *(--(c))=(unsigned char)(((l1)     )&0xff); \
152                                } \
153                        }
154
155#if (defined(OPENSSL_SYS_WIN32) && defined(_MSC_VER)) || defined(__ICC)
156#define ROTATE(a,n)     (_lrotr(a,n))
157#elif defined(__GNUC__) && __GNUC__>=2 && !defined(__STRICT_ANSI__) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM) && !defined(PEDANTIC)
158# if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
159#  define ROTATE(a,n)   ({ register unsigned int ret;   \
160                                asm ("rorl %1,%0"       \
161                                        : "=r"(ret)     \
162                                        : "I"(n),"0"(a) \
163                                        : "cc");        \
164                           ret;                         \
165                        })
166# endif
167#endif
168#ifndef ROTATE
169#define ROTATE(a,n)     (((a)>>(n))+((a)<<(32-(n))))
170#endif
171
172/* Don't worry about the LOAD_DATA() stuff, that is used by
173 * fcrypt() to add it's little bit to the front */
174
175#ifdef DES_FCRYPT
176
177#define LOAD_DATA_tmp(R,S,u,t,E0,E1) \
178        { DES_LONG tmp; LOAD_DATA(R,S,u,t,E0,E1,tmp); }
179
180#define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
181        t=R^(R>>16L); \
182        u=t&E0; t&=E1; \
183        tmp=(u<<16); u^=R^s[S  ]; u^=tmp; \
184        tmp=(t<<16); t^=R^s[S+1]; t^=tmp
185#else
186#define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)
187#define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
188        u=R^s[S  ]; \
189        t=R^s[S+1]
190#endif
191
192/* The changes to this macro may help or hinder, depending on the
193 * compiler and the architecture.  gcc2 always seems to do well :-).
194 * Inspired by Dana How <how@isl.stanford.edu>
195 * DO NOT use the alternative version on machines with 8 byte longs.
196 * It does not seem to work on the Alpha, even when DES_LONG is 4
197 * bytes, probably an issue of accessing non-word aligned objects :-( */
198#ifdef DES_PTR
199
200/* It recently occurred to me that 0^0^0^0^0^0^0 == 0, so there
201 * is no reason to not xor all the sub items together.  This potentially
202 * saves a register since things can be xored directly into L */
203
204#if defined(DES_RISC1) || defined(DES_RISC2)
205#ifdef DES_RISC1
206#define D_ENCRYPT(LL,R,S) { \
207        unsigned int u1,u2,u3; \
208        LOAD_DATA(R,S,u,t,E0,E1,u1); \
209        u2=(int)u>>8L; \
210        u1=(int)u&0xfc; \
211        u2&=0xfc; \
212        t=ROTATE(t,4); \
213        u>>=16L; \
214        LL^= *(const DES_LONG *)(des_SP      +u1); \
215        LL^= *(const DES_LONG *)(des_SP+0x200+u2); \
216        u3=(int)(u>>8L); \
217        u1=(int)u&0xfc; \
218        u3&=0xfc; \
219        LL^= *(const DES_LONG *)(des_SP+0x400+u1); \
220        LL^= *(const DES_LONG *)(des_SP+0x600+u3); \
221        u2=(int)t>>8L; \
222        u1=(int)t&0xfc; \
223        u2&=0xfc; \
224        t>>=16L; \
225        LL^= *(const DES_LONG *)(des_SP+0x100+u1); \
226        LL^= *(const DES_LONG *)(des_SP+0x300+u2); \
227        u3=(int)t>>8L; \
228        u1=(int)t&0xfc; \
229        u3&=0xfc; \
230        LL^= *(const DES_LONG *)(des_SP+0x500+u1); \
231        LL^= *(const DES_LONG *)(des_SP+0x700+u3); }
232#endif
233#ifdef DES_RISC2
234#define D_ENCRYPT(LL,R,S) { \
235        unsigned int u1,u2,s1,s2; \
236        LOAD_DATA(R,S,u,t,E0,E1,u1); \
237        u2=(int)u>>8L; \
238        u1=(int)u&0xfc; \
239        u2&=0xfc; \
240        t=ROTATE(t,4); \
241        LL^= *(const DES_LONG *)(des_SP      +u1); \
242        LL^= *(const DES_LONG *)(des_SP+0x200+u2); \
243        s1=(int)(u>>16L); \
244        s2=(int)(u>>24L); \
245        s1&=0xfc; \
246        s2&=0xfc; \
247        LL^= *(const DES_LONG *)(des_SP+0x400+s1); \
248        LL^= *(const DES_LONG *)(des_SP+0x600+s2); \
249        u2=(int)t>>8L; \
250        u1=(int)t&0xfc; \
251        u2&=0xfc; \
252        LL^= *(const DES_LONG *)(des_SP+0x100+u1); \
253        LL^= *(const DES_LONG *)(des_SP+0x300+u2); \
254        s1=(int)(t>>16L); \
255        s2=(int)(t>>24L); \
256        s1&=0xfc; \
257        s2&=0xfc; \
258        LL^= *(const DES_LONG *)(des_SP+0x500+s1); \
259        LL^= *(const DES_LONG *)(des_SP+0x700+s2); }
260#endif
261#else
262#define D_ENCRYPT(LL,R,S) { \
263        LOAD_DATA_tmp(R,S,u,t,E0,E1); \
264        t=ROTATE(t,4); \
265        LL^= \
266        *(const DES_LONG *)(des_SP      +((u     )&0xfc))^ \
267        *(const DES_LONG *)(des_SP+0x200+((u>> 8L)&0xfc))^ \
268        *(const DES_LONG *)(des_SP+0x400+((u>>16L)&0xfc))^ \
269        *(const DES_LONG *)(des_SP+0x600+((u>>24L)&0xfc))^ \
270        *(const DES_LONG *)(des_SP+0x100+((t     )&0xfc))^ \
271        *(const DES_LONG *)(des_SP+0x300+((t>> 8L)&0xfc))^ \
272        *(const DES_LONG *)(des_SP+0x500+((t>>16L)&0xfc))^ \
273        *(const DES_LONG *)(des_SP+0x700+((t>>24L)&0xfc)); }
274#endif
275
276#else /* original version */
277
278#if defined(DES_RISC1) || defined(DES_RISC2)
279#ifdef DES_RISC1
280#define D_ENCRYPT(LL,R,S) {\
281        unsigned int u1,u2,u3; \
282        LOAD_DATA(R,S,u,t,E0,E1,u1); \
283        u>>=2L; \
284        t=ROTATE(t,6); \
285        u2=(int)u>>8L; \
286        u1=(int)u&0x3f; \
287        u2&=0x3f; \
288        u>>=16L; \
289        LL^=DES_SPtrans[0][u1]; \
290        LL^=DES_SPtrans[2][u2]; \
291        u3=(int)u>>8L; \
292        u1=(int)u&0x3f; \
293        u3&=0x3f; \
294        LL^=DES_SPtrans[4][u1]; \
295        LL^=DES_SPtrans[6][u3]; \
296        u2=(int)t>>8L; \
297        u1=(int)t&0x3f; \
298        u2&=0x3f; \
299        t>>=16L; \
300        LL^=DES_SPtrans[1][u1]; \
301        LL^=DES_SPtrans[3][u2]; \
302        u3=(int)t>>8L; \
303        u1=(int)t&0x3f; \
304        u3&=0x3f; \
305        LL^=DES_SPtrans[5][u1]; \
306        LL^=DES_SPtrans[7][u3]; }
307#endif
308#ifdef DES_RISC2
309#define D_ENCRYPT(LL,R,S) {\
310        unsigned int u1,u2,s1,s2; \
311        LOAD_DATA(R,S,u,t,E0,E1,u1); \
312        u>>=2L; \
313        t=ROTATE(t,6); \
314        u2=(int)u>>8L; \
315        u1=(int)u&0x3f; \
316        u2&=0x3f; \
317        LL^=DES_SPtrans[0][u1]; \
318        LL^=DES_SPtrans[2][u2]; \
319        s1=(int)u>>16L; \
320        s2=(int)u>>24L; \
321        s1&=0x3f; \
322        s2&=0x3f; \
323        LL^=DES_SPtrans[4][s1]; \
324        LL^=DES_SPtrans[6][s2]; \
325        u2=(int)t>>8L; \
326        u1=(int)t&0x3f; \
327        u2&=0x3f; \
328        LL^=DES_SPtrans[1][u1]; \
329        LL^=DES_SPtrans[3][u2]; \
330        s1=(int)t>>16; \
331        s2=(int)t>>24L; \
332        s1&=0x3f; \
333        s2&=0x3f; \
334        LL^=DES_SPtrans[5][s1]; \
335        LL^=DES_SPtrans[7][s2]; }
336#endif
337
338#else
339
340#define D_ENCRYPT(LL,R,S) {\
341        LOAD_DATA_tmp(R,S,u,t,E0,E1); \
342        t=ROTATE(t,4); \
343        LL^=\
344                DES_SPtrans[0][(u>> 2L)&0x3f]^ \
345                DES_SPtrans[2][(u>>10L)&0x3f]^ \
346                DES_SPtrans[4][(u>>18L)&0x3f]^ \
347                DES_SPtrans[6][(u>>26L)&0x3f]^ \
348                DES_SPtrans[1][(t>> 2L)&0x3f]^ \
349                DES_SPtrans[3][(t>>10L)&0x3f]^ \
350                DES_SPtrans[5][(t>>18L)&0x3f]^ \
351                DES_SPtrans[7][(t>>26L)&0x3f]; }
352#endif
353#endif
354
355        /* IP and FP
356         * The problem is more of a geometric problem that random bit fiddling.
357         0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
358         8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
359        16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
360        24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
361
362        32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
363        40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
364        48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
365        56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
366
367        The output has been subject to swaps of the form
368        0 1 -> 3 1 but the odd and even bits have been put into
369        2 3    2 0
370        different words.  The main trick is to remember that
371        t=((l>>size)^r)&(mask);
372        r^=t;
373        l^=(t<<size);
374        can be used to swap and move bits between words.
375
376        So l =  0  1  2  3  r = 16 17 18 19
377                4  5  6  7      20 21 22 23
378                8  9 10 11      24 25 26 27
379               12 13 14 15      28 29 30 31
380        becomes (for size == 2 and mask == 0x3333)
381           t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
382                 6^20  7^21 -- --        4  5 20 21       6  7 22 23
383                10^24 11^25 -- --        8  9 24 25      10 11 24 25
384                14^28 15^29 -- --       12 13 28 29      14 15 28 29
385
386        Thanks for hints from Richard Outerbridge - he told me IP&FP
387        could be done in 15 xor, 10 shifts and 5 ands.
388        When I finally started to think of the problem in 2D
389        I first got ~42 operations without xors.  When I remembered
390        how to use xors :-) I got it to its final state.
391        */
392#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
393        (b)^=(t),\
394        (a)^=((t)<<(n)))
395
396#define IP(l,r) \
397        { \
398        register DES_LONG tt; \
399        PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
400        PERM_OP(l,r,tt,16,0x0000ffffL); \
401        PERM_OP(r,l,tt, 2,0x33333333L); \
402        PERM_OP(l,r,tt, 8,0x00ff00ffL); \
403        PERM_OP(r,l,tt, 1,0x55555555L); \
404        }
405
406#define FP(l,r) \
407        { \
408        register DES_LONG tt; \
409        PERM_OP(l,r,tt, 1,0x55555555L); \
410        PERM_OP(r,l,tt, 8,0x00ff00ffL); \
411        PERM_OP(l,r,tt, 2,0x33333333L); \
412        PERM_OP(r,l,tt,16,0x0000ffffL); \
413        PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
414        }
415
416extern const DES_LONG DES_SPtrans[8][64];
417
418/*void fcrypt_body(DES_LONG *out,DES_key_schedule *ks,
419                 DES_LONG Eswap0, DES_LONG Eswap1);*/
420
421#endif
Note: See TracBrowser for help on using the repository browser.