ronin-support 0.4.0.rc1 → 0.4.0.rc2

data/spec/network/http/http_spec.rb

@@ -270,4 +270,197 @@ describe Network::HTTP do
       }.should raise_error(ArgumentError)
     end
   end
+
+  describe "helper methods", :network do
+    let(:host) { 'www.google.com' }
+    let(:port) { 80 }
+    let(:path) { '/' }
+    let(:uri)  { URI::HTTP.build(:host => host, :port => 80, :path => path) }
+
+    subject do
+      obj = Object.new
+      obj.extend described_class
+      obj
+    end
+
+    describe "#http_connect" do
+      it "should create a Net::HTTP session" do
+        http = subject.http_connect(:host => host, :port => port)
+        
+        http.should be_kind_of(Net::HTTP)
+        http.should be_started
+
+        http.finish
+      end
+
+      it "should yield the new Net::HTTP session" do
+        http = nil
+
+        subject.http_connect(:url => uri) do |session|
+          http = session
+        end
+
+        http.should be_kind_of(Net::HTTP)
+      end
+
+      it "should allow yielding the expanded options" do
+        expanded_options = nil
+
+        subject.http_connect(:url => uri) do |session,options|
+          expanded_options = options
+        end
+
+        expanded_options[:host].should == host
+        expanded_options[:port].should == port
+        expanded_options[:path].should == path
+      end
+    end
+
+    describe "#http_session" do
+      it "should start and then finish a Net::HTTP session" do
+        http = nil
+        
+        subject.http_session(:host => host, :port => port) do |session|
+          http = session
+        end
+        
+        http.should be_kind_of(Net::HTTP)
+        http.should_not be_started
+      end
+
+      it "should allow yielding the Net::HTTP session" do
+        http = nil
+
+        subject.http_session(:url => uri) do |session|
+          http = session
+        end
+        
+        http.should be_kind_of(Net::HTTP)
+      end
+
+      it "should allow yielding the expanded options" do
+        expanded_options = nil
+
+        subject.http_session(:url => uri) do |session,options|
+          expanded_options = options
+        end
+
+        expanded_options[:host].should == host
+        expanded_options[:port].should == port
+        expanded_options[:path].should == path
+      end
+    end
+
+    describe "#http_request" do
+      it "should send an arbitrary request and return the response" do
+        response = subject.http_request(:url => uri, :method => :options)
+
+        response.should be_kind_of(Net::HTTPMethodNotAllowed)
+      end
+
+      it "should allow yielding the request" do
+        request = nil
+
+        subject.http_request(:url => uri, :method => :options) do |req|
+          request = req
+        end
+
+        request.should be_kind_of(Net::HTTP::Options)
+      end
+
+      it "should allow yielding the expanded options" do
+        expanded_options = nil
+
+        subject.http_request(:url => uri, :method => :options) do |req,options|
+          expanded_options = options
+        end
+        
+        expanded_options[:host].should == host
+        expanded_options[:port].should == port
+        expanded_options[:path].should == path
+      end
+    end
+
+    describe "#http_status" do
+      it "should return an Integer" do
+        subject.http_status(:url => uri).should be_kind_of(Integer)
+      end
+
+      it "should return the status-code of the Response" do
+        subject.http_status(:url => uri).should == 200
+      end
+    end
+
+    describe "#http_ok?" do
+      it "should check if the Response has code 200" do
+        subject.http_ok?(:url => uri).should == true
+      end
+    end
+
+    describe "#http_server" do
+      let(:url)     { "http://www.php.net/" }
+      let(:headers) { subject.http_get_headers(:url => url) }
+
+      it "should return the 'Server' header" do
+        subject.http_server(:url => url).should == headers['Server']
+      end
+    end
+
+    describe "#http_powered_by" do
+      let(:url)     { "http://www.php.net/" }
+      let(:headers) { subject.http_get_headers(:url => url) }
+
+      it "should return the 'X-Powered-By' header" do
+        subject.http_powered_by(:url => url).should == headers['X-Powered-By']
+      end
+    end
+
+    describe "#http_get_headers" do
+      let(:headers) { subject.http_get_headers(:url => uri) }
+
+      it "should return HTTP Headers" do
+        headers.should_not be_empty
+      end
+
+      it "should format the HTTP Headers accordingly" do
+        format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
+        bad_headers = headers.keys.reject { |name| name =~ format }
+
+        bad_headers.should == []
+      end
+    end
+
+    describe "#http_get_body" do
+      it "should return the response body" do
+        body = subject.http_get_body(:url => uri)
+
+        body.should be_kind_of(String)
+        body.should_not be_empty
+      end
+    end
+
+    describe "#http_post_headers" do
+      let(:headers) { subject.http_post_headers(:url => uri) }
+
+      it "should return HTTP Headers" do
+        headers.should_not be_empty
+      end
+
+      it "should format the HTTP Headers accordingly" do
+        format = /^[A-Z][a-z0-9]*(-[A-Z][a-z0-9]*)*$/
+        bad_headers = headers.keys.reject { |name| name =~ format }
+
+        bad_headers.should == []
+      end
+    end
+
+    describe "#http_post_body" do
+      it "should return the response body" do
+        body = subject.http_post_body(:url => uri)
+
+        body.should be_kind_of(String)
+        body.should_not be_empty
+      end
+    end
+  end
 end

data/spec/network/tcp_spec.rb

@@ -0,0 +1,244 @@
+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_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)
+
+        local_address = socket.local_address
+        local_address.ip_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) }
+
+      it "should connect and then send data" do
+        socket   = subject.tcp_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 host and port" do
+        socket = subject.tcp_connect_and_send(data,host,port,nil,local_port)
+
+        local_address = socket.local_address
+        local_address.ip_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.start_with?('250').should be_true
+
+        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
+        local_address = nil
+
+        subject.tcp_session(host,port,nil,local_port) do |socket|
+          local_address = socket.local_address
+        end
+
+        local_address.ip_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) }
+
+      it "should read the service banner" do
+        banner = subject.tcp_banner(host,port)
+
+        banner.start_with?('220').should be_true
+      end
+
+      it "should bind to a local host and port" do
+        banner = subject.tcp_banner(host,port,nil,local_port)
+
+        banner.start_with?('220').should be_true
+      end
+
+      it "should yield the banner" do
+        banner = nil
+        
+        subject.tcp_banner(host,port) do |yielded_banner|
+          banner = yielded_banner
+        end
+
+        banner.start_with?('220').should be_true
+      end
+    end
+
+    describe "#tcp_send" do
+      let(:server)      { TCPServer.new(server_host,nil) }
+      let(:server_port) { server.local_address.ip_port }
+
+      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_address = client.remote_address
+        client_address.ip_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)
+
+        local_address = server.local_address
+        local_address.ip_address.should == server_ip
+        local_address.ip_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
+        local_address = nil
+        
+        subject.tcp_server_session(server_port,server_host) do |yielded_server|
+          local_address = yielded_server.local_address
+        end
+
+        local_address.ip_address.should == server_ip
+        local_address.ip_port.should    == server_port
+      end
+    end
+
+    describe "#tcp_single_server" do
+      let(:server_port) { 1024 + rand(65535 - 1024) }
+
+      pending "need to automate connecting to the TCPServer"
+    end
+  end
+end

data/spec/network/udp_spec.rb

@@ -0,0 +1,245 @@
+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_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 host and port" do
+        socket        = subject.udp_connect(host,port,nil,local_port)
+
+        local_address = socket.local_address
+        local_address.ip_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 host and port" do
+          socket = subject.udp_connect_and_send(data,host,port,nil,local_port)
+
+          local_address = socket.local_address
+          local_address.ip_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
+        local_address = nil
+
+        subject.udp_session(host,port,nil,local_port) do |socket|
+          local_address = socket.local_address
+        end
+
+        local_address.ip_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,nil)
+        socket
+      end
+      let(:server_port) { server.local_address.ip_port }
+
+      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)
+
+        local_address = server.local_address
+        local_address.ip_address.should == server_ip
+        local_address.ip_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
+        local_address = nil
+        
+        subject.udp_server_session(server_port,server_host) do |yielded_server|
+          local_address = yielded_server.local_address
+        end
+
+        local_address.ip_address.should == server_ip
+        local_address.ip_port.should    == server_port
+      end
+    end
+
+    describe "#udp_single_server" do
+      let(:server_port) { 1024 + rand(65535 - 1024) }
+    end
+  end
+end