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.
175 lines
4.8 KiB
Go
175 lines
4.8 KiB
Go
package web
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
// Stable audit event names. Keep these stable: operators build alerts and
|
|
// dashboards on them. Every record also carries audit=true.
|
|
const (
|
|
auditWSConnect = "web.ws.connect"
|
|
auditWSReject = "web.ws.reject"
|
|
auditWSClose = "web.ws.close"
|
|
auditLoginOK = "web.login.success"
|
|
auditLoginFail = "web.login.failure"
|
|
auditLoginThrot = "web.login.throttled"
|
|
auditSession = "web.session.resume"
|
|
auditBadToken = "web.auth.invalid_token"
|
|
auditDenied = "web.authz.denied"
|
|
auditUnknownCmd = "web.command.unknown"
|
|
auditSaltProbe = "web.salt.unknown_user"
|
|
|
|
auditScreenStart = "remote.screen.start"
|
|
auditScreenStop = "remote.screen.stop"
|
|
auditScreenDenied = "remote.screen.denied"
|
|
auditTermStart = "remote.terminal.start"
|
|
auditTermStop = "remote.terminal.stop"
|
|
auditTermDenied = "remote.terminal.denied"
|
|
auditClipSet = "remote.clipboard.set"
|
|
auditClipGet = "remote.clipboard.get"
|
|
auditRdpReset = "remote.rdp_reset"
|
|
|
|
auditUserCreate = "admin.user.create"
|
|
auditUserDelete = "admin.user.delete"
|
|
auditDeviceAdmin = "admin.device.delete"
|
|
auditDeviceTransfer = "admin.device.transfer"
|
|
auditDeviceBind = "admin.device.bind"
|
|
auditDeviceUnbind = "admin.device.unbind"
|
|
auditQuery = "admin.audit.query"
|
|
)
|
|
|
|
// audit emits one audit record for a WebSocket client. Identity fields are
|
|
// read under h.mu because requireAuth/handleLogin install them there and
|
|
// broadcast goroutines may observe the same client concurrently.
|
|
//
|
|
// Callers MUST NOT hold h.mu when calling this method.
|
|
func (h *wsHub) audit(c *wsClient, warn bool, event string, fields map[string]any) {
|
|
if fields == nil {
|
|
fields = make(map[string]any)
|
|
}
|
|
if c != nil {
|
|
h.mu.RLock()
|
|
connID := c.id
|
|
addr := c.addr
|
|
peer := c.peerAddr
|
|
user := c.user
|
|
role := c.role
|
|
h.mu.RUnlock()
|
|
|
|
if _, ok := fields["conn"]; !ok && connID != "" {
|
|
fields["conn"] = connID
|
|
}
|
|
if _, ok := fields["ip"]; !ok && addr != "" {
|
|
fields["ip"] = addr
|
|
}
|
|
if _, ok := fields["peer_ip"]; !ok && peer != "" && peer != addr {
|
|
fields["peer_ip"] = peer
|
|
}
|
|
if _, ok := fields["actor"]; !ok && user != "" {
|
|
fields["actor"] = user
|
|
}
|
|
if _, ok := fields["role"]; !ok && role != "" {
|
|
fields["role"] = role
|
|
}
|
|
}
|
|
if warn {
|
|
h.log.AuditWarn(event, fields)
|
|
} else {
|
|
h.log.Audit(event, fields)
|
|
}
|
|
}
|
|
|
|
// auditClose records the end of a browser WebSocket. Anonymous scanners that
|
|
// connect and do nothing produce only the connect event; authenticated
|
|
// sessions, failed-login probes, and command traffic always produce a close
|
|
// record with counters that help spot brute-force / probing behavior.
|
|
func (h *wsHub) auditClose(c *wsClient, screens int) {
|
|
suspicious := c.statInvalidToken > 0 ||
|
|
c.statLoginFailures > 0 ||
|
|
c.statAdminDenied > 0 ||
|
|
c.statUnknownSalt > 0 ||
|
|
c.statUnknownCmd > 0
|
|
if c.user == "" && c.statCommands == 0 && !suspicious {
|
|
return
|
|
}
|
|
|
|
fields := map[string]any{
|
|
"duration_ms": time.Since(c.connectedAt).Milliseconds(),
|
|
"commands": c.statCommands,
|
|
}
|
|
if screens > 0 {
|
|
fields["screens"] = screens
|
|
}
|
|
if c.statInvalidToken > 0 {
|
|
fields["invalid_tokens"] = c.statInvalidToken
|
|
}
|
|
if c.statLoginFailures > 0 {
|
|
fields["login_failures"] = c.statLoginFailures
|
|
}
|
|
if c.statAdminDenied > 0 {
|
|
fields["admin_denied"] = c.statAdminDenied
|
|
}
|
|
if c.statUnknownSalt > 0 {
|
|
fields["unknown_salt"] = c.statUnknownSalt
|
|
}
|
|
if c.statUnknownCmd > 0 {
|
|
fields["unknown_commands"] = c.statUnknownCmd
|
|
}
|
|
h.audit(c, suspicious, auditWSClose, fields)
|
|
}
|
|
|
|
// requestFields builds the audit context available before a WebSocket client
|
|
// exists (upgrade rejected) or for plain HTTP endpoints (SSO).
|
|
func requestFields(r *http.Request, trustForwardedFor bool) map[string]any {
|
|
fields := make(map[string]any)
|
|
if r == nil {
|
|
return fields
|
|
}
|
|
ip := clientIP(r, trustForwardedFor)
|
|
if ip != "" {
|
|
fields["ip"] = ip
|
|
}
|
|
if peer := stripPort(r.RemoteAddr); peer != "" && peer != ip {
|
|
fields["peer_ip"] = peer
|
|
}
|
|
if origin := r.Header.Get("Origin"); origin != "" {
|
|
fields["origin"] = origin
|
|
}
|
|
if ua := r.UserAgent(); ua != "" {
|
|
fields["ua"] = ua
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// wsRequestFields returns request metadata worth attaching to login events.
|
|
func (c *wsClient) wsRequestFields() map[string]any {
|
|
fields := make(map[string]any)
|
|
if c.origin != "" {
|
|
fields["origin"] = c.origin
|
|
}
|
|
if c.userAgent != "" {
|
|
fields["ua"] = c.userAgent
|
|
}
|
|
return fields
|
|
}
|
|
|
|
func durationMs(start time.Time) int64 {
|
|
if start.IsZero() {
|
|
return 0
|
|
}
|
|
return time.Since(start).Milliseconds()
|
|
}
|
|
|
|
// newConnID returns a short random identifier used to correlate all audit
|
|
// records belonging to one browser WebSocket connection.
|
|
func newConnID() string {
|
|
var b [4]byte
|
|
if _, err := rand.Read(b[:]); err != nil {
|
|
return "conn"
|
|
}
|
|
return hex.EncodeToString(b[:])
|
|
}
|