运行时单个进程/可执行程序能否修改其他进程变量的技术问询

Great question—let’s break this down with practical context, since this gets to the core of how modern operating systems handle process isolation.

Short Answer #

Yes, both scenarios are possible, but they require intentional setup or elevated privileges because operating systems enforce strict memory isolation between processes by default.

How It Works (and the Methods to Do It) #

Modern OSes use virtual memory to give each process its own isolated address space—by default, one process can’t directly read or write another’s memory. But there are well-established ways to bypass this isolation when needed:

• Shared Memory Mechanisms
  This is the most common legitimate way. OSes provide APIs to create a block of memory that multiple processes can map into their own address spaces. Any changes to variables in this shared region are immediately visible to all processes that have access to it.

  • On Linux: Use shmget() to allocate shared memory, shmat() to attach it to your process’s address space.
  • On Windows: Use CreateFileMapping() and MapViewOfFile() to create a shared memory segment.
    Whether the processes come from the same executable or different ones doesn’t matter here—shared memory works across any authorized processes.

• Debugging & Process Injection
  If you have sufficient privileges (like root on Linux or Administrator on Windows), you can attach to a target process using debugging APIs:

  • Linux: The ptrace() system call lets you read/write the target process’s memory, register values, etc.
  • Windows: APIs like DebugActiveProcess() and WriteProcessMemory() let you directly modify another process’s memory.
    Process injection (e.g., injecting a DLL into the target process) is another variant—once the DLL runs in the target’s context, it can modify variables as if it were part of that process. Again, this works regardless of whether the target is from the same executable or a different one.

• Kernel-Level Access
  For extremely low-level control, a kernel module or driver can bypass user-space memory isolation entirely. It can directly access the physical memory corresponding to the target process’s virtual address space. This is highly specialized, risky, and typically only used by system tools or advanced debugging utilities.

Key Distinction Between Your Two Questions #

Your two scenarios are actually functionally identical: an "executable program running as a process" is just a process, whether it’s an instance of the same executable as the target or a different one. The mechanisms to modify another process’s variables don’t depend on whether the executables are the same—they depend on the OS’s permissions and the techniques used to break memory isolation.

Important Caveats #

• Default Isolation: Without using one of these methods, processes cannot modify each other’s variables—this is a fundamental security feature of modern OSes.
• Permissions: Most of these methods require elevated privileges (root/Administrator) to prevent unauthorized tampering.
• Safety: Modifying another process’s memory directly is risky—you can crash the target process, corrupt data, or trigger OS security protections.

内容的提问来源于stack exchange，提问作者Reveles