windwows's architecture is still shitty

main.go

@@ -47,8 +47,17 @@ func main() {
 		Repo:     envOrDefault("GITEA_REPO", defaultRepo),
 	}
 
+	if err := platformEnsureElevated(); err != nil {
+		printError(err)
+		os.Exit(1)
+	}
+
 	args := os.Args[1:]
 
+	if len(args) > 0 && args[0] == "--elevated" {
+		args = args[1:]
+	}
+
 	if len(args) == 0 {
 		runTUI(config)
 		return

platform_linux.go

@@ -13,6 +13,10 @@ func getInstallDir() (string, error) {
 	return "/opt/logofclient", nil
 }
 
+func platformEnsureElevated() error {
+	return nil
+}
+
 func platformRunPrivileged(config Config, action string) error {
 	// Bereits als root gestartet.
 	if os.Geteuid() == 0 {

platform_windows.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 	"syscall"
 	"unsafe"
 )
@@ -22,16 +21,15 @@ var (
 
 	kernel32          = syscall.NewLazyDLL("kernel32.dll")
 	closeHandle       = kernel32.NewProc("CloseHandle")
-	waitForSingleObject = kernel32.NewProc("WaitForSingleObject")
 )
 
 const (
 	tokenQuery          = 0x0008
 	tokenElevationClass = 20
-	seeMaskNoCloseProcess  = 0x00000040
-	swShow                 = 1
-	infinite               = 0xFFFFFFFF
+
 	errorCancelled = 1223
+
+	swShow = 1
 )
 
 type shellExecuteInfo struct {
@@ -56,46 +54,94 @@ type tokenElevationData struct {
 	TokenIsElevated uint32
 }
 
-func getInstallDir() (string, error) {
-	programFiles := os.Getenv("ProgramFiles")
-
-	if programFiles == "" {
-		return "", errors.New("ProgramFiles ist nicht gesetzt")
-	}
-
-	return filepath.Join(programFiles, "logofclient"), nil
-}
-
-func platformRunPrivileged(config Config, action string) error {
-	if isWindowsElevated() {
-		return runAction(config, action)
-	}
-
-	fmt.Println()
-	fmt.Println("Für diese Aktion werden Administratorrechte benötigt.")
-	fmt.Print("Jetzt Administratorrechte anfordern? [J/n]: ")
-
-	var answer string
-	if _, err := fmt.Scanln(&answer); err != nil {
-		// Enter ohne Eingabe = Ja
-		answer = ""
-	}
-
-	answer = strings.ToLower(strings.TrimSpace(answer))
-
-	if answer != "" && answer != "j" && answer != "ja" {
-		fmt.Println("Abgebrochen.")
+func platformEnsureElevated() error {
+	// Die erhöhte Instanz wurde bereits gestartet.
+	// Sie darf sich nicht noch einmal selbst per runas starten.
+	if hasElevatedFlag() {
 		return nil
 	}
 
-	return runElevated(action)
+	if isWindowsElevated() {
+		return nil
+	}
+
+	return restartElevated()
+}
+
+func hasElevatedFlag() bool {
+	for _, arg := range os.Args[1:] {
+		if arg == "--elevated" {
+			return true
+		}
+	}
+
+	return false
+}
+
+func restartElevated() error {
+	exe, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf(
+			"Pfad des Installers konnte nicht ermittelt werden: %w",
+			err,
+		)
+	}
+
+	verb, err := syscall.UTF16PtrFromString("runas")
+	if err != nil {
+		return err
+	}
+
+	file, err := syscall.UTF16PtrFromString(exe)
+	if err != nil {
+		return err
+	}
+
+	// Die erhöhte Instanz bekommt nur das interne Flag.
+	parameters, err := syscall.UTF16PtrFromString("--elevated")
+	if err != nil {
+		return err
+	}
+
+	info := shellExecuteInfo{
+		cbSize:       uint32(unsafe.Sizeof(shellExecuteInfo{})),
+		lpVerb:       verb,
+		lpFile:       file,
+		lpParameters: parameters,
+		nShow:        swShow,
+	}
+
+	ret, _, callErr := shellExecuteExW.Call(
+		uintptr(unsafe.Pointer(&info)),
+	)
+
+	if ret == 0 {
+		if errno, ok := callErr.(syscall.Errno); ok &&
+			errno == errorCancelled {
+			fmt.Println("Administratorrechte wurden nicht erteilt.")
+			return errors.New("Administratorrechte erforderlich")
+		}
+
+		return fmt.Errorf(
+			"Administratorrechte konnten nicht angefordert werden: %w",
+			callErr,
+		)
+	}
+
+	// WICHTIG:
+	// Die ursprüngliche Instanz beendet sich sofort.
+	// Nur die erhöhte Instanz führt danach main() weiter aus.
+	os.Exit(0)
+
+	return nil
 }
 
 func isWindowsElevated() bool {
 	var token uintptr
 
+	// GetCurrentProcess() = -1
 	ret, _, _ := openProcessToken.Call(
-		uintptr(^uint(0)>>1),
+		uintptr(^uint(0)),
 		tokenQuery,
 		uintptr(unsafe.Pointer(&token)),
 	)
@@ -124,72 +170,17 @@ func isWindowsElevated() bool {
 	return elevation.TokenIsElevated != 0
 }
 
-func runElevated(action string) error {
-	exe, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf(
-			"Pfad des Installers konnte nicht ermittelt werden: %w",
-			err,
-		)
-	}
-
-	verb, err := syscall.UTF16PtrFromString("runas")
-	if err != nil {
-		return err
-	}
-
-	file, err := syscall.UTF16PtrFromString(exe)
-	if err != nil {
-		return err
-	}
-
-	parameters, err := syscall.UTF16PtrFromString(action)
-	if err != nil {
-		return err
-	}
-
-	info := shellExecuteInfo{
-		cbSize:       uint32(unsafe.Sizeof(shellExecuteInfo{})),
-		fMask:        seeMaskNoCloseProcess,
-		lpVerb:       verb,
-		lpFile:       file,
-		lpParameters: parameters,
-		nShow:        swShow,
-	}
-
-	ret, _, callErr := shellExecuteExW.Call(
-		uintptr(unsafe.Pointer(&info)),
-	)
-
-	if ret == 0 {
-		if errno, ok := callErr.(syscall.Errno); ok &&
-			errno == errorCancelled {
-			fmt.Println("Administratorrechte wurden nicht erteilt.")
-			return nil
-		}
+func platformRunPrivileged(config Config, action string) error {
+	// Die komplette Windows-Anwendung läuft bereits erhöht.
+	return runAction(config, action)
+}
 
-		return fmt.Errorf(
-			"Administratorrechte konnten nicht angefordert werden: %w",
-			callErr,
-		)
-	}
-
-	if info.hProcess != 0 {
-		handle := syscall.Handle(info.hProcess)
-		defer syscall.CloseHandle(handle)
+func getInstallDir() (string, error) {
+	programFiles := os.Getenv("ProgramFiles")
 
-		ret, _, err := waitForSingleObject.Call(
-			uintptr(handle),
-			infinite,
-		)
-
-		if ret == 0xFFFFFFFF {
-			return fmt.Errorf(
-				"auf erhöhte Instanz konnte nicht gewartet werden: %w",
-				err,
-			)
-		}
+	if programFiles == "" {
+		return "", errors.New("ProgramFiles ist nicht gesetzt")
 	}
 
-	return nil
+	return filepath.Join(programFiles, "logofclient"), nil
 }