CVSS Metrics for the template.
Examples:
```yaml
cvss-metrics: 3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
```
template-id - ID of the template executed
- template-info - Info Block of the template executed
- template-path - Path of the template executed
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
- type - Type is the type of request made
- request - HTTP request made from the client
- response - HTTP response received from server
- status_code - Status Code received from the Server
- body - HTTP response body received from server (default)
- content_length - HTTP Response content length
- header,all_headers - HTTP response headers
- duration - HTTP request time duration
- all - HTTP response body + headers
- cookies_from_response - HTTP response cookies in name:value format
- headers_from_response - HTTP response headers in name:value format
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
path []string
Path contains the path/s for the HTTP requests. It supports variables
as placeholders.
Examples:
```yaml
# Some example path values
path:
- '{{BaseURL}}'
- '{{BaseURL}}/+CSCOU+/../+CSCOE+/files/file_list.json?path=/sessions'
```
raw []string
Raw contains HTTP Requests in Raw format.
Examples:
```yaml
# Some example raw requests
raw:
- |-
GET /etc/passwd HTTP/1.1
Host:
Content-Length: 4
- |-
POST /.%0d./.%0d./.%0d./.%0d./bin/sh HTTP/1.1
Host: {{Hostname}}
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:71.0) Gecko/20100101 Firefox/71.0
Content-Length: 1
Connection: close
echo
echo
cat /etc/passwd 2>&1
```
id string
ID is the optional id of the request
name string
Name is the optional name of the request.
If a name is specified, all the named request in a template can be matched upon
in a combined manner allowing multi-request based matchers.
Attack is the type of payload combinations to perform.
batteringram is inserts the same payload into all defined payload positions at once, pitchfork combines multiple payload sets and clusterbomb generates
permutations and combinations for all payloads.
Valid values:
- batteringram
- pitchfork
- clusterbomb
Method is the HTTP Request Method.
body string
Body is an optional parameter which contains HTTP Request body.
Examples:
```yaml
# Same Body for a Login POST request
body: username=test&password=test
```
payloads map[string]interface{}
Payloads contains any payloads for the current request.
Payloads support both key-values combinations where a list
of payloads is provided, or optionally a single file can also
be provided as payload which will be read on run-time.
headers map[string]string
Headers contains HTTP Headers to send with the request.
Examples:
```yaml
headers:
Any-Header: Any-Value
Content-Length: "1"
Content-Type: application/x-www-form-urlencoded
```
race_count int
RaceCount is the number of times to send a request in Race Condition Attack.
Examples:
```yaml
# Send a request 5 times
race_count: 5
```
max-redirects int
MaxRedirects is the maximum number of redirects that should be followed.
Examples:
```yaml
# Follow up to 5 redirects
max-redirects: 5
```
pipeline-concurrent-connections int
PipelineConcurrentConnections is number of connections to create during pipelining.
Examples:
```yaml
# Create 40 concurrent connections
pipeline-concurrent-connections: 40
```
pipeline-requests-per-connection int
PipelineRequestsPerConnection is number of requests to send per connection when pipelining.
Examples:
```yaml
# Send 100 requests per pipeline connection
pipeline-requests-per-connection: 100
```
threads int
Threads specifies number of threads to use sending requests. This enables Connection Pooling.
Connection: Close attribute must not be used in request while using threads flag, otherwise
pooling will fail and engine will continue to close connections after requests.
Examples:
```yaml
# Send requests using 10 concurrent threads
threads: 10
```
max-size int
MaxSize is the maximum size of http response body to read in bytes.
Examples:
```yaml
# Read max 2048 bytes of the response
max-size: 2048
```
Signature is the request signature method
Valid values:
- AWS
cookie-reuse bool
CookieReuse is an optional setting that enables cookie reuse for
all requests defined in raw section.
read-all bool
Enables force reading of the entire raw unsafe request body ignoring
any specified content length headers.
redirects bool
Redirects specifies whether redirects should be followed by the HTTP Client.
This can be used in conjunction with `max-redirects` to control the HTTP request redirects.
pipeline bool
Pipeline defines if the attack should be performed with HTTP 1.1 Pipelining
All requests must be idempotent (GET/POST). This can be used for race conditions/billions requests.
unsafe bool
Unsafe specifies whether to use rawhttp engine for sending Non RFC-Compliant requests.
This uses the [rawhttp](https://github.com/projectdiscovery/rawhttp) engine to achieve complete
control over the request, with no normalization performed by the client.
race bool
Race determines if all the request have to be attempted at the same time (Race Condition)
The actual number of requests that will be sent is determined by the `race_count` field.
req-condition bool
ReqCondition automatically assigns numbers to requests and preserves their history.
This allows matching on them later for multi-request conditions.
stop-at-first-match bool
StopAtFirstMatch stops the execution of the requests and template as soon as a match is found.
skip-variables-check bool
SkipVariablesCheck skips the check for unresolved variables in request
iterate-all bool
IterateAll iterates all the values extracted from internal extractors
## matchers.Matcher
Matcher is used to match a part in the output from a protocol.
Appears in:
- http.Request.matchers
- dns.Request.matchers
- file.Request.matchers
- network.Request.matchers
- headless.Request.matchers
- ssl.Request.matchers
- websocket.Request.matchers
- whois.Request.matchers
Type is the type of the matcher.
condition string
Condition is the optional condition between two matcher variables. By default,
the condition is assumed to be OR.
Valid values:
- and
- or
part string
Part is the part of the request response to match data from.
Each protocol exposes a lot of different parts which are well
documented in docs for each request type.
Examples:
```yaml
part: body
```
```yaml
part: raw
```
negative bool
Negative specifies if the match should be reversed
It will only match if the condition is not true.
name string
Name of the matcher. Name should be lowercase and must not contain
spaces or underscores (_).
Examples:
```yaml
name: cookie-matcher
```
status []int
Status are the acceptable status codes for the response.
Examples:
```yaml
status:
- 200
- 302
```
size []int
Size is the acceptable size for the response
Examples:
```yaml
size:
- 3029
- 2042
```
words []string
Words contains word patterns required to be present in the response part.
Examples:
```yaml
# Match for Outlook mail protection domain
words:
- mail.protection.outlook.com
```
```yaml
# Match for application/json in response headers
words:
- application/json
```
regex []string
Regex contains Regular Expression patterns required to be present in the response part.
Examples:
```yaml
# Match for Linkerd Service via Regex
regex:
- (?mi)^Via\\s*?:.*?linkerd.*$
```
```yaml
# Match for Open Redirect via Location header
regex:
- (?m)^(?:Location\\s*?:\\s*?)(?:https?://|//)?(?:[a-zA-Z0-9\\-_\\.@]*)example\\.com.*$
```
binary []string
Binary are the binary patterns required to be present in the response part.
Examples:
```yaml
# Match for Springboot Heapdump Actuator "JAVA PROFILE", "HPROF", "Gunzip magic byte"
binary:
- 4a4156412050524f46494c45
- 4850524f46
- 1f8b080000000000
```
```yaml
# Match for 7zip files
binary:
- 377ABCAF271C
```
dsl []string
DSL are the dsl expressions that will be evaluated as part of nuclei matching rules.
A list of these helper functions are available [here](https://nuclei.projectdiscovery.io/templating-guide/helper-functions/).
Examples:
```yaml
# DSL Matcher for package.json file
dsl:
- contains(body, 'packages') && contains(tolower(all_headers), 'application/octet-stream') && status_code == 200
```
```yaml
# DSL Matcher for missing strict transport security header
dsl:
- '!contains(tolower(all_headers), ''''strict-transport-security'''')'
```
encoding string
Encoding specifies the encoding for the words field if any.
Valid values:
- hex
case-insensitive bool
CaseInsensitive enables case-insensitive matches. Default is false.
Valid values:
- false
- true
match-all bool
MatchAll enables matching for all matcher values. Default is false.
Valid values:
- false
- true
## MatcherTypeHolder
MatcherTypeHolder is used to hold internal type of the matcher
Appears in:
- matchers.Matcher.type
Enum Values:
- word
- regex
- binary
- status
- size
- dsl
## extractors.Extractor
Extractor is used to extract part of response using a regex.
Appears in:
- http.Request.extractors
- dns.Request.extractors
- file.Request.extractors
- network.Request.extractors
- headless.Request.extractors
- ssl.Request.extractors
- websocket.Request.extractors
- whois.Request.extractors
name string
Name of the extractor. Name should be lowercase and must not contain
spaces or underscores (_).
Examples:
```yaml
name: cookie-extractor
```
Type is the type of the extractor.
regex []string
Regex contains the regular expression patterns to extract from a part.
Go regex engine does not support lookaheads or lookbehinds, so as a result
they are also not supported in nuclei.
Examples:
```yaml
# Braintree Access Token Regex
regex:
- access_token\$production\$[0-9a-z]{16}\$[0-9a-f]{32}
```
```yaml
# Wordpress Author Extraction regex
regex:
- Author:(?:[A-Za-z0-9 -\_="]+)?
group int
Group specifies a numbered group to extract from the regex.
Examples:
```yaml
# Example Regex Group
group: 1
```
kval []string
description: |
kval contains the key-value pairs present in the HTTP response header.
kval extractor can be used to extract HTTP response header and cookie key-value pairs.
kval extractor inputs are case-insensitive, and does not support dash (-) in input which can replaced with underscores (_)
For example, Content-Type should be replaced with content_type
A list of supported parts is available in docs for request types.
examples:
- name: Extract Server Header From HTTP Response
value: >
[]string{"server"}
- name: Extracting value of PHPSESSID Cookie
value: >
[]string{"phpsessid"}
- name: Extracting value of Content-Type Cookie
value: >
[]string{"content_type"}
json []string
JSON allows using jq-style syntax to extract items from json response
Examples:
```yaml
json:
- .[] | .id
```
```yaml
json:
- .batters | .batter | .[] | .id
```
xpath []string
XPath allows using xpath expressions to extract items from html response
Examples:
```yaml
xpath:
- /html/body/div/p[2]/a
```
attribute string
Attribute is an optional attribute to extract from response XPath.
Examples:
```yaml
attribute: href
```
part string
Part is the part of the request response to extract data from.
Each protocol exposes a lot of different parts which are well
documented in docs for each request type.
Examples:
```yaml
part: body
```
```yaml
part: raw
```
internal bool
Internal, when set to true will allow using the value extracted
in the next request for some protocols (like HTTP).
case-insensitive bool
CaseInsensitive enables case-insensitive extractions. Default is false.
Valid values:
- false
- true
## ExtractorTypeHolder
ExtractorTypeHolder is used to hold internal type of the extractor
Appears in:
- extractors.Extractor.type
Enum Values:
- regex
- kval
- xpath
- json
## generators.AttackTypeHolder
AttackTypeHolder is used to hold internal type of the protocol
Appears in:
- http.Request.attack
- network.Request.attack
- headless.Request.attack
- websocket.Request.attack
Enum Values:
- batteringram
- pitchfork
- clusterbomb
## HTTPMethodTypeHolder
HTTPMethodTypeHolder is used to hold internal type of the HTTP Method
Appears in:
- http.Request.method
Enum Values:
- GET
- GET
- POST
- PUT
- DELETE
- CONNECT
- OPTIONS
- TRACE
- PATCH
- PURGE
- Debug
## SignatureTypeHolder
SignatureTypeHolder is used to hold internal type of the signature
Appears in:
- http.Request.signature
## dns.Request
Request contains a DNS protocol request to be made from a template
Appears in:
- Template.dns
```yaml
extractors:
- type: regex
regex:
- ec2-[-\d]+\.compute[-\d]*\.amazonaws\.com
- ec2-[-\d]+\.[\w\d\-]+\.compute[-\d]*\.amazonaws\.com
name: '{{FQDN}}'
type: CNAME
class: inet
retries: 2
recursion: false
```
Part Definitions:
- template-id - ID of the template executed
- template-info - Info Block of the template executed
- template-path - Path of the template executed
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
- request - Request contains the DNS request in text format
- type - Type is the type of request made
- rcode - Rcode field returned for the DNS request
- question - Question contains the DNS question field
- extra - Extra contains the DNS response extra field
- answer - Answer contains the DNS response answer field
- ns - NS contains the DNS response NS field
- raw,body,all - Raw contains the raw DNS response (default)
- trace - Trace contains trace data for DNS request if enabled
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
id string
ID is the optional id of the request
name string
Name is the Hostname to make DNS request for.
Generally, it is set to {{FQDN}} which is the domain we get from input.
Examples:
```yaml
name: '{{FQDN}}'
```
RequestType is the type of DNS request to make.
class string
Class is the class of the DNS request.
Usually it's enough to just leave it as INET.
Valid values:
- inet
- csnet
- chaos
- hesiod
- none
- any
retries int
Retries is the number of retries for the DNS request
Examples:
```yaml
# Use a retry of 3 to 5 generally
retries: 5
```
trace bool
Trace performs a trace operation for the target.
trace-max-recursion int
TraceMaxRecursion is the number of max recursion allowed for trace operations
Examples:
```yaml
# Use a retry of 100 to 150 generally
trace-max-recursion: 100
```
recursion dns.bool
Recursion determines if resolver should recurse all records to get fresh results.
resolvers []string
Resolvers to use for the dns requests
## DNSRequestTypeHolder
DNSRequestTypeHolder is used to hold internal type of the DNS type
Appears in:
- dns.Request.type
Enum Values:
- A
- NS
- DS
- CNAME
- SOA
- PTR
- MX
- TXT
- AAAA
- CAA
## file.Request
Request contains a File matching mechanism for local disk operations.
Appears in:
- Template.file
```yaml
extractors:
- type: regex
regex:
- amzn\.mws\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
extensions:
- all
```
Part Definitions:
- template-id - ID of the template executed
- template-info - Info Block of the template executed
- template-path - Path of the template executed
- matched - Matched is the input which was matched upon
- path - Path is the path of file on local filesystem
- type - Type is the type of request made
- raw,body,all,data - Raw contains the raw file contents
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
extensions []string
Extensions is the list of extensions to perform matching on.
Examples:
```yaml
extensions:
- .txt
- .go
- .json
```
denylist []string
DenyList is the list of file, directories or extensions to deny during matching.
By default, it contains some non-interesting extensions that are hardcoded
in nuclei.
Examples:
```yaml
denylist:
- .avi
- .mov
- .mp3
```
id string
ID is the optional id of the request
max-size int
MaxSize is the maximum size of the file to run request on.
By default, nuclei will process 5 MB files and not go more than that.
It can be set to much lower or higher depending on use.
Examples:
```yaml
max-size: 2048
```
no-recursive bool
NoRecursive specifies whether to not do recursive checks if folders are provided.
## network.Request
Request contains a Network protocol request to be made from a template
Appears in:
- Template.network
```yaml
host:
- '{{Hostname}}'
- '{{Hostname}}:2181'
inputs:
- data: "envi\r\nquit\r\n"
read-size: 2048
matchers:
- type: word
words:
- zookeeper.version
```
Part Definitions:
- template-id - ID of the template executed
- template-info - Info Block of the template executed
- template-path - Path of the template executed
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
- type - Type is the type of request made
- request - Network request made from the client
- body,all,data - Network response received from server (default)
- raw - Full Network protocol data
id string
ID is the optional id of the request
host []string
Host to send network requests to.
Usually it's set to `{{Hostname}}`. If you want to enable TLS for
TCP Connection, you can use `tls://{{Hostname}}`.
Examples:
```yaml
host:
- '{{Hostname}}'
```
Attack is the type of payload combinations to perform.
Batteringram is inserts the same payload into all defined payload positions at once, pitchfork combines multiple payload sets and clusterbomb generates
permutations and combinations for all payloads.
payloads map[string]interface{}
Payloads contains any payloads for the current request.
Payloads support both key-values combinations where a list
of payloads is provided, or optionally a single file can also
be provided as payload which will be read on run-time.
Inputs contains inputs for the network socket
read-size int
ReadSize is the size of response to read at the end
Default value for read-size is 1024.
Examples:
```yaml
read-size: 2048
```
read-all bool
ReadAll determines if the data stream should be read till the end regardless of the size
Default value for read-all is false.
Examples:
```yaml
read-all: false
```
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
## network.Input
Appears in:
- network.Request.inputs
data string
Data is the data to send as the input.
It supports DSL Helper Functions as well as normal expressions.
Examples:
```yaml
data: TEST
```
```yaml
data: hex_decode('50494e47')
```
Type is the type of input specified in `data` field.
Default value is text, but hex can be used for hex formatted data.
Valid values:
- hex
- text
read int
Read is the number of bytes to read from socket.
This can be used for protocols which expect an immediate response. You can
read and write responses one after another and eventually perform matching
on every data captured with `name` attribute.
The [network docs](https://nuclei.projectdiscovery.io/templating-guide/protocols/network/) highlight more on how to do this.
Examples:
```yaml
read: 1024
```
name string
Name is the optional name of the data read to provide matching on.
Examples:
```yaml
name: prefix
```
## NetworkInputTypeHolder
NetworkInputTypeHolder is used to hold internal type of the Network type
Appears in:
- network.Input.type
Enum Values:
- hex
- text
## headless.Request
Request contains a Headless protocol request to be made from a template
Appears in:
- Template.headless
Part Definitions:
- template-id - ID of the template executed
- template-info - Info Block of the template executed
- template-path - Path of the template executed
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
- type - Type is the type of request made
- req - Headless request made from the client
- resp,body,data - Headless response received from client (default)
id string
ID is the optional id of the request
Attack is the type of payload combinations to perform.
Batteringram is inserts the same payload into all defined payload positions at once, pitchfork combines multiple payload sets and clusterbomb generates
permutations and combinations for all payloads.
payloads map[string]interface{}
Payloads contains any payloads for the current request.
Payloads support both key-values combinations where a list
of payloads is provided, or optionally a single file can also
be provided as payload which will be read on run-time.
Steps is the list of actions to run for headless request
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
## engine.Action
Action is an action taken by the browser to reach a navigation
Each step that the browser executes is an action. Most navigations
usually start from the ActionLoadURL event, and further navigations
are discovered on the found page. We also keep track and only
scrape new navigation from pages we haven't crawled yet.
Appears in:
- headless.Request.steps
args map[string]string
Args contain arguments for the headless action.
Per action arguments are described in detail [here](https://nuclei.projectdiscovery.io/templating-guide/protocols/headless/).
name string
Name is the name assigned to the headless action.
This can be used to execute code, for instance in browser
DOM using script action, and get the result in a variable
which can be matched upon by nuclei. An Example template [here](https://github.com/projectdiscovery/nuclei-templates/blob/master/headless/prototype-pollution-check.yaml).
description string
Description is the optional description of the headless action
Action is the type of the action to perform.
## ActionTypeHolder
ActionTypeHolder is used to hold internal type of the action
Appears in:
- engine.Action.action
Enum Values:
- navigate
- script
- click
- rightclick
- text
- screenshot
- time
- select
- files
- waitload
- getresource
- extract
- setmethod
- addheader
- setheader
- deleteheader
- setbody
- waitevent
- keyboard
- debug
- sleep
- waitvisible
## ssl.Request
Request is a request for the SSL protocol
Appears in:
- Template.ssl
Part Definitions:
- type - Type is the type of request made
- response - JSON SSL protocol handshake details
- not_after - Timestamp after which the remote cert expires
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
address string
Address contains address for the request
min_version string
Minimum tls version - auto if not specified.
Valid values:
- sslv3
- tls10
- tls11
- tls12
- tls13
max_version string
Max tls version - auto if not specified.
Valid values:
- sslv3
- tls10
- tls11
- tls12
- tls13
cipher_suites []string
Client Cipher Suites - auto if not specified.
## websocket.Request
Request is a request for the Websocket protocol
Appears in:
- Template.websocket
Part Definitions:
- type - Type is the type of request made
- success - Success specifies whether websocket connection was successful
- request - Websocket request made to the server
- response - Websocket response received from the server
- host - Host is the input to the template
- matched - Matched is the input which was matched upon
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
address string
Address contains address for the request
Inputs contains inputs for the websocket protocol
headers map[string]string
Headers contains headers for the request.
Attack is the type of payload combinations to perform.
Sniper is each payload once, pitchfork combines multiple payload sets and clusterbomb generates
permutations and combinations for all payloads.
payloads map[string]interface{}
Payloads contains any payloads for the current request.
Payloads support both key-values combinations where a list
of payloads is provided, or optionally a single file can also
be provided as payload which will be read on run-time.
## websocket.Input
Appears in:
- websocket.Request.inputs
data string
Data is the data to send as the input.
It supports DSL Helper Functions as well as normal expressions.
Examples:
```yaml
data: TEST
```
```yaml
data: hex_decode('50494e47')
```
name string
Name is the optional name of the data read to provide matching on.
Examples:
```yaml
name: prefix
```
## whois.Request
Request is a request for the WHOIS protocol
Appears in:
- Template.whois
Matchers contains the detection mechanism for the request to identify
whether the request was successful by doing pattern matching
on request/responses.
Multiple matchers can be combined with `matcher-condition` flag
which accepts either `and` or `or` as argument.
Extractors contains the extraction mechanism for the request to identify
and extract parts of the response.
matchers-condition string
MatchersCondition is the condition between the matchers. Default is OR.
Valid values:
- and
- or
query string
Query contains query for the request
server string
description: |
Optional WHOIS server URL.
If present, specifies the WHOIS server to execute the Request on.
Otherwise, nil enables bootstrapping
## workflows.WorkflowTemplate
Appears in:
- Template.workflows
- workflows.WorkflowTemplate.subtemplates
- workflows.Matcher.subtemplates
template string
Template is a single template or directory to execute as part of workflow.
Examples:
```yaml
# A single template
template: dns/worksites-detection.yaml
```
```yaml
# A template directory
template: misconfigurations/aem
```
Tags to run templates based on.
Matchers perform name based matching to run subtemplates for a workflow.
Subtemplates are run if the `template` field Template matches.
## workflows.Matcher
Appears in:
- workflows.WorkflowTemplate.matchers
name string
Name is the name of the item to match.
Subtemplates are run if the name of matcher matches.
## http.SignatureTypeHolder
SignatureTypeHolder is used to hold internal type of the signature
Appears in:
- Template.signature