@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/tls/alerts/tls-alert.d.ts

@@ -0,0 +1,150 @@
+import * as plugins from '../../plugins.js';
+import { TlsAlertLevel, TlsAlertDescription } from '../utils/tls-utils.js';
+/**
+ * TlsAlert class for creating and sending TLS alert messages
+ */
+export declare class TlsAlert {
+    static readonly LEVEL_WARNING = TlsAlertLevel.WARNING;
+    static readonly LEVEL_FATAL = TlsAlertLevel.FATAL;
+    static readonly CLOSE_NOTIFY = TlsAlertDescription.CLOSE_NOTIFY;
+    static readonly UNEXPECTED_MESSAGE = TlsAlertDescription.UNEXPECTED_MESSAGE;
+    static readonly BAD_RECORD_MAC = TlsAlertDescription.BAD_RECORD_MAC;
+    static readonly DECRYPTION_FAILED = TlsAlertDescription.DECRYPTION_FAILED;
+    static readonly RECORD_OVERFLOW = TlsAlertDescription.RECORD_OVERFLOW;
+    static readonly DECOMPRESSION_FAILURE = TlsAlertDescription.DECOMPRESSION_FAILURE;
+    static readonly HANDSHAKE_FAILURE = TlsAlertDescription.HANDSHAKE_FAILURE;
+    static readonly NO_CERTIFICATE = TlsAlertDescription.NO_CERTIFICATE;
+    static readonly BAD_CERTIFICATE = TlsAlertDescription.BAD_CERTIFICATE;
+    static readonly UNSUPPORTED_CERTIFICATE = TlsAlertDescription.UNSUPPORTED_CERTIFICATE;
+    static readonly CERTIFICATE_REVOKED = TlsAlertDescription.CERTIFICATE_REVOKED;
+    static readonly CERTIFICATE_EXPIRED = TlsAlertDescription.CERTIFICATE_EXPIRED;
+    static readonly CERTIFICATE_UNKNOWN = TlsAlertDescription.CERTIFICATE_UNKNOWN;
+    static readonly ILLEGAL_PARAMETER = TlsAlertDescription.ILLEGAL_PARAMETER;
+    static readonly UNKNOWN_CA = TlsAlertDescription.UNKNOWN_CA;
+    static readonly ACCESS_DENIED = TlsAlertDescription.ACCESS_DENIED;
+    static readonly DECODE_ERROR = TlsAlertDescription.DECODE_ERROR;
+    static readonly DECRYPT_ERROR = TlsAlertDescription.DECRYPT_ERROR;
+    static readonly EXPORT_RESTRICTION = TlsAlertDescription.EXPORT_RESTRICTION;
+    static readonly PROTOCOL_VERSION = TlsAlertDescription.PROTOCOL_VERSION;
+    static readonly INSUFFICIENT_SECURITY = TlsAlertDescription.INSUFFICIENT_SECURITY;
+    static readonly INTERNAL_ERROR = TlsAlertDescription.INTERNAL_ERROR;
+    static readonly INAPPROPRIATE_FALLBACK = TlsAlertDescription.INAPPROPRIATE_FALLBACK;
+    static readonly USER_CANCELED = TlsAlertDescription.USER_CANCELED;
+    static readonly NO_RENEGOTIATION = TlsAlertDescription.NO_RENEGOTIATION;
+    static readonly MISSING_EXTENSION = TlsAlertDescription.MISSING_EXTENSION;
+    static readonly UNSUPPORTED_EXTENSION = TlsAlertDescription.UNSUPPORTED_EXTENSION;
+    static readonly CERTIFICATE_REQUIRED = TlsAlertDescription.CERTIFICATE_REQUIRED;
+    static readonly UNRECOGNIZED_NAME = TlsAlertDescription.UNRECOGNIZED_NAME;
+    static readonly BAD_CERTIFICATE_STATUS_RESPONSE = TlsAlertDescription.BAD_CERTIFICATE_STATUS_RESPONSE;
+    static readonly BAD_CERTIFICATE_HASH_VALUE = TlsAlertDescription.BAD_CERTIFICATE_HASH_VALUE;
+    static readonly UNKNOWN_PSK_IDENTITY = TlsAlertDescription.UNKNOWN_PSK_IDENTITY;
+    static readonly CERTIFICATE_REQUIRED_1_3 = TlsAlertDescription.CERTIFICATE_REQUIRED_1_3;
+    static readonly NO_APPLICATION_PROTOCOL = TlsAlertDescription.NO_APPLICATION_PROTOCOL;
+    /**
+     * Create a TLS alert buffer with the specified level and description code
+     *
+     * @param level Alert level (warning or fatal)
+     * @param description Alert description code
+     * @param tlsVersion TLS version bytes (default is TLS 1.2: 0x0303)
+     * @returns Buffer containing the TLS alert message
+     */
+    static create(level: number, description: number, tlsVersion?: [number, number]): Buffer;
+    /**
+     * Create a warning-level TLS alert
+     *
+     * @param description Alert description code
+     * @returns Buffer containing the warning-level TLS alert message
+     */
+    static createWarning(description: number): Buffer;
+    /**
+     * Create a fatal-level TLS alert
+     *
+     * @param description Alert description code
+     * @returns Buffer containing the fatal-level TLS alert message
+     */
+    static createFatal(description: number): Buffer;
+    /**
+     * Send a TLS alert to a socket and optionally close the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param level Alert level (warning or fatal)
+     * @param description Alert description code
+     * @param closeAfterSend Whether to close the connection after sending the alert
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static send(socket: plugins.net.Socket, level: number, description: number, closeAfterSend?: boolean, closeDelay?: number): Promise<void>;
+    /**
+     * Pre-defined TLS alert messages
+     */
+    static readonly alerts: {
+        closeNotify: Buffer<ArrayBufferLike>;
+        unsupportedExtension: Buffer<ArrayBufferLike>;
+        certificateRequired: Buffer<ArrayBufferLike>;
+        unrecognizedName: Buffer<ArrayBufferLike>;
+        noRenegotiation: Buffer<ArrayBufferLike>;
+        userCanceled: Buffer<ArrayBufferLike>;
+        certificateExpiredWarning: Buffer<ArrayBufferLike>;
+        handshakeFailureWarning: Buffer<ArrayBufferLike>;
+        insufficientSecurityWarning: Buffer<ArrayBufferLike>;
+        unexpectedMessage: Buffer<ArrayBufferLike>;
+        badRecordMac: Buffer<ArrayBufferLike>;
+        recordOverflow: Buffer<ArrayBufferLike>;
+        handshakeFailure: Buffer<ArrayBufferLike>;
+        badCertificate: Buffer<ArrayBufferLike>;
+        certificateExpired: Buffer<ArrayBufferLike>;
+        certificateUnknown: Buffer<ArrayBufferLike>;
+        illegalParameter: Buffer<ArrayBufferLike>;
+        unknownCA: Buffer<ArrayBufferLike>;
+        accessDenied: Buffer<ArrayBufferLike>;
+        decodeError: Buffer<ArrayBufferLike>;
+        decryptError: Buffer<ArrayBufferLike>;
+        protocolVersion: Buffer<ArrayBufferLike>;
+        insufficientSecurity: Buffer<ArrayBufferLike>;
+        internalError: Buffer<ArrayBufferLike>;
+        unrecognizedNameFatal: Buffer<ArrayBufferLike>;
+    };
+    /**
+     * Utility method to send a warning-level unrecognized_name alert
+     * Specifically designed for SNI issues to encourage the client to retry with SNI
+     *
+     * @param socket The socket to send the alert to
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static sendSniRequired(socket: plugins.net.Socket): Promise<void>;
+    /**
+     * Utility method to send a close_notify alert and close the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent and the connection closed
+     */
+    static sendCloseNotify(socket: plugins.net.Socket, closeDelay?: number): Promise<void>;
+    /**
+     * Utility method to send a certificate_expired alert to force new TLS session
+     *
+     * @param socket The socket to send the alert to
+     * @param fatal Whether to send as a fatal alert (default: false)
+     * @param closeAfterSend Whether to close the connection after sending the alert (default: true)
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static sendCertificateExpired(socket: plugins.net.Socket, fatal?: boolean, closeAfterSend?: boolean, closeDelay?: number): Promise<void>;
+    /**
+     * Send a sequence of alerts to force SNI from clients
+     * This combines multiple alerts to ensure maximum browser compatibility
+     *
+     * @param socket The socket to send the alerts to
+     * @returns Promise that resolves when all alerts have been sent
+     */
+    static sendForceSniSequence(socket: plugins.net.Socket): Promise<void>;
+    /**
+     * Send a fatal level alert that immediately terminates the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param description Alert description code
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 100ms)
+     * @returns Promise that resolves when the alert has been sent and the connection closed
+     */
+    static sendFatalAndClose(socket: plugins.net.Socket, description: number, closeDelay?: number): Promise<void>;
+}

package/dist_ts/tls/alerts/tls-alert.js

@@ -0,0 +1,226 @@
+import * as plugins from '../../plugins.js';
+import { TlsAlertLevel, TlsAlertDescription, TlsVersion } from '../utils/tls-utils.js';
+/**
+ * TlsAlert class for creating and sending TLS alert messages
+ */
+export class TlsAlert {
+    // Use enum values from TlsAlertLevel
+    static { this.LEVEL_WARNING = TlsAlertLevel.WARNING; }
+    static { this.LEVEL_FATAL = TlsAlertLevel.FATAL; }
+    // Use enum values from TlsAlertDescription
+    static { this.CLOSE_NOTIFY = TlsAlertDescription.CLOSE_NOTIFY; }
+    static { this.UNEXPECTED_MESSAGE = TlsAlertDescription.UNEXPECTED_MESSAGE; }
+    static { this.BAD_RECORD_MAC = TlsAlertDescription.BAD_RECORD_MAC; }
+    static { this.DECRYPTION_FAILED = TlsAlertDescription.DECRYPTION_FAILED; }
+    static { this.RECORD_OVERFLOW = TlsAlertDescription.RECORD_OVERFLOW; }
+    static { this.DECOMPRESSION_FAILURE = TlsAlertDescription.DECOMPRESSION_FAILURE; }
+    static { this.HANDSHAKE_FAILURE = TlsAlertDescription.HANDSHAKE_FAILURE; }
+    static { this.NO_CERTIFICATE = TlsAlertDescription.NO_CERTIFICATE; }
+    static { this.BAD_CERTIFICATE = TlsAlertDescription.BAD_CERTIFICATE; }
+    static { this.UNSUPPORTED_CERTIFICATE = TlsAlertDescription.UNSUPPORTED_CERTIFICATE; }
+    static { this.CERTIFICATE_REVOKED = TlsAlertDescription.CERTIFICATE_REVOKED; }
+    static { this.CERTIFICATE_EXPIRED = TlsAlertDescription.CERTIFICATE_EXPIRED; }
+    static { this.CERTIFICATE_UNKNOWN = TlsAlertDescription.CERTIFICATE_UNKNOWN; }
+    static { this.ILLEGAL_PARAMETER = TlsAlertDescription.ILLEGAL_PARAMETER; }
+    static { this.UNKNOWN_CA = TlsAlertDescription.UNKNOWN_CA; }
+    static { this.ACCESS_DENIED = TlsAlertDescription.ACCESS_DENIED; }
+    static { this.DECODE_ERROR = TlsAlertDescription.DECODE_ERROR; }
+    static { this.DECRYPT_ERROR = TlsAlertDescription.DECRYPT_ERROR; }
+    static { this.EXPORT_RESTRICTION = TlsAlertDescription.EXPORT_RESTRICTION; }
+    static { this.PROTOCOL_VERSION = TlsAlertDescription.PROTOCOL_VERSION; }
+    static { this.INSUFFICIENT_SECURITY = TlsAlertDescription.INSUFFICIENT_SECURITY; }
+    static { this.INTERNAL_ERROR = TlsAlertDescription.INTERNAL_ERROR; }
+    static { this.INAPPROPRIATE_FALLBACK = TlsAlertDescription.INAPPROPRIATE_FALLBACK; }
+    static { this.USER_CANCELED = TlsAlertDescription.USER_CANCELED; }
+    static { this.NO_RENEGOTIATION = TlsAlertDescription.NO_RENEGOTIATION; }
+    static { this.MISSING_EXTENSION = TlsAlertDescription.MISSING_EXTENSION; }
+    static { this.UNSUPPORTED_EXTENSION = TlsAlertDescription.UNSUPPORTED_EXTENSION; }
+    static { this.CERTIFICATE_REQUIRED = TlsAlertDescription.CERTIFICATE_REQUIRED; }
+    static { this.UNRECOGNIZED_NAME = TlsAlertDescription.UNRECOGNIZED_NAME; }
+    static { this.BAD_CERTIFICATE_STATUS_RESPONSE = TlsAlertDescription.BAD_CERTIFICATE_STATUS_RESPONSE; }
+    static { this.BAD_CERTIFICATE_HASH_VALUE = TlsAlertDescription.BAD_CERTIFICATE_HASH_VALUE; }
+    static { this.UNKNOWN_PSK_IDENTITY = TlsAlertDescription.UNKNOWN_PSK_IDENTITY; }
+    static { this.CERTIFICATE_REQUIRED_1_3 = TlsAlertDescription.CERTIFICATE_REQUIRED_1_3; }
+    static { this.NO_APPLICATION_PROTOCOL = TlsAlertDescription.NO_APPLICATION_PROTOCOL; }
+    /**
+     * Create a TLS alert buffer with the specified level and description code
+     *
+     * @param level Alert level (warning or fatal)
+     * @param description Alert description code
+     * @param tlsVersion TLS version bytes (default is TLS 1.2: 0x0303)
+     * @returns Buffer containing the TLS alert message
+     */
+    static create(level, description, tlsVersion = [TlsVersion.TLS1_2[0], TlsVersion.TLS1_2[1]]) {
+        return Buffer.from([
+            0x15, // Alert record type
+            tlsVersion[0],
+            tlsVersion[1], // TLS version (default to TLS 1.2: 0x0303)
+            0x00,
+            0x02, // Length
+            level, // Alert level
+            description, // Alert description
+        ]);
+    }
+    /**
+     * Create a warning-level TLS alert
+     *
+     * @param description Alert description code
+     * @returns Buffer containing the warning-level TLS alert message
+     */
+    static createWarning(description) {
+        return this.create(this.LEVEL_WARNING, description);
+    }
+    /**
+     * Create a fatal-level TLS alert
+     *
+     * @param description Alert description code
+     * @returns Buffer containing the fatal-level TLS alert message
+     */
+    static createFatal(description) {
+        return this.create(this.LEVEL_FATAL, description);
+    }
+    /**
+     * Send a TLS alert to a socket and optionally close the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param level Alert level (warning or fatal)
+     * @param description Alert description code
+     * @param closeAfterSend Whether to close the connection after sending the alert
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static async send(socket, level, description, closeAfterSend = false, closeDelay = 200) {
+        const alert = this.create(level, description);
+        return new Promise((resolve, reject) => {
+            try {
+                // Ensure the alert is written as a single packet
+                socket.cork();
+                const writeSuccessful = socket.write(alert, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    if (closeAfterSend) {
+                        setTimeout(() => {
+                            socket.end();
+                            resolve();
+                        }, closeDelay);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+                socket.uncork();
+                // If write wasn't successful immediately, wait for drain
+                if (!writeSuccessful && !closeAfterSend) {
+                    socket.once('drain', () => {
+                        resolve();
+                    });
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    /**
+     * Pre-defined TLS alert messages
+     */
+    static { this.alerts = {
+        // Warning level alerts
+        closeNotify: TlsAlert.createWarning(TlsAlert.CLOSE_NOTIFY),
+        unsupportedExtension: TlsAlert.createWarning(TlsAlert.UNSUPPORTED_EXTENSION),
+        certificateRequired: TlsAlert.createWarning(TlsAlert.CERTIFICATE_REQUIRED),
+        unrecognizedName: TlsAlert.createWarning(TlsAlert.UNRECOGNIZED_NAME),
+        noRenegotiation: TlsAlert.createWarning(TlsAlert.NO_RENEGOTIATION),
+        userCanceled: TlsAlert.createWarning(TlsAlert.USER_CANCELED),
+        // Warning level alerts for session resumption
+        certificateExpiredWarning: TlsAlert.createWarning(TlsAlert.CERTIFICATE_EXPIRED),
+        handshakeFailureWarning: TlsAlert.createWarning(TlsAlert.HANDSHAKE_FAILURE),
+        insufficientSecurityWarning: TlsAlert.createWarning(TlsAlert.INSUFFICIENT_SECURITY),
+        // Fatal level alerts
+        unexpectedMessage: TlsAlert.createFatal(TlsAlert.UNEXPECTED_MESSAGE),
+        badRecordMac: TlsAlert.createFatal(TlsAlert.BAD_RECORD_MAC),
+        recordOverflow: TlsAlert.createFatal(TlsAlert.RECORD_OVERFLOW),
+        handshakeFailure: TlsAlert.createFatal(TlsAlert.HANDSHAKE_FAILURE),
+        badCertificate: TlsAlert.createFatal(TlsAlert.BAD_CERTIFICATE),
+        certificateExpired: TlsAlert.createFatal(TlsAlert.CERTIFICATE_EXPIRED),
+        certificateUnknown: TlsAlert.createFatal(TlsAlert.CERTIFICATE_UNKNOWN),
+        illegalParameter: TlsAlert.createFatal(TlsAlert.ILLEGAL_PARAMETER),
+        unknownCA: TlsAlert.createFatal(TlsAlert.UNKNOWN_CA),
+        accessDenied: TlsAlert.createFatal(TlsAlert.ACCESS_DENIED),
+        decodeError: TlsAlert.createFatal(TlsAlert.DECODE_ERROR),
+        decryptError: TlsAlert.createFatal(TlsAlert.DECRYPT_ERROR),
+        protocolVersion: TlsAlert.createFatal(TlsAlert.PROTOCOL_VERSION),
+        insufficientSecurity: TlsAlert.createFatal(TlsAlert.INSUFFICIENT_SECURITY),
+        internalError: TlsAlert.createFatal(TlsAlert.INTERNAL_ERROR),
+        unrecognizedNameFatal: TlsAlert.createFatal(TlsAlert.UNRECOGNIZED_NAME),
+    }; }
+    /**
+     * Utility method to send a warning-level unrecognized_name alert
+     * Specifically designed for SNI issues to encourage the client to retry with SNI
+     *
+     * @param socket The socket to send the alert to
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static async sendSniRequired(socket) {
+        return this.send(socket, this.LEVEL_WARNING, this.UNRECOGNIZED_NAME);
+    }
+    /**
+     * Utility method to send a close_notify alert and close the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent and the connection closed
+     */
+    static async sendCloseNotify(socket, closeDelay = 200) {
+        return this.send(socket, this.LEVEL_WARNING, this.CLOSE_NOTIFY, true, closeDelay);
+    }
+    /**
+     * Utility method to send a certificate_expired alert to force new TLS session
+     *
+     * @param socket The socket to send the alert to
+     * @param fatal Whether to send as a fatal alert (default: false)
+     * @param closeAfterSend Whether to close the connection after sending the alert (default: true)
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 200ms)
+     * @returns Promise that resolves when the alert has been sent
+     */
+    static async sendCertificateExpired(socket, fatal = false, closeAfterSend = true, closeDelay = 200) {
+        const level = fatal ? this.LEVEL_FATAL : this.LEVEL_WARNING;
+        return this.send(socket, level, this.CERTIFICATE_EXPIRED, closeAfterSend, closeDelay);
+    }
+    /**
+     * Send a sequence of alerts to force SNI from clients
+     * This combines multiple alerts to ensure maximum browser compatibility
+     *
+     * @param socket The socket to send the alerts to
+     * @returns Promise that resolves when all alerts have been sent
+     */
+    static async sendForceSniSequence(socket) {
+        try {
+            // Send unrecognized_name (warning)
+            socket.cork();
+            socket.write(this.alerts.unrecognizedName);
+            socket.uncork();
+            // Give the socket time to send the alert
+            return new Promise((resolve) => {
+                setTimeout(resolve, 50);
+            });
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    /**
+     * Send a fatal level alert that immediately terminates the connection
+     *
+     * @param socket The socket to send the alert to
+     * @param description Alert description code
+     * @param closeDelay Milliseconds to wait before closing the connection (default: 100ms)
+     * @returns Promise that resolves when the alert has been sent and the connection closed
+     */
+    static async sendFatalAndClose(socket, description, closeDelay = 100) {
+        return this.send(socket, this.LEVEL_FATAL, description, true, closeDelay);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tls-alert.js","sourceRoot":"","sources":["../../../ts/tls/alerts/tls-alert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEvF;;GAEG;AACH,MAAM,OAAO,QAAQ;IACnB,qCAAqC;aACrB,kBAAa,GAAG,aAAa,CAAC,OAAO,CAAC;aACtC,gBAAW,GAAG,aAAa,CAAC,KAAK,CAAC;IAElD,2CAA2C;aAC3B,iBAAY,GAAG,mBAAmB,CAAC,YAAY,CAAC;aAChD,uBAAkB,GAAG,mBAAmB,CAAC,kBAAkB,CAAC;aAC5D,mBAAc,GAAG,mBAAmB,CAAC,cAAc,CAAC;aACpD,sBAAiB,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;aAC1D,oBAAe,GAAG,mBAAmB,CAAC,eAAe,CAAC;aACtD,0BAAqB,GAAG,mBAAmB,CAAC,qBAAqB,CAAC;aAClE,sBAAiB,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;aAC1D,mBAAc,GAAG,mBAAmB,CAAC,cAAc,CAAC;aACpD,oBAAe,GAAG,mBAAmB,CAAC,eAAe,CAAC;aACtD,4BAAuB,GAAG,mBAAmB,CAAC,uBAAuB,CAAC;aACtE,wBAAmB,GAAG,mBAAmB,CAAC,mBAAmB,CAAC;aAC9D,wBAAmB,GAAG,mBAAmB,CAAC,mBAAmB,CAAC;aAC9D,wBAAmB,GAAG,mBAAmB,CAAC,mBAAmB,CAAC;aAC9D,sBAAiB,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;aAC1D,eAAU,GAAG,mBAAmB,CAAC,UAAU,CAAC;aAC5C,kBAAa,GAAG,mBAAmB,CAAC,aAAa,CAAC;aAClD,iBAAY,GAAG,mBAAmB,CAAC,YAAY,CAAC;aAChD,kBAAa,GAAG,mBAAmB,CAAC,aAAa,CAAC;aAClD,uBAAkB,GAAG,mBAAmB,CAAC,kBAAkB,CAAC;aAC5D,qBAAgB,GAAG,mBAAmB,CAAC,gBAAgB,CAAC;aACxD,0BAAqB,GAAG,mBAAmB,CAAC,qBAAqB,CAAC;aAClE,mBAAc,GAAG,mBAAmB,CAAC,cAAc,CAAC;aACpD,2BAAsB,GAAG,mBAAmB,CAAC,sBAAsB,CAAC;aACpE,kBAAa,GAAG,mBAAmB,CAAC,aAAa,CAAC;aAClD,qBAAgB,GAAG,mBAAmB,CAAC,gBAAgB,CAAC;aACxD,sBAAiB,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;aAC1D,0BAAqB,GAAG,mBAAmB,CAAC,qBAAqB,CAAC;aAClE,yBAAoB,GAAG,mBAAmB,CAAC,oBAAoB,CAAC;aAChE,sBAAiB,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;aAC1D,oCAA+B,GAAG,mBAAmB,CAAC,+BAA+B,CAAC;aACtF,+BAA0B,GAAG,mBAAmB,CAAC,0BAA0B,CAAC;aAC5E,yBAAoB,GAAG,mBAAmB,CAAC,oBAAoB,CAAC;aAChE,6BAAwB,GAAG,mBAAmB,CAAC,wBAAwB,CAAC;aACxE,4BAAuB,GAAG,mBAAmB,CAAC,uBAAuB,CAAC;IAEtF;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CACX,KAAa,EACb,WAAmB,EACnB,aAA+B,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAE3E,OAAO,MAAM,CAAC,IAAI,CAAC;YACjB,IAAI,EAAE,oBAAoB;YAC1B,UAAU,CAAC,CAAC,CAAC;YACb,UAAU,CAAC,CAAC,CAAC,EAAE,2CAA2C;YAC1D,IAAI;YACJ,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,cAAc;YACrB,WAAW,EAAE,oBAAoB;SAClC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,WAAmB;QACtC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;IACtD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,WAAmB;QACpC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CACf,MAA0B,EAC1B,KAAa,EACb,WAAmB,EACnB,iBAA0B,KAAK,EAC/B,aAAqB,GAAG;QAExB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAE9C,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,IAAI,CAAC;gBACH,iDAAiD;gBACjD,MAAM,CAAC,IAAI,EAAE,CAAC;gBACd,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBAClD,IAAI,GAAG,EAAE,CAAC;wBACR,MAAM,CAAC,GAAG,CAAC,CAAC;wBACZ,OAAO;oBACT,CAAC;oBAED,IAAI,cAAc,EAAE,CAAC;wBACnB,UAAU,CAAC,GAAG,EAAE;4BACd,MAAM,CAAC,GAAG,EAAE,CAAC;4BACb,OAAO,EAAE,CAAC;wBACZ,CAAC,EAAE,UAAU,CAAC,CAAC;oBACjB,CAAC;yBAAM,CAAC;wBACN,OAAO,EAAE,CAAC;oBACZ,CAAC;gBACH,CAAC,CAAC,CAAC;gBACH,MAAM,CAAC,MAAM,EAAE,CAAC;gBAEhB,yDAAyD;gBACzD,IAAI,CAAC,eAAe,IAAI,CAAC,cAAc,EAAE,CAAC;oBACxC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE;wBACxB,OAAO,EAAE,CAAC;oBACZ,CAAC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,GAAG,CAAC,CAAC;YACd,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;aACa,WAAM,GAAG;QACvB,uBAAuB;QACvB,WAAW,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC;QAC1D,oBAAoB,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,qBAAqB,CAAC;QAC5E,mBAAmB,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,oBAAoB,CAAC;QAC1E,gBAAgB,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QACpE,eAAe,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAClE,YAAY,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,aAAa,CAAC;QAE5D,8CAA8C;QAC9C,yBAAyB,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QAC/E,uBAAuB,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC3E,2BAA2B,EAAE,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,qBAAqB,CAAC;QAEnF,qBAAqB;QACrB,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,kBAAkB,CAAC;QACpE,YAAY,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC;QAC3D,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,eAAe,CAAC;QAC9D,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAClE,cAAc,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,eAAe,CAAC;QAC9D,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QACtE,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,mBAAmB,CAAC;QACtE,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAClE,SAAS,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC;QACpD,YAAY,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC;QAC1D,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,YAAY,CAAC;QACxD,YAAY,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,aAAa,CAAC;QAC1D,eAAe,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAChE,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,qBAAqB,CAAC;QAC1E,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC;QAC5D,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC;KACxE,CAAC;IAEF;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,MAA0B;QACrD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,MAA0B,EAAE,aAAqB,GAAG;QAC/E,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IACpF,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,CAAC,sBAAsB,CACjC,MAA0B,EAC1B,QAAiB,KAAK,EACtB,iBAA0B,IAAI,EAC9B,aAAqB,GAAG;QAExB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;IACxF,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAA0B;QAC1D,IAAI,CAAC;YACH,mCAAmC;YACnC,MAAM,CAAC,IAAI,EAAE,CAAC;YACd,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;YAC3C,MAAM,CAAC,MAAM,EAAE,CAAC;YAEhB,yCAAyC;YACzC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC7B,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAC1B,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAC5B,MAA0B,EAC1B,WAAmB,EACnB,aAAqB,GAAG;QAExB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;IAC5E,CAAC"}

package/dist_ts/tls/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * TLS module providing SNI extraction, TLS alerts, and other TLS-related utilities
+ */
+export * from './alerts/tls-alert.js';
+export * from './sni/sni-handler.js';
+export * from './sni/sni-extraction.js';
+export * from './sni/client-hello-parser.js';
+export * from './utils/tls-utils.js';
+import { SniHandler } from './sni/sni-handler.js';
+import { SniExtraction } from './sni/sni-extraction.js';
+import { ClientHelloParser } from './sni/client-hello-parser.js';
+export declare const SNI: {
+    Handler: typeof SniHandler;
+    Extraction: typeof SniExtraction;
+    Parser: typeof ClientHelloParser;
+    extractSNI: typeof SniHandler.extractSNI;
+    processTlsPacket: typeof SniHandler.processTlsPacket;
+};

package/dist_ts/tls/index.js

@@ -0,0 +1,27 @@
+/**
+ * TLS module providing SNI extraction, TLS alerts, and other TLS-related utilities
+ */
+// Export TLS alert functionality
+export * from './alerts/tls-alert.js';
+// Export SNI handling
+export * from './sni/sni-handler.js';
+export * from './sni/sni-extraction.js';
+export * from './sni/client-hello-parser.js';
+// Export TLS utilities
+export * from './utils/tls-utils.js';
+// Create a namespace for SNI utilities
+import { SniHandler } from './sni/sni-handler.js';
+import { SniExtraction } from './sni/sni-extraction.js';
+import { ClientHelloParser } from './sni/client-hello-parser.js';
+// Export utility objects for convenience
+export const SNI = {
+    // Main handler class (for backward compatibility)
+    Handler: SniHandler,
+    // Utility classes
+    Extraction: SniExtraction,
+    Parser: ClientHelloParser,
+    // Convenience functions
+    extractSNI: SniHandler.extractSNI,
+    processTlsPacket: SniHandler.processTlsPacket,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90bHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxpQ0FBaUM7QUFDakMsY0FBYyx1QkFBdUIsQ0FBQztBQUV0QyxzQkFBc0I7QUFDdEIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsOEJBQThCLENBQUM7QUFFN0MsdUJBQXVCO0FBQ3ZCLGNBQWMsc0JBQXNCLENBQUM7QUFFckMsdUNBQXVDO0FBQ3ZDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFakUseUNBQXlDO0FBQ3pDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsR0FBRztJQUNqQixrREFBa0Q7SUFDbEQsT0FBTyxFQUFFLFVBQVU7SUFFbkIsa0JBQWtCO0lBQ2xCLFVBQVUsRUFBRSxhQUFhO0lBQ3pCLE1BQU0sRUFBRSxpQkFBaUI7SUFFekIsd0JBQXdCO0lBQ3hCLFVBQVUsRUFBRSxVQUFVLENBQUMsVUFBVTtJQUNqQyxnQkFBZ0IsRUFBRSxVQUFVLENBQUMsZ0JBQWdCO0NBQzlDLENBQUMifQ==

package/dist_ts/tls/sni/client-hello-parser.d.ts

@@ -0,0 +1,100 @@
+import { Buffer } from 'buffer';
+/**
+ * Interface for logging functions used by the parser
+ */
+export type LoggerFunction = (message: string) => void;
+/**
+ * Result of a session resumption check
+ */
+export interface SessionResumptionResult {
+    isResumption: boolean;
+    hasSNI: boolean;
+}
+/**
+ * Information about parsed TLS extensions
+ */
+export interface ExtensionInfo {
+    type: number;
+    length: number;
+    data: Buffer;
+}
+/**
+ * Result of a ClientHello parse operation
+ */
+export interface ClientHelloParseResult {
+    isValid: boolean;
+    version?: [number, number];
+    random?: Buffer;
+    sessionId?: Buffer;
+    hasSessionId: boolean;
+    cipherSuites?: Buffer;
+    compressionMethods?: Buffer;
+    extensions: ExtensionInfo[];
+    serverNameList?: string[];
+    hasSessionTicket: boolean;
+    hasPsk: boolean;
+    hasEarlyData: boolean;
+    error?: string;
+}
+/**
+ * Fragment tracking information
+ */
+export interface FragmentTrackingInfo {
+    buffer: Buffer;
+    timestamp: number;
+    connectionId: string;
+}
+/**
+ * Class for parsing TLS ClientHello messages
+ */
+export declare class ClientHelloParser {
+    private static fragmentedBuffers;
+    private static fragmentTimeout;
+    /**
+     * Clean up expired fragments
+     */
+    private static cleanupExpiredFragments;
+    /**
+     * Handles potential fragmented ClientHello messages by buffering and reassembling
+     * TLS record fragments that might span multiple TCP packets.
+     *
+     * @param buffer The current buffer fragment
+     * @param connectionId Unique identifier for the connection
+     * @param logger Optional logging function
+     * @returns A complete buffer if reassembly is successful, or undefined if more fragments are needed
+     */
+    static handleFragmentedClientHello(buffer: Buffer, connectionId: string, logger?: LoggerFunction): Buffer | undefined;
+    /**
+     * Parses a TLS ClientHello message and extracts all components
+     *
+     * @param buffer The buffer containing the ClientHello message
+     * @param logger Optional logging function
+     * @returns Parsed ClientHello or undefined if parsing failed
+     */
+    static parseClientHello(buffer: Buffer, logger?: LoggerFunction): ClientHelloParseResult;
+    /**
+     * Parses the server name extension data and extracts hostnames
+     *
+     * @param data Extension data buffer
+     * @param serverNames Array to populate with found server names
+     * @param logger Optional logging function
+     * @returns true if parsing succeeded
+     */
+    private static parseServerNameExtension;
+    /**
+     * Determines if a ClientHello contains session resumption indicators
+     *
+     * @param buffer The ClientHello buffer
+     * @param logger Optional logging function
+     * @returns Session resumption result
+     */
+    static hasSessionResumption(buffer: Buffer, logger?: LoggerFunction): SessionResumptionResult;
+    /**
+     * Checks if a ClientHello appears to be from a tab reactivation
+     *
+     * @param buffer The ClientHello buffer
+     * @param logger Optional logging function
+     * @returns true if it appears to be a tab reactivation
+     */
+    static isTabReactivationHandshake(buffer: Buffer, logger?: LoggerFunction): boolean;
+}