ai-remote 0.1.0

package/dist/protocols/rdp/credssp.js

@@ -0,0 +1,254 @@
+import { concatBytes } from "./buffer";
+import { NtlmSealer, authenticateMessage, negotiateMessage, parseChallengeMessage } from "./ntlm";
+const CREDSSP_VERSION = 6;
+const CLIENT_TO_SERVER_MAGIC = "CredSSP Client-To-Server Binding Hash\0";
+const SERVER_TO_CLIENT_MAGIC = "CredSSP Server-To-Client Binding Hash\0";
+const NT_STATUS_MESSAGES = {
+  3221225581: "The host rejected the username or password (STATUS_LOGON_FAILURE).",
+  3221225582: "The account is not allowed to sign in right now (STATUS_ACCOUNT_RESTRICTION).",
+  3221225583: "The account is outside its permitted logon hours.",
+  3221225584: "The account is not allowed to sign in from this machine (STATUS_INVALID_WORKSTATION).",
+  3221225585: "The account password has expired.",
+  3221225586: "The account is disabled.",
+  3221225819: "The account is not allowed the Remote Desktop logon type -- add it to the Remote Desktop Users group.",
+  3221225875: "The account has expired.",
+  3221226020: "The account must change its password before signing in.",
+  3221226036: "The account is locked out.",
+  2148074252: "The host denied the logon (SEC_E_LOGON_DENIED).",
+  2148074248: "The host rejected the authentication token (SEC_E_INVALID_TOKEN).",
+  2148074242: "The host rejected the CredSSP exchange (SEC_E_UNSUPPORTED_FUNCTION) -- usually a public-key binding mismatch."
+};
+function derLength(length) {
+  if (length < 128) return new Uint8Array([length]);
+  if (length <= 255) return new Uint8Array([129, length]);
+  if (length <= 65535) return new Uint8Array([130, length >> 8, length & 255]);
+  return new Uint8Array([131, length >> 16 & 255, length >> 8 & 255, length & 255]);
+}
+const derTlv = (tag, content) => concatBytes(new Uint8Array([tag]), derLength(content.length), content);
+const derSequence = (...parts) => derTlv(48, concatBytes(...parts));
+const derOctetString = (bytes) => derTlv(4, bytes);
+const derContext = (index, content) => derTlv(160 | index, content);
+function derInteger(value) {
+  const bytes = [];
+  let remaining = value;
+  do {
+    bytes.unshift(remaining & 255);
+    remaining >>>= 8;
+  } while (remaining > 0);
+  if (bytes[0] & 128) bytes.unshift(0);
+  return derTlv(2, new Uint8Array(bytes));
+}
+function derRead(bytes, offset) {
+  const tag = bytes[offset];
+  let cursor = offset + 1;
+  let length = bytes[cursor++];
+  if (length & 128) {
+    const count = length & 127;
+    length = 0;
+    for (let i = 0; i < count; i++) length = length << 8 | bytes[cursor++];
+  }
+  return { tag, content: bytes.subarray(cursor, cursor + length), end: cursor + length };
+}
+function derElementLength(bytes, offset = 0) {
+  if (bytes.length - offset < 2) return 0;
+  let cursor = offset + 1;
+  let length = bytes[cursor++];
+  if (length & 128) {
+    const count = length & 127;
+    if (bytes.length - cursor < count) return 0;
+    length = 0;
+    for (let i = 0; i < count; i++) length = length << 8 | bytes[cursor++];
+  }
+  const total = cursor - offset + length;
+  return bytes.length - offset < total ? 0 : total;
+}
+function encodeTsRequest({ version, negoToken, authInfo, pubKeyAuth, clientNonce }) {
+  const parts = [derContext(0, derInteger(version))];
+  if (negoToken) {
+    parts.push(derContext(1, derSequence(derSequence(derContext(0, derOctetString(negoToken))))));
+  }
+  if (authInfo) parts.push(derContext(2, derOctetString(authInfo)));
+  if (pubKeyAuth) parts.push(derContext(3, derOctetString(pubKeyAuth)));
+  if (clientNonce) parts.push(derContext(5, derOctetString(clientNonce)));
+  return derSequence(...parts);
+}
+function decodeTsRequest(bytes) {
+  const outer = derRead(bytes, 0);
+  const result = { version: 0, negoToken: null, authInfo: null, pubKeyAuth: null, errorCode: 0 };
+  let offset = 0;
+  while (offset < outer.content.length) {
+    const field = derRead(outer.content, offset);
+    offset = field.end;
+    const index = field.tag & 31;
+    if (index === 0) {
+      result.version = derRead(field.content, 0).content[0];
+      continue;
+    }
+    if (index === 1) {
+      const sequence = derRead(field.content, 0);
+      const item = derRead(sequence.content, 0);
+      const token = derRead(item.content, 0);
+      result.negoToken = derRead(token.content, 0).content;
+      continue;
+    }
+    if (index === 2) {
+      result.authInfo = derRead(field.content, 0).content;
+      continue;
+    }
+    if (index === 3) {
+      result.pubKeyAuth = derRead(field.content, 0).content;
+      continue;
+    }
+    if (index === 4) {
+      const value = derRead(field.content, 0).content;
+      let code = 0;
+      for (const byte of value) code = (code << 8 | byte) >>> 0;
+      result.errorCode = code;
+      continue;
+    }
+  }
+  return result;
+}
+function encodeCredentials(domain, username, password) {
+  const utf16 = (text) => {
+    const out = new Uint8Array(text.length * 2);
+    const view = new DataView(out.buffer);
+    for (let i = 0; i < text.length; i++) view.setUint16(i * 2, text.charCodeAt(i), true);
+    return out;
+  };
+  const passwordCreds = derSequence(
+    derContext(0, derOctetString(utf16(domain))),
+    derContext(1, derOctetString(utf16(username))),
+    derContext(2, derOctetString(utf16(password)))
+  );
+  return derSequence(
+    derContext(0, derInteger(1)),
+    // credType: password
+    derContext(1, derOctetString(passwordCreds))
+  );
+}
+class CredSspClient {
+  username;
+  domain;
+  password;
+  serverPublicKey;
+  send;
+  log;
+  inbound;
+  waiters;
+  constructor({ username, domain, password, serverPublicKey, send, log }) {
+    this.username = username || "";
+    this.domain = domain || "";
+    this.password = password || "";
+    this.serverPublicKey = serverPublicKey;
+    this.send = send;
+    this.log = log || (() => {
+    });
+    this.inbound = new Uint8Array(0);
+    this.waiters = [];
+  }
+  /** Feed decrypted TLS application data. */
+  receive(bytes) {
+    this.inbound = this.inbound.length === 0 ? bytes : concatBytes(this.inbound, bytes);
+    for (; ; ) {
+      const length = derElementLength(this.inbound);
+      if (length === 0) return;
+      const request = decodeTsRequest(this.inbound.subarray(0, length));
+      this.inbound = this.inbound.subarray(length).slice();
+      const waiter = this.waiters.shift();
+      if (waiter) waiter.resolve(request);
+    }
+  }
+  #next(timeoutMs = 15e3) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("CredSSP: the host did not answer within 15s")),
+        timeoutMs
+      );
+      this.waiters.push({
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        }
+      });
+    });
+  }
+  async #bindingHash(magic, nonce) {
+    const digest = await crypto.subtle.digest(
+      "SHA-256",
+      concatBytes(new TextEncoder().encode(magic), nonce, this.serverPublicKey)
+    );
+    return new Uint8Array(digest);
+  }
+  async authenticate() {
+    const negotiate = negotiateMessage();
+    this.send(encodeTsRequest({ version: CREDSSP_VERSION, negoToken: negotiate }));
+    this.log("CredSSP", "sent NTLM NEGOTIATE");
+    const challengeRequest = await this.#next();
+    if (challengeRequest.errorCode) throw new Error(this.#statusMessage(challengeRequest.errorCode));
+    if (!challengeRequest.negoToken) throw new Error("CredSSP: the host sent no NTLM challenge");
+    const challengeBytes = challengeRequest.negoToken.slice();
+    const challenge = parseChallengeMessage(challengeBytes);
+    const targetName = new TextDecoder("utf-16le").decode(challenge.targetName);
+    this.log("CredSSP", `received NTLM CHALLENGE from "${targetName}" (host CredSSP version ${challengeRequest.version})`);
+    if (!this.username) {
+      return {
+        authenticated: false,
+        reachedChallenge: true,
+        hostVersion: challengeRequest.version,
+        targetName,
+        note: "no credentials supplied, stopping after the challenge"
+      };
+    }
+    const { message, keys } = authenticateMessage({
+      username: this.username,
+      domain: this.domain,
+      password: this.password,
+      challenge,
+      negotiateBytes: negotiate,
+      challengeBytes
+    });
+    const sealer = new NtlmSealer(keys);
+    const clientNonce = new Uint8Array(32);
+    crypto.getRandomValues(clientNonce);
+    const legacy = challengeRequest.version < 5;
+    const binding = legacy ? this.serverPublicKey : await this.#bindingHash(CLIENT_TO_SERVER_MAGIC, clientNonce);
+    this.send(encodeTsRequest({
+      version: CREDSSP_VERSION,
+      negoToken: message,
+      pubKeyAuth: sealer.seal(binding),
+      clientNonce: legacy ? null : clientNonce
+    }));
+    this.log("CredSSP", `sent NTLM AUTHENTICATE with the ${legacy ? "legacy" : "hashed"} public-key binding`);
+    const response = await this.#next();
+    if (response.errorCode) throw new Error(this.#statusMessage(response.errorCode));
+    if (!response.pubKeyAuth) throw new Error("CredSSP: the host returned no public-key confirmation");
+    const confirmed = sealer.unseal(response.pubKeyAuth);
+    const expected = legacy ? this.#incrementedPublicKey() : await this.#bindingHash(SERVER_TO_CLIENT_MAGIC, clientNonce);
+    if (confirmed.length !== expected.length || !expected.every((byte, i) => byte === confirmed[i])) {
+      throw new Error(
+        "CredSSP: the host public-key confirmation did not match. The TLS session is not the one the host authenticated, which is what this check exists to catch."
+      );
+    }
+    this.log("CredSSP", "host confirmed the public-key binding");
+    this.send(encodeTsRequest({
+      version: CREDSSP_VERSION,
+      authInfo: sealer.seal(encodeCredentials(this.domain, this.username, this.password))
+    }));
+    this.log("CredSSP", "sent credentials");
+    return { authenticated: true, hostVersion: challengeRequest.version, targetName };
+  }
+  /** Legacy confirmation is the public key with its first byte incremented. */
+  #incrementedPublicKey() {
+    const expected = this.serverPublicKey.slice();
+    expected[0] = expected[0] + 1 & 255;
+    return expected;
+  }
+  #statusMessage(errorCode) {
+    return NT_STATUS_MESSAGES[errorCode] || `CredSSP: the host reported error 0x${errorCode.toString(16).padStart(8, "0")}.`;
+  }
+}
+export {
+  CredSspClient
+};
+//# sourceMappingURL=credssp.js.map

package/dist/protocols/rdp/credssp.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocols/rdp/credssp.ts"],
+  "sourcesContent": ["// CredSSP (MS-CSSP): the protocol behind RDP's Network Level Authentication.\n//\n// It runs inside the TLS channel and does three things in order: authenticate\n// with NTLM, prove to the host that the TLS certificate we were shown is the\n// one the host actually holds, and only then hand over the credentials. The\n// second step is why this gateway needs its own TLS client -- the proof is\n// computed over the host certificate's public key, which no runtime here\n// exposes for a TLS session it established on our behalf.\n\nimport { concatBytes } from './buffer';\nimport { NtlmSealer, authenticateMessage, negotiateMessage, parseChallengeMessage } from './ntlm';\n\nconst CREDSSP_VERSION = 6;\n\n// MS-CSSP 3.1.5: from version 5 the binding is a hash over a client nonce and\n// the public key, rather than the bare public key.\nconst CLIENT_TO_SERVER_MAGIC = 'CredSSP Client-To-Server Binding Hash\\0';\nconst SERVER_TO_CLIENT_MAGIC = 'CredSSP Server-To-Client Binding Hash\\0';\n\nconst NT_STATUS_MESSAGES = {\n  0xc000006d: 'The host rejected the username or password (STATUS_LOGON_FAILURE).',\n  0xc000006e: 'The account is not allowed to sign in right now (STATUS_ACCOUNT_RESTRICTION).',\n  0xc000006f: 'The account is outside its permitted logon hours.',\n  0xc0000070: 'The account is not allowed to sign in from this machine (STATUS_INVALID_WORKSTATION).',\n  0xc0000071: 'The account password has expired.',\n  0xc0000072: 'The account is disabled.',\n  0xc000015b: 'The account is not allowed the Remote Desktop logon type -- add it to the Remote Desktop Users group.',\n  0xc0000193: 'The account has expired.',\n  0xc0000224: 'The account must change its password before signing in.',\n  0xc0000234: 'The account is locked out.',\n  0x8009030c: 'The host denied the logon (SEC_E_LOGON_DENIED).',\n  0x80090308: 'The host rejected the authentication token (SEC_E_INVALID_TOKEN).',\n  0x80090302: 'The host rejected the CredSSP exchange (SEC_E_UNSUPPORTED_FUNCTION) -- usually a public-key binding mismatch.',\n};\n\n// --- DER --------------------------------------------------------------------\n\nfunction derLength(length: number) {\n  if (length < 0x80) return new Uint8Array([length]);\n  if (length <= 0xff) return new Uint8Array([0x81, length]);\n  if (length <= 0xffff) return new Uint8Array([0x82, length >> 8, length & 0xff]);\n  return new Uint8Array([0x83, (length >> 16) & 0xff, (length >> 8) & 0xff, length & 0xff]);\n}\n\nconst derTlv = (tag, content: Uint8Array) => concatBytes(new Uint8Array([tag]), derLength(content.length), content);\nconst derSequence = (...parts) => derTlv(0x30, concatBytes(...parts));\nconst derOctetString = (bytes: Uint8Array) => derTlv(0x04, bytes);\nconst derContext = (index, content: Uint8Array) => derTlv(0xa0 | index, content);\n\nfunction derInteger(value) {\n  const bytes = [];\n  let remaining = value;\n  do {\n    bytes.unshift(remaining & 0xff);\n    remaining >>>= 8;\n  } while (remaining > 0);\n  // A leading bit of 1 would read as negative.\n  if (bytes[0] & 0x80) bytes.unshift(0x00);\n  return derTlv(0x02, new Uint8Array(bytes));\n}\n\nfunction derRead(bytes: Uint8Array, offset: number) {\n  const tag = bytes[offset];\n  let cursor = offset + 1;\n  let length = bytes[cursor++];\n\n  if (length & 0x80) {\n    const count = length & 0x7f;\n    length = 0;\n    for (let i = 0; i < count; i++) length = (length << 8) | bytes[cursor++];\n  }\n\n  return { tag, content: bytes.subarray(cursor, cursor + length), end: cursor + length };\n}\n\n/** Total encoded length of the DER element starting at `offset`, or 0 if partial. */\nfunction derElementLength(bytes: Uint8Array, offset = 0) {\n  if (bytes.length - offset < 2) return 0;\n  let cursor = offset + 1;\n  let length = bytes[cursor++];\n\n  if (length & 0x80) {\n    const count = length & 0x7f;\n    if (bytes.length - cursor < count) return 0;\n    length = 0;\n    for (let i = 0; i < count; i++) length = (length << 8) | bytes[cursor++];\n  }\n\n  const total = cursor - offset + length;\n  return bytes.length - offset < total ? 0 : total;\n}\n\nfunction encodeTsRequest({ version, negoToken, authInfo, pubKeyAuth, clientNonce }) {\n  const parts = [derContext(0, derInteger(version))];\n\n  if (negoToken) {\n    parts.push(derContext(1, derSequence(derSequence(derContext(0, derOctetString(negoToken))))));\n  }\n  if (authInfo) parts.push(derContext(2, derOctetString(authInfo)));\n  if (pubKeyAuth) parts.push(derContext(3, derOctetString(pubKeyAuth)));\n  if (clientNonce) parts.push(derContext(5, derOctetString(clientNonce)));\n\n  return derSequence(...parts);\n}\n\nfunction decodeTsRequest(bytes: Uint8Array) {\n  const outer = derRead(bytes, 0);\n  const result = { version: 0, negoToken: null, authInfo: null, pubKeyAuth: null, errorCode: 0 };\n\n  let offset = 0;\n  while (offset < outer.content.length) {\n    const field = derRead(outer.content, offset);\n    offset = field.end;\n    const index = field.tag & 0x1f;\n\n    if (index === 0) {\n      result.version = derRead(field.content, 0).content[0];\n      continue;\n    }\n    if (index === 1) {\n      const sequence = derRead(field.content, 0);       // SEQUENCE OF\n      const item = derRead(sequence.content, 0);        // SEQUENCE\n      const token = derRead(item.content, 0);           // [0] OCTET STRING\n      result.negoToken = derRead(token.content, 0).content;\n      continue;\n    }\n    if (index === 2) {\n      result.authInfo = derRead(field.content, 0).content;\n      continue;\n    }\n    if (index === 3) {\n      result.pubKeyAuth = derRead(field.content, 0).content;\n      continue;\n    }\n    if (index === 4) {\n      const value = derRead(field.content, 0).content;\n      let code = 0;\n      for (const byte of value) code = ((code << 8) | byte) >>> 0;\n      result.errorCode = code;\n      continue;\n    }\n  }\n\n  return result;\n}\n\n/** TSCredentials wrapping TSPasswordCreds (MS-CSSP 2.2.1.2). */\nfunction encodeCredentials(domain: string, username: string, password: string) {\n  const utf16 = (text: string) => {\n    const out = new Uint8Array(text.length * 2);\n    const view = new DataView(out.buffer);\n    for (let i = 0; i < text.length; i++) view.setUint16(i * 2, text.charCodeAt(i), true);\n    return out;\n  };\n\n  const passwordCreds = derSequence(\n    derContext(0, derOctetString(utf16(domain))),\n    derContext(1, derOctetString(utf16(username))),\n    derContext(2, derOctetString(utf16(password)))\n  );\n\n  return derSequence(\n    derContext(0, derInteger(1)), // credType: password\n    derContext(1, derOctetString(passwordCreds))\n  );\n}\n\nexport class CredSspClient {\n  private readonly username: string;\n  private readonly domain: string;\n  private readonly password: string;\n  private readonly serverPublicKey: Uint8Array;\n  private readonly send: (bytes: Uint8Array) => void;\n  private readonly log: (message: string, detail?: unknown) => void;\n  private inbound: Uint8Array;\n  private waiters: Array<{ resolve: (bytes: Uint8Array) => void; reject: (error: Error) => void }>;\n\n  constructor({ username, domain, password, serverPublicKey, send, log }) {\n    this.username = username || '';\n    this.domain = domain || '';\n    this.password = password || '';\n    this.serverPublicKey = serverPublicKey;\n    this.send = send;\n    this.log = log || (() => {});\n\n    this.inbound = new Uint8Array(0);\n    this.waiters = [];\n  }\n\n  /** Feed decrypted TLS application data. */\n  receive(bytes: Uint8Array) {\n    this.inbound = this.inbound.length === 0 ? bytes : concatBytes(this.inbound, bytes);\n\n    // TSRequests are self-delimiting, so several can share one TLS record.\n    for (;;) {\n      const length = derElementLength(this.inbound);\n      if (length === 0) return;\n\n      const request = decodeTsRequest(this.inbound.subarray(0, length));\n      this.inbound = this.inbound.subarray(length).slice();\n\n      const waiter = this.waiters.shift();\n      if (waiter) waiter.resolve(request);\n    }\n  }\n\n  #next(timeoutMs = 15000) {\n    return new Promise((resolve, reject) => {\n      const timer = setTimeout(\n        () => reject(new Error('CredSSP: the host did not answer within 15s')),\n        timeoutMs\n      );\n      this.waiters.push({\n        resolve: (value) => {\n          clearTimeout(timer);\n          resolve(value);\n        },\n      });\n    });\n  }\n\n  async #bindingHash(magic, nonce) {\n    const digest = await crypto.subtle.digest(\n      'SHA-256',\n      concatBytes(new TextEncoder().encode(magic), nonce, this.serverPublicKey)\n    );\n    return new Uint8Array(digest);\n  }\n\n  async authenticate() {\n    const negotiate = negotiateMessage();\n    this.send(encodeTsRequest({ version: CREDSSP_VERSION, negoToken: negotiate }));\n    this.log('CredSSP', 'sent NTLM NEGOTIATE');\n\n    const challengeRequest = await this.#next();\n    if (challengeRequest.errorCode) throw new Error(this.#statusMessage(challengeRequest.errorCode));\n    if (!challengeRequest.negoToken) throw new Error('CredSSP: the host sent no NTLM challenge');\n\n    const challengeBytes = challengeRequest.negoToken.slice();\n    const challenge = parseChallengeMessage(challengeBytes);\n    const targetName = new TextDecoder('utf-16le').decode(challenge.targetName);\n    this.log('CredSSP', `received NTLM CHALLENGE from \"${targetName}\" (host CredSSP version ${challengeRequest.version})`);\n\n    if (!this.username) {\n      return {\n        authenticated: false,\n        reachedChallenge: true,\n        hostVersion: challengeRequest.version,\n        targetName,\n        note: 'no credentials supplied, stopping after the challenge',\n      };\n    }\n\n    const { message, keys } = authenticateMessage({\n      username: this.username,\n      domain: this.domain,\n      password: this.password,\n      challenge,\n      negotiateBytes: negotiate,\n      challengeBytes,\n    });\n\n    const sealer = new NtlmSealer(keys);\n    const clientNonce = new Uint8Array(32);\n    crypto.getRandomValues(clientNonce);\n\n    // Hosts older than CredSSP 5 expect the bare public key instead of a hash.\n    const legacy = challengeRequest.version < 5;\n    const binding = legacy\n      ? this.serverPublicKey\n      : await this.#bindingHash(CLIENT_TO_SERVER_MAGIC, clientNonce);\n\n    this.send(encodeTsRequest({\n      version: CREDSSP_VERSION,\n      negoToken: message,\n      pubKeyAuth: sealer.seal(binding),\n      clientNonce: legacy ? null : clientNonce,\n    }));\n    this.log('CredSSP', `sent NTLM AUTHENTICATE with the ${legacy ? 'legacy' : 'hashed'} public-key binding`);\n\n    const response = await this.#next();\n    if (response.errorCode) throw new Error(this.#statusMessage(response.errorCode));\n    if (!response.pubKeyAuth) throw new Error('CredSSP: the host returned no public-key confirmation');\n\n    const confirmed = sealer.unseal(response.pubKeyAuth);\n    const expected = legacy\n      ? this.#incrementedPublicKey()\n      : await this.#bindingHash(SERVER_TO_CLIENT_MAGIC, clientNonce);\n\n    if (confirmed.length !== expected.length || !expected.every((byte, i) => byte === confirmed[i])) {\n      throw new Error(\n        'CredSSP: the host public-key confirmation did not match. The TLS session is not the one the host authenticated, which is what this check exists to catch.'\n      );\n    }\n    this.log('CredSSP', 'host confirmed the public-key binding');\n\n    this.send(encodeTsRequest({\n      version: CREDSSP_VERSION,\n      authInfo: sealer.seal(encodeCredentials(this.domain, this.username, this.password)),\n    }));\n    this.log('CredSSP', 'sent credentials');\n\n    return { authenticated: true, hostVersion: challengeRequest.version, targetName };\n  }\n\n  /** Legacy confirmation is the public key with its first byte incremented. */\n  #incrementedPublicKey() {\n    const expected = this.serverPublicKey.slice();\n    expected[0] = (expected[0] + 1) & 0xff;\n    return expected;\n  }\n\n  #statusMessage(errorCode) {\n    return (\n      NT_STATUS_MESSAGES[errorCode] ||\n      `CredSSP: the host reported error 0x${errorCode.toString(16).padStart(8, '0')}.`\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/protocols/rdp/crypto.js

@@ -0,0 +1,369 @@
+const MD5_SHIFTS = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+];
+const MD5_K = new Uint32Array(
+  Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296))
+);
+function rotl32(value, count) {
+  return value << count | value >>> 32 - count;
+}
+function md5(message) {
+  const bitLength = message.length * 8;
+  const blockCount = Math.floor((message.length + 8) / 64) + 1;
+  const padded = new Uint8Array(blockCount * 64);
+  padded.set(message);
+  padded[message.length] = 128;
+  const tail = new DataView(padded.buffer, padded.byteLength - 8, 8);
+  tail.setUint32(0, bitLength >>> 0, true);
+  tail.setUint32(4, Math.floor(bitLength / 4294967296), true);
+  let a0 = 1732584193, b0 = 4023233417, c0 = 2562383102, d0 = 271733878;
+  const words = new Uint32Array(16);
+  const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+  for (let block = 0; block < blockCount; block++) {
+    for (let i = 0; i < 16; i++) words[i] = view.getUint32(block * 64 + i * 4, true);
+    let a = a0, b = b0, c = c0, d = d0;
+    for (let i = 0; i < 64; i++) {
+      let f;
+      let g;
+      if (i < 16) {
+        f = b & c | ~b & d;
+        g = i;
+      } else if (i < 32) {
+        f = d & b | ~d & c;
+        g = (5 * i + 1) % 16;
+      } else if (i < 48) {
+        f = b ^ c ^ d;
+        g = (3 * i + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        g = 7 * i % 16;
+      }
+      const temp = d;
+      d = c;
+      c = b;
+      const sum = a + f + MD5_K[i] + words[g] | 0;
+      b = b + rotl32(sum, MD5_SHIFTS[i]) | 0;
+      a = temp;
+    }
+    a0 = a0 + a | 0;
+    b0 = b0 + b | 0;
+    c0 = c0 + c | 0;
+    d0 = d0 + d | 0;
+  }
+  const digest = new Uint8Array(16);
+  const out = new DataView(digest.buffer);
+  out.setUint32(0, a0 >>> 0, true);
+  out.setUint32(4, b0 >>> 0, true);
+  out.setUint32(8, c0 >>> 0, true);
+  out.setUint32(12, d0 >>> 0, true);
+  return digest;
+}
+function sha1(message) {
+  const bitLength = message.length * 8;
+  const blockCount = Math.floor((message.length + 8) / 64) + 1;
+  const padded = new Uint8Array(blockCount * 64);
+  padded.set(message);
+  padded[message.length] = 128;
+  const tail = new DataView(padded.buffer, padded.byteLength - 8, 8);
+  tail.setUint32(0, Math.floor(bitLength / 4294967296));
+  tail.setUint32(4, bitLength >>> 0);
+  let h0 = 1732584193, h1 = 4023233417, h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
+  const words = new Uint32Array(80);
+  const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+  for (let block = 0; block < blockCount; block++) {
+    for (let i = 0; i < 16; i++) words[i] = view.getUint32(block * 64 + i * 4);
+    for (let i = 16; i < 80; i++) {
+      words[i] = rotl32(words[i - 3] ^ words[i - 8] ^ words[i - 14] ^ words[i - 16], 1);
+    }
+    let a = h0, b = h1, c = h2, d = h3, e = h4;
+    for (let i = 0; i < 80; i++) {
+      let f;
+      let k;
+      if (i < 20) {
+        f = b & c | ~b & d;
+        k = 1518500249;
+      } else if (i < 40) {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      } else if (i < 60) {
+        f = b & c | b & d | c & d;
+        k = 2400959708;
+      } else {
+        f = b ^ c ^ d;
+        k = 3395469782;
+      }
+      const temp = rotl32(a, 5) + f + e + k + words[i] | 0;
+      e = d;
+      d = c;
+      c = rotl32(b, 30);
+      b = a;
+      a = temp;
+    }
+    h0 = h0 + a | 0;
+    h1 = h1 + b | 0;
+    h2 = h2 + c | 0;
+    h3 = h3 + d | 0;
+    h4 = h4 + e | 0;
+  }
+  const digest = new Uint8Array(20);
+  const out = new DataView(digest.buffer);
+  [h0, h1, h2, h3, h4].forEach((word, i) => out.setUint32(i * 4, word >>> 0));
+  return digest;
+}
+function rc4Init(key) {
+  const s = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) s[i] = i;
+  let j = 0;
+  for (let i = 0; i < 256; i++) {
+    j = j + (s[i] ?? 0) + (key[i % key.length] ?? 0) & 255;
+    const t = s[i] ?? 0;
+    s[i] = s[j] ?? 0;
+    s[j] = t;
+  }
+  return { s, i: 0, j: 0 };
+}
+function rc4Crypt(state, data) {
+  const out = new Uint8Array(data.length);
+  const { s } = state;
+  let { i, j } = state;
+  for (let n = 0; n < data.length; n++) {
+    i = i + 1 & 255;
+    j = j + s[i] & 255;
+    const t = s[i];
+    s[i] = s[j];
+    s[j] = t;
+    out[n] = data[n] ^ s[s[i] + s[j] & 255];
+  }
+  state.i = i;
+  state.j = j;
+  return out;
+}
+function bigIntFromLe(bytes) {
+  let value = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) value = value << 8n | BigInt(bytes[i]);
+  return value;
+}
+function bigIntToLe(value, length) {
+  const out = new Uint8Array(length);
+  let remaining = value;
+  for (let i = 0; i < length; i++) {
+    out[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return out;
+}
+function modPow(base, exponent, modulus) {
+  let result = 1n;
+  let b = base % modulus;
+  let e = exponent;
+  while (e > 0n) {
+    if (e & 1n) result = result * b % modulus;
+    b = b * b % modulus;
+    e >>= 1n;
+  }
+  return result;
+}
+function rsaEncrypt(dataLe, modulusLe, exponentLe) {
+  const modulus = bigIntFromLe(modulusLe);
+  const exponent = bigIntFromLe(exponentLe);
+  const value = bigIntFromLe(dataLe);
+  if (value >= modulus) throw new Error("RDP: client random is larger than the server RSA modulus");
+  return bigIntToLe(modPow(value, exponent, modulus), modulusLe.length);
+}
+function rsaEncryptPkcs1(message, modulusBe, exponentBe) {
+  const bigIntFromBe = (bytes) => {
+    let value = 0n;
+    for (const byte of bytes) value = value << 8n | BigInt(byte);
+    return value;
+  };
+  const modulus = bigIntFromBe(modulusBe);
+  const exponent = bigIntFromBe(exponentBe);
+  const keyLength = modulusBe.length;
+  if (message.length > keyLength - 11) {
+    throw new Error("TLS: RSA message is too long for this key");
+  }
+  const block = new Uint8Array(keyLength);
+  block[0] = 0;
+  block[1] = 2;
+  const paddingLength = keyLength - message.length - 3;
+  const padding = new Uint8Array(paddingLength);
+  crypto.getRandomValues(padding);
+  for (let i = 0; i < paddingLength; i++) {
+    while (padding[i] === 0) padding[i] = Math.max(1, crypto.getRandomValues(new Uint8Array(1))[0]);
+    block[2 + i] = padding[i];
+  }
+  block[2 + paddingLength] = 0;
+  block.set(message, 3 + paddingLength);
+  const cipher = modPow(bigIntFromBe(block), exponent, modulus);
+  const out = new Uint8Array(keyLength);
+  let remaining = cipher;
+  for (let i = keyLength - 1; i >= 0; i--) {
+    out[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return out;
+}
+const PAD1 = new Uint8Array(40).fill(54);
+const PAD2 = new Uint8Array(48).fill(92);
+const ENCRYPTION_METHOD = {
+  NONE: 0,
+  BIT_40: 1,
+  BIT_128: 2,
+  BIT_56: 8,
+  FIPS: 16
+};
+function concat(...parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function saltedHash(secret, salt, clientRandom, serverRandom) {
+  return md5(concat(secret, sha1(concat(salt, secret, clientRandom, serverRandom))));
+}
+function finalHash(key, clientRandom, serverRandom) {
+  return md5(concat(key, clientRandom, serverRandom));
+}
+const SALT_A = new Uint8Array([65]);
+const SALT_BB = new Uint8Array([66, 66]);
+const SALT_CCC = new Uint8Array([67, 67, 67]);
+const SALT_X = new Uint8Array([88]);
+const SALT_YY = new Uint8Array([89, 89]);
+const SALT_ZZZ = new Uint8Array([90, 90, 90]);
+function reduceKey(key, keyLength, is40Bit) {
+  if (keyLength !== 8) return key.slice(0, keyLength);
+  const reduced = key.slice(0, 8);
+  reduced[0] = 209;
+  if (is40Bit) {
+    reduced[1] = 38;
+    reduced[2] = 158;
+  }
+  return reduced;
+}
+function keyLengthForMethod(encryptionMethod) {
+  if (encryptionMethod === ENCRYPTION_METHOD.BIT_40) return 8;
+  if (encryptionMethod === ENCRYPTION_METHOD.BIT_56) return 8;
+  return 16;
+}
+function deriveSessionKeys(clientRandom, serverRandom, encryptionMethod) {
+  const preMasterSecret = concat(clientRandom.subarray(0, 24), serverRandom.subarray(0, 24));
+  const masterSecret = concat(
+    saltedHash(preMasterSecret, SALT_A, clientRandom, serverRandom),
+    saltedHash(preMasterSecret, SALT_BB, clientRandom, serverRandom),
+    saltedHash(preMasterSecret, SALT_CCC, clientRandom, serverRandom)
+  );
+  const sessionKeyBlob = concat(
+    saltedHash(masterSecret, SALT_X, clientRandom, serverRandom),
+    saltedHash(masterSecret, SALT_YY, clientRandom, serverRandom),
+    saltedHash(masterSecret, SALT_ZZZ, clientRandom, serverRandom)
+  );
+  const keyLength = keyLengthForMethod(encryptionMethod);
+  const is40Bit = encryptionMethod === ENCRYPTION_METHOD.BIT_40;
+  const applyReduction = (key) => reduceKey(key, keyLength, is40Bit);
+  const macKey = applyReduction(sessionKeyBlob.subarray(0, 16));
+  const decryptKey = applyReduction(finalHash(sessionKeyBlob.subarray(16, 32), clientRandom, serverRandom));
+  const encryptKey = applyReduction(finalHash(sessionKeyBlob.subarray(32, 48), clientRandom, serverRandom));
+  return {
+    macKey,
+    keyLength,
+    is40Bit,
+    // Session-key updates always restart from these initial values.
+    initialDecryptKey: decryptKey.slice(),
+    initialEncryptKey: encryptKey.slice(),
+    decryptKey,
+    encryptKey
+  };
+}
+function macSignature(macKey, data) {
+  const lengthField = new Uint8Array(4);
+  new DataView(lengthField.buffer).setUint32(0, data.length, true);
+  const inner = sha1(concat(macKey, PAD1, lengthField, data));
+  return md5(concat(macKey, PAD2, inner)).subarray(0, 8);
+}
+function updateSessionKey(initialKey, currentKey, keyLength, is40Bit) {
+  const inner = sha1(concat(initialKey, PAD1, currentKey));
+  const nextKey = md5(concat(initialKey, PAD2, inner)).slice(0, keyLength);
+  const salted = rc4Crypt(rc4Init(nextKey), nextKey);
+  return reduceKey(salted, keyLength, is40Bit);
+}
+export {
+  ENCRYPTION_METHOD,
+  deriveSessionKeys,
+  keyLengthForMethod,
+  macSignature,
+  md5,
+  rc4Crypt,
+  rc4Init,
+  rsaEncrypt,
+  rsaEncryptPkcs1,
+  sha1,
+  updateSessionKey
+};
+//# sourceMappingURL=crypto.js.map