mirror of https://github.com/daffainfo/nuclei.git
108 lines
3.7 KiB
Go
108 lines
3.7 KiB
Go
package headless
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/model"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/operators"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/operators/extractors"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/operators/matchers"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/output"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/protocols"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/types"
|
|
)
|
|
|
|
// Match matches a generic data response again a given matcher
|
|
func (request *Request) Match(data map[string]interface{}, matcher *matchers.Matcher) (bool, []string) {
|
|
itemStr, ok := request.getMatchPart(matcher.Part, data)
|
|
if !ok {
|
|
return false, []string{}
|
|
}
|
|
|
|
switch matcher.GetType() {
|
|
case matchers.SizeMatcher:
|
|
return matcher.Result(matcher.MatchSize(len(itemStr))), []string{}
|
|
case matchers.WordsMatcher:
|
|
return matcher.ResultWithMatchedSnippet(matcher.MatchWords(itemStr, nil))
|
|
case matchers.RegexMatcher:
|
|
return matcher.ResultWithMatchedSnippet(matcher.MatchRegex(itemStr))
|
|
case matchers.BinaryMatcher:
|
|
return matcher.ResultWithMatchedSnippet(matcher.MatchBinary(itemStr))
|
|
case matchers.DSLMatcher:
|
|
return matcher.Result(matcher.MatchDSL(data)), []string{}
|
|
}
|
|
return false, []string{}
|
|
}
|
|
|
|
// Extract performs extracting operation for an extractor on model and returns true or false.
|
|
func (request *Request) Extract(data map[string]interface{}, extractor *extractors.Extractor) map[string]struct{} {
|
|
itemStr, ok := request.getMatchPart(extractor.Part, data)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
switch extractor.GetType() {
|
|
case extractors.RegexExtractor:
|
|
return extractor.ExtractRegex(itemStr)
|
|
case extractors.KValExtractor:
|
|
return extractor.ExtractKval(data)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (request *Request) getMatchPart(part string, data output.InternalEvent) (string, bool) {
|
|
switch part {
|
|
case "body", "resp", "":
|
|
part = "data"
|
|
}
|
|
|
|
item, ok := data[part]
|
|
if !ok {
|
|
return "", false
|
|
}
|
|
itemStr := types.ToString(item)
|
|
|
|
return itemStr, true
|
|
}
|
|
|
|
// responseToDSLMap converts a headless response to a map for use in DSL matching
|
|
func (request *Request) responseToDSLMap(resp, req, host, matched string) output.InternalEvent {
|
|
return output.InternalEvent{
|
|
"host": host,
|
|
"matched": matched,
|
|
"req": req,
|
|
"data": resp,
|
|
"type": request.Type().String(),
|
|
"template-id": request.options.TemplateID,
|
|
"template-info": request.options.TemplateInfo,
|
|
"template-path": request.options.TemplatePath,
|
|
}
|
|
}
|
|
|
|
// MakeResultEvent creates a result event from internal wrapped event
|
|
func (request *Request) MakeResultEvent(wrapped *output.InternalWrappedEvent) []*output.ResultEvent {
|
|
return protocols.MakeDefaultResultEvent(request, wrapped)
|
|
}
|
|
|
|
func (request *Request) GetCompiledOperators() []*operators.Operators {
|
|
return []*operators.Operators{request.CompiledOperators}
|
|
}
|
|
|
|
func (request *Request) MakeResultEventItem(wrapped *output.InternalWrappedEvent) *output.ResultEvent {
|
|
data := &output.ResultEvent{
|
|
TemplateID: types.ToString(wrapped.InternalEvent["template-id"]),
|
|
TemplatePath: types.ToString(wrapped.InternalEvent["template-path"]),
|
|
Info: wrapped.InternalEvent["template-info"].(model.Info),
|
|
Type: types.ToString(wrapped.InternalEvent["type"]),
|
|
Host: types.ToString(wrapped.InternalEvent["host"]),
|
|
Matched: types.ToString(wrapped.InternalEvent["matched"]),
|
|
ExtractedResults: wrapped.OperatorsResult.OutputExtracts,
|
|
Timestamp: time.Now(),
|
|
MatcherStatus: true,
|
|
IP: types.ToString(wrapped.InternalEvent["ip"]),
|
|
Request: types.ToString(wrapped.InternalEvent["request"]),
|
|
Response: types.ToString(wrapped.InternalEvent["data"]),
|
|
}
|
|
return data
|
|
}
|