Skip to content
CAI
Software that uses CAICheck a score

projectdiscovery/nuclei

53.3

Adequate · 10 October 2026

89.3k

lines of production code

Go

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is Nuclei v3, a high-performance vulnerability scanner and security testing framework that executes templates across diverse protocols including HTTP, DNS, SSL, and headless browsers. It features a comprehensive JavaScript runtime for complex logic, a dedicated fuzzing engine for request mutation, and a programmatic Go SDK for integration. The platform supports automated reporting, cloud result uploads, and Kubernetes deployment, while enforcing strict security policies for network access and template integrity.

How it got here

2020–2023 — Nuclei v3 architecture and SDK

115 changes.

The project underwent a major architectural overhaul to establish the Nuclei v3 core engine, introducing a new SDK, workflow orchestration, and a comprehensive JavaScript scripting environment. This period focused on expanding protocol support, implementing robust template signing and security controls, and building out the infrastructure for cloud integration and external reporting.

2024–2026 — DAST expansion and JavaScript runtime

65 changes.

This period focused on expanding the tool's capabilities into Dynamic Application Security Testing (DAST) by introducing a live server, raw HTTP input support, and a comprehensive fuzzing engine. It also significantly enhanced the JavaScript runtime with extensive libraries for Active Directory attacks, network protocols, and Windows remote execution, alongside robust TypeScript tooling for developers.

Features

AI-generated templates and persistent metadata caching in the loader

The template loader now supports generating templates via an AI prompt (using the ProjectDiscovery Cloud API) and saving them to the local catalog, while also introducing a persistent metadata index cache to speed up subsequent loads. Additionally, a new path-based filter allows explicit inclusion and exclusion of templates by file path, and remote template loading is parallelized with concurrency limits and domain validation.

pkg/catalog/loader · high confidence

Add Elasticsearch and Splunk HEC reporting exporters

Users can now export Nuclei scan results to Elasticsearch and Splunk HTTP Event Collector (HEC). The new Elasticsearch exporter sends results to a specified index with configurable host, IP, port, SSL, and Basic Authentication options. The Splunk HEC exporter sends results to a specified index using a token-based authentication header. Both exporters utilize the projectdiscovery useragent library for HTTP requests and include validation for their respective configuration options.

pkg/reporting/exporters/es · high confidence

Add Gitea issue tracker integration

Users can now report Nuclei findings to Gitea repositories. This new integration supports self-hosted Gitea instances, allows filtering events via allow/deny lists, optionally adds severity as a label, and includes duplicate detection that paginates through existing issues to avoid creating redundant reports.

pkg/reporting/trackers/gitea · high confidence

Add JSONL input format parser for Proxify-style request/response data

Users can now provide input files in JSONL format containing HTTP requests and optional responses, specifically structured for Proxify exports. The new parser in \pkg/input/formats/json\ reads these files, extracts the URL and raw request data, and correctly reconstructs the HTTP response by appending the body to the raw header string when necessary. This enables passive scanning workflows using saved Proxify traffic logs.

pkg/input/formats/json · high confidence

Add JavaScript net library with HTTP/HTTPS proxy support

Introduces a new \net\ library for JavaScript templates, enabling TCP and UDP connections via \net.Open\ and \net.Dial\. This implementation adds support for HTTP and HTTPS proxies, allowing users to route network requests through proxy servers configured in the context, including handling of proxy authentication and TLS handshakes for HTTPS proxies.

pkg/js/libs/net · high confidence

Add Linear issue tracker integration for vulnerability reporting

Users can now automatically create and manage issues in Linear when security vulnerabilities are detected. This new integration allows configuration of API keys, team and project IDs, and filtering rules (allow/deny lists). It supports duplicate detection to avoid creating redundant issues, automatically reopens closed issues if new findings occur, and adds detailed comments to existing tickets with report descriptions.

pkg/reporting/trackers/linear · high confidence

Add MongoDB exporter for reporting results

A new MongoDB exporter has been added to the reporting system, allowing users to store scan results directly in a MongoDB collection. Users can configure the connection string (via YAML or the MONGO\_CONNECTION\_STRING environment variable), specify the target collection, and control memory usage by setting a batch size for flushing results. The exporter also supports omitting raw request/response data to reduce storage size.

pkg/reporting/exporters/mongo · high confidence

Add PDF export for scan results

Users can now export Nuclei scan results to a PDF report. The new PDF exporter generates a document containing a summary of findings by severity (critical, high, medium, low, info, unknown) with color-coded headers, followed by detailed findings including the host and template name. The exporter supports configuration options to specify the output file path and to omit raw request/response data from the report for privacy or size reduction. The implementation includes concurrency-safe result buffering and handles directory creation for the output file.

pkg/reporting/exporters/pdf · high confidence

Add YAML/JSON serialization support for severity types

The severity model now supports marshaling and unmarshaling to and from YAML and JSON formats. This allows severity values to be correctly persisted in configuration files and API payloads, ensuring that severity settings are preserved when templates or configurations are serialized and deserialized.

pkg/model/types/severity · high confidence

Add generic template execution engine

Introduces a new generic execution engine that processes template requests sequentially without intermediate logic. This engine supports context cancellation to allow for graceful shutdowns, integrates with the host error cache to track failures per protocol type, and handles dynamic input transformation and previous event state management for each request.

pkg/tmplexec/generic · high confidence

Add optional scan statistics tracking via build tags

Introduces a new \stats\ build tag that enables the \pkg/scan/events\ package to record scan progress and metadata. When built with this tag, the system creates a timestamped directory containing a \config.json\ and an \events.jsonl\ file, writing structured scan events (such as start/finish status, targets, and template details) in JSON Lines format. Without the tag, the event recording functions remain as no-ops, ensuring zero performance overhead for standard builds.

pkg/scan/events · high confidence

Add structured UserAgent configuration type with JSON/YAML support

A new \UserAgent\ type is introduced in \pkg/model/types/userAgent\, allowing users to configure the HTTP user-agent string for headless requests via configuration files. The type supports four modes: \random\, \off\, \default\, and \custom\. It includes custom JSON and YAML marshaling/unmarshaling logic to handle string-to-enum conversion and provides a JSON Schema definition for validation, ensuring that only valid user-agent options are accepted in the configuration.

pkg/model/types/userAgent · high confidence

Added JSON utility for Linear GraphQL integration

A new \jsonutil\ package has been introduced to handle JSON decoding for Linear issue tracker GraphQL queries. This component provides a custom decoder that supports GraphQL-specific features such as fragments and embedded structs, enabling the application to correctly parse responses from the Linear API.

pkg/reporting/trackers/linear/jsonutil · high confidence

Added Java deserialization payload generation and scan strategy configuration

The tool now includes a new \deserialization\ helper package that generates Java deserialization payloads (gadgets) for various libraries including commons-collections, Groovy, and JDK versions, supporting multiple output encodings like base64 and gzip. Additionally, a new \scanstrategy\ package defines configurable scan modes (Auto, HostSpray, TemplateSpray) to control how templates are applied during scans, and a new \extensions\ package standardizes supported file extensions for templates.

pkg/protocols/common/helpers/deserialization, pkg/templates/extensions, pkg/types/scanstrategy · high confidence

Added TypeScript definition generator for JavaScript bindings

A new command-line tool (\tsgen\) has been added to generate TypeScript definition files (.d.ts) from Go source code. This tool parses Go modules in a specified directory and outputs corresponding TypeScript modules and an index file, enabling better type safety and IDE support for the project's JavaScript bindings.

pkg/js/devtools/tsgen/cmd · high confidence

Added frequency tracking to reduce redundant fuzzing requests

A new frequency tracker has been introduced in the fuzzing engine to identify and skip input parameters that are likely to yield uninteresting results. This component tracks how often a parameter fails to produce results for a specific target and template combination; once a parameter exceeds a configurable occurrence threshold, it is temporarily skipped to reduce the total number of requests made during a scan. Parameters can be unmarked if they eventually produce results, ensuring they are re-evaluated in future scans.

pkg/fuzz/frequency · high confidence

Added hang detection and stack trace dumping for stuck scanner processes

A new monitoring utility has been introduced to detect when scanner goroutines become stuck. The system periodically checks for unchanged goroutine stacks over a set number of iterations; if a hang is confirmed, it writes a detailed stack trace dump to disk (e.g., nuclei-stacktrace-\<id\>.dump) and exits the process to facilitate investigation. This includes a test suite verifying the stack comparison logic and the monitor's ability to exit cleanly upon cancellation.

pkg/utils/monitor · high confidence

Added memogen tool for transparent function memoization

A new CLI tool, memogen, has been added to automatically generate memoized versions of Go functions. By scanning source files for the \@memo\ annotation, it uses a template to produce wrapper code that caches results via the \protocolstate.Memoizer\, allowing developers to enable transparent memoization for functions returning result-error tuples without manual implementation.

cmd/memogen · high confidence

Added scrapefuncs tool to generate JavaScript helper documentation

A new Go-based CLI tool named \scrapefuncs\ has been added to \pkg/js/devtools/scrapefuncs\. This tool scans Go source code for registered JavaScript helper functions (using \RegisterFuncWithSignature\) and generates a Markdown file containing a table of these functions, including their names, descriptions, and signatures. It also includes a README demonstrating how to use the tool to generate JSDoc comments for these functions, aiding in the maintenance of JavaScript runtime documentation.

pkg/js/devtools/scrapefuncs · high confidence

Added utility functions to expand CIDR and ASN ranges into individual IP addresses

A new expand utility package has been introduced, providing two helper functions: CIDR, which converts a single CIDR block into a list of individual IP addresses, and ASN, which resolves an Autonomous System Number to its associated CIDR blocks and then expands those into a complete list of IP addresses. These functions leverage the mapcidr library to facilitate network range expansion for downstream processing.

pkg/utils/expand · high confidence

Adopts XDG Base Directory spec and introduces AWS S3 template catalog support

Nuclei now stores configuration, state, and cache data in standard XDG directories (config, state, and cache) instead of a single hidden folder, and automatically migrates legacy state files to the new format. Users can now source templates from AWS S3 buckets by configuring a custom S3 template directory, with the new \pkg/catalog/aws\ package handling credential resolution and file retrieval. The \.nuclei-ignore\ file validation has been tightened to reject corrupt, empty, or multi-document YAML payloads, and template discovery logic now explicitly excludes common misc directories like \.git\ and \.github\ to prevent false positives.

pkg/catalog/config · high confidence

Advanced SDK example demonstrates concurrent scanning with custom headers and passive mode

The examples/advanced directory now includes a Go example (advanced.go) that showcases the Nuclei v3 SDK's capabilities for concurrent execution. This example initializes a thread-safe Nuclei engine and uses a sized waitgroup to run multiple scans in parallel. It specifically demonstrates passing custom HTTP headers (e.g., 'X-Bug-Bounty: pdteam') via the new headers option and enabling passive mode, alongside template filtering for DNS protocols and OAST tags.

examples/advanced · high confidence

Cloud result upload with chunked transfers and team isolation

The PDCP module now uploads scan results to the cloud in 4 MB chunks to handle large outputs efficiently. Results are sent via a background goroutine that flushes data every minute or when the buffer limit is reached. The upload includes support for associating results with a specific team via the \PDCP\_TEAM\_ID\ environment variable or a \team-id\ option, ensuring data isolation in the dashboard. Users can also optionally name their scans, and the system provides a direct link to the scan dashboard upon completion.

internal/pdcp · high confidence

DNS protocol support added with clustering, DNSSEC types, and templated resolver resolution

The DNS protocol implementation has been introduced, enabling users to perform DNS reconnaissance using a wide range of request types including DNSSEC records (NSEC, NSEC3, NSEC3PARAM, DNSKEY, RRSIG) and SRV. The engine now supports request clustering to optimize performance for identical requests, allows specifying custom resolvers (including templated variables that are resolved at runtime), and enables recursion control. Users can also leverage payload concurrency with dynamic thread management and access detailed trace data for debugging DNS lookups.

pkg/protocols/dns · high confidence

Expanded JavaScript protocol bindings for network and security modules

The JavaScript scripting environment now exposes a significantly broader set of protocol-specific helper modules, allowing users to interact with a wider range of network services directly from templates. This update adds bindings for Kerberos (including AS-REP and TGS roasting, golden/silver ticket creation, and hashcat conversion), DCERPC, DCOM, and Impacket-style utilities (WMI, Task Scheduler, Service Control Manager, Secrets Dump). It also introduces dedicated modules for SMB, RDP (with encryption and authentication checks), SSH, Telnet, VNC, Rsync, POP3, and WebSocket, alongside enhancements to existing HTTP, LDAP, MySQL, and MSSQL bindings.

pkg/js/generated/go · high confidence

Expose cluster-to-template ID mappings and standardize protocol type definitions

Users can now map specific cluster IDs to template IDs via the new \ClusterMappingsMap\ type, which provides safe accessors (\Get\, \GetAll\, \Copy\) for retrieving associated templates. Additionally, the protocol type system has been standardized with explicit enum definitions for all supported protocols (including JavaScript and Code) and robust YAML/JSON serialization support via \TypeHolder\ and \ProtocolTypes\, ensuring consistent handling of protocol identifiers across template configurations.

pkg/templates/types · high confidence

HTTP request/response caching via persistent project file

The \pkg/projectfile\ package now provides a mechanism to cache HTTP interactions on disk. It introduces \ProjectFile\, which uses a hybrid map to store hashed, cleaned HTTP requests and their corresponding responses. This allows subsequent identical requests to be served from the cache rather than making new network calls, improving performance and enabling offline replay of recorded interactions.

pkg/projectfile · high confidence

Headless protocol support for XPath and JSON extraction

The headless protocol now supports XPath and JSON extractors, allowing templates to parse and extract data from HTML and JSON responses using these specific query languages. This change introduces the necessary matching and extraction logic in the headless operators, enabling more precise data retrieval from headless browser interactions.

pkg/protocols/headless · high confidence

Hex dump highlighting support added to response highlighter

The response highlighter now supports highlighting matches within hex dump output in addition to standard ASCII text. When hex dump mode is enabled, the system parses the hex representation, identifies matching byte sequences in both the hex and ASCII columns, and applies color codes to the corresponding characters. This allows users to visually identify matched patterns in binary responses directly within the hex view, with tests confirming correct handling of wrapped snippets, separator characters, and non-printable bytes.

pkg/protocols/common/helpers/responsehighlighter · high confidence

Honeypot detection to reduce scan noise

A new honeypot detector has been added to the protocols common package to identify and flag hosts likely to be honeypots. The system tracks distinct template matches per normalized host and flags a host once a configurable threshold of unique templates is reached. This helps reduce scan noise by identifying potentially deceptive or monitoring infrastructure during scans.

pkg/protocols/common/honeypotdetector · high confidence

Initial DAST server implementation with scope management and report UI

This change introduces the core components for a new Live DAST (Dynamic Application Security Testing) server. It adds a scope management system (\internal/server/scope\) that validates URLs against configurable in-scope and out-of-scope regex patterns, while filtering out uninteresting static file extensions (images, videos, archives, etc.). It also includes the initial server template (\internal/server/templates/index.html\) which provides a dark-themed, terminal-style UI for displaying DAST scan reports, complete with severity-based styling and theme toggle capabilities.

internal/server/scope, internal/server/templates · high confidence

Initial Helm chart for Nuclei and Interactsh deployment

Adds a new Helm chart (version 0.1.0, app version 2.5.7) that enables deploying the Nuclei vulnerability scanner and its Interactsh server on Kubernetes. The chart provisions a CronJob for Nuclei scans, a Deployment with HorizontalPodAutoscaler support for the Interactsh service, and associated Kubernetes resources including Services, Ingress (with version-aware API groups), ConfigMaps for configuration, and a ServiceAccount.

helm · high confidence

Initial OpenAPI 3.0 input format support

Users can now provide OpenAPI 3.0 specification files (JSON) as input to drive request generation. The new \pkg/input/formats/openapi\ package implements a parser that loads the schema, resolves security requirements, and generates HTTP requests for all defined paths and methods. It includes a downloader to fetch remote JSON specs, validates the OpenAPI version, and automatically injects server URLs if missing. The implementation handles complex schema features like \allOf\, \oneOf\, and \anyOf\ to generate representative examples, and enforces required parameter validation, exiting with a helpful error if global auth variables are missing.

pkg/input/formats/openapi · high confidence

Introduce GitHub issue tracker integration

Added a new GitHub issue tracker integration that automatically creates issues in a specified repository for detected findings. The integration supports configuration for self-hosted GitHub instances, custom issue labels, severity-based labeling, and deduplication via existing issue comments. It also includes granular filtering capabilities using allow and deny lists to control which events are reported.

pkg/reporting/trackers/github · high confidence

Introduce TemplateMan CLI for template standardization

A new \tmc\ command-line utility is added to standardize Nuclei templates via the TemplateMan API. It supports linting, validation, formatting, and enhancing templates, with specific flags to add or update the \max-request\ counter and to enable code, self-contained, and headless template processing by default.

cmd/tmc · high confidence

Introduce automatic technology-based scanning service

A new automatic scan service has been added to the protocol layer, enabling technology detection via Wappalyzer and custom detection templates to dynamically select and execute relevant templates for each target. The service normalizes application names, combines detected tags with user-provided tags, and leverages template clustering to reduce request volume, providing a streamlined way to scan for identified technologies without manual template selection.

pkg/protocols/common/automaticscan · high confidence

Introduce dedicated fuzzing engine with rule-based HTTP mutation and statistics tracking

This change introduces the \pkg/fuzz\ package, providing a new fuzzing engine for dynamic HTTP request mutation. It adds a \Rule\ structure that defines fuzzing behavior via configurable types (replace, prefix, postfix, infix, replace-regex), target parts (query, header, path, body, cookie, request), and modes (single, multiple). The engine supports variable evaluation with interactsh URL integration, frequency-based parameter deduplication to avoid noisy requests, and a statistics tracking system (\pkg/fuzz/stats\) that records component events, matched results, and errors. The implementation includes race-condition-safe variable evaluation and comprehensive test coverage for variable matching, interactsh handling, and frequency logic.

pkg/fuzz · high confidence

Introduce file-based authentication provider with dynamic secret support

Added a new \FileAuthProvider\ in \pkg/authprovider\ that reads authentication strategies from a secrets file, supporting both static secrets and dynamic secrets fetched via a lazy callback. The provider indexes strategies by domain and regex patterns for efficient lookup, and includes a \MultiAuthProvider\ to combine multiple sources. A concurrent access test ensures dynamic secret fetching is thread-safe and executed only once.

pkg/authprovider · high confidence

Introduce per-host rate limiting with normalized host keys

Added a new per-host rate limiting system in the hostratelimit package that groups requests by a normalized host:port key, ensuring that HTTP, HTTPS, WebSocket, and WSS schemes are correctly mapped to their default ports (80/443) when no port is specified. This change introduces a pool-based rate limiter that avoids creating a background goroutine per host, instead using a continuous refill mechanism to maintain steady pressure and prevent resource exhaustion during large scans. The implementation includes a new host normalization function to ensure consistent key generation across different protocol types and a pool that tracks request statistics for per-host performance monitoring.

pkg/protocols/common/hostratelimit · high confidence

Introduces extensible analyzer framework for fuzzing payloads

The fuzzing engine now supports an extensible analyzer interface that allows for modular transformation and analysis of generated requests. This change introduces a registration system for analyzers, enabling features like time-based delay detection and context-aware payload transformations. Users can now configure specific analyzers via templates with customizable parameters, and the system automatically applies payload transformations such as replacing placeholders with random numbers or strings during the fuzzing process.

pkg/fuzz/analyzers · high confidence

Introduces global matchers, refined Interactsh marker handling, and centralized template rendering

This change adds a new global matchers system in \pkg/protocols/common/globalmatchers\ that allows passive HTTP templates to define matchers evaluated across all responses, with execution context enriched by origin template metadata. It also introduces a dedicated \marker\ package to robustly detect Interactsh URL placeholders (including URL-encoded variants) and a new \render\ package that centralizes template text evaluation, ensuring Interactsh markers are replaced before DSL helper execution while treating injected values as terminal data to prevent double-evaluation. Additionally, the \replacer\ package is updated to use these markers for placeholder substitution, and the \ExecutorOptions\ struct now includes fields for global matchers and Interactsh request scoping to support concurrent engine execution.

pkg/protocols · high confidence

Introduction of Goja module and function registration infrastructure

The \pkg/js/gojs\ package introduces new infrastructure for managing JavaScript modules and functions within the Goja runtime. This includes the \GojaModule\ type, which handles module registration, enabling, and setting object exports, as well as a \RegisterFuncWithSignature\ function for registering Go functions with specific signatures and descriptions. The code also implements context injection for wrapped functions, allowing Go functions to receive a context object from the runtime, and utilizes \maps.Copy\ and \reflect.TypeFor\ for cleaner map handling and type reflection.

pkg/js/gojs · high confidence

Introduction of JavaScript protocol support in Nuclei

Nuclei now supports executing JavaScript code within templates, allowing users to write custom logic for vulnerability detection and exploitation. This new protocol enables the definition of initialization scripts, pre-conditions, and main execution code via the \init\, \pre-condition\, and \code\ fields. It supports payload generation with various attack types (sniper, pitchfork, clusterbomb), configurable concurrency via threads, and integrates with existing Nuclei features like matchers, extractors, and interactsh for out-of-band detection. The implementation includes safety measures such as refusing to execute unverified templates and handling context cancellation to prevent resource leaks.

pkg/protocols/javascript · high confidence

Introduction of the Catalog interface for template and file resolution

A new Catalog interface has been added to the pkg/catalog package, defining the contract for template and payload file management. This interface provides methods to open files for reading, parse and resolve template paths (including support for glob patterns and relative path resolution), and retrieve absolute paths for template definitions, enabling the system to locate and access template resources.

pkg/catalog · high confidence

Introduction of workflow chaining and conditional execution

Users can now define workflows that chain multiple templates or directories together, allowing subsequent templates to run based on the results of previous ones. This new capability includes support for conditional matching using 'and' or 'or' logic on template names, enabling more complex, multi-step scanning scenarios where specific sub-templates are triggered only when certain conditions are met.

pkg/workflows · high confidence

Jira tracker now supports custom template syntax for issue fields

The Jira reporting integration now allows users to define custom field values using Go text/template syntax (e.g., {{.Name}}, {{if eq .Severity "critical"}}) in addition to the legacy $variable syntax. This enables more granular control over how vulnerability data is mapped to Jira custom fields, including support for conditional logic, string manipulation functions (upper, lower, title, trim, replace, split, join), and access to detailed classification data like CVSS scores and CVE IDs. The change also includes a new Formatter for Jira-specific markdown rendering and test coverage for the template evaluation logic.

pkg/reporting/trackers/jira · high confidence

New CLI tools for template signing and fuzzing playground

Two new command-line utilities are now available in the tools directory. The \signer\ tool allows users to sign and verify Nuclei templates using X.509 certificates, ensuring template integrity and authenticity. The \fuzzplayground\ tool launches a local HTTP server (default localhost:8082) that provides an interactive environment for testing fuzzing inputs and types.

cmd/tools · high confidence

New GoExec adapter for Windows helper modules

The \pkg/js/libs/goexec\ package now provides the adapter layer that exposes WMI, Task Scheduler (TSCH), Service Control Manager (SCMR), and DCOM helper modules to JavaScript templates. This change introduces the \goexec\ adapter boundary, including authentication constructors (password, NT hash, Kerberos, AES key, ccache, PFX), execution options (timeout, proxy, output method, directory), and a redaction system that strips credential material from results before they reach the JavaScript engine. It also enforces network policies by denying targets, proxies, and endpoints listed in the exclusion list before any network dial occurs, and adds tests to verify credential redaction, policy enforcement, and option merging behavior.

pkg/js/libs/goexec · high confidence

New HTTP probing, template path, and utility utilities

The \pkg/utils\ package now includes several new capabilities: HTTP probing logic that determines scheme order based on port heuristics (prioritizing HTTP for common ports and ports \>1024) and normalizes unbracketed IPv6 literals; a template path utility that generates relative paths and cloud URLs for signed templates while enforcing directory containment checks; an insertion-ordered string map that preserves key order during YAML/JSON unmarshalling; and general utility functions including a safe index transformer, error unwrapper, and centralized rate limiter factory.

pkg/utils · high confidence

New HTTP request utility functions for port handling and header management

Added new helper functions in the HTTP protocol utilities to improve request construction. The \UpdateURLPortFromPayload\ function now allows dynamic port overrides in request payloads (e.g., \{{BaseURL}}:8080\), ensuring the URL and payload are synchronized. \HasTrailingSlash\ provides reliable detection of trailing slashes in paths containing default variables. Additionally, \SetHeader\ ensures that specific headers like 'Host' are set only if not already provided by the user, preventing accidental overwrites of user-defined configurations.

pkg/protocols/utils/http · high confidence

New JSONL and JSON exporters with batching and raw data omission

Added new JSONL and JSON exporters for the reporting system. The JSONL exporter supports configurable batching (via \batch-size\) to write results to disk in chunks, reducing memory usage for large scans, and includes an \omit-raw\ option to exclude sensitive request/response data from the output. The JSON exporter provides a simpler, non-batched alternative that writes all results to a single JSON file upon completion, also supporting the \omit-raw\ configuration.

pkg/reporting/exporters/jsonl · high confidence

New JavaScript DCE/RPC client for Active Directory enumeration and remote execution

Added a new \nuclei/dcerpc\ JavaScript library that exposes a stateful DCE/RPC and SMB client backed by the goimpacket library. This enables AD attack templates to interact with domain controllers and member servers via named pipes, providing methods to enumerate domain users (SAMR), list services (SVCCTL), view active sessions (SRVSVC), list processes (Terminal Services Legacy API), and check logged-on users (WKSSVC). It also supports remote command execution via WMI (DCOM Win32\_Process.Create) and pass-the-hash or Kerberos authentication. All network traffic is routed through nuclei's fastdialer and strictly validated against the per-execution network policy before any connection is established.

pkg/js/libs/dcerpc · high confidence

New JavaScript HTTP client library for Nuclei templates

Users can now import and use a new \nuclei/http\ module in JavaScript templates to perform HTTP requests. This library provides a \Client\ class with configurable options for timeouts, redirects, and cookies, and exposes methods for GET, HEAD, POST, and custom HTTP methods. It also includes utilities for NTLM authentication, such as \DecodeNTLM\ to parse server challenges and \NegotiateNTLM\ to generate negotiate messages, allowing templates to interact with NTLM-protected endpoints.

pkg/js/libs/http · high confidence

New JavaScript LDAP client library for Active Directory enumeration

Introduces a new \nuclei/ldap\ JavaScript module that allows users to connect to LDAP servers, authenticate, and perform Active Directory enumeration. The library provides methods to retrieve users, groups, and domain controllers, with specific helpers for finding accounts with never-expiring passwords, those trusted for delegation, and those not requiring passwords. It also includes utility functions for joining and negating LDAP filters. The implementation enforces network policies, blocking connections to restricted hosts (including local loopback for LDAPI) before dialing.

pkg/js/libs/ldap · high confidence

New JavaScript SMTP library for email sending and server checks

Added a new \nuclei/smtp\ JavaScript library that allows scripts to interact with SMTP servers. This includes an \SMTPMessage\ builder for composing emails (with support for From, To, Subject, Body, and Auth fields) and a \Client\ capable of checking if a host is running an SMTP server (\IsSMTP\), detecting open relays (\IsOpenRelay\), and sending emails (\SendMail\).

pkg/js/libs/smtp · high confidence

New JavaScript SSH client library with connection, info, and command execution capabilities

A new SSH client library is now available for JavaScript templates, exposing an \SSHClient\ object that allows users to connect to SSH servers using passwords or private keys, retrieve detailed handshake information via an info-mode connection, and execute remote commands over an established session. The implementation includes configurable connection timeouts and leverages memoization for handshake info requests to optimize repeated calls.

pkg/js/libs/ssh · high confidence

New JavaScript bindings generator for Nuclei modules

A new command-line tool has been added to generate Go bindings for JavaScript libraries used in Nuclei. This tool processes library modules from a specified directory and outputs generated Go code, enabling the integration of JavaScript-based functionality into the Nuclei engine.

pkg/js/devtools/bindgen/cmd · high confidence

New JavaScript filesystem library for Nuclei templates

A new \fs\ module is now available in the JavaScript execution environment, allowing template authors to interact with the local filesystem. This module exposes functions to list directory contents (filtering by file or directory type), read individual files as bytes or strings, and read the contents of all files within a specified directory. All operations are scoped to permitted paths using the execution ID to ensure security boundaries are respected.

pkg/js/libs/fs · high confidence

New JavaScript global helpers and Active Directory utilities

This change introduces a new set of JavaScript global functions available in the Nuclei engine. It adds base64 encoding and decoding helpers (\atob\, \btoa\), data manipulation utilities (\dump\_json\, \to\_json\, \to\_array\, \hex\_to\_ascii\), and network checks (\isPortOpen\, \isUDPPortOpen\, \getNetworkPort\). Additionally, it provides Active Directory-specific functionality via \getDomainControllerName\, which queries domain controller information via LDAP or SMB. The random number generation functions (\Rand\, \RandInt\) have been updated to use \crypto/rand\ for cryptographic security instead of \math/rand\.

pkg/js/global · high confidence

New JavaScript helper modules for WMI, Task Scheduler, SCMR, and DCOM

Added four new Go-based JavaScript helper libraries (WMI, Task Scheduler, SCMR, and DCOM) that expose Windows remote execution capabilities via the Nuclei JS runtime. These modules provide client objects with methods to run commands, create services, schedule tasks, and invoke DCOM interfaces, allowing users to leverage these Windows-specific protocols directly in their Nuclei templates.

(repo-wide) · high confidence

New JavaScript krbforge library for Kerberos ticket forging

A new \krbforge\ JavaScript library is available in Nuclei templates, exposing \CreateGoldenTicket\ and \CreateSilverTicket\ functions that wrap the \goimpacket\ Kerberos primitives. This allows templates to forge Golden (TGT) and Silver (TGS) tickets using provided NT hashes or AES keys, with the ability to optionally persist the resulting credential cache (ccache) to a file. The implementation enforces a file sandbox by default, rejecting writes to paths outside the template directory unless the \-allow-local-file-access\ flag is enabled, ensuring that ticket artifacts are only written to permitted locations.

pkg/js/libs/krbforge · high confidence

New JavaScript libraries for Kerberos roasting and DCSync

Added two new JavaScript libraries to the Nuclei runtime: \nuclei/krbroast\ and \nuclei/secretsdump\. The \krbroast\ library exposes AS-REP roasting and Kerberoasting primitives, allowing templates to extract Kerberos hashes for offline cracking. The \secretsdump\ library exposes a single-object DCSync capability via the DRSUAPI interface, enabling the retrieval of NT/LM hashes and account details for a specific principal when the template has the necessary replication rights.

pkg/js/libs/krbroast, pkg/js/libs/secretsdump · high confidence

New JavaScript libraries for byte buffers, console logging, and IKEv2 protocol handling

This change introduces three new JavaScript libraries to the Nuclei engine, enabling script authors to manipulate binary data, log messages, and construct IKEv2 network messages. The \nuclei/bytes\ library provides a Buffer object with methods to write, append, and convert byte arrays (including hex and hexdump formats), as well as a \Pack\ method for binary struct serialization. The \nuclei/goconsole\ library exposes a console interface that routes log, warn, and error messages through the application's standard logger. Additionally, the \nuclei/ikev2\ library allows scripts to build and encode IKEv2 SA\_INIT exchange messages by appending nonce and notification payloads.

pkg/js/libs/bytes · high confidence

New JavaScript structs library for binary packing and unpacking

A new \structs\ JavaScript library is now available in the nuclei bindings, exposing Go-based binary packing and unpacking capabilities to JavaScript templates. This addition allows users to construct and parse binary network protocols (such as the SMB exploit example provided) using familiar format strings, bridging the gap between Go's efficient binary handling and JavaScript's template scripting environment.

pkg/js/libs/structs · high confidence

New Kerberos JavaScript library with network policy enforcement

A new \kerberos\ module is now available in the JavaScript bindings, allowing users to interact with Kerberos authentication (e.g., enumerating users, retrieving AS-REP hashes) via \nuclei/kerberos\. This implementation introduces a network policy check that validates domain controller addresses against a blacklist before initiating connections, and it supports custom IP address overrides and timeout configurations for the underlying KDC communications.

pkg/js/libs/kerberos · high confidence

New LLM extractor and regex group safety guard

The extractors package now supports a new LLM-based extraction type that uses a natural-language prompt and a JSON schema to instruct a model to extract specific fields from a response, with {{...}} variable interpolation and a random response boundary to mitigate prompt injection. Additionally, regex extractors now reject negative group indices at compile time and fail closed at runtime to prevent index-out-of-range panics, while all extractors require at least one value for their type to prevent misconfiguration.

pkg/operators/extractors · high confidence

New LLM matcher and internal matcher support

The matchers package now supports an LLM-based matcher type that uses a configurable model to classify HTTP responses, requiring a minimum confidence threshold and restricting the model to a fixed set of verdicts to prevent prompt injection. Additionally, a new \internal\ flag allows matchers to be used for conditional logic in flow templates without appearing in the final output.

pkg/operators/matchers · high confidence

New LevelDB-backed deduplication layer for nuclei scan results

A new deduplication storage component has been added to the reporting pipeline, persisting scan event hashes to a LevelDB database. This allows nuclei to track and suppress duplicate findings across sessions by indexing specific result fields (such as template ID, host, port, and metadata) into durable keys. The implementation includes logic to handle storage corruption recovery and ensures that concurrent indexing operations are serialized to prevent race conditions.

pkg/reporting/dedupe · high confidence

New MSSQL JavaScript library with fingerprinting, connection, and query execution

The MSSQL JavaScript library now provides a comprehensive set of capabilities for interacting with Microsoft SQL Server. Users can detect MSSQL services via a new \FingerprintMssql\ function that performs a TDS pre-login probe to extract version, encryption, and MARS details, as well as a simpler \IsMssql\ check. The library supports connecting to databases using \Connect\ and \ConnectWithDB\, and includes an \ExecuteQuery\ method to run arbitrary SQL statements and retrieve results. Additionally, the library implements memoization for all network calls to optimize repeated probes and connections, and ensures database names in connection strings are properly escaped to prevent parameter injection.

pkg/js/libs/mssql · high confidence

New Markdown exporter with path-traversal-safe filename sanitization

A new Markdown reporting exporter has been added to generate \.md\ files for scan results, supporting an optional sort mode that organizes output into subdirectories by severity, host, or template. The implementation includes a robust filename sanitizer that strips path separators and \..\ sequences to prevent directory traversal attacks when user-controlled values (like hostnames or template IDs) are used in file paths, and this safety logic is verified by unit and fuzz tests.

pkg/reporting/exporters/markdown · high confidence

New Markdown formatting utilities with code block escaping

The markdown reporting exporter now includes a new utility package (\pkg/reporting/exporters/markdown/util\) that provides functions for generating markdown elements such as bold text, links, tables, and headings. A key addition is the \CreateCodeBlock\ function, which automatically escapes backticks and backslashes in code content to prevent markdown syntax breaking. This ensures that code snippets in reports are rendered correctly without interfering with the surrounding markdown structure.

pkg/reporting/exporters/markdown/util · high confidence

New MySQL service detection and fingerprinting capabilities

The JavaScript library now includes a MySQL client that allows users to detect MySQL services, retrieve detailed server fingerprints, and establish connections. The \FingerprintMySQL\ function performs a native handshake parse to extract server version, authentication plugin, capabilities, and status flags, while \IsMySQL\ provides a simple boolean check. Connection methods (\Connect\ and \ConnectWithDSN\) utilize a custom \nucleitcp\ dialer to respect network policies and include sandboxing to prevent local file access attacks via \LOAD DATA LOCAL INFILE\. Results are memoized to avoid redundant network probes for the same host and port within an execution.

pkg/js/libs/mysql · high confidence

New Nuclei SDK for programmatic scanning

The \lib\ package introduces a new SDK that allows developers to integrate Nuclei scanning capabilities directly into their Go applications. This includes a \NucleiEngine\ for single-threaded scans and a \ThreadSafeNucleiEngine\ for concurrent, multi-target scanning. The SDK provides configuration options for template filtering (by severity, tags, IDs), concurrency limits, rate limiting, and result callbacks. It also supports loading templates from local paths, remote URLs, and workflows, as well as integrating with the PDCP dashboard for result uploads. Documentation and examples are provided in \lib/README.md\ and \lib/example\_test.go\.

lib · high confidence

New NucleiJS helper utilities and SQL result unmarshaling

This change introduces new utility functions in the JavaScript engine layer to improve stability and usability. A new \NucleiJS\ helper wraps the Goja runtime, providing safer argument retrieval, error handling, and context propagation (falling back to \context.Background\ if not set), which helps prevent crashes during script execution. Additionally, a new \UnmarshalSQLRows\ function is added to easily convert raw SQL query results into a structured format containing row counts, column names, and data maps, simplifying database interactions within Nuclei templates.

pkg/js/utils · high confidence

New Rsync JavaScript library for server detection and module listing

Users can now interact with Rsync servers directly from JavaScript templates. The new \pkg/js/libs/rsync\ module exposes an \IsRsync\ function to detect if a host is running an Rsync service and a \RsyncClient\ with \ListModules\ and \ListFilesInModule\ methods to enumerate server shares and files. The implementation leverages the \go-rsync\ library for protocol operations and \fingerprintx\ for service identification, with memoization applied to detection calls to optimize performance.

pkg/js/libs/rsync · high confidence

New SARIF export capability for vulnerability reports

Users can now export scan results in SARIF format, enabling integration with GitHub Security and other SARIF-compatible tools. The new exporter in \pkg/reporting/exporters/sarif\ maps Nuclei findings to SARIF rules and results, including severity levels, CWE tags, CVSS scores, and detailed rule metadata. This feature adds the necessary infrastructure to generate standardized security reports from scan data.

pkg/reporting/exporters/sarif · high confidence

New SSL protocol support with TLS version and cipher enumeration

Users can now scan targets for SSL/TLS configuration details using a new SSL protocol. This feature allows specifying minimum and maximum TLS versions, selecting scan modes (auto, openssl, ztls, ctls), and enabling enumeration of supported TLS versions and cipher suites (with filtering for insecure, weak, secure, or all types). The protocol integrates with the existing operator framework for matching and extracting results, and includes duration tracking for performance monitoring.

pkg/protocols/ssl · high confidence

New TypeScript definitions for JavaScript protocol modules

Generated TypeScript definition files (.d.ts) are now available for the Nuclei JavaScript bindings, providing type information for modules including HTTP, gRPC, Kerberos, LDAP, MSSQL, MySQL, DCERPC, and others. This enables IDE autocomplete and static type checking for developers writing Nuclei templates in JavaScript.

pkg/js/generated/ts · high confidence

New VNC library for JavaScript bindings

Added a new VNC library to the JavaScript bindings, exposing \vnc.IsVNC\ to detect VNC servers and retrieve their banners, and a \vnc.VNCClient\ with a \Connect\ method to authenticate against VNC servers using a password. The implementation leverages the fingerprintx library for detection and includes memoization for repeated checks.

pkg/js/libs/vnc · high confidence

New WAF detection and scan statistics tracking

The \pkg/output/stats\ package now tracks HTTP status codes, error kinds, and Web Application Firewall (WAF) detections during scans. It includes a new WAF detector that identifies WAFs like Cloudflare, ModSecurity, and AWS WAF using embedded regex signatures, and reports operational metrics such as regex evaluations and prefilter skips. Users will see these statistics displayed in the CLI output, including top status codes, top errors, and WAF detections, with color-coded formatting.

pkg/output/stats · high confidence

New WHOIS protocol support with RDAP integration and duration tracking

Nuclei now supports a new WHOIS protocol that queries RDAP servers to retrieve domain and IP registration data, exposing results as structured JSON events. Users can define custom queries and target specific WHOIS/RDAP servers, with built-in network policy enforcement to block unauthorized hosts. The protocol output includes a \duration\ field (in seconds) for performance monitoring, and supports standard matchers and extractors for filtering and parsing responses.

pkg/protocols/whois · high confidence

New WebSocket client library for JavaScript templates

A new \nuclei/websocket\ module is now available for use in JavaScript templates, providing a \Client\ object to establish WebSocket connections (ws:// and wss://). Users can configure connection options such as custom headers, subprotocols, timeouts, and TLS server names. The client supports sending text and binary (hex-encoded) messages, receiving responses, and automatically handling ping frames during communication. It integrates with the existing network policy and proxy settings, ensuring that WebSocket connections respect the same security constraints as other network requests.

pkg/js/libs/websocket · high confidence

New WebSocket protocol support with robust URL path resolution

Added a new WebSocket protocol implementation in \pkg/protocols/websocket\ that allows templates to connect to WebSocket endpoints. The implementation includes specific logic to correctly merge template addresses with target URLs, ensuring that if a template specifies a path (e.g., \/ws\), it is preserved, while falling back to the target's path if the template address has no path. This prevents common issues like path doubling or incorrect endpoint targeting when scanning WebSocket services.

pkg/protocols/websocket · high confidence

New XSS reflection context analyzer for fuzzing

The fuzzing engine now includes a new XSS context analyzer that detects where reflected payloads appear in HTML responses. It distinguishes between contexts such as HTML body text, generic attributes, URL attributes (like href and src), event handlers (like onclick), and executable script contexts (including javascript: URIs and data: URIs). This allows the fuzzer to provide more precise feedback on the potential impact of reflected input based on the specific HTML context in which it is rendered.

pkg/fuzz/analyzers/xss · high confidence

New bindgen templates for Go, JavaScript, and Markdown class generation

The bindgen system now includes new template files (go\_class.tmpl, js\_class.tmpl, markdown\_class.tmpl) that define how protocol bindings are generated. The Go template registers package functions, variables, and types with the goja runtime, the JavaScript template exports classes and functions for use in Nuclei scripts, and the Markdown template generates documentation tables for types, methods, and variables.

pkg/js/devtools/bindgen/templates · high confidence

New bindgen tool for generating Goja bindings and documentation

A new \bindgen\ tool has been added to the \pkg/js/devtools\ directory to automatically generate JavaScript bindings for native Go packages using the Goja engine. This tool parses Go source code and produces three types of output: Goja binding code (\.go\), JavaScript type representations (\.js\), and Markdown documentation. The generation process relies on embedded Go templates and requires \js-beautify\ and \gofmt\ to be installed in the system PATH for formatting the generated files.

pkg/js/devtools/bindgen · high confidence

New centralized reporting module with issue tracking and export capabilities

Nuclei now includes a new reporting subsystem that allows users to automatically create issues in external trackers (GitHub, GitLab, Gitea, Jira, Linear) and export scan results to various formats (JSON, JSONL, PDF, Markdown, SARIF, Elasticsearch, Splunk, MongoDB). The module supports granular filtering by severity and tags, deduplication of results, and configurable options for each tracker and exporter.

pkg/reporting · high confidence

New configuration system with layered profiles and inline secrets

The runner now uses a new configuration layering system that automatically loads settings from system, user, and explicit config files in a defined priority order, and introduces a profile mechanism that can override settings and inject inline secrets. Profiles can be specified by ID or path, and any secrets defined within a profile are automatically written to a temporary file and passed to the engine, while inline targets defined in a profile are merged into the active target list.

internal/runner · high confidence

New core engine architecture with workflow and scan strategy support

The \pkg/core\ package has been restructured to introduce a new \Engine\ that manages template and workflow execution. This change adds support for distinct scan strategies (\TemplateSpray\ and \HostSpray\), allowing users to control how templates are distributed across targets. It also introduces a new workflow execution engine that supports subtemplates, matchers, and input extraction, enabling complex multi-step scanning logic. The engine now provides lifecycle callbacks for template execution events, improving observability, and includes a work pool for managing concurrency across different protocol types (e.g., headless vs. non-headless).

pkg/core · high confidence

New custom template providers for Azure Blob, GitLab, and S3 with path-traversal protection

Users can now download custom Nuclei templates from Azure Blob Storage, GitLab repositories, and AWS S3 buckets in addition to the existing GitHub support. The implementation in \pkg/external/customtemplates\ introduces dedicated providers for each source (Azure, GitLab, S3) and a unified \CustomTemplatesManager\ that orchestrates them. To prevent path-traversal attacks from malicious server-controlled names or keys, all providers use a shared \safeJoinWithinDirectory\ helper that validates paths stay within the configured download directory, and GitLab downloads now preserve nested directory structures instead of flattening files.

pkg/external · high confidence

New docgen and checksum generation utilities

Added two new command-line tools: \cmd/docgen\ generates Markdown documentation and JSON schema definitions for Nuclei templates, and \cmd/generate-checksum\ computes SHA1 checksums for template files to ensure integrity.

cmd/docgen · high confidence

New example demonstrating runtime speed control

Added a new Go example in examples/with\_speed\_control that demonstrates how to initialize the Nuclei engine with specific concurrency and rate-limiting settings, and how to modify these parameters (rate limit, template threads, bulk size, and payload concurrency) at runtime during execution.

_examples/with\_speed\control · high confidence

New file protocol supporting local and remote SMB targets

The file protocol now supports scanning remote SMB shares in addition to local files. Users can target UNC paths (e.g., \\\\\fs01\\share\\file.txt\) or \smb://\ URLs, with authentication configured via template fields (\smb-user\, \smb-password\, \smb-domain\, \smb-hash\) or embedded in the URL. The implementation includes SMB path parsing, credential resolution, and directory enumeration, while enforcing network scan restrictions to deny excluded hosts.

pkg/protocols/file · high confidence

Added a new \pkg/utils/filepath\ package that provides utilities for safe file access, specifically designed to support sandboxing in template environments. The package introduces \IsPathWithinDirectory\ and \IsPathWithinAnyDirectory\ functions that correctly canonicalize paths to handle symlinks and platform-specific case sensitivity (such as on Windows), ensuring that path containment checks are robust against traversal attacks and sibling-prefix false positives. It also includes \IsHardLinkedRegularFile\ to detect hard-linked regular files, with platform-specific implementations for Unix and Windows to accurately determine link counts without following symlinks.

pkg/utils/filepath · high confidence

New flow template engine for conditional request orchestration

Nuclei v3 introduces a new \flow\ template engine that enables conditional execution and orchestration of requests using JavaScript (ECMAScript 5.1). This allows templates to perform logic such as checking if a target is a specific service before attempting an attack, iterating over extracted values to execute further requests, and managing dynamic variables at runtime. The engine is implemented in \pkg/tmplexec/flow\ and provides JavaScript bindings like \http()\, \dns()\, \iterate()\, and \set()\ to interact with Nuclei's protocol handlers, along with a \Dedupe\ object for value deduplication. This replaces the need for external workflow files for complex multi-step scenarios.

pkg/tmplexec/flow · high confidence

New fuzzing data format layer for structured encoding and decoding

A new \pkg/fuzz/dataformat\ package has been introduced to standardize how fuzzing templates encode and decode request payloads. It provides a unified interface for handling JSON, XML, raw strings, standard form data, and multipart forms, including specific logic to correctly preserve duplicate query parameters and form field names with shared prefixes. The multipart implementation also adds support for file uploads with metadata (filename and content-type) and handles mixed-type arrays, ensuring that fuzzing operations can reliably manipulate complex structured data without losing order or metadata.

pkg/fuzz/dataformat · high confidence

New fuzzing engine and per-target profile selection

Nuclei introduces a new fuzzing engine that allows templates to define fuzzing rules (specifying parts like query, header, or body, and modes like single or multiple) to systematically mutate requests. This capability is integrated into the HTTP and Headless protocols, enabling targeted fuzzing within those workflows. Additionally, a new target profile selector allows users to bind specific template selections (such as tags, severity, or profile IDs) to individual targets via JSON input lines, enabling complex, per-target scan configurations.

github.com/projectdiscovery/nuclei/v3 · high confidence

New gRPC JavaScript library for nuclei templates

Added a new \nuclei/grpc\ JavaScript library that allows templates to interact with gRPC services. The library provides a \Client\ class supporting both server reflection and precompiled protoset descriptors, enabling users to list services, describe symbols, and invoke unary methods with JSON payloads. It enforces nuclei's network policies (including host allowlists and local network restrictions) and local file access controls for protoset files, and supports TLS configuration, plaintext connections, and custom headers.

pkg/js/libs/grpc · high confidence

New high-performance JSON utility package with platform-specific optimization

A new \pkg/utils/json\ package has been introduced to provide fast JSON encoding and decoding. On supported platforms (Linux, Darwin, or Windows on amd64/arm64 with Go 1.20–1.26), it uses the high-performance \sonic\ library; on other systems, it falls back to \go-json\. The package exposes standard operations (Marshal, Unmarshal, Encoder, Decoder) and custom interfaces (Marshaler, Unmarshaler, JSONCodec) to maintain compatibility with standard library patterns while delivering improved performance.

pkg/utils/json · high confidence

New hmap-backed list input provider with per-target profile support

The list input provider has been replaced with a new implementation backed by hybrid hmap/filekv storage, enabling efficient deduplication and streaming of large input sets. This change introduces support for per-target template profiles, allowing users to specify JSON lines in their input (e.g., \{"target": "192.0.2.0/30", "tags": \["tomcat"\]}\) to restrict which templates run against specific hosts or CIDRs. The provider also handles CIDR expansion, ASN lookups, and respects the \--scan-all-ips\ flag to resolve hostnames to all associated IP addresses.

pkg/input/provider/list · high confidence

New input format support for OpenAPI, Postman, and Burp/Proxify sources

The tool now supports generating fuzzing requests from multiple input sources, including OpenAPI 3.0/Swagger 2.0 specifications, Postman collections, Burp Suite XML, and Proxify JSONL files. Users can pass these files directly to the engine, which parses the definitions to create HTTP requests with support for various content types (JSON, XML, form-data, etc.) and authentication methods. The implementation also introduces a variable injection system, allowing users to provide custom values via CLI flags, configuration files, or a dedicated YAML dump file for OpenAPI parameters, with optional text templating via ytt for YAML-based inputs.

pkg/input/formats · high confidence

New markdown report formatting infrastructure with injection protection

The reporting system now uses a new \format\ package to generate structured markdown reports. This introduces a \ResultFormatter\ interface and utility functions that build report descriptions, including template information tables, extracted results, and interaction data. A key behavioral change is the automatic escaping of code blocks in the response and request data to prevent markdown injection attacks, ensuring that raw payloads do not break the report structure or execute unintended formatting. The system also supports extensibility via metadata hooks and truncates large responses to 5KB.

pkg/reporting/format · high confidence

New multiprotocol execution engine

A new multiprotocol execution engine has been introduced to handle templates that define multiple protocols. This engine executes the protocol requests in the order they appear in the template, allowing dynamic values extracted by one protocol to be passed to subsequent protocols in the same template. It also ensures that response fields from each protocol are added to the template context, prefixed with the protocol type, making them available for use in later stages of the template execution.

pkg/tmplexec/multiproto · high confidence

New network protocol implementation with service name support and duration tracking

The network protocol has been re-implemented to support IANA service names (e.g., ftp, ssh) in the port field, automatically resolving them to numeric ports. It now includes a \stop-at-first-match\ option to halt template execution upon the first successful match, and adds \duration\ fields to track operation timing. The implementation also supports TLS connections via the \tls://\ address prefix and allows multiple ports to be specified in a single template.

pkg/protocols/network · high confidence

New offline HTTP protocol support for analyzing local response files

The offline HTTP protocol has been implemented, allowing users to scan local files containing raw HTTP responses (such as Burp Suite exports or JSONL/YAML dumps) using standard Nuclei matchers and extractors. The implementation handles input resolution for files, directories, and glob patterns (filtering for .txt files), parses raw HTTP response strings (including fixing HTTP/2 minor version compatibility issues), and maps response data to DSL variables for template evaluation.

pkg/protocols/offlinehttp · high confidence

New random IP generation utility for CIDR ranges

Added a new \randomip\ package that provides a \GetRandomIPWithCidr\ function, allowing users to generate a random IP address within one or more specified IPv4 or IPv6 CIDR ranges. The implementation handles various network classes and edge cases, such as non-zero base networks and /32 or /128 prefixes, while ensuring the returned IP falls within the provided network boundaries.

pkg/protocols/common/randomip · high confidence

New raw HTTP request parsing and fuzzing infrastructure

The \pkg/protocols/http/raw\ package now provides the core logic for parsing raw HTTP requests, including support for absolute URLs in unsafe mode, path automerging, and the persistence of query authentication parameters. This location also introduces a comprehensive fuzzing harness and seed corpus to exercise the parser across safe, unsafe, and self-contained modes, ensuring robustness against malformed inputs.

pkg/protocols/http/raw · high confidence

New scan event visualization charts

Added a new \pkg/scan/charts\ package that provides an HTTP server and HTML rendering capabilities for visualizing Nuclei scan events. Users can now view real-time charts via endpoints (e.g., \/concurrency\, \/fuzz\, \/slow\, \/rps\) or generate static HTML reports, displaying metrics such as total requests over time, top slow templates, request-per-second intervals, and concurrency trends.

pkg/scan/charts · high confidence

New scan-charts utility for generating HTML reports from scan events

A new command-line tool has been added at cmd/scan-charts that allows users to generate HTML reports from scan event data. The tool accepts a directory containing scan data, an optional output filename for the generated HTML, and an optional address to run a local server for viewing the charts. If an output file is specified, it generates the HTML and exits; otherwise, it starts a web server on the specified address (defaulting to :9000) to display the scan event charts.

cmd/scan-charts · high confidence

New simple Go SDK example demonstrating nuclei v3 integration

A new example file (examples/simple/simple.go) has been added to demonstrate how to use the nuclei v3 Go SDK. It shows initializing the NucleiEngine with context, applying template filters (specifically for 'oast' tags), enabling a metrics server on port 6064 for observability, loading targets, and executing scans with a callback.

examples/simple · high confidence

New statistics storage utility for engine metrics

A new \pkg/utils/stats\ package has been introduced to provide a thread-safe storage mechanism for tracking and displaying vital statistics of the engine. This utility allows components to record metrics (such as counts or values) and display them as warnings or errors at user-defined intervals, utilizing atomic operations for safety and integrating with the existing logging and colorization libraries.

pkg/utils/stats · high confidence

New structured fuzzing components for request parts

The fuzzing engine now uses a new component-based architecture in \pkg/fuzz/component\ to parse, mutate, and rebuild individual parts of HTTP requests. This introduces dedicated components for the request body (supporting JSON, XML, form data, and multipart), query parameters, URL path segments, headers, and cookies. Each component parses the raw request data into a structured format, allows values to be set or deleted, and rebuilds the request while preserving the original structure. This enables more precise and reliable fuzzing of specific request elements, such as mutating individual path segments without affecting others or handling complex multipart forms safely.

pkg/fuzz/component · high confidence

New telnetmini library for Telnet authentication and NTLM info extraction

Added the \pkg/utils/telnetmini\ package, providing a minimal client for interacting with Telnet servers. This includes basic username/password authentication, encryption negotiation detection, and a port of Nmap's SMB/NTLM logic to parse NTLM challenge responses for system information (such as OS version and computer name). The implementation includes a fix to the NTLM parser to require a minimum 48-byte response length, preventing slice-bounds panics on truncated data, and is accompanied by comprehensive tests covering valid challenges, boundary conditions, and error cases.

pkg/utils/telnetmini · high confidence

New template metadata model and workflow loader interface

The \pkg/model\ package now introduces a structured \Info\ type for template metadata, including fields for name, authors, tags, description, impact, references, severity, classification (CVE/CWE/EPSS), and remediation, along with JSON schema extension support. A corresponding \Classification\ struct standardizes vulnerability identifiers. Additionally, a \WorkflowLoader\ interface is defined to manage template path resolution by tags or explicit lists, laying the groundwork for workflow initialization.

pkg/model · high confidence

New time-delay analyzer for fuzzing

Added a new time-delay analyzer to the fuzzing engine that detects time-based vulnerabilities using linear regression heuristics. The analyzer sends requests with varying sleep durations, measures response times, and checks for a statistical correlation between the injected delay and the server's response time to identify timing-dependent issues.

pkg/fuzz/analyzers/time · high confidence

New tsgen tool for generating TypeScript definitions from Go code

A new development tool, tsgen, has been added to generate TypeScript definition files (.d.ts) for Goja Node modules written in Go. This tool parses Go source code to extract exported functions, methods, structs, and interfaces, converting them into TypeScript types (classes, interfaces, functions) to provide editor intellisense and documentation. It handles type mapping (e.g., Go int to TypeScript number, time.Time to Date) and supports nested structures and external package types.

pkg/js/devtools/tsgen · high confidence

New type utilities and resume state management

The \pkg/types\ package now includes new helper functions for converting JSON scalar values to strings and slices, as well as a new \ResumeCfg\ structure to manage scan progression and crash recovery state. Additionally, tests have been added to verify that resume file paths are correctly generated within the configured state directory.

pkg/types · high confidence

New unified authentication provider supporting multiple strategies and dynamic secrets

The \pkg/authprovider/authx\ package introduces a comprehensive authentication framework that supports Basic Auth, Bearer Token, Header, Cookie, and Query parameter strategies. It allows users to define static credentials in YAML files and apply them to requests via a unified \AuthStrategy\ interface. Additionally, it introduces dynamic secrets that can fetch credentials at runtime using templates and variables, with thread-safe lazy fetching to prevent race conditions.

pkg/authprovider/authx · high confidence

New utility package for protocol variables and JSON metadata fields

The \pkg/protocols/utils\ package has been introduced to centralize common protocol logic. It provides \GenerateVariables\ and \GenerateDNSVariables\ functions that parse URLs and domain names to extract structured metadata (such as BaseURL, Host, Port, Path, Scheme, FQDN, and TLD) for use in templates. Additionally, it adds a \JsonFields\ struct and helper functions (\GetJsonFieldsFromURL\, \GetJsonFieldsFromMetaInput\) to extract and standardize host, port, IP, scheme, and URL components for JSON output, including robust handling of IPv6 and explicit port extraction. The package also includes utility functions for cleaning JSON struct tags, configuring TLS client certificates, calculating HTTP content lengths, and formatting HTTP headers.

pkg/protocols/utils · high confidence

Per-host HTTP client pooling with connection reuse and HTTP-to-HTTPS auto-correction

The HTTP protocol engine now uses a per-host connection pool instead of a single shared client, significantly improving scan performance by reusing TCP and TLS connections across requests to the same host. The pool automatically detects and corrects HTTP-to-HTTPS port mismatches (e.g., when a server returns a 400 Bad Request on an HTTP port that actually requires HTTPS), and the idle connection pool size is dynamically sized based on template and payload thread concurrency to prevent connection churn. Users benefit from faster scans, especially for HTTPS targets, and more reliable handling of misconfigured ports without manual intervention.

pkg/protocols/http/httpclientpool · high confidence

Per-target template selection and profile support

The input system now supports specifying template selection criteria (such as tags, severity, types, and technology) on a per-target basis via JSON target lines, allowing different targets in a single scan to run different subsets of templates. It introduces a target profile registry that parses these lines, validates that profile references are strictly IDs (rejecting file paths), and merges profile settings with inline overrides. The system also implements tech-aware selection, matching multi-word technology names (e.g., "Apache Tomcat") against template metadata to ensure relevant templates run for specific products, while generic templates always execute. Duplicate target entries are handled by merging their selections, and unrestricted targets ensure all templates are loaded.

pkg/input/targetprofile · high confidence

PostgreSQL connections now use the project's custom dialer for context and timeout control

A new \pgwrap\ package registers a custom PostgreSQL driver (\pgwrap\) that intercepts database connection attempts. This ensures that all PostgreSQL network calls respect the execution context, support configurable timeouts, and utilize the centralized \fastdialer\ infrastructure, replacing the previous behavior where the standard \lib/pq\ driver handled connections directly without these controls.

pkg/js/utils/pgwrap · high confidence

Repository initialization with build, release, and documentation scaffolding

The repository has been initialized with core project scaffolding, including a GoReleaser configuration for building and releasing binaries across multiple operating systems and architectures, Dockerfiles for containerized builds, and a Makefile defining build, test, and fuzzing targets. Documentation files such as README, CONTRIBUTING, and architecture guides have been added to support development and usage.

(repo-wide) · high confidence

Support for Swagger 2.0 API specifications

Users can now import and scan APIs defined using Swagger 2.0 (OpenAPI 2.0) specifications. The system automatically converts Swagger 2.0 schemas to OpenAPI 3.0 internally to leverage existing scanning capabilities, handling both JSON and YAML formats. It also includes a downloader component that fetches remote Swagger specs, validates them, and ensures host and scheme information is correctly populated for accurate request generation.

pkg/input/formats/swagger · high confidence

Support for concurrent DNS clients with custom resolvers and proxy settings

The DNS client pool now supports concurrent Nuclei engines by introducing a configurable client pool. Users can now specify custom resolvers, retry counts, and SOCKS proxies for DNS requests via the Configuration struct. The system maintains a default client for standard operations but creates and caches separate clients for requests requiring specific resolver lists or proxy settings, ensuring isolation and performance in multi-engine scenarios.

pkg/protocols/dns/dnsclientpool · high confidence

Support for multi-document YAML inputs with ytt templating

The YAML input format now supports parsing multi-document YAML files (separated by '---') and allows variables to be injected into the input content using the ytt templating engine. Users can enable this by setting the \VarsTextTemplating\ option, which processes the YAML input through ytt before parsing, enabling dynamic variable substitution in HTTP request definitions.

pkg/input/formats/yaml · high confidence

Support for multi-format HTTP input files

Users can now load HTTP request inputs from various file formats including Burp Suite, JSON, YAML, OpenAPI, Swagger, and raw HTTP requests. The new HttpInputProvider in the HTTP input package automatically detects and parses these formats based on the specified input mode, allowing for more flexible input configuration without manual conversion.

pkg/input/provider/http · high confidence

Support for multiple uncover queries via template metadata

The uncover protocol handler now supports executing multiple discovery queries defined in template metadata. It parses keys ending in '-query' (e.g., 'shodan-query', 'fofa-query') from template info, deduplicates them per engine, and sequentially executes them against their respective discovery agents. This allows templates to specify multiple search queries for different engines, with results processed and output according to a specified format, while respecting rate limits and timeouts.

pkg/protocols/common/uncover · high confidence

Support for parsing Burp XML input files

Users can now provide Burp Suite XML export files as input to Nuclei. The new parser in the Burp format handler reads the XML structure, extracts HTTP requests and responses, and converts them into the internal request format, enabling the use of previously captured Burp traffic for scanning.

pkg/input/formats/burp · high confidence

Support for raw HTTP request input and per-target profiles

Users can now provide raw HTTP requests (e.g., from Burp Suite or browser devtools) as input using the \-im http\ flag, enabling direct DAST scanning of captured traffic without needing an OpenAPI spec. Additionally, the input system now supports per-target profiles, allowing users to define JSON lines in their target list to apply specific template selections, tags, or severity filters to individual targets within a single scan run.

pkg/input · high confidence

Template signing and verification infrastructure

This change introduces the core signing and verification logic for Nuclei templates. It adds a new \signer\ package that manages ECDSA key pairs (generation, storage, and parsing from environment variables or disk) and implements signing of template content, including handling of file imports and code protocols. The system verifies signatures by checking the template content against the stored signature, ensuring template integrity and authenticity. It also includes specific handling for JavaScript templates, requiring signatures for them and preventing re-signing by unauthorized parties.

pkg/templates/signer · high confidence

Unified input provider interface with multi-format support

The input handling layer has been refactored to use a new \InputProvider\ interface that unifies how targets are processed. This change introduces support for multiple input formats including lists, OpenAPI, and Swagger specifications, allowing users to provide targets via direct URLs or specification files. The system now automatically downloads and parses OpenAPI/Swagger specs when specified, and supports variable templating and HTTP probing for inputs. A new \SimpleInputProvider\ handles basic URL lists, while the architecture prepares for chunked input processing to improve memory efficiency with large target sets.

pkg/input/provider · high confidence

Removals

Removal of legacy matcher implementation

The \pkg/matchers\ package has been completely removed, deleting the legacy \compile.go\, \match.go\, and \matchers.go\ files. This eliminates the previous logic for matching HTTP responses against status codes, sizes, words, and regexes using OR/AND conditions and body/header parts, indicating a shift to a new matching architecture elsewhere in the codebase.

pkg/matchers · high confidence

Security

Secure DAST proxy with per-installation CA and authentication

The internal proxy now uses a unique, per-installation Certificate Authority (CA) to sign intercepted TLS connections, replacing the library's default CA to prevent third-party certificate forgery. The CA private key is stored with restrictive permissions (0600) and validated on load, and the system detects and rejects incomplete keypairs to avoid wedging startup. Additionally, the proxy enforces basic authentication for non-loopback bindings and ignores ambient HTTP\_PROXY/HTTPS\_PROXY environment variables to prevent silent traffic chaining.

internal/server/proxy · high confidence

Behavioural changes

Add variable exclusion logic and improve debug variable dumping

Users can now exclude specific matchers from templates using the \excludematchers\ utility, which supports wildcard patterns for template IDs and matcher names. Additionally, the variable dump functionality has been refactored to use the \godump\ library, providing a colorized, pretty-printed output for debugging variables with a configurable character limit.

pkg/protocols/common/utils · high confidence

Centralized initialization of protocol client pools

The \protocolinit\ package now provides a unified \Init\ function that sequentially initializes the client pools for DNS, HTTP signing, network, WHOIS/RDAP, and the JavaScript compiler, along with the global protocol state. This change consolidates the setup logic previously scattered across the engine, ensuring that all underlying protocol resources are correctly configured and ready before scan execution begins.

pkg/protocols/common/protocolinit · high confidence

Deduplicate crawled URLs before template execution

The input normalization layer now groups URLs by their structural pattern to prevent scanning the same resource multiple times. It canonicalizes URLs by lowercasing the scheme and host, removing default ports, stripping fragments, and dropping known tracking parameters (such as UTM and ad IDs). Additionally, a new fingerprinting mechanism identifies and collapses variable path segments—such as numeric IDs, UUIDs, hashes, and dates—into placeholders, and treats high-cardinality slugs as variables once a threshold is exceeded. This ensures that URLs differing only in these identifiers are treated as the same target, significantly reducing redundant scans.

pkg/input/normalize · high confidence

GitLab tracker now supports paginated duplicate issue detection

The GitLab issue tracker integration now includes configurable pagination for duplicate issue checks. Users can control the number of issues fetched per page via the \duplicate-issue-page-size\ option (defaulting to 100) and limit the total number of pages searched via \duplicate-issue-max-pages\ (defaulting to 0 for unlimited). This prevents excessive API usage or timeouts when searching for existing issues by title in large projects.

pkg/reporting/trackers/gitlab · high confidence

HTTP protocol engine refactored with RFC 9111 caching and request clustering

The HTTP protocol engine has been restructured to improve performance and reliability. A new RFC 9111-compliant HTTP response cache (backed by LevelDB) is now available, allowing repeated requests to be served from disk or memory. Request generation has been consolidated into a new \build\_request.go\ module, which introduces a \requestURLPattern\ field to ensure consistent vulnerability hashing. Additionally, a clustering mechanism (\cluster.go\) has been added to group identical static requests, reducing redundant network traffic, while connection reuse policies are now analyzed to prevent issues with race conditions and pipelining.

pkg/protocols/http · high confidence

Headless browser engine rewritten with go-rod and expanded action support

The headless engine in \pkg/protocols/headless/engine\ has been completely rewritten to use the go-rod library, replacing the previous implementation. This change introduces a comprehensive set of browser actions including navigation, scripting, clicking, screenshots, and various wait conditions (DOM, FCP, FMP, idle, load, stable, visible). It also adds support for request and response modification via headers and body manipulation, dialog handling, keyboard events, and file inputs. The engine now supports connecting to an external Chrome instance via a \cdp-endpoint\ option, manages incognito browser instances for isolation, and includes a robust HTTP client with TLS session caching and proxy support. Additionally, the new engine tracks action durations and maintains a request/response history for each page.

pkg/protocols/headless/engine · high confidence

Honeypot detection suppresses false-positive scan noise

The result-writing helper now checks for \output.ErrHoneypotSuppressed\ errors when writing output. If a result is suppressed due to honeypot detection, the system skips creating an issue in the tracker and does not increment the matched progress counter, effectively reducing noise from honeypot triggers.

pkg/protocols/common/helpers/writer · high confidence

Host error cache now supports removal and permanent error tracking

The host error cache in \pkg/protocols/common/hosterrorscache\ has been expanded to allow explicit removal of hosts via the new \Remove\ method and to distinguish between transient and permanent failures using \MarkFailedOrRemove\. This enables the scanner to reset a host's error count upon success (removing it from the failure list) and to permanently skip hosts that exhibit consistent, unresolvable errors, rather than just counting consecutive timeouts. The cache also now respects parent context cancellation, ensuring that scan-wide timeouts do not incorrectly penalize individual hosts.

pkg/protocols/common/hosterrorscache · high confidence

Introduce case-sensitive string slice type for model types

Added a new \stringslice\ package in \pkg/model/types/stringslice\ that provides a \StringSlice\ type for handling YAML and JSON unmarshalling of string values or arrays. This type normalizes input by converting values to lowercase and trimming whitespace, while also introducing a \RawStringSlice\ variant that preserves the original case of the input strings. This change supports the broader effort to preserve reference links as case-sensitive during unmarshalling.

pkg/model/types/stringslice · high confidence

Introduction of TemplateLogic error kind

A new error kind, TemplateLogic, has been added to the nuclei error handling system to categorize errors expected due to template logic issues, such as missing variables or timeout annotations. This allows the system to distinguish these specific logical errors from other runtime failures.

pkg/types/nucleierr · high confidence

Introduction of template execution engine and scan error formatting

The \pkg/tmplexec\ package has been introduced to handle the execution of templates, supporting Generic, MultiProtocol, and Flow engines. This change includes the addition of a \TemplateEngine\ interface and a new \parseScanError\ function that cleans up error messages by removing internal error kinds and context deadline details, resulting in clearer error reporting for users.

pkg/tmplexec · high confidence

LLM response framing hardened against prompt injection with stable caching

The LLM operator now wraps untrusted model responses in a random boundary marker to prevent prompt injection attacks, ensuring that injected instructions within the response cannot be interpreted as part of the system prompt. To maintain provider-side caching efficiency, this boundary marker is generated once per process rather than per call, allowing identical responses to produce identical prompts. This change includes a shared LLM client interface and token-truncation logic to standardize provider interactions across matchers and extractors.

pkg/operators/common/llm · high confidence

Lazy evaluation of template variables with undefined parameters

The variable evaluation engine in \pkg/protocols/common/variables\ now supports lazy evaluation for variables containing expressions that reference undefined parameters or runtime-specific values (such as \BaseURL\, \interactsh-url\, or unknown DSL arguments). Previously, such variables might fail or produce incorrect results if evaluated too early; the new \LazyEval\ flag ensures they are deferred until all necessary context is available, improving reliability for complex template chains and dynamic data sources.

pkg/protocols/common/variables · high confidence

Network DSL helpers now enforce scan context and network policies

DSL functions that perform network I/O—\resolve\, \public\_ip\, \publicip\, and \jarm\—are now disabled in context-free evaluations and require an active scan context to execute. When a scan is active, these helpers are subject to the scan's network policy, meaning local network access restrictions and target exclusions are enforced. This prevents unauthorized or accidental network access from template expressions and ensures that network operations respect the user's configured security boundaries.

pkg/operators/common/dsl · high confidence

New disk-based template catalog with path containment safety

The \pkg/catalog/disk\ package introduces a new \DiskCatalog\ implementation that supports both standard OS filesystems and Go's \fs.FS\ interface for template resolution. This change adds robust path containment checks to prevent sibling-prefix path traversal bugs (e.g., \/foo-evil\ incorrectly matching \/foo\) when using embedded filesystems, ensuring that glob and file lookups are strictly confined to the intended templates directory. It also filters out known non-template configuration files (like \cves.json\) from template searches.

pkg/catalog/disk · high confidence

New expression evaluation engine with stricter security and variable handling

The \pkg/protocols/common/expressions\ package has been rewritten to use the \projectdiscovery/govaluate\ library, introducing stricter rules for how dynamic variables and helper functions are processed. Resolved values are no longer re-evaluated or compiled as expressions, preventing previously resolved data from triggering further variable lookups or helper function execution. Additionally, unresolved variable markers are now correctly propagated through encoding functions (such as \base64\ and \hex\_encode\) instead of being hidden, and the engine strictly distinguishes between template-authored placeholders and literal expressions to avoid unintended side effects.

pkg/protocols/common/expressions · high confidence

New payload generation engine with attack modes and aggression levels

The payload generation subsystem has been replaced with a new implementation that introduces three distinct attack modes—Battering Ram, Pitchfork, and Cluster Bomb—controlling how multiple payload sets are combined. It adds support for payload aggression levels (low, medium, high) to allow users to scale the breadth of payload execution, and introduces a memoized environment variable resolver for consistent variable expansion. The new generator also features improved payload file resolution, automatically probing relative paths against the template directory hierarchy to fix path resolution issues, and includes a concurrent-safe options payload cache to improve performance when building payloads from CLI options.

pkg/protocols/common/generators · high confidence

New pooled JavaScript runtime with context-aware execution and security controls

The JavaScript engine now uses a dedicated compiler package that executes scripts in a pooled runtime, significantly improving performance and resource reuse. This change introduces strict context cancellation, ensuring that scripts are interrupted and abandoned if they exceed the configured execution deadline or if the parent context is cancelled, preventing goroutine leaks. Security is enhanced by enforcing local file access restrictions via the \-lfa\ flag, ensuring that \require()\ calls cannot access arbitrary local files unless explicitly permitted. Additionally, the runtime now correctly propagates proxy settings, custom headers, and timeout configurations to all JavaScript network calls, ensuring consistent behavior with the rest of the tool.

pkg/js/compiler · high confidence

Optimized LLM operator execution order

The operator execution engine now prioritizes cheap matchers before invoking LLM-based matchers and extractors. This change ensures that expensive LLM calls are skipped when a cheap matcher fails (in AND conditions) or succeeds (in OR conditions), and defers LLM extraction until a match is confirmed, significantly reducing latency and cost for templates that combine standard and LLM operators.

pkg/operators · high confidence

Oracle library adds memoization, context propagation, and trace-file sandboxing

The Oracle JavaScript library now caches \IsOracle\ detection results to improve performance and ensures all network calls respect the execution context and host-allowlist policies via a custom dialer. Additionally, it enforces security by normalizing or rejecting Oracle trace file and directory options in connection strings unless local file access is explicitly allowed, preventing unintended file system writes.

pkg/js/libs/oracle · high confidence

Persistent template metadata cache and refined filtering logic

The catalog now caches template metadata in a persistent, versioned store (index.gob) to avoid re-parsing templates on every run, significantly improving startup and scanning performance. The new filter system introduces precise precedence rules: exclusion criteria (tags, IDs, severities, protocols, and template paths) now take precedence over inclusion criteria, and the new IncludeTags field allows users to force-include a template that was excluded by a matching tag, without overriding other exclusion types like severity or protocol. The filter also supports wildcard patterns for template IDs and uses a compiled lookup structure for faster matching.

pkg/catalog/index · high confidence

PostgreSQL JS library introduces memoization and connection URL escaping

The JavaScript Postgres library now caches the results of service detection, connection, and query execution to improve performance for repeated calls with identical parameters. Additionally, the library now properly escapes database names and credentials when building connection URLs, preventing potential injection of unwanted query parameters (such as SSL settings) into the connection string.

pkg/js/libs/postgres · high confidence

Preserve explicit target ports in network templates

Network templates now correctly preserve ports explicitly specified by the user in the target input (e.g., \example.com:80\), preventing them from being overwritten by the template's default port. Previously, if a target included a URL scheme (like \http://\), the engine would assume the port was implied by the scheme and replace it with the template's port, even if the user had intentionally specified a different or reserved port. This change ensures that bare \host:port\ inputs are always respected, while scheme-prefixed inputs with reserved ports (80, 443, 8080, 8443, 8081, 53) are still updated to match the template's port unless excluded. Additionally, the system now supports resolving IANA service names (like \ssh\, \mysql\) to their numeric ports in network templates, with a fallback for services not recognized by the OS.

pkg/protocols/common/contextargs · high confidence

Protocol state management refactored for execution-scoped isolation and performance

The protocol state layer has been restructured to support concurrent Nuclei engines within the same process by introducing execution-scoped isolation. A new \ExecutionContext\ is now propagated via context values, allowing dialers, network policies, and HTTP client pools to be keyed by a unique execution ID rather than using global singletons. This change eliminates data races and improves concurrency safety. Additionally, a new lock-free \HTTPPool\ with singleflight creation and idle-connection eviction replaces the previous map-based caching, significantly reducing lock contention during high-throughput scanning. The refactoring also integrates local file access (LFA) and network policy checks directly into the execution context, ensuring that security constraints like \allow-local-file-access\ and host allowlists are consistently enforced per execution.

pkg/protocols/common/protocolstate · high confidence

RDP library now caches detection results

The RDP JavaScript library (pkg/js/libs/rdp) now memoizes the results of IsRDP, CheckRDPAuth, and CheckRDPEncryption calls. This means that repeated checks for the same host, port, and execution ID will return cached results instead of performing new network connections, improving performance and reducing redundant network traffic.

pkg/js/libs/rdp · high confidence

Redis library adds memoization to improve performance

The Redis JavaScript library now caches the results of repeated calls to \GetServerInfo\, \Connect\, \GetServerInfoAuth\, and \IsAuthenticated\ for the same host, port, and execution context. This optimization reduces redundant network requests and speeds up template execution when these operations are invoked multiple times.

pkg/js/libs/redis · high confidence

Refactored event creation to use godump and extract values in order

The event creation logic in \pkg/protocols/common/helpers/eventcreator\ has been updated to use the \godump\ library for variable dumping, replacing the previous implementation. Additionally, the system now ensures that extracted values are processed and included in the output in a consistent, ordered manner, which affects how dynamic values and operator results are assembled into the final event structure.

pkg/protocols/common/helpers/eventcreator · medium confidence

Rewritten output system with honeypot suppression and enhanced JSON fields

The output subsystem has been rewritten to provide more granular control over scan results. Screen output now supports optional timestamps, matcher status indicators, and detailed metadata display. JSON output includes new fields such as port, IP, scheme, and URL for better context. A key behavioral change is the introduction of honeypot detection, which automatically suppresses results identified as honeypots to reduce scan noise. The system also supports template signature verification via an embedded certificate and allows for credential redaction in output.

pkg/output · high confidence

Robust template installation with ownership tracking and cross-process locking

The installer now manages template updates with a new ownership system that tracks file digests to safely quarantine and clean up retired templates, preventing data loss during interrupted or concurrent updates. It introduces a cross-process file lock to serialize template installations and updates, avoiding race conditions, and adds strict path validation to reject zip-slip attacks and symlinks that escape the templates directory. Additionally, the installer now respects local file permissions during updates, validates downloaded ignore files against HTML responses, and logs a summary table of changes to stderr.

pkg/installer · high confidence

SMB JavaScript library adds memoization and SMBv1 fallback probing

The \nuclei/smb\ JavaScript module now caches repeated SMB operations (such as listing shares, directories, reading files, and detecting SMBGhost) using a generated memoization layer, reducing redundant network calls for identical parameters. Additionally, the \ConnectSMBInfoMode\ function now probes for SMBv1 support after an initial SMB2 negotiation, ensuring that hosts supporting only SMBv1 are correctly identified in protocol discovery results.

pkg/js/libs/smb · high confidence

SMB session library with secure transport and path validation

The JavaScript SMB session library now uses a dedicated transport layer (gptransport) that enforces execution-scoped network policies and fastdialer routing, preventing unauthorized or out-of-scope connections. The library also introduces strict validation for SMB share paths and identities, rejecting path traversal attempts and normalizing inputs to ensure safe file operations.

pkg/js/libs/gptransport, pkg/js/libs/smbsession · high confidence

Stop-at-first-match execution control and interactsh URL extraction

The HTTP protocol utilities now include a generic StopAtFirstMatchHandler that manages concurrent request execution, allowing the system to stop processing further requests immediately after the first match is found (when enabled). This handler supports both blocking and non-blocking work pool modes and provides callbacks for result handling. Additionally, a new utility function extracts Interactsh URLs from event data, ensuring that Interactsh interactions are correctly triggered even when matchers require conditions from multiple requests.

pkg/protocols/http/httputils · high confidence

Telnet library adds memoization and context propagation

The Telnet JavaScript library now memoizes the IsTelnet check to avoid redundant network probes for the same host and port within an execution, and ensures all network calls properly propagate the execution context for watchdog and safety checks.

pkg/js/libs/telnet · high confidence

Template loading and execution performance improvements

The template loading and execution pipeline has been optimized for speed and memory efficiency. A new template cache (\pkg/templates/cache.go\) stores parsed templates and validates them against file modification times to avoid redundant parsing. The workflow loader (\pkg/loader/workflow/workflow\_loader.go\) now preloads templates once and reuses the parser cache. Additionally, a new cloning mechanism (\pkg/templates/clone.go\) allows templates to be safely copied for engine-local state without deep-copying immutable parse data, reducing allocation overhead during execution.

pkg/templates · high confidence

YAML template includes now enforce sandboxing and depth limits

The YAML preprocessing layer now supports \!include\ directives with strict security controls: circular and excessively deep include chains are rejected (capped at 32 levels), and by default, includes are confined to the template's own directory and the configured template base directory, blocking access to arbitrary local files and hard-linked files unless the \-allow-local-file-access\ flag is enabled. Additionally, the YAML decoder wrapper normalizes duplicate mapping keys in lax mode to match legacy v2 behavior (keeping the last value) while \UnmarshalStrict\ now rejects both unknown fields and duplicate keys, and preserves the \map\[interface{}\]interface{}\ shape for nested interfaces.

pkg/utils/yaml · high confidence

Fixes

Execution-scoped interaction tracking for Out-of-Band requests

The interactsh client now uses per-execution scopes to track and manage Out-of-Band (OOB) interaction registrations. This ensures that when a scan execution completes, only the interactions generated by that specific run are cleaned up, preventing interference with other concurrent or subsequent executions. The implementation introduces a \RequestScope\ mechanism that isolates registration IDs and waits for in-flight callbacks to finish before removing data, improving reliability in multi-threaded scanning environments.

pkg/protocols/common/interactsh · high confidence

Guard against division-by-zero in progress statistics

The progress display mechanism now safely handles cases where the total request count is zero, preventing a division-by-zero panic when calculating progress percentages. This fix ensures the CLI output remains stable even when no requests are processed, and includes tests to verify the correct behavior for both known and unknown total counts.

pkg/progress · high confidence

Test coverage

Added CLI-level tests for configuration, storage, and performance; Added SDK regression and goroutine-leak tests; Added functional test suite for release-vs-current binary comparison; Added tests for code protocol execution and stderr capture; Expanded integration test coverage for Nuclei v3 protocols and features; Expanded integration test coverage for fuzzing, code execution, and protocol flows; New fuzzing harness and raw HTTP request parser for input ingestion; New integration and unit test utilities for nuclei.

Dependencies

Upgrade to Nuclei v3 with Go 1.26 and expanded dependency ecosystem

The project has been upgraded to version 3 (module path \github.com/projectdiscovery/nuclei/v3\) and now requires Go 1.26.8, enabling support for newer Go features and fixing Windows overlapped I/O issues. This update significantly expands the dependency graph, introducing major libraries for cloud storage (AWS SDK v2, Azure SDK), authentication (Azure AD, NTLM, Kerberos), and data processing (Sonic JSON, Gitea SDK, SOPS). It also integrates new security and network tools including Impacket, Rsync, VNC, and updated versions of core ProjectDiscovery libraries like \httpx\, \fastdialer\, and \dsl\, while replacing older dependencies such as \docker/docker\ with \gozero\ and \testcontainers\.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 56 → 53 (-2.6)
  • Rubric changed (rubric-2026.09.15 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 90 → 59 (-30.9)
  • Architecture 95 → 61 (-33.7)
  • Maturity 60 → 61 (+0.3)
  • Readiness 84 → 81 (-2.5)
  • Security 59 → 63 (+3.8)
  • Event-Driven 100 (new)
  • Accessibility 43 → 43 (+0.0)
  • Performance 81 (new)

Resolved (5)

  • Documentation: no installation or build instructions (README.md)
  • High: security finding (details withheld)
  • Low CVE: [GHSA redacted] (go.mod)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2

New (650)

  • Banned license: github.com/projectdiscovery/ldapserver
  • Cache.checkError (cognitive 18) (pkg/protocols/common/hosterrorscache/hosterrorscache.go)
  • ClassTooLong: Options (pkg/types/types.go)
  • ClassTooLong: Request (pkg/protocols/javascript/js.go)
  • ClassTooLong: Runner (internal/runner/runner.go)
  • Client.DCSync (cognitive 23) (pkg/js/libs/secretsdump/secretsdump.go)
  • Client.DCSync (cyclomatic 22) (pkg/js/libs/secretsdump/secretsdump.go)
  • Client.GetServiceTicket (cognitive 29) (pkg/js/libs/kerberos/kerberosx.go)
  • Client.RequestEvent (cognitive 27) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.debugPrintInteraction (cognitive 19) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.debugPrintInteraction (cyclomatic 19) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.do (cognitive 26) (pkg/js/libs/http/http.go)
  • Client.do (cyclomatic 24) (pkg/js/libs/http/http.go)
  • Client.poll (cognitive 18) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.poll (cyclomatic 16) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.processInteractionForRequest (cognitive 35) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.processInteractionForRequest (cyclomatic 31) (pkg/protocols/common/interactsh/interactsh.go)
  • Client.readUntil (cognitive 63) (pkg/utils/telnetmini/telnet.go)
  • Client.readUntil (cyclomatic 24) (pkg/utils/telnetmini/telnet.go)
  • ClusterExecuter.Execute (cognitive 28) (pkg/templates/cluster.go)
  • …and 630 more

Changes since last survey

  • 66 commits — 44 feature/other, 22 fixes

By area

  • (repo) — 22 commits
  • pkg/protocols — 15 commits
  • (root) — 6 commits
  • .github/workflows — 4 commits
  • pkg/input — 4 commits
  • pkg/installer — 4 commits
  • internal/tests — 3 commits
  • pkg/catalog — 2 commits
  • pkg/operators — 2 commits
  • pkg/tmplexec — 2 commits
  • pkg/js — 1 commit
  • pkg/loader — 1 commit

Notable commits

  • fix: Merge pull request #7776 from projectdiscovery/fix/7764-go-1.27
  • fix: Merge pull request #7827 from projectdiscovery/dwisiswant0/fix/fuzz/preserve-cookie-payloads-when-rebuilding-requests
  • fix: Merge pull request #7840 from projectdiscovery/fix/7836-fuzz-progress-total
  • fix: Merge pull request #7841 from projectdiscovery/fix/7837-js-port-requests
  • fix: Merge pull request #7842 from projectdiscovery/fix/7838-flow-request-count
  • fix: Merge pull request #7843 from projectdiscovery/fix/7839-js-precondition-count
  • fix: Merge pull request #7847 from projectdiscovery/fix/per-host-rate-limit-all-protocols
  • fix: Merge remote-tracking branch 'origin/fix/rate-limit-all-protocols' into fix/per-host-rate-limit-all-protocols
  • fix: fix dedup
  • fix: fix inputs
  • fix: fix keys
  • fix: fix(flow): count only requests a flow sends
  • fix: fix(flow): count skipped requests as processed like other protocols
  • fix: fix(fuzz): count fuzzing requests in the progress total
  • fix: fix(fuzz): count nothing up front for fuzzing requests with path or raw
  • fix: fix(fuzz): preserve cookie payloads when rebuilding requests
  • fix: fix(installer): give every alias of a templates directory the same update lock
  • fix: fix(installer): reload the templates version after taking the update lock
  • fix: fix(js): count pre-condition requests without -debug
  • fix: fix(js): count requests per port
  • …and 46 more

Architecture

  • 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

projectdiscovery/nuclei was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 10 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a48a58ef596747f86a65d701c6c73359f08b6b02 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer preprod-fe8540b5da9b.