/* Fixed own EXE fixture authoring source. Not an exported RMM provider. * No shell, network, service, reboot, repair, retry or caller-selected target. * An error after the first file/key mutation returns20: effect unresolved. */ #define _WIN32_WINNT 0x0a00 #include #include #include #include #include #include #include "contract.h" #if !defined(FIXTURE_VERSION) || (FIXTURE_VERSION != 10 && FIXTURE_VERSION != 11) #error Compile exactly one fixed fixture version10 or11 #endif static const wchar_t *const ROOT = L"C:\\Program Files\\RustDiscoveryFixtures"; static const wchar_t *const FILE_PATH = L"C:\\Program Files\\RustDiscoveryFixtures\\exe-payload.txt"; static const wchar_t *const PARENT_KEY = L"SOFTWARE\\RustDiscovery"; static const wchar_t *const PRODUCT_KEY = L"ExeFixture"; static const wchar_t *const HASH10 = L"7b8019c151f3953261b3afbbea1b59ca7112ab09c7a2911d24d17921d6fd6adf"; static const wchar_t *const HASH11 = L"e1da48d2a8b89d66db822c24dc2ef7a0cfc13bce11875f15157d03081979d3f0"; static const char *payload(unsigned version) { return version == 10 ? "RustDiscovery EXE fixture 1.0.0\r\n" : "RustDiscovery EXE fixture 1.1.0\r\n"; } static const wchar_t *version_text(unsigned version) {return version == 10 ? L"1.0.0" : L"1.1.0";} static const wchar_t *hash_text(unsigned version) {return version == 10 ? HASH10 : HASH11;} static int privileged_sid(PSID sid) { return IsWellKnownSid(sid, WinLocalSystemSid) || IsWellKnownSid(sid, WinBuiltinAdministratorsSid); } static int protected_object(HANDLE handle, SE_OBJECT_TYPE kind, DWORD read_mask) { PSID owner = NULL; PACL dacl = NULL; PSECURITY_DESCRIPTOR sd = NULL; if (GetSecurityInfo(handle, kind, OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, &owner, NULL, &dacl, NULL, &sd) != ERROR_SUCCESS) return 0; int valid = owner && privileged_sid(owner) && dacl && dacl->AceCount; for (DWORD i = 0; valid && i < dacl->AceCount; ++i) { PVOID raw = NULL; if (!GetAce(dacl, i, &raw)) {valid = 0; break;} ACCESS_ALLOWED_ACE *ace = raw; if (ace->Header.AceType != ACCESS_ALLOWED_ACE_TYPE || ace->Header.AceSize < sizeof(*ace)) {valid = 0; break;} if (ace->Header.AceFlags & INHERIT_ONLY_ACE) continue; PSID who = &ace->SidStart; if (!IsValidSid(who) || (!privileged_sid(who) && (ace->Mask & ~read_mask))) valid = 0; } LocalFree(sd); return valid; } static int system_process(void) { HANDLE token = NULL; _Alignas(8) BYTE buffer[128]; DWORD bytes = sizeof(buffer); if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) return 0; int ok = GetTokenInformation(token, TokenUser, buffer, bytes, &bytes) && IsWellKnownSid(((TOKEN_USER *)buffer)->User.Sid, WinLocalSystemSid); CloseHandle(token); return ok; } static int regular(HANDLE file, int directory, BY_HANDLE_FILE_INFORMATION *info) { return GetFileInformationByHandle(file, info) && !(info->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) && !!(info->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == directory && (directory || info->nNumberOfLinks == 1); } static int same_file(const BY_HANDLE_FILE_INFORMATION *a, const BY_HANDLE_FILE_INFORMATION *b) { return a->dwVolumeSerialNumber == b->dwVolumeSerialNumber && a->nFileIndexHigh == b->nFileIndexHigh && a->nFileIndexLow == b->nFileIndexLow; } static int file_version(HANDLE file) { BY_HANDLE_FILE_INFORMATION info; BYTE bytes[64], digest[32]; DWORD read = 0; BCRYPT_ALG_HANDLE alg = NULL; BCRYPT_HASH_HANDLE hash = NULL; BYTE *object = NULL; DWORD size = 0, got = 0; wchar_t hex[65]; int version = 99; if (!regular(file, 0, &info) || !protected_object(file, SE_FILE_OBJECT, FILE_GENERIC_READ | FILE_GENERIC_EXECUTE) || info.nFileSizeHigh || info.nFileSizeLow != 33 || SetFilePointer(file, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER || !ReadFile(file, bytes, sizeof(bytes), &read, NULL) || read != 33) return 99; if (BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, NULL, 0) < 0) goto done; if (BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (PUCHAR)&size, sizeof(size), &got, 0) < 0 || size == 0 || size > 4096) goto done; object = HeapAlloc(GetProcessHeap(), 0, size); if (!object) goto done; if (BCryptCreateHash(alg, &hash, object, size, NULL, 0, 0) < 0 || BCryptHashData(hash, bytes, read, 0) < 0 || BCryptFinishHash(hash, digest, sizeof(digest), 0) < 0) goto done; for (unsigned i = 0; i < 32; ++i) { static const wchar_t digits[] = L"0123456789abcdef"; hex[2*i] = digits[digest[i] >> 4]; hex[2*i+1] = digits[digest[i] & 15]; } hex[64] = 0; if (!wcscmp(hex, HASH10) && !memcmp(bytes, payload(10), 33)) version = 10; if (!wcscmp(hex, HASH11) && !memcmp(bytes, payload(11), 33)) version = 11; done: if (hash) BCryptDestroyHash(hash); if (object) HeapFree(GetProcessHeap(), 0, object); if (alg) BCryptCloseAlgorithmProvider(alg, 0); return version; } static int string_value(HKEY key, const wchar_t *name, const wchar_t *expected) { wchar_t data[128]; DWORD type = 0, size = sizeof(data); return RegQueryValueExW(key, name, NULL, &type, (BYTE *)data, &size) == ERROR_SUCCESS && type == REG_SZ && size == (wcslen(expected) + 1) * sizeof(wchar_t) && !memcmp(data, expected, size); } static int dword_value(HKEY key, const wchar_t *name, DWORD expected) { DWORD data = 0, type = 0, size = sizeof(data); return RegQueryValueExW(key, name, NULL, &type, (BYTE *)&data, &size) == ERROR_SUCCESS && type == REG_DWORD && size == sizeof(data) && data == expected; } static int not_registry_link(HKEY key) { DWORD type = 0, size = 0; LSTATUS s = RegQueryValueExW(key, L"SymbolicLinkValue", NULL, &type, NULL, &size); return s == ERROR_FILE_NOT_FOUND; /* Never follow/adopt a caller-created link. */ } static int registry_version(void) { HKEY parent = NULL, key = NULL; DWORD subkeys = 0, values = 0; int version = 99; LSTATUS s = RegOpenKeyExW(HKEY_LOCAL_MACHINE, PARENT_KEY, REG_OPTION_OPEN_LINK, KEY_READ | KEY_WOW64_64KEY, &parent); if (s == ERROR_FILE_NOT_FOUND) return 0; if (s != ERROR_SUCCESS) return 99; if (!protected_object((HANDLE)parent, SE_REGISTRY_KEY, KEY_READ) || !not_registry_link(parent)) goto done; s = RegOpenKeyExW(parent, PRODUCT_KEY, REG_OPTION_OPEN_LINK, KEY_READ | KEY_WOW64_64KEY, &key); if (s == ERROR_FILE_NOT_FOUND) {version = 0; goto done;} if (s != ERROR_SUCCESS || !protected_object((HANDLE)key, SE_REGISTRY_KEY, KEY_READ) || !not_registry_link(key)) goto done; if (RegQueryInfoKeyW(key, NULL, NULL, NULL, &subkeys, NULL, NULL, &values, NULL, NULL, NULL, NULL) != ERROR_SUCCESS || subkeys || values != 7) goto done; unsigned candidate = string_value(key, L"Version", L"1.0.0") ? 10 : string_value(key, L"Version", L"1.1.0") ? 11 : 0; if (candidate && string_value(key, L"ProductId", L"RustDiscovery.ExeFixture") && string_value(key, L"PayloadSHA256", hash_text(candidate)) && string_value(key, L"Architecture", L"x64") && string_value(key, L"Context", L"machine") && dword_value(key, L"PayloadBytes", 33) && dword_value(key, L"NoReboot", 1)) version = (int)candidate; done: if (key) RegCloseKey(key); if (parent) RegCloseKey(parent); return version; } static int set_string(HKEY key, const wchar_t *name, const wchar_t *value) { return RegSetValueExW(key, name, 0, REG_SZ, (const BYTE *)value, (DWORD)((wcslen(value)+1)*sizeof(wchar_t))) == ERROR_SUCCESS; } static int write_registry(unsigned version) { HKEY parent = NULL, key = NULL; PSECURITY_DESCRIPTOR sd = NULL; int ok = 0; if (!ConvertStringSecurityDescriptorToSecurityDescriptorW( L"D:P(A;;KA;;;SY)(A;;KA;;;BA)(A;;KR;;;BU)", SDDL_REVISION_1, &sd, NULL)) return 0; SECURITY_ATTRIBUTES sa = {sizeof(sa), sd, FALSE}; DWORD disposition = 0, bytes = 33, no_reboot = 1; if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, PARENT_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_CREATE_SUB_KEY | KEY_WOW64_64KEY, &sa, &parent, &disposition) != ERROR_SUCCESS) goto done; if (!protected_object((HANDLE)parent, SE_REGISTRY_KEY, KEY_READ) || !not_registry_link(parent)) goto done; if (RegCreateKeyExW(parent, PRODUCT_KEY, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_SET_VALUE | KEY_WOW64_64KEY, &sa, &key, &disposition) != ERROR_SUCCESS) goto done; if (!protected_object((HANDLE)key, SE_REGISTRY_KEY, KEY_READ) || !not_registry_link(key)) goto done; ok = set_string(key, L"ProductId", L"RustDiscovery.ExeFixture") && set_string(key, L"Version", version_text(version)) && set_string(key, L"PayloadSHA256", hash_text(version)) && set_string(key, L"Architecture", L"x64") && set_string(key, L"Context", L"machine") && RegSetValueExW(key, L"PayloadBytes", 0, REG_DWORD, (BYTE *)&bytes, sizeof(bytes)) == ERROR_SUCCESS && RegSetValueExW(key, L"NoReboot", 0, REG_DWORD, (BYTE *)&no_reboot, sizeof(no_reboot)) == ERROR_SUCCESS && RegFlushKey(key) == ERROR_SUCCESS; done: if (key) RegCloseKey(key); if (parent) RegCloseKey(parent); LocalFree(sd); return ok; } int wmain(int argc, wchar_t **argv) { HANDLE parents[3] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE}; const wchar_t *const directories[] = {L"C:\\", L"C:\\Program Files", ROOT}; HANDLE file = INVALID_HANDLE_VALUE; BY_HANDLE_FILE_INFORMATION original = {0}, current; int result = 10, observed_file = 0, observed_registry; PSECURITY_DESCRIPTOR sd = NULL; SYSTEM_INFO platform; GetNativeSystemInfo(&platform); if (platform.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_AMD64 || !fixture_arguments(argc, (const wchar_t *const *)argv) || !system_process()) return 10; for (unsigned i = 0; i < 3; ++i) { parents[i] = CreateFileW(directories[i], FILE_READ_ATTRIBUTES | READ_CONTROL, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL); if (parents[i] == INVALID_HANDLE_VALUE || !regular(parents[i], 1, ¤t)) goto done; } if (!protected_object(parents[2], SE_FILE_OBJECT, FILE_GENERIC_READ | FILE_GENERIC_EXECUTE)) goto done; file = CreateFileW(FILE_PATH, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL); if (file == INVALID_HANDLE_VALUE) { if (GetLastError() != ERROR_FILE_NOT_FOUND) goto done; } else { if (!regular(file, 0, &original)) goto done; observed_file = file_version(file); } observed_registry = registry_version(); enum fixture_step step = fixture_step(FIXTURE_VERSION, fixture_state((unsigned)observed_registry, (unsigned)observed_file)); if (step == FIXTURE_NOOP) {result = 0; goto done;} if (step == FIXTURE_DENY) goto done; if (file != INVALID_HANDLE_VALUE) {CloseHandle(file); file = INVALID_HANDLE_VALUE;} if (!ConvertStringSecurityDescriptorToSecurityDescriptorW( L"D:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;FR;;;BU)", SDDL_REVISION_1, &sd, NULL)) goto done; SECURITY_ATTRIBUTES sa = {sizeof(sa), sd, FALSE}; file = CreateFileW(FILE_PATH, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, &sa, step == FIXTURE_INSTALL ? CREATE_NEW : OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL); if (file == INVALID_HANDLE_VALUE) goto done; /* CREATE_NEW itself is the first possible mutation (an empty own file). */ if (step == FIXTURE_INSTALL) result = 20; if (!regular(file, 0, ¤t) || !protected_object(file, SE_FILE_OBJECT, FILE_GENERIC_READ | FILE_GENERIC_EXECUTE)) goto done; if (step == FIXTURE_UPGRADE && (!same_file(&original, ¤t) || file_version(file) != 10)) goto done; if (registry_version() != observed_registry) goto done; /* From this boundary onwards every error is effect-unresolved, no rollback. */ result = 20; DWORD written = 0; if (SetFilePointer(file, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER || !WriteFile(file, payload(FIXTURE_VERSION), 33, &written, NULL) || written != 33 || !SetEndOfFile(file) || !FlushFileBuffers(file) || !write_registry(FIXTURE_VERSION)) goto done; if (file_version(file) == FIXTURE_VERSION && registry_version() == FIXTURE_VERSION) result = 0; done: if (sd) LocalFree(sd); if (file != INVALID_HANDLE_VALUE) CloseHandle(file); for (unsigned i = 0; i < 3; ++i) if (parents[i] != INVALID_HANDLE_VALUE) CloseHandle(parents[i]); return result; }