git.sesse.net Git - rdpsrv/blob - Xserver/lib/Xdmcp/Wraphelp.c

   1 /*
   2  * This program implements the
   3  * Proposed Federal Information Processing
   4  *  Data Encryption Standard.
   5  * See Federal Register, March 17, 1975 (40FR12134)
   6  */
   7
   8 /*
   9  * Initial permutation,
  10  */
  11 static char    IP[] = {
  12        58,50,42,34,26,18,10, 2,
  13        60,52,44,36,28,20,12, 4,
  14        62,54,46,38,30,22,14, 6,
  15        64,56,48,40,32,24,16, 8,
  16        57,49,41,33,25,17, 9, 1,
  17        59,51,43,35,27,19,11, 3,
  18        61,53,45,37,29,21,13, 5,
  19        63,55,47,39,31,23,15, 7,
  20 };
  21
  22 /*
  23  * Final permutation, FP = IP^(-1)
  24  */
  25 static char    FP[] = {
  26        40, 8,48,16,56,24,64,32,
  27        39, 7,47,15,55,23,63,31,
  28        38, 6,46,14,54,22,62,30,
  29        37, 5,45,13,53,21,61,29,
  30        36, 4,44,12,52,20,60,28,
  31        35, 3,43,11,51,19,59,27,
  32        34, 2,42,10,50,18,58,26,
  33        33, 1,41, 9,49,17,57,25,
  34 };
  35
  36 /*
  37  * Permuted-choice 1 from the key bits
  38  * to yield C and D.
  39  * Note that bits 8,16... are left out:
  40  * They are intended for a parity check.
  41  */
  42 static char    PC1_C[] = {
  43        57,49,41,33,25,17, 9,
  44         1,58,50,42,34,26,18,
  45        10, 2,59,51,43,35,27,
  46        19,11, 3,60,52,44,36,
  47 };
  48
  49 static char    PC1_D[] = {
  50        63,55,47,39,31,23,15,
  51         7,62,54,46,38,30,22,
  52        14, 6,61,53,45,37,29,
  53        21,13, 5,28,20,12, 4,
  54 };
  55
  56 /*
  57  * Sequence of shifts used for the key schedule.
  58 */
  59 static char    shifts[] = {
  60        1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
  61 };
  62
  63 /*
  64  * Permuted-choice 2, to pick out the bits from
  65  * the CD array that generate the key schedule.
  66  */
  67 static char    PC2_C[] = {
  68        14,17,11,24, 1, 5,
  69         3,28,15, 6,21,10,
  70        23,19,12, 4,26, 8,
  71        16, 7,27,20,13, 2,
  72 };
  73
  74 static char    PC2_D[] = {
  75        41,52,31,37,47,55,
  76        30,40,51,45,33,48,
  77        44,49,39,56,34,53,
  78        46,42,50,36,29,32,
  79 };
  80
  81 /*
  82  * The C and D arrays used to calculate the key schedule.
  83  */
  84
  85 static char    C[28];
  86 static char    D[28];
  87
  88 /*
  89  * The key schedule.
  90  * Generated from the key.
  91  */
  92 static char    KS[16][48];
  93
  94 /*
  95  * The E bit-selection table.
  96  */
  97 static char    E[48];
  98 static char    e[] = {
  99        32, 1, 2, 3, 4, 5,
 100         4, 5, 6, 7, 8, 9,
 101         8, 9,10,11,12,13,
 102        12,13,14,15,16,17,
 103        16,17,18,19,20,21,
 104        20,21,22,23,24,25,
 105        24,25,26,27,28,29,
 106        28,29,30,31,32, 1,
 107 };
 108
 109 /*
 110  * Set up the key schedule from the key.
 111  */
 112
 113 static
 114 setkey(key)
 115 char *key;
 116 {
 117        int     i, j, k;
 118        int     t;
 119        char    *ptr;
 120
 121        /*
 122         * First, generate C and D by permuting
 123         * the key.  The low order bit of each
 124         * 8-bit char is not used, so C and D are only 28
 125         * bits apiece.
 126         */
 127        for (i=0; i<28; i++) {
 128                C[i] = key[PC1_C[i]-1];
 129                D[i] = key[PC1_D[i]-1];
 130        }
 131        /*
 132         * To generate Ki, rotate C and D according
 133         * to schedule and pick up a permutation
 134         * using PC2.
 135         */
 136        for (i=0; i<16; i++) {
 137                /*
 138                 * rotate.
 139                 */
 140                for (k=0; k<shifts[i]; k++) {
 141                        t = C[0];
 142                        ptr = C;
 143                        for (j=0; j<28-1; j++)
 144                        {
 145                                *ptr = ptr[1];
 146                                ptr++;
 147                        }
 148                        C[27] = t;
 149                        t = D[0];
 150                        ptr = D;
 151                        for (j=0; j<28-1; j++)
 152                        {
 153                                *ptr = ptr[1];
 154                                ptr++;
 155                        }
 156                        D[27] = t;
 157                }
 158                /*
 159                 * get Ki. Note C and D are concatenated.
 160                 */
 161                ptr = &KS[i][0];
 162                for (j=0; j<24; j++) {
 163                        ptr[j] = C[PC2_C[j]-1];
 164                        ptr[j+24] = D[PC2_D[j]-28-1];
 165                }
 166        }
 167
 168        for(i=0;i<48;i++)
 169                E[i] = e[i];
 170 }
 171
 172 /*
 173  * The 8 selection functions.
 174  * For some reason, they give a 0-origin
 175  * index, unlike everything else.
 176  */
 177 static char    S[8][64] = {
 178        14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
 179         0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
 180         4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
 181        15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
 182
 183        15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
 184         3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
 185         0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
 186        13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
 187
 188        10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
 189        13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
 190        13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
 191         1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
 192
 193         7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
 194        13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
 195        10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
 196         3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
 197
 198         2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
 199        14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
 200         4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
 201        11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
 202
 203        12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
 204        10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
 205         9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
 206         4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
 207
 208         4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
 209        13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
 210         1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
 211         6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
 212
 213        13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
 214         1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
 215         7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
 216         2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
 217 };
 218
 219 /*
 220  * P is a permutation on the selected combination
 221  * of the current L and key.
 222  */
 223 static char    P[] = {
 224        16, 7,20,21,
 225        29,12,28,17,
 226         1,15,23,26,
 227         5,18,31,10,
 228         2, 8,24,14,
 229        32,27, 3, 9,
 230        19,13,30, 6,
 231        22,11, 4,25,
 232 };
 233
 234 /*
 235  * The current block, divided into 2 halves.
 236  */
 237
 238 static char    L[64];
 239 #define R   (L + 32)
 240 static char    tempL[32];
 241 static char    f[32];
 242
 243 /*
 244  * The combination of the key and the input, before selection.
 245  */
 246 static char    preS[48];
 247
 248 /*
 249  * The payoff: encrypt a block.
 250  */
 251
 252 static
 253 encrypt (block, edflag)
 254 char *block;
 255 {
 256        int i, ii;
 257        register t, j, k;
 258
 259        /*
 260         * First, permute the bits in the input
 261         */
 262        for (j=0; j<64; j++)
 263                L[j] = block[IP[j]-1];
 264        /*
 265         * Perform an encryption operation 16 times.
 266         */
 267        for (ii=0; ii<16; ii++) {
 268 /*             print_bits ("L R", L); */
 269                /*
 270                 * Set direction
 271                 */
 272                if (edflag)
 273                        i = 15-ii;
 274                else
 275                        i = ii;
 276                /*
 277                 * Save the R array,
 278                 * which will be the new L.
 279                 */
 280                for (j=0; j<32; j++)
 281                        tempL[j] = R[j];
 282                /*
 283                 * Expand R to 48 bits using the E selector;
 284                 * exclusive-or with the current key bits.
 285                 */
 286                for (j=0; j<48; j++)
 287                        preS[j] = R[E[j]-1] ^ KS[i][j];
 288                /*
 289                 * The pre-select bits are now considered
 290                 * in 8 groups of 6 bits each.
 291                 * The 8 selection functions map these
 292                 * 6-bit quantities into 4-bit quantities
 293                 * and the results permuted
 294                 * to make an f(R, K).
 295                 * The indexing into the selection functions
 296                 * is peculiar; it could be simplified by
 297                 * rewriting the tables.
 298                 */
 299                for (j=0; j<8; j++) {
 300                        t = 6*j;
 301                        k = S[j][(preS[t+0]<<5)+
 302                                (preS[t+1]<<3)+
 303                                (preS[t+2]<<2)+
 304                                (preS[t+3]<<1)+
 305                                (preS[t+4]<<0)+
 306                                (preS[t+5]<<4)];
 307                        t = 4*j;
 308                        f[t+0] = (k>>3)&01;
 309                        f[t+1] = (k>>2)&01;
 310                        f[t+2] = (k>>1)&01;
 311                        f[t+3] = (k>>0)&01;
 312                }
 313                /*
 314                 * The new R is L ^ f(R, K).
 315                 * The f here has to be permuted first, though.
 316                 */
 317                for (j=0; j<32; j++)
 318                        R[j] = L[j] ^ f[P[j]-1];
 319                /*
 320                 * Finally, the new L (the original R)
 321                 * is copied back.
 322                 */
 323                for (j=0; j<32; j++)
 324                        L[j] = tempL[j];
 325        }
 326        /*
 327         * The output L and R are reversed.
 328         */
 329        for (j=0; j<32; j++) {
 330                t = L[j];
 331                L[j] = R[j];
 332                R[j] = t;
 333        }
 334        /*
 335         * The final output
 336         * gets the inverse permutation of the very original.
 337         */
 338        for (j=0; j<64; j++)
 339                block[j] = L[FP[j]-1];
 340 }
 341
 342 static
 343 bytes_to_bits (bytes, bits)
 344     unsigned char   *bytes;
 345     char           *bits;
 346 {
 347     int            bit, byte, value;
 348
 349     for (byte = 0; byte < 8; byte++)
 350     {
 351        value = *bytes++;
 352        for (bit = 0; bit < 8; bit++)
 353            *bits++ = (value >> (7-bit)) & 1;
 354     }
 355 }
 356
 357 static
 358 bits_to_bytes (bits, bytes)
 359     char           *bits;
 360     unsigned char   *bytes;
 361 {
 362     int            bit, byte, value;
 363
 364     for (byte = 0; byte < 8; byte++)
 365     {
 366        value = 0;
 367        for (bit = 0; bit < 8; bit++)
 368            value |= *bits++ << (7-bit);
 369        *bytes++ = value;
 370     }
 371 }
 372
 373 /*
 374  * Interface compatible with Kerberos DES implementation
 375  */
 376
 377 # include   "Wrap.h"
 378
 379 /*ARGSUSED*/
 380 _XdmcpAuthSetup (key, schedule)
 381     auth_cblock                key;
 382     auth_wrapper_schedule      schedule;
 383 {
 384     char    expand_key[64];
 385
 386     bytes_to_bits ((unsigned char *) key, expand_key);
 387     setkey (expand_key);
 388 }
 389
 390 /*ARGSUSED*/
 391 _XdmcpAuthDoIt (input, output, schedule, edflag)
 392     auth_cblock                input, output;
 393     auth_wrapper_schedule      schedule;
 394     int                        edflag;
 395 {
 396     char    expand_input[64];
 397
 398     bytes_to_bits ((unsigned char *) input, expand_input);
 399     encrypt (expand_input, !edflag);
 400     bits_to_bytes (expand_input, (unsigned char *) output);
 401 }