ronin-support 0.4.1 → 0.5.0.rc1

data/spec/network/{tcp_spec.rb → tcp/tcp_spec.rb}

@@ -17,6 +17,29 @@ describe Network::TCP do
       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) }
 
@@ -238,7 +261,7 @@ describe Network::TCP do
       end
     end
 
-    describe "#tcp_single_server" do
+    describe "#tcp_accept" do
       let(:server_port) { 1024 + rand(65535 - 1024) }
 
       pending "need to automate connecting to the TCPServer"

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)
+
+        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_spec.rb → udp/udp_spec.rb}

@@ -17,6 +17,29 @@ describe Network::UDP do
       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) }
 
@@ -241,7 +264,7 @@ describe Network::UDP do
       end
     end
 
-    describe "#udp_single_server" do
+    describe "#udp_recv" do
       let(:server_port) { 1024 + rand(65535 - 1024) }
     end
   end

data/spec/network/unix_spec.rb

@@ -0,0 +1,183 @@
+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/wordlist_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 require 'ronin/wordlist'
 
-require 'tempfile'
+require 'tmpdir'
 
 describe Wordlist do
   let(:words) { %w[foo bar baz] }
+  let(:path)  { File.join(Dir.tmpdir,'ronin-support-wordlist') }
 
   before(:all) do
-    Tempfile.open('ronin-support-wordlist') do |file|
-      words.each { |word| file.puts word }
-
-      @path = file.path
+    File.open(path,'w') do |file|
+      file.puts(*words)
     end
   end
 
@@ -41,28 +40,73 @@ describe Wordlist do
     end
   end
 
+  describe "create" do
+    let(:created_path) { File.join(Dir.tmpdir,'ronin-support-created-wordlist') }
+    let(:text) { words.join(' ') }
+
+    it "should return the new Wordlist object" do
+      wordlist = described_class.create(created_path,text)
+
+      wordlist.to_a.should =~ words
+    end
+
+    it "should create a wordlist file from text" do
+      described_class.create(created_path,text)
+
+      saved_words = File.open(created_path).each_line.map(&:chomp)
+
+      saved_words.should =~ words
+    end
+
+    it "should apply mutations to the created wordlist" do
+      described_class.create(created_path,text, 'o' => ['0'])
+
+      saved_words = File.open(created_path).each_line.map(&:chomp)
+
+      saved_words.should =~ %w[foo f0o fo0 f00 bar baz]
+    end
+
+    after(:all) { FileUtils.rm(created_path) }
+  end
+
   describe "#initialize" do
     it "should accept a list of words" do
-      subject.to_a.should == words
+      wordlist = described_class.new(path)
+
+      wordlist.to_a.should == words
     end
 
     it "should accept a path to a wordlist file" do
-      file = described_class.new(@path)
+      wordlist = described_class.new(path)
 
-      file.to_a.should == words
+      wordlist.to_a.should == words
     end
-  end
 
-  describe "#each_word" do
     it "should raise a TypeError for non-String / non-Enumerable objects" do
-      wordlist = described_class.new(Object.new)
-
       lambda {
-        wordlist.each_word { |word| }
+        described_class.new(Object.new)
       }.should raise_error(TypeError)
     end
   end
 
+  describe "#each_word" do
+    context "with wordlist file" do
+      subject { described_class.new(path) }
+
+      it "should enumerate over the words" do
+        subject.each_word.to_a.should == words
+      end
+    end
+
+    context "with words" do
+      subject { described_class.new(words) }
+
+      it "should enumerate over the words" do
+        subject.each_word.to_a.should == words
+      end
+    end
+  end
+
   describe "#each" do
     it "should rewind file lists" do
       subject.each { |word| }
@@ -87,4 +131,21 @@ describe Wordlist do
       ]
     end
   end
+
+  describe "#save" do
+    let(:saved_path) { File.join(Dir.tmpdir,'ronin-support-saved-wordlist') }
+
+    it "should save the words with mutations to a file" do
+      subject.save(saved_path)
+
+      saved_words    = File.open(saved_path).each_line.map(&:chomp)
+      expected_words = subject.to_a
+
+      saved_words.should == expected_words
+    end
+
+    after(:all) { FileUtils.rm(saved_path) }
+  end
+
+  after(:all) { FileUtils.rm(path) }
 end