É possível fazer isso substituindo a Tabela de ambiente dentro de um processo especificado.
Como prova de conceito, escrevi este aplicativo de exemplo, que acabou de editar uma única variável de ambiente (conhecida) em um processo 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;
}
Saída de amostra:
>set ENVTEST=abc
>cppTest.exe 13796
Target PID: 13796
PEB: 000007FFFFFD3000
UserProcessParameters: 00000000004B2F30
environment: 000000000052E700
Offset: 1528
>set ENVTEST
ENVTEST=def
Notas
Essa abordagem também seria limitada a restrições de segurança. Se o destino for executado em uma elevação mais alta ou em uma conta mais alta (como SYSTEM), não teremos permissão para editar sua memória.
Se você quisesse fazer isso em um aplicativo de 32 bits, as compensações codificadas anteriormente mudariam para 0x10 e 0x48, respectivamente. Essas compensações podem ser encontradas despejando as estruturas _PEB e _RTL_USER_PROCESS_PARAMETERS em um depurador (por exemplo, no WinDbg dt _PEBe dt _RTL_USER_PROCESS_PARAMETERS)
Para alterar a prova de conceito para o que o OP precisa, ele apenas enumera as variáveis atuais do sistema e do ambiente do usuário (como documentadas pela resposta do @ tsadok) e grava a tabela de ambiente inteira na memória do processo de destino.
Editar: o tamanho do bloco de ambiente também é armazenado na estrutura _RTL_USER_PROCESS_PARAMETERS, mas a memória é alocada no heap do processo. Portanto, a partir de um processo externo, não teríamos a capacidade de redimensioná-lo e torná-lo maior. Eu brinquei com o uso do VirtualAllocEx para alocar memória adicional no processo de destino para o armazenamento do ambiente e pude definir e ler uma tabela totalmente nova. Infelizmente, qualquer tentativa de modificar o ambiente de maneira normal falha e queima quando o endereço não aponta mais para o heap (ele trava no RtlSizeHeap).