node-ikev2 0.1.3 → 0.2.1

package/lib/src/index.d.ts

@@ -5,5 +5,7 @@ export * from "./proposal";
 export * from "./selector";
 export * from "./transform";
 export * from "./message";
+export * from "./configuration-attribute";
+export * from "./ip-address";
 import * as ikev2 from "./message";
 export { ikev2 };

package/lib/src/index.js

@@ -44,5 +44,7 @@ __exportStar(require("./proposal"), exports);
 __exportStar(require("./selector"), exports);
 __exportStar(require("./transform"), exports);
 __exportStar(require("./message"), exports);
+__exportStar(require("./configuration-attribute"), exports);
+__exportStar(require("./ip-address"), exports);
 const ikev2 = __importStar(require("./message"));
 exports.ikev2 = ikev2;

package/lib/src/ip-address.d.ts

@@ -0,0 +1,6 @@
+export declare function parseIPv4AddressString(addressString: string): Buffer;
+export declare function formatIPv4AddressBuffer(buffer: Buffer): string;
+export declare function parseIPv6AddressString(addressString: string): Buffer;
+export declare function formatIPv6AddressBuffer(addressBuffer: Buffer): string;
+export declare function parseIPAddressString(addressString: string): Buffer;
+export declare function formatIPAddressBuffer(addressBuffer: Buffer): string;

package/lib/src/ip-address.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIPv4AddressString = parseIPv4AddressString;
+exports.formatIPv4AddressBuffer = formatIPv4AddressBuffer;
+exports.parseIPv6AddressString = parseIPv6AddressString;
+exports.formatIPv6AddressBuffer = formatIPv6AddressBuffer;
+exports.parseIPAddressString = parseIPAddressString;
+exports.formatIPAddressBuffer = formatIPAddressBuffer;
+function parseIPv4AddressString(addressString) {
+    if (addressString.length === 0) {
+        throw new Error(`Invalid IPv4 address ${addressString}`);
+    }
+    const buffer = Buffer.alloc(4);
+    const stringParts = addressString.split(".");
+    const parts = stringParts.map((p) => {
+        if (!/^\d+$/.test(p)) {
+            throw new Error(`Invalid IPv4 address ${addressString}: part "${p}" contains non-digit characters.`);
+        }
+        const parsed = parseInt(p, 10);
+        if (parsed < 0 || parsed > 255) {
+            throw new Error(`Invalid IPv4 address ${addressString}: part "${p}" is not a valid octet.`);
+        }
+        return parsed;
+    });
+    if (parts.length !== 4) {
+        throw new Error(`Invalid IPv4 address ${addressString}`);
+    }
+    buffer.writeUInt8(parts[0], 0);
+    buffer.writeUInt8(parts[1], 1);
+    buffer.writeUInt8(parts[2], 2);
+    buffer.writeUInt8(parts[3], 3);
+    return buffer;
+}
+function formatIPv4AddressBuffer(buffer) {
+    if (buffer.length === 0) {
+        throw new Error(`Invalid IPv4 address ${buffer}`);
+    }
+    if (buffer.length !== 4) {
+        throw new Error(`Invalid IPv4 address ${buffer}`);
+    }
+    const parts = [
+        buffer.readUInt8(0),
+        buffer.readUInt8(1),
+        buffer.readUInt8(2),
+        buffer.readUInt8(3),
+    ];
+    return parts.join(".");
+}
+function parseIPv6AddressString(addressString) {
+    if (addressString.length === 0) {
+        return Buffer.alloc(0);
+    }
+    const buffer = Buffer.alloc(16);
+    let parts;
+    let zeroFillCount = 0;
+    let currentBufferIndex = 0;
+    if (addressString.includes("::")) {
+        const partsSplitted = addressString.split("::");
+        if (partsSplitted.length > 2) {
+            throw new Error(`Invalid IPv6 address ${addressString}: multiple '::' sequences.`);
+        }
+        const [beforeDoubleColon, afterDoubleColon] = partsSplitted;
+        const beforeParts = beforeDoubleColon.split(":").filter((p) => p !== "");
+        const afterParts = afterDoubleColon.split(":").filter((p) => p !== "");
+        // Calculate how many zero groups are needed for '::'
+        zeroFillCount = 8 - (beforeParts.length + afterParts.length);
+        if (zeroFillCount < 0) {
+            throw new Error(`Invalid IPv6 address ${addressString}: too many parts for '::' expansion.`);
+        }
+        parts = [...beforeParts];
+        for (let i = 0; i < zeroFillCount; i++) {
+            parts.push("0"); // Represent the zero groups
+        }
+        parts.push(...afterParts);
+    }
+    else {
+        parts = addressString.split(":");
+    }
+    if (parts.length !== 8) {
+        throw new Error(`Invalid IPv6 address ${addressString}: expected 8 parts, got ${parts.length}.`);
+    }
+    for (let i = 0; i < 8; i++) {
+        const part = parts[i];
+        if (part.length > 4) {
+            throw new Error(`Invalid IPv6 address ${addressString}: part length: ${part}`);
+        }
+        const value = parseInt(part, 16);
+        if (isNaN(value) || value < 0 || value > 0xffff) {
+            throw new Error(`Invalid IPv6 address ${addressString}: part: ${part}`);
+        }
+        buffer.writeUInt16BE(value, currentBufferIndex);
+        currentBufferIndex += 2;
+    }
+    return buffer;
+}
+function formatIPv6AddressBuffer(addressBuffer) {
+    if (addressBuffer.length === 0) {
+        return "";
+    }
+    if (addressBuffer.length !== 16) {
+        throw new Error(`Invalid buffer length for IPv6 address ${addressBuffer}: expected 16 bytes.`);
+    }
+    const parts = Array.from({ length: 8 }, (_, i) => addressBuffer
+        .readUInt16BE(i * 2)
+        .toString(16)
+        .replace(/^0+/, "") || "0");
+    let maxZeroLength = 0;
+    let maxZeroIndex = -1;
+    let currentZeroLength = 0;
+    let currentZeroIndex = -1;
+    for (let i = 0; i < parts.length; i++) {
+        if (parts[i] === "0") {
+            if (currentZeroLength === 0) {
+                currentZeroIndex = i;
+            }
+            currentZeroLength++;
+        }
+        else {
+            if (currentZeroLength > maxZeroLength) {
+                maxZeroLength = currentZeroLength;
+                maxZeroIndex = currentZeroIndex;
+            }
+            currentZeroLength = 0;
+        }
+    }
+    if (currentZeroLength > maxZeroLength) {
+        maxZeroLength = currentZeroLength;
+        maxZeroIndex = currentZeroIndex;
+    }
+    if (maxZeroLength > 1) {
+        const before = parts.slice(0, maxZeroIndex).join(":");
+        const after = parts.slice(maxZeroIndex + maxZeroLength).join(":");
+        return `${before}::${after}`;
+    }
+    else {
+        return parts.join(":");
+    }
+}
+function parseIPAddressString(addressString) {
+    if (addressString.length === 0) {
+        return Buffer.alloc(0);
+    }
+    if (addressString.includes(":")) {
+        return parseIPv6AddressString(addressString);
+    }
+    return parseIPv4AddressString(addressString);
+}
+function formatIPAddressBuffer(addressBuffer) {
+    if (addressBuffer.length === 0) {
+        return "";
+    }
+    if (addressBuffer.length === 4) {
+        return formatIPv4AddressBuffer(addressBuffer);
+    }
+    if (addressBuffer.length === 16) {
+        return formatIPv6AddressBuffer(addressBuffer);
+    }
+    throw new Error(`Invalid buffer length for IP address ${addressBuffer}: expected 4 or 16 bytes.`);
+}

package/lib/src/payload.d.ts

@@ -732,11 +732,11 @@ export declare class PayloadVENDOR extends Payload {
  */
 export declare class PayloadTS extends Payload {
     nextPayload: payloadType;
-    numTs: number;
+    tsType: payloadType;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsType: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
     /**
      * Parses a Traffic Selector Payload from a buffer
      * @param buffer
@@ -779,11 +779,10 @@ export declare class PayloadTS extends Payload {
  */
 export declare class PayloadTSi extends PayloadTS {
     nextPayload: payloadType;
-    numTs: number;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
 }
 /**
  * IKEv2 Traffic Selector - Responder Payload
@@ -792,11 +791,10 @@ export declare class PayloadTSi extends PayloadTS {
  */
 export declare class PayloadTSr extends PayloadTS {
     nextPayload: payloadType;
-    numTs: number;
     tsList: TrafficSelector[];
     critical: boolean;
     length: number;
-    constructor(nextPayload: payloadType, numTs: number, tsList: TrafficSelector[], critical?: boolean, length?: number);
+    constructor(nextPayload: payloadType, tsList: TrafficSelector[], critical?: boolean, length?: number);
 }
 /**
  * IKEv2 Encrypted and Authenticated Payload

package/lib/src/payload.js

@@ -1347,10 +1347,10 @@ exports.PayloadVENDOR = PayloadVENDOR;
  * @extends Payload
  */
 class PayloadTS extends Payload {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(payloadType.NONE, nextPayload, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsType, tsList, critical = false, length = 0) {
+        super(tsType, nextPayload, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
+        this.tsType = tsType;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1372,7 +1372,7 @@ class PayloadTS extends Payload {
             tsList.push(ts);
             offset += ts.length;
         }
-        return new PayloadTS(genericPayload.nextPayload, numTs, tsList, genericPayload.critical, genericPayload.length);
+        return new PayloadTS(genericPayload.nextPayload, genericPayload.type, tsList, genericPayload.critical, genericPayload.length);
     }
     /**
      * Serializes a JSON representation of the TS payload to a buffer
@@ -1383,6 +1383,7 @@ class PayloadTS extends Payload {
      */
     static serializeJSON(json) {
         var _a;
+        // const type = json.type; // TODO include the type in the JSON, as it is discriminating
         const buffer = Buffer.alloc(json.length);
         const genericPayload = Payload.serializeJSON(json);
         genericPayload.copy(buffer);
@@ -1404,13 +1405,16 @@ class PayloadTS extends Payload {
      */
     serialize() {
         // Encode deep first to calculate length
+        if (this.tsList.length > 255) {
+            throw new Error(`Too many traffic selectors ${this.tsList.length}`);
+        }
         const tsListBuffer = this.tsList.map((ts) => ts.serialize());
         const tsBuffer = Buffer.concat(tsListBuffer);
         // Fix the length
-        this.length = 5 + tsBuffer.length;
+        this.length = 8 + tsBuffer.length;
         const buffer = Buffer.alloc(this.length);
         super.serialize().copy(buffer);
-        buffer.writeUInt8(this.numTs, 4);
+        buffer.writeUInt8(this.tsList.length, 4);
         // No need to blank 3 reserved bytes, Buffer.alloc does that
         tsBuffer.copy(buffer, 8);
         return buffer;
@@ -1422,7 +1426,6 @@ class PayloadTS extends Payload {
      */
     toJSON() {
         const json = super.genToJSON();
-        json.numTs = this.numTs;
         json.tsList = this.tsList.map((ts) => ts.toJSON());
         return json;
     }
@@ -1433,7 +1436,7 @@ class PayloadTS extends Payload {
      */
     toString() {
         const genericString = super.genToString();
-        return `${genericString}\nnumTs: ${this.numTs}\ntsList: ${this.tsList.map((ts) => ts.toString()).join(", ")}`;
+        return `${genericString}\ntsList: ${this.tsList.map((ts) => ts.toString()).join(", ")}`;
     }
 }
 exports.PayloadTS = PayloadTS;
@@ -1443,10 +1446,9 @@ exports.PayloadTS = PayloadTS;
  * @extends Payload
  */
 class PayloadTSi extends PayloadTS {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(nextPayload, numTs, tsList, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsList, critical = false, length = 0) {
+        super(nextPayload, payloadType.TSi, tsList, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1460,10 +1462,9 @@ exports.PayloadTSi = PayloadTSi;
  * @extends Payload
  */
 class PayloadTSr extends PayloadTS {
-    constructor(nextPayload, numTs, tsList, critical = false, length = 0) {
-        super(nextPayload, numTs, tsList, critical, length > 0 ? length : 5 + tsList.reduce((acc, ts) => acc + ts.length, 0));
+    constructor(nextPayload, tsList, critical = false, length = 0) {
+        super(nextPayload, payloadType.TSr, tsList, critical, length > 0 ? length : 0);
         this.nextPayload = nextPayload;
-        this.numTs = numTs;
         this.tsList = tsList;
         this.critical = critical;
         this.length = length;
@@ -1684,7 +1685,7 @@ class PayloadCP extends Payload {
     static parse(buffer) {
         const genericPayload = Payload.parse(buffer);
         const cfgType = buffer.readUInt8(4);
-        const cfgData = buffer.subarray(5, genericPayload.length);
+        const cfgData = buffer.subarray(8, genericPayload.length);
         return new PayloadCP(genericPayload.nextPayload, cfgType, cfgData, genericPayload.critical, genericPayload.length);
     }
     /**
@@ -1699,10 +1700,7 @@ class PayloadCP extends Payload {
         const genericPayload = Payload.serializeJSON(json);
         genericPayload.copy(buffer);
         buffer.writeUInt8(json.cfgType, 4);
-        // Write 3-byte reserved field as zeros in big-endian order
-        buffer.writeUInt8(0, 5);
-        buffer.writeUInt8(0, 6);
-        buffer.writeUInt8(0, 7);
+        // 3-bytes reserved field as zeros in big-endian order
         Buffer.from(json.cfgData, "hex").copy(buffer, 8);
         return buffer;
     }

package/lib/src/selector.d.ts

@@ -37,12 +37,12 @@ export declare enum TrafficSelectorType {
 export declare class TrafficSelector {
     type: number;
     protocolId: number;
-    length: number;
     startPort: number;
     endPort: number;
     startAddress: Buffer;
     endAddress: Buffer;
-    constructor(type: number, protocolId: number, length: number, startPort: number, endPort: number, startAddress: Buffer, endAddress: Buffer);
+    length: number;
+    constructor(type: number, protocolId: number, startPort: number, endPort: number, startAddress: Buffer, endAddress: Buffer, length?: number);
     /**
      * Parses a Traffic Selector from a buffer
      * @param buffer The buffer to parse from.

package/lib/src/selector.js

@@ -1,4 +1,7 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficSelector = exports.TrafficSelectorType = void 0;
+const ip_address_1 = require("./ip-address");
 /**
  * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -17,8 +20,6 @@
 
                         Traffic Selector
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrafficSelector = exports.TrafficSelectorType = void 0;
 /**
  * Traffic Selector Type
  */
@@ -39,14 +40,14 @@ var TrafficSelectorType;
  * @property {Buffer} endAddress - 4 bytes
  */
 class TrafficSelector {
-    constructor(type, protocolId, length, startPort, endPort, startAddress, endAddress) {
+    constructor(type, protocolId, startPort, endPort, startAddress, endAddress, length = 0) {
         this.type = type;
         this.protocolId = protocolId;
-        this.length = length;
         this.startPort = startPort;
         this.endPort = endPort;
         this.startAddress = startAddress;
         this.endAddress = endAddress;
+        this.length = length;
     }
     /**
      * Parses a Traffic Selector from a buffer
@@ -58,16 +59,42 @@ class TrafficSelector {
     static parse(buffer) {
         try {
             const type = buffer.readUInt8(0);
+            var expectedLength;
+            switch (type) {
+                case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                    expectedLength = 16;
+                    break;
+                case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                    expectedLength = 40;
+                    break;
+                default:
+                    throw new Error("Invalid traffic selector type");
+            }
             const protocolId = buffer.readUInt8(1);
             const length = buffer.readUInt16BE(2);
+            if (length !== expectedLength) {
+                throw new Error("Invalid traffic selector length");
+            }
             const startPort = buffer.readUInt16BE(4);
             const endPort = buffer.readUInt16BE(6);
-            const startAddress = buffer.subarray(8, 12);
-            const endAddress = buffer.subarray(12, 16);
-            return new TrafficSelector(type, protocolId, length, startPort, endPort, startAddress, endAddress);
+            var startAddress;
+            var endAddress;
+            switch (type) {
+                case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                    startAddress = buffer.subarray(8, 12);
+                    endAddress = buffer.subarray(12, 16);
+                    break;
+                case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                    startAddress = buffer.subarray(8, 24);
+                    endAddress = buffer.subarray(24, 40);
+                    break;
+                default:
+                    throw new Error("Invalid traffic selector type");
+            }
+            return new TrafficSelector(type, protocolId, startPort, endPort, startAddress, endAddress, length);
         }
         catch (error) {
-            throw new Error("Failed to parse traffic selector");
+            throw new Error("Failed to parse traffic selector: " + error);
         }
     }
     /**
@@ -78,14 +105,29 @@ class TrafficSelector {
      * @returns {Buffer}
      */
     static serializeJSON(json) {
-        const buffer = Buffer.alloc(16);
+        var length;
+        var ipLength;
+        const startAddress = (0, ip_address_1.parseIPAddressString)(json.startAddress);
+        const endAddress = (0, ip_address_1.parseIPAddressString)(json.endAddress);
+        if (startAddress.length === 4 && endAddress.length === 4) {
+            length = 16;
+            ipLength = 4;
+        }
+        else if (startAddress.length === 16 && endAddress.length === 16) {
+            length = 40;
+            ipLength = 16;
+        }
+        else {
+            throw new Error("Invalid traffic selector length");
+        }
+        const buffer = Buffer.alloc(length);
         buffer.writeUInt8(json.type, 0);
         buffer.writeUInt8(json.protocolId, 1);
-        buffer.writeUInt16BE(json.length, 2);
+        buffer.writeUInt16BE(length, 2);
         buffer.writeUInt16BE(json.startPort, 4);
         buffer.writeUInt16BE(json.endPort, 6);
-        Buffer.from(json.startAddress, "hex").copy(buffer, 8);
-        Buffer.from(json.endAddress, "hex").copy(buffer, 12);
+        startAddress.copy(buffer, 8);
+        endAddress.copy(buffer, 8 + ipLength);
         return buffer;
     }
     /**
@@ -94,14 +136,33 @@ class TrafficSelector {
      * @returns {Buffer}
      */
     serialize() {
-        const buffer = Buffer.alloc(16);
+        var ipLength;
+        switch (this.type) {
+            case TrafficSelectorType.TS_IPV4_ADDR_RANGE:
+                if (this.startAddress.length != 4 || this.endAddress.length != 4) {
+                    throw new Error("Invalid traffic selector length");
+                }
+                this.length = 16;
+                ipLength = 4;
+                break;
+            case TrafficSelectorType.TS_IPV6_ADDR_RANGE:
+                if (this.startAddress.length != 16 || this.endAddress.length != 16) {
+                    throw new Error("Invalid traffic selector length");
+                }
+                this.length = 40;
+                ipLength = 16;
+                break;
+            default:
+                throw new Error("Invalid traffic selector type");
+        }
+        const buffer = Buffer.alloc(this.length);
         buffer.writeUInt8(this.type, 0);
         buffer.writeUInt8(this.protocolId, 1);
         buffer.writeUInt16BE(this.length, 2);
         buffer.writeUInt16BE(this.startPort, 4);
         buffer.writeUInt16BE(this.endPort, 6);
         this.startAddress.copy(buffer, 8);
-        this.endAddress.copy(buffer, 12);
+        this.endAddress.copy(buffer, 8 + ipLength);
         return buffer;
     }
     /**
@@ -113,11 +174,10 @@ class TrafficSelector {
         return {
             type: this.type,
             protocolId: this.protocolId,
-            length: this.length,
             startPort: this.startPort,
             endPort: this.endPort,
-            startAddress: this.startAddress.toString("hex"),
-            endAddress: this.endAddress.toString("hex"),
+            startAddress: (0, ip_address_1.formatIPAddressBuffer)(this.startAddress),
+            endAddress: (0, ip_address_1.formatIPAddressBuffer)(this.endAddress),
         };
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-ikev2",
   "title": "Node-IKEV2",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "IKEv2 parser and serializer for Node.js",
   "main": "./lib/src/index.js",
   "types": "./lib/src/index.d.ts",