ronin-post_ex 0.1.0.beta1

data/spec/sessions/shell_session_spec.rb

@@ -0,0 +1,482 @@
+require 'spec_helper'
+require 'ronin/post_ex/sessions/shell_session'
+
+require 'socket'
+
+describe Ronin::PostEx::Sessions::ShellSession do
+  let(:pipe)  { UNIXSocket.pair }
+  let(:io)    { pipe[0] }
+  let(:shell) { pipe[1] }
+
+  subject { described_class.new(io) }
+
+  describe "#initialize" do
+    it "must set #io" do
+      expect(subject.io).to be(io)
+    end
+  end
+
+  describe "#shell_gets" do
+    it "must read a line of text from #io" do
+      thread = Thread.new do
+        sleep 0.1
+        shell.write("foo bar\n")
+      end
+
+      expect(subject.shell_gets).to eq("foo bar\n")
+    end
+  end
+
+  describe "#shell_puts" do
+    let(:line) { "foo bar" }
+
+    it "must write a line of text to #io" do
+      subject.shell_puts(line)
+
+      expect(shell.gets).to eq("#{line}\n")
+    end
+  end
+
+  describe "#shell_exec" do
+    let(:command) { 'ls' }
+    let(:output) do
+      [
+        "API_SPEC.md",
+        "ChangeLog.md",
+        "COPYING.txt",
+        "Gemfile",
+        "Gemfile.lock",
+        "gemspec.yml",
+        "lib",
+        "Rakefile",
+        "README.md",
+        "ronin-post_ex.gemspec",
+        "spec",
+        "vendor"
+      ].map { |line| "#{line}\n" }.join
+    end
+
+    it "must print a beginning deliminator, pipe the command into base64, and print an ending deliminator" do
+      thread = Thread.new do
+        sleep 0.1
+        subject.shell_exec(command)
+      end
+
+      expect(shell.gets).to eq("echo #{described_class::DELIMINATOR}; #{command} 2>/dev/null | base64; echo #{described_class::DELIMINATOR}\n")
+      shell.puts(described_class::DELIMINATOR)
+      shell.write(Base64.encode64(output))
+      shell.puts(described_class::DELIMINATOR)
+    end
+
+    it "must return the output of the command" do
+      thread = Thread.new do
+        sleep 0.1
+
+        shell.gets
+        shell.puts(described_class::DELIMINATOR)
+        shell.write(Base64.encode64(output))
+        shell.puts(described_class::DELIMINATOR)
+      end
+
+      expect(subject.shell_exec(command)).to eq(output)
+    end
+  end
+
+  describe "#sys_time" do
+    let(:timestamp) { 1668692783         }
+    let(:output)    { "#{timestamp}\n"   }
+
+    it "must run the 'date +%s' and parse the output as an Integer" do
+      expect(subject).to receive(:shell_exec).with('date +%s').and_return(output)
+
+      expect(subject.sys_time).to eq(timestamp)
+    end
+  end
+
+  describe "#sys_hostname" do
+    let(:hostname) { 'computer'      }
+    let(:output)   { "#{hostname}\n" }
+
+    it "must run the 'echo $HOSTNAME' and parse the output as an Integer" do
+      expect(subject).to receive(:shell_exec).with('echo $HOSTNAME').and_return(output)
+
+      expect(subject.sys_hostname).to eq(hostname)
+    end
+  end
+
+  describe "#fs_getcwd" do
+    let(:pwd)    { '/current/directory' }
+    let(:output) { "#{pwd}\n" }
+
+    it "must run the 'pwd' command and return the path" do
+      expect(subject).to receive(:shell_exec).with('pwd').and_return(output)
+
+      expect(subject.fs_getcwd).to eq(pwd)
+    end
+  end
+
+  describe "#fs_chdir" do
+    let(:new_dir) { '/path/to/directory' }
+    let(:output)  { "\n" }
+
+    it "must run the 'cd <path> 2>/dev/null' command" do
+      expect(subject).to receive(:shell_puts).with("cd #{new_dir} 2>/dev/null")
+
+      subject.fs_chdir(new_dir)
+    end
+  end
+
+  describe "#fs_readfile" do
+    let(:path)     { '/path/to/file' }
+    let(:contents) { "foo bar\nbaz qux\n"  }
+
+    it "must run the 'cat <path>' command and return the file contents" do
+      expect(subject).to receive(:command_exec).with('cat',path).and_return(contents)
+
+      expect(subject.fs_readfile(path)).to eq(contents)
+    end
+  end
+
+  describe "#fs_readlink" do
+    let(:path)      { '/path/to/link'  }
+    let(:dest_path) { 'path/to/file'   }
+    let(:output)    { "#{dest_path}\n" }
+
+    it "must run the 'readlink -f <path>' command and return the link's path" do
+      expect(subject).to receive(:command_exec).with('readlink','-f',path).and_return(output)
+
+      expect(subject.fs_readlink(path)).to eq(dest_path)
+    end
+  end
+
+  describe "#fs_readdir" do
+    let(:path) { '/path/to/dir'  }
+    let(:entries) do
+      %w[
+        API_SPEC.md
+        ChangeLog.md
+        COPYING.txt
+        examples
+        Gemfile
+        Gemfile.lock
+        gemspec.yml
+        lib
+        Rakefile
+        README.md
+        ronin-post_ex.gemspec
+        spec
+        vendor
+      ]
+    end
+    let(:output) { "#{entries.join("\n")}\n" }
+
+    it "must run the 'ls <path>' command and return the directories entries" do
+      expect(subject).to receive(:command_exec).with('ls',path).and_return(output)
+
+      expect(subject.fs_readdir(path)).to eq(entries)
+    end
+  end
+
+  describe "#fs_glob" do
+    let(:pattern) { '*.md' }
+    let(:entries) do
+      %w[
+        API_SPEC.md
+        ChangeLog.md
+        README.md
+      ]
+    end
+    let(:output) { "#{entries.join("\n")}\n" }
+
+    it "must run the 'ls <pattern>' command and return the matching paths" do
+      expect(subject).to receive(:shell_exec).with("ls #{pattern}").and_return(output)
+
+      expect(subject.fs_glob(pattern)).to eq(entries)
+    end
+  end
+
+  describe "#fs_mktemp" do
+    let(:basename) { 'ronin-XXXX.txt' }
+    let(:tempfile) { 'ronin-LtFK.txt' }
+    let(:output) { "#{tempfile}\n" }
+
+    it "must run the 'mktemp <basename>' command and return the tempfile name" do
+      expect(subject).to receive(:command_exec).with('mktemp',basename).and_return(output)
+
+      expect(subject.fs_mktemp(basename)).to eq(tempfile)
+    end
+  end
+
+  describe "#fs_mkdir" do
+    let(:path) { '/path/to/new_dir' }
+
+    it "must run the 'mkdir <pattern>' command" do
+      expect(subject).to receive(:command_exec).with('mkdir',path)
+
+      subject.fs_mkdir(path)
+    end
+  end
+
+  describe "#fs_copy" do
+    let(:src)  { '/path/to/src'  }
+    let(:dest) { '/path/to/dest' }
+
+    it "must run the 'cp -r <src> <dest>' command" do
+      expect(subject).to receive(:command_exec).with('cp','-r',src,dest)
+
+      subject.fs_copy(src,dest)
+    end
+  end
+
+  describe "#fs_unlink" do
+    let(:path) { '/path/to/file' }
+
+    it "must run the 'rm <path>' command" do
+      expect(subject).to receive(:command_exec).with('rm',path)
+
+      subject.fs_unlink(path)
+    end
+  end
+
+  describe "#fs_rmdir" do
+    let(:path) { '/path/to/dir' }
+
+    it "must run the 'rmdir <path>' command" do
+      expect(subject).to receive(:command_exec).with('rmdir',path)
+
+      subject.fs_rmdir(path)
+    end
+  end
+
+  describe "#fs_move" do
+    let(:src)  { '/path/to/src'  }
+    let(:dest) { '/path/to/dest' }
+
+    it "must run the 'mv <src> <dest>' command" do
+      expect(subject).to receive(:command_exec).with('mv',src,dest)
+
+      subject.fs_move(src,dest)
+    end
+  end
+
+  describe "#fs_link" do
+    let(:src)  { '/path/to/src'  }
+    let(:dest) { '/path/to/dest' }
+
+    it "must run the 'ln -s <src> <dest>' command" do
+      expect(subject).to receive(:command_exec).with('ln','-s',src,dest)
+
+      subject.fs_link(src,dest)
+    end
+  end
+
+  describe "#fs_chgrp" do
+    let(:group) { 'wheel' }
+    let(:path)  { '/path/to/file' }
+
+    it "must run the 'chgrp <group> <path>' command" do
+      expect(subject).to receive(:command_exec).with('chgrp',group,path)
+
+      subject.fs_chgrp(group,path)
+    end
+  end
+
+  describe "#fs_chown" do
+    let(:user) { 'root' }
+    let(:path) { '/path/to/file' }
+
+    it "must run the 'chown <user> <path>' command" do
+      expect(subject).to receive(:command_exec).with('chown',user,path)
+
+      subject.fs_chown(user,path)
+    end
+  end
+
+  describe "#fs_chmod" do
+    let(:mode)  { 0777 }
+    let(:umask) { "%.4o" % mode }
+    let(:path)  { '/path/to/file' }
+
+    it "must run the 'chown <user> <path>' command" do
+      expect(subject).to receive(:command_exec).with('chmod',umask,path)
+
+      subject.fs_chmod(mode,path)
+    end
+  end
+
+  describe "#fs_stat" do
+    let(:path) { '/path/to/file' }
+    let(:size) { 420 }
+    let(:blocks) { 16 }
+    let(:uid) { 1000 }
+    let(:gid) { 1000 }
+    let(:inode) { 12345 }
+    let(:links) { 1 }
+    let(:atime) { Time.at(1668608914) }
+    let(:mtime) { Time.at(1668427627) }
+    let(:ctime) { Time.at(1668427627) }
+    let(:blocksize) { 1668427627 }
+
+    let(:output) do
+      "#{path} #{size} #{blocks} 81a4 #{uid} #{gid} fd01 #{inode} #{links} 0 0 #{atime.to_i} #{mtime.to_i} #{ctime.to_i} #{blocksize} 4096 unconfined_u:object_r:unlabeled_t:s0\n"
+    end
+
+    it "must run the 'stat -t <path>' command and return a Hash of parsed stat information" do
+      expect(subject).to receive(:command_exec).with('stat','-t',path).and_return(output)
+
+      expect(subject.fs_stat(path)).to eq(
+        {
+          path:      path,
+          size:      size,
+          blocks:    blocks,
+          uid:       uid,
+          gid:       gid,
+          inode:     inode,
+          links:     links,
+          atime:     atime,
+          mtime:     mtime,
+          ctime:     ctime,
+          blocksize: blocksize
+        }
+      )
+    end
+  end
+
+  describe "#process_getpid" do
+    let(:pid)    { 1234 }
+    let(:output) { "#{pid}\n" }
+
+    it "must run the 'echo $$' command and return the parsed PID" do
+      expect(subject).to receive(:shell_exec).with('echo $$').and_return(output)
+
+      expect(subject.process_getpid).to eq(pid)
+    end
+  end
+
+  describe "#process_getppid" do
+    let(:ppid)   { 1234 }
+    let(:output) { "#{ppid}\n" }
+
+    it "must run the 'echo $PPID' command and return the parsed PPID" do
+      expect(subject).to receive(:shell_exec).with('echo $PPID').and_return(output)
+
+      expect(subject.process_getppid).to eq(ppid)
+    end
+  end
+
+  describe "#process_getuid" do
+    let(:uid)    { 1000 }
+    let(:output) { "#{uid}\n" }
+
+    it "must run the 'id -u' command and return the parsed UID" do
+      expect(subject).to receive(:command_exec).with('id','-u').and_return(output)
+
+      expect(subject.process_getuid).to eq(uid)
+    end
+  end
+
+  describe "#process_getgid" do
+    let(:gid)    { 1000 }
+    let(:output) { "#{gid}\n" }
+
+    it "must run the 'id -g' command and return the parsed GID" do
+      expect(subject).to receive(:command_exec).with('id','-g').and_return(output)
+
+      expect(subject.process_getgid).to eq(gid)
+    end
+  end
+
+  describe "#process_getgid" do
+    let(:env) do
+      {
+        'FOO' => 'foo',
+        'BAR' => 'bar'
+      }
+    end
+    let(:output) do
+      "#{env.keys[0]}=#{env.values[0]}\n#{env.keys[1]}=#{env.values[1]}\n"
+    end
+
+    it "must run the 'env' command and return the parsed env Hash" do
+      expect(subject).to receive(:command_exec).with('env').and_return(output)
+
+      expect(subject.process_environ).to eq(env)
+    end
+  end
+
+  describe "#process_getenv" do
+    let(:name)  { 'FOO' }
+    let(:value) { 'foo bar baz' }
+    let(:output) { "#{value}\n" }
+
+    it "must run the 'echo $<name>' command and return the parsed value" do
+      expect(subject).to receive(:shell_exec).with("echo $#{name}").and_return(output)
+
+      expect(subject.process_getenv(name)).to eq(value)
+    end
+  end
+
+  describe "#process_setenv" do
+    let(:name)  { 'FOO' }
+    let(:value) { 'foo bar baz' }
+
+    it "must run the 'export <name>=<value>' command and return the parsed value" do
+      expect(subject).to receive(:shell_puts).with("export #{name}=#{value}")
+
+      subject.process_setenv(name,value)
+    end
+  end
+
+  describe "#process_unsetenv" do
+    let(:name) { 'FOO' }
+
+    it "must run the 'unset <name>' command" do
+      expect(subject).to receive(:shell_puts).with("unset #{name}")
+
+      subject.process_unsetenv(name)
+    end
+  end
+
+  describe "#process_kill" do
+    let(:pid)    { 1234   }
+    let(:signal) { 'TERM' }
+
+    it "must run the 'kill -s <signal> <pid>' command" do
+      expect(subject).to receive(:command_exec).with('kill','-s',signal,pid)
+
+      subject.process_kill(pid,signal)
+    end
+  end
+
+  describe "#process_spawn" do
+    let(:command_name) { 'cmd' }
+    let(:arguments)    { ['foo', 'bar baz'] }
+
+    let(:pid)    { 1234 }
+    let(:output) { "#{pid}\n" }
+
+    it "must run the command with arguments and return the parsed PID" do
+      command = Shellwords.join([command_name, *arguments])
+
+      expect(subject).to receive(:shell_exec).with("#{command} 2>&1 >/dev/null &; echo $!").and_return(output)
+
+      expect(subject.process_spawn(command_name,*arguments)).to eq(pid)
+    end
+  end
+
+  describe "#process_exit" do
+    it "must run the 'exit' command" do
+      expect(subject).to receive(:shell_puts).with('exit')
+
+      subject.process_exit
+    end
+  end
+
+  describe "#close" do
+    it "must call #close on #io" do
+      expect(io).to receive(:close)
+
+      subject.close
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'simplecov'
+require 'ronin/post_ex/version'
+
+SimpleCov.start
+
+RSpec.configure do |c|
+  c.include Ronin::PostEx
+end

data/spec/system_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'ronin/post_ex/system'
+require 'ronin/post_ex/sessions/session'
+
+describe Ronin::PostEx::System do
+  let(:session) { Ronin::PostEx::Sessions::Session.new }
+
+  subject { described_class.new(session) }
+
+  describe "#initialize" do
+    it "must set #session" do
+      expect(subject.session).to be(session)
+    end
+
+    it "must initialize #fs" do
+      expect(subject.fs).to be_kind_of(described_class::FS)
+    end
+
+    it "must initialize #process" do
+      expect(subject.process).to be_kind_of(described_class::Process)
+    end
+
+    it "must initialize #shell" do
+      expect(subject.shell).to be_kind_of(described_class::Shell)
+    end
+  end
+
+  describe "#fs" do
+    it "must return a System::FS object" do
+      expect(subject.fs).to be_kind_of(described_class::FS)
+    end
+  end
+
+  describe "#process" do
+    it "must return a System::Process object" do
+      expect(subject.process).to be_kind_of(described_class::Process)
+    end
+  end
+
+  describe "#shell" do
+    it "must return a System::Shell object" do
+      expect(subject.shell).to be_kind_of(described_class::Shell)
+    end
+  end
+
+  describe "#time" do
+    let(:unix_timestamp) { 1642775495 }
+    let(:time)           { Time.at(unix_timestamp) }
+
+    it "must call the 'sys_time' API function and return a Time object" do
+      expect(session).to receive(:sys_time).and_return(unix_timestamp)
+
+      expect(subject.time).to eq(time)
+    end
+  end
+
+  describe "#hostname" do
+    let(:hostname) { 'computer' }
+
+    it "must call the 'sys_hostname' API function and return the hostname" do
+      expect(session).to receive(:sys_hostname).and_return(hostname)
+
+      expect(subject.hostname).to eq(hostname)
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: ronin-post_ex
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta1
+platform: ruby
+authors:
+- Postmodern
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fake_io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: hexdump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ronin-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0.beta1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: ronin-post_ex is a Ruby API for Post-Exploitation.
+email: postmodern.mod3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- API_SPEC.md
+- COPYING.txt
+- ChangeLog.md
+- README.md
+files:
+- ".document"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".yardopts"
+- API_SPEC.md
+- COPYING.txt
+- ChangeLog.md
+- Gemfile
+- README.md
+- Rakefile
+- examples/bind_shell.rb
+- gemspec.yml
+- lib/ronin/post_ex.rb
+- lib/ronin/post_ex/cli/shell_shell.rb
+- lib/ronin/post_ex/cli/system_shell.rb
+- lib/ronin/post_ex/remote_dir.rb
+- lib/ronin/post_ex/remote_file.rb
+- lib/ronin/post_ex/remote_file/stat.rb
+- lib/ronin/post_ex/remote_process.rb
+- lib/ronin/post_ex/resource.rb
+- lib/ronin/post_ex/sessions/bind_shell.rb
+- lib/ronin/post_ex/sessions/remote_shell_session.rb
+- lib/ronin/post_ex/sessions/reverse_shell.rb
+- lib/ronin/post_ex/sessions/rpc_session.rb
+- lib/ronin/post_ex/sessions/session.rb
+- lib/ronin/post_ex/sessions/shell_session.rb
+- lib/ronin/post_ex/system.rb
+- lib/ronin/post_ex/system/fs.rb
+- lib/ronin/post_ex/system/process.rb
+- lib/ronin/post_ex/system/shell.rb
+- lib/ronin/post_ex/version.rb
+- ronin-post_ex.gemspec
+- spec/sessions/bind_shell_spec.rb
+- spec/sessions/remote_shell_session_spec.rb
+- spec/sessions/reverse_shell_spec.rb
+- spec/sessions/rpc_session_spec.rb
+- spec/sessions/session_spec.rb
+- spec/sessions/shell_session_spec.rb
+- spec/spec_helper.rb
+- spec/system_spec.rb
+homepage: https://ronin-rb.dev/
+licenses:
+- LGPL-3.0
+metadata:
+  documentation_uri: https://rubydoc.info/gems/ronin-post_ex
+  source_code_uri: https://github.com/ronin-rb/ronin-post_ex
+  bug_tracker_uri: https://github.com/ronin-rb/ronin-post_ex/issues
+  changelog_uri: https://github.com/ronin-rb/ronin-post_ex/blob/master/ChangeLog.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Ruby API for Post-Exploitation
+test_files:
+- spec/sessions/bind_shell_spec.rb
+- spec/sessions/remote_shell_session_spec.rb
+- spec/sessions/reverse_shell_spec.rb
+- spec/sessions/rpc_session_spec.rb
+- spec/sessions/session_spec.rb
+- spec/sessions/shell_session_spec.rb
+- spec/system_spec.rb