Configuration options

ne, err := nuclei.NewNucleiEngine(options...)

ctx := context.WithTimeout(context.Background(), 10*time.Minute)
ne, err := nuclei.NewNucleiEngineCtx(ctx, options...)

ne, err := nuclei.NewThreadSafeNucleiEngine(options...)

ctx := context.Background()
ne, err := nuclei.NewThreadSafeNucleiEngineCtx(ctx, options...)

nuclei.WithTemplatesOrWorkflows(nuclei.TemplateSources{
	Templates:       []string{"/path/to/templates"},
	Workflows:       []string{"/path/to/workflows"},
	RemoteTemplates: []string{"https://example.com/template.yaml"},
	RemoteWorkflows: []string{"https://example.com/workflow.yaml"},
	TrustedDomains:  []string{"example.com"},
})

nuclei.WithTemplateFilters(nuclei.TemplateFilters{
	Severity:             "critical,high",
	ExcludeSeverities:    "info,low",
	ProtocolTypes:        "http,dns",
	ExcludeProtocolTypes: "code",
	Authors:              []string{"pdteam"},
	Tags:                 []string{"cve", "rce"},
	ExcludeTags:          []string{"intrusive"},
	IncludeTags:          []string{"safe"},
	IDs:                  []string{"CVE-2021-44228"},
	ExcludeIDs:           []string{"test-template"},
	TemplateCondition:    []string{"contains(tags, 'cve')"},
})

nuclei.WithConcurrency(nuclei.Concurrency{
	TemplateConcurrency:           25,
	HostConcurrency:               25,
	HeadlessHostConcurrency:       10,
	HeadlessTemplateConcurrency:   10,
	JavascriptTemplateConcurrency: 120,
	TemplatePayloadConcurrency:    25,
	ProbeConcurrency:              50,
})

nuclei.WithGlobalRateLimit(150, time.Second)

ctx := context.Background()
nuclei.WithGlobalRateLimitCtx(ctx, 150, time.Second)

nuclei.WithNetworkConfig(nuclei.NetworkConfig{
	Timeout:               30,
	Retries:               3,
	LeaveDefaultPorts:     true,
	Interface:             "eth0",
	SourceIP:              "192.168.1.100",
	SystemResolvers:       false,
	InternalResolversList: []string{"1.1.1.1", "8.8.8.8"},
	MaxHostError:          30,
	DisableMaxHostErr:     false,
	TrackError:            []string{"timeout", "no-address"},
})

nuclei.WithProxy(
	[]string{"http://proxy.example.com:8080"},
	true, // proxy internal requests
)

nuclei.WithResponseReadSize(10485760) // 10MB

nuclei.EnableCodeTemplates()

nuclei.EnableSelfContainedTemplates()

nuclei.EnableGlobalMatchersTemplates()

nuclei.EnableFileTemplates()

nuclei.EnablePassiveMode()

nuclei.EnableMatcherStatus()

nuclei.DisableTemplateCache()

nuclei.SignedTemplatesOnly()

nuclei.DASTMode()

nuclei.EnableHeadlessWithOpts(&nuclei.HeadlessOpts{
	PageTimeout: 20,
	ShowBrowser: false,
	UseChrome:   false,
	HeadlessOptions: []string{
		"--no-sandbox",
		"--disable-gpu",
	},
})

nuclei.WithInteractshOptions(nuclei.InteractshOpts{
	ServerURL:      "https://interact.sh",
	CacheSize:      5000,
	Eviction:       60,
	CooldownPeriod: 5,
	PollDuration:   5,
})

nuclei.EnableStatsWithOpts(nuclei.StatsOptions{
	Interval:         5,
	JSON:             true,
	MetricServerPort: 6064,
})

nuclei.WithVerbosity(nuclei.VerbosityOptions{
	Verbose:       true,
	Silent:        false,
	Debug:         false,
	DebugRequest:  false,
	DebugResponse: false,
	ShowVarDump:   false,
})

import "github.com/projectdiscovery/gologger"

logger := gologger.NewLogger()
nuclei.WithLogger(logger)

type CustomWriter struct{}

func (w *CustomWriter) Write(event *output.ResultEvent) error {
	return nil
}

func (w *CustomWriter) Close() {}

nuclei.UseOutputWriter(&CustomWriter{})

type CustomStatsWriter struct{}

nuclei.UseStatsWriter(&CustomStatsWriter{})

nuclei.WithTemplateUpdateCallback(
	false, // don't disable auto-upgrade
	func(newVersion string) {
		fmt.Printf("New templates version: %s\n", newVersion)
	},
)

import "github.com/projectdiscovery/nuclei/v3/pkg/authprovider"

type CustomAuthProvider struct{}

nuclei.WithAuthProvider(&CustomAuthProvider{})

nuclei.LoadSecretsFromFile(
	[]string{"/path/to/secrets.yaml"},
	true, // prefetch secrets
)

nuclei.WithHeaders([]string{
	"X-Custom-Header: value",
	"Cookie: session=abc123",
})

nuclei.WithVars([]string{
	"api_key=secret123",
	"username=admin",
})

nuclei.WithSandboxOptions(
	true,  // allow local file access
	false, // don't restrict local network access
)

nuclei.WithScanStrategy("host-spray") // or "template-spray"

import "github.com/projectdiscovery/nuclei/v3/pkg/catalog"

catalog := catalog.New()
nuclei.WithCatalog(catalog)

import "github.com/projectdiscovery/nuclei/v3/pkg/types"

opts := types.DefaultOptions()
opts.TemplateThreads = 50
nuclei.WithOptions(opts)

nuclei.WithResumeFile("/tmp/nuclei-resume.cfg")

nuclei.WithTemporaryDirectory("/custom/tmp/path")

nuclei.DisableUpdateCheck()