ronin-support 0.4.1 → 0.5.2

data/spec/network/tcp/proxy_spec.rb

@@ -0,0 +1,118 @@
+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
+      expect(@socket.readline).to eq(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
+      expect(@socket.readline).to eq(injection)
+    end
+
+    after { @socket.close }
+  end
+
+  describe "#on_client_data" do
+    before do
+      @proxy.on_client_data do |client,server,data|
+        if (match = data.match(/HTTP\/(\d\.\d)/))
+          client.write("HTTP #{match[1]} detected!\r\n")
+        end
+      end
+
+      @socket = TCPSocket.new(host,port)
+    end
+
+    it "should trigger when the client sends data" do
+      @socket.write("GET /placeholder HTTP/1.0\r\n\r\n")
+
+      expect(@socket.readline).to eq("HTTP 1.0 detected!\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")
+
+      expect(@socket.read).to 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")
+
+      expect(@socket.read.end_with?(injection)).to be(true)
+    end
+
+    after { @socket.close }
+  end
+
+  after(:each) do
+    @thread.kill
+    @proxy.close
+  end
+end

data/spec/network/tcp/tcp_spec.rb

@@ -0,0 +1,316 @@
+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) { 587 }
+
+    subject do
+      obj = Object.new
+      obj.extend described_class
+      obj
+    end
+
+    shared_examples "TCP Server" do
+      let(:server_host) { 'localhost' }
+      let(:server_port) { 1024 + rand(65535 - 1024) }
+      let(:server_ip)   { Resolv.getaddress(server_host) }
+      let(:server) { TCPServer.new(server_host,server_port) }
+      let(:server_bind_ip)   { server.addr[3] }
+      let(:server_bind_port) { server.addr[1] }
+
+      before(:each) { server.listen(1) }
+      after(:each)  { server.close }
+    end
+
+    describe "#tcp_open?" do
+      include_examples "TCP Server"
+
+      let(:host) { server_bind_ip }
+      let(:port) { server_bind_port }
+
+      it "should return true for open ports" do
+        expect(subject.tcp_open?(host,port)).to be(true)
+      end
+
+      let(:closed_port) { port + 1 }
+
+      it "should return false for closed ports" do
+        expect(subject.tcp_open?(host,closed_port)).to be(false)
+      end
+
+      context "when given a timeout" do
+        it "should have a timeout for firewalled ports" do
+          timeout = 2
+
+          t1 = Time.now
+          subject.tcp_open?(host,port+1,nil,nil,timeout)
+          t2 = Time.now
+
+          expect((t2 - t1).to_i).to be <= timeout
+        end
+      end
+    end
+
+    describe "#tcp_connect" do
+      let(:host) { 'example.com' }
+      let(:port) { 80 }
+
+      it "should open a TCPSocket" do
+        socket = subject.tcp_connect(host,port)
+
+        expect(socket).to be_kind_of(TCPSocket)
+        expect(socket).not_to be_closed
+
+        socket.close
+      end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a local host and port" do
+          socket     = subject.tcp_connect(host,port,nil,local_port)
+          bound_port = socket.addr[1]
+
+          expect(bound_port).to eq(local_port)
+
+          socket.close
+        end
+      end
+
+      context "when given a block" do
+        it "should yield the new TCPSocket" do
+          socket = nil
+
+          subject.tcp_connect(host,port) do |yielded_socket|
+            socket = yielded_socket
+          end
+
+          expect(socket).not_to be_closed
+          socket.close
+        end
+      end
+    end
+
+    describe "#tcp_connect_and_send" do
+      let(:data) { "HELO ronin-support\n" }
+
+      let(:expected_response) { "250 #{host} 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
+
+        expect(response).to eq(expected_response)
+
+        socket.close
+       end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        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]
+
+          expect(bound_port).to eq(local_port)
+
+          socket.close
+        end
+      end
+
+      context "when given a block" do
+        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
+
+          expect(response).to eq(expected_response)
+
+          socket.close
+        end
+      end
+    end
+
+    describe "#tcp_session" do
+      it "should open then close a TCPSocket" do
+        socket = nil
+
+        subject.tcp_session(host,port) do |yielded_socket|
+          socket = yielded_socket
+        end
+
+        expect(socket).to be_kind_of(TCPSocket)
+        expect(socket).to be_closed
+      end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        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
+
+          expect(bound_port).to eq(local_port)
+        end
+      end
+    end
+
+    describe "#tcp_banner" do
+      let(:host)       { 'smtp.gmail.com' }
+      let(:port)       { 587 }
+
+      let(:expected_banner) { /^220 #{Regexp.escape(host)} ESMTP [^\s]+ - gsmtp$/ }
+
+      it "should return the read service banner" do
+        banner = subject.tcp_banner(host,port)
+
+        expect(banner).to match(expected_banner)
+      end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a local host and port" do
+          banner = subject.tcp_banner(host,port,nil,local_port)
+
+          expect(banner).to match(expected_banner)
+        end
+      end
+
+      context "when given a block" do
+        it "should yield the banner" do
+          banner = nil
+
+          subject.tcp_banner(host,port) do |yielded_banner|
+            banner = yielded_banner
+          end
+
+          expect(banner).to match(expected_banner)
+        end
+      end
+    end
+
+    let(:local_host) { 'localhost' }
+    let(:local_ip)   { Resolv.getaddress(local_host) }
+
+    describe "#tcp_send" do
+      include_context "TCP Server"
+
+      let(:data) { "hello\n" }
+
+      it "should send data to a service" do
+        subject.tcp_send(data,server_bind_ip,server_bind_port)
+
+        client = server.accept
+        sent   = client.readline
+
+        client.close
+
+        expect(sent).to eq(data)
+      end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a local host and port" do
+          subject.tcp_send(data,server_bind_ip,server_bind_port,server_bind_ip,local_port)
+
+          client      = server.accept
+          client_port = client.peeraddr[1]
+
+          expect(client_port).to eq(local_port)
+
+          client.close
+        end
+      end
+    end
+
+    describe "#tcp_server" do
+      it "should create a new TCPServer" do
+        server = subject.tcp_server
+
+        expect(server).to be_kind_of(TCPServer)
+        expect(server).not_to be_closed
+
+        server.close
+      end
+
+      context "when given a local host and port" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a specific port and host" do
+          server     = subject.tcp_server(local_port,local_host)
+          bound_host = server.addr[3]
+          bound_port = server.addr[1]
+
+          expect(bound_host).to eq(local_ip)
+          expect(bound_port).to eq(local_port)
+
+          server.close
+        end
+      end
+
+      context "when given a block" do
+        it "should yield the new TCPServer" do
+          server = nil
+
+          subject.tcp_server do |yielded_server|
+            server = yielded_server
+          end
+
+          expect(server).to be_kind_of(TCPServer)
+          expect(server).not_to be_closed
+
+          server.close
+        end
+      end
+    end
+
+    describe "#tcp_server_session" do
+      it "should create a temporary TCPServer" do
+        server = nil
+        
+        subject.tcp_server_session do |yielded_server|
+          server = yielded_server
+        end
+
+        expect(server).to be_kind_of(TCPServer)
+        expect(server).to be_closed
+      end
+
+      context "when given a block" do
+        let(:local_port) { 1024 + rand(65535 - 1024) }
+
+        it "should bind to a specific port and host" do
+          bound_host = nil
+          bound_port = nil
+
+          subject.tcp_server_session(local_port,local_host) do |server|
+            bound_host = server.addr[3]
+            bound_port = server.addr[1]
+          end
+
+          expect(bound_host).to eq(local_ip)
+          expect(bound_port).to eq(local_port)
+        end
+      end
+    end
+
+    describe "#tcp_accept" do
+      let(:server_port) { 1024 + rand(65535 - 1024) }
+
+      pending "need to automate connecting to the TCPServer"
+    end
+  end
+end

data/spec/network/telnet_spec.rb

@@ -0,0 +1,67 @@
+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)
+
+        expect(telnet).to 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
+
+          expect(telnet).to 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
+
+        expect(yielded_telnet).to 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
+
+        expect(was_open).to be(true)
+        expect(session.sock).to be_closed
+      end
+    end
+  end
+end