GitHub图床+Cloudflare加速访问教程

前期准备

Cloudflare的账号：Cloudflare Dashboard | Manage Your Account（必须）
Github的账号：GitHub · Build and ship software on a single, collaborative platform · GitHub（必须）
一个域名

创建github仓库

登录github，点击创建仓库的按钮。

输入自定义仓库名，勾选上仓库私有

仓库创建后，随便创建一个文件

点击创建，到此存储图片的仓库创建完成。

获取Github的Token

点击github头像，点击设置（settings)的按钮
点击“开发者设置”

创建token

创建完成，保存一下token.

CloudFlare加速图床访问

创建workers项目

登录CloudFlare的网站
创建一个workers的项目

在Workers.js，粘贴如下如下代码

// raw.githubusercontent.com是GitHub提供的直接访问仓库原始文件（如代码、图片、文本）的域名。  
const upstream = "raw.githubusercontent.com";  
  
// Custom pathname for the upstream website.  
const upstream_path = "/<用户>/<仓库名>/<分支>";  
  
// github personal access token.  
const github_token = "github的token";  
  
// Website you intended to retrieve for users using mobile devices.  
const upstream_mobile = upstream;  
  
// Countries and regions where you wish to suspend your service.  
const blocked_region = [];  
  
// IP addresses which you wish to block from using your service.  
const blocked_ip_address = ["0.0.0.0", "127.0.0.1"];  
  
// Whether to use HTTPS protocol for upstream address.  
const https = true;  
  
// Whether to disable cache.  
const disable_cache = false;  
  
// Replace texts.  
const replace_dict = {  
  $upstream: "$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_hostname = url.hostname;  
  
  if (https == true) {  
    url.protocol = "https:";  
  } else {  
    url.protocol = "http:";  
  }  
  
  if (await device_status(user_agent)) {  
    var upstream_domain = upstream;  
  } else {  
    var upstream_domain = upstream_mobile;  
  }  
  
  url.host = upstream_domain;  
  if (url.pathname == "/") {  
    url.pathname = upstream_path;  
  } else {  
    url.pathname = upstream_path + url.pathname;  
  }  
  
  if (blocked_region.includes(region)) {  
    response = new Response(  
      "Access denied: WorkersProxy is not available in your region yet.",  
      {  
        status: 403,  
      }  
    );  
  } else if (blocked_ip_address.includes(ip_address)) {  
    response = new Response(  
      "Access denied: Your IP address is blocked by WorkersProxy.",  
      {  
        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.protocol + "//" + url_hostname);  
    new_request_headers.set("Authorization", "token " + github_token);  
  
    let original_response = await fetch(url.href, {  
      method: method,  
      headers: new_request_headers,  
      body: request.body,  
    });  
  
    connection_upgrade = new_request_headers.get("Upgrade");  
    if (connection_upgrade && connection_upgrade.toLowerCase() == "websocket") {  
      return original_response;  
    }  
  
    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;  
  
    if (disable_cache) {  
      new_response_headers.set("Cache-Control", "no-store");  
    } else {  
      new_response_headers.set("Cache-Control", "max-age=43200000");  
    }  
  
    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");  
  
    if (new_response_headers.get("x-pjax-url")) {  
      new_response_headers.set(  
        "x-pjax-url",  
        response_headers  
          .get("x-pjax-url")  
          .replace("//" + upstream_domain, "//" + url_hostname)  
      );  
    }  
  
    const content_type = new_response_headers.get("content-type");  
    if (  
      content_type != null &&  
      content_type.includes("text/html") &&  
      content_type.includes("UTF-8")  
    ) {  
      original_text = await replace_response_text(  
        original_response_clone,  
        upstream_domain,  
        url_hostname  
      );  
    } 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;  
}  
  
async function device_status(user_agent_info) {  
  var agents = [  
    "Android",  
    "iPhone",  
    "SymbianOS",  
    "Windows Phone",  
    "iPad",  
    "iPod",  
  ];  
  var flag = true;  
  for (var v = 0; v < agents.length; v++) {  
    if (user_agent_info.indexOf(agents[v]) > 0) {  
      flag = false;  
      break;  
    }  
  }  
  return flag;  
}