libcli/auth/smbdes.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    a partial implementation of DES designed for use in the
   5    SMB authentication protocol
   6
   7    Copyright (C) Andrew Tridgell 1998
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "libcli/auth/libcli_auth.h"
  25
  26 #include <gnutls/gnutls.h>
  27 #include <gnutls/crypto.h>
  28
  29 /* NOTES:
  30
  31    This code makes no attempt to be fast! In fact, it is a very
  32    slow implementation
  33
  34    This code is NOT a complete DES implementation. It implements only
  35    the minimum necessary for SMB authentication, as used by all SMB
  36    products (including every copy of Microsoft Windows95 ever sold)
  37
  38    In particular, it can only do a unchained forward DES pass. This
  39    means it is not possible to use this code for encryption/decryption
  40    of data, instead it is only useful as a "hash" algorithm.
  41
  42    There is no entry point into this code that allows normal DES operation.
  43
  44    I believe this means that this code does not come under ITAR
  45    regulations but this is NOT a legal opinion. If you are concerned
  46    about the applicability of ITAR regulations to this code then you
  47    should confirm it for yourself (and maybe let me know if you come
  48    up with a different answer to the one above)
  49 */
  50
  51
  52 static const uint8_t perm1[56] = {57, 49, 41, 33, 25, 17,  9,
  53                          1, 58, 50, 42, 34, 26, 18,
  54                         10,  2, 59, 51, 43, 35, 27,
  55                         19, 11,  3, 60, 52, 44, 36,
  56                         63, 55, 47, 39, 31, 23, 15,
  57                          7, 62, 54, 46, 38, 30, 22,
  58                         14,  6, 61, 53, 45, 37, 29,
  59                         21, 13,  5, 28, 20, 12,  4};
  60
  61 static const uint8_t perm2[48] = {14, 17, 11, 24,  1,  5,
  62                          3, 28, 15,  6, 21, 10,
  63                         23, 19, 12,  4, 26,  8,
  64                         16,  7, 27, 20, 13,  2,
  65                         41, 52, 31, 37, 47, 55,
  66                         30, 40, 51, 45, 33, 48,
  67                         44, 49, 39, 56, 34, 53,
  68                         46, 42, 50, 36, 29, 32};
  69
  70 static const uint8_t perm3[64] = {58, 50, 42, 34, 26, 18, 10,  2,
  71                         60, 52, 44, 36, 28, 20, 12,  4,
  72                         62, 54, 46, 38, 30, 22, 14,  6,
  73                         64, 56, 48, 40, 32, 24, 16,  8,
  74                         57, 49, 41, 33, 25, 17,  9,  1,
  75                         59, 51, 43, 35, 27, 19, 11,  3,
  76                         61, 53, 45, 37, 29, 21, 13,  5,
  77                         63, 55, 47, 39, 31, 23, 15,  7};
  78
  79 static const uint8_t perm4[48] = {   32,  1,  2,  3,  4,  5,
  80                             4,  5,  6,  7,  8,  9,
  81                             8,  9, 10, 11, 12, 13,
  82                            12, 13, 14, 15, 16, 17,
  83                            16, 17, 18, 19, 20, 21,
  84                            20, 21, 22, 23, 24, 25,
  85                            24, 25, 26, 27, 28, 29,
  86                            28, 29, 30, 31, 32,  1};
  87
  88 static const uint8_t perm5[32] = {      16,  7, 20, 21,
  89                               29, 12, 28, 17,
  90                                1, 15, 23, 26,
  91                                5, 18, 31, 10,
  92                                2,  8, 24, 14,
  93                               32, 27,  3,  9,
  94                               19, 13, 30,  6,
  95                               22, 11,  4, 25};
  96
  97
  98 static const uint8_t perm6[64] ={ 40,  8, 48, 16, 56, 24, 64, 32,
  99                         39,  7, 47, 15, 55, 23, 63, 31,
 100                         38,  6, 46, 14, 54, 22, 62, 30,
 101                         37,  5, 45, 13, 53, 21, 61, 29,
 102                         36,  4, 44, 12, 52, 20, 60, 28,
 103                         35,  3, 43, 11, 51, 19, 59, 27,
 104                         34,  2, 42, 10, 50, 18, 58, 26,
 105                         33,  1, 41,  9, 49, 17, 57, 25};
 106
 107
 108 static const uint8_t sc[16] = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
 109
 110 static const uint8_t sbox[8][4][16] = {
 111         {{14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7},
 112          {0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8},
 113          {4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0},
 114          {15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13}},
 115
 116         {{15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10},
 117          {3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5},
 118          {0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15},
 119          {13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9}},
 120
 121         {{10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8},
 122          {13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1},
 123          {13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7},
 124          {1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12}},
 125
 126         {{7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15},
 127          {13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9},
 128          {10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4},
 129          {3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14}},
 130
 131         {{2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9},
 132          {14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6},
 133          {4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14},
 134          {11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3}},
 135
 136         {{12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11},
 137          {10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8},
 138          {9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6},
 139          {4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13}},
 140
 141         {{4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1},
 142          {13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6},
 143          {1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2},
 144          {6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12}},
 145
 146         {{13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7},
 147          {1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2},
 148          {7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8},
 149          {2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11}}};
 150
 151 static void permute(char *out, const char *in, const uint8_t *p, int n)
 152 {
 153         int i;
 154         for (i=0;i<n;i++)
 155                 out[i] = in[p[i]-1];
 156 }
 157
 158 static void lshift(char *d, int count, int n)
 159 {
 160         char out[64];
 161         int i;
 162         for (i=0;i<n;i++)
 163                 out[i] = d[(i+count)%n];
 164         for (i=0;i<n;i++)
 165                 d[i] = out[i];
 166 }
 167
 168 static void concat(char *out, char *in1, char *in2, int l1, int l2)
 169 {
 170         while (l1--)
 171                 *out++ = *in1++;
 172         while (l2--)
 173                 *out++ = *in2++;
 174 }
 175
 176 static void xor(char *out, char *in1, char *in2, int n)
 177 {
 178         int i;
 179         for (i=0;i<n;i++)
 180                 out[i] = in1[i] ^ in2[i];
 181 }
 182
 183 static void dohash(char *out, char *in, char *key, int forw)
 184 {
 185         int i, j, k;
 186         char pk1[56];
 187         char c[28];
 188         char d[28];
 189         char cd[56];
 190         char ki[16][48];
 191         char pd1[64];
 192         char l[32], r[32];
 193         char rl[64];
 194
 195         permute(pk1, key, perm1, 56);
 196
 197         for (i=0;i<28;i++)
 198                 c[i] = pk1[i];
 199         for (i=0;i<28;i++)
 200                 d[i] = pk1[i+28];
 201
 202         for (i=0;i<16;i++) {
 203                 lshift(c, sc[i], 28);
 204                 lshift(d, sc[i], 28);
 205
 206                 concat(cd, c, d, 28, 28);
 207                 permute(ki[i], cd, perm2, 48);
 208         }
 209
 210         permute(pd1, in, perm3, 64);
 211
 212         for (j=0;j<32;j++) {
 213                 l[j] = pd1[j];
 214                 r[j] = pd1[j+32];
 215         }
 216
 217         for (i=0;i<16;i++) {
 218                 char er[48];
 219                 char erk[48];
 220                 char b[8][6];
 221                 char cb[32];
 222                 char pcb[32];
 223                 char r2[32];
 224
 225                 permute(er, r, perm4, 48);
 226
 227                 xor(erk, er, ki[forw ? i : 15 - i], 48);
 228
 229                 for (j=0;j<8;j++)
 230                         for (k=0;k<6;k++)
 231                                 b[j][k] = erk[j*6 + k];
 232
 233                 for (j=0;j<8;j++) {
 234                         int m, n;
 235                         m = (b[j][0]<<1) | b[j][5];
 236
 237                         n = (b[j][1]<<3) | (b[j][2]<<2) | (b[j][3]<<1) | b[j][4];
 238
 239                         for (k=0;k<4;k++)
 240                                 b[j][k] = (sbox[j][m][n] & (1<<(3-k)))?1:0;
 241                 }
 242
 243                 for (j=0;j<8;j++)
 244                         for (k=0;k<4;k++)
 245                                 cb[j*4+k] = b[j][k];
 246                 permute(pcb, cb, perm5, 32);
 247
 248                 xor(r2, l, pcb, 32);
 249
 250                 for (j=0;j<32;j++)
 251                         l[j] = r[j];
 252
 253                 for (j=0;j<32;j++)
 254                         r[j] = r2[j];
 255         }
 256
 257         concat(rl, r, l, 32, 32);
 258
 259         permute(out, rl, perm6, 64);
 260 }
 261
 262 static void str_to_key(const uint8_t *str,uint8_t *key)
 263 {
 264         int i;
 265
 266         key[0] = str[0]>>1;
 267         key[1] = ((str[0]&0x01)<<6) | (str[1]>>2);
 268         key[2] = ((str[1]&0x03)<<5) | (str[2]>>3);
 269         key[3] = ((str[2]&0x07)<<4) | (str[3]>>4);
 270         key[4] = ((str[3]&0x0F)<<3) | (str[4]>>5);
 271         key[5] = ((str[4]&0x1F)<<2) | (str[5]>>6);
 272         key[6] = ((str[5]&0x3F)<<1) | (str[6]>>7);
 273         key[7] = str[6]&0x7F;
 274         for (i=0;i<8;i++) {
 275                 key[i] = (key[i]<<1);
 276         }
 277 }
 278
 279 int des_crypt56_gnutls(uint8_t out[8], const uint8_t in[8],
 280                        const uint8_t key_in[7],
 281                        enum samba_gnutls_direction encrypt)
 282 {
 283         /*
 284          * A single block DES-CBC op, with an all-zero IV is the same as DES
 285          * because the IV is combined with the data using XOR.
 286          * This allows us to use GNUTLS_CIPHER_DES_CBC from GnuTLS and not
 287          * implement single-DES in Samba.
 288          *
 289          * In turn this is used to build DES-ECB, which is used
 290          * for example in the NTLM challenge/response calculation.
 291          */
 292         static const uint8_t iv8[8];
 293         gnutls_datum_t iv = { discard_const(iv8), 8 };
 294         gnutls_datum_t key;
 295         gnutls_cipher_hd_t ctx;
 296         uint8_t key2[8];
 297         uint8_t outb[8];
 298         int ret;
 299
 300         memset(out, 0, 8);
 301
 302         str_to_key(key_in, key2);
 303
 304         key.data = key2;
 305         key.size = 8;
 306
 307         ret = gnutls_global_init();
 308         if (ret != 0) {
 309                 return ret;
 310         }
 311
 312         ret = gnutls_cipher_init(&ctx, GNUTLS_CIPHER_DES_CBC, &key, &iv);
 313         if (ret != 0) {
 314                 return ret;
 315         }
 316
 317         memcpy(outb, in, 8);
 318         if (encrypt == SAMBA_GNUTLS_ENCRYPT) {
 319                 ret = gnutls_cipher_encrypt(ctx, outb, 8);
 320         } else {
 321                 ret = gnutls_cipher_decrypt(ctx, outb, 8);
 322         }
 323
 324         if (ret == 0) {
 325                 memcpy(out, outb, 8);
 326         }
 327
 328         gnutls_cipher_deinit(ctx);
 329
 330         return ret;
 331 }
 332
 333 /*
 334   basic des crypt using a 56 bit (7 byte) key
 335 */
 336 void des_crypt56(uint8_t out[8], const uint8_t in[8], const uint8_t key[7], int forw)
 337 {
 338         int i;
 339         char outb[64];
 340         char inb[64];
 341         char keyb[64];
 342         uint8_t key2[8];
 343
 344         str_to_key(key, key2);
 345
 346         for (i=0;i<64;i++) {
 347                 inb[i] = (in[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
 348                 keyb[i] = (key2[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
 349                 outb[i] = 0;
 350         }
 351
 352         dohash(outb, inb, keyb, forw);
 353
 354         for (i=0;i<8;i++) {
 355                 out[i] = 0;
 356         }
 357
 358         for (i=0;i<64;i++) {
 359                 if (outb[i])
 360                         out[i/8] |= (1<<(7-(i%8)));
 361         }
 362 }
 363
 364 int E_P16(const uint8_t *p14,uint8_t *p16)
 365 {
 366         const uint8_t sp8[8] = {0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25};
 367         int ret;
 368
 369         ret = des_crypt56_gnutls(p16, sp8, p14, SAMBA_GNUTLS_ENCRYPT);
 370         if (ret != 0) {
 371                 return ret;
 372         }
 373
 374         return des_crypt56_gnutls(p16+8, sp8, p14+7, SAMBA_GNUTLS_ENCRYPT);
 375 }
 376
 377 int E_P24(const uint8_t *p21, const uint8_t *c8, uint8_t *p24)
 378 {
 379         int ret;
 380
 381         ret = des_crypt56_gnutls(p24, c8, p21, SAMBA_GNUTLS_ENCRYPT);
 382         if (ret != 0) {
 383                 return ret;
 384         }
 385
 386         ret = des_crypt56_gnutls(p24+8, c8, p21+7, SAMBA_GNUTLS_ENCRYPT);
 387         if (ret != 0) {
 388                 return ret;
 389         }
 390
 391         return des_crypt56_gnutls(p24+16, c8, p21+14, SAMBA_GNUTLS_ENCRYPT);
 392 }
 393
 394 int E_old_pw_hash( uint8_t *p14, const uint8_t *in, uint8_t *out)
 395 {
 396         int ret;
 397
 398         ret = des_crypt56_gnutls(out, in, p14, SAMBA_GNUTLS_ENCRYPT);
 399         if (ret != 0) {
 400                 return ret;
 401         }
 402
 403         return des_crypt56_gnutls(out+8, in+8, p14+7, SAMBA_GNUTLS_ENCRYPT);
 404 }
 405
 406 /* des encryption with a 128 bit key */
 407 int des_crypt128(uint8_t out[8], const uint8_t in[8], const uint8_t key[16])
 408 {
 409         uint8_t buf[8];
 410         int ret;
 411
 412         ret = des_crypt56_gnutls(buf, in, key, SAMBA_GNUTLS_ENCRYPT);
 413         if (ret != 0) {
 414                 return ret;
 415         }
 416
 417         return des_crypt56_gnutls(out, buf, key+9, SAMBA_GNUTLS_ENCRYPT);
 418 }
 419
 420 /* des encryption with a 112 bit (14 byte) key */
 421 int des_crypt112(uint8_t out[8], const uint8_t in[8], const uint8_t key[14],
 422                  enum samba_gnutls_direction encrypt)
 423 {
 424         uint8_t buf[8];
 425         int ret;
 426
 427         if (encrypt == SAMBA_GNUTLS_ENCRYPT) {
 428                 ret = des_crypt56_gnutls(buf, in, key, SAMBA_GNUTLS_ENCRYPT);
 429                 if (ret != 0) {
 430                         return ret;
 431                 }
 432
 433                 return des_crypt56_gnutls(out, buf, key+7, SAMBA_GNUTLS_ENCRYPT);
 434         }
 435
 436         ret = des_crypt56_gnutls(buf, in, key+7, SAMBA_GNUTLS_DECRYPT);
 437         if (ret != 0) {
 438                 return ret;
 439         }
 440
 441         return des_crypt56_gnutls(out, buf, key, SAMBA_GNUTLS_DECRYPT);
 442 }
 443
 444 /* des encryption of a 16 byte lump of data with a 112 bit key */
 445 void des_crypt112_16(uint8_t out[16], const uint8_t in[16], const uint8_t key[14], int forw)
 446 {
 447         des_crypt56(out, in, key, forw);
 448         des_crypt56(out + 8, in + 8, key+7, forw);
 449 }
 450
 451 /* Decode a sam password hash into a password.  The password hash is the
 452    same method used to store passwords in the NT registry.  The DES key
 453    used is based on the RID of the user. */
 454 int sam_rid_crypt(unsigned int rid, const uint8_t *in, uint8_t *out,
 455                   enum samba_gnutls_direction encrypt)
 456 {
 457         uint8_t s[14];
 458         int ret;
 459
 460         s[0] = s[4] = s[8] = s[12] = (uint8_t)(rid & 0xFF);
 461         s[1] = s[5] = s[9] = s[13] = (uint8_t)((rid >> 8) & 0xFF);
 462         s[2] = s[6] = s[10]        = (uint8_t)((rid >> 16) & 0xFF);
 463         s[3] = s[7] = s[11]        = (uint8_t)((rid >> 24) & 0xFF);
 464
 465         ret = des_crypt56_gnutls(out, in, s, encrypt);
 466         if (ret != 0) {
 467                 return ret;
 468         }
 469         return des_crypt56_gnutls(out+8, in+8, s+7, encrypt);
 470 }