1/* 2 Unix SMB/CIFS implementation. 3 4 Extract the user/system database from a remote server 5 6 Copyright (C) Stefan Metzmacher 2004-2006 7 Copyright (C) Brad Henry 2005 8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2008 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. 22*/ 23 24 25#include "includes.h" 26#include "libnet/libnet.h" 27#include "lib/events/events.h" 28#include "dsdb/samdb/samdb.h" 29#include "../lib/util/dlinklist.h" 30#include "lib/ldb/include/ldb.h" 31#include "lib/ldb/include/ldb_errors.h" 32#include "librpc/ndr/libndr.h" 33#include "librpc/gen_ndr/ndr_drsuapi.h" 34#include "librpc/gen_ndr/ndr_drsblobs.h" 35#include "librpc/gen_ndr/ndr_misc.h" 36#include "system/time.h" 37#include "lib/ldb_wrap.h" 38#include "auth/auth.h" 39#include "param/param.h" 40#include "param/provision.h" 41#include "libcli/security/dom_sid.h" 42 43/* 44List of tasks vampire.py must perform: 45- Domain Join 46 - but don't write the secrets.ldb 47 - results for this should be enough to handle the provision 48- if vampire method is samsync 49 - Provision using these results 50 - do we still want to support this NT4 technology? 51- Start samsync with libnet code 52 - provision in the callback 53- Write out the secrets database, using the code from libnet_Join 54 55*/ 56struct vampire_state { 57 const char *netbios_name; 58 struct libnet_JoinDomain *join; 59 struct cli_credentials *machine_account; 60 struct dsdb_schema *self_made_schema; 61 const struct dsdb_schema *schema; 62 63 struct ldb_context *ldb; 64 65 struct { 66 uint32_t object_count; 67 struct drsuapi_DsReplicaObjectListItemEx *first_object; 68 struct drsuapi_DsReplicaObjectListItemEx *last_object; 69 } schema_part; 70 71 const char *targetdir; 72 73 struct loadparm_context *lp_ctx; 74 struct tevent_context *event_ctx; 75 unsigned total_objects; 76 char *last_partition; 77}; 78 79static NTSTATUS vampire_prepare_db(void *private_data, 80 const struct libnet_BecomeDC_PrepareDB *p) 81{ 82 struct vampire_state *s = talloc_get_type(private_data, struct vampire_state); 83 struct provision_settings settings; 84 struct provision_result result; 85 NTSTATUS status; 86 87 ZERO_STRUCT(settings); 88 settings.site_name = p->dest_dsa->site_name; 89 settings.root_dn_str = p->forest->root_dn_str; 90 settings.domain_dn_str = p->domain->dn_str; 91 settings.config_dn_str = p->forest->config_dn_str; 92 settings.schema_dn_str = p->forest->schema_dn_str; 93 settings.netbios_name = p->dest_dsa->netbios_name; 94 settings.realm = s->join->out.realm; 95 settings.domain = s->join->out.domain_name; 96 settings.server_dn_str = p->dest_dsa->server_dn_str; 97 settings.machine_password = generate_random_str(s, 16); 98 settings.targetdir = s->targetdir; 99 100 status = provision_bare(s, s->lp_ctx, &settings, &result); 101 102 if (!NT_STATUS_IS_OK(status)) { 103 return status; 104 } 105 106 s->ldb = result.samdb; 107 s->lp_ctx = result.lp_ctx; 108 109 /* wrap the entire vapire operation in a transaction. This 110 isn't just cosmetic - we use this to ensure that linked 111 attribute back links are added at the end by relying on a 112 transaction commit hook in the linked attributes module. We 113 need to do this as the order of objects coming from the 114 server is not sufficiently deterministic to know that the 115 record that a backlink needs to be created in has itself 116 been created before the object containing the forward link 117 has come over the wire */ 118 if (ldb_transaction_start(s->ldb) != LDB_SUCCESS) { 119 return NT_STATUS_FOOBAR; 120 } 121 122 return NT_STATUS_OK; 123 124 125} 126 127static NTSTATUS vampire_check_options(void *private_data, 128 const struct libnet_BecomeDC_CheckOptions *o) 129{ 130 struct vampire_state *s = talloc_get_type(private_data, struct vampire_state); 131 132 DEBUG(0,("Become DC [%s] of Domain[%s]/[%s]\n", 133 s->netbios_name, 134 o->domain->netbios_name, o->domain->dns_name)); 135 136 DEBUG(0,("Promotion Partner is Server[%s] from Site[%s]\n", 137 o->source_dsa->dns_name, o->source_dsa->site_name)); 138 139 DEBUG(0,("Options:crossRef behavior_version[%u]\n" 140 "\tschema object_version[%u]\n" 141 "\tdomain behavior_version[%u]\n" 142 "\tdomain w2k3_update_revision[%u]\n", 143 o->forest->crossref_behavior_version, 144 o->forest->schema_object_version, 145 o->domain->behavior_version, 146 o->domain->w2k3_update_revision)); 147 148 return NT_STATUS_OK; 149} 150 151static NTSTATUS vampire_apply_schema(struct vampire_state *s, 152 const struct libnet_BecomeDC_StoreChunk *c) 153{ 154 WERROR status; 155 const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr; 156 uint32_t object_count; 157 struct drsuapi_DsReplicaObjectListItemEx *first_object; 158 struct drsuapi_DsReplicaObjectListItemEx *cur; 159 uint32_t linked_attributes_count; 160 struct drsuapi_DsReplicaLinkedAttribute *linked_attributes; 161 const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector; 162 struct dsdb_extended_replicated_objects *objs; 163 struct repsFromTo1 *s_dsa; 164 char *tmp_dns_name; 165 struct ldb_message *msg; 166 struct ldb_val prefixMap_val; 167 struct ldb_message_element *prefixMap_el; 168 struct ldb_val schemaInfo_val; 169 uint32_t i; 170 int ret; 171 bool ok; 172 uint64_t seq_num; 173 174 DEBUG(0,("Analyze and apply schema objects\n")); 175 176 s_dsa = talloc_zero(s, struct repsFromTo1); 177 NT_STATUS_HAVE_NO_MEMORY(s_dsa); 178 s_dsa->other_info = talloc(s_dsa, struct repsFromTo1OtherInfo); 179 NT_STATUS_HAVE_NO_MEMORY(s_dsa->other_info); 180 181 switch (c->ctr_level) { 182 case 1: 183 mapping_ctr = &c->ctr1->mapping_ctr; 184 object_count = s->schema_part.object_count; 185 first_object = s->schema_part.first_object; 186 linked_attributes_count = 0; 187 linked_attributes = NULL; 188 s_dsa->highwatermark = c->ctr1->new_highwatermark; 189 s_dsa->source_dsa_obj_guid = c->ctr1->source_dsa_guid; 190 s_dsa->source_dsa_invocation_id = c->ctr1->source_dsa_invocation_id; 191 uptodateness_vector = NULL; /* TODO: map it */ 192 break; 193 case 6: 194 mapping_ctr = &c->ctr6->mapping_ctr; 195 object_count = s->schema_part.object_count; 196 first_object = s->schema_part.first_object; 197 linked_attributes_count = c->ctr6->linked_attributes_count; 198 linked_attributes = c->ctr6->linked_attributes; 199 s_dsa->highwatermark = c->ctr6->new_highwatermark; 200 s_dsa->source_dsa_obj_guid = c->ctr6->source_dsa_guid; 201 s_dsa->source_dsa_invocation_id = c->ctr6->source_dsa_invocation_id; 202 uptodateness_vector = c->ctr6->uptodateness_vector; 203 break; 204 default: 205 return NT_STATUS_INVALID_PARAMETER; 206 } 207 208 s_dsa->replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE 209 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP 210 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS; 211 memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule)); 212 213 tmp_dns_name = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid); 214 NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name); 215 tmp_dns_name = talloc_asprintf_append_buffer(tmp_dns_name, "._msdcs.%s", c->forest->dns_name); 216 NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name); 217 s_dsa->other_info->dns_name = tmp_dns_name; 218 219 for (cur = first_object; cur; cur = cur->next_object) { 220 bool is_attr = false; 221 bool is_class = false; 222 223 for (i=0; i < cur->object.attribute_ctr.num_attributes; i++) { 224 struct drsuapi_DsReplicaAttribute *a; 225 uint32_t j; 226 const char *oid = NULL; 227 228 a = &cur->object.attribute_ctr.attributes[i]; 229 status = dsdb_map_int2oid(s->self_made_schema, a->attid, s, &oid); 230 if (!W_ERROR_IS_OK(status)) { 231 return werror_to_ntstatus(status); 232 } 233 234 switch (a->attid) { 235 case DRSUAPI_ATTRIBUTE_objectClass: 236 for (j=0; j < a->value_ctr.num_values; j++) { 237 uint32_t val = 0xFFFFFFFF; 238 239 if (a->value_ctr.values[j].blob 240 && a->value_ctr.values[j].blob->length == 4) { 241 val = IVAL(a->value_ctr.values[j].blob->data,0); 242 } 243 244 if (val == DRSUAPI_OBJECTCLASS_attributeSchema) { 245 is_attr = true; 246 } 247 if (val == DRSUAPI_OBJECTCLASS_classSchema) { 248 is_class = true; 249 } 250 } 251 252 break; 253 default: 254 break; 255 } 256 } 257 258 if (is_attr) { 259 struct dsdb_attribute *sa; 260 261 sa = talloc_zero(s->self_made_schema, struct dsdb_attribute); 262 NT_STATUS_HAVE_NO_MEMORY(sa); 263 264 status = dsdb_attribute_from_drsuapi(s->ldb, s->self_made_schema, &cur->object, s, sa); 265 if (!W_ERROR_IS_OK(status)) { 266 return werror_to_ntstatus(status); 267 } 268 269 DLIST_ADD_END(s->self_made_schema->attributes, sa, struct dsdb_attribute *); 270 } 271 272 if (is_class) { 273 struct dsdb_class *sc; 274 275 sc = talloc_zero(s->self_made_schema, struct dsdb_class); 276 NT_STATUS_HAVE_NO_MEMORY(sc); 277 278 status = dsdb_class_from_drsuapi(s->self_made_schema, &cur->object, s, sc); 279 if (!W_ERROR_IS_OK(status)) { 280 return werror_to_ntstatus(status); 281 } 282 283 DLIST_ADD_END(s->self_made_schema->classes, sc, struct dsdb_class *); 284 } 285 } 286 287 /* attach the schema to the ldb */ 288 ret = dsdb_set_schema(s->ldb, s->self_made_schema); 289 if (ret != LDB_SUCCESS) { 290 return NT_STATUS_FOOBAR; 291 } 292 /* we don't want to access the self made schema anymore */ 293 s->self_made_schema = NULL; 294 s->schema = dsdb_get_schema(s->ldb); 295 296 status = dsdb_extended_replicated_objects_commit(s->ldb, 297 c->partition->nc.dn, 298 mapping_ctr, 299 object_count, 300 first_object, 301 linked_attributes_count, 302 linked_attributes, 303 s_dsa, 304 uptodateness_vector, 305 c->gensec_skey, 306 s, &objs, &seq_num); 307 if (!W_ERROR_IS_OK(status)) { 308 DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status))); 309 return werror_to_ntstatus(status); 310 } 311 312 if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) { 313 for (i=0; i < objs->num_objects; i++) { 314 struct ldb_ldif ldif; 315 fprintf(stdout, "#\n"); 316 ldif.changetype = LDB_CHANGETYPE_NONE; 317 ldif.msg = objs->objects[i].msg; 318 ldb_ldif_write_file(s->ldb, stdout, &ldif); 319 NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data); 320 } 321 } 322 323 msg = ldb_msg_new(objs); 324 NT_STATUS_HAVE_NO_MEMORY(msg); 325 msg->dn = objs->partition_dn; 326 327 status = dsdb_get_oid_mappings_ldb(s->schema, msg, &prefixMap_val, &schemaInfo_val); 328 if (!W_ERROR_IS_OK(status)) { 329 DEBUG(0,("Failed dsdb_get_oid_mappings_ldb(%s)\n", win_errstr(status))); 330 return werror_to_ntstatus(status); 331 } 332 333 /* we only add prefixMap here, because schemaInfo is a replicated attribute and already applied */ 334 ret = ldb_msg_add_value(msg, "prefixMap", &prefixMap_val, &prefixMap_el); 335 if (ret != LDB_SUCCESS) { 336 return NT_STATUS_FOOBAR; 337 } 338 prefixMap_el->flags = LDB_FLAG_MOD_REPLACE; 339 340 ret = ldb_modify(s->ldb, msg); 341 if (ret != LDB_SUCCESS) { 342 DEBUG(0,("Failed to add prefixMap and schemaInfo %s\n", ldb_strerror(ret))); 343 return NT_STATUS_FOOBAR; 344 } 345 346 talloc_free(s_dsa); 347 talloc_free(objs); 348 349 /* We must set these up to ensure the replMetaData is written 350 * correctly, before our NTDS Settings entry is replicated */ 351 ok = samdb_set_ntds_invocation_id(s->ldb, &c->dest_dsa->invocation_id); 352 if (!ok) { 353 DEBUG(0,("Failed to set cached ntds invocationId\n")); 354 return NT_STATUS_FOOBAR; 355 } 356 ok = samdb_set_ntds_objectGUID(s->ldb, &c->dest_dsa->ntds_guid); 357 if (!ok) { 358 DEBUG(0,("Failed to set cached ntds objectGUID\n")); 359 return NT_STATUS_FOOBAR; 360 } 361 362 s->schema = dsdb_get_schema(s->ldb); 363 if (!s->schema) { 364 DEBUG(0,("Failed to get loaded dsdb_schema\n")); 365 return NT_STATUS_FOOBAR; 366 } 367 368 return NT_STATUS_OK; 369} 370 371static NTSTATUS vampire_schema_chunk(void *private_data, 372 const struct libnet_BecomeDC_StoreChunk *c) 373{ 374 struct vampire_state *s = talloc_get_type(private_data, struct vampire_state); 375 WERROR status; 376 const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr; 377 uint32_t nc_object_count; 378 uint32_t object_count; 379 struct drsuapi_DsReplicaObjectListItemEx *first_object; 380 struct drsuapi_DsReplicaObjectListItemEx *cur; 381 uint32_t nc_linked_attributes_count; 382 uint32_t linked_attributes_count; 383 struct drsuapi_DsReplicaLinkedAttribute *linked_attributes; 384 385 switch (c->ctr_level) { 386 case 1: 387 mapping_ctr = &c->ctr1->mapping_ctr; 388 nc_object_count = c->ctr1->extended_ret; /* maybe w2k send this unexpected? */ 389 object_count = c->ctr1->object_count; 390 first_object = c->ctr1->first_object; 391 nc_linked_attributes_count = 0; 392 linked_attributes_count = 0; 393 linked_attributes = NULL; 394 break; 395 case 6: 396 mapping_ctr = &c->ctr6->mapping_ctr; 397 nc_object_count = c->ctr6->nc_object_count; 398 object_count = c->ctr6->object_count; 399 first_object = c->ctr6->first_object; 400 nc_linked_attributes_count = c->ctr6->nc_linked_attributes_count; 401 linked_attributes_count = c->ctr6->linked_attributes_count; 402 linked_attributes = c->ctr6->linked_attributes; 403 break; 404 default: 405 return NT_STATUS_INVALID_PARAMETER; 406 } 407 408 if (nc_object_count) { 409 DEBUG(0,("Schema-DN[%s] objects[%u/%u] linked_values[%u/%u]\n", 410 c->partition->nc.dn, object_count, nc_object_count, 411 linked_attributes_count, nc_linked_attributes_count)); 412 } else { 413 DEBUG(0,("Schema-DN[%s] objects[%u] linked_values[%u]\n", 414 c->partition->nc.dn, object_count, linked_attributes_count)); 415 } 416 417 if (!s->schema) { 418 s->self_made_schema = dsdb_new_schema(s, lp_iconv_convenience(s->lp_ctx)); 419 420 NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema); 421 422 status = dsdb_load_oid_mappings_drsuapi(s->self_made_schema, mapping_ctr); 423 if (!W_ERROR_IS_OK(status)) { 424 return werror_to_ntstatus(status); 425 } 426 427 s->schema = s->self_made_schema; 428 } else { 429 status = dsdb_verify_oid_mappings_drsuapi(s->schema, mapping_ctr); 430 if (!W_ERROR_IS_OK(status)) { 431 return werror_to_ntstatus(status); 432 } 433 } 434 435 if (!s->schema_part.first_object) { 436 s->schema_part.object_count = object_count; 437 s->schema_part.first_object = talloc_steal(s, first_object); 438 } else { 439 s->schema_part.object_count += object_count; 440 s->schema_part.last_object->next_object = talloc_steal(s->schema_part.last_object, 441 first_object); 442 } 443 for (cur = first_object; cur->next_object; cur = cur->next_object) {} 444 s->schema_part.last_object = cur; 445 446 if (!c->partition->more_data) { 447 return vampire_apply_schema(s, c); 448 } 449 450 return NT_STATUS_OK; 451} 452 453static NTSTATUS vampire_store_chunk(void *private_data, 454 const struct libnet_BecomeDC_StoreChunk *c) 455{ 456 struct vampire_state *s = talloc_get_type(private_data, struct vampire_state); 457 WERROR status; 458 const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr; 459 uint32_t nc_object_count; 460 uint32_t object_count; 461 struct drsuapi_DsReplicaObjectListItemEx *first_object; 462 uint32_t nc_linked_attributes_count; 463 uint32_t linked_attributes_count; 464 struct drsuapi_DsReplicaLinkedAttribute *linked_attributes; 465 const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector; 466 struct dsdb_extended_replicated_objects *objs; 467 struct repsFromTo1 *s_dsa; 468 char *tmp_dns_name; 469 uint32_t i; 470 uint64_t seq_num; 471 472 s_dsa = talloc_zero(s, struct repsFromTo1); 473 NT_STATUS_HAVE_NO_MEMORY(s_dsa); 474 s_dsa->other_info = talloc(s_dsa, struct repsFromTo1OtherInfo); 475 NT_STATUS_HAVE_NO_MEMORY(s_dsa->other_info); 476 477 switch (c->ctr_level) { 478 case 1: 479 mapping_ctr = &c->ctr1->mapping_ctr; 480 nc_object_count = c->ctr1->extended_ret; /* maybe w2k send this unexpected? */ 481 object_count = c->ctr1->object_count; 482 first_object = c->ctr1->first_object; 483 nc_linked_attributes_count = 0; 484 linked_attributes_count = 0; 485 linked_attributes = NULL; 486 s_dsa->highwatermark = c->ctr1->new_highwatermark; 487 s_dsa->source_dsa_obj_guid = c->ctr1->source_dsa_guid; 488 s_dsa->source_dsa_invocation_id = c->ctr1->source_dsa_invocation_id; 489 uptodateness_vector = NULL; /* TODO: map it */ 490 break; 491 case 6: 492 mapping_ctr = &c->ctr6->mapping_ctr; 493 nc_object_count = c->ctr6->nc_object_count; 494 object_count = c->ctr6->object_count; 495 first_object = c->ctr6->first_object; 496 nc_linked_attributes_count = c->ctr6->nc_linked_attributes_count; 497 linked_attributes_count = c->ctr6->linked_attributes_count; 498 linked_attributes = c->ctr6->linked_attributes; 499 s_dsa->highwatermark = c->ctr6->new_highwatermark; 500 s_dsa->source_dsa_obj_guid = c->ctr6->source_dsa_guid; 501 s_dsa->source_dsa_invocation_id = c->ctr6->source_dsa_invocation_id; 502 uptodateness_vector = c->ctr6->uptodateness_vector; 503 break; 504 default: 505 return NT_STATUS_INVALID_PARAMETER; 506 } 507 508 s_dsa->replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE 509 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP 510 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS; 511 memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule)); 512 513 tmp_dns_name = GUID_string(s_dsa->other_info, &s_dsa->source_dsa_obj_guid); 514 NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name); 515 tmp_dns_name = talloc_asprintf_append_buffer(tmp_dns_name, "._msdcs.%s", c->forest->dns_name); 516 NT_STATUS_HAVE_NO_MEMORY(tmp_dns_name); 517 s_dsa->other_info->dns_name = tmp_dns_name; 518 519 /* we want to show a count per partition */ 520 if (!s->last_partition || strcmp(s->last_partition, c->partition->nc.dn) != 0) { 521 s->total_objects = 0; 522 talloc_free(s->last_partition); 523 s->last_partition = talloc_strdup(s, c->partition->nc.dn); 524 } 525 s->total_objects += object_count; 526 527 if (nc_object_count) { 528 DEBUG(0,("Partition[%s] objects[%u/%u] linked_values[%u/%u]\n", 529 c->partition->nc.dn, s->total_objects, nc_object_count, 530 linked_attributes_count, nc_linked_attributes_count)); 531 } else { 532 DEBUG(0,("Partition[%s] objects[%u] linked_values[%u]\n", 533 c->partition->nc.dn, s->total_objects, linked_attributes_count)); 534 } 535 536 537 status = dsdb_extended_replicated_objects_commit(s->ldb, 538 c->partition->nc.dn, 539 mapping_ctr, 540 object_count, 541 first_object, 542 linked_attributes_count, 543 linked_attributes, 544 s_dsa, 545 uptodateness_vector, 546 c->gensec_skey, 547 s, &objs, &seq_num); 548 if (!W_ERROR_IS_OK(status)) { 549 DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status))); 550 return werror_to_ntstatus(status); 551 } 552 553 if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) { 554 for (i=0; i < objs->num_objects; i++) { 555 struct ldb_ldif ldif; 556 fprintf(stdout, "#\n"); 557 ldif.changetype = LDB_CHANGETYPE_NONE; 558 ldif.msg = objs->objects[i].msg; 559 ldb_ldif_write_file(s->ldb, stdout, &ldif); 560 NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data); 561 } 562 } 563 talloc_free(s_dsa); 564 talloc_free(objs); 565 566 for (i=0; i < linked_attributes_count; i++) { 567 const struct dsdb_attribute *sa; 568 569 if (!linked_attributes[i].identifier) { 570 return NT_STATUS_FOOBAR; 571 } 572 573 if (!linked_attributes[i].value.blob) { 574 return NT_STATUS_FOOBAR; 575 } 576 577 sa = dsdb_attribute_by_attributeID_id(s->schema, 578 linked_attributes[i].attid); 579 if (!sa) { 580 return NT_STATUS_FOOBAR; 581 } 582 583 if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) { 584 DEBUG(0,("# %s\n", sa->lDAPDisplayName)); 585 NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]); 586 dump_data(0, 587 linked_attributes[i].value.blob->data, 588 linked_attributes[i].value.blob->length); 589 } 590 } 591 592 return NT_STATUS_OK; 593} 594 595NTSTATUS libnet_Vampire(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, 596 struct libnet_Vampire *r) 597{ 598 struct libnet_JoinDomain *join; 599 struct provision_store_self_join_settings *set_secrets; 600 struct libnet_BecomeDC b; 601 struct vampire_state *s; 602 struct ldb_message *msg; 603 const char *error_string; 604 int ldb_ret; 605 uint32_t i; 606 NTSTATUS status; 607 608 const char *account_name; 609 const char *netbios_name; 610 611 r->out.error_string = NULL; 612 613 s = talloc_zero(mem_ctx, struct vampire_state); 614 if (!s) { 615 return NT_STATUS_NO_MEMORY; 616 } 617 618 s->lp_ctx = ctx->lp_ctx; 619 s->event_ctx = ctx->event_ctx; 620 621 join = talloc_zero(s, struct libnet_JoinDomain); 622 if (!join) { 623 return NT_STATUS_NO_MEMORY; 624 } 625 626 if (r->in.netbios_name != NULL) { 627 netbios_name = r->in.netbios_name; 628 } else { 629 netbios_name = talloc_reference(join, lp_netbios_name(ctx->lp_ctx)); 630 if (!netbios_name) { 631 r->out.error_string = NULL; 632 talloc_free(s); 633 return NT_STATUS_NO_MEMORY; 634 } 635 } 636 637 account_name = talloc_asprintf(join, "%s$", netbios_name); 638 if (!account_name) { 639 r->out.error_string = NULL; 640 talloc_free(s); 641 return NT_STATUS_NO_MEMORY; 642 } 643 644 join->in.domain_name = r->in.domain_name; 645 join->in.account_name = account_name; 646 join->in.netbios_name = netbios_name; 647 join->in.level = LIBNET_JOINDOMAIN_AUTOMATIC; 648 join->in.acct_type = ACB_WSTRUST; 649 join->in.recreate_account = false; 650 status = libnet_JoinDomain(ctx, join, join); 651 if (!NT_STATUS_IS_OK(status)) { 652 r->out.error_string = talloc_steal(mem_ctx, join->out.error_string); 653 talloc_free(s); 654 return status; 655 } 656 657 s->join = join; 658 659 s->targetdir = r->in.targetdir; 660 661 ZERO_STRUCT(b); 662 b.in.domain_dns_name = join->out.realm; 663 b.in.domain_netbios_name = join->out.domain_name; 664 b.in.domain_sid = join->out.domain_sid; 665 b.in.source_dsa_address = join->out.samr_binding->host; 666 b.in.dest_dsa_netbios_name = netbios_name; 667 668 b.in.callbacks.private_data = s; 669 b.in.callbacks.check_options = vampire_check_options; 670 b.in.callbacks.prepare_db = vampire_prepare_db; 671 b.in.callbacks.schema_chunk = vampire_schema_chunk; 672 b.in.callbacks.config_chunk = vampire_store_chunk; 673 b.in.callbacks.domain_chunk = vampire_store_chunk; 674 675 status = libnet_BecomeDC(ctx, s, &b); 676 if (!NT_STATUS_IS_OK(status)) { 677 printf("libnet_BecomeDC() failed - %s\n", nt_errstr(status)); 678 talloc_free(s); 679 return status; 680 } 681 682 msg = ldb_msg_new(s); 683 if (!msg) { 684 printf("ldb_msg_new() failed\n"); 685 talloc_free(s); 686 return NT_STATUS_NO_MEMORY; 687 } 688 msg->dn = ldb_dn_new(msg, s->ldb, "@ROOTDSE"); 689 if (!msg->dn) { 690 printf("ldb_msg_new(@ROOTDSE) failed\n"); 691 talloc_free(s); 692 return NT_STATUS_NO_MEMORY; 693 } 694 695 ldb_ret = ldb_msg_add_string(msg, "isSynchronized", "TRUE"); 696 if (ldb_ret != LDB_SUCCESS) { 697 printf("ldb_msg_add_string(msg, isSynchronized, TRUE) failed: %d\n", ldb_ret); 698 talloc_free(s); 699 return NT_STATUS_NO_MEMORY; 700 } 701 702 for (i=0; i < msg->num_elements; i++) { 703 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE; 704 } 705 706 printf("mark ROOTDSE with isSynchronized=TRUE\n"); 707 ldb_ret = ldb_modify(s->ldb, msg); 708 if (ldb_ret != LDB_SUCCESS) { 709 printf("ldb_modify() failed: %d\n", ldb_ret); 710 talloc_free(s); 711 return NT_STATUS_INTERNAL_DB_ERROR; 712 } 713 714 /* prepare the transaction - this prepares to commit all the changes in 715 the ldb from the whole vampire. Note that this 716 triggers the writing of the linked attribute backlinks. 717 */ 718 if (ldb_transaction_prepare_commit(s->ldb) != LDB_SUCCESS) { 719 printf("Failed to prepare_commit vampire transaction\n"); 720 return NT_STATUS_INTERNAL_DB_ERROR; 721 } 722 723 set_secrets = talloc(s, struct provision_store_self_join_settings); 724 if (!set_secrets) { 725 r->out.error_string = NULL; 726 talloc_free(s); 727 return NT_STATUS_NO_MEMORY; 728 } 729 730 ZERO_STRUCTP(set_secrets); 731 set_secrets->domain_name = join->out.domain_name; 732 set_secrets->realm = join->out.realm; 733 set_secrets->account_name = account_name; 734 set_secrets->netbios_name = netbios_name; 735 set_secrets->secure_channel_type = SEC_CHAN_BDC; 736 set_secrets->machine_password = join->out.join_password; 737 set_secrets->key_version_number = join->out.kvno; 738 set_secrets->domain_sid = join->out.domain_sid; 739 740 status = provision_store_self_join(ctx, ctx->lp_ctx, ctx->event_ctx, set_secrets, &error_string); 741 if (!NT_STATUS_IS_OK(status)) { 742 r->out.error_string = talloc_steal(mem_ctx, error_string); 743 talloc_free(s); 744 return status; 745 } 746 747 r->out.domain_name = talloc_steal(r, join->out.domain_name); 748 r->out.domain_sid = dom_sid_dup(r, join->out.domain_sid); 749 750 /* commit the transaction now we know the secrets were written 751 * out properly 752 */ 753 if (ldb_transaction_commit(s->ldb) != LDB_SUCCESS) { 754 printf("Failed to commit vampire transaction\n"); 755 return NT_STATUS_INTERNAL_DB_ERROR; 756 } 757 758 talloc_free(s); 759 760 return NT_STATUS_OK; 761 762} 763