@api-client/core 0.3.2 → 0.3.5

package/src/runtime/http-engine/RequestUtils.ts

@@ -0,0 +1,164 @@
+import { Headers } from '../../lib/headers/Headers.js';
+import { ResponseRedirect } from '../../models/ResponseRedirect.js';
+
+/**
+ * Reads a port number for a connection.
+ *
+ * @param port Existing information about the port.
+ * @param protocol Request protocol. Only used if `port` is not set.
+ * @return A port number. Default to 80.
+ */
+export function getPort(port: number|string, protocol?: string): number {
+  if (port) {
+    const typedPort = Number(port);
+    if (!Number.isNaN(typedPort)) {
+      return typedPort;
+    }
+  }
+  if (protocol === 'https:') {
+    return 443;
+  }
+  return 80;
+}
+
+/**
+ * Creates a value for host header.
+ *
+ * @param value An url to get the information from.
+ * @return Value of the host header
+ */
+export function getHostHeader(value: string): string | undefined {
+  let uri;
+  try {
+    uri = new URL(value);
+  } catch (e) {
+    return;
+  }
+  let hostValue = uri.hostname;
+  const defaultPorts = [80, 443];
+  const port = getPort(uri.port, uri.protocol);
+  if (!defaultPorts.includes(port)) {
+    hostValue += `:${port}`;
+  }
+  return hostValue;
+}
+
+/**
+ * Adds the `content-length` header to current request headers list if
+ * it's required.
+ * This function will do nothing if the request do not carry a payload or
+ * when the content length header is already set.
+ *
+ * @param method HTTP request method
+ * @param buffer Generated message buffer.
+ * @param headers A headers object where to append headers when needed
+ */
+export function addContentLength(method: string, buffer: Buffer, headers: Headers): void {
+  if (method.toLowerCase() === 'get') {
+    return;
+  }
+  const size = buffer ? buffer.length : 0;
+  headers.set('content-length', String(size));
+}
+
+export declare interface RedirectOptions {
+  /**
+   * true if redirect is required
+   */
+  redirect?: boolean;
+  /**
+   * If true the redirected request has to be a GET request.
+   */
+  forceGet?: boolean;
+  /**
+   * location of the resource (redirect uri)
+   */
+  location?: string;
+}
+
+/**
+   * Checks if redirect is required.
+   * @param status Response status code
+   * @param method Request HTTP method
+   * @param location Location header value, if any
+   * @returns The redirect options
+   */
+export function redirectOptions(status: number, method: string, location?: string): RedirectOptions {
+  const result: RedirectOptions = {
+    redirect: false,
+    forceGet: false,
+  };
+  switch (status) {
+    case 300:
+    case 304:
+    case 305:
+      // do nothing;
+      break;
+    case 301:
+    case 302:
+    case 307:
+      if (['GET', 'HEAD'].indexOf(method) !== -1) {
+        result.redirect = true;
+      }
+      break;
+    case 303:
+      result.redirect = true;
+      result.forceGet = true;
+      break;
+    default:
+  }
+  if (!result.redirect) {
+    return result;
+  }
+  if (location) {
+    result.location = location;
+  }
+  return result;
+}
+
+
+/**
+ * Checks if request is an infinite loop.
+ * @param location Redirect location
+ * @param redirects List of response objects
+ * @return True if redirect is into the same place as already visited.
+ */
+export function isRedirectLoop(location: string, redirects: ResponseRedirect[]): boolean {
+  if (redirects) {
+    let index = -1;
+    let i = 0;
+    for (const item of redirects) {
+      if (item.url === location) {
+        index = i;
+        break;
+      }
+      i++;
+    }
+    if (index !== -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Processes redirection location
+ * 
+ * @param location Redirect location
+ * @param requestUrl Request url
+ * @return Redirect location
+ */
+export function getRedirectLocation(location: string, requestUrl: string): string | undefined {
+  // https://github.com/jarrodek/socket-fetch/issues/5
+  try {
+    // eslint-disable-next-line no-new
+    new URL(location);
+  } catch (e) {
+    try {
+      location = new URL(location, requestUrl).toString();
+    } catch (_) {
+      return;
+    }
+  }
+  return location;
+}

package/src/runtime/http-engine/ntlm/Des.ts

@@ -0,0 +1,345 @@
+// Paul Tero, July 2001
+// http://www.tero.co.uk/des/
+//
+// Optimised for performance with large blocks by Michael Hayworth, November 2001
+// http://www.netdealing.com
+//
+// THIS SOFTWARE IS PROVIDED "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+export class Des {
+  static des(key: string, message: string, encrypt: number, mode: number, iv?: string, padding?: number): string {
+    const spfunction1 = [0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404,
+      0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004,
+      0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000,
+      0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404,
+      0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000,
+      0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404,
+      0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404,
+      0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004,
+    ];
+    const spfunction2 = [-0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20,
+      -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000,
+      -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020, -0x7fff7fe0, 0,
+      -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000,
+      0x8020, -0x7fef8000, -0x7ff00000, 0x8020, 0, 0x108020, -0x7fefffe0, 0x100000,
+      -0x7fff7fe0, -0x7ff00000, -0x7fef8000, 0x8000, -0x7ff00000, -0x7fff8000, 0x20,
+      -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000,
+      -0x7fffffe0, 0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000,
+      0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0, 0x108000,
+    ];
+    const spfunction3 = [0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200,
+      0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208,
+      0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208,
+      0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000,
+      0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200,
+      0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000,
+      0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208,
+      0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200,
+    ];
+    const spfunction4 = [0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001,
+      0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1,
+      0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080,
+      0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081,
+      0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081,
+      0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001,
+      0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080,
+    ];
+    const spfunction5 = [0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000,
+      0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100,
+      0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100,
+      0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000,
+      0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100,
+      0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000,
+      0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000,
+      0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100,
+      0x40000100,
+    ];
+    const spfunction6 = [0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10,
+      0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000,
+      0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10,
+      0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000,
+      0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010,
+      0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000,
+      0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010,
+      0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010,
+    ];
+    const spfunction7 = [0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802,
+      0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802,
+      0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002,
+      0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000,
+      0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002,
+      0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802,
+      0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000,
+      0x800, 0x4000002, 0x4000800, 0x800, 0x200002,
+    ];
+    const spfunction8 = [0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040,
+      0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040,
+      0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040,
+      0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040,
+      0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40,
+      0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040,
+      0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000,
+      0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000,
+    ];
+
+    // create the 16 or 48 subkeys we will need
+    const keys = Des.createKeys(key);
+    let m = 0;
+    let i;
+    let j;
+    let temp;
+    let right1;
+    let right2;
+    let left;
+    let right;
+    let looping;
+    let cbcleft;
+    let cbcleft2;
+    let cbcright;
+    let cbcright2;
+    let endloop;
+    let loopinc;
+    let len = message.length;
+    let chunk = 0;
+    const iterations = keys.length === 32 ? 3 : 9;
+    if (iterations === 3) {
+      looping = encrypt ? [0, 32, 2] : [30, -2, -2];
+    } else {
+      looping = encrypt ? [0, 32, 2, 62, 30, -2, 64, 96, 2] : [94, 62, -2, 32, 64, 2, 30, -2, -2];
+    }
+    if (padding === 2) {
+      message += '        ';
+    } else if (padding === 1) {
+      temp = 8 - (len % 8);
+      message += String.fromCharCode(temp, temp, temp, temp, temp, temp, temp, temp);
+      if (temp === 8) {
+        len += 8;
+      }
+    } else if (!padding) {
+      message += '\0\0\0\0\0\0\0\0';
+    }
+    let result = '';
+    let tempresult = '';
+    if (mode === 1) {
+      cbcleft = (iv!.charCodeAt(m++) << 24) | (iv!.charCodeAt(m++) << 16) |
+        (iv!.charCodeAt(m++) << 8) | iv!.charCodeAt(m++);
+      cbcright = (iv!.charCodeAt(m++) << 24) | (iv!.charCodeAt(m++) << 16) |
+        (iv!.charCodeAt(m++) << 8) | iv!.charCodeAt(m++);
+      m = 0;
+    }
+    while (m < len) {
+      left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) |
+        (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+      right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) |
+        (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+      if (mode === 1) {
+        if (encrypt) {
+          left ^= cbcleft as number;
+          right ^= cbcright as number;
+        } else {
+          cbcleft2 = cbcleft;
+          cbcright2 = cbcright;
+          cbcleft = left;
+          cbcright = right;
+        }
+      }
+      temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+      right ^= temp;
+      left ^= (temp << 4);
+      temp = ((left >>> 16) ^ right) & 0x0000ffff;
+      right ^= temp;
+      left ^= (temp << 16);
+      temp = ((right >>> 2) ^ left) & 0x33333333;
+      left ^= temp;
+      right ^= (temp << 2);
+      temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+      left ^= temp;
+      right ^= (temp << 8);
+      temp = ((left >>> 1) ^ right) & 0x55555555;
+      right ^= temp;
+      left ^= (temp << 1);
+
+      left = ((left << 1) | (left >>> 31));
+      right = ((right << 1) | (right >>> 31));
+      for (j = 0; j < iterations; j += 3) {
+        endloop = looping[j + 1];
+        loopinc = looping[j + 2];
+        for (i = looping[j]; i !== endloop; i += loopinc) {
+          right1 = right ^ keys[i];
+          right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
+          temp = left;
+          left = right;
+          right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] |
+            spfunction4[(right1 >>> 16) & 0x3f] | spfunction6[(right1 >>> 8) & 0x3f] |
+            spfunction8[right1 & 0x3f] | spfunction1[(right2 >>> 24) & 0x3f] |
+            spfunction3[(right2 >>> 16) & 0x3f] | spfunction5[(right2 >>> 8) & 0x3f] |
+            spfunction7[right2 & 0x3f]);
+        }
+        temp = left;
+        left = right;
+        right = temp;
+      }
+      left = ((left >>> 1) | (left << 31));
+      right = ((right >>> 1) | (right << 31));
+      temp = ((left >>> 1) ^ right) & 0x55555555;
+      right ^= temp;
+      left ^= (temp << 1);
+      temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+      left ^= temp;
+      right ^= (temp << 8);
+      temp = ((right >>> 2) ^ left) & 0x33333333;
+      left ^= temp;
+      right ^= (temp << 2);
+      temp = ((left >>> 16) ^ right) & 0x0000ffff;
+      right ^= temp;
+      left ^= (temp << 16);
+      temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+      right ^= temp;
+      left ^= (temp << 4);
+      if (mode === 1) {
+        if (encrypt) {
+          cbcleft = left;
+          cbcright = right;
+        } else {
+          left ^= cbcleft2 as number;
+          right ^= cbcright2 as number;
+        }
+      }
+      tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff),
+          ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24),
+          ((right >>> 16) & 0xff), ((right >>> 8) & 0xff), (right & 0xff));
+
+      chunk += 8;
+      if (chunk === 512) {
+        result += tempresult;
+        tempresult = '';
+        chunk = 0;
+      }
+    }
+    return result + tempresult;
+  }
+
+  static createKeys(key: string): number[] {
+    const pc2bytes0 = [0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000,
+      0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200,
+      0x20010204,
+    ];
+    const pc2bytes1 = [0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000,
+      0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100,
+      0x4100101,
+    ];
+    const pc2bytes2 = [0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808,
+      0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808,
+    ];
+    const pc2bytes3 = [0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000,
+      0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000,
+      0x8222000,
+    ];
+    const pc2bytes4 = [0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000,
+      0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010,
+    ];
+    const pc2bytes5 = [0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400,
+      0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420,
+    ];
+    const pc2bytes6 = [0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002,
+      0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002,
+    ];
+    const pc2bytes7 = [0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800,
+      0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800,
+      0x20030800,
+    ];
+    const pc2bytes8 = [0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000,
+      0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002,
+    ];
+    const pc2bytes9 = [0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008,
+      0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408,
+    ];
+    const pc2bytes10 = [0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000,
+      0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020,
+    ];
+    const pc2bytes11 = [0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200,
+      0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000,
+      0x4200200, 0x5200200,
+    ];
+    const pc2bytes12 = [0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000,
+      0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010,
+    ];
+    const pc2bytes13 = [0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101,
+      0x105, 0x1, 0x5, 0x101, 0x105,
+    ];
+
+    const iterations = key.length > 8 ? 3 : 1;
+    const keys: number[] = new Array(32 * iterations);
+    const shifts = [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0];
+    let lefttemp;
+    let righttemp;
+    let m = 0;
+    let n = 0;
+    let temp;
+
+    for (let j = 0; j < iterations; j++) {
+      let left = (key.charCodeAt(m++) << 24) |
+        (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+      let right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) |
+        (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+
+      temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+      right ^= temp;
+      left ^= (temp << 4);
+      temp = ((right >>> -16) ^ left) & 0x0000ffff;
+      left ^= temp;
+      right ^= (temp << -16);
+      temp = ((left >>> 2) ^ right) & 0x33333333;
+      right ^= temp;
+      left ^= (temp << 2);
+      temp = ((right >>> -16) ^ left) & 0x0000ffff;
+      left ^= temp;
+      right ^= (temp << -16);
+      temp = ((left >>> 1) ^ right) & 0x55555555;
+      right ^= temp;
+      left ^= (temp << 1);
+      temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+      left ^= temp;
+      right ^= (temp << 8);
+      temp = ((left >>> 1) ^ right) & 0x55555555;
+      right ^= temp;
+      left ^= (temp << 1);
+      temp = (left << 8) | ((right >>> 20) & 0x000000f0);
+      left = (right << 24) | ((right << 8) & 0xff0000) |
+        ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
+      right = temp;
+      for (let i = 0; i < shifts.length; i++) {
+        if (shifts[i]) {
+          left = (left << 2) | (left >>> 26);
+          right = (right << 2) | (right >>> 26);
+        } else {
+          left = (left << 1) | (left >>> 27);
+          right = (right << 1) | (right >>> 27);
+        }
+        left &= -0xf;
+        right &= -0xf;
+        lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf] |
+          pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf] |
+          pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf] |
+          pc2bytes6[(left >>> 4) & 0xf];
+        righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf] |
+          pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf] |
+          pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf] |
+          pc2bytes13[(right >>> 4) & 0xf];
+        temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
+        keys[n++] = lefttemp ^ temp;
+        keys[n++] = righttemp ^ (temp << 16);
+      }
+    }
+    return keys;
+  }
+}

package/src/runtime/http-engine/ntlm/MD4.ts

@@ -0,0 +1,135 @@
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD4 Message
+ * Digest Algorithm, as defined in RFC 1320.
+ * Version 2.1 Copyright (C) Jerrad Pierce, Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+export class MD4 {
+  static str(s: string): string {
+    return MD4.binl2str(MD4.core(MD4.str2binl(s), s.length * MD4.chrsz));
+  }
+
+  static core(x: any[], len: number): number[] {
+    x[len >> 5] |= 0x80 << (len % 32);
+    x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+    let a = 1732584193;
+    let b = -271733879;
+    let c = -1732584194;
+    let d = 271733878;
+
+    for (let i = 0; i < x.length; i += 16) {
+      const olda = a;
+      const oldb = b;
+      const oldc = c;
+      const oldd = d;
+
+      a = MD4.ff(a, b, c, d, x[i + 0], 3);
+      d = MD4.ff(d, a, b, c, x[i + 1], 7);
+      c = MD4.ff(c, d, a, b, x[i + 2], 11);
+      b = MD4.ff(b, c, d, a, x[i + 3], 19);
+      a = MD4.ff(a, b, c, d, x[i + 4], 3);
+      d = MD4.ff(d, a, b, c, x[i + 5], 7);
+      c = MD4.ff(c, d, a, b, x[i + 6], 11);
+      b = MD4.ff(b, c, d, a, x[i + 7], 19);
+      a = MD4.ff(a, b, c, d, x[i + 8], 3);
+      d = MD4.ff(d, a, b, c, x[i + 9], 7);
+      c = MD4.ff(c, d, a, b, x[i + 10], 11);
+      b = MD4.ff(b, c, d, a, x[i + 11], 19);
+      a = MD4.ff(a, b, c, d, x[i + 12], 3);
+      d = MD4.ff(d, a, b, c, x[i + 13], 7);
+      c = MD4.ff(c, d, a, b, x[i + 14], 11);
+      b = MD4.ff(b, c, d, a, x[i + 15], 19);
+
+      a = MD4.gg(a, b, c, d, x[i + 0], 3);
+      d = MD4.gg(d, a, b, c, x[i + 4], 5);
+      c = MD4.gg(c, d, a, b, x[i + 8], 9);
+      b = MD4.gg(b, c, d, a, x[i + 12], 13);
+      a = MD4.gg(a, b, c, d, x[i + 1], 3);
+      d = MD4.gg(d, a, b, c, x[i + 5], 5);
+      c = MD4.gg(c, d, a, b, x[i + 9], 9);
+      b = MD4.gg(b, c, d, a, x[i + 13], 13);
+      a = MD4.gg(a, b, c, d, x[i + 2], 3);
+      d = MD4.gg(d, a, b, c, x[i + 6], 5);
+      c = MD4.gg(c, d, a, b, x[i + 10], 9);
+      b = MD4.gg(b, c, d, a, x[i + 14], 13);
+      a = MD4.gg(a, b, c, d, x[i + 3], 3);
+      d = MD4.gg(d, a, b, c, x[i + 7], 5);
+      c = MD4.gg(c, d, a, b, x[i + 11], 9);
+      b = MD4.gg(b, c, d, a, x[i + 15], 13);
+
+      a = MD4.hh(a, b, c, d, x[i + 0], 3);
+      d = MD4.hh(d, a, b, c, x[i + 8], 9);
+      c = MD4.hh(c, d, a, b, x[i + 4], 11);
+      b = MD4.hh(b, c, d, a, x[i + 12], 15);
+      a = MD4.hh(a, b, c, d, x[i + 2], 3);
+      d = MD4.hh(d, a, b, c, x[i + 10], 9);
+      c = MD4.hh(c, d, a, b, x[i + 6], 11);
+      b = MD4.hh(b, c, d, a, x[i + 14], 15);
+      a = MD4.hh(a, b, c, d, x[i + 1], 3);
+      d = MD4.hh(d, a, b, c, x[i + 9], 9);
+      c = MD4.hh(c, d, a, b, x[i + 5], 11);
+      b = MD4.hh(b, c, d, a, x[i + 13], 15);
+      a = MD4.hh(a, b, c, d, x[i + 3], 3);
+      d = MD4.hh(d, a, b, c, x[i + 11], 9);
+      c = MD4.hh(c, d, a, b, x[i + 7], 11);
+      b = MD4.hh(b, c, d, a, x[i + 15], 15);
+
+      a = MD4.safeAdd(a, olda);
+      b = MD4.safeAdd(b, oldb);
+      c = MD4.safeAdd(c, oldc);
+      d = MD4.safeAdd(d, oldd);
+    }
+    return [a, b, c, d];
+  }
+
+  static cmn(q: number, a: number, b: number, x: number, s: number, t: number): number {
+    return MD4.safeAdd(MD4.rol(MD4.safeAdd(MD4.safeAdd(a, q), MD4.safeAdd(x, t)), s), b);
+  }
+
+  static ff(a: number, b: number, c: number, d: number, x: number, s: number): number {
+    return MD4.cmn((b & c) | ((~b) & d), a, 0, x, s, 0);
+  }
+
+  static gg(a: number, b: number, c: number, d: number, x: number, s: number): number {
+    return MD4.cmn((b & c) | (b & d) | (c & d), a, 0, x, s, 1518500249);
+  }
+
+  static hh(a: number, b: number, c: number, d: number, x: number, s: number): number {
+    return MD4.cmn(b ^ c ^ d, a, 0, x, s, 1859775393);
+  }
+
+  static safeAdd(x: number, y: number): number {
+    const lsw = (x & 0xFFFF) + (y & 0xFFFF);
+    const msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xFFFF);
+  }
+
+  static rol(num: number, cnt: number): number {
+    return (num << cnt) | (num >>> (32 - cnt));
+  }
+
+  static str2binl(str: string): number[] {
+    const bin: number[] = [];
+    const mask = (1 << MD4.chrsz) - 1;
+    for (let i = 0; i < str.length * MD4.chrsz; i += MD4.chrsz) {
+      bin[i >> 5] |= (str.charCodeAt(i / MD4.chrsz) & mask) << (i % 32);
+    }
+    return bin;
+  }
+
+  static binl2str(bin: number[]): string {
+    let str = '';
+    const mask = (1 << MD4.chrsz) - 1;
+    for (let i = 0; i < bin.length * 32; i += MD4.chrsz) {
+      str += String.fromCharCode((bin[i >> 5] >>> (i % 32)) & mask);
+    }
+    return str;
+  }
+
+  static get chrsz(): number {
+    return 8;
+  }
+}