ruby-masscan 0.1.0

data/spec/parsers/parser_examples.rb

@@ -0,0 +1,58 @@
+require 'rspec'
+
+shared_examples_for "Parser.open" do
+  context "when not given a block" do
+    it "must return the opened file" do
+      file = subject.open(path)
+
+      expect(file).to be_kind_of(File)
+      expect(file.closed?).to be(false)
+    end
+  end
+
+  context "when given a block" do
+    it "must yield the opened file" do
+      file_class  = nil
+      file_opened = nil
+
+      subject.open(path) do |file|
+        file_class  = file.class
+        file_opened = !file.closed?
+      end
+
+      expect(file_class).to be(File)
+      expect(file_opened).to be(true)
+    end
+  end
+end
+
+shared_examples_for "Parser.parse" do
+  context "when given a block" do
+    it "must yield Masscan::Status and Masscan::Banner objects" do
+      yielded_record_classes = []
+
+      subject.parse(io) do |record|
+        yielded_record_classes << record.class
+      end
+
+      expect(yielded_record_classes.uniq).to eq([
+        Masscan::Status,
+        Masscan::Banner
+      ])
+    end
+  end
+
+  context "when given no block" do
+    let(:expected_records) do
+      [].tap do |yielded_records|
+        subject.parse(subject.open(path)) do |record|
+          yielded_records << record
+        end
+      end
+    end
+
+    it "must return an Enumerator" do
+      expect(subject.parse(io).to_a).to eq(expected_records)
+    end
+  end
+end

data/spec/parsers/plain_text_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'masscan/parsers/plain_text'
+
+describe Masscan::Parsers::PlainText do
+  module TestPlainText
+    extend Masscan::Parsers::PlainText
+  end
+
+  subject { TestPlainText }
+
+  describe "#parse_status" do
+    context "when given 'open'" do
+      it "must return :open" do
+        expect(subject.parse_status("open")).to be(:open)
+      end
+    end
+
+    context "when given 'closed'" do
+      it "must return :closed" do
+        expect(subject.parse_status("closed")).to be(:closed)
+      end
+    end
+
+    context "when given an unknown String" do
+      it "must return the String" do
+        expect(subject.parse_status("foo")).to eq("foo")
+      end
+    end
+  end
+
+  describe "#parse_reason" do
+    context "when given one flag" do
+      it "must map it to a keyword and return an Array" do
+        expect(subject.parse_reason("rst")).to eq([:rst])
+      end
+    end
+
+    context "when given multiple flags" do
+      it "must split them and map them to keyword" do
+        expect(subject.parse_reason("syn-ack")).to eq([:syn, :ack])
+      end
+    end
+
+    context "when given an unknown String" do
+      it "must return the String" do
+        expect(subject.parse_reason("foo")).to eq(["foo"])
+      end
+    end
+  end
+
+  describe "#parse_ip_protocol" do
+    context "when given 'tcp'" do
+      it "must return :tcp" do
+        expect(subject.parse_ip_protocol("tcp")).to be(:tcp)
+      end
+    end
+
+    context "when given 'udp'" do
+      it "must return :udp" do
+        expect(subject.parse_ip_protocol("udp")).to be(:udp)
+      end
+    end
+
+    context "when given 'icmp'" do
+      it "must return :icmp" do
+        expect(subject.parse_ip_protocol("icmp")).to be(:icmp)
+      end
+    end
+
+    context "when given 'sctp'" do
+      it "must return :sctp" do
+        expect(subject.parse_ip_protocol("sctp")).to be(:sctp)
+      end
+    end
+
+    context "when given an unknown String" do
+      it "must return the String" do
+        expect(subject.parse_ip_protocol("foo")).to eq("foo")
+      end
+    end
+  end
+
+  describe "#parse_app_protocol" do
+    described_class::APP_PROTOCOLS.each do |string,keyword|
+      context "when given '#{string}'" do
+        it "must return #{keyword.inspect}" do
+          expect(subject.parse_app_protocol(string)).to be(keyword)
+        end
+      end
+    end
+
+    context "when given an unknown String" do
+      it "must return the String" do
+        expect(subject.parse_app_protocol("foo")).to eq("foo")
+      end
+    end
+  end
+
+  describe "#parse_timestamp" do
+    let(:timestamp) { 1629960470         }
+    let(:time)      { Time.at(timestamp) }
+
+    it "must parse a given UNIX timestamp and return a Time object" do
+      expect(subject.parse_timestamp(timestamp)).to eq(time)
+    end
+  end
+
+  describe "#parse_ip" do
+    let(:ip_string) { "1.2.3.4" }
+    let(:ip_addr)   { IPAddr.new(ip_string) }
+
+    it "must parse a given IP string and return an IPAddr" do
+      expect(subject.parse_ip(ip_string)).to eq(ip_addr)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'simplecov'
+SimpleCov.start
+
+module Fixtures
+  DIR = File.join(__dir__,'fixtures')
+
+  def self.join(*names)
+    File.join(DIR,*names)
+  end
+end

data/spec/task_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'masscan/task'
+
+describe Masscan::Task do
+  describe "#ports=" do
+    context "when given an empty Array" do
+      before { subject.ports = [] }
+
+      it "should ignore empty port Arrays" do
+        subject.ports = []
+
+        expect(subject.arguments).to eq([])
+      end
+    end
+
+    context "when given a String" do
+      let(:ports) { '80,21,25' }
+
+      before { subject.ports = ports }
+
+      it "should emit the String as is" do
+        expect(subject.arguments).to eq(['-p', ports])
+      end
+    end
+
+    context "when given an Array of Strings" do
+      let(:ports) { %w[80 21 25] }
+
+      before { subject.ports = ports }
+
+      it "should format an Array of String ports" do
+        expect(subject.arguments).to eq(['-p', ports.join(',')])
+      end
+    end
+
+    context "when given an Array of Integers" do
+      let(:ports) { [80, 21, 25] }
+
+      before { subject.ports = ports }
+
+      it "should format an Array of Integer ports" do
+        expect(subject.arguments).to eq(['-p', ports.join(',')])
+      end
+    end
+
+    context "when given an Array containing a Range" do
+      let(:ports) { [80, 21..25] }
+
+      before { subject.ports = ports }
+
+      it "should format the Range" do
+        expect(subject.arguments).to eq([
+          '-p', "#{ports[0]},#{ports[1].begin}-#{ports[1].end}"
+        ])
+      end
+    end
+  end
+
+  describe "#shards=" do
+    context "when given a Rational value" do
+      let(:rational) { (1/2r) }
+
+      before { subject.shards = rational }
+
+      it "must format it into \#{numerator}/\#{denominator}" do
+        expect(subject.arguments).to eq([
+          "--shards", "#{rational.numerator}/#{rational.denominator}"
+        ])
+      end
+    end
+
+    context "when given an Array value" do
+      let(:array) { [1, 2] }
+
+      before { subject.shards = array }
+
+      it "must format it into \#{array[0]}/\#{array[1]}" do
+        expect(subject.arguments).to eq([
+          "--shards", "#{array[0]}/#{array[1]}"
+        ])
+      end
+
+      context "but the Array length is > 2" do
+        let(:array) { [1,2,3] }
+
+        before { subject.shards = array }
+
+        it do
+          expect {
+            subject.arguments
+          }.to raise_error(ArgumentError,"#{described_class}#shards= does not accept more than two values")
+        end
+      end
+    end
+
+    context "otherwise" do
+      let(:object) { :"1/2" }
+
+      before { subject.shards = object }
+
+      it "must convert the value to a String" do
+        expect(subject.arguments).to eq([
+          "--shards", object.to_s
+        ])
+      end
+    end
+  end
+
+  describe "#http_field=" do
+    let(:name)  { 'X-Foo' }
+    let(:value) { 'bar'   }
+
+    before { subject.http_field = [ [name, value] ] }
+
+    it "must join two values together with a ':'" do
+      expect(subject.arguments).to eq([
+        "--http-field", "#{name}:#{value}"
+      ])
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ruby-masscan
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Postmodern
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rprogram
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !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 masscan, an Internet-scale port scanner. Allows automating
+  masscan and parsing masscan Binary, List, JSON, and output file formats.
+email: postmodern.mod3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".editorconfig"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- lib/masscan.rb
+- lib/masscan/banner.rb
+- lib/masscan/output_file.rb
+- lib/masscan/parsers.rb
+- lib/masscan/parsers/binary.rb
+- lib/masscan/parsers/json.rb
+- lib/masscan/parsers/list.rb
+- lib/masscan/parsers/plain_text.rb
+- lib/masscan/program.rb
+- lib/masscan/status.rb
+- lib/masscan/task.rb
+- lib/masscan/version.rb
+- ruby-masscan.gemspec
+- spec/fixtures/masscan.bin
+- spec/fixtures/masscan.json
+- spec/fixtures/masscan.list
+- spec/fixtures/masscan.ndjson
+- spec/fixtures/masscan.xml
+- spec/output_file_spec.rb
+- spec/parsers/binary_spec.rb
+- spec/parsers/json_spec.rb
+- spec/parsers/list_spec.rb
+- spec/parsers/parser_examples.rb
+- spec/parsers/plain_text_spec.rb
+- spec/spec_helper.rb
+- spec/task_spec.rb
+homepage: https://github.com/postmodern/ruby-masscan#readme
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://rubydoc.info/gems/ruby-masscan
+  source_code_uri: https://github.com/postmodern/ruby-masscan
+  bug_tracker_uri: https://github.com/postmodern/ruby-masscan/issues
+  changelog_uri: https://github.com/postmodern/ruby-masscan/blob/master/ChangeLog.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- masscan >= 1.0.0
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A Ruby interface to masscan.
+test_files: []