metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

data/spec/dummy/app/models/dummy/module/path.rb

@@ -0,0 +1,64 @@
+# In-memory implementation of {Metasploit::Model::Module::Path} to allow testing of {Metasploit::Model::Module::Path} in
+# an ActiveModel and use of factories.
+class Dummy::Module::Path < Metasploit::Model::Base
+  include Metasploit::Model::Module::Path
+
+  #
+  # Attributes Methods - used to track changed attributes
+  #
+
+  define_attribute_method :gem
+  define_attribute_method :name
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] gem
+  #   The gem that owns this path.
+  #
+  #   @return [String, nil]
+  attr_accessor :gem
+
+  # @!attribute [rw] name
+  #   The name of this path, scoped to {#gem}.
+  #
+  #   @return [String, nil]
+  attr_accessor :name
+
+  # @!attribute [rw] real_path
+  #   Real (absolute) path on-disk.
+  #
+  #   @return [String]
+  attr_accessor :real_path
+
+  #
+  # Methods
+  #
+
+  # Updates {#gem} value and marks {#gem} as changed if `gem` differs from
+  # {#gem}.
+  #
+  # @param gem [String, nil] (see #gem)
+  # @return [String, nil] `gem`
+  def gem=(gem)
+    unless gem == @gem
+      gem_will_change!
+    end
+
+    @gem = gem
+  end
+
+  # Updates {#name} value and marks {#name} as changed if `name` differs
+  # from {#name}.
+  #
+  # @param name [String, nil] (see #name)
+  # @return [String, nil] `name`
+  def name=(name)
+    unless name == @name
+      name_will_change!
+    end
+
+    @name = name
+  end
+end

data/spec/dummy/app/models/dummy/module/platform.rb

@@ -0,0 +1,19 @@
+class Dummy::Module::Platform < Metasploit::Model::Base
+  include Metasploit::Model::Module::Platform
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] module_instance
+  #   Module that supports {#platform}.
+  #
+  #   @return [Dummy::Module::Instance]
+  attr_accessor :module_instance
+
+  # @!attribute [rw] platform
+  #  Platform supported by {#module_instance}.
+  #
+  #  @return [Dummy::Platform]
+  attr_accessor :platform
+end

data/spec/dummy/app/models/dummy/module/rank.rb

@@ -0,0 +1,44 @@
+# Implementation of {Metasploit::Model::Module::Rank} to allow testing of {Metasploit::Model::Module::Rank}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Rank < Metasploit::Model::Base
+  include Metasploit::Model::Module::Rank
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] name
+  #   The name of the rank.
+  #
+  #   @return [String]
+  attr_accessor :name
+
+  # @!attribute [rw] number
+  #   The numerical value of the rank.  Higher numbers are better.
+  #
+  #   @return [Integer]
+  attr_accessor :number
+
+  # Keep single instance for each pair in {Metasploit::Model::Module::Rank::NUMBER_BY_NAME} to emulate unique database
+  # seeds in-memory.
+  #
+  # @param name [String] {#name}
+  # @return [Dummy::Module::Rank]
+  def self.with_name(name)
+    unless instance_variable_defined? :@instance_by_name
+      @instance_by_name = {}
+
+      NUMBER_BY_NAME.each do |instance_name, number|
+        instance = new(:name => instance_name, :number => number)
+
+        unless instance.valid?
+          raise Metasploit::Model::Invalid.new(instance)
+        end
+
+        @instance_by_name[instance_name] = instance
+      end
+    end
+
+    @instance_by_name.fetch(name)
+  end
+end

data/spec/dummy/app/models/dummy/module/reference.rb

@@ -0,0 +1,19 @@
+class Dummy::Module::Reference < Metasploit::Model::Base
+  include Metasploit::Model::Module::Reference
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] module_instance
+  #   {Dummy::Module::Instance Module} with {#reference}.
+  #
+  #   @return [Dummy::Module::Instance]
+  attr_accessor :module_instance
+
+  # @!attribute [rw] reference
+  #   {Dummy::Reference reference} to exploit or proof-of-concept (PoC) code for {#module_instance}.
+  #
+  #   @return [Dummy::Reference]
+  attr_accessor :reference
+end

data/spec/dummy/app/models/dummy/module/target.rb

@@ -0,0 +1,62 @@
+# Implementation of {Metasploit::Model::Module::Target} to allow testing of {Metasploit::Model::Module::Target}
+# using an in-memory ActiveModel and use of factories.
+class Dummy::Module::Target < Metasploit::Model::Base
+  include Metasploit::Model::Module::Target
+
+  #
+  # Associations
+  #
+
+
+  # @!attribute [r] architectures
+  #   Architectures that this target supports, either by being declared specifically for this target or because
+  #   this target did not override architectures and so inheritted the architecture set from the class.
+  #
+  #   @return [Array<Metasploit::Model::Architecture>]
+  def architectures
+    target_architectures.map(&:architecture)
+  end
+
+  # @!attribute [rw] module_instance
+  #   Module where this target was declared.
+  #
+  #   @return [Dummy::Module::Instance]
+  attr_accessor :module_instance
+
+  # @!attribute [r] platforms
+  #   Platforms that this target supports, either by being declared specifically for this target or because this
+  #   target did not override platforms and so inheritted the platform set from the class.
+  #
+  #   @return [Array<Metasploit::Model::Platform>]
+  def platforms
+    target_platforms.map(&:platform)
+  end
+
+  # @!attribute [rw] target_architectures
+  #   Joins this target to its {#architectures}
+  #
+  #   @return [Array<Metasploit::Model::Module::Target::Architecture]
+  def target_architectures
+    @target_architectures ||= []
+  end
+  attr_writer :target_architectures
+
+  # @!attribute [rw] target_platforms
+  #   Joins this target to its {#platforms}
+  #
+  #   @return [Array<Metasploit::Model::Module::Target::Platform>]
+  def target_platforms
+    @target_platforms ||= []
+  end
+  attr_writer :target_platforms
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] name
+  #   The name of this target.
+  #
+  #   @return [String]
+  attr_accessor :name
+end

data/spec/dummy/app/models/dummy/module/target/architecture.rb

@@ -0,0 +1,19 @@
+class Dummy::Module::Target::Architecture < Metasploit::Model::Base
+  include Metasploit::Model::Module::Target::Architecture
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] architecture
+  #   The architecture supported by the {#module_target}.
+  #
+  #   @return [Dummy::Architecture]
+  attr_accessor :architecture
+
+  # @!attribute [rw] module_target
+  #   The module target that supports {#architecture}.
+  #
+  #   @return [Dummy::Module::Target]
+  attr_accessor :module_target
+end

data/spec/dummy/app/models/dummy/module/target/platform.rb

@@ -0,0 +1,19 @@
+class Dummy::Module::Target::Platform < Metasploit::Model::Base
+  include Metasploit::Model::Module::Target::Platform
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] module_target
+  #   The module target that supports {#platform}.
+  #
+  #   @return [Dummy::Module::Target]
+  attr_accessor :module_target
+
+  # @!attribute [rw] platform
+  #   The platform supported by the {#module_target}.
+  #
+  #   @return [Dummy::Platform]
+  attr_accessor :platform
+end

data/spec/dummy/app/models/dummy/platform.rb

@@ -0,0 +1,58 @@
+# Implementation of {Metasploit::Model::Platform} to allow testing of {Metasploit::Model::Platform} using an in-memory
+# ActiveModel and use of factories.
+class Dummy::Platform < Metasploit::Model::Base
+  include Metasploit::Model::Platform
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] fully_qualified_name
+  #   The fully qualified name of this platform, as would be used in the platform list in a metasploit-framework
+  #   module.
+  #
+  #   @return [String]
+  attr_accessor :fully_qualified_name
+
+  # @!attribute [rw] parent
+  #   The parent platform of this platform.  For example, Windows is parent of Windows 98, which is the parent of
+  #   Windows 98 FE.
+  #
+  #   @return [nil] if this is a top-level platform, such as Windows or Linux.
+  #   @return [Metasploit::Model::Platform]
+  attr_accessor :parent
+
+  # @!attribute [rw] relative_name
+  #   The name of this platform relative to the {#fully_qualified_name} of {#parent}.
+  #
+  #   @return [String]
+  attr_accessor :relative_name
+
+  #
+  # Methods
+  #
+
+  def self.all
+    # cache so that Dummy::Platform can be compared by identity
+    unless instance_variable_defined? :@all
+      @all = []
+
+      Metasploit::Model::Platform.each_seed_attributes do |attributes|
+        child = new(attributes)
+        # validate to populate {#fully_qualified_name}
+        child.valid!
+
+        @all << child
+
+        # yieldreturn
+        child
+      end
+
+      # freeze objects to prevent specs from modifying them and interfering with other specs.
+      @all.map(&:freeze)
+    end
+
+    @all
+  end
+end
+

data/spec/dummy/app/models/dummy/reference.rb

@@ -0,0 +1,31 @@
+# Implementation of {Metasploit::Model::Reference} to allow testing of {Metasploit::Model::Reference} using an in-memory
+# ActiveModel and use of factories.
+class Dummy::Reference < Metasploit::Model::Base
+  include Metasploit::Model::Reference
+
+  #
+  # Associations
+  #
+
+  # @!attribute [rw] authority
+  #   The {Metasploit::Model::Authority authority} that assigned {#designation}.
+  #
+  #   @return [Metasploit::Model::Authority, nil]
+  attr_accessor :authority
+
+  #
+  # Attributes
+  #
+
+  # @!attribute [rw] designation
+  #   A designation (usually a string of numbers and dashes) assigned by {#authority}.
+  #
+  #   @return [String, nil]
+  attr_accessor :designation
+
+  # @!attribute [rw] url
+  #   URL to web page with information about referenced exploit.
+  #
+  #   @return [String, nil]
+  attr_accessor :url
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application", :media => "all" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application

data/spec/dummy/config/application.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require(*Rails.groups)
+# require the engine being tested.  In a non-dummy app this would be handled by the engine's gem being in the Gemfile
+# for real app and Bundler.require requiring the gem.
+require 'metasploit/model'
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable escaping HTML in JSON.
+    config.active_support.escape_html_entities_in_json = true
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end
+

data/spec/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/spec/dummy/config/environments/development.rb

@@ -0,0 +1,27 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Do not compress assets
+  config.assets.compress = false
+
+  # Expands the lines which load the assets
+  config.assets.debug = true
+end