Разрешения реестра в Windows 10

Как я уже говорил в моих комментариях выше, вам нужно создать все ключи, которые вам нужны в HKLM, в вашем установщике (который должен быть запущен с повышенными правами), а затем изменить защиту, чтобы они могли быть доступны приложению, работающему со стандартными разрешениями (т.е. как член группы BUILTIN\Usersи работает без поднятия).

Вот код для «снятия защиты» с ключа реестра. Код, написанный в блокноте, может не скомпилироваться, и, очевидно, немного хакерский, извините.

Служебная функция BuildAce (изначально отсутствовала, извините за это):

// Build an access allowed, access denied, system alarm or system audit ACE.  Caller must free.
ACE_HEADER * BuildACE (PSID sid, int ace_type, int ace_flags, ACCESS_MASK ace_mask)
{
int sid_len = GetLengthSid (sid);
int ace_len = sizeof (ACCESS_ALLOWED_ACE) - sizeof (DWORD) + sid_len;
ACCESS_ALLOWED_ACE *ace = (ACCESS_ALLOWED_ACE *) malloc (ace_len);
memset (ace, 0, ace_len);
ace->Header.AceType = ace_type;
ace->Header.AceFlags = ace_flags;
ace->Header.AceSize = ace_len;
ace->Mask = ace_mask;
memcpy (&ace->SidStart, sid, sid_len);
return (ACE_HEADER *) ace;
}

Служебная функция AddOrRemoveACE:

// Add or remove an ACE to/from an ACL
// Returns a copy of the original ACL with the relevant changes made; caller must free
// Sequence of ACE's must be:
//      not inherited, denied
//      not inherited, allowed
//      inherited, denied
//      inherited, allowed
ACL *AddOrRemoveACE (ACL *acl, ACE_HEADER *new_ace, bool add)
{
int acl_size = acl->AclSize;
if (add)
acl_size += new_ace->AceSize;

ACL *new_acl = (ACL *) malloc (acl_size);
BOOL ok = InitializeAcl (new_acl, acl_size, ACL_REVISION);
assert (ok);

// Add new denied ACE at start of list
if (add && new_ace->AceType == ACCESS_DENIED_ACE_TYPE)
{
ok = AddAce (new_acl, ACL_REVISION, MAXDWORD, new_ace, new_ace->AceSize);
assert (ok);
}

// Copy all non-inherited ACE's, removing anything matching new_ace
for (int i = 0; ; ++i)
{
ACE_HEADER *old_ace;
if (!GetAce (acl, i, (VOID **) &old_ace))
break;
if ((old_ace->AceFlags & INHERITED_ACE) == 0 &&
(old_ace->AceSize != new_ace->AceSize ||
memcmp (old_ace, new_ace, old_ace->AceSize) != 0))
{
ok = AddAce (new_acl, ACL_REVISION, MAXDWORD, old_ace, old_ace->AceSize);
assert (ok);
}
}

// Add new allowed ACE at end of list
if (add && new_ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
{
ok = AddAce (new_acl, ACL_REVISION, MAXDWORD, new_ace, new_ace->AceSize);
assert (ok);
}

// Copy all inherited ACE's
for (int j = 0; ; ++j)
{
ACE_HEADER *old_ace;
if (!GetAce (acl, j, (VOID **) &old_ace))
break;
if (old_ace->AceFlags & INHERITED_ACE)
{
ok = AddAce (new_acl, ACL_REVISION, MAXDWORD, old_ace, old_ace->AceSize);
assert (ok);
}
}

// Store the actual size of the acl data (not reversible)
ACL_SIZE_INFORMATION asi;
ok = GetAclInformation (new_acl, &asi, sizeof (asi), AclSizeInformation);
assert (ok);
new_acl->AclSize = (WORD) asi.AclBytesInUse;
return new_acl;
}

Служебная функция AddOrRemoveRegKeyACE (возвращает код ошибки):

// Add or remove a registry key ACE.  hKey must have WRITE_DAC access
DWORD AddOrRemoveRegKeyACE
(HKEY hKey, bool add, int ace_type, PSID sid, ACCESS_MASK access_mask)
{
LONG    err;
PSECURITY_DESCRIPTOR psd;
DWORD buflen = 1024;

// Read current security information
for ( ; ; )
{
psd = malloc (buflen);
err = RegGetKeySecurity (hKey, DACL_SECURITY_INFORMATION, psd, &buflen);
if (err == 0)
break;
free (psd);
if (err == ERROR_INSUFFICIENT_BUFFER)
continue;
return err;
}

SECURITY_DESCRIPTOR_RELATIVE *sdr = (SECURITY_DESCRIPTOR_RELATIVE *) psd;
ACL *pdacl = (ACL *) ((BYTE *) sdr + sdr->Dacl);

ACE_HEADER *ace = BuildACE (sid, ace_type, CONTAINER_INHERIT_ACE, access_mask);
ACL *new_acl = AddOrRemoveACE (pdacl, ace, add);
free (ace);
free (psd);

SECURITY_DESCRIPTOR sd;
BOOL ok = InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION);
assert (ok);

ok = SetSecurityDescriptorControl (&sd,
SE_DACL_AUTO_INHERIT_REQ | SE_DACL_AUTO_INHERITED,
SE_DACL_AUTO_INHERIT_REQ | SE_DACL_AUTO_INHERITED);
assert (ok);

ok = SetSecurityDescriptorDacl (&sd, TRUE, new_acl, FALSE);
assert (ok);

// apply the security descriptor to the registry key
err = RegSetKeySecurity (hKey, DACL_SECURITY_INFORMATION, &sd);
free (new_acl);

return err;
}

А теперь появилась функция предоставления доступа к ключу реестра всем в группе «Пользователи». Возвращает TRUE в случае успеха:

BOOL grant_access_to_registry_key (HKEY hKey)
{
// Give the Users group access to hKey
SID_IDENTIFIER_AUTHORITY sia = SECURITY_NT_AUTHORITY;
PSID pUsersSid;
BOOL ok = AllocateAndInitializeSid (&sia, 2,
SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_USERS,
0, 0, 0, 0, 0, 0, &pUsersSid);
if (!ok)
return FALSE;
ok = AddOrRemoveRegKeyACE (hKey, true, ACCESS_ALLOWED_ACE_TYPE,
pUsersSid, KEY_ALL_ACCESS) == 0;
FreeSid (pUsersSid);
return ok;
}