1
// 替换成你想镜像的站点
2
const upstream = 'example.com'
3

4
// 如果那个站点有专门的移动适配站点，否则保持和上面一致
5
const upstream_mobile = 'example.com'
6

7
// 你希望禁止哪些国家访问
8
const blocked_region = ['KP']
9

10
// 禁止自访问
11
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']
12

13
// 替换成你想镜像的站点
14
const replace_dict = {
15
    '$upstream': '$custom_domain',
16
    '//google.com': ''
17
}
18

19
//以下内容都不用动
20
addEventListener('fetch', event => {
21
    event.respondWith(fetchAndApply(event.request));
22
})
23

24
async function fetchAndApply(request) {
25

26
    const region = request.headers.get('cf-ipcountry').toUpperCase();
27
    const ip_address = request.headers.get('cf-connecting-ip');
28
    const user_agent = request.headers.get('user-agent');
29

30
    let response = null;
31
    let url = new URL(request.url);
32
    let url_host = url.host;
33

34
    if (url.protocol == 'http:') {
35
        url.protocol = 'https:'
36
        response = Response.redirect(url.href);
37
        return response;
38
    }
39

40
    if (await device_status(user_agent)) {
41
        upstream_domain = upstream
42
    } else {
43
        upstream_domain = upstream_mobile
44
    }
45

46
    url.host = upstream_domain;
47

48
    if (blocked_region.includes(region)) {
49
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
50
            status: 403
51
        });
52
    } else if(blocked_ip_address.includes(ip_address)){
53
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
54
            status: 403
55
        });
56
    } else{
57
        let method = request.method;
58
        let request_headers = request.headers;
59
        let new_request_headers = new Headers(request_headers);
60

61
        new_request_headers.set('Host', upstream_domain);
62
        new_request_headers.set('Referer', url.href);
63

64
        let original_response = await fetch(url.href, {
65
            method: method,
66
            headers: new_request_headers
67
        })
68

69
        let original_response_clone = original_response.clone();
70
        let original_text = null;
71
        let response_headers = original_response.headers;
72
        let new_response_headers = new Headers(response_headers);
73
        let status = original_response.status;
74

75
        new_response_headers.set('access-control-allow-origin', '*');
76
        new_response_headers.set('access-control-allow-credentials', true);
77
        new_response_headers.delete('content-security-policy');
78
        new_response_headers.delete('content-security-policy-report-only');
79
        new_response_headers.delete('clear-site-data');
80

81
        const content_type = new_response_headers.get('content-type');
82
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
83
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_host);
84
        } else {
85
            original_text = original_response_clone.body
86
        }
87

88
        response = new Response(original_text, {
89
            status,
90
            headers: new_response_headers
91
        })
92
    }
93
    return response;
94
}
95

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

99
    var i, j;
100
    for (i in replace_dict) {
101
        j = replace_dict[i]
102
        if (i == '$upstream') {
103
            i = upstream_domain
104
        } else if (i == '$custom_domain') {
105
            i = host_name
106
        }
107

108
        if (j == '$upstream') {
109
            j = upstream_domain
110
        } else if (j == '$custom_domain') {
111
            j = host_name
112
        }
113

114
        let re = new RegExp(i, 'g')
115
        text = text.replace(re, j);
116
    }
117
    return text;
118
}
119

120
async function device_status (user_agent_info) {
121
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
122
    var flag = true;
123
    for (var v = 0; v < agents.length; v++) {
124
        if (user_agent_info.indexOf(agents[v]) > 0) {
125
            flag = false;
126
            break;
127
        }
128
    }
129
    return flag;
130
}

1
// 替换成你想镜像的站点
2
const upstream = 'google.com'
3

4
// 如果那个站点有专门的移动适配站点，否则保持和上面一致
5
const upstream_mobile = 'm.google.com'
6

7
// 密码访问
8

9
const openAuth = false
10
const username = 'username'
11
const password = 'password'
12

13
// 你希望禁止哪些国家访问
14
const blocked_region = ['KP']
15

16
// 禁止自访问
17
const blocked_ip_address = ['0.0.0.0', '127.0.0.1']
18

19
// 替换成你想镜像的站点
20
const replace_dict = {
21
    '$upstream': '$custom_domain',
22
    '//google.com': ''
23
}
24

25
function unauthorized() {
26
  return new Response('Unauthorized', {
27
    headers: {
28
      'WWW-Authenticate': 'Basic realm="goindex"',
29
      'Access-Control-Allow-Origin': '*'
30
    },
31
    status: 401
32
  });
33
}
34

35
function parseBasicAuth(auth) {
36
    try {
37
      return atob(auth.split(' ').pop()).split(':');
38
    } catch (e) {
39
      return [];
40
    }
41
}
42

43
function doBasicAuth(request) {
44
  const auth = request.headers.get('Authorization');
45

46
  if (!auth || !/^Basic [A-Za-z0-9._~+/-]+=*$/i.test(auth)) {
47
    return false;
48
  }
49

50
  const [user, pass] = parseBasicAuth(auth);
51
  return user === username && pass === password;
52
}
53

54

55
async function fetchAndApply(request) {
56
  if (request.method === 'OPTIONS') // allow preflight request
57
    return new Response('', {
58
      status: 200,
59
      headers: {
60
        'Access-Control-Allow-Origin': '*',
61
        'Access-Control-Allow-Headers': '*',
62
        'Access-Control-Allow-Methods': 'GET, POST, PUT, HEAD, OPTIONS'
63
      }
64
    });
65

66
  if (openAuth && !doBasicAuth(request)) {
67
    return unauthorized();
68
  }
69
    const region = request.headers.get('cf-ipcountry').toUpperCase();
70
    const ip_address = request.headers.get('cf-connecting-ip');
71
    const user_agent = request.headers.get('user-agent');
72

73
    let response = null;
74
    let url = new URL(request.url);
75
    let url_host = url.host;
76

77
    if (url.protocol == 'http:') {
78
        url.protocol = 'https:'
79
        response = Response.redirect(url.href);
80
        return response;
81
    }
82

83
    if (await device_status(user_agent)) {
84
        upstream_domain = upstream
85
    } else {
86
        upstream_domain = upstream_mobile
87
    }
88

89
    url.host = upstream_domain;
90

91
    if (blocked_region.includes(region)) {
92
        response = new Response('Access denied: WorkersProxy is not available in your region yet.', {
93
            status: 403
94
        });
95
    } else if(blocked_ip_address.includes(ip_address)){
96
        response = new Response('Access denied: Your IP address is blocked by WorkersProxy.', {
97
            status: 403
98
        });
99
    } else{
100
        let method = request.method;
101
        let request_headers = request.headers;
102
        let new_request_headers = new Headers(request_headers);
103

104
        new_request_headers.set('Host', upstream_domain);
105
        new_request_headers.set('Referer', url.href);
106

107
        let original_response = await fetch(url.href, {
108
            method: method,
109
            headers: new_request_headers
110
        })
111

112
        let original_response_clone = original_response.clone();
113
        let original_text = null;
114
        let response_headers = original_response.headers;
115
        let new_response_headers = new Headers(response_headers);
116
        let status = original_response.status;
117

118
        new_response_headers.set('access-control-allow-origin', '*');
119
        new_response_headers.set('access-control-allow-credentials', true);
120
        new_response_headers.delete('content-security-policy');
121
        new_response_headers.delete('content-security-policy-report-only');
122
        new_response_headers.delete('clear-site-data');
123

124
        const content_type = new_response_headers.get('content-type');
125
        if (content_type.includes('text/html') && content_type.includes('UTF-8')) {
126
            original_text = await replace_response_text(original_response_clone, upstream_domain, url_host);
127
        } else {
128
            original_text = original_response_clone.body
129
        }
130

131
        response = new Response(original_text, {
132
            status,
133
            headers: new_response_headers
134
        })
135
    }
136
    return response;
137
}
138

139
addEventListener('fetch', event => {
140
    event.respondWith(fetchAndApply(event.request).catch(err => {
141
      console.error(err);
142
      new Response(JSON.stringify(err.stack), {
143
        status: 500,
144
        headers: {
145
          'Content-Type': 'application/json'
146
        }
147
      });
148
    }));
149
})
150

151

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

155
    var i, j;
156
    for (i in replace_dict) {
157
        j = replace_dict[i]
158
        if (i == '$upstream') {
159
            i = upstream_domain
160
        } else if (i == '$custom_domain') {
161
            i = host_name
162
        }
163

164
        if (j == '$upstream') {
165
            j = upstream_domain
166
        } else if (j == '$custom_domain') {
167
            j = host_name
168
        }
169

170
        let re = new RegExp(i, 'g')
171
        text = text.replace(re, j);
172
    }
173
    return text;
174
}
175

176
async function device_status (user_agent_info) {
177
    var agents = ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"];
178
    var flag = true;
179
    for (var v = 0; v < agents.length; v++) {
180
        if (user_agent_info.indexOf(agents[v]) > 0) {
181
            flag = false;
182
            break;
183
        }
184
    }
185
    return flag;
186
}