// SPDX-License-Identifier: BSD-3-Clause package cli import ( "fmt" "math/rand" "strings" "git.froth.zone/sam/awl/conf" "git.froth.zone/sam/awl/pkg/util" "github.com/miekg/dns" "golang.org/x/net/idna" ) // ParseMiscArgs parses the wildcard arguments, dig style. // Only one command is supported at a time, so any extra information overrides previous. func ParseMiscArgs(args []string, opts *util.Options) error { for _, arg := range args { r, ok := dns.StringToType[strings.ToUpper(arg)] switch { // If it starts with @, it's a DNS server case strings.HasPrefix(arg, "@"): arg = arg[1:] // Automatically set flags based on URI header opts.Logger.Info(arg, "detected as a server") switch { case strings.HasPrefix(arg, "tls://"): opts.TLS = true opts.Request.Server = strings.TrimPrefix(arg, "tls://") opts.Logger.Info("DNS-over-TLS implicitly set") case strings.HasPrefix(arg, "https://"): opts.HTTPS = true opts.Request.Server = arg opts.Logger.Info("DNS-over-HTTPS implicitly set") case strings.HasPrefix(arg, "quic://"): opts.QUIC = true opts.Request.Server = strings.TrimPrefix(arg, "quic://") opts.Logger.Info("DNS-over-QUIC implicitly set.") case strings.HasPrefix(arg, "sdns://"): opts.DNSCrypt = true opts.Request.Server = arg opts.Logger.Info("DNSCrypt implicitly set") case strings.HasPrefix(arg, "tcp://"): opts.TCP = true opts.Request.Server = strings.TrimPrefix(arg, "tcp://") opts.Logger.Info("TCP implicitly set") case strings.HasPrefix(arg, "udp://"): opts.Request.Server = strings.TrimPrefix(arg, "udp://") default: opts.Request.Server = arg } // Dig-style +queries case strings.HasPrefix(arg, "+"): opts.Logger.Info(arg, "detected as a dig query") if err := ParseDig(strings.ToLower(arg[1:]), opts); err != nil { return err } // Domain names case strings.Contains(arg, "."): var err error opts.Logger.Info(arg, "detected as a domain name") opts.Request.Name, err = idna.ToASCII(arg) if err != nil { return fmt.Errorf("unicode to punycode: %w", err) } // DNS query type case ok: opts.Logger.Info(arg, "detected as a type") opts.Request.Type = r // Domain? default: var err error opts.Logger.Info(arg, "is unknown. Assuming domain") opts.Request.Name, err = idna.ToASCII(arg) if err != nil { return fmt.Errorf("unicode to punycode: %w", err) } } } // If nothing was set, set a default if opts.Request.Name == "" { opts.Logger.Info("Domain not specified, making a default") opts.Request.Name = "." if opts.Request.Type == 0 { opts.Logger.Info("Query not specified, making an \"NS\" query") opts.Request.Type = dns.StringToType["NS"] } } else if opts.Request.Type == 0 { opts.Logger.Info("Query not specified, making an \"A\" query") opts.Request.Type = dns.StringToType["A"] } if opts.Request.Server == "" { opts.Logger.Info("Server not specified, selecting a default") // Set "defaults" for each if there is no input switch { case opts.DNSCrypt: // This is adguard opts.Request.Server = "sdns://AQMAAAAAAAAAETk0LjE0MC4xNC4xNDo1NDQzINErR_JS3PLCu_iZEIbq95zkSV2LFsigxDIuUso_OQhzIjIuZG5zY3J5cHQuZGVmYXVsdC5uczEuYWRndWFyZC5jb20" case opts.TLS: opts.Request.Server = "dns.google" case opts.HTTPS: opts.Request.Server = "https://dns.cloudflare.com/dns-query" case opts.QUIC: opts.Request.Server = "dns.adguard.com" default: var err error resolv, err := conf.GetDNSConfig() if err != nil { // :^) opts.Logger.Warn("Could not query system for server. Using localhost\n", "Error:", err) opts.Request.Server = "127.0.0.1" } else { // Make sure that if IPv4 or IPv6 is asked for it actually uses it harmful: for _, srv := range resolv.Servers { switch { case opts.IPv4: if strings.Contains(srv, ".") { opts.Request.Server = srv break harmful } case opts.IPv6: if strings.Contains(srv, ":") { opts.Request.Server = srv break harmful } default: //#nosec -- This isn't used for anything secure opts.Request.Server = resolv.Servers[rand.Intn(len(resolv.Servers))] break harmful } } } } } opts.Logger.Info("DNS server set to", opts.Request.Server) // Make reverse addresses proper addresses if opts.Reverse { var err error opts.Logger.Info("Making reverse DNS query proper *.arpa domain") if dns.TypeToString[opts.Request.Type] == "A" { opts.Request.Type = dns.StringToType["PTR"] } opts.Request.Name, err = util.ReverseDNS(opts.Request.Name, opts.Request.Type) if err != nil { return fmt.Errorf("reverse DNS: %w", err) } } // if the domain is not canonical, make it canonical if !strings.HasSuffix(opts.Request.Name, ".") { opts.Request.Name = fmt.Sprintf("%s.", opts.Request.Name) opts.Logger.Info("Domain made canonical") } return nil }