mirror of
https://github.com/projectdiscovery/nuclei.git
synced 2025-12-17 19:55:26 +00:00
02a9b86dd7
* log warnings + use scanContext in flow * refactor flow to use scanContext + log all events * feat: internal matcher * fix integration test * bug fix extractor: merge dynamic values, fix missing extractors in file * flow: fix 'No Results Found' if last statement output is false * fix unit test
119 lines
4.3 KiB
Go
119 lines
4.3 KiB
Go
package file
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/model"
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/operators"
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/operators/extractors"
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/operators/matchers"
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/output"
|
|
"github.com/projectdiscovery/nuclei/v3/pkg/protocols"
|
|
"github.com/projectdiscovery/nuclei/v3/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 && matcher.Type.MatcherType != matchers.DSLMatcher {
|
|
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{}
|
|
case matchers.XPathMatcher:
|
|
return matcher.Result(matcher.MatchXPath(itemStr)), []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 && !extractors.SupportsMap(extractor) {
|
|
return nil
|
|
}
|
|
|
|
switch extractor.GetType() {
|
|
case extractors.RegexExtractor:
|
|
return extractor.ExtractRegex(itemStr)
|
|
case extractors.KValExtractor:
|
|
return extractor.ExtractKval(data)
|
|
case extractors.JSONExtractor:
|
|
return extractor.ExtractJSON(itemStr)
|
|
case extractors.XPathExtractor:
|
|
return extractor.ExtractXPath(itemStr)
|
|
case extractors.DSLExtractor:
|
|
return extractor.ExtractDSL(data)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (request *Request) getMatchPart(part string, data output.InternalEvent) (string, bool) {
|
|
switch part {
|
|
case "body", "all", "data", "":
|
|
part = "raw"
|
|
}
|
|
|
|
item, ok := data[part]
|
|
if !ok {
|
|
return "", false
|
|
}
|
|
itemStr := types.ToString(item)
|
|
|
|
return itemStr, true
|
|
}
|
|
|
|
// responseToDSLMap converts a file chunk elaboration to a map for use in DSL matching
|
|
func (request *Request) responseToDSLMap(raw, inputFilePath, matchedFileName string) output.InternalEvent {
|
|
return output.InternalEvent{
|
|
"path": inputFilePath,
|
|
"matched": matchedFileName,
|
|
"raw": raw,
|
|
"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
|
|
// Deprecated: unused in stream mode, must be present for interface compatibility
|
|
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}
|
|
}
|
|
|
|
// MakeResultEventItem
|
|
// Deprecated: unused in stream mode, must be present for interface compatibility
|
|
func (request *Request) MakeResultEventItem(wrapped *output.InternalWrappedEvent) *output.ResultEvent {
|
|
data := &output.ResultEvent{
|
|
MatcherStatus: true,
|
|
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"]),
|
|
Path: types.ToString(wrapped.InternalEvent["path"]),
|
|
Matched: types.ToString(wrapped.InternalEvent["matched"]),
|
|
Host: types.ToString(wrapped.InternalEvent["host"]),
|
|
ExtractedResults: wrapped.OperatorsResult.OutputExtracts,
|
|
Response: types.ToString(wrapped.InternalEvent["raw"]),
|
|
Timestamp: time.Now(),
|
|
TemplateEncoded: request.options.EncodeTemplate(),
|
|
Error: types.ToString(wrapped.InternalEvent["error"]),
|
|
}
|
|
return data
|
|
}
|