itube-specs 0.0.1071 → 0.0.1072

package/middleware/age.global.ts

@@ -1,4 +1,4 @@
-import { isGeoMatch, isAgeVerified } from '../runtime';
+import { isGeoMatch, isAgeVerified, isSearchBotIp, getClientHeaders } from '../runtime';
 import { useAgeGate } from '../composables/use-age-gate';
 
 export default defineNuxtRouteMiddleware(async () => {
@@ -10,6 +10,8 @@ export default defineNuxtRouteMiddleware(async () => {
   const event = useRequestEvent();
   if (!(await isGeoMatch(event, config))) return;
 
+  if (await isSearchBotIp(getClientHeaders(event).remoteIP)) return;
+
   const { isAgeGated } = useAgeGate();
   try {
     isAgeGated.value = !(await isAgeVerified(event, config));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.1071",
+  "version": "0.0.1072",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {

package/runtime/index.ts

@@ -71,5 +71,7 @@ export * from './utils/check-device-width';
 export * from './utils/is-mobile-device';
 export * from './utils/vtt-helper';
 export * from './utils/server/age';
+export * from './utils/server/ip-ranges';
+export * from './utils/server/search-bot-ips';
 export * from './utils/server/get-client-headers';
 export * from './utils/server/get-path-locale';

package/runtime/utils/server/__tests__/ip-ranges.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { parseIp, parseCidr, isIpInRanges, type IIpRange } from '../ip-ranges';
+
+const ranges = (...cidrs: string[]) => cidrs.map((cidr) => parseCidr(cidr)).filter((range): range is IIpRange => range !== null);
+
+describe('parseIp', () => {
+  it('разбирает IPv4', () => {
+    expect(parseIp('66.249.66.1')).toEqual({ bits: 32, value: 0x42f94201n });
+    expect(parseIp(' 0.0.0.0 ')).toEqual({ bits: 32, value: 0n });
+  });
+
+  it('сводит IPv4-mapped IPv6 к IPv4', () => {
+    expect(parseIp('::ffff:66.249.66.1')).toEqual({ bits: 32, value: 0x42f94201n });
+  });
+
+  it('разбирает IPv6 с сокращением и без', () => {
+    expect(parseIp('::1')).toEqual({ bits: 128, value: 1n });
+    expect(parseIp('::')).toEqual({ bits: 128, value: 0n });
+    expect(parseIp('2001:4860:4801:10::')?.value).toBe(0x20014860480100100000000000000000n);
+    expect(parseIp('2001:4860:4801:10:0:0:0:1')?.value).toBe(0x20014860480100100000000000000001n);
+    expect(parseIp('64:ff9b::1.2.3.4')?.value).toBe(0x0064ff9b000000000000000001020304n);
+  });
+
+  it('невалидное — null', () => {
+    expect(parseIp('')).toBeNull();
+    expect(parseIp('256.1.1.1')).toBeNull();
+    expect(parseIp('1.2.3')).toBeNull();
+    expect(parseIp('1::2::3')).toBeNull();
+    expect(parseIp('1:2:3:4:5:6:7:8:9')).toBeNull();
+    expect(parseIp('gggg::1')).toBeNull();
+    expect(parseIp('unknown')).toBeNull();
+  });
+});
+
+describe('parseCidr', () => {
+  it('обнуляет хост-биты базы', () => {
+    expect(parseCidr('66.249.66.77/24')).toEqual({ bits: 32, base: 0x42f94200n, mask: 0xffffff00n });
+  });
+
+  it('без префикса — один адрес', () => {
+    expect(parseCidr('1.2.3.4')?.mask).toBe(0xffffffffn);
+  });
+
+  it('невалидный префикс — null', () => {
+    expect(parseCidr('1.2.3.4/33')).toBeNull();
+    expect(parseCidr('1.2.3.4/x')).toBeNull();
+    expect(parseCidr('::/129')).toBeNull();
+    expect(parseCidr('nope/24')).toBeNull();
+  });
+});
+
+describe('isIpInRanges', () => {
+  const list = ranges('66.249.64.0/27', '2001:4860:4801:10::/64', '157.55.39.0/24');
+
+  it('находит IPv4 внутри диапазона и на его границах', () => {
+    expect(isIpInRanges('66.249.64.0', list)).toBe(true);
+    expect(isIpInRanges('66.249.64.31', list)).toBe(true);
+    expect(isIpInRanges('157.55.39.200', list)).toBe(true);
+    expect(isIpInRanges('::ffff:66.249.64.5', list)).toBe(true);
+  });
+
+  it('не находит соседние адреса', () => {
+    expect(isIpInRanges('66.249.64.32', list)).toBe(false);
+    expect(isIpInRanges('66.249.63.255', list)).toBe(false);
+  });
+
+  it('находит IPv6 внутри /64 и не путает разрядности', () => {
+    expect(isIpInRanges('2001:4860:4801:10::1', list)).toBe(true);
+    expect(isIpInRanges('2001:4860:4801:10:ffff:ffff:ffff:ffff', list)).toBe(true);
+    expect(isIpInRanges('2001:4860:4801:11::1', list)).toBe(false);
+    expect(isIpInRanges('::42f9:4001', list)).toBe(false);
+  });
+
+  it('невалидный адрес и пустой список — false', () => {
+    expect(isIpInRanges('garbage', list)).toBe(false);
+    expect(isIpInRanges('66.249.64.1', [])).toBe(false);
+  });
+});

package/runtime/utils/server/ip-ranges.ts

@@ -0,0 +1,81 @@
+export interface IIpRange {
+  bits: 32 | 128;
+  base: bigint;
+  mask: bigint;
+}
+
+function parseIpv4(ip: string): bigint | null {
+  const parts = ip.split('.');
+  if (parts.length !== 4) return null;
+
+  let value = 0n;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part) || Number(part) > 255) return null;
+    value = (value << 8n) | BigInt(part);
+  }
+  return value;
+}
+
+function parseIpv6(ip: string): bigint | null {
+  let address = ip;
+  let tail: bigint | null = null;
+
+  const lastColon = address.lastIndexOf(':');
+  if (address.slice(lastColon + 1).includes('.')) {
+    tail = parseIpv4(address.slice(lastColon + 1));
+    if (tail === null) return null;
+    address = `${address.slice(0, lastColon + 1)}0:0`;
+  }
+
+  const halves = address.split('::');
+  if (halves.length > 2) return null;
+
+  const head = halves[0] ? halves[0].split(':') : [];
+  const rest = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+  const missing = 8 - head.length - rest.length;
+  if (halves.length === 2 ? missing < 1 : missing !== 0) return null;
+
+  const groups = [...head, ...Array(halves.length === 2 ? missing : 0).fill('0'), ...rest];
+
+  let value = 0n;
+  for (const group of groups) {
+    if (!/^[\da-f]{1,4}$/i.test(group)) return null;
+    value = (value << 16n) | BigInt(`0x${group}`);
+  }
+
+  return tail === null ? value : (value & ~0xffffffffn) | tail;
+}
+
+/** Адрес → число и разрядность. IPv4-mapped IPv6 (`::ffff:1.2.3.4`) сводится к IPv4. */
+export function parseIp(ip: string): { bits: 32 | 128, value: bigint } | null {
+  const trimmed = ip.trim();
+  const mapped = trimmed.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  const v4 = parseIpv4(mapped ? mapped[1] : trimmed);
+  if (v4 !== null) return { bits: 32, value: v4 };
+
+  const v6 = parseIpv6(trimmed);
+  return v6 === null ? null : { bits: 128, value: v6 };
+}
+
+/** CIDR (`66.249.64.0/27`, `2001:4860:4801:10::/64`) → диапазон для `isIpInRanges`. */
+export function parseCidr(cidr: string): IIpRange | null {
+  const [ip, prefix] = cidr.split('/');
+  const parsed = parseIp(ip);
+  if (!parsed) return null;
+
+  const length = prefix === undefined ? parsed.bits : Number(prefix);
+  if (!Number.isInteger(length) || length < 0 || length > parsed.bits) return null;
+
+  const all = (1n << BigInt(parsed.bits)) - 1n;
+  const mask = all ^ ((1n << BigInt(parsed.bits - length)) - 1n);
+
+  return { bits: parsed.bits, base: parsed.value & mask, mask };
+}
+
+/** Попадает ли адрес хотя бы в один диапазон. Невалидный адрес — нет. */
+export function isIpInRanges(ip: string, ranges: IIpRange[]): boolean {
+  const parsed = parseIp(ip);
+  if (!parsed) return false;
+
+  return ranges.some((range) => range.bits === parsed.bits && (parsed.value & range.mask) === range.base);
+}

package/runtime/utils/server/search-bot-ips.ts

@@ -0,0 +1,62 @@
+import { isIpInRanges, parseCidr, type IIpRange } from './ip-ranges';
+
+/** Официальные списки адресов поисковых роботов. */
+const SOURCES = [
+  'https://developers.google.com/static/crawling/ipranges/common-crawlers.json',
+  'https://www.bing.com/toolbox/bingbot.json',
+];
+
+const TTL = 24 * 60 * 60 * 1000;
+const RETRY_TTL = 5 * 60 * 1000;
+const FETCH_TIMEOUT = 5000;
+
+interface IPrefixesResponse {
+  prefixes?: { ipv4Prefix?: string, ipv6Prefix?: string }[];
+}
+
+const rangesBySource = new Map<string, IIpRange[]>();
+let expiresAt = 0;
+let loading: Promise<void> | null = null;
+
+async function loadSource(url: string): Promise<boolean> {
+  try {
+    const res = await $fetch<IPrefixesResponse>(url, { timeout: FETCH_TIMEOUT, parseResponse: JSON.parse });
+    const ranges = (res.prefixes || [])
+      .map((prefix) => parseCidr(prefix.ipv4Prefix || prefix.ipv6Prefix || ''))
+      .filter((range): range is IIpRange => range !== null);
+    if (!ranges.length) return false;
+
+    rangesBySource.set(url, ranges);
+    return true;
+  } catch (error) {
+    console.error(`Search bot IP list failed: ${url}`, error);
+    return false;
+  }
+}
+
+async function refresh(): Promise<void> {
+  const results = await Promise.all(SOURCES.map(loadSource));
+  expiresAt = Date.now() + (results.every(Boolean) ? TTL : RETRY_TTL);
+}
+
+/**
+ * Адрес принадлежит проверенному поисковому роботу (Google, Bing) — по их официальным спискам, не по
+ * User-Agent: тот подделывается. Списки живут в памяти процесса: качаются при первой проверке, дальше
+ * обновляются в фоне раз в сутки (после ошибки — через 5 минут), упавший источник держит прежний список.
+ * Ни одного списка ещё нет — ждём первую загрузку, не дольше таймаута; не скачалось — «не робот».
+ */
+export async function isSearchBotIp(ip: string | undefined): Promise<boolean> {
+  if (!ip) return false;
+
+  if (Date.now() >= expiresAt && !loading) {
+    loading = refresh().finally(() => {
+      loading = null;
+    });
+  }
+  if (!rangesBySource.size && loading) await loading;
+
+  for (const ranges of rangesBySource.values()) {
+    if (isIpInRanges(ip, ranges)) return true;
+  }
+  return false;
+}