Land rapid7#5066 : EncodedPayload#generate specs

Author: OJ

spec/lib/msf/core/encoded_payload_spec.rb

@@ -4,16 +4,31 @@
 describe Msf::EncodedPayload do
   include_context 'Msf::Simple::Framework#modules loading'
 
+  before do
+    expect_to_load_module_ancestors(
+      ancestor_reference_names: [
+        # Excellent rank
+        'x86/shikata_ga_nai',
+        # Great rank
+        'x86/call4_dword_xor',
+        'generic/none',
+        ],
+      module_type: 'encoder',
+      modules_path: modules_path,
+    )
+  end
+
   let(:ancestor_reference_names) {
-    %w{singles/linux/x86/shell_reverse_tcp}
+    # A module that doesn't require any datastore junk to generate
+    %w{singles/linux/x86/shell_bind_tcp}
   }
 
   let(:module_type) {
     'payload'
   }
 
   let(:reference_name) {
-    'linux/x86/shell_reverse_tcp'
+    'linux/x86/shell_bind_tcp'
   }
 
   let(:payload) {
@@ -25,22 +40,34 @@
   }
 
   subject(:encoded_payload) do
-    described_class.new(framework, payload, {})
+    described_class.new(framework, payload, reqs)
   end
 
+  let(:badchars) { nil }
+  let(:reqs) { { 'BadChars' => badchars } }
+
   it 'is an Msf::EncodedPayload' do
     expect(encoded_payload).to be_a(described_class)
   end
 
   describe '.create' do
+    subject(:encoded_payload) do
+      described_class.create(payload, { 'BadChars' => badchars } )
+    end
+
+    specify { expect(encoded_payload).to respond_to(:encoded) }
+
+    it 'is an Msf::EncodedPayload' do
+      expect(encoded_payload).to be_a(described_class)
+    end
 
     context 'when passed a valid payload instance' do
 
       # don't ever actually generate payload bytes
       before { described_class.any_instance.stub(:generate) }
 
       it 'returns an Msf::EncodedPayload instance' do
-        expect(described_class.create(payload)).to be_a(described_class)
+        expect(encoded_payload).to be_a(described_class)
       end
 
     end
@@ -76,4 +103,44 @@
       end
     end
   end
+
+  describe '#generate' do
+    let!(:generate) { encoded_payload.generate }
+
+    context 'with no badchars' do
+      let(:badchars) { nil }
+
+      specify 'returns the raw value' do
+        expect(encoded_payload.generate("RAW")).to eql("RAW")
+      end
+
+    end
+
+    context 'with bad characters: "\\0"' do
+      let(:badchars) { "\0".force_encoding('binary') }
+
+      specify 'chooses x86/shikata_ga_nai' do
+        expect(encoded_payload.encoder.refname).to eq("x86/shikata_ga_nai")
+      end
+
+      specify do
+        expect(encoded_payload.encoded).not_to include(badchars)
+      end
+
+    end
+    context 'with bad characters: "\\xD9\\x00"' do
+      let(:badchars) { "\xD9\x00".force_encoding('binary') }
+
+      specify 'chooses x86/call4_dword_xor' do
+        expect(encoded_payload.encoder.refname).to eq("x86/call4_dword_xor")
+      end
+
+      specify do
+        expect(encoded_payload.encoded).not_to include(badchars)
+      end
+
+    end
+
+  end
+
 end