Could anyone help with changing the nuclei-templates directory via code (GO) ?

[iangregsondev]

I have created some code by reading various discussions and issues on github. I couldn't find any examples specifically so this is what I have, any ideas if I am doing something wrong ?

Specifically, I am creating a new catalog and pointing it to the new templates location.

i.e.

	cpath := filepath.Join(getwd, "rules")

	fmt.Println("Here is the catalog directory ", cpath)

	catalog := disk.NewCatalog(cpath)

When I run the code, I get the following error

 Could not find template '/Users/ian/nuclei-templates': could not find file: stat /Users/ian/nuclei-templates: no such file or directory

Here is my code, I am obviously doing something wrong, can anyone help or is there a more concrete example?

func (s *Scan) Scan(ctx context.Context, data networkscanner.ScanCommandData) {
	s.logger.Info("Starting Scan.....")
	s.scanInProgress.Store(true)

	defer func() {
		s.scanInProgress.Store(false)
		fmt.Println("Scan Completed.....")
	}()

	scanData := make([]networkscanner.ScanData, 0)

	// Set writer to our custom writer that also wraps the source logger info
	gologger.DefaultLogger.SetWriter(s.customWriter.GetWriter(ctx, string(SourceLoggerNuclei)))

	cache := hosterrorscache.New(30, hosterrorscache.DefaultMaxHostsCount, nil)
	defer cache.Close()

	mockProgress := &testutils.MockProgressClient{}
	reportingClient, _ := reporting.New(&reporting.Options{}, "", true)
	defer reportingClient.Close()

	outputWriter := testutils.NewMockOutputWriter(true)
	outputWriter.WriteCallback = func(event *output.ResultEvent) {
		s.logger.Debug("an event has arrived, processing it.....")
		scanData = append(
			scanData, networkscanner.ScanData{
				TemplateID:  event.TemplateID,
				Name:        event.Info.Name,
				Description: event.Info.Description,
				Type:        event.Type,
				Tags:        event.Info.Tags.ToSlice(),
				Host:        event.Host,
				Port:        event.Port,
			},
		)
	}

	defaultOpts := types.DefaultOptions()
	defaultOpts.UpdateTemplates = false
	defaultOpts.Silent = false
	defaultOpts.Verbose = false
	defaultOpts.Debug = false

	err := protocolstate.Init(defaultOpts)
	if err != nil {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error initializing protocol state: %w", err),
		}
		return
	}
	err = protocolinit.Init(defaultOpts)
	if err != nil {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error initializing protocol init: %w", err),
		}
		return
	}

	defaultOpts.Tags = data.Tags

	interactOpts := interactsh.DefaultOptions(outputWriter, reportingClient, mockProgress)
	interactClient, err := interactsh.New(interactOpts)
	if err != nil {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error creating interact client: %w", err),
		}
		return
	}
	defer interactClient.Close()

	getwd, err := os.Getwd()
	if err != nil {
		fmt.Println("Error getting current working directory")
		return
	}

	cpath := filepath.Join(getwd, "rules")

	fmt.Println("Here is the catalog directory ", cpath)

	catalog := disk.NewCatalog(cpath)

	parser := templates.NewParser()
	executerOpts := protocols.ExecutorOptions{
		Output:          outputWriter,
		Options:         defaultOpts,
		Progress:        mockProgress,
		Catalog:         catalog,
		IssuesClient:    reportingClient,
		RateLimiter:     ratelimit.New(context.Background(), 150, time.Second),
		Interactsh:      interactClient,
		HostErrorsCache: cache,
		Colorizer:       aurora.NewAurora(false),
		ResumeCfg:       types.NewResumeCfg(),
		Parser:          parser,
	}
	engine := core.New(defaultOpts)
	engine.SetExecuterOptions(executerOpts)

	workflowLoader, err := parsers.NewLoader(&executerOpts)
	if err != nil {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error creating workflow loader: %w", err),
		}
		return
	}

	executerOpts.WorkflowLoader = workflowLoader

	loaderConfig := loader.NewConfig(defaultOpts, catalog, executerOpts)

	store, err := loader.New(loaderConfig)
	if err != nil {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error creating loader client: %w", err),
		}
		return
	}

	store.Load()

	s.logger.Debug("total number of templates loaded: ", len(store.Templates()))

	inputArgs := make([]*contextargs.MetaInput, 0)

	for _, r := range data.Ranges {
		inputArgs = append(inputArgs, &contextargs.MetaInput{Input: r})
	}

	input := &provider.SimpleInputProvider{Inputs: inputArgs}

	egResult := engine.Execute(ctx, store.Templates(), input)

	if !egResult.Load() {
		s.scanResultCh <- networkscanner.ScanResult{
			ScanID: data.ID,
			Error:  fmt.Errorf("error executing engine"),
		}
		return
	}

	s.scanResultCh <- networkscanner.ScanResult{
		ScanID:   data.ID,
		ScanData: scanData,
	}
}