node-ikev2 0.1.0

package/lib/src/transform.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transform = exports.transformTypeMap = exports.esnId = exports.dhId = exports.integId = exports.prfId = exports.encrId = exports.transformType = void 0;
+const attribute_1 = require("./attribute");
+/**
+ * Transform Substructure
+
+                           1                   2                   3
+       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
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      ! 0 (last) or 3 !   RESERVED    !        Transform Length       !
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      !Transform Type !   RESERVED    !          Transform ID         !
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+      !                                                               !
+      ~                      Transform Attributes                     ~
+      !                                                               !
+      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+                        Transform Substructure
+*/
+/**
+ * Transform Type Values: \
+    RESERVED                        0 \
+    Encryption Algorithm (ENCR)     1       (IKE and ESP) \
+    Pseudo-random Function (PRF)    2       (IKE) \
+    Integrity Algorithm (INTEG)     3       (IKE, AH, optional in ESP) \
+    Diffie-Hellman Group (D-H)      4       (IKE, optional in AH & ESP) \
+    Extended Sequence Numbers (ESN) 5       (AH and ESP)
+*/
+var transformType;
+(function (transformType) {
+    transformType[transformType["Encryption_Algorithm_ENCR"] = 1] = "Encryption_Algorithm_ENCR";
+    transformType[transformType["Pseudo_Random_PRF"] = 2] = "Pseudo_Random_PRF";
+    transformType[transformType["Integrity_Algorithm_INTEG"] = 3] = "Integrity_Algorithm_INTEG";
+    transformType[transformType["Diffie_Hellman_Group_DH"] = 4] = "Diffie_Hellman_Group_DH";
+    transformType[transformType["Extended_Sequence_Numbers_ESN"] = 5] = "Extended_Sequence_Numbers_ESN";
+})(transformType || (exports.transformType = transformType = {}));
+/**
+ * For Transform Type 1 (Encryption Algorithm), defined Transform IDs are: \
+    RESERVED           0 \
+    ENCR_DES_IV64      1 \
+    ENCR_DES           2 \
+    ENCR_3DES          3 \
+    ENCR_RC5           4 \
+    ENCR_IDEA          5 \
+    ENCR_CAST          6 \
+    ENCR_BLOWFISH      7 \
+    ENCR_3IDEA         8 \
+    ENCR_DES_IV32      9 \
+    RESERVED           10 \
+    ENCR_NULL          11 \
+    ENCR_AES_CBC       12 \
+    ENCR_AES_CTR       13 \
+    ENCR_AES_CCM_8     14 \
+    ENCR_AES_CCM_12    15 \
+    ENCR_AES_CCM_16    16 \
+    RESERVED           17 \
+    AES_GCM_8_OCTET_ICV 18 \
+    AES_GCM_12_OCTET_ICV 19 \
+    AES_GCM_16_OCTET_ICV 20 \
+    ENCR_NULL_AUTH_AES_GMAC 21 \
+    RESERVED_FOR_IEEE_P1619_XTS_AES 22 \
+    ENCR_CAMELLIA_CBC  23 \
+    ENCR_CAMELLIA_CTR  24 \
+    ENCR_CAMELLIA_CCM_8_OCTET_ICV 25 \
+    ENCR_CAMELLIA_CCM_12_OCTET_ICV 26 \
+    ENCR_CAMELLIA_CCM_16_OCTET_ICV 27 \
+    ENCR_CHACHA20_POLY1305 28 \
+    ENCR_AES_CCM_8_IIV 29 \
+    ENCR_AES_CCM_16_IIV 30 \
+    ENCR_CHACHA20_POLY1305_IIV 31 \
+    ENCR_KUZNYECHIK_MGM_KTREE 32 \
+    ENCR_MAGMA_MGM_KTREE 33 \
+    ENCR_KUZNYECHIK_MGM_MAC_KTREE 34 \
+    ENCR_MAGMA_MGM_MAC_KTREE 35 \
+    36-1023 Unassigned \
+    1024-65535 Reserved for Private Use
+*/
+var encrId;
+(function (encrId) {
+    // RESERVED = 0,
+    encrId[encrId["ENCR_DES_IV64"] = 1] = "ENCR_DES_IV64";
+    encrId[encrId["ENCR_DES"] = 2] = "ENCR_DES";
+    encrId[encrId["ENCR_3DES"] = 3] = "ENCR_3DES";
+    encrId[encrId["ENCR_RC5"] = 4] = "ENCR_RC5";
+    encrId[encrId["ENCR_IDEA"] = 5] = "ENCR_IDEA";
+    encrId[encrId["ENCR_CAST"] = 6] = "ENCR_CAST";
+    encrId[encrId["ENCR_BLOWFISH"] = 7] = "ENCR_BLOWFISH";
+    encrId[encrId["ENCR_3IDEA"] = 8] = "ENCR_3IDEA";
+    encrId[encrId["ENCR_DES_IV32"] = 9] = "ENCR_DES_IV32";
+    // RESERVED = 10,
+    encrId[encrId["ENCR_NULL"] = 11] = "ENCR_NULL";
+    encrId[encrId["ENCR_AES_CBC"] = 12] = "ENCR_AES_CBC";
+    encrId[encrId["ENCR_AES_CTR"] = 13] = "ENCR_AES_CTR";
+    encrId[encrId["ENCR_AES_CCM_8"] = 14] = "ENCR_AES_CCM_8";
+    encrId[encrId["ENCR_AES_CCM_12"] = 15] = "ENCR_AES_CCM_12";
+    encrId[encrId["ENCR_AES_CCM_16"] = 16] = "ENCR_AES_CCM_16";
+    // UNASSIGNED = 17,
+    encrId[encrId["ENCR_AES_GCM_8"] = 18] = "ENCR_AES_GCM_8";
+    encrId[encrId["ENCR_AES_GCM_12"] = 19] = "ENCR_AES_GCM_12";
+    encrId[encrId["ENCR_AES_GCM_16"] = 20] = "ENCR_AES_GCM_16";
+    encrId[encrId["ENCR_NULL_AUTH_AES_GMAC"] = 21] = "ENCR_NULL_AUTH_AES_GMAC";
+    encrId[encrId["RESERVED_FOR_IEEE_P1619_XTS_AES"] = 22] = "RESERVED_FOR_IEEE_P1619_XTS_AES";
+    encrId[encrId["ENCR_CAMELLIA_CBC"] = 23] = "ENCR_CAMELLIA_CBC";
+    encrId[encrId["ENCR_CAMELLIA_CTR"] = 24] = "ENCR_CAMELLIA_CTR";
+    encrId[encrId["ENCR_CAMELLIA_CCM_8"] = 25] = "ENCR_CAMELLIA_CCM_8";
+    encrId[encrId["ENCR_CAMELLIA_CCM_12"] = 26] = "ENCR_CAMELLIA_CCM_12";
+    encrId[encrId["ENCR_CAMELLIA_CCM_16"] = 27] = "ENCR_CAMELLIA_CCM_16";
+    encrId[encrId["ENCR_CHACHA20_POLY1305"] = 28] = "ENCR_CHACHA20_POLY1305";
+    encrId[encrId["ENCR_AES_CCM_8_IIV"] = 29] = "ENCR_AES_CCM_8_IIV";
+    encrId[encrId["ENCR_AES_GCM_16_IIV"] = 30] = "ENCR_AES_GCM_16_IIV";
+    encrId[encrId["ENCR_CHACHA20_POLY1305_IIV"] = 31] = "ENCR_CHACHA20_POLY1305_IIV";
+    encrId[encrId["ENCR_KUZNYECHIK_MGM_KTREE"] = 32] = "ENCR_KUZNYECHIK_MGM_KTREE";
+    encrId[encrId["ENCR_MAGMA_MGM_KTREE"] = 33] = "ENCR_MAGMA_MGM_KTREE";
+    encrId[encrId["ENCR_KUZNYECHIK_MGM_MAC_KTREE"] = 34] = "ENCR_KUZNYECHIK_MGM_MAC_KTREE";
+    encrId[encrId["ENCR_MAGMA_MGM_MAC_KTREE"] = 35] = "ENCR_MAGMA_MGM_MAC_KTREE";
+    // 36-1023 Unassigned
+    // 1024-65535 Reserved for Private Use
+})(encrId || (exports.encrId = encrId = {}));
+/**
+ * For Transform Type 2 (Pseudo-random Function), defined Transform IDs are: \
+    RESERVED                    0 \
+    PRF_HMAC_MD5                1 \
+    PRF_HMAC_SHA1               2 \
+    PRF_HMAC_TIGER              3 \
+    PRF_AES128_XCBC             4 \
+    PRF_HMAC_SHA2_256           5 \
+    PRF_HMAC_SHA2_384           6 \
+    PRF_HMAC_SHA2_512           7 \
+    PRF_AES128_CMAC             8 \
+    PRF_HMAC_STREEBOG_512       9 \
+    10-1023 Unassigned \
+    1024-65535 Reserved for Private Use
+*/
+var prfId;
+(function (prfId) {
+    // RESERVED = 0,
+    prfId[prfId["PRF_HMAC_MD5"] = 1] = "PRF_HMAC_MD5";
+    prfId[prfId["PRF_HMAC_SHA1"] = 2] = "PRF_HMAC_SHA1";
+    prfId[prfId["PRF_HMAC_TIGER"] = 3] = "PRF_HMAC_TIGER";
+    prfId[prfId["PRF_AES128_XCBC"] = 4] = "PRF_AES128_XCBC";
+    prfId[prfId["PRF_HMAC_SHA2_256"] = 5] = "PRF_HMAC_SHA2_256";
+    prfId[prfId["PRF_HMAC_SHA2_384"] = 6] = "PRF_HMAC_SHA2_384";
+    prfId[prfId["PRF_HMAC_SHA2_512"] = 7] = "PRF_HMAC_SHA2_512";
+    prfId[prfId["PRF_AES128_CMAC"] = 8] = "PRF_AES128_CMAC";
+    prfId[prfId["PRF_HMAC_STREEBOG_512"] = 9] = "PRF_HMAC_STREEBOG_512";
+    // 10-1023 Unassigned
+    // 1024-65535 Reserved for Private Use
+})(prfId || (exports.prfId = prfId = {}));
+/**
+ * For Transform Type 3 (Integrity Algorithm), defined Transform IDs are: \
+    NONE                       0 \
+    AUTH_HMAC_MD5_96           1 \
+    AUTH_HMAC_SHA1_96          2 \
+    AUTH_DES_MAC               3 \
+    AUTH_KPDK_MD5              4 \
+    AUTH_AES_XCBC_96           5 \
+    AUTH_HMAC_MD5_128          6 \
+    AUTH_HMAC_SHA1_160         7 \
+    AUTH_AES_CMAC_96           8 \
+    AUTH_AES_128_GMAC          9 \
+    AUTH_AES_192_GMAC          10 \
+    AUTH_AES_256_GMAC          11 \
+    AUTH_HMAC_SHA2_256_128     12 \
+    AUTH_HMAC_SHA2_384_192     13 \
+    AUTH_HMAC_SHA2_512_256     14 \
+    15-1023 Unassigned \
+    1024-65535 Reserved for Private Use
+*/
+var integId;
+(function (integId) {
+    integId[integId["NONE"] = 0] = "NONE";
+    integId[integId["AUTH_HMAC_MD5_96"] = 1] = "AUTH_HMAC_MD5_96";
+    integId[integId["AUTH_HMAC_SHA1_96"] = 2] = "AUTH_HMAC_SHA1_96";
+    integId[integId["AUTH_DES_MAC"] = 3] = "AUTH_DES_MAC";
+    integId[integId["AUTH_KPDK_MD5"] = 4] = "AUTH_KPDK_MD5";
+    integId[integId["AUTH_AES_XCBC_96"] = 5] = "AUTH_AES_XCBC_96";
+    integId[integId["AUTH_HMAC_MD5_128"] = 6] = "AUTH_HMAC_MD5_128";
+    integId[integId["AUTH_HMAC_SHA1_160"] = 7] = "AUTH_HMAC_SHA1_160";
+    integId[integId["AUTH_AES_CMAC_96"] = 8] = "AUTH_AES_CMAC_96";
+    integId[integId["AUTH_AES_128_GMAC"] = 9] = "AUTH_AES_128_GMAC";
+    integId[integId["AUTH_AES_192_GMAC"] = 10] = "AUTH_AES_192_GMAC";
+    integId[integId["AUTH_AES_256_GMAC"] = 11] = "AUTH_AES_256_GMAC";
+    integId[integId["AUTH_HMAC_SHA2_256_128"] = 12] = "AUTH_HMAC_SHA2_256_128";
+    integId[integId["AUTH_HMAC_SHA2_384_192"] = 13] = "AUTH_HMAC_SHA2_384_192";
+    integId[integId["AUTH_HMAC_SHA2_512_256"] = 14] = "AUTH_HMAC_SHA2_512_256";
+    // 15-1023 Unassigned
+    // 1024-65535 Reserved for Private Use
+})(integId || (exports.integId = integId = {}));
+/**
+ * For Transform Type 4 (Diffie-Hellman Group), defined Transform IDs are: \
+    RESERVED                    0 \
+    DH_768_BIT_MODP             1 \
+    DH_1024_BIT_MODP            2 \
+    3-4 Reserved \
+    DH_1536_BIT_MODP            5 \
+    6-13 Unassigned \
+    DH_2048_BIT_MODP            14 \
+    DH_3072_BIT_MODP            15 \
+    DH_4096_BIT_MODP            16 \
+    DH_6144_BIT_MODP            17 \
+    DH_8192_BIT_MODP            18 \
+    DH_256_BIT_RANDOM_ECP       19 \
+    DH_384_BIT_RANDOM_ECP       20 \
+    DH_521_BIT_RANDOM_ECP       21 \
+    DH_1024_BIT_MODP_WITH_160_BIT_PRIME_ORDER 22 \
+    DH_2048_BIT_MODP_WITH_224_BIT_PRIME_ORDER 23 \
+    DH_2048_BIT_MODP_WITH_256_BIT_PRIME_ORDER 24 \
+    DH_192_BIT_RANDOM_ECP       25 \
+    DH_224_BIT_RANDOM_ECP       26 \
+    DH_BRAINPOOLP224R1          27 \
+    DH_BRAINPOOLP256R1          28 \
+    DH_BRAINPOOLP384R1          29 \
+    DH_BRAINPOOLP512R1          30 \
+    DH_CURVE25519               31 \
+    DH_CURVE448                 32 \
+    DH_GOST3410_2012_256        33 \
+    DH_GOST3410_2012_512        34 \
+    DH_ML_KEM_512              35 \
+    DH_ML_KEM_768               36 \
+    DH_ML_KEM_1024              37 \
+    38-1023 Unassigned \
+    1024-65535 Reserved for Private Use
+*/
+var dhId;
+(function (dhId) {
+    dhId[dhId["NONE"] = 0] = "NONE";
+    dhId[dhId["DH_768_bit_MODP"] = 1] = "DH_768_bit_MODP";
+    dhId[dhId["DH_1024_bit_MODP"] = 2] = "DH_1024_bit_MODP";
+    // 3-4 Reserved
+    dhId[dhId["DH_1536_bit_MODP"] = 5] = "DH_1536_bit_MODP";
+    // 6-13 Unassigned
+    dhId[dhId["DH_2048_bit_MODP"] = 14] = "DH_2048_bit_MODP";
+    dhId[dhId["DH_3072_bit_MODP"] = 15] = "DH_3072_bit_MODP";
+    dhId[dhId["DH_4096_bit_MODP"] = 16] = "DH_4096_bit_MODP";
+    dhId[dhId["DH_6144_bit_MODP"] = 17] = "DH_6144_bit_MODP";
+    dhId[dhId["DH_8192_bit_MODP"] = 18] = "DH_8192_bit_MODP";
+    dhId[dhId["DH_256_bit_random_ECP"] = 19] = "DH_256_bit_random_ECP";
+    dhId[dhId["DH_384_bit_random_ECP"] = 20] = "DH_384_bit_random_ECP";
+    dhId[dhId["DH_521_bit_random_ECP"] = 21] = "DH_521_bit_random_ECP";
+    dhId[dhId["DH_1024_bit_MODP_with_160_bit_Prime_Order"] = 22] = "DH_1024_bit_MODP_with_160_bit_Prime_Order";
+    dhId[dhId["DH_2048_bit_MODP_with_224_bit_Prime_Order"] = 23] = "DH_2048_bit_MODP_with_224_bit_Prime_Order";
+    dhId[dhId["DH_2048_bit_MODP_with_256_bit_Prime_Order"] = 24] = "DH_2048_bit_MODP_with_256_bit_Prime_Order";
+    dhId[dhId["DH_192_bit_random_ECP"] = 25] = "DH_192_bit_random_ECP";
+    dhId[dhId["DH_224_bit_random_ECP"] = 26] = "DH_224_bit_random_ECP";
+    dhId[dhId["DH_brainpoolP224r1"] = 27] = "DH_brainpoolP224r1";
+    dhId[dhId["DH_brainpoolP256r1"] = 28] = "DH_brainpoolP256r1";
+    dhId[dhId["DH_brainpoolP384r1"] = 29] = "DH_brainpoolP384r1";
+    dhId[dhId["DH_brainpoolP512r1"] = 30] = "DH_brainpoolP512r1";
+    dhId[dhId["DH_Curve25519"] = 31] = "DH_Curve25519";
+    dhId[dhId["DH_Curve448"] = 32] = "DH_Curve448";
+    dhId[dhId["DH_GOST3410_2012_256"] = 33] = "DH_GOST3410_2012_256";
+    dhId[dhId["DH_GOST3410_2012_512"] = 34] = "DH_GOST3410_2012_512";
+    dhId[dhId["DH_ml_kem_512"] = 35] = "DH_ml_kem_512";
+    dhId[dhId["DH_ml_kem_768"] = 36] = "DH_ml_kem_768";
+    dhId[dhId["DH_ml_kem_1024"] = 37] = "DH_ml_kem_1024";
+    // 38-1023 Unassigned
+    // 1024-65535 Reserved for Private Use
+})(dhId || (exports.dhId = dhId = {}));
+/**
+ * For Transform Type 5 (Extended Sequence Numbers), defined Transform IDs are: \
+    No Extended Sequence Numbers       0 \
+    Extended Sequence Numbers          1 \
+    RESERVED                           2 - 65535
+*/
+var esnId;
+(function (esnId) {
+    esnId[esnId["ESN_NONE"] = 0] = "ESN_NONE";
+    esnId[esnId["ESN"] = 1] = "ESN";
+})(esnId || (exports.esnId = esnId = {}));
+/**
+ * Transform Type Map to their Ids
+ */
+exports.transformTypeMap = new Map([
+    [transformType.Encryption_Algorithm_ENCR, encrId],
+    [transformType.Pseudo_Random_PRF, prfId],
+    [transformType.Integrity_Algorithm_INTEG, integId],
+    [transformType.Diffie_Hellman_Group_DH, dhId],
+    [transformType.Extended_Sequence_Numbers_ESN, esnId],
+]);
+/**
+ * IKEv2 Transform Substructure
+ * @class
+ * @property {number} lastSubstructure - Last Substructure (1 bit)
+ * @property {number} length - Transform Length (2 bytes)
+ * @property {transformType} type - Transform Type (1 byte)
+ * @property {number} id - Transform ID (2 bytes)
+ * @property {Attribute} attributes - Transform Attributes (n bytes)
+ */
+class Transform {
+    constructor(lastSubstructure, length, type, id, attributes) {
+        this.lastSubstructure = lastSubstructure;
+        this.length = length;
+        this.type = type;
+        this.id = id;
+        this.attributes = attributes;
+    }
+    /**
+     * Parses a transform from a buffer
+     * @param buffer The buffer to parse from.
+     * @static
+     * @public
+     * @returns {Transform}
+     */
+    static parse(buffer) {
+        try {
+            const lastSubstructure = buffer.readUInt8(0); // First octet
+            const length = buffer.readUInt16BE(2); // Transform Length starts at byte 2
+            const type = buffer.readUInt8(4); // Transform Type at byte 4
+            const id = buffer.readUInt16BE(6); // Transform ID starts at byte 6
+            // Attributes start at byte 8 onward
+            const attributesBuffer = buffer.subarray(8, length);
+            const attributes = this.parseAttributes(attributesBuffer);
+            return new Transform(lastSubstructure, length, type, id, attributes);
+        }
+        catch (error) {
+            throw new Error("Failed to parse transform");
+        }
+    }
+    /**
+     * Serializes a JSON representation of the transform to a buffer
+     * @param json The JSON object to serialize.
+     * @static
+     * @public
+     * @returns {Buffer}
+     */
+    static serializeJSON(json) {
+        const lastSubstructure = json.lastSubstructure;
+        const length = json.length;
+        const type = json.type;
+        const id = json.id;
+        const attributesBuffer = json.attributes.map((attr) => attribute_1.Attribute.serializeJSON(attr));
+        const totalLength = 8 +
+            attributesBuffer.reduce((acc, buf) => acc + buf.length, 0);
+        const buffer = Buffer.alloc(totalLength);
+        buffer.writeUInt8(lastSubstructure, 0);
+        buffer.writeUInt8(0, 1);
+        buffer.writeUInt16BE(length, 2);
+        buffer.writeUInt8(type, 4);
+        buffer.writeUInt8(0, 5);
+        buffer.writeUInt16BE(id, 6);
+        Buffer.concat(attributesBuffer).copy(buffer, 8);
+        return buffer;
+    }
+    /**
+     * Parses attributes from a buffer
+     * @param buffer The buffer to parse from
+     * @static
+     * @private
+     * @returns {Attribute[]}
+     */
+    static parseAttributes(buffer) {
+        if (!Buffer.isBuffer(buffer)) {
+            throw new Error("Input must be a Buffer");
+        }
+        const attributes = [];
+        let offset = 0;
+        const maxIterations = 1000; // Prevent infinite loops
+        let iterationCount = 0;
+        while (offset < buffer.length && iterationCount < maxIterations) {
+            iterationCount++;
+            // Ensure we have at least 4 bytes for the attribute header
+            if (offset + 4 > buffer.length) {
+                throw new Error("Buffer too short for attribute header");
+            }
+            try {
+                const attribute = attribute_1.Attribute.parse(buffer.subarray(offset));
+                attributes.push(attribute);
+                // Calculate the actual length of the parsed attribute
+                const attributeLength = attribute.format === 0
+                    ? 4 + attribute.length
+                    : 4; // AF=1 --> fixed 4 bytes, value is in the "length" field
+                offset += attributeLength;
+                // Safety check: ensure we're making progress
+                if (attributeLength <= 0) {
+                    throw new Error("Invalid attribute length: must be greater than 0");
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to parse attribute at offset ${offset}: ${error.message}`);
+                }
+                throw new Error(`Failed to parse attribute at offset ${offset}: Unknown error`);
+            }
+        }
+        if (iterationCount >= maxIterations) {
+            throw new Error("Too many attributes parsed, possible infinite loop detected");
+        }
+        return attributes;
+    }
+    get attributeKeyLength() {
+        var _a;
+        let keyLengthAttribute = (_a = this.attributes) === null || _a === void 0 ? void 0 : _a.find((attr) => attr.type === attribute_1.attributeType.KeyLength);
+        if (keyLengthAttribute &&
+            keyLengthAttribute.value &&
+            keyLengthAttribute.value.length === 2) {
+            return keyLengthAttribute.value.readUInt16BE(0);
+        }
+        return undefined;
+    }
+    set attributeKeyLength(keyLength) {
+        var _a;
+        let keyLengthBuffer = Buffer.alloc(2);
+        keyLengthBuffer.writeUInt16BE(keyLength, 0);
+        let keyLengthAttribute = (_a = this.attributes) === null || _a === void 0 ? void 0 : _a.find((attr) => attr.type === attribute_1.attributeType.KeyLength);
+        if (keyLengthAttribute) {
+            keyLengthAttribute.value = keyLengthBuffer;
+            keyLengthAttribute.length = 0;
+        }
+        else {
+            this.attributes.push(new attribute_1.Attribute(1, attribute_1.attributeType.KeyLength, keyLengthBuffer));
+        }
+    }
+    /**
+     * Serializes the transform to a buffer
+     * @method
+     * @public
+     * @returns {Buffer}
+     */
+    serialize() {
+        // Encode deep attributes first
+        const attributes = this.attributes.map((attr) => attr.serialize());
+        const attributesBuffer = Buffer.concat(attributes);
+        // Fix the length
+        this.length = 8 + attributesBuffer.length;
+        // Allocate a buffer with the exact length
+        const buffer = Buffer.alloc(this.length);
+        // Serialize fields into the buffer
+        buffer.writeUInt8(this.lastSubstructure, 0); // First byte: lastSubstructure
+        buffer.writeUInt8(0, 1);
+        buffer.writeUInt16BE(this.length, 2); // Transform Length (2 bytes)
+        buffer.writeUInt8(this.type, 4); // Transform Type (1 byte)
+        buffer.writeUInt8(0, 5); // Reserved (1 byte)
+        buffer.writeUInt16BE(this.id, 6); // Transform ID (2 bytes)
+        attributesBuffer.copy(buffer, 8); // Copy attributes starting at byte 8
+        return buffer;
+    }
+    /**
+     * Convert object to JSON
+     * @method
+     * @public
+     * @returns {Record<string, any>} JSON object
+     */
+    toJSON() {
+        return {
+            lastSubstructure: this.lastSubstructure,
+            length: this.length,
+            type: this.type,
+            id: this.id,
+            attributes: this.attributes.map((attr) => attr.toJSON()),
+        };
+    }
+    /**
+     * Returns a string representation of the transform
+     * @method
+     * @public
+     * @returns {void}
+     */
+    toString() {
+        const prettyJson = this.toJSON();
+        prettyJson.lastSubstructure =
+            this.lastSubstructure === 3 ? "Transform (3)" : "None (0)";
+        prettyJson.type = `${transformType[this.type] || "UNKNOWN"} (${prettyJson.type})`;
+        prettyJson.id = `${exports.transformTypeMap.get(this.type)[this.id] || "UNKNOWN"} (${prettyJson.id})`;
+        prettyJson.attributes = this.attributes.map((attr) => JSON.parse(attr.toString()));
+        return JSON.stringify(prettyJson, null, 2);
+    }
+}
+exports.Transform = Transform;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "node-ikev2",
+  "title": "Node-IKEV2",
+  "version": "0.1.0",
+  "description": "IKEv2 parser and serializer for Node.js",
+  "main": "./lib/src/index.js",
+  "types": "./lib/src/index.d.ts",
+  "module": "./lib/src/index.js",
+  "files": [
+    "lib/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint 'src/**/*.ts'",
+    "lint-fix": "eslint 'src/**/*.ts' --fix",
+    "test": "jest",
+    "build-and-test": "npm run build && npm run test",
+    "prepublishOnly": "npm run build-and-test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hyavari/node-ikev2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hyavari/node-ikev2/issues"
+  },
+  "homepage": "https://github.com/hyavari/node-ikev2#readme",
+  "keywords": [
+    "ikev2",
+    "ipsec",
+    "vpn",
+    "security",
+    "cryptography",
+    "parser"
+  ],
+  "author": "Hossein Yavari",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.7.9",
+    "@typescript-eslint/eslint-plugin": "^8.10.0",
+    "@typescript-eslint/parser": "^8.10.0",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "globals": "^15.11.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.10.0"
+  }
+}