import { LinkLayerType } from '#lib/enums';
import defaults from '#lib/defaults';
import { layers, linktype } from '#lib/layers/index';
import { shrinkAt, extendAt } from '#lib/buffer';
import { TimeStamp } from '#lib/timestamp';
import { LayersList } from '#lib/layersList';
/**
* Represents a network packet with protocol layer support
* Provides fluent interface for packet crafting and parsing
*
* @class
* @extends LayersList
*
* @param {Object} [data] - Packet data, options object, or existing packet
* @param {Buffer} [data.buffer] - Raw packet buffer for parsing existing packets
* @param {Object} [data.iface] - Network interface configuration
*
* @example
*
* // Create an ICMP echo request packet
* const packet = new Packet({ iface: 'eth0' })
* .ethernet({ dst: 'ff:ff:ff:ff:ff:ff', src: '00:11:22:33:44:55' })
* .ipv4({ src: '192.168.1.1', dst: '8.8.8.8', timeToLive: 64 })
* .icmp({ type: 8, code: 0, id: 12345, sequence: 1 });
*
* @example
* // Parse existing packet
* const packet = new Packet({ buffer: rawBuffer });
* console.log(packet.layers.IPv4.src);
*/
const isTruncatedLayerError = (err) => {
return err instanceof Error && err.message.startsWith('Invalid buffer length');
};
class Packet extends LayersList {
constructor(data, opts = {}) {
super({});
this._toBuild = [];
this._defaultOpts = {
shrinkAt: this.shrinkAt,
extendAt: this.extendAt,
};
if (data instanceof Packet) {
const builtSourceBuffer = data.buffer;
const origLength = data._origLength;
this._buffer = builtSourceBuffer ? Buffer.from(builtSourceBuffer) : null;
this._origLength = origLength;
this.iface = { ...data.iface };
this.linktype = data.linktype;
if (opts.copy) {
this.timestamp = TimeStamp.now();
}
else {
this.timestamp = data.timestamp.clone();
}
if (data._needsParse) {
this._needsParse = true;
}
else {
let offset = 0;
data._eachLayer(l => {
this._createLayer(layers[l.name], this._buffer.subarray(offset), { allocated: l.length });
offset += l.length;
});
}
}
else if (typeof data == 'object') {
const { buffer = null, iface = { ...defaults }, timestamp = TimeStamp.now(), origLength = null } = data;
this._buffer = buffer;
this._origLength = origLength;
this._layersCount = 0;
this.iface = iface;
this.linktype = this.iface?.linktype ?? LinkLayerType.LINKTYPE_ETHERNET;
this.timestamp = timestamp;
this._needsParse = this._buffer?.length > 0;
}
if (data?.peer) {
this.peer = data.peer;
}
if (data?.comment) {
this.comment = data.comment;
}
}
/**
* Compares this packet with another packet for equality
*
* @param {Packet} pkt - The packet to compare with
* @returns {boolean} True if packets are identical (same interface, timestamp, and buffer content)
*
* @example
* const packet1 = new Packet({ buffer: data });
* const packet2 = new Packet({ buffer: data });
* if (packet1.equals(packet2)) {
* console.log('Packets are identical');
* }
*/
equals(pkt) {
if (!(pkt instanceof Packet)) {
return false;
}
if (this.iface?.linktype !== pkt.iface?.linktype) {
return false;
}
if (this.iface?.name !== pkt.iface?.name) {
return false;
}
if (this.iface?.mtu !== pkt.iface?.mtu) {
return false;
}
if (this.comment !== pkt.comment) {
return false;
}
if (this.timestamp.compare(pkt.timestamp) !== 0) {
return false;
}
if (Buffer.compare(this.buffer, pkt.buffer) !== 0) {
return false;
}
return true;
}
get _needsBuild() {
return this._toBuild.length > 0;
}
summary() {
const described = [];
this.layers;
this._eachLayer((layer) => {
const hasEndpoints = ['string', 'number'].includes(typeof layer.src) && ['string', 'number'].includes(typeof layer.dst);
described.push(hasEndpoints ? `${layer.name} ${layer.src} > ${layer.dst}` : layer.name);
});
return described.join(' / ');
}
[Symbol.for('nodejs.util.inspect.custom')]() {
const parts = [];
const ifaceName = this.iface?.name;
if (ifaceName !== undefined) {
parts.push(ifaceName);
}
parts.push(`${this.buffer?.length ?? 0} bytes`);
const layersSummary = this.summary();
if (layersSummary.length > 0) {
parts.push(layersSummary);
}
if (this.comment) {
parts.push(this.comment);
}
return `<Packet ${parts.join(' | ')}>`;
}
_build() {
if (!this._needsBuild) {
return;
}
const pending = this._toBuild;
this._toBuild = [];
let toAlloc = 0;
const sizes = [];
for (const { Layer, data } of pending) {
const size = Layer.toAlloc(data);
toAlloc += size;
sizes.push(size);
}
const newBuffer = Buffer.alloc(toAlloc);
let curBuffer = newBuffer;
if (Buffer.isBuffer(this._buffer)) {
this._buffer = Buffer.concat([this._buffer, newBuffer]);
curBuffer = this._buffer;
this._eachLayer(l => {
l.buffer = curBuffer;
curBuffer = curBuffer.subarray(l.length);
});
}
else {
this._buffer = newBuffer;
}
const built = [];
for (let i = 0; i < pending.length; i++) {
const { Layer, data } = pending[i];
const layer = this._createLayer(Layer, curBuffer, { allocated: sizes[i] });
layer.merge(data);
curBuffer = curBuffer.subarray(layer.length);
built.push(layer);
}
for (let innermostFirst = built.length - 1; innermostFirst >= 0; innermostFirst--) {
built[innermostFirst].defaults(pending[innermostFirst].data);
}
for (let innermostFirst = built.length - 1; innermostFirst >= 0; innermostFirst--) {
if (typeof built[innermostFirst].checksums == 'function') {
built[innermostFirst].checksums(pending[innermostFirst].data);
}
}
this._origLength = null;
}
get origLength() {
return this._origLength ?? this.length;
}
get length() {
return this.buffer.length;
}
_parse() {
let buf = this._buffer;
const Layer = linktype[this.linktype] ?? layers.Payload;
let layer;
try {
layer = new Layer(buf, {
shrinkAt: this.shrinkAt,
extendAt: this.extendAt,
prev: null,
});
}
catch (err) {
if (!isTruncatedLayerError(err)) {
throw err;
}
layer = new layers.Payload(buf, { prev: null });
}
let remaining = buf.length;
while (layer !== null && remaining > 0) {
this._addLayer(layer);
remaining -= layer.length;
try {
layer = layer.nextProto(layers);
}
catch (err) {
if (!isTruncatedLayerError(err)) {
throw err;
}
layer = remaining > 0 ? new layers.Payload(buf.subarray(buf.length - remaining), { prev: layer }) : null;
}
}
this._dropLayerCreatedPastTheEnd();
this._needsParse = false;
}
_dropLayerCreatedPastTheEnd() {
if (this._layersTail !== null) {
this._layersTail.next = null;
}
}
get layers() {
if (this._needsParse) {
this._parse();
}
if (this._needsBuild) {
this._build();
}
return this._layers;
}
/**
* Converts the packet to a plain JavaScript object
*
* @returns {Object} Plain object representation
* @returns {Object} returns.iface - Interface configuration
* @returns {Object} returns.layers - Layer objects with their fields
*
* @example
* const obj = packet.toObject();
* console.log(obj.layers.IPv4.src);
*/
toObject() {
this.layers;
const layers = {};
for (const [name, layer] of Object.entries(this._layers)) {
layers[name] = Array.isArray(layer) ? layer.map(l => l.toObject()) : layer.toObject();
}
return {
iface: { ...this.iface },
layers,
};
}
shrinkAt(...args) {
throw new Error('Buffer shrinking not yet implemented, try creating new packet');
//return shrinkAt(this.buffer, ...args);
}
extendAt(...args) {
throw new Error('Buffer extending not yet implemented, try creating new packet');
//return extendAt(this.buffer, ...args);
}
/**
* Raw buffer containing the complete packet data
* Automatically builds packet if layers were added
*
* @returns {Buffer} Complete packet buffer
*/
get buffer() {
if (this._needsBuild) {
this._build();
}
return this._buffer;
}
/**
* Creates a deep clone of the packet
* Preserves all layers, timestamps, and interface settings
*
* @returns {Packet} New packet instance identical to this one
*/
clone() {
return new Packet(this);
}
copy() {
return new Packet(this, { copy: true });
}
}
Packet.prototype.add = function(Layer, data = {}) {
this._toBuild.push({ Layer, data });
return this;
};
const installLayerMethods = (Builder, Layer) => {
const addThisLayer = function(data = {}) {
return this.add(Layer, data);
};
Builder.prototype[Layer.name.toLowerCase()] = addThisLayer;
Builder.prototype[Layer.name] = addThisLayer;
};
for (const Layer of Object.values(layers)) {
installLayerMethods(Packet, Layer);
}
export { Packet, installLayerMethods };
export default { Packet, installLayerMethods };