dns-sniper 0.0.1.pre4 → 0.0.1.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d15d70b6571fb7db1cd3b4e53c4eac7a6041c0d08072c47309d8202dc5569d3
-  data.tar.gz: 5dadb99daabfd7896735c94ac8981a70df077f73daa3f52f4bbc50570c6efd32
+  metadata.gz: 61bc06052722d5ac53448692a1c4cfb8e52a86ebe41fe2ef3973b5f36a0ff1da
+  data.tar.gz: '058667f512cdaa447c377325a0cc17df712f05c0d1aac2d82c09337f1faa2b3b'
 SHA512:
-  metadata.gz: 4eac165aa45a6056690e69f2a5ebe939996a8b7364d0ebecd953827c8d3c20f112e9e8fd4cf42421d16771d0084fdb23c12e52dddba50911dbd9d8e61f8797e7
-  data.tar.gz: 6e6a4e723a92e90ce128e893172395fc3f66333aac3e9d0eda03c7f2f98fbb8f5d559cde4c25540b78b476c032e9e78af698cfc52e156b5dbabbbf5ba5697a3e
+  metadata.gz: a2ab89c5edd6fa0ee2be7fee4078859ee15b4af1f8598ea12cc4925103d6155d0ddc1d2da313ada9b055635ec76dcf5c6cab1a2be3d3a1a45e6bd12f2fcb53f2
+  data.tar.gz: 05d1dc924c958d1172da20cce2795498c60c33278db0738fbf0b1bed4539b28ab291a8f6fd7aa3b64db010b3ffa1a7f58ee872cb936705114e4c7819b43ae225

data/bin/dns-sniper

@@ -5,19 +5,16 @@ require 'optparse'
 require 'set'
 require 'dns-sniper'
 
-VALID_FORMATS = DNSSniper::Formatters.all.inject([]) { |arr, f| arr << f.name.to_s.sub('DNSSniper::', '').downcase }
-Options = Struct.new(:blacklist_urls_file, :whitelisted_hosts_file, :format)
+VALID_FORMATS = DNSSniper::Exporters.all.inject([]) { |arr, f| arr << f.name.to_s.sub('DNSSniper::', '').sub('Exporter', '').downcase }
+Options = Struct.new(:conf_path, :format)
 
 class Parser
   def self.parse(options)
     args = Options.new('world')
     opt_parser = OptionParser.new do |opts|
       opts.banner = "Usage: #{File.basename(__FILE__)} -f PATH -o FORMAT [options]\n#{File.basename(__FILE__)} combines online DNS blacklists and combines them into the desired configuration FORMAT.\n\n"
-      opts.on('-f', '--blacklist=PATH', 'PATH to file with line-separated list of URL’s of blacklists') do |path|
-        args.blacklist_urls_file = path
-      end
-      opts.on('-w', '--whitelist=path', 'Path to file with line-separated list of whitelisted hostnames') do |path|
-        args.whitelisted_hosts_file = path
+      opts.on('-c', '--conf=PATH', 'PATH to YAML configuration file') do |path|
+        args.conf_path = path
       end
       opts.on('-o', '--output=FORMAT', "FORMAT to output — one of #{VALID_FORMATS.join(', ')}") do |format|
         args.format = format
@@ -34,20 +31,20 @@ end
 
 options = Parser.parse ARGV
 
-unless VALID_FORMATS.include?(options[:format])
-  warn options[:format].blank? ? 'Error: Format not defined' : "Error: Invalid format \"#{options[:format]}\""
+unless File.exist?(options[:conf_path])
+  warn "Error: Unable to access ”#{options[:conf_path]}”"
   exit(-1)
 end
 
-unless File.exist?(options[:blacklist_urls_file])
-  warn "Error: Unable to access ”#{options[:blacklist_urls_file]}”"
-  exit(-1)
-end
-
-if options[:whitelisted_hosts_file] && !File.exist?(options[:whitelisted_hosts_file])
-  warn "Error: Unable to access ”#{options[:whitelisted_hosts_file]}”"
+exporter = DNSSniper.const_get("#{options[:format].to_s.split('_').map(&:capitalize).join}Exporter")
+if !exporter
+  warn "Error: Invalid format #{options[:format]}"
   exit(-1)
 end
 
 hostnames = DNSSniper::Hostnames.new
-puts hostnames.add_from(File.open(options[:blacklist_urls_file]).readlines).remove_from(options[:whitelisted_hosts_file]).to_format(options[:format])
+hostnames.blacklist += DNSSniper::ConfigurationImporter.new(options[:conf_path], list: :reject).hostnames
+hostnames.whitelist += DNSSniper::ConfigurationImporter.new(options[:conf_path], list: :allow).hostnames
+
+exporter = exporter.new(hostnames.blocklist)
+puts exporter.data

data/dns-sniper.gemspec

@@ -3,8 +3,8 @@
 Gem::Specification.new do |spec|
   spec.name = 'dns-sniper'
   spec.license = 'MIT'
-  spec.version = '0.0.1.pre4'
-  spec.date = '2020-11-01'
+  spec.version = '0.0.1.pre5'
+  spec.date = '2020-11-10'
 
   spec.authors = ['Brody Hoskins']
   spec.email = ['brody@brody.digital']

data/lib/dns-sniper.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require 'resolv'
+require 'yaml'
+
+require 'dns-sniper/exporter'
+require 'dns-sniper/exporters'
 require 'dns-sniper/hostnames'
-require 'dns-sniper/formatter'
-require 'dns-sniper/formatters'
+require 'dns-sniper/importer'
+require 'dns-sniper/importers'

data/lib/dns-sniper/{formatter.rb → exporter.rb}

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Formatter
+  class Exporter
+    attr_accessor :data, :hostnames
+
     def initialize(hostnames, options = {})
       @hostnames = hostnames
-      @options = options
+      @data = output(options)
     end
 
-    def output
+    def output(*)
       raise NotImplementedError, "Error: #output isn’t supported by #{self.class.name}"
     end
   end

data/lib/dns-sniper/exporters.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  module Exporters
+    module_function
+
+    attr_reader :registered
+    @registered = []
+
+    def register(class_name, autoload_require)
+      DNSSniper.autoload(class_name, autoload_require)
+      @registered << class_name
+    end
+
+    def all
+      @registered.map { |name| DNSSniper.const_get(name) }
+    end
+
+    def find(name)
+      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown exporter \"#{name}\""
+    end
+  end
+end
+
+DNSSniper::Exporters.register :Bind8Exporter, 'dns-sniper/exporters/bind8_exporter'
+DNSSniper::Exporters.register :DnsmasqExporter, 'dns-sniper/exporters/dnsmasq_exporter'
+DNSSniper::Exporters.register :HostsExporter, 'dns-sniper/exporters/hosts_exporter'
+DNSSniper::Exporters.register :NetgearExporter, 'dns-sniper/exporters/netgear_exporter'
+DNSSniper::Exporters.register :TextExporter, 'dns-sniper/exporters/text_exporter'
+DNSSniper::Exporters.register :UnboundExporter, 'dns-sniper/exporters/unbound_exporter'

data/lib/dns-sniper/{formatters/bind8.rb → exporters/bind8_exporter.rb}

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Bind8 < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
+  class Bind8Exporter < Exporter
     def output(options = {})
       raise ArgumentError, 'zone_file is required' unless defined?(options[:zone_file])
 

data/lib/dns-sniper/{formatters/dnsmasq.rb → exporters/dnsmasq_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Dnsmasq < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class DnsmasqExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each do |hostname|
         str << "server=/#{hostname}/#{$/}"

data/lib/dns-sniper/{formatters/hosts.rb → exporters/hosts_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Hosts < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class HostsExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each do |hostname|
         str << "127.0.0.1\t#{hostname}#{$/}"

data/lib/dns-sniper/{formatters/netgear.rb → exporters/netgear_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Netgear < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class NetgearExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each_with_index do |hostname, i|
         str << "[517003_e]: #{i + 1}) #{hostname}\n"

data/lib/dns-sniper/exporters/text_exporter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class TextExporter < Exporter
+    def output(_options = {})
+      @hostnames.to_a.join($/)
+    end
+  end
+end

data/lib/dns-sniper/{formatters/unbound.rb → exporters/unbound_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Unbound < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class UnboundExporter < Exporter
+    def output(*)
       str = ''.dup
       str << "server:#{$/}"
       @hostnames.each do |hostname|

data/lib/dns-sniper/hostnames.rb

@@ -7,152 +7,28 @@ require 'resolv'
 
 module DNSSniper
   class Hostnames
-    def initialize(_options = {})
-      @hostnames = [].to_set
-      self
-    end
+    attr_accessor :blacklist
+    attr_accessor :whitelist
 
-    def add(hostnames)
-      hostnames = clean(hostnames.class == String ? [hostnames] : hostnames)
-      @hostnames += hostnames unless hostnames.empty?
+    def initialize
+      @blacklist = [].to_set
+      @whitelist = [].to_set
       self
     end
 
-    def add_from(paths_or_urls)
-      return self unless paths_or_urls
-
-      paths_or_urls = [paths_or_urls] if paths_or_urls.class == String
-
-      paths_or_urls.each do |path_or_url|
-        path_or_url.chomp!
-
-        if File.exist?(path_or_url)
-          contents = File.open(path_or_url).readlines(chomp: true)
-        else
-          begin
-            down = Down.download(path_or_url)
-            path_or_url = down.path
-            contents = down.readlines(chomp: true)
-          rescue Down::InvalidUrl
-            warn "\"#{path_or_url}\" does not exist, nor is it a valid URL"
-          rescue Down::NotFound
-            warn "\"#{path_or_url}\" does not exist"
-            return self
-          rescue Down::ResponseError
-            warn "\"#{path_or_url}\": No data from server"
-            return self
-          end
-        end
+    def blocklist
+      blacklist = @blacklist
+      whitelist = @whitelist
 
-        case syntax(path_or_url, contents)
-        when nil
-          warn "Error: Syntax: Syntax of \"#{path_or_url}\" not recognized, ignored"
-          return self
-        when 'hosts'
-          add from_hosts_file(path_or_url)
-        when 'hostnames'
-          add from_hostnames_file(contents)
+      whitelist.each do |domain|
+        domain_parts = domain.split('.')
+        domain_parts.count.times do |count|
+          next if count == 1
+          whitelist += [domain_parts[count - 1, domain_parts.length].join('.')]
         end
       end
 
-      self
-    end
-
-    def remove(hostnames)
-      hostnames = clean(hostnames.class == String ? [hostnames] : hostnames)
-      @hostnames -= hostnames unless hostnames.empty?
-      self
-    end
-
-    def remove_from(paths_or_urls)
-      return self unless paths_or_urls
-
-      paths_or_urls = [paths_or_urls] if paths_or_urls.class == String
-
-      paths_or_urls.each do |path_or_url|
-        path_or_url = path_or_url.strip
-
-        if File.exist?(path_or_url)
-          contents = File.open(path_or_url).readlines
-        else
-          begin
-            down = Down.download(path_or_url)
-            path_or_url = down.path
-            contents = down.readlines
-          rescue Down::NotFound
-            warn "\"#{path_or_url}\" does not exist"
-            return self
-          rescue Down::ResponseError
-            warn "\"#{path_or_url}\": No data from server"
-            return self
-          end
-        end
-
-        case syntax(path_or_url, contents)
-        when nil
-          warn "Error: Syntax: Syntax of \"#{path_or_url}\" not recognized, ignored"
-          return self
-        when 'hosts'
-          remove from_hosts_file(path_or_url)
-        when 'hostnames'
-          remove from_hostnames_file(contents)
-        end
-      end
-
-      self
-    end
-
-    def to_format(format, options = {})
-      format = format.capitalize
-      begin
-        klass = DNSSniper.const_get(format)
-        klass.new(@hostnames.to_a).output(options)
-      rescue NameError
-        false
-      end
-    end
-
-    def to_a
-      @hostnames.to_a
-    end
-
-    private
-
-    def clean(hostnames)
-      cleaned_hostnames = []
-      hostnames.each do |hostname|
-        hostname = hostname.downcase.strip
-        hostname = hostname.sub('www.', '')
-        hostname_top_domain = "#{hostname.split('.')[-2]}.#{hostname.split('.')[-1]}"
-
-        if !hostname.include?('#') && !['broadcasthost', 'localhost', ''].include?(hostname) && !@hostnames.include?(hostname_top_domain)
-          cleaned_hostnames << hostname
-        end
-      end
-      cleaned_hostnames
-    end
-
-    def syntax(path_or_url, contents)
-      contents.each do |line|
-        next if line.include?('#')
-
-        line = line.downcase
-        if line.strip.split(/\s/).first =~ Regexp.union([Resolv::IPv4::Regex, Resolv::IPv6::Regex])
-          return 'hosts'
-        elsif line.include?('.') && !URI.parse(line).is_a?(URI::HTTP)
-          return 'hostnames'
-        end
-      end
-      nil
-    end
-
-    def from_hosts_file(path_or_url)
-      # TODO: Remove downloading file twice
-      HostsFile.load(path_or_url).map(&:name)
-    end
-
-    def from_hostnames_file(contents)
-      contents.each { |line| add(line) }
+      blacklist - whitelist
     end
   end
 end

data/lib/dns-sniper/importer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class Importer
+    attr_accessor :uri, :hostnames
+
+    def initialize(uri, *)
+      @uri = uri
+      @hostnames = File.exist?(uri) ? import_file(uri) : import_uri(uri)
+    end
+
+    def import_file(*)
+      raise NotImplementedError, "#{self.class.name}: #import_file not supported"
+    end
+
+    def import_uri(*)
+      raise NotImplementedError, "#{self.class.name}: #import_uri not supported"
+    end
+
+    # Helper methods
+
+    def clean(domain)
+      domain = domain.split('#')[0] if domain[0] != '#' && domain.include?('#')
+      domain = domain.split(':')[0] if domain.include?(':') && !ip_addr?(domain)
+      domain = domain.sub('www.', '') if domain.start_with?('www.') && domain.scan('www.').count == 1
+
+      domain.chomp.gsub(/\s+/, '').downcase
+    end
+
+    def rejector(domain)
+      !domain?(domain)
+    end
+
+    def domain?(domain)
+      return false if domain == ''
+      return false if domain.gsub('#', '').gsub(/\s+/, '').empty?
+      return false if domain[0] == '#'
+      return false unless domain.include?('.')
+      return false if domain.include?(':')
+      return false if ip_addr?(domain)
+      return false unless /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/.match?(domain)
+
+      begin
+        return false if URI.parse(domain).is_a?(URI::HTTP)
+      rescue URI::InvalidURIError; end
+      true
+    end
+
+    def ip_addr?(domain)
+      domain =~ Regexp.union([Resolv::IPv4::Regex, Resolv::IPv6::Regex])
+    end
+  end
+end

data/lib/dns-sniper/importers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  module Importers
+    module_function
+
+    attr_reader :registered
+    @registered = []
+
+    def register(class_name, autoload_require)
+      DNSSniper.autoload(class_name, autoload_require)
+      @registered << class_name
+    end
+
+    def all
+      @registered.map { |name| DNSSniper.const_get(name) }
+    end
+
+    def find(name)
+      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown Importer \"#{name}\""
+    end
+  end
+end
+
+DNSSniper::Importers.register :ConfigurationImporter, 'dns-sniper/importers/configuration_importer'
+DNSSniper::Importers.register :DomainsImporter, 'dns-sniper/importers/domains_importer'
+DNSSniper::Importers.register :HostsImporter, 'dns-sniper/importers/hosts_importer'

data/lib/dns-sniper/importers/configuration_importer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class ConfigurationImporter < Importer
+    def initialize(uri, list:)
+      @uri = uri
+      @hostnames = File.exist?(uri) ? import_file(uri, list: list) : import_uri(uri, list: list)
+    end
+
+    def import_file(path, list:)
+      raise ArgumentError, "#{self.class.name}: #from_path requies list to be defined" unless list
+      return [].to_set unless File.exist?(path)
+
+      yaml = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+      return [].to_set unless yaml.dig(:sources)&.dig(list.to_sym)
+
+      hostnames = [].to_set
+      yaml.dig(:sources).dig(list.to_sym).each do |source|
+        return [].to_set unless source.dig(:importer)
+        return [].to_set unless source.dig(:uri)
+
+        importer = DNSSniper.const_get("#{source.dig(:importer).to_s.split('_').map(&:capitalize).join}Importer")
+        if !importer
+          next
+        else
+          importer = importer.new(source.dig(:uri))
+          hostnames += importer.hostnames
+        end
+      end
+
+      hostnames
+    end
+
+    def import_uri(_uri, list:)
+      raise NotImplementedError, "#{self.class.name}: #from_uri not supported"
+    end
+  end
+end

data/lib/dns-sniper/importers/domains_importer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class DomainsImporter < Importer
+    def import_file(path)
+      return [].to_set unless File.exist?(path)
+
+      File.open(path).readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+    end
+
+    def import_uri(uri)
+      begin
+        down = Down.download(uri)
+        return down.readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+      rescue Down::InvalidUrl => e
+        warn "#{self.class.name}: #{e}"
+      end
+
+      [].to_set
+    end
+  end
+end

data/lib/dns-sniper/importers/hosts_importer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class HostsImporter < Importer
+    def import_file(path, *)
+      return [].to_set unless File.exist?(path)
+
+      HostsFile.load(path).map(&:name).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+    end
+
+    def import_uri(uri, *)
+      begin
+        down = Down.download(uri)
+        path = down.path
+      rescue Down::InvalidUrl => e
+        warn "#{self.class.name}: #{e}"
+      end
+
+      if path
+        return HostsFile.load(path).map(&:name).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+      end
+
+      [].to_set
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dns-sniper
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre4
+  version: 0.0.1.pre5
 platform: ruby
 authors:
 - Brody Hoskins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-01 00:00:00.000000000 Z
+date: 2020-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -56,15 +56,20 @@ files:
 - bin/dns-sniper
 - dns-sniper.gemspec
 - lib/dns-sniper.rb
-- lib/dns-sniper/formatter.rb
-- lib/dns-sniper/formatters.rb
-- lib/dns-sniper/formatters/bind8.rb
-- lib/dns-sniper/formatters/dnsmasq.rb
-- lib/dns-sniper/formatters/hosts.rb
-- lib/dns-sniper/formatters/netgear.rb
-- lib/dns-sniper/formatters/text.rb
-- lib/dns-sniper/formatters/unbound.rb
+- lib/dns-sniper/exporter.rb
+- lib/dns-sniper/exporters.rb
+- lib/dns-sniper/exporters/bind8_exporter.rb
+- lib/dns-sniper/exporters/dnsmasq_exporter.rb
+- lib/dns-sniper/exporters/hosts_exporter.rb
+- lib/dns-sniper/exporters/netgear_exporter.rb
+- lib/dns-sniper/exporters/text_exporter.rb
+- lib/dns-sniper/exporters/unbound_exporter.rb
 - lib/dns-sniper/hostnames.rb
+- lib/dns-sniper/importer.rb
+- lib/dns-sniper/importers.rb
+- lib/dns-sniper/importers/configuration_importer.rb
+- lib/dns-sniper/importers/domains_importer.rb
+- lib/dns-sniper/importers/hosts_importer.rb
 homepage: https://github.com/brodyhoskins/dns-sniper
 licenses:
 - MIT

data/lib/dns-sniper/formatters.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  module Formatters
-    extend self
-
-    attr_reader :registered
-    @registered = []
-
-    def register(class_name, autoload_require)
-      DNSSniper.autoload(class_name, autoload_require)
-      @registered << class_name
-    end
-
-    def all
-      @registered.map { |name| DNSSniper.const_get(name) }
-    end
-
-    def find(name)
-      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown formatter \"#{name}\""
-    end
-  end
-end
-
-DNSSniper::Formatters.register :Bind8, 'dns-sniper/formatters/bind8'
-DNSSniper::Formatters.register :Dnsmasq, 'dns-sniper/formatters/dnsmasq'
-DNSSniper::Formatters.register :Hosts, 'dns-sniper/formatters/hosts'
-DNSSniper::Formatters.register :Netgear, 'dns-sniper/formatters/netgear'
-DNSSniper::Formatters.register :Text, 'dns-sniper/formatters/text'
-DNSSniper::Formatters.register :Unbound, 'dns-sniper/formatters/unbound'

data/lib/dns-sniper/formatters/text.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  class Text < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
-      @hostnames.to_a.join($/)
-    end
-  end
-end