metasploit-credential 0.14.7 → 0.14.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa144979c299b0a5f2106efdcf0a27ce27a6238c
-  data.tar.gz: 798207915ad34014125264ed3852ae34d38bbcc3
+  metadata.gz: 895352ea1fdface54872f23f7ef803a5733cd3c2
+  data.tar.gz: ff8bb3e6f773ec263c99459fe8618db96fa66855
 SHA512:
-  metadata.gz: 9fc16422c984eb40a14b9eec56297590b8c4a5309acdca87ddb240f6151f68c45606988a3ddfe8488fc074f28a69ed06627493712f6f8241d79fc57e044ba529
-  data.tar.gz: b84875b6fb285621d6171e3cc7b9cdb502e10d79d497305651e1e3f43d0e2bccc349892fe8db23847310452b3ed027c10565c100fb0762042350d04fece97a4d
+  metadata.gz: f13f43bae66ba9283939559732ffef33303215e06146ee78ccb0ba14fb1c8d7b1cc3f9be1fe424ba519ef499cab9d666ac877cb30ff17b19d1183b13d54962a7
+  data.tar.gz: fa0396f86e9f469da28eb4875c57f70719d1b0aa177cde5bc06b69848b53438b80414ed10b4522ead6c732a1b2ea53778f11769259b8a703e158851b7e162bf5

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 {MAJOR}, {MINOR}, and {PATCH} version number.
+# The prerelease version, scoped to the {PATCH} version number.
 PRERELEASE = '<SUMMARY>'
 ```
 2. `rake spec`
@@ -36,7 +36,7 @@ PRERELEASE = '<SUMMARY>'
 
 ### Your changes
 
-Make your changes or however many commits you like, committing each with `git commit`.
+Make your changes or however many commits you like, commiting each with `git commit`.
 
 ### Pre-Pull Request Testing
 
@@ -45,12 +45,12 @@ Make your changes or however many commits you like, committing each with `git co
 
 ### Push
 
-Push your branch to your fork on github: `git push TYPE/ISSUE/SUMMARY`
+Push your branch to your fork on gitub: `git push push TYPE/ISSUE/SUMMARY`
 
 ### Pull Request
 
 * [Create new Pull Request](https://github.com/rapid7/metasploit-credential/compare/)
-* Add a Verification Steps to the description comment
+* Add a Verification Steps comment
 
 ```
 # Verification Steps
@@ -61,7 +61,6 @@ Push your branch to your fork on github: `git push TYPE/ISSUE/SUMMARY`
 - [ ] `rake spec`
 - [ ] VERIFY no failures
 ```
-
 You should also include at least one scenario to manually check the changes outside of specs.
 
 * Add a Post-merge Steps comment
@@ -106,7 +105,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 metasploit-credential.gemspec
+- [ ] gem build *.gemspec
 - [ ] VERIFY the prerelease suffix has change on the gem.
 
 ## RSpec
@@ -118,5 +117,38 @@ Perform these steps prior to pushing to DESTINATION or the build will be broke o
 - [ ] `git push origin DESTINATION`
 ```
 
-To update the [CHANGELOG.md](CHANGELOG.md) with the merged changes or release the merged code see
-[RELEASING.md](RELEASING.md)
+* 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)

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

@@ -49,10 +49,10 @@ class Metasploit::Credential::Exporter::Core
   # Attributes
   #
 
-  # @!attribute [rw] export_data
+  # @!attribute export_data
   #   Holds the raw information from the database before it is formatted into the {#data} attribute
   #   @return [Array]
-  attr_writer :export_data
+  attr_accessor :export_data
 
   # @!attribute finalized_zip_file
   #   The final output artifacts, zipped

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

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

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.exist?(path)
+    if File.exists?(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,26 +4,20 @@ 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 = 0
       # The minor version number, scoped to the {MAJOR} version number.
       MINOR = 14
-      # The patch version number, scoped to the {MAJOR} and {MINOR} version numbers.
-      PATCH = 7
+      # The patch number, scoped to the {MAJOR} and {MINOR} version number.
+      PATCH = 8
+      # The prerelease version, scoped to the {MAJOR}, {MINOR}, and {PATCH} version number.
+      # PRERELEASE =
 
-      # 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
+      # The full version string, including the {MAJOR}, {MINOR}, {PATCH}, and optionally, the {PRERELEASE} in the
       # {http://semver.org/spec/v2.0.0.html semantic versioning v2.0.0} 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.
+      # @return [String] '{MAJOR}.{MINOR}.{PATCH}' on master.  '{MAJOR}.{MINOR}.{PATCH}-{PRERELEASE}' on any branch
+      #   other than master.
       def self.full
         version = "#{MAJOR}.#{MINOR}.#{PATCH}"
 
@@ -34,23 +28,20 @@ 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
+      # The full gem version string, including the {MAJOR}, {MINOR}, {PATCH}, and optionally, the {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.
+      # @return [String] '{MAJOR}.{MINOR}.{PATCH}' on master.  '{MAJOR}.{MINOR}.{PATCH}.{PRERELEASE}' on any branch
+      #   other than master.
       def self.gem
         full.gsub('-', '.pre.')
       end
     end
 
-    # (see Version.gem)
+    # @see Version.gem
     GEM_VERSION = Version.gem
 
-    # (see Version.full)
+    # @see Version.full
     VERSION = Version.full
   end
 end

data/spec/dummy/db/structure.sql

@@ -3,7 +3,6 @@
 --
 
 SET statement_timeout = 0;
-SET lock_timeout = 0;
 SET client_encoding = 'UTF8';
 SET standard_conforming_strings = on;
 SET check_function_bodies = false;

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

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

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

@@ -1,4 +1,6 @@
-RSpec.describe Metasploit::Credential::Exporter::Core do
+require 'spec_helper'
+
+describe Metasploit::Credential::Exporter::Core do
   include_context 'Mdm::Workspace'
   include_context 'export objects'
 
@@ -22,19 +24,19 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
     end
 
     it 'should be in LOGIN_MODE by default' do
-      expect(core_exporter.mode).to eq(Metasploit::Credential::Exporter::Core::LOGIN_MODE)
+      core_exporter.mode.should == Metasploit::Credential::Exporter::Core::LOGIN_MODE
     end
   end
 
   describe "#export!" do
     it 'should create the zipfile' do
       core_exporter.export!
-      expect(File.exists?(core_exporter.output_zipfile_path)).to eq(true)
+      File.exists?(core_exporter.output_zipfile_path).should be_true
     end
 
     it 'should output to a directory whose name contains the standardized identifier' do
       core_exporter.export!
-      expect(core_exporter.output_final_directory_path).to include(Metasploit::Credential::Exporter::Core::CREDS_DUMP_FILE_IDENTIFIER)
+      core_exporter.output_final_directory_path.should include(Metasploit::Credential::Exporter::Core::CREDS_DUMP_FILE_IDENTIFIER)
     end
   end
 
@@ -44,14 +46,14 @@ RSpec.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)
-        expect(Pathname.new(key_path).basename.to_s).to eq(key_path_basename_string)
+        Pathname.new(key_path).basename.to_s.should == 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)
-        expect(Pathname.new(key_path).basename.to_s).to eq(key_path_basename_string)
+        Pathname.new(key_path).basename.to_s.should == key_path_basename_string
       end
     end
   end
@@ -60,27 +62,20 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
     let(:result_hash) { core_exporter.line_for_core(core) }
 
     it 'should produce values in the proper order' do
-      expect(result_hash.values).to eq(
-                                        [
-                                            core.public.username,
-                                            core.private.type,
-                                            core.private.data,
-                                            core.realm.key,
-                                            core.realm.value
-                                        ]
-                                    )
+      result_hash.values.should == [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
-      expect(result_hash[:username]).to eq(core.public.username)
+      result_hash[:username].should == core.public.username
     end
 
     it 'should produce a hash with the private data' do
-      expect(result_hash[:private_data]).to eq(core.private.data)
+      result_hash[:private_data].should == core.private.data
     end
 
     it 'should produce a hash with the name of the private type' do
-      expect(result_hash[:private_type]).to eq(core.private.type)
+      result_hash[:private_type].should == core.private.type
     end
   end
 
@@ -89,94 +84,84 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
     let(:result_hash) { core_exporter.line_for_login(login) }
 
     it 'should produce values in the proper order' do
-      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
-                                        ]
-                                    )
+      result_hash.values.should == [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
-      expect(result_hash[:host_address]).to eq(login.service.host.address)
+      result_hash[:host_address].should == login.service.host.address
     end
 
     it 'should produce a hash with the service port' do
-      expect(result_hash[:service_port]).to eq(login.service.port)
+      result_hash[:service_port].should == login.service.port
     end
 
     it 'should produce a hash with the service name' do
-      expect(result_hash[:service_name]).to eq(login.service.name)
+      result_hash[:service_name].should == login.service.name
     end
 
     it 'should produce a hash with the service protocol' do
-      expect(result_hash[:service_protocol]).to eq(login.service.proto)
+      result_hash[:service_protocol].should == login.service.proto
     end
 
     it 'should produce a hash with the login status' do
-      expect(result_hash[:status]).to eq(login.status)
+      result_hash[:status].should == login.status
     end
 
     it 'should produce a hash with the login access_level' do
-      expect(result_hash[:access_level]).to eq(login.access_level)
+      result_hash[:access_level].should == login.access_level
     end
 
     it 'should produce a hash with the login last_attempted_at' do
-      expect(result_hash[:last_attempted_at]).to eq(login.last_attempted_at)
+      result_hash[:last_attempted_at].should == login.last_attempted_at
     end
 
     it 'should produce a hash with the public information' do
-      expect(result_hash[:username]).to eq(login.core.public.username)
+      result_hash[:username].should == login.core.public.username
     end
 
     it 'should produce a hash with the private data' do
-      expect(result_hash[:private_data]).to eq(login.core.private.data)
+      result_hash[:private_data].should == login.core.private.data
     end
 
     it 'should produce a hash with the demodulized name of the private type' do
-      expect(result_hash[:private_type]).to eq(login.core.private.type)
+      result_hash[:private_type].should == login.core.private.type
     end
   end
 
   describe "#output" do
     it 'should be a writable File' do
       file_stat = core_exporter.output.stat
-      expect(file_stat).to be_writable
+      file_stat.should be_writable
     end
 
     it 'should not be opened in binmode' do
-      expect(core_exporter.output).not_to be_binmode
+      core_exporter.output.should_not be_binmode
     end
   end
 
   describe "#output_directory_path" do
     it 'should be in the platform-agnostic temp directory' do
-      expect(core_exporter.output_final_directory_path).to include(Dir.tmpdir)
+      core_exporter.output_final_directory_path.should include(Dir.tmpdir)
     end
 
     it 'should have the set export prefix' do
-      expect(core_exporter.output_final_directory_path).to include(Metasploit::Credential::Exporter::Core::TEMP_ZIP_PATH_PREFIX)
+      core_exporter.output_final_directory_path.should 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
-        allow(core_exporter).to receive(:output_final_subdirectory_name).and_return(path_fragment)
+        core_exporter.stub(: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
-        expect(core_exporter.output_final_directory_path).to include(core_exporter.output_final_subdirectory_name)
+        core_exporter.output_final_directory_path.should include(core_exporter.output_final_subdirectory_name)
       end
     end
   end
@@ -184,44 +169,44 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
   describe "#data" do
     describe "in LOGIN_MODE" do
       before(:each) do
-        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
       end
 
       describe "when whitelist_ids is present" do
         before(:each) do
-          allow(core_exporter).to receive(:whitelist_ids).and_return([login1.id])
+          core_exporter.stub(:whitelist_ids).and_return([login1.id])
         end
 
         it 'should contain only those objects whose IDs are in the whitelist' do
-          expect(core_exporter.data).not_to include(login2)
+          core_exporter.data.should_not include(login2)
         end
       end
 
       describe "when whitelist_ids is blank" do
         it 'should be the same as #export_data' do
-          expect(core_exporter.data).to eq(core_exporter.export_data)
+          core_exporter.data.should == core_exporter.export_data
         end
       end
     end
 
     describe "in CORE_MODE" do
       before(:each) do
-        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
       end
 
       describe "when whitelist_ids is present" do
         before(:each) do
-          allow(core_exporter).to receive(:whitelist_ids).and_return([core1.id])
+          core_exporter.stub(:whitelist_ids).and_return([core1.id])
         end
 
         it 'should contain only those objects whose IDs are in the whitelist' do
-          expect(core_exporter.data).not_to include(core2)
+          core_exporter.data.should_not include(core2)
         end
       end
 
       describe "when whitelist_ids is blank" do
         it 'should be the same as #export_data' do
-          expect(core_exporter.data).to eq(core_exporter.export_data)
+          core_exporter.data.should == core_exporter.export_data
         end
       end
     end
@@ -230,22 +215,22 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
   describe "#export_data" do
     describe "in CORE_MODE" do
       before(:each) do
-        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
       end
 
       it 'should grab data using the proper scope' do
-        expect(Metasploit::Credential::Core).to receive(:workspace_id).with(core_exporter.workspace.id)
+        Metasploit::Credential::Core.should_receive(:workspace_id).with(core_exporter.workspace.id)
         core_exporter.export_data
       end
     end
 
     describe "in LOGIN_MODE" do
       before(:each) do
-        allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+        core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
       end
 
       it 'should grab data using the proper scope' do
-        expect(Metasploit::Credential::Login).to receive(:in_workspace_including_hosts_and_services).with(core_exporter.workspace)
+        Metasploit::Credential::Login.should_receive(:in_workspace_including_hosts_and_services).with(core_exporter.workspace)
         core_exporter.export_data
       end
     end
@@ -255,7 +240,7 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
     describe "#render_manifest_and_output_keys" do
       describe "in CORE_MODE" do
         before(:each) do
-          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          core_exporter.stub(: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
 
@@ -275,34 +260,34 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
         end
 
         it 'should contain the Public#username for all Core objects' do
-          expect(@core_publics).to include(core1.public.username)
-          expect(@core_publics).to include(core2.public.username)
+          @core_publics.should include(core1.public.username)
+          @core_publics.should include(core2.public.username)
         end
 
         it 'should contain the Private#type for all Core objects' do
-          expect(@core_private_types).to include(core1.private.type)
-          expect(@core_private_types).to include(core2.private.type)
+          @core_private_types.should include(core1.private.type)
+          @core_private_types.should include(core2.private.type)
         end
 
         it 'should contain the Private#data for all Core objects' do
-          expect(@core_private_data).to include(core1.private.data)
-          expect(@core_private_data).to include(core2.private.data)
+          @core_private_data.should include(core1.private.data)
+          @core_private_data.should include(core2.private.data)
         end
 
         it 'should contain the Realm#key for all Core objects' do
-          expect(@core_realm_keys).to include(core1.realm.key)
-          expect(@core_realm_keys).to include(core2.realm.key)
+          @core_realm_keys.should include(core1.realm.key)
+          @core_realm_keys.should include(core2.realm.key)
         end
 
         it 'should contain the Realm#value for all Core objects' do
-          expect(@core_realm_values).to include(core1.realm.value)
-          expect(@core_realm_values).to include(core2.realm.value)
+          @core_realm_values.should include(core1.realm.value)
+          @core_realm_values.should include(core2.realm.value)
         end
       end
 
       describe "in LOGIN_MODE" do
         before(:each) do
-          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::LOGIN_MODE
+          core_exporter.stub(: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
 
@@ -331,48 +316,48 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
 
 
         it 'should contain the Public#username for all Login objects' do
-          expect(@login_publics).to include(login1.core.public.username)
-          expect(@login_publics).to include(login2.core.public.username)
+          @login_publics.should include(login1.core.public.username)
+          @login_publics.should include(login2.core.public.username)
         end
 
         it 'should contain the Private#type for all Login objects' do
-          expect(@login_private_types).to include(login1.core.private.type)
-          expect(@login_private_types).to include(login2.core.private.type)
+          @login_private_types.should include(login1.core.private.type)
+          @login_private_types.should include(login2.core.private.type)
         end
 
         it 'should contain the Private#data for all Login objects' do
-          expect(@login_private_data).to include(login1.core.private.data)
-          expect(@login_private_data).to include(login2.core.private.data)
+          @login_private_data.should include(login1.core.private.data)
+          @login_private_data.should include(login2.core.private.data)
         end
 
         it 'should contain the Realm#key for all Login objects' do
-          expect(@login_realm_keys).to include(login1.core.realm.key)
-          expect(@login_realm_keys).to include(login2.core.realm.key)
+          @login_realm_keys.should include(login1.core.realm.key)
+          @login_realm_keys.should include(login2.core.realm.key)
         end
 
         it 'should contain the Realm#value for all Login objects' do
-          expect(@login_realm_values).to include(login1.core.realm.value)
-          expect(@login_realm_values).to include(login2.core.realm.value)
+          @login_realm_values.should include(login1.core.realm.value)
+          @login_realm_values.should include(login2.core.realm.value)
         end
 
         it 'should contain the associated Mdm::Host#address for all Login objects' do
-          expect(@login_host_addresses).to include(login1.service.host.address)
-          expect(@login_host_addresses).to include(login2.service.host.address)
+          @login_host_addresses.should include(login1.service.host.address)
+          @login_host_addresses.should include(login2.service.host.address)
         end
 
         it 'should contain the associated Mdm::Service#port (stringified) for all Login objects' do
-          expect(@login_service_ports).to include(login1.service.port.to_s)
-          expect(@login_service_ports).to include(login2.service.port.to_s)
+          @login_service_ports.should include(login1.service.port.to_s)
+          @login_service_ports.should include(login2.service.port.to_s)
         end
 
         it 'should contain the associated Mdm::Service#name for all Login objects' do
-          expect(@login_service_names).to include(login1.service.name)
-          expect(@login_service_names).to include(login2.service.name)
+          @login_service_names.should include(login1.service.name)
+          @login_service_names.should include(login2.service.name)
         end
 
         it 'should contain the associated Mdm::Service#proto for all Login objects' do
-          expect(@login_service_protocols).to include(login1.service.proto)
-          expect(@login_service_protocols).to include(login2.service.proto)
+          @login_service_protocols.should include(login1.service.proto)
+          @login_service_protocols.should include(login2.service.proto)
         end
       end
     end
@@ -380,7 +365,7 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
     describe "#render_zip" do
       describe "when there are no SSH keys in the dataset" do
         before(:each) do
-          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
           core_exporter.render_manifest_output_and_keys
           core_exporter.render_zip
         end
@@ -390,7 +375,7 @@ RSpec.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
-          expect(manifest_entry).not_to be_blank
+          manifest_entry.should_not be_blank
         end
 
         it 'should not contain a keys directory' do
@@ -398,7 +383,7 @@ RSpec.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
-          expect(keys_entry).to be_blank
+          keys_entry.should be_blank
         end
       end
 
@@ -411,7 +396,7 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
                                                  workspace: workspace)}
 
         before(:each) do
-          allow(core_exporter).to receive(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
+          core_exporter.stub(:mode).and_return Metasploit::Credential::Exporter::Core::CORE_MODE
           core_exporter.render_manifest_output_and_keys
           core_exporter.render_zip
         end
@@ -421,7 +406,7 @@ RSpec.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
-          expect(manifest_entry).not_to be_blank
+          manifest_entry.should_not be_blank
         end
 
         it 'should contain a keys directory' do
@@ -429,7 +414,7 @@ RSpec.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
-          expect(keys_entry).not_to be_blank
+          keys_entry.should_not be_blank
         end
 
         describe "the keys directory" do
@@ -441,12 +426,12 @@ RSpec.describe Metasploit::Credential::Exporter::Core do
           end
 
           it 'should contain a key for each SSH private in the export' do
-            expect(@key_entries.size).to eq(core_exporter.data[:core].select{ |d| d.private.type == Metasploit::Credential::SSHKey.name }.size)
+            @key_entries.size.should == 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}/", '') }
-            expect(key_names).to include("#{core_with_key.public.username}-#{core_with_key.private.id}")
+            key_names.should include("#{core_with_key.public.username}-#{core_with_key.private.id}")
           end
 
         end