File Explorer

1"use strict";2/* eslint-disable no-param-reassign */3var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {4    if (k2 === undefined) k2 = k;5    var desc = Object.getOwnPropertyDescriptor(m, k);6    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {7      desc = { enumerable: true, get: function() { return m[k]; } };8    }9    Object.defineProperty(o, k2, desc);10}) : (function(o, m, k, k2) {11    if (k2 === undefined) k2 = k;12    o[k2] = m[k];13}));14var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {15    Object.defineProperty(o, "default", { enumerable: true, value: v });16}) : function(o, v) {17    o["default"] = v;18});19var __importStar = (this && this.__importStar) || function (mod) {20    if (mod && mod.__esModule) return mod;21    var result = {};22    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);23    __setModuleDefault(result, mod);24    return result;25};26Object.defineProperty(exports, "__esModule", { value: true });27exports.Address4 = void 0;28const common = __importStar(require("./common"));29const constants = __importStar(require("./v4/constants"));30const address_error_1 = require("./address-error");31const isCorrect4 = common.isCorrect(constants.BITS);32/**33 * Represents an IPv4 address34 * @param {string} address - An IPv4 address string35 */36class Address4 {37    constructor(address) {38        this.groups = constants.GROUPS;39        this.parsedAddress = [];40        this.parsedSubnet = '';41        this.subnet = '/32';42        this.subnetMask = 32;43        this.v4 = true;44        /**45         * Returns true if the address is correct, false otherwise46         * @returns {Boolean}47         */48        this.isCorrect = isCorrect4;49        /**50         * Returns true if the given address is in the subnet of the current address51         * @returns {boolean}52         */53        this.isInSubnet = common.isInSubnet;54        this.address = address;55        const subnet = constants.RE_SUBNET_STRING.exec(address);56        if (subnet) {57            this.parsedSubnet = subnet[0].replace('/', '');58            this.subnetMask = parseInt(this.parsedSubnet, 10);59            this.subnet = `/${this.subnetMask}`;60            if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {61                throw new address_error_1.AddressError('Invalid subnet mask.');62            }63            address = address.replace(constants.RE_SUBNET_STRING, '');64        }65        this.addressMinusSuffix = address;66        this.parsedAddress = this.parse(address);67    }68    /**69     * Returns true if the given string is a valid IPv4 address (with optional70     * CIDR subnet), false otherwise. Host bits in the subnet portion are71     * allowed (e.g. `192.168.1.5/24` is valid); for strict network-address72     * validation compare `correctForm()` to `startAddress().correctForm()`,73     * or use `networkForm()`.74     */75    static isValid(address) {76        try {77            // eslint-disable-next-line no-new78            new Address4(address);79            return true;80        }81        catch (e) {82            return false;83        }84    }85    /**86     * Parses an IPv4 address string into its four octet groups and stores the87     * result on `this.parsedAddress`. Called automatically by the constructor;88     * you typically don't need to call it directly. Throws `AddressError` if89     * the input is not a valid IPv4 address.90     */91    parse(address) {92        const groups = address.split('.');93        if (!address.match(constants.RE_ADDRESS)) {94            throw new address_error_1.AddressError('Invalid IPv4 address.');95        }96        return groups;97    }98    /**99     * Returns the address in correct form: octets joined with `.` and any100     * leading zeros stripped (e.g. `192.168.1.1`). For IPv4 this matches the101     * canonical dotted-decimal representation.102     */103    correctForm() {104        return this.parsedAddress.map((part) => parseInt(part, 10)).join('.');105    }106    /**107     * Construct an `Address4` from an address and a dotted-decimal subnet108     * mask given as separate strings (e.g. as returned by Node's109     * `os.networkInterfaces()`). Throws `AddressError` if the mask is110     * non-contiguous (e.g. `255.0.255.0`).111     * @example112     * var address = Address4.fromAddressAndMask('192.168.1.1', '255.255.255.0');113     * address.subnetMask; // 24114     */115    static fromAddressAndMask(address, mask) {116        const bits = common.prefixLengthFromMask(new Address4(mask).bigInt(), constants.BITS);117        return new Address4(`${address}/${bits}`);118    }119    /**120     * Construct an `Address4` from an address and a Cisco-style wildcard mask121     * given as separate strings (e.g. `0.0.0.255` for a `/24`). The wildcard122     * mask is the bitwise inverse of the subnet mask. Throws `AddressError`123     * if the mask is non-contiguous (e.g. `0.255.0.255`).124     * @example125     * var address = Address4.fromAddressAndWildcardMask('10.0.0.1', '0.0.0.255');126     * address.subnetMask; // 24127     */128    static fromAddressAndWildcardMask(address, wildcardMask) {129        const wildcard = new Address4(wildcardMask).bigInt();130        const allOnes = (BigInt(1) << BigInt(constants.BITS)) - BigInt(1);131        // eslint-disable-next-line no-bitwise132        const mask = wildcard ^ allOnes;133        const bits = common.prefixLengthFromMask(mask, constants.BITS);134        return new Address4(`${address}/${bits}`);135    }136    /**137     * Construct an `Address4` from a wildcard pattern with trailing `*`138     * octets. The number of trailing wildcards determines the prefix139     * length: each `*` represents 8 bits.140     *141     * Only trailing whole-octet wildcards are supported. Partial-octet142     * wildcards (e.g. `192.168.0.1*`) and interior wildcards (e.g.143     * `192.*.0.1`) throw `AddressError`.144     * @example145     * Address4.fromWildcard('192.168.0.*').subnet;   // '/24'146     * Address4.fromWildcard('192.168.*.*').subnet;   // '/16'147     * Address4.fromWildcard('*.*.*.*').subnet;       // '/0'148     */149    static fromWildcard(input) {150        const groups = input.split('.');151        if (groups.length !== constants.GROUPS) {152            throw new address_error_1.AddressError('Wildcard pattern must have 4 octets');153        }154        let firstWildcard = -1;155        for (let i = 0; i < groups.length; i++) {156            if (groups[i] === '*') {157                if (firstWildcard === -1) {158                    firstWildcard = i;159                }160            }161            else if (firstWildcard !== -1) {162                throw new address_error_1.AddressError('Wildcard `*` must only appear in trailing octets (e.g. `192.168.0.*`)');163            }164        }165        const trailing = firstWildcard === -1 ? 0 : groups.length - firstWildcard;166        const replaced = groups.map((g) => (g === '*' ? '0' : g));167        const subnetBits = constants.BITS - trailing * 8;168        return new Address4(`${replaced.join('.')}/${subnetBits}`);169    }170    /**171     * Converts a hex string to an IPv4 address object. Accepts 8 hex digits172     * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`).173     * Throws `AddressError` for any other length or for non-hex characters.174     * @param {string} hex - a hex string to convert175     * @returns {Address4}176     */177    static fromHex(hex) {178        const stripped = hex.replace(/:/g, '');179        if (!/^[0-9a-fA-F]{8}$/.test(stripped)) {180            throw new address_error_1.AddressError('IPv4 hex must be exactly 8 hex digits');181        }182        const groups = [];183        for (let i = 0; i < 8; i += 2) {184            groups.push(parseInt(stripped.slice(i, i + 2), 16));185        }186        return new Address4(groups.join('.'));187    }188    /**189     * Converts an integer into a IPv4 address object. The integer must be a190     * non-negative safe integer in the range `[0, 2**32 - 1]`; otherwise191     * `AddressError` is thrown.192     * @param {integer} integer - a number to convert193     * @returns {Address4}194     */195    static fromInteger(integer) {196        if (!Number.isInteger(integer) || integer < 0 || integer > 0xffffffff) {197            throw new address_error_1.AddressError('IPv4 integer must be in the range 0 to 2**32 - 1');198        }199        return Address4.fromHex(integer.toString(16).padStart(8, '0'));200    }201    /**202     * Return an address from in-addr.arpa form203     * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address204     * @returns {Adress4}205     * @example206     * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)207     * address.correctForm(); // '192.0.2.42'208     */209    static fromArpa(arpaFormAddress) {210        // remove ending ".in-addr.arpa." or just "."211        const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, '');212        const address = leader.split('.').reverse().join('.');213        return new Address4(address);214    }215    /**216     * Converts an IPv4 address object to a hex string217     * @returns {String}218     */219    toHex() {220        return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(':');221    }222    /**223     * Converts an IPv4 address object to an array of bytes.224     *225     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toArray())`.226     * @returns {Array}227     */228    toArray() {229        return this.parsedAddress.map((part) => parseInt(part, 10));230    }231    /**232     * Converts an IPv4 address object to an IPv6 address group233     * @returns {String}234     */235    toGroup6() {236        const output = [];237        let i;238        for (i = 0; i < constants.GROUPS; i += 2) {239            output.push(`${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`);240        }241        return output.join(':');242    }243    /**244     * Returns the address as a `bigint`245     * @returns {bigint}246     */247    bigInt() {248        return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join('')}`);249    }250    /**251     * Helper function getting start address.252     * @returns {bigint}253     */254    _startAddress() {255        return BigInt(`0b${this.mask() + '0'.repeat(constants.BITS - this.subnetMask)}`);256    }257    /**258     * The first address in the range given by this address' subnet.259     * Often referred to as the Network Address.260     * @returns {Address4}261     */262    startAddress() {263        return Address4.fromBigInt(this._startAddress());264    }265    /**266     * The first host address in the range given by this address's subnet ie267     * the first address after the Network Address268     * @returns {Address4}269     */270    startAddressExclusive() {271        const adjust = BigInt('1');272        return Address4.fromBigInt(this._startAddress() + adjust);273    }274    /**275     * Helper function getting end address.276     * @returns {bigint}277     */278    _endAddress() {279        return BigInt(`0b${this.mask() + '1'.repeat(constants.BITS - this.subnetMask)}`);280    }281    /**282     * The last address in the range given by this address' subnet283     * Often referred to as the Broadcast284     * @returns {Address4}285     */286    endAddress() {287        return Address4.fromBigInt(this._endAddress());288    }289    /**290     * The last host address in the range given by this address's subnet ie291     * the last address prior to the Broadcast Address292     * @returns {Address4}293     */294    endAddressExclusive() {295        const adjust = BigInt('1');296        return Address4.fromBigInt(this._endAddress() - adjust);297    }298    /**299     * The dotted-decimal form of the subnet mask, e.g. `255.255.240.0` for300     * a `/20`. Returns an `Address4`; call `.correctForm()` for the string.301     * @returns {Address4}302     */303    subnetMaskAddress() {304        return Address4.fromBigInt(BigInt(`0b${'1'.repeat(this.subnetMask)}${'0'.repeat(constants.BITS - this.subnetMask)}`));305    }306    /**307     * The Cisco-style wildcard mask, e.g. `0.0.0.255` for a `/24`. This is308     * the bitwise inverse of `subnetMaskAddress()`. Returns an `Address4`;309     * call `.correctForm()` for the string.310     * @returns {Address4}311     */312    wildcardMask() {313        return Address4.fromBigInt(BigInt(`0b${'0'.repeat(this.subnetMask)}${'1'.repeat(constants.BITS - this.subnetMask)}`));314    }315    /**316     * The network address in CIDR string form, e.g. `192.168.1.0/24` for317     * `192.168.1.5/24`. For an address with no explicit subnet the prefix is318     * `/32`, e.g. `networkForm()` on `192.168.1.5` returns `192.168.1.5/32`.319     * @returns {string}320     */321    networkForm() {322        return `${this.startAddress().correctForm()}/${this.subnetMask}`;323    }324    /**325     * Converts a BigInt to a v4 address object. The value must be in the326     * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown.327     * @param {bigint} bigInt - a BigInt to convert328     * @returns {Address4}329     */330    static fromBigInt(bigInt) {331        if (bigInt < 0n || bigInt > 0xffffffffn) {332            throw new address_error_1.AddressError('IPv4 BigInt must be in the range 0 to 2**32 - 1');333        }334        return Address4.fromHex(bigInt.toString(16).padStart(8, '0'));335    }336    /**337     * Convert a byte array to an Address4 object.338     *339     * To convert from a Node.js `Buffer`, spread it: `Address4.fromByteArray([...buf])`.340     * @param {Array<number>} bytes - an array of 4 bytes (0-255)341     * @returns {Address4}342     */343    static fromByteArray(bytes) {344        if (bytes.length !== 4) {345            throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');346        }347        // Validate that all bytes are within valid range (0-255)348        for (let i = 0; i < bytes.length; i++) {349            if (!Number.isInteger(bytes[i]) || bytes[i] < 0 || bytes[i] > 255) {350                throw new address_error_1.AddressError('All bytes must be integers between 0 and 255');351            }352        }353        return this.fromUnsignedByteArray(bytes);354    }355    /**356     * Convert an unsigned byte array to an Address4 object357     * @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)358     * @returns {Address4}359     */360    static fromUnsignedByteArray(bytes) {361        if (bytes.length !== 4) {362            throw new address_error_1.AddressError('IPv4 addresses require exactly 4 bytes');363        }364        const address = bytes.join('.');365        return new Address4(address);366    }367    /**368     * Returns the first n bits of the address, defaulting to the369     * subnet mask370     * @returns {String}371     */372    mask(mask) {373        if (mask === undefined) {374            mask = this.subnetMask;375        }376        return this.getBitsBase2(0, mask);377    }378    /**379     * Returns the bits in the given range as a base-2 string380     * @returns {string}381     */382    getBitsBase2(start, end) {383        return this.binaryZeroPad().slice(start, end);384    }385    /**386     * Return the reversed ip6.arpa form of the address387     * @param {Object} options388     * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix389     * @returns {String}390     */391    reverseForm(options) {392        if (!options) {393            options = {};394        }395        const reversed = this.correctForm().split('.').reverse().join('.');396        if (options.omitSuffix) {397            return reversed;398        }399        return `${reversed}.in-addr.arpa.`;400    }401    /**402     * Returns true if the given address is a multicast address403     * @returns {boolean}404     */405    isMulticast() {406        return this.isInSubnet(MULTICAST_V4);407    }408    /**409     * Returns true if the address is in one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private address ranges (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`).410     * @returns {boolean}411     */412    isPrivate() {413        return PRIVATE_V4.some((subnet) => this.isInSubnet(subnet));414    }415    /**416     * Returns true if the address is in the loopback range `127.0.0.0/8` ([RFC 1122](https://datatracker.ietf.org/doc/html/rfc1122)).417     * @returns {boolean}418     */419    isLoopback() {420        return this.isInSubnet(LOOPBACK_V4);421    }422    /**423     * Returns true if the address is in the link-local range `169.254.0.0/16` ([RFC 3927](https://datatracker.ietf.org/doc/html/rfc3927)).424     * @returns {boolean}425     */426    isLinkLocal() {427        return this.isInSubnet(LINK_LOCAL_V4);428    }429    /**430     * Returns true if the address is the unspecified address `0.0.0.0`.431     * @returns {boolean}432     */433    isUnspecified() {434        return this.isInSubnet(UNSPECIFIED_V4);435    }436    /**437     * Returns true if the address is the limited broadcast address `255.255.255.255` ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)).438     * @returns {boolean}439     */440    isBroadcast() {441        return this.isInSubnet(BROADCAST_V4);442    }443    /**444     * Returns true if the address is in the carrier-grade NAT range `100.64.0.0/10` ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)).445     * @returns {boolean}446     */447    isCGNAT() {448        return this.isInSubnet(CGNAT_V4);449    }450    /**451     * Returns a zero-padded base-2 string representation of the address452     * @returns {string}453     */454    binaryZeroPad() {455        if (this._binaryZeroPad === undefined) {456            this._binaryZeroPad = this.bigInt().toString(2).padStart(constants.BITS, '0');457        }458        return this._binaryZeroPad;459    }460    /**461     * Groups an IPv4 address for inclusion at the end of an IPv6 address462     * @returns {String}463     */464    groupForV6() {465        const segments = this.parsedAddress;466        return this.address.replace(constants.RE_ADDRESS, `<span class="hover-group group-v4 group-6">${segments467            .slice(0, 2)468            .join('.')}</span>.<span class="hover-group group-v4 group-7">${segments469            .slice(2, 4)470            .join('.')}</span>`);471    }472}473exports.Address4 = Address4;474const MULTICAST_V4 = new Address4('224.0.0.0/4');475const PRIVATE_V4 = [476    new Address4('10.0.0.0/8'),477    new Address4('172.16.0.0/12'),478    new Address4('192.168.0.0/16'),479];480const LOOPBACK_V4 = new Address4('127.0.0.0/8');481const LINK_LOCAL_V4 = new Address4('169.254.0.0/16');482const UNSPECIFIED_V4 = new Address4('0.0.0.0/32');483const BROADCAST_V4 = new Address4('255.255.255.255/32');484const CGNAT_V4 = new Address4('100.64.0.0/10');485//# sourceMappingURL=ipv4.js.map