%s
", status, message) + resp := fmt.Sprintf("HTTP/1.1 %d Error\r\nContent-Type: text/html\r\nContent-Length: %d\r\n\r\n%s", status, len(body), body) + return []byte(resp) +} + +func (f *DomainFronter) parseRelayJSON(data map[string]any) []byte { + if e, ok := data["e"]; ok { + return f.errorResponse(502, fmt.Sprintf("Relay error: %v", e)) + } + status := intVal(data["s"], 200) + headers := map[string]any{} + if h, ok := data["h"].(map[string]any); ok { + headers = h + } + bodyRaw := "" + if b, ok := data["b"].(string); ok { + bodyRaw = b + } + body, _ := base64.StdEncoding.DecodeString(bodyRaw) + if len(body) > f.maxResp { + return f.errorResponse(502, "Relay response exceeds cap") + } + statusText := "OK" + switch status { + case 206: + statusText = "Partial Content" + case 301: + statusText = "Moved" + case 302: + statusText = "Found" + case 304: + statusText = "Not Modified" + case 400: + statusText = "Bad Request" + case 403: + statusText = "Forbidden" + case 404: + statusText = "Not Found" + case 500: + statusText = "Internal Server Error" + } + + buf := bytes.NewBufferString(fmt.Sprintf("HTTP/1.1 %d %s\r\n", status, statusText)) + skip := map[string]bool{ + "transfer-encoding": true, + "connection": true, + "keep-alive": true, + "content-length": true, + "content-encoding": true, + } + for k, v := range headers { + lk := strings.ToLower(k) + if skip[lk] { + continue + } + switch val := v.(type) { + case []any: + for _, item := range val { + buf.WriteString(fmt.Sprintf("%s: %v\r\n", k, item)) + } + default: + buf.WriteString(fmt.Sprintf("%s: %v\r\n", k, val)) + } + } + buf.WriteString(fmt.Sprintf("Content-Length: %d\r\n\r\n", len(body))) + buf.Write(body) + return buf.Bytes() +} + +func (f *DomainFronter) parseBatchBody(body []byte, expected int) ([][]byte, error) { + text := strings.TrimSpace(string(body)) + var data map[string]any + if err := json.Unmarshal([]byte(text), &data); err != nil { + return nil, err + } + if e, ok := data["e"]; ok { + return nil, fmt.Errorf("Batch error: %v", e) + } + arr, ok := data["q"].([]any) + if !ok || len(arr) != expected { + return nil, errors.New("batch size mismatch") + } + results := make([][]byte, 0, len(arr)) + for _, item := range arr { + if obj, ok := item.(map[string]any); ok { + results = append(results, f.parseRelayJSON(obj)) + } + } + return results, nil +} + +func (f *DomainFronter) isStatefulRequest(method, urlStr string, headers map[string]string, body []byte) bool { + method = strings.ToUpper(method) + if method != "GET" && method != "HEAD" { + return true + } + if len(body) > 0 { + return true + } + for _, name := range constants.StatefulHeaderNames { + if headerValue(headers, name) != "" { + return true + } + } + accept := strings.ToLower(headerValue(headers, "accept")) + if strings.Contains(accept, "text/html") || strings.Contains(accept, "application/json") { + return true + } + fetchMode := strings.ToLower(headerValue(headers, "sec-fetch-mode")) + if fetchMode == "navigate" || fetchMode == "cors" { + return true + } + return !isStaticAssetURL(urlStr) +} + +func isStaticAssetURL(urlStr string) bool { + parsed, err := url.Parse(urlStr) + if err != nil { + return false + } + path := strings.ToLower(parsed.Path) + for _, ext := range constants.StaticExts { + if strings.HasSuffix(path, ext) { + return true + } + } + return false +} + +func (f *DomainFronter) coalesceKey(urlStr string, headers map[string]string) string { + key := []string{urlStr} + if headers != nil { + for _, name := range []string{"accept", "accept-language", "user-agent", "sec-fetch-dest", "sec-fetch-mode", "sec-fetch-site"} { + if v := headerValue(headers, name); v != "" { + key = append(key, name+"="+v) + } + } + } + return strings.Join(key, "\n") +} + +func (f *DomainFronter) recordSite(urlStr string, bytes int, latency time.Duration, errored bool) { + host := hostKey(urlStr) + if host == "" { + return + } + stat, ok := f.perSite[host] + if !ok { + stat = &HostStat{} + f.perSite[host] = stat + } + stat.Requests++ + stat.Bytes += bytes + stat.TotalLatencyNs += latency.Nanoseconds() + if errored { + stat.Errors++ + } +} + +func (f *DomainFronter) statsLoop() { + ticker := time.NewTicker(time.Duration(constants.StatsLogInterval) * time.Second) + defer ticker.Stop() + for { + select { + case <-f.statsStop: + return + case <-ticker.C: + f.logStats() + } + } +} + +func (f *DomainFronter) logStats() { + if len(f.perSite) == 0 { + return + } + type statEntry struct { + host string + stat *HostStat + } + entries := make([]statEntry, 0, len(f.perSite)) + for host, stat := range f.perSite { + entries = append(entries, statEntry{host: host, stat: stat}) + } + sort.Slice(entries, func(i, j int) bool { + return entries[i].stat.Bytes > entries[j].stat.Bytes + }) + count := constants.StatsLogTopN + if count > len(entries) { + count = len(entries) + } + log.Debugf("-- Per-host stats (top %d by bytes) --", count) + for i := 0; i < count; i++ { + e := entries[i] + avgLatency := time.Duration(0) + if e.stat.Requests > 0 { + avgLatency = time.Duration(e.stat.TotalLatencyNs / int64(e.stat.Requests)) + } + log.Debugf(" %s: %d reqs, %.2fMB, %s avg, %d errs", + e.host, e.stat.Requests, float64(e.stat.Bytes)/1024/1024, avgLatency, e.stat.Errors) + } +} + +func headerValue(headers map[string]string, name string) string { + for k, v := range headers { + if strings.ToLower(k) == name { + return v + } + } + return "" +} + +func truncate(s string, max int) string { + if len(s) <= max { + return s + } + return s[:max] +} + +func intVal(v any, def int) int { + switch t := v.(type) { + case float64: + return int(t) + case int: + return t + case string: + if i, err := strconv.Atoi(t); err == nil { + return i + } + } + return def +} diff --git a/internal/h2/h2_transport.go b/internal/h2/h2_transport.go new file mode 100644 index 0000000..aea4cb3 --- /dev/null +++ b/internal/h2/h2_transport.go @@ -0,0 +1,144 @@ +package h2 + +import ( + "bytes" + "context" + "crypto/tls" + "errors" + "io" + "net" + "net/http" + "net/url" + "strings" + "sync" + "sync/atomic" + "time" + + "golang.org/x/net/http2" + + "github.com/denuitt1/mhr-cfw/internal/codec" + "github.com/denuitt1/mhr-cfw/internal/logging" +) + +var log = logging.Get("H2") + +type Transport struct { + connectHost string + verifySSL bool + sniHosts []string + sniIdx uint32 + + mu sync.Mutex + h2 *http2.Transport + client *http.Client +} + +func New(connectHost string, sniHosts []string, verifySSL bool) *Transport { + if len(sniHosts) == 0 { + sniHosts = []string{"www.google.com"} + } + return &Transport{ + connectHost: connectHost, + verifySSL: verifySSL, + sniHosts: sniHosts, + } +} + +func (t *Transport) ensure() { + t.mu.Lock() + defer t.mu.Unlock() + if t.h2 != nil && t.client != nil { + return + } + tr := &http2.Transport{ + AllowHTTP: false, + DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) { + sni := t.nextSNI() + tlsCfg := &tls.Config{ + ServerName: sni, + InsecureSkipVerify: !t.verifySSL, + NextProtos: []string{"h2", "http/1.1"}, + } + dialer := &net.Dialer{Timeout: 15 * time.Second} + conn, err := dialer.DialContext(ctx, network, net.JoinHostPort(t.connectHost, "443")) + if err != nil { + return nil, err + } + if tcp, ok := conn.(*net.TCPConn); ok { + _ = tcp.SetNoDelay(true) + } + tlsConn := tls.Client(conn, tlsCfg) + if err := tlsConn.HandshakeContext(ctx); err != nil { + _ = conn.Close() + return nil, err + } + if tlsConn.ConnectionState().NegotiatedProtocol != "h2" { + _ = tlsConn.Close() + return nil, errors.New("h2 ALPN negotiation failed") + } + return tlsConn, nil + }, + } + client := &http.Client{Transport: tr} + t.h2 = tr + t.client = client + log.Infof("H2 transport ready -> %s", t.connectHost) +} + +func (t *Transport) Request(ctx context.Context, method, path, host string, headers map[string]string, body []byte, timeout time.Duration) (int, map[string]string, []byte, error) { + t.ensure() + if !strings.HasPrefix(path, "/") { + path = "/" + path + } + u := &url.URL{Scheme: "https", Host: host, Path: path} + req, err := http.NewRequestWithContext(ctx, method, u.String(), bytes.NewReader(body)) + if err != nil { + return 0, nil, nil, err + } + for k, v := range headers { + req.Header.Set(k, v) + } + req.Header.Set("accept-encoding", codec.SupportedEncodings()) + req.Host = host + + ctx, cancel := context.WithTimeout(req.Context(), timeout) + defer cancel() + req = req.WithContext(ctx) + + resp, err := t.client.Do(req) + if err != nil { + return 0, nil, nil, err + } + defer resp.Body.Close() + + data, err := io.ReadAll(resp.Body) + if err != nil { + return 0, nil, nil, err + } + respHeaders := map[string]string{} + for k, v := range resp.Header { + if len(v) > 0 { + respHeaders[strings.ToLower(k)] = v[0] + } + } + if enc := respHeaders["content-encoding"]; enc != "" { + data = codec.Decode(data, enc) + } + return resp.StatusCode, respHeaders, data, nil +} + +func (t *Transport) Close() error { + t.mu.Lock() + defer t.mu.Unlock() + if t.h2 != nil { + t.h2.CloseIdleConnections() + } + t.h2 = nil + t.client = nil + return nil +} + +func (t *Transport) nextSNI() string { + idx := atomic.AddUint32(&t.sniIdx, 1) + return t.sniHosts[int(idx)%len(t.sniHosts)] +} diff --git a/internal/lan/lan.go b/internal/lan/lan.go new file mode 100644 index 0000000..c6bf721 --- /dev/null +++ b/internal/lan/lan.go @@ -0,0 +1,95 @@ +package lan + +import ( + "net" + "net/netip" + "os" + "strconv" + "strings" + + "github.com/denuitt1/mhr-cfw/internal/logging" +) + +var log = logging.Get("LAN") + +func GetNetworkInterfaces() map[string][]string { + out := map[string][]string{} + seen := map[string]bool{} + + add := func(label, ip string) { + if ip == "" || seen[ip] || strings.HasPrefix(ip, "127.") { + return + } + seen[ip] = true + out[label] = append(out[label], ip) + } + + if ip := primaryIPv4(); ip != "" { + add("primary", ip) + } + + host, _ := os.Hostname() + if host != "" { + if addrs, err := net.LookupIP(host); err == nil { + for _, a := range addrs { + if a4 := a.To4(); a4 != nil { + add("host", a4.String()) + } + } + } + } + + return out +} + +func GetLANIPs(port int) []string { + ifaces := GetNetworkInterfaces() + var lan []string + seen := map[string]bool{} + for _, ips := range ifaces { + for _, ip := range ips { + addr, err := netip.ParseAddr(ip) + if err != nil { + continue + } + if addr.IsLoopback() || addr.IsUnspecified() { + continue + } + if addr.IsPrivate() || addr.IsLinkLocalUnicast() { + addrStr := ip + ":" + strconv.Itoa(port) + if !seen[addrStr] { + seen[addrStr] = true + lan = append(lan, addrStr) + } + } + } + } + return lan +} + +func LogLANAccess(port int, socksPort *int) { + lanHTTP := GetLANIPs(port) + if len(lanHTTP) > 0 { + log.Infof("LAN HTTP proxy : %s", strings.Join(lanHTTP, ", ")) + } else { + log.Warnf("No LAN IP addresses detected for HTTP proxy") + } + if socksPort != nil { + lanSocks := GetLANIPs(*socksPort) + if len(lanSocks) > 0 { + log.Infof("LAN SOCKS5 proxy : %s", strings.Join(lanSocks, ", ")) + } else { + log.Warnf("No LAN IP addresses detected for SOCKS5 proxy") + } + } +} + +func primaryIPv4() string { + conn, err := net.Dial("udp", "192.0.2.1:80") + if err != nil { + return "" + } + defer conn.Close() + local := conn.LocalAddr().(*net.UDPAddr) + return local.IP.String() +} diff --git a/internal/logging/logging.go b/internal/logging/logging.go new file mode 100644 index 0000000..0300b44 --- /dev/null +++ b/internal/logging/logging.go @@ -0,0 +1,245 @@ +package logging + +import ( + "fmt" + "io" + "os" + "runtime" + "strings" + "sync" + "time" +) + +type Level int + +const ( + Debug Level = iota + Info + Warn + Error +) + +type Logger struct { + name string +} + +var ( + mu sync.RWMutex + globalLvl = Info + colorOn = false + outWriter io.Writer = os.Stderr +) + +func Configure(level string) { + lvl := Info + switch strings.ToUpper(level) { + case "DEBUG": + lvl = Debug + case "WARNING", "WARN": + lvl = Warn + case "ERROR": + lvl = Error + default: + lvl = Info + } + mu.Lock() + globalLvl = lvl + outWriter = os.Stderr + colorOn = supportsColor(os.Stderr) + mu.Unlock() +} + +func Get(name string) *Logger { + return &Logger{name: name} +} + +func (l *Logger) Debugf(format string, args ...any) { + l.log(Debug, format, args...) +} + +func (l *Logger) Infof(format string, args ...any) { + l.log(Info, format, args...) +} + +func (l *Logger) Warnf(format string, args ...any) { + l.log(Warn, format, args...) +} + +func (l *Logger) Errorf(format string, args ...any) { + l.log(Error, format, args...) +} + +func (l *Logger) log(level Level, format string, args ...any) { + mu.RLock() + if level < globalLvl { + mu.RUnlock() + return + } + out := outWriter + useColor := colorOn + mu.RUnlock() + + now := time.Now() + ts := now.Format("15:04:05") + levelLabel := levelText(level) + line := fmt.Sprintf(format, args...) + component := l.name + if len(component) > 8 { + component = component[:8] + } + component = fmt.Sprintf("%-8s", component) + + if useColor { + ts = color("90", ts) + levelLabel = color(levelColor(level), levelLabel) + component = color(componentColor(l.name), "["+component+"]") + } else { + component = "[" + component + "]" + } + + fmt.Fprintf(out, "%s %s %s %s\n", ts, levelLabel, component, line) +} + +func levelText(level Level) string { + switch level { + case Debug: + return "DBG" + case Info: + return "INF" + case Warn: + return "WRN" + case Error: + return "ERR" + default: + return "INF" + } +} + +func levelColor(level Level) string { + switch level { + case Debug: + return "38;5;245" + case Info: + return "38;5;39" + case Warn: + return "38;5;214" + case Error: + return "38;5;203" + default: + return "38;5;39" + } +} + +func componentColor(name string) string { + switch name { + case "Main": + return "38;5;81" + case "Proxy": + return "38;5;75" + case "Fronter": + return "38;5;141" + case "H2": + return "38;5;87" + case "MITM": + return "38;5;208" + case "Cert": + return "38;5;177" + case "LAN": + return "38;5;80" + case "Scanner": + return "38;5;45" + default: + return "38;5;245" + } +} + +func color(code, text string) string { + return "\x1b[" + code + "m" + text + "\x1b[0m" +} + +func bold(s string) string { return "\x1b[1m" + s + "\x1b[0m" } +func dim(s string) string { return "\x1b[2m" + s + "\x1b[0m" } +func teal(s string) string { return "\x1b[1;38;5;45m" + s + "\x1b[0m" } +func faint(s string) string { return "\x1b[38;5;250m" + s + "\x1b[0m" } +func amber(s string) string { return "\x1b[38;5;214m" + s + "\x1b[0m" } +func violet(s string) string { return "\x1b[38;5;141m" + s + "\x1b[0m" } + +func supportsColor(stream *os.File) bool { + if os.Getenv("NO_COLOR") != "" || os.Getenv("DFT_NO_COLOR") == "1" { + return false + } + if os.Getenv("FORCE_COLOR") != "" || os.Getenv("DFT_FORCE_COLOR") != "" { + return true + } + info, err := stream.Stat() + if err != nil || (info.Mode()&os.ModeCharDevice) == 0 { + return false + } + if runtime.GOOS != "windows" { + return true + } + return enableVirtualTerminal(stream) +} + + +func enableVirtualTerminal(stream *os.File) bool { + if runtime.GOOS != "windows" { + return true + } + // PowerShell + Windows Terminal already support ANSI; conservative default + return true +} + +func PrintBanner(version string) { + title := "MHR-CFW Go Version" + subtitle := "Domain-Fronted Relay Suite" + credit := "ThisIsDara" + versionTag := "v" + version + + innerWidth := max(76, max(len(title), max(len(subtitle), len(credit)))+8) + line := strings.Repeat("═", innerWidth) + borderTop := "╔ " + line + " ╗" + borderMid := "║" + strings.Repeat(" ", innerWidth) + "║" + borderBot := "╚ " + line + " ╝" + + centerLine := func(text string) string { + pad := innerWidth - len(text) + left := pad / 2 + right := pad - left + return "║" + strings.Repeat(" ", left) + text + strings.Repeat(" ", right) + "║" + } + + if colorOn { + fmt.Fprintln(outWriter) + fmt.Fprintln(outWriter, borderTop) + fmt.Fprintln(outWriter, borderMid) + outLine := "║" + bold(teal(centerLine(title))) + "║" + fmt.Fprintln(outWriter, outLine) + outLine = "║" + faint(centerLine(subtitle)) + "║" + fmt.Fprintln(outWriter, outLine) + outLine = "║" + amber(centerLine(versionTag)) + "║" + fmt.Fprintln(outWriter, outLine) + outLine = "║" + violet(centerLine(credit)) + "║" + fmt.Fprintln(outWriter, outLine) + fmt.Fprintln(outWriter, borderMid) + fmt.Fprintln(outWriter, borderBot) + return + } + + fmt.Println() + fmt.Println(borderTop) + fmt.Println(borderMid) + fmt.Println(centerLine(title)) + fmt.Println(centerLine(subtitle)) + fmt.Println(centerLine(versionTag)) + fmt.Println(centerLine(credit)) + fmt.Println(borderMid) + fmt.Println(borderBot) +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} diff --git a/internal/mitm/mitm.go b/internal/mitm/mitm.go new file mode 100644 index 0000000..864aa6f --- /dev/null +++ b/internal/mitm/mitm.go @@ -0,0 +1,187 @@ +package mitm + +import ( + "crypto/rand" + "crypto/rsa" + "crypto/tls" + "crypto/x509" + "crypto/x509/pkix" + "encoding/pem" + "math/big" + "net" + "os" + "path/filepath" + "sync" + "time" +) + +var ( + projectRoot = func() string { + wd, err := os.Getwd() + if err != nil { + exe, _ := os.Executable() + return filepath.Dir(exe) + } + return wd + }() + CADir = filepath.Join(projectRoot, "ca") + CAKeyFile = filepath.Join(CADir, "ca.key") + CACertFile = filepath.Join(CADir, "ca.crt") +) + +type Manager struct { + mu sync.Mutex + caKey *rsa.PrivateKey + caCert *x509.Certificate + cache map[string]*tls.Certificate +} + +func NewManager() *Manager { + m := &Manager{ + cache: map[string]*tls.Certificate{}, + } + m.ensureCA() + return m +} + +func (m *Manager) GetServerTLSConfig(domain string) (*tls.Config, error) { + cert, err := m.getCertificate(domain) + if err != nil { + return nil, err + } + return &tls.Config{ + Certificates: []tls.Certificate{*cert}, + NextProtos: []string{"http/1.1"}, + }, nil +} + +func (m *Manager) getCertificate(domain string) (*tls.Certificate, error) { + m.mu.Lock() + defer m.mu.Unlock() + + if cert, ok := m.cache[domain]; ok { + return cert, nil + } + if m.caKey == nil || m.caCert == nil { + m.ensureCA() + } + key, err := rsa.GenerateKey(rand.Reader, 4096) + if err != nil { + return nil, err + } + + now := time.Now().UTC() + tmpl := &x509.Certificate{ + SerialNumber: randomSerial(), + Subject: pkix.Name{ + CommonName: domain, + }, + NotBefore: now, + NotAfter: now.AddDate(1, 0, 0), + KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment, + ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, + } + if ip := net.ParseIP(domain); ip != nil { + tmpl.IPAddresses = []net.IP{ip} + } else { + tmpl.DNSNames = []string{domain} + } + + der, err := x509.CreateCertificate(rand.Reader, tmpl, m.caCert, &key.PublicKey, m.caKey) + if err != nil { + return nil, err + } + certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}) + caPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: m.caCert.Raw}) + keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)}) + + tlsCert, err := tls.X509KeyPair(append(certPEM, caPEM...), keyPEM) + if err != nil { + return nil, err + } + m.cache[domain] = &tlsCert + return &tlsCert, nil +} + +func (m *Manager) ensureCA() { + if fileExists(CAKeyFile) && fileExists(CACertFile) { + keyPEM, _ := os.ReadFile(CAKeyFile) + certPEM, _ := os.ReadFile(CACertFile) + key, _ := parsePrivateKeyPEM(keyPEM) + cert, _ := parseCertPEM(certPEM) + if key != nil && cert != nil { + m.caKey = key + m.caCert = cert + return + } + } + + _ = os.MkdirAll(CADir, 0755) + key, _ := rsa.GenerateKey(rand.Reader, 2048) + now := time.Now().UTC() + ca := &x509.Certificate{ + SerialNumber: randomSerial(), + Subject: pkix.Name{ + CommonName: "mhr-cfw", + Organization: []string{"mhr-cfw"}, + }, + NotBefore: now, + NotAfter: now.AddDate(10, 0, 0), + KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature | x509.KeyUsageCRLSign, + BasicConstraintsValid: true, + IsCA: true, + MaxPathLen: 0, + } + der, _ := x509.CreateCertificate(rand.Reader, ca, ca, &key.PublicKey, key) + cert, _ := x509.ParseCertificate(der) + + m.caKey = key + m.caCert = cert + + writePEM(CAKeyFile, "RSA PRIVATE KEY", x509.MarshalPKCS1PrivateKey(key)) + writePEM(CACertFile, "CERTIFICATE", der) +} + +func fileExists(path string) bool { + _, err := os.Stat(path) + return err == nil +} + +func writePEM(path, typ string, der []byte) { + f, _ := os.Create(path) + defer f.Close() + _ = pem.Encode(f, &pem.Block{Type: typ, Bytes: der}) + if os.PathSeparator == '/' { + _ = os.Chmod(path, 0600) + } +} + +func parsePrivateKeyPEM(pemBytes []byte) (*rsa.PrivateKey, error) { + block, _ := pem.Decode(pemBytes) + if block == nil { + return nil, nil + } + if key, err := x509.ParsePKCS1PrivateKey(block.Bytes); err == nil { + return key, nil + } + if key, err := x509.ParsePKCS8PrivateKey(block.Bytes); err == nil { + if k, ok := key.(*rsa.PrivateKey); ok { + return k, nil + } + } + return nil, nil +} + +func parseCertPEM(pemBytes []byte) (*x509.Certificate, error) { + block, _ := pem.Decode(pemBytes) + if block == nil { + return nil, nil + } + return x509.ParseCertificate(block.Bytes) +} + +func randomSerial() *big.Int { + serialLimit := new(big.Int).Lsh(big.NewInt(1), 128) + serial, _ := rand.Int(rand.Reader, serialLimit) + return serial +} diff --git a/internal/proxy/proxy_server.go b/internal/proxy/proxy_server.go new file mode 100644 index 0000000..b97b595 --- /dev/null +++ b/internal/proxy/proxy_server.go @@ -0,0 +1,589 @@ +package proxy + +import ( + "bufio" + "bytes" + "context" + "crypto/tls" + "errors" + "fmt" + "io" + "net" + "net/textproto" + "regexp" + "strconv" + "strings" + "sync" + "time" + + "github.com/denuitt1/mhr-cfw/internal/config" + "github.com/denuitt1/mhr-cfw/internal/constants" + "github.com/denuitt1/mhr-cfw/internal/fronter" + "github.com/denuitt1/mhr-cfw/internal/logging" + "github.com/denuitt1/mhr-cfw/internal/mitm" +) + +var log = logging.Get("Proxy") + +var maxAgeRegex = regexp.MustCompile(`max-age=(\d+)`) + +type ResponseCache struct { + mu sync.Mutex + store map[string]cacheEntry + order []string + size int + max int + Hits int + Misses int +} + +type cacheEntry struct { + raw []byte + expires time.Time +} + +func NewResponseCache(maxMB int) *ResponseCache { + return &ResponseCache{store: map[string]cacheEntry{}, order: []string{}, max: maxMB * 1024 * 1024} +} + +func (c *ResponseCache) Get(url string) []byte { + c.mu.Lock() + defer c.mu.Unlock() + entry, ok := c.store[url] + if !ok { + c.Misses++ + return nil + } + if time.Now().After(entry.expires) { + c.size -= len(entry.raw) + delete(c.store, url) + for i, u := range c.order { + if u == url { + c.order = append(c.order[:i], c.order[i+1:]...) + break + } + } + c.Misses++ + return nil + } + c.Hits++ + return entry.raw +} + +func (c *ResponseCache) Put(url string, raw []byte, ttl int) { + if len(raw) == 0 { + return + } + size := len(raw) + if size > c.max/4 { + return + } + c.mu.Lock() + defer c.mu.Unlock() + for c.size+size > c.max && len(c.store) > 0 { + oldURL := c.order[0] + c.size -= len(c.store[oldURL].raw) + delete(c.store, oldURL) + c.order = c.order[1:] + } + if old, ok := c.store[url]; ok { + for i, u := range c.order { + if u == url { + c.order = append(c.order[:i], c.order[i+1:]...) + break + } + } + c.size -= len(old.raw) + } + c.store[url] = cacheEntry{raw: raw, expires: time.Now().Add(time.Duration(ttl) * time.Second)} + c.order = append(c.order, url) + c.size += size +} + +func (c *ResponseCache) ParseTTL(raw []byte, urlStr string) int { + sep := []byte("\r\n\r\n") + idx := bytes.Index(raw, sep) + if idx < 0 { + return 0 + } + head := strings.ToLower(string(raw[:idx])) + if !strings.HasPrefix(string(raw[:20]), "HTTP/1.1 200") { + return 0 + } + if strings.Contains(head, "no-store") || strings.Contains(head, "private") || strings.Contains(head, "set-cookie:") { + return 0 + } + if m := maxAgeRegex.FindStringSubmatch(head); len(m) == 2 { + v, _ := strconv.Atoi(m[1]) + if v > constants.CacheTTLMax { + return constants.CacheTTLMax + } + return v + } + path := strings.ToLower(strings.Split(urlStr, "?")[0]) + for _, ext := range constants.StaticExts { + if strings.HasSuffix(path, ext) { + return constants.CacheTTLStaticLong + } + } + if strings.Contains(head, "image/") || strings.Contains(head, "font/") { + return constants.CacheTTLStaticLong + } + if strings.Contains(head, "text/css") || strings.Contains(head, "javascript") { + return constants.CacheTTLStaticMed + } + if strings.Contains(head, "text/html") || strings.Contains(head, "application/json") { + return 0 + } + return 0 +} + +type Server struct { + host string + port int + socksEnabled bool + socksHost string + socksPort int + + fronter *fronter.DomainFronter + mitm *mitm.Manager + cache *ResponseCache + + directFailUntil map[string]time.Time + mu sync.Mutex + + servers []net.Listener + wg sync.WaitGroup + ctx context.Context +} + +func NewServer(cfg config.Config) (*Server, error) { + host := cfg.GetString("listen_host", "127.0.0.1") + port := cfg.GetInt("listen_port", 8080) + socksEnabled := cfg.GetBool("socks5_enabled", true) + socksHost := cfg.GetString("socks5_host", host) + socksPort := cfg.GetInt("socks5_port", 1080) + if socksEnabled && socksHost == host && socksPort == port { + return nil, fmt.Errorf("listen_port and socks5_port must differ on the same host (both set to %d on %s)", port, host) + } + + return &Server{ + host: host, + port: port, + socksEnabled: socksEnabled, + socksHost: socksHost, + socksPort: socksPort, + fronter: fronter.New(cfg), + mitm: mitm.NewManager(), + cache: NewResponseCache(constants.CacheMaxMB), + directFailUntil: map[string]time.Time{}, + }, nil +} + +func (s *Server) Start(ctx context.Context) error { + s.ctx = ctx + ln, err := net.Listen("tcp", net.JoinHostPort(s.host, strconv.Itoa(s.port))) + if err != nil { + return err + } + s.servers = append(s.servers, ln) + log.Infof("HTTP proxy listening on %s:%d", s.host, s.port) + + if s.socksEnabled { + socksLn, err := net.Listen("tcp", net.JoinHostPort(s.socksHost, strconv.Itoa(s.socksPort))) + if err != nil { + log.Errorf("SOCKS5 listener failed on %s:%d: %v", s.socksHost, s.socksPort, err) + } else { + s.servers = append(s.servers, socksLn) + log.Infof("SOCKS5 proxy listening on %s:%d", s.socksHost, s.socksPort) + s.wg.Add(1) + go func() { + defer s.wg.Done() + s.acceptLoop(socksLn, s.handleSocksConn) + }() + } + } + + s.wg.Add(1) + go func() { + defer s.wg.Done() + s.acceptLoop(ln, s.handleHTTPConn) + }() + + <-ctx.Done() + for _, l := range s.servers { + _ = l.Close() + } + _ = s.fronter.Close() + s.wg.Wait() + log.Infof("Server stopped") + return nil +} + +func (s *Server) acceptLoop(ln net.Listener, handler func(net.Conn)) { + defer ln.Close() + for { + conn, err := ln.Accept() + if err != nil { + if errors.Is(err, net.ErrClosed) { + return + } + continue + } + s.wg.Add(1) + go func() { + defer s.wg.Done() + handler(conn) + }() + } +} + +func (s *Server) handleHTTPConn(conn net.Conn) { + defer conn.Close() + conn.SetDeadline(time.Now().Add(30 * time.Second)) + reader := bufio.NewReader(conn) + line, err := reader.ReadString('\n') + if err != nil { + return + } + + headers := []string{line} + for { + ln, err := reader.ReadString('\n') + if err != nil { + return + } + headers = append(headers, ln) + if ln == "\r\n" || ln == "\n" { + break + } + if sumLen(headers) > constants.MaxHeaderBytes { + return + } + } + + parts := strings.Split(strings.TrimSpace(line), " ") + if len(parts) < 2 { + return + } + method := strings.ToUpper(parts[0]) + if method == "CONNECT" { + s.handleConnect(conn, reader, parts[1]) + return + } + s.handlePlainHTTP(conn, reader, headers) +} + +func (s *Server) handleConnect(conn net.Conn, reader *bufio.Reader, target string) { + host, port := splitHostPort(target, 443) + log.Infof("CONNECT -> %s:%d", host, port) + _, _ = conn.Write([]byte("HTTP/1.1 200 Connection Established\r\n\r\n")) + s.handleTunnel(host, port, conn, reader) +} + +func (s *Server) handleTunnel(host string, port int, conn net.Conn, reader *bufio.Reader) { + if port == 443 { + cfg, err := s.mitm.GetServerTLSConfig(host) + if err != nil { + return + } + tlsConn := tls.Server(conn, cfg) + if err := tlsConn.Handshake(); err != nil { + return + } + s.relayHTTPStream(host, port, tlsConn) + return + } + s.relayHTTPStream(host, port, conn) +} + +func (s *Server) relayHTTPStream(host string, port int, conn net.Conn) { + reader := bufio.NewReader(conn) + for { + conn.SetDeadline(time.Now().Add(time.Duration(constants.ClientIdleTimeout) * time.Second)) + line, err := reader.ReadString('\n') + if err != nil { + return + } + if line == "\r\n" || line == "\n" { + continue + } + headers := []string{line} + for { + ln, err := reader.ReadString('\n') + if err != nil { + return + } + headers = append(headers, ln) + if ln == "\r\n" || ln == "\n" { + break + } + if sumLen(headers) > constants.MaxHeaderBytes { + return + } + } + method, path := parseRequestLine(line) + body, err := readBody(reader, headers) + if err != nil { + return + } + headerMap := parseHeaders(headers[1:]) + + urlStr := normalizeURL(host, port, path) + log.Infof("MITM -> %s %s", method, urlStr) + + origin := headerValue(headerMap, "origin") + acrMethod := headerValue(headerMap, "access-control-request-method") + acrHeaders := headerValue(headerMap, "access-control-request-headers") + if strings.ToUpper(method) == "OPTIONS" && acrMethod != "" { + resp := corsPreflight(origin, acrMethod, acrHeaders) + _, _ = conn.Write(resp) + continue + } + + response := s.fronter.Relay(method, urlStr, headerMap, body) + if origin != "" { + response = injectCORSHeaders(response, origin) + } + _, _ = conn.Write(response) + } +} + +func (s *Server) handlePlainHTTP(conn net.Conn, reader *bufio.Reader, headers []string) { + method, path := parseRequestLine(headers[0]) + body, err := readBody(reader, headers) + if err != nil { + return + } + headerMap := parseHeaders(headers[1:]) + + origin := headerValue(headerMap, "origin") + acrMethod := headerValue(headerMap, "access-control-request-method") + acrHeaders := headerValue(headerMap, "access-control-request-headers") + if strings.ToUpper(method) == "OPTIONS" && acrMethod != "" { + resp := corsPreflight(origin, acrMethod, acrHeaders) + _, _ = conn.Write(resp) + return + } + + urlStr := path + response := s.fronter.Relay(method, urlStr, headerMap, body) + if origin != "" { + response = injectCORSHeaders(response, origin) + } + _, _ = conn.Write(response) +} + +func (s *Server) handleSocksConn(conn net.Conn) { + defer conn.Close() + conn.SetDeadline(time.Now().Add(15 * time.Second)) + buf := make([]byte, 2) + if _, err := io.ReadFull(conn, buf); err != nil { + return + } + if buf[0] != 5 { + return + } + methods := make([]byte, int(buf[1])) + if _, err := io.ReadFull(conn, methods); err != nil { + return + } + conn.Write([]byte{0x05, 0x00}) + + request := make([]byte, 4) + if _, err := io.ReadFull(conn, request); err != nil { + return + } + if request[0] != 5 || request[1] != 0x01 { + conn.Write([]byte{0x05, 0x07, 0x00, 0x01, 0, 0, 0, 0, 0, 0}) + return + } + + addrType := request[3] + var host string + switch addrType { + case 0x01: + ip := make([]byte, 4) + if _, err := io.ReadFull(conn, ip); err != nil { + return + } + host = net.IP(ip).String() + case 0x03: + ln := make([]byte, 1) + if _, err := io.ReadFull(conn, ln); err != nil { + return + } + name := make([]byte, int(ln[0])) + if _, err := io.ReadFull(conn, name); err != nil { + return + } + host = string(name) + case 0x04: + ip := make([]byte, 16) + if _, err := io.ReadFull(conn, ip); err != nil { + return + } + host = net.IP(ip).String() + default: + conn.Write([]byte{0x05, 0x08, 0x00, 0x01, 0, 0, 0, 0, 0, 0}) + return + } + portBuf := make([]byte, 2) + if _, err := io.ReadFull(conn, portBuf); err != nil { + return + } + port := int(portBuf[0])<<8 | int(portBuf[1]) + + log.Infof("SOCKS5 CONNECT -> %s:%d", host, port) + conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0}) + + s.handleTunnel(host, port, conn, bufio.NewReader(conn)) +} + +func sumLen(lines []string) int { + count := 0 + for _, l := range lines { + count += len(l) + } + return count +} + +func parseRequestLine(line string) (string, string) { + parts := strings.Split(strings.TrimSpace(line), " ") + if len(parts) < 2 { + return "GET", "/" + } + return parts[0], parts[1] +} + +func parseHeaders(lines []string) map[string]string { + h := map[string]string{} + for _, ln := range lines { + ln = strings.TrimRight(ln, "\r\n") + if ln == "" { + continue + } + parts := strings.SplitN(ln, ":", 2) + if len(parts) != 2 { + continue + } + key := textproto.CanonicalMIMEHeaderKey(strings.TrimSpace(parts[0])) + val := strings.TrimSpace(parts[1]) + h[key] = val + } + return h +} + +func readBody(reader *bufio.Reader, headers []string) ([]byte, error) { + cl := 0 + for _, ln := range headers { + if strings.HasPrefix(strings.ToLower(ln), "content-length:") { + v := strings.TrimSpace(strings.TrimPrefix(ln, "Content-Length:")) + n, err := strconv.Atoi(v) + if err != nil || n < 0 { + return nil, errors.New("invalid Content-Length") + } + cl = n + } + } + if cl > constants.MaxRequestBodyBytes { + return nil, errors.New("request body too large") + } + if cl == 0 { + return nil, nil + } + buf := make([]byte, cl) + _, err := io.ReadFull(reader, buf) + return buf, err +} + +func normalizeURL(host string, port int, path string) string { + if strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") { + return path + } + scheme := "http" + if port == 443 { + scheme = "https" + } + if port == 80 || port == 443 { + return fmt.Sprintf("%s://%s%s", scheme, host, path) + } + return fmt.Sprintf("%s://%s:%d%s", scheme, host, port, path) +} + +func headerValue(headers map[string]string, name string) string { + for k, v := range headers { + if strings.ToLower(k) == name { + return v + } + } + return "" +} + +func corsPreflight(origin, acrMethod, acrHeaders string) []byte { + allowOrigin := origin + if allowOrigin == "" { + allowOrigin = "*" + } + allowMethods := "GET, POST, PUT, DELETE, PATCH, OPTIONS" + if acrMethod != "" { + allowMethods = acrMethod + ", " + allowMethods + } + allowHeaders := acrHeaders + if allowHeaders == "" { + allowHeaders = "*" + } + resp := "HTTP/1.1 204 No Content\r\n" + + "Access-Control-Allow-Origin: " + allowOrigin + "\r\n" + + "Access-Control-Allow-Methods: " + allowMethods + "\r\n" + + "Access-Control-Allow-Headers: " + allowHeaders + "\r\n" + + "Access-Control-Allow-Credentials: true\r\n" + + "Access-Control-Max-Age: 86400\r\n" + + "Vary: Origin\r\n" + + "Content-Length: 0\r\n\r\n" + return []byte(resp) +} + +func injectCORSHeaders(response []byte, origin string) []byte { + sep := []byte("\r\n\r\n") + idx := bytes.Index(response, sep) + if idx < 0 { + return response + } + head := string(response[:idx]) + body := response[idx+4:] + lines := strings.Split(head, "\r\n") + filtered := []string{} + for _, ln := range lines { + low := strings.ToLower(ln) + if strings.HasPrefix(low, "access-control-") { + continue + } + filtered = append(filtered, ln) + } + allowOrigin := origin + if allowOrigin == "" { + allowOrigin = "*" + } + filtered = append(filtered, + "Access-Control-Allow-Origin: "+allowOrigin, + "Access-Control-Allow-Credentials: true", + "Access-Control-Allow-Methods: GET, POST, PUT, DELETE, PATCH, OPTIONS", + "Access-Control-Allow-Headers: *", + "Access-Control-Expose-Headers: *", + "Vary: Origin", + ) + newHead := strings.Join(filtered, "\r\n") + "\r\n\r\n" + return append([]byte(newHead), body...) +} + +func splitHostPort(target string, defPort int) (string, int) { + if strings.Contains(target, ":") { + parts := strings.Split(target, ":") + if len(parts) >= 2 { + port, _ := strconv.Atoi(parts[len(parts)-1]) + return strings.Join(parts[:len(parts)-1], ":"), port + } + } + return target, defPort +} diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go new file mode 100644 index 0000000..9635c58 --- /dev/null +++ b/internal/scanner/scanner.go @@ -0,0 +1,127 @@ +package scanner + +import ( + "crypto/tls" + "fmt" + "net" + "sort" + "strings" + "time" + + "github.com/denuitt1/mhr-cfw/internal/constants" +) + +type ProbeResult struct { + IP string + LatencyMS *int + Error string +} + +func (r ProbeResult) OK() bool { + return r.LatencyMS != nil +} + +func ScanSync(frontDomain string) bool { + results := run(frontDomain) + + okCount := 0 + fmt.Printf("\nIP LATENCY STATUS\n") + fmt.Printf("------------------- ----------- -------------------------\n") + for _, r := range results { + if r.OK() { + fmt.Printf("%-19s %8dms OK\n", r.IP, *r.LatencyMS) + okCount++ + } else { + fmt.Printf("%-19s %-11s %s\n", r.IP, "-", r.Error) + } + } + fmt.Printf("\nResult: %d / %d reachable\n", okCount, len(results)) + + if okCount == 0 { + fmt.Println("No Google IPs reachable from this network.\n") + return false + } + + fastest := []ProbeResult{} + for _, r := range results { + if r.OK() { + fastest = append(fastest, r) + } + if len(fastest) == 3 { + break + } + } + fmt.Println("\nTop 3 fastest IPs:") + for i, r := range fastest { + fmt.Printf(" %d. %s (%dms)\n", i+1, r.IP, *r.LatencyMS) + } + fmt.Printf("\nRecommended: Set \"google_ip\": \"%s\" in config.json\n\n", fastest[0].IP) + return true +} + +func run(frontDomain string) []ProbeResult { + timeout := time.Duration(constants.GoogleScannerTimeout) * time.Second + sem := make(chan struct{}, constants.GoogleScannerConcurrency) + results := make([]ProbeResult, 0, len(constants.CandidateIPs)) + ch := make(chan ProbeResult, len(constants.CandidateIPs)) + + for _, ip := range constants.CandidateIPs { + ip := ip + sem <- struct{}{} + go func() { + defer func() { <-sem }() + ch <- probeIP(ip, frontDomain, timeout) + }() + } + + for i := 0; i < len(constants.CandidateIPs); i++ { + results = append(results, <-ch) + } + + sort.Slice(results, func(i, j int) bool { + ri, rj := results[i], results[j] + if ri.OK() != rj.OK() { + return ri.OK() + } + if !ri.OK() { + return ri.IP < rj.IP + } + return *ri.LatencyMS < *rj.LatencyMS + }) + return results +} + +func probeIP(ip, sni string, timeout time.Duration) ProbeResult { + start := time.Now() + dialer := &net.Dialer{Timeout: timeout} + raw, err := dialer.Dial("tcp", net.JoinHostPort(ip, "443")) + if err != nil { + return ProbeResult{IP: ip, Error: "network error"} + } + defer raw.Close() + + cfg := &tls.Config{ + ServerName: sni, + InsecureSkipVerify: true, + } + conn := tls.Client(raw, cfg) + _ = conn.SetDeadline(time.Now().Add(timeout)) + if err := conn.Handshake(); err != nil { + return ProbeResult{IP: ip, Error: "handshake failed"} + } + + req := fmt.Sprintf("HEAD / HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", sni) + if _, err := conn.Write([]byte(req)); err != nil { + return ProbeResult{IP: ip, Error: "write failed"} + } + buf := make([]byte, 256) + n, err := conn.Read(buf) + if err != nil || n == 0 { + return ProbeResult{IP: ip, Error: "empty response"} + } + if !strings.HasPrefix(string(buf[:n]), "HTTP/") { + return ProbeResult{IP: ip, Error: "invalid response"} + } + ms := int(time.Since(start).Milliseconds()) + return ProbeResult{IP: ip, LatencyMS: &ms} +} diff --git a/internal/setup/wizard.go b/internal/setup/wizard.go new file mode 100644 index 0000000..01f33cc --- /dev/null +++ b/internal/setup/wizard.go @@ -0,0 +1,366 @@ +package setup + +import ( + "bufio" + "encoding/json" + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "time" +) + +func RunInteractiveWizard(configPath string) error { + cfg := loadBaseConfig() + + reader := bufio.NewReader(os.Stdin) + ui := newWizardUI() + + ui.Space() + ui.Title("mhr-cfw setup") + ui.Subtitle("Guided configuration for the local relay proxy") + ui.Space() + + if _, err := os.Stat(configPath); err == nil { + if !promptYesNo(reader, ui, "config.json already exists. Overwrite?", false) { + ui.Muted("Nothing changed.") + return nil + } + } + + ui.Section("Shared password") + ui.Muted("Must match AUTH_KEY inside apps_script/Code.gs") + cfg["auth_key"] = prompt(reader, ui, "auth_key", randomAuthKey(32)) + + cfg = configureAppsScript(reader, cfg, ui) + cfg = configureNetwork(reader, cfg, ui) + + if err := writeConfig(configPath, cfg, ui); err != nil { + return err + } + + ui.Space() + ui.Ok("wrote " + filepath.Base(configPath)) + ui.Space() + ui.Section("Next step") + ui.Code("mhr-cfw") + ui.Space() + ui.Warn("AUTH_KEY inside apps_script/Code.gs must match the auth_key you entered") + return nil +} + +type wizardUI struct { + color bool +} + +func newWizardUI() *wizardUI { + color := supportsColor() + return &wizardUI{color: color} +} + +func (w *wizardUI) Space() { + fmt.Println() +} + +func (w *wizardUI) Title(text string) { + line := strings.Repeat("─", max(48, len(text)+12)) + if w.color { + fmt.Println(dim(line)) + fmt.Println(bold(cyan(" " + text + " "))) + fmt.Println(dim(line)) + return + } + fmt.Println(line) + fmt.Println(" " + text) + fmt.Println(line) +} + +func (w *wizardUI) Subtitle(text string) { + if w.color { + fmt.Println(dim(text)) + return + } + fmt.Println(text) +} + +func (w *wizardUI) Section(text string) { + if w.color { + fmt.Println(bold(cyan(text))) + return + } + fmt.Println(text) +} + +func (w *wizardUI) Step(n int, text string) { + label := fmt.Sprintf("%d.", n) + if w.color { + fmt.Println(dim(label), text) + return + } + fmt.Println(label, text) +} + +func (w *wizardUI) Code(text string) { + if w.color { + fmt.Println(dim(" $"), bold(text)) + return + } + fmt.Println(" $", text) +} + +func (w *wizardUI) Prompt(question, hint string) { + if hint != "" { + if w.color { + fmt.Printf("%s %s %s: ", cyan("?"), question, dim("["+hint+"]")) + return + } + fmt.Printf("? %s [%s]: ", question, hint) + return + } + if w.color { + fmt.Printf("%s %s: ", cyan("?"), question) + return + } + fmt.Printf("? %s: ", question) +} + +func (w *wizardUI) Ok(text string) { + if w.color { + fmt.Println(green("[OK]"), text) + return + } + fmt.Println("[OK]", text) +} + +func (w *wizardUI) Warn(text string) { + if w.color { + fmt.Println(yellow("!"), text) + return + } + fmt.Println("!", text) +} + +func (w *wizardUI) Error(text string) { + if w.color { + fmt.Println(red("!"), text) + return + } + fmt.Println("!", text) +} + +func (w *wizardUI) Muted(text string) { + if w.color { + fmt.Println(dim(text)) + return + } + fmt.Println(text) +} + +func supportsColor() bool { + if os.Getenv("NO_COLOR") != "" || os.Getenv("DFT_NO_COLOR") == "1" { + return false + } + if !isTTY(os.Stdout) { + return false + } + return true +} + +func isTTY(f *os.File) bool { + info, err := f.Stat() + if err != nil { + return false + } + return (info.Mode() & os.ModeCharDevice) != 0 +} + +func bold(s string) string { return "\x1b[1m" + s + "\x1b[0m" } +func dim(s string) string { return "\x1b[2m" + s + "\x1b[0m" } +func cyan(s string) string { return "\x1b[36m" + s + "\x1b[0m" } +func green(s string) string { return "\x1b[32m" + s + "\x1b[0m" } +func yellow(s string) string { return "\x1b[33m" + s + "\x1b[0m" } +func red(s string) string { return "\x1b[31m" + s + "\x1b[0m" } + +func max(a, b int) int { + if a > b { + return a + } + return b +} + +func loadBaseConfig() map[string]any { + return map[string]any{ + "mode": "apps_script", + "google_ip": "216.239.38.120", + "front_domain": "www.google.com", + "listen_host": "127.0.0.1", + "listen_port": 8085, + "socks5_enabled": true, + "socks5_port": 1080, + "log_level": "INFO", + "verify_ssl": true, + "lan_sharing": false, + "relay_timeout": 25, + "tls_connect_timeout": 15, + "tcp_connect_timeout": 10, + "max_response_body_bytes": 200 * 1024 * 1024, + "chunked_download_min_size": 5 * 1024 * 1024, + "chunked_download_chunk_size": 512 * 1024, + "chunked_download_max_parallel": 8, + "chunked_download_max_chunks": 256, + "hosts": map[string]string{}, + } +} + +func configureAppsScript(r *bufio.Reader, cfg map[string]any, ui *wizardUI) map[string]any { + ui.Section("Google Apps Script setup") + ui.Step(1, "Open https://script.google.com -> New project") + ui.Step(2, "Paste apps_script/Code.gs from this repo into the editor") + ui.Step(3, "Set AUTH_KEY in Code.gs to the password above") + ui.Step(4, "Deploy -> New deployment -> Web app") + ui.Step(5, "Execute as: Me | Who has access: Anyone") + ui.Step(6, "Copy the Deployment ID and paste it here") + ui.Space() + + idsRaw := prompt(r, ui, "Deployment ID(s) - comma-separated for load balancing", "") + ids := []string{} + for _, v := range strings.Split(idsRaw, ",") { + v = strings.TrimSpace(v) + if v != "" { + ids = append(ids, v) + } + } + if len(ids) == 1 { + cfg["script_id"] = ids[0] + delete(cfg, "script_ids") + } else if len(ids) > 1 { + cfg["script_ids"] = ids + delete(cfg, "script_id") + } + return cfg +} + +func configureNetwork(r *bufio.Reader, cfg map[string]any, ui *wizardUI) map[string]any { + ui.Section("Network settings") + ui.Muted("Press enter to accept defaults") + ui.Space() + + lanSharing := promptYesNo(r, ui, "Enable LAN sharing?", boolVal(cfg["lan_sharing"])) + cfg["lan_sharing"] = lanSharing + + defaultHost := strVal(cfg["listen_host"]) + if lanSharing && defaultHost == "127.0.0.1" { + defaultHost = "0.0.0.0" + } + cfg["listen_host"] = prompt(r, ui, "Listen host", defaultHost) + + port := prompt(r, ui, "HTTP proxy port", fmt.Sprintf("%v", cfg["listen_port"])) + cfg["listen_port"] = toInt(port, 8085) + + socks := promptYesNo(r, ui, "Enable SOCKS5 proxy?", boolVal(cfg["socks5_enabled"])) + cfg["socks5_enabled"] = socks + if socks { + sport := prompt(r, ui, "SOCKS5 port", fmt.Sprintf("%v", cfg["socks5_port"])) + cfg["socks5_port"] = toInt(sport, 1080) + } + return cfg +} + +func writeConfig(path string, cfg map[string]any, ui *wizardUI) error { + if _, err := os.Stat(path); err == nil { + backup := strings.TrimSuffix(path, ".json") + ".json.bak" + _ = copyFile(path, backup) + ui.Muted("existing config.json backed up to " + filepath.Base(backup)) + } + f, err := os.Create(path) + if err != nil { + return err + } + defer f.Close() + + enc := json.NewEncoder(f) + enc.SetIndent("", " ") + return enc.Encode(cfg) +} + +func copyFile(src, dst string) error { + input, err := os.ReadFile(src) + if err != nil { + return err + } + return os.WriteFile(dst, input, 0644) +} + +func prompt(r *bufio.Reader, ui *wizardUI, question, def string) string { + for { + if def != "" { + ui.Prompt(question, def) + } else { + ui.Prompt(question, "") + } + raw, _ := r.ReadString('\n') + raw = strings.TrimSpace(raw) + if raw == "" && def != "" { + return def + } + if raw != "" { + return raw + } + ui.Error("value required") + } +} + +func promptYesNo(r *bufio.Reader, ui *wizardUI, question string, def bool) bool { + hint := "Y/n" + if !def { + hint = "y/N" + } + for { + ui.Prompt(question, hint) + raw, _ := r.ReadString('\n') + raw = strings.TrimSpace(strings.ToLower(raw)) + if raw == "" { + return def + } + if raw == "y" || raw == "yes" { + return true + } + if raw == "n" || raw == "no" { + return false + } + } +} + +func randomAuthKey(length int) string { + const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + out := make([]byte, length) + seed := time.Now().UnixNano() + for i := range out { + seed = (seed*1664525 + 1013904223) & 0x7fffffff + out[i] = alphabet[int(seed)%len(alphabet)] + } + return string(out) +} + +func boolVal(v any) bool { + if b, ok := v.(bool); ok { + return b + } + return false +} + +func strVal(v any) string { + if s, ok := v.(string); ok { + return s + } + return "" +} + +func toInt(s string, def int) int { + i, err := strconv.Atoi(strings.TrimSpace(s)) + if err != nil { + return def + } + return i +} diff --git a/internal/tui/menu.go b/internal/tui/menu.go new file mode 100644 index 0000000..650636f --- /dev/null +++ b/internal/tui/menu.go @@ -0,0 +1,148 @@ +package tui + +import ( + "bufio" + "fmt" + "os" + "strconv" + "strings" +) + +type Option struct { + Key int + Label string + Handler func() error +} + +type Menu struct { + Title string + Options []Option +} + +func (m *Menu) Run() error { + reader := bufio.NewReader(os.Stdin) + for { + clearScreen() + m.render() + fmt.Print("Select an option: ") + line, _ := reader.ReadString('\n') + line = strings.TrimSpace(line) + if line == "" { + continue + } + idx, err := strconv.Atoi(line) + if err != nil { + fmt.Println("Invalid selection.") + continue + } + for _, opt := range m.Options { + if opt.Key == idx { + if opt.Handler == nil { + return nil + } + if err := opt.Handler(); err != nil { + fmt.Println("Error:", err) + } + fmt.Print("\nPress Enter to return to menu...") + _, _ = reader.ReadString('\n') + break + } + } + } +} + +func (m *Menu) render() { + useColor := supportsColor() + width := max(70, len(m.Title)+16) + borderTop := "╔ " + strings.Repeat("═", width) + " ╗" + borderMid := "╠" + strings.Repeat("═", width+2) + "╣" + borderBot := "╚ " + strings.Repeat("═", width) + " ╝" + inner := "║" + strings.Repeat(" ", width+2) + "║" + tag := "Mhr-Cfw-Go V1.0" + link := "https://github.com/ThisIsDara/" + + centerText := func(text string) string { + pad := width + 2 - len(text) + left := pad / 2 + right := pad - left + return strings.Repeat(" ", left) + text + strings.Repeat(" ", right) + } + + fmt.Println() + fmt.Println(borderTop) + fmt.Println(inner) + + if useColor { + fmt.Println(cyan(centerText(tag))) + fmt.Println(faint(centerText(link))) + } else { + fmt.Println(centerText(tag)) + fmt.Println(centerText(link)) + } + + fmt.Println(inner) + fmt.Println(borderMid) + + for _, opt := range m.Options { + label := fmt.Sprintf("%d) %s", opt.Key, opt.Label) + if useColor { + fmt.Println(" " + violet(">") + " " + bold(ice(fmt.Sprintf("%d)", opt.Key))) + " " + label[3:]) + } else { + fmt.Println(" * " + label) + } + } + + if useColor { + fmt.Println(dim(borderBot)) + } else { + fmt.Println(borderBot) + } + fmt.Println() +} + +func supportsColor() bool { + if os.Getenv("NO_COLOR") != "" || os.Getenv("DFT_NO_COLOR") == "1" { + return false + } + if !isTTY(os.Stdout) { + return false + } + return true +} + +func clearScreen() { + if !supportsColor() { + return + } + fmt.Print("\x1b[2J\x1b[H") +} + +func isTTY(f *os.File) bool { + info, err := f.Stat() + if err != nil { + return false + } + return (info.Mode() & os.ModeCharDevice) != 0 +} + +func pad(s string, width int) string { + if len(s) >= width { + return s[:width] + } + return s + strings.Repeat(" ", width-len(s)) +} + +func bold(s string) string { return "\x1b[1m" + s + "\x1b[0m" } +func dim(s string) string { return "\x1b[2m" + s + "\x1b[0m" } +func faint(s string) string { return "\x1b[38;5;250m" + s + "\x1b[0m" } +func teal(s string) string { return "\x1b[1;38;5;45m" + s + "\x1b[0m" } +func ice(s string) string { return "\x1b[1;38;5;81m" + s + "\x1b[0m" } +func violet(s string) string { return "\x1b[38;5;141m" + s + "\x1b[0m" } +func cyan(s string) string { return "\x1b[1;36m" + s + "\x1b[0m" } + +func max(a, b int) int { + if a > b { + return a + } + return b +}