93 lines
2.5 KiB
Go
93 lines
2.5 KiB
Go
package runner
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"io"
|
|
"os"
|
|
"path"
|
|
|
|
"github.com/projectdiscovery/subfinder/pkg/passive"
|
|
"github.com/projectdiscovery/subfinder/pkg/resolve"
|
|
)
|
|
|
|
// Runner is an instance of the subdomain enumeration
|
|
// client used to orchestrate the whole process.
|
|
type Runner struct {
|
|
options *Options
|
|
passiveAgent *passive.Agent
|
|
resolverClient *resolve.Resolver
|
|
}
|
|
|
|
// NewRunner creates a new runner struct instance by parsing
|
|
// the configuration options, configuring sources, reading lists
|
|
// and setting up loggers, etc.
|
|
func NewRunner(options *Options) (*Runner, error) {
|
|
runner := &Runner{options: options}
|
|
|
|
// Initialize the passive subdomain enumeration engine
|
|
runner.initializePassiveEngine()
|
|
|
|
// Initialize the active subdomain enumeration engine
|
|
err := runner.initializeActiveEngine()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return runner, nil
|
|
}
|
|
|
|
// RunEnumeration runs the subdomain enumeration flow on the targets specified
|
|
func (r *Runner) RunEnumeration(ctx context.Context) error {
|
|
// Check if only a single domain is sent as input. Process the domain now.
|
|
if r.options.Domain != "" {
|
|
return r.EnumerateSingleDomain(ctx, r.options.Domain, r.options.Output, false)
|
|
}
|
|
|
|
// If we have multiple domains as input,
|
|
if r.options.DomainsFile != "" {
|
|
f, err := os.Open(r.options.DomainsFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = r.EnumerateMultipleDomains(ctx, f)
|
|
f.Close()
|
|
return err
|
|
}
|
|
|
|
// If we have STDIN input, treat it as multiple domains
|
|
if r.options.Stdin {
|
|
return r.EnumerateMultipleDomains(ctx, os.Stdin)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// EnumerateMultipleDomains enumerates subdomains for multiple domains
|
|
// We keep enumerating subdomains for a given domain until we reach an error
|
|
func (r *Runner) EnumerateMultipleDomains(ctx context.Context, reader io.Reader) error {
|
|
scanner := bufio.NewScanner(reader)
|
|
for scanner.Scan() {
|
|
domain := scanner.Text()
|
|
if domain == "" {
|
|
continue
|
|
}
|
|
|
|
var err error
|
|
// If the user has specified an output file, use that output file instead
|
|
// of creating a new output file for each domain. Else create a new file
|
|
// for each domain in the directory.
|
|
if r.options.Output != "" {
|
|
err = r.EnumerateSingleDomain(ctx, domain, r.options.Output, true)
|
|
} else if r.options.OutputDirectory != "" {
|
|
outputFile := path.Join(r.options.OutputDirectory, domain)
|
|
err = r.EnumerateSingleDomain(ctx, domain, outputFile, false)
|
|
} else {
|
|
err = r.EnumerateSingleDomain(ctx, domain, "", true)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|