source3/passdb/secrets.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Copyright (C) Andrew Tridgell 1992-2001
   4    Copyright (C) Andrew Bartlett      2002
   5    Copyright (C) Rafal Szczesniak     2002
   6    Copyright (C) Tim Potter           2001
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 /* the Samba secrets database stores any generated, private information
  23    such as the local SID and machine trust password */
  24
  25 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_PASSDB
  29
  30 static TDB_CONTEXT *tdb;
  31
  32 /* Urrrg. global.... */
  33 bool global_machine_password_needs_changing;
  34
  35 /**
  36  * Use a TDB to store an incrementing random seed.
  37  *
  38  * Initialised to the current pid, the very first time Samba starts,
  39  * and incremented by one each time it is needed.
  40  *
  41  * @note Not called by systems with a working /dev/urandom.
  42  */
  43 static void get_rand_seed(int *new_seed)
  44 {
  45         *new_seed = sys_getpid();
  46         if (tdb) {
  47                 tdb_change_int32_atomic(tdb, "INFO/random_seed", new_seed, 1);
  48         }
  49 }
  50
  51 /* open up the secrets database */
  52 bool secrets_init(void)
  53 {
  54         TALLOC_CTX *ctx;
  55         char *fname = NULL;
  56         unsigned char dummy;
  57
  58         if (tdb)
  59                 return True;
  60
  61         ctx = talloc_init("secrets_init");
  62         if (!ctx) {
  63                 return false;
  64         }
  65         fname = talloc_asprintf(ctx,
  66                         "%s/secrets.tdb",
  67                         lp_private_dir());
  68         if (!fname) {
  69                 TALLOC_FREE(ctx);
  70                 return false;
  71         }
  72
  73         tdb = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
  74
  75         if (!tdb) {
  76                 DEBUG(0,("Failed to open %s\n", fname));
  77                 TALLOC_FREE(ctx);
  78                 return False;
  79         }
  80
  81         TALLOC_FREE(ctx);
  82
  83         /**
  84          * Set a reseed function for the crypto random generator
  85          *
  86          * This avoids a problem where systems without /dev/urandom
  87          * could send the same challenge to multiple clients
  88          */
  89         set_rand_reseed_callback(get_rand_seed);
  90
  91         /* Ensure that the reseed is done now, while we are root, etc */
  92         generate_random_buffer(&dummy, sizeof(dummy));
  93
  94         return True;
  95 }
  96
  97 /* read a entry from the secrets database - the caller must free the result
  98    if size is non-null then the size of the entry is put in there
  99  */
 100 void *secrets_fetch(const char *key, size_t *size)
 101 {
 102         TDB_DATA dbuf;
 103         secrets_init();
 104         if (!tdb)
 105                 return NULL;
 106         dbuf = tdb_fetch(tdb, string_tdb_data(key));
 107         if (size)
 108                 *size = dbuf.dsize;
 109         return dbuf.dptr;
 110 }
 111
 112 /* store a secrets entry
 113  */
 114 bool secrets_store(const char *key, const void *data, size_t size)
 115 {
 116         secrets_init();
 117         if (!tdb)
 118                 return False;
 119         return tdb_trans_store(tdb, string_tdb_data(key),
 120                                make_tdb_data((const uint8 *)data, size),
 121                                TDB_REPLACE) == 0;
 122 }
 123
 124
 125 /* delete a secets database entry
 126  */
 127 bool secrets_delete(const char *key)
 128 {
 129         secrets_init();
 130         if (!tdb)
 131                 return False;
 132         return tdb_trans_delete(tdb, string_tdb_data(key)) == 0;
 133 }
 134
 135 bool secrets_store_domain_sid(const char *domain, const DOM_SID *sid)
 136 {
 137         fstring key;
 138         bool ret;
 139
 140         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_SID, domain);
 141         strupper_m(key);
 142         ret = secrets_store(key, sid, sizeof(DOM_SID));
 143
 144         /* Force a re-query, in case we modified our domain */
 145         if (ret)
 146                 reset_global_sam_sid();
 147         return ret;
 148 }
 149
 150 bool secrets_fetch_domain_sid(const char *domain, DOM_SID *sid)
 151 {
 152         DOM_SID *dyn_sid;
 153         fstring key;
 154         size_t size = 0;
 155
 156         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_SID, domain);
 157         strupper_m(key);
 158         dyn_sid = (DOM_SID *)secrets_fetch(key, &size);
 159
 160         if (dyn_sid == NULL)
 161                 return False;
 162
 163         if (size != sizeof(DOM_SID)) {
 164                 SAFE_FREE(dyn_sid);
 165                 return False;
 166         }
 167
 168         *sid = *dyn_sid;
 169         SAFE_FREE(dyn_sid);
 170         return True;
 171 }
 172
 173 bool secrets_store_domain_guid(const char *domain, struct GUID *guid)
 174 {
 175         fstring key;
 176
 177         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_GUID, domain);
 178         strupper_m(key);
 179         return secrets_store(key, guid, sizeof(struct GUID));
 180 }
 181
 182 bool secrets_fetch_domain_guid(const char *domain, struct GUID *guid)
 183 {
 184         struct GUID *dyn_guid;
 185         fstring key;
 186         size_t size = 0;
 187         struct GUID new_guid;
 188
 189         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_GUID, domain);
 190         strupper_m(key);
 191         dyn_guid = (struct GUID *)secrets_fetch(key, &size);
 192
 193         if (!dyn_guid) {
 194                 if (lp_server_role() == ROLE_DOMAIN_PDC) {
 195                         smb_uuid_generate_random(&new_guid);
 196                         if (!secrets_store_domain_guid(domain, &new_guid))
 197                                 return False;
 198                         dyn_guid = (struct GUID *)secrets_fetch(key, &size);
 199                 }
 200                 if (dyn_guid == NULL) {
 201                         return False;
 202                 }
 203         }
 204
 205         if (size != sizeof(struct GUID)) {
 206                 DEBUG(1,("UUID size %d is wrong!\n", (int)size));
 207                 SAFE_FREE(dyn_guid);
 208                 return False;
 209         }
 210
 211         *guid = *dyn_guid;
 212         SAFE_FREE(dyn_guid);
 213         return True;
 214 }
 215
 216 /**
 217  * Form a key for fetching the machine trust account password
 218  *
 219  * @param domain domain name
 220  *
 221  * @return stored password's key
 222  **/
 223 static const char *trust_keystr(const char *domain)
 224 {
 225         char *keystr;
 226
 227         keystr = talloc_asprintf(talloc_tos(), "%s/%s",
 228                                  SECRETS_MACHINE_ACCT_PASS, domain);
 229         SMB_ASSERT(keystr != NULL);
 230
 231         strupper_m(keystr);
 232
 233         return keystr;
 234 }
 235
 236 /**
 237  * Form a key for fetching a trusted domain password
 238  *
 239  * @param domain trusted domain name
 240  *
 241  * @return stored password's key
 242  **/
 243 static char *trustdom_keystr(const char *domain)
 244 {
 245         char *keystr;
 246
 247         keystr = talloc_asprintf(talloc_tos(), "%s/%s",
 248                                  SECRETS_DOMTRUST_ACCT_PASS, domain);
 249         SMB_ASSERT(keystr != NULL);
 250         strupper_m(keystr);
 251
 252         return keystr;
 253 }
 254
 255 /************************************************************************
 256  Lock the trust password entry.
 257 ************************************************************************/
 258
 259 bool secrets_lock_trust_account_password(const char *domain, bool dolock)
 260 {
 261         if (!tdb)
 262                 return False;
 263
 264         if (dolock)
 265                 return (tdb_lock_bystring(tdb, trust_keystr(domain)) == 0);
 266         else
 267                 tdb_unlock_bystring(tdb, trust_keystr(domain));
 268         return True;
 269 }
 270
 271 /************************************************************************
 272  Routine to get the default secure channel type for trust accounts
 273 ************************************************************************/
 274
 275 uint32 get_default_sec_channel(void)
 276 {
 277         if (lp_server_role() == ROLE_DOMAIN_BDC ||
 278             lp_server_role() == ROLE_DOMAIN_PDC) {
 279                 return SEC_CHAN_BDC;
 280         } else {
 281                 return SEC_CHAN_WKSTA;
 282         }
 283 }
 284
 285 /************************************************************************
 286  Routine to get the trust account password for a domain.
 287  This only tries to get the legacy hashed version of the password.
 288  The user of this function must have locked the trust password file using
 289  the above secrets_lock_trust_account_password().
 290 ************************************************************************/
 291
 292 bool secrets_fetch_trust_account_password_legacy(const char *domain,
 293                                                  uint8 ret_pwd[16],
 294                                                  time_t *pass_last_set_time,
 295                                                  uint32 *channel)
 296 {
 297         struct machine_acct_pass *pass;
 298         size_t size = 0;
 299
 300         if (!(pass = (struct machine_acct_pass *)secrets_fetch(
 301                       trust_keystr(domain), &size))) {
 302                 DEBUG(5, ("secrets_fetch failed!\n"));
 303                 return False;
 304         }
 305
 306         if (size != sizeof(*pass)) {
 307                 DEBUG(0, ("secrets were of incorrect size!\n"));
 308                 return False;
 309         }
 310
 311         if (pass_last_set_time) {
 312                 *pass_last_set_time = pass->mod_time;
 313         }
 314         memcpy(ret_pwd, pass->hash, 16);
 315
 316         if (channel) {
 317                 *channel = get_default_sec_channel();
 318         }
 319
 320         /* Test if machine password has expired and needs to be changed */
 321         if (lp_machine_password_timeout()) {
 322                 if (pass->mod_time > 0 && time(NULL) > (pass->mod_time +
 323                                 (time_t)lp_machine_password_timeout())) {
 324                         global_machine_password_needs_changing = True;
 325                 }
 326         }
 327
 328         SAFE_FREE(pass);
 329         return True;
 330 }
 331
 332 /************************************************************************
 333  Routine to get the trust account password for a domain.
 334  The user of this function must have locked the trust password file using
 335  the above secrets_lock_trust_account_password().
 336 ************************************************************************/
 337
 338 bool secrets_fetch_trust_account_password(const char *domain, uint8 ret_pwd[16],
 339                                           time_t *pass_last_set_time,
 340                                           uint32 *channel)
 341 {
 342         char *plaintext;
 343
 344         plaintext = secrets_fetch_machine_password(domain, pass_last_set_time,
 345                                                    channel);
 346         if (plaintext) {
 347                 DEBUG(4,("Using cleartext machine password\n"));
 348                 E_md4hash(plaintext, ret_pwd);
 349                 SAFE_FREE(plaintext);
 350                 return True;
 351         }
 352
 353         return secrets_fetch_trust_account_password_legacy(domain, ret_pwd,
 354                                                            pass_last_set_time,
 355                                                            channel);
 356 }
 357
 358 /**
 359  * Pack SID passed by pointer
 360  *
 361  * @param pack_buf pointer to buffer which is to be filled with packed data
 362  * @param bufsize size of packing buffer
 363  * @param sid pointer to sid to be packed
 364  *
 365  * @return length of the packed representation of the whole structure
 366  **/
 367 static size_t tdb_sid_pack(uint8 *pack_buf, int bufsize, DOM_SID* sid)
 368 {
 369         int idx;
 370         size_t len = 0;
 371         uint8 *p = pack_buf;
 372         int remaining_space = pack_buf ? bufsize : 0;
 373
 374         if (!sid) {
 375                 return -1;
 376         }
 377
 378         len += tdb_pack(p, remaining_space, "bb", sid->sid_rev_num,
 379                         sid->num_auths);
 380         if (pack_buf) {
 381                 p = pack_buf + len;
 382                 remaining_space = bufsize - len;
 383         }
 384
 385         for (idx = 0; idx < 6; idx++) {
 386                 len += tdb_pack(p, remaining_space, "b",
 387                                 sid->id_auth[idx]);
 388                 if (pack_buf) {
 389                         p = pack_buf + len;
 390                         remaining_space = bufsize - len;
 391                 }
 392         }
 393
 394         for (idx = 0; idx < MAXSUBAUTHS; idx++) {
 395                 len += tdb_pack(p, remaining_space, "d",
 396                                 sid->sub_auths[idx]);
 397                 if (pack_buf) {
 398                         p = pack_buf + len;
 399                         remaining_space = bufsize - len;
 400                 }
 401         }
 402
 403         return len;
 404 }
 405
 406 /**
 407  * Unpack SID into a pointer
 408  *
 409  * @param pack_buf pointer to buffer with packed representation
 410  * @param bufsize size of the buffer
 411  * @param sid pointer to sid structure to be filled with unpacked data
 412  *
 413  * @return size of structure unpacked from buffer
 414  **/
 415 static size_t tdb_sid_unpack(uint8 *pack_buf, int bufsize, DOM_SID* sid)
 416 {
 417         int idx, len = 0;
 418
 419         if (!sid || !pack_buf) return -1;
 420
 421         len += tdb_unpack(pack_buf + len, bufsize - len, "bb",
 422                           &sid->sid_rev_num, &sid->num_auths);
 423
 424         for (idx = 0; idx < 6; idx++) {
 425                 len += tdb_unpack(pack_buf + len, bufsize - len, "b",
 426                                   &sid->id_auth[idx]);
 427         }
 428
 429         for (idx = 0; idx < MAXSUBAUTHS; idx++) {
 430                 len += tdb_unpack(pack_buf + len, bufsize - len, "d",
 431                                   &sid->sub_auths[idx]);
 432         }
 433
 434         return len;
 435 }
 436
 437 /**
 438  * Pack TRUSTED_DOM_PASS passed by pointer
 439  *
 440  * @param pack_buf pointer to buffer which is to be filled with packed data
 441  * @param bufsize size of the buffer
 442  * @param pass pointer to trusted domain password to be packed
 443  *
 444  * @return length of the packed representation of the whole structure
 445  **/
 446 static size_t tdb_trusted_dom_pass_pack(uint8 *pack_buf, int bufsize,
 447                                         TRUSTED_DOM_PASS* pass)
 448 {
 449         int idx, len = 0;
 450         uint8 *p = pack_buf;
 451         int remaining_space = pack_buf ? bufsize : 0;
 452
 453         if (!pass) {
 454                 return -1;
 455         }
 456
 457         /* packing unicode domain name and password */
 458         len += tdb_pack(p, remaining_space, "d",
 459                         pass->uni_name_len);
 460         if (pack_buf) {
 461                 p = pack_buf + len;
 462                 remaining_space = bufsize - len;
 463         }
 464
 465         for (idx = 0; idx < 32; idx++) {
 466                 len += tdb_pack(p, remaining_space, "w",
 467                                  pass->uni_name[idx]);
 468                 if (pack_buf) {
 469                         p = pack_buf + len;
 470                         remaining_space = bufsize - len;
 471                 }
 472         }
 473
 474         len += tdb_pack(p, remaining_space, "dPd", pass->pass_len,
 475                              pass->pass, pass->mod_time);
 476         if (pack_buf) {
 477                 p = pack_buf + len;
 478                 remaining_space = bufsize - len;
 479         }
 480
 481         /* packing SID structure */
 482         len += tdb_sid_pack(p, remaining_space, &pass->domain_sid);
 483         if (pack_buf) {
 484                 p = pack_buf + len;
 485                 remaining_space = bufsize - len;
 486         }
 487
 488         return len;
 489 }
 490
 491
 492 /**
 493  * Unpack TRUSTED_DOM_PASS passed by pointer
 494  *
 495  * @param pack_buf pointer to buffer with packed representation
 496  * @param bufsize size of the buffer
 497  * @param pass pointer to trusted domain password to be filled with unpacked data
 498  *
 499  * @return size of structure unpacked from buffer
 500  **/
 501 static size_t tdb_trusted_dom_pass_unpack(uint8 *pack_buf, int bufsize,
 502                                           TRUSTED_DOM_PASS* pass)
 503 {
 504         int idx, len = 0;
 505         char *passp = NULL;
 506
 507         if (!pack_buf || !pass) return -1;
 508
 509         /* unpack unicode domain name and plaintext password */
 510         len += tdb_unpack(pack_buf, bufsize - len, "d", &pass->uni_name_len);
 511
 512         for (idx = 0; idx < 32; idx++)
 513                 len +=  tdb_unpack(pack_buf + len, bufsize - len, "w",
 514                                    &pass->uni_name[idx]);
 515
 516         len += tdb_unpack(pack_buf + len, bufsize - len, "dPd",
 517                           &pass->pass_len, &passp, &pass->mod_time);
 518         if (passp) {
 519                 fstrcpy(pass->pass, passp);
 520         }
 521         SAFE_FREE(passp);
 522
 523         /* unpack domain sid */
 524         len += tdb_sid_unpack(pack_buf + len, bufsize - len,
 525                               &pass->domain_sid);
 526
 527         return len;
 528 }
 529
 530 /************************************************************************
 531  Routine to get account password to trusted domain
 532 ************************************************************************/
 533
 534 bool secrets_fetch_trusted_domain_password(const char *domain, char** pwd,
 535                                            DOM_SID *sid, time_t *pass_last_set_time)
 536 {
 537         struct trusted_dom_pass pass;
 538         size_t size = 0;
 539
 540         /* unpacking structures */
 541         uint8 *pass_buf;
 542         int pass_len = 0;
 543
 544         ZERO_STRUCT(pass);
 545
 546         /* fetching trusted domain password structure */
 547         if (!(pass_buf = (uint8 *)secrets_fetch(trustdom_keystr(domain),
 548                                                &size))) {
 549                 DEBUG(5, ("secrets_fetch failed!\n"));
 550                 return False;
 551         }
 552
 553         /* unpack trusted domain password */
 554         pass_len = tdb_trusted_dom_pass_unpack(pass_buf, size, &pass);
 555         SAFE_FREE(pass_buf);
 556
 557         if (pass_len != size) {
 558                 DEBUG(5, ("Invalid secrets size. Unpacked data doesn't match trusted_dom_pass structure.\n"));
 559                 return False;
 560         }
 561
 562         /* the trust's password */
 563         if (pwd) {
 564                 *pwd = SMB_STRDUP(pass.pass);
 565                 if (!*pwd) {
 566                         return False;
 567                 }
 568         }
 569
 570         /* last change time */
 571         if (pass_last_set_time) *pass_last_set_time = pass.mod_time;
 572
 573         /* domain sid */
 574         if (sid != NULL) sid_copy(sid, &pass.domain_sid);
 575
 576         return True;
 577 }
 578
 579 /**
 580  * Routine to store the password for trusted domain
 581  *
 582  * @param domain remote domain name
 583  * @param pwd plain text password of trust relationship
 584  * @param sid remote domain sid
 585  *
 586  * @return true if succeeded
 587  **/
 588
 589 bool secrets_store_trusted_domain_password(const char* domain, const char* pwd,
 590                                            const DOM_SID *sid)
 591 {
 592         smb_ucs2_t *uni_dom_name;
 593         bool ret;
 594
 595         /* packing structures */
 596         uint8 *pass_buf = NULL;
 597         int pass_len = 0;
 598
 599         struct trusted_dom_pass pass;
 600         ZERO_STRUCT(pass);
 601
 602         if (push_ucs2_allocate(&uni_dom_name, domain) == (size_t)-1) {
 603                 DEBUG(0, ("Could not convert domain name %s to unicode\n",
 604                           domain));
 605                 return False;
 606         }
 607
 608         strncpy_w(pass.uni_name, uni_dom_name, sizeof(pass.uni_name) - 1);
 609         pass.uni_name_len = strlen_w(uni_dom_name)+1;
 610         SAFE_FREE(uni_dom_name);
 611
 612         /* last change time */
 613         pass.mod_time = time(NULL);
 614
 615         /* password of the trust */
 616         pass.pass_len = strlen(pwd);
 617         fstrcpy(pass.pass, pwd);
 618
 619         /* domain sid */
 620         sid_copy(&pass.domain_sid, sid);
 621
 622         /* Calculate the length. */
 623         pass_len = tdb_trusted_dom_pass_pack(NULL, 0, &pass);
 624         pass_buf = SMB_MALLOC_ARRAY(uint8, pass_len);
 625         if (!pass_buf) {
 626                 return false;
 627         }
 628         pass_len = tdb_trusted_dom_pass_pack(pass_buf, pass_len, &pass);
 629         ret = secrets_store(trustdom_keystr(domain), (void *)pass_buf,
 630                         pass_len);
 631         SAFE_FREE(pass_buf);
 632         return ret;
 633 }
 634
 635 /************************************************************************
 636  Routine to set the plaintext machine account password for a realm
 637 the password is assumed to be a null terminated ascii string
 638 ************************************************************************/
 639
 640 bool secrets_store_machine_password(const char *pass, const char *domain, uint32 sec_channel)
 641 {
 642         char *key = NULL;
 643         bool ret;
 644         uint32 last_change_time;
 645         uint32 sec_channel_type;
 646
 647         asprintf(&key, "%s/%s", SECRETS_MACHINE_PASSWORD, domain);
 648         if (!key)
 649                 return False;
 650         strupper_m(key);
 651
 652         ret = secrets_store(key, pass, strlen(pass)+1);
 653         SAFE_FREE(key);
 654
 655         if (!ret)
 656                 return ret;
 657
 658         asprintf(&key, "%s/%s", SECRETS_MACHINE_LAST_CHANGE_TIME, domain);
 659         if (!key)
 660                 return False;
 661         strupper_m(key);
 662
 663         SIVAL(&last_change_time, 0, time(NULL));
 664         ret = secrets_store(key, &last_change_time, sizeof(last_change_time));
 665         SAFE_FREE(key);
 666
 667         asprintf(&key, "%s/%s", SECRETS_MACHINE_SEC_CHANNEL_TYPE, domain);
 668         if (!key)
 669                 return False;
 670         strupper_m(key);
 671
 672         SIVAL(&sec_channel_type, 0, sec_channel);
 673         ret = secrets_store(key, &sec_channel_type, sizeof(sec_channel_type));
 674         SAFE_FREE(key);
 675
 676         return ret;
 677 }
 678
 679 /************************************************************************
 680  Routine to fetch the plaintext machine account password for a realm
 681  the password is assumed to be a null terminated ascii string.
 682 ************************************************************************/
 683
 684 char *secrets_fetch_machine_password(const char *domain,
 685                                      time_t *pass_last_set_time,
 686                                      uint32 *channel)
 687 {
 688         char *key = NULL;
 689         char *ret;
 690         asprintf(&key, "%s/%s", SECRETS_MACHINE_PASSWORD, domain);
 691         strupper_m(key);
 692         ret = (char *)secrets_fetch(key, NULL);
 693         SAFE_FREE(key);
 694
 695         if (pass_last_set_time) {
 696                 size_t size;
 697                 uint32 *last_set_time;
 698                 asprintf(&key, "%s/%s", SECRETS_MACHINE_LAST_CHANGE_TIME, domain);
 699                 strupper_m(key);
 700                 last_set_time = (unsigned int *)secrets_fetch(key, &size);
 701                 if (last_set_time) {
 702                         *pass_last_set_time = IVAL(last_set_time,0);
 703                         SAFE_FREE(last_set_time);
 704                 } else {
 705                         *pass_last_set_time = 0;
 706                 }
 707                 SAFE_FREE(key);
 708         }
 709
 710         if (channel) {
 711                 size_t size;
 712                 uint32 *channel_type;
 713                 asprintf(&key, "%s/%s", SECRETS_MACHINE_SEC_CHANNEL_TYPE, domain);
 714                 strupper_m(key);
 715                 channel_type = (unsigned int *)secrets_fetch(key, &size);
 716                 if (channel_type) {
 717                         *channel = IVAL(channel_type,0);
 718                         SAFE_FREE(channel_type);
 719                 } else {
 720                         *channel = get_default_sec_channel();
 721                 }
 722                 SAFE_FREE(key);
 723         }
 724
 725         return ret;
 726 }
 727
 728 /************************************************************************
 729  Routine to delete the password for trusted domain
 730 ************************************************************************/
 731
 732 bool trusted_domain_password_delete(const char *domain)
 733 {
 734         return secrets_delete(trustdom_keystr(domain));
 735 }
 736
 737 bool secrets_store_ldap_pw(const char* dn, char* pw)
 738 {
 739         char *key = NULL;
 740         bool ret;
 741
 742         if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, dn) < 0) {
 743                 DEBUG(0, ("secrets_store_ldap_pw: asprintf failed!\n"));
 744                 return False;
 745         }
 746
 747         ret = secrets_store(key, pw, strlen(pw)+1);
 748
 749         SAFE_FREE(key);
 750         return ret;
 751 }
 752
 753 /*******************************************************************
 754  Find the ldap password.
 755 ******************************************************************/
 756
 757 bool fetch_ldap_pw(char **dn, char** pw)
 758 {
 759         char *key = NULL;
 760         size_t size = 0;
 761
 762         *dn = smb_xstrdup(lp_ldap_admin_dn());
 763
 764         if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, *dn) < 0) {
 765                 SAFE_FREE(*dn);
 766                 DEBUG(0, ("fetch_ldap_pw: asprintf failed!\n"));
 767         }
 768
 769         *pw=(char *)secrets_fetch(key, &size);
 770         SAFE_FREE(key);
 771
 772         if (!size) {
 773                 /* Upgrade 2.2 style entry */
 774                 char *p;
 775                 char* old_style_key = SMB_STRDUP(*dn);
 776                 char *data;
 777                 fstring old_style_pw;
 778
 779                 if (!old_style_key) {
 780                         DEBUG(0, ("fetch_ldap_pw: strdup failed!\n"));
 781                         return False;
 782                 }
 783
 784                 for (p=old_style_key; *p; p++)
 785                         if (*p == ',') *p = '/';
 786
 787                 data=(char *)secrets_fetch(old_style_key, &size);
 788                 if (!size && size < sizeof(old_style_pw)) {
 789                         DEBUG(0,("fetch_ldap_pw: neither ldap secret retrieved!\n"));
 790                         SAFE_FREE(old_style_key);
 791                         SAFE_FREE(*dn);
 792                         return False;
 793                 }
 794
 795                 size = MIN(size, sizeof(fstring)-1);
 796                 strncpy(old_style_pw, data, size);
 797                 old_style_pw[size] = 0;
 798
 799                 SAFE_FREE(data);
 800
 801                 if (!secrets_store_ldap_pw(*dn, old_style_pw)) {
 802                         DEBUG(0,("fetch_ldap_pw: ldap secret could not be upgraded!\n"));
 803                         SAFE_FREE(old_style_key);
 804                         SAFE_FREE(*dn);
 805                         return False;
 806                 }
 807                 if (!secrets_delete(old_style_key)) {
 808                         DEBUG(0,("fetch_ldap_pw: old ldap secret could not be deleted!\n"));
 809                 }
 810
 811                 SAFE_FREE(old_style_key);
 812
 813                 *pw = smb_xstrdup(old_style_pw);
 814         }
 815
 816         return True;
 817 }
 818
 819 /**
 820  * Get trusted domains info from secrets.tdb.
 821  **/
 822
 823 NTSTATUS secrets_trusted_domains(TALLOC_CTX *mem_ctx, uint32 *num_domains,
 824                                  struct trustdom_info ***domains)
 825 {
 826         TDB_LIST_NODE *keys, *k;
 827         char *pattern;
 828         TALLOC_CTX *tmp_ctx;
 829
 830         if (!(tmp_ctx = talloc_new(mem_ctx))) {
 831                 return NT_STATUS_NO_MEMORY;
 832         }
 833
 834         if (!secrets_init()) return NT_STATUS_ACCESS_DENIED;
 835
 836         /* generate searching pattern */
 837         pattern = talloc_asprintf(tmp_ctx, "%s/*", SECRETS_DOMTRUST_ACCT_PASS);
 838         if (pattern == NULL) {
 839                 DEBUG(0, ("secrets_trusted_domains: talloc_asprintf() "
 840                           "failed!\n"));
 841                 TALLOC_FREE(tmp_ctx);
 842                 return NT_STATUS_NO_MEMORY;
 843         }
 844
 845         *num_domains = 0;
 846
 847         /*
 848          * Make sure that a talloc context for the trustdom_info structs
 849          * exists
 850          */
 851
 852         if (!(*domains = TALLOC_ARRAY(mem_ctx, struct trustdom_info *, 1))) {
 853                 TALLOC_FREE(tmp_ctx);
 854                 return NT_STATUS_NO_MEMORY;
 855         }
 856
 857         /* fetching trusted domains' data and collecting them in a list */
 858         keys = tdb_search_keys(tdb, pattern);
 859
 860         /* searching for keys in secrets db -- way to go ... */
 861         for (k = keys; k; k = k->next) {
 862                 uint8 *packed_pass;
 863                 size_t size = 0, packed_size = 0;
 864                 struct trusted_dom_pass pass;
 865                 char *secrets_key;
 866                 struct trustdom_info *dom_info;
 867
 868                 /* important: ensure null-termination of the key string */
 869                 secrets_key = talloc_strndup(tmp_ctx,
 870                                              (const char *)k->node_key.dptr,
 871                                              k->node_key.dsize);
 872                 if (!secrets_key) {
 873                         DEBUG(0, ("strndup failed!\n"));
 874                         tdb_search_list_free(keys);
 875                         TALLOC_FREE(tmp_ctx);
 876                         return NT_STATUS_NO_MEMORY;
 877                 }
 878
 879                 packed_pass = (uint8 *)secrets_fetch(secrets_key, &size);
 880                 packed_size = tdb_trusted_dom_pass_unpack(packed_pass, size,
 881                                                           &pass);
 882                 /* packed representation isn't needed anymore */
 883                 SAFE_FREE(packed_pass);
 884
 885                 if (size != packed_size) {
 886                         DEBUG(2, ("Secrets record %s is invalid!\n",
 887                                   secrets_key));
 888                         continue;
 889                 }
 890
 891                 if (pass.domain_sid.num_auths != 4) {
 892                         DEBUG(0, ("SID %s is not a domain sid, has %d "
 893                                   "auths instead of 4\n",
 894                                   sid_string_static(&pass.domain_sid),
 895                                   pass.domain_sid.num_auths));
 896                         continue;
 897                 }
 898
 899                 if (!(dom_info = TALLOC_P(*domains, struct trustdom_info))) {
 900                         DEBUG(0, ("talloc failed\n"));
 901                         tdb_search_list_free(keys);
 902                         TALLOC_FREE(tmp_ctx);
 903                         return NT_STATUS_NO_MEMORY;
 904                 }
 905
 906                 if (pull_ucs2_talloc(dom_info, &dom_info->name,
 907                                      pass.uni_name) == (size_t)-1) {
 908                         DEBUG(2, ("pull_ucs2_talloc failed\n"));
 909                         tdb_search_list_free(keys);
 910                         TALLOC_FREE(tmp_ctx);
 911                         return NT_STATUS_NO_MEMORY;
 912                 }
 913
 914                 sid_copy(&dom_info->sid, &pass.domain_sid);
 915
 916                 ADD_TO_ARRAY(*domains, struct trustdom_info *, dom_info,
 917                              domains, num_domains);
 918
 919                 if (*domains == NULL) {
 920                         tdb_search_list_free(keys);
 921                         TALLOC_FREE(tmp_ctx);
 922                         return NT_STATUS_NO_MEMORY;
 923                 }
 924         }
 925
 926         DEBUG(5, ("secrets_get_trusted_domains: got %d domains\n",
 927                   *num_domains));
 928
 929         /* free the results of searching the keys */
 930         tdb_search_list_free(keys);
 931         TALLOC_FREE(tmp_ctx);
 932
 933         return NT_STATUS_OK;
 934 }
 935
 936 /*******************************************************************************
 937  Lock the secrets tdb based on a string - this is used as a primitive form of mutex
 938  between smbd instances.
 939 *******************************************************************************/
 940
 941 bool secrets_named_mutex(const char *name, unsigned int timeout)
 942 {
 943         int ret = 0;
 944
 945         if (!secrets_init())
 946                 return False;
 947
 948         ret = tdb_lock_bystring_with_timeout(tdb, name, timeout);
 949         if (ret == 0)
 950                 DEBUG(10,("secrets_named_mutex: got mutex for %s\n", name ));
 951
 952         return (ret == 0);
 953 }
 954
 955 /*******************************************************************************
 956  Unlock a named mutex.
 957 *******************************************************************************/
 958
 959 void secrets_named_mutex_release(const char *name)
 960 {
 961         tdb_unlock_bystring(tdb, name);
 962         DEBUG(10,("secrets_named_mutex: released mutex for %s\n", name ));
 963 }
 964
 965 /*******************************************************************************
 966  Store a complete AFS keyfile into secrets.tdb.
 967 *******************************************************************************/
 968
 969 bool secrets_store_afs_keyfile(const char *cell, const struct afs_keyfile *keyfile)
 970 {
 971         fstring key;
 972
 973         if ((cell == NULL) || (keyfile == NULL))
 974                 return False;
 975
 976         if (ntohl(keyfile->nkeys) > SECRETS_AFS_MAXKEYS)
 977                 return False;
 978
 979         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_AFS_KEYFILE, cell);
 980         return secrets_store(key, keyfile, sizeof(struct afs_keyfile));
 981 }
 982
 983 /*******************************************************************************
 984  Fetch the current (highest) AFS key from secrets.tdb
 985 *******************************************************************************/
 986 bool secrets_fetch_afs_key(const char *cell, struct afs_key *result)
 987 {
 988         fstring key;
 989         struct afs_keyfile *keyfile;
 990         size_t size = 0;
 991         uint32 i;
 992
 993         slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_AFS_KEYFILE, cell);
 994
 995         keyfile = (struct afs_keyfile *)secrets_fetch(key, &size);
 996
 997         if (keyfile == NULL)
 998                 return False;
 999
1000         if (size != sizeof(struct afs_keyfile)) {
1001                 SAFE_FREE(keyfile);
1002                 return False;
1003         }
1004
1005         i = ntohl(keyfile->nkeys);
1006
1007         if (i > SECRETS_AFS_MAXKEYS) {
1008                 SAFE_FREE(keyfile);
1009                 return False;
1010         }
1011
1012         *result = keyfile->entry[i-1];
1013
1014         result->kvno = ntohl(result->kvno);
1015
1016         return True;
1017 }
1018
1019 /******************************************************************************
1020   When kerberos is not available, choose between anonymous or
1021   authenticated connections.
1022
1023   We need to use an authenticated connection if DCs have the
1024   RestrictAnonymous registry entry set > 0, or the "Additional
1025   restrictions for anonymous connections" set in the win2k Local
1026   Security Policy.
1027
1028   Caller to free() result in domain, username, password
1029 *******************************************************************************/
1030 void secrets_fetch_ipc_userpass(char **username, char **domain, char **password)
1031 {
1032         *username = (char *)secrets_fetch(SECRETS_AUTH_USER, NULL);
1033         *domain = (char *)secrets_fetch(SECRETS_AUTH_DOMAIN, NULL);
1034         *password = (char *)secrets_fetch(SECRETS_AUTH_PASSWORD, NULL);
1035
1036         if (*username && **username) {
1037
1038                 if (!*domain || !**domain)
1039                         *domain = smb_xstrdup(lp_workgroup());
1040
1041                 if (!*password || !**password)
1042                         *password = smb_xstrdup("");
1043
1044                 DEBUG(3, ("IPC$ connections done by user %s\\%s\n",
1045                           *domain, *username));
1046
1047         } else {
1048                 DEBUG(3, ("IPC$ connections done anonymously\n"));
1049                 *username = smb_xstrdup("");
1050                 *domain = smb_xstrdup("");
1051                 *password = smb_xstrdup("");
1052         }
1053 }
1054
1055 /******************************************************************************
1056  Open or create the schannel session store tdb.
1057 *******************************************************************************/
1058
1059 static TDB_CONTEXT *open_schannel_session_store(TALLOC_CTX *mem_ctx)
1060 {
1061         TDB_DATA vers;
1062         uint32 ver;
1063         TDB_CONTEXT *tdb_sc = NULL;
1064         char *fname = talloc_asprintf(mem_ctx, "%s/schannel_store.tdb", lp_private_dir());
1065
1066         if (!fname) {
1067                 return NULL;
1068         }
1069
1070         tdb_sc = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
1071
1072         if (!tdb_sc) {
1073                 DEBUG(0,("open_schannel_session_store: Failed to open %s\n", fname));
1074                 TALLOC_FREE(fname);
1075                 return NULL;
1076         }
1077
1078         vers = tdb_fetch_bystring(tdb_sc, "SCHANNEL_STORE_VERSION");
1079         if (vers.dptr == NULL) {
1080                 /* First opener, no version. */
1081                 SIVAL(&ver,0,1);
1082                 vers.dptr = (uint8 *)&ver;
1083                 vers.dsize = 4;
1084                 tdb_store_bystring(tdb_sc, "SCHANNEL_STORE_VERSION", vers, TDB_REPLACE);
1085                 vers.dptr = NULL;
1086         } else if (vers.dsize == 4) {
1087                 ver = IVAL(vers.dptr,0);
1088                 if (ver != 1) {
1089                         tdb_close(tdb_sc);
1090                         tdb_sc = NULL;
1091                         DEBUG(0,("open_schannel_session_store: wrong version number %d in %s\n",
1092                                 (int)ver, fname ));
1093                 }
1094         } else {
1095                 tdb_close(tdb_sc);
1096                 tdb_sc = NULL;
1097                 DEBUG(0,("open_schannel_session_store: wrong version number size %d in %s\n",
1098                         (int)vers.dsize, fname ));
1099         }
1100
1101         SAFE_FREE(vers.dptr);
1102         TALLOC_FREE(fname);
1103
1104         return tdb_sc;
1105 }
1106
1107 /******************************************************************************
1108  Store the schannel state after an AUTH2 call.
1109  Note we must be root here.
1110 *******************************************************************************/
1111
1112 bool secrets_store_schannel_session_info(TALLOC_CTX *mem_ctx,
1113                                 const char *remote_machine,
1114                                 const struct dcinfo *pdc)
1115 {
1116         TDB_CONTEXT *tdb_sc = NULL;
1117         TDB_DATA value;
1118         bool ret;
1119         char *keystr = talloc_asprintf(mem_ctx, "%s/%s", SECRETS_SCHANNEL_STATE,
1120                                 remote_machine);
1121         if (!keystr) {
1122                 return False;
1123         }
1124
1125         strupper_m(keystr);
1126
1127         /* Work out how large the record is. */
1128         value.dsize = tdb_pack(NULL, 0, "dBBBBBfff",
1129                                 pdc->sequence,
1130                                 8, pdc->seed_chal.data,
1131                                 8, pdc->clnt_chal.data,
1132                                 8, pdc->srv_chal.data,
1133                                 16, pdc->sess_key,
1134                                 16, pdc->mach_pw,
1135                                 pdc->mach_acct,
1136                                 pdc->remote_machine,
1137                                 pdc->domain);
1138
1139         value.dptr = TALLOC_ARRAY(mem_ctx, uint8, value.dsize);
1140         if (!value.dptr) {
1141                 TALLOC_FREE(keystr);
1142                 return False;
1143         }
1144
1145         value.dsize = tdb_pack(value.dptr, value.dsize, "dBBBBBfff",
1146                                 pdc->sequence,
1147                                 8, pdc->seed_chal.data,
1148                                 8, pdc->clnt_chal.data,
1149                                 8, pdc->srv_chal.data,
1150                                 16, pdc->sess_key,
1151                                 16, pdc->mach_pw,
1152                                 pdc->mach_acct,
1153                                 pdc->remote_machine,
1154                                 pdc->domain);
1155
1156         tdb_sc = open_schannel_session_store(mem_ctx);
1157         if (!tdb_sc) {
1158                 TALLOC_FREE(keystr);
1159                 TALLOC_FREE(value.dptr);
1160                 return False;
1161         }
1162
1163         ret = (tdb_store_bystring(tdb_sc, keystr, value, TDB_REPLACE) == 0 ? True : False);
1164
1165         DEBUG(3,("secrets_store_schannel_session_info: stored schannel info with key %s\n",
1166                 keystr ));
1167
1168         tdb_close(tdb_sc);
1169         TALLOC_FREE(keystr);
1170         TALLOC_FREE(value.dptr);
1171         return ret;
1172 }
1173
1174 /******************************************************************************
1175  Restore the schannel state on a client reconnect.
1176  Note we must be root here.
1177 *******************************************************************************/
1178
1179 bool secrets_restore_schannel_session_info(TALLOC_CTX *mem_ctx,
1180                                 const char *remote_machine,
1181                                 struct dcinfo **ppdc)
1182 {
1183         TDB_CONTEXT *tdb_sc = NULL;
1184         TDB_DATA value;
1185         unsigned char *pseed_chal = NULL;
1186         unsigned char *pclnt_chal = NULL;
1187         unsigned char *psrv_chal = NULL;
1188         unsigned char *psess_key = NULL;
1189         unsigned char *pmach_pw = NULL;
1190         uint32 l1, l2, l3, l4, l5;
1191         int ret;
1192         struct dcinfo *pdc = NULL;
1193         char *keystr = talloc_asprintf(mem_ctx, "%s/%s", SECRETS_SCHANNEL_STATE,
1194                                 remote_machine);
1195
1196         *ppdc = NULL;
1197
1198         if (!keystr) {
1199                 return False;
1200         }
1201
1202         strupper_m(keystr);
1203
1204         tdb_sc = open_schannel_session_store(mem_ctx);
1205         if (!tdb_sc) {
1206                 TALLOC_FREE(keystr);
1207                 return False;
1208         }
1209
1210         value = tdb_fetch_bystring(tdb_sc, keystr);
1211         if (!value.dptr) {
1212                 DEBUG(0,("secrets_restore_schannel_session_info: Failed to find entry with key %s\n",
1213                         keystr ));
1214                 tdb_close(tdb_sc);
1215                 return False;
1216         }
1217
1218         pdc = TALLOC_ZERO_P(mem_ctx, struct dcinfo);
1219
1220         /* Retrieve the record. */
1221         ret = tdb_unpack(value.dptr, value.dsize, "dBBBBBfff",
1222                                 &pdc->sequence,
1223                                 &l1, &pseed_chal,
1224                                 &l2, &pclnt_chal,
1225                                 &l3, &psrv_chal,
1226                                 &l4, &psess_key,
1227                                 &l5, &pmach_pw,
1228                                 &pdc->mach_acct,
1229                                 &pdc->remote_machine,
1230                                 &pdc->domain);
1231
1232         if (ret == -1 || l1 != 8 || l2 != 8 || l3 != 8 || l4 != 16 || l5 != 16) {
1233                 /* Bad record - delete it. */
1234                 tdb_delete_bystring(tdb_sc, keystr);
1235                 tdb_close(tdb_sc);
1236                 TALLOC_FREE(keystr);
1237                 TALLOC_FREE(pdc);
1238                 SAFE_FREE(pseed_chal);
1239                 SAFE_FREE(pclnt_chal);
1240                 SAFE_FREE(psrv_chal);
1241                 SAFE_FREE(psess_key);
1242                 SAFE_FREE(pmach_pw);
1243                 SAFE_FREE(value.dptr);
1244                 return False;
1245         }
1246
1247         tdb_close(tdb_sc);
1248
1249         memcpy(pdc->seed_chal.data, pseed_chal, 8);
1250         memcpy(pdc->clnt_chal.data, pclnt_chal, 8);
1251         memcpy(pdc->srv_chal.data, psrv_chal, 8);
1252         memcpy(pdc->sess_key, psess_key, 16);
1253         memcpy(pdc->mach_pw, pmach_pw, 16);
1254
1255         /* We know these are true so didn't bother to store them. */
1256         pdc->challenge_sent = True;
1257         pdc->authenticated = True;
1258
1259         DEBUG(3,("secrets_restore_schannel_session_info: restored schannel info key %s\n",
1260                 keystr ));
1261
1262         SAFE_FREE(pseed_chal);
1263         SAFE_FREE(pclnt_chal);
1264         SAFE_FREE(psrv_chal);
1265         SAFE_FREE(psess_key);
1266         SAFE_FREE(pmach_pw);
1267
1268         TALLOC_FREE(keystr);
1269         SAFE_FREE(value.dptr);
1270
1271         *ppdc = pdc;
1272
1273         return True;
1274 }
1275
1276 bool secrets_store_generic(const char *owner, const char *key, const char *secret)
1277 {
1278         char *tdbkey = NULL;
1279         bool ret;
1280
1281         if (asprintf(&tdbkey, "SECRETS/GENERIC/%s/%s", owner, key) < 0) {
1282                 DEBUG(0, ("asprintf failed!\n"));
1283                 return False;
1284         }
1285
1286         ret = secrets_store(tdbkey, secret, strlen(secret)+1);
1287
1288         SAFE_FREE(tdbkey);
1289         return ret;
1290 }
1291
1292 /*******************************************************************
1293  Find the ldap password.
1294 ******************************************************************/
1295
1296 char *secrets_fetch_generic(const char *owner, const char *key)
1297 {
1298         char *secret = NULL;
1299         char *tdbkey = NULL;
1300
1301         if (( ! owner) || ( ! key)) {
1302                 DEBUG(1, ("Invalid Paramters"));
1303                 return NULL;
1304         }
1305
1306         if (asprintf(&tdbkey, "SECRETS/GENERIC/%s/%s", owner, key) < 0) {
1307                 DEBUG(0, ("Out of memory!\n"));
1308                 return NULL;
1309         }
1310
1311         secret = (char *)secrets_fetch(tdbkey, NULL);
1312         SAFE_FREE(tdbkey);
1313
1314         return secret;
1315 }
1316