ronin-support 0.5.1 → 1.0.0.beta1

data/spec/network/proxy_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/proxy'
-
-describe Network::Proxy do
-  let(:port)  { 1337              }
-  let(:host)  { '127.0.0.1'       }
-  let(:server_host) { 'www.example.com' }
-  let(:server_port) { 80                }
-
-  let(:proxy) do
-    described_class.new(
-      :port   => port,
-      :host   => host,
-      :server => [server_host, server_port]
-    )
-  end
-
-  subject { proxy }
-
-  describe "#initialize" do
-    it "should default host to '0.0.0.0'" do
-      proxy = described_class.new(
-        :port   => port,
-        :server => [server_host, server_port]
-      )
-
-      proxy.port.should == port
-      proxy.host.should == '0.0.0.0'
-    end
-
-    it "should allow setting both the host and port" do
-      proxy = described_class.new(
-        :port   => port,
-        :host   => host,
-        :server => [server_host, server_port]
-      )
-
-      proxy.port.should == port
-      proxy.host.should == host
-    end
-
-    it "should set the server_host and server_port" do
-      proxy = described_class.new(
-        :port   => port,
-        :host   => host,
-        :server => [server_host, server_port]
-      )
-
-      proxy.server_host.should == server_host
-      proxy.server_port.should == server_port
-    end
-  end
-
-  describe "#on_data" do
-    it "should call on_client_data" do
-      subject.should_receive(:on_client_data)
-
-      subject.on_data { |client,server,data| }
-    end
-
-    it "should call on_server_data" do
-      subject.should_receive(:on_server_data)
-
-      subject.on_data { |client,server,data| }
-    end
-  end
-
-  describe "actions" do
-    describe "#ignore!" do
-      it "should throw the :ignore action" do
-        lambda {
-          subject.ignore!
-        }.should throw_symbol(:action, :ignore)
-      end
-    end
-
-    describe "#close!" do
-      it "should throw the :close action" do
-        lambda {
-          subject.close!
-        }.should throw_symbol(:action, :close)
-      end
-    end
-
-    describe "#reset!" do
-      it "should throw the :reset action" do
-        lambda {
-          subject.reset!
-        }.should throw_symbol(:action, :reset)
-      end
-    end
-
-    describe "#stop!" do
-      it "should throw the :stop action" do
-        lambda {
-          subject.stop!
-        }.should throw_symbol(:action, :stop)
-      end
-    end
-  end
-
-  describe "#to_s" do
-    subject { proxy.to_s }
-
-    it "should include the proxy host and port" do
-      subject.should include("#{host}:#{port}")
-    end
-
-    it "should include the server host and port" do
-      subject.should include("#{server_host}:#{server_port}")
-    end
-  end
-
-  describe "#inspect" do
-    subject { proxy.inspect }
-
-    it "should include the output of #to_s" do
-      subject.should include(proxy.to_s)
-    end
-  end
-end

data/spec/network/shared/unix_server.rb

@@ -1,31 +0,0 @@
-require 'rspec'
-
-require 'tmpdir'
-require 'fileutils'
-require 'socket'
-
-shared_context "UNIX Server" do
-  def socket_path(name); File.join(Dir.tmpdir,name); end
-
-  let(:path) { socket_path('ronin_unix_server') }
-
-  before(:each) do
-    @server = UNIXServer.new(path)
-    @server_thread = Thread.new do
-      socket = @server.accept
-
-      begin
-        socket.puts socket.readline
-      ensure
-        socket.close
-      end
-    end
-  end
-
-  after(:each) do
-    @server_thread.kill
-    @server.close
-
-    FileUtils.rm(path)
-  end
-end

data/spec/network/smtp/email_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/smtp/email'
-
-require 'date'
-
-describe Network::SMTP::Email do
-  describe "#initialize" do
-    it "should default 'date' to Time.now" do
-      email = Network::SMTP::Email.new
-
-      email.date.should_not be_nil
-    end
-
-    it "should accept a String body" do
-      body = 'hello'
-      email = Network::SMTP::Email.new(:body => body)
-
-      email.body.should == [body]
-    end
-
-    it "should accept an Array body" do
-      body = ['hello', 'world']
-      email = Network::SMTP::Email.new(:body => body)
-
-      email.body.should == body
-    end
-
-    it "should default 'body' to an empty Array" do
-      email = Network::SMTP::Email.new
-
-      email.body.should be_empty
-    end
-  end
-
-  describe "#to_s" do
-    subject { Network::SMTP::Email.new }
-
-    it "should add the 'from'" do
-      subject.from = 'joe@example.com'
-
-      subject.to_s.should include("From: joe@example.com\n\r")
-    end
-
-    context "when formatting 'to'" do
-      it "should accept an Array of addresses" do
-        subject.to = ['alice@example.com', 'joe@example.com']
-
-        subject.to_s.should include("To: alice@example.com, joe@example.com\n\r")
-      end
-
-      it "should accept a String" do
-        subject.to = 'joe@example.com'
-
-        subject.to_s.should include("To: joe@example.com\n\r")
-      end
-    end
-
-    it "should add the 'subject'" do
-      subject.subject = 'Hello'
-
-      subject.to_s.should include("Subject: Hello\n\r")
-    end
-
-    it "should add the 'date'" do
-      subject.date = Date.parse('Sun Apr 24 17:22:55 PDT 2011')
-
-      subject.to_s.should include("Date: #{subject.date}\n\r")
-    end
-
-    it "should add the 'message_id'" do
-      subject.message_id = '1234'
-
-      subject.to_s.should include("Message-Id: <#{subject.message_id}>\n\r")
-    end
-
-    it "should add additional headers" do
-      subject.headers['X-Foo'] = 'Bar'
-      subject.headers['X-Baz'] = 'Quix'
-
-      lines = subject.to_s.split("\n\r")
-      
-      lines.should include('X-Foo: Bar')
-      lines.should include('X-Baz: Quix')
-    end
-
-    context "when formatting 'body'" do
-      it "should append each line with a CRLF" do
-        subject.body = ['hello', 'world']
-
-        subject.to_s.should include("hello\n\rworld")
-      end
-
-      it "should add a CRLF before the body" do
-        subject.body = ['hello', 'world']
-
-        subject.to_s.should include("\n\rhello")
-      end
-    end
-  end
-end

data/spec/network/ssl_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/ssl'
-
-describe Network::SSL do
-  describe 'VERIFY' do
-    subject { Network::SSL::VERIFY }
-
-    it "should map verify mode names to OpenSSL VERIFY_* constants" do
-      subject[:peer].should == OpenSSL::SSL::VERIFY_PEER
-    end
-
-    it "should default to VERIFY_NONE if no verify mode name is given" do
-      subject[nil].should == OpenSSL::SSL::VERIFY_NONE
-    end
-
-    it "should raise an exception for unknown verify modes" do
-      lambda { subject[:foo_bar] }.should raise_error
-    end
-  end
-
-  describe "helpers", :network do
-    let(:host) { 'github.com' }
-    let(:port) { 443 }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#ssl_connect" do
-      it "should connect to an SSL protected port" do
-        lambda {
-          subject.ssl_connect(host,port)
-        }.should_not raise_error(OpenSSL::SSL::SSLError)
-      end
-
-      it "should return an OpenSSL::SSL::SSLSocket" do
-        socket = subject.ssl_connect(host,port)
-
-        socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
-      end
-
-      context "when a block is given" do
-        it "should yield the OpenSSL::SSL::SSLSocket" do
-          socket = nil
-
-          subject.ssl_connect(host,port) do |yielded_socket|
-            socket = yielded_socket
-          end
-
-          socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
-        end
-      end
-    end
-
-    describe "#ssl_session" do
-      it "should open then close a OpenSSL::SSL::SSLSocket" do
-        socket = nil
-
-        subject.ssl_session(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should be_kind_of(OpenSSL::SSL::SSLSocket)
-        socket.should be_closed
-      end
-    end
-  end
-end

data/spec/network/tcp/proxy_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/tcp/proxy'
-
-describe Network::TCP::Proxy, :network => true do
-  let(:port)   { 1337                    }
-  let(:host)   { 'localhost'             }
-  let(:server) { ['www.example.com', 80] }
-
-  before(:each) do
-    @proxy  = described_class.new(
-      :port   => port,
-      :host   => host,
-      :server => server
-    )
-    @thread = Thread.new { @proxy.start }
-
-    sleep 0.1
-  end
-
-  describe "#on_client_connect" do
-    let(:injection) { "Client connected\r\n" }
-
-    before do
-      @proxy.on_client_connect do |client|
-        client.write(injection)
-      end
-
-      @socket = TCPSocket.new(host,port)
-    end
-
-    it "should trigger when a new client connects" do
-      @socket.readline.should == injection
-    end
-
-    after { @socket.close }
-  end
-
-  describe "#on_server_connect" do
-    let(:injection) { "Server connected\r\n" }
-
-    before do
-      @proxy.on_server_connect do |client,server|
-        client.write(injection)
-      end
-
-      @socket = TCPSocket.new(host,port)
-    end
-
-    it "should trigger after a new client connects" do
-      @socket.readline.should == injection
-    end
-
-    after { @socket.close }
-  end
-
-  describe "#on_client_data" do
-    before do
-      @proxy.on_client_data do |client,server,data|
-        data.gsub!(/HTTP\/1.1/,'HTTP/1.0')
-      end
-
-      @socket = TCPSocket.new(host,port)
-    end
-
-    it "should trigger when the client sends data" do
-      @socket.write("GET / HTTP/1.1\r\n\r\n")
-
-      @socket.readline.should == "HTTP/1.0 302 Found\r\n"
-    end
-
-    after { @socket.close }
-  end
-
-  describe "#on_server_data" do
-    before do
-      @proxy.on_server_data do |client,server,data|
-        data.gsub!(/Connection: \S+/,'Connection: keep-alive')
-      end
-
-      @socket = TCPSocket.new(host,port)
-    end
-
-    it "should trigger when the server sends data" do
-      @socket.write("GET / HTTP/1.0\r\n\r\n")
-
-      @socket.read.should include("Connection: keep-alive\r\n")
-    end
-
-    after { @socket.close }
-  end
-
-  describe "#on_server_disconnect" do
-    let(:injection) { "Haha Internet!\r\n" }
-
-    before do
-      @proxy.on_server_disconnect do |client,server|
-        client.write(injection)
-      end
-
-      @socket = TCPSocket.new(host,port)
-    end
-
-    it "should trigger when the server closes the connection" do
-      @socket.write("GET / HTTP/1.0\r\n\r\n")
-
-      @socket.read.end_with?(injection).should be_true
-    end
-
-    after { @socket.close }
-  end
-
-  after(:each) do
-    @thread.kill
-    @proxy.close
-  end
-end

data/spec/network/tcp/tcp_spec.rb

@@ -1,273 +0,0 @@
-require 'spec_helper'
-require 'ronin/network/tcp'
-
-require 'resolv'
-
-describe Network::TCP do
-  describe "helper methods", :network do
-    let(:host) { 'smtp.gmail.com' }
-    let(:port) { 25 }
-
-    let(:server_host) { 'localhost' }
-    let(:server_ip)   { Resolv.getaddress(server_host) }
-
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#tcp_open?" do
-      let(:host) { 'example.com' }
-      let(:port) { 80 }
-
-      it "should return true for open ports" do
-        subject.tcp_open?(host,port).should == true
-      end
-
-      it "should return false for closed ports" do
-        subject.tcp_open?('localhost',rand(1024) + 1).should == false
-      end
-
-      it "should have a timeout for firewalled ports" do
-        timeout = 2
-
-        t1 = Time.now
-        subject.tcp_open?(host,1337,nil,nil,timeout)
-        t2 = Time.now
-
-        (t2 - t1).to_i.should <= timeout
-      end
-    end
-
-    describe "#tcp_connect" do
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      it "should open a TCPSocket" do
-        socket = subject.tcp_connect(host,port)
-
-        socket.should be_kind_of(TCPSocket)
-        socket.should_not be_closed
-
-        socket.close
-      end
-
-      it "should bind to a local host and port" do
-        socket     = subject.tcp_connect(host,port,nil,local_port)
-        bound_port = socket.addr[1]
-
-        bound_port.should == local_port
-
-        socket.close
-      end
-
-      it "should yield the new TCPSocket" do
-        socket = nil
-
-        subject.tcp_connect(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should_not be_closed
-        socket.close
-      end
-    end
-
-    describe "#tcp_connect_and_send" do
-      let(:data) { "HELO ronin\n" }
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      let(:expected_response) { "250 mx.google.com at your service\r\n" }
-
-      it "should connect and then send data" do
-        socket   = subject.tcp_connect_and_send(data,host,port)
-        banner   = socket.readline
-        response = socket.readline
-
-        response.should == expected_response
-
-        socket.close
-       end
-
-      it "should bind to a local host and port" do
-        socket     = subject.tcp_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 TCPSocket" do
-        response = nil
-
-        socket = subject.tcp_connect_and_send(data,host,port) do |socket|
-          banner   = socket.readline
-          response = socket.readline
-        end
-
-        response.should == expected_response
-
-        socket.close
-      end
-    end
-
-    describe "#tcp_session" do
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      it "should open then close a TCPSocket" do
-        socket = nil
-
-        subject.tcp_session(host,port) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        socket.should be_kind_of(TCPSocket)
-        socket.should be_closed
-      end
-
-      it "should bind to a local host and port" do
-        bound_port = nil
-
-        subject.tcp_session(host,port,nil,local_port) do |socket|
-          bound_port = socket.addr[1]
-        end
-
-        bound_port.should == local_port
-      end
-    end
-
-    describe "#tcp_banner" do
-      let(:host)       { 'smtp.gmail.com' }
-      let(:port)       { 25 }
-      let(:local_port) { 1024 + rand(65535 - 1024) }
-
-      let(:expected_banner) { /^220 mx\.google\.com ESMTP/ }
-
-      it "should return the read service banner" do
-        banner = subject.tcp_banner(host,port)
-
-        banner.should =~ expected_banner
-      end
-
-      it "should bind to a local host and port" do
-        banner = subject.tcp_banner(host,port,nil,local_port)
-
-        banner.should =~ expected_banner
-      end
-
-      it "should yield the banner" do
-        banner = nil
-        
-        subject.tcp_banner(host,port) do |yielded_banner|
-          banner = yielded_banner
-        end
-
-        banner.should =~ expected_banner
-      end
-    end
-
-    describe "#tcp_send" do
-      let(:server)      { TCPServer.new(server_host,0) }
-      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.tcp_send(data,server_host,server_port)
-
-        client = server.accept
-        sent   = client.readline
-
-        client.close
-
-        sent.should == data
-      end
-
-      it "should bind to a local host and port" do
-        subject.tcp_send(data,server_host,server_port,nil,local_port)
-
-        client      = server.accept
-        client_port = client.peeraddr[1]
-
-        client_port.should == local_port
-
-        client.close
-      end
-    end
-
-    describe "#tcp_server" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
-      it "should create a new TCPServer" do
-        server = subject.tcp_server
-
-        server.should be_kind_of(TCPServer)
-        server.should_not be_closed
-
-        server.close
-      end
-
-      it "should bind to a specific port and host" do
-        server     = subject.tcp_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 TCPServer" do
-        server = nil
-        
-        subject.tcp_server do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(TCPServer)
-        server.should_not be_closed
-
-        server.close
-      end
-    end
-
-    describe "#tcp_server_session" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
-      it "should create a temporary TCPServer" do
-        server = nil
-        
-        subject.tcp_server_session do |yielded_server|
-          server = yielded_server
-        end
-
-        server.should be_kind_of(TCPServer)
-        server.should be_closed
-      end
-
-      it "should bind to a specific port and host" do
-        bound_host = nil
-        bound_port = nil
-        
-        subject.tcp_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 "#tcp_accept" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-
-      pending "need to automate connecting to the TCPServer"
-    end
-  end
-end