@wirebench/engine 2.1.1

package/dist/http/auth/apply.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sending one request with credentials that may need a round trip of their own.
+ *
+ * Basic can be preemptive or answer a 401 challenge; NTLMv2 needs three legs on one connection.
+ * Both are transport concerns rather than protocol ones, so this module owns them for every
+ * protocol: the SOAP send and the REST send call it instead of each implementing the same flow.
+ *
+ * Every scheme that needs no round trip — a bearer token, an API key, an OAuth2 access token — is
+ * applied by its own protocol layer as a plain header or query value and never reaches here.
+ */
+import type { Dispatcher } from 'undici';
+import type { HttpExchange, HttpRequest } from '../types.js';
+import type { AuthSummary, SendAuth } from '../../types.js';
+/** Options for {@link sendWithAuth}: the same hooks `sendHttp` takes, for tests. */
+export interface SendWithAuthOptions {
+    readonly dispatcher?: Dispatcher;
+    readonly now?: () => number;
+}
+/** What one authenticated send did: the final exchange, and how it got there. */
+export interface AuthenticatedExchange {
+    readonly http: HttpExchange;
+    /** Total time across every leg, which is what the UI shows as the send's duration. */
+    readonly durationMs: number;
+    /** Absent when there were no credentials to apply. */
+    readonly auth?: AuthSummary;
+}
+/**
+ * Sends `request`, applying `auth` if it is a scheme that needs the transport's help.
+ *
+ * A caller-supplied `Authorization` header is an explicit override and wins: two credentials on one
+ * request is never what anyone meant. A Basic credential that is not preemptive is sent bare first
+ * and retried once if the server answers with a 401 `Basic` challenge; both attempts share the one
+ * timeout budget, so a challenged send cannot take twice as long as the user allowed. When the
+ * budget is already spent the 401 is reported as the result rather than retried into a certain
+ * timeout.
+ */
+export declare function sendWithAuth(request: HttpRequest, auth: SendAuth | undefined, options?: SendWithAuthOptions): Promise<AuthenticatedExchange>;

package/dist/http/auth/apply.js

@@ -0,0 +1,74 @@
+/**
+ * Sending one request with credentials that may need a round trip of their own.
+ *
+ * Basic can be preemptive or answer a 401 challenge; NTLMv2 needs three legs on one connection.
+ * Both are transport concerns rather than protocol ones, so this module owns them for every
+ * protocol: the SOAP send and the REST send call it instead of each implementing the same flow.
+ *
+ * Every scheme that needs no round trip — a bearer token, an API key, an OAuth2 access token — is
+ * applied by its own protocol layer as a plain header or query value and never reaches here.
+ */
+import { sendHttp } from '../client.js';
+import { headerValue } from '../headers.js';
+import { basicAuthorization, isBasicChallenge } from './basic.js';
+import { ntlmHandshake } from './ntlm-transport.js';
+/**
+ * Sends `request`, applying `auth` if it is a scheme that needs the transport's help.
+ *
+ * A caller-supplied `Authorization` header is an explicit override and wins: two credentials on one
+ * request is never what anyone meant. A Basic credential that is not preemptive is sent bare first
+ * and retried once if the server answers with a 401 `Basic` challenge; both attempts share the one
+ * timeout budget, so a challenged send cannot take twice as long as the user allowed. When the
+ * budget is already spent the 401 is reported as the result rather than retried into a certain
+ * timeout.
+ */
+export async function sendWithAuth(request, auth, options) {
+    const callerAuthorization = headerValue(request.headers, 'authorization') !== undefined;
+    const basicAuth = auth?.type === 'basic' && !callerAuthorization ? auth : undefined;
+    const ntlmAuth = auth?.type === 'ntlm' && !callerAuthorization ? auth : undefined;
+    const headers = { ...request.headers };
+    if (basicAuth?.preemptive === true) {
+        headers.Authorization = basicAuthorization(basicAuth.username, basicAuth.password);
+    }
+    const firstRequest = { ...request, headers };
+    const now = options?.now ?? Date.now;
+    const startedAt = now();
+    let http;
+    let durationMs;
+    let challenged = false;
+    let attempts = 1;
+    if (ntlmAuth !== undefined) {
+        // NTLM owns the whole exchange: three legs on one connection, its own dispatcher.
+        const handshake = await ntlmHandshake(firstRequest, ntlmAuth, {
+            ...(options?.now !== undefined ? { now: options.now } : {}),
+            ...(options?.dispatcher !== undefined ? { dispatcher: options.dispatcher } : {}),
+        });
+        http = handshake.http;
+        durationMs = handshake.durationMs;
+        challenged = handshake.challenged;
+        attempts = handshake.attempts;
+    }
+    else {
+        http = await sendHttp(firstRequest, options);
+        durationMs = http.timings.totalMs;
+    }
+    if (basicAuth !== undefined && basicAuth.preemptive !== true && isBasicChallenge(http)) {
+        challenged = true;
+        const remainingMs = request.timeoutMs - (now() - startedAt);
+        if (remainingMs > 0) {
+            attempts = 2;
+            const retry = await sendHttp({
+                ...firstRequest,
+                headers: { ...headers, Authorization: basicAuthorization(basicAuth.username, basicAuth.password) },
+                timeoutMs: remainingMs,
+            }, options);
+            durationMs += retry.timings.totalMs;
+            http = retry;
+        }
+    }
+    return {
+        http,
+        durationMs,
+        ...(auth !== undefined ? { auth: { scheme: auth.type, challenged, attempts } } : {}),
+    };
+}

package/dist/http/auth/basic.d.ts

@@ -0,0 +1,36 @@
+/**
+ * HTTP Basic authentication (RFC 7617) plus the `WWW-Authenticate` parsing needed to
+ * recognise a 401 challenge. Pure string work — the send path owns the retry.
+ */
+/** One parsed `WWW-Authenticate` challenge: a lower-cased scheme and its (lower-cased) parameter names. */
+export interface AuthChallenge {
+    readonly scheme: string;
+    readonly params: Readonly<Record<string, string>>;
+}
+/**
+ * Builds the `Authorization` header value for Basic credentials: `Basic base64(user:password)`
+ * with the credentials encoded as UTF-8 (RFC 7617's `charset` parameter is only ever `UTF-8`).
+ *
+ * @param username the user id; must not contain a colon per RFC 7617
+ * @param password the password; colons are fine, only the first colon separates
+ */
+export declare function basicAuthorization(username: string, password: string): string;
+/**
+ * Tolerantly parses a `WWW-Authenticate` header into its challenges. Real servers send
+ * several challenges in one header, quote (or fail to quote) parameter values, and use any
+ * casing they like, so this favours recovering what it can over strict RFC 7235 grammar.
+ * A `token68` credential after the scheme (as NTLM sends) yields the scheme with no params.
+ *
+ * @param header the raw header value, or `undefined` when the response had none
+ */
+export declare function parseWwwAuthenticate(header: string | undefined): readonly AuthChallenge[];
+/**
+ * True when `response` is a 401 offering a `Basic` challenge — the signal that a
+ * non-preemptive Basic send should retry once with an `Authorization` header.
+ *
+ * @param response the status and (case-insensitive) headers of the response to inspect
+ */
+export declare function isBasicChallenge(response: {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+}): boolean;

package/dist/http/auth/basic.js

@@ -0,0 +1,69 @@
+/**
+ * HTTP Basic authentication (RFC 7617) plus the `WWW-Authenticate` parsing needed to
+ * recognise a 401 challenge. Pure string work — the send path owns the retry.
+ */
+import { headerValue } from '../headers.js';
+/**
+ * Builds the `Authorization` header value for Basic credentials: `Basic base64(user:password)`
+ * with the credentials encoded as UTF-8 (RFC 7617's `charset` parameter is only ever `UTF-8`).
+ *
+ * @param username the user id; must not contain a colon per RFC 7617
+ * @param password the password; colons are fine, only the first colon separates
+ */
+export function basicAuthorization(username, password) {
+    return `Basic ${Buffer.from(`${username}:${password}`, 'utf-8').toString('base64')}`;
+}
+/**
+ * Tolerantly parses a `WWW-Authenticate` header into its challenges. Real servers send
+ * several challenges in one header, quote (or fail to quote) parameter values, and use any
+ * casing they like, so this favours recovering what it can over strict RFC 7235 grammar.
+ * A `token68` credential after the scheme (as NTLM sends) yields the scheme with no params.
+ *
+ * @param header the raw header value, or `undefined` when the response had none
+ */
+export function parseWwwAuthenticate(header) {
+    if (header === undefined || header.trim() === '') {
+        return [];
+    }
+    const challenges = [];
+    // One regex pass over the header: either `name=value` (quoted or not) belonging to the
+    // current challenge, or a bare token that starts a new one.
+    const token = /([A-Za-z0-9!#$%&'*+\-.^_`|~]+)\s*=\s*("(?:[^"\\]|\\.)*"|[^,\s]*)|([A-Za-z0-9!#$%&'*+\-.^_`|~/=]+)/g;
+    let match;
+    let lastEnd = 0;
+    while ((match = token.exec(header)) !== null) {
+        const [, name, rawValue, bare] = match;
+        const separated = header.slice(lastEnd, match.index).includes(',');
+        lastEnd = match.index + match[0].length;
+        if (name !== undefined && rawValue !== undefined) {
+            const current = challenges[challenges.length - 1];
+            if (current === undefined) {
+                continue;
+            }
+            const value = rawValue.startsWith('"') && rawValue.endsWith('"') && rawValue.length >= 2
+                ? rawValue.slice(1, -1).replace(/\\(.)/g, '$1')
+                : rawValue;
+            current.params[name.toLowerCase()] = value;
+        }
+        else if (bare !== undefined) {
+            if (!separated && challenges.length > 0) {
+                // A bare token right after a scheme is its `token68` credential (NTLM), not a new scheme.
+                continue;
+            }
+            challenges.push({ scheme: bare.toLowerCase(), params: {} });
+        }
+    }
+    return challenges;
+}
+/**
+ * True when `response` is a 401 offering a `Basic` challenge — the signal that a
+ * non-preemptive Basic send should retry once with an `Authorization` header.
+ *
+ * @param response the status and (case-insensitive) headers of the response to inspect
+ */
+export function isBasicChallenge(response) {
+    if (response.status !== 401) {
+        return false;
+    }
+    return parseWwwAuthenticate(headerValue(response.headers, 'www-authenticate')).some((challenge) => challenge.scheme === 'basic');
+}

package/dist/http/auth/md4.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MD4 (RFC 1320), implemented here because NTLM's NT hash is `MD4(UTF-16LE(password))`
+ * and Node's `crypto` only exposes MD4 through the OpenSSL legacy provider, which is
+ * disabled in the Node builds we ship on. MD4 is used *only* as NTLM's key-derivation
+ * primitive; it is not a security primitive anywhere else in Wirebench.
+ */
+/**
+ * Computes the MD4 digest of `bytes`.
+ *
+ * @param bytes the message to hash
+ * @returns the 16-byte digest
+ */
+export declare function md4(bytes: Uint8Array): Uint8Array;

package/dist/http/auth/md4.js

@@ -0,0 +1,81 @@
+/**
+ * MD4 (RFC 1320), implemented here because NTLM's NT hash is `MD4(UTF-16LE(password))`
+ * and Node's `crypto` only exposes MD4 through the OpenSSL legacy provider, which is
+ * disabled in the Node builds we ship on. MD4 is used *only* as NTLM's key-derivation
+ * primitive; it is not a security primitive anywhere else in Wirebench.
+ */
+/** Left-rotates a 32-bit word, staying inside the 32-bit range. */
+function rotl(x, n) {
+    return ((x << n) | (x >>> (32 - n))) >>> 0;
+}
+function f(x, y, z) {
+    return (x & y) | (~x & z);
+}
+function g(x, y, z) {
+    return (x & y) | (x & z) | (y & z);
+}
+function h(x, y, z) {
+    return x ^ y ^ z;
+}
+/** Round-1 order is 0..15; rounds 2 and 3 permute the block words per RFC 1320 §3.4. */
+const ROUND2_ORDER = [0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15];
+const ROUND3_ORDER = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];
+const SHIFTS_1 = [3, 7, 11, 19];
+const SHIFTS_2 = [3, 5, 9, 13];
+const SHIFTS_3 = [3, 9, 11, 15];
+/**
+ * Computes the MD4 digest of `bytes`.
+ *
+ * @param bytes the message to hash
+ * @returns the 16-byte digest
+ */
+export function md4(bytes) {
+    // Pad to a multiple of 64 bytes: 0x80, zeroes, then the bit length as 64-bit little-endian.
+    const bitLength = BigInt(bytes.length) * 8n;
+    const paddedLength = (((bytes.length + 8) >> 6) + 1) << 6;
+    const message = new Uint8Array(paddedLength);
+    message.set(bytes, 0);
+    message[bytes.length] = 0x80;
+    const view = new DataView(message.buffer);
+    view.setBigUint64(paddedLength - 8, bitLength & 0xffffffffffffffffn, true);
+    let a = 0x67452301;
+    let b = 0xefcdab89;
+    let c = 0x98badcfe;
+    let d = 0x10325476;
+    const words = new Array(16);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            words[i] = view.getUint32(offset + i * 4, true);
+        }
+        const [aa, bb, cc, dd] = [a, b, c, d];
+        for (let i = 0; i < 16; i++) {
+            const shift = SHIFTS_1[i % 4] ?? 0;
+            const word = words[i] ?? 0;
+            const value = (a + f(b, c, d) + word) >>> 0;
+            [a, b, c, d] = [d, rotl(value, shift), b, c];
+        }
+        for (let i = 0; i < 16; i++) {
+            const shift = SHIFTS_2[i % 4] ?? 0;
+            const word = words[ROUND2_ORDER[i] ?? 0] ?? 0;
+            const value = (a + g(b, c, d) + word + 0x5a827999) >>> 0;
+            [a, b, c, d] = [d, rotl(value, shift), b, c];
+        }
+        for (let i = 0; i < 16; i++) {
+            const shift = SHIFTS_3[i % 4] ?? 0;
+            const word = words[ROUND3_ORDER[i] ?? 0] ?? 0;
+            const value = (a + h(b, c, d) + word + 0x6ed9eba1) >>> 0;
+            [a, b, c, d] = [d, rotl(value, shift), b, c];
+        }
+        a = (a + aa) >>> 0;
+        b = (b + bb) >>> 0;
+        c = (c + cc) >>> 0;
+        d = (d + dd) >>> 0;
+    }
+    const digest = new Uint8Array(16);
+    const out = new DataView(digest.buffer);
+    out.setUint32(0, a, true);
+    out.setUint32(4, b, true);
+    out.setUint32(8, c, true);
+    out.setUint32(12, d, true);
+    return digest;
+}

package/dist/http/auth/ntlm-transport.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The NTLM three-leg handshake over HTTP. NTLM authenticates the *connection*, so every leg
+ * has to travel over one socket: this module opens a dedicated single-connection dispatcher,
+ * runs the legs sequentially over it, and closes it again.
+ *
+ *   leg 1  bare request, the real body   → 200 (no auth needed), or 401 + `WWW-Authenticate: NTLM`
+ *   leg 2  Type 1, empty body            → 401 + `WWW-Authenticate: NTLM <Type 2>`
+ *   leg 3  Type 3, the real body again   → the final response
+ *
+ * Leg 1 *is* the caller's real request — most servers never challenge it, so the common
+ * case pays for the envelope exactly once. The empty-body optimisation applies only to leg
+ * 2, the Type 1 token, which never carries a body of its own; a server that does challenge
+ * causes the envelope to cross the wire a second time, on leg 3.
+ */
+import type { Dispatcher } from 'undici';
+import type { HttpExchange, HttpRequest } from '../types.js';
+/** The NTLM credentials, as resolved by the caller. The password is never logged or stored. */
+export interface NtlmCredentials {
+    readonly username: string;
+    readonly password: string;
+    readonly domain?: string;
+    readonly workstation?: string;
+}
+/** The outcome of {@link ntlmHandshake}: the final exchange plus how it was reached. */
+export interface NtlmHandshakeResult {
+    /** The exchange of the last leg actually made — its raw capture is the one to surface. */
+    readonly http: HttpExchange;
+    /** 1 (no challenge), 2 (challenge without a usable Type 2) or 3 (full handshake). */
+    readonly attempts: 1 | 2 | 3;
+    /** True once the server answered any leg with an NTLM challenge. */
+    readonly challenged: boolean;
+    /** The summed wall time of every leg, so a handshake reports its true cost. */
+    readonly durationMs: number;
+}
+/** Injection points for tests: the clock, the client nonce and the timestamp in the NTLMv2 blob. */
+export interface NtlmHandshakeOptions {
+    readonly now?: () => number;
+    /** The 8-byte client challenge; random when omitted. */
+    readonly clientChallenge?: Uint8Array;
+    /** The NTLMv2 blob timestamp as a Windows FILETIME; `now()` when omitted. */
+    readonly timestamp?: bigint;
+    /**
+     * A dispatcher to run the legs on instead of a freshly created single-connection one.
+     * Only tests pass this; it is the caller's to close.
+     */
+    readonly dispatcher?: Dispatcher;
+}
+/**
+ * Runs the NTLM handshake for `request` and returns the final exchange.
+ *
+ * All legs share the one `request.timeoutMs` budget (each leg gets what is left of it) and
+ * the caller's `AbortSignal`; a budget already spent stops the handshake and reports the
+ * last exchange as it stands, rather than firing a leg doomed to time out immediately.
+ * A 401 from the final leg (a wrong password, typically) is returned as a normal exchange,
+ * not thrown.
+ *
+ * @param request the fully-built request, including the real body for the final leg
+ * @param credentials the NTLM account to authenticate as
+ * @param options injected clock/nonce/dispatcher, for deterministic tests
+ */
+export declare function ntlmHandshake(request: HttpRequest, credentials: NtlmCredentials, options?: NtlmHandshakeOptions): Promise<NtlmHandshakeResult>;

package/dist/http/auth/ntlm-transport.js

@@ -0,0 +1,97 @@
+/**
+ * The NTLM three-leg handshake over HTTP. NTLM authenticates the *connection*, so every leg
+ * has to travel over one socket: this module opens a dedicated single-connection dispatcher,
+ * runs the legs sequentially over it, and closes it again.
+ *
+ *   leg 1  bare request, the real body   → 200 (no auth needed), or 401 + `WWW-Authenticate: NTLM`
+ *   leg 2  Type 1, empty body            → 401 + `WWW-Authenticate: NTLM <Type 2>`
+ *   leg 3  Type 3, the real body again   → the final response
+ *
+ * Leg 1 *is* the caller's real request — most servers never challenge it, so the common
+ * case pays for the envelope exactly once. The empty-body optimisation applies only to leg
+ * 2, the Type 1 token, which never carries a body of its own; a server that does challenge
+ * causes the envelope to cross the wire a second time, on leg 3.
+ */
+import { randomBytes } from 'node:crypto';
+import { createSingleConnectionDispatcher } from '../client.js';
+import { sendHttp } from '../client.js';
+import { headerValue, withoutHeader } from '../headers.js';
+import { createType1, createType3, encodeNtlmAuthorization, offersNtlm, parseNtlmChallengeHeader, parseType2, toFileTime, } from './ntlm.js';
+const EMPTY_BODY = new Uint8Array(0);
+/**
+ * Runs the NTLM handshake for `request` and returns the final exchange.
+ *
+ * All legs share the one `request.timeoutMs` budget (each leg gets what is left of it) and
+ * the caller's `AbortSignal`; a budget already spent stops the handshake and reports the
+ * last exchange as it stands, rather than firing a leg doomed to time out immediately.
+ * A 401 from the final leg (a wrong password, typically) is returned as a normal exchange,
+ * not thrown.
+ *
+ * @param request the fully-built request, including the real body for the final leg
+ * @param credentials the NTLM account to authenticate as
+ * @param options injected clock/nonce/dispatcher, for deterministic tests
+ */
+export async function ntlmHandshake(request, credentials, options) {
+    const now = options?.now ?? Date.now;
+    const startedAt = now();
+    const budgetMs = request.timeoutMs;
+    const remaining = () => budgetMs - (now() - startedAt);
+    let ownDispatcher;
+    let dispatcher = options?.dispatcher;
+    if (dispatcher === undefined) {
+        ownDispatcher = createSingleConnectionDispatcher({
+            ...(request.tls !== undefined ? { tls: request.tls } : {}),
+            ...(request.proxy !== undefined ? { proxy: request.proxy } : {}),
+            ...(request.localAddress !== undefined ? { localAddress: request.localAddress } : {}),
+        });
+        dispatcher = ownDispatcher;
+    }
+    const sendOptions = { dispatcher, ...(options?.now !== undefined ? { now: options.now } : {}) };
+    let durationMs = 0;
+    const leg = async (headers, body) => {
+        const exchange = await sendHttp({ ...request, headers, body, timeoutMs: Math.max(1, remaining()) }, sendOptions);
+        durationMs += exchange.timings.totalMs;
+        return exchange;
+    };
+    try {
+        // Leg 1: the real request, real body. A server that needs no auth answers here and we
+        // are done — the envelope has already made it, so nothing is resent.
+        const first = await leg(request.headers, request.body ?? EMPTY_BODY);
+        if (first.status !== 401 || !offersNtlm(headerValue(first.headers, 'www-authenticate'))) {
+            return { http: first, attempts: 1, challenged: false, durationMs };
+        }
+        if (remaining() <= 0) {
+            return { http: first, attempts: 1, challenged: true, durationMs };
+        }
+        // Leg 2: the Type 1 negotiate message, bodyless. Strip any content-encoding/length
+        // that described leg 1's body — a gzip-declared zero-length body can trip up a strict
+        // server — the server answers with its Type 2 challenge.
+        const type1 = createType1({
+            ...(credentials.domain !== undefined ? { domain: credentials.domain } : {}),
+            ...(credentials.workstation !== undefined ? { workstation: credentials.workstation } : {}),
+        });
+        const type1Headers = withoutHeader(withoutHeader({ ...request.headers, Authorization: encodeNtlmAuthorization(type1) }, 'content-encoding'), 'content-length');
+        const second = await leg(type1Headers, EMPTY_BODY);
+        const challengeBytes = parseNtlmChallengeHeader(headerValue(second.headers, 'www-authenticate'));
+        if (challengeBytes === undefined || remaining() <= 0) {
+            return { http: second, attempts: 2, challenged: true, durationMs };
+        }
+        // Leg 3: the Type 3 authenticate message, this time carrying the real body.
+        const type2 = parseType2(challengeBytes);
+        const type3 = createType3({
+            username: credentials.username,
+            password: credentials.password,
+            ...(credentials.domain !== undefined ? { domain: credentials.domain } : {}),
+            ...(credentials.workstation !== undefined ? { workstation: credentials.workstation } : {}),
+            type2,
+            clientChallenge: options?.clientChallenge ?? new Uint8Array(randomBytes(8)),
+            timestamp: options?.timestamp ?? toFileTime(now()),
+        });
+        const third = await leg({ ...request.headers, Authorization: encodeNtlmAuthorization(type3.message) }, request.body ?? EMPTY_BODY);
+        return { http: third, attempts: 3, challenged: true, durationMs };
+    }
+    finally {
+        if (ownDispatcher !== undefined)
+            await ownDispatcher.close().catch(() => undefined);
+    }
+}

package/dist/http/auth/ntlm.d.ts

@@ -0,0 +1,190 @@
+/**
+ * NTLM (MS-NLMP) message codec: the Type 1 (NEGOTIATE), Type 2 (CHALLENGE) and
+ * Type 3 (AUTHENTICATE) messages plus the NTLMv2/LMv2 response computation, as a
+ * pure byte-level module. The connection choreography lives in `ntlm-transport.ts`.
+ *
+ * Only NTLMv2 with extended session security is produced; no session key exchange,
+ * signing or sealing, none of which HTTP needs. No MIC is emitted (it is optional
+ * for a client that negotiates no key exchange).
+ */
+/** NTLM negotiate flags (MS-NLMP §2.2.2.5) this codec cares about. */
+export declare const NTLM_FLAGS: {
+    readonly NEGOTIATE_UNICODE: 1;
+    readonly NEGOTIATE_OEM: 2;
+    readonly REQUEST_TARGET: 4;
+    readonly NEGOTIATE_NTLM: 512;
+    readonly NEGOTIATE_OEM_DOMAIN_SUPPLIED: 4096;
+    readonly NEGOTIATE_OEM_WORKSTATION_SUPPLIED: 8192;
+    readonly NEGOTIATE_ALWAYS_SIGN: 32768;
+    readonly NEGOTIATE_EXTENDED_SESSIONSECURITY: 524288;
+    readonly NEGOTIATE_TARGET_INFO: 8388608;
+    readonly NEGOTIATE_VERSION: 33554432;
+    readonly NEGOTIATE_128: 536870912;
+    readonly NEGOTIATE_56: 2147483648;
+};
+/**
+ * The flag set every Wirebench Type 1/Type 3 message carries: Unicode names, NTLM with
+ * extended session security (NTLMv2), target info, a version block, and 128/56-bit key
+ * strengths. Deliberately *without* `NEGOTIATE_SIGN`/`SEAL`/`KEY_EXCH` — HTTP carries no
+ * signed or sealed payloads, so advertising them would only invite a server to expect one.
+ */
+export declare const DEFAULT_NEGOTIATE_FLAGS: number;
+/** AV pair identifiers (MS-NLMP §2.2.2.1). */
+export declare const AV_IDS: {
+    readonly MsvAvEOL: 0;
+    readonly MsvAvNbComputerName: 1;
+    readonly MsvAvNbDomainName: 2;
+    readonly MsvAvDnsComputerName: 3;
+    readonly MsvAvDnsDomainName: 4;
+    readonly MsvAvTimestamp: 7;
+    readonly MsvAvFlags: 6;
+};
+/** Converts a Unix millisecond timestamp to a Windows FILETIME (100 ns ticks since 1601). */
+export declare function toFileTime(unixMillis: number): bigint;
+/** Options for {@link createType1}. */
+export interface Type1Options {
+    /** Override the negotiate flags; defaults to {@link DEFAULT_NEGOTIATE_FLAGS}. */
+    readonly flags?: number;
+    /** Optional NetBIOS domain to advertise (OEM-encoded, as the Type 1 message requires). */
+    readonly domain?: string;
+    /** Optional NetBIOS workstation name to advertise (OEM-encoded). */
+    readonly workstation?: string;
+}
+/**
+ * Builds a Type 1 NEGOTIATE message.
+ *
+ * @param options negotiate flags plus the optional domain/workstation to advertise
+ * @returns the raw message bytes, ready for {@link encodeNtlmAuthorization}
+ */
+export declare function createType1(options?: Type1Options): Uint8Array;
+/** A decoded Type 2 CHALLENGE message. */
+export interface Type2Message {
+    readonly flags: number;
+    /** The 8-byte server challenge. */
+    readonly serverChallenge: Uint8Array;
+    /** The target name, decoded as UTF-16LE or OEM depending on the negotiated flags. */
+    readonly targetName: string;
+    /** The raw AV-pair block, copied verbatim into the NTLMv2 blob. */
+    readonly targetInfo: Uint8Array;
+    /** The 8-byte version block, when the server sent one. */
+    readonly version?: Uint8Array;
+}
+/**
+ * Parses a Type 2 CHALLENGE message.
+ *
+ * @param bytes the raw message (already base64-decoded)
+ * @throws WirebenchError (`ntlm-invalid-message`) when the signature or message type is not a Type 2 message
+ */
+export declare function parseType2(bytes: Uint8Array): Type2Message;
+/**
+ * `NTOWFv2` (MS-NLMP §3.3.2): `HMAC_MD5(MD4(UTF16LE(password)), UTF16LE(UPPER(user) + domain))`.
+ * The domain keeps its case; only the user name is upper-cased.
+ *
+ * @param username the account name
+ * @param domain the domain (empty string when there is none)
+ * @param password the plaintext password — never logged, never stored by this module
+ */
+export declare function ntowfv2(username: string, domain: string, password: string): Uint8Array;
+/**
+ * Builds the NTLMv2 `temp` blob: version bytes, the timestamp, the client challenge and the
+ * server's AV pairs. Exported so a verifier can rebuild the exact blob it received.
+ */
+export declare function ntlmv2Blob(params: {
+    readonly timestamp: bigint;
+    readonly clientChallenge: Uint8Array;
+    readonly targetInfo: Uint8Array;
+}): Uint8Array;
+/**
+ * `NTProofStr` (MS-NLMP §3.3.2): `HMAC_MD5(NTOWFv2, serverChallenge || temp)`.
+ *
+ * @param responseKeyNt the `NTOWFv2` for the account
+ * @param serverChallenge the 8-byte challenge from the Type 2 message
+ * @param blob the `temp` blob from {@link ntlmv2Blob}
+ */
+export declare function ntProofString(responseKeyNt: Uint8Array, serverChallenge: Uint8Array, blob: Uint8Array): Uint8Array;
+/**
+ * The LMv2 response: `HMAC_MD5(NTOWFv2, serverChallenge || clientChallenge) || clientChallenge`.
+ */
+export declare function lmv2Response(responseKeyNt: Uint8Array, serverChallenge: Uint8Array, clientChallenge: Uint8Array): Uint8Array;
+/** Reads an AV-pair block into a list of `{id, value}` entries, stopping at `MsvAvEOL`. */
+export declare function parseAvPairs(bytes: Uint8Array): readonly {
+    readonly id: number;
+    readonly value: Uint8Array;
+}[];
+/** Builds an AV-pair block from `{id, value}` entries, terminated with `MsvAvEOL`. */
+export declare function buildAvPairs(pairs: readonly {
+    readonly id: number;
+    readonly value: Uint8Array;
+}[]): Uint8Array;
+/** Inputs for {@link createType3}. */
+export interface Type3Params {
+    readonly username: string;
+    readonly password: string;
+    readonly domain?: string;
+    readonly workstation?: string;
+    readonly type2: Type2Message;
+    /** The 8-byte client challenge; injected in tests, random in production. */
+    readonly clientChallenge: Uint8Array;
+    /** The timestamp as a Windows FILETIME; injected in tests, `toFileTime(Date.now())` otherwise. */
+    readonly timestamp: bigint;
+}
+/** The Type 3 message plus the intermediate values a test (or a verifier) wants to assert on. */
+export interface Type3Result {
+    readonly message: Uint8Array;
+    readonly ntProofStr: Uint8Array;
+    readonly ntChallengeResponse: Uint8Array;
+    readonly lmChallengeResponse: Uint8Array;
+    readonly responseKeyNt: Uint8Array;
+}
+/**
+ * Builds a Type 3 AUTHENTICATE message answering `params.type2`, computing the NTLMv2 and
+ * LMv2 responses. The server's target info is carried through verbatim (with an
+ * `MsvAvTimestamp` added when the server sent none, and `MsvAvFlags` = 0 to state
+ * explicitly that no MIC follows).
+ *
+ * The password is used only to derive `NTOWFv2` and never appears in the message.
+ *
+ * When the server's Type 2 did not negotiate `NEGOTIATE_UNICODE`, the domain/user/workstation
+ * are OEM- (latin1-) encoded instead of UTF-16LE, and the Type 3's own flags clear the Unicode
+ * bit and set `NEGOTIATE_OEM`, matching what the server asked for.
+ *
+ * @param params the credentials, the parsed challenge and the injectable nonce/clock
+ */
+export declare function createType3(params: Type3Params): Type3Result;
+/** A decoded Type 3 AUTHENTICATE message, as a server verifier sees it. */
+export interface Type3Message {
+    readonly flags: number;
+    readonly domain: string;
+    readonly username: string;
+    readonly workstation: string;
+    readonly lmChallengeResponse: Uint8Array;
+    readonly ntChallengeResponse: Uint8Array;
+}
+/**
+ * Parses a Type 3 AUTHENTICATE message. Used by the test NTLM server to verify a client's
+ * response independently of {@link createType3}.
+ *
+ * @param bytes the raw message (already base64-decoded)
+ * @throws WirebenchError (`ntlm-invalid-message`) when the signature or message type is not a Type 3 message
+ */
+export declare function parseType3(bytes: Uint8Array): Type3Message;
+/**
+ * Formats a message as an `Authorization`/`WWW-Authenticate` value: `NTLM <base64>`.
+ * Wirebench always answers with the `NTLM` scheme, even when the server advertised
+ * `Negotiate` — every server that offers raw NTLMSSP under `Negotiate` accepts it.
+ */
+export declare function encodeNtlmAuthorization(message: Uint8Array): string;
+/**
+ * Extracts an NTLMSSP message from a `WWW-Authenticate` header value. Accepts both
+ * `NTLM <base64>` and `Negotiate <base64>` (only when the payload really is NTLMSSP,
+ * not a Kerberos/SPNEGO token), and tolerates several challenges in one header.
+ *
+ * @param header the raw header value, or `undefined` when the response had none
+ * @returns the decoded message bytes, or `undefined` when there is no usable NTLM challenge
+ */
+export declare function parseNtlmChallengeHeader(header: string | undefined): Uint8Array | undefined;
+/**
+ * True when `header` offers an NTLM (or NTLMSSP-over-Negotiate) challenge at all, including
+ * the bare `WWW-Authenticate: NTLM` that starts a handshake.
+ */
+export declare function offersNtlm(header: string | undefined): boolean;