ronin-support 0.4.1 → 0.5.2

data/spec/formatting/binary/helpers/hexdumps.rb

@@ -1,16 +0,0 @@
-module Helpers
-  def load_binary_data(name)
-    path = File.join(File.dirname(__FILE__),'hexdumps',"#{name}.bin")
-    buffer = []
-
-    File.open(path) do |file|
-      file.each_byte { |b| buffer << b }
-    end
-
-    return buffer
-  end
-
-  def load_hexdump(name)
-    File.read(File.join(File.dirname(__FILE__),'hexdumps',"#{name}.txt"))
-  end
-end

data/spec/fuzzing/string_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-require 'ronin/fuzzing/extensions/string'
-
-describe String do
-  it "should provide String.generate" do
-    described_class.should respond_to(:generate)
-  end
-
-  it "should provide String#repeating" do
-    subject.should respond_to(:repeating)
-  end
-
-  it "should provide String#fuzz" do
-    subject.should respond_to(:fuzz)
-  end
-
-  it "should provide String#mutate" do
-    subject.should respond_to(:mutate)
-  end
-
-  describe "generate" do
-    subject { described_class }
-
-    it "should generate Strings from CharSets" do
-      strings = subject.generate(:lowercase_hexadecimal, :numeric).to_a
-
-      strings.grep(/^[0-9a-f][0-9]$/).should == strings
-    end
-
-    it "should generate Strings from lengths of CharSets" do
-      strings = subject.generate([:numeric, 2]).to_a
-
-      strings.grep(/^[0-9]{2}$/).should == strings
-    end
-
-    it "should generate Strings from varying lengths of CharSets" do
-      strings = subject.generate([:numeric, 1..2]).to_a
-
-      strings.grep(/^[0-9]{1,2}$/).should == strings
-    end
-
-    it "should generate Strings from custom CharSets" do
-      strings = subject.generate([%w[a b c], 2]).to_a
-
-      strings.grep(/^[abc]{2}$/).should == strings
-    end
-
-    it "should generate Strings containing known Strings" do
-      strings = subject.generate('foo', [%w[a b c], 2]).to_a
-
-      strings.grep(/^foo[abc]{2}$/).should == strings
-    end
-
-    it "should raise a TypeError for non String, Symbol, Enumerable CharSets" do
-      lambda {
-        subject.generate([Object.new, 2]).to_a
-      }.should raise_error(TypeError)
-    end
-
-    it "should raise an ArgumentError for unknown CharSets" do
-      lambda {
-        subject.generate([:foo_bar, 2]).to_a
-      }.should raise_error(ArgumentError)
-    end
-
-    it "should raise a TypeError for non Integer,Array,Range lengths" do
-      lambda {
-        subject.generate([:numeric, 'foo']).to_a
-      }.should raise_error(TypeError)
-    end
-  end
-
-  describe "#repeating" do
-    subject { 'A' }
-
-    context "when n is an Integer" do
-      let(:n) { 100 }
-
-      it "should multiply the String by n" do
-        subject.repeating(n).should == (subject * n)
-      end
-    end
-
-    context "when n is Enumerable" do
-      let(:n) { [128, 512, 1024] }
-
-      it "should repeat the String by each length" do
-        strings = subject.repeating(n).to_a
-
-        strings.should == n.map { |length| subject * length }
-      end
-    end
-  end
-
-  describe "#fuzz" do
-    subject { 'GET /one/two/three' }
-
-    context "matching" do
-      it "should allow Regexps" do
-        fuzzed = subject.fuzz(/GET/ => ['get']).to_a
-
-        fuzzed.should == ['get /one/two/three']
-      end
-
-      it "should allow Strings" do
-        fuzzed = subject.fuzz('GET' => ['get']).to_a
-
-        fuzzed.should == ['get /one/two/three']
-      end
-
-      it "should match Symbols to Regexp constants" do
-        fuzzed = subject.fuzz(:absolute_path => ['../../../..']).to_a
-
-        fuzzed.should == ['GET ../../../..']
-      end
-    end
-
-    context "substitution" do
-      it "should allow Procs" do
-        fuzzed = subject.fuzz('GET' => [lambda { |s| s.downcase }]).to_a
-
-        fuzzed.should == ['get /one/two/three']
-      end
-
-      it "should allow Integers" do
-        fuzzed = subject.fuzz(' ' => [0x09]).to_a
-
-        fuzzed.should == ["GET\t/one/two/three"]
-      end
-
-      it "should map Symbols to Fuzzing methods" do
-        fuzzed = subject.fuzz(/\/.*/ => :format_strings).to_a
-
-        fuzzed.should_not == [subject]
-      end
-
-      it "should incrementally replace each occurrence" do
-        fuzzed = subject.fuzz('/' => ["\n\r"]).to_a
-
-        fuzzed.should == [
-          "GET \n\rone/two/three",
-          "GET /one\n\rtwo/three",
-          "GET /one/two\n\rthree"
-        ]
-      end
-
-      it "should replace each occurrence with each substitution" do
-        fuzzed = subject.fuzz('GET' => ["\n\rGET", "G\n\rET", "GET\n\r"]).to_a
-
-        fuzzed.should == [
-          "\n\rGET /one/two/three",
-          "G\n\rET /one/two/three",
-          "GET\n\r /one/two/three"
-        ]
-      end
-    end
-  end
-end

data/spec/network/tcp_spec.rb

@@ -1,247 +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_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) }
-
-      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)
-        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.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
-        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) }
-
-      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,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_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

@@ -1,248 +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_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_single_server" do
-      let(:server_port) { 1024 + rand(65535 - 1024) }
-    end
-  end
-end