Про ИИ, который «ничего не умеет»

// ==UserScript==
// @name         Chatroulett WebRTC Blocker
// @namespace    http://tampermonkey.net/
// @version      1.2
// @description  Мгновенная блокировка нежелательных WebRTC соединений для chatroulett.ru
// @author       Your Name
// @match        https://chatroulett.ru/*
// @grant        none
// @run-at       document-start
// ==/UserScript==

(function() {
    'use strict';

    // Инициализация черного списка
    const STORAGE_KEY = 'webrtc_blacklist';
    const RECENT_IPS_KEY = 'webrtc_recent_ips';

    // Функция для получения актуального черного списка
    const getBlacklist = () => JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]');

    // Разделенные списки исключений
    const EXCLUDED_DOMAINS = [
        'chatroulett.ru',
        'api.chatroulett.ru',
        'webrtc.chatroulett.ru'
    ];

    const EXCLUDED_IP_RANGES = [
        '0.0.0.0/8',              // Текущая сеть
        '10.0.0.0/8',             // Частная сеть
        '100.64.0.0/10',          // CGNAT
        '127.0.0.0/8',            // Loopback
        '169.254.0.0/16',         // Link-local
        '172.16.0.0/12',          // Частная сеть
        '192.0.0.0/24',           // Зарезервировано IANA
        '192.0.2.0/24',           // TEST-NET-1
        '192.168.0.0/16',         // Частная сеть
        '198.18.0.0/15',          // Тестовые сети
        '198.51.100.0/24',        // TEST-NET-2
        '203.0.113.0/24',         // TEST-NET-3
        '224.0.0.0/4',            // Multicast
        '240.0.0.0/4',            // Зарезервировано
        '255.255.255.255/32',     // Broadcast
        '7.0.0.0/8',              // Министерство обороны США
        '26.0.0.0/8',             // Министерство обороны США
        '28.0.0.0/8',             // Министерство обороны США
        '14.0.0.0/8',              // Китай (публичная сеть, но часто используется для NAT)
        // подсеть хостинга видеочата
        '93.189.228.0/22'
    ];

    // Функция для преобразования IP в число
    const ipToNumber = (ip) => {
        const parts = ip.split('.');
        if (parts.length !== 4) return 0;

        let result = 0;
        for (let i = 0; i < 4; i++) {
            const part = parseInt(parts[i], 10);
            if (isNaN(part) || part < 0 || part > 255) return 0;
            result += part * Math.pow(256, 3 - i);
        }
        return result;
    };

    // Функция проверки диапазона в CIDR нотации
    const isIPInRangeCIDR = (ip, cidr) => {
        const [network, prefix] = cidr.split('/');
        const prefixLength = parseInt(prefix, 10);

        const ipNum = ipToNumber(ip);
        const networkNum = ipToNumber(network);
        const mask = ~((1 << (32 - prefixLength)) - 1) >>> 0;

        return (ipNum & mask) === (networkNum & mask);
    };

    // Улучшенная функция проверки валидности IP
    const isValidIP = (ip) => {
        if (typeof ip !== 'string' || ip.trim() === '') {
            return false;
        }

        if (/[^0-9a-fA-F.:]/.test(ip)) {
            return false;
        }

        // IPv4
        const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
        if (ipv4Regex.test(ip)) {
            return true;
        }

        // IPv6 (упрощенная проверка)
        const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
        const ipv6ShortRegex = /^((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)::((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)$/;
        if (ipv6Regex.test(ip) || ipv6ShortRegex.test(ip)) {
            return true;
        }

        return false;
    };

    // Улучшенная функция проверки исключений
    const isExcluded = (value) => {
        // Проверка специальных адресов
        if (value === '0.0.0.0' ||
            value === '::' ||
            value === '0000:0000:0000:0000:0000:0000:0000:0000' ||
            value === '255.255.255.255' ||
            value.startsWith('192.0.2.') ||
            value.startsWith('198.51.100.') ||
            value.startsWith('203.0.113.') ||
            value.startsWith('169.254.')
        ) {
            return true;
        }

        // Проверка доменов
        if (!isValidIP(value)) {
            return EXCLUDED_DOMAINS.some(domain => value.includes(domain));
        }

        // Проверка CIDR диапазонов
        for (const cidr of EXCLUDED_IP_RANGES) {
            if (isIPInRangeCIDR(value, cidr)) {
                return true;
            }
        }

        return false;
    };

    // Функция для сохранения черного списка
    const saveBlacklist = (blacklist) => {
        localStorage.setItem(STORAGE_KEY, JSON.stringify(blacklist));
    };

    // Функция для добавления IP в список последних
    const addToRecentIPs = (ip) => {
        if (!isValidIP(ip) || isExcluded(ip)) {
            return;
        }

        let recentIPs = JSON.parse(localStorage.getItem(RECENT_IPS_KEY) || '[]');
        recentIPs = recentIPs.filter(existingIp => existingIp !== ip);
        recentIPs.push(ip);

        if (recentIPs.length > 10) {
            recentIPs = recentIPs.slice(-10);
        }

        localStorage.setItem(RECENT_IPS_KEY, JSON.stringify(recentIPs));
    };

    // Функция для принудительной очистки черного списка от исключенных IP
    const forceCleanBlacklist = () => {
        let blacklist = getBlacklist();
        const originalLength = blacklist.length;

        const cleanedBlacklist = blacklist.filter(ip => {
            if (isExcluded(ip)) {
                return false;
            }
            return isValidIP(ip);
        });

        if (cleanedBlacklist.length !== originalLength) {
            saveBlacklist(cleanedBlacklist);
        }

        return cleanedBlacklist;
    };

    // Функция для отображения сообщения
    const showMessage = (text, backgroundColor = 'red', textColor = 'white') => {
        document.querySelectorAll('.blocker-message').forEach(msg => msg.remove());

        const message = document.createElement('div');
        message.className = 'blocker-message';
        Object.assign(message.style, {
            position: 'fixed',
            bottom: '20px',
            left: '20px',
            padding: '15px 25px',
            backgroundColor: backgroundColor,
            color: textColor,
            borderRadius: '5px',
            fontSize: '18px',
            fontWeight: 'bold',
            zIndex: 10000,
            boxShadow: '0 4px 8px rgba(0,0,0,0.3)',
            transition: 'opacity 0.5s ease-out'
        });
        message.textContent = text;

        document.body.appendChild(message);

        setTimeout(() => {
            message.style.opacity = '0';
            setTimeout(() => {
                if (message.parentNode) {
                    message.parentNode.removeChild(message);
                }
            }, 500);
        }, backgroundColor === 'orange' ? 6000 : 6000);
    };

    // Функция для извлечения IP из ICE кандидата
    const extractIPFromCandidate = (candidate) => {
        const regex = /([0-9]{1,3}(\.[0-9]{1,3}){3})/;
        const match = candidate.match(regex);
        return match ? match[0] : null;
    };

    // Функция для извлечения IPv4 из IPv6 адресов
    const extractIPv4FromIPv6 = (ipv6) => {
        const ipv4MappedRegex = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/;
        const mappedMatch = ipv6.match(ipv4MappedRegex);
        if (mappedMatch) return mappedMatch[1];

        const ipv4CompatRegex = /^::(\d+\.\d+\.\d+\.\d+)$/;
        const compatMatch = ipv6.match(ipv4CompatRegex);
        if (compatMatch) return compatMatch[1];

        const nat64Regex = /^64:ff9b::(\d+\.\d+\.\d+\.\d+)$/;
        const nat64Match = ipv6.match(nat64Regex);
        if (nat64Match) return nat64Match[1];

        return null;
    };

    // Функция проверки блокировки IP
    const shouldBlockIP = (ip) => {
        if (!ip || typeof ip !== 'string') {
            return false;
        }

        // Сначала проверяем исключения
        if (isExcluded(ip)) {
            return false;
        }

        const blacklist = getBlacklist();

        if (!ip.includes(':')) {
            return blacklist.includes(ip);
        }

        const extractedIPv4 = extractIPv4FromIPv6(ip);
        if (extractedIPv4) {
            return blacklist.includes(extractedIPv4);
        }

        return false;
    };

    // Функция для поиска и клика по кнопке ДАЛЬШЕ
    const clickNextButton = () => {
        // Основной селектор для кнопки ДАЛЬШЕ на chatroulett.ru
        const nextButton = document.querySelector('button.btn.btn-primary.btn-lg.d-block.w-100.fs-2.px-0.py-3.py-lg-5');
        if (nextButton) {
            // Сначала снимаем disabled если есть
            if (nextButton.disabled) {
                nextButton.disabled = false;
            }
            nextButton.click();
            return true;
        }

        // Альтернативные селекторы для кнопки ДАЛЬШЕ
        const alternativeSelectors = [
            'button[class*="next"]',
            'button[class*="primary"]',
            '.next-btn',
            '[class*="next"]'
        ];

        for (const selector of alternativeSelectors) {
            const button = document.querySelector(selector);
            if (button) {
                if (button.disabled) {
                    button.disabled = false;
                }
                button.click();
                return true;
            }
        }

        return false;
    };

    // Наблюдатель за кнопкой ДАЛЬШЕ - снимает disabled если он появляется
    const observeNextButton = () => {
        const observer = new MutationObserver((mutations) => {
            const nextButton = document.querySelector('button.btn.btn-primary.btn-lg.d-block.w-100.fs-2.px-0.py-3.py-lg-5');
            if (nextButton && nextButton.disabled) {
                nextButton.disabled = false;
            }

            // Также проверяем альтернативные кнопки
            const alternativeButtons = document.querySelectorAll('button[class*="next"], button[class*="primary"]');
            alternativeButtons.forEach(button => {
                if (button.disabled) {
                    button.disabled = false;
                }
            });
        });

        // Начинаем наблюдение за изменениями атрибутов и поддерева
        observer.observe(document.body, {
            childList: true,
            subtree: true,
            attributes: true,
            attributeFilter: ['disabled', 'class']
        });

        return observer;
    };

    // Функция анализа SDP
    const analyzeSDP = (sdp) => {
        const foundIPs = new Set();
        if (!sdp) return foundIPs;

        const ipv4Regex = /\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g;

        const matches = sdp.match(ipv4Regex);
        if (matches) {
            matches.forEach(ip => {
                if (isValidIP(ip) && !isExcluded(ip)) {
                    foundIPs.add(ip);
                }
            });
        }

        return foundIPs;
    };

    // Создание кнопки блокировки
    const createButton = () => {
        const banButton = document.createElement('button');
        Object.assign(banButton.style, {
            position: 'fixed',
            top: '50px',
            left: '45px',
            width: '120px',
            height: '120px',
            borderRadius: '50%',
            backgroundColor: 'red',
            color: 'white',
            border: 'none',
            cursor: 'pointer',
            zIndex: 9999,
            fontSize: '12px',
            fontWeight: 'bold',
            boxShadow: '0 4px 8px rgba(0,0,0,0.3)'
        });
        banButton.textContent = 'BAN';
        banButton.title = 'Заблокировать текущего собеседника';
        document.body.appendChild(banButton);
        return banButton;
    };

    // Основная функция инициализации
    const init = () => {
        console.log('Chatroulett WebRTC Blocker initialized');

        // Принудительно очищаем черный список от исключенных IP
        forceCleanBlacklist();

        const banButton = createButton();
        let activeConnections = [];
        let nextButtonObserver = null;

        // Запускаем наблюдатель за кнопкой ДАЛЬШЕ
        nextButtonObserver = observeNextButton();

        // Перехват RTCPeerConnection
        const OriginalRTCPeerConnection = window.RTCPeerConnection ||
            window.webkitRTCPeerConnection ||
            window.mozRTCPeerConnection;

        if (OriginalRTCPeerConnection) {
            const createBlockedError = (ip) => {
                const error = new Error(`Connection blocked: IP ${ip} in blacklist`);
                error.name = 'BlockedConnectionError';
                return error;
            };

            window.RTCPeerConnection = function(...args) {
                const pc = new OriginalRTCPeerConnection(...args);

                // Перехват setRemoteDescription
                const originalSetRemoteDescription = pc.setRemoteDescription.bind(pc);
                pc.setRemoteDescription = function(description) {
                    if (description && description.sdp) {
                        const foundIPs = analyzeSDP(description.sdp);
                        for (const ip of foundIPs) {
                            if (shouldBlockIP(ip)) {
                                showMessage('Блокировка: ' + ip, 'orange', 'white');
                                pc.close();
                                setTimeout(clickNextButton, 100);
                                return Promise.reject(createBlockedError(ip));
                            }
                        }
                    }
                    return originalSetRemoteDescription(description);
                };

                // Перехват addIceCandidate
                const originalAddIceCandidate = pc.addIceCandidate.bind(pc);
                pc.addIceCandidate = function(candidate) {
                    if (candidate && candidate.candidate) {
                        const ip = extractIPFromCandidate(candidate.candidate);
                        if (ip && shouldBlockIP(ip)) {
                            showMessage('Блокировка: ' + ip, 'orange', 'white');
                            pc.close();
                            setTimeout(clickNextButton, 100);
                            return Promise.reject(createBlockedError(ip));
                        }
                    }
                    return originalAddIceCandidate(candidate);
                };

                // Отслеживание активных соединений
                pc.addEventListener('connectionstatechange', () => {
                    if (['closed', 'disconnected', 'failed'].includes(pc.connectionState)) {
                        const index = activeConnections.indexOf(pc);
                        if (index !== -1) activeConnections.splice(index, 1);
                    }
                });

                activeConnections.push(pc);
                return pc;
            };

            // Копируем прототип
            Object.setPrototypeOf(window.RTCPeerConnection, OriginalRTCPeerConnection);
            window.RTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
        }

        // Обработчик клика по кнопке блокировки
        banButton.addEventListener('click', () => {
            let currentBlacklist = getBlacklist();
            let foundIPs = new Set();
            let alreadyBlockedIPs = new Set();
            let newBlockedIPs = []; // Массив для новых заблокированных IP

            // Анализ активных соединений
            for (const pc of activeConnections) {
                try {
                    if (pc.remoteDescription && pc.remoteDescription.sdp) {
                        const sdpIPs = analyzeSDP(pc.remoteDescription.sdp);
                        sdpIPs.forEach(ip => {
                            if (shouldBlockIP(ip)) {
                                alreadyBlockedIPs.add(ip);
                            } else if (!isExcluded(ip)) {
                                foundIPs.add(ip);
                            }
                        });
                    }
                } catch (e) {
                    // Игнорируем ошибки анализа
                }
            }

            // Добавление новых IP в черный список
            let addedCount = 0;
            if (foundIPs.size > 0) {
                foundIPs.forEach(ip => {
                    if (!currentBlacklist.includes(ip)) {
                        currentBlacklist.push(ip);
                        newBlockedIPs.push(ip); // Добавляем IP в массив
                        addedCount++;
                        addToRecentIPs(ip);
                    }
                });

                if (addedCount > 0) {
                    saveBlacklist(currentBlacklist);

                    // Показываем IP через запятую
                    if (newBlockedIPs.length <= 3) {
                        // Если IP мало, показываем все
                        showMessage(`Добавлено ${addedCount} IP: ${newBlockedIPs.join(', ')}`, 'green', 'white');
                    } else {
                        // Если IP много, показываем количество и первые несколько
                        showMessage(`Добавлено ${addedCount} IP: ${newBlockedIPs.slice(0, 3).join(', ')}...`, 'green', 'white');
                    }

                    // Закрываем все соединения
                    activeConnections.forEach(pc => pc.close());
                    activeConnections = [];
                }
            }

            // Обработка уже заблокированных IP
            if (alreadyBlockedIPs.size > 0 && addedCount === 0) {
                const blockedList = Array.from(alreadyBlockedIPs);
                if (blockedList.length <= 3) {
                    showMessage(`Уже в списке блокировки: ${blockedList.join(', ')}`, 'orange', 'white');
                } else {
                    showMessage(`Уже в списке блокировки: ${blockedList.slice(0, 3).join(', ')}...`, 'orange', 'white');
                }
                activeConnections.forEach(pc => pc.close());
                activeConnections = [];
            }

            // Переход к следующему собеседнику
            clickNextButton();
        });
    };

    // Запуск инициализации
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        setTimeout(init, 1000);
    }
})();

const EXCLUDED_IP_RANGES = [
    '127.0.0.1/32',
    '10.0.0.0/8',
    '172.16.0.0/12',
    // ...
];