ronin-post_ex 0.1.0.beta1 → 0.1.0

data/spec/sessions/shell_session_spec.rb

@@ -1,482 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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