lib/encrypt.c

   1 #include "squid.h"
   2
   3 /* encrypt.c - providing 56 bit DES encryption
   4  * Copyright (C) 1991 Jochen Obalek
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <time.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23
  24 #define BS  64
  25 #define BS2 32
  26 #define KS  48
  27 #define KS2 24
  28 #define IS  56
  29 #define IS2 28
  30
  31 static char schluessel[16][KS];
  32
  33 static char PC1[] = {
  34     56, 48, 40, 32, 24, 16, 8, 0,
  35     57, 49, 41, 33, 25, 17, 9, 1,
  36     58, 50, 42, 34, 26, 18, 10, 2,
  37     59, 51, 43, 35,
  38     62, 54, 46, 38, 30, 22, 14, 6,
  39     61, 53, 45, 37, 29, 21, 13, 5,
  40     60, 52, 44, 36, 28, 20, 12, 4,
  41     27, 19, 11, 3
  42 };
  43
  44 static char PC2[] = {
  45     13, 16, 10, 23, 0, 4, 2, 27,
  46     14, 5, 20, 9, 22, 18, 11, 3,
  47     25, 7, 15, 6, 26, 19, 12, 1,
  48     40, 51, 30, 36, 46, 54, 29, 39,
  49     50, 44, 32, 47, 43, 48, 38, 55,
  50     33, 52, 45, 41, 49, 35, 28, 31
  51 };
  52
  53 static char IP[] = {
  54     57, 49, 41, 33, 25, 17, 9, 1,
  55     59, 51, 43, 35, 27, 19, 11, 3,
  56     61, 53, 45, 37, 29, 21, 13, 5,
  57     63, 55, 47, 39, 31, 23, 15, 7,
  58     56, 48, 40, 32, 24, 16, 8, 0,
  59     58, 50, 42, 34, 26, 18, 10, 2,
  60     60, 52, 44, 36, 28, 20, 12, 4,
  61     62, 54, 46, 38, 30, 22, 14, 6
  62 };
  63
  64 static char EP[] = {
  65     7, 39, 15, 47, 23, 55, 31, 63,
  66     6, 38, 14, 46, 22, 54, 30, 62,
  67     5, 37, 13, 45, 21, 53, 29, 61,
  68     4, 36, 12, 44, 20, 52, 28, 60,
  69     3, 35, 11, 43, 19, 51, 27, 59,
  70     2, 34, 10, 42, 18, 50, 26, 58,
  71     1, 33, 9, 41, 17, 49, 25, 57,
  72     0, 32, 8, 40, 16, 48, 24, 56
  73 };
  74
  75 static char E0[] = {
  76     31, 0, 1, 2, 3, 4, 3, 4,
  77     5, 6, 7, 8, 7, 8, 9, 10,
  78     11, 12, 11, 12, 13, 14, 15, 16,
  79     15, 16, 17, 18, 19, 20, 19, 20,
  80     21, 22, 23, 24, 23, 24, 25, 26,
  81     27, 28, 27, 28, 29, 30, 31, 0
  82 };
  83
  84 static char E[KS];
  85
  86 static char PERM[] = {
  87     15, 6, 19, 20, 28, 11, 27, 16,
  88     0, 14, 22, 25, 4, 17, 30, 9,
  89     1, 7, 23, 13, 31, 26, 2, 8,
  90     18, 12, 29, 5, 21, 10, 3, 24
  91 };
  92
  93 static char S_BOX[][64] = {
  94     {
  95         14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,
  96         3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,
  97         4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,
  98         15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13
  99     },
 100     {
 101         15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,
 102         9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,
 103         0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,
 104         5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9
 105     },
 106     {
 107         10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,
 108         1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,
 109         13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,
 110         11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12
 111     },
 112     {
 113         7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,
 114         1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,
 115         10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,
 116         15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14
 117     },
 118     {
 119         2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,
 120         8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,
 121         4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,
 122         15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3
 123     },
 124     {
 125         12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,
 126         0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,
 127         9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,
 128         7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13
 129     },
 130     {
 131         4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,
 132         3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,
 133         1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,
 134         10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12
 135     },
 136     {
 137         13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,
 138         10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,
 139         7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,
 140         0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11
 141     }
 142 };
 143
 144 static void
 145 perm(a, e, pc, n)
 146 register char *a, *e;
 147 register char *pc;
 148 int n;
 149 {
 150     for (; n--; pc++, a++)
 151         *a = e[(int)*pc];
 152 }
 153
 154 static void
 155 crypt_main(nachr_l, nachr_r, schl)
 156 register char *nachr_l, *nachr_r;
 157 register char *schl;
 158 {
 159     char tmp[KS];
 160     register int sbval;
 161     register char *tp = tmp;
 162     register char *e = E;
 163     register int i, j;
 164
 165     for (i = 0; i < 8; i++) {
 166         for (j = 0, sbval = 0; j < 6; j++)
 167             sbval = (sbval << 1) | (nachr_r[(int)*e++] ^ *schl++);
 168         sbval = S_BOX[i][sbval];
 169         for (tp += 4, j = 4; j--; sbval >>= 1)
 170             *--tp = sbval & 1;
 171         tp += 4;
 172     }
 173
 174     e = PERM;
 175     for (i = 0; i < BS2; i++)
 176         *nachr_l++ ^= tmp[(int)*e++];
 177 }
 178
 179 void
 180 encrypt(char *nachr, int decr)
 181 {
 182     char (*schl)[KS] = decr ? schluessel + 15 : schluessel;
 183     char tmp[BS];
 184     int i;
 185
 186     perm(tmp, nachr, IP, BS);
 187
 188     for (i = 8; i--;) {
 189         crypt_main(tmp, tmp + BS2, *schl);
 190         if (decr)
 191             schl--;
 192         else
 193             schl++;
 194         crypt_main(tmp + BS2, tmp, *schl);
 195         if (decr)
 196             schl--;
 197         else
 198             schl++;
 199     }
 200
 201     perm(nachr, tmp, EP, BS);
 202 }
 203
 204 void
 205 setkey(char *schl)
 206 {
 207     char tmp1[IS];
 208     register unsigned int ls = 0x7efc;
 209     register int i, j, k;
 210     register int shval = 0;
 211     register char *akt_schl;
 212
 213     memcpy(E, E0, KS);
 214     perm(tmp1, schl, PC1, IS);
 215
 216     for (i = 0; i < 16; i++) {
 217         shval += 1 + (ls & 1);
 218         akt_schl = schluessel[i];
 219         for (j = 0; j < KS; j++) {
 220             if ((k = PC2[j]) >= IS2) {
 221                 if ((k += shval) >= IS)
 222                     k = (k - IS2) % IS2 + IS2;
 223             } else if ((k += shval) >= IS2)
 224                 k %= IS2;
 225             *akt_schl++ = tmp1[k];
 226         }
 227         ls >>= 1;
 228     }
 229 }
 230
 231 char *
 232 crypt(const char *wort, const char *salt)
 233 {
 234     static char retkey[14];
 235     char key[BS + 2];
 236     char *k;
 237     int tmp, keybyte;
 238     int i, j;
 239
 240     memset(key, 0, BS + 2);
 241
 242     for (k = key, i = 0; i < BS; i++) {
 243         if (!(keybyte = *wort++))
 244             break;
 245         k += 7;
 246         for (j = 0; j < 7; j++, i++) {
 247             *--k = keybyte & 1;
 248             keybyte >>= 1;
 249         }
 250         k += 8;
 251     }
 252
 253     setkey(key);
 254     memset(key, 0, BS + 2);
 255
 256     for (k = E, i = 0; i < 2; i++) {
 257         retkey[i] = keybyte = *salt++;
 258         if (keybyte > 'Z')
 259             keybyte -= 'a' - 'Z' - 1;
 260         if (keybyte > '9')
 261             keybyte -= 'A' - '9' - 1;
 262         keybyte -= '.';
 263
 264         for (j = 0; j < 6; j++, keybyte >>= 1, k++) {
 265             if (!(keybyte & 1))
 266                 continue;
 267             tmp = *k;
 268             *k = k[24];
 269             k[24] = tmp;
 270         }
 271     }
 272
 273     for (i = 0; i < 25; i++)
 274         encrypt(key, 0);
 275
 276     for (k = key, i = 0; i < 11; i++) {
 277         for (j = keybyte = 0; j < 6; j++) {
 278             keybyte <<= 1;
 279             keybyte |= *k++;
 280         }
 281
 282         keybyte += '.';
 283         if (keybyte > '9')
 284             keybyte += 'A' - '9' - 1;
 285         if (keybyte > 'Z')
 286             keybyte += 'a' - 'Z' - 1;
 287         retkey[i + 2] = keybyte;
 288     }
 289
 290     retkey[i + 2] = 0;
 291
 292     if (!retkey[1])
 293         retkey[1] = *retkey;
 294
 295     return retkey;
 296 }