source3/libads/ldap.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 3.0
   4    ads (active directory) utility library
   5    Copyright (C) Andrew Tridgell 2001
   6    Copyright (C) Remus Koos 2001
   7
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26 #ifdef HAVE_ADS
  27
  28 /*
  29   connect to the LDAP server
  30 */
  31 ADS_STATUS ads_connect(ADS_STRUCT *ads)
  32 {
  33         int version = LDAP_VERSION3;
  34         ADS_STATUS status;
  35
  36         ads->last_attempt = time(NULL);
  37
  38         ads->ld = ldap_open(ads->ldap_server, ads->ldap_port);
  39         if (!ads->ld) {
  40                 return ADS_ERROR_SYSTEM(errno)
  41         }
  42         status = ads_server_info(ads);
  43         if (!ADS_ERR_OK(status)) {
  44                 DEBUG(1,("Failed to get ldap server info\n"));
  45                 return status;
  46         }
  47
  48         ldap_set_option(ads->ld, LDAP_OPT_PROTOCOL_VERSION, &version);
  49
  50         if (ads->password) {
  51                 ads_kinit_password(ads);
  52         }
  53
  54         return ads_sasl_bind(ads);
  55 }
  56
  57 /*
  58   do a search with a timeout
  59 */
  60 ADS_STATUS ads_do_search(ADS_STRUCT *ads, const char *bind_path, int scope,
  61                          const char *exp,
  62                          const char **attrs, void **res)
  63 {
  64         struct timeval timeout;
  65         int rc;
  66
  67         timeout.tv_sec = ADS_SEARCH_TIMEOUT;
  68         timeout.tv_usec = 0;
  69         *res = NULL;
  70
  71         rc = ldap_search_ext_s(ads->ld,
  72                                bind_path, scope,
  73                                exp, attrs, 0, NULL, NULL,
  74                                &timeout, LDAP_NO_LIMIT, (LDAPMessage **)res);
  75         return ADS_ERROR(rc);
  76 }
  77 /*
  78   do a general ADS search
  79 */
  80 ADS_STATUS ads_search(ADS_STRUCT *ads, void **res,
  81                       const char *exp,
  82                       const char **attrs)
  83 {
  84         return ads_do_search(ads, ads->bind_path, LDAP_SCOPE_SUBTREE,
  85                              exp, attrs, res);
  86 }
  87
  88 /*
  89   do a search on a specific DistinguishedName
  90 */
  91 ADS_STATUS ads_search_dn(ADS_STRUCT *ads, void **res,
  92                          const char *dn,
  93                          const char **attrs)
  94 {
  95         return ads_do_search(ads, dn, LDAP_SCOPE_BASE, "(objectclass=*)", attrs, res);
  96 }
  97
  98 /*
  99   free up memory from a ads_search
 100 */
 101 void ads_msgfree(ADS_STRUCT *ads, void *msg)
 102 {
 103         if (!msg) return;
 104         ldap_msgfree(msg);
 105 }
 106
 107 /*
 108   find a machine account given a hostname
 109 */
 110 ADS_STATUS ads_find_machine_acct(ADS_STRUCT *ads, void **res, const char *host)
 111 {
 112         ADS_STATUS status;
 113         char *exp;
 114         const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
 115
 116         /* the easiest way to find a machine account anywhere in the tree
 117            is to look for hostname$ */
 118         asprintf(&exp, "(samAccountName=%s$)", host);
 119         status = ads_search(ads, res, exp, attrs);
 120         free(exp);
 121         return status;
 122 }
 123
 124
 125 /*
 126   a convenient routine for adding a generic LDAP record
 127 */
 128 ADS_STATUS ads_gen_add(ADS_STRUCT *ads, const char *new_dn, ...)
 129 {
 130         int i;
 131         va_list ap;
 132         LDAPMod **mods;
 133         char *name, *value;
 134         int ret;
 135 #define MAX_MOD_VALUES 10
 136
 137         /* count the number of attributes */
 138         va_start(ap, new_dn);
 139         for (i=0; va_arg(ap, char *); i++) {
 140                 /* skip the values */
 141                 while (va_arg(ap, char *)) ;
 142         }
 143         va_end(ap);
 144
 145         mods = malloc(sizeof(LDAPMod *) * (i+1));
 146
 147         va_start(ap, new_dn);
 148         for (i=0; (name=va_arg(ap, char *)); i++) {
 149                 char **values;
 150                 int j;
 151                 values = (char **)malloc(sizeof(char *) * (MAX_MOD_VALUES+1));
 152                 for (j=0; (value=va_arg(ap, char *)) && j < MAX_MOD_VALUES; j++) {
 153                         values[j] = value;
 154                 }
 155                 values[j] = NULL;
 156                 mods[i] = malloc(sizeof(LDAPMod));
 157                 mods[i]->mod_type = name;
 158                 mods[i]->mod_op = LDAP_MOD_ADD;
 159                 mods[i]->mod_values = values;
 160         }
 161         mods[i] = NULL;
 162         va_end(ap);
 163
 164         ret = ldap_add_s(ads->ld, new_dn, mods);
 165
 166         for (i=0; mods[i]; i++) {
 167                 free(mods[i]->mod_values);
 168                 free(mods[i]);
 169         }
 170         free(mods);
 171
 172         return ADS_ERROR(ret);
 173 }
 174
 175 /*
 176   add a machine account to the ADS server
 177 */
 178 static ADS_STATUS ads_add_machine_acct(ADS_STRUCT *ads, const char *hostname,
 179                                        const char *org_unit)
 180 {
 181         ADS_STATUS ret;
 182         char *host_spn, *host_upn, *new_dn, *samAccountName, *controlstr;
 183
 184         asprintf(&host_spn, "HOST/%s", hostname);
 185         asprintf(&host_upn, "%s@%s", host_spn, ads->realm);
 186         asprintf(&new_dn, "cn=%s,cn=%s,%s", hostname, org_unit, ads->bind_path);
 187         asprintf(&samAccountName, "%s$", hostname);
 188         asprintf(&controlstr, "%u",
 189                 UF_DONT_EXPIRE_PASSWD | UF_WORKSTATION_TRUST_ACCOUNT |
 190                 UF_TRUSTED_FOR_DELEGATION | UF_USE_DES_KEY_ONLY);
 191
 192         ret = ads_gen_add(ads, new_dn,
 193                            "cn", hostname, NULL,
 194                            "sAMAccountName", samAccountName, NULL,
 195                            "objectClass",
 196                               "top", "person", "organizationalPerson",
 197                               "user", "computer", NULL,
 198                            "userPrincipalName", host_upn, NULL,
 199                            "servicePrincipalName", host_spn, NULL,
 200                            "dNSHostName", hostname, NULL,
 201                            "userAccountControl", controlstr, NULL,
 202                            "operatingSystem", "Samba", NULL,
 203                            "operatingSystemVersion", VERSION, NULL,
 204                            NULL);
 205
 206         free(host_spn);
 207         free(host_upn);
 208         free(new_dn);
 209         free(samAccountName);
 210         free(controlstr);
 211
 212         return ret;
 213 }
 214
 215 /*
 216   dump a binary result from ldap
 217 */
 218 static void dump_binary(const char *field, struct berval **values)
 219 {
 220         int i, j;
 221         for (i=0; values[i]; i++) {
 222                 printf("%s: ", field);
 223                 for (j=0; j<values[i]->bv_len; j++) {
 224                         printf("%02X", (unsigned char)values[i]->bv_val[j]);
 225                 }
 226                 printf("\n");
 227         }
 228 }
 229
 230 /*
 231   dump a sid result from ldap
 232 */
 233 static void dump_sid(const char *field, struct berval **values)
 234 {
 235         int i;
 236         for (i=0; values[i]; i++) {
 237                 DOM_SID sid;
 238                 sid_parse(values[i]->bv_val, values[i]->bv_len, &sid);
 239                 printf("%s: %s\n", field, sid_string_static(&sid));
 240         }
 241 }
 242
 243 /*
 244   dump a string result from ldap
 245 */
 246 static void dump_string(const char *field, struct berval **values)
 247 {
 248         int i;
 249         for (i=0; values[i]; i++) {
 250                 printf("%s: %s\n", field, values[i]->bv_val);
 251         }
 252 }
 253
 254 /*
 255   dump a record from LDAP on stdout
 256   used for debugging
 257 */
 258 void ads_dump(ADS_STRUCT *ads, void *res)
 259 {
 260         char *field;
 261         void *msg;
 262         BerElement *b;
 263         struct {
 264                 char *name;
 265                 void (*handler)(const char *, struct berval **);
 266         } handlers[] = {
 267                 {"objectGUID", dump_binary},
 268                 {"nTSecurityDescriptor", dump_binary},
 269                 {"objectSid", dump_sid},
 270                 {NULL, NULL}
 271         };
 272
 273         for (msg = ads_first_entry(ads, res); msg; msg = ads_next_entry(ads, msg)) {
 274                 for (field = ldap_first_attribute(ads->ld, (LDAPMessage *)msg, &b);
 275                      field;
 276                      field = ldap_next_attribute(ads->ld, (LDAPMessage *)msg, b)) {
 277                         struct berval **values;
 278                         int i;
 279
 280                         values = ldap_get_values_len(ads->ld, (LDAPMessage *)msg, field);
 281
 282                         for (i=0; handlers[i].name; i++) {
 283                                 if (StrCaseCmp(handlers[i].name, field) == 0) {
 284                                         handlers[i].handler(field, values);
 285                                         break;
 286                                 }
 287                         }
 288                         if (!handlers[i].name) {
 289                                 dump_string(field, values);
 290                         }
 291                         ldap_value_free_len(values);
 292                         ldap_memfree(field);
 293                 }
 294
 295                 ber_free(b, 1);
 296                 printf("\n");
 297         }
 298 }
 299
 300 /*
 301   count how many replies are in a LDAPMessage
 302 */
 303 int ads_count_replies(ADS_STRUCT *ads, void *res)
 304 {
 305         return ldap_count_entries(ads->ld, (LDAPMessage *)res);
 306 }
 307
 308 /*
 309   join a machine to a realm, creating the machine account
 310   and setting the machine password
 311 */
 312 ADS_STATUS ads_join_realm(ADS_STRUCT *ads, const char *hostname, const char *org_unit)
 313 {
 314         ADS_STATUS status;
 315         LDAPMessage *res;
 316         char *host;
 317
 318         /* hostname must be lowercase */
 319         host = strdup(hostname);
 320         strlower(host);
 321
 322         status = ads_find_machine_acct(ads, (void **)&res, host);
 323         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
 324                 DEBUG(0, ("Host account for %s already exists - deleting for readd\n", host));
 325                 status = ads_leave_realm(ads, host);
 326                 if (!ADS_ERR_OK(status)) {
 327                         DEBUG(0, ("Failed to delete host '%s' from the '%s' realm.\n",
 328                                   host, ads->realm));
 329                         return status;
 330                 }
 331         }
 332
 333         status = ads_add_machine_acct(ads, host, org_unit);
 334         if (!ADS_ERR_OK(status)) {
 335                 DEBUG(0, ("ads_add_machine_acct: %s\n", ads_errstr(status)));
 336                 return status;
 337         }
 338
 339         status = ads_find_machine_acct(ads, (void **)&res, host);
 340         if (!ADS_ERR_OK(status)) {
 341                 DEBUG(0, ("Host account test failed\n"));
 342                 return status;
 343         }
 344
 345         free(host);
 346
 347         return status;
 348 }
 349
 350 /*
 351   delete a machine from the realm
 352 */
 353 ADS_STATUS ads_leave_realm(ADS_STRUCT *ads, const char *hostname)
 354 {
 355         ADS_STATUS status;
 356         void *res;
 357         char *hostnameDN, *host;
 358         int rc;
 359
 360         /* hostname must be lowercase */
 361         host = strdup(hostname);
 362         strlower(host);
 363
 364         status = ads_find_machine_acct(ads, &res, host);
 365         if (!ADS_ERR_OK(status)) {
 366             DEBUG(0, ("Host account for %s does not exist.\n", host));
 367             return status;
 368         }
 369
 370         hostnameDN = ldap_get_dn(ads->ld, (LDAPMessage *)res);
 371         rc = ldap_delete_s(ads->ld, hostnameDN);
 372         ldap_memfree(hostnameDN);
 373         if (rc != LDAP_SUCCESS) {
 374                 return ADS_ERROR(rc);
 375         }
 376
 377         status = ads_find_machine_acct(ads, &res, host);
 378         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
 379                 DEBUG(0, ("Failed to remove host account.\n"));
 380                 return status;
 381         }
 382
 383         free(host);
 384
 385         return status;
 386 }
 387
 388
 389 ADS_STATUS ads_set_machine_password(ADS_STRUCT *ads,
 390                                     const char *hostname,
 391                                     const char *password)
 392 {
 393         ADS_STATUS status;
 394         char *host = strdup(hostname);
 395         char *principal;
 396
 397         strlower(host);
 398
 399         asprintf(&principal, "%s@%s", host, ads->realm);
 400
 401         status = krb5_set_password(ads->kdc_server, principal, password);
 402
 403         free(host);
 404         free(principal);
 405
 406         return status;
 407 }
 408
 409 /*
 410   pull the first entry from a ADS result
 411 */
 412 void *ads_first_entry(ADS_STRUCT *ads, void *res)
 413 {
 414         return (void *)ldap_first_entry(ads->ld, (LDAPMessage *)res);
 415 }
 416
 417 /*
 418   pull the next entry from a ADS result
 419 */
 420 void *ads_next_entry(ADS_STRUCT *ads, void *res)
 421 {
 422         return (void *)ldap_next_entry(ads->ld, (LDAPMessage *)res);
 423 }
 424
 425 /*
 426   pull a single string from a ADS result
 427 */
 428 char *ads_pull_string(ADS_STRUCT *ads,
 429                       TALLOC_CTX *mem_ctx, void *msg, const char *field)
 430 {
 431         char **values;
 432         char *ret = NULL;
 433
 434         values = ldap_get_values(ads->ld, msg, field);
 435         if (!values) return NULL;
 436
 437         if (values[0]) {
 438                 ret = talloc_strdup(mem_ctx, values[0]);
 439         }
 440         ldap_value_free(values);
 441         return ret;
 442 }
 443
 444 /*
 445   pull a single uint32 from a ADS result
 446 */
 447 BOOL ads_pull_uint32(ADS_STRUCT *ads,
 448                      void *msg, const char *field, uint32 *v)
 449 {
 450         char **values;
 451
 452         values = ldap_get_values(ads->ld, msg, field);
 453         if (!values) return False;
 454         if (!values[0]) {
 455                 ldap_value_free(values);
 456                 return False;
 457         }
 458
 459         *v = atoi(values[0]);
 460         ldap_value_free(values);
 461         return True;
 462 }
 463
 464 /*
 465   pull a single DOM_SID from a ADS result
 466 */
 467 BOOL ads_pull_sid(ADS_STRUCT *ads,
 468                   void *msg, const char *field, DOM_SID *sid)
 469 {
 470         struct berval **values;
 471         BOOL ret = False;
 472
 473         values = ldap_get_values_len(ads->ld, msg, field);
 474
 475         if (!values) return False;
 476
 477         if (values[0]) {
 478                 ret = sid_parse(values[0]->bv_val, values[0]->bv_len, sid);
 479         }
 480
 481         ldap_value_free_len(values);
 482         return ret;
 483 }
 484
 485 /*
 486   pull an array of DOM_SIDs from a ADS result
 487   return the count of SIDs pulled
 488 */
 489 int ads_pull_sids(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
 490                   void *msg, const char *field, DOM_SID **sids)
 491 {
 492         struct berval **values;
 493         BOOL ret;
 494         int count, i;
 495
 496         values = ldap_get_values_len(ads->ld, msg, field);
 497
 498         if (!values) return 0;
 499
 500         for (i=0; values[i]; i++) /* nop */ ;
 501
 502         (*sids) = talloc(mem_ctx, sizeof(DOM_SID) * i);
 503
 504         count = 0;
 505         for (i=0; values[i]; i++) {
 506                 ret = sid_parse(values[i]->bv_val, values[i]->bv_len, &(*sids)[count]);
 507                 if (ret) count++;
 508         }
 509
 510         ldap_value_free_len(values);
 511         return count;
 512 }
 513
 514
 515 /* find the update serial number - this is the core of the ldap cache */
 516 ADS_STATUS ads_USN(ADS_STRUCT *ads, uint32 *usn)
 517 {
 518         const char *attrs[] = {"highestCommittedUSN", NULL};
 519         ADS_STATUS status;
 520         void *res;
 521
 522         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
 523         if (!ADS_ERR_OK(status)) return status;
 524
 525         if (ads_count_replies(ads, res) != 1) {
 526                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 527         }
 528
 529         ads_pull_uint32(ads, res, "highestCommittedUSN", usn);
 530         ads_msgfree(ads, res);
 531         return ADS_SUCCESS;
 532 }
 533
 534
 535 /* find the servers name and realm - this can be done before authentication
 536    The ldapServiceName field on w2k  looks like this:
 537      vnet3.home.samba.org:win2000-vnet3$@VNET3.HOME.SAMBA.ORG
 538 */
 539 ADS_STATUS ads_server_info(ADS_STRUCT *ads)
 540 {
 541         const char *attrs[] = {"ldapServiceName", NULL};
 542         ADS_STATUS status;
 543         void *res;
 544         char **values;
 545         char *p;
 546
 547         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
 548         if (!ADS_ERR_OK(status)) return status;
 549
 550         values = ldap_get_values(ads->ld, res, "ldapServiceName");
 551         if (!values || !values[0]) return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 552
 553         p = strchr(values[0], ':');
 554         if (!p) {
 555                 ldap_value_free(values);
 556                 ldap_msgfree(res);
 557                 return ADS_ERROR(LDAP_DECODING_ERROR);
 558         }
 559
 560         SAFE_FREE(ads->ldap_server_name);
 561
 562         ads->ldap_server_name = strdup(p+1);
 563         p = strchr(ads->ldap_server_name, '$');
 564         if (!p || p[1] != '@') {
 565                 ldap_value_free(values);
 566                 ldap_msgfree(res);
 567                 SAFE_FREE(ads->ldap_server_name);
 568                 return ADS_ERROR(LDAP_DECODING_ERROR);
 569         }
 570
 571         *p = 0;
 572
 573         SAFE_FREE(ads->server_realm);
 574         SAFE_FREE(ads->bind_path);
 575
 576         ads->server_realm = strdup(p+2);
 577         ads->bind_path = ads_build_dn(ads->server_realm);
 578
 579         /* in case the realm isn't configured in smb.conf */
 580         if (!ads->realm || !ads->realm[0]) {
 581                 SAFE_FREE(ads->realm);
 582                 ads->realm = strdup(ads->server_realm);
 583         }
 584
 585         DEBUG(3,("got ldap server name %s@%s\n",
 586                  ads->ldap_server_name, ads->realm));
 587
 588         return ADS_SUCCESS;
 589 }
 590
 591
 592 /*
 593    find the list of trusted domains
 594 */
 595 ADS_STATUS ads_trusted_domains(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
 596                                int *num_trusts, char ***names, DOM_SID **sids)
 597 {
 598         const char *attrs[] = {"flatName", "securityIdentifier", NULL};
 599         ADS_STATUS status;
 600         void *res, *msg;
 601         int count, i;
 602
 603         *num_trusts = 0;
 604
 605         status = ads_search(ads, &res, "(objectcategory=trustedDomain)", attrs);
 606         if (!ADS_ERR_OK(status)) return status;
 607
 608         count = ads_count_replies(ads, res);
 609         if (count == 0) {
 610                 ads_msgfree(ads, res);
 611                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 612         }
 613
 614         (*names) = talloc(mem_ctx, sizeof(char *) * count);
 615         (*sids) = talloc(mem_ctx, sizeof(DOM_SID) * count);
 616         if (! *names || ! *sids) return ADS_ERROR(LDAP_NO_MEMORY);
 617
 618         for (i=0, msg = ads_first_entry(ads, res); msg; msg = ads_next_entry(ads, msg)) {
 619                 (*names)[i] = ads_pull_string(ads, mem_ctx, msg, "flatName");
 620                 ads_pull_sid(ads, msg, "securityIdentifier", &(*sids)[i]);
 621                 i++;
 622         }
 623
 624         ads_msgfree(ads, res);
 625
 626         *num_trusts = i;
 627
 628         return ADS_SUCCESS;
 629 }
 630
 631 /* find the domain sid for our domain */
 632 ADS_STATUS ads_domain_sid(ADS_STRUCT *ads, DOM_SID *sid)
 633 {
 634         const char *attrs[] = {"objectSid", NULL};
 635         void *res;
 636         ADS_STATUS rc;
 637
 638         rc = ads_do_search(ads, ads->bind_path, LDAP_SCOPE_BASE, "(objectclass=*)",
 639                            attrs, &res);
 640         if (!ADS_ERR_OK(rc)) return rc;
 641         if (!ads_pull_sid(ads, res, "objectSid", sid)) {
 642                 return ADS_ERROR_SYSTEM(ENOENT);
 643         }
 644         ads_msgfree(ads, res);
 645
 646         return ADS_SUCCESS;
 647 }
 648
 649 #endif