254 lines
8.3 KiB
Go
254 lines
8.3 KiB
Go
//go:build windows
|
|
|
|
package windows
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
rvboxv1 "github.com/rvbox/rvbox/gen/go/rvbox/v1"
|
|
"github.com/rvbox/rvbox/internal/client/supervisor"
|
|
"github.com/rvbox/rvbox/internal/domain"
|
|
winapi "golang.org/x/sys/windows"
|
|
)
|
|
|
|
// Native fixture children execute the production launcher/helper entrypoints.
|
|
// This dispatcher exists only in the test executable, never the release image.
|
|
func TestMain(m *testing.M) {
|
|
if len(os.Args) == 4 && os.Args[2] == "--channel" {
|
|
var err error
|
|
switch os.Args[1] {
|
|
case "--launcher":
|
|
err = RunLauncher(context.Background(), os.Args[3])
|
|
case "--signal-helper":
|
|
err = RunSignalHelper(context.Background(), os.Args[3])
|
|
default:
|
|
os.Exit(m.Run())
|
|
}
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
os.Exit(0)
|
|
}
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
func TestNativeDesktopAccessOnActualThread_HP_DESKTOP_02(t *testing.T) {
|
|
runtime.LockOSThread()
|
|
defer runtime.UnlockOSThread()
|
|
var sessionID uint32
|
|
if err := winapi.ProcessIdToSessionId(winapi.GetCurrentProcessId(), &sessionID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sessionID == 0 {
|
|
t.Skip("requires an interactive desktop; Session 0 is a separate route")
|
|
}
|
|
path, err := verifyCurrentInteractiveDesktop(sessionID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateInteractiveDesktop(path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// This fixture lane requires LocalSystem (SCM/service route), one usable active
|
|
// desktop, and the bundled PowerShell probe readable by that user. Run it in the
|
|
// disposable native fixture, not by changing an ordinary user's service state.
|
|
func desktopFixture(t *testing.T, elevated bool) (*execSupervisor, string, string) {
|
|
t.Helper()
|
|
var token winapi.Token
|
|
if err := winapi.OpenProcessToken(winapi.CurrentProcess(), winapi.TOKEN_QUERY, &token); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
user, err := token.GetTokenUser()
|
|
_ = token.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if user.User.Sid.String() != securitySystemRID {
|
|
t.Skip("requires LocalSystem native fixture process")
|
|
}
|
|
probe := os.Getenv("RVBOX_NATIVE_GUI_PROBE")
|
|
if probe == "" {
|
|
t.Skip("set RVBOX_NATIVE_GUI_PROBE to the bundled windows_gui_probe.ps1")
|
|
}
|
|
if !filepath.IsAbs(probe) {
|
|
t.Fatal("GUI probe path must be absolute")
|
|
}
|
|
if info, err := os.Lstat(probe); err != nil || !info.Mode().IsRegular() {
|
|
t.Fatalf("GUI probe must be a readable regular file: %v", err)
|
|
}
|
|
executable, err := os.Executable()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
root := os.Getenv("SystemRoot")
|
|
if root == "" {
|
|
root = `C:\Windows`
|
|
}
|
|
manager := newExecSupervisor(NativeOptions{ExecutablePath: executable, Shells: ShellPaths{CMD: filepath.Join(root, "System32", "cmd.exe"), PowerShell: filepath.Join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")}, WindowsTermGrace: 3 * time.Second})
|
|
selected, identity, err := manager.selectToken(elevated)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_ = selected.Close()
|
|
if identity.SessionID == 0 {
|
|
t.Skip("requires one usable active session, not a Session 0 fallback")
|
|
}
|
|
directory := t.TempDir()
|
|
// Both levels are owned by this t.TempDir fixture. Only SYSTEM and the
|
|
// selected effective SID receive access, including wrapper-file traversal.
|
|
for _, path := range []string{filepath.Dir(directory), directory} {
|
|
sd, err := winapi.SecurityDescriptorFromString(fmt.Sprintf("D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;%s)", identity.UserSID))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dacl, _, err := sd.DACL()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := winapi.SetNamedSecurityInfo(path, winapi.SE_FILE_OBJECT, winapi.DACL_SECURITY_INFORMATION|winapi.PROTECTED_DACL_SECURITY_INFORMATION, nil, nil, dacl, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
t.Cleanup(func() { _ = manager.StopAll(context.Background()) })
|
|
return manager, directory, probe
|
|
}
|
|
|
|
func desktopProbeProcess(t *testing.T, manager *execSupervisor, directory, probe string, elevated, consoleOnly bool) (supervisor.Process, context.Context) {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
|
|
t.Cleanup(cancel)
|
|
args := []string{manager.options.Shells.PowerShell, "-NoLogo", "-NoProfile", "-STA", "-ExecutionPolicy", "Bypass", "-File", probe, "-Seconds", "2"}
|
|
if consoleOnly {
|
|
args[len(args)-1] = "25"
|
|
args = append(args, "-ConsoleOnly")
|
|
}
|
|
command, err := BuildCommandLine(args)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
issue, err := domain.NewUUIDv7()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
spec := supervisor.StartSpec{IssueUUID: issue, CommandRevision: 1, WorkingDirectory: directory, Execution: &rvboxv1.ExecutionSpec{ShellType: rvboxv1.ShellType_SHELL_CMD, Elevated: elevated, Source: &rvboxv1.ExecutionSpec_CommandText{CommandText: "@" + command}}}
|
|
var process supervisor.Process
|
|
if consoleOnly {
|
|
// Isolate console-event delivery from cmd's own batch-abort behavior.
|
|
// The actual launcher still prepares this root shell suspended, puts it
|
|
// in the Job, and uses the production authenticated TERM helper.
|
|
token, identity, tokenErr := manager.selectToken(elevated)
|
|
if tokenErr != nil {
|
|
t.Fatal(tokenErr)
|
|
}
|
|
defer token.Close()
|
|
base, envErr := token.Environ(false)
|
|
if envErr != nil {
|
|
t.Fatal(envErr)
|
|
}
|
|
environment, envErr := BuildEnvironmentBlock(parseEnvironment(base), nil)
|
|
if envErr != nil {
|
|
t.Fatal(envErr)
|
|
}
|
|
process, err = manager.startViaLauncher(ctx, spec, token, identity, LaunchPlan{ApplicationName: args[0], CommandLine: command, WorkingDirectory: directory, Environment: environment}, nil)
|
|
} else {
|
|
process, err = manager.Start(ctx, spec)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if process.Identity().SessionID == 0 {
|
|
t.Fatal("native GUI route unexpectedly fell back to Session 0")
|
|
}
|
|
if err := process.Release(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return process, ctx
|
|
}
|
|
|
|
func TestNativeLauncherShowsGUIOnSelectedDesktop_HP_DESKTOP_03(t *testing.T) {
|
|
for _, elevated := range []bool{false, true} {
|
|
t.Run(fmt.Sprintf("elevated=%v", elevated), func(t *testing.T) {
|
|
manager, directory, probe := desktopFixture(t, elevated)
|
|
process, ctx := desktopProbeProcess(t, manager, directory, probe, elevated, false)
|
|
var output strings.Builder
|
|
for {
|
|
chunk, err := process.ReadOutput(ctx)
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
output.Write(chunk.Data)
|
|
}
|
|
status, err := process.Wait(ctx)
|
|
if err != nil || status.Code != 0 {
|
|
t.Fatalf("probe exit=%v err=%v output=%s", status, err, output.String())
|
|
}
|
|
var report struct {
|
|
SessionID uint32 `json:"session_id"`
|
|
Station string `json:"window_station"`
|
|
Desktop string `json:"desktop"`
|
|
Input string `json:"input_desktop"`
|
|
Visible bool `json:"window_observed"`
|
|
ConsoleVisible bool `json:"console_window_visible"`
|
|
}
|
|
found := false
|
|
for _, line := range strings.Split(output.String(), "\n") {
|
|
if strings.HasPrefix(strings.TrimSpace(line), "{") {
|
|
if err := json.Unmarshal([]byte(line), &report); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
found = true
|
|
}
|
|
}
|
|
if !found || !report.Visible || report.ConsoleVisible || report.SessionID != process.Identity().SessionID || !strings.EqualFold(report.Station+`\`+report.Desktop, interactiveDesktop) || !strings.EqualFold(report.Input, "default") {
|
|
t.Fatalf("GUI probe did not observe an interactive window: %+v output=%s", report, output.String())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNativeHeadlessConsoleStillReceivesTERM_HP_DESKTOP_04(t *testing.T) {
|
|
manager, directory, probe := desktopFixture(t, false)
|
|
process, ctx := desktopProbeProcess(t, manager, directory, probe, false, true)
|
|
var output strings.Builder
|
|
for !strings.Contains(output.String(), "RVBOX_CONSOLE_READY") {
|
|
chunk, err := process.ReadOutput(ctx)
|
|
if err != nil {
|
|
t.Fatalf("console never became ready: %v %s", err, output.String())
|
|
}
|
|
output.Write(chunk.Data)
|
|
}
|
|
outcome, err := manager.Signal(ctx, process, supervisor.SignalTerm)
|
|
if err != nil || !outcome.Delivered || outcome.Escalated {
|
|
t.Fatalf("TERM lost native console delivery: %+v err=%v", outcome, err)
|
|
}
|
|
for {
|
|
chunk, err := process.ReadOutput(ctx)
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
output.Write(chunk.Data)
|
|
}
|
|
if !strings.Contains(output.String(), "RVBOX_CTRL_BREAK_OBSERVED") {
|
|
t.Fatalf("TERM never reached the registered handler: %s", output.String())
|
|
}
|
|
}
|