ai-remote 0.4.0 → 0.4.2

package/dist/protocols/rdp/pdu.d.ts

@@ -0,0 +1,155 @@
+import { Reader } from './buffer';
+export declare const PDU_TYPE: {
+    DEMAND_ACTIVE: number;
+    CONFIRM_ACTIVE: number;
+    DEACTIVATE_ALL: number;
+    DATA: number;
+    SERVER_REDIRECT: number;
+};
+export declare const PDU_TYPE2: {
+    UPDATE: number;
+    CONTROL: number;
+    POINTER: number;
+    INPUT: number;
+    SYNCHRONIZE: number;
+    REFRESH_RECT: number;
+    PLAY_SOUND: number;
+    SUPPRESS_OUTPUT: number;
+    SHUTDOWN_REQUEST: number;
+    SHUTDOWN_DENIED: number;
+    SAVE_SESSION_INFO: number;
+    FONT_LIST: number;
+    FONT_MAP: number;
+    SET_ERROR_INFO: number;
+    MONITOR_LAYOUT: number;
+};
+export declare const UPDATE_TYPE: {
+    ORDERS: number;
+    BITMAP: number;
+    PALETTE: number;
+    SYNCHRONIZE: number;
+};
+export declare const CONTROL_ACTION: {
+    REQUEST_CONTROL: number;
+    GRANTED_CONTROL: number;
+    DETACH: number;
+    COOPERATE: number;
+};
+export declare const INPUT_EVENT: {
+    SYNC: number;
+    SCANCODE: number;
+    UNICODE: number;
+    MOUSE: number;
+    MOUSEX: number;
+};
+export declare const KEYBOARD_FLAG: {
+    EXTENDED: number;
+    DOWN: number;
+    RELEASE: number;
+};
+export declare const POINTER_FLAG: {
+    WHEEL: number;
+    HWHEEL: number;
+    WHEEL_NEGATIVE: number;
+    MOVE: number;
+    DOWN: number;
+    BUTTON1: number;
+    BUTTON2: number;
+    BUTTON3: number;
+};
+/** Translate browser-style wheel direction to the signed RDP rotation flags. */
+export declare function pointerWheelFlags(delta: number, horizontal?: boolean): number;
+export declare const TOGGLE_FLAG: {
+    SCROLL_LOCK: number;
+    NUM_LOCK: number;
+    CAPS_LOCK: number;
+    KANA_LOCK: number;
+};
+export declare function errorInfoMessage(errorInfo: any): any;
+/** TS_SHARECONTROLHEADER + payload. */
+export declare function shareControlPdu(pduType: any, userId: number, payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+/** TS_SHAREDATAHEADER inside a share control PDU of type DATA. */
+export declare function shareDataPdu(shareId: number, userId: number, pduType2: any, payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+/**
+ * Client Info PDU (MS-RDPBCGR 2.2.1.11). The credential lengths sit in front of
+ * the strings, so the strings are written to a scratch buffer first.
+ */
+export declare function clientInfoPdu({ domain, username, password, performanceFlags, autoLogon, remoteApp }: {
+    autoLogon: any;
+    domain: any;
+    password: any;
+    performanceFlags: any;
+    remoteApp?: boolean;
+    username: any;
+}): Uint8Array<ArrayBufferLike>;
+export declare function synchronizePdu(targetUser: any): Uint8Array<ArrayBufferLike>;
+export declare function controlPdu(action: any): Uint8Array<ArrayBufferLike>;
+export declare function fontListPdu(): Uint8Array<ArrayBufferLike>;
+export declare function confirmActivePdu(shareId: number, capabilities: any, capabilityCount: any): Uint8Array<ArrayBufferLike>;
+/** TS_INPUT_PDU_DATA: a batch of input events sharing one header. */
+export declare function inputEventsPdu(events: any): Uint8Array<ArrayBufferLike>;
+export declare function scancodeEvent(scancode: any, pressed: boolean, extended: any): Uint8Array<ArrayBufferLike>;
+export declare function unicodeEvent(codeUnit: any, pressed: boolean): Uint8Array<ArrayBufferLike>;
+export declare function mouseEvent(flags: number, x: number, y: number): Uint8Array<ArrayBufferLike>;
+export declare function extendedMouseEvent(flags: number, x: number, y: number): Uint8Array<ArrayBufferLike>;
+export declare function syncEvent(toggleFlags: number): Uint8Array<ArrayBufferLike>;
+export declare function refreshRectPdu(rects: any): Uint8Array<ArrayBufferLike>;
+export declare function suppressOutputPdu(allowDisplayUpdates: any, rect: any): Uint8Array<ArrayBufferLike>;
+export declare function parseShareControlHeader(bytes: Uint8Array): {
+    totalLength: number;
+    pduType: number;
+    pduSource: number;
+    payload: Uint8Array<ArrayBufferLike>;
+};
+export declare function parseShareDataHeader(bytes: Uint8Array): {
+    shareId: number;
+    pduType2: number;
+    compressedType: number;
+    compressedLength: number;
+    payload: Uint8Array<ArrayBufferLike>;
+};
+export declare function parseDemandActive(bytes: Uint8Array): {
+    shareId: number;
+    capabilities: Uint8Array<ArrayBufferLike>;
+};
+export declare function parseBitmapUpdate(reader: Reader): any[];
+export declare function parsePaletteUpdate(reader: Reader): Uint8Array<ArrayBuffer>;
+export declare function parsePointerUpdate(reader: Reader): {
+    kind: string;
+    cacheIndex: number;
+    hotSpotX: number;
+    hotSpotY: number;
+    width: number;
+    height: number;
+    xorBpp: any;
+    xorMask: Uint8Array<ArrayBuffer>;
+    andMask: Uint8Array<ArrayBuffer>;
+} | {
+    kind: string;
+    x: number;
+    y: number;
+    hidden?: undefined;
+    cacheIndex?: undefined;
+    messageType?: undefined;
+} | {
+    x?: undefined;
+    y?: undefined;
+    kind: string;
+    hidden: boolean;
+    cacheIndex?: undefined;
+    messageType?: undefined;
+} | {
+    x?: undefined;
+    y?: undefined;
+    hidden?: undefined;
+    kind: string;
+    cacheIndex: number;
+    messageType?: undefined;
+} | {
+    x?: undefined;
+    y?: undefined;
+    hidden?: undefined;
+    cacheIndex?: undefined;
+    kind: string;
+    messageType: number;
+};

package/dist/protocols/rdp/pdu.js

@@ -441,4 +441,3 @@ export {
   synchronizePdu,
   unicodeEvent
 };
-//# sourceMappingURL=pdu.js.map

package/dist/protocols/rdp/rail.d.ts

@@ -0,0 +1,119 @@
+import { Reader } from './buffer';
+export declare const RAIL_ORDER: {
+    EXEC: number;
+    ACTIVATE: number;
+    SYSPARAM: number;
+    SYSCOMMAND: number;
+    HANDSHAKE: number;
+    WINDOW_MOVE: number;
+    CLIENT_STATUS: number;
+    EXEC_RESULT: number;
+    HANDSHAKE_EX: number;
+};
+export declare const RAIL_EXEC_RESULT: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    5: string;
+    6: string;
+    7: string;
+};
+/** WM_SYSCOMMAND values a RAIL client may ask the host to apply to a window. */
+export declare const SYS_COMMAND: {
+    MINIMIZE: number;
+    MAXIMIZE: number;
+    CLOSE: number;
+    RESTORE: number;
+};
+/** SW_* show states reported by a window order's ShowState field. */
+export declare const SHOW_STATE: {
+    HIDDEN: number;
+    MINIMIZED: number;
+    MAXIMIZED: number;
+    NORMAL: number;
+};
+export declare const WINDOW_ORDER: {
+    TYPE_WINDOW: number;
+    STATE_NEW: number;
+    STATE_DELETED: number;
+    ICON: number;
+    CACHED_ICON: number;
+};
+export declare function railHandshake(buildNumber?: number): Uint8Array<ArrayBufferLike>;
+export declare function railClientStatus(flags?: number): Uint8Array<ArrayBufferLike>;
+/**
+ * SPI_SETWORKAREA. This is how a RAIL client tells the host how much room it
+ * has, and the host maximizes remote windows into it. Sending it again during
+ * the session is what keeps a maximized window matched to the browser window.
+ */
+export declare function railWorkArea(width: number, height: number): Uint8Array<ArrayBufferLike>;
+export declare function railSystemParameters(width: number, height: number): Uint8Array<ArrayBufferLike>[];
+/** TS_RAIL_ORDER_ACTIVATE: give (or take) input focus for one remote window. */
+export declare function railActivate(windowId: number, enabled?: boolean): Uint8Array<ArrayBufferLike>;
+/** TS_RAIL_ORDER_SYSCOMMAND: minimize, maximize, restore or close a window. */
+export declare function railSysCommand(windowId: number, command: string): Uint8Array<ArrayBufferLike>;
+/**
+ * TS_RAIL_ORDER_WINDOWMOVE. A client that draws remote windows itself sends
+ * this when the user finishes moving or resizing one; the host then applies
+ * the rectangle to the real window. It is the only way to give a remote window
+ * an exact size, which is what fitting one to the browser viewport needs.
+ */
+export declare function railWindowMove(windowId: number, { left, top, right, bottom }: {
+    bottom: any;
+    left: any;
+    right: any;
+    top: any;
+}): Uint8Array<ArrayBufferLike>;
+/** Build TS_RAIL_ORDER_EXEC. Strings are UTF-16LE and are not terminated. */
+export declare function railExecute({ program, workingDir, arguments: args }: {
+    arguments?: string;
+    program: any;
+    workingDir?: string;
+}): Uint8Array<ArrayBufferLike>;
+/**
+ * True for a window the session exists to show: not a child, not a tool
+ * window, and not one of the never-activated popups a Chromium or Electron
+ * application creates for menus, tooltips and drag images.
+ */
+export declare function isPrimaryWindow(candidate: any): boolean;
+/**
+ * Parse the window lifecycle subset of TS_UPDATE_ORDERS_PDU_DATA.
+ *
+ * RemoteApp window orders are Alternate Secondary orders and, unlike ordinary
+ * drawing orders, carry their total size in every header. That lets the parser
+ * read the fields it understands and then seek to the next order, rather than
+ * having to understand every icon, notification and desktop order to stay in
+ * sync with the stream.
+ */
+export declare function parseRemoteAppWindowOrders(reader: Reader): any[];
+/** Parse one or more complete RAIL PDUs delivered in a channel message. */
+export declare function parseRailPdus(bytes: Uint8Array): any[];
+/**
+ * Minimal RAIL endpoint for the browser client. It deliberately suppresses
+ * icon orders because the browser currently presents the RemoteApp session in
+ * one canvas rather than creating a local OS window per remote window.
+ */
+export declare class RailChannel {
+    private readonly application;
+    private width;
+    private height;
+    private readonly send;
+    private readonly onReady;
+    private readonly onResult;
+    private started;
+    constructor({ application, width, height, send, onReady, onResult }: {
+        application: any;
+        height: any;
+        onReady: any;
+        onResult: any;
+        send: any;
+        width: any;
+    });
+    receive(bytes: Uint8Array): void;
+    /** Republish the client's work area, which is what maximize resizes into. */
+    setWorkArea(width: number, height: number): boolean;
+    activate(windowId: number): boolean;
+    sysCommand(windowId: number, command: string): boolean;
+    moveWindow(windowId: number, rectangle: any): boolean;
+}

package/dist/protocols/rdp/rail.js

@@ -380,4 +380,3 @@ export {
   railWindowMove,
   railWorkArea
 };
-//# sourceMappingURL=rail.js.map

package/dist/protocols/rdp/rle.d.ts

@@ -0,0 +1,13 @@
+export declare function rleDecompress(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
+/**
+ * Reverse the row order of a decoded rectangle. RDP stores bitmaps bottom-up
+ * and a canvas expects top-down, so without this every rectangle is painted
+ * upside down.
+ */
+export declare function flipRows(pixels: Uint8Array, width: number): Uint32Array<ArrayBuffer> | Uint8Array<ArrayBufferLike>;
+/** Read uncompressed bitmap data, which RDP stores bottom-up. */
+export declare function readUncompressed(src: Uint8Array, width: number, height: number, bytesPerPixel: number): Uint32Array<ArrayBuffer>;
+/** Expand raw pixel values into RGBA for putImageData. */
+export declare function pixelsToRgba(pixels: Uint8Array, bitsPerPixel: number, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;
+/** Decode one TS_BITMAP_DATA rectangle to RGBA. */
+export declare function decodeBitmapRect(rect: BitmapRect, palette: Uint32Array): Uint8ClampedArray<ArrayBuffer>;

package/dist/protocols/rdp/rle.js

@@ -273,4 +273,3 @@ export {
   readUncompressed,
   rleDecompress
 };
-//# sourceMappingURL=rle.js.map

package/dist/protocols/rdp/sec.d.ts

@@ -0,0 +1,59 @@
+import { concatBytes } from './buffer';
+export declare const SEC_FLAG: {
+    EXCHANGE_PKT: number;
+    TRANSPORT_REQ: number;
+    ENCRYPT: number;
+    RESET_SEQNO: number;
+    IGNORE_SEQNO: number;
+    INFO_PKT: number;
+    LICENSE_PKT: number;
+    LICENSE_ENCRYPT_CS: number;
+    REDIRECTION_PKT: number;
+    SECURE_CHECKSUM: number;
+    AUTODETECT_REQ: number;
+    AUTODETECT_RSP: number;
+    HEARTBEAT: number;
+};
+export declare class SecurityLayer {
+    #private;
+    private encryptionMethod;
+    private encryptionLevel;
+    private keys;
+    private encryptState;
+    private decryptState;
+    private encryptedPdus;
+    private decryptedPdus;
+    constructor();
+    /** True when data PDUs carry a basic security header at all. */
+    get headerPresent(): boolean;
+    get encryptionEnabled(): boolean;
+    configure(encryptionMethod: number, encryptionLevel: number, clientRandom: Uint8Array, serverRandom: Uint8Array): void;
+    /**
+     * Prefix a payload with the basic security header, signing and encrypting it
+     * when the negotiated level asks for that.
+     *
+     * `flags` carries the PDU-kind bits (SEC_INFO_PKT and friends). A payload with
+     * no flags and no encryption needs no header at all.
+     */
+    wrap(payload: Uint8Array, flags?: number): Uint8Array<ArrayBufferLike>;
+    /**
+     * Strip (and if needed decrypt) the basic security header from a host PDU.
+     * `headerMandatory` forces the header to be read even when the host reported
+     * no encryption, which licensing PDUs require.
+     */
+    unwrap(bytes: Uint8Array, headerMandatory?: boolean): {
+        flags: number;
+        payload: Uint8Array<ArrayBufferLike>;
+    };
+    /**
+     * Fast-path output carries the same signature and RC4 stream as a slow-path
+     * PDU, but without the basic security header in front of it.
+     */
+    decryptFastPath(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+    /**
+     * Security Exchange PDU (MS-RDPBCGR 2.2.1.10): the client random encrypted
+     * with the host public key, followed by eight bytes of padding.
+     */
+    static securityExchange(encryptedClientRandom: any): Uint8Array<ArrayBufferLike>;
+}
+export { concatBytes };

package/dist/protocols/rdp/sec.js

@@ -153,4 +153,3 @@ export {
   SecurityLayer,
   concatBytes
 };
-//# sourceMappingURL=sec.js.map

package/dist/protocols/rdp/session.d.ts

@@ -0,0 +1,62 @@
+import type { ProtocolDriver } from '../types';
+export declare class RdpSession extends EventTarget {
+    #private;
+    readonly protocol: 'rdp';
+    constructor(container: any, url: string, options?: {});
+    /**
+     * Ask the host to size the remote application's window to the room this
+     * session has on the page. Full-desktop sessions have nothing to do here:
+     * their size is fixed when the connection is negotiated.
+     */
+    fitToViewport(): any;
+    get connected(): boolean;
+    get canvas(): HTMLCanvasElement | null;
+    /** The workspace instruments this socket for byte counters and keepalives. */
+    get socket(): WebSocket | null;
+    get _sock(): {
+        _websocket: any;
+    };
+    get scaleViewport(): any;
+    set scaleViewport(enabled: any);
+    get viewOnly(): any;
+    set viewOnly(enabled: any);
+    /**
+     * The on-screen keyboard and the special-keys dialog call this with an X11
+     * keysym and a DOM code. RDP wants a scancode, so the code decides; the
+     * keysym is only a fallback for characters with no key of their own.
+     */
+    sendKey(keysym: any, code: number, pressed: boolean): void;
+    sendCtrlAltDel(): void;
+    /** Desktop pixels. Returns false when the session cannot accept input. */
+    movePointer(x: number, y: number): boolean;
+    clickPointer(x: number, y: number, button?: number): boolean;
+    pointerButton(x: number, y: number, button?: number, pressed?: boolean): boolean;
+    scrollPointer(x: number, y: number, delta: {
+        x: number;
+        y: number;
+    }): boolean;
+    /** Type a run of characters, which RDP carries as Unicode rather than keys. */
+    typeText(text: string): boolean;
+    /** What the canvas is showing, for a screen capture or a coordinate check. */
+    get screenGeometry(): {
+        width: any;
+        height: any;
+        viewport: any;
+    };
+    /**
+     * Hand text to the host's clipboard, falling back to typing it when the host
+     * declined the clipboard channel -- xrdp builds often do.
+     */
+    clipboardPasteFrom(text: string): void;
+    /**
+     * Deliver text into the session, which is what the clipboard drawer's button
+     * has always visibly done. `clipboardPasteFrom` only loads the clipboard, the
+     * way noVNC's method of that name does.
+     */
+    pasteText(text: string): any;
+    releaseKeyboard(): void;
+    /** True once the host has agreed to share its clipboard. */
+    get clipboardShared(): any;
+    disconnect(): void;
+}
+export declare const rdpDriver: ProtocolDriver;

package/dist/protocols/rdp/session.js

@@ -304,4 +304,3 @@ export {
   RdpSession,
   rdpDriver
 };
-//# sourceMappingURL=session.js.map

package/dist/protocols/rdp/tls.d.ts

@@ -0,0 +1,18 @@
+export declare class Tls12Client {
+    #private;
+    /**
+     * @param {(bytes: Uint8Array) => void} send        write raw bytes to the transport
+     * @param {(bytes: Uint8Array) => void} onData      decrypted application data
+     * @param {(error: Error) => void} onError          fatal protocol failure
+     */
+    constructor({ send, onData, onError }: {
+        onData: any;
+        onError: any;
+        send: any;
+    });
+    start(): Promise<any>;
+    /** Feed transport bytes. Calls are serialized, so order is preserved. */
+    receive(bytes: Uint8Array): any;
+    /** Send application data once the handshake has completed. */
+    write(plaintext: Uint8Array): any;
+}

package/dist/protocols/rdp/tls.js

@@ -351,4 +351,3 @@ class Tls12Client {
 export {
   Tls12Client
 };
-//# sourceMappingURL=tls.js.map

package/dist/protocols/rdp/vchannel.d.ts

@@ -0,0 +1,28 @@
+/** Channel option bits used when the channel is declared in Client Network Data. */
+export declare const CHANNEL_OPTION: {
+    INITIALIZED: number;
+    ENCRYPT_RDP: number;
+    COMPRESS_RDP: number;
+    SHOW_PROTOCOL: number;
+};
+export declare const CHANNEL_FLAG_SHOW_PROTOCOL = 16;
+/** What RDP itself uses; a host may accept more, but never needs to. */
+export declare const CHANNEL_CHUNK_LENGTH = 1600;
+/**
+ * Split one logical channel message into wire chunks, each already carrying its
+ * CHANNEL_PDU_HEADER. An empty message still produces one chunk, because the
+ * header is what tells the host anything happened at all.
+ */
+export declare function chunkChannelData(data: Uint8Array, chunkSize?: number, extraFlags?: number): any[];
+/**
+ * Reassemble inbound chunks into whole messages. A chunk that arrives without a
+ * preceding FIRST is treated as its own message rather than dropped: some hosts
+ * send small PDUs with both flags set and others with neither.
+ */
+export declare class ChannelReassembler {
+    private parts;
+    private expectedLength;
+    constructor();
+    /** Returns the completed message, or null while more chunks are pending. */
+    push(bytes: Uint8Array): Uint8Array<ArrayBufferLike>;
+}

package/dist/protocols/rdp/vchannel.js

@@ -56,4 +56,3 @@ export {
   ChannelReassembler,
   chunkChannelData
 };
-//# sourceMappingURL=vchannel.js.map

package/dist/protocols/rdp/x224.d.ts

@@ -0,0 +1,40 @@
+export declare const TPKT_VERSION = 3;
+export declare const TPKT_HEADER_LENGTH = 4;
+export declare const NEG_FAILURE: {
+    SSL_REQUIRED: number;
+    SSL_NOT_ALLOWED: number;
+    SSL_CERT_NOT_ON_SERVER: number;
+    INCONSISTENT_FLAGS: number;
+    HYBRID_REQUIRED: number;
+    SSL_WITH_USER_AUTH_REQUIRED: number;
+};
+export declare const NEG_PROTOCOL: {
+    RDP: number;
+    SSL: number;
+    HYBRID: number;
+    RDSTLS: number;
+    HYBRID_EX: number;
+};
+/** X.224 Connection Request, carrying the protocols this client will accept. */
+export declare function connectionRequest(requestedProtocols: number): Uint8Array<ArrayBufferLike>;
+/**
+ * Read the X.224 Connection Confirm. Throws with the host's own explanation
+ * when it refuses the requested protocol.
+ */
+export declare function parseConnectionConfirm(frame: Uint8Array): {
+    selectedProtocol: number;
+    negotiated: boolean;
+};
+/** Wrap a payload in TPKT + X.224 Data. */
+export declare function dataFrame(payload: Uint8Array): Uint8Array<ArrayBufferLike>;
+/** Strip TPKT + X.224 Data headers from a complete frame. */
+export declare function dataPayload(frame: Uint8Array): Uint8Array<ArrayBufferLike>;
+/**
+ * Split a byte stream into whole frames. RDP interleaves two framings on one
+ * connection: TPKT (first byte 0x03) and fast-path output (any other value),
+ * each with its own length encoding.
+ */
+export declare function splitFrames(buffer: Uint8Array): {
+    frames: any[];
+    rest: Uint8Array<ArrayBufferLike>;
+};

package/dist/protocols/rdp/x224.js

@@ -107,4 +107,3 @@ export {
   parseConnectionConfirm,
   splitFrames
 };
-//# sourceMappingURL=x224.js.map

package/dist/protocols/ssh/kex.d.ts

@@ -0,0 +1,97 @@
+/** Key exchange methods, best first. All of them hash with SHA-256. */
+export declare const KEX_ALGORITHMS: {
+    'curve25519-sha256': {
+        type: string;
+        hash: string;
+    };
+    'curve25519-sha256@libssh.org': {
+        type: string;
+        hash: string;
+    };
+    'ecdh-sha2-nistp256': {
+        type: string;
+        curve: string;
+        hash: string;
+    };
+};
+/**
+ * Host key signature algorithms. `keyType` is what appears inside the key blob;
+ * a modern RSA key is signed with SHA-256 or SHA-512 but still calls itself
+ * ssh-rsa, so the two names differ there.
+ */
+export declare const HOST_KEY_ALGORITHMS: {
+    'ssh-ed25519': {
+        keyType: string;
+        kind: string;
+    };
+    'rsa-sha2-512': {
+        keyType: string;
+        kind: string;
+        hash: string;
+    };
+    'rsa-sha2-256': {
+        keyType: string;
+        kind: string;
+        hash: string;
+    };
+    'ecdsa-sha2-nistp256': {
+        keyType: string;
+        kind: string;
+        curve: string;
+        hash: string;
+    };
+};
+/**
+ * What this browser can actually do. X25519 and Ed25519 are recent additions to
+ * Web Crypto, so they are probed rather than assumed; the NIST curve and RSA
+ * have been there all along and always keep the session possible.
+ */
+export declare function negotiableAlgorithms(): Promise<any>;
+/** The client half of one key exchange. */
+export declare function createKexClient(algorithmName: string): Promise<{
+    hash: any;
+    publicKey: Uint8Array<ArrayBuffer>;
+    sharedSecret(serverPublicKey: any): Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The key type named inside a host key blob, which the algorithm must match. */
+export declare function hostKeyType(keyBlob: Uint8Array): string;
+/** The SHA256:… fingerprint OpenSSH prints, so a user can compare it. */
+export declare function hostKeyFingerprint(keyBlob: Uint8Array): Promise<string>;
+/**
+ * Check that the host owns the key it presented, by verifying its signature
+ * over the exchange hash. A failure here is fatal: it is what stands between
+ * the session and a machine in the middle of it.
+ */
+export declare function verifyHostKeySignature({ algorithm, keyBlob, signatureBlob, exchangeHash }: {
+    algorithm: any;
+    exchangeHash: any;
+    keyBlob: any;
+    signatureBlob: any;
+}): Promise<boolean>;
+/**
+ * The exchange hash H (RFC 4253 section 8), which both sides compute from the
+ * same inputs and the host signs.
+ */
+export declare function exchangeHash({ hash, clientVersion, serverVersion, clientKexInit, serverKexInit, hostKeyBlob, clientPublicKey, serverPublicKey, sharedSecret, }: {
+    clientKexInit: any;
+    clientPublicKey: any;
+    clientVersion: any;
+    hash: any;
+    hostKeyBlob: any;
+    serverKexInit: any;
+    serverPublicKey: any;
+    serverVersion: any;
+    sharedSecret: any;
+}): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Derive one key from the exchange (RFC 4253 section 7.2), extending it with
+ * further hash rounds when the cipher wants more bytes than one digest.
+ */
+export declare function deriveKey({ hash, sharedSecret, exchangeHash: h, letter, sessionId, length }: {
+    exchangeHash: any;
+    hash: any;
+    length: any;
+    letter: any;
+    sessionId: any;
+    sharedSecret: any;
+}): Promise<Uint8Array<ArrayBuffer>>;

package/dist/protocols/ssh/kex.js

@@ -174,4 +174,3 @@ export {
   negotiableAlgorithms,
   verifyHostKeySignature
 };
-//# sourceMappingURL=kex.js.map