[feat] add Windows secure desktop remote unlock support for locked sessions, refs #77

src/app/main.cpp

@@ -7,15 +7,165 @@
 #endif
 
 #include <cstring>
+#include <filesystem>
+#include <iostream>
 #include <memory>
 #include <string>
 
+#ifdef _WIN32
+#include <cstdio>
+#include "service_host.h"
+#endif
+
 #include "config_center.h"
 #include "daemon.h"
 #include "path_manager.h"
 #include "render.h"
 
+#ifdef _WIN32
+namespace {
+
+void EnsureConsoleForCli() {
+  static bool console_ready = false;
+  if (console_ready) {
+    return;
+  }
+
+  if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
+    DWORD error = GetLastError();
+    if (error != ERROR_ACCESS_DENIED) {
+      AllocConsole();
+    }
+  }
+
+  FILE* stream = nullptr;
+  freopen_s(&stream, "CONOUT$", "w", stdout);
+  freopen_s(&stream, "CONOUT$", "w", stderr);
+  freopen_s(&stream, "CONIN$", "r", stdin);
+  SetConsoleOutputCP(CP_UTF8);
+  console_ready = true;
+}
+
+void PrintServiceCliUsage() {
+  std::cout
+      << "CrossDesk service management commands\n"
+      << "  --service-install    Install the sibling crossdesk_service.exe\n"
+      << "  --service-uninstall  Remove the installed Windows service\n"
+      << "  --service-start      Start the Windows service\n"
+      << "  --service-stop       Stop the Windows service\n"
+  << "  --service-sas        Ask the service to send Secure Attention Sequence\n"
+      << "  --service-ping       Ping the service over named pipe IPC\n"
+      << "  --service-status     Query service runtime status\n"
+      << "  --service-help       Show this help\n";
+}
+
+std::wstring GetCurrentExecutablePathW() {
+  wchar_t path[MAX_PATH] = {0};
+  DWORD length = GetModuleFileNameW(nullptr, path, MAX_PATH);
+  if (length == 0 || length >= MAX_PATH) {
+    return L"";
+  }
+  return std::wstring(path, length);
+}
+
+std::filesystem::path GetSiblingServiceExecutablePath() {
+  std::wstring current_executable = GetCurrentExecutablePathW();
+  if (current_executable.empty()) {
+    return {};
+  }
+
+  return std::filesystem::path(current_executable).parent_path() /
+         L"crossdesk_service.exe";
+}
+
+bool IsServiceCliCommand(const char* arg) {
+  if (arg == nullptr) {
+    return false;
+  }
+
+  return std::strcmp(arg, "--service-install") == 0 ||
+         std::strcmp(arg, "--service-uninstall") == 0 ||
+         std::strcmp(arg, "--service-start") == 0 ||
+         std::strcmp(arg, "--service-stop") == 0 ||
+      std::strcmp(arg, "--service-sas") == 0 ||
+         std::strcmp(arg, "--service-ping") == 0 ||
+         std::strcmp(arg, "--service-status") == 0 ||
+         std::strcmp(arg, "--service-help") == 0;
+}
+
+int HandleServiceCliCommand(const std::string& command) {
+  EnsureConsoleForCli();
+
+  if (command == "--service-help") {
+    PrintServiceCliUsage();
+    return 0;
+  }
+
+  if (command == "--service-install") {
+    std::filesystem::path service_path = GetSiblingServiceExecutablePath();
+    if (service_path.empty()) {
+      std::cerr << "Failed to locate crossdesk_service.exe" << std::endl;
+      return 1;
+    }
+    if (!std::filesystem::exists(service_path)) {
+      std::cerr << "Service binary not found: " << service_path.string()
+                << std::endl;
+      return 1;
+    }
+
+    bool success = crossdesk::InstallCrossDeskService(service_path.wstring());
+    std::cout << (success ? "install ok" : "install failed") << std::endl;
+    return success ? 0 : 1;
+  }
+
+  if (command == "--service-uninstall") {
+    bool success = crossdesk::UninstallCrossDeskService();
+    std::cout << (success ? "uninstall ok" : "uninstall failed")
+              << std::endl;
+    return success ? 0 : 1;
+  }
+
+  if (command == "--service-start") {
+    bool success = crossdesk::StartCrossDeskService();
+    std::cout << (success ? "start ok" : "start failed") << std::endl;
+    return success ? 0 : 1;
+  }
+
+  if (command == "--service-stop") {
+    bool success = crossdesk::StopCrossDeskService();
+    std::cout << (success ? "stop ok" : "stop failed") << std::endl;
+    return success ? 0 : 1;
+  }
+
+  if (command == "--service-sas") {
+    std::cout << crossdesk::QueryCrossDeskService("sas") << std::endl;
+    return 0;
+  }
+
+  if (command == "--service-ping") {
+    std::cout << crossdesk::QueryCrossDeskService("ping") << std::endl;
+    return 0;
+  }
+
+  if (command == "--service-status") {
+    std::cout << crossdesk::QueryCrossDeskService("status") << std::endl;
+    return 0;
+  }
+
+  PrintServiceCliUsage();
+  return 1;
+}
+
+}  // namespace
+#endif
+
 int main(int argc, char* argv[]) {
+#ifdef _WIN32
+  if (argc > 1 && IsServiceCliCommand(argv[1])) {
+    return HandleServiceCliCommand(argv[1]);
+  }
+#endif
+
   // check if running as child process
   bool is_child = false;
   for (int i = 1; i < argc; i++) {

src/device_controller/device_controller.h

@@ -7,6 +7,7 @@
 #ifndef _DEVICE_CONTROLLER_H_
 #define _DEVICE_CONTROLLER_H_
 
+#include <cstring>
 #include <stdio.h>
 
 #include <nlohmann/json.hpp>
@@ -23,6 +24,8 @@ typedef enum {
   audio_capture,
   host_infomation,
   display_id,
+  service_status,
+  service_command,
 } ControlType;
 typedef enum {
   move = 0,
@@ -36,6 +39,7 @@ typedef enum {
   wheel_horizontal
 } MouseFlag;
 typedef enum { key_down = 0, key_up } KeyFlag;
+typedef enum { send_sas = 0 } ServiceCommandFlag;
 typedef struct {
   float x;
   float y;
@@ -59,6 +63,15 @@ typedef struct {
   int* bottom;
 } HostInfo;
 
+typedef struct {
+  bool available;
+  char interactive_stage[32];
+} ServiceStatus;
+
+typedef struct {
+  ServiceCommandFlag flag;
+} ServiceCommand;
+
 struct RemoteAction {
   ControlType type;
   union {
@@ -67,6 +80,8 @@ struct RemoteAction {
     HostInfo i;
     bool a;
     int d;
+    ServiceStatus ss;
+    ServiceCommand c;
   };
 
   // parse
@@ -96,6 +111,14 @@ struct RemoteAction {
       case ControlType::display_id:
         j["display_id"] = a.d;
         break;
+      case ControlType::service_status:
+        j["service_status"] = {{"available", a.ss.available},
+                               {"interactive_stage",
+                                a.ss.interactive_stage}};
+        break;
+      case ControlType::service_command:
+        j["service_command"] = {{"flag", a.c.flag}};
+        break;
       case ControlType::host_infomation: {
         json displays = json::array();
         for (size_t idx = 0; idx < a.i.display_num; idx++) {
@@ -137,6 +160,21 @@ struct RemoteAction {
         case ControlType::display_id:
           out.d = j.at("display_id").get<int>();
           break;
+        case ControlType::service_status: {
+          const auto& service_status_json = j.at("service_status");
+          out.ss.available = service_status_json.value("available", false);
+          std::string interactive_stage =
+            service_status_json.value("interactive_stage", std::string());
+          std::strncpy(out.ss.interactive_stage, interactive_stage.c_str(),
+                 sizeof(out.ss.interactive_stage) - 1);
+          out.ss.interactive_stage[sizeof(out.ss.interactive_stage) - 1] =
+            '\0';
+          break;
+        }
+        case ControlType::service_command:
+          out.c.flag = static_cast<ServiceCommandFlag>(
+            j.at("service_command").at("flag").get<int>());
+          break;
         case ControlType::host_infomation: {
           std::string host_name =
               j.at("host_info").at("host_name").get<std::string>();

src/gui/assets/localization/localization_data.h

@@ -51,6 +51,22 @@ struct TranslationRow {
   X(release_mouse, u8"释放", "Release", u8"Освободить")                        \
   X(audio_capture, u8"声音", "Audio", u8"Звук")                                \
   X(mute, u8" 静音", " Mute", u8"Без звука")                                   \
+  X(send_sas, u8"发送SAS", "Send SAS", u8"Отправить SAS")                     \
+  X(remote_password_box_visible, u8"远端密码框已出现",                            \
+    "Remote password box visible", u8"Окно ввода пароля видно")                 \
+  X(remote_lock_screen_hint, u8"远端处于锁屏封面，可发送SAS",                     \
+    "Remote lock screen visible, send SAS",                                     \
+    u8"Видна блокировка, отправьте SAS")                                         \
+  X(remote_secure_desktop_active, u8"远端已进入安全桌面",                         \
+    "Remote secure desktop active",                                              \
+    u8"Активен защищенный рабочий стол")                                         \
+  X(remote_service_unavailable, u8"远端Windows服务不可用",                        \
+    "Remote Windows service unavailable",                                        \
+    u8"Служба Windows на удаленной стороне недоступна")                          \
+  X(remote_unlock_requires_secure_desktop,                                        \
+    u8"当前仍需要安全桌面专用采集/输入",                                         \
+    "Secure desktop capture/input is still required",                            \
+    u8"По-прежнему нужен отдельный захват/ввод для защищенного рабочего стола")   \
   X(settings, u8"设置", "Settings", u8"Настройки")                             \
   X(language, u8"语言:", "Language:", u8"Язык:")                               \
   X(video_quality, u8"视频质量:", "Video Quality:", u8"Качество видео:")       \

src/gui/render.cpp

@@ -28,6 +28,10 @@
 #include "screen_capturer_factory.h"
 #include "version_checker.h"
 
+#if _WIN32
+#include "interactive_state.h"
+#include "service_host.h"
+#endif
 
 #if defined(__APPLE__)
 #include "window_util_mac.h"
@@ -75,6 +79,68 @@ HICON LoadTrayIcon() {
 
   return LoadIconW(nullptr, IDI_APPLICATION);
 }
+
+struct WindowsServiceInteractiveStatus {
+  bool available = false;
+  unsigned int error_code = 0;
+  std::string interactive_stage;
+  std::string error;
+};
+
+constexpr uint32_t kWindowsServiceStatusIntervalMs = 1000;
+constexpr DWORD kWindowsServiceQueryTimeoutMs = 100;
+constexpr DWORD kWindowsServiceSasTimeoutMs = 500;
+
+RemoteAction BuildWindowsServiceStatusAction(
+    const WindowsServiceInteractiveStatus& status) {
+  RemoteAction action{};
+  action.type = ControlType::service_status;
+  action.ss.available = status.available;
+  std::strncpy(action.ss.interactive_stage, status.interactive_stage.c_str(),
+               sizeof(action.ss.interactive_stage) - 1);
+  action.ss.interactive_stage[sizeof(action.ss.interactive_stage) - 1] =
+      '\0';
+  return action;
+}
+
+bool QueryWindowsServiceInteractiveStatus(
+    WindowsServiceInteractiveStatus* status) {
+  if (status == nullptr) {
+    return false;
+  }
+
+  *status = WindowsServiceInteractiveStatus{};
+  const std::string response =
+      QueryCrossDeskService("status", kWindowsServiceQueryTimeoutMs);
+  auto json = nlohmann::json::parse(response, nullptr, false);
+  if (json.is_discarded() || !json.is_object()) {
+    status->error = "invalid_service_status_json";
+    return false;
+  }
+
+  status->available = json.value("ok", false);
+  if (!status->available) {
+    status->error = json.value("error", std::string("service_unavailable"));
+    status->error_code = json.value("code", 0u);
+    return true;
+  }
+
+  status->interactive_stage = json.value("interactive_stage", std::string());
+
+  if (ShouldNormalizeUnlockToUserDesktop(
+          json.value("interactive_lock_screen_visible", false),
+          status->interactive_stage, json.value("session_locked", false),
+          json.value("interactive_logon_ui_visible", false),
+          json.value("interactive_secure_desktop_active",
+                     json.value("secure_desktop_active", false)),
+          json.value("credential_ui_visible", false),
+          json.value("password_box_visible", false),
+          json.value("unlock_ui_visible", false),
+          json.value("last_session_event", std::string()))) {
+    status->interactive_stage = "user-desktop";
+  }
+  return true;
+}
 #endif
 
 #if defined(__linux__) && !defined(__APPLE__)
@@ -1746,6 +1812,7 @@ void Render::MainLoop() {
     HandlePendingPresenceProbe();
     HandleStreamWindow();
     HandleServerWindow();
+    HandleWindowsServiceIntegration();
 
     DrawMainWindow();
     if (stream_window_inited_) {
@@ -1772,6 +1839,139 @@ void Render::UpdateLabels() {
   }
 }
 
+void Render::ResetRemoteServiceStatus(SubStreamWindowProperties& props) {
+  props.remote_service_status_received_ = false;
+  props.remote_service_available_ = false;
+  props.remote_interactive_stage_.clear();
+}
+
+void Render::ApplyRemoteServiceStatus(SubStreamWindowProperties& props,
+                                      const ServiceStatus& status) {
+  props.remote_service_status_received_ = true;
+  props.remote_service_available_ = status.available;
+  props.remote_interactive_stage_ = status.interactive_stage;
+}
+
+Render::RemoteUnlockState Render::GetRemoteUnlockState(
+    const SubStreamWindowProperties& props) const {
+  if (!props.remote_service_status_received_) {
+    return RemoteUnlockState::none;
+  }
+  if (!props.remote_service_available_) {
+    return RemoteUnlockState::service_unavailable;
+  }
+  if (props.remote_interactive_stage_ == "credential-ui") {
+    return RemoteUnlockState::credential_ui;
+  }
+  if (props.remote_interactive_stage_ == "lock-screen") {
+    return RemoteUnlockState::lock_screen;
+  }
+  if (props.remote_interactive_stage_ == "secure-desktop") {
+    return RemoteUnlockState::secure_desktop;
+  }
+  return RemoteUnlockState::none;
+}
+
+void Render::HandleWindowsServiceIntegration() {
+#if _WIN32
+  static bool last_logged_service_available = true;
+  static unsigned int last_logged_service_error_code = 0;
+  static std::string last_logged_service_error;
+
+  if (!is_server_mode_ || peer_ == nullptr) {
+    ResetLocalWindowsServiceState(true);
+    return;
+  }
+
+  const bool has_connected_remote = std::any_of(
+      connection_status_.begin(), connection_status_.end(),
+      [](const auto& entry) {
+        return entry.second == ConnectionStatus::Connected;
+      });
+  if (!has_connected_remote) {
+    ResetLocalWindowsServiceState(false);
+    return;
+  }
+
+  bool force_broadcast = false;
+  if (pending_windows_service_sas_.exchange(false,
+                                            std::memory_order_relaxed)) {
+    const std::string response =
+        QueryCrossDeskService("sas", kWindowsServiceSasTimeoutMs);
+    auto json = nlohmann::json::parse(response, nullptr, false);
+    if (json.is_discarded() || !json.value("ok", false)) {
+      LOG_WARN("Remote SAS request failed: {}", response);
+    } else {
+      LOG_INFO("Remote SAS request forwarded to local Windows service");
+    }
+    last_windows_service_status_tick_ = 0;
+    force_broadcast = true;
+  }
+
+  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
+  if (!force_broadcast && last_windows_service_status_tick_ != 0 &&
+      now - last_windows_service_status_tick_ <
+          kWindowsServiceStatusIntervalMs) {
+    return;
+  }
+  last_windows_service_status_tick_ = now;
+
+  WindowsServiceInteractiveStatus status;
+  const bool status_ok = QueryWindowsServiceInteractiveStatus(&status);
+  local_service_status_received_ = status_ok;
+  local_service_available_ = status.available;
+  local_interactive_stage_ = status.available ? status.interactive_stage : "";
+
+  if (status_ok) {
+    const bool availability_changed =
+        status.available != last_logged_service_available;
+    const bool error_changed =
+        !status.available &&
+        (status.error != last_logged_service_error ||
+         status.error_code != last_logged_service_error_code);
+    if (availability_changed || error_changed) {
+      if (status.available) {
+        LOG_INFO("Local Windows service available for secure desktop integration");
+      } else {
+        LOG_WARN(
+            "Local Windows service unavailable, secure desktop integration disabled: error={}, code={}",
+            status.error, status.error_code);
+      }
+      last_logged_service_available = status.available;
+      last_logged_service_error = status.error;
+      last_logged_service_error_code = status.error_code;
+    }
+  } else if (last_logged_service_available ||
+             last_logged_service_error != "invalid_service_status_json") {
+    LOG_WARN(
+        "Local Windows service status query failed, secure desktop integration disabled");
+    last_logged_service_available = false;
+    last_logged_service_error = "invalid_service_status_json";
+    last_logged_service_error_code = 0;
+  }
+
+  RemoteAction remote_action = BuildWindowsServiceStatusAction(status);
+  std::string msg = remote_action.to_json();
+  int ret = SendReliableDataFrame(peer_, msg.data(), msg.size(),
+                                  control_data_label_.c_str());
+  if (ret != 0) {
+    LOG_WARN("Broadcast Windows service status failed, ret={}", ret);
+  }
+#endif
+}
+
+#if _WIN32
+void Render::ResetLocalWindowsServiceState(bool clear_pending_sas) {
+  last_windows_service_status_tick_ = 0;
+  if (clear_pending_sas) {
+    pending_windows_service_sas_.store(false, std::memory_order_relaxed);
+  }
+  local_service_status_received_ = false;
+  local_service_available_ = false;
+  local_interactive_stage_.clear();
+}
+#endif
+
 void Render::HandleRecentConnections() {
   if (reload_recent_connections_ && main_renderer_) {
     uint32_t now_time = SDL_GetTicks();

src/gui/render.h

@@ -44,6 +44,14 @@
 namespace crossdesk {
 class Render {
  public:
+  enum class RemoteUnlockState {
+    none,
+    service_unavailable,
+    lock_screen,
+    credential_ui,
+    secure_desktop,
+  };
+
   struct FileTransferState {
     std::atomic<bool> file_sending_ = false;
     std::atomic<uint64_t> file_sent_bytes_ = 0;
@@ -159,6 +167,9 @@ class Render {
     std::string mouse_control_button_label_ = "Mouse Control";
     std::string audio_capture_button_label_ = "Audio Capture";
     std::string remote_host_name_ = "";
+    bool remote_service_status_received_ = false;
+    bool remote_service_available_ = false;
+    std::string remote_interactive_stage_ = "";
     std::vector<DisplayInfo> display_info_list_;
     SDL_Texture* stream_texture_ = nullptr;
     uint8_t* argb_buffer_ = nullptr;
@@ -271,6 +282,13 @@ class Render {
       std::shared_ptr<SubStreamWindowProperties>& props);
   void DrawReceivingScreenText(
       std::shared_ptr<SubStreamWindowProperties>& props);
+  void DrawRemoteUnlockStateText(
+      std::shared_ptr<SubStreamWindowProperties>& props);
+  void ResetRemoteServiceStatus(SubStreamWindowProperties& props);
+  void ApplyRemoteServiceStatus(SubStreamWindowProperties& props,
+                                const ServiceStatus& status);
+    RemoteUnlockState GetRemoteUnlockState(
+      const SubStreamWindowProperties& props) const;
 #ifdef __APPLE__
   int RequestPermissionWindow();
   bool CheckScreenRecordingPermission();
@@ -359,6 +377,10 @@ class Render {
 
   int AudioDeviceInit();
   int AudioDeviceDestroy();
+  void HandleWindowsServiceIntegration();
+#if _WIN32
+  void ResetLocalWindowsServiceState(bool clear_pending_sas);
+#endif
 
  private:
   struct CDCache {
@@ -515,6 +537,14 @@ class Render {
   SDL_Event last_mouse_event;
   SDL_AudioStream* output_stream_;
   uint32_t STREAM_REFRESH_EVENT = 0;
+#if _WIN32
+  std::atomic<bool> pending_windows_service_sas_{false};
+  bool local_service_status_received_ = false;
+  bool local_service_available_ = false;
+  std::string local_interactive_stage_;
+  uint32_t last_local_secure_input_block_log_tick_ = 0;
+  uint32_t last_windows_service_status_tick_ = 0;
+#endif
 
   // stream window render
   SDL_Window* stream_window_ = nullptr;

src/gui/render_callback.cpp

@@ -17,11 +17,63 @@
 #include "platform.h"
 #include "rd_log.h"
 #include "render.h"
+#if _WIN32
+#include "interactive_state.h"
+#include "service_host.h"
+#endif
 
 #define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
 
 namespace crossdesk {
 
+namespace {
+
+#if _WIN32
+constexpr uint32_t kSecureDesktopInputLogIntervalMs = 2000;
+
+bool BuildAbsoluteMousePosition(const std::vector<DisplayInfo>& displays,
+                                int display_index, float normalized_x,
+                                float normalized_y, int* absolute_x_out,
+                                int* absolute_y_out) {
+  if (absolute_x_out == nullptr || absolute_y_out == nullptr ||
+      display_index < 0 ||
+      display_index >= static_cast<int>(displays.size())) {
+    return false;
+  }
+
+  const DisplayInfo& display = displays[display_index];
+  if (display.width <= 0 || display.height <= 0) {
+    return false;
+  }
+
+  const float clamped_x = std::clamp(normalized_x, 0.0f, 1.0f);
+  const float clamped_y = std::clamp(normalized_y, 0.0f, 1.0f);
+  *absolute_x_out = static_cast<int>(clamped_x * display.width) + display.left;
+  *absolute_y_out = static_cast<int>(clamped_y * display.height) + display.top;
+  return true;
+}
+
+void LogSecureDesktopInputBlocked(uint32_t* last_tick, const char* side,
+                                  const char* stage) {
+  if (last_tick == nullptr) {
+    return;
+  }
+
+  const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
+  if (*last_tick != 0 && now - *last_tick < kSecureDesktopInputLogIntervalMs) {
+    return;
+  }
+
+  *last_tick = now;
+  LOG_WARN(
+      "{} secure-desktop input blocked, stage={}, normal SendInput path "
+      "cannot drive the Windows password UI",
+      side != nullptr ? side : "unknown", stage != nullptr ? stage : "");
+}
+#endif
+
+}  // namespace
+
 void Render::OnSignalMessageCb(const char* message, size_t size,
                                void* user_data) {
   Render* render = (Render*)user_data;
@@ -709,16 +761,31 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
   }
 
   std::string json_str(data, size);
-  RemoteAction remote_action;
+  RemoteAction remote_action{};
-
+  if (!remote_action.from_json(json_str)) {
-  try {
+    LOG_ERROR("Failed to parse RemoteAction JSON payload");
-    remote_action.from_json(json_str);
-  } catch (const std::exception& e) {
-    LOG_ERROR("Failed to parse RemoteAction JSON: {}", e.what());
     return;
   }
 
   std::string remote_id(user_id, user_id_size);
+  if (remote_action.type == ControlType::service_status) {
+    auto props_it = render->client_properties_.find(remote_id);
+    if (props_it != render->client_properties_.end()) {
+      render->ApplyRemoteServiceStatus(*props_it->second, remote_action.ss);
+    }
+    return;
+  }
+
+  if (remote_action.type == ControlType::service_command) {
+#if _WIN32
+    if (remote_action.c.flag == ServiceCommandFlag::send_sas) {
+      render->pending_windows_service_sas_.store(true,
+                                                 std::memory_order_relaxed);
+    }
+#endif
+    return;
+  }
+
   // std::shared_lock lock(render->client_properties_mutex_);
   if (remote_action.type == ControlType::host_infomation) {
     if (render->client_properties_.find(remote_id) !=
@@ -748,6 +815,59 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
     }
   } else {
     // remote
+#if _WIN32
+    if (render->local_service_status_received_ &&
+        render->local_service_available_ &&
+        IsSecureDesktopInteractionRequired(render->local_interactive_stage_)) {
+      if (remote_action.type == ControlType::mouse) {
+        int absolute_x = 0;
+        int absolute_y = 0;
+        if (!BuildAbsoluteMousePosition(render->display_info_list_,
+                                        render->selected_display_,
+                                        remote_action.m.x, remote_action.m.y,
+                                        &absolute_x, &absolute_y)) {
+          LOG_WARN(
+              "Secure desktop mouse injection skipped, invalid display mapping: display_index={}, x={}, y={}",
+              render->selected_display_, remote_action.m.x,
+              remote_action.m.y);
+          return;
+        }
+
+        const std::string response = SendCrossDeskSecureDesktopMouseInput(
+            absolute_x, absolute_y, remote_action.m.s,
+            static_cast<int>(remote_action.m.flag), 1000);
+        auto json = nlohmann::json::parse(response, nullptr, false);
+        if (json.is_discarded() || !json.value("ok", false)) {
+          LogSecureDesktopInputBlocked(
+              &render->last_local_secure_input_block_log_tick_, "local",
+              render->local_interactive_stage_.c_str());
+          LOG_WARN(
+              "Secure desktop mouse injection failed, x={}, y={}, wheel={}, flag={}, response={}",
+              absolute_x, absolute_y, remote_action.m.s,
+              static_cast<int>(remote_action.m.flag), response);
+        }
+        return;
+      }
+
+      if (remote_action.type == ControlType::keyboard) {
+        const int key_code = static_cast<int>(remote_action.k.key_value);
+        const bool is_down = remote_action.k.flag == KeyFlag::key_down;
+        const std::string response =
+            SendCrossDeskSecureDesktopKeyInput(key_code, is_down, 1000);
+        auto json = nlohmann::json::parse(response, nullptr, false);
+        if (json.is_discarded() || !json.value("ok", false)) {
+          LogSecureDesktopInputBlocked(
+              &render->last_local_secure_input_block_log_tick_, "local",
+              render->local_interactive_stage_.c_str());
+          LOG_WARN(
+              "Secure desktop keyboard injection failed, key_code={}, "
+              "is_down={}, response={}",
+              key_code, is_down, response);
+        }
+        return;
+      }
+    }
+#endif
     if (remote_action.type == ControlType::mouse && render->mouse_controller_) {
       render->mouse_controller_->SendMouseCommand(remote_action,
                                                   render->selected_display_);
@@ -841,6 +961,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
+        render->ResetRemoteServiceStatus(*props);
         {
           RemoteAction remote_action;
           remote_action.i.display_num = render->display_info_list_.size();
@@ -904,6 +1025,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
       case ConnectionStatus::Closed: {
         props->connection_established_ = false;
         props->enable_mouse_control_ = false;
+        render->ResetRemoteServiceStatus(*props);
 
         {
           std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
@@ -954,6 +1076,9 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
+#if _WIN32
+        render->last_windows_service_status_tick_ = 0;
+#endif
         {
           RemoteAction remote_action;
           remote_action.i.display_num = render->display_info_list_.size();

src/gui/toolbars/control_bar.cpp

@@ -193,6 +193,94 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
         text_pos, IM_COL32(0, 0, 0, 255),
         std::to_string(props->selected_display_ + 1).c_str());
 
+    if (props->remote_service_status_received_) {
+      ImGui::SameLine();
+      const RemoteUnlockState unlock_state = GetRemoteUnlockState(*props);
+      bool sas_button_style_pushed = false;
+      switch (unlock_state) {
+        case RemoteUnlockState::service_unavailable:
+          ImGui::PushStyleColor(ImGuiCol_Button,
+                                ImVec4(185 / 255.0f, 28 / 255.0f,
+                                       28 / 255.0f, 1.0f));
+          sas_button_style_pushed = true;
+          break;
+        case RemoteUnlockState::credential_ui:
+          ImGui::PushStyleColor(ImGuiCol_Button,
+                                ImVec4(22 / 255.0f, 163 / 255.0f,
+                                       74 / 255.0f, 1.0f));
+          sas_button_style_pushed = true;
+          break;
+        case RemoteUnlockState::lock_screen:
+          ImGui::PushStyleColor(ImGuiCol_Button,
+                                ImVec4(202 / 255.0f, 138 / 255.0f,
+                                       4 / 255.0f, 1.0f));
+          sas_button_style_pushed = true;
+          break;
+        default:
+          break;
+      }
+
+      const bool can_send_sas =
+          props->connection_status_ == ConnectionStatus::Connected &&
+          props->peer_ != nullptr && props->remote_service_available_;
+      if (!can_send_sas) {
+        ImGui::BeginDisabled();
+      }
+
+      std::string sas_button = ICON_FA_UNLOCK_KEYHOLE;
+      ImGui::SetWindowFontScale(0.5f);
+      if (ImGui::Button(sas_button.c_str(),
+                        ImVec2(button_width, button_height))) {
+        RemoteAction remote_action{};
+        remote_action.type = ControlType::service_command;
+        remote_action.c.flag = ServiceCommandFlag::send_sas;
+        std::string msg = remote_action.to_json();
+        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
+                              props->control_data_label_.c_str());
+      }
+
+      if (!can_send_sas) {
+        ImGui::EndDisabled();
+      }
+
+      if (ImGui::IsItemHovered()) {
+        std::string tooltip = localization::send_sas[localization_language_index_];
+        switch (unlock_state) {
+          case RemoteUnlockState::service_unavailable:
+            tooltip = localization::remote_service_unavailable
+                [localization_language_index_];
+            break;
+          case RemoteUnlockState::credential_ui:
+            tooltip = localization::remote_password_box_visible
+                          [localization_language_index_] +
+                      "\n" +
+                      localization::remote_unlock_requires_secure_desktop
+                          [localization_language_index_];
+            break;
+          case RemoteUnlockState::lock_screen:
+            tooltip = localization::remote_lock_screen_hint
+                [localization_language_index_];
+            break;
+          case RemoteUnlockState::secure_desktop:
+            tooltip = localization::remote_secure_desktop_active
+                [localization_language_index_];
+            break;
+          default:
+            break;
+        }
+
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(button_width * 8.0f);
+        ImGui::TextWrapped("%s", tooltip.c_str());
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+      }
+
+      if (sas_button_style_pushed) {
+        ImGui::PopStyleColor();
+      }
+    }
+
     ImGui::SameLine();
     float mouse_x = ImGui::GetCursorScreenPos().x;
     float mouse_y = ImGui::GetCursorScreenPos().y;

src/gui/windows/stream_window.cpp

@@ -59,6 +59,62 @@ void Render::DrawReceivingScreenText(
   ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.92f), "%s", text.c_str());
 }
 
+void Render::DrawRemoteUnlockStateText(
+    std::shared_ptr<SubStreamWindowProperties>& props) {
+  if (!props->remote_service_status_received_ ||
+      !props->connection_established_ ||
+      props->connection_status_ != ConnectionStatus::Connected) {
+    return;
+  }
+
+  const RemoteUnlockState unlock_state = GetRemoteUnlockState(*props);
+  std::string text;
+  ImU32 background_color = IM_COL32(37, 99, 235, 220);
+
+  switch (unlock_state) {
+    case RemoteUnlockState::service_unavailable:
+      text = localization::remote_service_unavailable
+          [localization_language_index_];
+      background_color = IM_COL32(185, 28, 28, 220);
+      break;
+    case RemoteUnlockState::credential_ui:
+      text = localization::remote_password_box_visible
+          [localization_language_index_];
+      background_color = IM_COL32(22, 163, 74, 220);
+      break;
+    case RemoteUnlockState::lock_screen:
+      text = localization::remote_lock_screen_hint
+          [localization_language_index_];
+      background_color = IM_COL32(202, 138, 4, 220);
+      break;
+    case RemoteUnlockState::secure_desktop:
+      text = localization::remote_secure_desktop_active
+          [localization_language_index_];
+      background_color = IM_COL32(147, 51, 234, 220);
+      break;
+    default:
+      return;
+  }
+
+  ImDrawList* draw_list = ImGui::GetWindowDrawList();
+  ImVec2 window_pos = ImGui::GetWindowPos();
+  ImVec2 window_size = ImGui::GetWindowSize();
+  ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+  float padding_x = title_bar_height_ * 0.45f;
+  float padding_y = title_bar_height_ * 0.18f;
+  float top_margin = fullscreen_button_pressed_ ? title_bar_height_ * 0.35f
+                                                : title_bar_height_ * 0.18f;
+  ImVec2 text_pos(window_pos.x + (window_size.x - text_size.x) * 0.5f,
+                  window_pos.y + top_margin + padding_y);
+  ImVec2 rect_min(text_pos.x - padding_x, text_pos.y - padding_y);
+  ImVec2 rect_max(text_pos.x + text_size.x + padding_x,
+                  text_pos.y + text_size.y + padding_y);
+
+  draw_list->AddRectFilled(rect_min, rect_max, background_color,
+                           window_rounding_ * 0.9f);
+  draw_list->AddText(text_pos, IM_COL32(255, 255, 255, 255), text.c_str());
+}
+
 void Render::CloseTab(decltype(client_properties_)::iterator& it) {
   // std::unique_lock lock(client_properties_mutex_);
   if (it != client_properties_.end()) {
@@ -173,6 +229,7 @@ int Render::StreamWindow() {
           FileTransferWindow(props);
 
           DrawReceivingScreenText(props);
+          DrawRemoteUnlockStateText(props);
 
           focused_remote_id_ = props->remote_id_;
 
@@ -275,6 +332,7 @@ int Render::StreamWindow() {
         FileTransferWindow(props);
 
         DrawReceivingScreenText(props);
+        DrawRemoteUnlockStateText(props);
 
         ImGui::End();
 

src/screen_capturer/windows/screen_capturer_win.cpp

@@ -2,22 +2,50 @@
 
 #include <Windows.h>
 
+#include <nlohmann/json.hpp>
+
 #include <cmath>
+#include <chrono>
+#include <cstring>
 #include <filesystem>
 #include <memory>
+#include <sstream>
 #include <string>
+#include <thread>
 #include <utility>
 #include <vector>
 
 #include "rd_log.h"
 #include "screen_capturer_dxgi.h"
 #include "screen_capturer_gdi.h"
+#include "interactive_state.h"
+#include "service_host.h"
+#include "session_helper_shared.h"
 #include "wgc_plugin_api.h"
 
 namespace crossdesk {
 
 namespace {
 
+using Json = nlohmann::json;
+
+constexpr DWORD kSecureDesktopStatusIntervalMs = 250;
+constexpr DWORD kSecureDesktopStatusPipeTimeoutMs = 150;
+constexpr DWORD kSecureDesktopHelperPipeTimeoutMs = 120;
+constexpr DWORD kSecureDesktopTransientErrorGraceMs = 1500;
+constexpr DWORD kSecureDesktopTransientErrorLogIntervalMs = 5000;
+constexpr int kSecureDesktopCaptureMinIntervalMs = 100;
+
+struct SecureDesktopServiceStatus {
+  bool service_available = false;
+  bool capture_active = false;
+  bool helper_running = false;
+  DWORD active_session_id = 0xFFFFFFFF;
+  DWORD error_code = 0;
+  std::string interactive_stage;
+  std::string error;
+};
+
 class WgcPluginCapturer final : public ScreenCapturer {
  public:
   using CreateFn = ScreenCapturer* (*)();
@@ -101,6 +129,213 @@ class WgcPluginCapturer final : public ScreenCapturer {
   DestroyFn destroy_fn_ = nullptr;
 };
 
+std::string BuildSecureCaptureCommand(int left, int top, int width, int height,
+                                      bool show_cursor) {
+  std::ostringstream stream;
+  stream << kCrossDeskSecureInputCaptureCommandPrefix << left << ":" << top
+         << ":" << width << ":" << height << ":" << (show_cursor ? 1 : 0);
+  return stream.str();
+}
+
+std::string ExtractPipeTextResponse(const std::vector<uint8_t>& response) {
+  if (response.empty() || response.front() != '{') {
+    return "<non-text-response>";
+  }
+  return std::string(response.begin(), response.end());
+}
+
+bool IsTransientSecureDesktopFrameError(const std::string& error_message) {
+  return error_message.rfind("pipe_unavailable:", 0) == 0 ||
+         error_message.find("\"error\":\"bitblt_failed\"") !=
+             std::string::npos;
+}
+
+bool ReadPipeMessage(HANDLE pipe, std::vector<uint8_t>* response_out,
+                     DWORD* error_code_out = nullptr) {
+  if (response_out == nullptr) {
+    return false;
+  }
+
+  response_out->clear();
+  if (error_code_out != nullptr) {
+    *error_code_out = 0;
+  }
+
+  std::vector<uint8_t> chunk(64 * 1024);
+  while (true) {
+    DWORD bytes_read = 0;
+    if (ReadFile(pipe, chunk.data(), static_cast<DWORD>(chunk.size()),
+                 &bytes_read, nullptr)) {
+      response_out->insert(response_out->end(), chunk.begin(),
+                           chunk.begin() + bytes_read);
+      return true;
+    }
+
+    const DWORD error = GetLastError();
+    response_out->insert(response_out->end(), chunk.begin(),
+                         chunk.begin() + bytes_read);
+    if (error == ERROR_MORE_DATA) {
+      continue;
+    }
+
+    if (error_code_out != nullptr) {
+      *error_code_out = error;
+    }
+    return false;
+  }
+}
+
+bool ParseSecureDesktopFrameResponse(const std::vector<uint8_t>& response,
+                                     std::vector<uint8_t>* nv12_frame_out,
+                                     int* width_out, int* height_out,
+                                     std::string* error_out) {
+  if (nv12_frame_out == nullptr || width_out == nullptr ||
+      height_out == nullptr) {
+    return false;
+  }
+
+  if (response.size() < sizeof(CrossDeskSecureDesktopFrameHeader)) {
+    if (error_out != nullptr) {
+      *error_out = ExtractPipeTextResponse(response);
+    }
+    return false;
+  }
+
+  CrossDeskSecureDesktopFrameHeader header{};
+  std::memcpy(&header, response.data(), sizeof(header));
+  if (header.magic != kCrossDeskSecureDesktopFrameMagic ||
+      header.version != kCrossDeskSecureDesktopFrameVersion) {
+    if (error_out != nullptr) {
+      *error_out = ExtractPipeTextResponse(response);
+    }
+    return false;
+  }
+
+  const size_t expected_size = sizeof(header) + header.payload_size;
+  if (expected_size != response.size()) {
+    if (error_out != nullptr) {
+      *error_out = "<invalid-frame-size>";
+    }
+    return false;
+  }
+
+  *width_out = static_cast<int>(header.width);
+  *height_out = static_cast<int>(header.height);
+  nv12_frame_out->assign(response.begin() + sizeof(header), response.end());
+  return true;
+}
+
+bool QuerySecureDesktopServiceStatus(SecureDesktopServiceStatus* status) {
+  if (status == nullptr) {
+    return false;
+  }
+
+  *status = {};
+  const std::string response =
+      QueryCrossDeskService("status", kSecureDesktopStatusPipeTimeoutMs);
+  Json json = Json::parse(response, nullptr, false);
+  if (json.is_discarded() || !json.is_object()) {
+    status->error = "invalid_service_status_json";
+    return false;
+  }
+
+  status->service_available = json.value("ok", false);
+  if (!status->service_available) {
+    status->error = json.value("error", std::string("service_unavailable"));
+    status->error_code = json.value("code", 0u);
+    return true;
+  }
+
+  if (ShouldNormalizeUnlockToUserDesktop(
+          json.value("interactive_lock_screen_visible", false),
+          json.value("interactive_stage", std::string()),
+          json.value("session_locked", false),
+          json.value("interactive_logon_ui_visible", false),
+          json.value("interactive_secure_desktop_active",
+                     json.value("secure_desktop_active", false)),
+          json.value("credential_ui_visible", false),
+          json.value("password_box_visible", false),
+          json.value("unlock_ui_visible", false),
+          json.value("last_session_event", std::string()))) {
+    status->active_session_id = json.value("active_session_id", 0xFFFFFFFFu);
+    status->interactive_stage = "user-desktop";
+    status->capture_active = false;
+    return true;
+  }
+
+  status->active_session_id = json.value("active_session_id", 0xFFFFFFFFu);
+  status->helper_running = json.value("secure_input_helper_running", false);
+  status->interactive_stage = json.value("interactive_stage", std::string());
+  const bool secure_desktop_active = json.value(
+      "interactive_secure_desktop_active",
+      json.value("secure_desktop_active", false));
+  status->capture_active =
+      status->active_session_id != 0xFFFFFFFF &&
+      (secure_desktop_active ||
+       IsSecureDesktopInteractionRequired(status->interactive_stage));
+  return true;
+}
+
+bool QuerySecureDesktopHelperFrame(DWORD session_id, int left, int top,
+                                   int width, int height, bool show_cursor,
+                                   std::vector<uint8_t>* nv12_frame_out,
+                                   int* captured_width_out,
+                                   int* captured_height_out,
+                                   std::string* error_out) {
+  if (nv12_frame_out == nullptr || captured_width_out == nullptr ||
+      captured_height_out == nullptr) {
+    return false;
+  }
+
+  const std::wstring pipe_name = GetCrossDeskSecureInputHelperPipeName(session_id);
+  if (!WaitNamedPipeW(pipe_name.c_str(), kSecureDesktopHelperPipeTimeoutMs)) {
+    if (error_out != nullptr) {
+      *error_out = "pipe_unavailable:" + std::to_string(GetLastError());
+    }
+    return false;
+  }
+
+  HANDLE pipe = CreateFileW(pipe_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0,
+                            nullptr, OPEN_EXISTING, 0, nullptr);
+  if (pipe == INVALID_HANDLE_VALUE) {
+    if (error_out != nullptr) {
+      *error_out = "pipe_connect_failed:" + std::to_string(GetLastError());
+    }
+    return false;
+  }
+
+  DWORD pipe_mode = PIPE_READMODE_MESSAGE;
+  SetNamedPipeHandleState(pipe, &pipe_mode, nullptr, nullptr);
+
+  const std::string command =
+      BuildSecureCaptureCommand(left, top, width, height, show_cursor);
+  DWORD bytes_written = 0;
+  if (!WriteFile(pipe, command.data(), static_cast<DWORD>(command.size()),
+                 &bytes_written, nullptr)) {
+    const DWORD error = GetLastError();
+    CloseHandle(pipe);
+    if (error_out != nullptr) {
+      *error_out = "pipe_write_failed:" + std::to_string(error);
+    }
+    return false;
+  }
+
+  std::vector<uint8_t> response;
+  DWORD read_error = 0;
+  const bool read_ok = ReadPipeMessage(pipe, &response, &read_error);
+  CloseHandle(pipe);
+  if (!read_ok) {
+    if (error_out != nullptr) {
+      *error_out = "pipe_read_failed:" + std::to_string(read_error);
+    }
+    return false;
+  }
+
+  return ParseSecureDesktopFrameResponse(response, nv12_frame_out,
+                                         captured_width_out,
+                                         captured_height_out, error_out);
+}
+
 }  // namespace
 
 ScreenCapturerWin::ScreenCapturerWin() {}
@@ -111,6 +346,10 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   cb_orig_ = cb;
   cb_ = [this](unsigned char* data, int size, int w, int h,
                const char* display_name) {
+    if (secure_desktop_capture_active_.load(std::memory_order_relaxed)) {
+      return;
+    }
+
     std::string mapped_name;
     {
       std::lock_guard<std::mutex> lock(alias_mutex_);
@@ -137,6 +376,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   if (ret == 0) {
     LOG_INFO("Windows capturer: using WGC plugin");
     BuildCanonicalFromImpl();
+    monitor_index_.store(0, std::memory_order_relaxed);
+    initial_monitor_index_ = 0;
     return 0;
   }
 
@@ -150,6 +391,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   if (ret == 0) {
     LOG_INFO("Windows capturer: using DXGI Desktop Duplication");
     BuildCanonicalFromImpl();
+    monitor_index_.store(0, std::memory_order_relaxed);
+    initial_monitor_index_ = 0;
     return 0;
   }
 
@@ -162,6 +405,8 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   if (ret == 0) {
     LOG_INFO("Windows capturer: using GDI BitBlt");
     BuildCanonicalFromImpl();
+    monitor_index_.store(0, std::memory_order_relaxed);
+    initial_monitor_index_ = 0;
     return 0;
   }
 
@@ -171,6 +416,10 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
 }
 
 int ScreenCapturerWin::Destroy() {
+  StopSecureCaptureThread();
+  running_.store(false, std::memory_order_relaxed);
+  paused_.store(false, std::memory_order_relaxed);
+  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
   if (impl_) {
     impl_->Destroy();
     impl_.reset();
@@ -187,67 +436,100 @@ int ScreenCapturerWin::Destroy() {
 
 int ScreenCapturerWin::Start(bool show_cursor) {
   if (!impl_) return -1;
+  if (running_.load(std::memory_order_relaxed)) {
+    return 0;
+  }
+
+  show_cursor_.store(show_cursor, std::memory_order_relaxed);
+  paused_.store(false, std::memory_order_relaxed);
+
   int ret = impl_->Start(show_cursor);
-  if (ret == 0) return 0;
+  if (ret != 0) {
+    LOG_WARN("Windows capturer: Start failed (ret={}), trying fallback", ret);
 
-  LOG_WARN("Windows capturer: Start failed (ret={}), trying fallback", ret);
+    auto try_init_start = [&](std::unique_ptr<ScreenCapturer> cand) -> bool {
+      int r = cand->Init(fps_, cb_);
+      if (r != 0) return false;
+      int s = cand->Start(show_cursor);
+      if (s == 0) {
+        impl_ = std::move(cand);
+        impl_is_wgc_plugin_ = false;
+        RebuildAliasesFromImpl();
+        return true;
+      }
+      return false;
+    };
 
-  auto try_init_start = [&](std::unique_ptr<ScreenCapturer> cand) -> bool {
+    bool fallback_started = false;
-    int r = cand->Init(fps_, cb_);
+    if (impl_is_wgc_plugin_) {
-    if (r != 0) return false;
+      if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
-    int s = cand->Start(show_cursor);
+        LOG_INFO("Windows capturer: fallback to DXGI");
-    if (s == 0) {
+        fallback_started = true;
-      impl_ = std::move(cand);
+      } else if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
-      impl_is_wgc_plugin_ = false;
+        LOG_INFO("Windows capturer: fallback to GDI");
-      RebuildAliasesFromImpl();
+        fallback_started = true;
-      return true;
+      }
+    } else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
+      if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
+        LOG_INFO("Windows capturer: fallback to GDI");
+        fallback_started = true;
+      }
     }
-    return false;
-  };
 
-  if (impl_is_wgc_plugin_) {
+    if (!fallback_started) {
-    if (try_init_start(std::make_unique<ScreenCapturerDxgi>())) {
+      LOG_ERROR("Windows capturer: all fallbacks failed to start");
-      LOG_INFO("Windows capturer: fallback to DXGI");
+      return ret;
-      return 0;
-    }
-    if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
-      LOG_INFO("Windows capturer: fallback to GDI");
-      return 0;
-    }
-  } else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
-    if (try_init_start(std::make_unique<ScreenCapturerGdi>())) {
-      LOG_INFO("Windows capturer: fallback to GDI");
-      return 0;
     }
   }
 
-  LOG_ERROR("Windows capturer: all fallbacks failed to start");
+  running_.store(true, std::memory_order_relaxed);
-  return ret;
+  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
+  if (!secure_capture_thread_.joinable()) {
+    secure_capture_thread_ =
+        std::thread([this]() { SecureDesktopCaptureLoop(); });
+  }
+  return 0;
 }
 
 int ScreenCapturerWin::Stop() {
-  if (!impl_) return 0;
+  running_.store(false, std::memory_order_relaxed);
-  return impl_->Stop();
+  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
+  int ret = 0;
+  if (impl_) {
+    ret = impl_->Stop();
+  }
+  StopSecureCaptureThread();
+  return ret;
 }
 
 int ScreenCapturerWin::Pause(int monitor_index) {
+  paused_.store(true, std::memory_order_relaxed);
   if (!impl_) return -1;
   return impl_->Pause(monitor_index);
 }
 
 int ScreenCapturerWin::Resume(int monitor_index) {
+  paused_.store(false, std::memory_order_relaxed);
   if (!impl_) return -1;
   return impl_->Resume(monitor_index);
 }
 
 int ScreenCapturerWin::SwitchTo(int monitor_index) {
   if (!impl_) return -1;
-  return impl_->SwitchTo(monitor_index);
+  const int ret = impl_->SwitchTo(monitor_index);
+  if (ret == 0) {
+    monitor_index_.store(monitor_index, std::memory_order_relaxed);
+  }
+  return ret;
 }
 
 int ScreenCapturerWin::ResetToInitialMonitor() {
   if (!impl_) return -1;
-  return impl_->ResetToInitialMonitor();
+  const int ret = impl_->ResetToInitialMonitor();
+  if (ret == 0) {
+    monitor_index_.store(initial_monitor_index_, std::memory_order_relaxed);
+  }
+  return ret;
 }
 
 std::vector<DisplayInfo> ScreenCapturerWin::GetDisplayInfoList() {
@@ -297,4 +579,171 @@ void ScreenCapturerWin::RebuildAliasesFromImpl() {
   }
 }
 
+void ScreenCapturerWin::StopSecureCaptureThread() {
+  if (secure_capture_thread_.joinable()) {
+    secure_capture_thread_.join();
+  }
+}
+
+bool ScreenCapturerWin::GetCurrentCaptureRegion(int* left, int* top,
+                                                int* width, int* height,
+                                                std::string* display_name) {
+  if (left == nullptr || top == nullptr || width == nullptr ||
+      height == nullptr || display_name == nullptr) {
+    return false;
+  }
+
+  std::lock_guard<std::mutex> lock(alias_mutex_);
+  if (canonical_displays_.empty()) {
+    return false;
+  }
+
+  int current_monitor = monitor_index_.load(std::memory_order_relaxed);
+  if (current_monitor < 0 ||
+      current_monitor >= static_cast<int>(canonical_displays_.size())) {
+    current_monitor = 0;
+  }
+
+  const auto& display = canonical_displays_[current_monitor];
+  const int capture_width = display.width & ~1;
+  const int capture_height = display.height & ~1;
+  if (capture_width <= 0 || capture_height <= 0) {
+    return false;
+  }
+
+  *left = display.left;
+  *top = display.top;
+  *width = capture_width;
+  *height = capture_height;
+  *display_name = display.name;
+  return true;
+}
+
+void ScreenCapturerWin::SecureDesktopCaptureLoop() {
+  const int frame_interval_ms =
+      fps_ > 0 ? (std::max)(kSecureDesktopCaptureMinIntervalMs, 1000 / fps_)
+               : kSecureDesktopCaptureMinIntervalMs;
+  ULONGLONG last_status_tick = 0;
+  ULONGLONG last_error_tick = 0;
+  bool last_capture_active = false;
+  bool last_service_available = true;
+  std::string last_stage;
+  std::string last_service_error;
+  ULONGLONG capture_stage_started_tick = 0;
+  SecureDesktopServiceStatus status;
+  std::vector<uint8_t> secure_frame;
+
+  while (running_.load(std::memory_order_relaxed)) {
+    if (paused_.load(std::memory_order_relaxed)) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      continue;
+    }
+
+    const ULONGLONG now = GetTickCount64();
+    if (last_status_tick == 0 ||
+        now - last_status_tick >= kSecureDesktopStatusIntervalMs) {
+      SecureDesktopServiceStatus latest_status;
+      const bool status_ok = QuerySecureDesktopServiceStatus(&latest_status);
+      status = latest_status;
+      if (status_ok) {
+        const bool service_changed =
+            status.service_available != last_service_available;
+        const bool service_error_changed =
+            !status.service_available && status.error != last_service_error;
+        if (service_changed || service_error_changed) {
+          if (status.service_available) {
+            LOG_INFO(
+                "Windows capturer secure desktop service available, polling session_id={}",
+                status.active_session_id);
+          } else {
+            LOG_WARN(
+                "Windows capturer secure desktop service unavailable: error={}, code={}",
+                status.error, status.error_code);
+          }
+          last_service_available = status.service_available;
+          last_service_error = status.error;
+        }
+      } else if (last_service_available ||
+                 last_service_error != "invalid_service_status_json") {
+        LOG_WARN(
+            "Windows capturer secure desktop service status query failed");
+        last_service_available = false;
+        last_service_error = "invalid_service_status_json";
+      }
+
+      secure_desktop_capture_active_.store(status.capture_active,
+                                           std::memory_order_relaxed);
+      if (status.capture_active != last_capture_active ||
+          status.interactive_stage != last_stage) {
+        capture_stage_started_tick = now;
+        LOG_INFO(
+            "Windows capturer secure desktop state: active={}, stage='{}', session_id={}",
+            status.capture_active, status.interactive_stage,
+            status.active_session_id);
+        last_capture_active = status.capture_active;
+        last_stage = status.interactive_stage;
+      }
+      last_status_tick = now;
+    }
+
+    if (!status.capture_active || status.active_session_id == 0xFFFFFFFF) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(
+          status.service_available ? 50 : 200));
+      continue;
+    }
+
+    if (!status.helper_running) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(30));
+      continue;
+    }
+
+    int left = 0;
+    int top = 0;
+    int width = 0;
+    int height = 0;
+    std::string display_name;
+    if (!GetCurrentCaptureRegion(&left, &top, &width, &height, &display_name)) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+      continue;
+    }
+
+    int captured_width = 0;
+    int captured_height = 0;
+    std::string error_message;
+    if (QuerySecureDesktopHelperFrame(
+            status.active_session_id, left, top, width, height,
+            show_cursor_.load(std::memory_order_relaxed), &secure_frame,
+            &captured_width, &captured_height, &error_message)) {
+      if (cb_orig_ && !secure_frame.empty()) {
+        cb_orig_(secure_frame.data(), static_cast<int>(secure_frame.size()),
+                 captured_width, captured_height, display_name.c_str());
+      }
+    } else {
+      const bool transient_error =
+          IsTransientSecureDesktopFrameError(error_message);
+      const bool in_grace_period =
+          capture_stage_started_tick != 0 &&
+          now - capture_stage_started_tick < kSecureDesktopTransientErrorGraceMs;
+      const DWORD log_interval = transient_error
+                                     ? kSecureDesktopTransientErrorLogIntervalMs
+                                     : 1000;
+      if (transient_error && in_grace_period) {
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(frame_interval_ms));
+        continue;
+      }
+      if (now - last_error_tick >= log_interval) {
+      LOG_WARN(
+          "Windows capturer secure desktop frame query failed, stage='{}', session_id={}, error={}",
+          status.interactive_stage, status.active_session_id, error_message);
+      last_error_tick = now;
+      }
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(frame_interval_ms));
+  }
+
+  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
+}
+
 }  // namespace crossdesk

src/screen_capturer/windows/screen_capturer_win.h

@@ -7,8 +7,12 @@
 #ifndef _SCREEN_CAPTURER_WIN_H_
 #define _SCREEN_CAPTURER_WIN_H_
 
+#include <Windows.h>
+
+#include <atomic>
 #include <memory>
 #include <mutex>
+#include <thread>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -48,9 +52,20 @@ class ScreenCapturerWin : public ScreenCapturer {
   std::mutex alias_mutex_;
   std::vector<DisplayInfo> canonical_displays_;
   std::unordered_set<std::string> canonical_labels_;
+  std::atomic<bool> running_{false};
+  std::atomic<bool> paused_{false};
+  std::atomic<bool> show_cursor_{true};
+  std::atomic<int> monitor_index_{0};
+  int initial_monitor_index_ = 0;
+  std::atomic<bool> secure_desktop_capture_active_{false};
+  std::thread secure_capture_thread_;
 
   void BuildCanonicalFromImpl();
   void RebuildAliasesFromImpl();
+  void StopSecureCaptureThread();
+  void SecureDesktopCaptureLoop();
+  bool GetCurrentCaptureRegion(int* left, int* top, int* width, int* height,
+                               std::string* display_name);
 };
 }  // namespace crossdesk
 #endif

src/service/windows/interactive_state.h

@@ -0,0 +1,35 @@
+#ifndef _CROSSDESK_INTERACTIVE_STATE_H_
+#define _CROSSDESK_INTERACTIVE_STATE_H_
+
+#include <string>
+
+namespace crossdesk {
+
+inline bool IsSecureDesktopInteractionRequired(
+    const std::string& interactive_stage) {
+  return interactive_stage == "credential-ui" ||
+         interactive_stage == "secure-desktop";
+}
+
+inline bool ShouldNormalizeUnlockToUserDesktop(
+    bool interactive_lock_screen_visible,
+    const std::string& interactive_stage, bool session_locked,
+    bool interactive_logon_ui_visible, bool interactive_secure_desktop_active,
+    bool credential_ui_visible, bool password_box_visible,
+    bool unlock_ui_visible, const std::string& last_session_event) {
+  if (!interactive_lock_screen_visible && interactive_stage != "lock-screen") {
+    return false;
+  }
+
+  if (session_locked || interactive_logon_ui_visible ||
+      interactive_secure_desktop_active || credential_ui_visible ||
+      password_box_visible || unlock_ui_visible) {
+    return false;
+  }
+
+  return last_session_event != "session-lock";
+}
+
+}  // namespace crossdesk
+
+#endif

src/service/windows/main.cpp

@@ -0,0 +1,87 @@
+#include <Windows.h>
+
+#include <iostream>
+#include <string>
+
+#include "service_host.h"
+
+namespace {
+
+std::wstring GetExecutablePath() {
+  wchar_t path[MAX_PATH] = {0};
+  DWORD length = GetModuleFileNameW(nullptr, path, MAX_PATH);
+  if (length == 0 || length >= MAX_PATH) {
+    return L"";
+  }
+  return std::wstring(path, length);
+}
+
+void PrintUsage() {
+  std::cout << "CrossDesk Windows service skeleton\n"
+            << "  --service    Run under the Windows Service Control Manager\n"
+            << "  --console    Run the service loop in console mode\n"
+            << "  --install    Install the service for the current executable\n"
+            << "  --uninstall  Remove the installed service\n"
+            << "  --start      Start the installed service\n"
+            << "  --stop       Stop the installed service\n"
+            << "  --sas        Ask the service to send Secure Attention Sequence\n"
+            << "  --ping       Ping the running service over named pipe IPC\n"
+            << "  --status     Query runtime status over named pipe IPC\n";
+}
+
+}  // namespace
+
+int main(int argc, char* argv[]) {
+  crossdesk::CrossDeskServiceHost host;
+
+  if (argc <= 1) {
+    PrintUsage();
+    return 0;
+  }
+
+  std::string command = argv[1];
+  if (command == "--service") {
+    return host.RunAsService();
+  }
+  if (command == "--console") {
+    return host.RunInConsole();
+  }
+  if (command == "--install") {
+    std::wstring executable_path = GetExecutablePath();
+    bool success = !executable_path.empty() &&
+                   crossdesk::InstallCrossDeskService(executable_path);
+    std::cout << (success ? "install ok" : "install failed") << std::endl;
+    return success ? 0 : 1;
+  }
+  if (command == "--uninstall") {
+    bool success = crossdesk::UninstallCrossDeskService();
+    std::cout << (success ? "uninstall ok" : "uninstall failed")
+              << std::endl;
+    return success ? 0 : 1;
+  }
+  if (command == "--start") {
+    bool success = crossdesk::StartCrossDeskService();
+    std::cout << (success ? "start ok" : "start failed") << std::endl;
+    return success ? 0 : 1;
+  }
+  if (command == "--stop") {
+    bool success = crossdesk::StopCrossDeskService();
+    std::cout << (success ? "stop ok" : "stop failed") << std::endl;
+    return success ? 0 : 1;
+  }
+  if (command == "--sas") {
+    std::cout << crossdesk::QueryCrossDeskService("sas") << std::endl;
+    return 0;
+  }
+  if (command == "--ping") {
+    std::cout << crossdesk::QueryCrossDeskService("ping") << std::endl;
+    return 0;
+  }
+  if (command == "--status") {
+    std::cout << crossdesk::QueryCrossDeskService("status") << std::endl;
+    return 0;
+  }
+
+  PrintUsage();
+  return 1;
+}

src/service/windows/service_host.h

@@ -0,0 +1,141 @@
+#ifndef _CROSSDESK_SERVICE_HOST_H_
+#define _CROSSDESK_SERVICE_HOST_H_
+
+#include <Windows.h>
+
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace crossdesk {
+
+inline constexpr wchar_t kCrossDeskServiceName[] = L"CrossDeskService";
+inline constexpr wchar_t kCrossDeskServiceDisplayName[] =
+    L"CrossDesk Service";
+inline constexpr wchar_t kCrossDeskServicePipeName[] =
+    L"\\\\.\\pipe\\CrossDeskService";
+
+class CrossDeskServiceHost {
+ public:
+  CrossDeskServiceHost();
+  ~CrossDeskServiceHost();
+
+  int RunAsService();
+  int RunInConsole();
+
+ private:
+  int RunServiceLoop(bool as_service);
+  int InitializeRuntime();
+  void ShutdownRuntime();
+  void RequestStop();
+  void ReportServiceStatus(DWORD current_state, DWORD win32_exit_code,
+                           DWORD wait_hint);
+  void IpcServerLoop();
+  void RefreshSessionState();
+  void EnsureSessionHelper();
+  void ReapSessionHelper();
+  void StopSessionHelper();
+  bool LaunchSessionHelper(DWORD session_id);
+  void ReapSecureInputHelper();
+  void StopSecureInputHelper();
+  bool LaunchSecureInputHelper(DWORD session_id);
+  std::wstring GetSessionHelperPath() const;
+  std::wstring GetSessionHelperStopEventName(DWORD session_id) const;
+  std::wstring GetSecureInputHelperPath() const;
+  std::wstring GetSecureInputHelperStopEventName(DWORD session_id) const;
+  void ResetSessionHelperReportedStateLocked(const char* error,
+                                             DWORD error_code);
+  bool GetEffectiveSessionLockedLocked() const;
+  bool IsHelperReportingLockScreenLocked() const;
+  bool HasSecureInputUiLocked() const;
+  bool ShouldKeepSecureInputHelperLocked(DWORD target_session_id) const;
+  void RefreshSessionHelperReportedState();
+  void RecordSessionEvent(DWORD event_type, DWORD session_id);
+  std::string HandleIpcCommand(const std::string& command);
+  std::string BuildStatusResponse();
+  std::string SendSecureAttentionSequence();
+  std::string SendSecureDesktopKeyboardInput(int key_code, bool is_down);
+
+  static void WINAPI ServiceMain(DWORD argc, LPWSTR* argv);
+  static BOOL WINAPI ConsoleControlHandler(DWORD control_type);
+  static DWORD WINAPI ServiceControlHandler(DWORD control, DWORD event_type,
+                                            LPVOID event_data,
+                                            LPVOID context);
+
+ private:
+  SERVICE_STATUS_HANDLE status_handle_ = nullptr;
+  SERVICE_STATUS service_status_{};
+  HANDLE stop_event_ = nullptr;
+  std::thread ipc_thread_;
+  std::mutex state_mutex_;
+  DWORD active_session_id_ = 0xFFFFFFFF;
+  DWORD process_session_id_ = 0xFFFFFFFF;
+  DWORD input_desktop_error_code_ = 0;
+  DWORD session_helper_process_id_ = 0;
+  DWORD session_helper_session_id_ = 0xFFFFFFFF;
+  DWORD session_helper_exit_code_ = 0;
+  DWORD session_helper_last_error_code_ = 0;
+  DWORD session_helper_status_error_code_ = 0;
+  DWORD session_helper_report_session_id_ = 0xFFFFFFFF;
+  DWORD session_helper_report_process_id_ = 0;
+  DWORD session_helper_report_input_desktop_error_code_ = 0;
+  DWORD secure_input_helper_process_id_ = 0;
+  DWORD secure_input_helper_session_id_ = 0xFFFFFFFF;
+  DWORD secure_input_helper_exit_code_ = 0;
+  DWORD secure_input_helper_last_error_code_ = 0;
+  DWORD last_session_event_type_ = 0;
+  DWORD last_session_event_session_id_ = 0xFFFFFFFF;
+  ULONGLONG started_at_tick_ = 0;
+  ULONGLONG last_sas_tick_ = 0;
+  ULONGLONG session_helper_started_at_tick_ = 0;
+  ULONGLONG session_helper_report_state_age_ms_ = 0;
+  ULONGLONG session_helper_report_uptime_ms_ = 0;
+  ULONGLONG secure_input_helper_started_at_tick_ = 0;
+  bool session_locked_ = false;
+  bool logon_ui_visible_ = false;
+  bool prelogin_ = false;
+  bool secure_desktop_active_ = false;
+  bool input_desktop_available_ = false;
+  bool session_helper_running_ = false;
+  bool session_helper_status_ok_ = false;
+    bool session_helper_report_session_locked_ = false;
+  bool session_helper_report_input_desktop_available_ = false;
+  bool session_helper_report_lock_app_visible_ = false;
+  bool session_helper_report_logon_ui_visible_ = false;
+  bool session_helper_report_secure_desktop_active_ = false;
+  bool session_helper_report_credential_ui_visible_ = false;
+  bool session_helper_report_unlock_ui_visible_ = false;
+  bool secure_input_helper_running_ = false;
+  bool console_mode_ = false;
+  DWORD last_sas_error_code_ = 0;
+  bool last_sas_success_ = false;
+  HANDLE session_helper_process_handle_ = nullptr;
+  HANDLE session_helper_stop_event_ = nullptr;
+  HANDLE secure_input_helper_process_handle_ = nullptr;
+  HANDLE secure_input_helper_stop_event_ = nullptr;
+  std::string input_desktop_name_;
+  std::string last_sas_error_;
+  std::string session_helper_last_error_;
+  std::string session_helper_status_error_;
+  std::string session_helper_report_input_desktop_;
+  std::string session_helper_report_interactive_stage_;
+  std::string secure_input_helper_last_error_;
+
+  static CrossDeskServiceHost* instance_;
+};
+
+bool InstallCrossDeskService(const std::wstring& binary_path);
+bool UninstallCrossDeskService();
+bool StartCrossDeskService();
+bool StopCrossDeskService(DWORD timeout_ms = 5000);
+std::string QueryCrossDeskService(const std::string& command,
+                                  DWORD timeout_ms = 1000);
+std::string SendCrossDeskSecureDesktopKeyInput(int key_code, bool is_down,
+                                               DWORD timeout_ms = 1000);
+std::string SendCrossDeskSecureDesktopMouseInput(int x, int y, int wheel,
+                                                 int flag,
+                                                 DWORD timeout_ms = 1000);
+
+}  // namespace crossdesk
+
+#endif

src/service/windows/session_helper_shared.h

@@ -0,0 +1,51 @@
+#ifndef _CROSSDESK_SESSION_HELPER_SHARED_H_
+#define _CROSSDESK_SESSION_HELPER_SHARED_H_
+
+#include <Windows.h>
+
+#include <cstdint>
+#include <string>
+
+namespace crossdesk {
+
+inline constexpr wchar_t kCrossDeskSessionHelperPipePrefix[] =
+    L"\\\\.\\pipe\\CrossDeskSessionHelper-";
+inline constexpr wchar_t kCrossDeskSecureInputHelperPipePrefix[] =
+  L"\\\\.\\pipe\\CrossDeskSecureInputHelper-";
+inline constexpr char kCrossDeskSessionHelperStatusCommand[] = "status";
+inline constexpr char kCrossDeskSecureInputKeyboardCommandPrefix[] =
+  "keyboard:";
+inline constexpr char kCrossDeskSecureInputMouseCommandPrefix[] =
+  "mouse:";
+inline constexpr char kCrossDeskSecureInputCaptureCommandPrefix[] =
+    "capture:";
+inline constexpr DWORD kCrossDeskSecureInputPipeBufferBytes =
+    16 * 1024 * 1024;
+inline constexpr uint32_t kCrossDeskSecureDesktopFrameMagic = 0x50444358;
+inline constexpr uint32_t kCrossDeskSecureDesktopFrameVersion = 1;
+
+#pragma pack(push, 1)
+struct CrossDeskSecureDesktopFrameHeader {
+  uint32_t magic;
+  uint32_t version;
+  int32_t left;
+  int32_t top;
+  uint32_t width;
+  uint32_t height;
+  uint32_t payload_size;
+};
+#pragma pack(pop)
+
+inline std::wstring GetCrossDeskSessionHelperPipeName(DWORD session_id) {
+  return std::wstring(kCrossDeskSessionHelperPipePrefix) +
+         std::to_wstring(session_id);
+}
+
+inline std::wstring GetCrossDeskSecureInputHelperPipeName(DWORD session_id) {
+  return std::wstring(kCrossDeskSecureInputHelperPipePrefix) +
+     std::to_wstring(session_id);
+}
+
+}  // namespace crossdesk
+
+#endif

xmake/targets.lua

@@ -34,7 +34,8 @@ function setup_targets()
             add_files("src/screen_capturer/windows/screen_capturer_dxgi.cpp",
                 "src/screen_capturer/windows/screen_capturer_gdi.cpp",
                 "src/screen_capturer/windows/screen_capturer_win.cpp")
-            add_includedirs("src/screen_capturer/windows", {public = true})
+            add_includedirs("src/screen_capturer/windows", "src/service/windows",
+                {public = true})
         elseif is_os("macosx") then
             add_files("src/screen_capturer/macosx/*.cpp",
                 "src/screen_capturer/macosx/*.mm")
@@ -146,7 +147,8 @@ function setup_targets()
             "src/gui/windows", {public = true})
         if is_os("windows") then
             add_files("src/gui/tray/*.cpp")
-            add_includedirs("src/gui/tray", {public = true})
+            add_includedirs("src/gui/tray", "src/service/windows",
+                {public = true})
         elseif is_os("macosx") then
             add_files("src/gui/windows/*.mm")
         end
@@ -163,6 +165,22 @@ function setup_targets()
                 "src/screen_capturer/windows/wgc_plugin_entry.cpp")
             add_includedirs("src/common", "src/screen_capturer",
                 "src/screen_capturer/windows")
+
+        target("crossdesk_service")
+            set_kind("binary")
+            add_deps("rd_log", "path_manager")
+            add_links("Advapi32", "Wtsapi32", "Ole32", "Userenv")
+            add_files("src/service/windows/main.cpp",
+                "src/service/windows/service_host.cpp")
+            add_includedirs("src/service/windows", {public = true})
+
+        target("crossdesk_session_helper")
+            set_kind("binary")
+            add_packages("libyuv")
+            add_deps("rd_log", "path_manager")
+            add_links("Advapi32", "User32", "Wtsapi32", "Gdi32")
+            add_files("src/service/windows/session_helper_main.cpp")
+            add_includedirs("src/service/windows", {public = true})
     end
 
     target("crossdesk")
@@ -171,6 +189,9 @@ function setup_targets()
         add_files("src/app/*.cpp")
         add_includedirs("src/app", {public = true})
         if is_os("windows") then
+            add_files("src/service/windows/service_host.cpp")
+            add_includedirs("src/service/windows", {public = true})
+            add_links("Advapi32", "Wtsapi32", "Ole32", "Userenv")
             add_deps("wgc_plugin")
             add_files("scripts/windows/crossdesk.rc")
         end