Print this page
first pass


  82  * Copy multiple of 8 bytes
  83  */
  84 #define DESCOPY(src, dst, len) { \
  85         char *a = (char *)dst; \
  86         char *b = (char *)src; \
  87         int i; \
  88         for (i = (int)len; i > 0; i -= 8) { \
  89                 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
  90                 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
  91         } \
  92 }
  93 static int common_crypt(char *, char *, unsigned, unsigned, struct desparams *);
  94 
  95 /*
  96  * CBC mode encryption
  97  */
  98 int
  99 cbc_crypt(char *key, char *buf, size_t len, unsigned int mode, char *ivec)
 100 {
 101         int err = 0;
 102 
 103 /* EXPORT DELETE START */
 104         struct desparams dp;
 105 
 106         dp.des_mode = CBC;
 107         COPY8(ivec, dp.des_ivec);
 108         err = common_crypt(key, buf, len, mode, &dp);
 109         COPY8(dp.des_ivec, ivec);
 110 /* EXPORT DELETE END */
 111         return (err);
 112 }
 113 
 114 
 115 /*
 116  * ECB mode encryption
 117  */
 118 int
 119 ecb_crypt(char *key, char *buf, size_t len, unsigned int mode)
 120 {
 121         int ret = 0;
 122 
 123 /* EXPORT DELETE START */
 124         struct desparams dp;
 125 
 126         dp.des_mode = ECB;
 127         ret = common_crypt(key, buf, len, mode, &dp);
 128 /* EXPORT DELETE END */
 129         return (ret);
 130 }
 131 
 132 
 133 /* EXPORT DELETE START */
 134 /*
 135  * Common code to cbc_crypt() & ecb_crypt()
 136  */
 137 static int
 138 common_crypt(char *key, char *buf, unsigned len,
 139     unsigned mode, struct desparams *desp)
 140 {
 141         int desdev;
 142         int res;
 143         int g_desfd = UNOPENED;
 144 
 145         if ((len % 8) != 0 || len > DES_MAXDATA) {
 146                 return (DESERR_BADPARAM);
 147         }
 148         desp->des_dir =
 149             ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT;
 150 
 151         desdev = mode & DES_DEVMASK;
 152         COPY8(key, desp->des_key);
 153 #ifdef sun


 165                 if (len <= DES_QUICKLEN) {
 166                         DESCOPY(buf, desp->des_data, len);
 167                         res = ioctl(g_desfd, (int)DESIOCQUICK, (char *)desp);
 168                         DESCOPY(desp->des_data, buf, len);
 169                 } else {
 170                         desp->des_buf = (uchar_t *)buf;
 171                         res = ioctl(g_desfd, (int)DESIOCBLOCK, (char *)desp);
 172                 }
 173                 return (res == 0 ? DESERR_NONE : DESERR_HWERROR);
 174         }
 175 software:
 176 #endif
 177         /*
 178          * software
 179          */
 180         if (!__des_crypt(buf, len, desp)) {
 181                 return (DESERR_HWERROR);
 182         }
 183         return (desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE);
 184 }
 185 /* EXPORT DELETE END */


  82  * Copy multiple of 8 bytes
  83  */
  84 #define DESCOPY(src, dst, len) { \
  85         char *a = (char *)dst; \
  86         char *b = (char *)src; \
  87         int i; \
  88         for (i = (int)len; i > 0; i -= 8) { \
  89                 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
  90                 *a++ = *b++; *a++ = *b++; *a++ = *b++; *a++ = *b++; \
  91         } \
  92 }
  93 static int common_crypt(char *, char *, unsigned, unsigned, struct desparams *);
  94 
  95 /*
  96  * CBC mode encryption
  97  */
  98 int
  99 cbc_crypt(char *key, char *buf, size_t len, unsigned int mode, char *ivec)
 100 {
 101         int err = 0;


 102         struct desparams dp;
 103 
 104         dp.des_mode = CBC;
 105         COPY8(ivec, dp.des_ivec);
 106         err = common_crypt(key, buf, len, mode, &dp);
 107         COPY8(dp.des_ivec, ivec);

 108         return (err);
 109 }
 110 
 111 
 112 /*
 113  * ECB mode encryption
 114  */
 115 int
 116 ecb_crypt(char *key, char *buf, size_t len, unsigned int mode)
 117 {
 118         int ret = 0;


 119         struct desparams dp;
 120 
 121         dp.des_mode = ECB;
 122         ret = common_crypt(key, buf, len, mode, &dp);

 123         return (ret);
 124 }
 125 
 126 

 127 /*
 128  * Common code to cbc_crypt() & ecb_crypt()
 129  */
 130 static int
 131 common_crypt(char *key, char *buf, unsigned len,
 132     unsigned mode, struct desparams *desp)
 133 {
 134         int desdev;
 135         int res;
 136         int g_desfd = UNOPENED;
 137 
 138         if ((len % 8) != 0 || len > DES_MAXDATA) {
 139                 return (DESERR_BADPARAM);
 140         }
 141         desp->des_dir =
 142             ((mode & DES_DIRMASK) == DES_ENCRYPT) ? ENCRYPT : DECRYPT;
 143 
 144         desdev = mode & DES_DEVMASK;
 145         COPY8(key, desp->des_key);
 146 #ifdef sun


 158                 if (len <= DES_QUICKLEN) {
 159                         DESCOPY(buf, desp->des_data, len);
 160                         res = ioctl(g_desfd, (int)DESIOCQUICK, (char *)desp);
 161                         DESCOPY(desp->des_data, buf, len);
 162                 } else {
 163                         desp->des_buf = (uchar_t *)buf;
 164                         res = ioctl(g_desfd, (int)DESIOCBLOCK, (char *)desp);
 165                 }
 166                 return (res == 0 ? DESERR_NONE : DESERR_HWERROR);
 167         }
 168 software:
 169 #endif
 170         /*
 171          * software
 172          */
 173         if (!__des_crypt(buf, len, desp)) {
 174                 return (DESERR_HWERROR);
 175         }
 176         return (desdev == DES_SW ? DESERR_NONE : DESERR_NOHWDEVICE);
 177 }