Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 export_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package httpproxy func ExportUseProxy(cfg Config, host string) bool { cfg1 := &config{ Config: cfg, } cfg1.init() return cfg1.useProxy(host) }	312 B	2025-05-25 12:27
📄 go19_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.9 package httpproxy_test import "testing" func init() { setHelper = func(t *testing.T) { t.Helper() } }	283 B	2025-05-25 12:27
📄 proxy.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package httpproxy provides support for HTTP proxy determination // based on environment variables, as provided by net/http's // ProxyFromEnvironment function. // // The API is not subject to the Go 1 compatibility promise and may change at // any time. package httpproxy import ( "errors" "fmt" "net" "net/url" "os" "strings" "unicode/utf8" "golang.org/x/net/idna" ) // Config holds configuration for HTTP proxy settings. See // FromEnvironment for details. type Config struct { // HTTPProxy represents the value of the HTTP_PROXY or // http_proxy environment variable. It will be used as the proxy // URL for HTTP requests unless overridden by NoProxy. HTTPProxy string // HTTPSProxy represents the HTTPS_PROXY or https_proxy // environment variable. It will be used as the proxy URL for // HTTPS requests unless overridden by NoProxy. HTTPSProxy string // NoProxy represents the NO_PROXY or no_proxy environment // variable. It specifies a string that contains comma-separated values // specifying hosts that should be excluded from proxying. Each value is // represented by an IP address prefix (1.2.3.4), an IP address prefix in // CIDR notation (1.2.3.4/8), a domain name, or a special DNS label (). // An IP address prefix and domain name can also include a literal port // number (1.2.3.4:80). // A domain name matches that name and all subdomains. A domain name with // a leading "." matches subdomains only. For example "foo.com" matches // "foo.com" and "bar.foo.com"; ".y.com" matches "x.y.com" but not "y.com". // A single asterisk () indicates that no proxying should be done. // A best effort is made to parse the string and errors are // ignored. NoProxy string // CGI holds whether the current process is running // as a CGI handler (FromEnvironment infers this from the // presence of a REQUEST_METHOD environment variable). // When this is set, ProxyForURL will return an error // when HTTPProxy applies, because a client could be // setting HTTP_PROXY maliciously. See https://golang.org/s/cgihttpproxy. CGI bool } // config holds the parsed configuration for HTTP proxy settings. type config struct { // Config represents the original configuration as defined above. Config // httpsProxy is the parsed URL of the HTTPSProxy if defined. httpsProxy url.URL // httpProxy is the parsed URL of the HTTPProxy if defined. httpProxy url.URL // ipMatchers represent all values in the NoProxy that are IP address // prefixes or an IP address in CIDR notation. ipMatchers []matcher // domainMatchers represent all values in the NoProxy that are a domain // name or hostname & domain name domainMatchers []matcher } // FromEnvironment returns a Config instance populated from the // environment variables HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the // lowercase versions thereof). // // The environment values may be either a complete URL or a // "host[:port]", in which case the "http" scheme is assumed. An error // is returned if the value is a different form. func FromEnvironment() Config { return &Config{ HTTPProxy: getEnvAny("HTTP_PROXY", "http_proxy"), HTTPSProxy: getEnvAny("HTTPS_PROXY", "https_proxy"), NoProxy: getEnvAny("NO_PROXY", "no_proxy"), CGI: os.Getenv("REQUEST_METHOD") != "", } } func getEnvAny(names ...string) string { for _, n := range names { if val := os.Getenv(n); val != "" { return val } } return "" } // ProxyFunc returns a function that determines the proxy URL to use for // a given request URL. Changing the contents of cfg will not affect // proxy functions created earlier. // // A nil URL and nil error are returned if no proxy is defined in the // environment, or a proxy should not be used for the given request, as // defined by NO_PROXY. // // As a special case, if req.URL.Host is "localhost" or a loopback address // (with or without a port number), then a nil URL and nil error will be returned. func (cfg Config) ProxyFunc() func(reqURL url.URL) (url.URL, error) { // Preprocess the Config settings for more efficient evaluation. cfg1 := &config{ Config: cfg, } cfg1.init() return cfg1.proxyForURL } func (cfg config) proxyForURL(reqURL url.URL) (url.URL, error) { var proxy url.URL if reqURL.Scheme == "https" { proxy = cfg.httpsProxy } else if reqURL.Scheme == "http" { proxy = cfg.httpProxy if proxy != nil && cfg.CGI { return nil, errors.New("refusing to use HTTP_PROXY value in CGI environment; see golang.org/s/cgihttpproxy") } } if proxy == nil { return nil, nil } if !cfg.useProxy(canonicalAddr(reqURL)) { return nil, nil } return proxy, nil } func parseProxy(proxy string) (url.URL, error) { if proxy == "" { return nil, nil } proxyURL, err := url.Parse(proxy) if err != nil \|\| proxyURL.Scheme == "" \|\| proxyURL.Host == "" { // proxy was bogus. Try prepending "http://" to it and // see if that parses correctly. If not, we fall // through and complain about the original one. if proxyURL, err := url.Parse("http://" + proxy); err == nil { return proxyURL, nil } } if err != nil { return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err) } return proxyURL, nil } // useProxy reports whether requests to addr should use a proxy, // according to the NO_PROXY or no_proxy environment variable. // addr is always a canonicalAddr with a host and port. func (cfg config) useProxy(addr string) bool { if len(addr) == 0 { return true } host, port, err := net.SplitHostPort(addr) if err != nil { return false } if host == "localhost" { return false } ip := net.ParseIP(host) if ip != nil { if ip.IsLoopback() { return false } } addr = strings.ToLower(strings.TrimSpace(host)) if ip != nil { for _, m := range cfg.ipMatchers { if m.match(addr, port, ip) { return false } } } for _, m := range cfg.domainMatchers { if m.match(addr, port, ip) { return false } } return true } func (c config) init() { if parsed, err := parseProxy(c.HTTPProxy); err == nil { c.httpProxy = parsed } if parsed, err := parseProxy(c.HTTPSProxy); err == nil { c.httpsProxy = parsed } for _, p := range strings.Split(c.NoProxy, ",") { p = strings.ToLower(strings.TrimSpace(p)) if len(p) == 0 { continue } if p == "" { c.ipMatchers = []matcher{allMatch{}} c.domainMatchers = []matcher{allMatch{}} return } // IPv4/CIDR, IPv6/CIDR if _, pnet, err := net.ParseCIDR(p); err == nil { c.ipMatchers = append(c.ipMatchers, cidrMatch{cidr: pnet}) continue } // IPv4:port, [IPv6]:port phost, pport, err := net.SplitHostPort(p) if err == nil { if len(phost) == 0 { // There is no host part, likely the entry is malformed; ignore. continue } if phost[0] == '[' && phost[len(phost)-1] == ']' { phost = phost[1 : len(phost)-1] } } else { phost = p } // IPv4, IPv6 if pip := net.ParseIP(phost); pip != nil { c.ipMatchers = append(c.ipMatchers, ipMatch{ip: pip, port: pport}) continue } if len(phost) == 0 { // There is no host part, likely the entry is malformed; ignore. continue } // domain.com or domain.com:80 // foo.com matches bar.foo.com // .domain.com or .domain.com:port // .domain.com or .domain.com:port if strings.HasPrefix(phost, ".") { phost = phost[1:] } matchHost := false if phost[0] != '.' { matchHost = true phost = "." + phost } if v, err := idnaASCII(phost); err == nil { phost = v } c.domainMatchers = append(c.domainMatchers, domainMatch{host: phost, port: pport, matchHost: matchHost}) } } var portMap = map[string]string{ "http": "80", "https": "443", "socks5": "1080", } // canonicalAddr returns url.Host but always with a ":port" suffix func canonicalAddr(url url.URL) string { addr := url.Hostname() if v, err := idnaASCII(addr); err == nil { addr = v } port := url.Port() if port == "" { port = portMap[url.Scheme] } return net.JoinHostPort(addr, port) } // Given a string of the form "host", "host:port", or "[ipv6::address]:port", // return true if the string includes a port. func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") } func idnaASCII(v string) (string, error) { // TODO: Consider removing this check after verifying performance is okay. // Right now punycode verification, length checks, context checks, and the // permissible character tests are all omitted. It also prevents the ToASCII // call from salvaging an invalid IDN, when possible. As a result it may be // possible to have two IDNs that appear identical to the user where the // ASCII-only version causes an error downstream whereas the non-ASCII // version does not. // Note that for correct ASCII IDNs ToASCII will only do considerably more // work, but it will not cause an allocation. if isASCII(v) { return v, nil } return idna.Lookup.ToASCII(v) } func isASCII(s string) bool { for i := 0; i < len(s); i++ { if s[i] >= utf8.RuneSelf { return false } } return true } // matcher represents the matching rule for a given value in the NO_PROXY list type matcher interface { // match returns true if the host and optional port or ip and optional port // are allowed match(host, port string, ip net.IP) bool } // allMatch matches on all possible inputs type allMatch struct{} func (a allMatch) match(host, port string, ip net.IP) bool { return true } type cidrMatch struct { cidr net.IPNet } func (m cidrMatch) match(host, port string, ip net.IP) bool { return m.cidr.Contains(ip) } type ipMatch struct { ip net.IP port string } func (m ipMatch) match(host, port string, ip net.IP) bool { if m.ip.Equal(ip) { return m.port == "" \|\| m.port == port } return false } type domainMatch struct { host string port string matchHost bool } func (m domainMatch) match(host, port string, ip net.IP) bool { if strings.HasSuffix(host, m.host) \|\| (m.matchHost && host == m.host[1:]) { return m.port == "" \|\| m.port == port } return false }	9.97 KB	2025-05-25 12:27
📄 proxy_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package httpproxy_test import ( "bytes" "errors" "fmt" "net/url" "os" "strings" "testing" "golang.org/x/net/http/httpproxy" ) // setHelper calls t.Helper() for Go 1.9+ (see go19_test.go) and does nothing otherwise. var setHelper = func(t testing.T) {} type proxyForURLTest struct { cfg httpproxy.Config req string // URL to fetch; blank means "http://example.com" want string wanterr error } func (t proxyForURLTest) String() string { var buf bytes.Buffer space := func() { if buf.Len() > 0 { buf.WriteByte(' ') } } if t.cfg.HTTPProxy != "" { fmt.Fprintf(&buf, "http_proxy=%q", t.cfg.HTTPProxy) } if t.cfg.HTTPSProxy != "" { space() fmt.Fprintf(&buf, "https_proxy=%q", t.cfg.HTTPSProxy) } if t.cfg.NoProxy != "" { space() fmt.Fprintf(&buf, "no_proxy=%q", t.cfg.NoProxy) } req := "http://example.com" if t.req != "" { req = t.req } space() fmt.Fprintf(&buf, "req=%q", req) return strings.TrimSpace(buf.String()) } var proxyForURLTests = []proxyForURLTest{{ cfg: httpproxy.Config{ HTTPProxy: "127.0.0.1:8080", }, want: "http://127.0.0.1:8080", }, { cfg: httpproxy.Config{ HTTPProxy: "cache.corp.example.com:1234", }, want: "http://cache.corp.example.com:1234", }, { cfg: httpproxy.Config{ HTTPProxy: "cache.corp.example.com", }, want: "http://cache.corp.example.com", }, { // single label domain is recognized as scheme by url.Parse cfg: httpproxy.Config{ HTTPProxy: "localhost", }, want: "http://localhost", }, { cfg: httpproxy.Config{ HTTPProxy: "https://cache.corp.example.com", }, want: "https://cache.corp.example.com", }, { cfg: httpproxy.Config{ HTTPProxy: "http://127.0.0.1:8080", }, want: "http://127.0.0.1:8080", }, { cfg: httpproxy.Config{ HTTPProxy: "https://127.0.0.1:8080", }, want: "https://127.0.0.1:8080", }, { cfg: httpproxy.Config{ HTTPProxy: "socks5://127.0.0.1", }, want: "socks5://127.0.0.1", }, { // Preserve unknown schemes. cfg: httpproxy.Config{ HTTPProxy: "foo://host", }, want: "foo://host", }, { // Don't use secure for http cfg: httpproxy.Config{ HTTPProxy: "http.proxy.tld", HTTPSProxy: "secure.proxy.tld", }, req: "http://insecure.tld/", want: "http://http.proxy.tld", }, { // Use secure for https. cfg: httpproxy.Config{ HTTPProxy: "http.proxy.tld", HTTPSProxy: "secure.proxy.tld", }, req: "https://secure.tld/", want: "http://secure.proxy.tld", }, { cfg: httpproxy.Config{ HTTPProxy: "http.proxy.tld", HTTPSProxy: "https://secure.proxy.tld", }, req: "https://secure.tld/", want: "https://secure.proxy.tld", }, { cfg: httpproxy.Config{ HTTPProxy: "http.proxy.tld", }, req: "https://secure.tld/", want: "<nil>", }, { cfg: httpproxy.Config{ HTTPProxy: "http.proxy.tld", }, req: "ftp://insecure.tld/", want: "<nil>", }, { // Issue 16405: don't use HTTP_PROXY in a CGI environment, // where HTTP_PROXY can be attacker-controlled. cfg: httpproxy.Config{ HTTPProxy: "http://10.1.2.3:8080", CGI: true, }, want: "<nil>", wanterr: errors.New("refusing to use HTTP_PROXY value in CGI environment; see golang.org/s/cgihttpproxy"), }, { // HTTPS proxy is still used even in CGI environment. // (perhaps dubious but it's the historical behaviour). cfg: httpproxy.Config{ HTTPSProxy: "https://secure.proxy.tld", CGI: true, }, req: "https://secure.tld/", want: "https://secure.proxy.tld", }, { want: "<nil>", }, { cfg: httpproxy.Config{ NoProxy: "example.com", HTTPProxy: "proxy", }, req: "http://example.com/", want: "<nil>", }, { cfg: httpproxy.Config{ NoProxy: ".example.com", HTTPProxy: "proxy", }, req: "http://example.com/", want: "http://proxy", }, { cfg: httpproxy.Config{ NoProxy: "ample.com", HTTPProxy: "proxy", }, req: "http://example.com/", want: "http://proxy", }, { cfg: httpproxy.Config{ NoProxy: "example.com", HTTPProxy: "proxy", }, req: "http://foo.example.com/", want: "<nil>", }, { cfg: httpproxy.Config{ NoProxy: ".foo.com", HTTPProxy: "proxy", }, req: "http://example.com/", want: "http://proxy", }, { cfg: httpproxy.Config{ NoProxy: ".示例.com", HTTPProxy: "proxy", }, req: "http://www.示例.com", want: "<nil>", }, { cfg: httpproxy.Config{ NoProxy: "xn--fsq092h.com", HTTPProxy: "proxy", }, req: "http://www.示例.com", want: "<nil>", }, { cfg: httpproxy.Config{ NoProxy: "示例.com", HTTPProxy: "proxy", }, req: "http://www.xn--fsq092h.com", want: "<nil>", }, } func testProxyForURL(t testing.T, tt proxyForURLTest) { setHelper(t) reqURLStr := tt.req if reqURLStr == "" { reqURLStr = "http://example.com" } reqURL, err := url.Parse(reqURLStr) if err != nil { t.Errorf("invalid URL %q", reqURLStr) return } cfg := tt.cfg proxyForURL := cfg.ProxyFunc() url, err := proxyForURL(reqURL) if g, e := fmt.Sprintf("%v", err), fmt.Sprintf("%v", tt.wanterr); g != e { t.Errorf("%v: got error = %q, want %q", tt, g, e) return } if got := fmt.Sprintf("%s", url); got != tt.want { t.Errorf("%v: got URL = %q, want %q", tt, url, tt.want) } // Check that changing the Config doesn't change the results // of the functuon. cfg = httpproxy.Config{} url, err = proxyForURL(reqURL) if g, e := fmt.Sprintf("%v", err), fmt.Sprintf("%v", tt.wanterr); g != e { t.Errorf("(after mutating config) %v: got error = %q, want %q", tt, g, e) return } if got := fmt.Sprintf("%s", url); got != tt.want { t.Errorf("(after mutating config) %v: got URL = %q, want %q", tt, url, tt.want) } } func TestProxyForURL(t testing.T) { for _, tt := range proxyForURLTests { testProxyForURL(t, tt) } } func TestFromEnvironment(t testing.T) { os.Setenv("HTTP_PROXY", "httpproxy") os.Setenv("HTTPS_PROXY", "httpsproxy") os.Setenv("NO_PROXY", "noproxy") os.Setenv("REQUEST_METHOD", "") got := httpproxy.FromEnvironment() want := httpproxy.Config{ HTTPProxy: "httpproxy", HTTPSProxy: "httpsproxy", NoProxy: "noproxy", } if got != want { t.Errorf("unexpected proxy config, got %#v want %#v", got, want) } } func TestFromEnvironmentWithRequestMethod(t testing.T) { os.Setenv("HTTP_PROXY", "httpproxy") os.Setenv("HTTPS_PROXY", "httpsproxy") os.Setenv("NO_PROXY", "noproxy") os.Setenv("REQUEST_METHOD", "PUT") got := httpproxy.FromEnvironment() want := httpproxy.Config{ HTTPProxy: "httpproxy", HTTPSProxy: "httpsproxy", NoProxy: "noproxy", CGI: true, } if got != want { t.Errorf("unexpected proxy config, got %#v want %#v", got, want) } } func TestFromEnvironmentLowerCase(t testing.T) { os.Setenv("http_proxy", "httpproxy") os.Setenv("https_proxy", "httpsproxy") os.Setenv("no_proxy", "noproxy") os.Setenv("REQUEST_METHOD", "") got := httpproxy.FromEnvironment() want := httpproxy.Config{ HTTPProxy: "httpproxy", HTTPSProxy: "httpsproxy", NoProxy: "noproxy", } if got != want { t.Errorf("unexpected proxy config, got %#v want %#v", got, want) } } var UseProxyTests = []struct { host string match bool }{ // Never proxy localhost: {"localhost", false}, {"127.0.0.1", false}, {"127.0.0.2", false}, {"[::1]", false}, {"[::2]", true}, // not a loopback address {"192.168.1.1", false}, // matches exact IPv4 {"192.168.1.2", true}, // ports do not match {"192.168.1.3", false}, // matches exact IPv4:port {"192.168.1.4", true}, // no match {"10.0.0.2", false}, // matches IPv4/CIDR {"[2001:db8::52:0:1]", false}, // matches exact IPv6 {"[2001:db8::52:0:2]", true}, // no match {"[2001:db8::52:0:3]", false}, // matches exact [IPv6]:port {"[2002:db8:a::123]", false}, // matches IPv6/CIDR {"[fe80::424b:c8be:1643:a1b6]", true}, // no match {"barbaz.net", true}, // does not match as .barbaz.net {"www.barbaz.net", false}, // does match as .barbaz.net {"foobar.com", false}, // does match as foobar.com {"www.foobar.com", false}, // match because NO_PROXY includes "foobar.com" {"foofoobar.com", true}, // not match as a part of foobar.com {"baz.com", true}, // not match as a part of barbaz.com {"localhost.net", true}, // not match as suffix of address {"local.localhost", true}, // not match as prefix as address {"barbarbaz.net", true}, // not match, wrong domain {"wildcard.io", true}, // does not match as .wildcard.io {"nested.wildcard.io", false}, // match as .wildcard.io {"awildcard.io", true}, // not a match because of '' } var noProxy = "foobar.com, .barbaz.net, .wildcard.io, 192.168.1.1, 192.168.1.2:81, 192.168.1.3:80, 10.0.0.0/30, 2001:db8::52:0:1, [2001:db8::52:0:2]:443, [2001:db8::52:0:3]:80, 2002:db8:a::45/64" func TestUseProxy(t testing.T) { cfg := &httpproxy.Config{ NoProxy: noProxy, } for _, test := range UseProxyTests { if httpproxy.ExportUseProxy(cfg, test.host+":80") != test.match { t.Errorf("useProxy(%v) = %v, want %v", test.host, !test.match, test.match) } } } func TestInvalidNoProxy(t testing.T) { cfg := &httpproxy.Config{ NoProxy: ":1", } ok := httpproxy.ExportUseProxy(cfg, "example.com:80") // should not panic if !ok { t.Errorf("useProxy unexpected return; got false; want true") } } func TestAllNoProxy(t testing.T) { cfg := &httpproxy.Config{ NoProxy: "", } for _, test := range UseProxyTests { if httpproxy.ExportUseProxy(cfg, test.host+":80") != false { t.Errorf("useProxy(%v) = true, want false", test.host) } } } func BenchmarkProxyForURL(b testing.B) { cfg := &httpproxy.Config{ HTTPProxy: "http://proxy.example.org", HTTPSProxy: "https://proxy.example.org", NoProxy: noProxy, } for _, test := range UseProxyTests { u, err := url.Parse("https://" + test.host + ":80") if err != nil { b.Fatalf("parsed failed: %s", test.host) } proxyFunc := cfg.ProxyFunc() b.Run(test.host, func(b *testing.B) { for n := 0; n < b.N; n++ { if au, e := proxyFunc(u); e != nil && test.match == (au != nil) { b.Errorf("useProxy(%v) = %v, want %v", test.host, !test.match, test.match) } } }) } }	10.06 KB	2025-05-25 12:27

Terminal