Nikto @ 25

Chris Sullo (Pen Tester)

Wild West Hackin' Fest @ Mile High 2026 · Day 1

Overview

In a captivating talk at Wild West Hackin' Fest @ Mile High, veteran pen tester Chris Sullo celebrated the remarkable 25-year journey of Nikto, the venerable web server scanner. Marking a significant milestone, Sullo unveiled Nikto 2.6, a release born from years of accumulated insights and a dedication to addressing long-standing issues. This presentation offered a unique blend of historical perspective on web scanning, a deep dive into Nikto's evolution, and a comprehensive overview of the new functionalities designed to empower modern penetration testers.

Watch on YouTube

Visual summary for Nikto @ 25 by Chris Sullo
Visual summary for Nikto @ 25 by Chris Sullo

Key moments

  1. 0:00 Nikto @ 25: A brief history of web scanners
  2. 6:15 Nikto's origin story and design philosophy
  3. 10:30 Announcing Nikto 2.6: New features and performance
  4. 16:00 New DSL for advanced response matching
  5. 22:50 Leveraging the 'save' flag for debugging and evidence
  6. 33:40 Q&A: Addressing false positives with the 404 string
  7. 38:00 Q&A: Nikto's 25 years of steady, functional development

Nikto @ 25

Speakers: Chris Sullo, Pen Tester

Conference: Wild West Hackin' Fest @ Mile High

YouTube: https://www.youtube.com/watch?v=fSlOqW6sLFk

Overview

In a captivating talk at Wild West Hackin' Fest @ Mile High, veteran pen tester Chris Sullo celebrated the remarkable 25-year journey of Nikto, the venerable web server scanner. Marking a significant milestone, Sullo unveiled Nikto 2.6, a release born from years of accumulated insights and a dedication to addressing long-standing issues. This presentation offered a unique blend of historical perspective on web scanning, a deep dive into Nikto's evolution, and a comprehensive overview of the new functionalities designed to empower modern penetration testers.

Sullo, the original author and maintainer, underscored Nikto's enduring relevance in a rapidly changing security landscape. The talk highlighted how Nikto, despite its age and Perl codebase, continues to be a critical tool for identifying both modern and legacy vulnerabilities that often elude newer, more complex scanners. The 2.6 release focuses on enhancing accuracy, reducing false positives, improving performance, and expanding its utility for pen testers through innovative features like a new domain-specific language (DSL) for matching and advanced cross-platform Local File Inclusion (LFI) testing.

The significance of this talk extends beyond a mere software update; it's a testament to the power of open-source tools maintained by passionate individuals. Nikto's longevity and continued evolution serve as a reminder that foundational security tools, when thoughtfully updated, remain indispensable. Sullo's work ensures that Nikto not only preserves its legacy but also adapts to the challenges posed by contemporary web application architectures and defensive mechanisms, making it an essential component of any pen tester's toolkit.

Background

▶ Watch: Nikto @ 25: A brief history of web scanners (0:00)

The genesis of web vulnerability scanning traces back to the late 1990s, shortly after the widespread adoption of the World Wide Web and the introduction of CGI (Common Gateway Interface) in 1993. This era saw the emergence of rudimentary scanners designed to identify misconfigurations and vulnerabilities in CGI scripts. Chris Sullo highlighted CGI scan.c by BroncBuster in 1998 as potentially the first web scanner, followed by variations like CGI check.c. These early tools were simple C programs, often making static requests and analyzing basic HTTP/1.x text-based responses. A notable early web vulnerability, the PHF vulnerability from 1996, a CGI-based command execution flaw, put web security on the radar.

In 1999, Rain Forest Puppy released Whisker, a Perl-based scanner that significantly advanced the field. Whisker introduced more sophisticated options and capabilities beyond simple compile-and-run programs, serving as a major inspiration for Nikto. Around 2000, commercial web scanners like WebInspect and AppScan began to appear, offering more dynamic testing, crawling, and evaluation capabilities. Nikto itself was released in December 2001, born out of Sullo's personal need to scan for specific files and support SSL, a feature Whisker lacked. Initially, a small script, it quickly evolved into a full-fledged scanner due to increasing requirements.

The early scanners, including Nikto, primarily relied on making browser-like requests, analyzing HTTP/1.x responses (headers and body), and matching them against known patterns. This approach was effective when web servers adhered strictly to RFCs. However, the landscape shifted dramatically around 2005-2010 with the rise of specialized scanners for platforms like Joomla and Drupal, and later, the advent of more complex web application firewalls (WAFs) and evolving HTTP protocols (HTTP/2, HTTP/3). While commercial scanners adapted with crawling and dynamic analysis, Nikto continued to focus on its strength: an extensive database of known vulnerabilities, misconfigurations, and interesting files, now numbering over 8,000 checks. Sullo noted that Nikto deliberately stopped chasing transient vulnerabilities like daily cross-site scripting (XSS) and SQL injection (SQLi), instead focusing on persistent issues valuable to pen testers, such as identifying admin directories and version information. This focus allows Nikto to uncover findings that modern scanners, which often neglect older checks, might miss.

Key Findings

▶ Watch: Announcing Nikto 2.6: New features and performance (10:30)

The central finding of Chris Sullo's talk is the release of Nikto 2.6, a substantial update that breathes new life into the 25-year-old web scanner. This release is a culmination of years of maintenance, addressing long-standing bugs, and integrating modern development techniques. Sullo leveraged Cursor, an AI-powered code editor, to assist in the development process, allowing him to implement significant enhancements efficiently while maintaining careful oversight.

Key findings and contributions of Nikto 2.6 include:

  • New Domain-Specific Language (DSL) for Matchers: This is a pivotal improvement, enabling more complex and precise matching logic for analyzing server responses. The DSL significantly reduces false positives by allowing granular conditions across HTTP codes, headers, cookies, and body content, moving beyond simple 200 OK checks.
  • Cross-Platform Local File Inclusion (LFI) Testing: Nikto 2.6 introduces sophisticated LFI testing that targets both Linux (/etc/hosts) and Windows (win.ini) systems, moving away from easily blocked etc/passwd checks. This functionality is supported by a platform profiler and a pseudo function that dynamically constructs paths, making tests more effective and stealthier.
  • Performance Optimization: Despite a slight increase in code size (approximately 4% to reach 10,000 lines), Nikto 2.6 is about 10% faster. This optimization stems from refactoring tight loops, improving regular expression efficiency, and standardizing test execution.
  • Enhanced Reporting and Usability: The new version offers multiple output formats, including JSON, and improved detail in reports, such as extracted version numbers (e.g., OWA version). Features like a random user agent for every request and a bash script for faking multi-threading improve its utility for consultants running multiple scans.
  • Bug Resolution and Code Cleanup: Sullo successfully closed every open bug and issue, some dating back a decade. The release also involved a thorough cleanup of dead website references and outdated plugins, streamlining the codebase and improving the accuracy of information.
  • Future-Proofing: By standardizing test definitions and leveraging the new DSL, Sullo is setting the stage for potential future porting of Nikto's engine to faster languages like Go, with programmatic conversion of tests to formats like Nuclei already showing promising (though still buggy) results.

These findings collectively demonstrate Nikto's continued evolution as a relevant and powerful tool in the web application security domain, adapting to modern challenges while retaining its core strengths.

Technical Deep Dive

▶ Watch: New DSL for advanced response matching (16:00)

Nikto 2.6 introduces several significant technical advancements, primarily centered around its new Domain-Specific Language (DSL) for response matching and enhanced cross-platform LFI testing. These features significantly improve the scanner's accuracy, flexibility, and overall effectiveness.

At the heart of Nikto's operation is its extensive database of tests, traditionally stored in CSV format. This format, which Sullo describes as "very easy to look at," allows users to inspect, modify, and create custom tests. The new DSL revolutionizes how these tests are defined and executed. Previously, matching logic was cumbersome, relying on multiple columns for logical conditions. Now, the DSL enables complex, human-readable conditional statements directly within the test definitions. For instance, a test can now specify if code not 404 and body matches admin to identify administrative interfaces more accurately. Another example provided is if code 200 or 500 and header matches server case insensitive to Apache, demonstrating the ability to combine HTTP status codes and header analysis.

The DSL supports matching against specific parts of an HTTP response: the code (status), a cookie (name or value), a header (name or value), or the body. This specificity is crucial for reducing false positives, as it prevents matching a header value against the body, for example. Regular expressions and grouping logic are fully supported, allowing for highly granular pattern detection. A particularly useful feature of the DSL is its ability to perform extractions. For example, extractor body matches Outlook and body matches this OWA path then extract version allows Nikto to not just report the presence of Outlook Web Access (OWA) but also to extract and present its specific version number in the report, providing more actionable intelligence to the pen tester. This rich matching capability allowed Sullo to remove eight older plugins by integrating their functionality directly into the standardized test database.

Another major technical upgrade is the cross-platform LFI testing. Historically, LFI tests often targeted Linux-specific files like /etc/passwd, which are now routinely blocked by WAFs. Nikto 2.6 shifts focus to less obvious targets like /etc/hosts for Linux and win.ini for Windows, making tests more effective. This is achieved through a new pseudo function and variables (e.g., win_next_absolute_path) that dynamically construct file paths. These variables are defined in a DB_variables file, allowing for easy customization. A platform profiler runs at the beginning of a scan, analyzing response headers to infer the target's operating system (Linux, Windows, etc.). This allows Nikto to automatically reduce the number of irrelevant tests, focusing only on platform-specific LFI attempts, thereby saving time and network traffic. For example, a single test database entry containing CGI_dirs and LFI variables can expand into multiple requests, testing various CGI directories for both Linux and Windows LFI paths. The CGI_dirs variable is particularly intelligent, performing initial probes to determine actual CGI directories and only running CGI-related tests if such directories are found.

Sullo also detailed significant performance optimizations. Despite a 4% increase in the total lines of code (now around 10,000 lines), Nikto 2.6 achieves a 10% speed increase. This was accomplished through meticulous optimization of tight loops, request handling, response analysis, and regular expressions. While Perl's lack of native threading presents limitations, these optimizations demonstrate a commitment to maximizing efficiency within the existing language. Other technical enhancements include the automatic sending of a random user agent with every request, addressing a common consultant's practice, and a bash script to "fake" multi-threading by running multiple Nikto instances in screen.

The architecture remains modular, with all tests residing in the databases directory. Users can create their own custom test files by prepending a U to the filename (e.g., U_custom.db), and Nikto will automatically load them. Each test requires a unique ID, which can be generated using the DB check utility. This extensibility makes Nikto highly adaptable for specific internal environments or custom application testing.

Demo / Proof of Concept

▶ Watch: Q&A: Addressing false positives with the 404 string (33:40)

While the talk did not feature a live, interactive demonstration of Nikto 2.6 exploiting a vulnerability, Chris Sullo effectively showcased key functionalities and provided compelling evidence of the tool's capabilities and historical roots.

A notable "demo" was the presentation of the original cgiscan.c program from February 1999, running successfully on a modern system. This visual proof underscored the deep history of web scanning and the fundamental principles that still apply. Sullo pointed out that this 50-line C program, despite its age and lack of TLS support, could still find vulnerabilities on an HTTP server today.

For Nikto 2.6 itself, Sullo highlighted the –save flag as a crucial feature for Proof of Concept (PoC) generation and evidence collection. When used, the –save flag creates a directory containing a text file for every positive response. Each file includes:

  • The raw request and response: Essential for understanding exactly what was sent and received.
  • Information about the test: Details on the specific check performed.
  • Reason for the match: Crucially, it explains why Nikto alerted on the response, detailing the DSL match (e.g., "body match") or other conditions.

Beyond just raw data, the –save output includes a JSON representation of the request. This is where the replay utility, located in Nikto's utils directory, comes into play. The replay script can take this JSON file as input and rerun the exact request. This functionality is invaluable for pen testers:

  1. Verification: Confirming a finding manually.
  2. Debugging: If a client disputes a finding, the full request/response provides undeniable evidence.
  3. Integration with other tools: replay supports proxying, allowing the request to be captured in tools like Burp Suite, Caido, or OWASP ZAP. This enables further manipulation, analysis, and exploitation within a tester's preferred environment, effectively serving as a flexible PoC generation mechanism.

Sullo also showed a screenshot of Nikto's standard output, illustrating how it presents host information and identifies vulnerabilities or "interesting" findings. This included examples like an "ADM directory" with indexing enabled and an "admin directory identified as WebLogic," demonstrating Nikto's ability to point out potentially exploitable areas without necessarily performing the exploit itself. The enhanced reporting with extracted version numbers (e.g., "OWA version 1.4.x identified") further strengthens the PoC by providing more specific context.

These features, particularly the –save and replay capabilities, provide pen testers with the necessary tools to document findings, verify their validity, and seamlessly transition to deeper manual exploitation, effectively acting as a robust demonstration of Nikto's practical utility.

Defensive Implications

▶ Watch: Q&A: Nikto's 25 years of steady, functional development (38:00)

Nikto, while primarily a pen testing tool, offers significant defensive implications for organizations. Understanding how Nikto operates and what it targets can directly inform and strengthen a defensive security posture.

Firstly, organizations should regularly run Nikto against their external and internal web assets. The tool's ability to identify over 8,000 different issues, including legacy vulnerabilities and misconfigurations that newer scanners might overlook, makes it a critical component of a comprehensive vulnerability management program. Discovering an old, unpatched vulnerability on a forgotten web application, as Sullo mentioned from his own experience with a 20-year-old web app, can prevent a breach. Defenders should treat Nikto's output as an attacker's preliminary reconnaissance report, highlighting potential entry points and weak spots.

The new DSL for matchers and the improved accuracy of Nikto 2.6 are beneficial for defenders. By understanding the specific conditions Nikto uses to flag an issue (e.g., if code not 404 and body matches admin), security teams can refine their own detection logic in WAFs, IDS/IPS, or SIEM rules to catch similar attack patterns. The reduction in false positives means defenders can focus on genuinely critical alerts rather than wasting time investigating benign results.

The advanced cross-platform LFI testing in Nikto 2.6, which targets /etc/hosts or win.ini instead of the ubiquitous /etc/passwd, provides crucial intelligence. Defenders should ensure that sensitive files are not exposed via directory traversal or other LFI techniques on any platform. This means reviewing file access permissions, web server configurations (e.g., alias directives, mod_rewrite rules), and application code to prevent arbitrary file reading. The platform profiler in Nikto also serves as a reminder for defenders to be aware of how their web servers are fingerprintable, as this information can guide targeted attacks.

Organizations can also leverage Nikto's customization features defensively. By creating user-defined database (UDB) files, security teams can add checks specific to their internal applications, custom frameworks, or known developer practices. This allows them to proactively scan for unique misconfigurations or vulnerabilities that might only exist within their enterprise, fostering a more tailored and effective security assessment.

Furthermore, Sullo's advice on using the –404string flag is invaluable for defenders. By providing Nikto with a unique string from their web server's "not found" page, organizations can train the scanner to ignore generic 200 OK responses that mimic legitimate content. This helps in understanding what an attacker actually sees as a valid finding versus a false positive, allowing defenders to better prioritize remediation efforts and avoid alert fatigue.

Finally, the discussion around WAF evasion (e.g., Cloudflare's aggressive TLS stack fingerprinting) and the recommendation to use MITM proxies like Burp or Caido with Nikto provides a critical defensive insight. Defenders should be aware that sophisticated attackers will employ such techniques to bypass WAFs. Therefore, relying solely on WAF logs for attack detection might be insufficient. Implementing additional layers of security, such as host-based intrusion detection, application-level logging, and behavioral analytics, is essential to detect attacks that successfully bypass perimeter defenses. Understanding Nikto's capabilities, therefore, empowers defenders to build more resilient and intelligent security controls.

Key Takeaways

  • Nikto 2.6 is a significant milestone for the 25-year-old web scanner, offering substantial improvements in accuracy, performance, and usability, demonstrating its enduring relevance in web application security.
  • The new Domain-Specific Language (DSL) for response matching dramatically reduces false positives and allows for highly complex, granular test definitions across HTTP codes, headers, cookies, and body content, enhancing the quality of scan results.
  • Cross-platform Local File Inclusion (LFI) testing is more sophisticated, targeting less common but effective files like /etc/hosts and win.ini and dynamically building paths based on platform profiling, making LFI checks stealthier and more potent.
  • Nikto 2.6 achieves a 10% speed increase through meticulous code optimization despite a slight increase in its 10,000 lines of Perl code, showcasing a commitment to efficiency while preserving the tool's core.
  • The –save flag with the replay utility is a powerful feature for evidence collection and debugging, allowing pen testers to capture raw requests/responses in JSON format and rerun them via a proxy for verification and integration with other tools like Burp Suite.
  • Nikto remains invaluable for discovering both legacy and modern vulnerabilities, especially those overlooked by newer scanners, and can be customized via user-defined database files to effectively test internal applications and specific enterprise environments.

About the Speaker(s)

Chris Sullo is a seasoned security professional with a career spanning back to the mid-1990s, specializing in penetration testing since 1999. His extensive experience includes working in banking and research sectors, contributing significantly to the field of security tools. Sullo is the original author and dedicated maintainer of several security tools, most notably Nikto, the widely-used web server scanner. He has also developed other tools like CMS Explorer and DAF test. His long-standing commitment to Nikto, celebrating its 25th anniversary with the release of version 2.6, highlights his passion for practical, effective security testing. Sullo's work underscores a deep respect for the history of security tools and a forward-thinking approach to adapting them for modern challenges. He actively encourages community feedback and contributions to further evolve his projects.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Sullo updating Nikto for its 25th anniversary isn't going to drop new CVEs, but it proves why some old dogs still hunt. Replacing the ancient CSV logic with a custom DSL and swapping out burned LFI payloads makes the 2.6 release genuinely viable in 2024. Strong, pragmatic tool update from the guy who built it.

Heather Calloway (CISO) — SOLID

Chris Sullo’s update to Nikto is a sharp reminder of the blind spots in enterprise vulnerability management. While primarily a tactical release for penetration testers, it exposes how modern commercial scanners optimize for speed by dropping legacy checks. It's a required watch for your red team and worth a direct conversation with your vulnerability management lead.

→ Top-rated talks at Wild West Hackin' Fest @ Mile High 2026

All talks from Wild West Hackin' Fest @ Mile High 2026