@api-client/core 0.20.10 → 0.21.1

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

@@ -1,137 +0,0 @@
-/* eslint-disable @typescript-eslint/class-literal-property-style */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/*
- * 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: number[], 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
-  }
-}

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

@@ -1,187 +0,0 @@
-import { Des } from './Des.js'
-import { MD4 } from './MD4.js'
-import { NtlmMessage } from './NtlmMessage.js'
-import type { INtlmAuthorization } from '../../../models/Authorization.js'
-
-/**
- * A base class for auth methods used in the library.
- * On the base of https://github.com/erlandranvinge/ntlm.js/blob/master/ntlm.js
- */
-export class NtlmAuth {
-  domain: string
-  uid: string
-  passwd: string
-  lmHashedPassword?: string
-  ntHashedPassword?: string
-
-  constructor(opts: INtlmAuthorization) {
-    this.domain = opts.domain || ''
-    this.uid = opts.username || ''
-    this.passwd = opts.password || ''
-
-    this.setCredentials()
-  }
-
-  createMessage1(hostname: string): NtlmMessage {
-    const msg1 = new NtlmMessage()
-    msg1.addString('NTLMSSP\0')
-    msg1.addByte(1)
-    msg1.addString('\0\0\0')
-    msg1.addShort(0xb203)
-    msg1.addString('\0\0')
-    msg1.addShort(this.domain.length)
-    msg1.addShort(this.domain.length)
-    msg1.addShort(32 + hostname.length)
-    msg1.addString('\0\0')
-    msg1.addShort(hostname.length)
-    msg1.addShort(hostname.length)
-    msg1.addShort(32)
-    msg1.addString('\0\0')
-    msg1.addString(hostname.toUpperCase())
-    msg1.addString(this.domain.toUpperCase())
-    return msg1
-  }
-
-  getChallenge(data: string): string {
-    if (!data || typeof data !== 'string') {
-      throw new Error('Invalid NTLM challenge data: data is required and must be a string.')
-    }
-
-    // Remove "NTLM " prefix if present (for robustness)
-    const cleanData = data.replace(/^NTLM\s+/i, '')
-
-    if (!cleanData) {
-      throw new Error('Invalid NTLM challenge data: empty or invalid format.')
-    }
-
-    const msg2 = new NtlmMessage(cleanData)
-    if (msg2.getString(0, 8) !== 'NTLMSSP\0') {
-      throw new Error('Invalid NTLM response header.')
-    }
-    if (msg2.getByte(8) !== 2) {
-      throw new Error('Invalid NTLM response type.')
-    }
-    const challenge = msg2.getString(24, 8)
-    return challenge
-  }
-
-  createMessage3(challenge: string, hostname: string): NtlmMessage {
-    const lmResponse = this.buildResponse(this.lmHashedPassword as string, challenge)
-    const ntResponse = this.buildResponse(this.ntHashedPassword as string, challenge)
-    const username = this.uid
-    const domain = this.domain
-    const msg3 = new NtlmMessage()
-
-    msg3.addString('NTLMSSP\0')
-    msg3.addByte(3)
-    msg3.addString('\0\0\0')
-
-    msg3.addShort(24) // lmResponse
-    msg3.addShort(24)
-    msg3.addShort(64 + (domain.length + username.length + hostname.length) * 2)
-    msg3.addString('\0\0')
-
-    msg3.addShort(24) // ntResponse
-    msg3.addShort(24)
-    msg3.addShort(88 + (domain.length + username.length + hostname.length) * 2)
-    msg3.addString('\0\0')
-
-    msg3.addShort(domain.length * 2) // Domain.
-    msg3.addShort(domain.length * 2)
-    msg3.addShort(64)
-    msg3.addString('\0\0')
-
-    msg3.addShort(username.length * 2) // Username.
-    msg3.addShort(username.length * 2)
-    msg3.addShort(64 + domain.length * 2)
-    msg3.addShort('\0\0')
-
-    msg3.addShort(hostname.length * 2) // Hostname.
-    msg3.addShort(hostname.length * 2)
-    msg3.addShort(64 + (domain.length + username.length) * 2)
-    msg3.addString('\0\0')
-
-    msg3.addString('\0\0\0\0')
-    msg3.addShort(112 + (domain.length + username.length + hostname.length) * 2)
-    msg3.addString('\0\0')
-    msg3.addShort(0x8201)
-    msg3.addString('\0\0')
-
-    msg3.addString(domain.toUpperCase(), true) // "Some" string are passed as UTF-16.
-    msg3.addString(username, true)
-    msg3.addString(hostname.toUpperCase(), true)
-    msg3.addString(lmResponse)
-    msg3.addString(ntResponse)
-
-    return msg3
-  }
-
-  createKey(str: string): string {
-    const key56: number[] = []
-    while (str.length < 7) {
-      str += '\0'
-    }
-    str = str.substr(0, 7)
-    str.split('').map((c) => {
-      key56.push(c.charCodeAt(0))
-    })
-    const key = [0, 0, 0, 0, 0, 0, 0, 0]
-    key[0] = key56[0] // Convert 56 bit key to 64 bit.
-    key[1] = ((key56[0] << 7) & 0xff) | (key56[1] >> 1)
-    key[2] = ((key56[1] << 6) & 0xff) | (key56[2] >> 2)
-    key[3] = ((key56[2] << 5) & 0xff) | (key56[3] >> 3)
-    key[4] = ((key56[3] << 4) & 0xff) | (key56[4] >> 4)
-    key[5] = ((key56[4] << 3) & 0xff) | (key56[5] >> 5)
-    key[6] = ((key56[5] << 2) & 0xff) | (key56[6] >> 6)
-    key[7] = (key56[6] << 1) & 0xff
-    for (let i = 0; i < key.length; i++) {
-      // Fix DES key parity bits.
-      let bit = 0
-      for (let k = 0; k < 7; k++) {
-        const t = key[i] >> k
-        bit = (t ^ bit) & 0x1
-      }
-      key[i] = (key[i] & 0xfe) | bit
-    }
-
-    let result = ''
-    key.forEach((i) => {
-      result += String.fromCharCode(i)
-    })
-    return result
-  }
-
-  buildResponse(key: string, text: string): string {
-    while (key.length < 21) {
-      key += '\0'
-    }
-    const key1 = this.createKey(key.substr(0, 7))
-    const key2 = this.createKey(key.substr(7, 7))
-    const key3 = this.createKey(key.substr(14, 7))
-    return Des.des(key1, text, 1, 0) + Des.des(key2, text, 1, 0) + Des.des(key3, text, 1, 0)
-  }
-
-  // to be called by constructor
-  setCredentials(): void {
-    const domain = this.domain
-    const password = this.passwd
-    const magic = 'KGS!@#$%' // Create LM password hash.
-    let lmPassword = password.toUpperCase().substr(0, 14)
-    while (lmPassword.length < 14) {
-      lmPassword += '\0'
-    }
-    const key1 = this.createKey(lmPassword)
-    const key2 = this.createKey(lmPassword.substr(7))
-    const lmHashedPassword = Des.des(key1, magic, 1, 0) + Des.des(key2, magic, 1, 0)
-
-    let ntPassword = '' // Create NT password hash.
-    for (let i = 0; i < password.length; i++) {
-      ntPassword += password.charAt(i) + '\0'
-    }
-    const ntHashedPassword = MD4.str(ntPassword)
-
-    this.domain = domain
-    this.lmHashedPassword = lmHashedPassword
-    this.ntHashedPassword = ntHashedPassword
-  }
-}

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

@@ -1,64 +0,0 @@
-export class NtlmMessage {
-  data: number[] = []
-
-  constructor(data?: string) {
-    if (!data) {
-      return
-    }
-    if (data.indexOf('NTLM ') === 0) {
-      data = data.substring(5)
-    }
-    // Use Buffer instead of atob for Node.js compatibility
-    const buffer = Buffer.from(data, 'base64')
-    for (const byte of buffer) {
-      this.data.push(byte)
-    }
-  }
-
-  addByte(b: number): void {
-    this.data.push(b)
-  }
-
-  addShort(s: number | string): void {
-    const typed = s as number
-    this.data.push(typed & 0xff)
-    this.data.push((typed >> 8) & 0xff)
-  }
-
-  addString(str: string, utf16?: boolean): void {
-    if (utf16) {
-      // Fake UTF16 by padding each character in string.
-      str = str
-        .split('')
-        .map(function (c) {
-          return c + '\0'
-        })
-        .join('')
-    }
-    for (let i = 0; i < str.length; i++) {
-      this.data.push(str.charCodeAt(i))
-    }
-  }
-
-  getString(offset: number, length: number): string {
-    let result = ''
-    for (let i = 0; i < length; i++) {
-      if (offset + i >= this.data.length) {
-        return ''
-      }
-      result += String.fromCharCode(this.data[offset + i])
-    }
-    return result
-  }
-
-  getByte(offset: number): number {
-    return this.data[offset]
-  }
-
-  toBase64(): string {
-    const str = String.fromCharCode.apply(null, this.data)
-    return Buffer.from(str)
-      .toString('base64')
-      .replace(/.{76}(?=.)/g, '$&')
-  }
-}

package/src/runtime/http-engine/parsers/BodyParser.ts

@@ -1,171 +0,0 @@
-import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
-import { ResponseInfo } from './HttpResponseParser.js'
-
-const nlNlBuffer = Buffer.from([13, 10, 13, 10])
-const nlBuffer = Buffer.from([13, 10])
-
-export type BodyCompleteCallback = (body: Buffer) => void
-
-/**
- * Parser for HTTP body data
- */
-export class BodyParser {
-  private logger: Logger<ILogObj>
-  private responseInfo: ResponseInfo
-  private rawBody?: Buffer
-
-  constructor(logger: Logger<ILogObj>, responseInfo: ResponseInfo) {
-    this.logger = logger
-    this.responseInfo = responseInfo
-  }
-
-  /**
-   * Process body with content-length encoding
-   * @param data Buffer containing body data
-   * @param onComplete Callback when body is complete
-   */
-  processContentLength(data: Buffer, onComplete: BodyCompleteCallback): void {
-    if (typeof this.responseInfo.contentLength === 'undefined') {
-      throw new Error('The content-length header of the response is missing.')
-    }
-
-    if (!this.responseInfo.body) {
-      this.responseInfo.body = data
-      if (data.length >= this.responseInfo.contentLength) {
-        const body = this.responseInfo.body.slice(0, this.responseInfo.contentLength)
-        this.rawBody = body
-        onComplete(body)
-        return
-      }
-      return
-    }
-
-    const sum = this.responseInfo.body.length + data.length
-    this.responseInfo.body = Buffer.concat([this.responseInfo.body, data], sum)
-
-    if (this.responseInfo.body.length >= this.responseInfo.contentLength) {
-      const body = this.responseInfo.body.slice(0, this.responseInfo.contentLength)
-      this.rawBody = body
-      onComplete(body)
-      return
-    }
-  }
-
-  /**
-   * Process body with chunked transfer encoding
-   * @param data Buffer containing chunked body data
-   * @param onComplete Callback when body is complete
-   */
-  processChunked(data: Buffer, onComplete: BodyCompleteCallback): void {
-    if (!data) {
-      return
-    }
-
-    if (this.responseInfo.chunk) {
-      data = Buffer.concat([this.responseInfo.chunk, data], this.responseInfo.chunk.length + data.length)
-      this.responseInfo.chunk = undefined
-    }
-
-    while (true) {
-      if (this.responseInfo.chunkSize === 0 && data.indexOf(nlNlBuffer) === 0) {
-        onComplete(this.rawBody || Buffer.alloc(0))
-        return
-      }
-
-      if (!this.responseInfo.chunkSize) {
-        const tmp = this.readChunkSize(data)
-        if (!tmp) {
-          return
-        }
-        data = tmp
-        if (!this.responseInfo.chunkSize && this.responseInfo.chunkSize !== 0) {
-          // It may happen that node's buffer cuts the data
-          // just before the chunk size.
-          // It should proceed it in next portion of the data.
-          this.responseInfo.chunk = data
-          return
-        }
-        if (!this.responseInfo.chunkSize) {
-          onComplete(this.rawBody || Buffer.alloc(0))
-          return
-        }
-      }
-
-      const size = Math.min(this.responseInfo.chunkSize, data.length)
-      const sliced = data.slice(0, size)
-
-      if (!this.rawBody) {
-        this.rawBody = sliced
-      } else {
-        const sum = size + this.rawBody.length
-        this.rawBody = Buffer.concat([this.rawBody, sliced], sum)
-      }
-
-      this.responseInfo.chunkSize -= size
-
-      if (data.length === 0) {
-        return
-      }
-
-      data = data.slice(size + 2) // + CR
-
-      if (data.length === 0) {
-        return
-      }
-    }
-  }
-
-  /**
-   * Read chunk size from chunked transfer encoding
-   * @param array Buffer containing chunk data
-   * @returns Remaining data after reading chunk size
-   */
-  readChunkSize(array: Buffer): Buffer | undefined {
-    let index = array.indexOf(nlBuffer)
-
-    if (index === -1) {
-      // not found in this portion of data.
-      return array
-    }
-
-    if (index === 0) {
-      // Node's buffer cuts CRLF after the end of chunk data, without last CLCR,
-      // here's to fix it.
-      // It can be either new line from the last chunk or end of
-      // the message where
-      // the rest of the array is [13, 10, 48, 13, 10, 13, 10]
-      if (array.indexOf(nlNlBuffer) === 0) {
-        this.responseInfo.chunkSize = 0
-        return Buffer.alloc(0)
-      }
-      array = array.subarray(index + 2)
-      index = array.indexOf(nlBuffer)
-    }
-
-    const chunkSize = parseInt(array.slice(0, index).toString(), 16)
-    if (Number.isNaN(chunkSize)) {
-      this.responseInfo.chunkSize = undefined
-      return array.slice(index + 2)
-    }
-
-    this.responseInfo.chunkSize = chunkSize
-    return array.slice(index + 2)
-  }
-
-  /**
-   * Get the raw body buffer
-   */
-  getRawBody(): Buffer | undefined {
-    return this.rawBody
-  }
-
-  /**
-   * Reset the parser state
-   */
-  reset(): void {
-    this.rawBody = undefined
-    this.responseInfo.body = undefined
-    this.responseInfo.chunk = undefined
-    this.responseInfo.chunkSize = undefined
-  }
-}

package/src/runtime/http-engine/parsers/HeadersParser.ts

@@ -1,103 +0,0 @@
-import { type Logger, type ILogObj } from '../../../lib/logging/index.js'
-
-const nlNlBuffer = Buffer.from([13, 10, 13, 10])
-const nlBuffer = Buffer.from([13, 10])
-
-export interface HeadersParseResult {
-  complete: boolean
-  headers?: Buffer
-  remaining?: Buffer
-}
-
-/**
- * Parser for HTTP headers
- */
-export class HeadersParser {
-  private logger: Logger<ILogObj>
-
-  constructor(logger: Logger<ILogObj>) {
-    this.logger = logger
-  }
-
-  /**
-   * Parse HTTP headers from buffer
-   * @param data Buffer containing header data
-   * @param existingHeaders Previously accumulated headers
-   * @returns Headers parse result
-   */
-  parse(data: Buffer, existingHeaders?: Buffer): HeadersParseResult {
-    this.logger.info('Processing headers')
-
-    // Looking for end of headers section
-    let index = data.indexOf(nlNlBuffer)
-    let padding = 4
-
-    if (index === -1) {
-      // It can also be 2x ASCII 10
-      const _index = data.indexOf(Buffer.from([10, 10]))
-      if (_index !== -1) {
-        index = _index
-        padding = 2
-      }
-    }
-
-    // https://github.com/jarrodek/socket-fetch/issues/3
-    const enterIndex = data.indexOf(nlBuffer)
-
-    if (index === -1 && enterIndex !== 0) {
-      // end in next chunk
-      if (!existingHeaders) {
-        return {
-          complete: false,
-          headers: data,
-        }
-      } else {
-        const sum = existingHeaders.length + data.length
-        const combined = Buffer.concat([existingHeaders, data], sum)
-        return {
-          complete: false,
-          headers: combined,
-        }
-      }
-    }
-
-    if (enterIndex !== 0) {
-      const headersArray = data.slice(0, index)
-      if (!existingHeaders) {
-        return {
-          complete: true,
-          headers: headersArray,
-          remaining: this.extractRemaining(data, index, padding),
-        }
-      } else {
-        const sum = existingHeaders.length + headersArray.length
-        const combined = Buffer.concat([existingHeaders, headersArray], sum)
-        return {
-          complete: true,
-          headers: combined,
-          remaining: this.extractRemaining(data, index, padding),
-        }
-      }
-    }
-
-    return {
-      complete: true,
-      headers: existingHeaders,
-      remaining: this.extractRemaining(data, index, padding),
-    }
-  }
-
-  /**
-   * Extract remaining data after headers
-   * @param data Original data buffer
-   * @param index Index where headers end
-   * @param padding Padding to skip
-   * @returns Remaining data
-   */
-  private extractRemaining(data: Buffer, index: number, padding: number): Buffer {
-    const start = index === -1 ? 0 : index
-    const enterIndex = data.indexOf(nlBuffer)
-    const move = enterIndex === 0 ? 2 : padding
-    return data.slice(start + move)
-  }
-}