反代

  • 网站代码(gpt的代码)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    export default {
      async fetch(request) {
        // 目标站点（在这里改成你想代理的地址）
        const target = "https://example.com";

        const url = new URL(request.url);
        const proxyUrl = target + url.pathname + url.search;

        // 构造新的请求头，避免部分头导致跨域或安全问题
        const newHeaders = new Headers(request.headers);
        newHeaders.set("Host", new URL(target).host);

        const newRequest = new Request(proxyUrl, {
          method: request.method,
          headers: newHeaders,
          body: request.method === "GET" || request.method === "HEAD" ? null : request.body,
          redirect: "follow"
        });

        const response = await fetch(newRequest);

        // 你也可以在这里对返回头进行处理
        const resHeaders = new Headers(response.headers);
        resHeaders.set("Access-Control-Allow-Origin", "*");

        return new Response(response.body, {
          status: response.status,
          headers: resHeaders
        });
      }
    };

  • 同上谷歌代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    export default {
      async fetch(request) {
        // 目标站点（在这里改成你想代理的地址）
        const target = "https://feichang99.github.io/";
        const targetUrl = new URL(target);

        // 1. 构造代理 URL
        const url = new URL(request.url);
        const proxyUrl = targetUrl.origin + url.pathname + url.search;

        // 2. 构造新的请求头，只复制不需要过滤的头，并设置 Host
        const newHeaders = new Headers();
        newHeaders.set("Host", targetUrl.host);

        // 复制原始请求头，排除敏感或可能导致问题的头
        for (const [key, value] of request.headers.entries()) {
          const lowerKey = key.toLowerCase();
          // 排除与 CF/IP/连接相关的头，以及 Cookie 等
          if (!lowerKey.startsWith('cf-') && !['host', 'cookie', 'connection', 'x-forwarded-for', 'x-real-ip'].includes(lowerKey)) {
            newHeaders.set(key, value);
          }
        }

        // 3. 处理请求 Body
        const hasBody = !['GET', 'HEAD'].includes(request.method.toUpperCase());

        const newRequest = new Request(proxyUrl, {
          method: request.method,
          headers: newHeaders,
          body: hasBody ? request.body : null,
          redirect: "follow"
        });

        const response = await fetch(newRequest);

        // 4. 处理响应头
        const resHeaders = new Headers(response.headers);

        // 移除 X-Frame-Options, Content-Security-Policy 等可能阻碍代理嵌入的头 (按需)
        resHeaders.delete("x-frame-options");
        resHeaders.delete("content-security-policy");

        // 强制添加 CORS 头
        resHeaders.set("Access-Control-Allow-Origin", "*");
        resHeaders.set("Access-Control-Allow-Methods", "*");
        resHeaders.set("Access-Control-Allow-Headers", "*");


        return new Response(response.body, {
          status: response.status,
          headers: resHeaders
        });
      }
    };

  • 网页代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    addEventListener('fetch', event => {
      event.respondWith(handleRequest(event.request))
    })

    // HTML代码
    let html = `
    <!DOCTYPE html>
    <html>
      <head><title>Test</title></head>
      <body><div>Hello world!</div></body>
    </html>
    `;

    /**
     * Respond to the request
     * @param {Request} request
     */
    async function handleRequest(request) {
      return new Response(html, {
        headers: {
          'Content-Type': 'text/html; charset=UTF-8'
        },
        status: 200
      })
    }

    来源….

代理 Google 站点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
// 反代目标网站
const upstream = 'ipv6.google.com.hk'
const upstream_v4 = 'www.google.com.hk'

// 访问区域黑名单（按需设置）.
const blocked_region = ['TK']

//资源重定向
const replace_dict = {
  $upstream: '$custom_domain',
  'www.google.com/': '你的域名/', //填入你的子域名，保留最后面的/
  'gstatic.com': 'gstatic.cn',
  'ajax.googleapis.com': 'ajax.lug.ustc.edu.cn',
  'fonts.googleapis.com': 'fonts.googleapis.cn',
  'themes.googleusercontent.com': 'google-themes.lug.ustc.edu.cn',
  'www.gravatar.com/avatar': 'dn-qiniu-avatar.qbox.me/avatar',
  'www.google.co.jp': '$custom_domain',
  'www.google.com.sg': '$custom_domain',
  'books.google.com.hk': '$custom_domain',
  'books.google.co.jp': '$custom_domain',
  'books.google.com.sg': '$custom_domain',
  'maps.google.com.hk': '$custom_domain',
  'maps.google.co.jp': '$custom_domain',
  'maps.google.com.sg': '$custom_domain',
  'maps.google.com': '$custom_domain',
  'books.google.com': '$custom_domain',
}

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

async function fetchAndApply(request) {
  const region = request.headers.get('cf-ipcountry').toUpperCase()
//   const ip_address = request.headers.get('cf-connecting-ip')
//   const user_agent = request.headers.get('user-agent')

  let response = null
  let url = new URL(request.url)
  let url_host = url.host

  if (url.protocol == 'http:') {
    url.protocol = 'https:'
    response = Response.redirect(url.href)
    return response
  }

  //检查是否为图片搜索
  var key = url.href
  var ikey1 = 'tbm=isch'
  var ikey2 = '/img'
  if ((key.search(ikey1) == -1) && (key.search(ikey2) == -1)) {
    var upstream_domain = upstream
  } else {
    var upstream_domain = upstream_v4
  }

  url.host = upstream_domain

  if (blocked_region.includes(region)) {
    response = new Response(
      'Access denied: WorkersProxy is not available in your region yet.',
      {
        status: 403,
      }
    )
  } else {
    let method = request.method
    let request_headers = request.headers
    let new_request_headers = new Headers(request_headers)

    new_request_headers.set('Host', upstream_domain)
    new_request_headers.set('Referer', url.href)

    let original_response = await fetch(url.href, {
      method: method,
      headers: new_request_headers,
    })

    let original_response_clone = original_response.clone()
    let original_text = null
    let response_headers = original_response.headers
    let new_response_headers = new Headers(response_headers)
    let status = original_response.status

    new_response_headers.set('cache-control', 'public, max-age=14400')
    new_response_headers.set('access-control-allow-origin', '*')
    new_response_headers.set('access-control-allow-credentials', true)
    new_response_headers.delete('content-security-policy')
    new_response_headers.delete('content-security-policy-report-only')
    new_response_headers.delete('clear-site-data')

    const content_type = new_response_headers.get('content-type')
    if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
      // && content_type.includes('UTF-8')
      original_text = await replace_response_text(
        original_response_clone,
        upstream_domain,
        url_host
      )
    } else {
      original_text = original_response_clone.body
    }

    response = new Response(original_text, {
      status,
      headers: new_response_headers,
    })
  }
  return response
}

async function replace_response_text(response, upstream_domain, host_name) {
  let text = await response.text()

  var i, j
  for (i in replace_dict) {
    j = replace_dict[i]
    if (i == '$upstream') {
      i = upstream_domain
    } else if (i == '$custom_domain') {
      i = host_name
    }

    if (j == '$upstream') {
      j = upstream_domain
    } else if (j == '$custom_domain') {
      j = host_name
    }

    let re = new RegExp(i, 'g')
    text = text.replace(re, j)
  }

  return text
}