@netkitty/codec 1.0.0

package/dist/headers/TLS_ApplicationData.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLS_ApplicationData = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+var TLSver;
+(function (TLSver) {
+    TLSver["SSL_3_0"] = "SSL3.0";
+    TLSver["TLS_1_0"] = "TLS1.0";
+    TLSver["TLS_1_1"] = "TLS1.1";
+    TLSver["TLS_1_2"] = "TLS1.2";
+    TLSver["TLS_1_3"] = "TLS1.3";
+})(TLSver || (TLSver = {}));
+/**
+ * TLS Application Data protocol — a TLS/SSL record carrying encrypted application payload, over TCP
+ * (heuristically, port 443). This codec decodes the 5-octet TLS record header plus its body: an 8-bit
+ * Content Type (`contentType`, offset 0, = 23 / 0x17 for Application Data), a 16-bit legacy Version
+ * (`version`, offset 1, mapped to the labels SSL3.0 / TLS1.0 / TLS1.1 / TLS1.2 / TLS1.3 for 0x0300-0x0304,
+ * else "0"), a 16-bit record Length (`length`, offset 3), and the ciphertext body (`appData`, offset 5,
+ * `length` octets).
+ *
+ * The body is encrypted and opaque, so it is kept verbatim as `appData` hex (byte-perfect) and never
+ * sub-decoded; the Length is honored as given. A well-formed record round-trips byte-for-byte. In the
+ * heuristic chain (`heuristicFallback`), match() requires a Content Type of 0x17 and a recognized legacy
+ * Version (0x0300-0x0304).
+ */
+class TLS_ApplicationData extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                contentType: {
+                    type: 'integer',
+                    label: 'Content Type',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.contentType.setValue((0, BufferToNumber_1.BufferToInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        const contentType = (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.contentType.getValue(0, (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(0, contentType);
+                    }
+                },
+                version: {
+                    type: 'string',
+                    label: 'Legacy Version',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        const version = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(1, 2));
+                        switch (version) {
+                            case 768:
+                                {
+                                    this.instance.version.setValue(TLSver.SSL_3_0);
+                                }
+                                break;
+                            case 769:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_0);
+                                }
+                                break;
+                            case 770:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_1);
+                                }
+                                break;
+                            case 771:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_2);
+                                }
+                                break;
+                            case 772:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_3);
+                                }
+                                break;
+                            default: {
+                                this.instance.version.setValue('0');
+                            }
+                        }
+                    },
+                    encode: () => {
+                        const version = this.instance.version.getValue('0', (nodePath) => this.recordError(nodePath, 'Not found'));
+                        switch (version) {
+                            case TLSver.SSL_3_0:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(768);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_0:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(769);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_1:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(770);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_2:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(771);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_3:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(772);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            default: {
+                                this.writeBytes(1, (0, NumberToBuffer_1.UInt16ToBuffer)(0));
+                            }
+                        }
+                    }
+                },
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(3, 2)));
+                    },
+                    encode: () => {
+                        const length = (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.length.getValue(0, (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(3, length);
+                    }
+                },
+                appData: {
+                    type: 'string',
+                    label: 'Encrypted Application Data',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.appData.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(5, this.instance.length.getValue())));
+                    },
+                    encode: () => {
+                        const appData = (0, HexToBuffer_1.HexToBuffer)(this.instance.appData.getValue('0', (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(5, appData);
+                    }
+                }
+            }
+        };
+        this.id = 'tls-appdata';
+        this.matchKeys = ['tcpport:443'];
+        this.heuristicFallback = true;
+        this.name = 'Transport Layer Security(Application Data Protocol)';
+        this.nickname = 'TLS-AppData';
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        if ((0, BufferToHex_1.BufferToHex)(this.readBytes(0, 1)) != '17')
+            return false;
+        const version = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(1, 2));
+        const validVersions = [768, 769, 770, 771, 772];
+        return validVersions.includes(version);
+    }
+}
+exports.TLS_ApplicationData = TLS_ApplicationData;

package/dist/headers/TLS_ChangeCipherSpec.d.ts

@@ -0,0 +1,23 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+/**
+ * TLS ChangeCipherSpec protocol — a TLS/SSL record signaling the switch to the negotiated cipher, over TCP
+ * (heuristically, port 443). This codec decodes the 5-octet TLS record header plus its body: an 8-bit
+ * Content Type (`contentType`, offset 0, = 20 / 0x14 for ChangeCipherSpec), a 16-bit legacy Version
+ * (`version`, offset 1, mapped to the labels SSL3.0 / TLS1.0 / TLS1.1 / TLS1.2 / TLS1.3 for 0x0300-0x0304,
+ * else "0"), a 16-bit record Length (`length`, offset 3), and the message body
+ * (`change_cipher_spec_message`, offset 5, `length` octets — canonically the single byte 0x01).
+ *
+ * The body is kept verbatim as hex (byte-perfect) and the Length is honored as given, so a well-formed
+ * record round-trips byte-for-byte. In the heuristic chain (`heuristicFallback`), match() requires a
+ * Content Type of 0x14 and a recognized legacy Version (0x0300-0x0304).
+ */
+export declare class TLS_ChangeCipherSpec extends BaseHeader {
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    name: string;
+    nickname: string;
+    match(): boolean;
+}

package/dist/headers/TLS_ChangeCipherSpec.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLS_ChangeCipherSpec = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+var TLSver;
+(function (TLSver) {
+    TLSver["SSL_3_0"] = "SSL3.0";
+    TLSver["TLS_1_0"] = "TLS1.0";
+    TLSver["TLS_1_1"] = "TLS1.1";
+    TLSver["TLS_1_2"] = "TLS1.2";
+    TLSver["TLS_1_3"] = "TLS1.3";
+})(TLSver || (TLSver = {}));
+/**
+ * TLS ChangeCipherSpec protocol — a TLS/SSL record signaling the switch to the negotiated cipher, over TCP
+ * (heuristically, port 443). This codec decodes the 5-octet TLS record header plus its body: an 8-bit
+ * Content Type (`contentType`, offset 0, = 20 / 0x14 for ChangeCipherSpec), a 16-bit legacy Version
+ * (`version`, offset 1, mapped to the labels SSL3.0 / TLS1.0 / TLS1.1 / TLS1.2 / TLS1.3 for 0x0300-0x0304,
+ * else "0"), a 16-bit record Length (`length`, offset 3), and the message body
+ * (`change_cipher_spec_message`, offset 5, `length` octets — canonically the single byte 0x01).
+ *
+ * The body is kept verbatim as hex (byte-perfect) and the Length is honored as given, so a well-formed
+ * record round-trips byte-for-byte. In the heuristic chain (`heuristicFallback`), match() requires a
+ * Content Type of 0x14 and a recognized legacy Version (0x0300-0x0304).
+ */
+class TLS_ChangeCipherSpec extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                contentType: {
+                    type: 'integer',
+                    label: 'Content Type',
+                    minimum: 0,
+                    maximum: 255,
+                    decode: () => {
+                        this.instance.contentType.setValue((0, BufferToNumber_1.BufferToInt8)(this.readBytes(0, 1)));
+                    },
+                    encode: () => {
+                        const contentType = (0, NumberToBuffer_1.UInt8ToBuffer)(this.instance.contentType.getValue(0, (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(0, contentType);
+                    }
+                },
+                version: {
+                    type: 'string',
+                    label: 'Legacy Version',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        const version = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(1, 2));
+                        switch (version) {
+                            case 768:
+                                {
+                                    this.instance.version.setValue(TLSver.SSL_3_0);
+                                }
+                                break;
+                            case 769:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_0);
+                                }
+                                break;
+                            case 770:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_1);
+                                }
+                                break;
+                            case 771:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_2);
+                                }
+                                break;
+                            case 772:
+                                {
+                                    this.instance.version.setValue(TLSver.TLS_1_3);
+                                }
+                                break;
+                            default: {
+                                this.instance.version.setValue('0');
+                            }
+                        }
+                    },
+                    encode: () => {
+                        const version = this.instance.version.getValue('0', (nodePath) => this.recordError(nodePath, 'Not found'));
+                        switch (version) {
+                            case TLSver.SSL_3_0:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(768);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_0:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(769);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_1:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(770);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_2:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(771);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            case TLSver.TLS_1_3:
+                                {
+                                    const version = (0, NumberToBuffer_1.UInt16ToBuffer)(772);
+                                    this.writeBytes(1, version);
+                                }
+                                break;
+                            default: {
+                                this.writeBytes(1, (0, NumberToBuffer_1.UInt16ToBuffer)(0));
+                            }
+                        }
+                    }
+                },
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 65535,
+                    decode: () => {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt16)(this.readBytes(3, 2)));
+                    },
+                    encode: () => {
+                        const length = (0, NumberToBuffer_1.UInt16ToBuffer)(this.instance.length.getValue(0, (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(3, length);
+                    }
+                },
+                change_cipher_spec_message: {
+                    type: 'string',
+                    label: 'Change Cipher Spec Message',
+                    decode: () => {
+                        const length = this.instance.length.getValue(0, (nodePath) => this.recordError(nodePath, 'Not found'));
+                        this.instance.change_cipher_spec_message.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(5, length)));
+                    },
+                    encode: () => {
+                        const message = (0, HexToBuffer_1.HexToBuffer)(this.instance.change_cipher_spec_message.getValue('0', (nodePath) => this.recordError(nodePath, 'Not found')));
+                        this.writeBytes(5, message);
+                    }
+                }
+            }
+        };
+        this.id = 'tls-ccsp';
+        this.matchKeys = ['tcpport:443'];
+        this.heuristicFallback = true;
+        this.name = 'Transport Layer Security(ChangeCipherSpec Protocol)';
+        this.nickname = 'TLS-ChangeCipherSpec';
+    }
+    match() {
+        if (!this.prevCodecModule)
+            return false;
+        if ((0, BufferToHex_1.BufferToHex)(this.readBytes(0, 1)) != '14')
+            return false;
+        const version = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(1, 2));
+        const validVersions = [768, 769, 770, 771, 772];
+        return validVersions.includes(version);
+    }
+}
+exports.TLS_ChangeCipherSpec = TLS_ChangeCipherSpec;

package/dist/headers/TLS_Handshake.d.ts

@@ -0,0 +1,65 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+export declare class TLS_Handshake extends BaseHeader {
+    /**
+     * Map a 2-byte TLS version to a friendly string, or its 4-hex form when unknown.
+     */
+    protected tlsVersionToString(version: number): string;
+    /**
+     * Inverse of tlsVersionToString: a friendly string or 4-hex back to 2 bytes.
+     */
+    protected tlsVersionStringToBuffer(version: string): Buffer;
+    /**
+     * True when the handshake body could not be structured (unsupported message type or a
+     * parse failure) and was preserved as messagedata.raw. Encode then re-emits those bytes
+     * verbatim; a structured Hello (messagedata.version set) turns this false.
+     */
+    protected messagedataRawFallbackActive(): boolean;
+    /**
+     * Structurally decode a ClientHello (handshake type 1) body starting at record offset 9.
+     * Throws on any bound overrun / trailing bytes so the caller can fall back to raw.
+     */
+    protected decodeClientHello(bodyLength: number): void;
+    /**
+     * Structurally decode a ServerHello (handshake type 2) body starting at record offset 9.
+     * Throws on any bound overrun / trailing bytes so the caller can fall back to raw.
+     */
+    protected decodeServerHello(bodyLength: number): void;
+    /**
+     * Friendly name for a 2-byte TLS extension type (IANA registry), or its 4-hex form.
+     */
+    protected tlsExtensionName(type: string): string;
+    /**
+     * Split a TLS extensions block into its individual extensions. Each extension is a
+     * type(2) + length(2) + data(length) triple; data is kept as hex (authoritative for
+     * re-encode). Throws on any overrun so the caller can fall back to raw.
+     */
+    protected parseTLSExtensions(buffer: Buffer): any[];
+    /**
+     * Decode a single extension's inner structure by type. Returns the structured fields, or
+     * null when the type has no (implemented) structure so the caller keeps it as hex. Throws
+     * on any bound violation so the caller falls back to hex for that one extension.
+     */
+    protected decodeExtensionData(type: string, buffer: Buffer, handshakeType: string): any | null;
+    /**
+     * Decode a 2-byte-length-prefixed list of 2-byte codes into hex strings (used by
+     * supported_groups and signature_algorithms).
+     */
+    protected decodeCodeList16(buffer: Buffer): string[];
+    /**
+     * Rebuild a single extension's data buffer from its structured fields (inverse of
+     * decodeExtensionData). Only called for extensions decoded structurally (no `data` hex).
+     */
+    protected encodeExtensionData(extension: any, handshakeType: string): Buffer;
+    /**
+     * Rebuild a 2-byte-length-prefixed list of 2-byte codes (inverse of decodeCodeList16).
+     */
+    protected encodeCodeList16(codes: string[]): Buffer;
+    SCHEMA: ProtocolJSONSchema;
+    id: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    name: string;
+    nickname: string;
+    match(): boolean;
+}