免责声明与用户协议

1. 性质与目的

本项目是一个开源的、非盈利的技术演示项目，旨在仅限于技术研究、学习和合法的开发测试用途。本项目不提供任何形式的服务等级协议或可用性保证。

2. 用户责任与行为约束

您（用户）明确理解并同意：

• 责任自负原则：您对使用、部署、修改或分发本脚本的全部行为及其直接或间接后果承担独立且全部的法律责任。
• 合法性保证：您必须确保您的使用行为完全符合您所在国家/地区的所有适用法律法规。特别是对于中华人民共和国境内的用户，您承诺严格遵守，包括但不限于：
  • 《中华人民共和国网络安全法》
  • 《中华人民共和国数据安全法》
  • 《中华人民共和国个人信息保护法》
  • 以及其他关于互联网信息服务的所有规范性文件。
• 禁止性行为：您严禁将本项目用于任何非法目的，包括但不限于：
  • 绕过网络访问控制，访问被禁止的或非法的内容。
  • 实施网络攻击、扫描、入侵或破坏他人系统。
  • 窃取、泄露、篡改或损害任何数据与个人信息。
  • 进行任何危害国家安全、社会稳定、公共利益的行为。
  • 从事任何商业性的代理服务。

3. 开发者免责

开发者（本项目贡献者）在此明确声明：

• 不提供担保：本项目按“现状”和“现有”基础提供，不提供任何明示或默示的担保，包括但不限于对适销性、特定用途适用性及不侵权的担保。
• 不承担责任：在任何情况下，开发者均不对任何因使用或无法使用本项目而引起的任何索赔、损害或其他责任（包括直接的、间接的、特殊的、附带的或后果性的损害）承担责任，无论该等责任是基于合同、侵权（包括过失）或其他原因。
• 无监控义务：开发者不监控、管理用户的使用行为，且对用户的具体使用情况不知情。

如果您不遵守本协议 请直接退出

以下正文

什么是cloudflare worker

Cloudflare Worker 是一个在全球范围内运行的“无服务器”计算平台。 它允许开发者将代码部署到 Cloudflare 遍布世界的 300 多个数据中心，并在离用户最近的地方执行，从而极快地响应请求。

部署教程

在开始之前我们首先需要一个cloudflare账号（不用绑卡）、一个域名（可以用一些支持cloudflare托管的免费域名）点击创建应用程序“计算和ai” workers和pages 创建应用程序

从hello word开始、部署

点击编辑代码并且粘贴如下代码

const TARGET_DOMAIN = 'example.com'; // 源站
const WORKER_DOMAIN = 'example.com'; // 替换为您的Worker域名
const SAFE_REDIRECT_DOMAIN = 'example.com'; // 替换为您希望重定向的安全域名（如果你的源站是一些比较大的网站 建议设置 配合屏蔽敏感路径和路径前缀等 如果你要套你的网站作为cdn的话建议改写满了域名设置 来让纠正网站地图的URL）

// XML域名替换配置
const XML_REPLACE_CONFIG = {
    oldDomain: 'gamma.app',
    newDomain: 'xxu.qzz.io'
};

// 需要精确屏蔽的敏感路径列表
const BLOCKED_PATHS = [

];

// 需要屏蔽的路径前缀
const BLOCKED_PATH_PREFIXES = [

];

// 免责声明HTML
const disclaimerHTML = `
</script>
`;

addEventListener('fetch', event => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const url = new URL(request.url);
    
    // 强制使用HTTPS
    if (url.protocol === 'http:') {
        url.protocol = 'https:';
        return Response.redirect(url.href, 301);
    }
    
    // 检查是否访问敏感路径
    if (isSensitivePath(url.pathname)) {
        // 记录访问日志
        console.log(`Blocked access to sensitive path: ${url.pathname} from IP: ${request.headers.get('cf-connecting-ip')}`);
        
        // 重定向到安全域名
        return Response.redirect(`https://${SAFE_REDIRECT_DOMAIN}`, 302);
    }
    
    // 构建目标URL
    const targetPath = url.pathname + url.search;
    const targetUrl = `https://${TARGET_DOMAIN}${targetPath}`;
    
    // 创建请求头
    const newHeaders = new Headers(request.headers);
    newHeaders.set('Host', TARGET_DOMAIN);
    newHeaders.set('X-Forwarded-Host', TARGET_DOMAIN);
    newHeaders.set('X-Forwarded-Proto', 'https');
    newHeaders.set('X-Forwarded-For', request.headers.get('cf-connecting-ip') || '');
    
    // 移除Cloudflare特定头
    const cfHeaders = [
        'cf-connecting-ip',
        'cf-ipcountry',
        'cf-ray',
        'cf-visitor',
        'cf-request-id'
    ];
    
    cfHeaders.forEach(header => newHeaders.delete(header));
    
    try {
        // 发起代理请求
        // DNS优选已在CNAME层面完成，这里直接使用目标域名
        const response = await fetch(targetUrl, {
            method: request.method,
            headers: newHeaders,
            body: request.method !== 'GET' && request.method !== 'HEAD' ? await request.clone().arrayBuffer() : undefined,
            redirect: 'manual'
        });
        
        // 处理响应
        return await processResponse(response, request);
    } catch (error) {
        return new Response(`Proxy Error: ${error.message}`, { 
            status: 502,
            headers: { 'Content-Type': 'text/plain' }
        });
    }
}

// 检查是否为敏感路径
function isSensitivePath(pathname) {
    // 检查完整路径匹配
    if (BLOCKED_PATHS.includes(pathname)) {
        return true;
    }
    
    // 检查路径前缀匹配
    for (const prefix of BLOCKED_PATH_PREFIXES) {
        if (pathname.startsWith(prefix)) {
            return true;
        }
    }
    
    // 特殊处理：根路径的变体
    if (pathname === '' || pathname === '/index.html' || pathname === '/index') {
        return true;
    }
    
    return false;
}

async function processResponse(response, originalRequest) {
    const responseHeaders = new Headers(response.headers);
    const originalUrl = new URL(originalRequest.url);
    
    // 设置CORS头
    responseHeaders.set('Access-Control-Allow-Origin', '*');
    responseHeaders.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
    responseHeaders.set('Access-Control-Allow-Headers', '*');
    
    // 移除可能引起问题的安全头
    const headersToRemove = [
        'content-security-policy',
        'content-security-policy-report-only',
        'x-frame-options',
        'strict-transport-security',
        'location'
    ];
    
    headersToRemove.forEach(header => responseHeaders.delete(header));
    
    // 处理重定向 - 确保重定向到代理地址
    if (response.status >= 300 && response.status < 400) {
        const location = response.headers.get('location');
        if (location) {
            // 检查重定向目标是否为敏感路径
            try {
                const redirectUrl = new URL(location, `https://${TARGET_DOMAIN}`);
                if (isSensitivePath(redirectUrl.pathname)) {
                    // 如果重定向到敏感路径，直接重定向到安全域名
                    responseHeaders.set('location', `https://${SAFE_REDIRECT_DOMAIN}`);
                } else {
                    // 将目标域名的重定向转换为代理域名的重定向
                    let newLocation = location;
                    
                    if (location.includes(TARGET_DOMAIN)) {
                        newLocation = location.replace(
                            `https://${TARGET_DOMAIN}`,
                            `https://${originalUrl.hostname}`
                        );
                    }
                    
                    responseHeaders.set('location', newLocation);
                }
            } catch (e) {
                // URL解析失败，使用原始重定向
                console.error('Failed to parse redirect URL:', e);
            }
        }
    }
    
    // 获取内容类型
    const contentType = responseHeaders.get('content-type') || '';
    const urlPath = originalUrl.pathname.toLowerCase();
    
    // 处理XML内容
    if (contentType.includes('application/xml') || 
        contentType.includes('text/xml') || 
        urlPath.endsWith('.xml') ||
        urlPath.endsWith('.rss') ||
        urlPath.endsWith('.atom')) {
        
        let text = await response.text();
        
        // 替换XML中的域名
        text = replaceXmlDomain(text);
        
        return new Response(text, {
            status: response.status,
            statusText: response.statusText,
            headers: responseHeaders
        });
    }
    
    if (contentType.includes('text/html')) {
        let text = await response.text();
        
        // 添加免责声明
        text = text.replace(/<body[^>]*>/i, `$&${disclaimerHTML}`);
        
        // 重写HTML中的URL
        text = rewriteUrls(text, originalUrl.hostname);
        
        return new Response(text, {
            status: response.status,
            statusText: response.statusText,
            headers: responseHeaders
        });
    }
    
    // 对于非HTML和XML内容，直接返回
    return new Response(response.body, {
        status: response.status,
        statusText: response.statusText,
        headers: responseHeaders
    });
}

// XML域名替换函数
function replaceXmlDomain(xmlContent) {
    const { oldDomain, newDomain } = XML_REPLACE_CONFIG;
    
    // 创建正则表达式，匹配所有出现的旧域名
    const regex = new RegExp(oldDomain.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
    
    // 执行替换
    return xmlContent.replace(regex, newDomain);
}

// URL重写函数
function rewriteUrls(content, workerHost) {
    // 重写绝对URL
    content = content.replace(
        new RegExp(`https?://${TARGET_DOMAIN}`, 'gi'),
        `https://${workerHost}`
    );
    
    // 重写协议相对URL (//github.com/path)
    content = content.replace(
        new RegExp(`//${TARGET_DOMAIN}`, 'gi'),
        `//${workerHost}`
    );
    
    return content;
}

// 健康检查端点
addEventListener('scheduled', event => {
    event.waitUntil(healthCheck());
});

async function healthCheck() {
    // 简单的健康检查，确保代理功能正常
    console.log('Running health check...');
    try {
        // 测试非敏感路径
        const response = await fetch(`https://${WORKER_DOMAIN}/explore`, {
            headers: { 'Host': TARGET_DOMAIN }
        });
        console.log(`Health check: ${response.status}`);
        
        // 测试敏感路径是否被正确屏蔽
        const sensitiveResponse = await fetch(`https://${WORKER_DOMAIN}/login`, {
            headers: { 'Host': TARGET_DOMAIN },
            redirect: 'manual'
        });
        
        if (sensitiveResponse.status === 302 && 
            sensitiveResponse.headers.get('location') === `https://${SAFE_REDIRECT_DOMAIN}`) {
            console.log('Sensitive path blocking: WORKING');
        } else {
            console.log('Sensitive path blocking: NOT WORKING');
        }
        
        // 测试XML替换功能
        const xmlTestResponse = await fetch(`https://${WORKER_DOMAIN}/test.xml`, {
            headers: { 'Host': TARGET_DOMAIN }
        });
        if (xmlTestResponse.status === 200) {
            const xmlContent = await xmlTestResponse.text();
            if (xmlContent.includes(XML_REPLACE_CONFIG.newDomain)) {
                console.log('XML domain replacement: WORKING');
            } else {
                console.log('XML domain replacement: NOT WORKING');
            }
        }
    } catch (error) {
        console.error('Health check failed:', error.message);
    }
}