metasploit-credential 1.0.0.pre.rails.pre.4.0c → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11d840c8a6573237be3beafd2d50864f6aafba26
-  data.tar.gz: db23977d91c96934ada85186052418deda1839ac
+  metadata.gz: 2d101098c3d7cc3ab27a13313cb0033a34349272
+  data.tar.gz: 357e125b89d9737aef2a6597a173a90e1bd149fc
 SHA512:
-  metadata.gz: 9bcf417c1898ba87001552ec9c44eb420f64d0deae78d6a36a0b9713f4f3cac49768f3d1adf2cbfd7e7e92f3fbab86d29226baf2b949a2b98d0c355f34b1ac0d
-  data.tar.gz: fbed05c95bcc659ce21eafc19b881319364f266c8235f560ad461dfb59412d91e547725c5c82620f434fc24c5945c7c4f4b55ecd1e607aed1035b37435b43db0
+  metadata.gz: 9dc70a5df26e28577fd90e7d01e4c739b27e4377e52b5f79ad73ea105b6768c2277ba46df76797b3eb234ef8a19c71b1aedf092e171d307d1564533c5dbda6b5
+  data.tar.gz: f454884167aee38773a88c79b73ad07190f60ac75e08d9fd43c3bf30c7d579f5f4fbc1a4d8468740ba0daa42eef43e1667dea4f662a9ecb265ba4a29e4b1ab67

data/CONTRIBUTING.md

@@ -25,9 +25,9 @@ issue tracking software.
 
 ### `PRERELEASE`
 
-1. Update `PRERELEASE` to match the `SUMMARY` in the branch name.  If you branched from `master`, and [version.rb](lib/metasploit/credential/version.rb) does not have `PRERELEASE` defined, then adding the following lines after `PATCH`: 
+1. Update `PRERELEASE` to match the `SUMMARY` in the branch name.  If you branched from `master`, and [version.rb](lib/metasploit/credential/version.rb) does not have `PRERELEASE` defined, then adding the following lines after `PATCH`:
 ```
-# The prerelease version, scoped to the {PATCH} version number.
+# The prerelease version, scoped to the {MAJOR}, {MINOR}, and {PATCH} version number.
 PRERELEASE = '<SUMMARY>'
 ```
 2. `rake spec`
@@ -36,21 +36,27 @@ PRERELEASE = '<SUMMARY>'
 
 ### Your changes
 
-Make your changes or however many commits you like, commiting each with `git commit`.
+Make your changes or however many commits you like, committing each with `git commit`.
 
 ### Pre-Pull Request Testing
 
+#### Specs
 1. Run specs one last time before opening the Pull Request: `rake spec`
 2. Verify there was no failures.
 
+#### Documentation
+1. Generate yard documentation to ensure all new code is documented: `rake yard`
+2. Verify there were no `[warn]`ings.
+3. Verify there were no undocumented objects.
+
 ### Push
 
-Push your branch to your fork on gitub: `git push push TYPE/ISSUE/SUMMARY`
+Push your branch to your fork on github: `git push TYPE/ISSUE/SUMMARY`
 
 ### Pull Request
 
 * [Create new Pull Request](https://github.com/rapid7/metasploit-credential/compare/)
-* Add a Verification Steps comment
+* Add a Verification Steps to the description comment
 
 ```
 # Verification Steps
@@ -60,7 +66,13 @@ Push your branch to your fork on gitub: `git push push TYPE/ISSUE/SUMMARY`
 ## `rake spec`
 - [ ] `rake spec`
 - [ ] VERIFY no failures
+
+## `rake yard`
+- [ ] `rake yard`
+- [ ] VERIFY no `[warn]`ings
+- [ ] VERIFY no undocumented objects
 ```
+
 You should also include at least one scenario to manually check the changes outside of specs.
 
 * Add a Post-merge Steps comment
@@ -105,7 +117,7 @@ Perform these steps prior to pushing to DESTINATION or the build will be broke o
 - [ ] Change `PRERELEASE` from `SOURCE_SUMMARY` to `DESTINATION_SUMMARY` to match the branch (DESTINATION) summary (DESTINATION_SUMMARY)
 
 ## Gem build
-- [ ] gem build *.gemspec
+- [ ] gem build metasploit-credential.gemspec
 - [ ] VERIFY the prerelease suffix has change on the gem.
 
 ## RSpec
@@ -117,38 +129,5 @@ Perform these steps prior to pushing to DESTINATION or the build will be broke o
 - [ ] `git push origin DESTINATION`
 ```
 
-* Add a 'Release Steps' comment
-
-The 'Release Steps' are a reminder to the reviewer of the Pull Request of how to release the gem.
-
-```
-# Release
-
-Complete these steps on DESTINATION
-
-## `VERSION`
-
-### Compatible changes
-
-If your change are compatible with the previous branch's API, then increment [`PATCH`](lib/metasploit/credential/version.rb).
-
-### Incompatible changes
-
-If your changes are incompatible with the previous branch's API, then increment [`MINOR`](lib/metasploit/credential/version.rb) and reset [`PATCH`](lib/metasploit/credential/version.rb) to `0`.
-
-- [ ] Following the rules for [semantic versioning 2.0](http://semver.org/spec/v2.0.0.html), update [`MINOR`](lib/metasploit/credential/version.rb) and [`PATCH`](lib/metasploit/credential/version.rb) and commit the changes.
-
-## MRI Ruby
-- [ ] `rvm use ruby-2.1@metasploit_data_models`
-- [ ] `rm Gemfile.lock`
-- [ ] `bundle install`
-- [ ] `rake release`
-```
-
-### Downstream dependencies
-
-When releasing new versions, the following projects may need to be updated:
-
-* [metasploit-framework](https://github.com/rapid7/metasploit-framework)
-* [metasploit-pro-ui](https://github.com/rapid7/pro/tree/master/ui)
-* [metasploit-pro-engine](https://github.com/rapid7/pro/tree/master/engine)
+To update the [CHANGELOG.md](CHANGELOG.md) with the merged changes or release the merged code see
+[RELEASING.md](RELEASING.md)

data/app/models/metasploit/credential/core.rb

@@ -12,7 +12,7 @@ class Metasploit::Credential::Core < ActiveRecord::Base
   #
 
   # @!attribute tasks
-  #   The {Mdm::Task tasks} using this to track what tasks interacted with a given core.
+  #   The `Mdm::Task`s using this to track what tasks interacted with a given core.
   #
   #   @return [ActiveRecord::Relation<Mdm::Task>]
   has_and_belongs_to_many :tasks,

data/app/models/metasploit/credential/login.rb

@@ -9,7 +9,7 @@ class Metasploit::Credential::Login < ActiveRecord::Base
   #
   
   # @!attribute tasks
-  #   The {Mdm::Task tasks} using this to track what tasks interacted with a given core.
+  #   The `Mdm::Task`s using this to track what tasks interacted with a given core.
   #
   #   @return [ActiveRecord::Relation<Mdm::Task>]
   has_and_belongs_to_many :tasks,

data/app/models/metasploit/credential/postgres_md5.rb

@@ -2,7 +2,11 @@
 # to authenticate to PostgreSQL servers. It is composed of a hexadecimal string of 32 charachters prepended by the string
 # 'md5'
 class Metasploit::Credential::PostgresMD5 < Metasploit::Credential::ReplayableHash
+  #
+  # CONSTANTS
+  #
 
+  # Valid format for {Metasploit::Credential::Private#data}
   DATA_REGEXP = /md5([a-f0-9]{32})/
 
   #

data/app/models/metasploit/credential/search/operator/type.rb

@@ -1,6 +1,6 @@
 # Operator that searches a polymorphic `#type` attribute.  Search terms are restricted to set of `Class#name`s and
 # `Class#model_name.human` with the `Class#model_name.human` being translated to `Class#name` in the operation returned
-# by {#operate_on}.
+# by `#operate_on`.
 class Metasploit::Credential::Search::Operator::Type < Metasploit::Model::Search::Operator::Attribute
   #
   # Attributes
@@ -40,7 +40,7 @@ class Metasploit::Credential::Search::Operator::Type < Metasploit::Model::Search
     @class_names ||= []
   end
 
-  # Maps `Class.model_name.human` to `Class.name` for all {#classes}.
+  # Maps `Class.model_name.human` to `Class.name` for {#class_set}.
   #
   # @return [Hash{String => String}] Maps `Class.model_name.name`s to `Class.name`s so `Class.model_names.name` can be
   #   converted to `Class.name` for the in database search.

data/lib/metasploit/credential/creation.rb

@@ -1,6 +1,6 @@
 # Implements a set of "convenience methods" for creating credentials and related portions of the object graph.  Creates
 # {Metasploit::Credential::Core} objects and their attendant relationships as well as {Metasploit::Credential::Login}
-# objects and their attendant {Mdm::Host} and {Mdm::Service} objects.
+# objects and their attendant `Mdm::Host` and `Mdm::Service` objects.
 module Metasploit::Credential::Creation
 
   # Returns true if ActiveRecord has an active database connection, false otherwise.

data/lib/metasploit/credential/exporter/core.rb

@@ -3,7 +3,7 @@
 # and `Mdm::Server` information is exported as well. Exported data can be optionally scoped to include only
 # a certain whitelist of database IDs.
 #
-# The {#export!} method creates a zip file on disk containing a CSV with the data.  If the {#workspace} contains
+# The {#export!} method creates a zip file on disk containing a CSV with the data.  If the `workspace` contains
 # {Metasploit::Credential::SSHKey} objects on the exported {Metasploit::Credential::Core} objects, the keys are
 # exported to files inside a subdirectory of the zip file.
 # @example Exporting all Cores
@@ -41,7 +41,7 @@ class Metasploit::Credential::Exporter::Core
   # The downcased and Symbolized name of the default object type to export
   DEFAULT_MODE  = LOGIN_MODE
 
-  # An argument to {Dir::mktmpdir}
+  # An argument to `Dir::mktmpdir`
   TEMP_ZIP_PATH_PREFIX = "metasploit-exports"
 
 
@@ -49,10 +49,10 @@ class Metasploit::Credential::Exporter::Core
   # Attributes
   #
 
-  # @!attribute export_data
+  # @!attribute [rw] export_data
   #   Holds the raw information from the database before it is formatted into the {#data} attribute
   #   @return [Array]
-  attr_accessor :export_data
+  attr_writer :export_data
 
   # @!attribute finalized_zip_file
   #   The final output artifacts, zipped
@@ -109,7 +109,7 @@ class Metasploit::Credential::Exporter::Core
   end
 
   # Returns a platform-agnostic filesystem path where the key data will be saved as a file
-  # @param line [Hash] the result of {#line_for_login} or #{line_for_core}
+  # @param line [Hash] the result of {#line_for_login} or {#line_for_core}
   # @return [String]
   def path_for_key(datum)
     core = datum.is_a?(Metasploit::Credential::Core) ? datum : datum.core

data/lib/metasploit/credential/exporter/pwdump.rb

@@ -70,10 +70,10 @@ class Metasploit::Credential::Exporter::Pwdump
   # Attributes
   #
 
-  # @!attribute logins
+  # @!attribute [rw] logins
   #   Holds the raw information from the database before it is formatted into the {#data} attribute
   #   @return [Array<Metasploit::Credential::Login>]
-  attr_accessor :logins
+  attr_writer :logins
 
 
   #

data/lib/metasploit/credential/importer/pwdump.rb

@@ -1,8 +1,8 @@
 # Implements importation behavior for pwdump files exported by Metasploit as well as files from the John the Ripper
 # hash cracking suite: http://www.openwall.com/john/
 #
-# Please note that in the case of data exported from Metasploit, the dataset will contain information on the {Mdm::Host}
-# and {Mdm::Service} objects that are related to the credential.  This means that Metasploit exports will be limited to
+# Please note that in the case of data exported from Metasploit, the dataset will contain information on the `Mdm::Host`
+# and `Mdm::Service` objects that are related to the credential.  This means that Metasploit exports will be limited to
 # containing {Metasploit::Credential::Login} objects, which is the legacy behavior of this export prior to the creation
 # of this library.
 class Metasploit::Credential::Importer::Pwdump
@@ -25,9 +25,10 @@ class Metasploit::Credential::Importer::Pwdump
   # Matches lines that contain usernames and plaintext passwords
   PLAINTEXT_REGEX                   = /^[\s]*([\x21-\x7f]+)[\s]+([\x21-\x7f]+)?/n
 
+  # Matches lines taht contain MD5 hashes for PostgreSQL
   POSTGRES_REGEX                    = /^[\s]*([\x21-\x7f]+):md5([0-9a-f]{32})$/
 
-  # Matches a line that we use to get information for creating {Mdm::Host} and {Mdm::Service} objects
+  # Matches a line that we use to get information for creating `Mdm::Host` and `Mdm::Service` objects
   # TODO: change to use named groups from 1.9+
   SERVICE_COMMENT_REGEX             = /^#[\s]*([0-9.]+):([0-9]+)(\x2f(tcp|udp))?[\s]*(\x28([^\x29]*)\x29)?/n
 
@@ -70,7 +71,7 @@ class Metasploit::Credential::Importer::Pwdump
     end
   end
 
-  # Perform the import of the credential data, creating {Mdm::Host} and {Mdm::Service} objects as needed,
+  # Perform the import of the credential data, creating `Mdm::Host` and `Mdm::Service` objects as needed,
   # parsing out data by matching against regex constants that match the various kinds of valid lines found
   # in the file.  Ignore lines which match none of the REGEX constants.
   # @return [void]
@@ -159,7 +160,7 @@ class Metasploit::Credential::Importer::Pwdump
   end
 
   # Take an msfpwdump comment string and parse it into information necessary for
-  # creating {Mdm::Host} and {Mdm::Service} objects.
+  # creating `Mdm::Host` and `Mdm::Service` objects.
   # @param comment_string [String] a string starting with a '#' that conforms to {SERVICE_COMMENT_REGEX}
   # @return [Hash]
   def service_info_from_comment_string(comment_string)

data/lib/metasploit/credential/migrator.rb

@@ -104,7 +104,7 @@ class Metasploit::Credential::Migrator
   # @return [String]
   def key_data_from_file(path)
     # Sometimes we will set the :pass attribute to a file path containing the key
-    if File.exists?(path)
+    if File.exist?(path)
       File.read(path)
     # In other cases we store the entire SSH key directly in the :pass attribute
     elsif Metasploit::Credential::SSHKey.new(data: path).private?

data/lib/metasploit/credential/version.rb

@@ -4,20 +4,30 @@ module Metasploit
   module Credential
     # Holds components of {VERSION} as defined by {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0}.
     module Version
+      #
+      # CONSTANTS
+      #
+
       # The major version number.
       MAJOR = 1
       # The minor version number, scoped to the {MAJOR} version number.
       MINOR = 0
-      # The patch number, scoped to the {MINOR} version number.
+      # The patch version number, scoped to the {MAJOR} and {MINOR} version numbers.
       PATCH = 0
-      # the prerelease identifier
-      PRERELEASE = 'rails-4.0c'
 
-      # The full version string, including the {MAJOR}, {MINOR}, {PATCH}, and optionally, the {PRERELEASE} in the
+      #
+      # Module Methods
+      #
+
+      # The full version string, including the {Metasploit::Credential::Version::MAJOR},
+      # {Metasploit::Credential::Version::MINOR}, {Metasploit::Credential::Version::PATCH}, and optionally, the
+      # `Metasploit::Credential::Version::PRERELEASE` in the
       # {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0} format.
       #
-      # @return [String] '{MAJOR}.{MINOR}.{PATCH}' on master.  '{MAJOR}.{MINOR}.{PATCH}-{PRERELEASE}' on any branch
-      #   other than master.
+      # @return [String] '{Metasploit::Credential::Version::MAJOR}.{Metasploit::Credential::Version::MINOR}.{Metasploit::Credential::Version::PATCH}'
+      #   on master.
+      #   '{Metasploit::Credential::Version::MAJOR}.{Metasploit::Credential::Version::MINOR}.{Metasploit::Credential::Version::PATCH}-PRERELEASE'
+      #   on any branch other than master.
       def self.full
         version = "#{MAJOR}.#{MINOR}.#{PATCH}"
 
@@ -27,9 +37,24 @@ module Metasploit
 
         version
       end
+
+      # The full gem version string, including the {Metasploit::Credential::Version::MAJOR},
+      # {Metasploit::Credential::Version::MINOR}, {Metasploit::Credential::Version::PATCH}, and optionally, the
+      # `Metasploit::Credential::Version::PRERELEASE` in the
+      # {http://guides.rubygems.org/specification-reference/#version RubyGems versioning} format.
+      #
+      # @return [String] '{Metasploit::Credential::Version::MAJOR}.{Metasploit::Credential::Version::MINOR}.{Metasploit::Credential::Version::PATCH}'
+      #   on master.  '{Metasploit::Credential::Version::MAJOR}.{Metasploit::Credential::Version::MINOR}.{Metasploit::Credential::Version::PATCH}.PRERELEASE'
+      #   on any branch other than master.
+      def self.gem
+        full.gsub('-', '.pre.')
+      end
     end
 
-    # @see Version.full
+    # (see Version.gem)
+    GEM_VERSION = Version.gem
+
+    # (see Version.full)
     VERSION = Version.full
   end
 end

data/spec/lib/metasploit/credential/creation_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Metasploit::Credential::Creation do
+RSpec.describe Metasploit::Credential::Creation do
   include_context 'Mdm::Workspace'
   let(:dummy_class) {
     Class.new do
@@ -42,7 +40,7 @@ describe Metasploit::Credential::Creation do
 
     it 'replicates realm in new credential' do
       expect {
-        core = test_object.create_cracked_credential(
+        test_object.create_cracked_credential(
           core_id: old_core.id,
           workspace_id: workspace.id,
           username: public.username,
@@ -160,7 +158,7 @@ describe Metasploit::Credential::Creation do
 
     it 'should create an Mdm::Service in state "open"' do
       service = test_object.create_credential_service opts
-      service.state.should == "open"
+      expect(service.state).to eq("open")
     end
   end
 
@@ -483,7 +481,7 @@ describe Metasploit::Credential::Creation do
           task_id: task.id
       }
       core = test_object.create_credential(opts)
-      core.tasks.should include(task)
+      expect(core.tasks).to include(task)
     end
 
   end
@@ -526,7 +524,7 @@ describe Metasploit::Credential::Creation do
           task_id: task.id
       }
       core = test_object.create_credential_core(opts)
-      core.tasks.should include(task)
+      expect(core.tasks).to include(task)
     end
 
   end
@@ -563,7 +561,7 @@ describe Metasploit::Credential::Creation do
         status: Metasploit::Model::Login::Status::SUCCESSFUL,
       }
       login = test_object.create_credential_login(login_data)
-      login.tasks.should include(task)
+      expect(login.tasks).to include(task)
 
     end
 

data/spec/lib/metasploit/credential/exporter/core_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Metasploit::Credential::Exporter::Core do
+RSpec.describe Metasploit::Credential::Exporter::Core do
   include_context 'Mdm::Workspace'
   include_context 'export objects'
 
@@ -24,19 +22,19 @@ describe Metasploit::Credential::Exporter::Core do
     end
 
     it 'should be in LOGIN_MODE by default' do
-      core_exporter.mode.should == Metasploit::Credential::Exporter::Core::LOGIN_MODE
+      expect(core_exporter.mode).to eq(Metasploit::Credential::Exporter::Core::LOGIN_MODE)
     end
   end
 
   describe "#export!" do
     it 'should create the zipfile' do
       core_exporter.export!
-      File.exists?(core_exporter.output_zipfile_path).should be_true
+      expect(File.exists?(core_exporter.output_zipfile_path)).to eq(true)
     end
 
     it 'should output to a directory whose name contains the standardized identifier' do
       core_exporter.export!
-      core_exporter.output_final_directory_path.should include(Metasploit::Credential::Exporter::Core::CREDS_DUMP_FILE_IDENTIFIER)
+      expect(core_exporter.output_final_directory_path).to include(Metasploit::Credential::Exporter::Core::CREDS_DUMP_FILE_IDENTIFIER)
     end
   end
 
@@ -46,14 +44,14 @@ describe Metasploit::Credential::Exporter::Core do
     describe "when the argument is a Core" do
       it 'should be formed from the Public#username and the Private#id' do
         key_path = core_exporter.path_for_key(core)
-        Pathname.new(key_path).basename.to_s.should == key_path_basename_string
+        expect(Pathname.new(key_path).basename.to_s).to eq(key_path_basename_string)
       end
     end
 
     describe "when the argument is a Login" do
       it 'should be formed from the Public#username and the Private#id' do
         key_path = core_exporter.path_for_key(login)
-        Pathname.new(key_path).basename.to_s.should == key_path_basename_string
+        expect(Pathname.new(key_path).basename.to_s).to eq(key_path_basename_string)
       end
     end
   end
@@ -62,20 +60,27 @@ describe Metasploit::Credential::Exporter::Core do
     let(:result_hash) { core_exporter.line_for_core(core) }
 
     it 'should produce values in the proper order' do
-      result_hash.values.should == [core.public.username, core.private.type,
-                                    core.private.data, core.realm.key, core.realm.value]
+      expect(result_hash.values).to eq(
+                                        [
+                                            core.public.username,
+                                            core.private.type,
+                                            core.private.data,
+                                            core.realm.key,
+                                            core.realm.value
+                                        ]
+                                    )
     end
 
     it 'should produce a hash with the public username' do
-      result_hash[:username].should == core.public.username
+      expect(result_hash[:username]).to eq(core.public.username)
     end
 
     it 'should produce a hash with the private data' do
-      result_hash[:private_data].should == core.private.data
+      expect(result_hash[:private_data]).to eq(core.private.data)
     end
 
     it 'should produce a hash with the name of the private type' do
-      result_hash[:private_type].should == core.private.type
+      expect(result_hash[:private_type]).to eq(core.private.type)
     end
   end
 
@@ -84,84 +89,94 @@ describe Metasploit::Credential::Exporter::Core do
     let(:result_hash) { core_exporter.line_for_login(login) }
 
     it 'should produce values in the proper order' do
-      result_hash.values.should == [core.public.username, core.private.type,
-                                    core.private.data, core.realm.key, core.realm.value,
-                                    login.service.host.address.to_s, login.service.port,
-                                    login.service.name, login.service.proto,
-                                    login.status, login.access_level, login.last_attempted_at
-      ]
+      expect(result_hash.values).to eq(
+                                        [
+                                            core.public.username,
+                                            core.private.type,
+                                            core.private.data,
+                                            core.realm.key,
+                                            core.realm.value,
+                                            login.service.host.address,
+                                            login.service.port,
+                                            login.service.name,
+                                            login.service.proto,
+                                            login.status,
+                                            login.access_level,
+                                            login.last_attempted_at
+                                        ]
+                                    )
     end
 
     it 'should produce a hash with the service host address' do
-      result_hash[:host_address].should == login.service.host.address.to_s
+      expect(result_hash[:host_address]).to eq(login.service.host.address.to_s)
     end
 
     it 'should produce a hash with the service port' do
-      result_hash[:service_port].should == login.service.port
+      expect(result_hash[:service_port]).to eq(login.service.port)
     end
 
     it 'should produce a hash with the service name' do
-      result_hash[:service_name].should == login.service.name
+      expect(result_hash[:service_name]).to eq(login.service.name)
     end
 
     it 'should produce a hash with the service protocol' do
-      result_hash[:service_protocol].should == login.service.proto
+      expect(result_hash[:service_protocol]).to eq(login.service.proto)
     end
 
     it 'should produce a hash with the login status' do
-      result_hash[:status].should == login.status
+      expect(result_hash[:status]).to eq(login.status)
     end
 
     it 'should produce a hash with the login access_level' do
-      result_hash[:access_level].should == login.access_level
+      expect(result_hash[:access_level]).to eq(login.access_level)
     end
 
     it 'should produce a hash with the login last_attempted_at' do
-      result_hash[:last_attempted_at].should == login.last_attempted_at
+      expect(result_hash[:last_attempted_at]).to eq(login.last_attempted_at)
     end
 
     it 'should produce a hash with the public information' do
-      result_hash[:username].should == login.core.public.username
+      expect(result_hash[:username]).to eq(login.core.public.username)
     end
 
     it 'should produce a hash with the private data' do
-      result_hash[:private_data].should == login.core.private.data
+      expect(result_hash[:private_data]).to eq(login.core.private.data)
     end
 
     it 'should produce a hash with the demodulized name of the private type' do
-      result_hash[:private_type].should == login.core.private.type
+      expect(result_hash[:private_type]).to eq(login.core.private.type)
     end
   end
 
   describe "#output" do
     it 'should be a writable File' do
       file_stat = core_exporter.output.stat
-      file_stat.should be_writable
+      expect(file_stat).to be_writable
     end
 
     it 'should not be opened in binmode' do
-      core_exporter.output.should_not be_binmode
+      expect(core_exporter.output).not_to be_binmode
     end
   end
 
   describe "#output_directory_path" do
     it 'should be in the platform-agnostic temp directory' do
-      core_exporter.output_final_directory_path.should include(Dir.tmpdir)
+      expect(core_exporter.output_final_directory_path).to include(Dir.tmpdir)
     end
 
     it 'should have the set export prefix' do
-      core_exporter.output_final_directory_path.should include(Metasploit::Credential::Exporter::Core::TEMP_ZIP_PATH_PREFIX)
+      expect(core_exporter.output_final_directory_path).to include(Metasploit::Credential::Exporter::Core::TEMP_ZIP_PATH_PREFIX)
     end
 
     describe "uniqueness for export" do
       let(:path_fragment){ "export-#{Time.now.to_s}" }
 
       before(:each) do
-        core_exporter.stub(:output_final_subdirectory_name).and_return(path_fragment)
+        allow(core_exporter).to receive(:output_final_subdirectory_name).and_return(path_fragment)
       end
 
       it 'should include a special time-stamped directory to contain the export data being staged' do
-        core_exporter.output_final_directory_path.should include(core_exporter.output_final_subdirectory_name)
+        expect(core_exporter.output_final_directory_path).to include(core_exporter.output_final_subdirectory_name)
       end
     end
   end
@@ -169,44 +184,44 @@ describe Metasploit::Credential::Exporter::Core do
   describe "#data" do
     describe "in LOGIN_MODE" do
       before(:each) do
-        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
       end
 
       describe "when whitelist_ids is present" do
         before(:each) do
-          core_exporter.stub(:whitelist_ids).and_return([login1.id])
+          allow(core_exporter).to receive(:whitelist_ids).and_return([login1.id])
         end
 
         it 'should contain only those objects whose IDs are in the whitelist' do
-          core_exporter.data.should_not include(login2)
+          expect(core_exporter.data).not_to include(login2)
         end
       end
 
       describe "when whitelist_ids is blank" do
         it 'should be the same as #export_data' do
-          core_exporter.data.should == core_exporter.export_data
+          expect(core_exporter.data).to eq(core_exporter.export_data)
         end
       end
     end
 
     describe "in CORE_MODE" do
       before(:each) do
-        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
       end
 
       describe "when whitelist_ids is present" do
         before(:each) do
-          core_exporter.stub(:whitelist_ids).and_return([core1.id])
+          allow(core_exporter).to receive(:whitelist_ids).and_return([core1.id])
         end
 
         it 'should contain only those objects whose IDs are in the whitelist' do
-          core_exporter.data.should_not include(core2)
+          expect(core_exporter.data).not_to include(core2)
         end
       end
 
       describe "when whitelist_ids is blank" do
         it 'should be the same as #export_data' do
-          core_exporter.data.should == core_exporter.export_data
+          expect(core_exporter.data).to eq(core_exporter.export_data)
         end
       end
     end
@@ -215,22 +230,22 @@ describe Metasploit::Credential::Exporter::Core do
   describe "#export_data" do
     describe "in CORE_MODE" do
       before(:each) do
-        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
       end
 
       it 'should grab data using the proper scope' do
-        Metasploit::Credential::Core.should_receive(:workspace_id).with(core_exporter.workspace.id)
+        expect(Metasploit::Credential::Core).to receive(:workspace_id).with(core_exporter.workspace.id)
         core_exporter.export_data
       end
     end
 
     describe "in LOGIN_MODE" do
       before(:each) do
-        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
       end
 
       it 'should grab data using the proper scope' do
-        Metasploit::Credential::Login.should_receive(:in_workspace_including_hosts_and_services).with(core_exporter.workspace)
+        expect(Metasploit::Credential::Login).to receive(:in_workspace_including_hosts_and_services).with(core_exporter.workspace)
         core_exporter.export_data
       end
     end
@@ -240,7 +255,7 @@ describe Metasploit::Credential::Exporter::Core do
     describe "#render_manifest_and_output_keys" do
       describe "in CORE_MODE" do
         before(:each) do
-          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
           core_exporter.render_manifest_output_and_keys
           path = core_exporter.output_final_directory_path + '/' + Metasploit::Credential::Importer::Zip::MANIFEST_FILE_NAME
 
@@ -260,34 +275,34 @@ describe Metasploit::Credential::Exporter::Core do
         end
 
         it 'should contain the Public#username for all Core objects' do
-          @core_publics.should include(core1.public.username)
-          @core_publics.should include(core2.public.username)
+          expect(@core_publics).to include(core1.public.username)
+          expect(@core_publics).to include(core2.public.username)
         end
 
         it 'should contain the Private#type for all Core objects' do
-          @core_private_types.should include(core1.private.type)
-          @core_private_types.should include(core2.private.type)
+          expect(@core_private_types).to include(core1.private.type)
+          expect(@core_private_types).to include(core2.private.type)
         end
 
         it 'should contain the Private#data for all Core objects' do
-          @core_private_data.should include(core1.private.data)
-          @core_private_data.should include(core2.private.data)
+          expect(@core_private_data).to include(core1.private.data)
+          expect(@core_private_data).to include(core2.private.data)
         end
 
         it 'should contain the Realm#key for all Core objects' do
-          @core_realm_keys.should include(core1.realm.key)
-          @core_realm_keys.should include(core2.realm.key)
+          expect(@core_realm_keys).to include(core1.realm.key)
+          expect(@core_realm_keys).to include(core2.realm.key)
         end
 
         it 'should contain the Realm#value for all Core objects' do
-          @core_realm_values.should include(core1.realm.value)
-          @core_realm_values.should include(core2.realm.value)
+          expect(@core_realm_values).to include(core1.realm.value)
+          expect(@core_realm_values).to include(core2.realm.value)
         end
       end
 
       describe "in LOGIN_MODE" do
         before(:each) do
-          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
           core_exporter.render_manifest_output_and_keys
           path = core_exporter.output_final_directory_path + '/' + Metasploit::Credential::Importer::Zip::MANIFEST_FILE_NAME
 
@@ -316,47 +331,47 @@ describe Metasploit::Credential::Exporter::Core do
 
 
         it 'should contain the Public#username for all Login objects' do
-          @login_publics.should include(login1.core.public.username)
-          @login_publics.should include(login2.core.public.username)
+          expect(@login_publics).to include(login1.core.public.username)
+          expect(@login_publics).to include(login2.core.public.username)
         end
 
         it 'should contain the Private#type for all Login objects' do
-          @login_private_types.should include(login1.core.private.type)
-          @login_private_types.should include(login2.core.private.type)
+          expect(@login_private_types).to include(login1.core.private.type)
+          expect(@login_private_types).to include(login2.core.private.type)
         end
 
         it 'should contain the Private#data for all Login objects' do
-          @login_private_data.should include(login1.core.private.data)
-          @login_private_data.should include(login2.core.private.data)
+          expect(@login_private_data).to include(login1.core.private.data)
+          expect(@login_private_data).to include(login2.core.private.data)
         end
 
         it 'should contain the Realm#key for all Login objects' do
-          @login_realm_keys.should include(login1.core.realm.key)
-          @login_realm_keys.should include(login2.core.realm.key)
+          expect(@login_realm_keys).to include(login1.core.realm.key)
+          expect(@login_realm_keys).to include(login2.core.realm.key)
         end
 
         it 'should contain the Realm#value for all Login objects' do
-          @login_realm_values.should include(login1.core.realm.value)
-          @login_realm_values.should include(login2.core.realm.value)
+          expect(@login_realm_values).to include(login1.core.realm.value)
+          expect(@login_realm_values).to include(login2.core.realm.value)
         end
 
         it 'should contain the associated Mdm::Host#address for all Login objects' do
-          @login_host_addresses.should include(login1.service.host.address.to_s, login2.service.host.address.to_s)
+          expect(@login_host_addresses).to include(login1.service.host.address.to_s, login2.service.host.address.to_s)
         end
 
         it 'should contain the associated Mdm::Service#port (stringified) for all Login objects' do
-          @login_service_ports.should include(login1.service.port.to_s)
-          @login_service_ports.should include(login2.service.port.to_s)
+          expect(@login_service_ports).to include(login1.service.port.to_s)
+          expect(@login_service_ports).to include(login2.service.port.to_s)
         end
 
         it 'should contain the associated Mdm::Service#name for all Login objects' do
-          @login_service_names.should include(login1.service.name)
-          @login_service_names.should include(login2.service.name)
+          expect(@login_service_names).to include(login1.service.name)
+          expect(@login_service_names).to include(login2.service.name)
         end
 
         it 'should contain the associated Mdm::Service#proto for all Login objects' do
-          @login_service_protocols.should include(login1.service.proto)
-          @login_service_protocols.should include(login2.service.proto)
+          expect(@login_service_protocols).to include(login1.service.proto)
+          expect(@login_service_protocols).to include(login2.service.proto)
         end
       end
     end
@@ -364,7 +379,7 @@ describe Metasploit::Credential::Exporter::Core do
     describe "#render_zip" do
       describe "when there are no SSH keys in the dataset" do
         before(:each) do
-          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
           core_exporter.render_manifest_output_and_keys
           core_exporter.render_zip
         end
@@ -374,7 +389,7 @@ describe Metasploit::Credential::Exporter::Core do
           Zip::File.open(core_exporter.output_zipfile_path) do |zip_file|
             manifest_entry = zip_file.glob(Metasploit::Credential::Importer::Zip::MANIFEST_FILE_NAME).first
           end
-          manifest_entry.should_not be_blank
+          expect(manifest_entry).not_to be_blank
         end
 
         it 'should not contain a keys directory' do
@@ -382,7 +397,7 @@ describe Metasploit::Credential::Exporter::Core do
           Zip::File.open(core_exporter.output_zipfile_path) do |zip_file|
             keys_entry = zip_file.glob(Metasploit::Credential::Importer::Zip::KEYS_SUBDIRECTORY_NAME).first
           end
-          keys_entry.should be_blank
+          expect(keys_entry).to be_blank
         end
       end
 
@@ -395,7 +410,7 @@ describe Metasploit::Credential::Exporter::Core do
                                                  workspace: workspace)}
 
         before(:each) do
-          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
           core_exporter.render_manifest_output_and_keys
           core_exporter.render_zip
         end
@@ -405,7 +420,7 @@ describe Metasploit::Credential::Exporter::Core do
           Zip::File.open(core_exporter.output_zipfile_path) do |zip_file|
             manifest_entry = zip_file.glob(Metasploit::Credential::Importer::Zip::MANIFEST_FILE_NAME).first
           end
-          manifest_entry.should_not be_blank
+          expect(manifest_entry).not_to be_blank
         end
 
         it 'should contain a keys directory' do
@@ -413,7 +428,7 @@ describe Metasploit::Credential::Exporter::Core do
           Zip::File.open(core_exporter.output_zipfile_path) do |zip_file|
             keys_entry = zip_file.glob(Metasploit::Credential::Importer::Zip::KEYS_SUBDIRECTORY_NAME).first
           end
-          keys_entry.should_not be_blank
+          expect(keys_entry).not_to be_blank
         end
 
         describe "the keys directory" do
@@ -425,12 +440,12 @@ describe Metasploit::Credential::Exporter::Core do
           end
 
           it 'should contain a key for each SSH private in the export' do
-            @key_entries.size.should == core_exporter.data[:core].select{ |d| d.private.type == Metasploit::Credential::SSHKey.name }.size
+            expect(@key_entries.size).to eq(core_exporter.data[:core].select{ |d| d.private.type == Metasploit::Credential::SSHKey.name }.size)
           end
 
           it 'should contain key files named with Public#username and Private#id for each Core that uses an SSHKey' do
             key_names = @key_entries.map{ |e| e.to_s.gsub("#{Metasploit::Credential::Importer::Zip::KEYS_SUBDIRECTORY_NAME}/", '') }
-            key_names.should include("#{core_with_key.public.username}-#{core_with_key.private.id}")
+            expect(key_names).to include("#{core_with_key.public.username}-#{core_with_key.private.id}")
           end
 
         end