portfinder 0.0.1 → 0.0.2

data/bin/portfinder

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+require "slop"
+require "portfinder"
+require "portfinder/option"
+
+module Portfinder
+  # Portfinder command-line interface base class
+  class CLI
+    def self.start argv
+      new(argv).start
+    end
+
+    def initialize argv
+      @host, options = preprocess argv
+      @options, @help_str = prepare_options options, @host
+    end
+
+    def start
+      @host ? scan(@options) : help
+    end
+
+    def scan options
+      scanner =
+        Portfinder::Scanner.new(
+          options[:host], options[:port],
+          randomize: options[:randomize], threaded: true,
+          threads: options[:thread], thread_for: :port
+        )
+      scanner.scan
+      puts scanner.generate_result true
+    end
+
+    def help
+      puts @help_str
+    end
+
+    def version
+      puts "v#{Portfinder::VERSION}"
+      exit
+    end
+
+    private
+
+    def preprocess argv
+      default_options = ["-h", "--help"]
+      host = argv[0]
+      if default_options.include? host
+        host = nil
+        options = argv
+      else
+        options = argv[1..-1] || []
+      end
+
+      [host, options]
+    end
+
+    # rubocop:disable Style/MethodLength
+    def option_parser
+      opts = Slop::Options.new
+      opts.banner = "Commands:"
+      opts.separator "    portfinder         # Display available options"
+      opts.separator(
+        "    portfinder <host>  # Scans host(s) for provided options"
+      )
+      opts.separator ""
+      opts.separator "Options:"
+      opts.port(
+        "-p", "--port", "# Specify a single port, range or selections",
+        default: 1..1024
+      )
+      opts.int "-t", "--thread", "# Specify threads to spawn", default: 10
+      opts.bool "-r", "--randomize", "# Randomize port scan order"
+      opts.out(
+        "-o", "--out", "# Dump scan result to the specified file",
+        default: "#{@host ? @host.gsub(%r{[./]}, '_') : 'export'}.json"
+      )
+      opts.bool "-v", "--verbose", "# More information during scan"
+      opts.bool "-h", "--help", "# Describe available commands and options"
+
+      Slop::Parser.new opts
+    end
+
+    # Refactor
+    def prepare_options options, host
+      version_opt = ["-V", "--version"]
+      version if version_opt.include?(host)
+
+      parsed = option_parser.parse options
+      parsed_hash = parsed.to_h
+      if host && /^[^-]+/ =~ host
+        parsed_hash.merge!(
+          Slop.parse ["--host", host] { |opt| opt.host "--host" }
+        )
+      end
+
+      [parsed_hash, parsed.to_s]
+    end
+  end
+end
+
+Portfinder::CLI.start ARGV

data/gemfiles/slop_4.4.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "slop", "~> 4.4.0"
+
+gemspec path: "../"

data/gemfiles/slop_4.5.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "slop", "~> 4.5.0"
+
+gemspec path: "../"

data/lib/portfinder.rb

@@ -1,5 +1,69 @@
-module Portfinder
-end
+require "socket"
+require "ipaddr"
+require "json"
+require "yaml"
+require "portfinder/constants"
+require "portfinder/error"
+require "portfinder/parser"
+require "portfinder/pool"
+require "portfinder/monitor"
+require "portfinder/scanner"
+require "portfinder/version"
 
-require 'portfinder/scanner'
+# Expectations
 
+## Mode 1: Blocking mode with monitoring
+# scanner = Portfinder::Scanner.new(hosts, ports,
+#   randomize: false, threaded: true, threads: 10, thread_for: :port)
+#
+# scanner.log do |monitor|
+#   puts "Active threads:\t#{monitor.threads}\nScanning now:\n"
+#   while true
+#     print "\tHost:\t#{monitor.host}\tPort:\t#{monitor.port}\tStatus: #{
+#       monitor.state}\r"
+#     sleep 0.1
+#   end
+# end
+#
+# scanner.scan
+# puts "\nScan complete!\n\nResult: #{scanner.generate_result}"
+#
+# format = "json"
+# file = open("meau.#{format}", "wb")
+# file.write scanner.report_as format.to_sym
+# file.close
+
+## Mode 2: Partial blocking (join during result invocation)
+# scanner = Portfinder::Scanner.new("192.168.0.101", 1..65535)
+# #logger can be placed here...
+#
+# scanner.log do |monitor|
+#   puts "Active threads:\t#{monitor.threads}\nScanning now:\n"
+#   while true
+#     print "\tHost:\t#{monitor.host}\tPort:\t#{monitor.port}\r"
+#     sleep 0.1
+#   end
+# end
+# scanner.scan synchronus = false
+#
+# # logger can be placed here
+# puts "\nScan complete!\n\nResult: #{scanner.generate_result}"
+
+## Mode 3: Non-blocking (callback invocation upon completion)
+# (NOTE: Parent thread must be alive to receive callback)
+#
+# scanner = Portfinder::Scanner.new("192.168.0.101", 1..65535)
+#
+# scanner.scan(false) do
+#   puts "\nScan complete!\n\nResult: #{scanner.generate_result}"
+# end
+#
+# scanner.log do |monitor|
+#   puts "Active threads:\t#{monitor.threads}\nScanning now:\n"
+#   while true
+#     print "\tHost:\t#{monitor.host}\tPort:\t#{monitor.port}\r"
+#     sleep 0.1
+#   end
+# end
+#
+# sleep 10

data/lib/portfinder/constants.rb

@@ -0,0 +1,31 @@
+module Portfinder
+  IP4_OCTET_ = /\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]/
+  IP4_ = /((#{IP4_OCTET_})\.){3}(#{IP4_OCTET_})/
+  CIDR_ = /\d|[12]\d|3[0-2]/
+  IP4 = /^(?<ip>#{IP4_})$/
+  IP4_RANGE = /^(?<start>#{IP4_})-(?<limit>[2-9]|[1-9]\d|1\d{2}|2[0-4]\d|
+25[0-4])$/x
+  IP4_SELECTION = /^(#{IP4_},)+#{IP4_}$/
+  IP4_NETWORK = %r{^(?<network>#{IP4_})/(?<net_bits>#{CIDR_})$}
+
+  PORT_ = /[1-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|
+65[0-4]\d{2}|655[0-2]\d|6553[0-5]/x
+  PORT = /^(?<port>#{PORT_})$/
+  PORT_RANGE = /^(?<start>#{PORT_})-(?<end>#{PORT_})$/
+  PORT_SELECTION = /^(#{PORT_},)+#{PORT_}$/
+
+  # UNIX_FILE_ = /[^;:\|\/\0]+/
+  # UNIX_DIR_ = //
+
+  IP4_TYPES = {
+    ip: Portfinder::IP4,
+    range: Portfinder::IP4_RANGE,
+    selection: Portfinder::IP4_SELECTION,
+    network: Portfinder::IP4_NETWORK
+  }.freeze
+  PORT_TYPES = {
+    port: Portfinder::PORT,
+    range: Portfinder::PORT_RANGE,
+    selection: Portfinder::PORT_SELECTION
+  }.freeze
+end

data/lib/portfinder/error.rb

@@ -0,0 +1,9 @@
+module Portfinder
+  # Generic Error baseclass for Portfinder specific errors
+  class Error < StandardError
+  end
+
+  # Portfinder Error class for invalid hosts
+  class InvalidHost < Error
+  end
+end

data/lib/portfinder/monitor.rb

@@ -0,0 +1,48 @@
+module Portfinder
+  # Portfinder scanner monitor
+  class Monitor
+    attr_reader :state
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :threads
+
+    def initialize state = :init
+      self.state = state
+      @host = ""
+      @port = nil
+      @threads = 1
+    end
+
+    # Refactor: Enum?
+    def state= value
+      states = %i[init run term]
+      unless states.include?(value)
+        raise TypeError, "state can be any of #{states}"
+      end
+      @state = value
+    end
+
+    def start
+      self.state = :run
+      reset
+    end
+
+    def stop
+      self.state = :term
+      reset
+    end
+
+    def update host, port
+      @host = host
+      @port = port
+    end
+
+    private
+
+    def reset
+      @host = ""
+      @port = nil
+      @threads = 1
+    end
+  end
+end

data/lib/portfinder/option.rb

@@ -0,0 +1,23 @@
+# FIXME: Slop doesn't raise an error during option parsing
+module Slop
+  # Slop parser for IPv4 Hosts
+  class HostOption < Option
+    def call value
+      Portfinder::Parser.new.parse_hosts value
+    end
+  end
+
+  # Slop parser for ports
+  class PortOption < Option
+    def call value
+      Portfinder::Parser.new.parse_ports value
+    end
+  end
+
+  # Slop parser for File path
+  class OutOption < Option
+    def call value
+      File.basename value
+    end
+  end
+end

data/lib/portfinder/parser.rb

@@ -0,0 +1,91 @@
+module Portfinder
+  # Argument parser
+  class Parser
+    # Parser match type
+    Type = Struct.new :name, :match
+
+    def initialize; end
+
+    # :reek:FeatureEnvy
+    def parse_hosts target
+      type = select_type target, IP4_TYPES
+      return unless type
+
+      case type.name
+      when :ip
+        type.match[:ip]
+      when :range
+        ip4_range type.match[:start], type.match[:limit].to_i
+      when :selection
+        target.split ","
+      when :network
+        ip4_network_hosts type.match[:network], type.match[:net_bits].to_i
+      end
+    end
+
+    # :reek:FeatureEnvy
+    def parse_ports target
+      type = select_type target, PORT_TYPES
+      return unless type
+
+      case type.name
+      when :port
+        type.match[:port].to_i
+      when :range
+        type.match[:start].to_i..type.match[:end].to_i
+      when :selection
+        target.split(",").map(&:to_i)
+      end
+    end
+
+    def parse_file_path _target, _verify = false
+      raise NotImplementedError, "Implementation pending"
+    end
+
+    def parse_dir_path _target, _verify = false
+      raise NotImplementedError, "Implementation pending"
+    end
+
+    private
+
+    def ip4_range start, limit
+      start_offset = start.split(".").last.to_i
+      host_count = (limit - start_offset) + 1
+      host_count_in_range = (1..254).cover? host_count
+      last_host_in_range = (2..254).cover? limit
+
+      return unless host_count_in_range && last_host_in_range
+
+      Enumerator.new host_count do |host|
+        IPAddr.new(
+          start + "/24"
+        ).to_range.each_with_index do |addr, index|
+          host << addr.to_s if (start_offset..limit).cover? index
+        end
+      end
+    end
+
+    def ip4_network_hosts network, net_bits
+      ip_count = 2**(32 - net_bits)
+      valid_host_count = ip_count < 2 ? 0 : ip_count - 2
+      range = IPAddr.new("#{network}/#{net_bits}").to_range
+      exceptions = [range.first, range.last]
+      Enumerator.new valid_host_count do |host|
+        range.each do |addr|
+          host << addr.to_s unless exceptions.include?(addr)
+        end
+      end
+    end
+
+    def select_type target, types
+      selection_type = nil
+
+      types.each_pair do |type, matcher|
+        match = matcher.match(target)
+        selection_type = Type.new(type, match) if match
+      end
+
+      selection_type
+    end
+  end
+end

data/lib/portfinder/pool.rb

@@ -0,0 +1,59 @@
+module Portfinder
+  # Portfinder Thread pool
+  class Pool
+    attr_reader :result
+    attr_reader :size
+
+    def initialize size
+      @pool = []
+      @size = size
+      @jobs = Queue.new
+      @result = {}
+      @formatter = nil
+      process
+    end
+
+    def complete_result
+      shutdown
+      @result
+    end
+
+    def result_format &block
+      @formatter = block
+    end
+
+    def schedule *args, &block
+      @jobs << [block, args]
+    end
+
+    def shutdown synchronize = true, &callback
+      @size.times do
+        schedule { throw :shutdown }
+      end
+
+      watcher =
+        Thread.fork do
+          @pool.map(&:join)
+          callback.call if callback
+        end
+
+      watcher.join if synchronize
+    end
+
+    private
+
+    def process
+      @pool = Array.new(@size) do
+        Thread.fork do
+          catch :shutdown do
+            loop do
+              job, args = @jobs.pop
+              value = job.call args
+              @result = @formatter.call(@result, args, value) if @formatter
+            end
+          end
+        end
+      end
+    end
+  end
+end