Merge pull request #236 from SenseUnit/pac_ex

JS: Microsoft's PAC extensions for IPv6

Author: Snawoot

README.md

@@ -459,15 +459,20 @@ Following builtin functions are addionally available within JS scripts:
   * `timeRange(...): boolean` - returns true if current time matches specified time range. See [full documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Proxy_servers_and_tunneling/Proxy_Auto-Configuration_PAC_file#timerange).
 * Address manipulation:
   * `myIpAddress(): string` - returns the IP address of the machine dumbproxy is running on.
+  * `myIpAddressEx(): string` - returns semi-colon delimited string containing all IP addresses for localhost (IPv6 and/or IPv4), or an empty string if unable to resolve localhost to an IP address.
   * `isPlainHostName(host: string): boolean` - returns true if and only if there is no domain name in the hostname (no dots).
   * `dnsDomainIs(host: string, domain: string): boolean` - returns true if and only if the domain of hostname matches.
   * `localHostOrDomainIs(host: string, hostDom: string): boolean` - returns true if the hostname matches exactly the specified hostname, or if there is no domain name part in the hostname, but the unqualified hostname matches.
   * `dnsDomainLevels(host: string): number` - returns the number (integer) of DNS domain levels (number of dots) in the hostname. Trailing dot representing DNS root is stripped from domain name before counting.
   * `convert_addr(IP: string): number | BigInt` - returns numeric representation of IP address or `NaN` if argument can't be converted to an IP address. IPv6 addresses are converted to BigInt.
   * `shExpMatch(str: string, shExp: string): boolean` - returns true if the string matches the specified shell glob expression.
   * `dnsResolve(host: string): string | null` - resolves the given DNS hostname into an IP address, and returns it in the dot-separated format as a string. **WARNING:** expect heavy performance penalty from use of this function.
-  * `isResolvable(host: string): boolean` - tries to resolve the hostname. Returns true if succeeds. **WARNING:** expect heavy performance penalty from use of this function.
+  * `dnsResolveEx(host: string): string` - returns semicolon delimited string containing IPv6 and IPv4 addresses or an empty string if host is not resolvable. **WARNING:** expect heavy performance penalty from use of this function.
+  * `isResolvable(host: string): boolean` - tries to resolve the hostname to IPv4 address. Returns true if succeeds. **WARNING:** expect heavy performance penalty from use of this function.
+  * `isResolvableEx(host: string): boolean` - tries to resolve the hostname to IPv4 or IPv6 address. Returns true if succeeds. **WARNING:** expect heavy performance penalty from use of this function.
   * `isInNet(host: string, pattern: string, mask: string): boolean` - true if and only if the IP address of the host matches the specified IP address pattern. See also [full documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Proxy_servers_and_tunneling/Proxy_Auto-Configuration_PAC_file#isinnet). **WARNING:** expect heavy performance penalty from use of this function if invoked with domain name as host argument.
+  * `isInNetEx(host: string, cidrPrefix: string): boolean` - true if and only if the IP address of the host matches the specified IP address prefix. See also [full documentation](https://learn.microsoft.com/en-us/windows/win32/winhttp/isinnetex).
+  * `sortIpAddressList(host: string): string` - returns list of sorted semi-colon delimited IP addresses or an empty string if unable to sort the IP address list.
   * `newStopAddressIteration(): Exception` - create an exception which, once `throw`n, halts further invocations of JS function with different resolved addresses for that request. Useful to cut excess JS calls of access filter scripts which can conclude access denial without looking further into remaining resolved addresses.
 
 Following objects are additionally available in global scope of JS scripts:

dialer/jsrouter.go

@@ -86,6 +86,10 @@ func NewJSRouter(filename string, instances int, factory func(string) (Dialer, e
 			if err != nil {
 				return fmt.Errorf("can't add ProxyObject.bindings into execution context: %w", err)
 			}
+			err = jsext.AddGetClientVersion(vm)
+			if err != nil {
+				return fmt.Errorf("can't add getClientVersion function: %w", err)
+			}
 			_, err = vm.RunString(string(script))
 			if err != nil {
 				return fmt.Errorf("script run failed: %w", err)

jsext/addrutil.go

@@ -6,6 +6,8 @@ import (
 	"math/big"
 	"net"
 	"net/netip"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/dop251/goja"
@@ -148,3 +150,119 @@ func AddIsInNet(vm *goja.Runtime) error {
 		return vm.ToValue(r&m == p&m)
 	})
 }
+
+func myIPAddressEx() []netip.Addr {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil
+	}
+	res := make([]netip.Addr, 0, len(addrs))
+	for _, addr := range addrs {
+		ipnet, ok := addr.(*net.IPNet)
+		if !ok {
+			continue
+		}
+		na, ok := netip.AddrFromSlice(ipnet.IP)
+		if !ok {
+			continue
+		}
+		res = append(res, na.Unmap())
+	}
+	return res
+}
+
+func AddMyIPAddressEx(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("myIpAddressEx", func(call goja.FunctionCall) goja.Value {
+		res := mapSlice(myIPAddressEx(), func(a netip.Addr) string { return a.String() })
+		return vm.ToValue(strings.Join(res, ";"))
+	})
+}
+
+func netipAddrCmp(a, b netip.Addr) int {
+	if a.Is6() == b.Is6() {
+		if a.Less(b) {
+			return -1
+		} else if b.Less(a) {
+			return 1
+		}
+		return 0
+	} else {
+		if a.Is6() {
+			return -1
+		} else {
+			return 1
+		}
+	}
+}
+
+func AddSortIPAddressList(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("sortIpAddressList", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) != 1 {
+			panic(vm.NewTypeError("sortIpAddressList expects exactly 1 argument"))
+		}
+		addrParts := strings.Split(call.Argument(0).String(), ";")
+		addrs := make([]netip.Addr, 0, len(addrParts))
+		for _, part := range addrParts {
+			addr, err := netip.ParseAddr(part)
+			if err != nil {
+				return vm.ToValue("")
+			}
+			addrs = append(addrs, addr)
+		}
+		slices.SortFunc(addrs, netipAddrCmp)
+		res := mapSlice(addrs, func(a netip.Addr) string { return a.String() })
+		return vm.ToValue(strings.Join(res, ";"))
+	})
+}
+
+func dnsResolveEx(host string) []netip.Addr {
+	ctx, cl := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cl()
+	// lookup "ip" network for better cache coherence with other lookups,
+	// even though we actually interested only in IPv4 only
+	addrs, err := DefaultResolver.LookupNetIP(ctx, "ip", host)
+	if err != nil {
+		return nil
+	}
+	for i := range addrs {
+		addrs[i] = addrs[i].Unmap()
+	}
+	return addrs
+}
+
+func AddDNSResolveEx(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("dnsResolveEx", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) != 1 {
+			panic(vm.NewTypeError("dnsResolveEx expects exactly 1 argument"))
+		}
+		res := mapSlice(dnsResolveEx(call.Argument(0).String()), func(a netip.Addr) string { return a.String() })
+		return vm.ToValue(strings.Join(res, ";"))
+	})
+}
+
+func AddIsResolvableEx(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("isResolvableEx", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) != 1 {
+			panic(vm.NewTypeError("isResolvableEx expects exactly 1 argument"))
+		}
+		res := dnsResolveEx(call.Argument(0).String())
+		return vm.ToValue(len(res) > 0)
+	})
+}
+
+func AddIsInNetEx(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("isInNetEx", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) != 2 {
+			panic(vm.NewTypeError("isInNet expects exactly 2 arguments"))
+		}
+		host, err := netip.ParseAddr(call.Argument(0).String())
+		if err != nil {
+			return vm.ToValue(false)
+		}
+		pfx, err := netip.ParsePrefix(call.Argument(1).String())
+		if err != nil {
+			return vm.ToValue(false)
+		}
+		return vm.ToValue(pfx.Contains(host))
+	})
+}

jsext/jsext.go

@@ -28,13 +28,26 @@ func ConfigureRuntime(vm *goja.Runtime) error {
 		AddDateRange,
 		AddTimeRange,
 		AddMyIPAddress,
+		AddMyIPAddressEx,
 		AddDNSResolve,
+		AddDNSResolveEx,
 		AddIsResolvable,
+		AddIsResolvableEx,
 		AddIsInNet,
+		AddIsInNetEx,
+		AddSortIPAddressList,
 	} {
 		if err := f(vm); err != nil {
 			return fmt.Errorf("JS runtime init part #%d failed: %w", idx+1, err)
 		}
 	}
 	return nil
 }
+
+const PACClientVersion = "1.0"
+
+func AddGetClientVersion(vm *goja.Runtime) error {
+	return vm.GlobalObject().Set("getClientVersion", func(call goja.FunctionCall) goja.Value {
+		return vm.ToValue(PACClientVersion)
+	})
+}