def autoroot(api_key, thread_count=10):

        api = WebAPI(api_key)
        search_queries = ['Server: Linux, HTTP/1.1, DIR','Mathopd/1.5p6' ]#, 'Server: Linux, HTTP/1.1, DIR-300']
        for query in search_queries:
            count = 0
            page = 1
            total = 0

            while True:
                results = api.search(query)
                if total == 0:
                    total = int(results['total'])
                    print('Results found: %s' % results['total'])
                    print('Countries found: ')
                    pprint(results['countries'])
                    raw_input('press enter to start hacking')
                dm = DlinkManager(results['matches'],thread_count=10)
                dm.run()
                page += 1
                count += len(results['matches'])
                if count == total:
                    break

        print("Rooted routers count: %i" % len(rooted))
        print(rooted)

	def locateip(self, data):
		if '!locateip' in data['recv']:
			args = argv('!locateip',data['recv'])
			api = WebAPI("KpYC07EoGBtGarTFXCpjsspMVQ0a5Aus")#don look
			query = args['argv'][1]
			try:
				socket.inet_aton(query)
			except socket.error:
				return None
			results = api.host(query)
			output = []
			output.append('OS: ' + str(results['os']))
			output.append('City: ' + str(results['city']) + '\tPostal code: ' + str(results['postal_code']))
			output.append('Area code: ' + str(results['area_code']) + '\t\tCountry code: ' + str(results['country_code']))
			output.append('Region name: ' + str(results['region_name']) + '\tCountry name: ' + str(results['country_name']))
			output.append('Latitude: ' + str(results['latitude']) + '\tLongitude: ' + str(results['longitude']))
			ports = []
			for data in results['data']:
				port = data['port']
				if not str(port) in ports:
					ports.append(str(port))
			output.append('Open ports: ' + ', '.join(ports))
			ircoutput = ''
			for line in output:
				ircoutput += say(args['channel'],line)
			return ircoutput

class Shodan:
    """ Clase para buscar en Shodan """
    def __init__(self,API_KEY):
        self.api =  WebAPI(API_KEY)    

    def buscar(self,cadena):
        """ Busca segun la cadena dada """
        try:
           # Buscamos lo de la cadena pasada como parametro
	   resultado = self.api.search(str(cadena))
	   return resultado
        except Exception as e:
	   print 'Ups! Ha ocurrido un error: %s' % e
	   resultado = []
	   return resultado

        
    def obtener_info_host(self,IP):
        """ Obtiene la info que pueda tener shodan sobre una IP """
        try:
	    host = self.api.host(IP)
	    return host
	except Exception as e:
	    print 'Ups! Ha ocurrido un error: %s' % e
	    host = []
	    return host	    

def shodan_search(search, apikey, pages):
    from shodan import WebAPI

    if apikey:
        API_KEY = apikey
    else:
        API_KEY = 'ENTER YOUR API KEY HERE AND KEEP THE QUOTES'

    api = WebAPI(API_KEY)

    ips_found = []

    try:
        results = api.search(search, page=1)
        total_results = results['total']
        print '[+] Results: %d' % total_results
        print '[*] Page 1...'
        pages = max_pages(pages, total_results)
        for r in results['matches']:
            ips_found.append(r['ip'])

        if pages > 1:
            i = 2
            while i <= pages:
                results = api.search(search, page=i)
                print '[*] Page %d...' % i
                for r in results['matches']:
                    ips_found.append(r['ip'])
                i += 1

        return ips_found

    except Exception as e:
        print '[!] Shodan search error:', e

    def run(self, info):

        # This is where we'll collect the data we'll return.
        results = []

        # Skip unsupported IP addresses.
        if info.version != 4:
            return
        ip = info.address
        parsed = netaddr.IPAddress(ip)
        if parsed.is_loopback() or \
           parsed.is_private()  or \
           parsed.is_link_local():
            return

        # Query Shodan for this host.
        try:
            key = self.get_api_key()
            api = WebAPI(key)
            shodan = api.host(ip)
        except Exception, e:
            tb = traceback.format_exc()
            Logger.log_error("Error querying Shodan for host %s: %s" % (ip, str(e)))
            Logger.log_error_more_verbose(tb)
            return

def shodanquery(query, api_key=None):
	if not api_key or api_key == "":
		return False
	api = WebAPI(api_key)
	if is_valid_ipv4(query):
		try:
			response = api.host(query)
		except:
			return False
	else:
		try:
			response = api.search(query)
		except:
			return False
	return response

class fingershodan:
	
	def __init__(self,search,typeSearch):		
		self.search = search
		self.typeSearch = typeSearch
		self.searchList = {}
		self.allCount = 0
		self.__initKey()
		self.__switchSearch()
		
	def __initKey(self):
			self.api = WebAPI("CvXzhcMm3YemfeNnNKE7ed9xRSCKfAhY")
				
	def __switchSearch(self):
		if self.typeSearch=="search":
			self.__execSearch()
		elif self.typeSearch=="lookup":
			self.search = socket.gethostbyname(self.search)
			self.webHost = self.api.host(self.search)
			self.__execLookup()
		#elif self.typeSearch=="mac":
		#	self.__macLocation()
			
	
	def __execSearch(self):
		searched = self.api.search(self.search)
		for search in searched["matches"]:
			try:
				self.searchList["Result "+str(self.allCount)] = {"Ip":search["ip"],"Updated":search["updated"],
				"Country":search["country_name"],"Latitude":search["latitude"],"Longitude":search["longitude"],
				"Port":search["port"],"Data":search["data"],"Os":search["os"]}
				self.allCount += 1
			except:
				continue
	
	def __execLookup(self):
		try:
			self.searchList["Result "+str(self.allCount)] = {"Ip":self.webHost["ip"],"Country":self.webHost["country_name"],"City":self.webHost["city"],
			"Os":self.webHost["os"],"Banner":self.webHost["data"][0]["banner"],"Port":self.webHost["data"][0]["port"],
			"TimeStamp":self.webHost["data"][0]["timestamp"]}
		except:
			print "Fail Lookup"
	
	#def __macLocation(self):

		
	def _returnData(self):
		return self.searchList

	def __init__(self,host):
		self.host=host
		self.key = ""
		if self.api =="":
			print "You need an API key in order to use SHODAN database. You can get one here: http://www.shodanhq.com/"
			sys.exit()
		self.api = WebAPI(self.key)

def shodan_search(search, apikey):
    if apikey:
        API_KEY = args.apikey
    else:
        API_KEY = 'ENTER YOUR API KEY HERE AND KEEP THE QUOTES'
    api = WebAPI(API_KEY)

    ips_found = []

    try:
        results = api.search('%s' % search)
        print '[+] Results: %s' % results['total']
        for r in results['matches']:
            ips_found.append(r['ip'])
        return ips_found
    except Exception as e:
        print '[!] Error:', e

	def __init__(self,host):
		self.host=host
		self.shodan_api_key = "oykKBEq2KRySU33OxizNkOir5PgHpMLv"

		if self.shodan_api_key =="":
			print "You need an API key in order to use SHODAN database. You can get one here: http://www.shodanhq.com/"
			sys.exit()

		self.api = WebAPI(self.shodan_api_key)

def shodan_search(search, apikey, pages):
    from shodan import WebAPI

    if apikey:
        API_KEY = apikey
    else:
        API_KEY = "ENTER YOUR API KEY HERE AND KEEP THE QUOTES"

    api = WebAPI(API_KEY)

    ips_found = []

    try:
        results = api.search(search, page=1)
        total_results = results["total"]
        print "[+] Results: %d" % total_results
        print "[*] Page 1..."
        pages = max_pages(pages, total_results)
        for r in results["matches"]:
            # Replace the following ports with port 80 since they'll virtually never have a web server running
            # ftp, ssh, telnet, smtp, smtp, netbios x3, smb
            if r["port"] in [21, 22, 23, 25, 26, 137, 138, 139, 445]:
                r["port"] = 80
            ips_found.append("%s:%s" % (r["ip"], r["port"]))

        if pages > 1:
            i = 2
            while i <= pages:
                results = api.search(search, page=i)
                print "[*] Page %d..." % i
                for r in results["matches"]:
                    ips_found.append(r["ip"])
                i += 1

        return ips_found

    except Exception as e:
        print "[!] Shodan search error:", e

def shodan_frame(port):

	# Currently Supports query based on port Filter only and Displays Corresponding IP
	print colored("\n[!] Shodan Search Module For NoSQL Framework Launched.....",'yellow')
	api = WebAPI("API KEY GOES HERE")
	if port == 5984:
		query='{"couchdb":"Welcome","version":""}'
	else:
		query='port:%s'%(port)
	result = api.search(query)
	print colored("[-] Would Like to write the Results to a File",'green')
	choice=raw_input()
	if choice.lower()=='y':
		file=open('shodan-%s.txt'%(port),'w')
		for host in result['matches']:
			file.write(host['ip']+"\n")
		print colored('[-] File to %s/shodan-%s.txt'%(os.getcwd(),port),'green')
		file.close()
	else:

		print colored("[-] Printing Found IP \n",'blue')
		for host in result['matches']:
			print colored("[-] "+host['ip'],'green')

def main(queue):

	# Connect to Shodan
	api = WebAPI(API_KEY)

	# get the first page of results
	res = api.search(filter)

	#keep track of how many results we have left
	#total_results = res['total']
	total_results = res.get('total', 0)

	# Start looping through results now
	page = 1
	try:
		while(page * 100 <= total_results):
			#check the matches to see if they fit what we are looking for
			for host in res['matches']:
				queue.put_nowait(host['ip'])
			page +=1
			res = api.search(filter,page)
	except Exception, e:
		print e

class CamScanner(object):
    filter = "netcam"

    def __init__(self, shodan_api_key):
        self.api_key = shodan_api_key
        self.api = WebAPI(self.api_key)

    def cam_available(self, url):
        try:
            resp = urlopen(url, None, 10)
        except (URLError, timeout):
            print "Failed to contact cam: %s" % url
            return False
        else:
            if resp.code == 200:
                return True
            print "Bad resp code: %d" % resp.code
            return False

    def get_cams(self):
        results = self.api.search(self.filter)
        total_pages = (results["total"] / 50) + 1
        current_page = 1
        skip = False
        while current_page <= total_pages:
            if not skip:
                for result in results["matches"]:
                    url = "http://%s/anony/mjpg.cgi" % result["ip"]
                    if self.cam_available(url):
                        yield url, result.get("latitude"), result.get("latitude")
            current_page += 1
            try:
                results = self.api.search(self.filter, page=current_page)
            except URLError:
                print "Failed to GET page %d" % current_page
                skip = True

class search_shodan():
	def __init__(self,host):
		self.host=host
		self.key = ""
		if self.api =="":
			print "You need an API key in order to use SHODAN database. You can get one here: http://www.shodanhq.com/"
			sys.exit()
		self.api = WebAPI(self.key)
	def run(self):
		try:
			host = self.api.host(self.host)
			return host['data']
		except:
			#print "SHODAN empty reply or error in the call"
			return "error"

class shodan_plug(PluginBase):
    """This plugin returns any information from Shodan"""
    name    =    'shodan'
    title   =    'Shodan'
    description   =  'Computer Search Engine'
    cache_timeout   =  60*60*2
    types   =    ['ip']
    remote = False

    def setup(self):
        from shodan import WebAPI
        self.api = WebAPI(self.plugin_config["api_key"])

    def get_info(self, arg):
        info = self.api.host(arg)
        return info

	def __init__(self, queue, tid, cli) :
		threading.Thread.__init__(self)
		self.queue = queue
		self.tid = tid
        	self.cli = cli
		self.bruteForcePorts ={'ftpBrute':21, 'sshBrute':22}
		if self.cli.useShodan == True:
			#Using Shodan to search information about this machine in shodan database.
			log.info("[+] Shodan Activated. About to read the Development Key. ")
			if self.cli.shodanKey == None:
				#If the key is None, we can't use shodan.
				log.warn("[-] Shodan Key's File has not been specified. We can't use shodan without a valid key")
			else:
				#Read the shodan key and create the WebAPI object.
				shodanKey = open(self.cli.shodanKey).readline().rstrip('\n')
				self.shodanApi = WebAPI(shodanKey)
				log.info("[+] Connected to Shodan. ")

class ShodanScanner(object):

    def __init__(self, KEY):
	self.api = WebAPI(KEY)

    def searchShodan(self, search_string):
	try:
	    filename = 'ips.txt'
	    fp = open(filename, 'w');
	    self.results = self.api.search(search_string)
	    for result in self.results['matches']:
		print result['ip'], str(result['latitude']), str(result['longitude'])
		fp.write(result['ip']+' '+str(result['latitude'])+','+str(result['longitude'])+'\n')
		for name in result['hostnames']:
		    print name
		print result['data']
	    print '***%s results with \"%s\"***' % (self.results['total'], search_string)
	    fp.close()
	except Exception, e:
	    print 'Error: %s' % e

 def __init__(self, shodan_api_key):
     self.api_key = shodan_api_key
     self.api = WebAPI(self.api_key)

'''
Created on Feb 22, 2014

@author: Zhu Yirong
'''

from shodan import WebAPI
SHODAN_API_KEY = "CUn5UHoYD784Z3AlfUdvulRjiP2oUBfm"
api= WebAPI(SHODAN_API_KEY)
# Wrap the request in a try/ except block to catch errors
try:
    # Search Shodan
    results = api.search('apache')
    print results
    # Show the results
    for result in results['matches']:
        if '200 OK' in result['data']:
            print 'IP: %s' % result['ip']

except Exception, e:
    print 'Error: %s' % e