1
package main
2

3
import (
4
  "fmt"
5
  "io"
6
  "log"
7
  "net/http"
8
  "net/url"
9
  "regexp"
10
  "strings"
11
  "time"
12
)
13

14
// 域名映射配置
15
var domainMappings = map[string]string{
16
  "github.com":                    "gh.",
17
  "avatars.githubusercontent.com": "avatars-githubusercontent-com.",
18
  "github.githubassets.com":       "github-githubassets-com.",
19
  "collector.github.com":          "collector-github-com.",
20
  "api.github.com":                "api-github-com.",
21
  "raw.githubusercontent.com":     "raw-githubusercontent-com.",
22
  "gist.githubusercontent.com":    "gist-githubusercontent-com.",
23
  "github.io":                     "github-io.",
24
  "assets-cdn.github.com":         "assets-cdn-github-com.",
25
  "cdn.jsdelivr.net":              "cdn.jsdelivr-net.",
26
  "securitylab.github.com":        "securitylab-github-com.",
27
  "www.githubstatus.com":          "www-githubstatus-com.",
28
  "npmjs.com":                     "npmjs-com.",
29
  "git-lfs.github.com":            "git-lfs-github-com.",
30
  "githubusercontent.com":         "githubusercontent-com.",
31
  "github.global.ssl.fastly.net":  "github-global-ssl-fastly-net.",
32
  "api.npms.io":                   "api-npms-io.",
33
  "github.community":              "github-community.",
34
}
35

36
// 需要重定向的路径
37
var redirectPaths = []string{"/", "/login", "/signup", "/copilot"}
38

39
// 检查路径是否需要重定向
40
func shouldRedirect(path string) bool {
41
  for _, p := range redirectPaths {
42
    if path == p {
43
      return true
44
    }
45
  }
46
  return false
47
}
48

49
// 获取代理前缀
50
func getProxyPrefix(host string) string {
51
  if strings.HasPrefix(host, "gh.") {
52
    return "gh."
53
  }
54

55
  for _, prefix := range domainMappings {
56
    if strings.HasPrefix(host, prefix) {
57
      return prefix
58
    }
59
  }
60

61
  return ""
62
}
63

64
// 根据前缀获取目标域名
65
func getTargetHost(prefix string) string {
66
  for original, p := range domainMappings {
67
    if p == prefix {
68
      return original
69
    }
70
  }
71
  return ""
72
}
73

74
// 处理响应内容，替换域名引用
75
func modifyResponse(body []byte, contentType, hostPrefix, currentHostname string) []byte {
76
  if !strings.Contains(contentType, "text/") &&
77
    !strings.Contains(contentType, "application/json") &&
78
    !strings.Contains(contentType, "application/javascript") &&
79
    !strings.Contains(contentType, "application/xml") {
80
    return body
81
  }
82

83
  text := string(body)
84
  domainSuffix := currentHostname[len(hostPrefix):]
85

86
  for originalDomain, proxyPrefix := range domainMappings {
87
    fullProxyDomain := proxyPrefix + domainSuffix
88
    text = strings.ReplaceAll(text, "https://"+originalDomain, "https://"+fullProxyDomain)
89
    text = strings.ReplaceAll(text, "http://"+originalDomain, "https://"+fullProxyDomain)
90
    text = strings.ReplaceAll(text, "//"+originalDomain, "//"+fullProxyDomain)
91
    text = strings.ReplaceAll(text, `"`+originalDomain+`"`, `"`+fullProxyDomain+`"`)
92
    text = strings.ReplaceAll(text, `'`+originalDomain+`'`, `'`+fullProxyDomain+`'`)
93
  }
94

95
  if hostPrefix == "gh." {
96
    text = strings.ReplaceAll(text, `"/`, `"https://`+currentHostname+`/`)
97
    text = strings.ReplaceAll(text, `'/`, `'https://`+currentHostname+`/`)
98
  }
99

100
  return []byte(text)
101
}
102

103
// 处理请求
104
func handleRequest(w http.ResponseWriter, r *http.Request) {
105
  currentHost := r.Host
106

107
  if shouldRedirect(r.URL.Path) {
108
    http.Redirect(w, r, "https://www.gov.cn", http.StatusFound)
109
    return
110
  }
111

112
  hostPrefix := getProxyPrefix(currentHost)
113
  if hostPrefix == "" {
114
    http.Error(w, "Domain not configured for proxy", http.StatusNotFound)
115
    return
116
  }
117

118
  targetHost := getTargetHost(hostPrefix)
119
  if targetHost == "" {
120
    http.Error(w, "Domain not configured for proxy", http.StatusNotFound)
121
    return
122
  }
123

124
  pathname := r.URL.Path
125

126
  re1 := regexp.MustCompile(`(/[^/]+/[^/]+/(?:latest-commit|tree-commit-info)/[^/]+)/https%3A//[^/]+.*`)
127
  pathname = re1.ReplaceAllString(pathname, "$1")
128

129
  re2 := regexp.MustCompile(`(/[^/]+/[^/]+/(?:latest-commit|tree-commit-info)/[^/]+)/https://[^/]+.*`)
130
  pathname = re2.ReplaceAllString(pathname, "$1")
131

132
  re3 := regexp.MustCompile(`(/[^/]+/[^/]+/(?:latest-commit|tree-commit-info)/[^/]+)/https:/[^/]+.*`)
133
  pathname = re3.ReplaceAllString(pathname, "$1")
134

135
  targetURL := &url.URL{
136
    Scheme:   "https",
137
    Host:     targetHost,
138
    Path:     pathname,
139
    RawQuery: r.URL.RawQuery,
140
  }
141

142
  req, err := http.NewRequest(r.Method, targetURL.String(), r.Body)
143
  if err != nil {
144
    http.Error(w, fmt.Sprintf("Failed to create request: %v", err), http.StatusInternalServerError)
145
    return
146
  }
147

148
  for key, values := range r.Header {
149
    for _, value := range values {
150
      req.Header.Add(key, value)
151
    }
152
  }
153

154
  req.Header.Set("Host", targetHost)
155
  req.Header.Set("Referer", targetURL.String())
156
  req.Header.Set("Accept-Encoding", "identity")
157

158
  client := &http.Client{
159
    Timeout: 30 * time.Second,
160
  }
161

162
  resp, err := client.Do(req)
163
  if err != nil {
164
    http.Error(w, fmt.Sprintf("Proxy Error: %v", err), http.StatusBadGateway)
165
    return
166
  }
167
  defer resp.Body.Close()
168

169
  body, err := io.ReadAll(resp.Body)
170
  if err != nil {
171
    http.Error(w, fmt.Sprintf("Failed to read response: %v", err), http.StatusInternalServerError)
172
    return
173
  }
174

175
  contentType := resp.Header.Get("Content-Type")
176
  modifiedBody := modifyResponse(body, contentType, hostPrefix, currentHost)
177

178
  for key, values := range resp.Header {
179
    if key == "Content-Encoding" || key == "Content-Length" {
180
      continue
181
    }
182
    for _, value := range values {
183
      w.Header().Add(key, value)
184
    }
185
  }
186

187
  w.Header().Set("Access-Control-Allow-Origin", "*")
188
  w.Header().Set("Access-Control-Allow-Credentials", "true")
189
  w.Header().Set("Cache-Control", "public, max-age=14400")
190
  w.Header().Del("Content-Security-Policy")
191
  w.Header().Del("Content-Security-Policy-Report-Only")
192
  w.Header().Del("Clear-Site-Data")
193
  w.Header().Set("Content-Length", fmt.Sprintf("%d", len(modifiedBody)))
194
  w.WriteHeader(resp.StatusCode)
195
  w.Write(modifiedBody)
196
}
197

198
func main() {
199
  http.HandleFunc("/", handleRequest)
200
  port := ":8080"
201
  log.Printf("GitHub代理服务器启动在端口 %s", port)
202
  log.Printf("请确保你的域名已正确配置并指向此服务器")
203

204
  if err := http.ListenAndServe(port, nil); err != nil {
205
    log.Fatal("服务器启动失败:", err)
206
  }
207
}

1
module github-proxy
2

3
go 1.19