Es posible hacer esto sobrescribiendo la tabla de entorno dentro de un proceso específico.
Como prueba de concepto, escribí esta aplicación de muestra, que acaba de editar una sola variable de entorno (conocida) en un proceso cmd.exe:
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;
}
Salida de muestra:
>set ENVTEST=abc
>cppTest.exe 13796
Target PID: 13796
PEB: 000007FFFFFD3000
UserProcessParameters: 00000000004B2F30
environment: 000000000052E700
Offset: 1528
>set ENVTEST
ENVTEST=def
Notas
Este enfoque también se limitaría a restricciones de seguridad. Si el objetivo se ejecuta a una elevación más alta o una cuenta más alta (como SYSTEM), entonces no tendríamos permiso para editar su memoria.
Si desea hacer esto en una aplicación de 32 bits, los desplazamientos codificados anteriormente cambiarían a 0x10 y 0x48 respectivamente. Estas compensaciones se pueden encontrar volcando las estructuras _PEB y _RTL_USER_PROCESS_PARAMETERS en un depurador (por ejemplo, en WinDbg dt _PEBy dt _RTL_USER_PROCESS_PARAMETERS)
Para cambiar la prueba de concepto en lo que el OP necesita, solo enumeraría las variables actuales del entorno del sistema y del usuario (como se documenta en la respuesta de @ tsadok) y escribiría la tabla de entorno completa en la memoria del proceso de destino.
Editar: el tamaño del bloque de entorno también se almacena en la estructura _RTL_USER_PROCESS_PARAMETERS, pero la memoria se asigna en el montón del proceso. Entonces, desde un proceso externo no tendríamos la capacidad de cambiar su tamaño y hacerlo más grande. Jugué con el uso de VirtualAllocEx para asignar memoria adicional en el proceso de destino para el almacenamiento del entorno, y pude configurar y leer una tabla completamente nueva. Desafortunadamente, cualquier intento de modificar el entorno de los medios normales se bloqueará y quemará ya que la dirección ya no apunta al montón (se bloqueará en RtlSizeHeap).