src/Crypto/src/DES.c

   1 /*
   2  *  des.c : Source code for the DES block cipher
   3  *
   4  * Part of the Python Cryptography Toolkit
   5  *
   6  * Distribute and use freely; there are no restrictions on further
   7  * dissemination and usage except those imposed by the laws of your
   8  * country of residence.
   9  *
  10  */
  11
  12 #include "Python.h"
  13
  14 /* des.c */
  15 /* Copyright (C) 1993 Eric Young */
  16 /* Integrated into the PCT by A.M. Kuchling, November 1994 */
  17
  18 #define MODULE_NAME DES
  19 #define BLOCK_SIZE 8
  20 #define KEY_SIZE 8
  21
  22
  23 typedef unsigned char des_cblock[8];
  24
  25 /* ecb_enc.c */
  26 /* Copyright (C) 1993 Eric Young - see README for more details */
  27
  28 #define c2l(c,l)        (l =((unsigned long)(*((c)++)))    , \
  29                          l|=((unsigned long)(*((c)++)))<< 8, \
  30                          l|=((unsigned long)(*((c)++)))<<16, \
  31                          l|=((unsigned long)(*((c)++)))<<24)
  32
  33 /* NOTE - c is not incremented as per c2l */
  34 #define c2ln(c,l1,l2,n) { \
  35                         c+=n; \
  36                         l1=l2=0; \
  37                         switch (n) { \
  38                         case 8: l2|=((unsigned long)(*(--(c))))<<24; \
  39                         case 7: l2|=((unsigned long)(*(--(c))))<<16; \
  40                         case 6: l2|=((unsigned long)(*(--(c))))<< 8; \
  41                         case 5: l2|=((unsigned long)(*(--(c))));     \
  42                         case 4: l1|=((unsigned long)(*(--(c))))<<24; \
  43                         case 3: l1|=((unsigned long)(*(--(c))))<<16; \
  44                         case 2: l1|=((unsigned long)(*(--(c))))<< 8; \
  45                         case 1: l1|=((unsigned long)(*(--(c))));     \
  46                                 } \
  47                         }
  48
  49 #define l2c(l,c)        (*((c)++)=(unsigned char)(((l)    )&0xff), \
  50                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
  51                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
  52                          *((c)++)=(unsigned char)(((l)>>24)&0xff))
  53
  54 /* replacements for htonl and ntohl since I have no idea what to do
  55  * when faced with machines with 8 byte longs. */
  56 #define HDRSIZE 4
  57
  58 #define n2l(c,l)        (l =((unsigned long)(*((c)++)))<<24, \
  59                          l|=((unsigned long)(*((c)++)))<<16, \
  60                          l|=((unsigned long)(*((c)++)))<< 8, \
  61                          l|=((unsigned long)(*((c)++))))
  62
  63 #define l2n(l,c)        (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
  64                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
  65                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
  66                          *((c)++)=(unsigned char)(((l)    )&0xff))
  67
  68 /* NOTE - c is not incremented as per l2c */
  69 #define l2cn(l1,l2,c,n) { \
  70                         c+=n; \
  71                         switch (n) { \
  72                         case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
  73                         case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
  74                         case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
  75                         case 5: *(--(c))=(unsigned char)(((l2)    )&0xff); \
  76                         case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
  77                         case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
  78                         case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
  79                         case 1: *(--(c))=(unsigned char)(((l1)    )&0xff); \
  80                                 } \
  81                         }
  82
  83 #define D_ENCRYPT(L,R,S)        \
  84         u=(R^s[S  ]); \
  85         t=R^s[S+1]; \
  86         t=((t>>4)+(t<<28)); \
  87         L^=     des_SPtrans[1][(t    )&0x3f]| \
  88                 des_SPtrans[3][(t>> 8)&0x3f]| \
  89                 des_SPtrans[5][(t>>16)&0x3f]| \
  90                 des_SPtrans[7][(t>>24)&0x3f]| \
  91                 des_SPtrans[0][(u    )&0x3f]| \
  92                 des_SPtrans[2][(u>> 8)&0x3f]| \
  93                 des_SPtrans[4][(u>>16)&0x3f]| \
  94                 des_SPtrans[6][(u>>24)&0x3f];
  95
  96         /* IP and FP
  97          * The problem is more of a geometric problem that random bit fiddling.
  98          0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
  99          8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
 100         16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
 101         24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
 102
 103         32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
 104         40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
 105         48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
 106         56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
 107
 108         The output has been subject to swaps of the form
 109         0 1 -> 3 1 but the odd and even bits have been put into
 110         2 3    2 0
 111         different words.  The main trick is to remember that
 112         t=((l>>size)^r)&(mask);
 113         r^=t;
 114         l^=(t<<size);
 115         can be used to swap and move bits between words.
 116
 117         So l =  0  1  2  3  r = 16 17 18 19
 118                 4  5  6  7      20 21 22 23
 119                 8  9 10 11      24 25 26 27
 120                12 13 14 15      28 29 30 31
 121         becomes (for size == 2 and mask == 0x3333)
 122            t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
 123                  6^20  7^21 -- --        4  5 20 21       6  7 22 23
 124                 10^24 11^25 -- --        8  9 24 25      10 11 24 25
 125                 14^28 15^29 -- --       12 13 28 29      14 15 28 29
 126
 127         Thanks for hints from Richard Outerbridge - he told me IP&FP
 128         could be done in 15 xor, 10 shifts and 5 ands.
 129         When I finally started to think of the problem in 2D
 130         I first got ~42 operations without xors.  When I remembered
 131         how to use xors :-) I got it to its final state.
 132         */
 133 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 134         (b)^=(t),\
 135         (a)^=((t)<<(n)))
 136
 137
 138
 139 /* spr.h */
 140 /* Copyright (C) 1993 Eric Young - see README for more details */
 141 static unsigned long des_SPtrans[8][64]={
 142 /* nibble 0 */
 143         {0x00820200, 0x00020000, 0x80800000, 0x80820200,
 144          0x00800000, 0x80020200, 0x80020000, 0x80800000,
 145          0x80020200, 0x00820200, 0x00820000, 0x80000200,
 146          0x80800200, 0x00800000, 0x00000000, 0x80020000,
 147          0x00020000, 0x80000000, 0x00800200, 0x00020200,
 148          0x80820200, 0x00820000, 0x80000200, 0x00800200,
 149          0x80000000, 0x00000200, 0x00020200, 0x80820000,
 150          0x00000200, 0x80800200, 0x80820000, 0x00000000,
 151          0x00000000, 0x80820200, 0x00800200, 0x80020000,
 152          0x00820200, 0x00020000, 0x80000200, 0x00800200,
 153          0x80820000, 0x00000200, 0x00020200, 0x80800000,
 154          0x80020200, 0x80000000, 0x80800000, 0x00820000,
 155          0x80820200, 0x00020200, 0x00820000, 0x80800200,
 156          0x00800000, 0x80000200, 0x80020000, 0x00000000,
 157          0x00020000, 0x00800000, 0x80800200, 0x00820200,
 158          0x80000000, 0x80820000, 0x00000200, 0x80020200},
 159
 160 /* nibble 1 */
 161         {0x10042004, 0x00000000, 0x00042000, 0x10040000,
 162          0x10000004, 0x00002004, 0x10002000, 0x00042000,
 163          0x00002000, 0x10040004, 0x00000004, 0x10002000,
 164          0x00040004, 0x10042000, 0x10040000, 0x00000004,
 165          0x00040000, 0x10002004, 0x10040004, 0x00002000,
 166          0x00042004, 0x10000000, 0x00000000, 0x00040004,
 167          0x10002004, 0x00042004, 0x10042000, 0x10000004,
 168          0x10000000, 0x00040000, 0x00002004, 0x10042004,
 169          0x00040004, 0x10042000, 0x10002000, 0x00042004,
 170          0x10042004, 0x00040004, 0x10000004, 0x00000000,
 171          0x10000000, 0x00002004, 0x00040000, 0x10040004,
 172          0x00002000, 0x10000000, 0x00042004, 0x10002004,
 173          0x10042000, 0x00002000, 0x00000000, 0x10000004,
 174          0x00000004, 0x10042004, 0x00042000, 0x10040000,
 175          0x10040004, 0x00040000, 0x00002004, 0x10002000,
 176          0x10002004, 0x00000004, 0x10040000, 0x00042000},
 177
 178 /* nibble 2 */
 179         {0x41000000, 0x01010040, 0x00000040, 0x41000040,
 180          0x40010000, 0x01000000, 0x41000040, 0x00010040,
 181          0x01000040, 0x00010000, 0x01010000, 0x40000000,
 182          0x41010040, 0x40000040, 0x40000000, 0x41010000,
 183          0x00000000, 0x40010000, 0x01010040, 0x00000040,
 184          0x40000040, 0x41010040, 0x00010000, 0x41000000,
 185          0x41010000, 0x01000040, 0x40010040, 0x01010000,
 186          0x00010040, 0x00000000, 0x01000000, 0x40010040,
 187          0x01010040, 0x00000040, 0x40000000, 0x00010000,
 188          0x40000040, 0x40010000, 0x01010000, 0x41000040,
 189          0x00000000, 0x01010040, 0x00010040, 0x41010000,
 190          0x40010000, 0x01000000, 0x41010040, 0x40000000,
 191          0x40010040, 0x41000000, 0x01000000, 0x41010040,
 192          0x00010000, 0x01000040, 0x41000040, 0x00010040,
 193          0x01000040, 0x00000000, 0x41010000, 0x40000040,
 194          0x41000000, 0x40010040, 0x00000040, 0x01010000},
 195
 196 /* nibble 3 */
 197         {0x00100402, 0x04000400, 0x00000002, 0x04100402,
 198          0x00000000, 0x04100000, 0x04000402, 0x00100002,
 199          0x04100400, 0x04000002, 0x04000000, 0x00000402,
 200          0x04000002, 0x00100402, 0x00100000, 0x04000000,
 201          0x04100002, 0x00100400, 0x00000400, 0x00000002,
 202          0x00100400, 0x04000402, 0x04100000, 0x00000400,
 203          0x00000402, 0x00000000, 0x00100002, 0x04100400,
 204          0x04000400, 0x04100002, 0x04100402, 0x00100000,
 205          0x04100002, 0x00000402, 0x00100000, 0x04000002,
 206          0x00100400, 0x04000400, 0x00000002, 0x04100000,
 207          0x04000402, 0x00000000, 0x00000400, 0x00100002,
 208          0x00000000, 0x04100002, 0x04100400, 0x00000400,
 209          0x04000000, 0x04100402, 0x00100402, 0x00100000,
 210          0x04100402, 0x00000002, 0x04000400, 0x00100402,
 211          0x00100002, 0x00100400, 0x04100000, 0x04000402,
 212          0x00000402, 0x04000000, 0x04000002, 0x04100400},
 213
 214 /* nibble 4 */
 215         {0x02000000, 0x00004000, 0x00000100, 0x02004108,
 216          0x02004008, 0x02000100, 0x00004108, 0x02004000,
 217          0x00004000, 0x00000008, 0x02000008, 0x00004100,
 218          0x02000108, 0x02004008, 0x02004100, 0x00000000,
 219          0x00004100, 0x02000000, 0x00004008, 0x00000108,
 220          0x02000100, 0x00004108, 0x00000000, 0x02000008,
 221          0x00000008, 0x02000108, 0x02004108, 0x00004008,
 222          0x02004000, 0x00000100, 0x00000108, 0x02004100,
 223          0x02004100, 0x02000108, 0x00004008, 0x02004000,
 224          0x00004000, 0x00000008, 0x02000008, 0x02000100,
 225          0x02000000, 0x00004100, 0x02004108, 0x00000000,
 226          0x00004108, 0x02000000, 0x00000100, 0x00004008,
 227          0x02000108, 0x00000100, 0x00000000, 0x02004108,
 228          0x02004008, 0x02004100, 0x00000108, 0x00004000,
 229          0x00004100, 0x02004008, 0x02000100, 0x00000108,
 230          0x00000008, 0x00004108, 0x02004000, 0x02000008},
 231
 232 /* nibble 5 */
 233         {0x20000010, 0x00080010, 0x00000000, 0x20080800,
 234          0x00080010, 0x00000800, 0x20000810, 0x00080000,
 235          0x00000810, 0x20080810, 0x00080800, 0x20000000,
 236          0x20000800, 0x20000010, 0x20080000, 0x00080810,
 237          0x00080000, 0x20000810, 0x20080010, 0x00000000,
 238          0x00000800, 0x00000010, 0x20080800, 0x20080010,
 239          0x20080810, 0x20080000, 0x20000000, 0x00000810,
 240          0x00000010, 0x00080800, 0x00080810, 0x20000800,
 241          0x00000810, 0x20000000, 0x20000800, 0x00080810,
 242          0x20080800, 0x00080010, 0x00000000, 0x20000800,
 243          0x20000000, 0x00000800, 0x20080010, 0x00080000,
 244          0x00080010, 0x20080810, 0x00080800, 0x00000010,
 245          0x20080810, 0x00080800, 0x00080000, 0x20000810,
 246          0x20000010, 0x20080000, 0x00080810, 0x00000000,
 247          0x00000800, 0x20000010, 0x20000810, 0x20080800,
 248          0x20080000, 0x00000810, 0x00000010, 0x20080010},
 249
 250 /* nibble 6 */
 251         {0x00001000, 0x00000080, 0x00400080, 0x00400001,
 252          0x00401081, 0x00001001, 0x00001080, 0x00000000,
 253          0x00400000, 0x00400081, 0x00000081, 0x00401000,
 254          0x00000001, 0x00401080, 0x00401000, 0x00000081,
 255          0x00400081, 0x00001000, 0x00001001, 0x00401081,
 256          0x00000000, 0x00400080, 0x00400001, 0x00001080,
 257          0x00401001, 0x00001081, 0x00401080, 0x00000001,
 258          0x00001081, 0x00401001, 0x00000080, 0x00400000,
 259          0x00001081, 0x00401000, 0x00401001, 0x00000081,
 260          0x00001000, 0x00000080, 0x00400000, 0x00401001,
 261          0x00400081, 0x00001081, 0x00001080, 0x00000000,
 262          0x00000080, 0x00400001, 0x00000001, 0x00400080,
 263          0x00000000, 0x00400081, 0x00400080, 0x00001080,
 264          0x00000081, 0x00001000, 0x00401081, 0x00400000,
 265          0x00401080, 0x00000001, 0x00001001, 0x00401081,
 266          0x00400001, 0x00401080, 0x00401000, 0x00001001},
 267
 268 /* nibble 7 */
 269         {0x08200020, 0x08208000, 0x00008020, 0x00000000,
 270          0x08008000, 0x00200020, 0x08200000, 0x08208020,
 271          0x00000020, 0x08000000, 0x00208000, 0x00008020,
 272          0x00208020, 0x08008020, 0x08000020, 0x08200000,
 273          0x00008000, 0x00208020, 0x00200020, 0x08008000,
 274          0x08208020, 0x08000020, 0x00000000, 0x00208000,
 275          0x08000000, 0x00200000, 0x08008020, 0x08200020,
 276          0x00200000, 0x00008000, 0x08208000, 0x00000020,
 277          0x00200000, 0x00008000, 0x08000020, 0x08208020,
 278          0x00008020, 0x08000000, 0x00000000, 0x00208000,
 279          0x08200020, 0x08008020, 0x08008000, 0x00200020,
 280          0x08208000, 0x00000020, 0x00200020, 0x08008000,
 281          0x08208020, 0x00200000, 0x08200000, 0x08000020,
 282          0x00208000, 0x00008020, 0x08008020, 0x08200000,
 283          0x00000020, 0x08208000, 0x00208020, 0x00000000,
 284          0x08000000, 0x08200020, 0x00008000, 0x00208020}};
 285
 286 static unsigned long des_skb[8][64]={
 287 /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
 288         {0x00000000,0x00000010,0x20000000,0x20000010,
 289          0x00010000,0x00010010,0x20010000,0x20010010,
 290          0x00000800,0x00000810,0x20000800,0x20000810,
 291          0x00010800,0x00010810,0x20010800,0x20010810,
 292          0x00000020,0x00000030,0x20000020,0x20000030,
 293          0x00010020,0x00010030,0x20010020,0x20010030,
 294          0x00000820,0x00000830,0x20000820,0x20000830,
 295          0x00010820,0x00010830,0x20010820,0x20010830,
 296          0x00080000,0x00080010,0x20080000,0x20080010,
 297          0x00090000,0x00090010,0x20090000,0x20090010,
 298          0x00080800,0x00080810,0x20080800,0x20080810,
 299          0x00090800,0x00090810,0x20090800,0x20090810,
 300          0x00080020,0x00080030,0x20080020,0x20080030,
 301          0x00090020,0x00090030,0x20090020,0x20090030,
 302          0x00080820,0x00080830,0x20080820,0x20080830,
 303          0x00090820,0x00090830,0x20090820,0x20090830},
 304 /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
 305         {0x00000000,0x02000000,0x00002000,0x02002000,
 306          0x00200000,0x02200000,0x00202000,0x02202000,
 307          0x00000004,0x02000004,0x00002004,0x02002004,
 308          0x00200004,0x02200004,0x00202004,0x02202004,
 309          0x00000400,0x02000400,0x00002400,0x02002400,
 310          0x00200400,0x02200400,0x00202400,0x02202400,
 311          0x00000404,0x02000404,0x00002404,0x02002404,
 312          0x00200404,0x02200404,0x00202404,0x02202404,
 313          0x10000000,0x12000000,0x10002000,0x12002000,
 314          0x10200000,0x12200000,0x10202000,0x12202000,
 315          0x10000004,0x12000004,0x10002004,0x12002004,
 316          0x10200004,0x12200004,0x10202004,0x12202004,
 317          0x10000400,0x12000400,0x10002400,0x12002400,
 318          0x10200400,0x12200400,0x10202400,0x12202400,
 319          0x10000404,0x12000404,0x10002404,0x12002404,
 320          0x10200404,0x12200404,0x10202404,0x12202404},
 321 /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
 322         {0x00000000,0x00000001,0x00040000,0x00040001,
 323          0x01000000,0x01000001,0x01040000,0x01040001,
 324          0x00000002,0x00000003,0x00040002,0x00040003,
 325          0x01000002,0x01000003,0x01040002,0x01040003,
 326          0x00000200,0x00000201,0x00040200,0x00040201,
 327          0x01000200,0x01000201,0x01040200,0x01040201,
 328          0x00000202,0x00000203,0x00040202,0x00040203,
 329          0x01000202,0x01000203,0x01040202,0x01040203,
 330          0x08000000,0x08000001,0x08040000,0x08040001,
 331          0x09000000,0x09000001,0x09040000,0x09040001,
 332          0x08000002,0x08000003,0x08040002,0x08040003,
 333          0x09000002,0x09000003,0x09040002,0x09040003,
 334          0x08000200,0x08000201,0x08040200,0x08040201,
 335          0x09000200,0x09000201,0x09040200,0x09040201,
 336          0x08000202,0x08000203,0x08040202,0x08040203,
 337          0x09000202,0x09000203,0x09040202,0x09040203},
 338 /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
 339         {0x00000000,0x00100000,0x00000100,0x00100100,
 340          0x00000008,0x00100008,0x00000108,0x00100108,
 341          0x00001000,0x00101000,0x00001100,0x00101100,
 342          0x00001008,0x00101008,0x00001108,0x00101108,
 343          0x04000000,0x04100000,0x04000100,0x04100100,
 344          0x04000008,0x04100008,0x04000108,0x04100108,
 345          0x04001000,0x04101000,0x04001100,0x04101100,
 346          0x04001008,0x04101008,0x04001108,0x04101108,
 347          0x00020000,0x00120000,0x00020100,0x00120100,
 348          0x00020008,0x00120008,0x00020108,0x00120108,
 349          0x00021000,0x00121000,0x00021100,0x00121100,
 350          0x00021008,0x00121008,0x00021108,0x00121108,
 351          0x04020000,0x04120000,0x04020100,0x04120100,
 352          0x04020008,0x04120008,0x04020108,0x04120108,
 353          0x04021000,0x04121000,0x04021100,0x04121100,
 354          0x04021008,0x04121008,0x04021108,0x04121108},
 355 /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
 356         {0x00000000,0x10000000,0x00010000,0x10010000,
 357          0x00000004,0x10000004,0x00010004,0x10010004,
 358          0x20000000,0x30000000,0x20010000,0x30010000,
 359          0x20000004,0x30000004,0x20010004,0x30010004,
 360          0x00100000,0x10100000,0x00110000,0x10110000,
 361          0x00100004,0x10100004,0x00110004,0x10110004,
 362          0x20100000,0x30100000,0x20110000,0x30110000,
 363          0x20100004,0x30100004,0x20110004,0x30110004,
 364          0x00001000,0x10001000,0x00011000,0x10011000,
 365          0x00001004,0x10001004,0x00011004,0x10011004,
 366          0x20001000,0x30001000,0x20011000,0x30011000,
 367          0x20001004,0x30001004,0x20011004,0x30011004,
 368          0x00101000,0x10101000,0x00111000,0x10111000,
 369          0x00101004,0x10101004,0x00111004,0x10111004,
 370          0x20101000,0x30101000,0x20111000,0x30111000,
 371          0x20101004,0x30101004,0x20111004,0x30111004},
 372 /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
 373         {0x00000000,0x08000000,0x00000008,0x08000008,
 374          0x00000400,0x08000400,0x00000408,0x08000408,
 375          0x00020000,0x08020000,0x00020008,0x08020008,
 376          0x00020400,0x08020400,0x00020408,0x08020408,
 377          0x00000001,0x08000001,0x00000009,0x08000009,
 378          0x00000401,0x08000401,0x00000409,0x08000409,
 379          0x00020001,0x08020001,0x00020009,0x08020009,
 380          0x00020401,0x08020401,0x00020409,0x08020409,
 381          0x02000000,0x0A000000,0x02000008,0x0A000008,
 382          0x02000400,0x0A000400,0x02000408,0x0A000408,
 383          0x02020000,0x0A020000,0x02020008,0x0A020008,
 384          0x02020400,0x0A020400,0x02020408,0x0A020408,
 385          0x02000001,0x0A000001,0x02000009,0x0A000009,
 386          0x02000401,0x0A000401,0x02000409,0x0A000409,
 387          0x02020001,0x0A020001,0x02020009,0x0A020009,
 388          0x02020401,0x0A020401,0x02020409,0x0A020409},
 389 /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
 390         {0x00000000,0x00000100,0x00080000,0x00080100,
 391          0x01000000,0x01000100,0x01080000,0x01080100,
 392          0x00000010,0x00000110,0x00080010,0x00080110,
 393          0x01000010,0x01000110,0x01080010,0x01080110,
 394          0x00200000,0x00200100,0x00280000,0x00280100,
 395          0x01200000,0x01200100,0x01280000,0x01280100,
 396          0x00200010,0x00200110,0x00280010,0x00280110,
 397          0x01200010,0x01200110,0x01280010,0x01280110,
 398          0x00000200,0x00000300,0x00080200,0x00080300,
 399          0x01000200,0x01000300,0x01080200,0x01080300,
 400          0x00000210,0x00000310,0x00080210,0x00080310,
 401          0x01000210,0x01000310,0x01080210,0x01080310,
 402          0x00200200,0x00200300,0x00280200,0x00280300,
 403          0x01200200,0x01200300,0x01280200,0x01280300,
 404          0x00200210,0x00200310,0x00280210,0x00280310,
 405          0x01200210,0x01200310,0x01280210,0x01280310},
 406 /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
 407         {0x00000000,0x04000000,0x00040000,0x04040000,
 408          0x00000002,0x04000002,0x00040002,0x04040002,
 409          0x00002000,0x04002000,0x00042000,0x04042000,
 410          0x00002002,0x04002002,0x00042002,0x04042002,
 411          0x00000020,0x04000020,0x00040020,0x04040020,
 412          0x00000022,0x04000022,0x00040022,0x04040022,
 413          0x00002020,0x04002020,0x00042020,0x04042020,
 414          0x00002022,0x04002022,0x00042022,0x04042022,
 415          0x00000800,0x04000800,0x00040800,0x04040800,
 416          0x00000802,0x04000802,0x00040802,0x04040802,
 417          0x00002800,0x04002800,0x00042800,0x04042800,
 418          0x00002802,0x04002802,0x00042802,0x04042802,
 419          0x00000820,0x04000820,0x00040820,0x04040820,
 420          0x00000822,0x04000822,0x00040822,0x04040822,
 421          0x00002820,0x04002820,0x00042820,0x04042820,
 422          0x00002822,0x04002822,0x00042822,0x04042822}
 423 };
 424
 425 typedef struct des_ks_struct
 426 {
 427         union   {
 428                 des_cblock _;
 429                 /* make sure things are correct size on machines with
 430                  * 8 byte longs */
 431                 unsigned long pad[2];
 432         } ks;
 433 #define _       ks._
 434 } block_state[16];
 435
 436 static int des_encrypt(unsigned long *input, unsigned long *output,
 437                        block_state ks, int encrypt)
 438 {
 439         unsigned long l,r,t,u;
 440         int i;
 441         unsigned long *s;
 442
 443         l=input[0];
 444         r=input[1];
 445
 446         /* do IP */
 447         PERM_OP(r,l,t, 4,0x0f0f0f0f);
 448         PERM_OP(l,r,t,16,0x0000ffff);
 449         PERM_OP(r,l,t, 2,0x33333333);
 450         PERM_OP(l,r,t, 8,0x00ff00ff);
 451         PERM_OP(r,l,t, 1,0x55555555);
 452         /* r and l are reversed - remember that :-) - fix
 453          * it in the next step */
 454
 455         /* Things have been modified so that the initial rotate is
 456          * done outside the loop.  This required the
 457          * des_SPtrans values in sp.h to be rotated 1 bit to the right.
 458          * One perl script later and things have a 5% speed up on a sparc2.
 459          * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
 460          * for pointing this out. */
 461         t=(r<<1)|(r>>31);
 462         r=(l<<1)|(l>>31);
 463         l=t;
 464
 465         /* clear the top bits on machines with 8byte longs */
 466         l&=0xffffffff;
 467         r&=0xffffffff;
 468
 469         s=(unsigned long *)ks;
 470         /* I don't know if it is worth the effort of loop unrolling the
 471          * inner loop */
 472         if (encrypt)
 473         {
 474                 for (i=0; i<32; i+=4)
 475                 {
 476                         D_ENCRYPT(l,r,i+0); /*  1 */
 477                         D_ENCRYPT(r,l,i+2); /*  2 */
 478                 }
 479         }
 480         else
 481         {
 482                 for (i=30; i>0; i-=4)
 483                 {
 484                         D_ENCRYPT(l,r,i-0); /* 16 */
 485                         D_ENCRYPT(r,l,i-2); /* 15 */
 486                 }
 487         }
 488         l=(l>>1)|(l<<31);
 489         r=(r>>1)|(r<<31);
 490         /* clear the top bits on machines with 8byte longs */
 491         l&=0xffffffff;
 492         r&=0xffffffff;
 493
 494         /* swap l and r
 495          * we will not do the swap so just remember they are
 496          * reversed for the rest of the subroutine
 497          * luckily FP fixes this problem :-) */
 498
 499         PERM_OP(r,l,t, 1,0x55555555);
 500         PERM_OP(l,r,t, 8,0x00ff00ff);
 501         PERM_OP(r,l,t, 2,0x33333333);
 502         PERM_OP(l,r,t,16,0x0000ffff);
 503         PERM_OP(r,l,t, 4,0x0f0f0f0f);
 504
 505         output[0]=l;
 506         output[1]=r;
 507         l=r=t=u=0;
 508         return(0);
 509 }
 510
 511 static int des_ecb_encrypt(des_cblock *input, des_cblock *output,
 512                            block_state ks, int encrypt)
 513 {
 514         register unsigned long l0,l1;
 515         register unsigned char *in,*out;
 516         unsigned long ll[2];
 517
 518         in=(unsigned char *)input;
 519         out=(unsigned char *)output;
 520         c2l(in,l0);
 521         c2l(in,l1);
 522         ll[0]=l0;
 523         ll[1]=l1;
 524         des_encrypt(ll,ll,ks,encrypt);
 525         l0=ll[0];
 526         l1=ll[1];
 527         l2c(l0,out);
 528         l2c(l1,out);
 529         l0=l1=ll[0]=ll[1]=0;
 530         return(0);
 531 }
 532
 533
 534
 535 static void block_decrypt(block_state *state,
 536                           unsigned char *in,
 537                           unsigned char *out)
 538 {
 539         des_ecb_encrypt((des_cblock *)in, (des_cblock *)out, *state, 0);
 540 }
 541
 542 static void block_encrypt(block_state *state,
 543                           unsigned char *in,
 544                           unsigned char *out)
 545 {
 546         des_ecb_encrypt((des_cblock *)in, (des_cblock *)out, *state, 1);
 547 }
 548
 549 /* NOW DEFINED IN des_local.h
 550  * See ecb_encrypt.c for a pseudo description of these macros.
 551  * #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 552  *      (b)^=(t),\
 553  *      (a)=((a)^((t)<<(n))))
 554  */
 555
 556 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
 557         (a)=(a)^(t)^(t>>(16-(n))))
 558
 559 static char shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
 560
 561 /* return 0 if key parity is odd (correct),
 562  * return -1 if key parity error,
 563  * return -2 if illegal weak key.
 564  */
 565 static int des_set_key(des_cblock *key, block_state schedule)
 566 {
 567         register unsigned long c,d,t,s;
 568         register unsigned char *in;
 569         register unsigned long *k;
 570         register int i;
 571
 572         k=(unsigned long *)schedule;
 573         in=(unsigned char *)key;
 574
 575         c2l(in,c);
 576         c2l(in,d);
 577
 578         /* do PC1 in 60 simple operations */
 579 /*      PERM_OP(d,c,t,4,0x0f0f0f0f);
 580         HPERM_OP(c,t,-2, 0xcccc0000);
 581         HPERM_OP(c,t,-1, 0xaaaa0000);
 582         HPERM_OP(c,t, 8, 0x00ff0000);
 583         HPERM_OP(c,t,-1, 0xaaaa0000);
 584         HPERM_OP(d,t,-8, 0xff000000);
 585         HPERM_OP(d,t, 8, 0x00ff0000);
 586         HPERM_OP(d,t, 2, 0x33330000);
 587         d=((d&0x00aa00aa)<<7)|((d&0x55005500)>>7)|(d&0xaa55aa55);
 588         d=(d>>8)|((c&0xf0000000)>>4);
 589         c&=0x0fffffff; */
 590
 591         /* I now do it in 47 simple operations :-)
 592          * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
 593          * for the inspiration. :-) */
 594         PERM_OP (d,c,t,4,0x0f0f0f0f);
 595         HPERM_OP(c,t,-2,0xcccc0000);
 596         HPERM_OP(d,t,-2,0xcccc0000);
 597         PERM_OP (d,c,t,1,0x55555555);
 598         PERM_OP (c,d,t,8,0x00ff00ff);
 599         PERM_OP (d,c,t,1,0x55555555);
 600         d=      (((d&0x000000ff)<<16)| (d&0x0000ff00)     |
 601                  ((d&0x00ff0000)>>16)|((c&0xf0000000)>>4));
 602         c&=0x0fffffff;
 603
 604         for (i=0; i<16; i++)
 605         {
 606                 if (shifts2[i])
 607                 { c=((c>>2)|(c<<26)); d=((d>>2)|(d<<26)); }
 608                 else
 609                 { c=((c>>1)|(c<<27)); d=((d>>1)|(d<<27)); }
 610                 c&=0x0fffffff;
 611                 d&=0x0fffffff;
 612                 /* could be a few less shifts but I am to lazy at this
 613                  * point in time to investigate */
 614                 s=      des_skb[0][ (c    )&0x3f                ]|
 615                         des_skb[1][((c>> 6)&0x03)|((c>> 7)&0x3c)]|
 616                         des_skb[2][((c>>13)&0x0f)|((c>>14)&0x30)]|
 617                         des_skb[3][((c>>20)&0x01)|((c>>21)&0x06) |
 618                                   ((c>>22)&0x38)];
 619                 t=      des_skb[4][ (d    )&0x3f                ]|
 620                         des_skb[5][((d>> 7)&0x03)|((d>> 8)&0x3c)]|
 621                         des_skb[6][ (d>>15)&0x3f                ]|
 622                         des_skb[7][((d>>21)&0x0f)|((d>>22)&0x30)];
 623
 624                 /* table contained 0213 4657 */
 625                 *(k++)=((t<<16)|(s&0x0000ffff))&0xffffffff;
 626                 s=     ((s>>16)|(t&0xffff0000));
 627
 628                 s=(s<<4)|(s>>28);
 629                 *(k++)=s&0xffffffff;
 630         }
 631         return(0);
 632 }
 633
 634 static const unsigned char odd_parity[256]={
 635         1,  1,  2,  2,  4,  4,  7,  7,  8,  8, 11, 11, 13, 13, 14, 14,
 636         16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
 637         32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
 638         49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
 639         64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
 640         81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
 641         97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
 642         112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
 643         128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
 644         145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
 645         161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
 646         176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
 647         193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
 648         208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
 649         224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
 650         241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254};
 651
 652 static void block_init(block_state *state, unsigned char *key,
 653                        int keylen)
 654 {
 655         char oddkey[8];
 656         int i;
 657
 658         for (i=0; i<8; i++)
 659         {
 660                 oddkey[i]=odd_parity[ key[i] ];
 661         }
 662         des_set_key((des_cblock *)oddkey, *state);
 663 }
 664
 665 #include "block_template.c"