The Go server answered TOKEN_HEARTBEAT with a 33-byte CMD_HEARTBEAT_ACK,
while the Linux and Android clients gate the ACK on 1 + sizeof(HeartbeatACK)
(1025 bytes) and silently drop anything shorter. Their application-level ACK
watchdog therefore never got fed and disconnected the main connection every
60s. Each re-login replaced the whole hub.Device, wiping the screen/shell
sub-conn bindings that ride their own TCP connections, so a web terminal kept
receiving shell output while every keystroke was dropped — the "terminal goes
unresponsive after a while" symptom — and the shell could no longer be torn
down (orphan bash + leaked sockets).
Clients now accept the 32-byte old ACK (Windows already did), and the server
sends the full 1024-byte struct. Hub.Register carries the sub-conn session
state across a re-login, and the disconnect cleanup is pinned to the
connection it belongs to so a stale OnDisconnect cannot tear down a
registration that has already replaced it. A shell sub-conn that can no
longer be bound now tells the viewer instead of leaving the pane waiting.
Verified on aa: RTT restored, zero "Heartbeat ACK timeout" lines, main-conn
port stable; Go build/vet/test pass. Server deploy to the Go host is still
pending, so un-upgraded clients will keep reconnecting until then.
Co-Authored-By: deepseek-flash
remote_block_input rejected anything but Windows because the Android
client had no COMMAND_SCREEN_BLOCK_INPUT handler. This adds the overlay
on the client and the server gating, and wires up COMMAND_SCREEN_BLANK.
Client: the accessibility service hangs a full-screen
TYPE_ACCESSIBILITY_OVERLAY on itself. block=true makes it transparent
and touchable so it swallows physical taps; black=true paints it black.
Both are absolute states, so repeated commands are idempotent, and the
handler clears the overlay when the screen sub-connection dies (Android
has no "released when the calling thread exits" fallback). During a
remote gesture the overlay is flipped to FLAG_NOT_TOUCHABLE, mirroring
Windows' BlockInput(false) wrap; the flag change and the injection must
be separated by a short delay or the gesture is swallowed.
Server: CLIENT_CAP_PRIVACY_OVERLAY distinguishes new APKs from old ones;
Linux/macOS and old APKs still get -32005 up front. Tool masks,
instructions and mcp/tools.json follow the change. COMMAND_SCREEN_BLANK
is implemented but not exposed as a tool: MediaProjection captures the
overlay, so blacking out the screen blinds the operator too and cannot
emulate Windows' WDA_EXCLUDEFROMCAPTURE.
Verified on the Android 15 emulator: blocked taps are swallowed while
remote clicks still land, the block re-arms after each gesture, the
watchdog auto-unblocks at the deadline, a dropped sub-connection clears
the overlay, and a black overlay shows up in both screencap and
get_screenshot. The committed ghost.apk is stale; rebuild before release.
Co-Authored-By: deepseek-flash
The terminal tools were Windows/Linux only because the Android client had
no COMMAND_SHELL handler: the server opened a shell sub-connection and
the command was silently dropped, leaving exec_command to time out. This
adds the PTY path on the client and the matching server gating.
Client: COMMAND_SHELL on the main connection spawns a terminal thread
that opens an authenticated sub-connection, sends TOKEN_TERMINAL_START
and keeps the PTY alive until the server closes it. common/PTYHandler.h
is reused, with a minSdk-21 openpty built from posix_openpt/grantpt and
/system/bin/sh (mksh) as the shell. A new CLIENT_CAP_TERMINAL bit lets
the server reject old APKs up front with -32005.
Server: the tool masks, instructions and docs matrix accept APK. While
verifying, exec_command left a second echoed copy of the command line in
stdout: mksh forks with ECHO still on, so input written before its line
editor takes over is echoed by the line discipline in addition to the
shell's own redraw. The server now waits for the shell's first output
(the prompt) before sending the command and sentinel, which restores the
single-echo assumption the cleaning step relies on. terminal_exec on a
ready session is unaffected.
Verified on the Android 15 emulator: exec_command returns clean stdout
and real exit codes for id/uname/df/ls (including a failing command),
and terminal_open keeps cwd across commands, pipes work and close is
clean. The committed ghost.apk is stale and must be rebuilt before
release; a rebuilt APK was used for this testing.
Co-Authored-By: deepseek-flash
The chat tools were Windows-only because the Android client had no
COMMAND_CHAT handler: the server asked for a chat sub-connection and the
command was silently dropped, leaving chat_open to time out. This adds
the full path on the client and the matching server gating.
Client: COMMAND_CHAT on the main connection spawns a chat thread that
opens an authenticated sub-connection, sends TOKEN_CHAT_START and waits
for the server to bind it. Incoming GBK lines are decoded and dispatched
to ChatSession, which drives an in-app chat activity; when accessibility
is available the activity is pulled to the front, otherwise a tappable
notification is posted. Outgoing text is strictly GBK encoded so emoji
and unmappable characters are rejected instead of becoming '?'. When the
server ends the session the activity closes itself, matching the Windows
client's DestroyWindow, and a new session starts from an empty log.
Server: a new CLIENT_CAP_REMOTE_CHAT bit lets the server tell new APKs
from old ones. ResolveHost now accepts Windows and Android hosts and
rejects older APKs up front with -32005 rather than waiting for the
command to expire. Tool platform masks, instructions, the docs matrix
and mcp/tools.json follow the same change.
Verified end to end on the Android 15 emulator: chat_open pops the
activity, Chinese text from the server renders, a device reply reaches
chat_wait, and ending the session from the master closes the activity
instead of leaving a dead window. The committed ghost.apk is stale and
must be rebuilt before release.
Co-Authored-By: deepseek-flash
WaitChatMessages decided overtime after the drain loop had already
emptied the session inbox. Whenever a reply arrived during the wait the
loop moved every queued message into the result and then evaluated
timed_out on the now-empty queue, so a successful wait was still
reported as a timeout. Callers that key off timed_out would either
retry needlessly or treat the answer as noise.
The arrival state is now captured before draining and the deadline flag
is computed from that snapshot. A wait that returns messages is never
marked timed out, while an empty wait still reports timed_out so the
caller can distinguish silence from a closed session.
Verified end to end against the Android emulator over the MCP debug
endpoint: after a device reply chat_wait returned one message with
timed_out=false, and a follow-up wait on the empty inbox returned
timed_out=true, preventing a regression in the other direction.
Co-Authored-By: deepseek-flash
The server's "uninstall host" action is the single-byte TOKEN_UNINSTALL on
the main connection. Windows clients have handled it for a long time; the
Android client ignored it, so the menu entry silently did nothing there.
Handle it in the Android client the only way Android allows: ask the
system to uninstall the package. The client first replies with COMMAND_BYE
and drops the connection, then opens the package installer's confirmation
dialog through the accessibility service, or posts a notification that
resumes the dialog from MainActivity when accessibility is off. The user
still has to confirm on the device; if they cancel, the client has already
left the server and must be reopened by hand. The manifest gains
REQUEST_DELETE_PACKAGES, without which the installer activity refuses the
request outright.
New APKs advertise CLIENT_CAP_UNINSTALL so the server can reject old
clients instead of sending a command nobody handles. The new MCP tool
uninstall_host is gated on McpManage and McpReadonly=0, rejects Linux and
macOS hosts, and offers the same wait=true verification as power_action,
reporting went_offline once the host disappears from the online list.
Verified on the emulator end to end: the tool returned went_offline after
200 ms, the system dialog appeared, confirming it removed the package.
Co-Authored-By: deepseek-flash
Implement the Ctrl+Alt+Del path on Android as a system lock screen.
Android has no secure attention sequence, so COMMAND_SCREEN_CTRL_ALT_DEL
is mapped in the client to GLOBAL_ACTION_LOCK_SCREEN and the server
exposes it as the new MCP tool remote_lock_screen.
The Android client resolves ControlService.lockScreen()/canLockScreen()
in nativeInit and dispatches the command from the screen sub-connection
through the usual attach/detach JNI path. The lock action is posted to
the accessibility service handler because performGlobalAction must not
run on the receiver thread.
Login advertises the new CLIENT_CAP_LOCK_SCREEN bit only when the
accessibility service is bound and the API level is 28+, so the server
can reject old APKs and Windows/Linux hosts up front instead of
reporting a lock that never happened. There is no receipt: a successful
call only means the command was delivered, and the tool description
tells the caller to confirm with get_screenshot.
Server side adds the schema and handler next to remote_clipboard, audits
the call, and gates it on client type plus the capability bit. Since it
is the only APK-only tool, check_platform_table.py gains a documented
exemption from the Windows baseline invariant, and make_tools_json.py
learns an APK-only platform set. tools.json is regenerated from the live
server and the plan document now counts 62 tools.
Co-Authored-By: deepseek-flash
The MCP remote-control family (remote_open / remote_close / remote_mouse /
remote_keyboard / remote_clipboard) previously stopped at Windows and Linux,
even though the Android client already translated injected events into touch
gestures and global actions. This wires up the missing piece and opens the five
tools to APK hosts.
Client side, the screen sub-connection now handles COMMAND_SCREEN_SET_CLIPBOARD:
the native handler forwards the raw GBK bytes to CaptureService.onClipboardText,
which decodes them, strips the trailing NUL that the human clipboard-sync
senders append, and writes the system clipboard from a background app (allowed
on Android 10+, only reads are restricted). Pasting cannot be a Ctrl+V combo,
so VK_V is mapped to ACTION_PASTE on the focused node, falling back to the
accessibility focus and then to the first editable node, since WebView and
self-drawn inputs often do not flag FOCUS_INPUT or isEditable.
A new capability bit CLIENT_CAP_SCREEN_CLIPBOARD (0x0800) tells the server the
APK understands both paths, so builds without the handler get an explicit
-32005 instead of a package that is silently dropped. action=type is rejected
outright for APK hosts - physical key events would only turn 'v' into a paste -
and the error points at remote_clipboard + key=V.
The platform table, server instructions and the five tool descriptions now
describe Android support, which keys actually act as global actions (ESC, HOME,
APPS, PRINTSCREEN), and that injection needs the accessibility service while
capture needs an authorized MediaProjection session, both without receipts.
Verified on the API 35 emulator against a Debug server: ASCII and GBK Chinese
text round-tripped through the clipboard into a focused Settings search field,
type / expect_hwnd / window_hwnd returned -32005, and PRINTSCREEN produced a
saved screenshot. check_platform_table.py and verify_tools.py --offline pass.
Co-Authored-By: deepseek-flash
get_screenshot and the server's online-list and hover thumbnails were
gated to Windows and X11 Linux. The Android client now answers
COMMAND_SCREEN_PREVIEW_REQ on the main connection with
TOKEN_SCREEN_PREVIEW_RSP plus a JPEG, and advertises
CLIENT_CAP_SCREEN_PREVIEW at login only when it can really capture.
Capture goes through AccessibilityService.takeScreenshot (API 30+),
enabled by canTakeScreenshot in the service config. MediaProjection is
deliberately not reused: its VirtualDisplay already feeds the H.264
encoder and Android 14+ refuses a second one from the same projection,
while accessibility capture runs alongside the live stream. The JPEG is
scaled to maxWidth and encoded in Kotlin; native only copies the bytes
and drops a request while one is in flight. Only mode=screen is
supported, and capabilities are re-evaluated on every login so turning
the service off withdraws the capability.
Also fix two review findings: a screenshot callback that lands after
the 3 s timeout now recycles its bitmap instead of leaking it, and the
server's failure hint lists the possible Android causes instead of
asserting disabled accessibility.
Verified on the emulator against a local debug server: get_screenshot
returns 640x1422 and 720x1600 JPEGs, the 120-wide list thumbnail works,
and both MCP tool-table checkers pass with apk added for get_screenshot,
get_activity_history and get_client_log.
Co-Authored-By: deepseek-flash
RecalcLayoutAndResize only clamped the window position, so a portrait
capture (an Android phone's 1080x2400 arrives as 480x1067 at the desktop
default width) plus the info text made a tip taller than the screen,
with its bottom half off it.
The tip now also shrinks the image to the work area's height and width
budget before placing the window. Text wraps to the image width, so the
measurement is redone after each pass; two passes are enough because
every pass only shrinks.
Verified with the emulator's 1080x2400 client against a local debug
server: the tip is 521x1016 inside a 1920x1032 work area and the image
kept its portrait aspect.
Co-Authored-By: deepseek-flash
get_activity_history was gated to Windows and Linux. The Android client
now answers COMMAND_QUERY_ACTIVITY with a TOKEN_REPORT_ACTIVITY snapshot
on the main connection, the same RPC shape as the other platforms; the
server takes the first packet without CancelIO, so no sub-connection or
request correlation is involved.
The sampler reuses linux/LinuxActivityHistory.h, whose ActivityHistory
class and formatters are platform-neutral, and is fed by a probe that
asks the new ControlService.currentActivityTitle() once per second over
JNI. The accessibility service already tracks the foreground package
from TYPE_WINDOW_STATE_CHANGED; the title is "label (package)" with the
label resolved once and cached, "Home" for the launcher, and idle for
lock or screen-off, so no permission beyond the service users already
enable is needed. Without the service the report says so instead of
recording placeholder "Android" entries.
Also scope the connection teardown to its own generation: a
ConnectionThread that exits late (CaptureService restart) no longer
clears the new run's g_running or g_pMainClient, and the report thread
takes one local snapshot of the main client pointer.
Verified on the emulator against a local debug server: five records
(Settings, Chrome, launcher, Home) came back newest-first with dwell
times, and disabling accessibility produced the permission hint.
Co-Authored-By: deepseek-flash
Before this change the Android client's run log went to logcat only:
Logger's init tried to create a log directory, enable was true, and the
in-memory ring that MCP's get_client_log reads was never fed, so the
tool returned an empty log for APK hosts.
Logger now has an Android branch that skips the directory and file writer
and keeps only the ring, which is always written regardless of enable.
Mprintf carries the source file and line as on Windows/Linux, and both
android_log (Mprintf) and a new android_log_tag (platform LOGI/LOGE,
LOGI_SH/LOGE_SH) print to logcat and append to the ring.
A new ClientLogThread opens a sub-connection on COMMAND_QUERY_LOG and
lets ClientLogHandler send TOKEN_REPORT_LOG plus the full ring as the
first packet. It has to be a sub-connection: the server takes the first
packet and calls CancelIO, which would drop the main connection. The
server side allows get_client_log on kPlatApk and decodes the payload as
UTF-8 like the other POSIX clients.
Verified on the emulator against a local debug server: get_client_log
returned 21 UTF-8 lines including [file:line] Mprintf output, LOGI
lines, and the ClientLogThread handshake.
Co-Authored-By: deepseek-flash
The master now sends COMMAND_UPDATE to Android hosts: it picks a
"Build Client -> Android" APK, checks the ZIP magic and that the package
carries this master's fingerprint, then sends [cmd][size][APK][xxh64].
The client verifies length and hash, writes filesDir/update.apk and
commits a PackageInstaller session, so the system installer still asks
the user to confirm - an app cannot replace itself silently. Write and
hash failures come back over TOKEN_CLIENT_MSG, so the master sees why
nothing happened instead of a silently dropped packet.
Sending the wrong file is what the fingerprint check guards against: a
template without the master id installs fine and then cannot connect
back. "Send anyway" is offered only after spelling that out, and the
client advertises CLIENT_CAP_APK_UPDATE (0x0400) so an old APK gets
"install a new build once by hand" instead of a packet it would discard.
Also report the real versionName/versionCode at login instead of the
hardcoded v1.0.0, add android/tools/verify_update_apk.py (pre-send check
of size, ZIP_STORED libs, ABI, package, versionCode and the decrypted
CONNECT_ADDRESS, which it still locates after BuildDlg rewrote szFlag),
and translate the nine new strings in en_US, zh_TW and de_DE.
Verified on the emulator and against the live release server: generate,
sign, send, install, and the device reconnects and re-grants screen
capture. Language packs are GBK and were appended as bytes.
Co-Authored-By: deepseek-flash
Pass the target HWND through the COMMAND_SCREEN_SPY token and send
COMMAND_SCREEN_ROI after session start, so MCP remote control can stream
just the target window or region instead of the scaled virtual desktop.
The session records the target kind, remote_mouse refuses a redundant
window_hwnd basis, and the cached resolution is refreshed per action so
resized windows keep mapping correctly. Cold starts now clear the stale
resolution cache used by the region handshake.
New Windows clients append an optional 20-byte WINDOWINFO_MCP_DESKTOP block
(virtual desktop rect, magic 'VDCP') after the window list, so the server can
map window-relative coordinates into the capture frame. remote_mouse accepts
an optional window_hwnd; x/y and drag x2/y2 are then normalized against the
intersection of the window and the virtual desktop, which is exactly the
source rect of get_screenshot mode=window. The target window must be foreground
by default, and window_hwnd/expect_hwnd must agree when both are given.
structuredContent gains coordinateWindow and resolved (frame coords plus the
basis rect), so callers can verify the mapping.
terminal_exec now allows pipes, && and || in PTY sessions (ConPTY on Windows,
POSIX PTY on Linux) because the sentinel runs on its own line; legacy non-PTY
sessions still reject & and |. A read-only PeekTermSession lets the server
reject unsupported syntax before BeginTermCommand. POSIX still rejects bare
background & (&&, &>, 2>&1 stay allowed).
Docs: Mcp_Design.md sections 12.1/20.2/22 and Mcp_Terminal_Design.md 4.4/4.6
are synchronized with the protocol, the new validation order, and the basis
rect semantics.
Co-Authored-By: deepseek-flash
New Windows clients advertise CLIENT_CAP_SCREEN_REGION and accept a 24-byte
ScreenPreviewReqEx appended to the existing 8-byte preview request, so
get_screenshot can capture a region, a window or a single monitor at 1:1
resolution instead of only the scaled virtual desktop. Successful v2
responses append an optional ScreenCaptureMeta block reporting the source
rect and scale, letting callers map coordinates back for remote input.
Old clients and old servers keep the v1 byte stream unchanged.
The 8192 px per-side bound only applies to native (1:1) capture, where it
guards bitmap memory; scaled captures are unaffected so ultra-wide virtual
desktops (for example triple 4K) still produce thumbnails and previews.
max_width is clamped to [64,1920] as before instead of rejected, matching
the documented schema.
Co-Authored-By: deepseek-flash
Add a capability-gated main-connection RPC (COMMAND_MCP_WINDOW_INFO=179 /
TOKEN_MCP_WINDOW_INFO=180) that returns visible top-level windows with UTF-8
titles, screen rectangles, foreground flag and z-order, so MCP can verify
focus before injecting input. New tool get_foreground_window; host_list_windows
switches to the richer fields; host_control_window and operate_window gain
action=activate; remote_keyboard and remote_mouse gain expect_hwnd,
require_foreground and report_foreground. Old clients keep the previous
behavior: the RPC is refused up front via CLIENT_CAP_WINDOW_INFO.
The client caps a response at 96 windows (about 101 KB, under MAX_SEND_BUFFER).
Signal the cut-off in the mode byte (0x80) instead of silently dropping windows:
host_list_windows now reports truncated=true and says the list is incomplete,
and activate verification reports state=unknown with reason=list_truncated
rather than claiming the window is gone. expect_hwnd is checked only after the
session is validated, so an invalid session_id no longer burns a window RPC and
no longer reports a window error for a session that does not exist. Nullable
output fields (foreground, window) are declared as ["object","null"] so strict
clients do not reject responses.
Co-Authored-By: deepseek-flash
Hidden web/MCP screen sessions never receive TOKEN_FIRSTSCREEN and never run
the local decode path, so m_bIsFirst stayed TRUE and every keyframe or scroll
frame after a resolution change was dropped, leaving the browser black. The
same black screen appears whenever the client runs a non-H.264 quality level
(Ultra/DIFF, High/RGB565): DrawNextScreenDiff forwards to the web only inside
the ALGORITHM_H264 branches while the MFC window renders every algorithm, and
the existing web clamp cannot run in fixed-level mode because EvaluateQuality
returns early when adaptive quality is disabled.
Clear m_bIsFirst once an IDR decodes and forward keyframe/nextscreen frames
for hidden web sessions. Clamp web sessions to QUALITY_GOOD in OnInitDialog,
re-push the level when the client reports a lower one in BITMAPINFO, and nudge
a flapping client back to H.264 at most three times. The browser now receives
stream_algorithm/web_supported notices and shows an explicit hint in both the
focus view and the wall instead of a silent black frame. Resolution-change
recovery moved into OnTimer(4) so hidden sessions flush the decoder and request
a fresh IDR too.
Also bound the client-supplied block offsets and scroll parameters in the
DIFF/GRAY/RGB565 decoders, which could otherwise write outside the destination
DIB, and share one keyframe-request throttle between the resolution path and
the web console. Verified with a Debug x64 server build and node --check on the
page script; the Go server does not emit the new notices yet and degrades to
the old behavior.
Co-Authored-By: deepseek-flash
The MCP Observe/Act loop requires screenshots and mouse injection to share
one coordinate space. Previously the client sent only the primary monitor
while injection used virtual-desktop coordinates, so multi-monitor hosts
were rejected outright.
- Client: COMMAND_SCREEN_SPY param buffer[11] (wire index 12) now forces
whole-virtual-desktop GDI capture; preview JPEGs also cover the virtual
desktop including negative origins.
- Server: advertise CLIENT_CAP_VIRTUAL_DESKTOP, gate multi-monitor remote
control on that capability, and pass the flag when starting the session.
Linux stays exempt (X root capture/injection are already consistent).
A browser or native controller can lose a keyup (window blur, tab switch,
browser shortcut, in-app dialog, disconnect). The remote OS then keeps
Ctrl/Shift/Alt down, later keystrokes turn into shortcuts, and only
pressing the modifier again clears it.
The web console now tracks the keys it sent down and releases them on
blur, visibilitychange, pagehide, dialog, control off, device switch and
disconnect; the next keydown/mousedown/wheel reconciles tracked modifiers
against the event's real modifier state. Keys held when the socket drops
are stashed and released once the screen session is confirmed after
reconnect, tagged with the device so they never reach another host. The
Ctrl+V bridge flag is reset wherever its physical keyup can be lost.
The Windows client tracks injected keys by VK + scan code + extended bit
so right-hand modifiers release the key that was pressed, and releases
them on session teardown and reconnect; the Linux agent does the same
on teardown with XTestFakeKeyEvent.
Verified with a 20-scenario headless Chrome harness, group filter
regressions, node --check, go build/vet/test, a Debug client build and
the WSL Linux build. Not exercised against a real controller and host;
the macOS agent is unchanged.
Co-Authored-By: deepseek-flash
Operators running several groups had to scan the whole fleet. The device
list now has a group filter: desktop renders the groups as chips in the
Total row (click to toggle any number), while touch devices get a compact
dropdown with checkbox rows plus Clear/Done. An empty selection means
"all groups"; multiple selections are OR-ed and combined with the search
box. Hosts without a group appear as "Ungrouped".
Groups are derived from the current device snapshot (no admin-only
get_groups call, so restricted users can filter too), and the selection
persists in localStorage for the browser. The offered list follows the
Offline toggle, while a selected group whose devices are temporarily
gone stays visible with count 0 instead of being silently dropped.
Logout clears the selection so the next account does not inherit it.
The Wall view keeps its own search and is unchanged.
Verified in headless Chrome at desktop and phone widths: multi-select,
counts, dropdown open/close/clear, stale-selection retention, search
focus, long names and persistence across reloads. go build and
go test ./web/ pass.
Co-Authored-By: deepseek-flash
The "启动信息" elapsed time was computed by subtracting a client-formatted
wall-clock string from the master's own local time. Windows clients send their
local time, Linux/Android/macOS send Beijing time, so a host whose clock runs
ahead of the master (UTC+8 clients on a UTC+1 master, a fast CMOS clock) gave a
negative difference that was clamped to 0s — permanently, for that host.
Add RES_UPTIME to the login reserved list: the client reports its process
uptime in seconds, a difference between two readings of the same clock, so
timezone and clock skew cancel out. The master adds the connection's alive
time to get the current value, and keeps the old string path as the fallback
for clients that do not send the field. That fallback now also treats MAC as
Beijing time, which was simply missed.
AddReserved() now goes through one bounds-checked append. The separator used
to be written without any length check (an overflow aborts the client, which
installs no invalid parameter handler), and an over-long value now leaves an
empty slot instead of dropping its separator, so positional lookups cannot
shift.
Verified with an ASan/UBSan test over the encoding boundaries and Debug builds
of the client and the master. The Linux/Android/macOS clients only append the
same field at the end of the list; they were not compiled here.
Co-Authored-By: deepseek-flash
Implement COMMAND_QUERY_ACTIVITY -> TOKEN_REPORT_ACTIVITY with two backends
picked at startup. With a desktop, a sampler thread reads the foreground
window every second and books dwell time like the Windows client: under
five seconds is dropped, five idle minutes close the window, the last 500
records stay newest first, each line being "[YYYY-MM-DD HH:MM:SS] [title]
duration". It uses its own ActivityChecker because an Xlib connection
cannot be shared with the heartbeat thread, and it is stopped before main's
locals go away.
A reachable X server is not enough: the window backend is only chosen when
the root window carries _NET_SUPPORTING_WM_CHECK, so Xvfb or a bare X
without an EWMH window manager falls back to the headless backend instead
of sampling a window id that never appears.
Without a desktop the answer is computed on demand: logins from
"last -n 100 -F" plus bash/zsh history of root and /home/*, tagged [登录] or
[命令] after a [来源] header. Both halves are merged and sorted by
timestamp; three fifths of the budget goes to logins and reboot records are
capped at ten, since a WSL or container writes one reboot per start.
activity_commands=0 drops the command half.
A single detached thread builds and sends it, only while the main link is up.
The MCP gate now admits Linux for get_activity_history and documents both
shapes. test/unit/linux covers the parsers, ordering and UTF-8 truncation;
15 cases pass.
Co-Authored-By: deepseek-flash
The adaptive quality controller counted only complete frames per second, so when
a single frame took several seconds to arrive the sample was 0 fps and the
throughput criterion abstained forever: Ultra and High kept flipping while a
foreground video played. The audio watchdog had the opposite problem: it rebuilt
the WASAPI capture every three seconds on an idle endpoint, and its sleep
detector measured the whole loop including a blocking send.
Sample the last ten seconds in a ring buffer and feed the criterion a windowed
rate, guarded so a scroll burst, a stale window or a few KB clock patch is not
mistaken for congestion. Apply the same per-frame floor to the one-second
fallback and to the post-downgrade local-bottleneck probe. Normalize delayed
timer ticks by real elapsed milliseconds, and make the 40 second
upgrade-failure window outlast the resolution cooldown it has to cross.
On the client, rebuild only when an audio session is actually rendering, and
rebuild immediately when the captured endpoint is no longer the default output;
refresh the sleep timestamps on failed as well as successful init.
Tests cover the window and fallback helpers directly; the full suite passes
845/845, and both the Debug server and Debug client build.
Co-Authored-By: deepseek-flash
The address label was 81 dialog units wide at x=8 while the combo box
starts at 93, and the prompt set at runtime - an IP:PORT hint that also
mentions the optional wss:// prefix - is far wider than that. The static
clipped it at its edge, so the rest of the hint looked hidden behind the
input field; with the English or German translation almost the whole
sentence disappeared. The days label had the same 81-unit width.
Move both labels onto their own full-width rows above their controls
and shift the combo box, days field, checkbox and buttons down to fit.
The dialog grows from 105 to 128 units and the days field narrows from
201 to 80 units, so every translation stays on one line. The share
variant still hides the days row, leaving the same gap it had before.
The share and transfer dialogs share this template, so both are fixed.
Co-Authored-By: deepseek-flash
OnSize only refreshed the cached client rect, letterbox offsets and zoom
factors; it never asked for a repaint. Windows invalidates a window only
when the client area grows, so restoring a maximized viewer marks nothing
invalid. Since the dialog stops erasing its background after the first
frame and has no periodic repaint timer, the sole remaining repaint source
is a change on the remote screen. A static remote desktop therefore kept
the maximized picture - cropped, not following the window - until something
moved on the far end.
Call InvalidateRect(NULL, FALSE) at the end of OnSize whenever the client
area is non-empty, so every size change (restore, fullscreen transitions
and interactive resizing) recomputes the layout and repaints once. It is a
no-op while the window is hidden; CHideScreenSpyDlg::OnSize calls the base
handler, so it inherits the same behaviour.
Verified on a Debug build against a live test client: the maximized client
(1920x1009) renders 63/64 px side bars and the restored one (717x355) 43/43
px, matching ComputeAdaptiveLayout (renderW=631, offsetX=43).
Co-Authored-By: deepseek-flash
With the toolbar unpinned, CheckMousePosition() runs from the full-screen
timer every 50ms and slides the bar out once the cursor leaves the edge
band. The quality menu drops from the button's bottom edge, so its first
item already sits past the monTop + m_nHeight + 10 threshold: the bar
retracted the moment the user moved onto the menu, taking the menu with it.
A m_bMenuOpen flag now suspends the retract decision while TrackPopupMenu
is running. The menu's modal loop still dispatches the parent's WM_TIMER,
so without this the bar animates away under it. The flag is set and cleared
around the call, so behaviour is unchanged once the menu closes or is
dismissed with Esc.
Only the quality menu opens a popup, so nothing else needed the flag.
Verified: debug server build, 0 errors, ToolbarDlg.cpp rebuilt. UI not
exercised.
Four items from a user-side review of the master. The common thread: the UI
now says what it is about to do instead of leaving the user to guess.
Confirm boxes. Logout, restart, shutdown, delete host and uninstall client
all asked "are you sure" without naming the action or the hosts, so a
multi-selection could not be checked. DescribeTargetHosts() lists
"note (or computer name) (ip)" capped at five lines, and the default button
is No. The preview is dropped before the modal box and targets are
re-resolved after it, since the list can reshuffle in between.
Screen modes. High Speed / Ultra Speed became High Quality (DXGI +
differential: lossless, bandwidth hungry) and Smooth (GDI + H264: lossy,
cheap). TranslateMenu looks menus up by displayed text, so the .rc entries,
the FeatureLimitsDlg item names and the language pack keys changed together.
Host filter. The Ctrl+F bar was find-next; it now filters as you type over
IP, location, note, OS and version, and Esc clears the filter. The status
line reads "filtered: N / M total" while active. Commands still resolve by
clientID and m_FilteredIndices still maps row to m_HostList index, so no
command path changes. SearchBarDlg drops from 446 to 312 lines.
Quality changes. The adaptive level now shows its reason for twenty seconds
("Good (high latency)") instead of silently changing. The full-screen info
bar was a fixed 170px, so that reason was clipped; the width is now measured
from the text with the same font that paints it, 170 becoming the floor and
16px quantisation so changing digits do not jitter the window. Cosmetic
only: no threshold, hysteresis, cooldown or lock-out logic is touched.
Verified: debug server build, 0 errors; new strings present in .res and in
the exe. UI not exercised - the debug master would fight the running release
master for the listening port in Bin/settings.ini.
The tuning switches lived in the master's Advanced menu and were saved
globally, so two hosts could not use different settings. The client already
sends ScreenSettings when a remote desktop starts, so the state belongs
there: the four items now sit in the remote desktop window's system menu,
directly below Screen quality, and are saved per client.
ScreenSettings had a 40-byte Reserved area at offset 56; four bytes became
TuningFlags, keeping the struct at 100 bytes with Capabilities at 96. A new
Capabilities bit marks a value written by a versioned master; old clients,
and new clients never configured, report 0 and are not trusted.
CMD_SCREEN_TUNING now ends with a version byte. A five-byte command comes
from an older master that does not know the server-only adaptive bit: the
client applies those three bits to the session but does not save them. A
fresh client starts at 0, so an old master still gets pre-feature
behaviour; the new master's 0xE default is persisted on its first session.
The per-client master copy stays as the old-client fallback, and the old
global [settings] Tuning* keys are honoured when neither exists, so an
explicit opt-out survives the migration.
Verified on the Debug server with the in-process test client: a fresh
client stored 0xE on first use; toggling VBV wrote 0xF to both sides; after
deleting the master copy and reopening, the menu restored VBV from the
client report.
Co-Authored-By: deepseek-flash
The client's audio thread starts before the capture thread sends
TOKEN_BITMAPINFO, so its first packet - the only one carrying the
AudioFormat - reaches the master before CScreenSpyDlg exists and is
dropped as an unknown command. Without a format the master cannot open
waveOut, and the client re-announced only on an audio off/on, so a
remote desktop opened with audio enabled stayed silent until the toolbar
button was toggled twice. The master now asks for a re-announce when
data arrives with no format on record (CMD_AUDIO_CTRL enable,
persist=0, one request per 2 s, 15 attempts max), and the client
attaches the format to its next packet.
Entering Modern Standby tears down the render endpoint. The client got
AUDCLNT_E_DEVICE_INVALIDATED and rebuilt its loopback capture in that
same instant; the new client initialized and started fine but was bound
to the dying audio engine, so after resume GetNextPacketSize returned
zero packets forever without error, and only a fresh screen session
recovered. The audio thread now measures its own loop gap (GetTickCount64
plus wall clock, 2 s; a normal pass is ~10 ms) and rebuilds the capture
client after the machine was frozen, waits a second after an
invalidation, and rebuilds on an audio off-to-on.
The master rebuilds waveOut on resume from WM_POWERBROADCAST. The format
recovery was verified live; the resume recovery is build-verified and
awaits a field check on a sleeping machine.
Co-Authored-By: deepseek-flash
Remote desktop audio could stop permanently after an idle period and only
came back by closing and reopening the remote desktop. The ring buffer and
WAVEHDRs were shared without locking between the IOCP worker thread
(OnAudioData) and the UI thread (MM_WOM_DONE): headers were queued twice
(waveOutWrite returning WAVERR_STILLPLAYING 33) and the non-atomic
m_nRingDataLen underflowed, leaving the buffer "full" of stale data.
Audio state is now serialized by a recursive m_AudioMutex, and opening,
resetting and closing the waveOut device happens only on the window's UI
thread: waveOutReset/Close can re-enter the MM_WOM_* handlers on that
thread, and a lock-holding worker would deadlock against the UI thread.
Workers post WM_AUDIO_INIT_DEVICE instead. Rebuilds are triggered by
format changes, waveOutWrite failures (throttled to 2 s), MM_WOM_CLOSE
with a 1 s guard against our own close notices, and a 2-second retry
while audio is enabled. Failed header preparation now tears the device
down instead of leaving a handle that rejects every write.
The client re-creates its Opus encoder when the endpoint channel count or
sample rate changes, downmixes more than two channels, and clamps
oversized WASAPI packets to the PCM staging buffer. Web audio forwarding
still runs outside the lock and is gated exactly as before. Verified by
building the Debug x64 server and client; the silence scenario itself was
not reproduced at runtime.
Co-Authored-By: deepseek-flash
The cap is capped CRF (VBV): when a frame needs more bits than the
profile's nominal bitrate allows, x264 has to raise QP to stay under the
ceiling. Scenes with lots of change (video, scrolling, window dragging)
therefore lose detail and look blurry, while static scenes stay sharp -
the cap only bites on motion. That trade is worth it on intercontinental
or otherwise constrained links, where an uncapped frame can take seconds
to transmit and stall everything queued behind it, but it is a pure
quality loss on a LAN.
The tuning item now defaults to unchecked, so a master sends 0x3 (GDI
no-sleep and send pacing) by default; machines that already stored
TuningX264Vbv keep their explicit choice. The menu entry is renamed to
"x264 码率封顶 (VBV,仅限洲际弱网)" and the en_US, zh_TW and de_DE
translations were updated to match the new source string.
Only newly opened remote desktops pick up the flag, since CMD_SCREEN_TUNING
is sent when the session starts. Verified by rebuilding the Debug x64
server and client, and by finding the new menu and translation strings in
the built binary.
Co-Authored-By: deepseek-flash
The Advanced menu now ends with Run Test Program. It copies the kernel
payload that was already read into memory, points its CONNECT_ADDRESS at
127.0.0.1:<listen port>, and loads it with MemoryLoadLibrary inside the
master process, so this machine comes online as a controlled host -- no
second machine is needed to try remote desktop or file transfer. A
worker thread waits for the client to exit, then frees the module and
re-enables the item. Only one instance runs at a time: the item is
grayed while it does, and stopping it means uninstalling the test host
from the online list.
The loaded copy carries LOCAL_TEST_CLIENT_MAGIC in szFuture. The client
uses that mark to refuse the commands that would otherwise hit the host
process or the whole machine: uninstall (no self_del), update, run as
admin, ban, share/assign, and shutdown/reboot/logoff. It also skips
auth-kernel detection, which GetModuleFileName(NULL) would misjudge
inside the master.
Renames szFututre to szFuture and documents that the first 16 bytes of
the reserved tail are now claimed, with a static_assert so it cannot
silently shrink below the magic.
Translations for en_US, zh_TW and de_DE, plus the HIDE_MENU_RUN_TEST
feature flag and its row in the limits dialog.
Verified on a Debug master: the item is last and has its icon, one click
brings the host online, a second click is refused, uninstall stops it in
about a second and the master survives, re-run works, and exiting the
master with a live test client takes 2.6s (3.0s baseline).
Co-Authored-By: deepseek-flash
The built-in certificate lives only inside the server config as base64
DER, so there was no way to take it elsewhere -- to install it as a
custom certificate on another machine, or to hand it to a proxy.
The TLS certificate dialog now has an Export Certificate button next to
the Built-in Certificate checkbox. It is enabled only while that box is
checked. Clicking it opens a save dialog and writes two PEM files: the
chosen .crt and a .key with the same base name in the same directory.
The key is PKCS#8 and unencrypted; the success message says so.
If the certificate has not been generated yet (box checked but the
dialog not applied), the export generates it first, the same way OK
does, then refreshes the expiry text. If the key cannot be written, the
certificate written just before it is deleted, so no half pair is left.
Translations added for en_US, zh_TW and de_DE; en_US and zh_TW are also
embedded resources, so the server was rebuilt.
Verified: Debug x64 server builds clean. Drove the dialog on a running
Debug instance over window messages -- the button, its label and its
enabled state track the checkbox. The PEM writer was checked against
OpenSSL (x509 -subject, pkey -check) using the same CryptoAPI flags.
The save dialog itself was not automated end to end.
Co-Authored-By: deepseek-flash
Every quality change restarts the capturer on both sides, and two defects
showed up along that path.
Monitor jump: on a multi-monitor client the view moved to another monitor.
switchScreen=false means "reuse the index", but index is the *next*
monitor to switch to, not the one being shown. Track `current` and read it
on the non-switch path; the switch path still advances.
H264 stall: switching from RGB565/DIFF back to H264 froze the view for up
to ten seconds. The client encoder kept its reference frames across the
gap, so it emitted P frames the server could not decode until the next
natural IDR. It is now rebuilt on the first H264 frame after an algorithm
or tuning change. The rebuild is requested with an atomic dirty flag that
the capture thread consumes in ensureEncoder(), because resetting the
encoder from the network thread raced with encode().
On the server, ApplyQualityLevel() only sets m_bResolutionChanging when
the client will really restart the capture: it compares the target
maxWidth with the client's reported bitmap width (cached atomically on
TOKEN_BITMAPINFO) and stays conservative while a previous resize is still
in flight. The fallback timeout drops from 5s to 1s, flushes the decoder
and asks the client for a keyframe (COMMAND_SCREEN_KEYFRAME_REQ).
Verified: Debug client and server build clean; the 1920-wide High->Good
switch no longer waits out the gate. Not yet retested on a live session.
Co-Authored-By: deepseek-flash
Adaptive quality only looked at RTT, so a short RTT over a narrow pipe
read as "excellent": at 20-40ms it picks Ultra/High (DIFF/RGB565), both
with bitRate == 0, and never steps down. One 1080p RGB565 frame is
4.15 MB -- 1.66s of transmission on 20 Mbps.
Adds GetTargetQualityLevelByLoad(): congestion needs both fps < 60% of
baseline and bytes/frame still near the nominal bitrate, because a static
screen has a near-zero byte rate on any link. Merged with the RTT result
as max() -- averaging lets a good RTT mask a narrow pipe. Step-down is 3
confirmations and jumps straight to the level the throughput can carry
(capped at +2); step-up stays RTT-only, so the criterion is one-way and
the worst case is one level too low instead of a 30s/15s oscillation.
Anti-oscillation, all inside the switch: RTT hysteresis (85%/115% dead
band against the target level's threshold), failed step-up pinned for 3
minutes, cooldowns 3s -> 10s down / 15s up, counters interrupt each
other, and a hard limit of 6 changes per 5 minutes.
Server-only, no client change. m_ulBytesThisSecond had to be fixed first:
it is accumulated before the switch, so file transfer, audio and
clipboard counted as screen traffic; added m_ulScreenBytesThisSecond for
the four frame cases. Also gates a real bug in the 10s post-step-down
probe that disabled the criterion permanently on a static screen.
Default on (same migration caveat as the other four). Unticking takes the
original path unchanged. Verified on Debug: 27 hysteresis cases and the
load cases pass, menu defaults correct; not yet measured end to end.
History used to jump to the last directory merely visited, and lived only
in memory. Now it is recorded only when a transfer actually starts (the
four copy/transfer handlers) and persisted as an MRU list of the last 10
directories in THIS_CFG [file_history], keyed "local" plus one key per
clientID. Paths are stored verbatim; '|' joins the list.
The history handlers read the head of that list; the rest is kept for the
future dropdown. Also translated the four zh_TW status messages, which
were still simplified copies.
Server-only; no protocol or client change.
Co-Authored-By: deepseek-flash
Adds "Advanced -> Remote desktop tuning" with three independently
checkable items, all enabled by default:
x264 bitrate cap (VBV) TUNING_X264_VBV 0x1
GDI capture: no slice delay TUNING_GDI_NO_SLEEP 0x2
Send pacing FPS floor TUNING_PACE_FPS_FLOOR 0x4
Unticking an item clears its bit and restores the pre-commit behaviour
exactly, so the escape hatch is one click per measure -- no rebuild, no
config edit. Each bit is independent; a problem with one does not force
turning all three off.
Plumbing
--------
Menu state -> [settings] Tuning* -> CMy2015RemoteDlg::GetScreenTuningFlags()
-> CScreenSpyDlg::SendScreenTuning() (right after TOKEN_BITMAPINFO)
-> CMD_SCREEN_TUNING = 178 [cmd:1][flags:4 LE]
-> CScreenManager::OnReceive -> m_nTuningFlags -> ScreenCapture::SetTuningFlags
Why it is safe to send to old clients: CScreenManager::OnReceive has no
default branch in its switch, so an unknown command falls straight out
(verified). 178 was unassigned (177 = COMMAND_SET_PROTO, 199 =
TOKEN_DECRYPT), and the enum re-anchors explicitly so nothing auto-
increments onto it.
Flags are sent even when all-zero on purpose: the client's flag lives in
CScreenManager, which survives closing and reopening the remote desktop
window on the same connection. Without the zero send, unticking the menu
would leave the previous flags in effect.
Per-measure notes
-----------------
VBV: capped CRF (peak = target, 0.5s buffer, init 0.9). The hardware
paths already cap via rc_max_rate (1.5x, 1s buffer); this is tighter and
only affects x264. After an IDR the buffer drains and takes up to 0.5s
to refill, so a brief quality dip follows every keyframe -- if that shows
up, relaxing to 1.5x/1s would match NVENC/QSV.
GDI: keeps the 50-line BitBlt slicing (large single BitBlts hit driver
limits) and only drops the 5ms sleep between slices -- 1080p is 22 slices
= a forced 110ms per frame against a 50ms budget at 20fps.
Pacing: clamps s0 to 2x the base interval instead of 4x (2fps -> 4fps),
taken as max(2x base, 1000/MaxFPS) so it never exceeds the configured
MaxFPS. The growth/decay code itself is untouched. This one works against
the loop's own congestion signal, so it is the first to untick if a bad
link feels laggier rather than smoother.
SetTuningFlags only rebuilds the encoder when TUNING_ENCODER_BITS
(currently just VBV) changes -- the GDI and pacing bits are read live by
the capture and send threads, and rebuilding for them would drop an IDR
and visibly flash the picture.
Defaults: the on-by-default value lives in the third argument of
THIS_CFG.GetInt(), which only applies when the key is absent. A machine
that already has an explicit 0 keeps it, so the flip is not retroactive
and a test machine can end up with a mixed state.
Verified on the Debug build: with no Tuning* keys all three items start
checked; unticking VBV alone leaves the other two checked and survives a
restart; en_US/de_DE/zh_TW translations all resolve. Not yet measured end
to end on a real remote desktop session.
The connections dialog decoded procName with CA2T(x, CP_UTF8). In this MBCS
build CA2T expands to CA2A, whose nCodePage argument ATL explicitly ignores
(atlconv.h: "(void)nCodePage") - the call just memcpy's the bytes. So the
UTF-8 process names sent by the client were copied verbatim into a CString and
rendered as GBK: Chinese names turned into mojibake while pure-ASCII names
looked fine, since UTF-8 and GBK coincide there.
Display via the established pattern instead (same as the client list and the
process manager): convert UTF-8 to UTF-16 with MultiByteToWideChar and write
the item text with LVM_SETITEMTEXTW, bypassing the ANSI code page entirely.
This also keeps Chinese names readable on servers running a non-Chinese ACP.
The sort key keeps the raw UTF-8 bytes: byte-wise comparison of UTF-8 equals
code-point order, and no characters can be lost in conversion.
CCheckListBox keeps its own per-row state in the item data slot and exposes a
DWORD_PTR user field inside it, so every flag this dialog stored travelled
through a value that is only 32 bits wide in a Win32 build. On a 32-bit
server, each menu and context row at bit 32 or above therefore came back as
zero: 26 entries in the 主菜单 tab, from 插件请求 to DLL内嵌TLS证书, and 14 in
the 右键菜单 tab, from 虚拟屏幕(插件) to 执行代码. Ticking one wrote nothing
into the generated master, and reopening the dialog showed it unticked again.
The narrowing never produced a warning because C4244 is listed in
DisableSpecificWarnings for all four configurations, and the x64 build, where
DWORD_PTR is 64 bits wide, was unaffected.
Store the row's index into the tab's item vector instead of the flag itself,
and have CollectFlags() look the flag up in that vector, so the value never
narrows in either architecture. The vector index also survives the
compile-time skips in PopulateList and needs no change when the flags grow
into a second 64-bit word.
Verified by building the Debug server for x64 and x86.
Co-Authored-By: deepseek-flash
Add a "高级 → DLL内嵌TLS证书" toggle (off by default, persisted as
[settings] EmbedTlsInDll). When it is on, ReadKernelDll patches the server's
current TLS anchor into the ServerDll and ShellCode payloads, so clients that
come online through the loaders start their own session over TLS without
waiting for an online push. The plaintext DLL loader in client/main.c is
untouched; only the DLL's fresh connection is protected. The write happens
after SetServer and before CalcMD5FromBytes, and the anchor records the host
part of the master address rather than "ip:port" because the client matches
the anchor against its configured address set. TinyRun has no anchor block and
keeps working as before.
Toggling the switch, and confirming the certificate dialog, rebuild the six
payloads in place, so no server restart is needed after a certificate change.
The payload pointers are replaced as a whole, and the network threads that read
them (SendServerDll and TOKEN_GETVERSION) now take a dedicated critical section
for the full duration of use.
COMMAND_UPDATE no longer clears the tls_disabled marker on the client. Now that
any delivered DLL may carry the anchor, "the payload has an anchor" no longer
means the operator opted this host into TLS, and clearing the marker would
silently flip a host that was explicitly set to plaintext onto TLS against a
plaintext path. Re-enabling TLS stays an explicit action through
COMMAND_TLS_ENABLE and COMMAND_SET_PROTO, which still clear the marker.
Menu and notice strings were added to en_US, zh_TW and de_DE, and the embedded
TLS design document records the new switch and the revised update semantics.
The new menu entry also takes a feature-limits slot so a subordinate master
can hide it like every other 高级 item (see 8807321):
HIDE_MENU_EMBED_TLS_ANCHOR in UIBranding.h, MF_EMBED_TLS_ANCHOR at bit 57
in FeatureFlags.h (the first free one after MF_FILE_SPEED), a row in the
主菜单 tab of CFeatureLimitsDlg, and the matching DeleteMenu on the 高级
menu. The entry still has no bitmap of its own, so it renders without an
icon next to its three siblings.
Co-Authored-By: deepseek-flash
The share payload was host:port:shine and carried no transport at all, so a
shared client fell back to its baked-in protoType. Share instances also skip
ApplyProtoSwitch (ClientDll.cpp:810), so a client upgraded to WSS was shared
to a TLS front end as raw TCP and looped on HTTP/1.1 400.
Extend both payloads with an optional trailing transport field:
share : host:port:shine[:transport]
assign : host:port:days:shine[:transport]
The field is omitted when the source protocol is not TCP/WS/WSS, so HTTP/UDP/
KCP hosts keep their previous behaviour instead of being silently downgraded
to plain TCP.
- server: add SelectedShareTransport(), share it between OnOnlineShare and
OnOnlineAssignTo, and accept a tcp:// ws:// wss:// prefix in the address.
- client: parse the field on both paths and persist the assigned value to
settings/master_transport, clearing it when the field is absent.
- share_list: dedup on host:port instead of the whole record, so re-sharing
a host with a different transport replaces the stale entry.
- assign: guard bToken[_MAX_PATH] against the longer payload.
- lang: translate the reworded prompt and the three new messages in en_US,
zh_TW and de_DE.
Transport is pinned at share time and does not follow a later protocol switch
on the master link; the m_bShared gate stays as-is on purpose.
When the server has TLS enabled, the builder can now bake its certificate into
the client it produces, so a distributed client speaks TLS on its very first
connection instead of waiting for the anchor to be pushed after a plaintext
login. The dialog gets a checkbox (IDC_CHECK_TLS_ANCHOR) that is only enabled
for payloads and protocols where an embedded anchor makes sense; the choice is
remembered even when the control flips to disabled and back, so switching
protocols cannot silently undo a deliberate opt-out. Every label variant stays
short enough to fit the 196 DLU field, including the German ones. A template
that predates the anchor block no longer aborts generation: it warns, clears
the checkbox and produces a plain client, so a master upgraded without
rebuilding the ghost/ServerDll resources does not block every build.
The certificate lands in a fixed 4 KiB block (magic, version, length, FNV-1a
hash, master address, PEM) carved out of the payload at build time. The client
reads its trust anchor from four sources in order: the tls_disabled marker,
the certificate the server pushed into the registry, a PEM file next to the
executable, and finally the embedded block.
The embedded block only applies to a connection whose target matches the
master recorded at generation time, compared as an address set: an exact
string match when only one address is configured, or an intersection of
resolved IPv4 addresses otherwise. A transferred, shared or parallel instance
falls back to the old plaintext first-connect path instead of pinning itself
to a certificate it can never verify. That decision is made per connection,
not per process: shared and parallel instances are threads inside a single
client process, so a process-wide flag let whichever instance connected first
decide for all of them, and the first load of the TLS state cached that answer
for good. The TLS layer now keeps two cached states (embedded anchor allowed,
and not allowed), picks one per handshake, and reports the anchor source of
that handshake for the login capability bit. Matching by resolved address also
keeps parallel mode working, where the connection goes to the single IP the
domain pool selected while the configured master is a domain or a list.
Server side, generated and updated payloads get the block written in place;
the client reports the capability bit on login so the console can tell which
hosts are already TLS-only on first connect. Loading the anchor decodes every
PEM block in the chain rather than just the leaf, and an anchor that exists
but fails to load keeps the old fail-closed behaviour. A pushed anchor only
reconnects when the transport of the live connection actually changes, judged
against that connection's own target rather than the process-wide switch.
This was verified end to end against a freshly generated client with an empty
registry: the first connection was a TLS 1.2 ClientHello 0.2 s after start,
and a four-certificate fullchain loaded all four blocks. Re-verified after the
per-connection rework with the anchor block patched into a debug client: with
a matching master the first bytes are a ClientHello, with a foreign master the
client logs the skip and sends plaintext, and a domain master resolves to the
IP it connects to and still matches. A master domain that no longer resolves
falls back to plaintext within a second and is not looked up again for a
minute, instead of stalling every reconnect on a DNS timeout while holding the
lock the certificate verification needs.
Co-Authored-By: deepseek-flash
A fresh install used to require openssl before the server could speak TLS:
two empty paths in [tls] meant the identity failed to load and every
ClientHello was refused. TLS is now on by default and, when no custom
certificate is configured, the server generates its own self-signed one the
first time it needs it -- RSA-2048, SHA-256, CN=yama-server, CA:TRUE, valid
for ten years from one day before now. Plaintext clients are untouched, since
the device port still splits plaintext from TLS by sniffing the first six
bytes of a connection.
The certificate and its PKCS#8 private key are stored side by side in the
config under [tls] BuiltinCert / BuiltinKey as single-line base64 DER. Single
line, because the server has two config backends -- the registry for Release,
settings.ini for a Debug master -- and only a line without newlines means the
same read/write code serves both. That in turn required fixing the registry
reader: iniFile::GetStr copied into a 512 byte stack buffer, so a 1.5 KB value
came back as a truncated or empty string. The two-phase dynamic read now lives
in common/iniFile.h as ReadRegistryValueSz / ReadRegistrySz, and the copy that
client/TlsChannel.cpp had been carrying for its own trust anchor is gone. This
also makes the built-in certificate self-checking: Ensure() re-reads what it
just wrote and fails loudly if the round trip did not survive.
Import has to go through NCRYPT_PKCS8_PRIVATE_KEY_BLOB, matching the import
path in BuildIdentityFromDer. NCRYPT_PKCS8_PRIV_KEY_INFO_BLOB, which most
samples reach for, is not implemented by the Microsoft Software KSP and
returns NTE_INVALID_PARAMETER; a probe confirmed it, and the export type that
works is the one the importer already expected. Building an identity is now
split into a file front-end (PEM, fullchain, PKCS#1 hints) and a shared DER
core, so the built-in and file paths cannot drift apart.
That key also exposed a second problem worth fixing here. The identity binds
its private key to the certificate by name -- CRYPT_KEY_PROV_INFO with
pwszContainerName -- and Schannel resolves that name on every handshake
through CryptAcquireCertificatePrivateKey. With the fixed name
"YamaServerTlsKey", two server processes under the same Windows user shared
one key slot: whichever loaded last overwrote it, and the other process's next
handshake picked up a private key that does not match its certificate. That is
exactly the debug-plus-release pairing used here, and defaulting to a built-in
certificate is what makes it reachable, since the debug instance no longer
points at the same PEM as the release instance. The name is now the base name
plus the first six bytes of the certificate's SHA-1 thumbprint, e.g.
YamaServerTlsKey-c0d469eae8a4: different certificates get different keys,
instances sharing one certificate still share one key. MCP picks this up too.
The effective name goes to the trace log so a collision is visible without a
debugger. A stale key from an older build may still sit in the key store under
the old name; nothing references it and it is not deleted automatically, since
a running instance of an older build could be using it.
The trust anchor still has to be pushed. The client pins exactly one root
through an exclusive-root chain engine and checks no host name, so a
self-signed CA:TRUE leaf chains cleanly to itself -- but only if the client is
told about it. That is the existing 启用 TLS / 切换到 WSS command, which now
takes the PEM from ServerTlsIdentity::AnchorPem instead of re-reading the
configured cert file, so it reports the same certificate the server actually
serves for both sources. Losing the stored certificate (cleared registry, new
Windows user) regenerates it, and every client must be re-pushed the anchor.
Two places that used to fall back to [tls] CertPath now skip that fallback
while the built-in certificate is active: the MCP HTTPS front end at startup
and the prefill in its settings dialog. A self-signed certificate cannot pass
validation at a public MCP client, and the retained CertPath is only a
leftover from switching back to a custom certificate, so pretending to use it
would fail later with a worse message. MCP HTTPS with empty paths already
fails closed with a log line.
The TLS dialog gains a 内置证书 checkbox, ticked by default and unticked when
certificate paths are present; ticking it greys out the path rows without
clearing them, and shows either "generated on first use" or the expiry date
read back from the stored certificate. Saving writes four keys -- Enabled,
UseBuiltIn, CertPath, KeyPath -- and an explicit UseBuiltIn keeps the paths
from being used as an implicit switch. Every reader of [tls] Enabled now
defaults to 1, so the menu check, the dialog and the loader agree on a fresh
install. The status bar panes on 无 / 有 grew a third state, 内置, and the
pane width is measured across all three.
Translations were added to en_US, zh_TW and de_DE; skipping the German file
would have left the new dialog text in Chinese there, as de_DE is loaded from
disk rather than embedded.
Verified with the debug server against openssl s_client. Both the generated
built-in certificate (CN=yama-server) and an existing custom one
(CN=localhost) complete a TLS 1.2 handshake with the pinned certificate, and
their log lines show distinct key names, c0d469eae8a4 and 272f2adfb19c. An
unmodified client still runs in plaintext without an anchor, an existing custom
certificate deployment behaves exactly as before, and client and server both
build clean at Debug x64.
Co-Authored-By: deepseek-flash
Both bugs let a remote peer terminate the server process: the first needs no
credentials at all, the second needs only a malicious client.
1) cpp-httplib 0.14.3 -- unauthenticated DoS via Content-Length
Content-Length was parsed with strtoull, which accepts a leading sign, so
"-1" wrapped around to ULLONG_MAX. read_content then treated that as an
oversized body and called skip_content_with_length(strm, ULLONG_MAX), a loop
that only exits after consuming 18 EB -- a client trickling bytes never trips
the read timeout, so the worker thread is stuck forever. With ThreadPool(32)
that is 32 connections to wedge the whole server. Body parsing runs before
the MCP token check, so no token is required.
Backported from upstream 0.51.0/0.64.0 as parse_content_length_strict(): only
plain decimal digits are accepted and overflow is rejected. Upgrading the
library instead is not possible -- 0.25.0+ requires _WIN32_WINNT >= 0x0A00
(Win10) while this project targets 0x0602 (Win8), and the last Win8-compatible
release (0.20.0) predates the fix.
Verified: negative, leading-plus, overflow and trailing-garbage values now all
return 400; 40 concurrent "-1" requests are rejected in under 50 ms with the
thread pool still healthy; plain and chunked requests are unaffected.
2) HideScreenSpyDlg::JPG_BMP -- malformed JPEG terminated the process
The decoder was set up with libjpeg's default error_exit, which calls
exit(EXIT_FAILURE). Since the input is a JPEG stream sent by the remote
client, one structurally invalid frame killed the whole server. Replaced with
a setjmp/longjmp handler that turns fatal errors into "return false", matching
this function's existing failure paths. Warnings still go through
emit_message, so truncated-but-recoverable images behave exactly as before.
Verified against 36 malformed samples: 19 used to terminate the process, none
do now (the same 19 return false), and valid JPEGs decode identically.
3) Drop the dead file_server.h
An older HTTP file-serving implementation, superseded by WebService.cpp and
referenced by nothing: no include anywhere, no instantiation, no entry in the
vcxproj or any build script. Removing it keeps the real HTTP attack surface --
httplib's /mcp plus WebService -- unambiguous for anyone auditing this code.
The "feature limits" dialog offered by 主控生成 had drifted well behind the
UI: a whole 高级 menu, five toolbar buttons and a couple of dozen context
menu entries could not be restricted at all, and several items were listed
under names that no longer appear anywhere.
The three tabs now follow the real resources. Menu items are listed in the
order of IDR_MENU_MAIN and carry the same text minus accelerators; the
toolbar covers all 19 IDR_TOOLBAR_MAIN buttons; the context menu lists the
nested 实验功能 / 客户管理 / 远程控制 / 机器管理 / 客户代理 / 执行程序 entries
individually and the two runtime-built ones (协议切换, 执行代码) as groups.
That makes 57 / 19 / 46 items, each with its own bit; new bits were added
at the end of each field so the existing positions stay put.
Enforcement was extended to match, and while wiring it up one long-standing
bug surfaced: DeleteMenu(MF_BYCOMMAND) only reaches items of the menu it is
called on, so hiding an entry of a nested popup had always been a no-op.
Nested items are now deleted through their own submenu handle, and a popup
whose items are all hidden is removed together with its parent entry, so
no empty popup is left behind. 协议切换 is inserted relative to where
实验功能 ended up, which keeps it next to it either way; 执行代码 is simply
skipped when restricted.
The missing labels were added to en_US, zh_TW and de_DE.
Co-Authored-By: deepseek-flash
The main window's status bar now carries two short panes between the host
count and the FRP address. The first reports whether the server identity is
loaded, using the same ServerTlsIdentity::IsReady() check the rest of the UI
uses, so a menu that claims TLS is on cannot leave the bar saying otherwise
when the certificate failed to load. The second reports whether MCP is
enabled and, while it is, which protocol the endpoint speaks: (HTTP) or
(HTTPS) according to McpHttps. Both panes follow the existing 60 second
statistics tick, and toggling either switch in its dialog refreshes them at
once instead of leaving the bar stale until the next tick.
Pane widths are measured from the widest text each pane can show in the
current language instead of hardcoded pixels, and the measurement selects
the status bar's own font: DEFAULT_GUI_FONT is about 8% narrower than the
Segoe UI the bar paints with, which would have clipped "MCP: ... (HTTPS)"
at higher display scaling. Switching HTTP/HTTPS keeps the column width
steady, and turning MCP off lets it shrink again.
The MCP settings dialog was also missing translations for several of its
labels, the file write switch among them, which is why they stayed Chinese
in the English UI. Those keys, together with the status bar ones, are added
to all three language files.
Co-Authored-By: deepseek-flash