nuclei/v2/pkg/templates/compile.go

134 lines
4.0 KiB
Go
Raw Normal View History

2020-04-03 21:20:32 +00:00
package templates
import (
"bytes"
"fmt"
"io/ioutil"
2020-04-03 21:20:32 +00:00
"os"
"strings"
2020-04-03 21:20:32 +00:00
"github.com/pkg/errors"
"github.com/projectdiscovery/nuclei/v2/pkg/operators"
"github.com/projectdiscovery/nuclei/v2/pkg/protocols"
"github.com/projectdiscovery/nuclei/v2/pkg/protocols/common/executer"
"github.com/projectdiscovery/nuclei/v2/pkg/protocols/offlinehttp"
"github.com/projectdiscovery/nuclei/v2/pkg/workflows/compile"
2020-12-30 07:56:55 +00:00
"gopkg.in/yaml.v2"
2020-04-03 21:20:32 +00:00
)
2020-06-29 12:13:08 +00:00
// Parse parses a yaml request template file
2021-02-26 07:43:11 +00:00
//nolint:gocritic // this cannot be passed by pointer
func Parse(filePath string, options protocols.ExecuterOptions) (*Template, error) {
2020-04-03 21:20:32 +00:00
template := &Template{}
2021-01-01 09:58:28 +00:00
f, err := os.Open(filePath)
2020-04-03 21:20:32 +00:00
if err != nil {
return nil, err
}
defer f.Close()
2020-04-03 21:20:32 +00:00
data, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
data = template.expandPreprocessors(data)
err = yaml.NewDecoder(bytes.NewReader(data)).Decode(template)
2020-04-03 21:20:32 +00:00
if err != nil {
return nil, err
}
2020-06-26 12:37:55 +00:00
if _, ok := template.Info["name"]; !ok {
return nil, errors.New("no template name field provided")
}
if _, ok := template.Info["author"]; !ok {
return nil, errors.New("no template author field provided")
}
// Setting up variables regarding template metadata
options.TemplateID = template.ID
options.TemplateInfo = template.Info
2021-01-01 09:58:28 +00:00
options.TemplatePath = filePath
2020-07-31 15:13:51 +00:00
2020-06-29 12:13:08 +00:00
// If no requests, and it is also not a workflow, return error.
if len(template.RequestsDNS)+len(template.RequestsHTTP)+len(template.RequestsFile)+len(template.RequestsNetwork)+len(template.RequestsHeadless)+len(template.Workflows) == 0 {
return nil, fmt.Errorf("no requests defined for %s", template.ID)
2020-06-26 12:37:55 +00:00
}
2020-04-03 21:20:32 +00:00
// Compile the workflow request
2020-12-29 13:18:13 +00:00
if len(template.Workflows) > 0 {
2020-12-30 07:56:55 +00:00
compiled := &template.Workflow
loader, err := compile.NewLoader(&options)
if err != nil {
return nil, errors.Wrap(err, "could not create workflow loader")
}
2021-07-06 08:29:38 +00:00
compileWorkflow(&options, compiled, loader)
2020-12-30 07:56:55 +00:00
template.CompiledWorkflow = compiled
2021-02-23 17:25:29 +00:00
template.CompiledWorkflow.Options = &options
}
// Compile the requests found
requests := []protocols.Request{}
2021-02-07 09:42:38 +00:00
if len(template.RequestsDNS) > 0 && !options.Options.OfflineHTTP {
for _, req := range template.RequestsDNS {
requests = append(requests, req)
}
template.Executer = executer.NewExecuter(requests, &options)
2020-12-29 11:03:25 +00:00
}
if len(template.RequestsHTTP) > 0 {
if options.Options.OfflineHTTP {
2021-02-26 07:43:11 +00:00
operatorsList := []*operators.Operators{}
mainLoop:
for _, req := range template.RequestsHTTP {
for _, path := range req.Path {
if !(strings.EqualFold(path, "{{BaseURL}}") || strings.EqualFold(path, "{{BaseURL}}/")) {
break mainLoop
}
}
2021-02-26 07:43:11 +00:00
operatorsList = append(operatorsList, &req.Operators)
}
if len(operatorsList) > 0 {
options.Operators = operatorsList
template.Executer = executer.NewExecuter([]protocols.Request{&offlinehttp.Request{}}, &options)
}
} else {
for _, req := range template.RequestsHTTP {
requests = append(requests, req)
}
template.Executer = executer.NewExecuter(requests, &options)
}
2021-01-01 09:58:28 +00:00
}
2021-02-07 09:42:38 +00:00
if len(template.RequestsFile) > 0 && !options.Options.OfflineHTTP {
for _, req := range template.RequestsFile {
requests = append(requests, req)
}
template.Executer = executer.NewExecuter(requests, &options)
2020-12-29 11:03:25 +00:00
}
2021-02-07 09:42:38 +00:00
if len(template.RequestsNetwork) > 0 && !options.Options.OfflineHTTP {
for _, req := range template.RequestsNetwork {
requests = append(requests, req)
}
template.Executer = executer.NewExecuter(requests, &options)
2020-12-30 09:24:20 +00:00
}
if len(template.RequestsHeadless) > 0 && !options.Options.OfflineHTTP && options.Options.Headless {
for _, req := range template.RequestsHeadless {
requests = append(requests, req)
}
template.Executer = executer.NewExecuter(requests, &options)
}
if template.Executer != nil {
err := template.Executer.Compile()
if err != nil {
return nil, errors.Wrap(err, "could not compile request")
}
template.TotalRequests += template.Executer.Requests()
2020-12-29 11:03:25 +00:00
}
2021-02-22 07:34:42 +00:00
if template.Executer == nil && template.CompiledWorkflow == nil {
2021-02-07 09:42:38 +00:00
return nil, errors.New("cannot create template executer")
}
2021-06-05 17:30:59 +00:00
template.Path = filePath
2020-04-03 21:20:32 +00:00
return template, nil
}