@layervai/qurl 0.3.1 → 0.5.0

package/dist/cjs/node/native-udp.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeUdpTesting = void 0;
+exports.nativeKnock = nativeKnock;
+const promises_1 = require("node:dns/promises");
+const node_dgram_1 = require("node:dgram");
+const node_net_1 = require("node:net");
+const nhp_wire_js_1 = require("./nhp-wire.js");
+// These are internal per-address exchange bounds. PortalOpener applies its own
+// whole-open deadline and does not expose per-address tuning.
+const NATIVE_DEFAULT_TIMEOUT_MS = 3_000;
+const NATIVE_DEFAULT_MAX_ADDRESSES = 3;
+const ipv4Denied = new node_net_1.BlockList();
+// Keep this set in lockstep with qurl-go's nonRoutablePrefixes plus the
+// IsPrivate/IsLoopback/IsLinkLocal/IsMulticast predicates it applies first.
+for (const [network, prefix] of [
+    ["0.0.0.0", 8],
+    ["10.0.0.0", 8],
+    ["100.64.0.0", 10],
+    ["127.0.0.0", 8],
+    ["169.254.0.0", 16],
+    ["172.16.0.0", 12],
+    ["192.0.0.0", 24],
+    ["192.0.2.0", 24],
+    ["192.168.0.0", 16],
+    ["192.88.99.0", 24],
+    ["198.18.0.0", 15],
+    ["198.51.100.0", 24],
+    ["203.0.113.0", 24],
+    ["224.0.0.0", 4],
+    ["240.0.0.0", 4],
+]) {
+    ipv4Denied.addSubnet(network, prefix, "ipv4");
+}
+const ipv6Allowed = new node_net_1.BlockList();
+for (const [network, prefix] of [
+    ["2001:200::", 23],
+    ["2001:400::", 23],
+    ["2001:600::", 23],
+    ["2001:800::", 22],
+    ["2001:c00::", 23],
+    ["2001:e00::", 23],
+    ["2001:1200::", 23],
+    ["2001:1400::", 22],
+    ["2001:1800::", 23],
+    ["2001:1a00::", 23],
+    ["2001:1c00::", 22],
+    ["2001:2000::", 19],
+    ["2001:4000::", 23],
+    ["2001:4200::", 23],
+    ["2001:4400::", 23],
+    ["2001:4600::", 23],
+    ["2001:4800::", 23],
+    ["2001:4a00::", 23],
+    ["2001:4c00::", 23],
+    ["2001:5000::", 20],
+    ["2001:8000::", 19],
+    ["2001:a000::", 20],
+    ["2001:b000::", 20],
+    ["2003::", 18],
+    ["2400::", 12],
+    ["2410::", 12],
+    ["2600::", 12],
+    ["2610::", 23],
+    ["2620::", 23],
+    ["2630::", 12],
+    ["2800::", 12],
+    ["2a00::", 12],
+    ["2a10::", 12],
+    ["2c00::", 12],
+]) {
+    ipv6Allowed.addSubnet(network, prefix, "ipv6");
+}
+const ipv6Denied = new node_net_1.BlockList();
+for (const [network, prefix] of [
+    ["100::", 64],
+    ["64:ff9b::", 96],
+    ["64:ff9b:1::", 48],
+    ["2001::", 23],
+    ["2001:db8::", 32],
+    ["2002::", 16],
+    ["3fff::", 20],
+    ["5f00::", 16],
+    ["fc00::", 7],
+    ["fe80::", 10],
+    ["fec0::", 10],
+    ["ff00::", 8],
+]) {
+    ipv6Denied.addSubnet(network, prefix, "ipv6");
+}
+const defaultNativeKnockRuntime = {
+    buildMessage: nhp_wire_js_1.buildNHPMessage,
+    resolveAddresses: resolvePublicAddresses,
+    exchange: exchangeDatagram,
+    decryptReply: nhp_wire_js_1.decryptNHPReply,
+};
+async function nativeKnock(cell, devicePrivateKey, body, options = {}) {
+    return nativeKnockWithRuntime(cell, devicePrivateKey, body, options, defaultNativeKnockRuntime);
+}
+async function nativeKnockWithRuntime(cell, devicePrivateKey, body, options, runtime) {
+    if (options.signal?.aborted)
+        throw options.signal.reason;
+    const built = runtime.buildMessage({
+        type: nhp_wire_js_1.NHP_TYPE_KNOCK,
+        devicePrivateKey,
+        serverPublicKey: cell.serverPublicKey,
+        body,
+    });
+    try {
+        const addresses = await runtime.resolveAddresses(cell.host, options.maxAddresses ?? NATIVE_DEFAULT_MAX_ADDRESSES, options.signal);
+        let lastError;
+        for (const address of addresses) {
+            try {
+                const packet = await runtime.exchange(address.address, address.family, cell.port, built.packet, options.timeoutMs ?? NATIVE_DEFAULT_TIMEOUT_MS, options.signal);
+                const reply = runtime.decryptReply(devicePrivateKey, cell.serverPublicKey, packet);
+                // NHP COOKIE is a stateless busy response. Go intentionally does
+                // not bind its counter to the request; only an ACK must match it.
+                if (reply.type === nhp_wire_js_1.NHP_TYPE_COOKIE)
+                    return reply;
+                if (reply.counter !== built.counter) {
+                    reply.body.fill(0);
+                    throw new Error("NHP reply counter does not match the request");
+                }
+                return reply;
+            }
+            catch (error) {
+                if (options.signal?.aborted)
+                    throw options.signal.reason;
+                // Authentication and reply-policy failures happen after a datagram was
+                // received. They are terminal and must not fall through to another DNS
+                // address. Only local socket failures carry this private marker.
+                if (!isSocketExchangeError(error))
+                    throw error;
+                lastError = error.cause;
+            }
+        }
+        throw new Error("native NHP exchange failed", { cause: lastError });
+    }
+    finally {
+        built.packet.fill(0);
+    }
+}
+async function resolvePublicAddresses(host, maximum, signal, lookupAddresses = promises_1.lookup) {
+    if (!Number.isInteger(maximum) || maximum < 1 || maximum > 16) {
+        throw new Error("native NHP maxAddresses must be an integer from 1 to 16");
+    }
+    if (signal?.aborted)
+        throw signal.reason;
+    let rows;
+    try {
+        rows = await waitForAbort(lookupAddresses(host, { all: true, verbatim: true }), signal);
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw signal.reason;
+        throw new Error("native NHP endpoint DNS resolution failed", { cause: error });
+    }
+    if (signal?.aborted)
+        throw signal.reason;
+    const accepted = [];
+    for (const row of rows) {
+        if (row.family !== 4 && row.family !== 6)
+            continue;
+        if (!isPublicAddress(row.address, row.family))
+            continue;
+        accepted.push({ address: row.address, family: row.family });
+        if (accepted.length === maximum)
+            break;
+    }
+    if (accepted.length === 0)
+        throw new Error("native NHP endpoint resolved to no public address");
+    return accepted;
+}
+function isPublicAddress(address, family) {
+    if ((0, node_net_1.isIP)(address) !== family)
+        return false;
+    if (family === 4)
+        return !ipv4Denied.check(address, "ipv4");
+    return ipv6Allowed.check(address, "ipv6") && !ipv6Denied.check(address, "ipv6");
+}
+class SocketExchangeError extends Error {
+    constructor(cause) {
+        super("native NHP socket exchange failed", { cause });
+        this.name = "SocketExchangeError";
+    }
+}
+// A received datagram is an authority-bearing response attempt. Its malformed
+// shape must stop address fallback instead of being treated as a local socket
+// miss that can send the same knock to another address.
+class ReceivedDatagramError extends Error {
+}
+function isSocketExchangeError(error) {
+    return error instanceof SocketExchangeError;
+}
+function exchangeDatagram(address, family, port, packet, timeoutMs, signal) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60_000) {
+        return Promise.reject(new Error("native NHP timeout must be from 1 to 60000 milliseconds"));
+    }
+    if (signal?.aborted) {
+        return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    }
+    return new Promise((resolve, reject) => {
+        const socket = (0, node_dgram_1.createSocket)(family === 6 ? "udp6" : "udp4");
+        let settled = false;
+        const finish = (error, reply) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            // An error that arrives while close settles must not become an unhandled
+            // EventEmitter error after the one-shot operational listener ran.
+            socket.on("error", () => undefined);
+            try {
+                socket.close();
+            }
+            catch {
+                // The socket can already be closed by a synchronous setup failure.
+            }
+            if (error instanceof ReceivedDatagramError)
+                reject(error);
+            else if (error !== undefined)
+                reject(new SocketExchangeError(error));
+            else
+                resolve(new Uint8Array(reply));
+        };
+        const abort = () => finish(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+        const timer = setTimeout(() => finish(new Error("native NHP reply timed out")), timeoutMs);
+        timer.unref();
+        signal?.addEventListener("abort", abort, { once: true });
+        socket.once("error", (error) => finish(error));
+        socket.once("message", (reply) => {
+            if (reply.byteLength > nhp_wire_js_1.NHP_PACKET_SIZE) {
+                finish(new ReceivedDatagramError("native NHP reply is too large"));
+            }
+            else
+                finish(undefined, reply);
+        });
+        socket.connect(port, address, () => {
+            sendOwnedDatagram(socket, packet, finish);
+        });
+    });
+}
+function sendOwnedDatagram(socket, packet, finish) {
+    // dgram owns its input until this callback. Use an independent encrypted
+    // datagram so nativeKnock can wipe the builder's packet immediately when an
+    // abort settles the exchange. Wipe this copy only after libuv releases it.
+    const outbound = Buffer.from(packet);
+    try {
+        socket.send(outbound, (error) => {
+            try {
+                if (error)
+                    finish(error);
+            }
+            finally {
+                outbound.fill(0);
+            }
+        });
+    }
+    catch (error) {
+        outbound.fill(0);
+        finish(error);
+    }
+}
+function waitForAbort(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    }
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            cleanup();
+            reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        };
+        const cleanup = () => signal.removeEventListener("abort", abort);
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+exports.nativeUdpTesting = {
+    isPublicAddress,
+    resolvePublicAddresses,
+    nativeKnockWithRuntime,
+    exchangeDatagram,
+    sendOwnedDatagram,
+    socketExchangeError: (cause) => new SocketExchangeError(cause),
+};

package/dist/cjs/node/nhp-wire.d.ts

@@ -0,0 +1,35 @@
+export declare const NHP_TYPE_KNOCK = 1;
+export declare const NHP_TYPE_ACK = 2;
+export declare const NHP_TYPE_COOKIE = 7;
+export declare const NHP_HEADER_SIZE = 240;
+export declare const NHP_PACKET_SIZE = 4096;
+export declare const NHP_MAX_BODY_SIZE: number;
+export interface NHPMessage {
+    readonly type: number;
+    readonly flags: number;
+    readonly counter: bigint;
+    readonly timestampNanos: bigint;
+    readonly body: Uint8Array;
+}
+export interface BuildNHPMessageInput {
+    readonly type: number;
+    readonly devicePrivateKey: Uint8Array;
+    readonly serverPublicKey: Uint8Array;
+    readonly body: Uint8Array;
+    readonly ephemeralPrivateKey?: Uint8Array;
+    readonly timestampNanos?: bigint;
+    readonly counter?: bigint;
+    readonly preamble?: number;
+}
+export declare function buildNHPMessage(input: BuildNHPMessageInput): {
+    packet: Uint8Array;
+    counter: bigint;
+};
+export declare function decryptNHPReply(devicePrivateKey: Uint8Array, expectedServerPublicKey: Uint8Array, packetValue: Uint8Array): NHPMessage;
+declare function validateReplyProfile(type: number, flags: number): void;
+declare function inflateReplyBody(body: Buffer, flags: number): Buffer;
+export declare const nhpWireTesting: {
+    validateReplyProfile: typeof validateReplyProfile;
+    inflateReplyBody: typeof inflateReplyBody;
+};
+export {};

package/dist/cjs/node/nhp-wire.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nhpWireTesting = exports.NHP_MAX_BODY_SIZE = exports.NHP_PACKET_SIZE = exports.NHP_HEADER_SIZE = exports.NHP_TYPE_COOKIE = exports.NHP_TYPE_ACK = exports.NHP_TYPE_KNOCK = void 0;
+exports.buildNHPMessage = buildNHPMessage;
+exports.decryptNHPReply = decryptNHPReply;
+const node_crypto_1 = require("node:crypto");
+const node_zlib_1 = require("node:zlib");
+exports.NHP_TYPE_KNOCK = 1;
+exports.NHP_TYPE_ACK = 2;
+exports.NHP_TYPE_COOKIE = 7;
+exports.NHP_HEADER_SIZE = 240;
+exports.NHP_PACKET_SIZE = 4_096;
+exports.NHP_MAX_BODY_SIZE = exports.NHP_PACKET_SIZE - exports.NHP_HEADER_SIZE - 16;
+const HEADER_COMMON_SIZE = 24;
+const OFFSET_EPHEMERAL = 24;
+const OFFSET_STATIC = 136;
+const OFFSET_TIMESTAMP = 184;
+const OFFSET_DIGEST = 208;
+const FLAG_COMPRESS = 1 << 1;
+const INITIAL_HASH = Buffer.from("NHP hashgen v.20230421@deepcloudsdp.com", "utf8");
+const INITIAL_CHAIN_KEY = Buffer.from("NHP keygen v.20230421@clouddeep.cn", "utf8");
+const X25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b656e04220420", "hex");
+const X25519_SPKI_PREFIX = Buffer.from("302a300506032b656e032100", "hex");
+function buildNHPMessage(input) {
+    validateKey(input.devicePrivateKey, "device private key");
+    validateKey(input.serverPublicKey, "server public key");
+    if (input.body.byteLength > exports.NHP_MAX_BODY_SIZE)
+        throw new Error("NHP application body is too large");
+    if (input.type !== exports.NHP_TYPE_KNOCK)
+        throw new Error("unsupported NHP initiator message type");
+    const ephemeralPrivateKey = input.ephemeralPrivateKey
+        ? Buffer.from(input.ephemeralPrivateKey)
+        : (0, node_crypto_1.randomBytes)(32);
+    const secrets = [ephemeralPrivateKey];
+    try {
+        validateKey(ephemeralPrivateKey, "ephemeral private key");
+        const random = input.counter === undefined || input.preamble === undefined ? (0, node_crypto_1.randomBytes)(12) : undefined;
+        const counter = input.counter ?? random.readBigUInt64BE(0);
+        const preamble = input.preamble ?? random.readUInt32BE(8);
+        const timestampNanos = input.timestampNanos ?? BigInt(Date.now()) * 1000000n;
+        const devicePublicKey = rawPublicFromPrivate(input.devicePrivateKey);
+        const ephemeralPublicKey = rawPublicFromPrivate(ephemeralPrivateKey);
+        const nonce = nonceForCounter(counter);
+        const header = Buffer.alloc(exports.NHP_HEADER_SIZE);
+        ephemeralPublicKey.copy(header, OFFSET_EPHEMERAL);
+        let chainHashParts = [INITIAL_HASH];
+        let chainKey = trackSecret(secrets, mixKey(hashParts(chainHashParts), INITIAL_CHAIN_KEY));
+        chainHashParts = [...chainHashParts, Buffer.from(input.serverPublicKey), ephemeralPublicKey];
+        chainKey = trackSecret(secrets, mixKey(chainKey, ephemeralPublicKey));
+        const ephemeralShared = trackSecret(secrets, sharedSecret(ephemeralPrivateKey, input.serverPublicKey));
+        let derived = keyGen2(chainKey, ephemeralShared);
+        secrets.push(...derived);
+        chainKey = derived[0];
+        const sealedStatic = seal(derived[1], nonce, devicePublicKey, hashParts(chainHashParts));
+        sealedStatic.copy(header, OFFSET_STATIC);
+        chainHashParts = [...chainHashParts, sealedStatic];
+        const staticShared = trackSecret(secrets, sharedSecret(input.devicePrivateKey, input.serverPublicKey));
+        derived = keyGen2(chainKey, staticShared);
+        secrets.push(...derived);
+        chainKey = derived[0];
+        const timestamp = Buffer.alloc(8);
+        timestamp.writeBigUInt64BE(timestampNanos);
+        const sealedTimestamp = seal(derived[1], nonce, timestamp, hashParts(chainHashParts));
+        sealedTimestamp.copy(header, OFFSET_TIMESTAMP);
+        chainHashParts = [...chainHashParts, sealedTimestamp];
+        derived = keyGen2(chainKey, sealedTimestamp);
+        secrets.push(...derived);
+        const bodyKey = derived[1];
+        header.writeUInt8(1, 8);
+        header.writeUInt8(1, 9);
+        header.writeUInt16BE(0, 10);
+        header.writeBigUInt64BE(counter, 16);
+        const payloadSize = input.body.byteLength === 0 ? 0 : input.body.byteLength + 16;
+        header.writeUInt32BE(preamble >>> 0, 0);
+        header.writeUInt32BE((preamble ^ ((input.type << 16) | payloadSize)) >>> 0, 4);
+        const bodyAad = hashParts([...chainHashParts, header.subarray(0, HEADER_COMMON_SIZE)]);
+        const sealedBody = input.body.byteLength === 0 ? Buffer.alloc(0) : seal(bodyKey, nonce, input.body, bodyAad);
+        headerDigest(input.serverPublicKey, header).copy(header, OFFSET_DIGEST);
+        return { packet: Buffer.concat([header, sealedBody]), counter };
+    }
+    finally {
+        wipeBuffers(secrets);
+    }
+}
+function decryptNHPReply(devicePrivateKey, expectedServerPublicKey, packetValue) {
+    validateKey(devicePrivateKey, "device private key");
+    validateKey(expectedServerPublicKey, "server public key");
+    const packet = Buffer.from(packetValue);
+    if (packet.byteLength < exports.NHP_HEADER_SIZE || packet.byteLength > exports.NHP_PACKET_SIZE) {
+        throw new Error("NHP reply size is outside the protocol bounds");
+    }
+    if (packet[8] !== 1 || packet[9] < 1)
+        throw new Error("unsupported NHP protocol version");
+    const header = packet.subarray(0, exports.NHP_HEADER_SIZE);
+    const sealedBody = packet.subarray(exports.NHP_HEADER_SIZE);
+    const secrets = [];
+    let body;
+    try {
+        const devicePublicKey = rawPublicFromPrivate(devicePrivateKey);
+        const expectedDigest = headerDigest(devicePublicKey, header);
+        if (!(0, node_crypto_1.timingSafeEqual)(expectedDigest, header.subarray(OFFSET_DIGEST))) {
+            throw new Error("NHP reply header authentication failed");
+        }
+        const counter = header.readBigUInt64BE(16);
+        const nonce = nonceForCounter(counter);
+        const serverEphemeral = header.subarray(OFFSET_EPHEMERAL, OFFSET_EPHEMERAL + 32);
+        const sealedStatic = header.subarray(OFFSET_STATIC, OFFSET_STATIC + 48);
+        const sealedTimestamp = header.subarray(OFFSET_TIMESTAMP, OFFSET_TIMESTAMP + 24);
+        let chainHashParts = [INITIAL_HASH];
+        let chainKey = trackSecret(secrets, mixKey(hashParts(chainHashParts), INITIAL_CHAIN_KEY));
+        chainHashParts = [...chainHashParts, devicePublicKey, serverEphemeral];
+        chainKey = trackSecret(secrets, mixKey(chainKey, serverEphemeral));
+        const ephemeralShared = trackSecret(secrets, sharedSecret(devicePrivateKey, serverEphemeral));
+        let derived = keyGen2(chainKey, ephemeralShared);
+        secrets.push(...derived);
+        chainKey = derived[0];
+        const serverStatic = open(derived[1], nonce, sealedStatic, hashParts(chainHashParts));
+        if (!(0, node_crypto_1.timingSafeEqual)(serverStatic, Buffer.from(expectedServerPublicKey))) {
+            throw new Error("NHP reply came from an unexpected server key");
+        }
+        chainHashParts = [...chainHashParts, sealedStatic];
+        const staticShared = trackSecret(secrets, sharedSecret(devicePrivateKey, serverStatic));
+        derived = keyGen2(chainKey, staticShared);
+        secrets.push(...derived);
+        chainKey = derived[0];
+        const timestamp = open(derived[1], nonce, sealedTimestamp, hashParts(chainHashParts));
+        chainHashParts = [...chainHashParts, sealedTimestamp];
+        derived = keyGen2(chainKey, sealedTimestamp);
+        secrets.push(...derived);
+        const bodyKey = derived[1];
+        const bodyAad = hashParts([...chainHashParts, header.subarray(0, HEADER_COMMON_SIZE)]);
+        body =
+            sealedBody.byteLength === 0 ? Buffer.alloc(0) : open(bodyKey, nonce, sealedBody, bodyAad);
+        const preamble = header.readUInt32BE(0);
+        const encodedTypeSize = (preamble ^ header.readUInt32BE(4)) >>> 0;
+        const type = (encodedTypeSize >>> 16) & 0xffff;
+        const flags = header.readUInt16BE(10);
+        validateReplyProfile(type, flags);
+        body = inflateReplyBody(body, flags);
+        if (body.byteLength > exports.NHP_PACKET_SIZE) {
+            throw new Error("NHP reply body exceeds the post-inflate limit");
+        }
+        const returnedBody = body;
+        body = undefined;
+        return {
+            type,
+            flags,
+            counter,
+            timestampNanos: timestamp.readBigUInt64BE(0),
+            body: returnedBody,
+        };
+    }
+    finally {
+        body?.fill(0);
+        wipeBuffers(secrets);
+    }
+}
+function validateReplyProfile(type, flags) {
+    if (![exports.NHP_TYPE_ACK, exports.NHP_TYPE_COOKIE].includes(type) || (flags !== 0 && flags !== FLAG_COMPRESS)) {
+        throw new Error("NHP reply type or flags are outside the reply profile");
+    }
+}
+function inflateReplyBody(body, flags) {
+    if (body.byteLength === 0 || (flags & FLAG_COMPRESS) === 0)
+        return body;
+    try {
+        return (0, node_zlib_1.inflateSync)(body, { maxOutputLength: exports.NHP_PACKET_SIZE });
+    }
+    finally {
+        body.fill(0);
+    }
+}
+function validateKey(key, name) {
+    if (key.byteLength !== 32)
+        throw new Error(`${name} must be 32 bytes`);
+}
+function rawPrivateKey(raw) {
+    const der = Buffer.alloc(X25519_PKCS8_PREFIX.byteLength + raw.byteLength);
+    X25519_PKCS8_PREFIX.copy(der);
+    der.set(raw, X25519_PKCS8_PREFIX.byteLength);
+    try {
+        return (0, node_crypto_1.createPrivateKey)({ key: der, format: "der", type: "pkcs8" });
+    }
+    finally {
+        der.fill(0);
+    }
+}
+function rawPublicKey(raw) {
+    return (0, node_crypto_1.createPublicKey)({
+        key: Buffer.concat([X25519_SPKI_PREFIX, Buffer.from(raw)]),
+        format: "der",
+        type: "spki",
+    });
+}
+function rawPublicFromPrivate(raw) {
+    const spki = (0, node_crypto_1.createPublicKey)(rawPrivateKey(raw)).export({ format: "der", type: "spki" });
+    return spki.subarray(spki.byteLength - 32);
+}
+function sharedSecret(privateValue, publicValue) {
+    return (0, node_crypto_1.diffieHellman)({
+        privateKey: rawPrivateKey(privateValue),
+        publicKey: rawPublicKey(publicValue),
+    });
+}
+function hashParts(parts) {
+    const hash = (0, node_crypto_1.createHash)("blake2s256");
+    for (const part of parts)
+        hash.update(part);
+    return hash.digest();
+}
+function hmac(key, ...parts) {
+    const mac = (0, node_crypto_1.createHmac)("blake2s256", key);
+    for (const part of parts)
+        mac.update(part);
+    return mac.digest();
+}
+function mixKey(key, input) {
+    const prk = hmac(key, input);
+    const mixed = hmac(prk, Uint8Array.of(1));
+    prk.fill(0);
+    return mixed;
+}
+function keyGen2(key, input) {
+    const prk = hmac(key, input);
+    const first = hmac(prk, Uint8Array.of(1));
+    const second = hmac(prk, first, Uint8Array.of(2));
+    prk.fill(0);
+    return [first, second];
+}
+function nonceForCounter(counter) {
+    const nonce = Buffer.alloc(12);
+    nonce.writeBigUInt64BE(counter, 4);
+    return nonce;
+}
+function seal(key, nonce, plaintext, aad) {
+    const cipher = (0, node_crypto_1.createCipheriv)("aes-256-gcm", key, nonce);
+    cipher.setAAD(aad);
+    return Buffer.concat([cipher.update(plaintext), cipher.final(), cipher.getAuthTag()]);
+}
+function open(key, nonce, sealed, aad) {
+    if (sealed.byteLength < 16)
+        throw new Error("NHP sealed field is shorter than its tag");
+    const ciphertext = sealed.subarray(0, sealed.byteLength - 16);
+    const tag = sealed.subarray(sealed.byteLength - 16);
+    const decipher = (0, node_crypto_1.createDecipheriv)("aes-256-gcm", key, nonce);
+    decipher.setAAD(aad);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function headerDigest(peerStaticPublicKey, header) {
+    return hashParts([INITIAL_HASH, peerStaticPublicKey, header.subarray(0, OFFSET_DIGEST)]);
+}
+function trackSecret(secrets, value) {
+    secrets.push(value);
+    return value;
+}
+function wipeBuffers(values) {
+    for (const value of values)
+        value.fill(0);
+}
+exports.nhpWireTesting = { validateReplyProfile, inflateReplyBody };