freeswan/libdes/des_locl.h

   1 /* crypto/des/des_locl.org */
   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 /* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
  60  *
  61  * Always modify des_locl.org since des_locl.h is automatically generated from
  62  * it during SSLeay configuration.
  63  *
  64  * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
  65  */
  66
  67 #ifndef HEADER_DES_LOCL_H
  68 #define HEADER_DES_LOCL_H
  69
  70 #if defined(WIN32) || defined(WIN16)
  71 #ifndef MSDOS
  72 #define MSDOS
  73 #endif
  74 #endif
  75
  76 #include "des.h"
  77 #ifdef HW_ASSIST
  78 #include "hw_assist.h"
  79 #endif
  80
  81 #ifndef DES_DEFAULT_OPTIONS
  82 /* the following is tweaked from a config script, that is why it is a
  83  * protected undef/define */
  84 #ifndef DES_PTR
  85 #undef DES_PTR
  86 #endif
  87
  88 /* This helps C compiler generate the correct code for multiple functional
  89  * units.  It reduces register dependancies at the expense of 2 more
  90  * registers */
  91 #ifndef DES_RISC1
  92 #undef DES_RISC1
  93 #endif
  94
  95 #ifndef DES_RISC2
  96 #undef DES_RISC2
  97 #endif
  98
  99 #if defined(DES_RISC1) && defined(DES_RISC2)
 100 YOU SHOULD NOT HAVE BOTH DES_RISC1 AND DES_RISC2 DEFINED!!!!!
 101 #endif
 102
 103 /* Unroll the inner loop, this sometimes helps, sometimes hinders.
 104  * Very mucy CPU dependant */
 105 #ifndef DES_UNROLL
 106 #undef DES_UNROLL
 107 #endif
 108
 109 /* These default values were supplied by
 110  * Peter Gutman <pgut001@cs.auckland.ac.nz>
 111  * They are only used if nothing else has been defined */
 112 #if !defined(DES_PTR) && !defined(DES_RISC1) && !defined(DES_RISC2) && !defined(DES_UNROLL)
 113 /* Special defines which change the way the code is built depending on the
 114    CPU and OS.  For SGI machines you can use _MIPS_SZLONG (32 or 64) to find
 115    even newer MIPS CPU's, but at the moment one size fits all for
 116    optimization options.  Older Sparc's work better with only UNROLL, but
 117    there's no way to tell at compile time what it is you're running on */
 118
 119 #if defined( sun )              /* Newer Sparc's */
 120   #define DES_PTR
 121   #define DES_RISC1
 122   #define DES_UNROLL
 123 #elif defined( __ultrix )       /* Older MIPS */
 124   #define DES_PTR
 125   #define DES_RISC2
 126   #define DES_UNROLL
 127 #elif defined( __osf1__ )       /* Alpha */
 128   #define DES_PTR
 129   #define DES_RISC2
 130 #elif defined ( _AIX )          /* RS6000 */
 131   /* Unknown */
 132 #elif defined( __hpux )         /* HP-PA */
 133   /* Unknown */
 134 #elif defined( __aux )          /* 68K */
 135   /* Unknown */
 136 #elif defined( __dgux )         /* 88K (but P6 in latest boxes) */
 137   #define DES_UNROLL
 138 #elif defined( __sgi )          /* Newer MIPS */
 139   #define DES_PTR
 140   #define DES_RISC2
 141   #define DES_UNROLL
 142 #elif defined( i386 )           /* x86 boxes, should be gcc */
 143   #define DES_PTR
 144   #define DES_RISC1
 145   #define DES_UNROLL
 146 #elif defined( __sh3__ )        /* Hitachi SH3 */
 147   #define DES_PTR
 148 #elif defined(mcf5307)          /* ColdFire 5307 */
 149   #define DES_PTR
 150 #elif defined(mcf5200)          /* ColdFire 52xx */
 151   #define DES_PTR               /* Not definitely sure this is best */
 152 #else
 153   /* These are the defaults that were previously applied so I've preserved
 154   * them.
 155   */
 156   #define DES_PTR
 157   #define DES_RISC1
 158   #define DES_UNROLL
 159 #endif /* Systems-specific speed defines */
 160 #endif
 161
 162 #endif /* DES_DEFAULT_OPTIONS */
 163
 164 #ifdef MSDOS            /* Visual C++ 2.1 (Windows NT/95) */
 165 #include <stdlib.h>
 166 #include <errno.h>
 167 #include <time.h>
 168 #include <io.h>
 169 #ifndef RAND
 170 #define RAND
 171 #endif
 172 #undef NOPROTO
 173 #endif
 174
 175 #if defined(__STDC__) || defined(VMS) || defined(M_XENIX) || defined(MSDOS)
 176 #ifndef __KERNEL__
 177 #include <string.h>
 178 #else
 179 #include <linux/string.h>
 180 #endif
 181 #endif
 182
 183 #ifndef RAND
 184 #define RAND
 185 #endif
 186
 187 #ifdef linux
 188 #undef RAND
 189 #endif
 190
 191 #ifdef MSDOS
 192 #define getpid() 2
 193 #define RAND
 194 #undef NOPROTO
 195 #endif
 196
 197 #if defined(NOCONST)
 198 #define const
 199 #endif
 200
 201 #ifdef __STDC__
 202 #undef NOPROTO
 203 #endif
 204
 205 #ifdef RAND
 206 #define srandom(s) srand(s)
 207 #define random rand
 208 #endif
 209
 210 #define ITERATIONS 16
 211 #define HALF_ITERATIONS 8
 212
 213 /* used in des_read and des_write */
 214 #define MAXWRITE        (1024*16)
 215 #define BSIZE           (MAXWRITE+4)
 216
 217 #define c2l(c,l)        (l =((DES_LONG)(*((c)++)))    , \
 218                          l|=((DES_LONG)(*((c)++)))<< 8L, \
 219                          l|=((DES_LONG)(*((c)++)))<<16L, \
 220                          l|=((DES_LONG)(*((c)++)))<<24L)
 221
 222 /* NOTE - c is not incremented as per c2l */
 223 #define c2ln(c,l1,l2,n) { \
 224                         c+=n; \
 225                         l1=l2=0; \
 226                         switch (n) { \
 227                         case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \
 228                         case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \
 229                         case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \
 230                         case 5: l2|=((DES_LONG)(*(--(c))));     \
 231                         case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \
 232                         case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \
 233                         case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \
 234                         case 1: l1|=((DES_LONG)(*(--(c))));     \
 235                                 } \
 236                         }
 237
 238 #define l2c(l,c)        (*((c)++)=(unsigned char)(((l)     )&0xff), \
 239                          *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
 240                          *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
 241                          *((c)++)=(unsigned char)(((l)>>24L)&0xff))
 242
 243 /* replacements for htonl and ntohl since I have no idea what to do
 244  * when faced with machines with 8 byte longs. */
 245 #define HDRSIZE 4
 246
 247 #define n2l(c,l)        (l =((DES_LONG)(*((c)++)))<<24L, \
 248                          l|=((DES_LONG)(*((c)++)))<<16L, \
 249                          l|=((DES_LONG)(*((c)++)))<< 8L, \
 250                          l|=((DES_LONG)(*((c)++))))
 251
 252 #define l2n(l,c)        (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \
 253                          *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
 254                          *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
 255                          *((c)++)=(unsigned char)(((l)     )&0xff))
 256
 257 /* NOTE - c is not incremented as per l2c */
 258 #define l2cn(l1,l2,c,n) { \
 259                         c+=n; \
 260                         switch (n) { \
 261                         case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \
 262                         case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \
 263                         case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \
 264                         case 5: *(--(c))=(unsigned char)(((l2)     )&0xff); \
 265                         case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \
 266                         case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \
 267                         case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \
 268                         case 1: *(--(c))=(unsigned char)(((l1)     )&0xff); \
 269                                 } \
 270                         }
 271
 272 #if defined(WIN32)
 273 #define ROTATE(a,n)     (_lrotr(a,n))
 274 #else
 275 #define ROTATE(a,n)     (((a)>>(n))+((a)<<(32-(n))))
 276 #endif
 277
 278 /* Don't worry about the LOAD_DATA() stuff, that is used by
 279  * fcrypt() to add it's little bit to the front */
 280
 281 #ifdef DES_FCRYPT
 282
 283 #define LOAD_DATA_tmp(R,S,u,t,E0,E1) \
 284         { DES_LONG tmp; LOAD_DATA(R,S,u,t,E0,E1,tmp); }
 285
 286 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
 287         t=R^(R>>16L); \
 288         u=t&E0; t&=E1; \
 289         tmp=(u<<16); u^=R^s[S  ]; u^=tmp; \
 290         tmp=(t<<16); t^=R^s[S+1]; t^=tmp
 291 #else
 292 #define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)
 293 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
 294         u=R^s[S  ]; \
 295         t=R^s[S+1]
 296 #endif
 297
 298 /* The changes to this macro may help or hinder, depending on the
 299  * compiler and the achitecture.  gcc2 always seems to do well :-).
 300  * Inspired by Dana How <how@isl.stanford.edu>
 301  * DO NOT use the alternative version on machines with 8 byte longs.
 302  * It does not seem to work on the Alpha, even when DES_LONG is 4
 303  * bytes, probably an issue of accessing non-word aligned objects :-( */
 304 #ifdef DES_PTR
 305
 306 /* It recently occured to me that 0^0^0^0^0^0^0 == 0, so there
 307  * is no reason to not xor all the sub items together.  This potentially
 308  * saves a register since things can be xored directly into L */
 309
 310 #if defined(DES_RISC1) || defined(DES_RISC2)
 311 #ifdef DES_RISC1
 312 #define D_ENCRYPT(LL,R,S) { \
 313         unsigned int u1,u2,u3; \
 314         LOAD_DATA(R,S,u,t,E0,E1,u1); \
 315         u2=(int)u>>8L; \
 316         u1=(int)u&0xfc; \
 317         u2&=0xfc; \
 318         t=ROTATE(t,4); \
 319         u>>=16L; \
 320         LL^= *(DES_LONG *)((unsigned char *)des_SP      +u1); \
 321         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x200+u2); \
 322         u3=(int)(u>>8L); \
 323         u1=(int)u&0xfc; \
 324         u3&=0xfc; \
 325         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x400+u1); \
 326         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x600+u3); \
 327         u2=(int)t>>8L; \
 328         u1=(int)t&0xfc; \
 329         u2&=0xfc; \
 330         t>>=16L; \
 331         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x100+u1); \
 332         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x300+u2); \
 333         u3=(int)t>>8L; \
 334         u1=(int)t&0xfc; \
 335         u3&=0xfc; \
 336         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x500+u1); \
 337         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x700+u3); }
 338 #endif
 339 #ifdef DES_RISC2
 340 #define D_ENCRYPT(LL,R,S) { \
 341         unsigned int u1,u2,s1,s2; \
 342         LOAD_DATA(R,S,u,t,E0,E1,u1); \
 343         u2=(int)u>>8L; \
 344         u1=(int)u&0xfc; \
 345         u2&=0xfc; \
 346         t=ROTATE(t,4); \
 347         LL^= *(DES_LONG *)((unsigned char *)des_SP      +u1); \
 348         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x200+u2); \
 349         s1=(int)(u>>16L); \
 350         s2=(int)(u>>24L); \
 351         s1&=0xfc; \
 352         s2&=0xfc; \
 353         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x400+s1); \
 354         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x600+s2); \
 355         u2=(int)t>>8L; \
 356         u1=(int)t&0xfc; \
 357         u2&=0xfc; \
 358         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x100+u1); \
 359         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x300+u2); \
 360         s1=(int)(t>>16L); \
 361         s2=(int)(t>>24L); \
 362         s1&=0xfc; \
 363         s2&=0xfc; \
 364         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x500+s1); \
 365         LL^= *(DES_LONG *)((unsigned char *)des_SP+0x700+s2); }
 366 #endif
 367 #else
 368 #define D_ENCRYPT(LL,R,S) { \
 369         LOAD_DATA_tmp(R,S,u,t,E0,E1); \
 370         t=ROTATE(t,4); \
 371         LL^= \
 372         *(DES_LONG *)((unsigned char *)des_SP      +((u     )&0xfc))^ \
 373         *(DES_LONG *)((unsigned char *)des_SP+0x200+((u>> 8L)&0xfc))^ \
 374         *(DES_LONG *)((unsigned char *)des_SP+0x400+((u>>16L)&0xfc))^ \
 375         *(DES_LONG *)((unsigned char *)des_SP+0x600+((u>>24L)&0xfc))^ \
 376         *(DES_LONG *)((unsigned char *)des_SP+0x100+((t     )&0xfc))^ \
 377         *(DES_LONG *)((unsigned char *)des_SP+0x300+((t>> 8L)&0xfc))^ \
 378         *(DES_LONG *)((unsigned char *)des_SP+0x500+((t>>16L)&0xfc))^ \
 379         *(DES_LONG *)((unsigned char *)des_SP+0x700+((t>>24L)&0xfc)); }
 380 #endif
 381
 382 #else /* original version */
 383
 384 #if defined(DES_RISC1) || defined(DES_RISC2)
 385 #ifdef DES_RISC1
 386 #define D_ENCRYPT(LL,R,S) {\
 387         unsigned int u1,u2,u3; \
 388         LOAD_DATA(R,S,u,t,E0,E1,u1); \
 389         u>>=2L; \
 390         t=ROTATE(t,6); \
 391         u2=(int)u>>8L; \
 392         u1=(int)u&0x3f; \
 393         u2&=0x3f; \
 394         u>>=16L; \
 395         LL^=des_SPtrans[0][u1]; \
 396         LL^=des_SPtrans[2][u2]; \
 397         u3=(int)u>>8L; \
 398         u1=(int)u&0x3f; \
 399         u3&=0x3f; \
 400         LL^=des_SPtrans[4][u1]; \
 401         LL^=des_SPtrans[6][u3]; \
 402         u2=(int)t>>8L; \
 403         u1=(int)t&0x3f; \
 404         u2&=0x3f; \
 405         t>>=16L; \
 406         LL^=des_SPtrans[1][u1]; \
 407         LL^=des_SPtrans[3][u2]; \
 408         u3=(int)t>>8L; \
 409         u1=(int)t&0x3f; \
 410         u3&=0x3f; \
 411         LL^=des_SPtrans[5][u1]; \
 412         LL^=des_SPtrans[7][u3]; }
 413 #endif
 414 #ifdef DES_RISC2
 415 #define D_ENCRYPT(LL,R,S) {\
 416         unsigned int u1,u2,s1,s2; \
 417         LOAD_DATA(R,S,u,t,E0,E1,u1); \
 418         u>>=2L; \
 419         t=ROTATE(t,6); \
 420         u2=(int)u>>8L; \
 421         u1=(int)u&0x3f; \
 422         u2&=0x3f; \
 423         LL^=des_SPtrans[0][u1]; \
 424         LL^=des_SPtrans[2][u2]; \
 425         s1=(int)u>>16L; \
 426         s2=(int)u>>24L; \
 427         s1&=0x3f; \
 428         s2&=0x3f; \
 429         LL^=des_SPtrans[4][s1]; \
 430         LL^=des_SPtrans[6][s2]; \
 431         u2=(int)t>>8L; \
 432         u1=(int)t&0x3f; \
 433         u2&=0x3f; \
 434         LL^=des_SPtrans[1][u1]; \
 435         LL^=des_SPtrans[3][u2]; \
 436         s1=(int)t>>16; \
 437         s2=(int)t>>24L; \
 438         s1&=0x3f; \
 439         s2&=0x3f; \
 440         LL^=des_SPtrans[5][s1]; \
 441         LL^=des_SPtrans[7][s2]; }
 442 #endif
 443
 444 #else
 445
 446 #define D_ENCRYPT(LL,R,S) {\
 447         LOAD_DATA_tmp(R,S,u,t,E0,E1); \
 448         t=ROTATE(t,4); \
 449         LL^=\
 450                 des_SPtrans[0][(u>> 2L)&0x3f]^ \
 451                 des_SPtrans[2][(u>>10L)&0x3f]^ \
 452                 des_SPtrans[4][(u>>18L)&0x3f]^ \
 453                 des_SPtrans[6][(u>>26L)&0x3f]^ \
 454                 des_SPtrans[1][(t>> 2L)&0x3f]^ \
 455                 des_SPtrans[3][(t>>10L)&0x3f]^ \
 456                 des_SPtrans[5][(t>>18L)&0x3f]^ \
 457                 des_SPtrans[7][(t>>26L)&0x3f]; }
 458 #endif
 459 #endif
 460
 461         /* IP and FP
 462          * The problem is more of a geometric problem that random bit fiddling.
 463          0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
 464          8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
 465         16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
 466         24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
 467
 468         32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
 469         40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
 470         48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
 471         56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
 472
 473         The output has been subject to swaps of the form
 474         0 1 -> 3 1 but the odd and even bits have been put into
 475         2 3    2 0
 476         different words.  The main trick is to remember that
 477         t=((l>>size)^r)&(mask);
 478         r^=t;
 479         l^=(t<<size);
 480         can be used to swap and move bits between words.
 481
 482         So l =  0  1  2  3  r = 16 17 18 19
 483                 4  5  6  7      20 21 22 23
 484                 8  9 10 11      24 25 26 27
 485                12 13 14 15      28 29 30 31
 486         becomes (for size == 2 and mask == 0x3333)
 487            t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
 488                  6^20  7^21 -- --        4  5 20 21       6  7 22 23
 489                 10^24 11^25 -- --        8  9 24 25      10 11 24 25
 490                 14^28 15^29 -- --       12 13 28 29      14 15 28 29
 491
 492         Thanks for hints from Richard Outerbridge - he told me IP&FP
 493         could be done in 15 xor, 10 shifts and 5 ands.
 494         When I finally started to think of the problem in 2D
 495         I first got ~42 operations without xors.  When I remembered
 496         how to use xors :-) I got it to its final state.
 497         */
 498 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 499         (b)^=(t),\
 500         (a)^=((t)<<(n)))
 501
 502 #define IP(l,r) \
 503         { \
 504         register DES_LONG tt; \
 505         PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
 506         PERM_OP(l,r,tt,16,0x0000ffffL); \
 507         PERM_OP(r,l,tt, 2,0x33333333L); \
 508         PERM_OP(l,r,tt, 8,0x00ff00ffL); \
 509         PERM_OP(r,l,tt, 1,0x55555555L); \
 510         }
 511
 512 #define FP(l,r) \
 513         { \
 514         register DES_LONG tt; \
 515         PERM_OP(l,r,tt, 1,0x55555555L); \
 516         PERM_OP(r,l,tt, 8,0x00ff00ffL); \
 517         PERM_OP(l,r,tt, 2,0x33333333L); \
 518         PERM_OP(r,l,tt,16,0x0000ffffL); \
 519         PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
 520         }
 521
 522 extern const DES_LONG des_SPtrans[8][64];
 523
 524 #ifndef NO_FCRYPT
 525 #ifndef NOPROTO
 526 void fcrypt_body(DES_LONG *out,des_key_schedule ks,
 527         DES_LONG Eswap0, DES_LONG Eswap1);
 528 #else
 529 void fcrypt_body();
 530 #endif
 531 #endif /* NO_FCRYPT */
 532
 533 #endif