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  The user of this function must have locked the trust password file using
 288  the above secrets_lock_trust_account_password().
 289 ************************************************************************/
 290
 291 bool secrets_fetch_trust_account_password(const char *domain, uint8 ret_pwd[16],
 292                                           time_t *pass_last_set_time,
 293                                           uint32 *channel)
 294 {
 295         struct machine_acct_pass *pass;
 296         char *plaintext;
 297         size_t size = 0;
 298
 299         plaintext = secrets_fetch_machine_password(domain, pass_last_set_time,
 300                                                    channel);
 301         if (plaintext) {
 302                 DEBUG(4,("Using cleartext machine password\n"));
 303                 E_md4hash(plaintext, ret_pwd);
 304                 SAFE_FREE(plaintext);
 305                 return True;
 306         }
 307
 308         if (!(pass = (struct machine_acct_pass *)secrets_fetch(
 309                       trust_keystr(domain), &size))) {
 310                 DEBUG(5, ("secrets_fetch failed!\n"));
 311                 return False;
 312         }
 313
 314         if (size != sizeof(*pass)) {
 315                 DEBUG(0, ("secrets were of incorrect size!\n"));
 316                 return False;
 317         }
 318
 319         if (pass_last_set_time) {
 320                 *pass_last_set_time = pass->mod_time;
 321         }
 322         memcpy(ret_pwd, pass->hash, 16);
 323
 324         if (channel) {
 325                 *channel = get_default_sec_channel();
 326         }
 327
 328         /* Test if machine password has expired and needs to be changed */
 329         if (lp_machine_password_timeout()) {
 330                 if (pass->mod_time > 0 && time(NULL) > (pass->mod_time +
 331                                 (time_t)lp_machine_password_timeout())) {
 332                         global_machine_password_needs_changing = True;
 333                 }
 334         }
 335
 336         SAFE_FREE(pass);
 337         return True;
 338 }
 339
 340 /**
 341  * Pack SID passed by pointer
 342  *
 343  * @param pack_buf pointer to buffer which is to be filled with packed data
 344  * @param bufsize size of packing buffer
 345  * @param sid pointer to sid to be packed
 346  *
 347  * @return length of the packed representation of the whole structure
 348  **/
 349 static size_t tdb_sid_pack(uint8 *pack_buf, int bufsize, DOM_SID* sid)
 350 {
 351         int idx;
 352         size_t len = 0;
 353         uint8 *p = pack_buf;
 354         int remaining_space = pack_buf ? bufsize : 0;
 355
 356         if (!sid) {
 357                 return -1;
 358         }
 359
 360         len += tdb_pack(p, remaining_space, "bb", sid->sid_rev_num,
 361                         sid->num_auths);
 362         if (pack_buf) {
 363                 p += len;
 364                 remaining_space -= len;
 365         }
 366
 367         for (idx = 0; idx < 6; idx++) {
 368                 len += tdb_pack(p, remaining_space, "b",
 369                                 sid->id_auth[idx]);
 370                 if (pack_buf) {
 371                         p += len;
 372                         remaining_space -= len;
 373                 }
 374         }
 375
 376         for (idx = 0; idx < MAXSUBAUTHS; idx++) {
 377                 len += tdb_pack(p, remaining_space, "d",
 378                                 sid->sub_auths[idx]);
 379                 if (pack_buf) {
 380                         p += len;
 381                         remaining_space -= len;
 382                 }
 383         }
 384
 385         return len;
 386 }
 387
 388 /**
 389  * Unpack SID into a pointer
 390  *
 391  * @param pack_buf pointer to buffer with packed representation
 392  * @param bufsize size of the buffer
 393  * @param sid pointer to sid structure to be filled with unpacked data
 394  *
 395  * @return size of structure unpacked from buffer
 396  **/
 397 static size_t tdb_sid_unpack(uint8 *pack_buf, int bufsize, DOM_SID* sid)
 398 {
 399         int idx, len = 0;
 400
 401         if (!sid || !pack_buf) return -1;
 402
 403         len += tdb_unpack(pack_buf + len, bufsize - len, "bb",
 404                           &sid->sid_rev_num, &sid->num_auths);
 405
 406         for (idx = 0; idx < 6; idx++) {
 407                 len += tdb_unpack(pack_buf + len, bufsize - len, "b",
 408                                   &sid->id_auth[idx]);
 409         }
 410
 411         for (idx = 0; idx < MAXSUBAUTHS; idx++) {
 412                 len += tdb_unpack(pack_buf + len, bufsize - len, "d",
 413                                   &sid->sub_auths[idx]);
 414         }
 415
 416         return len;
 417 }
 418
 419 /**
 420  * Pack TRUSTED_DOM_PASS passed by pointer
 421  *
 422  * @param pack_buf pointer to buffer which is to be filled with packed data
 423  * @param bufsize size of the buffer
 424  * @param pass pointer to trusted domain password to be packed
 425  *
 426  * @return length of the packed representation of the whole structure
 427  **/
 428 static size_t tdb_trusted_dom_pass_pack(uint8 *pack_buf, int bufsize,
 429                                         TRUSTED_DOM_PASS* pass)
 430 {
 431         int idx, len = 0;
 432         uint8 *p = pack_buf;
 433         int remaining_space = pack_buf ? bufsize : 0;
 434
 435         if (!pass) {
 436                 return -1;
 437         }
 438
 439         /* packing unicode domain name and password */
 440         len += tdb_pack(p, remaining_space, "d",
 441                         pass->uni_name_len);
 442         if (pack_buf) {
 443                 p += len;
 444                 remaining_space -= len;
 445         }
 446
 447         for (idx = 0; idx < 32; idx++) {
 448                 len += tdb_pack(p, remaining_space, "w",
 449                                  pass->uni_name[idx]);
 450                 if (pack_buf) {
 451                         p += len;
 452                         remaining_space -= len;
 453                 }
 454         }
 455
 456         len += tdb_pack(p, remaining_space, "dPd", pass->pass_len,
 457                              pass->pass, pass->mod_time);
 458         if (pack_buf) {
 459                 p += len;
 460                 remaining_space -= len;
 461         }
 462
 463         /* packing SID structure */
 464         len += tdb_sid_pack(p, remaining_space, &pass->domain_sid);
 465         if (pack_buf) {
 466                 p += len;
 467                 remaining_space -= len;
 468         }
 469
 470         return len;
 471 }
 472
 473
 474 /**
 475  * Unpack TRUSTED_DOM_PASS passed by pointer
 476  *
 477  * @param pack_buf pointer to buffer with packed representation
 478  * @param bufsize size of the buffer
 479  * @param pass pointer to trusted domain password to be filled with unpacked data
 480  *
 481  * @return size of structure unpacked from buffer
 482  **/
 483 static size_t tdb_trusted_dom_pass_unpack(uint8 *pack_buf, int bufsize,
 484                                           TRUSTED_DOM_PASS* pass)
 485 {
 486         int idx, len = 0;
 487
 488         if (!pack_buf || !pass) return -1;
 489
 490         /* unpack unicode domain name and plaintext password */
 491         len += tdb_unpack(pack_buf, bufsize - len, "d", &pass->uni_name_len);
 492
 493         for (idx = 0; idx < 32; idx++)
 494                 len +=  tdb_unpack(pack_buf + len, bufsize - len, "w",
 495                                    &pass->uni_name[idx]);
 496
 497         len += tdb_unpack(pack_buf + len, bufsize - len, "dPd",
 498                           &pass->pass_len, &pass->pass, &pass->mod_time);
 499
 500         /* unpack domain sid */
 501         len += tdb_sid_unpack(pack_buf + len, bufsize - len,
 502                               &pass->domain_sid);
 503
 504         return len;
 505 }
 506
 507 /************************************************************************
 508  Routine to get account password to trusted domain
 509 ************************************************************************/
 510
 511 bool secrets_fetch_trusted_domain_password(const char *domain, char** pwd,
 512                                            DOM_SID *sid, time_t *pass_last_set_time)
 513 {
 514         struct trusted_dom_pass pass;
 515         size_t size = 0;
 516
 517         /* unpacking structures */
 518         uint8 *pass_buf;
 519         int pass_len = 0;
 520
 521         ZERO_STRUCT(pass);
 522
 523         /* fetching trusted domain password structure */
 524         if (!(pass_buf = (uint8 *)secrets_fetch(trustdom_keystr(domain),
 525                                                &size))) {
 526                 DEBUG(5, ("secrets_fetch failed!\n"));
 527                 return False;
 528         }
 529
 530         /* unpack trusted domain password */
 531         pass_len = tdb_trusted_dom_pass_unpack(pass_buf, size, &pass);
 532         SAFE_FREE(pass_buf);
 533
 534         if (pass_len != size) {
 535                 DEBUG(5, ("Invalid secrets size. Unpacked data doesn't match trusted_dom_pass structure.\n"));
 536                 return False;
 537         }
 538
 539         /* the trust's password */
 540         if (pwd) {
 541                 *pwd = SMB_STRDUP(pass.pass);
 542                 if (!*pwd) {
 543                         return False;
 544                 }
 545         }
 546
 547         /* last change time */
 548         if (pass_last_set_time) *pass_last_set_time = pass.mod_time;
 549
 550         /* domain sid */
 551         if (sid != NULL) sid_copy(sid, &pass.domain_sid);
 552
 553         return True;
 554 }
 555
 556 /************************************************************************
 557  Routine to set the trust account password for a domain.
 558 ************************************************************************/
 559
 560 bool secrets_store_trust_account_password(const char *domain, uint8 new_pwd[16])
 561 {
 562         struct machine_acct_pass pass;
 563
 564         pass.mod_time = time(NULL);
 565         memcpy(pass.hash, new_pwd, 16);
 566
 567         return secrets_store(trust_keystr(domain), (void *)&pass, sizeof(pass));
 568 }
 569
 570 /**
 571  * Routine to store the password for trusted domain
 572  *
 573  * @param domain remote domain name
 574  * @param pwd plain text password of trust relationship
 575  * @param sid remote domain sid
 576  *
 577  * @return true if succeeded
 578  **/
 579
 580 bool secrets_store_trusted_domain_password(const char* domain, const char* pwd,
 581                                            const DOM_SID *sid)
 582 {
 583         smb_ucs2_t *uni_dom_name;
 584         bool ret;
 585
 586         /* packing structures */
 587         uint8 *pass_buf = NULL;
 588         int pass_len = 0;
 589
 590         struct trusted_dom_pass pass;
 591         ZERO_STRUCT(pass);
 592
 593         if (push_ucs2_allocate(&uni_dom_name, domain) == (size_t)-1) {
 594                 DEBUG(0, ("Could not convert domain name %s to unicode\n",
 595                           domain));
 596                 return False;
 597         }
 598
 599         strncpy_w(pass.uni_name, uni_dom_name, sizeof(pass.uni_name) - 1);
 600         pass.uni_name_len = strlen_w(uni_dom_name)+1;
 601         SAFE_FREE(uni_dom_name);
 602
 603         /* last change time */
 604         pass.mod_time = time(NULL);
 605
 606         /* password of the trust */
 607         pass.pass_len = strlen(pwd);
 608         fstrcpy(pass.pass, pwd);
 609
 610         /* domain sid */
 611         sid_copy(&pass.domain_sid, sid);
 612
 613         /* Calculate the length. */
 614         pass_len = tdb_trusted_dom_pass_pack(NULL, 0, &pass);
 615         pass_buf = SMB_MALLOC_ARRAY(uint8, pass_len);
 616         if (!pass_buf) {
 617                 return false;
 618         }
 619         pass_len = tdb_trusted_dom_pass_pack(pass_buf, pass_len, &pass);
 620         ret = secrets_store(trustdom_keystr(domain), (void *)&pass_buf,
 621                         pass_len);
 622         SAFE_FREE(pass_buf);
 623         return ret;
 624 }
 625
 626 /************************************************************************
 627  Routine to set the plaintext machine account password for a realm
 628 the password is assumed to be a null terminated ascii string
 629 ************************************************************************/
 630
 631 bool secrets_store_machine_password(const char *pass, const char *domain, uint32 sec_channel)
 632 {
 633         char *key = NULL;
 634         bool ret;
 635         uint32 last_change_time;
 636         uint32 sec_channel_type;
 637
 638         asprintf(&key, "%s/%s", SECRETS_MACHINE_PASSWORD, domain);
 639         if (!key)
 640                 return False;
 641         strupper_m(key);
 642
 643         ret = secrets_store(key, pass, strlen(pass)+1);
 644         SAFE_FREE(key);
 645
 646         if (!ret)
 647                 return ret;
 648
 649         asprintf(&key, "%s/%s", SECRETS_MACHINE_LAST_CHANGE_TIME, domain);
 650         if (!key)
 651                 return False;
 652         strupper_m(key);
 653
 654         SIVAL(&last_change_time, 0, time(NULL));
 655         ret = secrets_store(key, &last_change_time, sizeof(last_change_time));
 656         SAFE_FREE(key);
 657
 658         asprintf(&key, "%s/%s", SECRETS_MACHINE_SEC_CHANNEL_TYPE, domain);
 659         if (!key)
 660                 return False;
 661         strupper_m(key);
 662
 663         SIVAL(&sec_channel_type, 0, sec_channel);
 664         ret = secrets_store(key, &sec_channel_type, sizeof(sec_channel_type));
 665         SAFE_FREE(key);
 666
 667         return ret;
 668 }
 669
 670 /************************************************************************
 671  Routine to fetch the plaintext machine account password for a realm
 672  the password is assumed to be a null terminated ascii string.
 673 ************************************************************************/
 674
 675 char *secrets_fetch_machine_password(const char *domain,
 676                                      time_t *pass_last_set_time,
 677                                      uint32 *channel)
 678 {
 679         char *key = NULL;
 680         char *ret;
 681         asprintf(&key, "%s/%s", SECRETS_MACHINE_PASSWORD, domain);
 682         strupper_m(key);
 683         ret = (char *)secrets_fetch(key, NULL);
 684         SAFE_FREE(key);
 685
 686         if (pass_last_set_time) {
 687                 size_t size;
 688                 uint32 *last_set_time;
 689                 asprintf(&key, "%s/%s", SECRETS_MACHINE_LAST_CHANGE_TIME, domain);
 690                 strupper_m(key);
 691                 last_set_time = (unsigned int *)secrets_fetch(key, &size);
 692                 if (last_set_time) {
 693                         *pass_last_set_time = IVAL(last_set_time,0);
 694                         SAFE_FREE(last_set_time);
 695                 } else {
 696                         *pass_last_set_time = 0;
 697                 }
 698                 SAFE_FREE(key);
 699         }
 700
 701         if (channel) {
 702                 size_t size;
 703                 uint32 *channel_type;
 704                 asprintf(&key, "%s/%s", SECRETS_MACHINE_SEC_CHANNEL_TYPE, domain);
 705                 strupper_m(key);
 706                 channel_type = (unsigned int *)secrets_fetch(key, &size);
 707                 if (channel_type) {
 708                         *channel = IVAL(channel_type,0);
 709                         SAFE_FREE(channel_type);
 710                 } else {
 711                         *channel = get_default_sec_channel();
 712                 }
 713                 SAFE_FREE(key);
 714         }
 715
 716         return ret;
 717 }
 718
 719 /************************************************************************
 720  Routine to delete the machine trust account password file for a domain.
 721 ************************************************************************/
 722
 723 bool trust_password_delete(const char *domain)
 724 {
 725         return secrets_delete(trust_keystr(domain));
 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