ai-remote 0.1.0

package/src/protocols/rdp/pdu.ts

@@ -0,0 +1,497 @@
+// The share layer: PDU headers, the client info PDU, input events, and the
+// server update PDUs this client understands (MS-RDPBCGR 2.2.8, 2.2.9, 2.2.1.13).
+
+import { Reader, Writer } from './buffer';
+
+export const PDU_TYPE = {
+  DEMAND_ACTIVE: 1,
+  CONFIRM_ACTIVE: 3,
+  DEACTIVATE_ALL: 6,
+  DATA: 7,
+  SERVER_REDIRECT: 10,
+};
+
+export const PDU_TYPE2 = {
+  UPDATE: 2,
+  CONTROL: 20,
+  POINTER: 27,
+  INPUT: 28,
+  SYNCHRONIZE: 31,
+  REFRESH_RECT: 33,
+  PLAY_SOUND: 34,
+  SUPPRESS_OUTPUT: 35,
+  SHUTDOWN_REQUEST: 36,
+  SHUTDOWN_DENIED: 37,
+  SAVE_SESSION_INFO: 38,
+  FONT_LIST: 39,
+  FONT_MAP: 40,
+  SET_ERROR_INFO: 47,
+  MONITOR_LAYOUT: 55,
+};
+
+export const UPDATE_TYPE = {
+  ORDERS: 0,
+  BITMAP: 1,
+  PALETTE: 2,
+  SYNCHRONIZE: 3,
+};
+
+export const CONTROL_ACTION = {
+  REQUEST_CONTROL: 1,
+  GRANTED_CONTROL: 2,
+  DETACH: 3,
+  COOPERATE: 4,
+};
+
+export const INPUT_EVENT = {
+  SYNC: 0x0000,
+  SCANCODE: 0x0004,
+  UNICODE: 0x0005,
+  MOUSE: 0x8001,
+  MOUSEX: 0x8002,
+};
+
+export const KEYBOARD_FLAG = {
+  EXTENDED: 0x0100,
+  DOWN: 0x4000,
+  RELEASE: 0x8000,
+};
+
+export const POINTER_FLAG = {
+  WHEEL: 0x0200,
+  HWHEEL: 0x0400,
+  WHEEL_NEGATIVE: 0x0100,
+  MOVE: 0x0800,
+  DOWN: 0x8000,
+  BUTTON1: 0x1000,
+  BUTTON2: 0x2000,
+  BUTTON3: 0x4000,
+};
+
+/** Translate browser-style wheel direction to the signed RDP rotation flags. */
+export function pointerWheelFlags(delta: number, horizontal = false): number {
+  const steps = horizontal ? Math.sign(delta) : -Math.sign(delta);
+  if (steps === 0) return 0;
+  const wheelFlag = horizontal ? POINTER_FLAG.HWHEEL : POINTER_FLAG.WHEEL;
+  const rotation = 120;
+  return steps > 0
+    ? wheelFlag | rotation
+    : wheelFlag | POINTER_FLAG.WHEEL_NEGATIVE | ((-rotation) & 0xff);
+}
+
+export const TOGGLE_FLAG = {
+  SCROLL_LOCK: 0x0001,
+  NUM_LOCK: 0x0002,
+  CAPS_LOCK: 0x0004,
+  KANA_LOCK: 0x0008,
+};
+
+const POINTER_MESSAGE = {
+  SYSTEM: 0x0001,
+  POSITION: 0x0003,
+  COLOR: 0x0006,
+  CACHED: 0x0007,
+  POINTER: 0x0008,
+  LARGE: 0x0009,
+};
+
+const INFO_FLAG =
+  0x00000001 | // INFO_MOUSE
+  0x00000002 | // INFO_DISABLECTRLALTDEL
+  0x00000010 | // INFO_UNICODE
+  0x00000020 | // INFO_MAXIMIZESHELL
+  0x00000040 | // INFO_LOGONNOTIFY
+  0x00000100 | // INFO_ENABLEWINDOWSKEY
+  0x00010000 | // INFO_LOGONERRORS
+  0x00020000 | // INFO_MOUSE_HAS_WHEEL
+  0x00080000;  // INFO_NOAUDIOPLAYBACK
+
+const INFO_AUTOLOGON = 0x00000008;
+const INFO_RAIL = 0x00008000;
+
+const ERROR_INFO_MESSAGES = {
+  0x00000001: 'The host disconnected the session (an administrative API call ended it).',
+  0x00000002: 'The host logged the session off.',
+  0x00000003: 'The session was disconnected after being idle too long.',
+  0x00000004: 'The session was disconnected because sign-in took too long.',
+  0x00000005: 'The session was taken over by another connection.',
+  0x00000006: 'The host ran out of memory.',
+  0x00000007: 'The host denied the connection.',
+  0x00000009: 'This account does not have permission to sign in remotely.',
+  0x0000000a: 'The host requires fresh credentials.',
+  0x0000000b: 'A user on the host ended the session.',
+  0x0000000c: 'The remote user signed out.',
+  0x00000100: 'Remote Desktop licensing failed on the host (internal error).',
+  0x00000101: 'The host could not reach a Remote Desktop licensing server.',
+  0x00000102: 'The host has no Remote Desktop licence available for this client.',
+  0x00000103: 'The host rejected this client during licensing.',
+  0x00000104: 'The stored Remote Desktop licence does not match this client.',
+  0x00000105: 'The host rejected the client licence.',
+  0x00000106: 'Remote Desktop licensing could not be completed.',
+  0x00000107: 'The client ended the licensing exchange.',
+  0x00000108: 'The host rejected the client licence encryption.',
+  0x00000109: 'The host could not upgrade the client licence.',
+  0x0000010a: 'The host does not accept remote connections.',
+  0x000010f9: 'The host rejected a malformed capability set from this client.',
+  0x000010fa: 'The host rejected the client capability exchange.',
+};
+
+export function errorInfoMessage(errorInfo) {
+  return (
+    ERROR_INFO_MESSAGES[errorInfo] ||
+    `The host ended the session with error info 0x${errorInfo.toString(16).padStart(8, '0')}.`
+  );
+}
+
+// --- Outbound PDUs ----------------------------------------------------------
+
+/** TS_SHARECONTROLHEADER + payload. */
+export function shareControlPdu(pduType, userId: number, payload: Uint8Array) {
+  const writer = new Writer(payload.length + 6);
+  writer.u16le(payload.length + 6);
+  writer.u16le(pduType | 0x10); // low nibble is the type, high nibble the version
+  writer.u16le(userId);
+  writer.raw(payload);
+  return writer.take();
+}
+
+/** TS_SHAREDATAHEADER inside a share control PDU of type DATA. */
+export function shareDataPdu(shareId: number, userId: number, pduType2, payload: Uint8Array) {
+  const writer = new Writer(payload.length + 12);
+  writer.u32le(shareId);
+  writer.u8(0);                      // pad
+  writer.u8(1);                      // streamId: low priority
+  writer.u16le(payload.length + 18); // uncompressedLength, headers included
+  writer.u8(pduType2);
+  writer.u8(0);                      // compressedType: none
+  writer.u16le(0);                   // compressedLength
+  writer.raw(payload);
+  return shareControlPdu(PDU_TYPE.DATA, userId, writer.take());
+}
+
+/** Write a UTF-16LE field with its terminator, returning the length without it. */
+function unicodeField(writer: Writer, text: string) {
+  const start = writer.length;
+  writer.utf16le(text);
+  const byteLength = writer.length - start;
+  writer.u16le(0); // terminator
+  return byteLength;
+}
+
+/**
+ * Client Info PDU (MS-RDPBCGR 2.2.1.11). The credential lengths sit in front of
+ * the strings, so the strings are written to a scratch buffer first.
+ */
+export function clientInfoPdu({ domain, username, password, performanceFlags, autoLogon, remoteApp = false }) {
+  const strings = new Writer(512);
+  const cbDomain = unicodeField(strings, domain || '');
+  const cbUsername = unicodeField(strings, username || '');
+  const cbPassword = unicodeField(strings, password || '');
+  const cbAlternateShell = unicodeField(strings, '');
+  const cbWorkingDir = unicodeField(strings, '');
+
+  const writer = new Writer(768);
+  writer.u32le(0); // codePage
+  writer.u32le((INFO_FLAG | (autoLogon ? INFO_AUTOLOGON : 0) | (remoteApp ? INFO_RAIL : 0)) >>> 0);
+  writer.u16le(cbDomain);
+  writer.u16le(cbUsername);
+  writer.u16le(cbPassword);
+  writer.u16le(cbAlternateShell);
+  writer.u16le(cbWorkingDir);
+  writer.raw(strings.take());
+
+  // TS_EXTENDED_INFO_PACKET
+  writer.u16le(2);   // clientAddressFamily: AF_INET
+  writer.u16le(2);   // cbClientAddress: just the terminator
+  writer.u16le(0);
+  writer.u16le(2);   // cbClientDir
+  writer.u16le(0);
+  writer.zeros(172); // clientTimeZone
+  writer.u32le(0);   // clientSessionId
+  writer.u32le(performanceFlags >>> 0);
+  writer.u16le(0);   // cbAutoReconnectCookie
+
+  return writer.take();
+}
+
+export function synchronizePdu(targetUser) {
+  const writer = new Writer(4);
+  writer.u16le(1); // SYNCMSGTYPE_SYNC
+  writer.u16le(targetUser);
+  return writer.take();
+}
+
+export function controlPdu(action) {
+  const writer = new Writer(8);
+  writer.u16le(action);
+  writer.u16le(0); // grantId
+  writer.u32le(0); // controlId
+  return writer.take();
+}
+
+export function fontListPdu() {
+  const writer = new Writer(8);
+  writer.u16le(0);      // numberFonts
+  writer.u16le(0);      // totalNumberFonts
+  writer.u16le(0x0003); // listFlags: first and last
+  writer.u16le(0x0032); // entrySize
+  return writer.take();
+}
+
+export function confirmActivePdu(shareId: number, capabilities, capabilityCount) {
+  const sourceDescriptor = new TextEncoder().encode('MSTSC\0');
+  const writer = new Writer(capabilities.length + 32);
+
+  writer.u32le(shareId);
+  writer.u16le(0x03ea); // originatorId: the server channel
+  writer.u16le(sourceDescriptor.length);
+  writer.u16le(capabilities.length + 4); // lengthCombinedCapabilities
+  writer.raw(sourceDescriptor);
+  writer.u16le(capabilityCount);
+  writer.u16le(0); // pad
+  writer.raw(capabilities);
+
+  return writer.take();
+}
+
+/** TS_INPUT_PDU_DATA: a batch of input events sharing one header. */
+export function inputEventsPdu(events) {
+  const writer = new Writer(events.length * 12 + 4);
+  writer.u16le(events.length);
+  writer.u16le(0); // pad
+  for (const event of events) writer.raw(event);
+  return writer.take();
+}
+
+function inputEvent(messageType, write) {
+  const writer = new Writer(12);
+  writer.u32le(0); // eventTime, ignored by every host
+  writer.u16le(messageType);
+  write(writer);
+  return writer.take();
+}
+
+export function scancodeEvent(scancode, pressed: boolean, extended) {
+  return inputEvent(INPUT_EVENT.SCANCODE, (writer: Writer) => {
+    writer.u16le(
+      (pressed ? KEYBOARD_FLAG.DOWN : KEYBOARD_FLAG.RELEASE) |
+      (extended ? KEYBOARD_FLAG.EXTENDED : 0)
+    );
+    writer.u16le(scancode);
+    writer.u16le(0);
+  });
+}
+
+export function unicodeEvent(codeUnit, pressed: boolean) {
+  return inputEvent(INPUT_EVENT.UNICODE, (writer: Writer) => {
+    writer.u16le(pressed ? KEYBOARD_FLAG.DOWN : KEYBOARD_FLAG.RELEASE);
+    writer.u16le(codeUnit);
+    writer.u16le(0);
+  });
+}
+
+export function mouseEvent(flags: number, x: number, y: number) {
+  return inputEvent(INPUT_EVENT.MOUSE, (writer: Writer) => {
+    writer.u16le(flags);
+    writer.u16le(Math.max(0, Math.min(0xffff, Math.round(x))));
+    writer.u16le(Math.max(0, Math.min(0xffff, Math.round(y))));
+  });
+}
+
+export function extendedMouseEvent(flags: number, x: number, y: number) {
+  return inputEvent(INPUT_EVENT.MOUSEX, (writer: Writer) => {
+    writer.u16le(flags);
+    writer.u16le(Math.max(0, Math.min(0xffff, Math.round(x))));
+    writer.u16le(Math.max(0, Math.min(0xffff, Math.round(y))));
+  });
+}
+
+export function syncEvent(toggleFlags: number) {
+  return inputEvent(INPUT_EVENT.SYNC, (writer: Writer) => {
+    writer.u16le(0);
+    writer.u32le(toggleFlags >>> 0);
+  });
+}
+
+export function refreshRectPdu(rects) {
+  const writer = new Writer(4 + rects.length * 8);
+  writer.u8(rects.length);
+  writer.zeros(3); // pad
+  for (const rect of rects) {
+    writer.u16le(rect.left);
+    writer.u16le(rect.top);
+    writer.u16le(rect.right);
+    writer.u16le(rect.bottom);
+  }
+  return writer.take();
+}
+
+export function suppressOutputPdu(allowDisplayUpdates, rect) {
+  const writer = new Writer(12);
+  writer.u8(allowDisplayUpdates ? 1 : 0);
+  writer.zeros(3); // pad
+  if (allowDisplayUpdates && rect) {
+    writer.u16le(rect.left);
+    writer.u16le(rect.top);
+    writer.u16le(rect.right);
+    writer.u16le(rect.bottom);
+  }
+  return writer.take();
+}
+
+// --- Inbound PDUs -----------------------------------------------------------
+
+export function parseShareControlHeader(bytes: Uint8Array) {
+  const reader = new Reader(bytes);
+  const totalLength = reader.u16le();
+  const typeAndVersion = reader.u16le();
+  const pduSource = reader.u16le();
+
+  return {
+    totalLength,
+    pduType: typeAndVersion & 0x0f,
+    pduSource,
+    payload: reader.rest().subarray(0, Math.max(0, totalLength - 6)),
+  };
+}
+
+export function parseShareDataHeader(bytes: Uint8Array) {
+  const reader = new Reader(bytes);
+  const shareId = reader.u32le();
+  reader.u8();  // pad
+  reader.u8();  // streamId
+  reader.u16le(); // uncompressedLength
+  const pduType2 = reader.u8();
+  const compressedType = reader.u8();
+  const compressedLength = reader.u16le();
+
+  return { shareId, pduType2, compressedType, compressedLength, payload: reader.rest() };
+}
+
+export function parseDemandActive(bytes: Uint8Array) {
+  const reader = new Reader(bytes);
+  const shareId = reader.u32le();
+  const lengthSourceDescriptor = reader.u16le();
+  const lengthCombinedCapabilities = reader.u16le();
+  reader.skip(lengthSourceDescriptor);
+
+  const capabilities = reader.raw(Math.min(lengthCombinedCapabilities, reader.remaining));
+  return { shareId, capabilities };
+}
+
+const BITMAP_COMPRESSION = 0x0001;
+const NO_BITMAP_COMPRESSION_HDR = 0x0400;
+
+export function parseBitmapUpdate(reader: Reader) {
+  const count = reader.u16le();
+  const rects = [];
+
+  for (let i = 0; i < count && reader.remaining >= 18; i++) {
+    const left = reader.u16le();
+    const top = reader.u16le();
+    const right = reader.u16le();
+    const bottom = reader.u16le();
+    const width = reader.u16le();
+    const height = reader.u16le();
+    const bitsPerPixel = reader.u16le();
+    const flags = reader.u16le();
+    let bitmapLength = reader.u16le();
+
+    const compressed = Boolean(flags & BITMAP_COMPRESSION);
+    if (compressed && !(flags & NO_BITMAP_COMPRESSION_HDR)) {
+      // TS_CD_HEADER: the main body size is authoritative, and the eight header
+      // bytes are counted in bitmapLength.
+      reader.u16le();                       // cbCompFirstRowSize, always zero
+      const mainBodySize = reader.u16le();
+      reader.u16le();                       // cbScanWidth
+      reader.u16le();                       // cbUncompressedSize
+      bitmapLength = mainBodySize;
+    }
+
+    rects.push({
+      left,
+      top,
+      right,
+      bottom,
+      width,
+      height,
+      bitsPerPixel,
+      compressed,
+      data: reader.raw(Math.min(bitmapLength, reader.remaining)),
+    });
+  }
+
+  return rects;
+}
+
+export function parsePaletteUpdate(reader: Reader) {
+  reader.u16le(); // updateType, repeated
+  reader.u16le(); // pad
+  const count = reader.u32le();
+  const palette = new Uint8Array(256 * 3);
+
+  for (let i = 0; i < count && i < 256 && reader.remaining >= 3; i++) {
+    palette[i * 3] = reader.u8();
+    palette[i * 3 + 1] = reader.u8();
+    palette[i * 3 + 2] = reader.u8();
+  }
+  return palette;
+}
+
+function parseColorPointer(reader: Reader, xorBpp) {
+  const cacheIndex = reader.u16le();
+  const hotSpotX = reader.u16le();
+  const hotSpotY = reader.u16le();
+  const width = reader.u16le();
+  const height = reader.u16le();
+  const andMaskLength = reader.u16le();
+  const xorMaskLength = reader.u16le();
+  const xorMask = reader.raw(Math.min(xorMaskLength, reader.remaining)).slice();
+  const andMask = reader.raw(Math.min(andMaskLength, reader.remaining)).slice();
+
+  return {
+    kind: 'bitmap',
+    cacheIndex,
+    hotSpotX,
+    hotSpotY,
+    width,
+    height,
+    xorBpp: xorBpp || 24,
+    xorMask,
+    andMask,
+  };
+}
+
+export function parsePointerUpdate(reader: Reader) {
+  const messageType = reader.u16le();
+  reader.u16le(); // pad
+
+  if (messageType === POINTER_MESSAGE.POSITION) {
+    return { kind: 'position', x: reader.u16le(), y: reader.u16le() };
+  }
+
+  if (messageType === POINTER_MESSAGE.SYSTEM) {
+    const systemPointerType = reader.u32le();
+    return { kind: 'system', hidden: systemPointerType === 0x00000000 };
+  }
+
+  if (messageType === POINTER_MESSAGE.CACHED) {
+    return { kind: 'cached', cacheIndex: reader.u16le() };
+  }
+
+  if (messageType === POINTER_MESSAGE.COLOR) {
+    return parseColorPointer(reader, 24);
+  }
+
+  if (messageType === POINTER_MESSAGE.POINTER) {
+    const xorBpp = reader.u16le();
+    return parseColorPointer(reader, xorBpp);
+  }
+
+  if (messageType === POINTER_MESSAGE.LARGE) {
+    // Large pointers are only sent when advertised; treat as unsupported.
+    return { kind: 'unsupported', messageType };
+  }
+
+  return { kind: 'unsupported', messageType };
+}