在hexo-next配置gitalk

1
## ---------------------------------------------------------------
2
## Comments Settings
3
## See: https://theme-next.org/docs/third-party-services/comments
4
## ---------------------------------------------------------------
5

6
## Multiple Comment System Support
7
comments:
8
  #use: Valine
9
  text: true
10
  # Available values: tabs | buttons
11
  style: tabs
12
  count: true
13
  # Choose a comment system to be displayed by default.
14
  # Available values: changyan | disqus | disqusjs | gitalk | livere | valine
15
  active: gitalk
16
  # Setting `true` means remembering the comment system selected by the visitor.
17
  storage: true
18
  # Lazyload all comment systems.
19
  lazyload: false
20
  # Modify texts or order for any navs, here are some examples.
21
  nav:
22
    gitalk:
23
     order: -1
24
    #disqus:
25
    #  text: Load Disqus
26
    #  order: -1
27
    #gitalk:
28
    #  order: -2

1
## Gitalk
2
## For more information: https://gitalk.github.io, https://github.com/gitalk/gitalk
3
gitalk:
4
  enable: true
5
  github_id: xingwangzhe
6
  repo: xingwangzhe.github.io
7
  client_id: sdaf # OAuth app的
8
  client_secret: asdfghjgds #同上
9
  admin_user: xingwangzhe
10
  distraction_free_mode: true # Facebook-like distraction free mode
11
  # Gitalk's display language depends on user's browser or system environment
12
  # If you want everyone visiting your site to see a uniform language, you can set a force language value
13
  # Available values: en | es-ES | fr | ru | zh-CN | zh-TW
14
  language: zh-CN
15
  proxy: 'https://cors-anywhere.xingwangzhe.workers.dev/https://github.com/login/oauth/access_token'
16
  #worker，请记住这段链接，接下来要用到

1
const exclude = [];     // Regexp for blacklisted urls
2
const include = [/^https?:\/\/.*xingwangzhe\.github\.io$/, /^https?:\/\/localhost/]; // Regexp for whitelisted origins e.g.
3
const apiKeys = {
4
  EZWTLwVEqFnaycMzdhBz: {
5
    name: 'Test App',
6
    expired: false,
7
    exclude: [], // Regexp for blacklisted urls
8
    include: ["^http.?://xingwangzhe.github.io$", "xingwangzhe.github.io$", "^https?://localhost/"], // Regexp for whitelisted origins
9
  },
10
};
11

12
// Config is all above this line.
13
// It should not be necessary to change anything below.
14

15
function verifyCredentials(request) {
16
  // Throws exception on verification failure.
17
  const requestApiKey = request.headers.get('x-cors-proxy-api-key');
18
  if (!Object.keys(apiKeys).includes(requestApiKey)) {
19
    throw new UnauthorizedException('Invalid authorization key.');
20
  }
21

22
  if (apiKeys[requestApiKey].expired) {
23
    throw new UnauthorizedException('Expired authorization key.');
24
  }
25

26
  if (apiKeys[requestApiKey].expiresAt && apiKeys[requestApiKey].expiresAt.getTime() < Date.now()) {
27
    throw new UnauthorizedException(`Expired authorization key.\nKey was valid until: ${apiKeys[requestApiKey].expiresAt}`);
28
  }
29

30
  return apiKeys[requestApiKey];
31
}
32

33
function checkRequiredHeadersPresent(request) {
34
  // Throws exception on verification failure.
35
  if (!request.headers.get('Origin') && !request.headers.get('x-requested-with')) {
36
    throw new BadRequestException('Missing required request header. Must specify one of: origin,x-requested-with');
37
  }
38
}
39

40
function UnauthorizedException(reason) {
41
  this.status = 401;
42
  this.statusText = 'Unauthorized';
43
  this.reason = reason;
44
}
45

46
function BadRequestException(reason) {
47
  this.status = 400;
48
  this.statusText = 'Bad Request';
49
  this.reason = reason;
50
}
51

52
function isListed(uri, listing) {
53
  let returnValue = false;
54
  console.log(uri);
55
  if (typeof uri === 'string') {
56
    for (const m of listing) {
57
      if (uri.match(m) !== null) {
58
        returnValue = true;
59
      }
60
    }
61
  } else { //   Decide what to do when Origin is null
62
    returnValue = true; // True accepts null origins false rejects them.
63
  }
64

65
  return returnValue;
66
}
67

68
function fix(myHeaders, request, isOPTIONS) {
69
  myHeaders.set('Access-Control-Allow-Origin', request.headers.get('Origin'));
70
  if (isOPTIONS) {
71
    myHeaders.set('Access-Control-Allow-Methods', request.headers.get('access-control-request-method'));
72
    const acrh = request.headers.get('access-control-request-headers');
73

74
    if (acrh) {
75
      myHeaders.set('Access-Control-Allow-Headers', acrh);
76
    }
77

78
    myHeaders.delete('X-Content-Type-Options');
79
  }
80

81
  return myHeaders;
82
}
83

84
function parseURL(requestUrl) {
85
  const match = requestUrl.match(/^(?:(https?:)?\/\/)?(([^/?]+?)(?::(\d{0,5})(?=[/?]|$))?)([/?][\S\s]*|$)/i);
86
  //                              ^^^^^^^          ^^^^^^^^      ^^^^^^^                ^^^^^^^^^^^^
87
  //                            1:protocol       3:hostname     4:port                 5:path + query string
88
  //                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
89
  //                                            2:host
90

91
  if (!match) {
92
    console.log('no match');
93
    throw new BadRequestException('Invalid URL for proxy request.');
94
  }
95

96
  console.log('parseURL:match:', match);
97

98
  if (!match[1]) {
99
    console.log('nothing in match group 1');
100
    if (/^https?:/i.test(requestUrl)) {
101
      console.log('The pattern at top could mistakenly parse "http:///" as host="http:" and path=///.');
102
      throw new BadRequestException('Invalid URL for proxy request.');
103
    }
104

105
    // Scheme is omitted.
106
    if (requestUrl.lastIndexOf('//', 0) === -1) {
107
      console.log('"//" is omitted');
108
      requestUrl = '//' + requestUrl;
109
    }
110

111
    requestUrl = (match[4] === '443' ? 'https:' : 'http:') + requestUrl;
112
  }
113

114
  const parsed = new URL(requestUrl);
115
  if (!parsed.hostname) {
116
    console.log('"http://:1/" and "http:/notenoughslashes" could end up here.');
117
    throw new BadRequestException('Invalid URL for proxy request.');
118
  }
119

120
  return parsed;
121
}
122

123
async function proxyRequest(request, activeApiKey) {
124
  const isOPTIONS = (request.method === 'OPTIONS');
125
  const originUrl = new URL(request.url);
126
  const origin = request.headers.get('Origin');
127
  // ParseURL throws when the url is invalid
128
  const fetchUrl = parseURL(request.url.replace(originUrl.origin, '').slice(1));
129

130
  // Throws if it fails the check
131
  checkRequiredHeadersPresent(request);
132

133
  // Excluding urls which are not allowed as destination urls
134
  // Exclude origins which are not int he included ones
135
  if (isListed(fetchUrl.toString(), [...exclude, ...(activeApiKey?.exclude || [])]) || !isListed(origin, [...include, ...(activeApiKey?.include || [])])) {
136
    throw new BadRequestException('Origin or Destination URL is not allowed.');
137
  }
138

139
  let corsHeaders = request.headers.get('x-cors-headers');
140

141
  if (corsHeaders !== null) {
142
    try {
143
      corsHeaders = JSON.parse(corsHeaders);
144
    } catch {}
145
  }
146

147
  if (!originUrl.pathname.startsWith('/')) {
148
    throw new BadRequestException('Pathname does not start with "/"');
149
  }
150

151
  const recvHpaireaders = {};
152
  for (const pair of request.headers.entries()) {
153
    if ((pair[0].match('^origin') === null)
154
        && (pair[0].match('eferer') === null)
155
        && (pair[0].match('^cf-') === null)
156
        && (pair[0].match('^x-forw') === null)
157
        && (pair[0].match('^x-cors-headers') === null)
158
    ) {
159
      recvHpaireaders[pair[0]] = pair[1];
160
    }
161
  }
162

163
  if (corsHeaders !== null) {
164
    for (const c of Object.entries(corsHeaders)) {
165
      recvHpaireaders[c[0]] = c[1];
166
    }
167
  }
168

169
  const newRequest = new Request(request, {
170
    headers: recvHpaireaders,
171
  });
172

173
  const response = await fetch(fetchUrl, newRequest);
174
  let myHeaders = new Headers(response.headers);
175
  const newCorsHeaders = [];
176
  const allh = {};
177
  for (const pair of response.headers.entries()) {
178
    newCorsHeaders.push(pair[0]);
179
    allh[pair[0]] = pair[1];
180
  }
181

182
  newCorsHeaders.push('cors-received-headers');
183
  myHeaders = fix(myHeaders, request, isOPTIONS);
184

185
  myHeaders.set('Access-Control-Expose-Headers', newCorsHeaders.join(','));
186

187
  myHeaders.set('cors-received-headers', JSON.stringify(allh));
188

189
  const body = isOPTIONS ? null : await response.arrayBuffer();
190

191
  return new Response(body, {
192
    headers: myHeaders,
193
    status: (isOPTIONS ? 200 : response.status),
194
    statusText: (isOPTIONS ? 'OK' : response.statusText),
195
  });
196
}
197

198
function homeRequest(request) {
199
  const isOPTIONS = (request.method === 'OPTIONS');
200
  const originUrl = new URL(request.url);
201
  const origin = request.headers.get('Origin');
202
  const remIp = request.headers.get('CF-Connecting-IP');
203
  const corsHeaders = request.headers.get('x-cors-headers');
204
  let myHeaders = new Headers();
205
  myHeaders = fix(myHeaders, request, isOPTIONS);
206

207
  let country = false;
208
  let colo = false;
209
  if (typeof request.cf !== 'undefined') {
210
    country = typeof request.cf.country === 'undefined' ? false : request.cf.country;
211
    colo = typeof request.cf.colo === 'undefined' ? false : request.cf.colo;
212
  }
213

214
  return new Response(
215
    'CLOUDFLARE-CORS-ANYWHERE\n\n'
216
        + 'Source:\nhttps://github.com/chrisspiegl/cloudflare-cors-anywhere\n\n'
217
        + 'Usage:\n'
218
        + originUrl.origin + '/{uri}\n'
219
        + 'Header x-cors-proxy-api-key must be set with valid api key\n'
220
        + 'Header origin or x-requested-with must be set\n\n'
221
        // + 'Limits: 100,000 requests/day\n'
222
        // + '          1,000 requests/10 minutes\n\n'
223
        + (origin === null ? '' : 'Origin: ' + origin + '\n')
224
        + 'Ip: ' + remIp + '\n'
225
        + (country ? 'Country: ' + country + '\n' : '')
226
        + (colo ? 'Datacenter: ' + colo + '\n' : '') + '\n'
227
        + ((corsHeaders === null) ? '' : '\nx-cors-headers: ' + JSON.stringify(corsHeaders)),
228
    {status: 200, headers: myHeaders},
229
  );
230
}
231

232
async function handleRequest(request) {
233
  const {protocol, pathname} = new URL(request.url);
234
  // In the case of a "Basic" authentication, the exchange MUST happen over an HTTPS (TLS) connection to be secure.
235
  if (protocol !== 'https:' || request.headers.get('x-forwarded-proto') !== 'https') {
236
    throw new BadRequestException('Must use a HTTPS connection.');
237
  }
238

239
  switch (pathname) {
240
    case '/favicon.ico':
241
    case '/robots.txt':
242
      return new Response(null, {status: 204});
243
    case '/':
244
      return homeRequest(request);
245
    default: {
246
      // Not 100% sure if this is a good idea…
247
      // Right now all OPTIONS requests are just simply replied to because otherwise they fail.
248
      // This is necessary because apparently, OPTIONS requests do not carry the `x-cors-proxy-api-key` header so this can not be authorized.
249
      if (request.method === 'OPTIONS') {
250
        return new Response(null, {
251
          headers: fix(new Headers(), request, true),
252
          status: 200,
253
          statusText: 'OK',
254
        });
255
      }
256

257
      // The "x-cors-proxy-api-key" header is sent when authenticated.
258
      //if (request.headers.has('x-cors-proxy-api-key')) {
259
        // Throws exception when authorization fails.
260
        //const activeApiKey = verifyCredentials(request);
261

262
        // Only returns this response when no exception is thrown.
263
        return proxyRequest(request);
264
      //}
265

266
      // Not authenticated.
267
      //throw new UnauthorizedException('Valid x-cors-proxy-api-key header has to be provided.');
268
    }
269
  }
270
}
271

272
addEventListener('fetch', async event => {
273
  event.respondWith(
274
    handleRequest(event.request).catch(error => {
275
      const message = error.reason || error.stack || 'Unknown Error';
276

277
      return new Response(message, {
278
        status: error.status || 500,
279
        statusText: error.statusText || null,
280
        headers: {
281
          'Content-Type': 'text/plain;charset=UTF-8',
282
          // Disables caching by default.
283
          'Cache-Control': 'no-store',
284
          // Returns the "Content-Length" header for HTTP HEAD requests.
285
          'Content-Length': message.length,
286
        },
287
      });
288
    }),
289
  );
290
});