Dies ist möglich, indem die Umgebungstabelle innerhalb eines bestimmten Prozesses selbst überschrieben wird.
Als Proof of Concept habe ich diese Beispiel-App geschrieben, die gerade eine einzelne (bekannte) Umgebungsvariable in einem cmd.exe-Prozess bearbeitet hat:
typedef DWORD (__stdcall *NtQueryInformationProcessPtr)(HANDLE, DWORD, PVOID, ULONG, PULONG);
int __cdecl main(int argc, char* argv[])
{
HMODULE hNtDll = GetModuleHandleA("ntdll.dll");
NtQueryInformationProcessPtr NtQueryInformationProcess = (NtQueryInformationProcessPtr)GetProcAddress(hNtDll, "NtQueryInformationProcess");
int processId = atoi(argv[1]);
printf("Target PID: %u\n", processId);
// open the process with read+write access
HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, 0, processId);
if(hProcess == NULL)
{
printf("Error opening process (%u)\n", GetLastError());
return 0;
}
// find the location of the PEB
PROCESS_BASIC_INFORMATION pbi = {0};
NTSTATUS status = NtQueryInformationProcess(hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);
if(status != 0)
{
printf("Error ProcessBasicInformation (0x%8X)\n", status);
}
printf("PEB: %p\n", pbi.PebBaseAddress);
// find the process parameters
char *processParamsOffset = (char*)pbi.PebBaseAddress + 0x20; // hard coded offset for x64 apps
char *processParameters = NULL;
if(ReadProcessMemory(hProcess, processParamsOffset, &processParameters, sizeof(processParameters), NULL))
{
printf("UserProcessParameters: %p\n", processParameters);
}
else
{
printf("Error ReadProcessMemory (%u)\n", GetLastError());
}
// find the address to the environment table
char *environmentOffset = processParameters + 0x80; // hard coded offset for x64 apps
char *environment = NULL;
ReadProcessMemory(hProcess, environmentOffset, &environment, sizeof(environment), NULL);
printf("environment: %p\n", environment);
// copy the environment table into our own memory for scanning
wchar_t *localEnvBlock = new wchar_t[64*1024];
ReadProcessMemory(hProcess, environment, localEnvBlock, sizeof(wchar_t)*64*1024, NULL);
// find the variable to edit
wchar_t *found = NULL;
wchar_t *varOffset = localEnvBlock;
while(varOffset < localEnvBlock + 64*1024)
{
if(varOffset[0] == '\0')
{
// we reached the end
break;
}
if(wcsncmp(varOffset, L"ENVTEST=", 8) == 0)
{
found = varOffset;
break;
}
varOffset += wcslen(varOffset)+1;
}
// check to see if we found one
if(found)
{
size_t offset = (found - localEnvBlock) * sizeof(wchar_t);
printf("Offset: %Iu\n", offset);
// write a new version (if the size of the value changes then we have to rewrite the entire block)
if(!WriteProcessMemory(hProcess, environment + offset, L"ENVTEST=def", 12*sizeof(wchar_t), NULL))
{
printf("Error WriteProcessMemory (%u)\n", GetLastError());
}
}
// cleanup
delete[] localEnvBlock;
CloseHandle(hProcess);
return 0;
}
Beispielausgabe:
>set ENVTEST=abc
>cppTest.exe 13796
Target PID: 13796
PEB: 000007FFFFFD3000
UserProcessParameters: 00000000004B2F30
environment: 000000000052E700
Offset: 1528
>set ENVTEST
ENVTEST=def
Anmerkungen
Dieser Ansatz wäre auch auf Sicherheitsbeschränkungen beschränkt. Wenn das Ziel auf einer höheren Höhe oder einem höheren Konto (z. B. SYSTEM) ausgeführt wird, haben wir keine Berechtigung, seinen Speicher zu bearbeiten.
Wenn Sie dies mit einer 32-Bit-App tun möchten, ändern sich die oben angegebenen fest codierten Offsets auf 0x10 bzw. 0x48. Diese Offsets können gefunden werden, indem die Strukturen _PEB und _RTL_USER_PROCESS_PARAMETERS in einem Debugger ausgegeben werden (z. B. in WinDbg dt _PEBunddt _RTL_USER_PROCESS_PARAMETERS ).
Um den Proof-of-Concept in das zu ändern, was das OP benötigt, werden lediglich die aktuellen System- und Benutzerumgebungsvariablen (wie in der Antwort von @ tsadok dokumentiert) aufgelistet und die gesamte Umgebungstabelle in den Speicher des Zielprozesses geschrieben.
Bearbeiten: Die Größe des Umgebungsblocks wird auch in der Struktur _RTL_USER_PROCESS_PARAMETERS gespeichert, der Speicher wird jedoch auf dem Prozessheap zugewiesen. Von einem externen Prozess aus hätten wir also nicht die Möglichkeit, die Größe zu ändern und ihn zu vergrößern. Ich habe mit VirtualAllocEx herumgespielt, um zusätzlichen Speicher im Zielprozess für den Umgebungsspeicher zuzuweisen, und konnte eine völlig neue Tabelle festlegen und lesen. Leider stürzt jeder Versuch, die Umgebung auf normale Weise zu ändern, ab und brennt, da die Adresse nicht mehr auf den Heap verweist (sie stürzt in RtlSizeHeap ab).