@netkitty/codec 1.0.0

package/dist/headers/IRC.js

@@ -0,0 +1,175 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRC = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/** IRC command words (RFC 1459 / RFC 2812 + CAP/SASL) used only to recognize a message line. */
+const IRC_COMMANDS = ['PASS', 'NICK', 'USER', 'OPER', 'MODE', 'SERVICE', 'QUIT', 'SQUIT', 'JOIN', 'PART', 'TOPIC', 'NAMES', 'LIST', 'INVITE', 'KICK', 'PRIVMSG', 'NOTICE', 'MOTD', 'LUSERS', 'VERSION', 'STATS', 'LINKS', 'TIME', 'CONNECT', 'TRACE', 'ADMIN', 'INFO', 'SERVLIST', 'SQUERY', 'WHO', 'WHOIS', 'WHOWAS', 'KILL', 'PING', 'PONG', 'ERROR', 'AWAY', 'REHASH', 'DIE', 'RESTART', 'SUMMON', 'USERS', 'WALLOPS', 'USERHOST', 'ISON', 'CAP', 'AUTHENTICATE'];
+/**
+ * IRC — the Internet Relay Chat protocol (RFC 1459 / RFC 2812), carried as US-ASCII text over TCP
+ * well-known port 6667 (or 6697 for the TLS-wrapped IRC-over-TLS bucket). The channel is line-based: each
+ * message is an optional `:prefix` (source), then a COMMAND (a verb word like PRIVMSG/JOIN/NICK, or a
+ * 3-digit numeric reply code such as 001/433), then space-separated params with an optional ` :trailing`
+ * argument, terminated by CRLF. A client sends `NICK alice\r\n`, `JOIN #chan\r\n`, `PRIVMSG #chan :hi\r\n`;
+ * a server prefixes its messages with the source (`:server 001 alice :Welcome\r\n`,
+ * `:nick!user@host PRIVMSG #chan :hi\r\n`).
+ *
+ * Like FTP, SMTP, POP3, Syslog, SIP and HTTP, the message is text whose full internal structure
+ * (arbitrary params, significant whitespace, an optional trailing argument, multiple lines per segment)
+ * is richer than a form needs. So the ENTIRE raw message is kept verbatim as the authoritative `message`
+ * field (hex) and re-emitted untouched; only the FIRST line is parsed on decode into display-only
+ * metadata (prefix/command/params/isNumeric). Encode never reconstructs the message from the parsed
+ * fields — it writes `message` back byte-for-byte — so any conformant (or even malformed) IRC line
+ * round-trips exactly.
+ *
+ * Note: a single TCP segment may carry more than one line (IRC peers pipeline freely) or only part of a
+ * line; reassembly across segments is out of scope. This single-segment codec keeps whatever bytes are
+ * present verbatim, which is byte-perfect for the single-packet case.
+ */
+class IRC extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'irc';
+        this.name = 'Internet Relay Chat';
+        this.nickname = 'IRC';
+        //IRC is recognized ONLY on its well-known port buckets 6667 (plaintext) and 6697 (IRC-over-TLS) —
+        //deliberately NOT via heuristicFallback. Unlike HTTP/RTSP (whose method sets are distinctive), IRC's
+        //line signature is a generic verb (USER/QUIT/LIST/…) or a 3-digit numeric that is SHARED with other
+        //US-ASCII line protocols this codec also models — FTP (USER/QUIT/LIST + NNN codes), POP3/SMTP
+        //(USER/QUIT). The FTP code review found exactly this collision: an IRC `USER`/`QUIT` line is
+        //indistinguishable from an FTP one. Joining the global heuristic chain would let IRC mislabel an FTP
+        //`USER`/`LIST` line (or an FTP NNN greeting) on tcp:21 as IRC (and vice-versa). Confining IRC to the
+        //tcp:6667/tcp:6697 buckets keeps that collision impossible (FTP/POP3/SMTP live on 21/110/25, which
+        //never reach these buckets); alt-port IRC is rare and falls losslessly to raw. (IRC-over-TLS on 6697
+        //is normally TLS-wrapped, so the bucket rarely carries plain IRC text, but is listed for completeness.)
+        this.matchKeys = ['tcpport:6667', 'tcpport:6697'];
+        //A leaf header — the IRC session/dialog it belongs to is a higher-layer concern.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (_a.#schemaCache ??= _a.#buildSchema());
+    }
+    /**
+     * Bytes of this header: IRC rides on TCP, which has no per-message length, so take the rest of the
+     * segment. Reassembly across segments is out of scope (see class doc).
+     */
+    #payloadLength() {
+        const available = this.packet.length - this.startPos;
+        return available < 0 ? 0 : available;
+    }
+    /** The first line of the message (up to the first CRLF, or the whole payload if none). */
+    static #firstLine(text) {
+        const idx = text.indexOf('\r\n');
+        return idx >= 0 ? text.slice(0, idx) : text;
+    }
+    /**
+     * Parse the first line into the display-only metadata fields. An IRC message is
+     * `[':' prefix SP] COMMAND [params] [SP ':' trailing]`: if the line begins with `:` the token up to
+     * the first space is the source prefix (e.g. 'server' or 'nick!user@host'), otherwise there is no
+     * prefix. The COMMAND is the next token — kept as-is when it is a 3-digit numeric reply code,
+     * uppercased when it is a verb word; params is the remainder of the line (including any `:trailing`).
+     * Populated on decode only — these fields have no encode, so they never affect the re-emitted bytes
+     * and never mutate `message`. This is a pragmatic display split; never throws: missing/garbage tokens
+     * yield empty strings.
+     */
+    #parseFirstLine(text) {
+        const line = _a.#firstLine(text);
+        let rest = line;
+        let prefix = '';
+        if (rest.startsWith(':')) {
+            //A prefixed (server-originated) message: ':' source SP <rest>.
+            const sp = rest.indexOf(' ');
+            if (sp >= 0) {
+                prefix = rest.slice(1, sp);
+                rest = rest.slice(sp + 1).replace(/^ +/, '');
+            }
+            else {
+                prefix = rest.slice(1);
+                rest = '';
+            }
+        }
+        //COMMAND is the leading token of what remains; params is everything after it.
+        const idx = rest.indexOf(' ');
+        const rawCommand = idx >= 0 ? rest.slice(0, idx) : rest;
+        const params = idx >= 0 ? rest.slice(idx + 1) : '';
+        const isNumeric = /^\d{3}$/.test(rawCommand);
+        this.instance.prefix.setValue(prefix);
+        this.instance.command.setValue(isNumeric ? rawCommand : rawCommand.toUpperCase());
+        this.instance.params.setValue(params);
+        this.instance.isNumeric.setValue(isNumeric);
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'IRC ${command}',
+            properties: {
+                //The whole raw message is the single source of truth: decoded verbatim to hex and
+                //re-emitted untouched (byte-perfect for any IRC message text). The first line is parsed
+                //into the display-only metadata below, which carry no codec of their own.
+                message: {
+                    type: 'string',
+                    label: 'Message',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.#payloadLength();
+                        if (available <= 0) {
+                            this.instance.message.setValue('');
+                            this.#parseFirstLine('');
+                            return;
+                        }
+                        const raw = this.readBytes(0, available);
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(raw));
+                        this.#parseFirstLine(raw.toString('latin1'));
+                    },
+                    encode: function () {
+                        //Re-emit the authoritative message verbatim — never reconstruct from metadata.
+                        this.writeBytes(0, (0, HexToBuffer_1.HexToBuffer)(this.instance.message.getValue('')));
+                    }
+                },
+                //Display-only metadata parsed from the first line on decode (no encode — populated by the
+                //message field above, never read back). prefix is the optional message source; command is
+                //the verb word or numeric reply code; params is the remainder (including any :trailing);
+                //isNumeric marks a 3-digit numeric reply.
+                prefix: { type: 'string', label: 'Prefix' },
+                command: { type: 'string', label: 'Command' },
+                params: { type: 'string', label: 'Params' },
+                isNumeric: { type: 'boolean', label: 'Is Numeric' }
+            }
+        };
+    }
+    match() {
+        //IRC rides on TCP as US-ASCII text. Recognize it by the line signature: either a prefixed
+        //server message (`:` source SP COMMAND …) whose command token is a known verb/numeric, or a
+        //leading token that is itself a known verb/numeric — so non-IRC traffic on port 6667/6697 falls
+        //through to raw rather than claiming an un-decodable text layer.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.#payloadLength() < 4)
+            return false;
+        const lead = this.readBytes(0, 128, true).toString('latin1');
+        const line = _a.#firstLine(lead);
+        if (line.startsWith(':')) {
+            //A prefixed message: require ':' + a non-space source, then a space, then a command token.
+            //This keeps the `:` branch from over-claiming (a bare `:` or `: …` is not IRC).
+            const sp = line.indexOf(' ');
+            if (sp <= 1)
+                return false;
+            const rest = line.slice(sp + 1).replace(/^ +/, '');
+            const token = (rest.split(/[ \r]/)[0] || '').toUpperCase();
+            if (!token)
+                return false;
+            return /^\d{3}$/.test(token) || IRC_COMMANDS.includes(token);
+        }
+        //An unprefixed (typically client) message: the leading token must be a known verb or numeric.
+        const token = (line.split(/[ \r]/)[0] || '').toUpperCase();
+        return /^\d{3}$/.test(token) || IRC_COMMANDS.includes(token);
+    }
+}
+exports.IRC = IRC;
+_a = IRC;

package/dist/headers/ISAKMP.d.ts

@@ -0,0 +1,29 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * ISAKMP / IKE — Internet Security Association and Key Management Protocol carrying IKEv1 (RFC 2408 /
+ * RFC 2409) and IKEv2 (RFC 7296), UDP port 500 (NAT-T also uses 4500 with a 4-byte non-ESP marker
+ * prefix — out of scope for this slice, which matches port 500 only). A 28-byte fixed header (all
+ * big-endian): the 8-byte Initiator and 8-byte Responder SPIs (cookies), a Next Payload selector, a
+ * split Version byte (high nibble = major, low nibble = minor; IKEv1 is 0x10, IKEv2 is 0x20), the
+ * Exchange Type, a flags byte, the 4-byte Message ID, and the 4-byte total message Length (header +
+ * all payloads). The header is followed by a chain of generic payloads walked via each payload's own
+ * Next Payload / Payload Length until Next Payload == 0 (or the message Length / UDP payload is
+ * consumed).
+ *
+ * Payloads are carried generically (Next Payload + critical/reserved + length + verbatim body hex) so
+ * every payload — SA proposals, KE, Nonce, encrypted payloads — round-trips byte-for-byte; per-payload
+ * semantic decoding is a later enrichment. The chain walk is bounded by the message Length (honored
+ * else derived on encode) clamped by the UDP payload, so any trailing bytes spill to the raw layer.
+ */
+export declare class ISAKMP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/ISAKMP.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISAKMP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const BufferToNumber_1 = require("../helper/BufferToNumber");
+const NumberToBuffer_1 = require("../helper/NumberToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * ISAKMP / IKE — Internet Security Association and Key Management Protocol carrying IKEv1 (RFC 2408 /
+ * RFC 2409) and IKEv2 (RFC 7296), UDP port 500 (NAT-T also uses 4500 with a 4-byte non-ESP marker
+ * prefix — out of scope for this slice, which matches port 500 only). A 28-byte fixed header (all
+ * big-endian): the 8-byte Initiator and 8-byte Responder SPIs (cookies), a Next Payload selector, a
+ * split Version byte (high nibble = major, low nibble = minor; IKEv1 is 0x10, IKEv2 is 0x20), the
+ * Exchange Type, a flags byte, the 4-byte Message ID, and the 4-byte total message Length (header +
+ * all payloads). The header is followed by a chain of generic payloads walked via each payload's own
+ * Next Payload / Payload Length until Next Payload == 0 (or the message Length / UDP payload is
+ * consumed).
+ *
+ * Payloads are carried generically (Next Payload + critical/reserved + length + verbatim body hex) so
+ * every payload — SA proposals, KE, Nonce, encrypted payloads — round-trips byte-for-byte; per-payload
+ * semantic decoding is a later enrichment. The chain walk is bounded by the message Length (honored
+ * else derived on encode) clamped by the UDP payload, so any trailing bytes spill to the raw layer.
+ */
+class ISAKMP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'isakmp';
+        this.name = 'ISAKMP/IKE';
+        this.nickname = 'ISAKMP';
+        this.matchKeys = ['udpport:500'];
+        //A leaf header — payload bodies are carried verbatim; nothing demuxes above ISAKMP in this slice.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (ISAKMP.#schemaCache ??= ISAKMP.#buildSchema());
+    }
+    /** Bytes available for this ISAKMP message: the frame end, clamped by the UDP payload and the message Length. */
+    #available() {
+        let available = this.packet.length - this.startPos;
+        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+            const udpLength = this.prevCodecModule.instance.length.getValue(0);
+            if (udpLength >= 8 && udpLength - 8 < available)
+                available = udpLength - 8;
+        }
+        //During match() the Length field is not yet decoded (getValue → 0), so this reduces to the
+        //UDP-payload bound; during decode it is set and tightens the payload-chain walk.
+        const length = this.instance.length.getValue(0);
+        if (length >= 28 && length < available)
+            available = length;
+        return available < 0 ? 0 : available;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'ISAKMP exch=${exchangeType}',
+            properties: {
+                initiatorSPI: this.fieldHex('initiatorSPI', 0, 8, 'Initiator SPI'),
+                responderSPI: this.fieldHex('responderSPI', 8, 8, 'Responder SPI'),
+                nextPayload: this.fieldUInt('nextPayload', 16, 1, 'Next Payload'),
+                //Version byte (offset 17): high nibble = major, low nibble = minor. IKEv1 = 1.0 (0x10),
+                //IKEv2 = 2.0 (0x20). Split into nibbles (lossless: the whole byte is major+minor).
+                version: {
+                    type: 'object',
+                    label: 'Version',
+                    properties: {
+                        major: {
+                            type: 'integer', label: 'Major', minimum: 0, maximum: 15,
+                            decode: function () { this.instance.version.major.setValue(this.readBits(17, 1, 0, 4)); },
+                            encode: function () { this.writeBits(17, 1, 0, 4, this.instance.version.major.getValue(2)); }
+                        },
+                        minor: {
+                            type: 'integer', label: 'Minor', minimum: 0, maximum: 15,
+                            decode: function () { this.instance.version.minor.setValue(this.readBits(17, 1, 4, 4)); },
+                            encode: function () { this.writeBits(17, 1, 4, 4, this.instance.version.minor.getValue(0)); }
+                        }
+                    }
+                },
+                exchangeType: this.fieldUInt('exchangeType', 18, 1, 'Exchange Type'),
+                //Flags byte (offset 19) kept whole: IKEv2 uses bit X(0x08 Initiator)/V(0x10 Version)/
+                //R(0x20 Response); IKEv1 uses E/C/A. Carried verbatim so any flag combination round-trips.
+                flags: this.fieldUInt('flags', 19, 1, 'Flags'),
+                messageId: this.fieldUInt('messageId', 20, 4, 'Message ID'),
+                length: {
+                    type: 'integer',
+                    label: 'Length',
+                    minimum: 0,
+                    maximum: 4294967295,
+                    decode: function () {
+                        this.instance.length.setValue((0, BufferToNumber_1.BufferToUInt32)(this.readBytes(24, 4)));
+                    },
+                    encode: function () {
+                        //Honor an explicitly-set Length (even a decoded malformed one, so it round-trips
+                        //byte-for-byte); auto-compute the whole-message length only when absent (crafting).
+                        const length = this.instance.length.getValue();
+                        if (length !== undefined && length !== null) {
+                            this.instance.length.setValue(length);
+                            this.writeBytes(24, (0, NumberToBuffer_1.UInt32ToBuffer)(length));
+                        }
+                        else {
+                            this.writeBytes(24, (0, NumberToBuffer_1.UInt32ToBuffer)(0));
+                            //After the payload chain has encoded, the header length is the whole message.
+                            this.addPostSelfEncodeHandler(() => {
+                                this.instance.length.setValue(this.length);
+                                this.writeBytes(24, (0, NumberToBuffer_1.UInt32ToBuffer)(this.length));
+                            }, 1);
+                        }
+                    }
+                },
+                payloads: {
+                    type: 'array',
+                    label: 'Payloads',
+                    items: {
+                        type: 'object',
+                        label: 'Payload',
+                        properties: {
+                            nextPayload: { type: 'integer', label: 'Next Payload', minimum: 0, maximum: 255 },
+                            critical: { type: 'boolean', label: 'Critical' },
+                            reserved: { type: 'integer', label: 'Reserved', minimum: 0, maximum: 127, hidden: true },
+                            payloadLength: { type: 'integer', label: 'Payload Length', minimum: 0, maximum: 65535 },
+                            body: { type: 'string', label: 'Body', contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX }
+                        }
+                    },
+                    decode: function () {
+                        const end = this.#available();
+                        const payloads = [];
+                        let offset = 28;
+                        //The header's Next Payload selects the first payload's type; each generic payload
+                        //header's own Next Payload selects the following one — the chain ends at 0. Probe
+                        //the 4-byte generic header (dry) first; a Payload Length < 4 (would not advance) or
+                        //one that overruns the message stops the walk and leaves the rest to the raw layer.
+                        let next = this.instance.nextPayload.getValue(0);
+                        while (next !== 0 && offset + 4 <= end) {
+                            const payloadNext = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset, 1, true));
+                            const criticalReserved = (0, BufferToNumber_1.BufferToUInt8)(this.readBytes(offset + 1, 1, true));
+                            const payloadLength = (0, BufferToNumber_1.BufferToUInt16)(this.readBytes(offset + 2, 2, true));
+                            if (payloadLength < 4 || offset + payloadLength > end)
+                                break;
+                            const payloadBuffer = this.readBytes(offset, payloadLength);
+                            payloads.push({
+                                nextPayload: payloadNext,
+                                critical: !!(criticalReserved & 0x80),
+                                reserved: criticalReserved & 0x7f,
+                                payloadLength: payloadLength,
+                                body: payloadLength > 4 ? (0, BufferToHex_1.BufferToHex)(payloadBuffer.subarray(4)) : ''
+                            });
+                            offset += payloadLength;
+                            next = payloadNext;
+                        }
+                        this.instance.payloads.setValue(payloads);
+                    },
+                    encode: function () {
+                        const payloads = this.instance.payloads.getValue([]);
+                        if (!payloads)
+                            return;
+                        let offset = 28;
+                        for (const payload of payloads) {
+                            const body = (0, HexToBuffer_1.HexToBuffer)(payload.body ? payload.body : '');
+                            //Honor an explicit Payload Length (byte-perfect for decoded frames), else derive
+                            //it from the body (4-byte generic header + body).
+                            const payloadLength = (payload.payloadLength !== undefined && payload.payloadLength !== null)
+                                ? payload.payloadLength
+                                : body.length + 4;
+                            const criticalReserved = (payload.critical ? 0x80 : 0) | ((payload.reserved ? payload.reserved : 0) & 0x7f);
+                            this.writeBytes(offset, (0, NumberToBuffer_1.UInt8ToBuffer)(payload.nextPayload ? payload.nextPayload : 0));
+                            this.writeBytes(offset + 1, (0, NumberToBuffer_1.UInt8ToBuffer)(criticalReserved));
+                            this.writeBytes(offset + 2, (0, NumberToBuffer_1.UInt16ToBuffer)(payloadLength));
+                            offset += 4;
+                            if (body.length) {
+                                this.writeBytes(offset, body);
+                                offset += body.length;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //Require the full 28-byte fixed header within the UDP payload, a plausible message Length (>= the
+        //header itself), and a major-version nibble of 1 (IKEv1) or 2 (IKEv2) — anything else on port 500
+        //(e.g. an IKE NAT keepalive 0xff, or unrelated traffic) falls through to raw. No heuristic
+        //fallback: the port bucket plus this signature is the sole selector.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.#available() < 28)
+            return false;
+        const length = (0, BufferToNumber_1.BufferToUInt32)(this.readBytes(24, 4, true));
+        if (length < 28)
+            return false;
+        const major = this.readBytes(17, 1, true)[0] >> 4;
+        return major === 1 || major === 2;
+    }
+}
+exports.ISAKMP = ISAKMP;

package/dist/headers/ISCSI.d.ts

@@ -0,0 +1,39 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * iSCSI — Internet Small Computer Systems Interface (RFC 7143), TCP port 3260. Every iSCSI PDU begins
+ * with a fixed 48-byte Basic Header Segment (BHS):
+ *   byte 0  : reserved bit (0x80) | Immediate bit I (0x40) | 6-bit Opcode (0x3f)
+ *   byte 1  : Final/Transit bit F (0x80) | 7 opcode-specific flag bits
+ *   bytes 2-3 : opcode-specific
+ *   byte 4  : TotalAHSLength (count of 4-byte AHS words)
+ *   bytes 5-7 : DataSegmentLength (24-bit)
+ *   bytes 8-15 : LUN or opcode-specific
+ *   bytes 16-19 : Initiator Task Tag
+ *   bytes 20-47 : opcode-specific
+ * Opcodes include 0x00 NOP-Out, 0x01 SCSI Command, 0x03 Login Request, 0x21 SCSI Response, 0x23 Login
+ * Response. The BHS is followed by any AHS (TotalAHSLength*4 bytes), an optional header digest, the data
+ * segment (DataSegmentLength bytes padded to a 4-byte boundary), and an optional data digest.
+ *
+ * Byte-perfect strategy (minimal slice): the semantically useful values are structured — opcode /
+ * immediate / final / totalAHSLength / dataSegmentLength / initiatorTaskTag — and every other BHS byte is
+ * kept verbatim as bounded opcode-specific hex, together covering all 48 bytes exactly once (no field
+ * overlaps another, so reserved bits and opcode-specific fields round-trip untouched). DataSegmentLength
+ * is honored when supplied (a crafted PDU may lie), else derived from the actual data segment. The AHS and
+ * the (4-byte-padded) data segment follow, each bounded by the on-wire TCP payload (derived from the IP
+ * length) so a lying length never reads past the datagram; the data segment's alignment padding is
+ * consumed on decode and re-emitted as zeros on encode. This layer consumes exactly one PDU (BHS + AHS +
+ * data + pad); trailing bytes — a header/data digest (negotiated, so not modelled) or a pipelined PDU —
+ * are left to the codec's recursion / RawData. A well-formed PDU round-trips byte-for-byte.
+ */
+export declare class ISCSI extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}