ronin-support 0.5.1 → 1.0.0.beta1

data/spec/network/telnet_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/telnet'
-
-describe Network::Telnet do
-  describe "helpers", :network do
-    let(:host) { 'towel.blinkenlights.nl' }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#telnet_connect" do
-      it "should return a Net::Telnet object" do
-        telnet = subject.telnet_connect(host)
-
-        telnet.should be_kind_of(Net::Telnet)
-        telnet.close
-      end
-
-      it "should connect to a telnet service on port 23" do
-        telnet = subject.telnet_connect(host)
-
-        telnet.close
-      end
-
-      context "when given a block" do
-        it "should yield the new Net::Telnet object" do
-          telnet = nil
-
-          subject.telnet_connect(host) do |telnet_object|
-            telnet = telnet_object
-          end
-
-          telnet.should be_kind_of(Net::Telnet)
-          telnet.close
-        end
-      end
-    end
-
-    describe "#telnet_session" do
-      it "should yield a new Net::Telnet object" do
-        yielded_telnet = nil
-
-        subject.telnet_session(host) do |telnet|
-          yielded_telnet = telnet
-        end
-
-        yielded_telnet.should be_kind_of(Net::Telnet)
-      end
-
-      it "should close the Telnet session after yielding it" do
-        session  = nil
-        was_open = nil
-
-        subject.telnet_session(host) do |telnet|
-          session   = telnet
-          was_open  = !telnet.sock.closed?
-        end
-
-        was_open.should == true
-        session.sock.should be_closed
-      end
-    end
-  end
-end

data/spec/network/udp/udp_spec.rb

@@ -1,271 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/udp'
-
-require 'resolv'
-
-describe Network::UDP do
-  describe "helper methods", :network do
-    let(:host) { 'scanme.nmap.org' }
-    let(:port) { 123 }
-
-    let(:server_host) { 'localhost' }
-    let(:server_ip)   { Resolv.getaddress(server_host) }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#udp_open?" do
-      let(:host) { '4.2.2.1' }
-      let(:port) { 53 }
-
-      it "should return true for open ports" do
-        subject.udp_open?(host,port).should == true
-      end
-
-      it "should return false for closed ports" do
-        subject.udp_open?('localhost',rand(1024) + 1).should == false
-      end
-
-      it "should have a timeout for firewalled ports" do
-        timeout = 2
-
-        t1 = Time.now
-        subject.udp_open?(host,1337,nil,nil,timeout)
-        t2 = Time.now
-
-        (t2 - t1).to_i.should <= timeout
-      end
-    end
-
-    describe "#udp_connect" do
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      it "should open a UDPSocket" do
-        socket = subject.udp_connect(host,port)
-
-        socket.should be_kind_of(UDPSocket)
-        socket.should_not be_closed
-
-        socket.close
-      end
-
-      it "should bind to a local port" do
-        socket      = subject.udp_connect(host,port,nil,local_port)
-        bound_port = socket.addr[1]
-
-        bound_port.should == local_port
-
-        socket.close
-      end
-
-      it "should yield the new UDPSocket" do
-        socket = nil
-
-        subject.udp_connect(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should_not be_closed
-        socket.close
-      end
-    end
-
-    describe "#udp_connect_and_send" do
-      pending "need to find a UDP Service for these specs" do
-        let(:data) { "HELO ronin\n" }
-        let(:local_port) { 1024 + rand(65535 - 1024) }
-
-        it "should connect and then send data" do
-          socket   = subject.udp_connect_and_send(data,host,port)
-          banner   = socket.readline
-          response = socket.readline
-
-          response.start_with?('250').should be_true
-
-          socket.close
-        end
-
-        it "should bind to a local port" do
-          socket      = subject.udp_connect_and_send(data,host,port,nil,local_port)
-          bound_port = socket.addr[1]
-
-          bound_port.should == local_port
-
-          socket.close
-        end
-
-        it "should yield the UDPSocket" do
-          response = nil
-
-          socket = subject.udp_connect_and_send(data,host,port) do |socket|
-            banner   = socket.readline
-            response = socket.readline
-          end
-
-          response.start_with?('250').should be_true
-
-          socket.close
-        end
-      end
-    end
-
-    describe "#udp_session" do
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      it "should open then close a UDPSocket" do
-        socket = nil
-
-        subject.udp_session(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should be_kind_of(UDPSocket)
-        socket.should be_closed
-      end
-
-      it "should bind to a local host and port" do
-        bound_port = nil
-
-        subject.udp_session(host,port,nil,local_port) do |socket|
-          bound_port = socket.addr[1]
-        end
-
-        bound_port.should == local_port
-      end
-    end
-
-    describe "#udp_banner" do
-      pending "need to find a UDP service that sends a banner" do
-        let(:host) { 'smtp.gmail.com' }
-        let(:port) { 25 }
-
-        let(:local_port) { 1024 + rand(65535 - 1024) }
-
-        it "should read the service banner" do
-          banner = subject.udp_banner(host,port)
-
-          banner.start_with?('220').should be_true
-        end
-
-        it "should bind to a local host and port" do
-          banner = subject.udp_banner(host,port,nil,local_port)
-
-          banner.start_with?('220').should be_true
-        end
-
-        it "should yield the banner" do
-          banner = nil
-
-          subject.udp_banner(host,port) do |yielded_banner|
-            banner = yielded_banner
-          end
-
-          banner.start_with?('220').should be_true
-        end
-      end
-    end
-
-    describe "#udp_send" do
-      let(:server) do
-        socket = UDPSocket.new
-        socket.bind(server_host,0)
-        socket
-      end
-      let(:server_port) { server.addr[1] }
-
-      let(:data)       { "hello\n" }
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      after(:all) { server.close }
-
-      it "should send data to a service" do
-        subject.udp_send(data,server_host,server_port)
-
-        mesg = server.recvfrom(data.length)
-
-        mesg[0].should == data
-      end
-
-      it "should bind to a local host and port" do
-        subject.udp_send(data,server_host,server_port,nil,local_port)
-
-        mesg = server.recvfrom(data.length)
-
-        client_address = mesg[1]
-        client_address[1].should == local_port
-      end
-    end
-
-    describe "#udp_server" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
-      it "should create a new UDPSocket" do
-        server = subject.udp_server
-
-        server.should be_kind_of(UDPSocket)
-        server.should_not be_closed
-
-        server.close
-      end
-
-      it "should bind to a specific port and host" do
-        server      = subject.udp_server(server_port,server_host)
-        bound_host = server.addr[3]
-        bound_port = server.addr[1]
-
-        bound_host.should == server_ip
-        bound_port.should == server_port
-
-        server.close
-      end
-
-      it "should yield the new UDPSocket" do
-        server = nil
-        
-        subject.udp_server do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(UDPSocket)
-        server.should_not be_closed
-
-        server.close
-      end
-    end
-
-    describe "#udp_server_session" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
-      it "should create a temporary UDPSocket" do
-        server = nil
-        
-        subject.udp_server_session do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(UDPSocket)
-        server.should be_closed
-      end
-
-      it "should bind to a specific port and host" do
-        bound_host = nil
-        bound_port = nil
-        
-        subject.udp_server_session(server_port,server_host) do |yielded_server|
-          bound_host = yielded_server.addr[3]
-          bound_port = yielded_server.addr[1]
-        end
-
-        bound_host.should == server_ip
-        bound_port.should == server_port
-      end
-    end
-
-    describe "#udp_recv" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-    end
-  end
-end

data/spec/network/unix_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-require 'network/shared/unix_server'
-require 'ronin/network/unix'
-
-require 'fileutils'
-
-describe Network::UNIX do
-  describe "helper methods", :network do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#unix_open?" do
-      include_context "UNIX Server"
-
-      let(:old_path) { socket_path('ronin_old_unix_socket') }
-      let(:bad_path) { socket_path('ronin_bad_unix_socket') }
-
-      before(:all) { UNIXServer.new(old_path).close }
-
-      it "should return true for listening UNIX sockets" do
-        subject.unix_open?(path).should == true
-      end
-
-      it "should return false for closed UNIX sockets" do
-        subject.unix_open?(old_path).should == false
-      end
-
-      it "should have a timeout for non-existent UNIX sockets" do
-        timeout = 2
-
-        t1 = Time.now
-        subject.unix_open?(bad_path,timeout)
-        t2 = Time.now
-
-        (t2 - t1).to_i.should <= timeout
-      end
-
-      after(:all) { FileUtils.rm(old_path) }
-    end
-
-    describe "#unix_connect" do
-      include_context "UNIX Server"
-
-      it "should open a UNIXSocket" do
-        socket = subject.unix_connect(path)
-
-        socket.should be_kind_of(UNIXSocket)
-        socket.should_not be_closed
-
-        socket.close
-      end
-
-      it "should yield the new UNIXSocket" do
-        socket = nil
-
-        subject.unix_connect(path) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should_not be_closed
-        socket.close
-      end
-    end
-
-    describe "#unix_connect_and_send" do
-      include_context "UNIX Server"
-
-      let(:data) { "HELO ronin\n" }
-
-      it "should connect and then send data" do
-        socket   = subject.unix_connect_and_send(data,path)
-        response = socket.readline
-
-        response.should == data
-
-        socket.close
-       end
-
-      it "should yield the UNIXSocket" do
-        response = nil
-
-        socket = subject.unix_connect_and_send(data,path) do |socket|
-          response = socket.readline
-        end
-
-        response.should == data
-
-        socket.close
-      end
-    end
-
-    describe "#unix_session" do
-      include_context "UNIX Server"
-
-      it "should open then close a UNIXSocket" do
-        socket = nil
-
-        subject.unix_session(path) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should be_kind_of(UNIXSocket)
-        socket.should be_closed
-      end
-    end
-
-    describe "#unix_send" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-      let(:data)        { "hello\n" }
-
-      before(:each) { @server = UNIXServer.new(server_path) }
-
-      it "should send data to a service" do
-        subject.unix_send(data,server_path)
-
-        client = @server.accept
-        sent   = client.readline
-
-        client.close
-
-        sent.should == data
-      end
-
-      after(:each) do
-        @server.close
-
-        FileUtils.rm(server_path)
-      end
-    end
-
-    describe "#unix_server" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-
-      it "should create a new UNIXServer" do
-        server = subject.unix_server(server_path)
-
-        server.should be_kind_of(UNIXServer)
-        server.should_not be_closed
-
-        server.close
-      end
-
-      it "should yield the new UNIXServer" do
-        server = nil
-        
-        subject.unix_server(server_path) do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(UNIXServer)
-        server.should_not be_closed
-
-        server.close
-      end
-
-      after(:each) { FileUtils.rm(server_path) }
-    end
-
-    describe "#unix_server_session" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-
-      it "should create a temporary UNIXServer" do
-        server = nil
-        
-        subject.unix_server_session(server_path) do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(UNIXServer)
-        server.should be_closed
-      end
-
-      after(:each) { FileUtils.rm(server_path) }
-    end
-
-    describe "#unix_accept" do
-      pending "need to automate connecting to the UNIXServer"
-    end
-  end
-end

data/spec/path_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-require 'ronin/path'
-
-describe Path do
-  subject { described_class }
-
-  let(:n) { 7 }
-
-  it "should inherit from Pathname" do
-    subject.superclass.should == Pathname
-  end
-
-  it "should provide the root path" do
-    path = subject.root
-
-    path.should.class == Path
-    path.to_s.should == '/'
-  end
-
-  describe "up" do
-    it "should be able to traverse up 0 directories" do
-      subject.up(0).should == File::SEPARATOR
-    end
-
-    it "should raise an ArgumentError when not passed an Integer or Enumerable" do
-      lambda {
-        subject.up(1.5)
-      }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an ArgumentError on negative number of directories" do
-      lambda {
-        subject.up(-1)
-      }.should raise_error(ArgumentError)
-    end
-
-    it "should create directory-escaping paths" do
-      subject.up(n).to_s.should == (['..'] * n).join(File::SEPARATOR)
-    end
-
-    it "should create a range of directory-escaping paths" do
-      range = 7..10
-
-      subject.up(range).should == range.map { |i| Path.up(i) }
-    end
-
-    it "should allow using custom path separators" do
-      subject.up(n,'\\').to_s.should == (['..'] * n).join("\\")
-    end
-  end
-
-  describe "#join" do
-    subject { Path.new('base') }
-
-    it "should join with sub-paths" do
-      sub_path = File.join('one','two')
-      expected = [subject, sub_path].join(File::SEPARATOR)
-
-      subject.join(sub_path).to_s.should == expected
-    end
-
-    it "should join with a sub-directory" do
-      sub_directory = 'three'
-      expected = [subject, sub_directory].join(File::SEPARATOR)
-
-      subject.join(sub_directory).to_s.should == expected
-    end
-
-    it "should not collapse directory traversals" do
-      traversal = Path.up(n)
-      expected = [subject, traversal].join(File::SEPARATOR)
-
-      subject.join(traversal).to_s.should == expected
-    end
-
-    it "should filter out extra directory separators" do
-      expected = [subject, 'sub'].join(File::SEPARATOR)
-
-      subject.join('/','sub','/').to_s.should == expected
-    end
-
-    it "should join with the root path" do
-      Path.root.join('etc','passwd').to_s.should == '/etc/passwd'
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-require 'rspec'
-require 'ronin/support/version'
-
-include Ronin
-
-RSpec.configure do |specs|
-  specs.treat_symbols_as_metadata_keys_with_true_values = true
-  specs.filter_run_excluding :network
-end

data/spec/support/inflector_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'ronin/support/inflector'
-
-describe "Ronin::Support::Inflector" do
-  subject { Ronin::Support::Inflector }
-
-  it "should not be nil" do
-    subject.should_not be_nil
-  end
-
-  it "should support pluralizing words" do
-    subject.pluralize('word').should == 'words'
-  end
-
-  it "should support singularizing words" do
-    subject.singularize('words').should == 'word'
-  end
-
-  it "should support humanizing words" do
-    subject.humanize('word_id').should == 'Word'
-  end
-end

data/spec/support_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/support/version'
-
-describe Support do
-  it "should have a version" do
-    subject.const_defined?('VERSION').should == true
-  end
-end

data/spec/templates/classes/example_erb.rb

@@ -1,11 +0,0 @@
-require 'ronin/templates/erb'
-
-class ExampleErb
-
-  include Ronin::Templates::Erb
-
-  attr_accessor :x
-
-  attr_accessor :y
-
-end

data/spec/templates/classes/example_template.rb

@@ -1,35 +0,0 @@
-require 'ronin/templates/template'
-
-class ExampleTemplate
-
-  include Ronin::Templates::Template
-
-  def enter_example_template(&block)
-    enter_template(File.join('templates','example.erb'),&block)
-  end
-
-  def enter_relative_template(&block)
-    enter_template(File.join('templates','example.erb')) do |path|
-      enter_template(File.join('..','includes','_relative.erb'),&block)
-    end
-  end
-
-  def enter_missing_template(&block)
-    enter_template('totally_missing.erb',&block)
-  end
-
-  def read_example_template(&block)
-    read_template(File.join('templates','example.erb'),&block)
-  end
-
-  def read_relative_template(&block)
-    read_template(File.join('templates','example.erb')) do |contents|
-      read_template(File.join('..','includes','_relative.erb'),&block)
-    end
-  end
-
-  def read_missing_template(&block)
-    read_template('totally_missing.erb',&block)
-  end
-
-end