discovery

type BasicScopeManager ¶

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

BasicScopeManager implements the interfaces.ScopeManager interface. this defines the boundaries of the engagement. absolutely critical.

func NewBasicScopeManager(initialURL string, includeSubdomains bool) (*BasicScopeManager, error)

func (s *BasicScopeManager) GetRootDomain() string

func (s *BasicScopeManager) IsInScope(u *url.URL) bool

type CrtCache ¶

type CrtCache struct {
	RootDomain string    `json:"rootDomain"`
	Timestamp  time.Time `json:"timestamp"`
	Domains    []string  `json:"domains"`
}

CrtCache defines the structure for storing crt.sh results locally.

type CrtShEntry ¶

type CrtShEntry struct {
	NameValue string `json:"name_value"`
}

CrtShEntry defines the structure for a single JSON entry from the crt.sh API.

type DOMTechnologyDiscoverer ¶

type DOMTechnologyDiscoverer struct{}

DOMTechnologyDiscoverer uses the browser session context to identify technologies.

func NewDOMTechnologyDiscoverer() *DOMTechnologyDiscoverer

func (d *DOMTechnologyDiscoverer) Discover(ctx context.Context, session schemas.SessionContext) ([]Technology, error)

type Discoverer ¶

type Discoverer interface {
	Discover(ctx context.Context, session schemas.SessionContext) ([]Technology, error)
}

Discoverer defines the interface for technology discovery modules. we keep this interface generic and decoupled from the underlying browser implementation. It now operates on the canonical SessionContext interface.

type Engine ¶

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

Engine orchestrates the discovery process (passive and active crawling).

func NewEngine(
	cfg config.Interface,
	scope ScopeManager,
	kg schemas.KnowledgeGraphClient,
	browser schemas.BrowserInteractor,
	passive *PassiveRunner,
	logger *zap.Logger,
) *Engine

func (e *Engine) Start(ctx context.Context, initialTargets []string) (<-chan schemas.Task, error)

func (e *Engine) Stop()

type HTTPClient ¶

type HTTPClient interface {
	Get(ctx context.Context, url string) (body []byte, statusCode int, err error)
}

HTTPClient defines the interface for making HTTP GET requests. This allows for mocking the HTTP client in tests.

func NewHTTPClientAdapter(client *http.Client) HTTPClient

type PassiveRunner ¶

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

PassiveRunner handles passive discovery techniques. These are designed to be less noisy and yield high value intelligence without directly engaging the target in an aggressive manner.

func NewPassiveRunner(cfg config.Interface, client HTTPClient, scope ScopeManager, logger *zap.Logger) *PassiveRunner

func (p *PassiveRunner) Run(ctx context.Context, initialURL *url.URL) <-chan string

type ScopeManager ¶

type ScopeManager interface {
	IsInScope(u *url.URL) bool
	GetRootDomain() string
}

ScopeManager is an interface that defines the boundaries of the engagement.

type SitemapIndex ¶

type SitemapIndex struct {
	XMLName  xml.Name     `xml:"sitemapindex"`
	Sitemaps []SitemapRef `xml:"sitemap"`
}

-- XML Structures for Sitemap parsing --

type SitemapRef ¶

type SitemapRef struct {
	Loc string `xml:"loc"`
}

type Technology ¶

type Technology struct {
	Name    string
	Version string
}

Technology represents a detected web technology. this relates more to fingerprinting than pure discovery, but it lives here for now.

type URLLoc ¶

type URLLoc struct {
	Loc string `xml:"loc"`
}

type URLSet ¶

type URLSet struct {
	XMLName xml.Name `xml:"urlset"`
	URLs    []URLLoc `xml:"url"`
}