mirror of
https://github.com/projectdiscovery/nuclei.git
synced 2025-12-17 22:45:28 +00:00
128 lines
3.9 KiB
Go
128 lines
3.9 KiB
Go
package interactsh
|
|
|
|
import (
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/karlseguin/ccache"
|
|
"github.com/pkg/errors"
|
|
"github.com/projectdiscovery/interactsh/pkg/client"
|
|
"github.com/projectdiscovery/interactsh/pkg/server"
|
|
"github.com/projectdiscovery/nuclei/v2/internal/progress"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/operators"
|
|
"github.com/projectdiscovery/nuclei/v2/pkg/output"
|
|
)
|
|
|
|
// Client is a wrapped client for interactsh server.
|
|
type Client struct {
|
|
// interactsh is a client for interactsh server.
|
|
interactsh *client.Client
|
|
// requests is a stored cache for interactsh-url->request-event data.
|
|
requests *ccache.Cache
|
|
|
|
dotHostname string
|
|
eviction time.Duration
|
|
pollDuration time.Duration
|
|
cooldownDuration time.Duration
|
|
}
|
|
|
|
// Options contains configuration options for interactsh nuclei integration.
|
|
type Options struct {
|
|
// ServerURL is the URL of the interactsh server.
|
|
ServerURL string
|
|
// CacheSize is the numbers of requests to keep track of at a time.
|
|
// Older items are discarded in LRU manner in favour of new requests.
|
|
CacheSize int64
|
|
// Eviction is the period of time after which to automatically discard
|
|
// interaction requests.
|
|
Eviction time.Duration
|
|
// CooldownPeriod is additional time to wait for interactions after closing
|
|
// of the poller.
|
|
ColldownPeriod time.Duration
|
|
// PollDuration is the time to wait before each poll to the server for interactions.
|
|
PollDuration time.Duration
|
|
// Output is the output writer for nuclei
|
|
Output output.Writer
|
|
// Progress is the nuclei progress bar implementation.
|
|
Progress *progress.Progress
|
|
}
|
|
|
|
// New returns a new interactsh server client
|
|
func New(options *Options) (*Client, error) {
|
|
parsed, err := url.Parse(options.ServerURL)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not parse server url")
|
|
}
|
|
|
|
interactsh, err := client.New(&client.Options{
|
|
ServerURL: options.ServerURL,
|
|
PersistentSession: false,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not create client")
|
|
}
|
|
configure := ccache.Configure()
|
|
configure = configure.MaxSize(options.CacheSize)
|
|
cache := ccache.New(configure)
|
|
|
|
client := &Client{
|
|
interactsh: interactsh,
|
|
eviction: options.Eviction,
|
|
dotHostname: "." + parsed.Host,
|
|
requests: cache,
|
|
pollDuration: options.PollDuration,
|
|
cooldownDuration: options.ColldownPeriod,
|
|
}
|
|
client.interactsh.StartPolling(client.pollDuration, func(interaction *server.Interaction) {
|
|
item := client.requests.Get(interaction.UniqueID)
|
|
if item == nil {
|
|
return
|
|
}
|
|
data, ok := item.Value().(*internalRequestEvent)
|
|
if !ok {
|
|
return
|
|
}
|
|
client.requests.Delete(interaction.UniqueID)
|
|
|
|
data.event.OperatorsResult = &operators.Result{
|
|
Matches: map[string]struct{}{strings.ToLower(interaction.Protocol): {}},
|
|
}
|
|
data.event.Results = data.makeResultFunc(data.event)
|
|
for _, result := range data.event.Results {
|
|
result.Interaction = interaction
|
|
options.Output.Write(result)
|
|
options.Progress.IncrementMatched()
|
|
}
|
|
})
|
|
return client, nil
|
|
}
|
|
|
|
// URL returns a new URL that can be interacted with
|
|
func (c *Client) URL() string {
|
|
return c.interactsh.URL()
|
|
}
|
|
|
|
// Close closes the interactsh clients after waiting for cooldown period.
|
|
func (c *Client) Close() {
|
|
if c.cooldownDuration > 0 {
|
|
time.Sleep(c.cooldownDuration)
|
|
}
|
|
c.interactsh.StopPolling()
|
|
c.interactsh.Close()
|
|
}
|
|
|
|
// MakeResultEventFunc is a result making function for nuclei
|
|
type MakeResultEventFunc func(wrapped *output.InternalWrappedEvent) []*output.ResultEvent
|
|
|
|
type internalRequestEvent struct {
|
|
makeResultFunc MakeResultEventFunc
|
|
event *output.InternalWrappedEvent
|
|
}
|
|
|
|
// RequestEvent is the event for a network request sent by nuclei.
|
|
func (c *Client) RequestEvent(interactshURL string, event *output.InternalWrappedEvent, makeResult MakeResultEventFunc) {
|
|
id := strings.TrimSuffix(interactshURL, c.dotHostname)
|
|
c.requests.Set(id, &internalRequestEvent{makeResultFunc: makeResult, event: event}, c.eviction)
|
|
}
|