cms_scanner 0.0.2

data/lib/cms_scanner/browser/actions.rb

@@ -0,0 +1,48 @@
+module CMSScanner
+  class Browser
+    # Browser Actions (get, post etc)
+    module Actions
+      # @param [ String ] url
+      # @param [ Hash ] params
+      #
+      # @return [ Typhoeus::Response ]
+      def get(url, params = {})
+        process(url, params.merge(method: :get))
+      end
+
+      # @param [ String ] url
+      # @param [ Hash ] params
+      #
+      # @return [ Typhoeus::Response ]
+      def post(url, params = {})
+        process(url, params.merge(method: :post))
+      end
+
+      # @param [ String ] url
+      # @param [ Hash ] params
+      #
+      # @return [ Typhoeus::Response ]
+      def head(url, params = {})
+        process(url, params.merge(method: :head))
+      end
+
+      # @param [ String ] url
+      # @param [ Hash ] params
+      #
+      # @return [ Typhoeus::Response ]
+      def get_and_follow_location(url, params = {})
+        get(url, params.merge(followlocation: true))
+      end
+
+      protected
+
+      # @param [ String ] url
+      # @param [ Hash ] params
+      #
+      # @return [ Typhoeus::Response ]
+      def process(url, params)
+        Typhoeus::Request.new(url, NS::Browser.instance.request_params(params)).run
+      end
+    end
+  end
+end

data/lib/cms_scanner/browser/options.rb

@@ -0,0 +1,53 @@
+module Typhoeus
+  # Hack to have a setter for the :max_concurrency
+  # Which will be officially added in the next version
+  # See: https://github.com/typhoeus/typhoeus/issues/366
+  class Hydra
+    attr_accessor :max_concurrency
+  end
+end
+
+module CMSScanner
+  # Options available in the Browser
+  class Browser
+    OPTIONS = [
+      :cache_ttl,
+      :cookie_jar,
+      :cookie_string,
+      :connect_timeout,
+      :http_auth,
+      :max_threads,
+      :proxy,
+      :proxy_auth,
+      :request_timeout,
+      :user_agent
+    ]
+
+    attr_accessor(*OPTIONS)
+
+    # @param [ Hash ] options
+    def load_options(options = {})
+      OPTIONS.each do |sym|
+        send("#{sym}=", options[sym]) if options.key?(sym)
+      end
+    end
+
+    def hydra
+      @hydra ||= Typhoeus::Hydra.new(max_concurrency: max_threads || 1)
+    end
+
+    # Set the threads attribute and update
+    # the max_concurrency of Typhoeus::Hydra
+    #
+    # @param [ Integer ] number
+    def max_threads=(number)
+      @max_threads = number.to_i > 0 ? number.to_i : 1
+      hydra.max_concurrency = @max_threads
+    end
+
+    # Default user agent
+    def user_agent
+      @user_agent ||= "CMSScanner v#{VERSION}"
+    end
+  end
+end

data/lib/cms_scanner/cache/file_store.rb

@@ -0,0 +1,75 @@
+module CMSScanner
+  module Cache
+    # Cache Implementation using files
+    class FileStore
+      attr_reader :storage_path, :serializer
+
+      # The serializer must have the 2 methods #load and #dump
+      #   (Marshal and YAML have them)
+      # YAML is Human Readable, contrary to Marshal which store in a binary format
+      # Marshal does not need any "require"
+      #
+      # @param [ String ] storage_path
+      # @param [ ] serializer
+      def initialize(storage_path, serializer = Marshal)
+        @storage_path = File.expand_path(storage_path)
+        @serializer   = serializer
+
+        FileUtils.mkdir_p(@storage_path) unless Dir.exist?(@storage_path)
+      end
+
+      # TODO: rename this to clear ?
+      def clean
+        Dir[File.join(storage_path, '*')].each do |f|
+          File.delete(f) unless File.symlink?(f)
+        end
+      end
+
+      # @param [ String ] key
+      #
+      # @return [ Mixed ]
+      def read_entry(key)
+        file_path = entry_path(key)
+
+        return if expired_entry?(key)
+
+        serializer.load(File.read(file_path))
+      rescue
+        nil
+      end
+
+      # @param [ String ] key
+      # @param [ Mixed ] data_to_store
+      # @param [ Integer ] cache_ttl
+      def write_entry(key, data_to_store, cache_ttl)
+        return unless cache_ttl.to_i > 0
+
+        File.write(entry_path(key), serializer.dump(data_to_store))
+        File.write(entry_expiration_path(key), Time.now.to_i + cache_ttl)
+      end
+
+      # @param [ String ] key
+      #
+      # @return [ String ] The file path associated to the key
+      def entry_path(key)
+        File.join(storage_path, key)
+      end
+
+      # @param [ String ] key
+      #
+      # @return [ String ] The expiration file path associated to the key
+      def entry_expiration_path(key)
+        entry_path(key) + '.expiration'
+      end
+
+      private
+
+      # @param [ String ] key
+      #
+      # @return [ Boolean ]
+      def expired_entry?(key)
+        File.read(entry_expiration_path(key)).to_i <= Time.now.to_i rescue true
+      end
+    end
+  end
+end

data/lib/cms_scanner/cache/typhoeus.rb

@@ -0,0 +1,21 @@
+require 'cms_scanner/cache/file_store'
+
+module CMSScanner
+  module Cache
+    # Cache implementation for Typhoeus
+    class Typhoeus < FileStore
+      # @param [ Typhoeus::Request ] request
+      #
+      # @return [ Typhoeus::Response ]
+      def get(request)
+        read_entry(request.hash.to_s)
+      end
+
+      # @param [ Typhoeus::Request ] request
+      # @param [ Typhoeus::Response ] response
+      def set(request, response)
+        write_entry(request.hash.to_s, response, request.cache_ttl)
+      end
+    end
+  end
+end

data/lib/cms_scanner/controller.rb

@@ -0,0 +1,90 @@
+module CMSScanner
+  module Controller
+    # Base Controller
+    class Base
+      include OptParseValidator
+
+      # @return [ Array<OptParseValidator::OptBase> ]
+      def cli_options; end
+
+      def before_scan; end
+
+      def run; end
+
+      def after_scan; end
+
+      def ==(other)
+        self.class == other.class
+      end
+
+      # @return [ Target ]
+      def target
+        @@target ||= NS::Target.new(parsed_options[:url])
+      end
+
+      # Set the parsed options and initialize the browser
+      # with them
+      #
+      # @param [ Hash ] options
+      def self.parsed_options=(options)
+        @@parsed_options = options
+
+        NS::Browser.instance(options)
+      end
+
+      # @return [ Hash ]
+      def parsed_options
+        @@parsed_options ||= {}
+      end
+
+      # @return [ Hash ]
+      def datastore
+        @@datastore ||= {}
+      end
+
+      # @return [ Formatter::Base ]
+      def formatter
+        @@formatter ||= NS::Formatter.load(parsed_options[:format], datastore[:views])
+      end
+
+      # @see Formatter#output
+      #
+      # @return [ Void ]
+      def output(tpl, vars = {})
+        formatter.output(*tpl_params(tpl, vars))
+      end
+
+      # @see Formatter#render
+      #
+      # @return [ String ]
+      def render(tpl, vars = {})
+        formatter.render(*tpl_params(tpl, vars))
+      end
+
+      protected
+
+      # @param [ String ] tpl
+      # @param [ Hash ] vars
+      #
+      # @return [ Array<String> ]
+      def tpl_params(tpl, vars)
+        [
+          tpl,
+          instance_variable_values.merge(vars),
+          self.class.name.demodulize.underscore
+        ]
+      end
+
+      # @return [ Hash ] All the instance variable keys (and their values) and the verbose value
+      def instance_variable_values
+        h = { verbose: parsed_options[:verbose] }
+        instance_variables.each do |a|
+          s    = a.to_s
+          n    = s[1..s.size]
+          h[n.to_sym] = instance_variable_get(a)
+        end
+        h
+      end
+    end
+  end
+end

data/lib/cms_scanner/controllers.rb

@@ -0,0 +1,34 @@
+module CMSScanner
+  # Controllers Container
+  class Controllers < Array
+    attr_reader :option_parser
+
+    def initialize(option_parser = OptParseValidator::OptParser.new)
+      @option_parser = option_parser
+    end
+
+    # @param [ Controller::Base ] controller
+    #
+    # @retun [ Controllers ] self
+    def <<(controller)
+      options = controller.cli_options
+
+      unless include?(controller)
+        option_parser.add(*options) if options
+        super(controller)
+      end
+      self
+    end
+
+    def run
+      parsed_options             = option_parser.results
+      first.class.parsed_options = parsed_options
+
+      redirect_output_to_file(parsed_options[:output]) if parsed_options[:output]
+
+      each(&:before_scan)
+      each(&:run)
+      reverse.each(&:after_scan)
+    end
+  end
+end

data/lib/cms_scanner/errors/auth_errors.rb

@@ -0,0 +1,15 @@
+module CMSScanner
+  # HTTP Authentication Required Error
+  class HTTPAuthRequiredError < StandardError
+    def message
+      'HTTP authentication required (or was invalid), please provide it with --http-auth'
+    end
+  end
+
+  # Proxy Authentication Required Error
+  class ProxyAuthRequiredError < StandardError
+    def message
+      'Proxy authentication required (or was invalid), please provide it with --proxy-auth'
+    end
+  end
+end

data/lib/cms_scanner/finders.rb

@@ -0,0 +1,5 @@
+require 'cms_scanner/finders/finder'
+require 'cms_scanner/finders/finding'
+require 'cms_scanner/finders/findings'
+require 'cms_scanner/finders/independent_finders'
+require 'cms_scanner/finders/independent_finder'

data/lib/cms_scanner/finders/finder.rb

@@ -0,0 +1,27 @@
+module CMSScanner
+  module Finders
+    # Finder
+    class Finder
+      # Constants for common found_by
+      DIRECT_FILE_ACCESS = 'Direct File Access (aggressive detection)'
+
+      attr_accessor :target
+
+      def initialize(target)
+        @target = target
+      end
+
+      # @param [ Hash ] _opts
+      def passive(_opts = {})
+      end
+
+      # @param [ Hash ] _opts
+      def aggressive(_opts = {})
+      end
+
+      def found_by
+        "#{self.class.to_s.demodulize} (#{caller_locations(1, 1)[0].label} detection)"
+      end
+    end
+  end
+end

data/lib/cms_scanner/finders/finding.rb

@@ -0,0 +1,32 @@
+module CMSScanner
+  module Finders
+    # Finding
+    module Finding
+      FINDING_OPTS = [:confidence, :confirmed_by, :references, :found_by, :interesting_entries]
+
+      attr_accessor(*FINDING_OPTS)
+
+      # @return [ Array ]
+      def references
+        @references ||= []
+      end
+
+      # @return [ Array ]
+      def confirmed_by
+        @confirmed_by ||= []
+      end
+
+      # Should be overriden in child classes
+      # @return [ Array ]
+      def interesting_entries
+        @interesting_entries ||= []
+      end
+
+      # @param [ Hash ] opts
+      # TODO: Maybe use instance_variable_set ?
+      def parse_finding_options(opts = {})
+        FINDING_OPTS.each { |opt| send("#{opt}=", opts[opt]) if opts.key?(opt) }
+      end
+    end
+  end
+end

data/lib/cms_scanner/finders/findings.rb

@@ -0,0 +1,25 @@
+module CMSScanner
+  module Finders
+    # Findings container
+    class Findings < Array
+      # Override to include the confirmed_by logic
+      def <<(other)
+        each do |found|
+          next unless found == other
+
+          found.confirmed_by << other
+          # TODO: Increase confidence (e.g: (found + other) / 1.5 ?)
+          return self
+        end
+
+        super(other)
+      end
+
+      # Append the elements of other into self AND returns self
+      # This is not the default behaviour of Array#+ but it's intended
+      def +(other)
+        other.each { |f| self << f }
+      end
+    end
+  end
+end

data/lib/cms_scanner/finders/independent_finder.rb

@@ -0,0 +1,30 @@
+module CMSScanner
+  module Finders
+    # Independent Finder
+    module IndependentFinder
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Hack to have the #find as a class method
+      module ClassMethods
+        def find(target, opts = {})
+          new(target).find(opts)
+        end
+      end
+
+      # @param [ Hash ] opts
+      # @option opts [ Symbol ] mode (:mixed, :passive, :aggressive)
+      #
+      # @return [ Findings ]
+      def find(opts = {})
+        finders.run(opts)
+      end
+
+      # @return [ Array ]
+      def finders
+        @finders ||= NS::Finders::IndependentFinders.new
+      end
+    end
+  end
+end