在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(
28
      `Expired authorization key.\nKey was valid until: ${apiKeys[requestApiKey].expiresAt}`,
29
    );
30
  }
31

32
  return apiKeys[requestApiKey];
33
}
34

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

44
function UnauthorizedException(reason) {
45
  this.status = 401;
46
  this.statusText = "Unauthorized";
47
  this.reason = reason;
48
}
49

50
function BadRequestException(reason) {
51
  this.status = 400;
52
  this.statusText = "Bad Request";
53
  this.reason = reason;
54
}
55

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

70
  return returnValue;
71
}
72

73
function fix(myHeaders, request, isOPTIONS) {
74
  myHeaders.set("Access-Control-Allow-Origin", request.headers.get("Origin"));
75
  if (isOPTIONS) {
76
    myHeaders.set(
77
      "Access-Control-Allow-Methods",
78
      request.headers.get("access-control-request-method"),
79
    );
80
    const acrh = request.headers.get("access-control-request-headers");
81

82
    if (acrh) {
83
      myHeaders.set("Access-Control-Allow-Headers", acrh);
84
    }
85

86
    myHeaders.delete("X-Content-Type-Options");
87
  }
88

89
  return myHeaders;
90
}
91

92
function parseURL(requestUrl) {
93
  const match = requestUrl.match(
94
    /^(?:(https?:)?\/\/)?(([^/?]+?)(?::(\d{0,5})(?=[/?]|$))?)([/?][\S\s]*|$)/i,
95
  );
96
  //                              ^^^^^^^          ^^^^^^^^      ^^^^^^^                ^^^^^^^^^^^^
97
  //                            1:protocol       3:hostname     4:port                 5:path + query string
98
  //                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
99
  //                                            2:host
100

101
  if (!match) {
102
    console.log("no match");
103
    throw new BadRequestException("Invalid URL for proxy request.");
104
  }
105

106
  console.log("parseURL:match:", match);
107

108
  if (!match[1]) {
109
    console.log("nothing in match group 1");
110
    if (/^https?:/i.test(requestUrl)) {
111
      console.log(
112
        'The pattern at top could mistakenly parse "http:///" as host="http:" and path=///.',
113
      );
114
      throw new BadRequestException("Invalid URL for proxy request.");
115
    }
116

117
    // Scheme is omitted.
118
    if (requestUrl.lastIndexOf("//", 0) === -1) {
119
      console.log('"//" is omitted');
120
      requestUrl = "//" + requestUrl;
121
    }
122

123
    requestUrl = (match[4] === "443" ? "https:" : "http:") + requestUrl;
124
  }
125

126
  const parsed = new URL(requestUrl);
127
  if (!parsed.hostname) {
128
    console.log('"http://:1/" and "http:/notenoughslashes" could end up here.');
129
    throw new BadRequestException("Invalid URL for proxy request.");
130
  }
131

132
  return parsed;
133
}
134

135
async function proxyRequest(request, activeApiKey) {
136
  const isOPTIONS = request.method === "OPTIONS";
137
  const originUrl = new URL(request.url);
138
  const origin = request.headers.get("Origin");
139
  // ParseURL throws when the url is invalid
140
  const fetchUrl = parseURL(request.url.replace(originUrl.origin, "").slice(1));
141

142
  // Throws if it fails the check
143
  checkRequiredHeadersPresent(request);
144

145
  // Excluding urls which are not allowed as destination urls
146
  // Exclude origins which are not int he included ones
147
  if (
148
    isListed(fetchUrl.toString(), [...exclude, ...(activeApiKey?.exclude || [])]) ||
149
    !isListed(origin, [...include, ...(activeApiKey?.include || [])])
150
  ) {
151
    throw new BadRequestException("Origin or Destination URL is not allowed.");
152
  }
153

154
  let corsHeaders = request.headers.get("x-cors-headers");
155

156
  if (corsHeaders !== null) {
157
    try {
158
      corsHeaders = JSON.parse(corsHeaders);
159
    } catch {}
160
  }
161

162
  if (!originUrl.pathname.startsWith("/")) {
163
    throw new BadRequestException('Pathname does not start with "/"');
164
  }
165

166
  const recvHpaireaders = {};
167
  for (const pair of request.headers.entries()) {
168
    if (
169
      pair[0].match("^origin") === null &&
170
      pair[0].match("eferer") === null &&
171
      pair[0].match("^cf-") === null &&
172
      pair[0].match("^x-forw") === null &&
173
      pair[0].match("^x-cors-headers") === null
174
    ) {
175
      recvHpaireaders[pair[0]] = pair[1];
176
    }
177
  }
178

179
  if (corsHeaders !== null) {
180
    for (const c of Object.entries(corsHeaders)) {
181
      recvHpaireaders[c[0]] = c[1];
182
    }
183
  }
184

185
  const newRequest = new Request(request, {
186
    headers: recvHpaireaders,
187
  });
188

189
  const response = await fetch(fetchUrl, newRequest);
190
  let myHeaders = new Headers(response.headers);
191
  const newCorsHeaders = [];
192
  const allh = {};
193
  for (const pair of response.headers.entries()) {
194
    newCorsHeaders.push(pair[0]);
195
    allh[pair[0]] = pair[1];
196
  }
197

198
  newCorsHeaders.push("cors-received-headers");
199
  myHeaders = fix(myHeaders, request, isOPTIONS);
200

201
  myHeaders.set("Access-Control-Expose-Headers", newCorsHeaders.join(","));
202

203
  myHeaders.set("cors-received-headers", JSON.stringify(allh));
204

205
  const body = isOPTIONS ? null : await response.arrayBuffer();
206

207
  return new Response(body, {
208
    headers: myHeaders,
209
    status: isOPTIONS ? 200 : response.status,
210
    statusText: isOPTIONS ? "OK" : response.statusText,
211
  });
212
}
213

214
function homeRequest(request) {
215
  const isOPTIONS = request.method === "OPTIONS";
216
  const originUrl = new URL(request.url);
217
  const origin = request.headers.get("Origin");
218
  const remIp = request.headers.get("CF-Connecting-IP");
219
  const corsHeaders = request.headers.get("x-cors-headers");
220
  let myHeaders = new Headers();
221
  myHeaders = fix(myHeaders, request, isOPTIONS);
222

223
  let country = false;
224
  let colo = false;
225
  if (typeof request.cf !== "undefined") {
226
    country = typeof request.cf.country === "undefined" ? false : request.cf.country;
227
    colo = typeof request.cf.colo === "undefined" ? false : request.cf.colo;
228
  }
229

230
  return new Response(
231
    "CLOUDFLARE-CORS-ANYWHERE\n\n" +
232
      "Source:\nhttps://github.com/chrisspiegl/cloudflare-cors-anywhere\n\n" +
233
      "Usage:\n" +
234
      originUrl.origin +
235
      "/{uri}\n" +
236
      "Header x-cors-proxy-api-key must be set with valid api key\n" +
237
      "Header origin or x-requested-with must be set\n\n" +
238
      // + 'Limits: 100,000 requests/day\n'
239
      // + '          1,000 requests/10 minutes\n\n'
240
      (origin === null ? "" : "Origin: " + origin + "\n") +
241
      "Ip: " +
242
      remIp +
243
      "\n" +
244
      (country ? "Country: " + country + "\n" : "") +
245
      (colo ? "Datacenter: " + colo + "\n" : "") +
246
      "\n" +
247
      (corsHeaders === null ? "" : "\nx-cors-headers: " + JSON.stringify(corsHeaders)),
248
    { status: 200, headers: myHeaders },
249
  );
250
}
251

252
async function handleRequest(request) {
253
  const { protocol, pathname } = new URL(request.url);
254
  // In the case of a "Basic" authentication, the exchange MUST happen over an HTTPS (TLS) connection to be secure.
255
  if (protocol !== "https:" || request.headers.get("x-forwarded-proto") !== "https") {
256
    throw new BadRequestException("Must use a HTTPS connection.");
257
  }
258

259
  switch (pathname) {
260
    case "/favicon.ico":
261
    case "/robots.txt":
262
      return new Response(null, { status: 204 });
263
    case "/":
264
      return homeRequest(request);
265
    default: {
266
      // Not 100% sure if this is a good idea…
267
      // Right now all OPTIONS requests are just simply replied to because otherwise they fail.
268
      // This is necessary because apparently, OPTIONS requests do not carry the `x-cors-proxy-api-key` header so this can not be authorized.
269
      if (request.method === "OPTIONS") {
270
        return new Response(null, {
271
          headers: fix(new Headers(), request, true),
272
          status: 200,
273
          statusText: "OK",
274
        });
275
      }
276

277
      // The "x-cors-proxy-api-key" header is sent when authenticated.
278
      //if (request.headers.has('x-cors-proxy-api-key')) {
279
      // Throws exception when authorization fails.
280
      //const activeApiKey = verifyCredentials(request);
281

282
      // Only returns this response when no exception is thrown.
283
      return proxyRequest(request);
284
      //}
285

286
      // Not authenticated.
287
      //throw new UnauthorizedException('Valid x-cors-proxy-api-key header has to be provided.');
288
    }
289
  }
290
}
291

292
addEventListener("fetch", async (event) => {
293
  event.respondWith(
294
    handleRequest(event.request).catch((error) => {
295
      const message = error.reason || error.stack || "Unknown Error";
296

297
      return new Response(message, {
298
        status: error.status || 500,
299
        statusText: error.statusText || null,
300
        headers: {
301
          "Content-Type": "text/plain;charset=UTF-8",
302
          // Disables caching by default.
303
          "Cache-Control": "no-store",
304
          // Returns the "Content-Length" header for HTTP HEAD requests.
305
          "Content-Length": message.length,
306
        },
307
      });
308
    }),
309
  );
310
});