*/
#include "includes.h"
+#include "smbd/globals.h"
#include "../libcli/auth/libcli_auth.h"
+#include "../librpc/gen_ndr/srv_samr.h"
+#include "rpc_server/srv_samr_util.h"
+#include "../lib/crypto/arcfour.h"
+#include "secrets.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/dom_sid.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
};
typedef struct disp_info {
- DOM_SID sid; /* identify which domain this is. */
+ struct dom_sid sid; /* identify which domain this is. */
struct pdb_search *users; /* querydispinfo 1 and 4 */
struct pdb_search *machines; /* querydispinfo 2 */
struct pdb_search *groups; /* querydispinfo 3 and 5, enumgroups */
struct pdb_search *aliases; /* enumaliases */
- uint16 enum_acb_mask;
+ uint32_t enum_acb_mask;
struct pdb_search *enum_users; /* enumusers with a mask */
struct timed_event *cache_timeout_event; /* cache idle timeout
/*******************************************************************
*******************************************************************/
-static NTSTATUS make_samr_object_sd( TALLOC_CTX *ctx, SEC_DESC **psd, size_t *sd_size,
+static NTSTATUS make_samr_object_sd( TALLOC_CTX *ctx, struct security_descriptor **psd, size_t *sd_size,
const struct generic_mapping *map,
- DOM_SID *sid, uint32 sid_access )
+ struct dom_sid *sid, uint32 sid_access )
{
- DOM_SID domadmin_sid;
- SEC_ACE ace[5]; /* at most 5 entries */
+ struct dom_sid domadmin_sid;
+ struct security_ace ace[5]; /* at most 5 entries */
size_t i = 0;
- SEC_ACL *psa = NULL;
+ struct security_acl *psa = NULL;
/* basic access for Everyone */
/* Add Full Access for Domain Admins if we are a DC */
if ( IS_DC ) {
- sid_copy( &domadmin_sid, get_global_sam_sid() );
- sid_append_rid( &domadmin_sid, DOMAIN_GROUP_RID_ADMINS );
+ sid_compose(&domadmin_sid, get_global_sam_sid(),
+ DOMAIN_RID_ADMINS);
init_sec_ace(&ace[i++], &domadmin_sid,
SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
}
/*******************************************************************
Checks if access to an object should be granted, and returns that
level of access for further checks.
+
+ If the user has either of needed_priv_1 or needed_priv_2 then they
+ get the rights in rights_mask in addition to any calulated rights.
+
+ This handles the unusual case where we need to allow two different
+ privileges to obtain exactly the same rights, which occours only in
+ SAMR.
********************************************************************/
-static NTSTATUS access_check_samr_object( SEC_DESC *psd, NT_USER_TOKEN *token,
- SE_PRIV *rights, uint32 rights_mask,
- uint32 des_access, uint32 *acc_granted,
- const char *debug )
+NTSTATUS access_check_object( struct security_descriptor *psd, struct security_token *token,
+ enum sec_privilege needed_priv_1, enum sec_privilege needed_priv_2,
+ uint32 rights_mask,
+ uint32 des_access, uint32 *acc_granted,
+ const char *debug )
{
NTSTATUS status = NT_STATUS_ACCESS_DENIED;
uint32 saved_mask = 0;
by privileges (mostly having to do with creating/modifying/deleting
users and groups) */
- if ( rights && user_has_any_privilege( token, rights ) ) {
-
+ if ((needed_priv_1 != SEC_PRIV_INVALID && security_token_has_privilege(token, needed_priv_1)) ||
+ (needed_priv_2 != SEC_PRIV_INVALID && security_token_has_privilege(token, needed_priv_2))) {
saved_mask = (des_access & rights_mask);
des_access &= ~saved_mask;
- DEBUG(4,("access_check_samr_object: user rights access mask [0x%x]\n",
+ DEBUG(4,("access_check_object: user rights access mask [0x%x]\n",
rights_mask));
}
Map any MAXIMUM_ALLOWED_ACCESS request to a valid access set.
********************************************************************/
-static void map_max_allowed_access(const NT_USER_TOKEN *token,
- uint32_t *pacc_requested)
+void map_max_allowed_access(const struct security_token *nt_token,
+ const struct unix_user_token *unix_token,
+ uint32_t *pacc_requested)
{
if (!((*pacc_requested) & MAXIMUM_ALLOWED_ACCESS)) {
return;
}
*pacc_requested &= ~MAXIMUM_ALLOWED_ACCESS;
- /* At least try for generic read. */
- *pacc_requested = GENERIC_READ_ACCESS;
+ /* At least try for generic read|execute - Everyone gets that. */
+ *pacc_requested = GENERIC_READ_ACCESS|GENERIC_EXECUTE_ACCESS;
/* root gets anything. */
- if (geteuid() == sec_initial_uid()) {
+ if (unix_token->uid == sec_initial_uid()) {
*pacc_requested |= GENERIC_ALL_ACCESS;
return;
}
/* Full Access for 'BUILTIN\Administrators' and 'BUILTIN\Account Operators */
- if (is_sid_in_token(token, &global_sid_Builtin_Administrators) ||
- is_sid_in_token(token, &global_sid_Builtin_Account_Operators)) {
+ if (is_sid_in_token(nt_token, &global_sid_Builtin_Administrators) ||
+ is_sid_in_token(nt_token, &global_sid_Builtin_Account_Operators)) {
*pacc_requested |= GENERIC_ALL_ACCESS;
return;
}
/* Full access for DOMAIN\Domain Admins. */
if ( IS_DC ) {
- DOM_SID domadmin_sid;
- sid_copy( &domadmin_sid, get_global_sam_sid() );
- sid_append_rid( &domadmin_sid, DOMAIN_GROUP_RID_ADMINS );
- if (is_sid_in_token(token, &domadmin_sid)) {
+ struct dom_sid domadmin_sid;
+ sid_compose(&domadmin_sid, get_global_sam_sid(),
+ DOMAIN_RID_ADMINS);
+ if (is_sid_in_token(nt_token, &domadmin_sid)) {
*pacc_requested |= GENERIC_ALL_ACCESS;
return;
}
(unsigned int)secs_fromnow ));
disp_info->cache_timeout_event = event_add_timed(
- smbd_event_context(), NULL,
+ server_event_context(), NULL,
timeval_current_ofs(secs_fromnow, 0),
disp_info_cache_idle_timeout_handler, (void *)disp_info);
}
_samr_Close
********************************************************************/
-NTSTATUS _samr_Close(pipes_struct *p, struct samr_Close *r)
+NTSTATUS _samr_Close(struct pipes_struct *p, struct samr_Close *r)
{
if (!close_policy_hnd(p, r->in.handle)) {
return NT_STATUS_INVALID_HANDLE;
_samr_OpenDomain
********************************************************************/
-NTSTATUS _samr_OpenDomain(pipes_struct *p,
+NTSTATUS _samr_OpenDomain(struct pipes_struct *p,
struct samr_OpenDomain *r)
{
struct samr_connect_info *cinfo;
struct samr_domain_info *dinfo;
- SEC_DESC *psd = NULL;
+ struct security_descriptor *psd = NULL;
uint32 acc_granted;
uint32 des_access = r->in.access_mask;
NTSTATUS status;
size_t sd_size;
- SE_PRIV se_rights;
+ uint32_t extra_access = SAMR_DOMAIN_ACCESS_CREATE_USER;
/* find the connection policy handle. */
}
/*check if access can be granted as requested by client. */
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd( p->mem_ctx, &psd, &sd_size, &dom_generic_mapping, NULL, 0 );
se_map_generic( &des_access, &dom_generic_mapping );
- se_priv_copy( &se_rights, &se_machine_account );
- se_priv_add( &se_rights, &se_add_users );
+ /*
+ * Users with SeAddUser get the ability to manipulate groups
+ * and aliases.
+ */
+ if (security_token_has_privilege(p->server_info->ptok, SEC_PRIV_ADD_USERS)) {
+ extra_access |= (SAMR_DOMAIN_ACCESS_CREATE_GROUP |
+ SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
+ SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
+ SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS |
+ SAMR_DOMAIN_ACCESS_CREATE_ALIAS);
+ }
+
+ /*
+ * Users with SeMachineAccount or SeAddUser get additional
+ * SAMR_DOMAIN_ACCESS_CREATE_USER access.
+ */
- status = access_check_samr_object( psd, p->server_info->ptok,
- &se_rights, GENERIC_RIGHTS_DOMAIN_WRITE, des_access,
- &acc_granted, "_samr_OpenDomain" );
+ status = access_check_object( psd, p->server_info->ptok,
+ SEC_PRIV_MACHINE_ACCOUNT, SEC_PRIV_ADD_USERS,
+ extra_access, des_access,
+ &acc_granted, "_samr_OpenDomain" );
if ( !NT_STATUS_IS_OK(status) )
return status;
_samr_GetUserPwInfo
********************************************************************/
-NTSTATUS _samr_GetUserPwInfo(pipes_struct *p,
+NTSTATUS _samr_GetUserPwInfo(struct pipes_struct *p,
struct samr_GetUserPwInfo *r)
{
struct samr_user_info *uinfo;
switch (sid_type) {
case SID_NAME_USER:
become_root();
- pdb_get_account_policy(AP_MIN_PASSWORD_LEN,
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_LEN,
&min_password_length);
- pdb_get_account_policy(AP_USER_MUST_LOGON_TO_CHG_PASS,
+ pdb_get_account_policy(PDB_POLICY_USER_MUST_LOGON_TO_CHG_PASS,
&password_properties);
unbecome_root();
_samr_SetSecurity
********************************************************************/
-NTSTATUS _samr_SetSecurity(pipes_struct *p,
+NTSTATUS _samr_SetSecurity(struct pipes_struct *p,
struct samr_SetSecurity *r)
{
struct samr_user_info *uinfo;
uint32 i;
- SEC_ACL *dacl;
+ struct security_acl *dacl;
bool ret;
struct samu *sampass=NULL;
NTSTATUS status;
dacl = r->in.sdbuf->sd->dacl;
for (i=0; i < dacl->num_aces; i++) {
- if (sid_equal(&uinfo->sid, &dacl->aces[i].trustee)) {
+ if (dom_sid_equal(&uinfo->sid, &dacl->aces[i].trustee)) {
ret = pdb_set_pass_can_change(sampass,
(dacl->aces[i].access_mask &
SAMR_USER_ACCESS_CHANGE_PASSWORD) ?
/*******************************************************************
build correct perms based on policies and password times for _samr_query_sec_obj
*******************************************************************/
-static bool check_change_pw_access(TALLOC_CTX *mem_ctx, DOM_SID *user_sid)
+static bool check_change_pw_access(TALLOC_CTX *mem_ctx, struct dom_sid *user_sid)
{
struct samu *sampass=NULL;
bool ret;
_samr_QuerySecurity
********************************************************************/
-NTSTATUS _samr_QuerySecurity(pipes_struct *p,
+NTSTATUS _samr_QuerySecurity(struct pipes_struct *p,
struct samr_QuerySecurity *r)
{
struct samr_connect_info *cinfo;
struct samr_group_info *ginfo;
struct samr_alias_info *ainfo;
NTSTATUS status;
- SEC_DESC * psd = NULL;
- size_t sd_size;
+ struct security_descriptor * psd = NULL;
+ size_t sd_size = 0;
cinfo = policy_handle_find(p, r->in.handle,
- STD_RIGHT_READ_CONTROL_ACCESS, NULL,
+ SEC_STD_READ_CONTROL, NULL,
struct samr_connect_info, &status);
if (NT_STATUS_IS_OK(status)) {
DEBUG(5,("_samr_QuerySecurity: querying security on SAM\n"));
}
dinfo = policy_handle_find(p, r->in.handle,
- STD_RIGHT_READ_CONTROL_ACCESS, NULL,
+ SEC_STD_READ_CONTROL, NULL,
struct samr_domain_info, &status);
if (NT_STATUS_IS_OK(status)) {
DEBUG(5,("_samr_QuerySecurity: querying security on Domain "
}
uinfo = policy_handle_find(p, r->in.handle,
- STD_RIGHT_READ_CONTROL_ACCESS, NULL,
+ SEC_STD_READ_CONTROL, NULL,
struct samr_user_info, &status);
if (NT_STATUS_IS_OK(status)) {
DEBUG(10,("_samr_QuerySecurity: querying security on user "
}
ginfo = policy_handle_find(p, r->in.handle,
- STD_RIGHT_READ_CONTROL_ACCESS, NULL,
+ SEC_STD_READ_CONTROL, NULL,
struct samr_group_info, &status);
if (NT_STATUS_IS_OK(status)) {
/*
}
ainfo = policy_handle_find(p, r->in.handle,
- STD_RIGHT_READ_CONTROL_ACCESS, NULL,
+ SEC_STD_READ_CONTROL, NULL,
struct samr_alias_info, &status);
if (NT_STATUS_IS_OK(status)) {
/*
_samr_EnumDomainUsers
********************************************************************/
-NTSTATUS _samr_EnumDomainUsers(pipes_struct *p,
+NTSTATUS _samr_EnumDomainUsers(struct pipes_struct *p,
struct samr_EnumDomainUsers *r)
{
NTSTATUS status;
return status;
}
+ samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ if (!samr_array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ *r->out.sam = samr_array;
+
if (sid_check_is_builtin(&dinfo->sid)) {
/* No users in builtin. */
*r->out.resume_handle = *r->in.resume_handle;
return status;
}
- samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
- if (!samr_array) {
- return NT_STATUS_NO_MEMORY;
- }
- *r->out.sam = samr_array;
-
become_root();
/* AS ROOT !!!! */
_samr_EnumDomainGroups
********************************************************************/
-NTSTATUS _samr_EnumDomainGroups(pipes_struct *p,
+NTSTATUS _samr_EnumDomainGroups(struct pipes_struct *p,
struct samr_EnumDomainGroups *r)
{
NTSTATUS status;
DEBUG(5,("_samr_EnumDomainGroups: %d\n", __LINE__));
+ samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ if (!samr_array) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ *r->out.sam = samr_array;
+
if (sid_check_is_builtin(&dinfo->sid)) {
/* No groups in builtin. */
*r->out.resume_handle = *r->in.resume_handle;
return status;
}
- samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
- if (!samr_array) {
- return NT_STATUS_NO_MEMORY;
- }
-
/* the domain group array is being allocated in the function below */
become_root();
make_group_sam_entry_list(p->mem_ctx, &samr_entries,
num_groups, groups);
+ if (MAX_SAM_ENTRIES <= num_groups) {
+ status = STATUS_MORE_ENTRIES;
+ } else {
+ status = NT_STATUS_OK;
+ }
+
samr_array->count = num_groups;
samr_array->entries = samr_entries;
- *r->out.sam = samr_array;
*r->out.num_entries = num_groups;
*r->out.resume_handle = num_groups + *r->in.resume_handle;
_samr_EnumDomainAliases
********************************************************************/
-NTSTATUS _samr_EnumDomainAliases(pipes_struct *p,
+NTSTATUS _samr_EnumDomainAliases(struct pipes_struct *p,
struct samr_EnumDomainAliases *r)
{
NTSTATUS status;
DEBUG(5,("_samr_EnumDomainAliases: %d\n", __LINE__));
+ if (MAX_SAM_ENTRIES <= num_aliases) {
+ status = STATUS_MORE_ENTRIES;
+ } else {
+ status = NT_STATUS_OK;
+ }
+
samr_array->count = num_aliases;
samr_array->entries = samr_entries;
_samr_QueryDisplayInfo
********************************************************************/
-NTSTATUS _samr_QueryDisplayInfo(pipes_struct *p,
+NTSTATUS _samr_QueryDisplayInfo(struct pipes_struct *p,
struct samr_QueryDisplayInfo *r)
{
NTSTATUS status;
uint32 struct_size=0x20; /* W2K always reply that, client doesn't care */
uint32 max_entries = r->in.max_entries;
- uint32 enum_context = r->in.start_idx;
- uint32 max_size = r->in.buf_size;
union samr_DispInfo *disp_info = r->out.info;
- uint32 temp_size=0, total_data_size=0;
+ uint32 temp_size=0;
NTSTATUS disp_ret = NT_STATUS_UNSUCCESSFUL;
uint32 num_account = 0;
enum remote_arch_types ra_type = get_remote_arch();
}
/* first limit the number of entries we will return */
- if(max_entries > max_sam_entries) {
+ if (r->in.max_entries > max_sam_entries) {
DEBUG(5, ("_samr_QueryDisplayInfo: client requested %d "
- "entries, limiting to %d\n", max_entries,
+ "entries, limiting to %d\n", r->in.max_entries,
max_sam_entries));
max_entries = max_sam_entries;
}
temp_size=max_entries*struct_size;
- if (temp_size>max_size) {
- max_entries=MIN((max_size/struct_size),max_entries);;
+ if (temp_size > r->in.buf_size) {
+ max_entries = MIN((r->in.buf_size / struct_size),max_entries);;
DEBUG(5, ("_samr_QueryDisplayInfo: buffer size limits to "
"only %d entries\n", max_entries));
}
/* THe following done as ROOT. Don't return without unbecome_root(). */
switch (r->in.level) {
- case 0x1:
- case 0x4:
+ case 1:
+ case 4:
if (dinfo->disp_info->users == NULL) {
dinfo->disp_info->users = pdb_search_users(
dinfo->disp_info, ACB_NORMAL);
return NT_STATUS_ACCESS_DENIED;
}
DEBUG(10,("_samr_QueryDisplayInfo: starting user enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
} else {
DEBUG(10,("_samr_QueryDisplayInfo: using cached user enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
}
num_account = pdb_search_entries(dinfo->disp_info->users,
- enum_context, max_entries,
+ r->in.start_idx, max_entries,
&entries);
break;
- case 0x2:
+ case 2:
if (dinfo->disp_info->machines == NULL) {
dinfo->disp_info->machines = pdb_search_users(
dinfo->disp_info, ACB_WSTRUST|ACB_SVRTRUST);
return NT_STATUS_ACCESS_DENIED;
}
DEBUG(10,("_samr_QueryDisplayInfo: starting machine enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
} else {
DEBUG(10,("_samr_QueryDisplayInfo: using cached machine enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
}
num_account = pdb_search_entries(dinfo->disp_info->machines,
- enum_context, max_entries,
+ r->in.start_idx, max_entries,
&entries);
break;
- case 0x3:
- case 0x5:
+ case 3:
+ case 5:
if (dinfo->disp_info->groups == NULL) {
dinfo->disp_info->groups = pdb_search_groups(
dinfo->disp_info);
return NT_STATUS_ACCESS_DENIED;
}
DEBUG(10,("_samr_QueryDisplayInfo: starting group enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
} else {
DEBUG(10,("_samr_QueryDisplayInfo: using cached group enumeration at index %u\n",
- (unsigned int)enum_context ));
+ (unsigned int)r->in.start_idx));
}
num_account = pdb_search_entries(dinfo->disp_info->groups,
- enum_context, max_entries,
+ r->in.start_idx, max_entries,
&entries);
break;
default:
/* Now create reply structure */
switch (r->in.level) {
- case 0x1:
+ case 1:
disp_ret = init_samr_dispinfo_1(p->mem_ctx, &disp_info->info1,
- num_account, enum_context,
+ num_account, r->in.start_idx,
entries);
break;
- case 0x2:
+ case 2:
disp_ret = init_samr_dispinfo_2(p->mem_ctx, &disp_info->info2,
- num_account, enum_context,
+ num_account, r->in.start_idx,
entries);
break;
- case 0x3:
+ case 3:
disp_ret = init_samr_dispinfo_3(p->mem_ctx, &disp_info->info3,
- num_account, enum_context,
+ num_account, r->in.start_idx,
entries);
break;
- case 0x4:
+ case 4:
disp_ret = init_samr_dispinfo_4(p->mem_ctx, &disp_info->info4,
- num_account, enum_context,
+ num_account, r->in.start_idx,
entries);
break;
- case 0x5:
+ case 5:
disp_ret = init_samr_dispinfo_5(p->mem_ctx, &disp_info->info5,
- num_account, enum_context,
+ num_account, r->in.start_idx,
entries);
break;
default:
if (!NT_STATUS_IS_OK(disp_ret))
return disp_ret;
- /* calculate the total size */
- total_data_size=num_account*struct_size;
-
if (max_entries <= num_account) {
status = STATUS_MORE_ENTRIES;
} else {
DEBUG(5, ("_samr_QueryDisplayInfo: %d\n", __LINE__));
- *r->out.total_size = total_data_size;
- *r->out.returned_size = temp_size;
+ *r->out.total_size = num_account * struct_size;
+ *r->out.returned_size = num_account ? temp_size : 0;
return status;
}
_samr_QueryDisplayInfo2
****************************************************************/
-NTSTATUS _samr_QueryDisplayInfo2(pipes_struct *p,
+NTSTATUS _samr_QueryDisplayInfo2(struct pipes_struct *p,
struct samr_QueryDisplayInfo2 *r)
{
struct samr_QueryDisplayInfo q;
_samr_QueryDisplayInfo3
****************************************************************/
-NTSTATUS _samr_QueryDisplayInfo3(pipes_struct *p,
+NTSTATUS _samr_QueryDisplayInfo3(struct pipes_struct *p,
struct samr_QueryDisplayInfo3 *r)
{
struct samr_QueryDisplayInfo q;
_samr_QueryAliasInfo
********************************************************************/
-NTSTATUS _samr_QueryAliasInfo(pipes_struct *p,
+NTSTATUS _samr_QueryAliasInfo(struct pipes_struct *p,
struct samr_QueryAliasInfo *r)
{
struct samr_alias_info *ainfo;
alias_info->all.num_members = 1; /* ??? */
alias_info->all.description.string = alias_description;
break;
+ case ALIASINFONAME:
+ alias_info->name.string = alias_name;
+ break;
case ALIASINFODESCRIPTION:
alias_info->description.string = alias_description;
break;
_samr_LookupNames
********************************************************************/
-NTSTATUS _samr_LookupNames(pipes_struct *p,
+NTSTATUS _samr_LookupNames(struct pipes_struct *p,
struct samr_LookupNames *r)
{
struct samr_domain_info *dinfo;
rids.ids = rid;
types.count = num_rids;
- types.ids = type;
+ types.ids = talloc_array(p->mem_ctx, uint32_t, num_rids);
+ NT_STATUS_HAVE_NO_MEMORY(type);
+ for (i = 0; i < num_rids; i++) {
+ types.ids[i] = (type[i] & 0xffffffff);
+ }
*r->out.rids = rids;
*r->out.types = types;
_samr_ChangePasswordUser
****************************************************************/
-NTSTATUS _samr_ChangePasswordUser(pipes_struct *p,
+NTSTATUS _samr_ChangePasswordUser(struct pipes_struct *p,
struct samr_ChangePasswordUser *r)
{
NTSTATUS status;
lm_pass = pdb_get_lanman_passwd(pwd);
nt_pass = pdb_get_nt_passwd(pwd);
+ if (!lm_pass || !nt_pass) {
+ status = NT_STATUS_WRONG_PASSWORD;
+ goto out;
+ }
+
memcpy(&lm_pwd.hash, lm_pass, sizeof(lm_pwd.hash));
memcpy(&nt_pwd.hash, nt_pass, sizeof(nt_pwd.hash));
}
_samr_ChangePasswordUser2
********************************************************************/
-NTSTATUS _samr_ChangePasswordUser2(pipes_struct *p,
+NTSTATUS _samr_ChangePasswordUser2(struct pipes_struct *p,
struct samr_ChangePasswordUser2 *r)
{
NTSTATUS status;
*/
status = pass_oem_change(user_name,
+ p->client_id->name,
r->in.lm_password->data,
r->in.lm_verifier->hash,
r->in.nt_password->data,
DEBUG(5,("_samr_ChangePasswordUser2: %d\n", __LINE__));
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)) {
+ return NT_STATUS_WRONG_PASSWORD;
+ }
+
return status;
}
_samr_OemChangePasswordUser2
****************************************************************/
-NTSTATUS _samr_OemChangePasswordUser2(pipes_struct *p,
+NTSTATUS _samr_OemChangePasswordUser2(struct pipes_struct *p,
struct samr_OemChangePasswordUser2 *r)
{
NTSTATUS status;
}
status = pass_oem_change(user_name,
+ p->client_id->name,
r->in.password->data,
r->in.hash->hash,
0,
0,
NULL);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)) {
+ return NT_STATUS_WRONG_PASSWORD;
+ }
+
DEBUG(5,("_samr_OemChangePasswordUser2: %d\n", __LINE__));
return status;
_samr_ChangePasswordUser3
********************************************************************/
-NTSTATUS _samr_ChangePasswordUser3(pipes_struct *p,
+NTSTATUS _samr_ChangePasswordUser3(struct pipes_struct *p,
struct samr_ChangePasswordUser3 *r)
{
NTSTATUS status;
fstring user_name;
const char *wks = NULL;
- uint32 reject_reason;
+ enum samPwdChangeReason reject_reason;
struct samr_DomInfo1 *dominfo = NULL;
- struct samr_ChangeReject *reject = NULL;
+ struct userPwdChangeFailureInformation *reject = NULL;
uint32_t tmp;
DEBUG(5,("_samr_ChangePasswordUser3: %d\n", __LINE__));
*/
status = pass_oem_change(user_name,
+ p->client_id->name,
r->in.lm_password->data,
r->in.lm_verifier->hash,
r->in.nt_password->data,
r->in.nt_verifier->hash,
&reject_reason);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)) {
+ return NT_STATUS_WRONG_PASSWORD;
+ }
if (NT_STATUS_EQUAL(status, NT_STATUS_PASSWORD_RESTRICTION) ||
NT_STATUS_EQUAL(status, NT_STATUS_ACCOUNT_RESTRICTION)) {
return NT_STATUS_NO_MEMORY;
}
- reject = TALLOC_ZERO_P(p->mem_ctx, struct samr_ChangeReject);
+ reject = TALLOC_ZERO_P(p->mem_ctx,
+ struct userPwdChangeFailureInformation);
if (!reject) {
return NT_STATUS_NO_MEMORY;
}
/* AS ROOT !!! */
- pdb_get_account_policy(AP_MIN_PASSWORD_LEN, &tmp);
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_LEN, &tmp);
dominfo->min_password_length = tmp;
- pdb_get_account_policy(AP_PASSWORD_HISTORY, &tmp);
+ pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &tmp);
dominfo->password_history_length = tmp;
- pdb_get_account_policy(AP_USER_MUST_LOGON_TO_CHG_PASS,
+ pdb_get_account_policy(PDB_POLICY_USER_MUST_LOGON_TO_CHG_PASS,
&dominfo->password_properties);
- pdb_get_account_policy(AP_MAX_PASSWORD_AGE, &account_policy_temp);
+ pdb_get_account_policy(PDB_POLICY_MAX_PASSWORD_AGE, &account_policy_temp);
u_expire = account_policy_temp;
- pdb_get_account_policy(AP_MIN_PASSWORD_AGE, &account_policy_temp);
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_AGE, &account_policy_temp);
u_min_age = account_policy_temp;
/* !AS ROOT */
dominfo->password_properties |= DOMAIN_PASSWORD_COMPLEX;
}
- reject->reason = reject_reason;
+ reject->extendedFailureReason = reject_reason;
*r->out.dominfo = dominfo;
*r->out.reject = reject;
_samr_LookupRids
********************************************************************/
-NTSTATUS _samr_LookupRids(pipes_struct *p,
+NTSTATUS _samr_LookupRids(struct pipes_struct *p,
struct samr_LookupRids *r)
{
struct samr_domain_info *dinfo;
_samr_OpenUser
********************************************************************/
-NTSTATUS _samr_OpenUser(pipes_struct *p,
+NTSTATUS _samr_OpenUser(struct pipes_struct *p,
struct samr_OpenUser *r)
{
struct samu *sampass=NULL;
- DOM_SID sid;
+ struct dom_sid sid;
struct samr_domain_info *dinfo;
struct samr_user_info *uinfo;
- SEC_DESC *psd = NULL;
+ struct security_descriptor *psd = NULL;
uint32 acc_granted;
uint32 des_access = r->in.access_mask;
+ uint32_t extra_access = 0;
size_t sd_size;
bool ret;
NTSTATUS nt_status;
- SE_PRIV se_rights;
+
+ /* These two privileges, if != SEC_PRIV_INVALID, indicate
+ * privileges that the user must have to complete this
+ * operation in defience of the fixed ACL */
+ enum sec_privilege needed_priv_1, needed_priv_2;
NTSTATUS status;
dinfo = policy_handle_find(p, r->in.domain_handle,
return NT_STATUS_NO_SUCH_USER;
/* check if access can be granted as requested by client. */
-
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd(p->mem_ctx, &psd, &sd_size, &usr_generic_mapping, &sid, SAMR_USR_RIGHTS_WRITE_PW);
se_map_generic(&des_access, &usr_generic_mapping);
- se_priv_copy( &se_rights, &se_machine_account );
- se_priv_add( &se_rights, &se_add_users );
-
- nt_status = access_check_samr_object(psd, p->server_info->ptok,
- &se_rights, GENERIC_RIGHTS_USER_WRITE, des_access,
- &acc_granted, "_samr_OpenUser");
-
- if ( !NT_STATUS_IS_OK(nt_status) )
- return nt_status;
+ /*
+ * Get the sampass first as we need to check privileges
+ * based on what kind of user object this is.
+ * But don't reveal info too early if it didn't exist.
+ */
become_root();
ret=pdb_getsampwsid(sampass, &sid);
unbecome_root();
+ needed_priv_1 = SEC_PRIV_INVALID;
+ needed_priv_2 = SEC_PRIV_INVALID;
+ /*
+ * We do the override access checks on *open*, not at
+ * SetUserInfo time.
+ */
+ if (ret) {
+ uint32_t acb_info = pdb_get_acct_ctrl(sampass);
+
+ if (acb_info & ACB_WSTRUST) {
+ /*
+ * SeMachineAccount is needed to add
+ * GENERIC_RIGHTS_USER_WRITE to a machine
+ * account.
+ */
+ needed_priv_1 = SEC_PRIV_MACHINE_ACCOUNT;
+ }
+ if (acb_info & ACB_NORMAL) {
+ /*
+ * SeAddUsers is needed to add
+ * GENERIC_RIGHTS_USER_WRITE to a normal
+ * account.
+ */
+ needed_priv_1 = SEC_PRIV_ADD_USERS;
+ }
+ /*
+ * Cheat - we have not set a specific privilege for
+ * server (BDC) or domain trust account, so allow
+ * GENERIC_RIGHTS_USER_WRITE if pipe user is in
+ * DOMAIN_RID_ADMINS.
+ */
+ if (acb_info & (ACB_SVRTRUST|ACB_DOMTRUST)) {
+ if (lp_enable_privileges() && nt_token_check_domain_rid(p->server_info->ptok,
+ DOMAIN_RID_ADMINS)) {
+ des_access &= ~GENERIC_RIGHTS_USER_WRITE;
+ extra_access = GENERIC_RIGHTS_USER_WRITE;
+ DEBUG(4,("_samr_OpenUser: Allowing "
+ "GENERIC_RIGHTS_USER_WRITE for "
+ "rid admins\n"));
+ }
+ }
+ }
+
+ TALLOC_FREE(sampass);
+
+ nt_status = access_check_object(psd, p->server_info->ptok,
+ needed_priv_1, needed_priv_2,
+ GENERIC_RIGHTS_USER_WRITE, des_access,
+ &acc_granted, "_samr_OpenUser");
+
+ if ( !NT_STATUS_IS_OK(nt_status) )
+ return nt_status;
+
/* check that the SID exists in our domain. */
if (ret == False) {
return NT_STATUS_NO_SUCH_USER;
}
- TALLOC_FREE(sampass);
+ /* If we did the rid admins hack above, allow access. */
+ acc_granted |= extra_access;
uinfo = policy_handle_create(p, r->out.user_handle, acc_granted,
struct samr_user_info, &nt_status);
return NT_STATUS_OK;
}
+/*************************************************************************
+ *************************************************************************/
+
+static struct samr_LogonHours get_logon_hours_from_pdb(TALLOC_CTX *mem_ctx,
+ struct samu *pw)
+{
+ struct samr_LogonHours hours;
+ const int units_per_week = 168;
+
+ ZERO_STRUCT(hours);
+ hours.bits = talloc_array(mem_ctx, uint8_t, units_per_week);
+ if (!hours.bits) {
+ return hours;
+ }
+
+ hours.units_per_week = units_per_week;
+ memset(hours.bits, 0xFF, units_per_week);
+
+ if (pdb_get_hours(pw)) {
+ memcpy(hours.bits, pdb_get_hours(pw),
+ MIN(pdb_get_hours_len(pw), units_per_week));
+ }
+
+ return hours;
+}
+
/*************************************************************************
get_user_info_1.
*************************************************************************/
static NTSTATUS get_user_info_1(TALLOC_CTX *mem_ctx,
struct samr_UserInfo1 *r,
struct samu *pw,
- DOM_SID *domain_sid)
+ struct dom_sid *domain_sid)
{
- const DOM_SID *sid_group;
+ const struct dom_sid *sid_group;
uint32_t primary_gid;
become_root();
struct samu *pw)
{
r->comment.string = talloc_strdup(mem_ctx, pdb_get_comment(pw));
- r->unknown.string = NULL;
+ r->reserved.string = NULL;
r->country_code = 0;
r->code_page = 0;
static NTSTATUS get_user_info_3(TALLOC_CTX *mem_ctx,
struct samr_UserInfo3 *r,
struct samu *pw,
- DOM_SID *domain_sid)
+ struct dom_sid *domain_sid)
{
- const DOM_SID *sid_user, *sid_group;
+ const struct dom_sid *sid_user, *sid_group;
uint32_t rid, primary_gid;
sid_user = pdb_get_user_sid(pw);
static NTSTATUS get_user_info_5(TALLOC_CTX *mem_ctx,
struct samr_UserInfo5 *r,
struct samu *pw,
- DOM_SID *domain_sid)
+ struct dom_sid *domain_sid)
{
- const DOM_SID *sid_user, *sid_group;
+ const struct dom_sid *sid_user, *sid_group;
uint32_t rid, primary_gid;
sid_user = pdb_get_user_sid(pw);
user. JRA.
*************************************************************************/
-static NTSTATUS get_user_info_18(pipes_struct *p,
+static NTSTATUS get_user_info_18(struct pipes_struct *p,
TALLOC_CTX *mem_ctx,
struct samr_UserInfo18 *r,
- DOM_SID *user_sid)
+ struct dom_sid *user_sid)
{
struct samu *smbpass=NULL;
bool ret;
+ const uint8_t *nt_pass = NULL;
+ const uint8_t *lm_pass = NULL;
ZERO_STRUCTP(r);
- if (p->auth.auth_type != PIPE_AUTH_TYPE_NTLMSSP || p->auth.auth_type != PIPE_AUTH_TYPE_SPNEGO_NTLMSSP) {
+ if (p->server_info->system) {
+ goto query;
+ }
+
+ if ((p->auth.auth_type != DCERPC_AUTH_TYPE_NTLMSSP) ||
+ (p->auth.auth_type != DCERPC_AUTH_TYPE_KRB5) ||
+ (p->auth.auth_type != DCERPC_AUTH_TYPE_SPNEGO)) {
return NT_STATUS_ACCESS_DENIED;
}
- if (p->auth.auth_level != PIPE_AUTH_LEVEL_PRIVACY) {
+ if (p->auth.auth_level != DCERPC_AUTH_LEVEL_PRIVACY) {
return NT_STATUS_ACCESS_DENIED;
}
+ query:
/*
* Do *NOT* do become_root()/unbecome_root() here ! JRA.
*/
if (ret == False) {
DEBUG(4, ("User %s not found\n", sid_string_dbg(user_sid)));
TALLOC_FREE(smbpass);
- return (geteuid() == (uid_t)0) ? NT_STATUS_NO_SUCH_USER : NT_STATUS_ACCESS_DENIED;
+ return (geteuid() == sec_initial_uid()) ? NT_STATUS_NO_SUCH_USER : NT_STATUS_ACCESS_DENIED;
}
DEBUG(3,("User:[%s] 0x%x\n", pdb_get_username(smbpass), pdb_get_acct_ctrl(smbpass) ));
return NT_STATUS_ACCOUNT_DISABLED;
}
- r->lm_pwd_active = true;
- r->nt_pwd_active = true;
- memcpy(r->lm_pwd.hash, pdb_get_lanman_passwd(smbpass), 16);
- memcpy(r->nt_pwd.hash, pdb_get_nt_passwd(smbpass), 16);
+ lm_pass = pdb_get_lanman_passwd(smbpass);
+ if (lm_pass != NULL) {
+ memcpy(r->lm_pwd.hash, lm_pass, 16);
+ r->lm_pwd_active = true;
+ }
+
+ nt_pass = pdb_get_nt_passwd(smbpass);
+ if (nt_pass != NULL) {
+ memcpy(r->nt_pwd.hash, nt_pass, 16);
+ r->nt_pwd_active = true;
+ }
r->password_expired = 0; /* FIXME */
TALLOC_FREE(smbpass);
static NTSTATUS get_user_info_21(TALLOC_CTX *mem_ctx,
struct samr_UserInfo21 *r,
struct samu *pw,
- DOM_SID *domain_sid)
+ struct dom_sid *domain_sid,
+ uint32_t acc_granted)
{
NTSTATUS status;
- const DOM_SID *sid_user, *sid_group;
+ const struct dom_sid *sid_user, *sid_group;
uint32_t rid, primary_gid;
NTTIME force_password_change;
time_t must_change_time;
_samr_QueryUserInfo
********************************************************************/
-NTSTATUS _samr_QueryUserInfo(pipes_struct *p,
+NTSTATUS _samr_QueryUserInfo(struct pipes_struct *p,
struct samr_QueryUserInfo *r)
{
NTSTATUS status;
union samr_UserInfo *user_info = NULL;
struct samr_user_info *uinfo;
- DOM_SID domain_sid;
+ struct dom_sid domain_sid;
uint32 rid;
bool ret = false;
struct samu *pwd = NULL;
+ uint32_t acc_required, acc_granted;
+
+ switch (r->in.level) {
+ case 1: /* UserGeneralInformation */
+ /* USER_READ_GENERAL */
+ acc_required = SAMR_USER_ACCESS_GET_NAME_ETC;
+ break;
+ case 2: /* UserPreferencesInformation */
+ /* USER_READ_PREFERENCES | USER_READ_GENERAL */
+ acc_required = SAMR_USER_ACCESS_GET_LOCALE |
+ SAMR_USER_ACCESS_GET_NAME_ETC;
+ break;
+ case 3: /* UserLogonInformation */
+ /* USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT */
+ acc_required = SAMR_USER_ACCESS_GET_NAME_ETC |
+ SAMR_USER_ACCESS_GET_LOCALE |
+ SAMR_USER_ACCESS_GET_LOGONINFO |
+ SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ break;
+ case 4: /* UserLogonHoursInformation */
+ /* USER_READ_LOGON */
+ acc_required = SAMR_USER_ACCESS_GET_LOGONINFO;
+ break;
+ case 5: /* UserAccountInformation */
+ /* USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT */
+ acc_required = SAMR_USER_ACCESS_GET_NAME_ETC |
+ SAMR_USER_ACCESS_GET_LOCALE |
+ SAMR_USER_ACCESS_GET_LOGONINFO |
+ SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ break;
+ case 6: /* UserNameInformation */
+ case 7: /* UserAccountNameInformation */
+ case 8: /* UserFullNameInformation */
+ case 9: /* UserPrimaryGroupInformation */
+ case 13: /* UserAdminCommentInformation */
+ /* USER_READ_GENERAL */
+ acc_required = SAMR_USER_ACCESS_GET_NAME_ETC;
+ break;
+ case 10: /* UserHomeInformation */
+ case 11: /* UserScriptInformation */
+ case 12: /* UserProfileInformation */
+ case 14: /* UserWorkStationsInformation */
+ /* USER_READ_LOGON */
+ acc_required = SAMR_USER_ACCESS_GET_LOGONINFO;
+ break;
+ case 16: /* UserControlInformation */
+ case 17: /* UserExpiresInformation */
+ case 20: /* UserParametersInformation */
+ /* USER_READ_ACCOUNT */
+ acc_required = SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ break;
+ case 21: /* UserAllInformation */
+ /* FIXME! - gd */
+ acc_required = SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ break;
+ case 18: /* UserInternal1Information */
+ /* FIXME! - gd */
+ acc_required = SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ break;
+ case 23: /* UserInternal4Information */
+ case 24: /* UserInternal4InformationNew */
+ case 25: /* UserInternal4InformationNew */
+ case 26: /* UserInternal5InformationNew */
+ default:
+ return NT_STATUS_INVALID_INFO_CLASS;
+ break;
+ }
uinfo = policy_handle_find(p, r->in.user_handle,
- SAMR_USER_ACCESS_GET_ATTRIBUTES, NULL,
+ acc_required, &acc_granted,
struct samr_user_info, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
status = get_user_info_20(p->mem_ctx, &user_info->info20, pwd);
break;
case 21:
- status = get_user_info_21(p->mem_ctx, &user_info->info21, pwd, &domain_sid);
+ status = get_user_info_21(p->mem_ctx, &user_info->info21, pwd, &domain_sid, acc_granted);
break;
default:
status = NT_STATUS_INVALID_INFO_CLASS;
break;
}
- TALLOC_FREE(pwd);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto done;
+ }
*r->out.info = user_info;
+ done:
+ TALLOC_FREE(pwd);
+
DEBUG(5,("_samr_QueryUserInfo: %d\n", __LINE__));
return status;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_QueryUserInfo2(pipes_struct *p,
+NTSTATUS _samr_QueryUserInfo2(struct pipes_struct *p,
struct samr_QueryUserInfo2 *r)
{
struct samr_QueryUserInfo u;
_samr_GetGroupsForUser
********************************************************************/
-NTSTATUS _samr_GetGroupsForUser(pipes_struct *p,
+NTSTATUS _samr_GetGroupsForUser(struct pipes_struct *p,
struct samr_GetGroupsForUser *r)
{
struct samr_user_info *uinfo;
struct samu *sam_pass=NULL;
- DOM_SID *sids;
+ struct dom_sid *sids;
struct samr_RidWithAttribute dom_gid;
struct samr_RidWithAttribute *gids = NULL;
uint32 primary_group_rid;
}
/*******************************************************************
- _samr_QueryDomainInfo
********************************************************************/
-NTSTATUS _samr_QueryDomainInfo(pipes_struct *p,
- struct samr_QueryDomainInfo *r)
+static uint32_t samr_get_server_role(void)
{
- NTSTATUS status = NT_STATUS_OK;
- struct samr_domain_info *dinfo;
- union samr_DomainInfo *dom_info;
- time_t u_expire, u_min_age;
+ uint32_t role = ROLE_DOMAIN_PDC;
- time_t u_lock_duration, u_reset_time;
- uint32_t u_logout;
+ if (lp_server_role() == ROLE_DOMAIN_BDC) {
+ role = ROLE_DOMAIN_BDC;
+ }
- uint32 account_policy_temp;
+ return role;
+}
- time_t seq_num;
- uint32 server_role;
+/*******************************************************************
+ ********************************************************************/
- DEBUG(5,("_samr_QueryDomainInfo: %d\n", __LINE__));
+static NTSTATUS query_dom_info_1(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo1 *r)
+{
+ uint32_t account_policy_temp;
+ time_t u_expire, u_min_age;
- dinfo = policy_handle_find(p, r->in.domain_handle,
- SAMR_ACCESS_LOOKUP_DOMAIN, NULL,
- struct samr_domain_info, &status);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
+ become_root();
- dom_info = TALLOC_ZERO_P(p->mem_ctx, union samr_DomainInfo);
- if (!dom_info) {
- return NT_STATUS_NO_MEMORY;
- }
+ /* AS ROOT !!! */
- switch (r->in.level) {
- case 0x01:
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_LEN, &account_policy_temp);
+ r->min_password_length = account_policy_temp;
- become_root();
+ pdb_get_account_policy(PDB_POLICY_PASSWORD_HISTORY, &account_policy_temp);
+ r->password_history_length = account_policy_temp;
- /* AS ROOT !!! */
+ pdb_get_account_policy(PDB_POLICY_USER_MUST_LOGON_TO_CHG_PASS,
+ &r->password_properties);
- pdb_get_account_policy(AP_MIN_PASSWORD_LEN,
- &account_policy_temp);
- dom_info->info1.min_password_length = account_policy_temp;
+ pdb_get_account_policy(PDB_POLICY_MAX_PASSWORD_AGE, &account_policy_temp);
+ u_expire = account_policy_temp;
- pdb_get_account_policy(AP_PASSWORD_HISTORY, &account_policy_temp);
- dom_info->info1.password_history_length = account_policy_temp;
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_AGE, &account_policy_temp);
+ u_min_age = account_policy_temp;
- pdb_get_account_policy(AP_USER_MUST_LOGON_TO_CHG_PASS,
- &dom_info->info1.password_properties);
+ /* !AS ROOT */
- pdb_get_account_policy(AP_MAX_PASSWORD_AGE, &account_policy_temp);
- u_expire = account_policy_temp;
+ unbecome_root();
- pdb_get_account_policy(AP_MIN_PASSWORD_AGE, &account_policy_temp);
- u_min_age = account_policy_temp;
+ unix_to_nt_time_abs((NTTIME *)&r->max_password_age, u_expire);
+ unix_to_nt_time_abs((NTTIME *)&r->min_password_age, u_min_age);
- /* !AS ROOT */
+ if (lp_check_password_script() && *lp_check_password_script()) {
+ r->password_properties |= DOMAIN_PASSWORD_COMPLEX;
+ }
- unbecome_root();
+ return NT_STATUS_OK;
+}
- unix_to_nt_time_abs((NTTIME *)&dom_info->info1.max_password_age, u_expire);
- unix_to_nt_time_abs((NTTIME *)&dom_info->info1.min_password_age, u_min_age);
+/*******************************************************************
+ ********************************************************************/
- if (lp_check_password_script() && *lp_check_password_script()) {
- dom_info->info1.password_properties |= DOMAIN_PASSWORD_COMPLEX;
- }
+static NTSTATUS query_dom_info_2(TALLOC_CTX *mem_ctx,
+ struct samr_DomGeneralInformation *r,
+ struct samr_domain_info *dinfo)
+{
+ uint32_t u_logout;
+ time_t seq_num;
- break;
- case 0x02:
+ become_root();
- become_root();
+ /* AS ROOT !!! */
- /* AS ROOT !!! */
+ r->num_users = count_sam_users(dinfo->disp_info, ACB_NORMAL);
+ r->num_groups = count_sam_groups(dinfo->disp_info);
+ r->num_aliases = count_sam_aliases(dinfo->disp_info);
- dom_info->general.num_users = count_sam_users(
- dinfo->disp_info, ACB_NORMAL);
- dom_info->general.num_groups = count_sam_groups(
- dinfo->disp_info);
- dom_info->general.num_aliases = count_sam_aliases(
- dinfo->disp_info);
+ pdb_get_account_policy(PDB_POLICY_TIME_TO_LOGOUT, &u_logout);
- pdb_get_account_policy(AP_TIME_TO_LOGOUT, &u_logout);
+ unix_to_nt_time_abs(&r->force_logoff_time, u_logout);
- unix_to_nt_time_abs(&dom_info->general.force_logoff_time, u_logout);
+ if (!pdb_get_seq_num(&seq_num)) {
+ seq_num = time(NULL);
+ }
- if (!pdb_get_seq_num(&seq_num))
- seq_num = time(NULL);
+ /* !AS ROOT */
- /* !AS ROOT */
+ unbecome_root();
- unbecome_root();
+ r->oem_information.string = lp_serverstring();
+ r->domain_name.string = lp_workgroup();
+ r->primary.string = global_myname();
+ r->sequence_num = seq_num;
+ r->domain_server_state = DOMAIN_SERVER_ENABLED;
+ r->role = (enum samr_Role) samr_get_server_role();
+ r->unknown3 = 1;
- server_role = ROLE_DOMAIN_PDC;
- if (lp_server_role() == ROLE_DOMAIN_BDC)
- server_role = ROLE_DOMAIN_BDC;
+ return NT_STATUS_OK;
+}
- dom_info->general.oem_information.string = lp_serverstring();
- dom_info->general.domain_name.string = lp_workgroup();
- dom_info->general.primary.string = global_myname();
- dom_info->general.sequence_num = seq_num;
- dom_info->general.domain_server_state = DOMAIN_SERVER_ENABLED;
- dom_info->general.role = server_role;
- dom_info->general.unknown3 = 1;
+/*******************************************************************
+ ********************************************************************/
- break;
- case 0x03:
+static NTSTATUS query_dom_info_3(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo3 *r)
+{
+ uint32_t u_logout;
- become_root();
+ become_root();
- /* AS ROOT !!! */
+ /* AS ROOT !!! */
- {
- uint32 ul;
- pdb_get_account_policy(AP_TIME_TO_LOGOUT, &ul);
- u_logout = (time_t)ul;
- }
+ {
+ uint32_t ul;
+ pdb_get_account_policy(PDB_POLICY_TIME_TO_LOGOUT, &ul);
+ u_logout = (time_t)ul;
+ }
- /* !AS ROOT */
+ /* !AS ROOT */
- unbecome_root();
+ unbecome_root();
- unix_to_nt_time_abs(&dom_info->info3.force_logoff_time, u_logout);
+ unix_to_nt_time_abs(&r->force_logoff_time, u_logout);
- break;
- case 0x04:
- dom_info->oem.oem_information.string = lp_serverstring();
- break;
- case 0x05:
- dom_info->info5.domain_name.string = get_global_sam_name();
- break;
- case 0x06:
- /* NT returns its own name when a PDC. win2k and later
- * only the name of the PDC if itself is a BDC (samba4
- * idl) */
- dom_info->info6.primary.string = global_myname();
- break;
- case 0x07:
- server_role = ROLE_DOMAIN_PDC;
- if (lp_server_role() == ROLE_DOMAIN_BDC)
- server_role = ROLE_DOMAIN_BDC;
+ return NT_STATUS_OK;
+}
- dom_info->info7.role = server_role;
- break;
- case 0x08:
+/*******************************************************************
+ ********************************************************************/
- become_root();
+static NTSTATUS query_dom_info_4(TALLOC_CTX *mem_ctx,
+ struct samr_DomOEMInformation *r)
+{
+ r->oem_information.string = lp_serverstring();
- /* AS ROOT !!! */
+ return NT_STATUS_OK;
+}
- if (!pdb_get_seq_num(&seq_num)) {
- seq_num = time(NULL);
- }
+/*******************************************************************
+ ********************************************************************/
- /* !AS ROOT */
+static NTSTATUS query_dom_info_5(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo5 *r)
+{
+ r->domain_name.string = get_global_sam_name();
- unbecome_root();
+ return NT_STATUS_OK;
+}
- dom_info->info8.sequence_num = seq_num;
- dom_info->info8.domain_create_time = 0;
+/*******************************************************************
+ ********************************************************************/
- break;
- case 0x0c:
+static NTSTATUS query_dom_info_6(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo6 *r)
+{
+ /* NT returns its own name when a PDC. win2k and later
+ * only the name of the PDC if itself is a BDC (samba4
+ * idl) */
+ r->primary.string = global_myname();
- become_root();
+ return NT_STATUS_OK;
+}
- /* AS ROOT !!! */
+/*******************************************************************
+ ********************************************************************/
- pdb_get_account_policy(AP_LOCK_ACCOUNT_DURATION, &account_policy_temp);
- u_lock_duration = account_policy_temp;
- if (u_lock_duration != -1) {
- u_lock_duration *= 60;
- }
+static NTSTATUS query_dom_info_7(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo7 *r)
+{
+ r->role = (enum samr_Role) samr_get_server_role();
- pdb_get_account_policy(AP_RESET_COUNT_TIME, &account_policy_temp);
- u_reset_time = account_policy_temp * 60;
+ return NT_STATUS_OK;
+}
- pdb_get_account_policy(AP_BAD_ATTEMPT_LOCKOUT,
- &account_policy_temp);
- dom_info->info12.lockout_threshold = account_policy_temp;
+/*******************************************************************
+ ********************************************************************/
- /* !AS ROOT */
+static NTSTATUS query_dom_info_8(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo8 *r)
+{
+ time_t seq_num;
- unbecome_root();
+ become_root();
- unix_to_nt_time_abs(&dom_info->info12.lockout_duration,
- u_lock_duration);
- unix_to_nt_time_abs(&dom_info->info12.lockout_window,
- u_reset_time);
+ /* AS ROOT !!! */
- break;
- default:
- return NT_STATUS_INVALID_INFO_CLASS;
+ if (!pdb_get_seq_num(&seq_num)) {
+ seq_num = time(NULL);
}
- *r->out.info = dom_info;
+ /* !AS ROOT */
- DEBUG(5,("_samr_QueryDomainInfo: %d\n", __LINE__));
+ unbecome_root();
- return status;
+ r->sequence_num = seq_num;
+ r->domain_create_time = 0;
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS query_dom_info_9(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo9 *r)
+{
+ r->domain_server_state = DOMAIN_SERVER_ENABLED;
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS query_dom_info_11(TALLOC_CTX *mem_ctx,
+ struct samr_DomGeneralInformation2 *r,
+ struct samr_domain_info *dinfo)
+{
+ NTSTATUS status;
+ uint32_t account_policy_temp;
+ time_t u_lock_duration, u_reset_time;
+
+ status = query_dom_info_2(mem_ctx, &r->general, dinfo);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ /* AS ROOT !!! */
+
+ become_root();
+
+ pdb_get_account_policy(PDB_POLICY_LOCK_ACCOUNT_DURATION, &account_policy_temp);
+ u_lock_duration = account_policy_temp;
+ if (u_lock_duration != -1) {
+ u_lock_duration *= 60;
+ }
+
+ pdb_get_account_policy(PDB_POLICY_RESET_COUNT_TIME, &account_policy_temp);
+ u_reset_time = account_policy_temp * 60;
+
+ pdb_get_account_policy(PDB_POLICY_BAD_ATTEMPT_LOCKOUT, &account_policy_temp);
+ r->lockout_threshold = account_policy_temp;
+
+ /* !AS ROOT */
+
+ unbecome_root();
+
+ unix_to_nt_time_abs(&r->lockout_duration, u_lock_duration);
+ unix_to_nt_time_abs(&r->lockout_window, u_reset_time);
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS query_dom_info_12(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo12 *r)
+{
+ uint32_t account_policy_temp;
+ time_t u_lock_duration, u_reset_time;
+
+ become_root();
+
+ /* AS ROOT !!! */
+
+ pdb_get_account_policy(PDB_POLICY_LOCK_ACCOUNT_DURATION, &account_policy_temp);
+ u_lock_duration = account_policy_temp;
+ if (u_lock_duration != -1) {
+ u_lock_duration *= 60;
+ }
+
+ pdb_get_account_policy(PDB_POLICY_RESET_COUNT_TIME, &account_policy_temp);
+ u_reset_time = account_policy_temp * 60;
+
+ pdb_get_account_policy(PDB_POLICY_BAD_ATTEMPT_LOCKOUT, &account_policy_temp);
+ r->lockout_threshold = account_policy_temp;
+
+ /* !AS ROOT */
+
+ unbecome_root();
+
+ unix_to_nt_time_abs(&r->lockout_duration, u_lock_duration);
+ unix_to_nt_time_abs(&r->lockout_window, u_reset_time);
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS query_dom_info_13(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo13 *r)
+{
+ time_t seq_num;
+
+ become_root();
+
+ /* AS ROOT !!! */
+
+ if (!pdb_get_seq_num(&seq_num)) {
+ seq_num = time(NULL);
+ }
+
+ /* !AS ROOT */
+
+ unbecome_root();
+
+ r->sequence_num = seq_num;
+ r->domain_create_time = 0;
+ r->modified_count_at_last_promotion = 0;
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ _samr_QueryDomainInfo
+ ********************************************************************/
+
+NTSTATUS _samr_QueryDomainInfo(struct pipes_struct *p,
+ struct samr_QueryDomainInfo *r)
+{
+ NTSTATUS status = NT_STATUS_OK;
+ struct samr_domain_info *dinfo;
+ union samr_DomainInfo *dom_info;
+
+ uint32_t acc_required;
+
+ DEBUG(5,("_samr_QueryDomainInfo: %d\n", __LINE__));
+
+ switch (r->in.level) {
+ case 1: /* DomainPasswordInformation */
+ case 12: /* DomainLockoutInformation */
+ /* DOMAIN_READ_PASSWORD_PARAMETERS */
+ acc_required = SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1;
+ break;
+ case 11: /* DomainGeneralInformation2 */
+ /* DOMAIN_READ_PASSWORD_PARAMETERS |
+ * DOMAIN_READ_OTHER_PARAMETERS */
+ acc_required = SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
+ SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
+ break;
+ case 2: /* DomainGeneralInformation */
+ case 3: /* DomainLogoffInformation */
+ case 4: /* DomainOemInformation */
+ case 5: /* DomainReplicationInformation */
+ case 6: /* DomainReplicationInformation */
+ case 7: /* DomainServerRoleInformation */
+ case 8: /* DomainModifiedInformation */
+ case 9: /* DomainStateInformation */
+ case 10: /* DomainUasInformation */
+ case 13: /* DomainModifiedInformation2 */
+ /* DOMAIN_READ_OTHER_PARAMETERS */
+ acc_required = SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
+ break;
+ default:
+ return NT_STATUS_INVALID_INFO_CLASS;
+ }
+
+ dinfo = policy_handle_find(p, r->in.domain_handle,
+ acc_required, NULL,
+ struct samr_domain_info, &status);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ dom_info = TALLOC_ZERO_P(p->mem_ctx, union samr_DomainInfo);
+ if (!dom_info) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ switch (r->in.level) {
+ case 1:
+ status = query_dom_info_1(p->mem_ctx, &dom_info->info1);
+ break;
+ case 2:
+ status = query_dom_info_2(p->mem_ctx, &dom_info->general, dinfo);
+ break;
+ case 3:
+ status = query_dom_info_3(p->mem_ctx, &dom_info->info3);
+ break;
+ case 4:
+ status = query_dom_info_4(p->mem_ctx, &dom_info->oem);
+ break;
+ case 5:
+ status = query_dom_info_5(p->mem_ctx, &dom_info->info5);
+ break;
+ case 6:
+ status = query_dom_info_6(p->mem_ctx, &dom_info->info6);
+ break;
+ case 7:
+ status = query_dom_info_7(p->mem_ctx, &dom_info->info7);
+ break;
+ case 8:
+ status = query_dom_info_8(p->mem_ctx, &dom_info->info8);
+ break;
+ case 9:
+ status = query_dom_info_9(p->mem_ctx, &dom_info->info9);
+ break;
+ case 11:
+ status = query_dom_info_11(p->mem_ctx, &dom_info->general2, dinfo);
+ break;
+ case 12:
+ status = query_dom_info_12(p->mem_ctx, &dom_info->info12);
+ break;
+ case 13:
+ status = query_dom_info_13(p->mem_ctx, &dom_info->info13);
+ break;
+ default:
+ return NT_STATUS_INVALID_INFO_CLASS;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ *r->out.info = dom_info;
+
+ DEBUG(5,("_samr_QueryDomainInfo: %d\n", __LINE__));
+
+ return status;
}
/* W2k3 seems to use the same check for all 3 objects that can be created via
_samr_CreateUser2
********************************************************************/
-NTSTATUS _samr_CreateUser2(pipes_struct *p,
+NTSTATUS _samr_CreateUser2(struct pipes_struct *p,
struct samr_CreateUser2 *r)
{
const char *account = NULL;
- DOM_SID sid;
+ struct dom_sid sid;
uint32_t acb_info = r->in.acct_flags;
struct samr_domain_info *dinfo;
struct samr_user_info *uinfo;
NTSTATUS nt_status;
uint32 acc_granted;
- SEC_DESC *psd;
+ struct security_descriptor *psd;
size_t sd_size;
/* check this, when giving away 'add computer to domain' privs */
uint32 des_access = GENERIC_RIGHTS_USER_ALL_ACCESS;
bool can_add_account = False;
- SE_PRIV se_rights;
+
+ /* Which privilege is needed to override the ACL? */
+ enum sec_privilege needed_priv = SEC_PRIV_INVALID;
dinfo = policy_handle_find(p, r->in.domain_handle,
SAMR_DOMAIN_ACCESS_CREATE_USER, NULL,
/* determine which user right we need to check based on the acb_info */
- if ( acb_info & ACB_WSTRUST )
- {
- se_priv_copy( &se_rights, &se_machine_account );
- can_add_account = user_has_privileges(
- p->server_info->ptok, &se_rights );
- }
- /* usrmgr.exe (and net rpc trustdom grant) creates a normal user
- account for domain trusts and changes the ACB flags later */
- else if ( acb_info & ACB_NORMAL &&
- (account[strlen(account)-1] != '$') )
- {
- se_priv_copy( &se_rights, &se_add_users );
- can_add_account = user_has_privileges(
- p->server_info->ptok, &se_rights );
- }
- else /* implicit assumption of a BDC or domain trust account here
+ if (geteuid() == sec_initial_uid()) {
+ can_add_account = true;
+ } else if (acb_info & ACB_WSTRUST) {
+ needed_priv = SEC_PRIV_MACHINE_ACCOUNT;
+ can_add_account = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_MACHINE_ACCOUNT);
+ } else if (acb_info & ACB_NORMAL &&
+ (account[strlen(account)-1] != '$')) {
+ /* usrmgr.exe (and net rpc trustdom grant) creates a normal user
+ account for domain trusts and changes the ACB flags later */
+ needed_priv = SEC_PRIV_ADD_USERS;
+ can_add_account = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_ADD_USERS);
+ } else if (lp_enable_privileges()) {
+ /* implicit assumption of a BDC or domain trust account here
* (we already check the flags earlier) */
- {
- if ( lp_enable_privileges() ) {
- /* only Domain Admins can add a BDC or domain trust */
- se_priv_copy( &se_rights, &se_priv_none );
- can_add_account = nt_token_check_domain_rid(
- p->server_info->ptok,
- DOMAIN_GROUP_RID_ADMINS );
- }
+ /* only Domain Admins can add a BDC or domain trust */
+ can_add_account = nt_token_check_domain_rid(
+ p->server_info->ptok,
+ DOMAIN_RID_ADMINS );
}
DEBUG(5, ("_samr_CreateUser2: %s can add this account : %s\n",
uidtoname(p->server_info->utok.uid),
can_add_account ? "True":"False" ));
- /********** BEGIN Admin BLOCK **********/
+ if (!can_add_account) {
+ return NT_STATUS_ACCESS_DENIED;
+ }
- if ( can_add_account )
- become_root();
+ /********** BEGIN Admin BLOCK **********/
+ become_root();
nt_status = pdb_create_user(p->mem_ctx, account, acb_info,
r->out.rid);
-
- if ( can_add_account )
- unbecome_root();
+ unbecome_root();
/********** END Admin BLOCK **********/
sid_compose(&sid, get_global_sam_sid(), *r->out.rid);
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd(p->mem_ctx, &psd, &sd_size, &usr_generic_mapping,
&sid, SAMR_USR_RIGHTS_WRITE_PW);
se_map_generic(&des_access, &usr_generic_mapping);
- nt_status = access_check_samr_object(psd, p->server_info->ptok,
- &se_rights, GENERIC_RIGHTS_USER_WRITE, des_access,
+ /*
+ * JRA - TESTME. We just created this user so we
+ * had rights to create them. Do we need to check
+ * any further access on this object ? Can't we
+ * just assume we have all the rights we need ?
+ */
+
+ nt_status = access_check_object(psd, p->server_info->ptok,
+ needed_priv, SEC_PRIV_INVALID,
+ GENERIC_RIGHTS_USER_WRITE, des_access,
&acc_granted, "_samr_CreateUser2");
if ( !NT_STATUS_IS_OK(nt_status) ) {
/****************************************************************
****************************************************************/
-NTSTATUS _samr_CreateUser(pipes_struct *p,
+NTSTATUS _samr_CreateUser(struct pipes_struct *p,
struct samr_CreateUser *r)
{
struct samr_CreateUser2 c;
_samr_Connect
********************************************************************/
-NTSTATUS _samr_Connect(pipes_struct *p,
+NTSTATUS _samr_Connect(struct pipes_struct *p,
struct samr_Connect *r)
{
struct samr_connect_info *info;
was observed from a win98 client trying to enumerate users (when configured
user level access control on shares) --jerry */
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
se_map_generic( &des_access, &sam_generic_mapping );
_samr_Connect2
********************************************************************/
-NTSTATUS _samr_Connect2(pipes_struct *p,
+NTSTATUS _samr_Connect2(struct pipes_struct *p,
struct samr_Connect2 *r)
{
struct samr_connect_info *info = NULL;
struct policy_handle hnd;
- SEC_DESC *psd = NULL;
+ struct security_descriptor *psd = NULL;
uint32 acc_granted;
uint32 des_access = r->in.access_mask;
NTSTATUS nt_status;
size_t sd_size;
const char *fn = "_samr_Connect2";
- switch (p->hdr_req.opnum) {
+ switch (p->opnum) {
case NDR_SAMR_CONNECT2:
fn = "_samr_Connect2";
break;
return NT_STATUS_ACCESS_DENIED;
}
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd(p->mem_ctx, &psd, &sd_size, &sam_generic_mapping, NULL, 0);
se_map_generic(&des_access, &sam_generic_mapping);
- nt_status = access_check_samr_object(psd, p->server_info->ptok,
- NULL, 0, des_access, &acc_granted, fn);
+ nt_status = access_check_object(psd, p->server_info->ptok,
+ SEC_PRIV_INVALID, SEC_PRIV_INVALID,
+ 0, des_access, &acc_granted, fn);
if ( !NT_STATUS_IS_OK(nt_status) )
return nt_status;
_samr_Connect3
****************************************************************/
-NTSTATUS _samr_Connect3(pipes_struct *p,
+NTSTATUS _samr_Connect3(struct pipes_struct *p,
struct samr_Connect3 *r)
{
struct samr_Connect2 c;
_samr_Connect4
********************************************************************/
-NTSTATUS _samr_Connect4(pipes_struct *p,
+NTSTATUS _samr_Connect4(struct pipes_struct *p,
struct samr_Connect4 *r)
{
struct samr_Connect2 c;
_samr_Connect5
********************************************************************/
-NTSTATUS _samr_Connect5(pipes_struct *p,
+NTSTATUS _samr_Connect5(struct pipes_struct *p,
struct samr_Connect5 *r)
{
NTSTATUS status;
_samr_LookupDomain
**********************************************************************/
-NTSTATUS _samr_LookupDomain(pipes_struct *p,
+NTSTATUS _samr_LookupDomain(struct pipes_struct *p,
struct samr_LookupDomain *r)
{
NTSTATUS status;
struct samr_connect_info *info;
const char *domain_name;
- DOM_SID *sid = NULL;
+ struct dom_sid *sid = NULL;
/* win9x user manager likes to use SAMR_ACCESS_ENUM_DOMAINS here.
Reverted that change so we will work with RAS servers again */
_samr_EnumDomains
**********************************************************************/
-NTSTATUS _samr_EnumDomains(pipes_struct *p,
+NTSTATUS _samr_EnumDomains(struct pipes_struct *p,
struct samr_EnumDomains *r)
{
NTSTATUS status;
_samr_OpenAlias
********************************************************************/
-NTSTATUS _samr_OpenAlias(pipes_struct *p,
+NTSTATUS _samr_OpenAlias(struct pipes_struct *p,
struct samr_OpenAlias *r)
{
- DOM_SID sid;
+ struct dom_sid sid;
uint32 alias_rid = r->in.rid;
struct samr_alias_info *ainfo;
struct samr_domain_info *dinfo;
- SEC_DESC *psd = NULL;
+ struct security_descriptor *psd = NULL;
uint32 acc_granted;
uint32 des_access = r->in.access_mask;
size_t sd_size;
NTSTATUS status;
- SE_PRIV se_rights;
dinfo = policy_handle_find(p, r->in.domain_handle,
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, NULL,
/*check if access can be granted as requested by client. */
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd(p->mem_ctx, &psd, &sd_size, &ali_generic_mapping, NULL, 0);
se_map_generic(&des_access,&ali_generic_mapping);
- se_priv_copy( &se_rights, &se_add_users );
-
-
- status = access_check_samr_object(psd, p->server_info->ptok,
- &se_rights, GENERIC_RIGHTS_ALIAS_WRITE, des_access,
- &acc_granted, "_samr_OpenAlias");
+ status = access_check_object(psd, p->server_info->ptok,
+ SEC_PRIV_ADD_USERS, SEC_PRIV_INVALID,
+ GENERIC_RIGHTS_ALIAS_ALL_ACCESS,
+ des_access, &acc_granted, "_samr_OpenAlias");
if ( !NT_STATUS_IS_OK(status) )
return status;
code (like UNSUCCESSFUL instead of ALREADY_EXISTS). */
rc = can_create(mem_ctx, id7->account_name.string);
+
+ /* when there is nothing to change, we're done here */
+ if (NT_STATUS_EQUAL(rc, NT_STATUS_USER_EXISTS) &&
+ strequal(id7->account_name.string, pdb_get_username(pwd))) {
+ return NT_STATUS_OK;
+ }
if (!NT_STATUS_IS_OK(rc)) {
return rc;
}
static NTSTATUS set_user_info_23(TALLOC_CTX *mem_ctx,
struct samr_UserInfo23 *id23,
+ const char *rhost,
struct samu *pwd)
{
char *plaintext_buf = NULL;
DEBUG(1, ("chgpasswd: Username does not exist in system !?!\n"));
}
- if(!chgpasswd(pdb_get_username(pwd), passwd, "", plaintext_buf, True)) {
+ if(!chgpasswd(pdb_get_username(pwd), rhost,
+ passwd, "", plaintext_buf, True)) {
return NT_STATUS_ACCESS_DENIED;
}
TALLOC_FREE(passwd);
set_user_info_pw
********************************************************************/
-static bool set_user_info_pw(uint8 *pass, struct samu *pwd)
+static bool set_user_info_pw(uint8 *pass, const char *rhost, struct samu *pwd)
{
size_t len = 0;
char *plaintext_buf = NULL;
DEBUG(1, ("chgpasswd: Username does not exist in system !?!\n"));
}
- if(!chgpasswd(pdb_get_username(pwd), passwd, "", plaintext_buf, True)) {
+ if(!chgpasswd(pdb_get_username(pwd), rhost, passwd,
+ "", plaintext_buf, True)) {
return False;
}
TALLOC_FREE(passwd);
********************************************************************/
static NTSTATUS set_user_info_24(TALLOC_CTX *mem_ctx,
+ const char *rhost,
struct samr_UserInfo24 *id24,
struct samu *pwd)
{
return NT_STATUS_INVALID_PARAMETER;
}
- if (!set_user_info_pw(id24->password.data, pwd)) {
+ if (!set_user_info_pw(id24->password.data, rhost, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
********************************************************************/
static NTSTATUS set_user_info_25(TALLOC_CTX *mem_ctx,
+ const char *rhost,
struct samr_UserInfo25 *id25,
struct samu *pwd)
{
if ((id25->info.fields_present & SAMR_FIELD_NT_PASSWORD_PRESENT) ||
(id25->info.fields_present & SAMR_FIELD_LM_PASSWORD_PRESENT)) {
- if (!set_user_info_pw(id25->password.data, pwd)) {
+ if (!set_user_info_pw(id25->password.data, rhost, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
}
********************************************************************/
static NTSTATUS set_user_info_26(TALLOC_CTX *mem_ctx,
+ const char *rhost,
struct samr_UserInfo26 *id26,
struct samu *pwd)
{
return NT_STATUS_INVALID_PARAMETER;
}
- if (!set_user_info_pw(id26->password.data, pwd)) {
+ if (!set_user_info_pw(id26->password.data, rhost, pwd)) {
return NT_STATUS_WRONG_PASSWORD;
}
return NT_STATUS_OK;
}
+/*************************************************************
+**************************************************************/
+
+static uint32_t samr_set_user_info_map_fields_to_access_mask(uint32_t fields)
+{
+ uint32_t acc_required = 0;
+
+ /* USER_ALL_USERNAME */
+ if (fields & SAMR_FIELD_ACCOUNT_NAME)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_FULLNAME */
+ if (fields & SAMR_FIELD_FULL_NAME)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_PRIMARYGROUPID */
+ if (fields & SAMR_FIELD_PRIMARY_GID)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_HOMEDIRECTORY */
+ if (fields & SAMR_FIELD_HOME_DIRECTORY)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_HOMEDIRECTORYDRIVE */
+ if (fields & SAMR_FIELD_HOME_DRIVE)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_SCRIPTPATH */
+ if (fields & SAMR_FIELD_LOGON_SCRIPT)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_PROFILEPATH */
+ if (fields & SAMR_FIELD_PROFILE_PATH)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_ADMINCOMMENT */
+ if (fields & SAMR_FIELD_COMMENT)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_WORKSTATIONS */
+ if (fields & SAMR_FIELD_WORKSTATIONS)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_LOGONHOURS */
+ if (fields & SAMR_FIELD_LOGON_HOURS)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_ACCOUNTEXPIRES */
+ if (fields & SAMR_FIELD_ACCT_EXPIRY)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_USERACCOUNTCONTROL */
+ if (fields & SAMR_FIELD_ACCT_FLAGS)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_PARAMETERS */
+ if (fields & SAMR_FIELD_PARAMETERS)
+ acc_required |= SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ /* USER_ALL_USERCOMMENT */
+ if (fields & SAMR_FIELD_COMMENT)
+ acc_required |= SAMR_USER_ACCESS_SET_LOC_COM;
+ /* USER_ALL_COUNTRYCODE */
+ if (fields & SAMR_FIELD_COUNTRY_CODE)
+ acc_required |= SAMR_USER_ACCESS_SET_LOC_COM;
+ /* USER_ALL_CODEPAGE */
+ if (fields & SAMR_FIELD_CODE_PAGE)
+ acc_required |= SAMR_USER_ACCESS_SET_LOC_COM;
+ /* USER_ALL_NTPASSWORDPRESENT */
+ if (fields & SAMR_FIELD_NT_PASSWORD_PRESENT)
+ acc_required |= SAMR_USER_ACCESS_SET_PASSWORD;
+ /* USER_ALL_LMPASSWORDPRESENT */
+ if (fields & SAMR_FIELD_LM_PASSWORD_PRESENT)
+ acc_required |= SAMR_USER_ACCESS_SET_PASSWORD;
+ /* USER_ALL_PASSWORDEXPIRED */
+ if (fields & SAMR_FIELD_EXPIRED_FLAG)
+ acc_required |= SAMR_USER_ACCESS_SET_PASSWORD;
+
+ return acc_required;
+}
/*******************************************************************
samr_SetUserInfo
********************************************************************/
-NTSTATUS _samr_SetUserInfo(pipes_struct *p,
+NTSTATUS _samr_SetUserInfo(struct pipes_struct *p,
struct samr_SetUserInfo *r)
{
struct samr_user_info *uinfo;
NTSTATUS status;
struct samu *pwd = NULL;
union samr_UserInfo *info = r->in.info;
- uint16_t switch_value = r->in.level;
- uint32_t acc_required;
+ uint32_t acc_required = 0;
+ uint32_t fields = 0;
bool ret;
- bool has_enough_rights = False;
- uint32_t acb_info;
DEBUG(5,("_samr_SetUserInfo: %d\n", __LINE__));
This should be enough for levels 18, 24, 25,& 26. Info level 23 can set more so
we'll use the set from the WinXP join as the basis. */
- switch (switch_value) {
- case 18:
- case 24:
- case 25:
- case 26:
+ switch (r->in.level) {
+ case 2: /* UserPreferencesInformation */
+ /* USER_WRITE_ACCOUNT | USER_WRITE_PREFERENCES */
+ acc_required = SAMR_USER_ACCESS_SET_ATTRIBUTES | SAMR_USER_ACCESS_SET_LOC_COM;
+ break;
+ case 4: /* UserLogonHoursInformation */
+ case 6: /* UserNameInformation */
+ case 7: /* UserAccountNameInformation */
+ case 8: /* UserFullNameInformation */
+ case 9: /* UserPrimaryGroupInformation */
+ case 10: /* UserHomeInformation */
+ case 11: /* UserScriptInformation */
+ case 12: /* UserProfileInformation */
+ case 13: /* UserAdminCommentInformation */
+ case 14: /* UserWorkStationsInformation */
+ case 16: /* UserControlInformation */
+ case 17: /* UserExpiresInformation */
+ case 20: /* UserParametersInformation */
+ /* USER_WRITE_ACCOUNT */
+ acc_required = SAMR_USER_ACCESS_SET_ATTRIBUTES;
+ break;
+ case 18: /* UserInternal1Information */
+ /* FIXME: gd, this is a guess */
acc_required = SAMR_USER_ACCESS_SET_PASSWORD;
break;
- default:
- acc_required = SAMR_USER_ACCESS_SET_PASSWORD |
- SAMR_USER_ACCESS_SET_ATTRIBUTES |
- SAMR_USER_ACCESS_GET_ATTRIBUTES;
+ case 21: /* UserAllInformation */
+ fields = info->info21.fields_present;
+ acc_required = samr_set_user_info_map_fields_to_access_mask(fields);
+ break;
+ case 23: /* UserInternal4Information */
+ fields = info->info23.info.fields_present;
+ acc_required = samr_set_user_info_map_fields_to_access_mask(fields);
+ break;
+ case 25: /* UserInternal4InformationNew */
+ fields = info->info25.info.fields_present;
+ acc_required = samr_set_user_info_map_fields_to_access_mask(fields);
+ break;
+ case 24: /* UserInternal5Information */
+ case 26: /* UserInternal5InformationNew */
+ acc_required = SAMR_USER_ACCESS_SET_PASSWORD;
break;
+ default:
+ return NT_STATUS_INVALID_INFO_CLASS;
}
uinfo = policy_handle_find(p, r->in.user_handle, acc_required, NULL,
}
DEBUG(5, ("_samr_SetUserInfo: sid:%s, level:%d\n",
- sid_string_dbg(&uinfo->sid), switch_value));
+ sid_string_dbg(&uinfo->sid), r->in.level));
if (info == NULL) {
DEBUG(5, ("_samr_SetUserInfo: NULL info level\n"));
return NT_STATUS_NO_SUCH_USER;
}
- /* deal with machine password changes differently from userinfo changes */
- /* check to see if we have the sufficient rights */
-
- acb_info = pdb_get_acct_ctrl(pwd);
- if (acb_info & ACB_WSTRUST)
- has_enough_rights = user_has_privileges(p->server_info->ptok,
- &se_machine_account);
- else if (acb_info & ACB_NORMAL)
- has_enough_rights = user_has_privileges(p->server_info->ptok,
- &se_add_users);
- else if (acb_info & (ACB_SVRTRUST|ACB_DOMTRUST)) {
- if (lp_enable_privileges()) {
- has_enough_rights = nt_token_check_domain_rid(p->server_info->ptok,
- DOMAIN_GROUP_RID_ADMINS);
- }
- }
-
- DEBUG(5, ("_samr_SetUserInfo: %s does%s possess sufficient rights\n",
- uidtoname(p->server_info->utok.uid),
- has_enough_rights ? "" : " not"));
-
- /* ================ BEGIN SeMachineAccountPrivilege BLOCK ================ */
+ /* ================ BEGIN Privilege BLOCK ================ */
- if (has_enough_rights) {
- become_root();
- }
+ become_root();
/* ok! user info levels (lots: see MSDEV help), off we go... */
- switch (switch_value) {
+ switch (r->in.level) {
case 2:
status = set_user_info_2(p->mem_ctx,
dump_data(100, info->info23.password.data, 516);
status = set_user_info_23(p->mem_ctx,
- &info->info23, pwd);
+ &info->info23,
+ p->client_id->name,
+ pwd);
break;
case 24:
dump_data(100, info->info24.password.data, 516);
status = set_user_info_24(p->mem_ctx,
+ p->client_id->name,
&info->info24, pwd);
break;
dump_data(100, info->info25.password.data, 532);
status = set_user_info_25(p->mem_ctx,
+ p->client_id->name,
&info->info25, pwd);
break;
dump_data(100, info->info26.password.data, 516);
status = set_user_info_26(p->mem_ctx,
+ p->client_id->name,
&info->info26, pwd);
break;
TALLOC_FREE(pwd);
- if (has_enough_rights) {
- unbecome_root();
- }
+ unbecome_root();
- /* ================ END SeMachineAccountPrivilege BLOCK ================ */
+ /* ================ END Privilege BLOCK ================ */
if (NT_STATUS_IS_OK(status)) {
force_flush_samr_cache(&uinfo->sid);
_samr_SetUserInfo2
********************************************************************/
-NTSTATUS _samr_SetUserInfo2(pipes_struct *p,
+NTSTATUS _samr_SetUserInfo2(struct pipes_struct *p,
struct samr_SetUserInfo2 *r)
{
struct samr_SetUserInfo q;
_samr_GetAliasMembership
*********************************************************************/
-NTSTATUS _samr_GetAliasMembership(pipes_struct *p,
+NTSTATUS _samr_GetAliasMembership(struct pipes_struct *p,
struct samr_GetAliasMembership *r)
{
size_t num_alias_rids;
NTSTATUS status;
- DOM_SID *members;
+ struct dom_sid *members;
DEBUG(5,("_samr_GetAliasMembership: %d\n", __LINE__));
return NT_STATUS_OBJECT_TYPE_MISMATCH;
if (r->in.sids->num_sids) {
- members = TALLOC_ARRAY(p->mem_ctx, DOM_SID, r->in.sids->num_sids);
+ members = TALLOC_ARRAY(p->mem_ctx, struct dom_sid, r->in.sids->num_sids);
if (members == NULL)
return NT_STATUS_NO_MEMORY;
r->out.rids->count = num_alias_rids;
r->out.rids->ids = alias_rids;
+ if (r->out.rids->ids == NULL) {
+ /* Windows domain clients don't accept a NULL ptr here */
+ r->out.rids->ids = talloc_zero(p->mem_ctx, uint32_t);
+ }
+ if (r->out.rids->ids == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
return NT_STATUS_OK;
}
_samr_GetMembersInAlias
*********************************************************************/
-NTSTATUS _samr_GetMembersInAlias(pipes_struct *p,
+NTSTATUS _samr_GetMembersInAlias(struct pipes_struct *p,
struct samr_GetMembersInAlias *r)
{
struct samr_alias_info *ainfo;
size_t i;
size_t num_sids = 0;
struct lsa_SidPtr *sids = NULL;
- DOM_SID *pdb_sids = NULL;
+ struct dom_sid *pdb_sids = NULL;
ainfo = policy_handle_find(p, r->in.alias_handle,
SAMR_ALIAS_ACCESS_GET_MEMBERS, NULL,
DEBUG(10, ("sid is %s\n", sid_string_dbg(&ainfo->sid)));
become_root();
- status = pdb_enum_aliasmem(&ainfo->sid, &pdb_sids, &num_sids);
+ status = pdb_enum_aliasmem(&ainfo->sid, talloc_tos(), &pdb_sids,
+ &num_sids);
unbecome_root();
if (!NT_STATUS_IS_OK(status)) {
}
for (i = 0; i < num_sids; i++) {
- sids[i].sid = sid_dup_talloc(p->mem_ctx, &pdb_sids[i]);
+ sids[i].sid = dom_sid_dup(p->mem_ctx, &pdb_sids[i]);
if (!sids[i].sid) {
TALLOC_FREE(pdb_sids);
return NT_STATUS_NO_MEMORY;
_samr_QueryGroupMember
*********************************************************************/
-NTSTATUS _samr_QueryGroupMember(pipes_struct *p,
+NTSTATUS _samr_QueryGroupMember(struct pipes_struct *p,
struct samr_QueryGroupMember *r)
{
struct samr_group_info *ginfo;
_samr_AddAliasMember
*********************************************************************/
-NTSTATUS _samr_AddAliasMember(pipes_struct *p,
+NTSTATUS _samr_AddAliasMember(struct pipes_struct *p,
struct samr_AddAliasMember *r)
{
struct samr_alias_info *ainfo;
- SE_PRIV se_rights;
- bool can_add_accounts;
NTSTATUS status;
ainfo = policy_handle_find(p, r->in.alias_handle,
DEBUG(10, ("sid is %s\n", sid_string_dbg(&ainfo->sid)));
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_add_aliasmem(&ainfo->sid, r->in.sid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
_samr_DeleteAliasMember
*********************************************************************/
-NTSTATUS _samr_DeleteAliasMember(pipes_struct *p,
+NTSTATUS _samr_DeleteAliasMember(struct pipes_struct *p,
struct samr_DeleteAliasMember *r)
{
struct samr_alias_info *ainfo;
- SE_PRIV se_rights;
- bool can_add_accounts;
NTSTATUS status;
ainfo = policy_handle_find(p, r->in.alias_handle,
DEBUG(10, ("_samr_del_aliasmem:sid is %s\n",
sid_string_dbg(&ainfo->sid)));
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_del_aliasmem(&ainfo->sid, r->in.sid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
_samr_AddGroupMember
*********************************************************************/
-NTSTATUS _samr_AddGroupMember(pipes_struct *p,
+NTSTATUS _samr_AddGroupMember(struct pipes_struct *p,
struct samr_AddGroupMember *r)
{
struct samr_group_info *ginfo;
NTSTATUS status;
uint32 group_rid;
- SE_PRIV se_rights;
- bool can_add_accounts;
ginfo = policy_handle_find(p, r->in.group_handle,
SAMR_GROUP_ACCESS_ADD_MEMBER, NULL,
return NT_STATUS_INVALID_HANDLE;
}
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_add_groupmem(p->mem_ctx, group_rid, r->in.rid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
_samr_DeleteGroupMember
*********************************************************************/
-NTSTATUS _samr_DeleteGroupMember(pipes_struct *p,
+NTSTATUS _samr_DeleteGroupMember(struct pipes_struct *p,
struct samr_DeleteGroupMember *r)
{
struct samr_group_info *ginfo;
NTSTATUS status;
uint32 group_rid;
- SE_PRIV se_rights;
- bool can_add_accounts;
/*
* delete the group member named r->in.rid
return NT_STATUS_INVALID_HANDLE;
}
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_del_groupmem(p->mem_ctx, group_rid, r->in.rid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
_samr_DeleteUser
*********************************************************************/
-NTSTATUS _samr_DeleteUser(pipes_struct *p,
+NTSTATUS _samr_DeleteUser(struct pipes_struct *p,
struct samr_DeleteUser *r)
{
struct samr_user_info *uinfo;
NTSTATUS status;
struct samu *sam_pass=NULL;
- bool can_add_accounts;
- uint32 acb_info;
bool ret;
DEBUG(5, ("_samr_DeleteUser: %d\n", __LINE__));
uinfo = policy_handle_find(p, r->in.user_handle,
- STD_RIGHT_DELETE_ACCESS, NULL,
+ SEC_STD_DELETE, NULL,
struct samr_user_info, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
ret = pdb_getsampwsid(sam_pass, &uinfo->sid);
unbecome_root();
- if( !ret ) {
+ if(!ret) {
DEBUG(5,("_samr_DeleteUser: User %s doesn't exist.\n",
sid_string_dbg(&uinfo->sid)));
TALLOC_FREE(sam_pass);
return NT_STATUS_NO_SUCH_USER;
}
- acb_info = pdb_get_acct_ctrl(sam_pass);
-
- /* For machine accounts it's the SeMachineAccountPrivilege that counts. */
- if ( acb_info & ACB_WSTRUST ) {
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_machine_account );
- } else {
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_add_users );
- }
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_delete_user(p->mem_ctx, sam_pass);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
TALLOC_FREE(sam_pass);
+ force_flush_samr_cache(&uinfo->sid);
+
if (!close_policy_hnd(p, r->in.user_handle))
return NT_STATUS_OBJECT_NAME_INVALID;
ZERO_STRUCTP(r->out.user_handle);
- force_flush_samr_cache(&uinfo->sid);
-
return NT_STATUS_OK;
}
_samr_DeleteDomainGroup
*********************************************************************/
-NTSTATUS _samr_DeleteDomainGroup(pipes_struct *p,
+NTSTATUS _samr_DeleteDomainGroup(struct pipes_struct *p,
struct samr_DeleteDomainGroup *r)
{
struct samr_group_info *ginfo;
NTSTATUS status;
uint32 group_rid;
- SE_PRIV se_rights;
- bool can_add_accounts;
DEBUG(5, ("samr_DeleteDomainGroup: %d\n", __LINE__));
ginfo = policy_handle_find(p, r->in.group_handle,
- STD_RIGHT_DELETE_ACCESS, NULL,
+ SEC_STD_DELETE, NULL,
struct samr_group_info, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
return NT_STATUS_NO_SUCH_GROUP;
}
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
status = pdb_delete_dom_group(p->mem_ctx, group_rid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
return status;
}
+ force_flush_samr_cache(&ginfo->sid);
+
if (!close_policy_hnd(p, r->in.group_handle))
return NT_STATUS_OBJECT_NAME_INVALID;
- force_flush_samr_cache(&ginfo->sid);
-
return NT_STATUS_OK;
}
_samr_DeleteDomAlias
*********************************************************************/
-NTSTATUS _samr_DeleteDomAlias(pipes_struct *p,
+NTSTATUS _samr_DeleteDomAlias(struct pipes_struct *p,
struct samr_DeleteDomAlias *r)
{
struct samr_alias_info *ainfo;
- SE_PRIV se_rights;
- bool can_add_accounts;
NTSTATUS status;
DEBUG(5, ("_samr_DeleteDomAlias: %d\n", __LINE__));
ainfo = policy_handle_find(p, r->in.alias_handle,
- STD_RIGHT_DELETE_ACCESS, NULL,
+ SEC_STD_DELETE, NULL,
struct samr_alias_info, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
DEBUG(10, ("lookup on Local SID\n"));
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
/* Have passdb delete the alias */
status = pdb_delete_alias(&ainfo->sid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
if ( !NT_STATUS_IS_OK(status))
return status;
+ force_flush_samr_cache(&ainfo->sid);
+
if (!close_policy_hnd(p, r->in.alias_handle))
return NT_STATUS_OBJECT_NAME_INVALID;
- force_flush_samr_cache(&ainfo->sid);
-
return NT_STATUS_OK;
}
_samr_CreateDomainGroup
*********************************************************************/
-NTSTATUS _samr_CreateDomainGroup(pipes_struct *p,
+NTSTATUS _samr_CreateDomainGroup(struct pipes_struct *p,
struct samr_CreateDomainGroup *r)
{
const char *name;
struct samr_domain_info *dinfo;
struct samr_group_info *ginfo;
- SE_PRIV se_rights;
- bool can_add_accounts;
dinfo = policy_handle_find(p, r->in.domain_handle,
SAMR_DOMAIN_ACCESS_CREATE_GROUP, NULL,
return status;
}
- if (!sid_equal(&dinfo->sid, get_global_sam_sid()))
+ if (!sid_check_is_domain(&dinfo->sid)) {
return NT_STATUS_ACCESS_DENIED;
+ }
name = r->in.name->string;
if (name == NULL) {
return status;
}
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
/* check that we successfully create the UNIX group */
-
status = pdb_create_dom_group(p->mem_ctx, name, r->out.rid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
_samr_CreateDomAlias
*********************************************************************/
-NTSTATUS _samr_CreateDomAlias(pipes_struct *p,
+NTSTATUS _samr_CreateDomAlias(struct pipes_struct *p,
struct samr_CreateDomAlias *r)
{
- DOM_SID info_sid;
+ struct dom_sid info_sid;
const char *name = NULL;
struct samr_domain_info *dinfo;
struct samr_alias_info *ainfo;
gid_t gid;
NTSTATUS result;
- SE_PRIV se_rights;
- bool can_add_accounts;
dinfo = policy_handle_find(p, r->in.domain_handle,
SAMR_DOMAIN_ACCESS_CREATE_ALIAS, NULL,
return result;
}
- if (!sid_equal(&dinfo->sid, get_global_sam_sid()))
+ if (!sid_check_is_domain(&dinfo->sid)) {
return NT_STATUS_ACCESS_DENIED;
+ }
name = r->in.alias_name->string;
- se_priv_copy( &se_rights, &se_add_users );
- can_add_accounts = user_has_privileges( p->server_info->ptok, &se_rights );
-
result = can_create(p->mem_ctx, name);
if (!NT_STATUS_IS_OK(result)) {
return result;
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_add_accounts )
- become_root();
-
+ become_root();
/* Have passdb create the alias */
result = pdb_create_alias(name, r->out.rid);
-
- if ( can_add_accounts )
- unbecome_root();
+ unbecome_root();
/******** END SeAddUsers BLOCK *********/
/* check if the group has been successfully created */
if ( getgrgid(gid) == NULL ) {
- DEBUG(10, ("getgrgid(%d) of just created alias failed\n",
- gid));
+ DEBUG(10, ("getgrgid(%u) of just created alias failed\n",
+ (unsigned int)gid));
return NT_STATUS_ACCESS_DENIED;
}
_samr_QueryGroupInfo
*********************************************************************/
-NTSTATUS _samr_QueryGroupInfo(pipes_struct *p,
+NTSTATUS _samr_QueryGroupInfo(struct pipes_struct *p,
struct samr_QueryGroupInfo *r)
{
struct samr_group_info *ginfo;
_samr_SetGroupInfo
*********************************************************************/
-NTSTATUS _samr_SetGroupInfo(pipes_struct *p,
+NTSTATUS _samr_SetGroupInfo(struct pipes_struct *p,
struct samr_SetGroupInfo *r)
{
struct samr_group_info *ginfo;
GROUP_MAP map;
NTSTATUS status;
bool ret;
- bool can_mod_accounts;
ginfo = policy_handle_find(p, r->in.group_handle,
SAMR_GROUP_ACCESS_SET_INFO, NULL,
return NT_STATUS_NO_SUCH_GROUP;
switch (r->in.level) {
- case 1:
- fstrcpy(map.comment, r->in.info->all.description.string);
- break;
case 2:
- /* group rename is not supported yet */
- return NT_STATUS_NOT_SUPPORTED;
+ fstrcpy(map.nt_name, r->in.info->name.string);
+ break;
+ case 3:
+ break;
case 4:
fstrcpy(map.comment, r->in.info->description.string);
break;
return NT_STATUS_INVALID_INFO_CLASS;
}
- can_mod_accounts = user_has_privileges( p->server_info->ptok, &se_add_users );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_mod_accounts )
- become_root();
-
+ become_root();
status = pdb_update_group_mapping_entry(&map);
-
- if ( can_mod_accounts )
- unbecome_root();
+ unbecome_root();
/******** End SeAddUsers BLOCK *********/
_samr_SetAliasInfo
*********************************************************************/
-NTSTATUS _samr_SetAliasInfo(pipes_struct *p,
+NTSTATUS _samr_SetAliasInfo(struct pipes_struct *p,
struct samr_SetAliasInfo *r)
{
struct samr_alias_info *ainfo;
struct acct_info info;
- bool can_mod_accounts;
NTSTATUS status;
ainfo = policy_handle_find(p, r->in.alias_handle,
return NT_STATUS_INVALID_INFO_CLASS;
}
- can_mod_accounts = user_has_privileges( p->server_info->ptok, &se_add_users );
-
/******** BEGIN SeAddUsers BLOCK *********/
- if ( can_mod_accounts )
- become_root();
-
+ become_root();
status = pdb_set_aliasinfo( &ainfo->sid, &info );
-
- if ( can_mod_accounts )
- unbecome_root();
+ unbecome_root();
/******** End SeAddUsers BLOCK *********/
_samr_GetDomPwInfo
****************************************************************/
-NTSTATUS _samr_GetDomPwInfo(pipes_struct *p,
+NTSTATUS _samr_GetDomPwInfo(struct pipes_struct *p,
struct samr_GetDomPwInfo *r)
{
uint32_t min_password_length = 0;
}
become_root();
- pdb_get_account_policy(AP_MIN_PASSWORD_LEN,
+ pdb_get_account_policy(PDB_POLICY_MIN_PASSWORD_LEN,
&min_password_length);
- pdb_get_account_policy(AP_USER_MUST_LOGON_TO_CHG_PASS,
+ pdb_get_account_policy(PDB_POLICY_USER_MUST_LOGON_TO_CHG_PASS,
&password_properties);
unbecome_root();
_samr_OpenGroup
*********************************************************************/
-NTSTATUS _samr_OpenGroup(pipes_struct *p,
+NTSTATUS _samr_OpenGroup(struct pipes_struct *p,
struct samr_OpenGroup *r)
{
- DOM_SID info_sid;
+ struct dom_sid info_sid;
GROUP_MAP map;
struct samr_domain_info *dinfo;
struct samr_group_info *ginfo;
- SEC_DESC *psd = NULL;
+ struct security_descriptor *psd = NULL;
uint32 acc_granted;
uint32 des_access = r->in.access_mask;
size_t sd_size;
NTSTATUS status;
bool ret;
- SE_PRIV se_rights;
dinfo = policy_handle_find(p, r->in.domain_handle,
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, NULL,
}
/*check if access can be granted as requested by client. */
- map_max_allowed_access(p->server_info->ptok, &des_access);
+ map_max_allowed_access(p->server_info->ptok,
+ &p->server_info->utok,
+ &des_access);
make_samr_object_sd(p->mem_ctx, &psd, &sd_size, &grp_generic_mapping, NULL, 0);
se_map_generic(&des_access,&grp_generic_mapping);
- se_priv_copy( &se_rights, &se_add_users );
-
- status = access_check_samr_object(psd, p->server_info->ptok,
- &se_rights, GENERIC_RIGHTS_GROUP_WRITE, des_access,
- &acc_granted, "_samr_OpenGroup");
+ status = access_check_object(psd, p->server_info->ptok,
+ SEC_PRIV_ADD_USERS, SEC_PRIV_INVALID, GENERIC_RIGHTS_GROUP_ALL_ACCESS,
+ des_access, &acc_granted, "_samr_OpenGroup");
if ( !NT_STATUS_IS_OK(status) )
return status;
/* this should not be hard-coded like this */
- if (!sid_equal(&dinfo->sid, get_global_sam_sid()))
+ if (!sid_check_is_domain(&dinfo->sid)) {
return NT_STATUS_ACCESS_DENIED;
+ }
sid_compose(&info_sid, &dinfo->sid, r->in.rid);
return NT_STATUS_NO_SUCH_GROUP;
ginfo = policy_handle_create(p, r->out.group_handle,
- GENERIC_RIGHTS_GROUP_ALL_ACCESS,
+ acc_granted,
struct samr_group_info, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
_samr_RemoveMemberFromForeignDomain
*********************************************************************/
-NTSTATUS _samr_RemoveMemberFromForeignDomain(pipes_struct *p,
+NTSTATUS _samr_RemoveMemberFromForeignDomain(struct pipes_struct *p,
struct samr_RemoveMemberFromForeignDomain *r)
{
struct samr_domain_info *dinfo;
/* Find the policy handle. Open a policy on it. */
dinfo = policy_handle_find(p, r->in.domain_handle,
- STD_RIGHT_DELETE_ACCESS, NULL,
+ SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT, NULL,
struct samr_domain_info, &result);
if (!NT_STATUS_IS_OK(result)) {
return result;
_samr_QueryDomainInfo2
********************************************************************/
-NTSTATUS _samr_QueryDomainInfo2(pipes_struct *p,
+NTSTATUS _samr_QueryDomainInfo2(struct pipes_struct *p,
struct samr_QueryDomainInfo2 *r)
{
struct samr_QueryDomainInfo q;
}
/*******************************************************************
- _samr_SetDomainInfo
********************************************************************/
-NTSTATUS _samr_SetDomainInfo(pipes_struct *p,
- struct samr_SetDomainInfo *r)
+static NTSTATUS set_dom_info_1(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo1 *r)
{
- struct samr_domain_info *dinfo;
time_t u_expire, u_min_age;
+
+ u_expire = nt_time_to_unix_abs((NTTIME *)&r->max_password_age);
+ u_min_age = nt_time_to_unix_abs((NTTIME *)&r->min_password_age);
+
+ pdb_set_account_policy(PDB_POLICY_MIN_PASSWORD_LEN,
+ (uint32_t)r->min_password_length);
+ pdb_set_account_policy(PDB_POLICY_PASSWORD_HISTORY,
+ (uint32_t)r->password_history_length);
+ pdb_set_account_policy(PDB_POLICY_USER_MUST_LOGON_TO_CHG_PASS,
+ (uint32_t)r->password_properties);
+ pdb_set_account_policy(PDB_POLICY_MAX_PASSWORD_AGE, (int)u_expire);
+ pdb_set_account_policy(PDB_POLICY_MIN_PASSWORD_AGE, (int)u_min_age);
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS set_dom_info_3(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo3 *r)
+{
time_t u_logout;
+
+ u_logout = nt_time_to_unix_abs((NTTIME *)&r->force_logoff_time);
+
+ pdb_set_account_policy(PDB_POLICY_TIME_TO_LOGOUT, (int)u_logout);
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ ********************************************************************/
+
+static NTSTATUS set_dom_info_12(TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo12 *r)
+{
time_t u_lock_duration, u_reset_time;
- NTSTATUS result;
+
+ u_lock_duration = nt_time_to_unix_abs((NTTIME *)&r->lockout_duration);
+ if (u_lock_duration != -1) {
+ u_lock_duration /= 60;
+ }
+
+ u_reset_time = nt_time_to_unix_abs((NTTIME *)&r->lockout_window)/60;
+
+ pdb_set_account_policy(PDB_POLICY_LOCK_ACCOUNT_DURATION, (int)u_lock_duration);
+ pdb_set_account_policy(PDB_POLICY_RESET_COUNT_TIME, (int)u_reset_time);
+ pdb_set_account_policy(PDB_POLICY_BAD_ATTEMPT_LOCKOUT,
+ (uint32_t)r->lockout_threshold);
+
+ return NT_STATUS_OK;
+}
+
+/*******************************************************************
+ _samr_SetDomainInfo
+ ********************************************************************/
+
+NTSTATUS _samr_SetDomainInfo(struct pipes_struct *p,
+ struct samr_SetDomainInfo *r)
+{
+ struct samr_domain_info *dinfo;
+ NTSTATUS status;
+ uint32_t acc_required = 0;
DEBUG(5,("_samr_SetDomainInfo: %d\n", __LINE__));
- /* We do have different access bits for info
- * levels here, but we're really just looking for
- * GENERIC_RIGHTS_DOMAIN_WRITE access. Unfortunately
- * this maps to different specific bits. So
- * assume if we have SAMR_DOMAIN_ACCESS_SET_INFO_1
- * set we are ok. */
+ switch (r->in.level) {
+ case 1: /* DomainPasswordInformation */
+ case 12: /* DomainLockoutInformation */
+ /* DOMAIN_WRITE_PASSWORD_PARAMETERS */
+ acc_required = SAMR_DOMAIN_ACCESS_SET_INFO_1;
+ break;
+ case 3: /* DomainLogoffInformation */
+ case 4: /* DomainOemInformation */
+ /* DOMAIN_WRITE_OTHER_PARAMETERS */
+ acc_required = SAMR_DOMAIN_ACCESS_SET_INFO_2;
+ break;
+ case 6: /* DomainReplicationInformation */
+ case 9: /* DomainStateInformation */
+ case 7: /* DomainServerRoleInformation */
+ /* DOMAIN_ADMINISTER_SERVER */
+ acc_required = SAMR_DOMAIN_ACCESS_SET_INFO_3;
+ break;
+ default:
+ return NT_STATUS_INVALID_INFO_CLASS;
+ }
dinfo = policy_handle_find(p, r->in.domain_handle,
- SAMR_DOMAIN_ACCESS_SET_INFO_1, NULL,
- struct samr_domain_info, &result);
- if (!NT_STATUS_IS_OK(result)) {
- return result;
+ acc_required, NULL,
+ struct samr_domain_info, &status);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
}
DEBUG(5,("_samr_SetDomainInfo: level: %d\n", r->in.level));
switch (r->in.level) {
- case 0x01:
- u_expire=nt_time_to_unix_abs((NTTIME *)&r->in.info->info1.max_password_age);
- u_min_age=nt_time_to_unix_abs((NTTIME *)&r->in.info->info1.min_password_age);
- pdb_set_account_policy(AP_MIN_PASSWORD_LEN, (uint32)r->in.info->info1.min_password_length);
- pdb_set_account_policy(AP_PASSWORD_HISTORY, (uint32)r->in.info->info1.password_history_length);
- pdb_set_account_policy(AP_USER_MUST_LOGON_TO_CHG_PASS, (uint32)r->in.info->info1.password_properties);
- pdb_set_account_policy(AP_MAX_PASSWORD_AGE, (int)u_expire);
- pdb_set_account_policy(AP_MIN_PASSWORD_AGE, (int)u_min_age);
+ case 1:
+ status = set_dom_info_1(p->mem_ctx, &r->in.info->info1);
break;
- case 0x02:
+ case 3:
+ status = set_dom_info_3(p->mem_ctx, &r->in.info->info3);
break;
- case 0x03:
- u_logout=nt_time_to_unix_abs((NTTIME *)&r->in.info->info3.force_logoff_time);
- pdb_set_account_policy(AP_TIME_TO_LOGOUT, (int)u_logout);
+ case 4:
break;
- case 0x05:
+ case 6:
break;
- case 0x06:
+ case 7:
break;
- case 0x07:
+ case 9:
break;
- case 0x0c:
- u_lock_duration=nt_time_to_unix_abs((NTTIME *)&r->in.info->info12.lockout_duration);
- if (u_lock_duration != -1)
- u_lock_duration /= 60;
-
- u_reset_time=nt_time_to_unix_abs((NTTIME *)&r->in.info->info12.lockout_window)/60;
-
- pdb_set_account_policy(AP_LOCK_ACCOUNT_DURATION, (int)u_lock_duration);
- pdb_set_account_policy(AP_RESET_COUNT_TIME, (int)u_reset_time);
- pdb_set_account_policy(AP_BAD_ATTEMPT_LOCKOUT, (uint32)r->in.info->info12.lockout_threshold);
+ case 12:
+ status = set_dom_info_12(p->mem_ctx, &r->in.info->info12);
break;
default:
return NT_STATUS_INVALID_INFO_CLASS;
}
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
DEBUG(5,("_samr_SetDomainInfo: %d\n", __LINE__));
return NT_STATUS_OK;
_samr_GetDisplayEnumerationIndex
****************************************************************/
-NTSTATUS _samr_GetDisplayEnumerationIndex(pipes_struct *p,
+NTSTATUS _samr_GetDisplayEnumerationIndex(struct pipes_struct *p,
struct samr_GetDisplayEnumerationIndex *r)
{
struct samr_domain_info *dinfo;
_samr_GetDisplayEnumerationIndex2
****************************************************************/
-NTSTATUS _samr_GetDisplayEnumerationIndex2(pipes_struct *p,
+NTSTATUS _samr_GetDisplayEnumerationIndex2(struct pipes_struct *p,
struct samr_GetDisplayEnumerationIndex2 *r)
{
struct samr_GetDisplayEnumerationIndex q;
}
/****************************************************************
+ _samr_RidToSid
****************************************************************/
-NTSTATUS _samr_Shutdown(pipes_struct *p,
- struct samr_Shutdown *r)
+NTSTATUS _samr_RidToSid(struct pipes_struct *p,
+ struct samr_RidToSid *r)
{
- p->rng_fault_state = true;
- return NT_STATUS_NOT_IMPLEMENTED;
+ struct samr_domain_info *dinfo;
+ NTSTATUS status;
+ struct dom_sid sid;
+
+ dinfo = policy_handle_find(p, r->in.domain_handle,
+ 0, NULL,
+ struct samr_domain_info, &status);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ if (!sid_compose(&sid, &dinfo->sid, r->in.rid)) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ *r->out.sid = dom_sid_dup(p->mem_ctx, &sid);
+ if (!*r->out.sid) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ return NT_STATUS_OK;
}
/****************************************************************
****************************************************************/
-NTSTATUS _samr_SetMemberAttributesOfGroup(pipes_struct *p,
- struct samr_SetMemberAttributesOfGroup *r)
+static enum samr_ValidationStatus samr_ValidatePassword_Change(TALLOC_CTX *mem_ctx,
+ const struct samr_PwInfo *dom_pw_info,
+ const struct samr_ValidatePasswordReq2 *req,
+ struct samr_ValidatePasswordRepCtr *rep)
{
- p->rng_fault_state = true;
- return NT_STATUS_NOT_IMPLEMENTED;
+ NTSTATUS status;
+
+ if (req->password.string == NULL) {
+ return SAMR_VALIDATION_STATUS_SUCCESS;
+ }
+ if (strlen(req->password.string) < dom_pw_info->min_password_length) {
+ ZERO_STRUCT(rep->info);
+ return SAMR_VALIDATION_STATUS_PWD_TOO_SHORT;
+ }
+ if (dom_pw_info->password_properties & DOMAIN_PASSWORD_COMPLEX) {
+ status = check_password_complexity(req->account.string,
+ req->password.string,
+ NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ ZERO_STRUCT(rep->info);
+ return SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH;
+ }
+ }
+
+ return SAMR_VALIDATION_STATUS_SUCCESS;
}
/****************************************************************
****************************************************************/
-NTSTATUS _samr_TestPrivateFunctionsDomain(pipes_struct *p,
- struct samr_TestPrivateFunctionsDomain *r)
+static enum samr_ValidationStatus samr_ValidatePassword_Reset(TALLOC_CTX *mem_ctx,
+ const struct samr_PwInfo *dom_pw_info,
+ const struct samr_ValidatePasswordReq3 *req,
+ struct samr_ValidatePasswordRepCtr *rep)
+{
+ NTSTATUS status;
+
+ if (req->password.string == NULL) {
+ return SAMR_VALIDATION_STATUS_SUCCESS;
+ }
+ if (strlen(req->password.string) < dom_pw_info->min_password_length) {
+ ZERO_STRUCT(rep->info);
+ return SAMR_VALIDATION_STATUS_PWD_TOO_SHORT;
+ }
+ if (dom_pw_info->password_properties & DOMAIN_PASSWORD_COMPLEX) {
+ status = check_password_complexity(req->account.string,
+ req->password.string,
+ NULL);
+ if (!NT_STATUS_IS_OK(status)) {
+ ZERO_STRUCT(rep->info);
+ return SAMR_VALIDATION_STATUS_NOT_COMPLEX_ENOUGH;
+ }
+ }
+
+ return SAMR_VALIDATION_STATUS_SUCCESS;
+}
+
+/****************************************************************
+ _samr_ValidatePassword
+****************************************************************/
+
+NTSTATUS _samr_ValidatePassword(struct pipes_struct *p,
+ struct samr_ValidatePassword *r)
+{
+ union samr_ValidatePasswordRep *rep;
+ NTSTATUS status;
+ struct samr_GetDomPwInfo pw;
+ struct samr_PwInfo dom_pw_info;
+
+ if (r->in.level < 1 || r->in.level > 3) {
+ return NT_STATUS_INVALID_INFO_CLASS;
+ }
+
+ pw.in.domain_name = NULL;
+ pw.out.info = &dom_pw_info;
+
+ status = _samr_GetDomPwInfo(p, &pw);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ rep = talloc_zero(p->mem_ctx, union samr_ValidatePasswordRep);
+ if (!rep) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ switch (r->in.level) {
+ case 1:
+ status = NT_STATUS_NOT_SUPPORTED;
+ break;
+ case 2:
+ rep->ctr2.status = samr_ValidatePassword_Change(p->mem_ctx,
+ &dom_pw_info,
+ &r->in.req->req2,
+ &rep->ctr2);
+ break;
+ case 3:
+ rep->ctr3.status = samr_ValidatePassword_Reset(p->mem_ctx,
+ &dom_pw_info,
+ &r->in.req->req3,
+ &rep->ctr3);
+ break;
+ default:
+ status = NT_STATUS_INVALID_INFO_CLASS;
+ break;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ talloc_free(rep);
+ return status;
+ }
+
+ *r->out.rep = rep;
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************
+****************************************************************/
+
+NTSTATUS _samr_Shutdown(struct pipes_struct *p,
+ struct samr_Shutdown *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_TestPrivateFunctionsUser(pipes_struct *p,
- struct samr_TestPrivateFunctionsUser *r)
+NTSTATUS _samr_SetMemberAttributesOfGroup(struct pipes_struct *p,
+ struct samr_SetMemberAttributesOfGroup *r)
{
+ p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
}
/****************************************************************
****************************************************************/
-NTSTATUS _samr_AddMultipleMembersToAlias(pipes_struct *p,
- struct samr_AddMultipleMembersToAlias *r)
+NTSTATUS _samr_TestPrivateFunctionsDomain(struct pipes_struct *p,
+ struct samr_TestPrivateFunctionsDomain *r)
{
- p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
}
/****************************************************************
****************************************************************/
-NTSTATUS _samr_RemoveMultipleMembersFromAlias(pipes_struct *p,
- struct samr_RemoveMultipleMembersFromAlias *r)
+NTSTATUS _samr_TestPrivateFunctionsUser(struct pipes_struct *p,
+ struct samr_TestPrivateFunctionsUser *r)
{
- p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
}
/****************************************************************
****************************************************************/
-NTSTATUS _samr_SetBootKeyInformation(pipes_struct *p,
- struct samr_SetBootKeyInformation *r)
+NTSTATUS _samr_AddMultipleMembersToAlias(struct pipes_struct *p,
+ struct samr_AddMultipleMembersToAlias *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_GetBootKeyInformation(pipes_struct *p,
- struct samr_GetBootKeyInformation *r)
+NTSTATUS _samr_RemoveMultipleMembersFromAlias(struct pipes_struct *p,
+ struct samr_RemoveMultipleMembersFromAlias *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_RidToSid(pipes_struct *p,
- struct samr_RidToSid *r)
+NTSTATUS _samr_SetBootKeyInformation(struct pipes_struct *p,
+ struct samr_SetBootKeyInformation *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_SetDsrmPassword(pipes_struct *p,
- struct samr_SetDsrmPassword *r)
+NTSTATUS _samr_GetBootKeyInformation(struct pipes_struct *p,
+ struct samr_GetBootKeyInformation *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
/****************************************************************
****************************************************************/
-NTSTATUS _samr_ValidatePassword(pipes_struct *p,
- struct samr_ValidatePassword *r)
+NTSTATUS _samr_SetDsrmPassword(struct pipes_struct *p,
+ struct samr_SetDsrmPassword *r)
{
p->rng_fault_state = true;
return NT_STATUS_NOT_IMPLEMENTED;
git.samba.org / samba.git / blobdiff