Print this page
first pass

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/des/des_soft.c
          +++ new/usr/src/uts/common/des/des_soft.c
↓ open down ↓ 52 lines elided ↑ open up ↑
  53   53  #include <sys/types.h>
  54   54  #include <des/des.h>
  55   55  #include <des/softdes.h>
  56   56  #include <des/desdata.h>
  57   57  #include <sys/debug.h>
  58   58  
  59   59  static void des_setkey(u_char userkey[8], struct deskeydata *kd,
  60   60      unsigned int dir);
  61   61  static void des_encrypt(u_char *data, struct deskeydata *kd);
  62   62  
  63      -/* EXPORT DELETE START */
  64   63  #define btst(k, b)      (k[b >> 3] & (0x80 >> (b & 07)))
  65   64  #define BIT28   (1<<28)
  66      -/* EXPORT DELETE END */
  67   65  
  68   66  /*
  69   67   * Software encrypt or decrypt a block of data (multiple of 8 bytes)
  70   68   * Do the CBC ourselves if needed.
  71   69   */
  72   70  /* ARGSUSED */
  73   71  int
  74   72  _des_crypt(char *buf, size_t len, struct desparams *desp)
  75   73  {
  76      -/* EXPORT DELETE START */
  77   74          short i;
  78   75          uint_t mode;
  79   76          uint_t dir;
  80   77          char nextiv[8];
  81   78          struct deskeydata softkey;
  82   79  
  83   80          mode = desp->des_mode;
  84   81          dir = desp->des_dir;
  85   82          des_setkey(desp->des_key, &softkey, dir);
  86   83          while (len != 0) {
↓ open down ↓ 18 lines elided ↑ open up ↑
 105  102                                  break;
 106  103                          }
 107  104                          break;
 108  105                  case ECB:
 109  106                          des_encrypt((u_char *)buf, &softkey);
 110  107                          break;
 111  108                  }
 112  109                  buf += 8;
 113  110                  len -= 8;
 114  111          }
 115      -/* EXPORT DELETE END */
 116  112          return (1);
 117  113  }
 118  114  
 119  115  
 120  116  /*
 121  117   * Set the key and direction for an encryption operation
 122  118   * We build the 16 key entries here
 123  119   */
 124  120  /* ARGSUSED */
 125  121  static void
 126  122  des_setkey(u_char userkey[8], struct deskeydata *kd, unsigned int dir)
 127  123  {
 128      -/* EXPORT DELETE START */
 129  124          int32_t C, D;
 130  125          short i;
 131  126  
 132  127          /*
 133  128           * First, generate C and D by permuting
 134  129           * the key. The low order bit of each
 135  130           * 8-bit char is not used, so C and D are only 28
 136  131           * bits apiece.
 137  132           */
 138  133          {
↓ open down ↓ 60 lines elided ↑ open up ↑
 199  194                          for (k = 0; k < 6; k++) {
 200  195                                  if (C & (BIT28 >> PC2_C[bit]))
 201  196                                          c->long0 |= bbit >> k;
 202  197                                  if (D & (BIT28 >> PC2_D[bit]))
 203  198                                          c->long1 |= bbit >> k;
 204  199                                  bit++;
 205  200                          }
 206  201                          bbit >>= 8;
 207  202                  }
 208  203          }
 209      -/* EXPORT DELETE END */
 210  204  }
 211  205  
 212  206  
 213  207  
 214  208  /*
 215  209   * Do an encryption operation
 216  210   * Much pain is taken (with preprocessor) to avoid loops so the compiler
 217  211   * can do address arithmetic instead of doing it at runtime.
 218  212   * Note that the byte-to-chunk conversion is necessary to guarantee
 219  213   * processor byte-order independence.
 220  214   */
 221  215  /* ARGSUSED */
 222  216  static void
 223  217  des_encrypt(u_char *data, struct deskeydata *kd)
 224  218  {
 225      -/* EXPORT DELETE START */
 226  219          chunk_t work1, work2;
 227  220  
 228  221          /*
 229  222           * Initial permutation
 230  223           * and byte to chunk conversion
 231  224           */
 232  225          {
 233  226                  const uint32_t *lp;
 234  227                  uint32_t l0, l1, w;
 235  228                  short i, pbit;
↓ open down ↓ 157 lines elided ↑ open up ↑
 393  386                  work2.long1 = l1;
 394  387          }
 395  388          data[0] = work2.byte0;
 396  389          data[1] = work2.byte1;
 397  390          data[2] = work2.byte2;
 398  391          data[3] = work2.byte3;
 399  392          data[4] = work2.byte4;
 400  393          data[5] = work2.byte5;
 401  394          data[6] = work2.byte6;
 402  395          data[7] = work2.byte7;
 403      -/* EXPORT DELETE END */
 404  396  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX