ai-remote 0.1.0

package/src/protocols/rdp/rle.ts

@@ -0,0 +1,343 @@
+// Interleaved RLE bitmap decompression (MS-RDPEGDI 3.1.9) plus the pixel
+// conversion that turns decoded pixels into something a canvas can accept.
+//
+// Pixels are decoded into a Uint32Array of raw values first, so one copy of the
+// algorithm serves every colour depth; only the final conversion to RGBA knows
+// how a pixel is laid out.
+
+const REGULAR_BG_RUN = 0x00;
+const REGULAR_FG_RUN = 0x01;
+const REGULAR_FGBG_IMAGE = 0x02;
+const REGULAR_COLOR_RUN = 0x03;
+const REGULAR_COLOR_IMAGE = 0x04;
+const LITE_SET_FG_FG_RUN = 0x0c;
+const LITE_SET_FG_FGBG_IMAGE = 0x0d;
+const LITE_DITHERED_RUN = 0x0e;
+const MEGA_MEGA_BG_RUN = 0xf0;
+const MEGA_MEGA_FG_RUN = 0xf1;
+const MEGA_MEGA_FGBG_IMAGE = 0xf2;
+const MEGA_MEGA_COLOR_RUN = 0xf3;
+const MEGA_MEGA_COLOR_IMAGE = 0xf4;
+const MEGA_MEGA_SET_FG_RUN = 0xf6;
+const MEGA_MEGA_SET_FGBG_IMAGE = 0xf7;
+const MEGA_MEGA_DITHERED_RUN = 0xf8;
+const SPECIAL_FGBG_1 = 0xf9;
+const SPECIAL_FGBG_2 = 0xfa;
+const SPECIAL_WHITE = 0xfd;
+const SPECIAL_BLACK = 0xfe;
+
+const MASK_SPECIAL_FGBG_1 = 0x03;
+const MASK_SPECIAL_FGBG_2 = 0x05;
+
+/** Regular orders pack the code in the top bits; LITE and MEGA use a nibble. */
+function extractCodeId(header: number) {
+  if ((header & 0xc0) !== 0xc0) return header >> 5;
+  if ((header & 0xf0) === 0xf0) return header;
+  return header >> 4;
+}
+
+export function rleDecompress(src: Uint8Array, width: number, height: number, bytesPerPixel: number) {
+  const pixels = new Uint32Array(width * height);
+  const white = bytesPerPixel >= 4 ? 0xffffffff : (1 << (bytesPerPixel * 8)) - 1;
+
+  let srcOffset = 0;
+  let dest = 0;
+  let foreground = white;
+  let insertForegroundPixel = false;
+  let firstLine = true;
+
+  const readPixel = () => {
+    let value = 0;
+    for (let i = 0; i < bytesPerPixel; i++) value |= src[srcOffset + i] << (i * 8);
+    srcOffset += bytesPerPixel;
+    return value >>> 0;
+  };
+
+  const runLengthOf = (code: number) => {
+    const header = src[srcOffset];
+
+    if (code === REGULAR_FGBG_IMAGE) {
+      const packed = header & 0x1f;
+      if (packed === 0) {
+        srcOffset += 2;
+        return src[srcOffset - 1] + 1;
+      }
+      srcOffset += 1;
+      return packed * 8;
+    }
+
+    if (code === LITE_SET_FG_FGBG_IMAGE) {
+      const packed = header & 0x0f;
+      if (packed === 0) {
+        srcOffset += 2;
+        return src[srcOffset - 1] + 1;
+      }
+      srcOffset += 1;
+      return packed * 8;
+    }
+
+    if (
+      code === REGULAR_BG_RUN ||
+      code === REGULAR_FG_RUN ||
+      code === REGULAR_COLOR_RUN ||
+      code === REGULAR_COLOR_IMAGE
+    ) {
+      const packed = header & 0x1f;
+      if (packed === 0) {
+        srcOffset += 2;
+        return src[srcOffset - 1] + 32;
+      }
+      srcOffset += 1;
+      return packed;
+    }
+
+    if (code === LITE_SET_FG_FG_RUN || code === LITE_DITHERED_RUN) {
+      const packed = header & 0x0f;
+      if (packed === 0) {
+        srcOffset += 2;
+        return src[srcOffset - 1] + 16;
+      }
+      srcOffset += 1;
+      return packed;
+    }
+
+    // Every MEGA_MEGA order carries a 16-bit run length.
+    const length = src[srcOffset + 1] | (src[srcOffset + 2] << 8);
+    srcOffset += 3;
+    return length;
+  };
+
+  /** Foreground/background image: one bit per pixel, least significant first. */
+  const writeFgBgImage = (bitmask: number, count: number) => {
+    let mask = 0x01;
+    for (let i = 0; i < count; i++) {
+      if (firstLine) {
+        pixels[dest] = bitmask & mask ? foreground : 0;
+      } else {
+        const above = pixels[dest - width];
+        pixels[dest] = bitmask & mask ? (above ^ foreground) >>> 0 : above;
+      }
+      dest++;
+      mask = (mask << 1) & 0xff;
+    }
+  };
+
+  while (srcOffset < src.length && dest < pixels.length) {
+    // The first scanline has no row above it to delta against. The switch
+    // happens between orders, so a run that crosses the boundary keeps
+    // first-line semantics throughout.
+    if (firstLine && dest >= width) firstLine = false;
+
+    const code = extractCodeId(src[srcOffset]);
+
+    if (code === REGULAR_BG_RUN || code === MEGA_MEGA_BG_RUN) {
+      let runLength = runLengthOf(code);
+
+      if (firstLine) {
+        if (insertForegroundPixel) {
+          pixels[dest++] = foreground;
+          runLength--;
+        }
+        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = 0;
+      } else {
+        if (insertForegroundPixel) {
+          pixels[dest] = (pixels[dest - width] ^ foreground) >>> 0;
+          dest++;
+          runLength--;
+        }
+        while (runLength-- > 0 && dest < pixels.length) {
+          pixels[dest] = pixels[dest - width];
+          dest++;
+        }
+      }
+
+      // Two background runs in a row mean a single foreground pixel between them.
+      insertForegroundPixel = true;
+      continue;
+    }
+
+    insertForegroundPixel = false;
+
+    switch (code) {
+      case REGULAR_FG_RUN:
+      case MEGA_MEGA_FG_RUN:
+      case LITE_SET_FG_FG_RUN:
+      case MEGA_MEGA_SET_FG_RUN: {
+        let runLength = runLengthOf(code);
+        if (code === LITE_SET_FG_FG_RUN || code === MEGA_MEGA_SET_FG_RUN) foreground = readPixel();
+
+        if (firstLine) {
+          while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = foreground;
+        } else {
+          while (runLength-- > 0 && dest < pixels.length) {
+            pixels[dest] = (pixels[dest - width] ^ foreground) >>> 0;
+            dest++;
+          }
+        }
+        break;
+      }
+
+      case LITE_DITHERED_RUN:
+      case MEGA_MEGA_DITHERED_RUN: {
+        let runLength = runLengthOf(code);
+        const pixelA = readPixel();
+        const pixelB = readPixel();
+        while (runLength-- > 0 && dest < pixels.length - 1) {
+          pixels[dest++] = pixelA;
+          pixels[dest++] = pixelB;
+        }
+        break;
+      }
+
+      case REGULAR_COLOR_RUN:
+      case MEGA_MEGA_COLOR_RUN: {
+        let runLength = runLengthOf(code);
+        const color = readPixel();
+        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = color;
+        break;
+      }
+
+      case REGULAR_FGBG_IMAGE:
+      case MEGA_MEGA_FGBG_IMAGE:
+      case LITE_SET_FG_FGBG_IMAGE:
+      case MEGA_MEGA_SET_FGBG_IMAGE: {
+        let runLength = runLengthOf(code);
+        if (code === LITE_SET_FG_FGBG_IMAGE || code === MEGA_MEGA_SET_FGBG_IMAGE) {
+          foreground = readPixel();
+        }
+
+        while (runLength > 8) {
+          writeFgBgImage(src[srcOffset++], 8);
+          runLength -= 8;
+        }
+        if (runLength > 0) writeFgBgImage(src[srcOffset++], runLength);
+        break;
+      }
+
+      case REGULAR_COLOR_IMAGE:
+      case MEGA_MEGA_COLOR_IMAGE: {
+        let runLength = runLengthOf(code);
+        while (runLength-- > 0 && dest < pixels.length) pixels[dest++] = readPixel();
+        break;
+      }
+
+      case SPECIAL_FGBG_1:
+        srcOffset++;
+        writeFgBgImage(MASK_SPECIAL_FGBG_1, 8);
+        break;
+
+      case SPECIAL_FGBG_2:
+        srcOffset++;
+        writeFgBgImage(MASK_SPECIAL_FGBG_2, 8);
+        break;
+
+      case SPECIAL_WHITE:
+        srcOffset++;
+        pixels[dest++] = white;
+        break;
+
+      case SPECIAL_BLACK:
+        srcOffset++;
+        pixels[dest++] = 0;
+        break;
+
+      default:
+        throw new Error(`RDP: unsupported bitmap compression order 0x${code.toString(16)}`);
+    }
+  }
+
+  return pixels;
+}
+
+/**
+ * Reverse the row order of a decoded rectangle. RDP stores bitmaps bottom-up
+ * and a canvas expects top-down, so without this every rectangle is painted
+ * upside down.
+ */
+export function flipRows(pixels: Uint8Array, width: number) {
+  if (width <= 0) return pixels;
+  const height = Math.floor(pixels.length / width);
+  if (height < 2) return pixels;
+
+  const flipped = new Uint32Array(pixels.length);
+  for (let y = 0; y < height; y++) {
+    flipped.set(pixels.subarray(y * width, (y + 1) * width), (height - 1 - y) * width);
+  }
+  return flipped;
+}
+
+/** Read uncompressed bitmap data, which RDP stores bottom-up. */
+export function readUncompressed(src: Uint8Array, width: number, height: number, bytesPerPixel: number) {
+  const pixels = new Uint32Array(width * height);
+
+  for (let y = 0; y < height; y++) {
+    // Source row 0 is the bottom row of the rectangle.
+    const destRow = (height - 1 - y) * width;
+    let offset = y * width * bytesPerPixel;
+    for (let x = 0; x < width; x++) {
+      let value = 0;
+      for (let i = 0; i < bytesPerPixel; i++) value |= src[offset + i] << (i * 8);
+      pixels[destRow + x] = value >>> 0;
+      offset += bytesPerPixel;
+    }
+  }
+
+  return pixels;
+}
+
+/** Expand raw pixel values into RGBA for putImageData. */
+export function pixelsToRgba(pixels: Uint8Array, bitsPerPixel: number, palette: Uint32Array) {
+  const rgba = new Uint8ClampedArray(pixels.length * 4);
+
+  for (let i = 0; i < pixels.length; i++) {
+    const value = pixels[i];
+    let r;
+    let g;
+    let b;
+
+    switch (bitsPerPixel) {
+      case 15:
+        r = ((value >> 10) & 0x1f) * 255 / 31;
+        g = ((value >> 5) & 0x1f) * 255 / 31;
+        b = (value & 0x1f) * 255 / 31;
+        break;
+      case 16:
+        r = ((value >> 11) & 0x1f) * 255 / 31;
+        g = ((value >> 5) & 0x3f) * 255 / 63;
+        b = (value & 0x1f) * 255 / 31;
+        break;
+      case 8: {
+        const index = (value & 0xff) * 3;
+        r = palette ? palette[index] : value;
+        g = palette ? palette[index + 1] : value;
+        b = palette ? palette[index + 2] : value;
+        break;
+      }
+      default: // 24 and 32 bits per pixel are both BGR in the low three bytes
+        r = (value >> 16) & 0xff;
+        g = (value >> 8) & 0xff;
+        b = value & 0xff;
+        break;
+    }
+
+    const offset = i * 4;
+    rgba[offset] = r;
+    rgba[offset + 1] = g;
+    rgba[offset + 2] = b;
+    rgba[offset + 3] = 255;
+  }
+
+  return rgba;
+}
+
+/** Decode one TS_BITMAP_DATA rectangle to RGBA. */
+export function decodeBitmapRect(rect: BitmapRect, palette: Uint32Array) {
+  const bytesPerPixel = Math.max(1, Math.ceil(rect.bitsPerPixel / 8));
+  const pixels = rect.compressed
+    // Compressed data has to be expanded in wire order, because its runs delta
+    // against the row above, so the flip to top-down happens afterwards.
+    ? flipRows(rleDecompress(rect.data, rect.width, rect.height, bytesPerPixel), rect.width)
+    : readUncompressed(rect.data, rect.width, rect.height, bytesPerPixel);
+
+  return pixelsToRgba(pixels, rect.bitsPerPixel, palette);
+}

package/src/protocols/rdp/sec.ts

@@ -0,0 +1,184 @@
+// RDP Standard Security layer (MS-RDPBCGR 2.2.8.1.1.2, 5.3).
+//
+// When the host negotiates TLS this layer stays inert: the host reports no
+// encryption method and the transport is already protected. With the RDP
+// security layer selected it owns the per-PDU MAC, the RC4 streams in both
+// directions, and the key rotation that RDP requires every 4096 PDUs.
+
+import { Reader, Writer, concatBytes } from './buffer';
+import {
+  ENCRYPTION_METHOD,
+  deriveSessionKeys,
+  macSignature,
+  rc4Crypt,
+  rc4Init,
+  updateSessionKey,
+} from './crypto';
+import { ENCRYPTION_LEVEL } from './gcc';
+
+export const SEC_FLAG = {
+  EXCHANGE_PKT: 0x0001,
+  TRANSPORT_REQ: 0x0002,
+  ENCRYPT: 0x0008,
+  RESET_SEQNO: 0x0010,
+  IGNORE_SEQNO: 0x0020,
+  INFO_PKT: 0x0040,
+  LICENSE_PKT: 0x0080,
+  LICENSE_ENCRYPT_CS: 0x0200,
+  REDIRECTION_PKT: 0x0400,
+  SECURE_CHECKSUM: 0x0800,
+  AUTODETECT_REQ: 0x1000,
+  AUTODETECT_RSP: 0x2000,
+  HEARTBEAT: 0x4000,
+};
+
+const KEY_ROTATION_INTERVAL = 4096;
+
+export class SecurityLayer {
+  private encryptionMethod: number;
+  private encryptionLevel: number;
+  private keys: SessionKeys | null;
+  private encryptState: Rc4State | null;
+  private decryptState: Rc4State | null;
+  private encryptedPdus: number;
+  private decryptedPdus: number;
+
+  constructor() {
+    this.encryptionMethod = ENCRYPTION_METHOD.NONE;
+    this.encryptionLevel = ENCRYPTION_LEVEL.NONE;
+    this.keys = null;
+    this.encryptState = null;
+    this.decryptState = null;
+    this.encryptedPdus = 0;
+    this.decryptedPdus = 0;
+  }
+
+  /** True when data PDUs carry a basic security header at all. */
+  get headerPresent() {
+    return this.encryptionLevel !== ENCRYPTION_LEVEL.NONE || this.encryptionMethod !== ENCRYPTION_METHOD.NONE;
+  }
+
+  get encryptionEnabled() {
+    return this.encryptionMethod !== ENCRYPTION_METHOD.NONE && this.keys !== null;
+  }
+
+  configure(encryptionMethod: number, encryptionLevel: number, clientRandom: Uint8Array, serverRandom: Uint8Array) {
+    this.encryptionMethod = encryptionMethod;
+    this.encryptionLevel = encryptionLevel;
+
+    if (encryptionMethod === ENCRYPTION_METHOD.NONE) return;
+    if (encryptionMethod & ENCRYPTION_METHOD.FIPS) {
+      throw new Error('RDP: this host requires FIPS encryption, which this client does not implement');
+    }
+
+    this.keys = deriveSessionKeys(clientRandom, serverRandom, encryptionMethod);
+    this.encryptState = rc4Init(this.keys.encryptKey);
+    this.decryptState = rc4Init(this.keys.decryptKey);
+  }
+
+  #rotateEncryptKey() {
+    this.keys.encryptKey = updateSessionKey(
+      this.keys.initialEncryptKey,
+      this.keys.encryptKey,
+      this.keys.keyLength,
+      this.keys.is40Bit
+    );
+    this.encryptState = rc4Init(this.keys.encryptKey);
+    this.encryptedPdus = 0;
+  }
+
+  #rotateDecryptKey() {
+    this.keys.decryptKey = updateSessionKey(
+      this.keys.initialDecryptKey,
+      this.keys.decryptKey,
+      this.keys.keyLength,
+      this.keys.is40Bit
+    );
+    this.decryptState = rc4Init(this.keys.decryptKey);
+    this.decryptedPdus = 0;
+  }
+
+  /**
+   * Prefix a payload with the basic security header, signing and encrypting it
+   * when the negotiated level asks for that.
+   *
+   * `flags` carries the PDU-kind bits (SEC_INFO_PKT and friends). A payload with
+   * no flags and no encryption needs no header at all.
+   */
+  wrap(payload: Uint8Array, flags = 0) {
+    const encrypt = this.encryptionEnabled;
+    if (!encrypt && flags === 0 && !this.headerPresent) return payload;
+
+    const writer = new Writer(payload.length + 16);
+    writer.u16le(flags | (encrypt ? SEC_FLAG.ENCRYPT : 0));
+    writer.u16le(0); // flagsHi, reserved
+
+    if (!encrypt) {
+      writer.raw(payload);
+      return writer.take();
+    }
+
+    // The MAC covers the plaintext, and is sent alongside the ciphertext.
+    writer.raw(macSignature(this.keys.macKey, payload));
+    writer.raw(rc4Crypt(this.encryptState, payload));
+
+    if (++this.encryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateEncryptKey();
+    return writer.take();
+  }
+
+  /**
+   * Strip (and if needed decrypt) the basic security header from a host PDU.
+   * `headerMandatory` forces the header to be read even when the host reported
+   * no encryption, which licensing PDUs require.
+   */
+  unwrap(bytes: Uint8Array, headerMandatory = false) {
+    if (!this.headerPresent && !headerMandatory) return { flags: 0, payload: bytes };
+    if (bytes.length < 4) return { flags: 0, payload: bytes };
+
+    const reader = new Reader(bytes);
+    const flags = reader.u16le();
+    reader.u16le(); // flagsHi
+
+    if (!(flags & SEC_FLAG.ENCRYPT)) {
+      return { flags, payload: reader.rest() };
+    }
+    if (!this.encryptionEnabled) {
+      throw new Error('RDP: the host encrypted a PDU before the session keys existed');
+    }
+
+    reader.skip(8); // dataSignature -- verified implicitly by the stream decrypting
+    const payload = rc4Crypt(this.decryptState, reader.rest());
+
+    if (++this.decryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateDecryptKey();
+    return { flags, payload };
+  }
+
+  /**
+   * Fast-path output carries the same signature and RC4 stream as a slow-path
+   * PDU, but without the basic security header in front of it.
+   */
+  decryptFastPath(payload: Uint8Array) {
+    if (!this.encryptionEnabled) return payload;
+    if (payload.length <= 8) return payload;
+
+    const decrypted = rc4Crypt(this.decryptState, payload.subarray(8));
+    if (++this.decryptedPdus === KEY_ROTATION_INTERVAL) this.#rotateDecryptKey();
+    return decrypted;
+  }
+
+  /**
+   * Security Exchange PDU (MS-RDPBCGR 2.2.1.10): the client random encrypted
+   * with the host public key, followed by eight bytes of padding.
+   */
+  static securityExchange(encryptedClientRandom) {
+    const writer = new Writer(encryptedClientRandom.length + 16);
+    writer.u16le(SEC_FLAG.EXCHANGE_PKT);
+    writer.u16le(0);
+    writer.u32le(encryptedClientRandom.length + 8);
+    writer.raw(encryptedClientRandom);
+    writer.zeros(8);
+    return writer.take();
+  }
+}
+
+export { concatBytes };