sshdes.c

   1 #include <assert.h>
   2 #include "ssh.h"
   3
   4 /* des.c - implementation of DES
   5  */
   6
   7 /*
   8  * Description of DES
   9  *
  10  * Unlike the description in FIPS 46, I'm going to use _sensible_ indices:
  11  * bits in an n-bit word are numbered from 0 at the LSB to n-1 at the MSB.
  12  * And S-boxes are indexed by six consecutive bits, not by the outer two
  13  * followed by the middle four.
  14  *
  15  * The DES encryption routine requires a 64-bit input, and a key schedule K
  16  * containing 16 48-bit elements.
  17  *
  18  *   First the input is permuted by the initial permutation IP.
  19  *   Then the input is split into 32-bit words L and R. (L is the MSW.)
  20  *   Next, 16 rounds. In each round:
  21  *     (L, R) <- (R, L xor f(R, K[i]))
  22  *   Then the pre-output words L and R are swapped.
  23  *   Then L and R are glued back together into a 64-bit word. (L is the MSW,
  24  *     again, but since we just swapped them, the MSW is the R that came out
  25  *     of the last round.)
  26  *   The 64-bit output block is permuted by the inverse of IP and returned.
  27  *
  28  * Decryption is identical except that the elements of K are used in the
  29  * opposite order. (This wouldn't work if that word swap didn't happen.)
  30  *
  31  * The function f, used in each round, accepts a 32-bit word R and a
  32  * 48-bit key block K. It produces a 32-bit output.
  33  *
  34  *   First R is expanded to 48 bits using the bit-selection function E.
  35  *   The resulting 48-bit block is XORed with the key block K to produce
  36  *     a 48-bit block X.
  37  *   This block X is split into eight groups of 6 bits. Each group of 6
  38  *     bits is then looked up in one of the eight S-boxes to convert
  39  *     it to 4 bits. These eight groups of 4 bits are glued back
  40  *     together to produce a 32-bit preoutput block.
  41  *   The preoutput block is permuted using the permutation P and returned.
  42  *
  43  * Key setup maps a 64-bit key word into a 16x48-bit key schedule. Although
  44  * the approved input format for the key is a 64-bit word, eight of the
  45  * bits are discarded, so the actual quantity of key used is 56 bits.
  46  *
  47  *   First the input key is converted to two 28-bit words C and D using
  48  *     the bit-selection function PC1.
  49  *   Then 16 rounds of key setup occur. In each round, C and D are each
  50  *     rotated left by either 1 or 2 bits (depending on which round), and
  51  *     then converted into a key schedule element using the bit-selection
  52  *     function PC2.
  53  *
  54  * That's the actual algorithm. Now for the tedious details: all those
  55  * painful permutations and lookup tables.
  56  *
  57  * IP is a 64-to-64 bit permutation. Its output contains the following
  58  * bits of its input (listed in order MSB to LSB of output).
  59  *
  60  *    6 14 22 30 38 46 54 62  4 12 20 28 36 44 52 60
  61  *    2 10 18 26 34 42 50 58  0  8 16 24 32 40 48 56
  62  *    7 15 23 31 39 47 55 63  5 13 21 29 37 45 53 61
  63  *    3 11 19 27 35 43 51 59  1  9 17 25 33 41 49 57
  64  *
  65  * E is a 32-to-48 bit selection function. Its output contains the following
  66  * bits of its input (listed in order MSB to LSB of output).
  67  *
  68  *    0 31 30 29 28 27 28 27 26 25 24 23 24 23 22 21 20 19 20 19 18 17 16 15
  69  *   16 15 14 13 12 11 12 11 10  9  8  7  8  7  6  5  4  3  4  3  2  1  0 31
  70  *
  71  * The S-boxes are arbitrary table-lookups each mapping a 6-bit input to a
  72  * 4-bit output. In other words, each S-box is an array[64] of 4-bit numbers.
  73  * The S-boxes are listed below. The first S-box listed is applied to the
  74  * most significant six bits of the block X; the last one is applied to the
  75  * least significant.
  76  *
  77  *   14  0  4 15 13  7  1  4  2 14 15  2 11 13  8  1
  78  *    3 10 10  6  6 12 12 11  5  9  9  5  0  3  7  8
  79  *    4 15  1 12 14  8  8  2 13  4  6  9  2  1 11  7
  80  *   15  5 12 11  9  3  7 14  3 10 10  0  5  6  0 13
  81  *
  82  *   15  3  1 13  8  4 14  7  6 15 11  2  3  8  4 14
  83  *    9 12  7  0  2  1 13 10 12  6  0  9  5 11 10  5
  84  *    0 13 14  8  7 10 11  1 10  3  4 15 13  4  1  2
  85  *    5 11  8  6 12  7  6 12  9  0  3  5  2 14 15  9
  86  *
  87  *   10 13  0  7  9  0 14  9  6  3  3  4 15  6  5 10
  88  *    1  2 13  8 12  5  7 14 11 12  4 11  2 15  8  1
  89  *   13  1  6 10  4 13  9  0  8  6 15  9  3  8  0  7
  90  *   11  4  1 15  2 14 12  3  5 11 10  5 14  2  7 12
  91  *
  92  *    7 13 13  8 14 11  3  5  0  6  6 15  9  0 10  3
  93  *    1  4  2  7  8  2  5 12 11  1 12 10  4 14 15  9
  94  *   10  3  6 15  9  0  0  6 12 10 11  1  7 13 13  8
  95  *   15  9  1  4  3  5 14 11  5 12  2  7  8  2  4 14
  96  *
  97  *    2 14 12 11  4  2  1 12  7  4 10  7 11 13  6  1
  98  *    8  5  5  0  3 15 15 10 13  3  0  9 14  8  9  6
  99  *    4 11  2  8  1 12 11  7 10  1 13 14  7  2  8 13
 100  *   15  6  9 15 12  0  5  9  6 10  3  4  0  5 14  3
 101  *
 102  *   12 10  1 15 10  4 15  2  9  7  2 12  6  9  8  5
 103  *    0  6 13  1  3 13  4 14 14  0  7 11  5  3 11  8
 104  *    9  4 14  3 15  2  5 12  2  9  8  5 12 15  3 10
 105  *    7 11  0 14  4  1 10  7  1  6 13  0 11  8  6 13
 106  *
 107  *    4 13 11  0  2 11 14  7 15  4  0  9  8  1 13 10
 108  *    3 14 12  3  9  5  7 12  5  2 10 15  6  8  1  6
 109  *    1  6  4 11 11 13 13  8 12  1  3  4  7 10 14  7
 110  *   10  9 15  5  6  0  8 15  0 14  5  2  9  3  2 12
 111  *
 112  *   13  1  2 15  8 13  4  8  6 10 15  3 11  7  1  4
 113  *   10 12  9  5  3  6 14 11  5  0  0 14 12  9  7  2
 114  *    7  2 11  1  4 14  1  7  9  4 12 10 14  8  2 13
 115  *    0 15  6 12 10  9 13  0 15  3  3  5  5  6  8 11
 116  *
 117  * P is a 32-to-32 bit permutation. Its output contains the following
 118  * bits of its input (listed in order MSB to LSB of output).
 119  *
 120  *   16 25 12 11  3 20  4 15 31 17  9  6 27 14  1 22
 121  *   30 24  8 18  0  5 29 23 13 19  2 26 10 21 28  7
 122  *
 123  * PC1 is a 64-to-56 bit selection function. Its output is in two words,
 124  * C and D. The word C contains the following bits of its input (listed
 125  * in order MSB to LSB of output).
 126  *
 127  *    7 15 23 31 39 47 55 63  6 14 22 30 38 46
 128  *   54 62  5 13 21 29 37 45 53 61  4 12 20 28
 129  *
 130  * And the word D contains these bits.
 131  *
 132  *    1  9 17 25 33 41 49 57  2 10 18 26 34 42
 133  *   50 58  3 11 19 27 35 43 51 59 36 44 52 60
 134  *
 135  * PC2 is a 56-to-48 bit selection function. Its input is in two words,
 136  * C and D. These are treated as one 56-bit word (with C more significant,
 137  * so that bits 55 to 28 of the word are bits 27 to 0 of C, and bits 27 to
 138  * 0 of the word are bits 27 to 0 of D). The output contains the following
 139  * bits of this 56-bit input word (listed in order MSB to LSB of output).
 140  *
 141  *   42 39 45 32 55 51 53 28 41 50 35 46 33 37 44 52 30 48 40 49 29 36 43 54
 142  *   15  4 25 19  9  1 26 16  5 11 23  8 12  7 17  0 22  3 10 14  6 20 27 24
 143  */
 144
 145 typedef struct {
 146     word32 k0246[16], k1357[16];
 147     word32 eiv0, eiv1;
 148     word32 div0, div1;
 149 } DESContext;
 150
 151 #define rotl(x, c) ( (x << c) | (x >> (32-c)) )
 152 #define rotl28(x, c) ( ( (x << c) | (x >> (28-c)) ) & 0x0FFFFFFF)
 153
 154 static word32 bitsel(word32 *input, const int *bitnums, int size) {
 155     word32 ret = 0;
 156     while (size--) {
 157         int bitpos = *bitnums++;
 158         ret <<= 1;
 159         if (bitpos >= 0)
 160             ret |= 1 & (input[bitpos / 32] >> (bitpos % 32));
 161     }
 162     return ret;
 163 }
 164
 165 void des_key_setup(word32 key_msw, word32 key_lsw, DESContext *sched) {
 166
 167     static const int PC1_Cbits[] = {
 168         7, 15, 23, 31, 39, 47, 55, 63, 6, 14, 22, 30, 38, 46,
 169         54, 62, 5, 13, 21, 29, 37, 45, 53, 61, 4, 12, 20, 28
 170     };
 171     static const int PC1_Dbits[] = {
 172         1, 9, 17, 25, 33, 41, 49, 57, 2, 10, 18, 26, 34, 42,
 173         50, 58, 3, 11, 19, 27, 35, 43, 51, 59, 36, 44, 52, 60
 174     };
 175     static const int PC2_0246[] = {
 176         49, 36, 59, 55, -1, -1, 37, 41, 48, 56, 34, 52, -1, -1, 15, 4,
 177         25, 19, 9, 1, -1, -1, 12, 7, 17, 0, 22, 3, -1, -1, 46, 43
 178     };
 179     static const int PC2_1357[] = {
 180         -1, -1, 57, 32, 45, 54, 39, 50, -1, -1, 44, 53, 33, 40, 47, 58,
 181         -1, -1, 26, 16, 5, 11, 23, 8, -1, -1, 10, 14, 6, 20, 27, 24
 182     };
 183     static const int leftshifts[] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
 184
 185     word32 C, D;
 186     word32 buf[2];
 187     int i;
 188
 189     buf[0] = key_lsw;
 190     buf[1] = key_msw;
 191
 192     C = bitsel(buf, PC1_Cbits, 28);
 193     D = bitsel(buf, PC1_Dbits, 28);
 194
 195     for (i = 0; i < 16; i++) {
 196         C = rotl28(C, leftshifts[i]);
 197         D = rotl28(D, leftshifts[i]);
 198         buf[0] = D;
 199         buf[1] = C;
 200         sched->k0246[i] = bitsel(buf, PC2_0246, 32);
 201         sched->k1357[i] = bitsel(buf, PC2_1357, 32);
 202     }
 203
 204     sched->eiv0 = sched->eiv1 = 0;
 205     sched->div0 = sched->div1 = 0;       /* for good measure */
 206 }
 207
 208 static const word32 SPboxes[8][64] = {
 209     {0x01010400, 0x00000000, 0x00010000, 0x01010404,
 210     0x01010004, 0x00010404, 0x00000004, 0x00010000,
 211     0x00000400, 0x01010400, 0x01010404, 0x00000400,
 212     0x01000404, 0x01010004, 0x01000000, 0x00000004,
 213     0x00000404, 0x01000400, 0x01000400, 0x00010400,
 214     0x00010400, 0x01010000, 0x01010000, 0x01000404,
 215     0x00010004, 0x01000004, 0x01000004, 0x00010004,
 216     0x00000000, 0x00000404, 0x00010404, 0x01000000,
 217     0x00010000, 0x01010404, 0x00000004, 0x01010000,
 218     0x01010400, 0x01000000, 0x01000000, 0x00000400,
 219     0x01010004, 0x00010000, 0x00010400, 0x01000004,
 220     0x00000400, 0x00000004, 0x01000404, 0x00010404,
 221     0x01010404, 0x00010004, 0x01010000, 0x01000404,
 222     0x01000004, 0x00000404, 0x00010404, 0x01010400,
 223     0x00000404, 0x01000400, 0x01000400, 0x00000000,
 224     0x00010004, 0x00010400, 0x00000000, 0x01010004L},
 225
 226     {0x80108020, 0x80008000, 0x00008000, 0x00108020,
 227     0x00100000, 0x00000020, 0x80100020, 0x80008020,
 228     0x80000020, 0x80108020, 0x80108000, 0x80000000,
 229     0x80008000, 0x00100000, 0x00000020, 0x80100020,
 230     0x00108000, 0x00100020, 0x80008020, 0x00000000,
 231     0x80000000, 0x00008000, 0x00108020, 0x80100000,
 232     0x00100020, 0x80000020, 0x00000000, 0x00108000,
 233     0x00008020, 0x80108000, 0x80100000, 0x00008020,
 234     0x00000000, 0x00108020, 0x80100020, 0x00100000,
 235     0x80008020, 0x80100000, 0x80108000, 0x00008000,
 236     0x80100000, 0x80008000, 0x00000020, 0x80108020,
 237     0x00108020, 0x00000020, 0x00008000, 0x80000000,
 238     0x00008020, 0x80108000, 0x00100000, 0x80000020,
 239     0x00100020, 0x80008020, 0x80000020, 0x00100020,
 240     0x00108000, 0x00000000, 0x80008000, 0x00008020,
 241     0x80000000, 0x80100020, 0x80108020, 0x00108000L},
 242
 243     {0x00000208, 0x08020200, 0x00000000, 0x08020008,
 244     0x08000200, 0x00000000, 0x00020208, 0x08000200,
 245     0x00020008, 0x08000008, 0x08000008, 0x00020000,
 246     0x08020208, 0x00020008, 0x08020000, 0x00000208,
 247     0x08000000, 0x00000008, 0x08020200, 0x00000200,
 248     0x00020200, 0x08020000, 0x08020008, 0x00020208,
 249     0x08000208, 0x00020200, 0x00020000, 0x08000208,
 250     0x00000008, 0x08020208, 0x00000200, 0x08000000,
 251     0x08020200, 0x08000000, 0x00020008, 0x00000208,
 252     0x00020000, 0x08020200, 0x08000200, 0x00000000,
 253     0x00000200, 0x00020008, 0x08020208, 0x08000200,
 254     0x08000008, 0x00000200, 0x00000000, 0x08020008,
 255     0x08000208, 0x00020000, 0x08000000, 0x08020208,
 256     0x00000008, 0x00020208, 0x00020200, 0x08000008,
 257     0x08020000, 0x08000208, 0x00000208, 0x08020000,
 258     0x00020208, 0x00000008, 0x08020008, 0x00020200L},
 259
 260     {0x00802001, 0x00002081, 0x00002081, 0x00000080,
 261     0x00802080, 0x00800081, 0x00800001, 0x00002001,
 262     0x00000000, 0x00802000, 0x00802000, 0x00802081,
 263     0x00000081, 0x00000000, 0x00800080, 0x00800001,
 264     0x00000001, 0x00002000, 0x00800000, 0x00802001,
 265     0x00000080, 0x00800000, 0x00002001, 0x00002080,
 266     0x00800081, 0x00000001, 0x00002080, 0x00800080,
 267     0x00002000, 0x00802080, 0x00802081, 0x00000081,
 268     0x00800080, 0x00800001, 0x00802000, 0x00802081,
 269     0x00000081, 0x00000000, 0x00000000, 0x00802000,
 270     0x00002080, 0x00800080, 0x00800081, 0x00000001,
 271     0x00802001, 0x00002081, 0x00002081, 0x00000080,
 272     0x00802081, 0x00000081, 0x00000001, 0x00002000,
 273     0x00800001, 0x00002001, 0x00802080, 0x00800081,
 274     0x00002001, 0x00002080, 0x00800000, 0x00802001,
 275     0x00000080, 0x00800000, 0x00002000, 0x00802080L},
 276
 277     {0x00000100, 0x02080100, 0x02080000, 0x42000100,
 278     0x00080000, 0x00000100, 0x40000000, 0x02080000,
 279     0x40080100, 0x00080000, 0x02000100, 0x40080100,
 280     0x42000100, 0x42080000, 0x00080100, 0x40000000,
 281     0x02000000, 0x40080000, 0x40080000, 0x00000000,
 282     0x40000100, 0x42080100, 0x42080100, 0x02000100,
 283     0x42080000, 0x40000100, 0x00000000, 0x42000000,
 284     0x02080100, 0x02000000, 0x42000000, 0x00080100,
 285     0x00080000, 0x42000100, 0x00000100, 0x02000000,
 286     0x40000000, 0x02080000, 0x42000100, 0x40080100,
 287     0x02000100, 0x40000000, 0x42080000, 0x02080100,
 288     0x40080100, 0x00000100, 0x02000000, 0x42080000,
 289     0x42080100, 0x00080100, 0x42000000, 0x42080100,
 290     0x02080000, 0x00000000, 0x40080000, 0x42000000,
 291     0x00080100, 0x02000100, 0x40000100, 0x00080000,
 292     0x00000000, 0x40080000, 0x02080100, 0x40000100L},
 293
 294     {0x20000010, 0x20400000, 0x00004000, 0x20404010,
 295     0x20400000, 0x00000010, 0x20404010, 0x00400000,
 296     0x20004000, 0x00404010, 0x00400000, 0x20000010,
 297     0x00400010, 0x20004000, 0x20000000, 0x00004010,
 298     0x00000000, 0x00400010, 0x20004010, 0x00004000,
 299     0x00404000, 0x20004010, 0x00000010, 0x20400010,
 300     0x20400010, 0x00000000, 0x00404010, 0x20404000,
 301     0x00004010, 0x00404000, 0x20404000, 0x20000000,
 302     0x20004000, 0x00000010, 0x20400010, 0x00404000,
 303     0x20404010, 0x00400000, 0x00004010, 0x20000010,
 304     0x00400000, 0x20004000, 0x20000000, 0x00004010,
 305     0x20000010, 0x20404010, 0x00404000, 0x20400000,
 306     0x00404010, 0x20404000, 0x00000000, 0x20400010,
 307     0x00000010, 0x00004000, 0x20400000, 0x00404010,
 308     0x00004000, 0x00400010, 0x20004010, 0x00000000,
 309     0x20404000, 0x20000000, 0x00400010, 0x20004010L},
 310
 311     {0x00200000, 0x04200002, 0x04000802, 0x00000000,
 312     0x00000800, 0x04000802, 0x00200802, 0x04200800,
 313     0x04200802, 0x00200000, 0x00000000, 0x04000002,
 314     0x00000002, 0x04000000, 0x04200002, 0x00000802,
 315     0x04000800, 0x00200802, 0x00200002, 0x04000800,
 316     0x04000002, 0x04200000, 0x04200800, 0x00200002,
 317     0x04200000, 0x00000800, 0x00000802, 0x04200802,
 318     0x00200800, 0x00000002, 0x04000000, 0x00200800,
 319     0x04000000, 0x00200800, 0x00200000, 0x04000802,
 320     0x04000802, 0x04200002, 0x04200002, 0x00000002,
 321     0x00200002, 0x04000000, 0x04000800, 0x00200000,
 322     0x04200800, 0x00000802, 0x00200802, 0x04200800,
 323     0x00000802, 0x04000002, 0x04200802, 0x04200000,
 324     0x00200800, 0x00000000, 0x00000002, 0x04200802,
 325     0x00000000, 0x00200802, 0x04200000, 0x00000800,
 326     0x04000002, 0x04000800, 0x00000800, 0x00200002L},
 327
 328     {0x10001040, 0x00001000, 0x00040000, 0x10041040,
 329     0x10000000, 0x10001040, 0x00000040, 0x10000000,
 330     0x00040040, 0x10040000, 0x10041040, 0x00041000,
 331     0x10041000, 0x00041040, 0x00001000, 0x00000040,
 332     0x10040000, 0x10000040, 0x10001000, 0x00001040,
 333     0x00041000, 0x00040040, 0x10040040, 0x10041000,
 334     0x00001040, 0x00000000, 0x00000000, 0x10040040,
 335     0x10000040, 0x10001000, 0x00041040, 0x00040000,
 336     0x00041040, 0x00040000, 0x10041000, 0x00001000,
 337     0x00000040, 0x10040040, 0x00001000, 0x00041040,
 338     0x10001000, 0x00000040, 0x10000040, 0x10040000,
 339     0x10040040, 0x10000000, 0x00040000, 0x10001040,
 340     0x00000000, 0x10041040, 0x00040040, 0x10000040,
 341     0x10040000, 0x10001000, 0x10001040, 0x00000000,
 342     0x10041040, 0x00041000, 0x00041000, 0x00001040,
 343     0x00001040, 0x00040040, 0x10000000, 0x10041000L}
 344 };
 345
 346 #define f(R, K0246, K1357) (\
 347     s0246 = R ^ K0246, \
 348     s1357 = R ^ K1357, \
 349     s0246 = rotl(s0246, 28), \
 350     SPboxes[0] [(s0246 >> 24) & 0x3F] | \
 351     SPboxes[1] [(s1357 >> 24) & 0x3F] | \
 352     SPboxes[2] [(s0246 >> 16) & 0x3F] | \
 353     SPboxes[3] [(s1357 >> 16) & 0x3F] | \
 354     SPboxes[4] [(s0246 >>  8) & 0x3F] | \
 355     SPboxes[5] [(s1357 >>  8) & 0x3F] | \
 356     SPboxes[6] [(s0246      ) & 0x3F] | \
 357     SPboxes[7] [(s1357      ) & 0x3F])
 358
 359 #define bitswap(L, R, n, mask) (\
 360     swap = mask & ( (R >> n) ^ L ), \
 361     R ^= swap << n, \
 362     L ^= swap)
 363
 364 /* Initial permutation */
 365 #define IP(L, R) (\
 366     bitswap(R, L,  4, 0x0F0F0F0F), \
 367     bitswap(R, L, 16, 0x0000FFFF), \
 368     bitswap(L, R,  2, 0x33333333), \
 369     bitswap(L, R,  8, 0x00FF00FF), \
 370     bitswap(R, L,  1, 0x55555555))
 371
 372 /* Final permutation */
 373 #define FP(L, R) (\
 374     bitswap(R, L,  1, 0x55555555), \
 375     bitswap(L, R,  8, 0x00FF00FF), \
 376     bitswap(L, R,  2, 0x33333333), \
 377     bitswap(R, L, 16, 0x0000FFFF), \
 378     bitswap(R, L,  4, 0x0F0F0F0F))
 379
 380 void des_encipher(word32 *output, word32 L, word32 R, DESContext *sched) {
 381     word32 swap, s0246, s1357;
 382
 383     IP(L, R);
 384
 385     L = rotl(L, 1);
 386     R = rotl(R, 1);
 387
 388     L ^= f(R, sched->k0246[ 0], sched->k1357[ 0]);
 389     R ^= f(L, sched->k0246[ 1], sched->k1357[ 1]);
 390     L ^= f(R, sched->k0246[ 2], sched->k1357[ 2]);
 391     R ^= f(L, sched->k0246[ 3], sched->k1357[ 3]);
 392     L ^= f(R, sched->k0246[ 4], sched->k1357[ 4]);
 393     R ^= f(L, sched->k0246[ 5], sched->k1357[ 5]);
 394     L ^= f(R, sched->k0246[ 6], sched->k1357[ 6]);
 395     R ^= f(L, sched->k0246[ 7], sched->k1357[ 7]);
 396     L ^= f(R, sched->k0246[ 8], sched->k1357[ 8]);
 397     R ^= f(L, sched->k0246[ 9], sched->k1357[ 9]);
 398     L ^= f(R, sched->k0246[10], sched->k1357[10]);
 399     R ^= f(L, sched->k0246[11], sched->k1357[11]);
 400     L ^= f(R, sched->k0246[12], sched->k1357[12]);
 401     R ^= f(L, sched->k0246[13], sched->k1357[13]);
 402     L ^= f(R, sched->k0246[14], sched->k1357[14]);
 403     R ^= f(L, sched->k0246[15], sched->k1357[15]);
 404
 405     L = rotl(L, 31);
 406     R = rotl(R, 31);
 407
 408     swap = L; L = R; R = swap;
 409
 410     FP(L, R);
 411
 412     output[0] = L;
 413     output[1] = R;
 414 }
 415
 416 void des_decipher(word32 *output, word32 L, word32 R, DESContext *sched) {
 417     word32 swap, s0246, s1357;
 418
 419     IP(L, R);
 420
 421     L = rotl(L, 1);
 422     R = rotl(R, 1);
 423
 424     L ^= f(R, sched->k0246[15], sched->k1357[15]);
 425     R ^= f(L, sched->k0246[14], sched->k1357[14]);
 426     L ^= f(R, sched->k0246[13], sched->k1357[13]);
 427     R ^= f(L, sched->k0246[12], sched->k1357[12]);
 428     L ^= f(R, sched->k0246[11], sched->k1357[11]);
 429     R ^= f(L, sched->k0246[10], sched->k1357[10]);
 430     L ^= f(R, sched->k0246[ 9], sched->k1357[ 9]);
 431     R ^= f(L, sched->k0246[ 8], sched->k1357[ 8]);
 432     L ^= f(R, sched->k0246[ 7], sched->k1357[ 7]);
 433     R ^= f(L, sched->k0246[ 6], sched->k1357[ 6]);
 434     L ^= f(R, sched->k0246[ 5], sched->k1357[ 5]);
 435     R ^= f(L, sched->k0246[ 4], sched->k1357[ 4]);
 436     L ^= f(R, sched->k0246[ 3], sched->k1357[ 3]);
 437     R ^= f(L, sched->k0246[ 2], sched->k1357[ 2]);
 438     L ^= f(R, sched->k0246[ 1], sched->k1357[ 1]);
 439     R ^= f(L, sched->k0246[ 0], sched->k1357[ 0]);
 440
 441     L = rotl(L, 31);
 442     R = rotl(R, 31);
 443
 444     swap = L; L = R; R = swap;
 445
 446     FP(L, R);
 447
 448     output[0] = L;
 449     output[1] = R;
 450 }
 451
 452 #define GET_32BIT_MSB_FIRST(cp) \
 453   (((unsigned long)(unsigned char)(cp)[3]) | \
 454   ((unsigned long)(unsigned char)(cp)[2] << 8) | \
 455   ((unsigned long)(unsigned char)(cp)[1] << 16) | \
 456   ((unsigned long)(unsigned char)(cp)[0] << 24))
 457
 458 #define PUT_32BIT_MSB_FIRST(cp, value) do { \
 459   (cp)[3] = (value); \
 460   (cp)[2] = (value) >> 8; \
 461   (cp)[1] = (value) >> 16; \
 462   (cp)[0] = (value) >> 24; } while (0)
 463
 464 static void des_cbc_encrypt(unsigned char *dest, const unsigned char *src,
 465                             unsigned int len, DESContext *sched) {
 466     word32 out[2], iv0, iv1;
 467     unsigned int i;
 468
 469     assert((len & 7) == 0);
 470
 471     iv0 = sched->eiv0;
 472     iv1 = sched->eiv1;
 473     for (i = 0; i < len; i += 8) {
 474         iv0 ^= GET_32BIT_MSB_FIRST(src); src += 4;
 475         iv1 ^= GET_32BIT_MSB_FIRST(src); src += 4;
 476         des_encipher(out, iv0, iv1, sched);
 477         iv0 = out[0];
 478         iv1 = out[1];
 479         PUT_32BIT_MSB_FIRST(dest, iv0); dest += 4;
 480         PUT_32BIT_MSB_FIRST(dest, iv1); dest += 4;
 481     }
 482     sched->eiv0 = iv0;
 483     sched->eiv1 = iv1;
 484 }
 485
 486 static void des_cbc_decrypt(unsigned char *dest, const unsigned char *src,
 487                             unsigned int len, DESContext *sched) {
 488     word32 out[2], iv0, iv1, xL, xR;
 489     unsigned int i;
 490
 491     assert((len & 7) == 0);
 492
 493     iv0 = sched->div0;
 494     iv1 = sched->div1;
 495     for (i = 0; i < len; i += 8) {
 496         xL = GET_32BIT_MSB_FIRST(src); src += 4;
 497         xR = GET_32BIT_MSB_FIRST(src); src += 4;
 498         des_decipher(out, xL, xR, sched);
 499         iv0 ^= out[0];
 500         iv1 ^= out[1];
 501         PUT_32BIT_MSB_FIRST(dest, iv0); dest += 4;
 502         PUT_32BIT_MSB_FIRST(dest, iv1); dest += 4;
 503         iv0 = xL;
 504         iv1 = xR;
 505     }
 506     sched->div0 = iv0;
 507     sched->div1 = iv1;
 508 }
 509
 510 static void des_3cbc_encrypt(unsigned char *dest, const unsigned char *src,
 511                              unsigned int len, DESContext *scheds) {
 512     des_cbc_encrypt(dest, src, len, &scheds[0]);
 513     des_cbc_decrypt(dest, src, len, &scheds[1]);
 514     des_cbc_encrypt(dest, src, len, &scheds[2]);
 515 }
 516
 517 static void des_3cbc_decrypt(unsigned char *dest, const unsigned char *src,
 518                              unsigned int len, DESContext *scheds) {
 519     des_cbc_decrypt(dest, src, len, &scheds[2]);
 520     des_cbc_encrypt(dest, src, len, &scheds[1]);
 521     des_cbc_decrypt(dest, src, len, &scheds[0]);
 522 }
 523
 524 DESContext keys[3];
 525
 526 static void des3_sesskey(unsigned char *key) {
 527     des_key_setup(GET_32BIT_MSB_FIRST(key),
 528                   GET_32BIT_MSB_FIRST(key+4), &keys[0]);
 529     des_key_setup(GET_32BIT_MSB_FIRST(key+8),
 530                   GET_32BIT_MSB_FIRST(key+12), &keys[1]);
 531     des_key_setup(GET_32BIT_MSB_FIRST(key+16),
 532                   GET_32BIT_MSB_FIRST(key+20), &keys[2]);
 533     logevent("Initialised triple-DES encryption");
 534 }
 535
 536 static void des3_encrypt_blk(unsigned char *blk, int len) {
 537     des_3cbc_encrypt(blk, blk, len, keys);
 538 }
 539
 540 static void des3_decrypt_blk(unsigned char *blk, int len) {
 541     des_3cbc_decrypt(blk, blk, len, keys);
 542 }
 543
 544 struct ssh_cipher ssh_3des = {
 545     des3_sesskey,
 546     des3_encrypt_blk,
 547     des3_decrypt_blk
 548 };
 549
 550 static void des_sesskey(unsigned char *key) {
 551     des_key_setup(GET_32BIT_MSB_FIRST(key),
 552                   GET_32BIT_MSB_FIRST(key+4), &keys[0]);
 553     logevent("Initialised single-DES encryption");
 554 }
 555
 556 static void des_encrypt_blk(unsigned char *blk, int len) {
 557     des_cbc_encrypt(blk, blk, len, keys);
 558 }
 559
 560 static void des_decrypt_blk(unsigned char *blk, int len) {
 561     des_cbc_decrypt(blk, blk, len, keys);
 562 }
 563
 564 struct ssh_cipher ssh_des = {
 565     des_sesskey,
 566     des_encrypt_blk,
 567     des_decrypt_blk
 568 };