239 lines
9.0 KiB
JavaScript
239 lines
9.0 KiB
JavaScript
const net = require('net');
|
|
|
|
// Приложение А ТЗ — запрещённые диапазоны
|
|
const BLOCKED_RANGES = [
|
|
'10.0.0.0/8',
|
|
'172.16.0.0/12',
|
|
'192.168.0.0/16',
|
|
'100.64.0.0/10',
|
|
'127.0.0.0/8',
|
|
'169.254.0.0/16',
|
|
'192.0.0.0/24',
|
|
'192.0.2.0/24',
|
|
'198.51.100.0/24',
|
|
'203.0.113.0/24',
|
|
'198.18.0.0/15',
|
|
'224.0.0.0/4',
|
|
'240.0.0.0/4',
|
|
'0.0.0.0/8',
|
|
'255.255.255.255/32',
|
|
];
|
|
|
|
/**
|
|
* Проверить и нормализовать IPv4/CIDR.
|
|
* Возвращает { cidr: 'x.x.x.x/yy', wasNormalized: bool }
|
|
* или выбрасывает ошибку с понятным текстом.
|
|
*/
|
|
function validate(input) {
|
|
const raw = (input || '').trim();
|
|
if (!raw) throw new Error('Пустое значение');
|
|
|
|
// Отсекаем IPv6 и доменные имена
|
|
if (raw.includes(':')) throw new Error('IPv6 не поддерживается');
|
|
if (/[a-zA-Z]/.test(raw.replace(/\./g, '').replace(/\//g, '').replace(/\d/g, '')))
|
|
throw new Error('Некорректный формат');
|
|
|
|
// Отсекаем множественные слэши
|
|
if ((raw.match(/\//g) || []).length > 1) {
|
|
throw new Error('Некорректный формат');
|
|
}
|
|
|
|
// Если нет маски — добавляем /32
|
|
let cidr = raw.includes('/') ? raw : raw + '/32';
|
|
|
|
const [addr, maskStr] = cidr.split('/');
|
|
|
|
// Строгая проверка маски (parseInt глотает мусор: '24abc' → 24)
|
|
if (!/^\d{1,2}$/.test(maskStr)) {
|
|
throw new Error('Некорректная маска');
|
|
}
|
|
const mask = parseInt(maskStr, 10);
|
|
|
|
if (mask < 22 || mask > 32) {
|
|
throw new Error('Маска должна быть от /22 до /32');
|
|
}
|
|
|
|
if (!net.isIPv4(addr)) throw new Error('Некорректный IPv4 адрес');
|
|
|
|
// Нормализация: обнуляем host-биты
|
|
const ipNum = addr.split('.').reduce((acc, octet) => (acc << 8) + parseInt(octet, 10), 0) >>> 0;
|
|
const netMask = ~((1 << (32 - mask)) - 1) >>> 0;
|
|
const network = (ipNum & netMask) >>> 0;
|
|
const networkAddr = [
|
|
(network >>> 24) & 0xff,
|
|
(network >>> 16) & 0xff,
|
|
(network >>> 8) & 0xff,
|
|
network & 0xff,
|
|
].join('.');
|
|
|
|
const wasNormalized = addr !== networkAddr;
|
|
const normalized = networkAddr + '/' + mask;
|
|
|
|
// Проверка запрещённых диапазонов (overlaps ловит оба направления:
|
|
// и запись внутри запрещённого блока, и суперсеть над ним)
|
|
for (const blocked of BLOCKED_RANGES) {
|
|
if (overlaps(normalized, blocked)) {
|
|
throw new Error(`Диапазон ${normalized} пересекается с запрещённым (${blocked})`);
|
|
}
|
|
}
|
|
|
|
return { cidr: normalized, wasNormalized };
|
|
}
|
|
|
|
/**
|
|
* Проверить пересечение двух CIDR
|
|
*/
|
|
function overlaps(cidr1, cidr2) {
|
|
const a = cidrToRange(cidr1);
|
|
const b = cidrToRange(cidr2);
|
|
// Каноническая формула пересечения двух отрезков: [a.start, a.end] ∩ [b.start, b.end] ≠ ∅
|
|
return a.start <= b.end && b.start <= a.end;
|
|
}
|
|
|
|
/**
|
|
* Проверить что cidr является подсетью parent
|
|
*/
|
|
function isSubnetOf(cidr, parent) {
|
|
const child = cidrToRange(cidr);
|
|
const par = cidrToRange(parent);
|
|
return child.start >= par.start && child.end <= par.end;
|
|
}
|
|
|
|
function cidrToRange(cidr) {
|
|
const [addr, maskStr] = cidr.split('/');
|
|
const mask = parseInt(maskStr, 10);
|
|
const ip = addr.split('.').reduce((acc, o) => (acc << 8) + parseInt(o, 10), 0) >>> 0;
|
|
const start = ip >>> 0;
|
|
const end = (ip | ((1 << (32 - mask)) - 1)) >>> 0;
|
|
return { start, end };
|
|
}
|
|
|
|
/**
|
|
* Конвертировать беззнаковое 32-битное число в строку IPv4.
|
|
* Используется при обратном преобразовании диапазон → CIDR.
|
|
*/
|
|
function numToIP(n) {
|
|
return [
|
|
(n >>> 24) & 0xff,
|
|
(n >>> 16) & 0xff,
|
|
(n >>> 8) & 0xff,
|
|
n & 0xff,
|
|
].join('.');
|
|
}
|
|
|
|
/**
|
|
* Преобразовать числовой диапазон [start, end] (unsigned 32-bit) в
|
|
* минимальный набор CIDR-блоков.
|
|
*
|
|
* Алгоритм: для каждой текущей позиции ищем наибольший выровненный блок,
|
|
* начинающийся в cur и не выходящий за end. «Выровненный» — значит cur
|
|
* является адресом сети (host-биты = 0) для данного префикса.
|
|
* Кол-во trailing zeros в cur определяет максимально допустимый блок.
|
|
*
|
|
* @param {number} start — uint32 начало диапазона
|
|
* @param {number} end — uint32 конец диапазона (включительно)
|
|
* @returns {string[]} массив строк вида '1.2.3.4/24'
|
|
*/
|
|
function rangeToCIDRs(start, end) {
|
|
const cidrs = [];
|
|
let cur = start >>> 0;
|
|
const endU = end >>> 0;
|
|
|
|
while (cur <= endU) {
|
|
// Считаем кол-во trailing zeros в cur — они дают максимальный
|
|
// выровненный блок, который может начинаться с этого адреса.
|
|
let trailingZeros = 0;
|
|
if (cur === 0) {
|
|
trailingZeros = 32; // 0.0.0.0 выровнен на любой блок
|
|
} else {
|
|
let tmp = cur;
|
|
while ((tmp & 1) === 0 && trailingZeros < 32) {
|
|
tmp = tmp >>> 1;
|
|
trailingZeros++;
|
|
}
|
|
}
|
|
|
|
// Начинаем с максимально выровненного блока и сужаем,
|
|
// пока блок не поместится в [cur, endU].
|
|
let prefix = 32 - trailingZeros;
|
|
while (prefix <= 32) {
|
|
const hostBits = 32 - prefix;
|
|
// blockEnd = cur + 2^hostBits - 1; для /32 blockEnd = cur
|
|
const blockEnd = hostBits > 0 ? (cur + Math.pow(2, hostBits) - 1) >>> 0 : cur;
|
|
if (blockEnd <= endU) break;
|
|
prefix++;
|
|
}
|
|
|
|
cidrs.push(numToIP(cur) + '/' + prefix);
|
|
|
|
// Шагаем к следующему блоку
|
|
const hostBits = 32 - prefix;
|
|
if (hostBits === 0) {
|
|
// /32 — шаг ровно один адрес
|
|
if (cur === 0xFFFFFFFF) break; // последний адрес IPv4
|
|
cur = (cur + 1) >>> 0;
|
|
} else {
|
|
const blockSize = Math.pow(2, hostBits);
|
|
cur = (cur + blockSize) >>> 0;
|
|
if (cur === 0) break; // переполнение uint32 — весь диапазон пройден
|
|
}
|
|
}
|
|
|
|
return cidrs;
|
|
}
|
|
|
|
/**
|
|
* Агрегировать (суммаризировать) массив CIDR-строк в минимальный
|
|
* эквивалентный набор без пересечений.
|
|
*
|
|
* Шаги:
|
|
* 1. Конвертируем каждый CIDR в числовой диапазон [start, end].
|
|
* 2. Сортируем диапазоны по start.
|
|
* 3. Объединяем пересекающиеся и смежные диапазоны — scan-line merge.
|
|
* 4. Каждый слитый диапазон → минимальный набор CIDR (rangeToCIDRs).
|
|
*
|
|
* Используется в /export: все компании суммаризируются совместно по ТЗ.
|
|
*
|
|
* @param {string[]} cidrs — массив строк вида '1.2.3.4/24'
|
|
* @returns {string[]} минимальный набор CIDR в порядке возрастания
|
|
*/
|
|
function aggregateCIDRs(cidrs) {
|
|
if (!cidrs || cidrs.length === 0) return [];
|
|
|
|
// Шаг 1: CIDR → числовые диапазоны
|
|
const ranges = cidrs.map(cidrToRange);
|
|
|
|
// Шаг 2: сортировка по start (числа ≤ 2^32, безопасно сравнивать как float)
|
|
ranges.sort((a, b) => {
|
|
if (a.start < b.start) return -1;
|
|
if (a.start > b.start) return 1;
|
|
return 0;
|
|
});
|
|
|
|
// Шаг 3: scan-line merge — объединяем перекрывающиеся и смежные диапазоны
|
|
const merged = [{ start: ranges[0].start, end: ranges[0].end }];
|
|
for (let i = 1; i < ranges.length; i++) {
|
|
const last = merged[merged.length - 1];
|
|
const cur = ranges[i];
|
|
// «Смежные» означает cur.start === last.end + 1 (без зазора)
|
|
// Защита от переполнения: last.end === 0xFFFFFFFF — следующего нет
|
|
const adjacent = last.end < 0xFFFFFFFF && cur.start === last.end + 1;
|
|
if (cur.start <= last.end || adjacent) {
|
|
// Поглощаем cur в last (расширяем если cur заходит дальше)
|
|
if (cur.end > last.end) last.end = cur.end;
|
|
} else {
|
|
// Новый несмежный диапазон
|
|
merged.push({ start: cur.start, end: cur.end });
|
|
}
|
|
}
|
|
|
|
// Шаг 4: каждый слитый диапазон → минимальный набор CIDR
|
|
const result = [];
|
|
for (const range of merged) {
|
|
result.push(...rangeToCIDRs(range.start, range.end));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
module.exports = { validate, overlaps, BLOCKED_RANGES, aggregateCIDRs };
|