External/pmg
1
0
Fork 0
mirror of https://github.com/safedep/pmg.git synced 2026-08-03 07:24:09 +02:00
Code Issues Packages Projects Releases Wiki Activity

remove process control code to pause/resume process (#106)

Browse Source 
Co-authored-by: Abhisek Datta <abhisek.datta@gmail.com>
This commit is contained in:
Sahil Bansal
2026-01-10 11:21:24 +00:00
committed by GitHub
co-authored by Abhisek Datta
parent f50d296935
commit f851a1ebba
3 changed files with 0 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/flows/process_control_unix.go
-33
View File
@@ -1,33 +0,0 @@
//go:build !windows
// +build !windows
package flows
import (
"os/exec"
"syscall"
)
func platformPauseProcess(cmd *exec.Cmd) error {
if cmd == nil || cmd.Process == nil {
return nil
}
if err := cmd.Process.Signal(syscall.SIGSTOP); err != nil {
return err
}
return nil
}
func platformResumeProcess(cmd *exec.Cmd) error {
if cmd == nil || cmd.Process == nil {
return nil
}
if err := cmd.Process.Signal(syscall.SIGCONT); err != nil {
return err
}
return nil
}
internal/flows/process_control_windows.go
-78
View File
@@ -1,78 +0,0 @@
//go:build windows
// +build windows
package flows
import (
"fmt"
"os/exec"
"golang.org/x/sys/windows"
)
var (
modntdll = windows.NewLazySystemDLL("ntdll.dll")
procNtSuspendProcess = modntdll.NewProc("NtSuspendProcess")
procNtResumeProcess = modntdll.NewProc("NtResumeProcess")
)
// platformPauseProcess suspends the process using Windows NT API.
//
// Known limitations:
// - Race condition: threads created during suspension are not suspended
// - Remote thread injection still possible (very rare)
//
// For PMG's use case (brief suspension during user prompts), these limitations
// are acceptable.
//
// References:
// - gopsutil: https://github.com/shirou/gopsutil/blob/master/process/process_windows.go
// - Analysis: https://github.com/diversenok/Suspending-Techniques
func platformPauseProcess(cmd *exec.Cmd) error {
if cmd == nil || cmd.Process == nil {
return nil
}
handle, err := windows.OpenProcess(
windows.PROCESS_SUSPEND_RESUME,
false,
uint32(cmd.Process.Pid),
)
if err != nil {
return fmt.Errorf("failed to open process for suspension: %w", err)
}
defer windows.CloseHandle(handle)
r1, _, _ := procNtSuspendProcess.Call(uintptr(handle))
if r1 != 0 {
return fmt.Errorf("NtSuspendProcess failed with NTSTATUS=0x%.8X", r1)
}
return nil
}
// platformResumeProcess resumes a suspended process using Windows NT API.
func platformResumeProcess(cmd *exec.Cmd) error {
if cmd == nil || cmd.Process == nil {
return nil
}
handle, err := windows.OpenProcess(
windows.PROCESS_SUSPEND_RESUME,
false,
uint32(cmd.Process.Pid),
)
if err != nil {
return fmt.Errorf("failed to open process for resumption: %w", err)
}
defer windows.CloseHandle(handle)
r1, _, _ := procNtResumeProcess.Call(uintptr(handle))
if r1 != 0 {
return fmt.Errorf("NtResumeProcess failed with NTSTATUS=0x%.8X", r1)
}
return nil
}
internal/flows/process_control_windows_test.go
-114
View File
@@ -1,114 +0,0 @@
//go:build windows
// +build windows
package flows
import (
"os/exec"
"runtime"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestPlatformPauseResumeProcess(t *testing.T) {
if runtime.GOOS != "windows" {
t.Skip("Windows-only test")
}
cmd := exec.Command("ping", "127.0.0.1", "-n", "60")
err := cmd.Start()
assert.NoError(t, err)
defer cmd.Process.Kill()
time.Sleep(100 * time.Millisecond)
err = platformPauseProcess(cmd)
assert.NoError(t, err)
time.Sleep(500 * time.Millisecond)
err = platformResumeProcess(cmd)
assert.NoError(t, err)
}
func TestPlatformPauseProcessNil(t *testing.T) {
err := platformPauseProcess(nil)
assert.NoError(t, err)
}
func TestPlatformResumeProcessNil(t *testing.T) {
err := platformResumeProcess(nil)
assert.NoError(t, err)
}
func TestPlatformPauseProcessNilProcess(t *testing.T) {
cmd := exec.Command("ping", "127.0.0.1")
err := platformPauseProcess(cmd)
assert.NoError(t, err)
}
func TestPlatformResumeProcessNilProcess(t *testing.T) {
cmd := exec.Command("ping", "127.0.0.1")
err := platformResumeProcess(cmd)
assert.NoError(t, err)
}
func TestPlatformPauseProcessExited(t *testing.T) {
if runtime.GOOS != "windows" {
t.Skip("Windows-only test")
}
cmd := exec.Command("cmd", "/c", "exit 0")
err := cmd.Start()
assert.NoError(t, err)
defer cmd.Process.Kill()
err = platformPauseProcess(cmd)
assert.NoError(t, err)
}
func TestPlatformResumeProcessExited(t *testing.T) {
if runtime.GOOS != "windows" {
t.Skip("Windows-only test")
}
cmd := exec.Command("cmd", "/c", "exit 0")
err := cmd.Start()
assert.NoError(t, err)
defer cmd.Process.Kill()
err = platformResumeProcess(cmd)
assert.NoError(t, err)
}
func TestPlatformPauseResumeMultipleTimes(t *testing.T) {
if runtime.GOOS != "windows" {
t.Skip("Windows-only test")
}
cmd := exec.Command("ping", "127.0.0.1", "-n", "60")
err := cmd.Start()
assert.NoError(t, err)
defer cmd.Process.Kill()
time.Sleep(100 * time.Millisecond)
for i := 0; i < 3; i++ {
err = platformPauseProcess(cmd)
assert.NoError(t, err)
time.Sleep(100 * time.Millisecond)
err = platformResumeProcess(cmd)
assert.NoError(t, err)
time.Sleep(100 * time.Millisecond)
}
}