ruby-nikto 0.1.0

data/spec/xml/scan_details_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'nikto/xml/scan_details'
+require 'nokogiri'
+
+describe Nikto::XML::ScanDetails do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'..','fixtures')) }
+  let(:path) { File.join(fixtures_dir,'nikto.xml') }
+  let(:xml)  { File.read(path) }
+  let(:doc)  { Nokogiri::XML(File.open(path)) }
+  let(:node) { doc.at_xpath('/niktoscan/scandetails') }
+
+  subject { described_class.new(node) }
+
+  describe "#target_ip" do
+    subject { super().target_ip }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'targetip' attribute" do
+      expect(subject).to eq(node['targetip'])
+    end
+  end
+
+  describe "#target_hostname" do
+    subject { super().target_hostname }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'targethostname' attribute" do
+      expect(subject).to eq(node['targethostname'])
+    end
+  end
+
+  describe "#target_port" do
+    subject { super().target_port }
+
+    it "must return the 'targetport' attribute as an Integer" do
+      expect(subject).to eq(node['targetport'].to_i)
+    end
+
+    it "must be > 0" do
+      expect(subject).to be > 0
+    end
+  end
+
+  describe "#target_banner" do
+    subject { super().target_banner }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'targetbanner' attribute" do
+      expect(subject).to eq(node['targetbanner'])
+    end
+  end
+
+  describe "#start_time" do
+    subject { super().start_time }
+
+    it "must return the 'starttime' attribute as a Time object" do
+      expect(subject).to eq(Time.parse(node['starttime']))
+    end
+  end
+
+  describe "#site_name" do
+    subject { super().site_name }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'sitename' attribute" do
+      expect(subject).to eq(node['sitename'])
+    end
+  end
+
+  describe "#site_ip" do
+    subject { super().site_ip }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'siteip' attribute" do
+      expect(subject).to eq(node['siteip'])
+    end
+  end
+
+  describe "#host_header" do
+    subject { super().host_header }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'hostheader' attribute" do
+      expect(subject).to eq(node['hostheader'])
+    end
+  end
+
+  describe "#errors" do
+    subject { super().errors }
+
+    it "must return the 'errors' attribute as an Integer" do
+      expect(subject).to eq(node['errors'].to_i)
+    end
+  end
+
+  describe "#errors?" do
+    context "when #errors is 0" do
+      before { allow(subject).to receive(:errors).and_return(0) }
+
+      it "must return false" do
+        expect(subject.errors?).to be(false)
+      end
+    end
+
+    context "when #errors is greater than 0" do
+      before { allow(subject).to receive(:errors).and_return(1) }
+
+      it "must return true" do
+        expect(subject.errors?).to be(true)
+      end
+    end
+  end
+
+  describe "#checks" do
+    subject { super().checks }
+
+    it "must return the 'checks' attribute as an Integer" do
+      expect(subject).to eq(node['checks'].to_i)
+    end
+
+    it "must be > 0" do
+      expect(subject).to be > 0
+    end
+  end
+
+  let(:item_count) { node.xpath('item').count }
+
+  describe "#each_item" do
+    context "when given a block" do
+      it "must yield each Item object" do
+        expect { |b|
+          subject.each_item(&b)
+        }.to yield_successive_args(*Array.new(item_count,Nikto::XML::Item))
+      end
+    end
+
+    context "when no block is given" do
+      subject { super().each_item.to_a }
+
+      it "must return an Enumerator of Nikto::XML::Item objects" do
+        expect(subject.length).to be(item_count)
+        expect(subject).to all(be_kind_of(Nikto::XML::Item))
+      end
+    end
+  end
+
+  describe "#items" do
+    subject { super().items}
+
+    it "must return an Array of Nikto::XML::ScanDetails" do
+      expect(subject.length).to be(item_count)
+      expect(subject).to all(be_kind_of(Nikto::XML::Item))
+    end
+  end
+
+  describe "#statistics" do
+    subject { super().statistics }
+
+    it "must return a Statistics object" do
+      expect(subject).to be_kind_of(Nikto::XML::Statistics)
+    end
+  end
+end

data/spec/xml/statistics_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'nikto/xml/statistics'
+require 'nokogiri'
+
+describe Nikto::XML::Statistics do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'..','fixtures')) }
+  let(:path) { File.join(fixtures_dir,'nikto.xml') }
+  let(:xml)  { File.read(path) }
+  let(:doc)  { Nokogiri::XML(File.open(path)) }
+  let(:node) { doc.at_xpath('/niktoscan/scandetails/statistics') }
+
+  subject { described_class.new(node) }
+
+  describe "#elapsed" do
+    subject { super().elapsed }
+
+    it "must return the 'elapsed' attribute as an Integer" do
+      expect(subject).to eq(node['elapsed'].to_i)
+    end
+
+    it "must be greater than 0" do
+      expect(subject).to be > 0
+    end
+  end
+
+  describe "#items_found" do
+    subject { super().items_found }
+
+    it "must return the 'itemsfound' attribute as an Integer" do
+      expect(subject).to eq(node['itemsfound'].to_i)
+    end
+
+    it "must be greater than 0" do
+      expect(subject).to be > 0
+    end
+  end
+
+  describe "#items_tested" do
+    subject { super().items_tested }
+
+    it "must return the 'itemstested' attribute as an Integer" do
+      expect(subject).to eq(node['itemstested'].to_i)
+    end
+
+    it "must be greater than 0" do
+      expect(subject).to be > 0
+    end
+  end
+
+  describe "#end_time" do
+    subject { super().end_time }
+
+    it "must return the 'endtime' attribute as a Time object" do
+      expect(subject).to eq(Time.parse(node['endtime']))
+    end
+  end
+end

data/spec/xml_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+require 'nikto/xml'
+
+describe Nikto::XML do
+  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
+  let(:path) { File.join(fixtures_dir,'nikto.xml') }
+  let(:xml) { File.read(path) }
+  let(:doc) { Nokogiri::XML(File.open(path)) }
+
+  subject { described_class.new(doc, path: path) }
+
+  describe "#initialize" do
+    it "must set #doc" do
+      expect(subject.doc).to eq(doc)
+    end
+
+    context "when given a block" do
+      it "must yield the new XML object" do
+        expect { |b|
+          described_class.new(xml,&b)
+        }.to yield_with_args(described_class)
+      end
+    end
+
+    context "when the path: keyword argument is not given" do
+      subject { described_class.new(xml) }
+
+      it "must set #path to nil" do
+        expect(subject.path).to be(nil)
+      end
+    end
+
+    context "when the path: keyword argument is given" do
+      subject { described_class.new(xml, path: path) }
+
+      it "must set #path" do
+        expect(subject.path).to eq(path)
+      end
+    end
+  end
+
+  describe ".parse" do
+    subject { described_class.parse(xml) }
+
+    it "must parse the XML data" do
+      expect(subject.doc).to be_kind_of(Nokogiri::XML::Document)
+    end
+
+    it "must set #path to nil" do
+      expect(subject.path).to be(nil)
+    end
+  end
+
+  describe ".open" do
+    subject { described_class.open(path) }
+
+    it "must open the file and parse the XML" do
+      expect(subject.doc).to be_kind_of(Nokogiri::XML::Document)
+    end
+
+    it "must set #path" do
+      expect(subject.path).to eq(path)
+    end
+  end
+
+  describe "#hosts_test" do
+    subject { super().hosts_test }
+
+    it "must return the 'hoststest' attribute as an Integer" do
+      expect(subject).to eq(doc.root['hoststest'].to_i)
+    end
+  end
+
+  describe "#options" do
+    subject { super().options }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'options' attribute" do
+      expect(subject).to eq(doc.root['options'])
+    end
+  end
+
+  describe "#scan_start" do
+    subject { super().scan_start }
+
+    it "must return the 'scanstart' attribute as a Time object" do
+      expect(subject).to eq(Time.parse(doc.root['scanstart']))
+    end
+  end
+
+  describe "#scan_end" do
+    subject { super().scan_end }
+
+    it "must return the 'scanend' attribute as a Time object" do
+      expect(subject).to eq(Time.parse(doc.root['scanend']))
+    end
+  end
+
+  describe "#scan_elapsed" do
+    subject { super().scan_elapsed }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'scanelapsed' attribute" do
+      expect(subject).to eq(doc.root['scanelapsed'])
+    end
+  end
+
+  describe "#nikto_xml_version" do
+    subject { super().nikto_xml_version }
+
+    it "must return a String" do
+      expect(subject).to be_kind_of(String)
+    end
+
+    it "must return the 'nxmlversion' attribute" do
+      expect(subject).to eq(doc.root['nxmlversion'])
+    end
+  end
+
+  describe "#each_scan_details" do
+    context "when given a block" do
+      it "must yield each ScanDetails object" do
+        expect { |b|
+          subject.each_scan_details(&b)
+        }.to yield_successive_args(described_class::ScanDetails)
+      end
+    end
+
+    context "when no block is given" do
+      subject { super().each_scan_details.to_a }
+
+      it "must return an Enumerator of #{described_class}::ScanDetails objects" do
+        expect(subject.length).to be(1)
+        expect(subject[0]).to be_kind_of(described_class::ScanDetails)
+      end
+    end
+  end
+
+  describe "#scan_details" do
+    subject { super().scan_details }
+
+    it "must return an Array of #{described_class}::ScanDetails" do
+      expect(subject).to be_kind_of(Array)
+      expect(subject.length).to be(1)
+      expect(subject[0]).to be_kind_of(described_class::ScanDetails)
+    end
+  end
+
+  describe "#target" do
+    let(:first_scan_details) { subject.scan_details.first }
+    let(:target)             { subject.target             }
+
+    it "must return the first #scan_details" do
+      expect(target.target_ip).to eq(first_scan_details.target_ip)
+      expect(target.target_hostname).to eq(first_scan_details.target_hostname)
+      expect(target.target_port).to eq(first_scan_details.target_port)
+      expect(target.target_banner).to eq(first_scan_details.target_banner)
+      expect(target.start_time).to eq(first_scan_details.start_time)
+      expect(target.site_name).to eq(first_scan_details.site_name)
+      expect(target.site_ip).to eq(first_scan_details.site_ip)
+      expect(target.host_header).to eq(first_scan_details.host_header)
+      expect(target.errors).to eq(first_scan_details.errors)
+      expect(target.checks).to eq(first_scan_details.checks)
+    end
+  end
+
+  describe "#to_s" do
+    context "when #path is set" do
+      subject { described_class.open(path) }
+
+      it "must return the #path" do
+        expect(subject.to_s).to eq(path)
+      end
+    end
+
+    context "when #path is nil" do
+      subject { described_class.parse(xml) }
+
+      it "must return the XML" do
+        expect(subject.to_s).to eq(doc.to_s)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: ruby-nikto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Postmodern
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: command_mapper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A Ruby interface to Nikto, the Web Server scanner.
+email: postmodern.mod3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".editorconfig"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".specopts"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- lib/nikto.rb
+- lib/nikto/command.rb
+- lib/nikto/version.rb
+- lib/nikto/xml.rb
+- lib/nikto/xml/item.rb
+- lib/nikto/xml/scan_details.rb
+- lib/nikto/xml/statistics.rb
+- ruby-nikto.gemspec
+- spec/command_spec.rb
+- spec/fixtures/nikto.xml
+- spec/nikto_spec.rb
+- spec/spec_helper.rb
+- spec/xml/item_spec.rb
+- spec/xml/scan_details_spec.rb
+- spec/xml/statistics_spec.rb
+- spec/xml_spec.rb
+homepage: http://github.com/sophsec/ruby-nikto
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://rubydoc.info/gems/ruby-nikto
+  source_code_uri: https://github.com/postmodern/ruby-nikto
+  bug_tracker_uri: https://github.com/postmodern/ruby-nikto/issues
+  changelog_uri: https://github.com/postmodern/ruby-nikto/blob/master/ChangeLog.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- nikto >= 2.1.0
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A Ruby interface to Nikto.
+test_files: []