mirror of https://github.com/daffainfo/nuclei.git
91 lines
2.2 KiB
Go
91 lines
2.2 KiB
Go
package http
|
|
|
|
import (
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/output"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/protocols"
|
|
)
|
|
|
|
// Executer executes a group of requests for a protocol
|
|
type Executer struct {
|
|
requests []*Request
|
|
options *protocols.ExecuterOptions
|
|
}
|
|
|
|
var _ protocols.Executer = &Executer{}
|
|
|
|
// NewExecuter creates a new request executer for list of requests
|
|
func NewExecuter(requests []*Request, options *protocols.ExecuterOptions) *Executer {
|
|
return &Executer{requests: requests, options: options}
|
|
}
|
|
|
|
// Compile compiles the execution generators preparing any requests possible.
|
|
func (e *Executer) Compile() error {
|
|
for _, request := range e.requests {
|
|
err := request.Compile(e.options)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Requests returns the total number of requests the rule will perform
|
|
func (e *Executer) Requests() int64 {
|
|
var count int64
|
|
for _, request := range e.requests {
|
|
count += int64(request.Requests())
|
|
}
|
|
return count
|
|
}
|
|
|
|
// Execute executes the protocol group and returns true or false if results were found.
|
|
func (e *Executer) Execute(input string) (bool, error) {
|
|
var results bool
|
|
|
|
for _, req := range e.requests {
|
|
events, err := req.ExecuteHTTP(input, nil)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if events == nil {
|
|
return false, nil
|
|
}
|
|
|
|
// If we have a result field, we should add a result to slice.
|
|
for _, event := range events {
|
|
if event.OperatorsResult == nil {
|
|
continue
|
|
}
|
|
|
|
for _, result := range req.makeResultEvent(event) {
|
|
results = true
|
|
e.options.Output.Write(result)
|
|
}
|
|
}
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
// ExecuteWithResults executes the protocol requests and returns results instead of writing them.
|
|
func (e *Executer) ExecuteWithResults(input string) ([]*output.InternalWrappedEvent, error) {
|
|
var results []*output.InternalWrappedEvent
|
|
|
|
for _, req := range e.requests {
|
|
events, err := req.ExecuteHTTP(input, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if events == nil {
|
|
return nil, nil
|
|
}
|
|
for _, event := range events {
|
|
if event.OperatorsResult == nil {
|
|
continue
|
|
}
|
|
event.Results = req.makeResultEvent(event)
|
|
}
|
|
results = append(results, events...)
|
|
}
|
|
return results, nil
|
|
}
|