Print this page
first pass

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/libcrypt/common/des_crypt.c
          +++ new/usr/src/lib/libcrypt/common/des_crypt.c
↓ open down ↓ 34 lines elided ↑ open up ↑
  35   35  
  36   36  #include <sys/types.h>
  37   37  #include <crypt.h>
  38   38  #include "des_soft.h"
  39   39  
  40   40  #include <stdlib.h>
  41   41  #include <thread.h>
  42   42  #include <pthread.h>
  43   43  #include <sys/types.h>
  44   44  
  45      -/* EXPORT DELETE START */
  46   45  /*
  47   46   * This program implements the
  48   47   * Proposed Federal Information Processing
  49   48   *  Data Encryption Standard.
  50   49   * See Federal Register, March 17, 1975 (40FR12134)
  51   50   */
  52   51  
  53   52  /*
  54   53   * Initial permutation,
  55   54   */
↓ open down ↓ 91 lines elided ↑ open up ↑
 147  146          24, 25, 26, 27, 28, 29,
 148  147          28, 29, 30, 31, 32, 1,
 149  148  };
 150  149  
 151  150  /*
 152  151   * Set up the key schedule from the key.
 153  152   */
 154  153  
 155  154  static mutex_t lock = DEFAULTMUTEX;
 156  155  
 157      -/* EXPORT DELETE END */
 158      -
 159      -
 160  156  static void
 161  157  des_setkey_nolock(const char *key)
 162  158  {
 163      -/* EXPORT DELETE START */
 164  159          int i, j, k;
 165  160          char t;
 166  161  
 167  162          /*
 168  163           * First, generate C and D by permuting
 169  164           * the key.  The low order bit of each
 170  165           * 8-bit char is not used, so C and D are only 28
 171  166           * bits apiece.
 172  167           */
 173  168          for (i = 0; i < 28; i++) {
↓ open down ↓ 23 lines elided ↑ open up ↑
 197  192                   * get Ki. Note C and D are concatenated.
 198  193                   */
 199  194                  for (j = 0; j < 24; j++) {
 200  195                          KS[i][j] = C[PC2_C[j]-1];
 201  196                          KS[i][j+24] = D[PC2_D[j]-28-1];
 202  197                  }
 203  198          }
 204  199  
 205  200          for (i = 0; i < 48; i++)
 206  201                  E[i] = e2[i];
 207      -/* EXPORT DELETE END */
 208  202  }
 209  203  
 210  204  void
 211  205  des_setkey(const char *key)
 212  206  {
 213      -/* EXPORT DELETE START */
 214  207          (void) mutex_lock(&lock);
 215  208          des_setkey_nolock(key);
 216  209          (void) mutex_unlock(&lock);
 217      -/* EXPORT DELETE END */
 218  210  }
 219  211  
 220      -/* EXPORT DELETE START */
 221  212  /*
 222  213   * The 8 selection functions.
 223  214   * For some reason, they give a 0-origin
 224  215   * index, unlike everything else.
 225  216   */
 226  217  static char S[8][64] = {
 227  218          14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
 228  219          0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
 229  220          4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
 230  221          15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
↓ open down ↓ 57 lines elided ↑ open up ↑
 288  279  static char f[32];
 289  280  
 290  281  /*
 291  282   * The combination of the key and the input, before selection.
 292  283   */
 293  284  static char preS[48];
 294  285  
 295  286  /*
 296  287   * The payoff: encrypt a block.
 297  288   */
 298      -/* EXPORT DELETE END */
 299  289  
 300  290  static void
 301  291  des_encrypt_nolock(char *block, int edflag)
 302  292  {
 303      -/* EXPORT DELETE START */
 304      -
 305  293          if (edflag)
 306  294                  (void) _des_decrypt1(block, L, IP, &L[32],
 307  295                      preS, E, KS, S, f, tempL, P, FP);
 308  296          else
 309  297                  (void) des_encrypt1(block, L, IP, &L[32],
 310  298                      preS, E, KS, S, f, tempL, P, FP);
 311      -
 312      -/* EXPORT DELETE END */
 313  299  }
 314  300  
 315  301  void
 316  302  des_encrypt(char *block, int edflag)
 317  303  {
 318      -/* EXPORT DELETE START */
 319  304          (void) mutex_lock(&lock);
 320  305          des_encrypt_nolock(block, edflag);
 321  306          (void) mutex_unlock(&lock);
 322      -/* EXPORT DELETE END */
 323  307  }
 324  308  
 325  309  
 326  310  
 327  311  #define IOBUF_SIZE      16
 328  312  
 329  313  static char *
 330  314  _get_iobuf(thread_key_t *keyp, unsigned size)
 331  315  {
 332  316          char *iobuf;
↓ open down ↓ 7 lines elided ↑ open up ↑
 340  324                                  (void) free(iobuf);
 341  325                          iobuf = NULL;
 342  326                  }
 343  327          }
 344  328          return (iobuf);
 345  329  }
 346  330  
 347  331  char *
 348  332  des_crypt(const char *pw, const char *salt)
 349  333  {
 350      -/* EXPORT DELETE START */
 351  334          int     i, j;
 352  335          char    c, temp;
 353  336          char block[66];
 354  337          static thread_key_t key = THR_ONCE_KEY;
 355  338          char *iobuf = _get_iobuf(&key, IOBUF_SIZE);
 356  339  
 357  340          (void) mutex_lock(&lock);
 358  341          for (i = 0; i < 66; i++)
 359  342                  block[i] = 0;
 360  343          for (i = 0; (c = *pw) && (i < 64); pw++) {
↓ open down ↓ 38 lines elided ↑ open up ↑
 399  382                          c += 7;
 400  383                  if (c > 'Z')
 401  384                          c += 6;
 402  385                  iobuf[i+2] = (char)c;
 403  386          }
 404  387          iobuf[i+2] = 0;
 405  388          if (iobuf[1] == 0)
 406  389                  iobuf[1] = iobuf[0];
 407  390          (void) mutex_unlock(&lock);
 408  391          return (iobuf);
 409      -#if 0
 410      -/* EXPORT DELETE END */
 411      -        return (0);
 412      -/* EXPORT DELETE START */
 413      -#endif
 414      -/* EXPORT DELETE END */
 415  392  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX