amass

type ASRecord struct {
	ASN            int
	Prefix         string
	CC             string
	Registry       string
	AllocationDate time.Time
	Description    string
	Netblocks      []string
}

type AlterationService struct {
	BaseAmassService
}

type AmassAddressInfo struct {
	Address     net.IP
	Netblock    *net.IPNet
	ASN         int
	Description string
}

type AmassConfig struct {
	sync.Mutex

	Graph *Graph

	// The channel that will receive the results
	Output chan *AmassOutput

	// The ASNs that the enumeration will target
	ASNs []int

	// The CIDRs that the enumeration will target
	CIDRs []*net.IPNet

	// The IPs that the enumeration will target
	IPs []net.IP

	// The ports that will be checked for certificates
	Ports []int

	// The list of words to use when generating names
	Wordlist []string

	// Will the enumeration including brute forcing techniques
	BruteForcing bool

	// Will recursive brute forcing be performed?
	Recursive bool

	// Minimum number of subdomain discoveries before performing recursive brute forcing
	MinForRecursive int

	// Will discovered subdomain name alterations be generated?
	Alterations bool

	// Determines if active information gathering techniques will be used
	Active bool

	// A blacklist of subdomain names that will not be investigated
	Blacklist []string

	// Sets the maximum number of DNS queries per minute
	Frequency time.Duration

	// Preferred DNS resolvers identified by the user
	Resolvers []string

	// The Neo4j URL used by the bolt driver to connect with the database
	Neo4jPath string
	// contains filtered or unexported fields
}

type AmassOutput struct {
	Name      string
	Domain    string
	Addresses []AmassAddressInfo
	Tag       string
	Source    string
	Type      int
}

type AmassRequest struct {
	Name    string
	Domain  string
	Records []DNSAnswer
	Tag     string
	Source  string
}

type AmassService interface {
	// Start the service
	Start() error
	OnStart() error

	// Stop the service
	Stop() error
	OnStop() error

	NextRequest() *AmassRequest
	SendRequest(req *AmassRequest)

	// Return true if the service is active
	IsActive() bool

	// Returns a channel that is closed when the service is stopped
	Quit() <-chan struct{}

	// String description of the service
	String() string
}

type ArchiveService struct {
	BaseAmassService
	// contains filtered or unexported fields
}

type Archiver interface {
	Search(req *AmassRequest)
}

type BaseAmassService struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type BruteForceService struct {
	BaseAmassService
	// contains filtered or unexported fields
}

type DNSAnswer struct {
	Name string `json:"name"`
	Type int    `json:"type"`
	TTL  int    `json:"TTL"`
	Data string `json:"data"`
}

type DNSService struct {
	BaseAmassService
	// contains filtered or unexported fields
}

type DataManagerService struct {
	BaseAmassService
	// contains filtered or unexported fields
}

type Edge struct {
	From, To int
	Label    string
	// contains filtered or unexported fields
}

type Graph struct {
	sync.Mutex
	Domains    map[string]*Node
	Subdomains map[string]*Node
	Addresses  map[string]*Node
	PTRs       map[string]*Node
	Netblocks  map[string]*Node
	ASNs       map[int]*Node
	// contains filtered or unexported fields
}

type Neo4j struct {
	// contains filtered or unexported fields
}

type Node struct {
	Edges      []int
	Labels     []string
	Properties map[string]string
	// contains filtered or unexported fields
}

type Scraper interface {
	Scrape(domain string, done chan int)
	fmt.Stringer
}

type ScraperService struct {
	BaseAmassService
	// contains filtered or unexported fields
}