Changeset 457

Timestamp:

06/19/2010 03:27:39 AM (3 years ago)

Author:

sullo

Message:

tidying up... a few other minor changes.

Location:

trunk

Files:

• nikto.conf (modified) (1 diff)
• nikto.pl (modified) (4 diffs)
• plugins/nikto_apacheusers.plugin (modified) (4 diffs)
• plugins/nikto_auth.plugin (modified) (9 diffs)
• plugins/nikto_content_search.plugin (modified) (4 diffs)
• plugins/nikto_core.plugin (modified) (20 diffs)
• plugins/nikto_headers.plugin (modified) (3 diffs)
• plugins/nikto_httpoptions.plugin (modified) (8 diffs)
• plugins/nikto_report_nbe.plugin (modified) (1 diff)
• plugins/nikto_report_xml.plugin (modified) (1 diff)
• plugins/nikto_robots.plugin (modified) (2 diffs)
• plugins/nikto_subdomain.plugin (modified) (4 diffs)
• plugins/nikto_tests.plugin (modified) (12 diffs)

trunk/nikto.conf

@@ -17 +17 @@
 # RFI URL. This remote file should return a phpinfo call, for example: <?php phpinfo(); ?>
 # You may use the one below, if you like.
-#RFIURL=http://cirt.net/rfiinc.txt?
+RFIURL=http://cirt.net/rfiinc.txt?
 
 # IDs never to alert on (Note: this only works for IDs loaded from db_tests)

trunk/nikto.pl

@@ -5 +5 @@
 use Getopt::Long;
 Getopt::Long::Configure('no_ignore_case');
+
 # use LW2;                   ### Change this line to use a different installed version
 
@@ -90 +91 @@
 require "$NIKTOCONFIG{'PLUGINDIR'}/nikto_single.plugin";
 require "$NIKTOCONFIG{'PLUGINDIR'}/LW2.pm";
-
 
 my ($a, $b) = split(/\./, $LW2::VERSION);
@@ -148 +148 @@
 # Open reporting
 report_head($CLI{'format'}, $CLI{'file'});
+
 # Load db_tests
 set_scan_items();
@@ -175 +176 @@
     %FoF = ();
 
-    nfetch($mark, "/", "GET", "", "", { nocache => 1, noprefetch => 1, nopostfetch => 1 }, "getinfo");
-        
+    nfetch($mark, "/", "GET", "", "", { nocache => 1, noprefetch => 1, nopostfetch => 1 },
+           "getinfo");
+
     if ($CLI{'findonly'}) {
         my $protocol = "http";

trunk/plugins/nikto_apacheusers.plugin

@@ -30 +30 @@
             scan_method => \&nikto_apacheusers,
             copyright   => "2008 CIRT Inc.",
-            options     =>  {
-                                enumerate   => "Flag to indicate whether to attempt to enumerate users",
-                                dictionary  => "Filename for a dictionary file of users",
-                                size        => "Maximum size of username if bruteforcing",
-                                home        => "Look for ~user to enumerate",
-                                cgiwrap     => "User cgi-bin/cgiwrap to enumerate"
-                            }
-            };
+            options     => {
+                         enumerate  => "Flag to indicate whether to attempt to enumerate users",
+                         dictionary => "Filename for a dictionary file of users",
+                         size       => "Maximum size of username if bruteforcing",
+                         home       => "Look for ~user to enumerate",
+                         cgiwrap    => "User cgi-bin/cgiwrap to enumerate"
+                         }
+              };
     return $id;
 }
@@ -43 +43 @@
 sub nikto_apacheusers {
     my ($mark, $parameters) = @_;
-    my $apacheusers=0;
-    
+    my $apacheusers = 0;
+
     # First ensure that the server is vulnerable
     (my $result, $content) = nfetch($mark, "/~root", "GET", "", "", "", "apacheusers: known user");
@@ -66 +66 @@
                 );
         }
-        $apacheusers=1;
-    }
-    
+        $apacheusers = 1;
+    }
+
     # If we can't enumerate users then return
     return unless ($apacheusers == 1);
+
     # If we haven't been asked to enumerate users then return
-    return unless (defined $parameters->{'enumerate'} &&
-                   $parameters->{'enumerate'} == 1);
-    
+    return unless (defined $parameters->{'enumerate'}
+                   && $parameters->{'enumerate'} == 1);
+
     # Now we can attempt to enumerate the users
     my ($url, $dictfile, $size);
@@ -94 +95 @@
             my $curl = "$cgidir" . "cgiwrap";
             (my $result, $content) =
-                nfetch($mark, $curl, "GET", "", "", "", "user_enum_apache: cgiwrap");
+              nfetch($mark, $curl, "GET", "", "", "", "user_enum_apache: cgiwrap");
             if ($content =~ /check your URL/i) {
                 push(@cgiwraps, "$curl");

trunk/plugins/nikto_auth.plugin

@@ -42 +42 @@
 
 sub nikto_auth_load {
+
     # Load up the database as soon as we can
-    
-    $REALMS=init_db("db_realms");
+
+    $REALMS        = init_db("db_realms");
     %REALMSMATCHED = ();
 }
@@ -50 +51 @@
 sub nikto_auth_pre {
     my ($mark, $parameters, $request, $result) = @_;
+
     # If we know the realm then don't bother guessing it
     # See whether we've already guessed it
-    
+
     my ($uridir) = $request->{'whisker'}->{'uri'};
     $uridir =~ s#/[^/]*$#/#g;
 
-    if (exists $REALMSMATCHED{$mark->{'hostname'}}{$uridir}) {
+    if (exists $REALMSMATCHED{ $mark->{'hostname'} }{$uridir}) {
+
         # Just set up the auth and return the valid result
-        LW2::auth_set($REALMSMATCHED{$mark->{'hostname'}}{$uridir}{'authtype'}, $request, $REALMSMATCHED{$mark->{'hostname'}}{$uridir}{'id'}, $REALMSMATCHED{$mark->{'hostname'}}{$uridir}{'password'});
+        LW2::auth_set($REALMSMATCHED{ $mark->{'hostname'} }{$uridir}{'authtype'},
+                      $request,
+                      $REALMSMATCHED{ $mark->{'hostname'} }{$uridir}{'id'},
+                      $REALMSMATCHED{ $mark->{'hostname'} }{$uridir}{'password'}
+                      );
+
         # Patch to fix short reads
         $request->{'whisker'}->{'allow_short_reads'} = 1;
@@ -68 +76 @@
 sub nikto_auth {
     my ($mark, $parameters, $request, $result) = @_;
-    my ($authtype)  = 'basic';
-    my ($body)      = $result->{'whisker'}->{'data'};
-    my ($uri)       = $result->{'whisker'}->{'uri'};
-    my ($method)    = $result->{'whisker'}->{'method'} || "GET";
+    my ($authtype) = 'basic';
+    my ($body)     = $result->{'whisker'}->{'data'};
+    my ($uri)      = $result->{'whisker'}->{'uri'};
+    my ($method)   = $result->{'whisker'}->{'method'} || "GET";
     my ($realm, $save_auth);
 
@@ -78 +86 @@
         return $request, $result;
     }
-    
+
     # Save to revert
     $save_auth = $result{'www-authenticate'};
-    
+
     # Split up www-authenticate to realm and method
     my @authenticate = split(/ /, $result->{'www-authenticate'});
@@ -94 +102 @@
         $authtype = $authenticate[0];
         $realm    = $authenticate[1];
-        $realm    =~ s/^realm=//;
+        $realm =~ s/^realm=//;
     }
-    
+
     nprint("+ $uri - Requires Authentication for realm '$realm'") if $OUTPUT{'show_auth'};
 
@@ -102 +110 @@
     foreach my $entry (@{$REALMS}) {
         unless ($realm =~ /$entry->{'realm'}/i || $entry->{realm} eq '@ANY') { next; }
-        
+
         if ($result->{'www-authenticate'} =~ /^ntlm/i) {
-            $authtype='ntlm';
-        }       
+            $authtype = 'ntlm';
+        }
+
         # Set up LW hash
         LW2::auth_set($authtype, $request, $entry->{'id'}, $entry->{'password'});
+
         # Patch to fix short reads
-                $request->{'whisker'}->{'allow_short_reads'} = 1;
-        LW2::http_fixup_request($request);     
+        $request->{'whisker'}->{'allow_short_reads'} = 1;
+        LW2::http_fixup_request($request);
+
         # pause if needed
         if ($CLI{'pause'} > 0) { sleep $CLI{'pause'}; }
@@ -118 +129 @@
         dump_var("Auth Request",  $request);
         dump_var("Auth Response", $result);
-        
+
         if ($result{'www-authenticate'} =~ /^ntlm/i) {
+
             # Deal with ntlm
             my @ntlm_x = split(/ /, $result{'www-authenticate'});
@@ -129 +141 @@
         my $uridir = $request->{'whisker'}->{'uri'};
         $uridir =~ s#/[^/]*$#/#g;
-       
+
         if ($result->{'www-authenticate'} eq ''
             && !defined $result->{'whisker'}->{'error'}) {
-            
-            my $message="Default account found for '$realm' at $uridir ($request->{'whisker'}->{'uri'}) (ID '$entry->{'id'}', PW '$entry->{'password'}'). $entry->{message}";
+
+            my $message =
+              "Default account found for '$realm' at $uridir ($request->{'whisker'}->{'uri'}) (ID '$entry->{'id'}', PW '$entry->{'password'}'). $entry->{message}";
             if ($entry->{'id'} eq '' && $entry->{'password'} eq '') {
-                $message="Blank credentials found at $uridir ($request{whisker}->{uri}), $entry->{'realm'}: $entry->{'msg'}"
+                $message =
+                  "Blank credentials found at $uridir ($request{whisker}->{uri}), $entry->{'realm'}: $entry->{'msg'}";
             }
-            unless ( $entry->{'checked'} == 1) {
-                add_vulnerability(
-                    $mark,
-                    $message,
-                    $entry->{tid},
-                    0,
-                    "GET",
-                    $uridir,
-                    $result
-                    );
+            unless ($entry->{'checked'} == 1) {
+                add_vulnerability($mark, $message, $entry->{tid}, 0, "GET", $uridir, $result);
                 $entry->{checked} = 1;
             }
@@ -153 +159 @@
             LW2::http_do_request_timeout($request, $result);    # test auth
             $NIKTO{'totalrequests'}++;
-            
+
             # Set up so we don't have to repeat in future
             # / isn't a valid entry in a hash  - more stupid perl
 
-            $REALMSMATCHED{$mark->{hostname}}{$uridir}{'id'}=$entry->{'id'};
-            $REALMSMATCHED{$mark->{hostname}}{$uridir}{'password'}=$entry->{'password'};
-            $REALMSMATCHED{$mark->{hostname}}{$uridir}{'authtype'}=$authtype;
+            $REALMSMATCHED{ $mark->{hostname} }{$uridir}{'id'}       = $entry->{'id'};
+            $REALMSMATCHED{ $mark->{hostname} }{$uridir}{'password'} = $entry->{'password'};
+            $REALMSMATCHED{ $mark->{hostname} }{$uridir}{'authtype'} = $authtype;
 
             # and leave

trunk/plugins/nikto_content_search.plugin

@@ -24 +24 @@
 
 sub nikto_content_search_init {
-    my $id = { name         => "content_search",
-               full_name    => "Content Search",
-               author       => "Sullo",
-               description  => "Search resultant content for interesting strings",
-               recon_method => \&nikto_content_search_load,
-               recon_weight => 1,
+    my $id = { name             => "content_search",
+               full_name        => "Content Search",
+               author           => "Sullo",
+               description      => "Search resultant content for interesting strings",
+               recon_method     => \&nikto_content_search_load,
+               recon_weight     => 1,
                postfetch_method => \&nikto_content_search,
                postfetch_weight => 20,
-               copyright    => "2010 CIRT Inc"
+               copyright        => "2010 CIRT Inc"
                };
 
@@ -39 +39 @@
 
 sub nikto_content_search_load {
+
     # Load up the database as soon as we can
-    
-    $CONTENTSEARCH=init_db("db_content_search");
-    %CSMATCHED = ();
+
+    $CONTENTSEARCH = init_db("db_content_search");
+    %CSMATCHED     = ();
 
     # to try and speed it up - precompile the regular expressions
@@ -52 +53 @@
 sub nikto_content_search {
     my ($mark, $parameters, $request, $result) = @_;
-    
+
     my $body   = $result->{'whisker'}->{'data'};
     my $file   = $result->{'whisker'}->{'uri'};
@@ -58 +59 @@
 
     foreach my $testid (@$CONTENTSEARCH) {
-        if ($body =~ $testid->{'compiled'} &&
-            !exists $CSMATCHED{$mark->{'hostname'}}{$file}) {
+        if ($body =~ $testid->{'compiled'}
+            && !exists $CSMATCHED{ $mark->{'hostname'} }{$file}) {
+
             # Check whether we've already matched it
             my $outmessage = "$file: $testid->{'message'}";
-            add_vulnerability($mark, $outmessage,
-                              $testid->{'nikto_id'},
-                              $testid->{'osvdb'},
+            add_vulnerability($mark, $outmessage, $testid->{'nikto_id'}, $testid->{'osvdb'},
                               $method, $file);
-            $CSMATCHED{$mark->{'hostname'}}{$file} = 1;
+            $CSMATCHED{ $mark->{'hostname'} }{$file} = 1;
         }
     }

trunk/plugins/nikto_core.plugin

@@ -130 +130 @@
     if ((defined $CLI{'file'}) && ($CLI{'file'} eq "-")) { return; }
 
-    # print to scan details to standard output if the users wants another format and is saving results to a file
+# print to scan details to standard output if the users wants another format and is saving results to a file
     $line =~ s/(CVE\-[12][0-9]{4}-[0-9]{4})/http:\/\/cve.mitre.org\/cgi-bin\/cvename.cgi?name\=$1/g;
     $line =~ s/(CA\-[12][0-9]{3}-[0-9]{2})/http:\/\/www.cert.org\/advisories\/$1.html/g;
     $line =~ s/BID\-([0-9]{4})/http:\/\/www.securityfocus.com\/bid\/$1/g;
-    $line =~ s/(MS[0-9]{2}\-[0-9]{3})/http:\/\/www.microsoft.com\/technet\/security\/bulletin\/$1.asp/gi;
+    $line =~
+      s/(MS[0-9]{2}\-[0-9]{3})/http:\/\/www.microsoft.com\/technet\/security\/bulletin\/$1.asp/gi;
     print "$line\n";
 
@@ -287 +288 @@
     $cont =~ s/(?:[0-9]{4}|[0-9]{1,2})[-.\/][0-9]{1,2}[-.\/](?:[0-9]{4}|[0-9]{1,2})//g;
     $cont =~ s/(?:([0-9]{2}:[0-9]{2}(?::[0-9]{2})?)|(?:[0-9]{8,14}|[0-9]{6}))//g;
-    $cont =~ s/(?:mon|tue|wed|thu|fri|sat|sun),? [0-9]{1,2} (?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec) [0-9]{4} (?:[0-9]{2}:[0-9]{2}:?(?:[0-9]{2})?)?//ig;
-    $cont =~ s/(?:[0-9]{2,4})? ?(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)(?:[0-9]{2,4})?\/?(?:[0-9]{2})?(?:[0-9]{2})?//gi;
+    $cont =~
+      s/(?:mon|tue|wed|thu|fri|sat|sun),? [0-9]{1,2} (?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec) [0-9]{4} (?:[0-9]{2}:[0-9]{2}:?(?:[0-9]{2})?)?//ig;
+    $cont =~
+      s/(?:[0-9]{2,4})? ?(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)(?:[0-9]{2,4})?\/?(?:[0-9]{2})?(?:[0-9]{2})?//gi;
     $cont =~ s/[0-9\.]+ second//gi;    # page load time
     $cont =~ s/[0-9]+ queries//gi;     # wordpress
@@ -317 +320 @@
         # url encoding, query portion
         if ($file =~ /\?(.*$)/) {
-            my $qs = $1;
-
-            # match pages which link to themselves w/diff args
-            $cont =~ s/$qs//gs;
+            my $qs = $1;
+
+            # match pages which link to themselves w/diff args
+            $cont =~ s/$qs//gs;
 
             # url encoded
-            $qs =~ s/([^A-Za-z0-9])/sprintf("%%%02X", ord($1))/seg;
+            $qs   =~ s/([^A-Za-z0-9])/sprintf("%%%02X", ord($1))/seg;
             $cont =~ s/$qs//gs;
         }
@@ -339 +342 @@
         $sslprint = "$NIKTO{'DIV'}\n";
         $sslprint .=
-            "+ SSL Info:        Ciphers: $mark->{'ssl_cipher'}\n" .
-            "                   Info:    $mark->{'ssl_cert_issuer'}\n" . 
-            "                   Subject: $mark->{'ssl_cert_subject'}";
+            "+ SSL Info:        Ciphers: $mark->{'ssl_cipher'}\n"
+          . "                   Info:    $mark->{'ssl_cert_issuer'}\n"
+          . "                   Subject: $mark->{'ssl_cert_subject'}";
     }
 
@@ -424 +427 @@
     $NIKTO{'mutate_opts'}{'5'} =
       "Attempt to brute force sub-domain names, assume that the host name is the parent domain";
-    $NIKTO{'mutate_opts'}{'6'} = "Attempt to guess directory names from the supplied dictionary file";
+    $NIKTO{'mutate_opts'}{'6'} =
+      "Attempt to guess directory names from the supplied dictionary file";
 
     ### CLI STUFF
@@ -505 +509 @@
     # screen output
     if (defined $CLI{'display'}) {
-        if ($CLI{'display'} =~ /d/i) { $OUTPUT{'debug'}   = 1; }
-        if ($CLI{'display'} =~ /v/i) { $OUTPUT{'verbose'} = 1; }
-        if ($CLI{'display'} =~ /s/i) { $OUTPUT{'scrub'}   = 1; }
-        if ($CLI{'display'} =~ /e/i) { $OUTPUT{'errors'}  = 1; }
-        if ($CLI{'display'} =~ /p/i) { $OUTPUT{'progress'} = 1; }
+        if ($CLI{'display'} =~ /d/i) { $OUTPUT{'debug'}          = 1; }
+        if ($CLI{'display'} =~ /v/i) { $OUTPUT{'verbose'}        = 1; }
+        if ($CLI{'display'} =~ /s/i) { $OUTPUT{'scrub'}          = 1; }
+        if ($CLI{'display'} =~ /e/i) { $OUTPUT{'errors'}         = 1; }
+        if ($CLI{'display'} =~ /p/i) { $OUTPUT{'progress'}       = 1; }
         if ($CLI{'display'} =~ /1/i) { $OUTPUT{'show_redirects'} = 1; }
-        if ($CLI{'display'} =~ /2/i) { $OUTPUT{'show_cookies'} = 1; }
-        if ($CLI{'display'} =~ /3/i) { $OUTPUT{'show_ok'} = 1; }
-        if ($CLI{'display'} =~ /4/i) { $OUTPUT{'show_auth'} = 1; }
-        }
+        if ($CLI{'display'} =~ /2/i) { $OUTPUT{'show_cookies'}   = 1; }
+        if ($CLI{'display'} =~ /3/i) { $OUTPUT{'show_ok'}        = 1; }
+        if ($CLI{'display'} =~ /4/i) { $OUTPUT{'show_auth'}      = 1; }
+    }
 
     # port(s)
@@ -622 +626 @@
 
     # POSIX support for status?
-    $NIKTO{'POSIX'}{'support'}=0;
+    $NIKTO{'POSIX'}{'support'} = 0;
     eval "use POSIX qw(:termios_h)";
-    if ( !$@ ) {
-        eval "use Time::HiRes qw(ualarm)";
-        if ( !$@ ) {
-                $NIKTO{'POSIX'}{'support'}=1; 
-                $NIKTO{'POSIX'}{'echo'} = ECHO | ECHOK | ICANON;
-                $NIKTO{'POSIX'}{'noecho'} = $oterm & ~$echo;
-                $NIKTO{'POSIX'}{'fd_stdin'} = fileno(STDIN);
-                $NIKTO{'POSIX'}{'term'} = POSIX::Termios->new();
-                $NIKTO{'POSIX'}{'term'}->getattr($fd_stdin);
-                $NIKTO{'POSIX'}{'oterm'} = $NIKTO{'POSIX'}{'term'}->getlflag();
-                }
-        }
+    if (!$@) {
+        eval "use Time::HiRes qw(ualarm)";
+        if (!$@) {
+            $NIKTO{'POSIX'}{'support'}  = 1;
+            $NIKTO{'POSIX'}{'fd_stdin'} = fileno(STDIN);
+            $NIKTO{'POSIX'}{'term'}     = POSIX::Termios->new();
+            $NIKTO{'POSIX'}{'term'}->getattr($fd_stdin);
+            $NIKTO{'POSIX'}{'oterm'}  = $NIKTO{'POSIX'}{'term'}->getlflag();
+            $NIKTO{'POSIX'}{'echo'}   = ECHOE | ECHO | ECHOK | ICANON;
+            $NIKTO{'POSIX'}{'noecho'} = $oterm & ~$echo;
+        }
+    }
     return;
 }
@@ -641 +645 @@
 ###############################################################################
 sub reset_term {
-        $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'oterm'});
-        $NIKTO{'POSIX'}{'support'}=0; 
-        }
+    $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'oterm'});
+    $NIKTO{'POSIX'}{'support'} = 0;
+}
 
 ###############################################################################
 sub safe_quit {
-        $mark->{'end_time'} = time();
-        report_host_end($mark);
-        report_close($mark);
-        reset_term();
-        exit(1);
-        }
+    $mark->{'end_time'} = time();
+    report_host_end($mark);
+    report_close($mark);
+    reset_term();
+    exit(1);
+}
 
 ###############################################################################
 sub check_input {
-        my $key = readkey();
-        if ($key eq '') { return; }
-
-        lc($key);
-        if ($key eq ' ') { 
-        my $line = sprintf("- Completed: %d tests, approximately %.0f%% complete", $NIKTO{'totalrequests'}, ($NIKTO{'totalrequests'} / $NIKTO{'total_checks'}) * 100);
-        if ($NIKTO{'current_plugin'} ne '') { $line .= " (in plugin $NIKTO{'current_plugin'})"; }
+    my $key = readkey();
+    if ($key eq '') { return; }
+
+    lc($key);
+    if ($key eq ' ') {
+        my $line = sprintf("- Completed: %d tests, approximately %.0f%% complete",
+                           $NIKTO{'totalrequests'},
+                           ($NIKTO{'totalrequests'} / $NIKTO{'total_checks'}) * 100);
+        if ($NIKTO{'current_plugin'} ne '') { $line .= " (in plugin $NIKTO{'current_plugin'})"; }
         nprint($line);
-        return;
-    }
-        elsif ($key eq 'v') { 
-                if ($OUTPUT{'verbose'}) { $OUTPUT{'verbose'}=0; }
-                else { $OUTPUT{'verbose'}=1; }
-        }
-        elsif ($key eq 'd') { 
-                if ($OUTPUT{'debug'}) { $OUTPUT{'debug'}=0; }
-                else { $OUTPUT{'debug'}=1; }
-        }
-        elsif ($key eq 'e') { 
-                if ($OUTPUT{'errors'}) { $OUTPUT{'errors'}=0; }
-                else { $OUTPUT{'errors'}=1; }
-        }
-        elsif ($key eq 'p') { 
-                if ($OUTPUT{'progress'}) { $OUTPUT{'progress'}=0; }
-                else { $OUTPUT{'progress'}=1; }
-        }
-        elsif ($key eq 'r') { 
-                if ($OUTPUT{'show_redirects'}) { $OUTPUT{'show_redirects'}=0; }
-                else { $OUTPUT{'show_redirects'}=1; }
-        }
-        elsif ($key eq 'c') { 
-                if ($OUTPUT{'show_cookies'}) { $OUTPUT{'show_cookies'}=0; }
-                else { $OUTPUT{'show_cookies'}=1; }
-        }
-        elsif ($key eq 'o') { 
-                if ($OUTPUT{'show_ok'}) { $OUTPUT{'show_ok'}=0; }
-                else { $OUTPUT{'show_ok'}=1; }
-        }
-        elsif ($key eq 'a') { 
-                if ($OUTPUT{'show_auth'}) { $OUTPUT{'show_auth'}=0; }
-                else { $OUTPUT{'show_auth'}=1; }
-        }
-       elsif (($key eq 'q') || (ord($key) eq 3)){ 
-                safe_quit();
-        }
-        return;
+        return;
+    }
+    elsif ($key eq 'v') {
+        if   ($OUTPUT{'verbose'}) { $OUTPUT{'verbose'} = 0; }
+        else                      { $OUTPUT{'verbose'} = 1; }
+    }
+    elsif ($key eq 'd') {
+        if   ($OUTPUT{'debug'}) { $OUTPUT{'debug'} = 0; }
+        else                    { $OUTPUT{'debug'} = 1; }
+    }
+    elsif ($key eq 'e') {
+        if   ($OUTPUT{'errors'}) { $OUTPUT{'errors'} = 0; }
+        else                     { $OUTPUT{'errors'} = 1; }
+    }
+    elsif ($key eq 'p') {
+        if   ($OUTPUT{'progress'}) { $OUTPUT{'progress'} = 0; }
+        else                       { $OUTPUT{'progress'} = 1; }
+    }
+    elsif ($key eq 'r') {
+        if   ($OUTPUT{'show_redirects'}) { $OUTPUT{'show_redirects'} = 0; }
+        else                             { $OUTPUT{'show_redirects'} = 1; }
+    }
+    elsif ($key eq 'c') {
+        if   ($OUTPUT{'show_cookies'}) { $OUTPUT{'show_cookies'} = 0; }
+        else                           { $OUTPUT{'show_cookies'} = 1; }
+    }
+    elsif ($key eq 'o') {
+        if   ($OUTPUT{'show_ok'}) { $OUTPUT{'show_ok'} = 0; }
+        else                      { $OUTPUT{'show_ok'} = 1; }
+    }
+    elsif ($key eq 'a') {
+        if   ($OUTPUT{'show_auth'}) { $OUTPUT{'show_auth'} = 0; }
+        else                        { $OUTPUT{'show_auth'} = 1; }
+    }
+    elsif (($key eq 'q') || (ord($key) eq 3)) {
+        safe_quit();
+    }
+    return;
 }
 
 ###############################################################################
 sub readkey {
-        if (!$NIKTO{'POSIX'}{'support'}) { return; }
-
-        my $key;
-        $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'noecho'});
-        $NIKTO{'POSIX'}{'term'}->setattr($NIKTO{'POSIX'}{'fd_stdin'}, TCSANOW);
-        eval {
-                local $SIG{ALRM} = sub { die; };
-                ualarm(1_000);
-                sysread(STDIN, $key, 1);
-                ualarm(0);
-                };
-        $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'oterm'});
-        $NIKTO{'POSIX'}{'term'}->setattr($NIKTO{'POSIX'}{'fd_stdin'}, TCSANOW);
-
-        return $key;
-        }
+    if (!$NIKTO{'POSIX'}{'support'}) { return; }
+
+    my $key;
+    $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'noecho'});
+    $NIKTO{'POSIX'}{'term'}->setattr($NIKTO{'POSIX'}{'fd_stdin'}, TCSANOW);
+    eval {
+        local $SIG{ALRM} = sub { die; };
+        ualarm(1_000);
+        sysread(STDIN, $key, 1);
+        ualarm(0);
+    };
+    $NIKTO{'POSIX'}{'term'}->setlflag($NIKTO{'POSIX'}{'oterm'});
+    $NIKTO{'POSIX'}{'term'}->setattr($NIKTO{'POSIX'}{'fd_stdin'}, TCSANOW);
+
+    return $key;
+}
 
 ###############################################################################
@@ -1235 +1241 @@
             $m->{ssl} = ($checkssl eq "HTTP") ? 0 : 1;
             proxy_check($m);
-            my ($res, $content) = nfetch($m, "/", $method, "", \%headers, { noerror => 1, noprefetch => 1, nopostfetch => 1 }, "Port Check");
+            my ($res, $content) =
+              nfetch($m, "/", $method, "", \%headers,
+                     { noerror => 1, noprefetch => 1, nopostfetch => 1 },
+                     "Port Check");
 
             if ($res) {
@@ -1399 +1408 @@
         }
 
-        if (!$run) { next; }
+        if (!$run) { next; }
 
         my $oldverbose = $OUTPUT{'verbose'};
@@ -1414 +1423 @@
             $OUTPUT{'debug'} = 1;
         }
-        unless ($type eq "prefetch" || $type eq "postfetch") { $NIKTO{'current_plugin'}=$plugin->{'full_name'}; }
+        unless ($type eq "prefetch" || $type eq "postfetch") {
+            $NIKTO{'current_plugin'} = $plugin->{'full_name'};
+        }
         &{ $plugin->{ $type . '_method' } }($mark, $plugin->{'parameters'}, $request, $result);
         $OUTPUT{'verbose'} = $oldverbose;
@@ -1584 +1595 @@
     # check main nikto versions
     foreach my $remotefile (keys %REMOTE) {
-        my @l = split(/\./, $LOCAL{$remotefile});
-        my @r = split(/\./, $REMOTE{$remotefile});
-        my $update=0;
-        if ($LOCAL{$remotefile} eq '') { $update=1; }
-        elsif ($r[0] > $l[0]) { $update=1; }
-        elsif ($r[1] > $l[1]) { $update=1; }
-        elsif ($r[2] > $l[2]) { $update=1; }
-
-        if ($update) {
-                if ($remotefile eq "nikto") {
-                                nprint "+ Nikto has been updated to $REMOTE{$remotefile}, local copy is $NIKTO{'version'}\n";
-                                nprint "+ No update has taken place. Please upgrade Nikto by visiting http://$server/\n";
-                                if ($remotemsg ne "") { nprint "+ $server message: $remotemsg\n"; }
-                                exit;
-                        }
-                push(@DBTOGET, $remotefile);
-                if ($remotefile !~ /^db_/) { $code_updates = 1; }
-                }
-        }
+        my @l = split(/\./, $LOCAL{$remotefile});
+        my @r = split(/\./, $REMOTE{$remotefile});
+        my $update = 0;
+        if ($LOCAL{$remotefile} eq '') { $update = 1; }
+        elsif ($r[0] > $l[0]) { $update = 1; }
+        elsif ($r[1] > $l[1]) { $update = 1; }
+        elsif ($r[2] > $l[2]) { $update = 1; }
+
+        if ($update) {
+            if ($remotefile eq "nikto") {
+                nprint
+                  "+ Nikto has been updated to $REMOTE{$remotefile}, local copy is $NIKTO{'version'}\n";
+                nprint
+                  "+ No update has taken place. Please upgrade Nikto by visiting http://$server/\n";
+                if ($remotemsg ne "") { nprint "+ $server message: $remotemsg\n"; }
+                exit;
+            }
+            push(@DBTOGET, $remotefile);
+            if ($remotefile !~ /^db_/) { $code_updates = 1; }
+        }
+    }
 
     # replace local files if updated
@@ -1640 +1653 @@
 
 ###############################################################################
-# read_data ( prompt, mode )
-# read STDIN data from the user
-# portions of this (POSIX code) were taken from the
-# Term::ReadPassword module by Tom Phoenix <rootbeer@redcat.com> (many thanks).
-# it has been modified to not require Term::ReadLine, but still requires
-# POSIX::Termios of it's a POSIX machine
+# portions of this sub were taken from the Term::ReadPassword module.
+# It has been modified to not require Term::ReadLine, but still requires
+# POSIX::Termios if it's a POSIX machine
 ###############################################################################
 sub read_data {
-    if ($NIKTOCONFIG{PROMPTS} =~ /no/i) { return; }
+    if ($NIKTOCONFIG{PROMPTS} eq 'no') { return; }
     my ($prompt, $mode, $POSIX) = @_;
-    my $input = "";
+    my $input;
 
     my %SPECIAL = ("\x03" => 'INT',    # Control-C, Interrupt
@@ -1658 +1668 @@
                    "\x0a" => 'ENT',    # LF, Enter
                    );
-
-    # if we're on a non-POSIX machine we can't not-echo the
-    # characters, so just use getc to avoid the dependency on
-    # POSIX::Termios. We would be best to get rid of this
-    # entirely and use another way...
 
     if ($NIKTO{'POSIX'}{'support'}) {
@@ -1904 +1909 @@
 
     if ((!defined $CLI{'nocache'}) && (!$flags_nocache)) {
-        my $key =  $mark->{'ip'}
-                   . $mark->{'hostname'}
-                   . $mark->{'port'}
-                   . $mark->{'ssl'}
-                   . $method
-                   . $uri
-                   . $postdata;
+        my $key =
+            $mark->{'ip'}
+          . $mark->{'hostname'}
+          . $mark->{'port'}
+          . $mark->{'ssl'}
+          . $method
+          . $uri
+          . $postdata;
 
         $CACHE{$key}{'method'}  = $method;
@@ -1956 +1962 @@
     if (($NIKTO{'totalrequests'} % 10) == 0) {
         check_input();
-        }
+    }
 
     if (defined $CLI{'root'}) {
@@ -1962 +1968 @@
     }
     else {
-        $request{'whisker'}->{'uri'} = $uri;
+        $request{'whisker'}->{'uri'} = $uri;
     }
     $request{'whisker'}->{'method'} = $method;
@@ -1973 +1979 @@
     # check for extra HTTP headers
     if (defined $headers) {
+
         # loop through the hash ref passed and add each header to request
         while (my ($key, $value) = each(%$headers)) {
@@ -2009 +2016 @@
 
         # Snarf what we can from the whisker hash and put in mark
-                if (!exists $result{'whisker'}->{'error'}) {            
-                        if (!exists $mark->{'banner'}) {
-                                $mark->{'banner'} = $result{'server'};
-                        }
-                        else {
-                                # Check banner hasn't changed
-                                if (exists $result{'server'} && $mark->{'banner'} ne $result{'server'} && !exists $mark->{'bannerchanged'}) {
-                                        nprint("+ Server banner has changed from $mark->{banner} to $result{server}, this may suggest a WAF is in place");
-                                        $mark->{'bannerchanged'} = 1;
-                                }
-                        }
-                        
-                        if (!exists $mark->{'ssl_cipher'} && $mark->{'ssl'}) {
-                                # Grab ssl details
-                                $mark->{'ssl_cipher'} = $result{'whisker'}->{'ssl_cipher'};
-                                $mark->{'ssl_cert_issuer'} = $result{'whisker'}->{'ssl_cert_issuer'};
-                                $mark->{'ssl_cert_subject'} = $result{'whisker'}->{'ssl_cert_subject'};
-                        }
-                }
+        if (!exists $result{'whisker'}->{'error'}) {
+            if (!exists $mark->{'banner'}) {
+                $mark->{'banner'} = $result{'server'};
+            }
+            else {
+
+                # Check banner hasn't changed
+                if (   exists $result{'server'}
+                    && $mark->{'banner'} ne $result{'server'}
+                    && !exists $mark->{'bannerchanged'}) {
+                    nprint(
+                        "+ Server banner has changed from $mark->{banner} to $result{server}, this may suggest a WAF is in place"
+                        );
+                    $mark->{'bannerchanged'} = 1;
+                }
+            }
+
+            if (!exists $mark->{'ssl_cipher'} && $mark->{'ssl'}) {
+
+                # Grab ssl details
+                $mark->{'ssl_cipher'}       = $result{'whisker'}->{'ssl_cipher'};
+                $mark->{'ssl_cert_issuer'}  = $result{'whisker'}->{'ssl_cert_issuer'};
+                $mark->{'ssl_cert_subject'} = $result{'whisker'}->{'ssl_cert_subject'};
+            }
+        }
     }
     nprint("- $result{'whisker'}{'code'} for $method:\t$uri", "v");
@@ -2118 +2131 @@
                 $db_extensions{$ext} = 1;
 
-                # Escape chars in the conditionals.  This must change if regexs are allowed in the db.
+              # Escape chars in the conditionals.  This must change if regexs are allowed in the db.
                 for (my $y = 5 ; $y <= 9 ; $y++) { $item[$y] = quotemeta($item[$y]); }
 

trunk/plugins/nikto_headers.plugin

@@ -28 +28 @@
          description => "Performs various checks against the headers returned from a HTTP request.",
          postfetch_method => \&nikto_headers_postfetch,
-         scan_method => \&nikto_headers,
-         copyright   => "2008 CIRT Inc."
+         scan_method      => \&nikto_headers,
+         copyright        => "2008 CIRT Inc."
          };
-   
+
     # some global variables
     use vars qw/%HFOUND/;
@@ -40 +40 @@
 sub nikto_headers_postfetch {
     my ($mark, $parameters, $request, $result) = @_;
-   
+
     if (exists $result->{'whisker'}->{'error'}) {
         return $request, $result;
@@ -59 +59 @@
     my ($mark, $result, $header, $message, $tid) = @_;
 
-    if (exists $result->{$header})
-    {
-        my $key = LW2::md5(  $mark->{'ip'}
-                           . $mark->{'hostname'}
-                           . $mark->{'port'}
-                           . $mark->{'ssl'}
-                           . $result->{'whisker'}->{'method'}
-                           . $header);
+    if (exists $result->{$header}) {
+        my $key =
+          LW2::md5(  $mark->{'ip'}
+                   . $mark->{'hostname'}
+                   . $mark->{'port'}
+                   . $mark->{'ssl'}
+                   . $result->{'whisker'}->{'method'}
+                   . $header);
 
         if (!exists $HFOUND{$key}) {
             my $value = $result->{$header};
             $HFOUND{$key} = $value;
-        
-            add_vulnerability($mark, $message . " " . $value, $tid, "0",
+
+            add_vulnerability($mark, $message . " " . $value,
+                              $tid, "0",
                               $result->{'whisker'}->{'method'},
                               $result->{'whisker'}->{'uri'});

trunk/plugins/nikto_httpoptions.plugin

@@ -72 +72 @@
         foreach my $m (split /,? /, $allow_methods) {
             my $method = eval_methods($m, "Allow", $dbarray, $mark);
-            if ($method ne "") { $davmethods{$method} = 1 };
+            if ($method ne "") { $davmethods{$method} = 1 }
         }
     }
@@ -80 +80 @@
         foreach my $m (split /,? /, $public_methods) {
             my $method = eval_methods($m, "Public", $dbarray, $mark);
-            if ($method ne "") { $davmethods{$method} = 1 };
+            if ($method ne "") { $davmethods{$method} = 1 }
         }
     }
-    
+
     if (scalar(keys(%davmethods)) > 0) {
         $message = "WebDAV enabled (";
@@ -92 +92 @@
         add_vulnerability($mark, "$message", "999977", "0");
     }
+
     # Check for other weirdness
     # IIS Debug
@@ -109 +110 @@
     %headers = ("Host"           => "",
                 "Content-Length" => "0",);
-    ($res, $content) = nfetch($mark, "/", "PROPFIND", "", \%headers, { noclean => 1 }, "httpoptions: PROPFIND");
+    ($res, $content) =
+      nfetch($mark, "/", "PROPFIND", "", \%headers, { noclean => 1 }, "httpoptions: PROPFIND");
     if ($res == 207) {
         if ($content =~ "<a:href>http://") {
@@ -124 +126 @@
     %headers = ("Host" => "Nikto",);
     foreach my $method (split(/ /, "TRACE TRACK")) {
+
         # Check for all flavours of HTTP
         foreach my $version (split(/ /, "1.0 1.1")) {
@@ -159 +162 @@
     # Now search database for the method.
     foreach my $item (@$dbarray) {
-        if ($method eq "PROPPATCH" || $method eq "SEARCH" ||
-            $method eq "PROPFIND" || $method eq "COPY" ||
-            $method eq "LOCK" || $method eq "UNLOCK") {
+        if (   $method eq "PROPPATCH"
+            || $method eq "SEARCH"
+            || $method eq "PROPFIND"
+            || $method eq "COPY"
+            || $method eq "LOCK"
+            || $method eq "UNLOCK") {
             return $method;
         }
@@ -167 +173 @@
         if ($item->{'method'} eq $method) {
             if ($item->{'nikto_id'} eq "0") {
+
                 # is webdav
                 return $method;
@@ -177 +184 @@
         }
     }
-       
+
     return "";
 }

trunk/plugins/nikto_report_nbe.plugin

@@ -41 +41 @@
 
     # Write header
-    print OUT "timestamps|network|host|port|nikto_id|prio|$NIKTO{'name'} v$NIKTO{'version'}/$NIKTO{'core_version'}\n";
+    print OUT
+      "timestamps|network|host|port|nikto_id|prio|$NIKTO{'name'} v$NIKTO{'version'}/$NIKTO{'core_version'}\n";
     return OUT;
 }
 
 sub nbe_item {
-        my ($handle, $mark, $item) = @_;
-        foreach my $uri (split(' ', $item->{'uri'})) {
-                my ( $line, $network );
-                if ( $item->{'mark'}->{'hostname'} && $item->{'mark'}->{'port'} && $item->{'nikto_id'} ) {
-                        if ($item->{'mark'}->{'hostname'} =~ /^(\d+\.\d+\.\d+)\.\d+$/) {
-                                $network = $1;
-                        }
-                        $line.="results|";
-                        $line.="$network|";
-                        $line.="$item->{'mark'}->{'hostname'}|";
-                        $line.="$item->{'mark'}->{'port'}|";
-                        $line.="$item->{'nikto_id'}|";
-                        $line.="Security Warning|";
-                        if ($item->{'osvdb'})  { $line.="OSVDB-$item->{'osvdb'}: " };
-                        if ($item->{'method'}) { $line.="$item->{'method'} " };
-                        if ($uri)            { $line.="${'uri'}: " };
-                        $line.=$item->{'message'};
-                        print $handle "$line\n";
-                } else {
-                        my $debug = "Data provided:\n$handle, $mark, $item";
-                        $debug.= "\nContents of \$mark:";
-                        foreach my $key ( sort keys %$mark ) {
-                                $debug .= "\n$key - $mark->{$key}";
-                        }
-                        $debug.= "\nContents of \$item:";
-                        foreach my $key ( sort keys %$item ) {
-                                $debug .= "\n$key - $item->{$key}";
-                        }
-                        $debug.= "\nContents of \$item->{mark}:";
-                        foreach my $key ( sort keys %{$item->{mark}} ) {
-                                $debug .= "\n$key - $item->{mark}->{$key}";
-                        }
-                        #die $debug;
-                        nprint("+ Invalid reporting line: $debug");
-                }
-        }
+    my ($handle, $mark, $item) = @_;
+    foreach my $uri (split(' ', $item->{'uri'})) {
+        my ($line, $network);
+        if ($item->{'mark'}->{'hostname'} && $item->{'mark'}->{'port'} && $item->{'nikto_id'}) {
+            if ($item->{'mark'}->{'hostname'} =~ /^(\d+\.\d+\.\d+)\.\d+$/) {
+                $network = $1;
+            }
+            $line .= "results|";
+            $line .= "$network|";
+            $line .= "$item->{'mark'}->{'hostname'}|";
+            $line .= "$item->{'mark'}->{'port'}|";
+            $line .= "$item->{'nikto_id'}|";
+            $line .= "Security Warning|";
+            if ($item->{'osvdb'})  { $line .= "OSVDB-$item->{'osvdb'}: " }
+            if ($item->{'method'}) { $line .= "$item->{'method'} " }
+            if ($uri)              { $line .= "${'uri'}: " }
+            $line .= $item->{'message'};
+            print $handle "$line\n";
+        }
+        else {
+            my $debug = "Data provided:\n$handle, $mark, $item";
+            $debug .= "\nContents of \$mark:";
+            foreach my $key (sort keys %$mark) {
+                $debug .= "\n$key - $mark->{$key}";
+            }
+            $debug .= "\nContents of \$item:";
+            foreach my $key (sort keys %$item) {
+                $debug .= "\n$key - $item->{$key}";
+            }
+            $debug .= "\nContents of \$item->{mark}:";
+            foreach my $key (sort keys %{ $item->{mark} }) {
+                $debug .= "\n$key - $item->{mark}->{$key}";
+            }
+
+            #die $debug;
+            nprint("+ Invalid reporting line: $debug");
+        }
+    }
 }
 

trunk/plugins/nikto_report_xml.plugin

@@ -188 +188 @@
     foreach my $c (split(//, $invar)) {
         my $n = ord($c);
-        if (($n > 127) || ($n < 32) || ($n == 38) || ($n == 60) || ($n == 62) | ($n == 34)) { $outvar .= sprintf '%#x', $n; }
+        if (($n > 127) || ($n < 32) || ($n == 38) || ($n == 60) || ($n == 62) | ($n == 34)) {
+            $outvar .= sprintf '%#x', $n;
+        }
         else { $outvar .= $c; }
-        }
+    }
     return $outvar;
 }

trunk/plugins/nikto_robots.plugin

@@ -40 +40 @@
     (my $RES, $CONTENT) = nfetch($mark, "/robots.txt", "GET", "", \%headers, "", "robots");
 
-    if (($RES eq 200) || ($RES eq $FoF{'okay'}{'response'}))
-    {
+    if (($RES eq 200) || ($RES eq $FoF{'okay'}{'response'})) {
         if (is_404("robots.txt", $CONTENT, $RES, $headers{'location'})) { return; }
 
@@ -49 +48 @@
         foreach my $line (@DOC) {
             $line = quotemeta($line);
-            if ($line =~ /allow/i)
-            {
+            if ($line =~ /allow/i) {
                 chomp($line);
                 $line =~ s/\#.*$//;

trunk/plugins/nikto_subdomain.plugin

@@ -32 +32 @@
 
     return $id;
-    }
+}
 
 sub nikto_subdomain {
@@ -48 +48 @@
                "v");
         return;
-        }
+    }
 
     # Check if the start of the domain is "www"
@@ -55 +55 @@
         # Remove the www.
         $host =~ s/^www\.//;
-        }
+    }
 
     my $nocache_enabled = 0;
@@ -72 +72 @@
             add_vulnerability($mark, "Subdomain $item->{'subdomain'} found", $item->{'nikto_id'},
                               0);
-            }    # End if
+        }    # End if
 
-        }    # End foreach
+    }    # End foreach
     if (!$nocache_enabled) { undef $CLI{'nocache'}; }
-    }    # End sub
+}    # End sub
 
 1;

trunk/plugins/nikto_tests.plugin

@@ -36 +36 @@
                  };
     return $id;
-    }
+}
 
 sub nikto_tests {
@@ -59 +59 @@
             # auth is now done in nfetch
             if ($res eq 200) {
-                nprint("+ $uri - 200/OK Response could be $TESTS{$checkid}{'message'}") if $OUTPUT{'show_ok'};
-                }
+                nprint("+ $uri - 200/OK Response could be $TESTS{$checkid}{'message'}")
+                  if $OUTPUT{'show_ok'};
+            }
             elsif ($res =~ /30(?:[0-3]|7)/) {
                 nprint(  "+ $uri - Redirects ($res) to "
@@ -66 +67 @@
                        . " , $TESTS{$checkid}{'message'}")
                   if $OUTPUT{'show_redirects'};
-                }
+            }
 
             my $m1_method = my $m1o_method = my $m1a_method = my $f2_method = my $f1_method =
@@ -83 +84 @@
                 if ($content =~ /$TESTS{$checkid}{'match_1'}/) {
                     $positive = 1;
-                    }
-                }
+                }
+            }
             else {
                 if (($res eq $TESTS{$checkid}{'match_1'}) || ($res eq $FoF{'okay'}{'response'})) {
                     $positive = 1;
-                    }
-                }
+                }
+            }
 
             # no match, check optional match
@@ -96 +97 @@
                     if ($content =~ /$TESTS{$checkid}{'match_1_or'}/) {
                         $positive = 1;
-                        }
-                    }
+                    }
+                }
                 else {
                     if (   ($res eq $TESTS{$checkid}{'match_1_or'})
                         || ($res eq $FoF{'okay'}{'response'})) {
                         $positive = 1;
-                        }
-                    }
-                }
+                    }
+                }
+            }
 
             # matched on something, check fails/ands
@@ -111 +112 @@
                     if ($f1_method eq "content") {
                         if ($content =~ /$TESTS{$checkid}{'fail_1'}/) { next; }
-                        }
+                    }
                     else {
                         if ($res eq $TESTS{$checkid}{'fail_1'}) { next; }
-                        }
-                    }
+                    }
+                }
                 if ($TESTS{$checkid}{'fail_2'} ne "") {
                     if ($f2_method eq "content") {
                         if ($content =~ /$TESTS{$checkid}{'fail_2'}/) { next; }
-                        }
+                    }
                     else {
                         if ($res eq $TESTS{$checkid}{'fail_2'}) { next; }
-                        }
-                    }
+                    }
+                }
                 if ($TESTS{$checkid}{'match_1_and'} ne "") {
                     if ($m1a_method eq "content") {
                         if ($content !~ /$TESTS{$checkid}{'match_1_and'}/) { next; }
-                        }
+                    }
                     else {
                         if ($res ne $TESTS{$checkid}{'match_1_and'}) { next; }
-                        }
-                    }
+                    }
+                }
 
                 # if it's an index.php, check for normal /index.php to see if it's a FP
@@ -137 +138 @@
                     my $content = rm_active_content($content, $uri);
                     if (LW2::md4($content) eq $FoF{'index.php'}{'match'}) { next; }
-                    }
+                }
 
                 # lastly check for a false positive based on file extension or type
                 if (($m1_method eq "code") || ($m1o_method eq "code")) {
                     if (is_404($uri, $content, $res, $headers{'location'})) { next; }
-                    }
+                }
 
                 $TESTS{$checkid}{'osvdb'} =~ s/\s+/ OSVDB\-/g;
@@ -149 +150 @@
                                   $TESTS{$checkid}{'osvdb'},
                                   $TESTS{$checkid}{'method'}, $uri);
-                }
-            }
+            }
+        }
 
         # Percentages
-        if ($OUTPUT{'progress'}) {
-                if ($parameters->{'report'}) {
-                    $progress++;
-                    if (($progress % $parameters->{'report'}) == 0) {
-                        my $line = sprintf("- Tests completed: %d %.0f%%",
-                                   $progress, ($progress / $NIKTO{total_checks}) * 100);
-                nprint($line);
-                }
-            }
-        }
-        }    # end check loop
+        if ($OUTPUT{'progress'}) {
+            if ($parameters->{'report'}) {
+                $progress++;
+                if (($progress % $parameters->{'report'}) == 0) {
+                    my $line = sprintf("- Tests completed: %d %.0f%%",
+                                       $progress, ($progress / $NIKTO{total_checks}) * 100);
+                    nprint($line);
+                }
+            }
+        }
+    }    # end check loop
 
     # Perform mutation tests
     if ($parameters->{'passfiles'}) {
         passchecks($mark);
-        }
+    }
     if ($parameters->{'all'}) {
         allchecks($mark);
-        }
+    }
 
     return;
-    }
+}
 
 sub passchecks {
@@ -203 +204 @@
                     # dir/file
                     testfile($mark, "$cgi$dir$file", "passfiles", "299998");
-                    }
-                }
-            }
-        }
-    }
+                }
+            }
+        }
+    }
+}
 
 sub allchecks {
@@ -231 +232 @@
                 $dir  =~ s/([^a-zA-Z0-9])/\\$1/g;
                 $file =~ s/$dir//;
-                }
+            }
             if (($file ne "") && ($file !~ /^\?/)) {
                 $FILES{$file} = "";
-                }
-            }
-        }
+            }
+        }
+    }
 
     # Now do a check for each item - just check the return status, nothing else
@@ -242 +243 @@
         foreach my $file (keys %FILES) {
             testfile($mark, "$dir$file", "all checks", 299999);
-            }
-        }
-    }
+        }
+    }
+}
 
 sub testfile {
@@ -254 +255 @@
         nprint("+ ERROR: $uri returned an error: $error", "e");
         return;
-        }
+    }
     if ($res == 200) {
         add_vulnerability($mark, "$uri: file found during $name mutation", "$tid", "0", "GET");
-        }
-    }
+    }
+}
 
 1;