^^&&^^

Edit File: dnsbl.lua

--- A minimalistic DNS BlackList library implemented to facilitate querying
-- various DNSBL services. The current list of services has been implemented
-- based on the following compilations of services:
-- * http://en.wikipedia.org/wiki/Comparison_of_DNS_blacklists
-- * http://www.robtex.com
-- * http://www.sdsc.edu/~jeff/spam/cbc.html
--
-- The library implements a helper class through which script may access
-- the BL services. A typical script implementation could look like this:
--
-- <code>
-- local helper = dnsbl.Helper:new("SPAM", "short")
-- helper:setFilter('dnsbl.inps.de')
-- local status, result = helper:checkBL(host.ip)
-- ... formatting code ...
-- </code>
--
-- @author "Patrik Karlsson <patrik@cqure.net>"
--

local bit = require "bit"
local coroutine = require "coroutine"
local dns = require "dns"
local ipOps = require "ipOps"
local nmap = require "nmap"
local stdnse = require "stdnse"
local string = require "string"
local table = require "table"
_ENV = stdnse.module("dnsbl", stdnse.seeall)

-- The services table contains a list of valid DNSBL providers
-- Providers are categorized in categories that should contain services that
-- do DNS blacklist checks for that particular category.
--
-- Each service should be stored under a key that specifies the service name
-- and should contain:
-- <code>ns_type</code> - A table with a record type as key and mode as value
--   eg: { ["A"] = "short", ["TXT"] = "long" }.
--   If only short queries are supported using A records, this argument may be
--   omitted.
--
-- <code>resp_parser</code> - A function to parse the response received from
--   the DNS query. The function should take two arguments:
--     * <code>response</code> - the DNS response received by the server,
--       typically a code represented by an IP.
--     * <code>mode</code> - a string representing what mode (long|short) that
--       the function should parse. If <code>ns_type</code> does not contain
--       the TXT record, this argument and check can be omitted.
--   When the short mode is used, the function should return a table containing
--   the <code>state</code> field, or nil if the IP wasn't listed. When long
--   mode is used, the function should return additional information using the 
--  <code>details</code> field. Eg:
--     return { state = "SPAM" } -- short mode
--     return { state = "PROXY", details = {
--                           "Proxy is working",
--                           "Proxy was scanned"
--                          } -- long mode
--
-- <code>fmt_query</code> - A function responsible for formatting the DNS
--   query. When the default format is being used <reverse ip>.<servicename>
--   eg: 4.3.2.1.spam.dnsbl.sorbs.net, this function can be omitted. But if
--   this function is defined, it must return the query to be executed,
--   otherwise the library will assume that the provider needs configuration
--   that failed to be provided.
--
-- <code>configuration</code> - If the service requires the user to provide
--   configurations, this function will have to return a list with the name
--   and description of the arguments that provide the configuration/options.
--   If this function isn't specified, the library will assume the service
--   doesn't require configuration.
--                            
SERVICES = {
	
	SPAM = {
		
		["dnsbl.inps.de"] = {
			-- This service supports both long and short <code>mode</code>
			ns_type = {
				["short"] = "A",
				["long"] = "TXT",
			},
			-- Creates a new Service instance
			-- @param ip host that needs to be checked
			-- @param mode string (short|long) specifying whether short or long
			--        results are to be returned
			-- @param config service configuration in case this service provider
			--        needs user supplied configuration
			-- @return o instance of Helper
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			-- Sample fmt_query function, if no function is specified, the library
			-- will assume that the IP should be reversed add suffixed with the
			-- service name.
			fmt_query = function(self)
				local rev_ip = dns.reverse(self.ip):match("^(.*)%.in%-addr%.arpa$")
				return ("%s.spam.dnsbl.sorbs.net"):format(rev_ip)
			end,
			-- This function parses the response and supports borth long and
			-- short mode.
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "SPAM",
				}
				if ( ("short" == self.mode and r[1]) ) then
					return responses[r[1]]
				else
					return { state = "SPAM", details = { r[1] } }
				end
			end,
		},

["spam.dnsbl.sorbs.net"] = { 
			ns_type = {
				["short"] = "A"
			},
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				return ( r[1] == "127.0.0.6" and { state = "SPAM" } )
			end,
		},

["bl.nszones.com"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "SPAM",
					["127.0.0.3"] = "DYNAMIC"
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
	
		["all.spamrats.com"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.36"] = "DYNAMIC",
					["127.0.0.38"] = "SPAM",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["list.quorum.to"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				-- this service appears to return 127.0.0.0 when the service is
				-- "blocked because it has never been seen to send mail".
				-- This would essentially return every host as SPAM and we
				-- don't want that. 
				return ( ( r[1] and r[1] ~= "127.0.0.0" ) and { state = "SPAM" } ) 
			end
		},
		
		["sbl.spamhaus.org"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "SPAM",
					["127.0.0.3"] = "SPAM",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,		
		},
		
		["bl.spamcop.net"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "SPAM",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["dnsbl.ahbl.org"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.4"] = "SPAM",
					["127.0.0.5"] = "SPAM",
					["127.0.0.6"] = "SPAM",
					["127.0.0.7"] = "SPAM",
					["127.0.0.8"] = "SPAM",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["l2.apews.org"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "SPAM",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
	
	},

PROXY = {
		
		["dnsbl.tornevall.org"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				if ( "short" == self.mode and r[1] ) then
					return { state = "PROXY" }
				elseif ( "long" == self.mode ) then
					local responses = {
						[1]	= "Proxy has been scanned",
						[2]	= "Proxy is working",
						[4]	= "?",
						[8] 	= "Proxy was tested, but timed out on connection",
						[16]	= "Proxy was tested but failed at connection",
						[32]	= "Proxy was tested but the IP was different",
						[64]	= "IP marked as \"abusive host\"",
						[128]	= "Proxy has a different anonymous-state"
					}

local code = tonumber(r[1]:match("%.(%d*)$"))
					local result = {}

for k, v in pairs(responses) do
						if ( bit.band( code, k ) == k ) then
							table.insert(result, v)
						end
					end	
					return { state = "PROXY", details = result }
				end	
			end,
		},
		
		["ip-port.exitlist.torproject.org"] = {
			configuration = {
				["port"] = "the port to which the target can relay to",
				["ip"] = "the IP address to which the target can relay to"
			},
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			fmt_query = function(self)
				if ( not(self.config.port) or not(self.config.ip) ) then
					return
				end

local rev_ip = dns.reverse(self.ip):match("^(.*)%.in%-addr%.arpa$")
				return ("%s.%s.%s.ip-port.exitlist.torproject.org"):format(rev_ip,
						self.config.port, self.config.ip)
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "PROXY",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},

["tor.dan.me.uk"] = {
			ns_type = {
				["short"] = "A",
				["long"] = "TXT",
			},
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.100"] = "PROXY",
				}
				if ( "short" == self.mode and r[1] ) then
					return { state = responses[r[1]] }
				else
					local flagsinfo = {
						["E"] = "Exit",
						["A"] = "Authority",
						["B"] = "BadExit",
						["D"] = "V2Dir",
						["F"] = "Fast",
						["G"] = "Guard",
						["H"] = "HSDir",
						["N"] = "Named",
						["R"] = "Running",
						["S"] = "Stable",
						["U"] = "Unnamed",
						["V"] = "Valid"
					}

local name, ports, flagsfound = r[1]:match(
						"N:(.+)/P:([%d,]+)/F:([EABDFGHNRSUV]+)")

local flags = {}
					flags['name'] = "Flags"

for k, v in pairs(flagsinfo) do
						if flagsfound:match(k) then
							table.insert(flags, v)
						end
					end

local result = {
						("Name: %s"):format(name),
						("Ports: %s"):format(ports),
						flags
					}

return { state = "PROXY", details = result }
				end
			end,
		},
		
		["dnsbl.ahbl.org"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.3"] = "PROXY",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["http.dnsbl.sorbs.net"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.2"] = "PROXY",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["socks.dnsbl.sorbs.net"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.3"] = "PROXY",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		},
		
		["misc.dnsbl.sorbs.net"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
				local responses = {
					["127.0.0.4"] = "PROXY",
				}
				return ( r[1] and responses[r[1]] ) and { state = responses[r[1]] }
			end,
		}
			
	},

ATTACK = {
		["dnsbl.httpbl.org"] = {
			configuration = {
				["apikey"] = "the http:BL API key"
			},
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			fmt_query = function(self)
				if ( not(self.config.apikey) ) then
					return
				end

local rev_ip = dns.reverse(self.ip):match("^(.*)%.in%-addr%.arpa$")
				return ("%s.%s.dnsbl.httpbl.org"):format(self.config.apikey, rev_ip)
			end,
			resp_parser = function(self, r)
				if ( not(r[1]) ) then
					return
				end

local parts, err = ipOps.get_parts_as_number(r[1])

if ( not(parts) or err ) then
					-- TODO Should we return failure in the result?
					stdnse.print_debug("The dnsbl.httpbl.org provider failed to return a valid address")
					return
				end

local octet1, octet2, octet3, octet4 = table.unpack(parts)

if ( octet1 ~= 127 ) then
					-- This should'nt happen :P
					stdnse.print_debug(string.format(
						"The request made to dnsbl.httpbl.org was considered invalid (%i)", octet1))
				elseif ( "short" == self.mode ) then
					return { state = "ATTACK" }
				else
					local search = {
						[0] = "Undocumented",
						[1] = "AltaVista",
						[2] = "Ask",
						[3] = "Baidu",
						[4] = "Excite",
						[5] = "Google",
						[6] = "Looksmart",
						[7] = "Lycos",
						[8] = "MSN",
						[9] = "Yahoo",
						[10] = "Cuil",
						[11] = "InfoSeek",
						[12] = "Miscellaneous"
					}

local result = {}
					
					-- Search engines are a special case.
					if ( octet4 == 0 ) then
						table.insert(result, ("Search engine: %s"):format(
							search[octet3]))
					else
						table.insert(result, ("Last activity: %i days"):format(
							octet2))
						table.insert(result, ("Threat score: %i"):format(
							octet3))
						
						local activity = {}
						activity['name'] = "Activity"
						-- Suspicious activity
						if ( bit.band(octet4, 1) == 1) then
							table.insert(activity, "Suspicious")
						end

-- Harvester
						if ( bit.band(octet4, 2) == 2) then
							table.insert(activity, "Harvester")
						end

-- Comment spammer
						if ( bit.band(octet4, 4)  == 4) then
							table.insert(activity, "Comment spammer")
						end
						
						table.insert(result, activity)
					end

return { state = "ATTACK", details = result }
				end
			end,
		},

["all.bl.blocklist.de"] = {
			new = function(self, ip, mode, config)
				local o = { ip = ip, mode = mode, config = config }
				setmetatable(o, self)
				self.__index = self
				return o
			end,
			resp_parser = function(self, r)
 				local responses = {
 					["127.0.0.2"] = "Amavis",
 					["127.0.0.3"] = "DDoS",
 					["127.0.0.4"] = "Asterisk, SIP, VoIP",
 					["127.0.0.5"] = "Badbot",
 					["127.0.0.6"] = "FTP",
 					["127.0.0.7"] = "IMAP",
 					["127.0.0.8"] = "IRC bot",
 					["127.0.0.9"] = "Mail",
 					["127.0.0.10"] = "POP3",
 					["127.0.0.11"] = "Registration bot",
 					["127.0.0.12"] = "Remote file inclusion",
 					["127.0.0.13"] = "SASL",
 					["127.0.0.14"] = "SSH",
 					["127.0.0.15"] = "w00tw00t",
 					["127.0.0.16"] = "Port flood",
 				}
 				if ( "short" == self.mode and r[1] ) then
 					return "ATTACK"
 				else
 					return ( r[1] and responses[r[1]] ) and { state = "ATTACK",
 						details = {
 							("Type: %s"):format(responses[r[1]])
 						}
 					}
 				end
 			end,
 		}
	},
	
}

Helper = {
	
	-- Creates a new Helper instance
	-- @param category string containing a valid DNSBL service category
	-- @param mode string (short|long) specifying whether short or long
	--        results are to be returned
	-- @return o instance of Helper
	new = function(self, category, mode)
		local o = { category = category:upper(), mode = mode }
		assert(category and SERVICES[category:upper()], "Invalid category was supplied, aborting")
		setmetatable(o, self)
		self.__index = self
		return o
	end,
    
	-- Lists all DNSBL services for the category
	-- @return services table of service names
	listServices = function(self)
		local services = {}
		for name, svc in pairs(SERVICES[self.category]) do
			if ( svc.configuration ) then
				local service = {}
				service['name'] = name

for config, description in pairs(svc.configuration) do
					table.insert(service, ("config: %s.%s - %s"):format(
						name, config, description))
				end

table.insert(services, service )
			else
				table.insert(services, name)
			end
		end
		return services		
	end,
	
	-- Validates the filter set by setFilter to make sure it contains only
	-- valid service names.
	-- @return status boolean, true on success false on failure
	-- @return err string containing an error message on failure
	validateFilter = function(self)
	
		if ( not(self.filterstr) ) then
			return true
		end
	
		local all = SERVICES[self.category]
		self.filter = {}
		for _, f in pairs(stdnse.strsplit(",%s*", self.filterstr)) do
			if ( not(SERVICES[self.category][f]) ) then
				self.filter = nil
				return false, ("Service does not exist '%s'"):format(f)
			end
			self.filter[f] = true
		end
		return true
	end,
	
	-- Sets a new service filter to choose only a limited subset of services
	-- within a category.
	-- @param filter string containing a comma separated list of service names
	setFilter = function(self, filter) self.filterstr = filter end,
	
	-- Gets a list of filtered services, or all services if no filter is in use
	-- @return services table containing a list of services
	getServices = function(self)
		if ( not(self:validateFilter()) ) then
			return nil
		end
		
		if ( self.filter ) then
			local filtered = {}
			for name, svc in pairs(SERVICES[self.category]) do
				if ( self.filter[name] ) then
					filtered[name] = svc
				end
			end
			return filtered
		else
			return SERVICES[self.category]
		end
	end,
	
	doQuery = function(self, ip, name, svc, answers)

local condvar = nmap.condvar(answers)
		local config = {}

if ( svc.configuration ) then
			for key in pairs(svc.configuration) do
				config[key] = stdnse.get_script_args(("%s.%s"):format(name, key))
			end
		end

svc = svc:new(ip, self.mode, config)

local ns_type = ( svc.ns_type and svc.ns_type[self.mode] ) and svc.ns_type[self.mode] or "A"
		local query

if ( not(svc.fmt_query) ) then
			local rev_ip = dns.reverse(ip):match("^(.*)%.in%-addr%.arpa$")
			query = ("%s.%s"):format(rev_ip, name)
		else
			query = svc:fmt_query()
		end

if ( query ) then
			local status, answer = dns.query(query, {dtype=ns_type, retAll=true} )
			answers[name] = { status = status, answer = answer, svc = svc }
		else
			stdnse.print_debug("Query function returned nothing, skipping '%s'", name)
		end
		
		condvar "signal"
	end,
	
	-- Runs the DNS blacklist check for the given IP against all non-filtered
	-- services in the given category.
	-- @param ip string containing the IP address to check
	-- @return result table containing the results of the BL checks
	checkBL = function(self, ip)
		local result, answers, threads = {}, {}, {}
		local condvar = nmap.condvar(answers)
		
		for name, svc in pairs(self:getServices()) do
			local co = stdnse.new_thread(self.doQuery, self, ip, name, svc, answers)
			threads[co] = true
		end

repeat
			for t in pairs(threads) do
				if ( coroutine.status(t) == "dead" ) then threads[t] = nil end
			end
			if ( next(threads) ) then
				condvar "wait"
			end
		until( next(threads) == nil )
		
		for name, answer in pairs(answers) do
			local status, answer, svc = answer.status, answer.answer, answer.svc
			if ( status ) then
				local svc_result = svc:resp_parser(answer)
				if ( not(svc_result) ) then
					local resp = ( #answer > 0 and ("UNKNOWN (%s)"):format(answer[1]) or "UNKNOWN" )
					stdnse.print_debug(2, ("%s received %s"):format(name, resp))
				end
	
				if ( svc_result ) then
					table.insert(result, { name = name, result = svc_result })
				end

-- if status is false, and the response was "No Such Name", it
				-- simply means that the IP isn't listed, we haven't failed at
				-- this point. It would obviously be better to check this against
				-- an error code, or in some other way, but this is what we've got.
			elseif ( answer ~= "No Such Name" ) then
				table.insert(result, { name = name, result = { state = "FAIL" }})
			end
		end
		return result
	end,

}

return _ENV;