arachni 0.4.0.4 → 0.4.1

data/plugins/defaults/content_types.rb

@@ -1,54 +1,73 @@
 =begin
-                  Arachni
-  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    Copyright 2010-2012 Tasos Laskos <tasos.laskos@gmail.com>
 
-  This is free software; you can copy and distribute and modify
-  this program under the term of the GPL v2.0 License
-  (See LICENSE file for details)
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
 
-=end
+        http://www.apache.org/licenses/LICENSE-2.0
 
-module Arachni
-module Plugins
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+=end
 
 #
 # Logs content-types of all server responses.
 #
-# @author: Tasos "Zapotek" Laskos
-#                                      <tasos.laskos@gmail.com>
-#                                      <zapotek@segfault.gr>
-# @version: 0.1.3
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 #
-class ContentTypes < Arachni::Plugin::Base
+# @version 0.1.4
+#
+class Arachni::Plugins::ContentTypes < Arachni::Plugin::Base
+
+    is_distributable
 
     def prepare
         @results = {}
-        @exclude = Regexp.new( @options['exclude'] )
+        @exclude = Regexp.new( options['exclude'] )
 
-        @logged = Set.new
+        @logged = Arachni::BloomFilter.new
     end
 
     def run
-        @framework.http.add_on_complete {
-            |res|
-
-            next if @logged.include?( res.request.method.to_s.upcase + res.effective_url )
-            next if !(type = res.headers_hash['Content-type'] ) || type.empty?
+        framework.http.add_on_complete do |res|
+            next if skip?( res )
 
+            type = res.content_type
             type = type.join( ' - ' ) if type.is_a?( Array )
 
-            if( !@options['exclude'].empty? && !type.match( @exclude ) ) ||
-                @options['exclude'].empty?
-                @results[type] ||= []
-                @results[type] << {
-                    :url    => res.effective_url,
-                    :method => res.request.method.to_s.upcase,
-                    :params => res.request.params
-                }
+            @results[type] ||= []
+            @results[type] << {
+                url:    res.effective_url,
+                method: res.request.method.to_s.upcase,
+                params: res.request.params
+            }
 
-                @logged << res.request.method.to_s.upcase + res.effective_url
-            end
-        }
+            log( res )
+        end
+    end
+
+    def skip?( res )
+        logged?( res ) || res.content_type.to_s.empty? || !log?( res )
+    end
+
+    def log?( res )
+        options['exclude'].empty? || !res.content_type.to_s.match( @exclude )
+    end
+
+    def logged?( res )
+        @logged.include?( log_id( res ) )
+    end
+
+    def log( res )
+        @logged << log_id( res )
+    end
+
+    def log_id( res )
+        res.request.method.to_s.upcase + res.effective_url
     end
 
     def clean_up
@@ -56,41 +75,33 @@ class ContentTypes < Arachni::Plugin::Base
         register_results( @results )
     end
 
-    def self.distributable?
-        true
-    end
-
     def self.merge( results )
         merged = {}
-        results.each {
-            |result|
-            result.each {
-                |type, val|
+
+        results.each do |result|
+            result.each do |type, val|
                 merged[type] ||= []
                 merged[type] |= val
-            }
-        }
+            end
+        end
 
-        return merged
+        merged
     end
 
     def self.info
         {
-            :name           => 'Content-types',
-            :description    => %q{Logs content-types of server responses.
+            name:        'Content-types',
+            description: %q{Logs content-types of server responses.
                 It can help you categorize and identify publicly available file-types
                 which in turn can help you identify accidentally leaked files.},
-            :author         => 'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
-            :version        => '0.1.3',
-            :options        => [
-                Arachni::OptString.new( 'exclude', [ false,
-                    'Exclude content-types that match this regular expression.', 'text' ]
+            author:      'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
+            version:     '0.1.4',
+            options:     [
+                Options::String.new( 'exclude',
+                    [false, 'Exclude content-types that match this regular expression.', 'text']
                 )
             ]
         }
     end
 
 end
-
-end
-end

data/plugins/defaults/healthmap.rb

@@ -1,106 +1,89 @@
 =begin
-                  Arachni
-  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    Copyright 2010-2012 Tasos Laskos <tasos.laskos@gmail.com>
 
-  This is free software; you can copy and distribute and modify
-  this program under the term of the GPL v2.0 License
-  (See LICENSE file for details)
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
 
-=end
+        http://www.apache.org/licenses/LICENSE-2.0
 
-module Arachni
-module Plugins
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+=end
 
 #
 # Generates a simple list of safe/unsafe URLs.
 #
-# @author: Tasos "Zapotek" Laskos
-#                                      <tasos.laskos@gmail.com>
-#                                      <zapotek@segfault.gr>
-# @version: 0.1.1
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 #
-class HealthMap < Arachni::Plugin::Base
+class Arachni::Plugins::HealthMap < Arachni::Plugin::Base
 
-    include Arachni::Module::Utilities
+    is_distributable
 
     def prepare
         wait_while_framework_running
-        @audit_store = @framework.audit_store( true )
     end
 
     def run
-        sitemap  = @audit_store.sitemap.map{ |url| normalize( url ) }.uniq
-        sitemap |= issue_urls = @audit_store.issues.map { |issue| issue.url }.uniq
+        auditstore = framework.auditstore
+
+        sitemap  = auditstore.sitemap.map { |url| url.split( '?' ).first }.uniq
+        sitemap |= issue_urls = auditstore.issues.map { |issue| issue.url }.uniq
 
         return if sitemap.size == 0
 
-        issue = 0
+        issue_cnt = 0
         map = []
-        sitemap.each {
-            |url|
-
+        sitemap.each do |url|
             next if !url
 
             if issue_urls.include?( url )
-                map << { :unsafe => url }
-                issue += 1
+                map << { unsafe: url }
+                issue_cnt += 1
             else
-                map << { :safe  => url }
+                map << { safe: url }
             end
-        }
-
-        register_results( {
-            :map    => map,
-            :total  => map.size,
-            :safe   => map.size - issue,
-            :unsafe => issue,
-            :issue_percentage => ( ( Float( issue ) / map.size ) * 100 ).round
-        } )
-
-    end
-
-    def normalize( url )
-        query = URI( normalize_url( url ) ).query
-        return url if !query
-
-        url.gsub( '?' + query, '' )
-    end
-
-    def self.distributable?
-        true
+        end
+
+        register_results(
+            map:              map,
+            total:            map.size,
+            safe:             map.size - issue_cnt,
+            unsafe:           issue_cnt,
+            issue_percentage: ((issue_cnt.to_f / map.size.to_f) * 100).round
+        )
     end
 
     def self.merge( results )
         merged = {
-            :map    => [],
-            :total  => 0,
-            :safe   => 0,
-            :unsafe => 0,
-            :issue_percentage => 0
+            map:              [],
+            total:            0,
+            safe:             0,
+            unsafe:           0,
+            issue_percentage: 0
         }
 
-        results.each {
-            |healthmap|
+        results.each do |healthmap|
             merged[:map]    |= healthmap[:map]
             merged[:total]  += healthmap[:total]
             merged[:safe]   += healthmap[:safe]
             merged[:unsafe] += healthmap[:unsafe]
-        }
-        merged[:issue_percentage] = ( ( Float( merged[:unsafe] ) / merged[:total] ) * 100 ).round
-        return merged
+        end
+        merged[:issue_percentage] = ( ( merged[:unsafe].to_f / merged[:total].to_f ) * 100 ).round
+        merged
     end
 
 
     def self.info
         {
-            :name           => 'Health map',
-            :description    => %q{Generates a simple list of safe/unsafe URLs.},
-            :author         => 'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
-            :version        => '0.1.1',
+            name:        'Health map',
+            description: %q{Generates a simple list of safe/unsafe URLs.},
+            author:      'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
+            version:     '0.1.3'
         }
     end
 
 end
-
-end
-end

data/plugins/defaults/{metamodules → meta}/remedies/discovery.rb

@@ -1,40 +1,37 @@
 =begin
-                  Arachni
-  Copyright (c) 2010-2012 Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    Copyright 2010-2012 Tasos Laskos <tasos.laskos@gmail.com>
 
-  This is free software; you can copy and distribute and modify
-  this program under the term of the GPL v2.0 License
-  (See LICENSE file for details)
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
 
-=end
+        http://www.apache.org/licenses/LICENSE-2.0
 
-module Arachni
-module Plugins
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+=end
 
 #
 # Catches custom 404 or similar server behavior that can confuse discovery
 # modules.
 #
 # This is relatively easy to determine since valid responses to discovery modules
-# should vary wildly while custom 404 responses will have many comonalities
+# should vary wildly while custom 404 responses will have many commonalities
 # every time.
 #
 # This is a sort of baseline implementation/anomaly detection.
 #
-# @author: Tasos "Zapotek" Laskos
-#                                      <tasos.laskos@gmail.com>
-#                                      <zapotek@segfault.gr>
-# @version: 0.1.1
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 #
-class Discovery < Arachni::Plugin::Base
-
-    include Arachni::Module::Utilities
-
-    # look for issues containing the following tags
-    TAGS = [ [ 'file', 'discovery' ], [ 'directory', 'discovery' ] ]
+# @version 0.1.2
+#
+class Arachni::Plugins::Discovery < Arachni::Plugin::Base
 
     # valid responses to discovery modules should vary *wildly*
-    # especially considereing the types of directories and files that
+    # especially considering the types of directories and files that
     # these modules look for
     #
     # on the other hand custom 404 or such responses will have many things
@@ -55,10 +52,8 @@ class Discovery < Arachni::Plugin::Base
         # URL path => size of responses
         response_size_per_path  = {}
 
-        @framework.audit_store.issues.each_with_index {
-            |issue, idx|
-
-            next if !includes_tags?( issue.tags )
+        framework.auditstore.issues.each_with_index do |issue, idx|
+            next if !issue.tags.includes_tags?( :discovery )
 
             # discovery issues only have 1 variation
             variation = issue.variations.first
@@ -68,18 +63,11 @@ class Discovery < Arachni::Plugin::Base
             # will control the behavior under that path
             #
             # did that make any sense?
-            path = ''
-            begin
-                exception_jail {
-                    path = File.dirname( URI( normalize_url( variation['url'] ) ).path )
-                }
-            rescue
-                next
-            end
+            path = File.dirname( uri_parse( variation.url ).path )
 
             # gathering total response sizes for issues per path
             response_size_per_path[path] ||= 0
-            response_size_per_path[path] += variation['response'].size
+            response_size_per_path[path] += variation.response.size
 
             # categorize issues per path as well
             issues_per_path[path] ||= []
@@ -99,60 +87,37 @@ class Discovery < Arachni::Plugin::Base
             #
             # on the other hand, valid responses will be dissimilar since the
             # discovery modules look for different things.
-            if !diffs_per_path[path]
-                diffs_per_path[path] = variation['response']
+            diffs_per_path[path] = if !diffs_per_path[path]
+                 variation['response']
             else
-                diffs_per_path[path] = diffs_per_path[path].rdiff( variation['response'] )
+                diffs_per_path[path].rdiff( variation['response'] )
             end
-        }
+        end
 
         issues = []
-        diffs_per_path.each_pair {
-            |path, diff|
-
-            # calculate the similarity factor of the responses under the current path
+        diffs_per_path.each_pair do |path, diff|
+            # calculate the similarity ratio of the responses under the current path
             similarity = Float( diff.size * issues_per_path[path].size ) / response_size_per_path[path]
 
             # gotcha!
-            if similarity >= SIMILARITY_TOLERANCE
-                issues |= issues_per_path[path]
-            end
-        }
+            issues |= issues_per_path[path] if similarity >= SIMILARITY_TOLERANCE
+        end
 
         register_results( issues ) if !issues.empty?
     end
 
-    #
-    # Checks if 'tags' contain any item in {TAGS}
-    #
-    # @param    [Array]     tags
-    #
-    # @return   [Bool]
-    #
-    def includes_tags?( tags )
-        TAGS.each {
-            |tag_pair|
-            intersection = (tags & tag_pair)
-            return true if intersection && (intersection.size  == tag_pair.size)
-        }
-        return false
-    end
-
     def self.info
         {
-            :name           => 'Discovery module response anomalies',
-            :description    => %q{Analyzes the scan results and identifies issues logged by discovery modules
+            name:        'Discovery module response anomalies',
+            description: %q{Analyzes the scan results and identifies issues logged by discovery modules
                 (i.e. modules that look for certain files and folders on the server),
                 while the server responses were exhibiting an anomalous factor of similarity.
 
                 There's a good chance that these issues are false positives.},
-            :author         => 'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
-            :version        => '0.1.1',
-            :tags           => [ 'anomaly' , 'discovery', 'file', 'directories', 'meta']
+            author:      'Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>',
+            version:     '0.1.2',
+            tags:        %w(anomaly discovery file directories meta)
         }
     end
 
 end
-
-end
-end