sunrpc/des_impl.c

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