setup.c File Reference

#include "samsrv.h"
#include <ntsecapi.h>
#include "resources.h"

Include dependency graph for setup.c:

Go to the source code of this file.

Macros
#define	TICKS_PER_SECOND   10000000LL

Functions
static BOOL	SampSetupAddMemberToAlias (HKEY hDomainKey, ULONG AliasId, PSID MemberSid)
static NTSTATUS	SampSetupCreateAliasAccount (HANDLE hDomainKey, LPCWSTR lpAccountName, LPCWSTR lpDescription, ULONG ulRelativeId)
static NTSTATUS	SampSetupAddMemberToGroup (IN HANDLE hDomainKey, IN ULONG GroupId, IN ULONG MemberId)
static NTSTATUS	SampSetupCreateGroupAccount (HANDLE hDomainKey, LPCWSTR lpAccountName, LPCWSTR lpComment, ULONG ulRelativeId)
static NTSTATUS	SampSetupCreateUserAccount (HANDLE hDomainKey, LPCWSTR lpAccountName, LPCWSTR lpComment, PSID lpDomainSid, ULONG ulRelativeId, ULONG UserAccountControl)
static NTSTATUS	SampSetupCreateDomain (IN HANDLE hServerKey, IN LPCWSTR lpKeyName, IN LPCWSTR lpDomainName, IN PSID lpDomainSid, IN BOOLEAN bBuiltinDomain, OUT HANDLE *lpDomainKey)
static NTSTATUS	SampSetupCreateServer (IN HANDLE hSamKey, OUT HANDLE *lpServerKey)
NTSTATUS	SampGetAccountDomainInfo (PPOLICY_ACCOUNT_DOMAIN_INFO *AccountDomainInfo)
BOOL	SampInitializeSAM (VOID)

Variables
SID_IDENTIFIER_AUTHORITY	SecurityNtAuthority = {SECURITY_NT_AUTHORITY}

Macro Definition Documentation

TICKS_PER_SECOND

#define TICKS_PER_SECOND   10000000LL

Definition at line 18 of file setup.c.

Function Documentation

SampGetAccountDomainInfo()

NTSTATUS SampGetAccountDomainInfo

(

PPOLICY_ACCOUNT_DOMAIN_INFO *

AccountDomainInfo

)

Definition at line 856 of file setup.c.

{
    LSA_OBJECT_ATTRIBUTES ObjectAttributes;
    LSA_HANDLE PolicyHandle;
    NTSTATUS Status;
 
    TRACE("SampGetAccountDomainInfo\n");
 
    memset(&ObjectAttributes, 0, sizeof(LSA_OBJECT_ATTRIBUTES));
    ObjectAttributes.Length = sizeof(LSA_OBJECT_ATTRIBUTES);
 
    Status = LsaOpenPolicy(NULL,
                           &ObjectAttributes,
                           POLICY_VIEW_LOCAL_INFORMATION,
                           &PolicyHandle);
    if (Status != STATUS_SUCCESS)
    {
        ERR("LsaOpenPolicy failed (Status: 0x%08lx)\n", Status);
        return Status;
    }
 
    Status = LsaQueryInformationPolicy(PolicyHandle,
                                       PolicyAccountDomainInformation,
                                       (PVOID *)AccountDomainInfo);
 
    LsaClose(PolicyHandle);
 
    return Status;
}

Referenced by SampInitializeSAM().

SampInitializeSAM()

BOOL SampInitializeSAM

(

VOID

)

Definition at line 888 of file setup.c.

{
    PPOLICY_ACCOUNT_DOMAIN_INFO AccountDomainInfo = NULL;
    HANDLE hSamKey = NULL;
    HANDLE hServerKey = NULL;
    HANDLE hBuiltinDomainKey = NULL;
    HANDLE hAccountDomainKey = NULL;
    PSID pBuiltinSid = NULL;
    PSID pInteractiveSid = NULL;
    PSID pAuthenticatedUserSid = NULL;
    BOOL bResult = TRUE;
    PSID pSid;
    HINSTANCE hInstance;
    WCHAR szComment[256];
    WCHAR szName[80];
    NTSTATUS Status;
 
    TRACE("SampInitializeSAM() called\n");
 
    hInstance = GetModuleHandleW(L"samsrv.dll");
 
    /* Open the SAM key */
    Status = SampRegOpenKey(NULL,
                            L"\\Registry\\Machine\\SAM",
                            KEY_READ | KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS,
                            &hSamKey);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to open the SAM key (Status: 0x%08lx)\n", Status);
        return FALSE;
    }
 
    /* Create the SAM Server object */
    Status = SampSetupCreateServer(hSamKey,
                                   &hServerKey);
    if (!NT_SUCCESS(Status))
    {
        bResult = FALSE;
        goto done;
    }
 
    /* Create and initialize the Builtin Domain SID */
    pBuiltinSid = RtlAllocateHeap(RtlGetProcessHeap(), 0, RtlLengthRequiredSid(1));
    if (pBuiltinSid == NULL)
    {
        ERR("Failed to allocate the Builtin Domain SID\n");
        bResult = FALSE;
        goto done;
    }
 
    RtlInitializeSid(pBuiltinSid, &SecurityNtAuthority, 1);
    *(RtlSubAuthoritySid(pBuiltinSid, 0)) = SECURITY_BUILTIN_DOMAIN_RID;
 
    /* Create and initialize the Interactive SID */
    pInteractiveSid = RtlAllocateHeap(RtlGetProcessHeap(), 0, RtlLengthRequiredSid(1));
    if (pInteractiveSid == NULL)
    {
        ERR("Failed to allocate the Interactive SID\n");
        bResult = FALSE;
        goto done;
    }
 
    RtlInitializeSid(pInteractiveSid, &SecurityNtAuthority, 1);
    *(RtlSubAuthoritySid(pInteractiveSid, 0)) = SECURITY_INTERACTIVE_RID;
 
    /* Create and initialize the Authenticated User SID */
    pAuthenticatedUserSid = RtlAllocateHeap(RtlGetProcessHeap(), 0, RtlLengthRequiredSid(1));
    if (pAuthenticatedUserSid == NULL)
    {
        ERR("Failed to allocate the Authenticated User SID\n");
        bResult = FALSE;
        goto done;
    }
 
    RtlInitializeSid(pAuthenticatedUserSid, &SecurityNtAuthority, 1);
    *(RtlSubAuthoritySid(pAuthenticatedUserSid, 0)) = SECURITY_AUTHENTICATED_USER_RID;
 
    /* Get account domain information */
    Status = SampGetAccountDomainInfo(&AccountDomainInfo);
    if (!NT_SUCCESS(Status))
    {
        ERR("SampGetAccountDomainInfo failed (Status %08lx)\n", Status);
        bResult = FALSE;
        goto done;
    }
 
    SampLoadString(hInstance, IDS_DOMAIN_BUILTIN_NAME, szName, 80);
 
    /* Create the Builtin domain */
    Status = SampSetupCreateDomain(hServerKey,
                                   L"Builtin",
                                   szName,
                                   pBuiltinSid,
                                   TRUE,
                                   &hBuiltinDomainKey);
    if (!NT_SUCCESS(Status))
    {
        bResult = FALSE;
        goto done;
    }
 
    /* Create the Administrators alias */
    SampLoadString(hInstance, IDS_ALIAS_ADMINISTRATORS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_ADMINISTRATORS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_ADMINS);
 
    /* Create the Users alias */
    SampLoadString(hInstance, IDS_ALIAS_USERS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_USERS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_USERS);
 
    /* Create the Guests alias */
    SampLoadString(hInstance, IDS_ALIAS_GUESTS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_GUESTS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_GUESTS);
 
    /* Create the Power Users alias */
    SampLoadString(hInstance, IDS_ALIAS_POWER_USERS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_POWER_USERS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_POWER_USERS);
 
    if (SampProductType != NtProductWinNt)
    {
        /* Create the Print Operators alias (Server only) */
        SampLoadString(hInstance, IDS_ALIAS_PRINT_OPS_NAME, szName, 80);
        SampLoadString(hInstance, IDS_ALIAS_PRINT_OPS_COMMENT, szComment, 256);
 
        SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                    szName,
                                    szComment,
                                    DOMAIN_ALIAS_RID_PRINT_OPS);
    }
 
    /* Create the Backup Operators alias */
    SampLoadString(hInstance, IDS_ALIAS_BACKUP_OPS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_BACKUP_OPS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_BACKUP_OPS);
 
    /* Create the Replicator alias */
    SampLoadString(hInstance, IDS_ALIAS_REPLICATOR_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_REPLICATOR_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_REPLICATOR);
 
    /* Create the Remote Desktop Users alias */
    SampLoadString(hInstance, IDS_ALIAS_REMOTE_DESKTOP_USERS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_REMOTE_DESKTOP_USERS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS);
 
    /* Create the Network Configuration Operators alias */
    SampLoadString(hInstance, IDS_ALIAS_NETWORK_CONFIGURATION_OPS_NAME, szName, 80);
    SampLoadString(hInstance, IDS_ALIAS_NETWORK_CONFIGURATION_OPS_COMMENT, szComment, 256);
 
    SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                szName,
                                szComment,
                                DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS);
 
    if (SampProductType != NtProductWinNt)
    {
        /* Create the Performance Monitor Users alias (Server only) */
        SampLoadString(hInstance, IDS_ALIAS_MONITORING_USERS_NAME, szName, 80);
        SampLoadString(hInstance, IDS_ALIAS_MONITORING_USERS_COMMENT, szComment, 256);
 
        SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                    szName,
                                    szComment,
                                    DOMAIN_ALIAS_RID_MONITORING_USERS);
 
        /* Create the Performance Log Users alias (Server only) */
        SampLoadString(hInstance, IDS_ALIAS_LOGGING_USERS_NAME, szName, 80);
        SampLoadString(hInstance, IDS_ALIAS_LOGGING_USERS_COMMENT, szComment, 256);
 
        SampSetupCreateAliasAccount(hBuiltinDomainKey,
                                    szName,
                                    szComment,
                                    DOMAIN_ALIAS_RID_LOGGING_USERS);
    }
 
    /* Add the Administrator user to the Administrators alias */
    pSid = AppendRidToSid(AccountDomainInfo->DomainSid,
                          DOMAIN_USER_RID_ADMIN);
    if (pSid != NULL)
    {
        SampSetupAddMemberToAlias(hBuiltinDomainKey,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  pSid);
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, pSid);
    }
 
    /* Add the Guest user to the Guests alias */
    pSid = AppendRidToSid(AccountDomainInfo->DomainSid,
                          DOMAIN_USER_RID_GUEST);
    if (pSid != NULL)
    {
        SampSetupAddMemberToAlias(hBuiltinDomainKey,
                                  DOMAIN_ALIAS_RID_GUESTS,
                                  pSid);
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, pSid);
    }
 
    /* Add the Interactive SID to the Users alias */
    SampSetupAddMemberToAlias(hBuiltinDomainKey,
                              DOMAIN_ALIAS_RID_USERS,
                              pInteractiveSid);
 
    /* Add the Authenticated User SID to the Users alias */
    SampSetupAddMemberToAlias(hBuiltinDomainKey,
                              DOMAIN_ALIAS_RID_USERS,
                              pAuthenticatedUserSid);
 
    /* Create the Account domain */
    Status = SampSetupCreateDomain(hServerKey,
                                   L"Account",
                                   L"",
                                   AccountDomainInfo->DomainSid,
                                   FALSE,
                                   &hAccountDomainKey);
    if (!NT_SUCCESS(Status))
    {
        bResult = FALSE;
        goto done;
    }
 
    /* Create the None group */
    SampLoadString(hInstance, IDS_GROUP_NONE_NAME, szName, 80);
    SampLoadString(hInstance, IDS_GROUP_NONE_COMMENT, szComment, 256);
 
    SampSetupCreateGroupAccount(hAccountDomainKey,
                                szName,
                                szComment,
                                DOMAIN_GROUP_RID_USERS);
 
    /* Create the Administrator user */
    SampLoadString(hInstance, IDS_USER_ADMINISTRATOR_NAME, szName, 80);
    SampLoadString(hInstance, IDS_USER_ADMINISTRATOR_COMMENT, szComment, 256);
 
    SampSetupCreateUserAccount(hAccountDomainKey,
                               szName,
                               szComment,
                               AccountDomainInfo->DomainSid,
                               DOMAIN_USER_RID_ADMIN,
                               USER_DONT_EXPIRE_PASSWORD | USER_NORMAL_ACCOUNT);
 
    /* Add the Adminitrator user to the Administrators alias */
    SampSetupAddMemberToGroup(hAccountDomainKey,
                              DOMAIN_GROUP_RID_USERS,
                              DOMAIN_USER_RID_ADMIN);
 
    /* Create the Guest user */
    SampLoadString(hInstance, IDS_USER_GUEST_NAME, szName, 80);
    SampLoadString(hInstance, IDS_USER_GUEST_COMMENT, szComment, 256);
 
    SampSetupCreateUserAccount(hAccountDomainKey,
                               szName,
                               szComment,
                               AccountDomainInfo->DomainSid,
                               DOMAIN_USER_RID_GUEST,
                               USER_ACCOUNT_DISABLED | USER_DONT_EXPIRE_PASSWORD | USER_NORMAL_ACCOUNT);
 
    /* Add the Guest user to the Guests alias */
    SampSetupAddMemberToGroup(hAccountDomainKey,
                              DOMAIN_GROUP_RID_USERS,
                              DOMAIN_USER_RID_GUEST);
 
done:
    if (AccountDomainInfo)
        LsaFreeMemory(AccountDomainInfo);
 
    if (pAuthenticatedUserSid)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pAuthenticatedUserSid);
 
    if (pInteractiveSid)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pInteractiveSid);
 
    if (pBuiltinSid)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pBuiltinSid);
 
    SampRegCloseKey(&hAccountDomainKey);
    SampRegCloseKey(&hBuiltinDomainKey);
    SampRegCloseKey(&hServerKey);
    SampRegCloseKey(&hSamKey);
 
    TRACE("SampInitializeSAM() done\n");
 
    return bResult;
}

Referenced by SampInitializeRegistry().

SampSetupAddMemberToAlias()

static BOOL SampSetupAddMemberToAlias ( HKEY  hDomainKey, ULONG  AliasId, PSID  MemberSid  )

static

Definition at line 25 of file setup.c.

{
    DWORD dwDisposition;
    LPWSTR MemberSidString = NULL;
    WCHAR szKeyName[256];
    HKEY hMembersKey;
 
    ConvertSidToStringSidW(MemberSid, &MemberSidString);
 
    swprintf(szKeyName, L"Aliases\\%08lX\\Members", AliasId);
 
    if (!RegCreateKeyExW(hDomainKey,
                         szKeyName,
                         0,
                         NULL,
                         REG_OPTION_NON_VOLATILE,
                         KEY_ALL_ACCESS,
                         NULL,
                         &hMembersKey,
                         &dwDisposition))
    {
        RegSetValueEx(hMembersKey,
                      MemberSidString,
                      0,
                      REG_BINARY,
                      (LPVOID)MemberSid,
                      RtlLengthSid(MemberSid));
 
        RegCloseKey(hMembersKey);
    }
 
    swprintf(szKeyName, L"Aliases\\Members\\%s", MemberSidString);
 
    if (!RegCreateKeyExW(hDomainKey,
                         szKeyName,
                         0,
                         NULL,
                         REG_OPTION_NON_VOLATILE,
                         KEY_ALL_ACCESS,
                         NULL,
                         &hMembersKey,
                         &dwDisposition))
    {
        swprintf(szKeyName, L"%08lX", AliasId);
 
        RegSetValueEx(hMembersKey,
                      szKeyName,
                      0,
                      REG_BINARY,
                      (LPVOID)MemberSid,
                      RtlLengthSid(MemberSid));
 
        RegCloseKey(hMembersKey);
    }
 
    if (MemberSidString != NULL)
        LocalFree(MemberSidString);
 
    return TRUE;
}

Referenced by SampInitializeSAM().

SampSetupAddMemberToGroup()

static NTSTATUS SampSetupAddMemberToGroup ( IN HANDLE  hDomainKey, IN ULONG  GroupId, IN ULONG  MemberId  )

static

Definition at line 177 of file setup.c.

{
    WCHAR szKeyName[256];
    HANDLE hGroupKey = NULL;
    PULONG MembersBuffer = NULL;
    ULONG MembersCount = 0;
    ULONG Length = 0;
    ULONG i;
    NTSTATUS Status;
 
    swprintf(szKeyName, L"Groups\\%08lX", GroupId);
 
    Status = SampRegOpenKey(hDomainKey,
                            szKeyName,
                            KEY_ALL_ACCESS,
                            &hGroupKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = SampRegQueryValue(hGroupKey,
                               L"Members",
                               NULL,
                               NULL,
                               &Length);
    if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
        goto done;
 
    MembersBuffer = midl_user_allocate(Length + sizeof(ULONG));
    if (MembersBuffer == NULL)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto done;
    }
 
    if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
    {
        Status = SampRegQueryValue(hGroupKey,
                                   L"Members",
                                   NULL,
                                   MembersBuffer,
                                   &Length);
        if (!NT_SUCCESS(Status))
            goto done;
 
        MembersCount = Length / sizeof(ULONG);
    }
 
    for (i = 0; i < MembersCount; i++)
    {
        if (MembersBuffer[i] == MemberId)
        {
            Status = STATUS_MEMBER_IN_GROUP;
            goto done;
        }
    }
 
    MembersBuffer[MembersCount] = MemberId;
    Length += sizeof(ULONG);
 
    Status = SampRegSetValue(hGroupKey,
                             L"Members",
                             REG_BINARY,
                             MembersBuffer,
                             Length);
 
done:
    if (MembersBuffer != NULL)
        midl_user_free(MembersBuffer);
 
    SampRegCloseKey(&hGroupKey);
 
    return Status;
}

Referenced by SampInitializeSAM().

SampSetupCreateAliasAccount()

static NTSTATUS SampSetupCreateAliasAccount ( HANDLE  hDomainKey, LPCWSTR  lpAccountName, LPCWSTR  lpDescription, ULONG  ulRelativeId  )

static

Definition at line 91 of file setup.c.

{
    WCHAR szAccountKeyName[32];
    HANDLE hAccountKey = NULL;
    HANDLE hNamesKey = NULL;
    PSECURITY_DESCRIPTOR Sd = NULL;
    ULONG SdSize = 0;
    NTSTATUS Status;
 
    swprintf(szAccountKeyName, L"Aliases\\%08lX", ulRelativeId);
 
    Status = SampRegCreateKey(hDomainKey,
                              szAccountKeyName,
                              KEY_ALL_ACCESS,
                              &hAccountKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Name",
                             REG_SZ,
                             (LPVOID)lpAccountName,
                             (wcslen(lpAccountName) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Description",
                             REG_SZ,
                             (LPVOID)lpDescription,
                             (wcslen(lpDescription) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Create the server SD */
    Status = SampCreateAliasSD(&Sd,
                               &SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set SecDesc attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"SecDesc",
                             REG_BINARY,
                             Sd,
                             SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegOpenKey(hDomainKey,
                            L"Aliases\\Names",
                            KEY_ALL_ACCESS,
                            &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hNamesKey,
                            lpAccountName,
                            REG_DWORD,
                            (LPVOID)&ulRelativeId,
                            sizeof(ULONG));
 
done:
    SampRegCloseKey(&hNamesKey);
 
    if (Sd != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
 
    if (hAccountKey != NULL)
    {
        SampRegCloseKey(&hAccountKey);
 
        if (!NT_SUCCESS(Status))
            SampRegDeleteKey(hDomainKey,
                             szAccountKeyName);
    }
 
    return Status;
}

Referenced by SampInitializeSAM().

SampSetupCreateDomain()

static NTSTATUS SampSetupCreateDomain ( IN HANDLE  hServerKey, IN LPCWSTR  lpKeyName, IN LPCWSTR  lpDomainName, IN PSID  lpDomainSid, IN BOOLEAN  bBuiltinDomain, OUT HANDLE *  lpDomainKey  )

static

Definition at line 618 of file setup.c.

{
    SAM_DOMAIN_FIXED_DATA FixedData;
    WCHAR szDomainKeyName[32];
    LPWSTR lpEmptyString = L"";
    HANDLE hDomainKey = NULL;
    HANDLE hAliasesKey = NULL;
    HANDLE hGroupsKey = NULL;
    HANDLE hUsersKey = NULL;
    HANDLE hNamesKey = NULL;
    PSECURITY_DESCRIPTOR Sd = NULL;
    ULONG SdSize = 0;
    NTSTATUS Status;
 
    if (lpDomainKey != NULL)
        *lpDomainKey = NULL;
 
    /* Initialize the fixed domain data */
    memset(&FixedData, 0, sizeof(SAM_DOMAIN_FIXED_DATA));
    FixedData.Version = 1;
    NtQuerySystemTime(&FixedData.CreationTime);
    FixedData.DomainModifiedCount.QuadPart = 0;
    FixedData.MaxPasswordAge.QuadPart = -(6LL * 7LL * 24LL * 60LL * 60LL * TICKS_PER_SECOND); /* 6 weeks */
    FixedData.MinPasswordAge.QuadPart = 0;                                                    /* right now */
    FixedData.ForceLogoff.QuadPart = LLONG_MAX;                                               /* very far in the future aka never */
    FixedData.LockoutDuration.QuadPart = -(30LL * 60LL * TICKS_PER_SECOND);                   /* 30 minutes */
    FixedData.LockoutObservationWindow.QuadPart = -(30LL * 60LL * TICKS_PER_SECOND);          /* 30 minutes */
    FixedData.ModifiedCountAtLastPromotion.QuadPart = 0;
    FixedData.NextRid = 1000;
    FixedData.PasswordProperties = 0;
    FixedData.MinPasswordLength = 0;
    FixedData.PasswordHistoryLength = 0;
    FixedData.LockoutThreshold = 0;
    FixedData.DomainServerState = DomainServerEnabled;
    FixedData.DomainServerRole = DomainServerRolePrimary;
    FixedData.UasCompatibilityRequired = TRUE;
 
    wcscpy(szDomainKeyName, L"Domains\\");
    wcscat(szDomainKeyName, lpKeyName);
 
    Status = SampRegCreateKey(hServerKey,
                              szDomainKeyName,
                              KEY_ALL_ACCESS,
                              &hDomainKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Set the fixed data value */
    Status = SampRegSetValue(hDomainKey,
                             L"F",
                             REG_BINARY,
                             (LPVOID)&FixedData,
                             sizeof(SAM_DOMAIN_FIXED_DATA));
    if (!NT_SUCCESS(Status))
        goto done;
 
    if (lpDomainSid != NULL)
    {
        Status = SampRegSetValue(hDomainKey,
                                 L"Name",
                                 REG_SZ,
                                 (LPVOID)lpDomainName,
                                 (wcslen(lpDomainName) + 1) * sizeof(WCHAR));
        if (!NT_SUCCESS(Status))
            goto done;
 
        Status = SampRegSetValue(hDomainKey,
                                 L"SID",
                                 REG_BINARY,
                                 (LPVOID)lpDomainSid,
                                 RtlLengthSid(lpDomainSid));
        if (!NT_SUCCESS(Status))
            goto done;
    }
 
    Status = SampRegSetValue(hDomainKey,
                             L"OemInformation",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hDomainKey,
                             L"ReplicaSourceNodeName",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Create the Alias container */
    Status = SampRegCreateKey(hDomainKey,
                              L"Aliases",
                              KEY_ALL_ACCESS,
                              &hAliasesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegCreateKey(hAliasesKey,
                              L"Names",
                              KEY_ALL_ACCESS,
                              &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    SampRegCloseKey(&hNamesKey);
 
    /* Create the Groups container */
    Status = SampRegCreateKey(hDomainKey,
                              L"Groups",
                              KEY_ALL_ACCESS,
                              &hGroupsKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegCreateKey(hGroupsKey,
                              L"Names",
                              KEY_ALL_ACCESS,
                              &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    SampRegCloseKey(&hNamesKey);
 
    /* Create the Users container */
    Status = SampRegCreateKey(hDomainKey,
                              L"Users",
                              KEY_ALL_ACCESS,
                              &hUsersKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegCreateKey(hUsersKey,
                              L"Names",
                              KEY_ALL_ACCESS,
                              &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Create the server SD */
    if (bBuiltinDomain != FALSE)
        Status = SampCreateBuiltinDomainSD(&Sd,
                                           &SdSize);
    else
        Status = SampCreateAccountDomainSD(&Sd,
                                           &SdSize);
 
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set SecDesc attribute*/
    Status = SampRegSetValue(hServerKey,
                             L"SecDesc",
                             REG_BINARY,
                             Sd,
                             SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    SampRegCloseKey(&hNamesKey);
 
    if (lpDomainKey != NULL)
        *lpDomainKey = hDomainKey;
 
done:
    if (Sd != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
 
    SampRegCloseKey(&hAliasesKey);
    SampRegCloseKey(&hGroupsKey);
    SampRegCloseKey(&hUsersKey);
 
    if (!NT_SUCCESS(Status))
        SampRegCloseKey(&hDomainKey);
 
    return Status;
}

Referenced by SampInitializeSAM().

SampSetupCreateGroupAccount()

static NTSTATUS SampSetupCreateGroupAccount ( HANDLE  hDomainKey, LPCWSTR  lpAccountName, LPCWSTR  lpComment, ULONG  ulRelativeId  )

static

Definition at line 256 of file setup.c.

{
    SAM_GROUP_FIXED_DATA FixedGroupData;
    WCHAR szAccountKeyName[32];
    HANDLE hAccountKey = NULL;
    HANDLE hNamesKey = NULL;
    PSECURITY_DESCRIPTOR Sd = NULL;
    ULONG SdSize = 0;
    NTSTATUS Status;
 
    /* Initialize fixed group data */
    FixedGroupData.Version = 1;
    FixedGroupData.Reserved = 0;
    FixedGroupData.GroupId = ulRelativeId;
    FixedGroupData.Attributes = 0;
 
    swprintf(szAccountKeyName, L"Groups\\%08lX", ulRelativeId);
 
    Status = SampRegCreateKey(hDomainKey,
                              szAccountKeyName,
                              KEY_ALL_ACCESS,
                              &hAccountKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = SampRegSetValue(hAccountKey,
                             L"F",
                             REG_BINARY,
                             (LPVOID)&FixedGroupData,
                             sizeof(SAM_GROUP_FIXED_DATA));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Name",
                             REG_SZ,
                             (LPVOID)lpAccountName,
                             (wcslen(lpAccountName) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"AdminComment",
                             REG_SZ,
                             (LPVOID)lpComment,
                             (wcslen(lpComment) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Create the security descriptor */
    Status = SampCreateGroupSD(&Sd,
                               &SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set the SecDesc attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"SecDesc",
                             REG_BINARY,
                             Sd,
                             SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegOpenKey(hDomainKey,
                            L"Groups\\Names",
                            KEY_ALL_ACCESS,
                            &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hNamesKey,
                            lpAccountName,
                            REG_DWORD,
                            (LPVOID)&ulRelativeId,
                            sizeof(ULONG));
 
done:
    SampRegCloseKey(&hNamesKey);
 
    if (Sd != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
 
    if (hAccountKey != NULL)
    {
        SampRegCloseKey(&hAccountKey);
 
        if (!NT_SUCCESS(Status))
            SampRegDeleteKey(hDomainKey,
                             szAccountKeyName);
    }
 
    return Status;
}

Referenced by SampInitializeSAM().

SampSetupCreateServer()

static NTSTATUS SampSetupCreateServer ( IN HANDLE  hSamKey, OUT HANDLE *  lpServerKey  )

static

Definition at line 805 of file setup.c.

{
    HANDLE hServerKey = NULL;
    HANDLE hDomainsKey = NULL;
    PSECURITY_DESCRIPTOR Sd = NULL;
    ULONG SdSize = 0;
    NTSTATUS Status;
 
    Status = SampRegCreateKey(hSamKey,
                              L"SAM",
                              KEY_ALL_ACCESS,
                              &hServerKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = SampRegCreateKey(hServerKey,
                              L"Domains",
                              KEY_ALL_ACCESS,
                              &hDomainsKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Create the server SD */
    Status = SampCreateServerSD(&Sd,
                                &SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set SecDesc attribute*/
    Status = SampRegSetValue(hServerKey,
                             L"SecDesc",
                             REG_BINARY,
                             Sd,
                             SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    SampRegCloseKey(&hDomainsKey);
 
    *lpServerKey = hServerKey;
 
done:
    if (Sd != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
 
    return Status;
}

Referenced by SampInitializeSAM().

SampSetupCreateUserAccount()

static NTSTATUS SampSetupCreateUserAccount ( HANDLE  hDomainKey, LPCWSTR  lpAccountName, LPCWSTR  lpComment, PSID  lpDomainSid, ULONG  ulRelativeId, ULONG  UserAccountControl  )

static

Definition at line 357 of file setup.c.

{
    SAM_USER_FIXED_DATA FixedUserData;
    GROUP_MEMBERSHIP GroupMembership;
    UCHAR LogonHours[23];
    LPWSTR lpEmptyString = L"";
    WCHAR szAccountKeyName[32];
    HANDLE hAccountKey = NULL;
    HANDLE hNamesKey = NULL;
    PSECURITY_DESCRIPTOR Sd = NULL;
    ULONG SdSize = 0;
    PSID UserSid = NULL;
    NTSTATUS Status;
 
    UserSid = AppendRidToSid(lpDomainSid,
                             ulRelativeId);
 
    /* Create the security descriptor */
    Status = SampCreateUserSD(UserSid,
                              &Sd,
                              &SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Initialize fixed user data */
    FixedUserData.Version = 1;
    FixedUserData.Reserved = 0;
    FixedUserData.LastLogon.QuadPart = 0;
    FixedUserData.LastLogoff.QuadPart = 0;
    FixedUserData.PasswordLastSet.QuadPart = 0;
    FixedUserData.AccountExpires.QuadPart = MAXLONGLONG;
    FixedUserData.LastBadPasswordTime.QuadPart = 0;
    FixedUserData.UserId = ulRelativeId;
    FixedUserData.PrimaryGroupId = DOMAIN_GROUP_RID_USERS;
    FixedUserData.UserAccountControl = UserAccountControl;
    FixedUserData.CountryCode = 0;
    FixedUserData.CodePage = 0;
    FixedUserData.BadPasswordCount = 0;
    FixedUserData.LogonCount = 0;
    FixedUserData.AdminCount = 0;
    FixedUserData.OperatorCount = 0;
 
    swprintf(szAccountKeyName, L"Users\\%08lX", ulRelativeId);
 
    Status = SampRegCreateKey(hDomainKey,
                              szAccountKeyName,
                              KEY_ALL_ACCESS,
                              &hAccountKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = SampRegSetValue(hAccountKey,
                             L"F",
                             REG_BINARY,
                             (LPVOID)&FixedUserData,
                             sizeof(SAM_USER_FIXED_DATA));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Name",
                             REG_SZ,
                             (LPVOID)lpAccountName,
                             (wcslen(lpAccountName) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"FullName",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"HomeDirectory",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"HomeDirectoryDrive",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"ScriptPath",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"ProfilePath",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"AdminComment",
                             REG_SZ,
                             (LPVOID)lpComment,
                             (wcslen(lpComment) + 1) * sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"UserComment",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"WorkStations",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Parameters",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set LogonHours attribute*/
    *((PUSHORT)LogonHours) = 168;
    memset(&(LogonHours[2]), 0xff, 21);
 
    Status = SampRegSetValue(hAccountKey,
                             L"LogonHours",
                             REG_BINARY,
                             (LPVOID)LogonHours,
                             sizeof(LogonHours));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set Groups attribute*/
    GroupMembership.RelativeId = DOMAIN_GROUP_RID_USERS;
    GroupMembership.Attributes = SE_GROUP_MANDATORY |
                                 SE_GROUP_ENABLED |
                                 SE_GROUP_ENABLED_BY_DEFAULT;
 
    Status = SampRegSetValue(hAccountKey,
                             L"Groups",
                             REG_BINARY,
                             (LPVOID)&GroupMembership,
                             sizeof(GROUP_MEMBERSHIP));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set LMPwd attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"LMPwd",
                             REG_BINARY,
                             (LPVOID)&EmptyLmHash,
                             sizeof(ENCRYPTED_LM_OWF_PASSWORD));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set NTPwd attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"NTPwd",
                             REG_BINARY,
                             (LPVOID)&EmptyNtHash,
                             sizeof(ENCRYPTED_NT_OWF_PASSWORD));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set LMPwdHistory attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"LMPwdHistory",
                             REG_BINARY,
                             NULL,
                             0);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set NTPwdHistory attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"NTPwdHistory",
                             REG_BINARY,
                             NULL,
                             0);
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set PrivateData attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"PrivateData",
                             REG_SZ,
                             (LPVOID)lpEmptyString,
                             sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Set the SecDesc attribute*/
    Status = SampRegSetValue(hAccountKey,
                             L"SecDesc",
                             REG_BINARY,
                             Sd,
                             SdSize);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegOpenKey(hDomainKey,
                            L"Users\\Names",
                            KEY_ALL_ACCESS,
                            &hNamesKey);
    if (!NT_SUCCESS(Status))
        goto done;
 
    Status = SampRegSetValue(hNamesKey,
                            lpAccountName,
                            REG_DWORD,
                            (LPVOID)&ulRelativeId,
                            sizeof(ULONG));
 
done:
    SampRegCloseKey(&hNamesKey);
 
    if (Sd != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
 
    if (UserSid != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, UserSid);
 
    if (hAccountKey != NULL)
    {
        SampRegCloseKey(&hAccountKey);
 
        if (!NT_SUCCESS(Status))
            SampRegDeleteKey(hDomainKey,
                             szAccountKeyName);
    }
 
    return Status;
}

Referenced by SampInitializeSAM().

Variable Documentation

SecurityNtAuthority

SID_IDENTIFIER_AUTHORITY SecurityNtAuthority = {SECURITY_NT_AUTHORITY}

Definition at line 20 of file setup.c.

Referenced by SampInitializeSAM().