eventmachine-dnsbl 0.0.1

data/lib/eventmachine/dnsbl/server.rb

@@ -0,0 +1,63 @@
+require 'eventmachine'
+require 'resolv'
+
+module EventMachine
+	module DNSBL
+		class Server < EventMachine::Connection
+			def initialize(zones = MemoryZone.new)
+				@zones = zones
+			end
+			
+			def receive_data(data)
+				dns = Resolv::DNS::Message.decode(data)
+				dns.qr = 1
+				dns.aa = 1
+				return if dns.opcode != Resolv::DNS::OpCode::Query
+				unless dns.question.length == 1 and dns.question[0][1] == Resolv::DNS::Resource::IN::A
+					dns.rcode = Resolv::DNS::RCode::FormErr
+					res = dns.encode
+					send_data res
+					return
+				end
+				query, qtype = dns.question[0]
+				rs = @zones.get_records(query.to_s, qtype)
+				unless rs
+					dns.rcode = Resolv::DNS::RCode::NXDomain
+					res = dns.encode
+					send_data res
+					return
+				end
+				# add the records them to the set of answers
+				rs.each do |rr|
+					dns.add_answer(query,rr.ttl,rr.answer)
+				end
+				# Make sure that we are authoritative for the response! Otherwise, return REFUSED
+				dns.rcode = Resolv::DNS::RCode::NoError # Or Refused
+				res = dns.encode
+				#port, ip = Socket.unpack_sockaddr_in(get_peername)
+				#puts "DEBUG: #{ip}:#{port} #{res.length}"
+				send_data res
+			end
+			
+			def add_record(qname, answer, ttl=300)
+				rr = ResourceRecord.new(qname, ttl, answer)
+				@rr[qname] = [] unless @rr[qname]
+				@rr[qname] << rr
+			end
+
+			def del_record(qname, answer)
+				return nil unless @rr[qname]
+				@rr[qname].delete_if {|rr| rr.answer == answer}
+			end
+			
+			def del_all_records(qname)
+				@rr.delete(qname)
+			end
+
+			def get_records(qname, qtype)
+				return nil unless @rr[qname]
+				@rr[qname].find_all {|rr| rr.answer.class == qtype}
+			end
+		end
+	end
+end

data/lib/eventmachine/dnsbl/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module DNSBL
+    VERSION = "0.0.1"
+  end
+end

data/lib/eventmachine/dnsbl/zone/abstract_zone.rb

@@ -0,0 +1,34 @@
+module EventMachine
+  module DNSBL
+    module Zone
+  		class DNSBLResourceRecord < Struct.new(:zone, :label_regex, :ttl, :answer, :valid_until); end
+      
+      class AbstractZone
+        def get_records(query, qtype)
+          records = Array.new
+          # A queries are all that I support right now
+          if qtype != Resolv::DNS::Resource::IN::A
+            return records
+          end
+
+          zone = label = nil
+          @zones.each do |z|
+            if query.end_with?(z)
+              label = query[0, query.length - z.length]
+              zone = z
+            end
+          end
+          
+          if zone
+            get_all_records_for_zone(zone).each do |rec|
+              if rec[:label_regex].match(label)
+                records << rec
+              end
+            end
+          end
+          records
+        end
+      end
+    end
+  end
+end

data/lib/eventmachine/dnsbl/zone/memory_zone.rb

@@ -0,0 +1,31 @@
+require "eventmachine/dnsbl/zone/abstract_zone"
+
+module EventMachine
+  module DNSBL
+    module Zone
+      class MemoryZone < AbstractZone
+        def initialize
+          @zones = Array.new
+          @backend = Hash.new
+        end
+        
+        def add_dnsblresource(dnsblrr)
+          zone = dnsblrr[:zone]
+          if not @backend[zone]
+            if not @zones.include?(zone)
+              @zones << zone
+              @zones = @zones.uniq.sort {|a,b| b.length <=> a.length}
+            end
+            @backend[zone] = Array.new
+          end
+          @backend[zone] << dnsblrr
+        end
+        
+        def get_all_records_for_zone(zone)
+          @backend[zone]
+        end
+        
+      end
+    end
+  end
+end

data/lib/eventmachine/dnsbl/zone/sqlite3_zone.rb

@@ -0,0 +1,61 @@
+require "eventmachine/dnsbl/zone/abstract_zone"
+require 'sqlite3'
+require 'resolv'
+require 'pp'
+
+module EventMachine
+  module DNSBL
+    module Zone
+      class Sqlite3Zone < AbstractZone
+        def initialize(sqlite3, tablename = "zone")
+          @class = DNSBLResourceRecord
+          @fields = @class.members.map {|x| x.to_s}.join(", ")
+          @tablename = tablename
+          if sqlite3.class == SQLite3::Database
+            @db = sqlite3
+          else
+            @db = SQLite3::Database.new(sqlite3)
+          end
+          if @db.table_info(tablename).length == 0
+            @db.execute("CREATE TABLE #{@tablename} (#{@fields})")
+          end            
+          @zones = Array.new
+          @backend = Hash.new
+        end
+        
+        def add_dnsblresource(dnsblrr)
+          dnsblrr.answer = dnsblrr.answer.address.to_s
+          args = (@class.members).map{|f| dnsblrr.send(f)}
+          qs = args.map{|x| "'#{quote(x.to_s)}'"}.join(",").gsub(/'NULL'/, "NULL")
+          zone = dnsblrr[:zone]
+          if not @zones.include?(zone)
+            @zones << zone
+            @zones = @zones.uniq.sort {|a,b| b.length <=> a.length}
+          end
+          sql = "INSERT INTO #{@tablename} (#{@fields}) VALUES (#{qs})"
+          @db.execute(sql)
+        end
+        
+        def get_records_by_field_and_value(field, value)
+          records = Array.new
+          rs = @db.execute("SELECT #{@fields} FROM #{@tablename} WHERE #{field}='#{value}'")
+          rs.each do |row|
+            row[1] = Regexp.new(row[1])
+            row[3] = Resolv::DNS::Resource::IN::A.new(row[3])
+            records << DNSBLResourceRecord.new(*row)
+          end
+          records
+        end
+        
+        def get_all_records_for_zone(zone)
+          get_records_by_field_and_value("zone", zone)
+        end
+        
+        def quote( string )
+          string.gsub( /'/, "''" )
+        end
+        private :quote
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+require 'minitest/test'
+require 'minitest/unit'
+include MiniTest::Assertions
+require File.expand_path('../../lib/eventmachine/dnsbl.rb', __FILE__)

data/test/test_dnsbl_client.rb

@@ -0,0 +1,38 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative 'helper'
+require 'eventmachine'
+include EventMachine::DNSBL
+require 'pp'
+
+
+class TestDNSBLClient < Minitest::Test
+  def run_test(item, expected_result)
+    EM.run do
+      EventMachine::DNSBL::Client.check(item) do |results|
+        pp results
+        assert_equal(expected_result, EventMachine::DNSBL::Client.blacklisted?(results))
+        EM.stop
+      end
+    end
+  end    
+  
+  def test_127_0_0_2
+    run_test("127.0.0.2", true)
+  end
+  def test_127_0_0_254
+    run_test("127.0.0.254", false)
+  end
+  def test_surbl
+    run_test("surbl-org-permanent-test-point.com", true)
+  end
+  def test_example_com
+    run_test("example.com", false)
+  end
+end

data/test/test_dnsbl_server.rb

@@ -0,0 +1,96 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative 'helper'
+#require 'eventmachine'
+require 'pp'
+
+#Monkeypatching for testing
+module EventMachine
+  module DNS
+    class Socket < EventMachine::Connection    
+      def send_packet(pkt)
+        send_datagram(pkt, nameserver, 2053)
+      end
+    end
+  end
+end
+
+class TestDNSBLServer < Minitest::Test
+  
+  def zone_add_test_resources(zone)
+    zone.add_dnsblresource(
+      EventMachine::DNSBL::Zone::DNSBLResourceRecord.new(
+        "example.com", 
+        /viagra/i, 
+        300, 
+        Resolv::DNS::Resource::IN::A.new("127.0.0.2"),
+        Time.now.to_i + 3600
+      )
+    )
+    zone.add_dnsblresource(
+      EventMachine::DNSBL::Zone::DNSBLResourceRecord.new(
+        "example.com", 
+        /pillz/i, 
+        300, 
+        Resolv::DNS::Resource::IN::A.new("127.0.0.3"),
+        Time.now.to_i + 3600
+      )
+    )
+  end
+  
+  def zone_test(zone)
+    zone_add_test_resources(zone)
+    recs = zone.get_records("viagrapillz.example.com", Resolv::DNS::Resource::IN::A)
+    assert(2, recs.length)
+    recs = zone.get_records("cialispillz.example.com", Resolv::DNS::Resource::IN::A)
+    assert(1, recs.length)
+  end
+    
+  def test_memory_zone
+    memzone = EventMachine::DNSBL::Zone::MemoryZone.new
+    zone_test(memzone)
+  end
+  
+  def test_sqlite3_zone
+    if File.exist?("test/test.sqlite3")
+      File.unlink("test/test.sqlite3")
+    end
+    sqlite3zone = EventMachine::DNSBL::Zone::Sqlite3Zone.new("test/test.sqlite3")
+    zone_test(sqlite3zone)
+    if File.exist?("test/test.sqlite3")
+      File.unlink("test/test.sqlite3")
+    end
+  end
+  
+  def test_dnsbl_server
+    memzone = EventMachine::DNSBL::Zone::MemoryZone.new
+    zone_add_test_resources(memzone)
+    completed = 0
+    EM.run {
+      EM::open_datagram_socket "0.0.0.0", 2053, EventMachine::DNSBL::Server, memzone
+      EM::DNS::Resolver.nameservers = ["127.0.0.1"]
+      r1 = EM::DNS::Resolver.resolve("viagrapillz.example.com")
+      r1.callback do |r|
+        assert_equal(2, r.length)
+        completed += 1
+        if completed == 2
+          EM.stop
+        end
+      end
+      r2 = EM::DNS::Resolver.resolve("cialispillz.example.com")
+      r2.callback do |r|
+        assert_equal(1, r.length)
+        completed += 1
+        if completed == 2
+          EM.stop
+        end
+      end
+    }
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: eventmachine-dnsbl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- chrislee35
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: For use in the Rubot Emulation Framework, I needed an EventMachine-based
+  implementation of a DNSBL checker and server.
+email:
+- rubygems@chrislee.dhs.org
+executables:
+- dnsbl-client
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/dnsbl-client
+- eventmachine-dnsbl.gemspec
+- lib/eventmachine/dnsbl.rb
+- lib/eventmachine/dnsbl/client.rb
+- lib/eventmachine/dnsbl/defaults.rb
+- lib/eventmachine/dnsbl/server.rb
+- lib/eventmachine/dnsbl/version.rb
+- lib/eventmachine/dnsbl/zone/abstract_zone.rb
+- lib/eventmachine/dnsbl/zone/memory_zone.rb
+- lib/eventmachine/dnsbl/zone/sqlite3_zone.rb
+- test/helper.rb
+- test/test_dnsbl_client.rb
+- test/test_dnsbl_server.rb
+homepage: https://github.com/chrislee35/eventmachine-dnsbl
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: EventMachine-based implementation of DNSBL checker and server
+test_files:
+- test/helper.rb
+- test/test_dnsbl_client.rb
+- test/test_dnsbl_server.rb