from selenium import webdriver
import unittest

class RegisterNewUser(unittest.TestCase):
　　def setUp(self):
　　　　self.driver = webdriver.Firefox
　　　　self.driver.implicitly_wait(30)
　　　　self.driver.maximize_window()

　　　　# navigate to the application home page
　　　　self.driver.get("http://demo.magentocommerce.com/")

def test_register_new_user(self):
    driver = self.driver

　　# click on Log In link to open Login page
　　driver.find_element_by_link_text("Log In").click()

# get the Create Account button
　　　　create_account_button = driver.find_element_by_xpath("//
button[@title='Create an Account']")

　　　　# check Create Account button is displayed and enabled
　　　　self.assertTrue(create_account_button.is_displayed() and
　　　　　　　　　　　　create_account_button.is_enabled())

# click on Create Account button. This will display
# new account
create_account_button.click()

# check title
self.assertEquals("Create New Customer Account -
　Magento Commerce Demo Store", driver.title)

# get all the fields from Create an Account form
first_name = driver.find_element_by_id("firstname")
last_name = driver.find_element_by_id("lastname")
email_address = driver.find_element_by_id("email_address")
news_letter_subscription =
　driver.find_element_by_id("is_subscribed")
password = driver.find_element_by_id("password")
confirm_password = driver.find_element_by_id("confirmation")
submit_button =
　driver.find_element_by_xpath("//button[@title='Submit']")

# check maxlength of first name and last name textbox
self.assertEqual("255", first_name.get_attribute("maxlength"))
self.assertEqual("255", last_name.get_attribute("maxlength"))

# check all fields are enabled
　　　　self.assertTrue(first_name.is_enabled()and last_name.is_enabled()
　　　　　 and email_address.is_enabled() and news_letter_subscription.is_enabled()
　　　　　 and password.is_enabled() and confirm_password.is_enabled()
　　　　　 and submit_button.is_enabled())

# check Sign Up for Newsletter is unchecked
　　　　self.assertFalse(news_letter_subscription.is_selected())

# check new user is registered
self.assertEqual("Hello, Test User1!", driver.find_
　　element_by_css_selector("p.hello > strong").text)
self.assertTrue(driver.find_element_by_link_text("LogOut").is_displayed())

from selenium import webdriver
from time import gmtime, strftime 
import unittest

class RegisterNewUser(unittest.TestCase):
　　def setUp(self):
　　　　self.driver = webdriver.Firefox()
　　　　self.driver.implicitly_wait(30)
　　　　self.driver.maximize_window()

　　　　# navigate to the application home page
　　　　self.driver.get("http://demo.magentocommerce.com/")

　　def test_register_new_user(self):
　　　　driver = self.driver

　　　　# click on Log In link to open Login page
　　　　driver.find_element_by_link_text("ACCOUNT").click()
　　　　driver.find_element_by_link_text("My Account").click()

　　　　# get the Create Account button
　　　　create_account_button = \
　　　　　　driver.find_element_by_link_text("CREATE AN ACCOUNT")

　　　　# check Create Account button is displayed
　　　　# and enabled
　　　　self.assertTrue(create_account_button.
　　　　　is_displayed() and
　　　　　create_account_button.is_enabled())

　　　　# click on Create Account button. This will
　　　　# display new account
　　　　create_account_button.click()

　　　　# check title
　　　　self.assertEquals("Create New Customer Account", driver.title)

　　　　# get all the fields from Create an Account form
　　　　first_name = driver.find_element_by_id("firstname")
　　　　last_name = driver.find_element_by_id("lastname")
　　　　email_address = driver.find_element_by_id("email_address")
　　　　password = driver.find_element_by_id("password")
　　　　confirm_password = driver.find_element_by_id("confirmation")
　　　　news_letter_subscription = driver.find_element_by_id("is_subscribed")
　　　　submit_button = driver.\find_element_by_xpath ("//button[@title='Register']")

　　　　# check maxlength of first name and
　　　　# last name textbox
　　　　self.assertEqual("255", first_name.get_attribute("maxlength"))
　　　　self.assertEqual("255", last_name.get_attribute("maxlength"))

　　　　# check all fields are enabled
　　　　self.assertTrue(first_name.is_enabled()
　　　　　and last_name.is_enabled()
　　　　　and email_address.is_enabled() and
　　　　　news_letter_subscription.is_enabled() and
　　　　　password.is_enabled() and
　　　　　confirm_password.is_enabled()
　　　　　and submit_button.is_enabled())

　　　　# check Sign Up for Newsletter is unchecked
　　　　self.assertFalse(news_letter_subscription. is_selected())

　　　　user_name = "user_" + strftime ("%Y%m%d%H%M%S", gmtime())

　　　　# fill out all the fields
　　　　first_name.send_keys("Test")
　　　　last_name.send_keys(user_name)
　　　　news_letter_subscription.click()
　　　　email_address.send_keys(user_name + "@example.com")
　　　　password.send_keys("tester")
　　　　confirm_password.send_keys("tester")

　　　　# click Submit button to submit the form
　　　　submit_button.click()

　　　　# check new user is registered
　　　　self.assertEqual("Hello, Test " + user_name + "!",
　　　　　 driver.find_element_by_css_selector("p.hello >strong").text)
　　　　driver.find_element_by_link_text("ACCOUNT").click()
　　　　self.assertTrue(driver.find_element_by_link_text ("Log Out").is_displayed())

　　def tearDown(self):
　　　　self.driver.quit()

if __name__ == "__main__":
　　unittest.main(verbosity=2)

def test_language_options(self):
　　# list of expected values in Language dropdown
　　exp_options = ["ENGLISH", "FRENCH", "GERMAN"]

　　# empty list for capturing actual options displayed
　　# in the dropdown
　　act_options = []

　　# get the Your language dropdown as instance of Select class
　　select_language = \
　　　　Select(self.driver.find_element_by_id("select-language"))

　　# check number of options in dropdown
　　self.assertEqual(2, len(select_language.options))

　　# get options in a list 
　　for option in select_language.options:
　　　　act_options.append(option.text)

　　# check expected options list with actual options list
　　self.assertListEqual(exp_options, act_options)

　　# check default selected option is English
　　self.assertEqual("ENGLISH", select_language.first_selected_option. text)

　　# select an option using select_by_visible text
　　select_language.select_by_visible_text("German")

　　# check store is now German
　　self.assertTrue("store=german" in self.driver.current_url)

　　# changing language will refresh the page,
　　# we need to get find language dropdown once again
　　select_language = \
　　　 Select(self.driver.find_element_by_id("select-language"))
　　　　select_language.select_by_index(0)

# select an option using select_by_visible text
select_language.select_by_visible_text("German")

# check store is now German
self.assertTrue("store=german" in self.driver.current_url)

from selenium import webdriver
import unittest

class CompareProducts(unittest.TestCase):
　　def setUp(self):
　　　　self.driver = webdriver.Firefox()
　　　　self.driver.implicitly_wait(30)
　　　　self.driver.maximize_window()
　　　　self.driver.get("http://demo.magentocommerce.com/")

　　def test_compare_products_removal_alert(self):
　　　　# get the search textbox
　　　　search_field = self.driver.find_element_by_name("q")
　　　　search_field.clear()

　　　　# enter search keyword and submit
　　　　search_field.send_keys("phones")
　　　　 search_field.submit()

　　　　# click the Add to compare link
　　　　self.driver.\
　　　　　　find_element_by_link_text("Add to Compare").click()

# click on Remove this item link, this will display
　　# an alert to the user
　　self.driver.find_element_by_link_text("Clear All").click()

　　# switch to the alert
　　alert = self.driver.switch_to_alert()

　　# get the text from alert
　　alert_text = alert.text

　　# check alert text
　　self.assertEqual("Are you sure you would like to
　　　remove all products from your comparison?", alert_text)

　　# click on Ok button
	alert.accept()

　　def tearDown(self):
　　　　self.driver.quit()

if __name__ == "__main__":
　　　unittest.main()

import unittest
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions

class NavigationTest(unittest.TestCase):
　　def setUp(self):
　　　# create a new Firefox session
　　　self.driver = webdriver.Chrome()
　　　self.driver.implicitly_wait(30)
　　　self.driver.maximize_window()

　　　# navigate to the application home page
　　　self.driver.get("http://www.google.com")

　　def testBrowserNavigation(self):
　　　driver = self.driver
　　　# get the search textbox
　　　search_field = driver.find_element_by_name("q")
　　　search_field.clear()

　　　# enter search keyword and submit
　　　search_field.send_keys("selenium webdriver")
　　　search_field.submit()

　　　se_wd_link = driver.find_element_by_link_text("Selenium WebDriver")
　　　se_wd_link.click()
　　　self.assertEqual("Selenium WebDriver", driver.title)

　　　driver.back()
　　　self.assertTrue(WebDriverWait(self.driver, 10)
　　　　　.until(expected_conditions.title_is
　　　　　　("selenium webdriver - Google Search")))

　　　driver.forward()
　　　self.assertTrue(WebDriverWait(self.driver, 10)
　　　　　.until(expected_conditions.title_is
　　　　　　("Selenium WebDriver")))

　　　driver.refresh()
　　　self.assertTrue(WebDriverWait(self.driver, 10)
　　　　.until(expected_conditions.title_is
　　　　　("Selenium WebDriver")))

　　def tearDown(self):
　　　# close the browser window
　　　self.driver.quit()

if __name__ == '__main__':
　　unittest.main()

import unittest
from selenium import webdriver

class SearchProductTest(unittest.TestCase):
　　def setUp(self):
　　　　# create a new Firefox session
　　　　self.driver = webdriver.Firefox()
　　　　self.driver.implicitly_wait(30)
　　　　self.driver.maximize_window()

　　　　# navigate to the application home page
　　　　self.driver.get("http://demo.magentocommerce.com/")

　　def test_search_by_category(self):
　　　　# get the search textbox
　　　　self.search_field = self.driver.find_element_by_name("q")
　　　　self.search_field.clear()

　　　　# enter search keyword and submit
　　　　self.search_field.send_keys("phones")
　　　　self.search_field.submit()
       # get all the anchor elements which have product names
　　　　# displayed currently on result page using
　　　　# find_elements_by_xpath method
　　　　products = self.driver\
　　　　　　.find_elements_by_xpath("//h2[@class='product-name']/a")

　　　　# check count of products shown in results
　　　　self.assertEqual(2, len(products))

　　def tearDown(self):
　　　　# close the browser window
　　　　self.driver.quit()

if __name__ == '__main__':
　　unittest.main(verbosity=2)

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions
import unittest

class ExplicitWaitTests(unittest.TestCase):
　　def setUp(self):
　　　　self.driver = webdriver.Firefox()
　　　　self.driver.get("http://demo.magentocommerce.com/")

　　def test_account_link(self):
　　　　WebDriverWait(self.driver, 10)\
　　　　　　.until(lambda s: s.find_element_by_id("select-
　　　　　　　language").get_attribute("length") == "3")
　　　　account = WebDriverWait(self.driver, 10)\
　　　　　　.until(expected_conditions.
　　　　　　　visibility_of_element_located
　　　　　　　　　((By.LINK_TEXT, "ACCOUNT")))
　　　　account.click()

　　def tearDown(self):
　　　　self.driver.quit()

if __name__ == "__main__":
　　unittest.main(verbosity=2)

def test_create_new_customer(self):
　　# click on Log In link to open Login page
　　self.driver.find_element_by_link_text("ACCOUNT").click()

　　# wait for My Account link in Menu
　　my_account = WebDriverWait(self.driver, 10)\
　　　　.until(expected_conditions.visibility_of_element_located((By.
　　LINK_TEXT, "My Account")))
　　my_account.click()

　　# get the Create Account button
　　create_account_button = WebDriverWait(self.driver, 10)\
　　　　.until(expected_conditions.element_to_be_clickable((By.LINK_
　　　　TEXT, "CREATE AN ACCOUNT")))

　　# click on Create Account button. This will displayed new account
　　create_account_button.click()
　　WebDriverWait(self.driver, 10)\
　　　　.until(expected_conditions.title_contains("Create New Customer Account"))

from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions
import unittest

class CompareProducts(unittest.TestCase):
　　def setUp(self):
　　　　self.driver = webdriver.Firefox()
　　　　self.driver.get("http://demo.magentocommerce.com/")

　　def test_compare_products_removal_alert(self):
　　　　# get the search textbox
　　　　search_field = self.driver.find_element_by_name("q")
　　　　search_field.clear()

　　　　# enter search keyword and submit
　　　　search_field.send_keys("phones")
　　　　search_field.submit()

　　　　# click the Add to compare link
　　　　self.driver.\
　　　　　　find_element_by_link_text("Add to Compare").click()

　　　　# wait for Clear All link to be visible
　　　　clear_all_link = WebDriverWait(self.driver, 10)\
　　　　　　.until(expected_conditions.visibility_of_element_
　　　　　　located((By.LINK_TEXT, "Clear All")))

　　　　# click on Clear All link,
　　　　# this will display an alert to the user
　　　　clear_all_link.click()

　　　　# wait for the alert to present
　　　　alert = WebDriverWait(self.driver, 10)\
　　　　　　.until(expected_conditions.alert_is_present())

　　　　# get the text from alert
　　　　alert_text = alert.text

　　　　# check alert text
　　　　self.assertEqual("Are you sure you would like
　to remove all products from your comparison?", alert_text)
　　　　# click on Ok button
　　　　alert.accept()

　　def tearDown(self):
　　　　self.driver.quit()

if __name__ == "__main__":
　　unittest.main(verbosity=2)

def testLoginLink(self):
　　WebDriverWait(self.driver, 10).until
　　　(lambda s: s.find_element_by_id
　　　("select-language").get_attribute("length") == "3")
　
　　login_link = WebDriverWait
　　　(self.driver, 10).until(expected_conditions.
　　　 visibility_of_element_located((By.LINK_TEXT,"Log In")))
　　　 login_link.click();

from selenium import webdriver

driver = webdriver.Firefox()
driver.implicitly_wait(30)
driver.maximize_window()

driver.get("https://www.baidu.com/")

search_field = driver.find_element_by_id('kw')
search_field.clear()

search_field.send_keys('wust')
search_field.submit()
# search_field.send_keys(Keys.RETURN)

products = driver.find_elements_by_xpath("//h3[@class='t']/a")

print('Found ' + str(len(products)) + ' products:')

for product in products:
    print(product.text)

driver.quit()

# searchtests.py
import unittest
from selenium import webdriver


class SearchTests(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.driver.implicitly_wait(30)
        self.driver.maximize_window()

        self.driver.get('https://www.baidu.com')

    def test_search_by_category(self):
        self.search_field = self.driver.find_element_by_id('kw')
        self.search_field.clear()

        self.search_field.send_keys('WUST')
        self.search_field.submit()

        products = self.driver.find_elements_by_xpath("//h3[@class='t']/a")
        self.assertEqual(7, len(products))

    def test_search_by_name(self):
        self.search_field = self.driver.find_element_by_id('kw')
        self.search_field.clear()

        self.search_field.send_keys('HUST')
        self.search_field.submit()

        products = self.driver.find_elements_by_xpath("//h3[@class='t']/a")
        self.assertEqual(8, len(products))

    def tearDown(self):
        self.driver.quit()


if __name__ == '__main__':
    unittest.main(verbosity=8)

# searchtests_with_class_method.py
import unittest
from selenium import webdriver


class SearchTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Firefox()
        cls.driver.implicitly_wait(30)
        cls.driver.maximize_window()

        cls.driver.get('https://www.baidu.com')
        cls.driver.title

    def test_search_by_category(self):
        self.search_field = self.driver.find_element_by_id('kw')
        self.search_field.clear()

        self.search_field.send_keys('xxx')
        self.search_field.submit()

        products = self.driver.find_elements_by_xpath("//h3[@class='t']/a")
        self.assertEqual(3, len(products))

    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()


if __name__ == '__main__':
    unittest.main(verbosity=2)

# homepagetests.py
# Test Suite测试套件，将不同的测试组成一个逻辑组，然后设置统一的测试套件，并通过一个命令来执行测试。

import unittest
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
from builtins import classmethod


class HomePageTest(unittest.TestCase):
    @classmethod
    def setUp(cls):
        cls.driver = webdriver.Firefox()
        cls.driver.implicitly_wait(30)
        cls.driver.maximize_window()

        cls.driver.get('http://demo-store.seleniumacademy.com/')

    def test_search_field(self):
        # check search field exists on Home page
        self.assertTrue(self.is_element_present(By.NAME, 'q'))

    def test_language_option(self):
        # check language options dropdown on Home page
        self.assertTrue(self.is_element_present(By.ID, 'select-language'))

    def test_shopping_cart_empty_message(self):
        # check content of My Shopping Cart block on Home page
        shopping_cart_icon = self.driver.find_element_by_css_selector('div.header-minicart span.icon')
        shopping_cart_icon.click()

        shopping_cart_status = self.driver.find_element_by_css_selector('p.empty').text
        self.assertEqual('You have no items in your shopping cart', shopping_cart_status)

        close_button = self.driver.find_element_by_css_selector('div.minicart-wrapper a.close')
        close_button.click()

    @classmethod
    def tearDown(cls):
        # close the browser window
        cls.driver.quit()

    def is_element_present(self, how, what):
        """
        Utility method to check presence of an element on page
        :params how: By locator type
        :params what: locator value
        """
        try:
            self.driver.find_element(by=how, value=what)
        except NoSuchElementException as e:
            return False
        return True


if __name__ == '__main__':
    unittest.main(verbosity=2)

# smoketests.py
# 用TestSuite类来定义和执行测试套件
# 多个测试加入到一个测试套件中去，用TestLoader和TextTestRunner来创建和运行测试套件
import unittest
from searchtests import SearchTests
from homepagetests import HomePageTest

# get all tests from SearchProductTest and HomePageTest class
search_tests = unittest.TestLoader().loadTestsFromTestCase(SearchTests)
home_page_tests = unittest.TestLoader().loadTestsFromTestCase(HomePageTest)

# create a test suite combining search_test and home_page_test
smoke_tests = unittest.TestSuite([home_page_tests, search_tests])

# run the suite
unittest.TextTestRunner(verbosity=2).run(smoke_tests)

# smoketests_with_html_report.py
import unittest
import HTMLTestRunner
import os
from searchtests import SearchTests
from homepagetests import HomePageTest

# get the directory path to output report file
result_dir = os.getcwd()

# get all tests from SearchProductTest and HomePageTest class

search_tests = unittest.TestLoader().loadTestsFromTestCase(SearchTests)
home_page_tests = unittest.TestLoader().loadTestsFromTestCase(HomePageTest)

# create a test suite combining search_test and home_page_test
smoke_tests = unittest.TestSuite([home_page_tests, search_tests])

# open the report file
outfile = open(result_dir + '\SmokeTestReport.html', 'w')

# configure.HTMLTestRunner options
runner = HTMLTestRunner.HTMLTestRunner(stream=outfile, title='Test Report', dscription='Smoke Testes')

# run the suite using HTMLTestRunner
runner.run(smoke_tests)

# brutedns.py
# coding=utf-8

import dns.resolver
import threading
from Queue import Queue
from config import *
import sys


class BruteDns(object):
    def __init__(self, domain):
        self.domain = domain
        self.thread_count = thread_count
        self.queue = Queue()
        self.result = []

    def run(self):
        with open('dict/dict.txt') as f:
            for i in f:
                self.queue.put(i.rstrip() + '.' + self.domain)
        total = self.queue.qsize()
        threads = []

        for i in xrange(self.thread_count):
            threads.append(self.BruteRun(self.queue, self.result, total))
        for i in threads:
            i.start()
        for i in threads:
            i.join()

        return list(set(self.result))

    class BruteRun(threading.Thread):
        def __init__(self, queue, result, total):
            threading.Thread.__init__(self)
            self._queue = queue
            self.result = result
            self.total = total

        def run(self):
            while not self._queue.empty():
                sub = self._queue.get_nowait()
                try:
                    self.msg()
                    results = dns.resolver.query(sub, 'A')
                    if results.response.answer:
                        self.result.append(sub)
                except Exception, e:
                    pass

        def msg(self):
            done_count = float(self.total - self._queue.qsize())
            all_count = float(self.total)
            found_count = len(self.result)
            msg = '\t[-]Last {} | Complete {:.2f}% | Found {}\t'.format(self._queue.qsize(),
                                                                        (done_count / all_count) * 100, found_count)
            sys.stdout.write('\r' + msg)
            sys.stdout.flush()

# Crt.py
# coding=utf-8

from common import http_requests_get, is_domain
import re


class Crt(object):
    def __init__(self, domain):
        self.domain = domain
        self.site = 'https://crt.sh/?q=%25.'
        self.result = []

    def run(self):
        url = self.site + self.domain
        try:
            r = http_requests_get(url=url)
            results = re.findall('</TD>\n    <TD>(.*?)</TD>\n    <TD><A', r.text, re.S)
            for result in results:
                if is_domain(result):
                    self.result.append(result)
            return list(set(self.result))
        except:
            return self.result

#ilink.py
# coding=utf-8

from common import http_requests_post, is_domain
import re


class ILink(object):
    def __init__(self, domain):
        self.domain = domain
        self.site = 'http://i.links.cn/subdomain/'
        self.result = []

    def run(self):
        payload = {
            'domain': self.domain,
            'b2': 1,
            'b3': 1,
            'b4': 1,
        }
        try:
            r = http_requests_post(self.site, payload)
            results = re.findall('value="http://(.*?)"><input', r.text)
            for result in results:
                if is_domain(result):
                    self.result.append(result)
            return list(set(self.result))
        except:
            return self.result

# common.py
# coding=utf-8
from config import *
import re

import requests.packages.urllib3

requests.packages.urllib3.disable_warnings()

import requests
import urllib3
import json


def http_requests_get(url, allow_redirects=allow_redirects):
    try:
        result = requests.get(
            url=url,
            headers=headers,
            timeout=timeout,
            allow_redirects=allow_redirects,
            verify=allow_ssl_verify)
        return result
    except Exception, e:
        return requests.models.Response()
        # return e


def http_requests_post(url, payload, allow_redirects=allow_redirects):
    try:
        result = requests.get(
            url=url,
            data=payload,
            headers=headers,
            timeout=timeout,
            allow_redirects=allow_redirects,
            verify=allow_ssl_verify)
        return result
    except Exception, e:
        return requests.models.Response()
        # return e


def is_domain(domain):
    domain_regex = re.compile(
        r'(?:[A-Z0-9_](?:[A-Z0-9-_]{0,247}[A-Z0-9])?\.)+(?:[A-Z]{2,6}|[A-Z0-9-]{2,}(?<!-))\Z', re.IGNORECASE)
    return True if domain_regex.match(domain) else False


def save_result(filename, result):
    try:
        f = open(filename, 'w')
        json.dump(result, f, indent=4)
    except Exception, e:
        print e


def read_json(filename):
    try:
        f = open(filename, 'r')
        datas = json.load(f)
        return datas
    except Exception, e:
        print e

# config.py
# coding=utf-8
import sys
import random

# 是否开启https服务的证书校验
allow_ssl_verify = False
# 线程数
thread_count = 50
# timeout
timeout = 10
# 是否允许重定向
allow_redirects = True
# 是否允许继承http Request类的session支持，在发出的所有请求之间保存cookies
allow_http_session = True
# 是否允许随机useragent
allow_random_useragent = False
# 是否允许随机x_forward_for头
allow_random_x_forward = False

USER_AGENTS = [
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.20 (KHTML, like Gecko) Chrome/19.0.1036.7 Safari/535.20',
]


def random_useragent(condition=False):
    if condition:
        return random.choice(USER_AGENTS)
    else:
        return USER_AGENTS[0]


def random_x_forward_for(condition=False):
    if condition:
        return '%d.%d.%d.%d' % (
            random.randint(1, 254), random.randint(1, 254), random.randint(1, 254), random.randint(1, 254))
    else:
        return '8.8.8.8'


headers = {
    'User-Agent': random_useragent(allow_random_useragent),
    'X_FORWARDED_FOR': random_x_forward_for(allow_random_x_forward),
    'Referer': 'http://www.baidu.com',
    'Cookie': "",
}

# domians.py
# coding=utf-8
import os
import sys
import argparse
from utils.Crt import Crt
from utils.ilink import ILink
from common import save_result, read_json
from utils.brutedns import BruteDns

def run(args):
    domain = args.domain
    if not domain:
        print "Usage:domains,py -d test.com"
        sys.exit(1)
    outfile = '{0}.log'.format(domain)

    script_path = os.path.dirname(os.path.abspath(__file__))
    _cache_path = os.path.join(script_path, 'result/{0}'.format(domain))
    if not os.path.exists(_cache_path):
        os.makedirs(_cache_path, 0777)

    print '[*]Starting CRT fetch........'
    result = Crt(domain=domain).run()
    _cache_file = os.path.join(_cache_path, 'crt.json')
    save_result(_cache_file, result)
    print '\t [-]Fetch Complete | Found {}'.format(len(result))

    print '[*]Starting ILink fetch........'
    result = ILink(domain=domain).run()
    _cache_file = os.path.join(_cache_path, 'ilink.json')
    save_result(_cache_file, result)
    print '\t [-]Fetch Complete | Found {}'.format(len(result))

    print '[*]Starting Brute........'
    result = BruteDns(domain=domain).run()
    _cache_file = os.path.join(_cache_path, 'brute.json')
    save_result(_cache_file, result)
    print '\n\t [-]Fetch Complete | Found {}'.format(len(result))

    _cache_files = ['crt.json', 'ilink.json', 'brute.json']

    subdomains = []

    for file in _cache_files:
        _cache_file = os.path.join(_cache_path, file)
        json_data = read_json(_cache_file)
        if json_data:
            subdomains.extend(json_data)

    subdomains = list(set(subdomains))

    _result_file = os.path.join(script_path, outfile)
    save_result(_result_file, subdomains)

    print '\n[*]{0} {1} subdomains \n\tsave to {2}'.format(domain, len(subdomains), _result_file)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="Domain Scan Ver:1.0")
    parser.add_argument("-d", "--domain", metavar="", help="domain name")
    args = parser.parse_args()

    try:
        run(args)
    except KeyboardInterrupt:
        sys.exit(1)

# coding=utf-8

import requests
from Queue import Queue
import time
import threading
import re

headers = {
    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'}


class C_Scan(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self._queue = queue

    def run(self):
        while not self._queue.empty():
            url = self._queue.get()
            print url
            try:
                r = requests.get(url=url, headers=headers, timeout=6)
                if r.status_code == 200:
                    print '[*]Web Service Found!%s' % url
                    try:
                        title = re.findall('<title>(.*?)</title>', r.text)[0]
                    except:
                        title = 'None'
                    f = open('result.html', 'a+')
                    f.write('<a href="' + url + '" target="_blank">' + url + '</a>' + '\t\t' + title + '\n')
                    f.write('<br>')
                    f.close()
            except Exception, e:
                pass


def create(ips):
    queue = Queue()
    req_m = ['http://', ]
    ports = ['80', '8080', ]
    dirs = ['', '/phpmyadmin', '/temp', ]
    for h in req_m:
        for i in ips:
            for j in ports:
                for k in dirs:
                    queue.put(str(h) + str(i) + ':' + str(j) + str(k))
    return queue


def main(ips):
    f = open('result.html', 'w')
    f.close()

    queue = create(ips)
    threads = []
    thread_count = 10
    for i in range(thread_count):
        threads.append(C_Scan(queue))
    for i in threads:
        i.start()
    for i in threads:
        i.join()


if __name__ == '__main__':
    with open('nmap.xml') as f:
        ips = re.findall('<address addr="(.*?)" addrtype=', f.read())
        main(ips)

# proxy_use.py
# coding=utf-8
import random

def get_proxy():
    proxy_list = [
        {'http': '61.135.217.7:80'},
        {'http': '61.135.155.82:443'},
        {'http': '115.46.69.56:8123'},
        {'https': '106.15.42.179:33543'},
        {'https': '171.35.50.80:8118'},
        {'https': '121.228.162.101:8118'},
        {'https': '115.225.60.111:8118'},
        {'https': '202.104.113.35:53281'},
        {'https': '139.129.207.72:808'},
        {'https': '182.111.64.7:41766'},
        {'https': '219.234.5.128:3128'},

    ]
    return random.choice(proxy_list)

# user_agent_use.py
# encoding: utf-8

import random


def get_user_agent():
    user_agent_list = [
        {
            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'},
        {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.20 (KHTML, like Gecko) Chrome/19.0.1036.7 Safari/535.20'}
    ]

    return random.choice(user_agent_list)

# webdirscan.py
# coding=utf-8

import requests
from libs.output import *
from libs.utils.FileUtils import FileUtils
from libs.checkWAF import checkWaf
from Queue import Queue
import sys
import threading
import user_agent_use
import proxy_use
from optparse import OptionParser


class WebDirScanMain:
    def __init__(self, options):
        self.url = options.url
        self.ext = options.ext
        self.count = options.count

    class WebDirScan(threading.Thread):
        def __init__(self, queue, total):
            threading.Thread.__init__(self)
            self._queue = queue
            self._total = total

        def run(self):
            while not self._queue.empty():
                url = self._queue.get()
                threading.Thread(target=self.msg).start()
                try:
                    r = requests.get(url=url, headers=user_agent_use.get_user_agent(), timeout=8,
                                     proxies=proxy_use.get_proxy(), allow_redirects=True)
                    # checkWaf(url=url, headers=user_agent_use.get_user_agent(), timeout=8,
                    #          proxies=proxy_use.get_proxy(), allow_redirects=True)
                    if r.status_code == 200:
                        sys.stdout.write('\r' + '[*]%s\t\t\n' % (url))
                        f = open('result.html', 'a+')
                        f.write('<a href="' + url + '" target="_black">' + url + '</a>')
                        f.write('\r\n</br>')
                        f.close()
                except Exception, e:
                    pass

        def msg(self):
            per = 100 - float(self._queue.qsize()) / float(self._total) * 100
            # print self._total, self._queue.qsize()
            msg = '%s Left|%s All|Scan in %1.f%s' % (self._queue.qsize(), self._total, per, '%')
            sys.stdout.write('\r' + '[#]' + msg)
            sys.stdout.flush()

    def start(self):
        f = open('result.html', 'w')
        f.close()
        queue = Queue()

        f = open('./dics/%s.txt' % self.ext, 'r')
        for i in f:
            queue.put(self.url + i.rstrip('\n'))

        total = queue.qsize()

        threads = []
        thread_count = self.count
        for i in range(thread_count):
            threads.append(self.WebDirScan(queue, total))
        for i in threads:
            i.start()
        for i in threads:
            i.join()


if __name__ == '__main__':
    print '''
__        __   _     ____  _      ____                  
\ \      / /__| |__ |  _ \(_)_ __/ ___|  ___ __ _ _ __  
 \ \ /\ / / _ \ '_ \| | | | | '__\___ \ / __/ _` | '_ \ 
  \ V  V /  __/ |_) | |_| | | |   ___) | (_| (_| | | | |
   \_/\_/ \___|_.__/|____/|_|_|  |____/ \___\__,_|_| |_|
                                                                
    '''
    print '''
    Design By:ShowMeShell   Version:1.0   
    '''
    parser = OptionParser()
    parser = OptionParser()
    parser.add_option("-u", "--url", dest="url", help="Target url for scan")
    parser.add_option("-f", "--file", dest="ext", help="Target url ext")
    parser.add_option("-t", "--thread", dest="count", type="int", default=10, help="Scan Thread_count")

    (options, args) = parser.parse_args()
    if options.url and options.ext:
        d = WebDirScanMain(options)
        d.start()
        sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

# coding=utf-8

import exrex
import sys

'''
host=http://123.456.com or 123.456.com or https://123.456.com or  http://123.456.com/
'''

web_white = ['com', 'cn', 'gov', 'edu', 'org', 'www']


def host_para(host):
    if '://' in host:
        host = host.split('://')[1].replace('/', '')

    if '/' in host:
        host = host.replace('/', '')
    return host


# 结合常用字典创造新的dic
def dic_creat(hosts):
    web_dics = hosts.split('.')
    # 核心的生成规则，写入配置文件

    f_rule = open('rule.ini', 'r')
    for i in f_rule:
        if '#' != i[0]:
            rule = i

    f_pass_out = open('dictonary.txt', 'w')
    f_pass_out.close()

    for web_dic in web_dics:
        if web_dic not in web_white:
            f_pass = open('pass_0.txt', 'r')
            for dic_pass in f_pass:
                dics = list(exrex.generate(rule.format(web_dic=web_dic, dic_pass=dic_pass.strip('\n'))))

                for dic in dics:
                    if len(dic) > 4:
                        f_pass_out = open('dictonary.txt', 'a+')
                        f_pass_out.write(dic + '\n')
                        f_pass_out.close()
                        print dic


if __name__ == '__main__':
    if len(sys.argv) == 2:
        dic_creat(host_para(sys.argv[1]))
    else:
        print 'Usage:%s www.demo.com' % sys.argv[0]
        sys.exit(-1)

# coding=utf-8
import requests
import json
import sys


# https://www.zoomeye.org/doc#host-search
def login():
    url_login = 'https://api.zoomeye.org/user/login'
    data = {
        "username": "zoomeye账号",
        "password": "zoomeys密码"
    }
    data = json.dumps(data)

    r = requests.post(url=url_login, data=data)
    return json.loads(r.content)['access_token']


def main(keyword):
    url = 'https://api.zoomeye.org/host/search?query=%s' % (keyword)
    headers = {'Authorization': 'JWT ' + login()}
    r = requests.get(url=url, headers=headers)
    # print r.content
    datas = json.loads(r.content)['matches']
    for data in datas:
        print data['ip'], data['portinfo']['port']


if __name__ == '__main__':
    if len(sys.argv) != 2:
        print 'Enter:%s keyword' % sys.argv[0]
        sys.exit(-1)
    else:
        for i in (1, 11):
            input = str(sys.argv[1] + '&page=' + str(i))
            main(input)

# coding=utf-8
import requests
from bs4 import BeautifulSoup as bs
import re


def proxy_spider():
    headers = {
        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'
    }
    url = 'http://www.xicidaili.com/nn'
    r = requests.get(url=url, headers=headers)
    # print r.status_code, r.content
    soup = bs(r.content, 'lxml')
    datas = soup.find_all(name='tr', attrs={'class': re.compile('|[^odd]')})
    for data in datas:
        soup_proxy_content = bs(str(data), 'lxml')
        soup_proxy = soup_proxy_content.find_all(name='td')
        # print soup_proxy
        ip = str(soup_proxy[1].string)
        port = str(soup_proxy[2].string)
        types = str(soup_proxy[5].string)
        proxy_check(ip, port, types)


def proxy_check(ip, port, types):
    proxy = {}
    proxy[types.lower()] = '%s:%s' % (ip, port)
    try:
        r = requests.get('http://showmeshell.top/', proxies=proxy, timeout=6)
        if r.status_code == 200:
            print proxy
    except Exception, e:
        pass

proxy_spider()

# coding=utf-8
import requests
import threading
import Queue
from bs4 import BeautifulSoup as bs
import time
import re
import sys

# https://www.baidu.com/s?wd=keyword&pn=10
# wd控制keyword，pn控制页码（0-750）

headers = {
    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'
}


class BaiduSpider(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self._queue = queue

    def run(self):
        while not self._queue.empty():
            url = self._queue.get()
            try:
                self.spider(url)
            except Exception, e:
                print e
                pass

    def spider(self, url):
        r = requests.get(url=url, headers=headers)
        print r.status_code
        soup = bs(r.content, 'lxml')
        urls = soup.find_all(name='a', attrs={'data-click': re.compile(('')), 'class': None})
        for url in urls:
            r_get_url = requests.get(url=url['href'], headers=headers, timeout=8)
            if r_get_url.status_code == 200:
                print r_get_url.url
                url_para = r_get_url.url
                url_index_tmp = url_para.split('/')
                url_index = url_index_tmp[0] + '//' + url_index_tmp[2]
                print url_index
                f1 = open('out_para.txt', 'a+')
                f1.write(url_para + '\n')
                f1.close()
                with open('out_index.txt') as f:
                    if url_index not in f.read():
                        f2 = open('out_index.txt', 'a+')
                        f2.write(url_index + '\n')
                        f2.close()


def main(keyword):
    queue = Queue.Queue()
    for i in range(0, 760, 10):
        queue.put('https://www.baidu.com/s?wd=%s&pn=%s' % (keyword, str(i)))

    threads = []
    threading_count = 3
    for i in range(threading_count):
        threads.append(BaiduSpider(queue))
    for t in threads:
        t.start()
    for t in threads:
        t.join()


if __name__ == '__main__':
    f1 = open('out_para.txt', 'w')
    f1.close()
    f2 = open('out_index.txt', 'w')
    f2.close()
    if len(sys.argv) != 2:
        print 'Enter:%s keyword' % sys.argv[0]
        sys.exit(-1)
    else:
        main(sys.argv[1])