2 Unix SMB/CIFS implementation.
4 Extract the user/system database from a remote SamSync server
6 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
7 Copyright (C) Guenther Deschner <gd@samba.org> 2008
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "libnet/libnet_samsync.h"
28 * Decrypt and extract the user's passwords.
30 * The writes decrypted (no longer 'RID encrypted' or arcfour encrypted)
31 * passwords back into the structure
34 static NTSTATUS fix_user(TALLOC_CTX *mem_ctx,
35 DATA_BLOB *session_key,
37 enum netr_SamDatabaseID database_id,
38 struct netr_DELTA_ENUM *delta)
41 uint32_t rid = delta->delta_id_union.rid;
42 struct netr_DELTA_USER *user = delta->delta_union.user;
43 struct samr_Password lm_hash;
44 struct samr_Password nt_hash;
47 if (user->lm_password_present) {
48 sam_pwd_hash(rid, user->lmpassword.hash, lm_hash.hash, 0);
49 user->lmpassword = lm_hash;
52 if (user->nt_password_present) {
53 sam_pwd_hash(rid, user->ntpassword.hash, nt_hash.hash, 0);
54 user->ntpassword = nt_hash;
58 if (user->user_private_info.SensitiveData) {
60 struct netr_USER_KEYS keys;
61 enum ndr_err_code ndr_err;
62 data.data = user->user_private_info.SensitiveData;
63 data.length = user->user_private_info.DataLength;
64 SamOEMhashBlob(data.data, data.length, session_key);
65 user->user_private_info.SensitiveData = data.data;
66 user->user_private_info.DataLength = data.length;
68 ndr_err = ndr_pull_struct_blob(&data, mem_ctx, &keys,
69 (ndr_pull_flags_fn_t)ndr_pull_netr_USER_KEYS);
70 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
71 dump_data(10, data.data, data.length);
72 return ndr_map_error2ntstatus(ndr_err);
75 if (keys.keys.keys2.lmpassword.length == 16) {
78 keys.keys.keys2.lmpassword.pwd.hash,
80 user->lmpassword = lm_hash;
82 user->lmpassword = keys.keys.keys2.lmpassword.pwd;
84 user->lm_password_present = true;
86 if (keys.keys.keys2.ntpassword.length == 16) {
89 keys.keys.keys2.ntpassword.pwd.hash,
91 user->ntpassword = nt_hash;
93 user->ntpassword = keys.keys.keys2.ntpassword.pwd;
95 user->nt_password_present = true;
97 /* TODO: rid decrypt history fields */
103 * Decrypt and extract the secrets
105 * The writes decrypted secrets back into the structure
107 static NTSTATUS fix_secret(TALLOC_CTX *mem_ctx,
108 DATA_BLOB *session_key,
109 enum netr_SamDatabaseID database_id,
110 struct netr_DELTA_ENUM *delta)
112 struct netr_DELTA_SECRET *secret = delta->delta_union.secret;
114 SamOEMhashBlob(secret->current_cipher.cipher_data,
115 secret->current_cipher.maxlen,
118 SamOEMhashBlob(secret->old_cipher.cipher_data,
119 secret->old_cipher.maxlen,
126 * Fix up the delta, dealing with encryption issues so that the final
127 * callback need only do the printing or application logic
130 static NTSTATUS samsync_fix_delta(TALLOC_CTX *mem_ctx,
131 DATA_BLOB *session_key,
133 enum netr_SamDatabaseID database_id,
134 struct netr_DELTA_ENUM *delta)
136 NTSTATUS status = NT_STATUS_OK;
138 switch (delta->delta_type) {
139 case NETR_DELTA_USER:
141 status = fix_user(mem_ctx,
147 case NETR_DELTA_SECRET:
149 status = fix_secret(mem_ctx,
162 * Fix up the delta, dealing with encryption issues so that the final
163 * callback need only do the printing or application logic
166 NTSTATUS samsync_fix_delta_array(TALLOC_CTX *mem_ctx,
167 DATA_BLOB *session_key,
169 enum netr_SamDatabaseID database_id,
170 struct netr_DELTA_ENUM_ARRAY *r)
175 for (i = 0; i < r->num_deltas; i++) {
177 status = samsync_fix_delta(mem_ctx,
182 if (!NT_STATUS_IS_OK(status)) {
191 * samsync_init_context
194 NTSTATUS samsync_init_context(TALLOC_CTX *mem_ctx,
195 const struct dom_sid *domain_sid,
196 const char *domain_name,
197 enum net_samsync_mode mode,
198 struct samsync_context **ctx_p)
200 struct samsync_context *ctx;
204 ctx = TALLOC_ZERO_P(mem_ctx, struct samsync_context);
205 NT_STATUS_HAVE_NO_MEMORY(ctx);
209 ctx->domain_name = talloc_strdup(mem_ctx, domain_name);
210 NT_STATUS_HAVE_NO_MEMORY(ctx->domain_name);
213 ctx->domain_sid = sid_dup_talloc(mem_ctx, domain_sid);
214 NT_STATUS_HAVE_NO_MEMORY(ctx->domain_sid);
216 ctx->domain_sid_str = sid_string_talloc(mem_ctx, ctx->domain_sid);
217 NT_STATUS_HAVE_NO_MEMORY(ctx->domain_sid_str);
226 * samsync_database_str
229 static const char *samsync_database_str(enum netr_SamDatabaseID database_id)
232 switch (database_id) {
233 case SAM_DATABASE_DOMAIN:
235 case SAM_DATABASE_BUILTIN:
237 case SAM_DATABASE_PRIVS:
248 static const char *samsync_debug_str(TALLOC_CTX *mem_ctx,
249 enum net_samsync_mode mode,
250 enum netr_SamDatabaseID database_id)
252 const char *action = NULL;
255 case NET_SAMSYNC_MODE_DUMP:
256 action = "Dumping (to stdout)";
258 case NET_SAMSYNC_MODE_FETCH_PASSDB:
259 action = "Fetching (to passdb)";
261 case NET_SAMSYNC_MODE_FETCH_LDIF:
262 action = "Fetching (to ldif)";
269 return talloc_asprintf(mem_ctx, "%s %s database",
270 action, samsync_database_str(database_id));
274 * samsync_process_database
277 NTSTATUS samsync_process_database(struct rpc_pipe_client *pipe_hnd,
278 enum netr_SamDatabaseID database_id,
279 samsync_fn_t callback_fn,
280 struct samsync_context *ctx)
284 const char *logon_server = pipe_hnd->desthost;
285 const char *computername = global_myname();
286 struct netr_Authenticator credential;
287 struct netr_Authenticator return_authenticator;
288 uint16_t restart_state = 0;
289 uint32_t sync_context = 0;
290 const char *debug_str;
291 DATA_BLOB session_key;
293 ZERO_STRUCT(return_authenticator);
295 if (!(mem_ctx = talloc_init("samsync_process_database"))) {
296 return NT_STATUS_NO_MEMORY;
299 debug_str = samsync_debug_str(mem_ctx, ctx->mode, database_id);
301 d_fprintf(stderr, "%s\n", debug_str);
305 struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
306 NTSTATUS callback_status;
308 netlogon_creds_client_step(pipe_hnd->dc, &credential);
310 result = rpccli_netr_DatabaseSync2(pipe_hnd, mem_ctx,
314 &return_authenticator,
320 if (NT_STATUS_EQUAL(result, NT_STATUS_NOT_SUPPORTED)) {
324 /* Check returned credentials. */
325 if (!netlogon_creds_client_check(pipe_hnd->dc,
326 &return_authenticator.cred)) {
327 DEBUG(0,("credentials chain check failed\n"));
328 return NT_STATUS_ACCESS_DENIED;
331 if (NT_STATUS_IS_ERR(result)) {
335 session_key = data_blob_const(pipe_hnd->dc->sess_key, 16);
337 samsync_fix_delta_array(mem_ctx,
343 /* Process results */
344 callback_status = callback_fn(mem_ctx, database_id, delta_enum_array, result, ctx);
345 if (!NT_STATUS_IS_OK(callback_status)) {
346 result = callback_status;
350 TALLOC_FREE(delta_enum_array);
352 /* Increment sync_context */
355 } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
358 if (NT_STATUS_IS_ERR(result) && !ctx->error_message) {
360 ctx->error_message = talloc_asprintf(ctx,
361 "Failed to fetch %s database: %s",
362 samsync_database_str(database_id),
365 if (NT_STATUS_EQUAL(result, NT_STATUS_NOT_SUPPORTED)) {
368 talloc_asprintf_append(ctx->error_message,
369 "\nPerhaps %s is a Windows native mode domain?",
374 talloc_destroy(mem_ctx);
380 * pull_netr_AcctLockStr
383 NTSTATUS pull_netr_AcctLockStr(TALLOC_CTX *mem_ctx,
384 struct lsa_BinaryString *r,
385 struct netr_AcctLockStr **str_p)
387 struct netr_AcctLockStr *str;
388 enum ndr_err_code ndr_err;
391 if (!mem_ctx || !r || !str_p) {
392 return NT_STATUS_INVALID_PARAMETER;
397 str = TALLOC_ZERO_P(mem_ctx, struct netr_AcctLockStr);
399 return NT_STATUS_NO_MEMORY;
402 blob = data_blob_const(r->array, r->length);
404 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, str,
405 (ndr_pull_flags_fn_t)ndr_pull_netr_AcctLockStr);
407 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
408 return ndr_map_error2ntstatus(ndr_err);