Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

5.7 KB
Raw Blame
package netguard

import (
	"context"
	"errors"
	"fmt"
	"net"
	"net/netip"
	"strings"
)

var (
	ErrResolveHost         = errors.New("could not resolve host")
	ErrPrivateInternalIP   = errors.New("private/internal IP blocked")
	ErrUnparseableRemoteIP = errors.New("unparseable remote IP")
)

var ResolveHostIPs = func(ctx context.Context, network, host string) ([]net.IP, error) {
	return net.DefaultResolver.LookupIP(ctx, network, host)
}

var blockedPrefixes = []netip.Prefix{
	netip.MustParsePrefix("100.64.0.0/10"),
	netip.MustParsePrefix("198.18.0.0/15"),
}

var nat64WellKnownPrefix = netip.MustParsePrefix("64:ff9b::/96")

// embeddedIPv4 extracts the IPv4 address carried inside an IPv6 transition
// address (6to4 2002::/16, NAT64 64:ff9b::/96). These wrappers are globally
// scoped, so IsPrivate/IsLoopback/IsLinkLocalUnicast all report false while the
// traffic still reaches the embedded IPv4 — 64:ff9b::a9fe:a9fe is the cloud
// metadata service. The embedded address is decoded rather than the prefixes
// being banned outright so transition addresses wrapping a public IPv4 keep
// working.
func embeddedIPv4(addr netip.Addr) (netip.Addr, bool) {
	if !addr.Is6() {
		return netip.Addr{}, false
	}
	b := addr.As16()
	if b[0] == 0x20 && b[1] == 0x02 {
		return netip.AddrFrom4([4]byte{b[2], b[3], b[4], b[5]}), true
	}
	if nat64WellKnownPrefix.Contains(addr) {
		return netip.AddrFrom4([4]byte{b[12], b[13], b[14], b[15]}), true
	}
	return netip.Addr{}, false
}

func NormalizeHost(host string) string {
	return strings.TrimSuffix(strings.ToLower(strings.TrimSpace(host)), ".")
}

func IsLocalHost(host string) bool {
	host = NormalizeHost(host)
	if host == "" {
		return false
	}
	if host == "localhost" || strings.HasSuffix(host, ".localhost") {
		return true
	}
	ip := net.ParseIP(host)
	if ip == nil {
		return false
	}
	addr, ok := netip.AddrFromSlice(ip)
	if !ok {
		return false
	}
	return addr.Unmap().IsLoopback()
}

func ValidatePublicIP(ip net.IP) error {
	if ip == nil {
		return ErrPrivateInternalIP
	}

	addr, ok := netip.AddrFromSlice(ip)
	if !ok {
		return ErrPrivateInternalIP
	}
	addr = addr.Unmap()
	if addr.IsPrivate() ||
		addr.IsLoopback() ||
		addr.IsLinkLocalUnicast() ||
		addr.IsLinkLocalMulticast() ||
		addr.IsInterfaceLocalMulticast() ||
		addr.IsMulticast() ||
		addr.IsUnspecified() {
		return ErrPrivateInternalIP
	}
	for _, prefix := range blockedPrefixes {
		if prefix.Contains(addr) {
			return ErrPrivateInternalIP
		}
	}
	if v4, ok := embeddedIPv4(addr); ok {
		return ValidatePublicIP(net.IP(v4.AsSlice()))
	}
	return nil
}

func ResolveAndValidatePublicIPs(ctx context.Context, host string) ([]netip.Addr, error) {
	host = NormalizeHost(host)
	if host == "" {
		return nil, ErrResolveHost
	}

	if ip := net.ParseIP(host); ip != nil {
		addr, ok := netip.AddrFromSlice(ip)
		if !ok {
			return nil, ErrPrivateInternalIP
		}
		return ValidateResolvedPublicAddrs([]netip.Addr{addr})
	}

	ips, err := ResolveHostIPs(ctx, "ip", host)
	if err != nil || len(ips) == 0 {
		return nil, ErrResolveHost
	}

	addrs := make([]netip.Addr, 0, len(ips))
	for _, ip := range ips {
		addr, ok := netip.AddrFromSlice(ip)
		if !ok {
			return nil, ErrPrivateInternalIP
		}
		addrs = append(addrs, addr)
	}
	return ValidateResolvedPublicAddrs(addrs)
}

func ValidateResolvedPublicAddrs(ips []netip.Addr) ([]netip.Addr, error) {
	if len(ips) == 0 {
		return nil, ErrResolveHost
	}
	seen := make(map[netip.Addr]struct{}, len(ips))
	out := make([]netip.Addr, 0, len(ips))
	for _, addr := range ips {
		if !addr.IsValid() {
			return nil, ErrPrivateInternalIP
		}
		addr = addr.Unmap()
		if err := ValidatePublicIP(net.IP(addr.AsSlice())); err != nil {
			return nil, err
		}
		if _, ok := seen[addr]; ok {
			continue
		}
		seen[addr] = struct{}{}
		out = append(out, addr)
	}
	if len(out) == 0 {
		return nil, ErrResolveHost
	}
	return out, nil
}

func NormalizeRemoteIP(raw string) string {
	raw = strings.TrimSpace(raw)
	raw = strings.TrimPrefix(raw, "[")
	raw = strings.TrimSuffix(raw, "]")
	return raw
}

func ValidateRemoteIPAddress(raw string) error {
	raw = NormalizeRemoteIP(raw)
	if raw == "" {
		// Accepted by design: CDP reports no remote IP for cache- and
		// service-worker-served responses, so erroring here would break
		// legitimate cached navigations. This post-connect check is the last
		// of several layers (URL validation, resolve-time checks with pinned
		// IPs, dial-time enforcement on the static path); the residual
		// exposure is a cached/SW response for an already-validated target.
		return nil
	}
	ip := net.ParseIP(raw)
	if ip == nil {
		return fmt.Errorf("%w %q", ErrUnparseableRemoteIP, raw)
	}
	return ValidatePublicIP(ip)
}

func ResolveAndValidateIPsWithTrustedCIDRs(ctx context.Context, host string, trusted []*net.IPNet) ([]netip.Addr, error) {
	host = NormalizeHost(host)
	if host == "" {
		return nil, ErrResolveHost
	}

	if ip := net.ParseIP(host); ip != nil {
		if err := ValidatePublicIP(ip); err != nil {
			if !ipInCIDRs(ip, trusted) {
				return nil, err
			}
		}
		addr, _ := netip.AddrFromSlice(ip)
		return []netip.Addr{addr.Unmap()}, nil
	}

	ips, err := ResolveHostIPs(ctx, "ip", host)
	if err != nil || len(ips) == 0 {
		return nil, ErrResolveHost
	}

	seen := make(map[netip.Addr]struct{}, len(ips))
	out := make([]netip.Addr, 0, len(ips))
	for _, ip := range ips {
		if err := ValidatePublicIP(ip); err != nil {
			if !ipInCIDRs(ip, trusted) {
				return nil, err
			}
		}
		addr, _ := netip.AddrFromSlice(ip)
		addr = addr.Unmap()
		if _, ok := seen[addr]; ok {
			continue
		}
		seen[addr] = struct{}{}
		out = append(out, addr)
	}
	if len(out) == 0 {
		return nil, ErrResolveHost
	}
	return out, nil
}

func ipInCIDRs(ip net.IP, cidrs []*net.IPNet) bool {
	for _, cidr := range cidrs {
		if cidr.Contains(ip) {
			return true
		}
	}
	return false
}