mirror of https://github.com/daffainfo/nuclei.git
120 lines
3.7 KiB
Go
120 lines
3.7 KiB
Go
package network
|
|
|
|
import (
|
|
"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/types"
|
|
)
|
|
|
|
// Match matches a generic data response again a given matcher
|
|
func (r *Request) Match(data map[string]interface{}, matcher *matchers.Matcher) bool {
|
|
partString := matcher.Part
|
|
switch partString {
|
|
case "body", "raw", "all", "":
|
|
partString = "data"
|
|
}
|
|
|
|
item, ok := data[partString]
|
|
if !ok {
|
|
return false
|
|
}
|
|
itemStr := types.ToString(item)
|
|
|
|
switch matcher.GetType() {
|
|
case matchers.SizeMatcher:
|
|
return matcher.Result(matcher.MatchSize(len(itemStr)))
|
|
case matchers.WordsMatcher:
|
|
return matcher.Result(matcher.MatchWords(itemStr))
|
|
case matchers.RegexMatcher:
|
|
return matcher.Result(matcher.MatchRegex(itemStr))
|
|
case matchers.BinaryMatcher:
|
|
return matcher.Result(matcher.MatchBinary(itemStr))
|
|
case matchers.DSLMatcher:
|
|
return matcher.Result(matcher.MatchDSL(data))
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Extract performs extracting operation for a extractor on model and returns true or false.
|
|
func (r *Request) Extract(data map[string]interface{}, extractor *extractors.Extractor) map[string]struct{} {
|
|
partString := extractor.Part
|
|
switch partString {
|
|
case "body", "raw", "all", "":
|
|
partString = "data"
|
|
}
|
|
|
|
item, ok := data[partString]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
itemStr := types.ToString(item)
|
|
|
|
switch extractor.GetType() {
|
|
case extractors.RegexExtractor:
|
|
return extractor.ExtractRegex(itemStr)
|
|
case extractors.KValExtractor:
|
|
return extractor.ExtractKval(data)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// responseToDSLMap converts a DNS response to a map for use in DSL matching
|
|
func (r *Request) responseToDSLMap(req, resp string, host, matched string) output.InternalEvent {
|
|
data := make(output.InternalEvent, 6)
|
|
|
|
// Some data regarding the request metadata
|
|
data["host"] = host
|
|
data["matched"] = matched
|
|
data["request"] = req
|
|
data["data"] = resp
|
|
data["template-id"] = r.options.TemplateID
|
|
data["template-info"] = r.options.TemplateInfo
|
|
return data
|
|
}
|
|
|
|
// MakeResultEvent creates a result event from internal wrapped event
|
|
func (r *Request) MakeResultEvent(wrapped *output.InternalWrappedEvent) []*output.ResultEvent {
|
|
if len(wrapped.OperatorsResult.DynamicValues) > 0 {
|
|
return nil
|
|
}
|
|
results := make([]*output.ResultEvent, 0, len(wrapped.OperatorsResult.Matches)+1)
|
|
|
|
// If we have multiple matchers with names, write each of them separately.
|
|
if len(wrapped.OperatorsResult.Matches) > 0 {
|
|
for k := range wrapped.OperatorsResult.Matches {
|
|
data := r.makeResultEventItem(wrapped)
|
|
data.MatcherName = k
|
|
results = append(results, data)
|
|
}
|
|
} else if len(wrapped.OperatorsResult.Extracts) > 0 {
|
|
for k, v := range wrapped.OperatorsResult.Extracts {
|
|
data := r.makeResultEventItem(wrapped)
|
|
data.ExtractedResults = v
|
|
data.ExtractorName = k
|
|
results = append(results, data)
|
|
}
|
|
} else {
|
|
data := r.makeResultEventItem(wrapped)
|
|
results = append(results, data)
|
|
}
|
|
return results
|
|
}
|
|
|
|
func (r *Request) makeResultEventItem(wrapped *output.InternalWrappedEvent) *output.ResultEvent {
|
|
data := &output.ResultEvent{
|
|
TemplateID: wrapped.InternalEvent["template-id"].(string),
|
|
Info: wrapped.InternalEvent["template-info"].(map[string]interface{}),
|
|
Type: "network",
|
|
Host: wrapped.InternalEvent["host"].(string),
|
|
Matched: wrapped.InternalEvent["matched"].(string),
|
|
ExtractedResults: wrapped.OperatorsResult.OutputExtracts,
|
|
IP: wrapped.InternalEvent["ip"].(string),
|
|
}
|
|
if r.options.Options.JSONRequests {
|
|
data.Request = wrapped.InternalEvent["request"].(string)
|
|
data.Response = wrapped.InternalEvent["data"].(string)
|
|
}
|
|
return data
|
|
}
|