v0.0.3

[README]fix wrong url format

.github/ISSUE_TEMPLATE/bug--.md

@@ -0,0 +1,36 @@
+---
+name: Bug报告
+about: 填写好报告有助于快速解决bug
+title: BUG
+labels: bug
+assignees: shmilylty
+
+---
+
+**是否使用了最新代码**
+是或否
+（如果不是的话尝试克隆最新的代码再跑一下）
+
+**bug描述**
+清晰而简洁的Bug描述
+
+**如何复现**
+复现步骤
+复现命令
+
+**预期结果**
+清晰而简洁的预期结果描述
+
+**实际结果**
+清晰而简洁的实际结果描述（如出现什么错误）
+
+**屏幕截图**
+
+
+**运行环境**
+ - 系统：[例如Windows 10 x64]
+ - Python版本：[例如3.7.1]
+
+
+**报错文本**
+复制完整的报错文本

.gitignore

@@ -0,0 +1,238 @@
+
+# Created by https://www.gitignore.io/api/python,windows,pycharm
+# Edit at https://www.gitignore.io/?templates=python,windows,pycharm
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# End of https://www.gitignore.io/api/python,windows,pycharm

.travis.yml

@@ -0,0 +1,39 @@
+sudo: true
+
+notifications:
+  email: false
+
+language: python
+
+matrix:
+  include:
+    - name: "Python 3.6 on Linux"
+      python: 3.6           # this works for Linux but is ignored on macOS or Windows
+    - name: "Python 3.7 on Xenial Linux"
+      python: 3.7           # this works for Linux but is ignored on macOS or Windows
+      dist: xenial          # required for Python >= 3.7
+    - name: "Python 3.8 on Xenial Linux"
+      python: 3.8-dev           # this works for Linux but is ignored on macOS or Windows
+      dist: xenial          # required for Python >= 3.7
+    - name: "Python 3.7 on macOS"
+      os: osx
+      osx_image: xcode10.2  # Python 3.7 running on macOS 10.14.3
+      language: shell       # 'language: python' is an error on Travis CI macOS
+    - name: "Python 3.7 on Windows"
+      os: windows           # Windows 10.0.17134 N/A Build 17134
+      language: shell
+      before_install:
+        - choco install python
+        - python -m pip install --upgrade pip
+      env: PATH=/c/Python37:/c/Python37/Scripts:$PATH
+
+install:
+  - pip3 install -U pip
+  - pip3 install codecov
+  - pip3 install -r requirements.txt
+
+script:
+ - coverage run oneforall/example.py
+
+after_success:
+ - codecov

CHANGES.md

@@ -1,18 +1,35 @@
-# Changelog
+# 更新日志
 OneForAll的所有值得注意的更改都将记录在此文件中。
 
 OneForAll的更新日志格式基于[Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)。
 
 OneForAll遵守[语义化版本格式](https://semver.org/)。
 
-## [Unreleased](https://github.com/shmilylty/onefroall/compare/v1.0.0...HEAD)
+## Unreleased
 
-## [0.0.1](https://github.com/shmilylty/onefroall/releases/tag/v0.0.1) - 2019-08-01
-### Added
-- 添加检查crossdomain.xml收集子域功能
-- 添加检查域名证书收集子域功能
-- 添加检查内容安全策略头收集子域功能
-- 添加域传送利用功能
-- 添加子域收集功能（搜索引擎，DNS数据集，证书透明度，网上爬虫档案）
-- 添加子域爆破功能
-- 添加数据库导出功能
+## [0.0.3](https://github.com/shmilylty/oneforall/releases/tag/v0.0.3) - 2019-08-08
+### 修改
+- 代码PEP8格式化
+### 修改
+- 修改一些已知Bugs
+
+## [0.0.2](https://github.com/shmilylty/oneforall/releases/tag/v0.0.2) - 2019-08-04
+### 新增
+- 新增有关文档
+### 修改
+- 修改有关日志输出格式和信息
+### 修复
+- 升级fire库版本解决运行报错问题
+### 移除
+- 移除brotlipy依赖
+
+
+## [0.0.1](https://github.com/shmilylty/oneforall/releases/tag/v0.0.1) - 2019-08-02
+### 新增
+- 新增检查crossdomain.xml收集子域功能
+- 新增检查域名证书收集子域功能
+- 新增检查内容安全策略头收集子域功能
+- 新增域传送利用功能
+- 新增子域收集功能（搜索引擎，DNS数据集，证书透明度，网上爬虫档案）
+- 新增子域爆破功能
+- 新增数据库导出功能

CONTRIBUTORS.md

@@ -3,5 +3,9 @@
 * **[Jing Ling](https://github.com/shmilylty)**
   * 核心开发
 
-* **[Black Star](https://github.com/shmilylty)**
-  * 模块贡献
+* **[Black Star](https://github.com/blackstar24)**
+  * 模块贡献
+
+* [**iceMatcha**](https://github.com/iceMatcha)
+  * bug调试
+

Pipfile

@@ -16,12 +16,10 @@ records = "*"
 tldextract = "*"
 exrex = "*"
 aiohttp = "*"
-fire = "*"
-fake-useragent = "*"
+fire = "==0.2.1"
 bs4 = "*"
 cchardet = "*"
 lxml = "*"
-brotlipy = "*"
 pysocks = "*"
 
 [requires]

Pipfile.lock

@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "c2d9fe3a7303466070733472b7b06b491d35bbbcf3db8863152e721d797e9195"
+            "sha256": "d95e37615ca48fe39a66e8c24eff76910c66b01b0739c0ab00ffa0f4df022107"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -88,41 +88,6 @@
             ],
             "version": "==4.8.0"
         },
-        "brotlipy": {
-            "hashes": [
-                "sha256:07194f4768eb62a4f4ea76b6d0df6ade185e24ebd85877c351daa0a069f1111a",
-                "sha256:091b299bf36dd6ef7a06570dbc98c0f80a504a56c5b797f31934d2ad01ae7d17",
-                "sha256:09ec3e125d16749b31c74f021aba809541b3564e5359f8c265cbae442810b41a",
-                "sha256:0be698678a114addcf87a4b9496c552c68a2c99bf93cf8e08f5738b392e82057",
-                "sha256:0fa6088a9a87645d43d7e21e32b4a6bf8f7c3939015a50158c10972aa7f425b7",
-                "sha256:1ea4e578241504b58f2456a6c69952c88866c794648bdc74baee74839da61d44",
-                "sha256:2699945a0a992c04fc7dc7fa2f1d0575a2c8b4b769f2874a08e8eae46bef36ae",
-                "sha256:2a80319ae13ea8dd60ecdc4f5ccf6da3ae64787765923256b62c598c5bba4121",
-                "sha256:2e5c64522364a9ebcdf47c5744a5ddeb3f934742d31e61ebfbbc095460b47162",
-                "sha256:36def0b859beaf21910157b4c33eb3b06d8ce459c942102f16988cca6ea164df",
-                "sha256:3a3e56ced8b15fbbd363380344f70f3b438e0fd1fcf27b7526b6172ea950e867",
-                "sha256:3c1d5e2cf945a46975bdb11a19257fa057b67591eb232f393d260e7246d9e571",
-                "sha256:50ca336374131cfad20612f26cc43c637ac0bfd2be3361495e99270883b52962",
-                "sha256:5de6f7d010b7558f72f4b061a07395c5c3fd57f0285c5af7f126a677b976a868",
-                "sha256:637847560d671657f993313ecc6c6c6666a936b7a925779fd044065c7bc035b9",
-                "sha256:653faef61241bf8bf99d73ca7ec4baa63401ba7b2a2aa88958394869379d67c7",
-                "sha256:786afc8c9bd67de8d31f46e408a3386331e126829114e4db034f91eacb05396d",
-                "sha256:79aaf217072840f3e9a3b641cccc51f7fc23037496bd71e26211856b93f4b4cb",
-                "sha256:7e31f7adcc5851ca06134705fcf3478210da45d35ad75ec181e1ce9ce345bb38",
-                "sha256:8b39abc3256c978f575df5cd7893153277216474f303e26f0e43ba3d3969ef96",
-                "sha256:9448227b0df082e574c45c983fa5cd4bda7bfb11ea6b59def0940c1647be0c3c",
-                "sha256:96bc59ff9b5b5552843dc67999486a220e07a0522dddd3935da05dc194fa485c",
-                "sha256:a07647886e24e2fb2d68ca8bf3ada398eb56fd8eac46c733d4d95c64d17f743b",
-                "sha256:af65d2699cb9f13b26ec3ba09e75e80d31ff422c03675fcb36ee4dabe588fdc2",
-                "sha256:b4c98b0d2c9c7020a524ca5bbff42027db1004c6571f8bc7b747f2b843128e7a",
-                "sha256:c6cc0036b1304dd0073eec416cb2f6b9e37ac8296afd9e481cac3b1f07f9db25",
-                "sha256:d2c1c724c4ac375feb2110f1af98ecdc0e5a8ea79d068efb5891f621a5b235cb",
-                "sha256:dc6c5ee0df9732a44d08edab32f8a616b769cc5a4155a12d2d010d248eb3fb07",
-                "sha256:fd1d1c64214af5d90014d82cee5d8141b13d44c92ada7a0c0ec0679c6f15a471"
-            ],
-            "index": "pypi",
-            "version": "==0.7.0"
-        },
         "bs4": {
             "hashes": [
                 "sha256:36ecea1fd7cc5c0c6e4a1ff075df26d50da647b75376626cc186e2212886dd3a"
@@ -248,19 +213,12 @@
             "index": "pypi",
             "version": "==0.10.5"
         },
-        "fake-useragent": {
-            "hashes": [
-                "sha256:c104998b750eb097eefc28ae28e92d66397598d2cf41a31aa45d5559ef1adf35"
-            ],
-            "index": "pypi",
-            "version": "==0.1.11"
-        },
         "fire": {
             "hashes": [
-                "sha256:cdae28ea728d6cad487c900d534426d2cd09ddd2993287a885ff7c8accb097c8"
+                "sha256:6865fefc6981a713d2ce56a2a2c92c56c729269f74a6cddd6f4b94d16ae084c9"
             ],
             "index": "pypi",
-            "version": "==0.2.0"
+            "version": "==0.2.1"
         },
         "idna": {
             "hashes": [

README.md

@@ -1,5 +1,352 @@
 # OneForAll
-Subdomain Collection One For All：Full Cowl-100% Smash
 
-# Developing
-OneForAll is under development, please look forward to it!
+[![Build Status](https://travis-ci.org/shmilylty/OneForAll.svg?branch=master)](https://travis-ci.org/shmilylty/OneForAll)
+[![codecov](https://codecov.io/gh/shmilylty/OneForAll/branch/master/graph/badge.svg)](https://codecov.io/gh/shmilylty/OneForAll)
+[![Maintainability](https://api.codeclimate.com/v1/badges/1287668a6b4c72af683e/maintainability)](https://codeclimate.com/github/shmilylty/OneForAll/maintainability)
+[![License](https://img.shields.io/github/license/shmilylty/OneForAll)](./LICENSE)
+[![python](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8-blue)](./)
+[![python](https://img.shields.io/badge/release-v0.0.3-brightgreen)](https://github.com/shmilylty/OneForAll/releases)
+
+👊**OneForAll是一款功能强大的子域收集工具**  📝[English Document](./README.en.md)
+
+![](./images/All_Might.jpg)
+
+## 🎉项目简介
+
+在渗透测试中信息收集的重要性不言而喻，子域收集是信息收集中必不可少且非常重要的一环，目前网上也开源了许多子域收集的工具，但是总是存在以下部分问题：
+
+* **不够强大**，子域收集的接口不够多，不能做到对批量子域自动收集，没有自动子域解析，验证，FUZZ以及信息拓展等功能。
+* **不够友好**，固然命令行模块比较方便，但是当可选的参数很多，要实现的操作复杂，用命令行模式就有点不够友好，如果有交互良好，高可操作的前端那么使用体验就会好很多。
+
+* **缺少维护**，很多工具几年没有更新过一次，issues和PR是啥，不存在的。
+
+* **效率问题**，没有利用多进程，多线程以及异步协程技术，速度较慢。
+
+为了解决以上痛点，此项目应用而生，OneForAll一词是来自我喜欢的一部日漫《[我的英雄学院](https://manhua.fzdm.com/131/)》，它是一种通过一代代的传承不断变强的潜力无穷的顶级个性，目前[番剧](https://www.bilibili.com/bangumi/media/md7452/)也更新到了第三季了，欢迎大佬们入坑😄。正如其名，我希望OneForAll是一款集百家之长，功能强大的全面快速子域收集终极神器🔨。
+
+目前OneForAll还在开发中，肯定有不少问题和需要改进的地方，欢迎大佬们提交[Issues](https://github.com/shmilylty/OneForAll/issues)和[PR](https://github.com/shmilylty/OneForAll/pulls)，用着还行给个小星星✨吧，目前有一个专门用于OneForAll交流和反馈QQ群👨‍👨‍👦‍👦：:[**824414244**](//shang.qq.com/wpa/qunwpa?idkey=125d3689b60445cdbb11e4ddff38036b7f6f2abbf4f7957df5dddba81aa90771)，也可以给我发邮件📧[admin@hackfun.org]。
+
+## 👍功能特性
+
+* **收集能力强大**，详细模块请阅读[收集模块说明](./docs/collection_modules.md)。
+  1. 利用证书透明度收集子域（目前有6个模块：`censys_api`，`certdb_api`，`certspotter`，`crtsh`，`entrust`，`google`）
+
+  2. 常规检查收集子域（目前有4个模块：域传送漏洞利用`axfr`，检查跨域策略文件`cdx`，检查HTTPS证书`cert`，检查内容安全策略`csp`，后续会添加检查NSEC记录，NSEC记录等模块）
+
+  3. 利用网上爬虫档案收集子域（目前有2个模块：`archivecrawl`，`commoncrawl`，此模块还在调试，该模块还有待添加和完善）
+
+  4. 利用DNS数据集收集子域（目前有16个模块：`binaryedge_api`, `circl_api`, `hackertarget`, `riddler`, `bufferover`, `dnsdb`, `ipv4info`, `robtex`, `chinaz`, `dnsdb_api`, `netcraft`, `securitytrails_api`, `chinaz_api`, `dnsdumpster`, `ptrarchive`, `sitedossier`）
+
+  5. 利用DNS查询收集子域（目前有1个模块：通过枚举常见的SRV记录并做查询来收集子域`srv`，该模块还有待添加和完善）
+
+  6. 利用威胁情报平台数据收集子域（目前有5个模块：`riskiq_api`，`threatbook_api`，`threatminer`，`virustotal`，`virustotal_api`该模块还有待添加和完善）
+
+  7. 利用搜索引擎发现子域（目前有15个模块：`ask`, `bing_api`, `fofa_api`, `shodan_api`, `yahoo`, `baidu`, `duckduckgo`, `google`, `so`, `yandex`, `bing`, `exalead`, `google_api`, `sogou`, `zoomeye_api`），在搜索模块中除特殊搜索引擎，通用的搜索引擎都支持自动排除搜索，全量搜索，递归搜索。
+
+* **处理功能强大**，发现的子域结果支持自动去除，自动DNS解析，HTTP请求探测，自动移除无效子域，拓展子域的Banner信息，最终支持的导出格式有`csv`, `tsv`, `json`, `yaml`, `html`, `xls`, `xlsx`, `dbf`, `latex`, `ods`。
+
+* **速度极速**，[收集模块](./oneforall/collect.py)使用多线程调用，[爆破模块](./oneforall/aiobrute.py)使用异步多进程多协程，DNS解析和HTTP请求使用异步多协程。
+
+## 🚀上手指南
+
+由于该项目**处于开发中**，会不断进行更新迭代，下载使用最好**克隆**最新项目。
+
+**🐍安装要求**
+
+1. Python 3.6-3.7
+
+**✔安装步骤**
+
+1. 下载更新
+
+   ```bash
+   git clone https://github.com/shmilylty/OneForAll.git
+   ```
+
+   ❗如果你之前已经克隆了项目运行之前请**备份**自己修改过的文件到项目外的地方（如**config.py**），然后执行以下命令**更新**项目：
+
+   ```bash
+   git fetch --all
+   git reset --hard origin/master
+   git pull
+   ```
+
+2. 安装依赖
+
+   * 使用pipenv
+
+     ```bash
+     pip3 install pipenv
+     cd OneForAll/
+     pipenv install --python 3.7
+     cd oneforall
+     pipenv run python3 oneforall.py --help
+     ```
+
+   * 使用pip3
+   
+     ```bash
+     cd OneForAll/oneforall
+     pip3 install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
+     python3 oneforall.py --help
+     ```
+
+
+如果在安装依赖过程中发现编译某个依赖库失败时可以参考[编译失败解决方法](./docs/building_fail_solution.md)，如果还没有解决欢迎加群反馈。
+
+**✨使用演示**
+
+```bash
+python3 oneforall.py --target example.com run
+```
+
+![Example](./docs/usage_example.svg)
+
+**🤔使用帮助**
+
+命令行参数只提供了一些常用参数，更多详细的参数配置请见[config.py](./oneforall/config.py)，如果你认为有些参数是命令界面经常使用到的或缺少了什么参数等问题非常欢迎反馈。由于众所周知的原因，如果要使用一些被墙的收集接口请先到[config.py](./oneforall/config.py)配置代理，有些收集模块需要提供API（大多都是可以注册账号免费获取），如果需要使用请到[config.py](./oneforall/config.py)配置API信息，如果不使用请忽略有关报错提示。（详细模块请阅读[收集模块说明](./docs/collection_modules.md)）
+
+OneForAll命令行界面基于[Fire](https://github.com/google/python-fire/)实现，有关Fire更高级使用方法请参阅[使用Fire CLI](https://github.com/google/python-fire/blob/master/docs/using-cli.md)，有任何使用疑惑欢迎加群交流。
+
+oneforall.py是主程序入口，oneforall.py里有调用aiobrute.py和dbexport.py，为了方便进行子域爆破和数据库导出独立出了aiobrute.py和dbexport.py，这两个文件可以单独运行，并且所接受参数要更丰富一点。
+
+1. oneforall.py使用帮助
+
+   ```bash
+   pipenv run python oneforall.py --help
+   ```
+   ```bash
+   NAME
+       oneforall.py - OneForAll是一款功能强大的子域收集工具
+   
+   SYNOPSIS
+       oneforall.py --target=TARGET <flags>
+   
+   DESCRIPTION
+       Version: 0.0.2
+       Project: https://github.com/shmilylty/OneForAll/
+   
+       Example:
+           python oneforall.py --target example.com run
+           python oneforall.py --target example.com --brute True --port medium valid 1 run
+           python oneforall.py --target ./domains.txt --format csv --path= ./result.csv  --output True run
+   
+       Note:
+           参数valid可选值有1，0，None，分别表示导出有效，无效，全部子域
+           参数port可选值有'small', 'medium', 'large', 'xlarge'，详见config.py配置
+           参数format可选格式有'csv','tsv','json','yaml','html','xls','xlsx','dbf','latex','ods'
+           参数path为None会根据format参数和域名名称在项目结果目录生成相应文件
+   
+   ARGUMENTS
+       TARGET
+           单个域名或者每行一个域名的文件路径
+   
+   FLAGS
+       --brute=BRUTE
+           是否使用爆破模块（默认禁用）
+       --port=PORT
+           HTTP请求验证的端口范围（默认medium）
+       --valid=VALID
+           导出子域的有效性（默认1）
+       --path=PATH
+           导出路径(默认None)
+       --format=FORMAT
+           导出格式（默认xlsx）
+       --output=OUTPUT
+           是否将导出数据输出到终端（默认False）
+   ```
+
+2. aiobrute.py使用帮助
+
+   关于泛解析问题处理程序首先会访问一个随机的子域判断是否泛解析，如果使用了泛解析则是通过以下判断处理：
+   - 一是主要是与泛解析的IP集合和TTL值做对比，可以参考[这篇文章](http://sh3ll.me/archives/201704041222.txt)。
+   - 二是多次解析到同一IP集合次数（默认设置为10，可以在config.py设置大小）
+   - 考虑爆破效率问题目前还没有加上HTTP响应体相似度对比和响应体内容判断
+   经过测试在16核心的CPU，使用16进程64协程，100M带宽的环境下，设置任务分割为50000，跑两百万字典大概10分钟左右跑完，大概3333个子域每秒。
+
+   ```bash
+   pipenv run python aiobrute.py --help
+   ```
+
+   ```bash
+    NAME
+        aiobrute.py - OneForAll多进程多协程异步子域爆破模块
+
+    SYNOPSIS
+        aiobrute.py COMMAND | --target=TARGET <flags>
+
+    DESCRIPTION
+        Example：
+            python aiobrute.py --target example.com run
+            python aiobrute.py --target ./domains.txt run
+            python aiobrute.py --target example.com --processes 4 --coroutine 64 --wordlist data/subdomains.txt run
+            python aiobrute.py --target example.com --recursive True --depth 2 --namelist data/next_subdomains.txt run
+            python aiobrute.py --target www.{fuzz}.example.com --fuzz True --rule [a-z][0-9] run
+
+        Note:
+            参数segment的设置受CPU性能，网络带宽，运营商限制等问题影响，默认设置500个子域为一任务组，
+            当你觉得你的环境不受以上因素影响，当前爆破速度较慢，那么强烈建议根据字典大小调整大小：
+            十万字典建议设置为5000，百万字典设置为50000
+
+    ARGUMENTS
+        TARGET
+            单个域名或者每行一个域名的文件路径
+
+    FLAGS
+        --processes=PROCESSES
+            爆破的进程数(默认CPU核心数)
+        --coroutine=COROUTINE
+            每个爆破进程下的协程数(默认16)
+        --wordlist=WORDLIST
+            指定爆破所使用的字典路径(默认使用config.py配置)
+        --segment=SEGMENT
+            爆破任务分割(默认500)
+        --recursive=RECURSIVE
+            是否使用递归爆破(默认False)
+        --depth=DEPTH
+            递归爆破的深度(默认2)
+        --namelist=NAMELIST
+            指定递归爆破所使用的字典路径(默认使用config.py配置)
+        --fuzz=FUZZ
+            是否使用fuzz模式进行爆破(默认False，开启必须指定fuzz正则规则)
+        --rule=RULE
+            fuzz模式使用的正则规则(默认使用config.py配置)
+
+   ```
+
+3. dbexport.py使用帮助
+
+   ```bash
+   pipenv run python dbexport.py --help
+   ```
+
+   ```bash
+   NAME
+       dbexport.py - OneForAll数据库导出模块
+   
+   SYNOPSIS
+       dbexport.py TABLE <flags>
+   
+   DESCRIPTION
+       Example:
+           python dbexport.py --db result.db --table name --format csv --output False
+           python dbexport.py --db result.db --table name --format csv --path= ./result.csv
+   
+       Note:
+           参数valid可选值1，0，None，分别表示导出有效，无效，全部子域
+           参数format可选格式：'csv', 'tsv', 'json', 'yaml', 'html', 'xls', 'xlsx', 'dbf', 'latex', 'ods'
+           参数path为None会根据format参数和域名名称在项目结果目录生成相应文件
+   
+   POSITIONAL ARGUMENTS
+       TABLE
+           要导出的表
+   
+   FLAGS
+       --db=DB
+           要导出的数据库路径(默认为results/result.sqlite3)
+       --valid=VALID
+           导出子域的有效性(默认None)
+       --path=PATH
+           导出路径(默认None)
+       --format=FORMAT
+           导出格式(默认xlsx)
+       --output=OUTPUT
+           是否将导出数据输出到终端(默认False)
+   
+   NOTES
+       You can also use flags syntax for POSITIONAL ARGUMENTS
+   ```
+
+## 👏主要框架
+
+* [aiodns](https://github.com/saghul/aiodns) - 简单DNS异步解析库。
+* [aiohttp](https://github.com/aio-libs/aiohttp) - 异步http客户端/服务器框架
+* [aiomultiprocess](https://github.com/jreese/aiomultiprocess) - 将Python代码提升到更高的性能水平(multiprocessing和asyncio结合，实现异步多进程多协程)
+* [beautifulsoup4](https://pypi.org/project/beautifulsoup4/) - 可以轻松从HTML或XML文件中提取数据的Python库
+* [fire](https://github.com/google/python-fire) - Python Fire是一个纯粹根据任何Python对象自动生成命令行界面（CLI）的库
+* [loguru](https://github.com/Delgan/loguru) - 旨在带来愉快的日志记录Python库
+* [records](https://github.com/kennethreitz/records) - Records是一个非常简单但功能强大的库，用于对大多数关系数据库进行最原始SQL查询。
+* [requests](https://github.com/psf/requests) - Requests 唯一的一个非转基因的 Python HTTP 库，人类可以安全享用。
+* [tqdm](https://github.com/tqdm/tqdm) - 适用于Python和CLI的快速，可扩展的进度条库
+
+感谢这些伟大优秀的Python库！
+
+## 🌲目录结构
+
+```bash
+D:.
+|
++---.github
++---docs
+|       collection_modules.md 收集模块说明
++---images
+\---oneforall
+    |   aiobrute.py   异步多进程多协程子域爆破模块，可以单独运行
+    |   collect.py    各个收集模块上层调用
+    |   config.py     配置文件
+    |   dbexport.py   数据库导出模块，可以单独运行
+    |   domains.txt   要批量爆破的域名列表
+    |   oneforall.py  OneForAll主入口，可以单独运行
+    |   __init__.py
+    |
+    +---common 公共调用模块
+    +---data   存放一些所需数据
+    |       next_subdomains.txt     下一层子域字典
+    |       public_suffix_list.dat  顶级域名后缀 
+    |       srv_names.json          常见SRV记录前缀名
+    |       subdomains.txt          子域爆破常见字典
+    |
+    \---modules 
+        +---certificates     利用证书透明度收集子域模块
+        +---check            常规检查收集子域模块
+        +---crawl            利用网上爬虫档案收集子域模块
+        +---datasets         利用DNS数据集收集子域模块
+        +---dnsquery         利用DNS查询收集子域模块
+        +---intelligence     利用威胁情报平台数据收集子域模块
+        \---search           利用搜索引擎发现子域模块
+
+```
+
+## 🙏贡献
+
+非常热烈欢迎各位大佬一起完善本项目！
+
+## ⌛后续计划
+
+- [ ] 子域收集模块优化
+- [ ] 子域接管功能实现
+- [ ] 子域收集爬虫实现
+- [ ] 操作强大交互人性的前端界面实现
+
+更多详细信息请阅读[TODO.md](./TODO.md)。
+
+## 🔖版本控制
+
+该项目使用[SemVer](https://semver.org/)语言化版本格式进行版本管理，你可以在[Releases](https://github.com/shmilylty/OneForAll/releases)查看可用版本。
+
+## 👨‍💻作者
+
+* **[Jing Ling](https://github.com/shmilylty)**
+  * 核心开发
+
+* **[Black Star](https://github.com/blackstar24)**
+  * 模块贡献
+
+* [**iceMatcha**](https://github.com/iceMatcha)
+  * bug调试
+
+*你也可以在[CONTRIBUTORS.md](./CONTRIBUTORS.md)中参看所有参与该项目的开发者。*
+
+## 📄版权
+
+该项目签署了GPL-3.0授权许可，详情请参阅[LICENSE.md](./LICENSE.md)。
+
+## 😘鸣谢
+
+感谢网上开源的各个子域收集项目！
+
+感谢[A-Team](https://github.com/QAX-A-Team)大哥们热情无私的问题解答！
+
+## 📜免责声明 ##
+
+本工具仅限于安全研究与教学使用，用户使用本工具所造成的所有后果，由用户承担全部法律及连带责任，本项目所有作者和贡献者不承担任何法律及连带责任。

docs/building_fail_solution.md

@@ -0,0 +1,13 @@
+如果在安装依赖过程遇到编译某个依赖库失败时可以尝试以下方法：
+
+1. 到提供编译好的whl文件的第三方平台，找到对应库手动下载安装。第三方平台平台有： 
+ * [https://www.lfd.uci.edu/~gohlke/pythonlibs](https://www.lfd.uci.edu/~gohlke/pythonlibs)
+ * [https://pythonwheels.com/](https://pythonwheels.com/)
+
+选择好对应版本执行以下命令手动安装。举个例子，当编译pycares时失败时，找到[https://www.lfd.uci.edu/~gohlke/pythonlibs/#pycares](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pycares)，由于我的系统是Windows 10 64位，使用的Python 3.7便下载`pycares‑3.0.0‑cp37‑cp37m‑win_amd64.whl`（一般来说下载最新版本的），然后手动安装：
+
+```bash
+pip3 install pycares‑3.0.0‑cp37‑cp37m‑win_amd64.whl
+```
+
+2. 到库的项目地址issues和wiki等找找有没有解决方法，如果没有就给他们提issues发邮件😜。

docs/collection_modules.md

@@ -0,0 +1,103 @@
+#  收集模块说明 #
+
+如果要使用通过API收集子域的模块请先到[config.py](../oneforall/config.py)配置相关信息，大多平台的API都是可以注册账号免费获取的。
+
+如果你指定使用某些模块可以在[config.py](../oneforall/config.py)中设置：
+
+```python
+enable_all_module = False  # 不开启所有模块
+enable_partial_module = [('modules.search', 'ask')，('modules.search', 'baidu')]  # 只使用ask和baidu搜索引擎收集子域
+```
+
+如果你指定使用某些模块使用代理可以在[config.py](../oneforall/config.py)中设置：
+
+```python
+enable_proxy = True  # 使用代理
+proxy_all_module = False  # 不代理所有模块
+proxy_partial_module = ['GoogleQuery', 'AskSearch']  # 只代理GoogleQuery和AskSearch模块（各个模块的source属性值）
+```
+
+以下是各个模块说明：
+
+ 1. 利用证书透明度收集子域（目前有6个模块：`censys_api`，`certdb_api`，`certspotter`，`crtsh`，`entrust`，`google`）
+    
+      | 模块名称    | 是否需要代理 | 是否需要API | 其他说明                                           |
+      | ----------- | ------------ | ----------- | -------------------------------------------------- |
+      | censys_api  | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | certdb_api  | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | certspotter | 否           | 否          |                                                    |
+      | crtsh       | 否           | 否          |                                                    |
+      | entrust     | 否           | 否          |                                                    |
+      | google      | 是           | 否          |                                                    |
+
+
+  2. 常规检查收集子域（目前有4个模块：域传送漏洞利用`axfr`，检查跨域策略文件`cdx`，检查HTTPS证书`cert`，检查内容安全策略`csp`，后续会添加检查NSEC记录，NSEC3记录等模块）
+
+      | 模块名称 | 是否需要代理 | 是否需要API | 其他说明         |
+      | -------- | ------------ | ----------- | ---------------- |
+      | axfr     | 否           | 否          | 域传送漏洞利用   |
+      | cdx      | 由域名决定   | 否          | 检查跨域策略文件 |
+      | cert     | 否           | 否          | 检查HTTPS证书    |
+      | csp      | 由域名决定   | 否          | 检查内容安全策略 |
+  3. 利用网上爬虫档案收集子域（目前有2个模块：`archivecrawl`，`commoncrawl`，此模块还在调试，该模块还有待添加和完善）
+
+      | 模块名称     | 是否需要代理 | 是否需要API | 其他说明 |
+      | ------------ | ------------ | ----------- | -------- |
+      | archivecrawl | 否           | 否          |          |
+      | commoncrawl  | 否           | 否          |          |
+
+  4. 利用DNS数据集收集子域（目前有16个模块：`binaryedge_api`, `circl_api`, `hackertarget`, `riddler`, `bufferover`, `dnsdb`, `ipv4info`, `robtex`, `chinaz`, `dnsdb_api`, `netcraft`, `securitytrails_api`, `chinaz_api`, `dnsdumpster`, `ptrarchive`, `sitedossier`）
+
+      | 模块名称           | 是否需要代理 | 是否需要API | 其他说明                                           |
+      | ------------------ | ------------ | ----------- | -------------------------------------------------- |
+      | binaryedge_api     | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | bufferover         | 否           | 否          |                                                    |
+      | chinaz             | 否           | 否          |                                                    |
+      | chinaz_api         | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | circl_api          | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | dnsdb              | 否           | 否          |                                                    |
+      | dnsdb_api          | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | dnsdumpster        | 否           | 否          |                                                    |
+      | hackertarget       | 否           | 否          |                                                    |
+      | ipv4info           | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | netcraft           | 否           | 否          |                                                    |
+      | ptrarchive         | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | riddler            | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | robtex             | 否           | 否          |                                                    |
+      | securitytrails_api | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | sitedossier        | 否           | 否          |                                                    |
+  5. 利用DNS查询收集子域（目前有1个模块：通过枚举常见的SRV记录并做查询来收集子域`srv`，该模块还有待添加和完善）
+
+      | 模块名称 | 是否需要代理 | 是否需要API | 其他说明                      |
+      | -------- | ------------ | ----------- | ----------------------------- |
+      | srv      | 否           | 否          | 枚举域名常见的SRV记录发现子域 |
+  6. 利用威胁平台数据收集子域（目前有5个模块：`riskiq_api`，`threatbook_api`，`threatminer`，`virustotal`，`virustotal_api`该模块还有待添加和完善）
+
+      | 模块名称       | 是否需要代理 | 是否需要API | 其他说明                                           |
+      | -------------- | ------------ | ----------- | -------------------------------------------------- |
+      | riskiq_api     | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | threatbook_api | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+      | threatminer    | 否           | 否          |                                                    |
+      | virustotal     | 否           | 否          |                                                    |
+      | virustotal_api | 否           | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+  7. 利用搜索引擎发现子域（目前有15个模块：`ask`, `bing_api`, `fofa_api`, `shodan_api`, `yahoo`, `baidu`, `duckduckgo`, `google`, `so`, `yandex`, `bing`, `exalead`, `google_api`, `sogou`, `zoomeye_api`）
+
+     除特殊搜索引擎，通用的搜索引擎都支持自动排除搜索，全量搜索，递归搜索。
+
+     | 模块        | 是否需要代理           | 是否需要API | 其他说明                                           |
+     | ----------- | ---------------------- | ----------- | -------------------------------------------------- |
+     | ask         | 是                     | 否          |                                                    |
+     | baidu       | 否                     | 否          |                                                    |
+     | bing        | 否                     | 否          |                                                    |
+     | bing_api    | 否                     | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+     | duckduckgo  | 是                     | 否          |                                                    |
+     | exalead     | 否，最好使用国外代理。 | 否          |                                                    |
+     | fofa_api    | 否                     | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+     | google      | 是                     | 否          |                                                    |
+     | google_api  | 是                     | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+     | shodan_api  | 否，最好使用国外代理。 | 是          | API使用和申请见[config.py](../oneforall/config.py) |
+     | so          | 否                     | 否          |                                                    |
+     | sogou       | 否                     | 否          |                                                    |
+     | yahoo       | 是                     | 否          |                                                    |
+     | yandex      | 是                     | 否          |                                                    |
+     | zoomeye_api | 否                     | 是          | API使用和申请见[config.py](../oneforall/config.py) |

oneforall/__init__.py

@@ -1 +0,0 @@
-# coding=utf-8

oneforall/aiobrute.py

@@ -1,42 +1,48 @@
+#!/usr/bin/python3
 # coding=utf-8
-import os
-import time
-import queue
-import signal
-import pathlib
+
+"""
+OneForAll多进程多协程异步子域爆破模块
+
+:copyright: Copyright (c) 2019, Jing Ling. All rights reserved.
+:license: GNU General Public License v3.0, see LICENSE for more details.
+"""
+
 import asyncio
+import queue
+import secrets
+import signal
+import time
+
+import aiomultiprocess
+import exrex
 import fire
 import tqdm
-import exrex
-import secrets
-import aiomultiprocess
+
 import config
-from config import logger
-from common import utils, database, resolve
+from common import database, resolve, utils
 from common.module import Module
+from config import logger
 
 
 def init_worker():
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
 
-def get_wordlist(name):
-    return config.data_storage_path.joinpath(name)
-
-
 def detect_wildcard(domain):
     """
     探测域名是否使用泛解析
 
     :param str domain: 域名
-    :return: 如果没有使用泛解析返回False 使用返回泛解析的IP集合和ttl整型值
+    :return: 如果没有使用泛解析返回False 反之返回泛解析的IP集合和ttl整型值
     """
     logger.log('INFOR', f'正在探测{domain}是否使用泛解析')
     token = secrets.token_hex(16)
     random_subdomain = f'{token}.{domain}'
     try:
         answers = resolve.dns_query_a(random_subdomain)
-    except Exception as e:  # 如果查询随机域名A记录出错 说明不存在随机子域的A记录 即没有开启泛解析
+    # 如果查询随机域名A记录出错 说明不存在随机子域的A记录 即没有开启泛解析
+    except Exception as e:
         logger.log('DEBUG', e)
         logger.log('INFOR', f'{domain}没有使用泛解析')
         return False, None, None
@@ -121,40 +127,49 @@ def gen_brute_domains(domain, path):
 
 class AIOBrute(Module):
     """
-    多进程多协程异步子域爆破
-
-    :param str target:       单个域名或者每行一个域名的文件路径
-    :param int processes:    爆破的进程数（默认CPU核心数）
-    :param int coroutine:    每个爆破进程下的协程数（默认16）
-    :param str wordlist:     指定爆破所使用的字典路径（默认使用config.py配置）
-    :param bool recursive:   是否使用递归爆破（默认禁用）
-    :param int depth:        递归爆破的深度（默认2）
-    :param str namelist:     指定递归爆破所使用的字典路径（默认使用config.py配置）
-    :param bool fuzz:        是否使用fuzz模式进行爆破（默认禁用，开启必须指定fuzz正则规则）
-    :param str rule:         fuzz模式使用的正则规则（默认使用config.py配置）
+    OneForAll多进程多协程异步子域爆破模块
 
     Example：
-    python aiobrute.py --target example.com run
-    python aiobrute.py --target ./domains.txt run
-    python aiobrute.py --target example.com --processes 4 --coroutine 64 --wordlist data/subdomains.txt run
-    python aiobrute.py --target example.com --recursive True --depth 2 --namelist data/next_subdomains.txt run
-    python aiobrute.py --target www.{fuzz}.example.com --fuzz True --rule [a-z][0-9] run
+        python3 aiobrute.py --target example.com run
+        python3 aiobrute.py --target ./domains.txt run
+        python3 aiobrute.py --target example.com --processes 4 --coroutine 64
+        python3 aiobrute.py --target example.com --wordlist subdomains.txt run
+        python3 aiobrute.py --target example.com --recursive True --depth 2 run
+        python3 aiobrute.py --target m.{fuzz}.a.bz --fuzz True --rule [a-z] run
+
+    Note:
+        参数segment的设置受CPU性能，网络带宽，运营商限制等问题影响，默认设置500个子域为任务组，
+        当你觉得你的环境不受以上因素影响，当前爆破速度较慢，那么强烈建议根据字典大小调整大小：
+        十万字典建议设置为5000，百万字典设置为50000
+
+    :param str target:       单个域名或者每行一个域名的文件路径
+    :param int processes:    爆破的进程数(默认CPU核心数)
+    :param int coroutine:    每个爆破进程下的协程数(默认64)
+    :param str wordlist:     指定爆破所使用的字典路径(默认使用config.py配置)
+    :param int segment:      爆破任务分割(默认500)
+    :param bool recursive:   是否使用递归爆破(默认False)
+    :param int depth:        递归爆破的深度(默认2)
+    :param str namelist:     指定递归爆破所使用的字典路径(默认使用config.py配置)
+    :param bool fuzz:        是否使用fuzz模式进行爆破(默认False，开启须指定fuzz正则规则)
+    :param str rule:         fuzz模式使用的正则规则(默认使用config.py配置)
     """
 
     def __init__(self, target, processes=None, coroutine=64, wordlist=None,
-                 recursive=False, depth=2, namelist=None, fuzz=False, rule=None):
+                 segment=500, recursive=False, depth=2, namelist=None,
+                 fuzz=False, rule=None):
         Module.__init__(self)
         self.domains = set()
         self.domain = str()
         self.module = 'Brute'
         self.source = 'AIOBrute'
         self.target = target
-        self.processes = processes or config.brute_processes_num or os.cpu_count()
+        self.processes = processes or config.brute_processes_num
         self.coroutine = coroutine or config.brute_coroutine_num
-        self.wordlist = wordlist or config.brute_wordlist_path or get_wordlist('subdomains.txt')
+        self.wordlist = wordlist or config.brute_wordlist_path
+        self.segment = segment or config.brute_task_segment
         self.recursive_brute = recursive or config.enable_recursive_brute
         self.recursive_depth = depth or config.brute_recursive_depth
-        self.recursive_namelist = namelist or config.recursive_namelist_path or get_wordlist('next_subdomains.txt')
+        self.recursive_namelist = namelist or config.recursive_namelist_path
         self.fuzz = fuzz or config.enable_fuzz
         self.rule = rule or config.fuzz_rule
         self.nameservers = config.resolver_nameservers
@@ -164,15 +179,18 @@ class AIOBrute(Module):
         self.wildcard_ttl = int()  # 泛解析TTL整型值
 
     def gen_tasks(self, domain):
-        logger.log('INFOR', f'正在生成{domain}的字典')
-        if self.domain != domain:  # 如果domain不是self.domain，而是self.domain的子域 生成递归爆破字典
+        # 如果domain不是self.domain，而是self.domain的子域 生成递归爆破字典
+        if self.domain != domain:
+            logger.log('INFOR', f'使用{self.recursive_namelist}字典')
             domains = gen_brute_domains(domain, self.recursive_namelist)
         elif self.fuzz and self.rule:  # 开启fuzz模式并指定了fuzz正则规则
+            logger.log('INFOR', f'正在生成{domain}的fuzz字典')
             domains = gen_fuzz_domains(domain, self.rule)
         else:
+            logger.log('INFOR', f'使用{self.wordlist}字典')
             domains = gen_brute_domains(domain, self.wordlist)
         domains = list(domains)
-        return utils.split_list(domains, 500)  # 分割任务组 500个子域为一组任务
+        return utils.split_list(domains, self.segment)  # 分割任务组
 
     def deal_results(self, results):
         for result in results:
@@ -181,16 +199,22 @@ class AIOBrute(Module):
                 continue
             if isinstance(result, tuple):
                 subdomain, answers = result
+                if not answers:
+                    continue
                 ips = {record.host for record in answers}
-                value = self.ips_times.setdefault(str(ips), 0)  # 取值 如果是首次出现的IP集合 出现次数先赋值0
+                # 取值 如果是首次出现的IP集合 出现次数先赋值0
+                value = self.ips_times.setdefault(str(ips), 0)
                 self.ips_times[str(ips)] = value + 1
                 ttl = answers[0].ttl
                 if self.enable_wildcard:
-                    if wildcard_by_compare(ips, ttl, self.wildcard_ips, self.wildcard_ttl):
+                    if wildcard_by_compare(ips, ttl,
+                                           self.wildcard_ips,
+                                           self.wildcard_ttl):
                         continue
                 if wildcard_by_times(ips, self.ips_times):
                     continue
-                logger.log('INFOR', f'发现{self.domain}的子域: {subdomain} 解析IP: {ips} TTL: {ttl}')
+                logger.log('INFOR', f'发现{self.domain}的子域: {subdomain} '
+                                    f'解析IP: {ips} TTL: {ttl}')
                 self.subdomains.add(subdomain)
                 self.records[subdomain] = str(ips)
 
@@ -199,9 +223,12 @@ class AIOBrute(Module):
             self.enable_wildcard, self.wildcard_ips, self.wildcard_ttl = detect_wildcard(domain)
         tasks = self.gen_tasks(domain)
         logger.log('INFOR', f'正在爆破{domain}的域名')
-        for task in tqdm.tqdm(tasks, desc='Progress', smoothing=1.0, ncols=True):
-            async with aiomultiprocess.Pool(processes=self.processes, initializer=init_worker,
-                                            childconcurrency=self.coroutine) as pool:
+        for task in tqdm.tqdm(tasks, desc='Progress',
+                              smoothing=1.0, ncols=True):
+            async with aiomultiprocess.Pool(processes=self.processes,
+                                            initializer=init_worker,
+                                            childconcurrency=self.coroutine)\
+                    as pool:
                 try:
                     results = await pool.map(resolve.aiodns_query_a, task)
                 except KeyboardInterrupt:
@@ -211,11 +238,10 @@ class AIOBrute(Module):
                     self.gen_result()
                     rx_queue.put(self.results)
                     return
-                else:
-                    self.deal_results(results)
-            self.save_json()
-            self.gen_result()
-            rx_queue.put(self.results)
+                self.deal_results(results)
+                self.save_json()
+                self.gen_result()
+                rx_queue.put(self.results)
 
     def run(self, rx_queue=None):
         self.domains = utils.get_domains(self.target)
@@ -228,25 +254,31 @@ class AIOBrute(Module):
             if not rx_queue:
                 rx_queue = queue.Queue()
             logger.log('INFOR', f'开始执行{self.source}模块爆破域名{self.domain}')
-            logger.log('INFOR', f'{self.source}模块使用{self.processes}个进程乘{self.coroutine}个协程')
-            # logger.log('INFOR', f'{self.source}模块使用个进程乘{self.coroutine}个协程')
-            if self.recursive_brute and not self.fuzz:  # fuzz模式不使用递归爆破
+            logger.log('INFOR', f'使用{self.processes}进程乘{self.coroutine}协程')
+            # fuzz模式不使用递归爆破
+            if self.recursive_brute and not self.fuzz:
                 logger.log('INFOR', f'开始递归爆破{self.domain}的第1层子域')
             loop = asyncio.get_event_loop()
             asyncio.set_event_loop(loop)
             loop.run_until_complete(self.main(self.domain, rx_queue))
 
             # 递归爆破下一层的子域
-            if self.recursive_brute and not self.fuzz:  # fuzz模式不使用递归爆破
-                for layer_num in range(1, self.recursive_depth):  # 之前已经做过1层子域爆破 当前实际递归层数是layer+1
-                    logger.log('INFOR', f'开始递归爆破{self.domain}的第{layer_num+1}层子域')
+            # fuzz模式不使用递归爆破
+            if self.recursive_brute and not self.fuzz:
+                for layer_num in range(1, self.recursive_depth):
+                    # 之前已经做过1层子域爆破 当前实际递归层数是layer+1
+                    logger.log('INFOR', f'开始递归爆破{self.domain}的'
+                                        f'第{layer_num + 1}层子域')
                     for subdomain in self.subdomains.copy():
-                        if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域爆破的限制条件
-                            loop.run_until_complete(self.main(subdomain, rx_queue))
-
-
-            while not rx_queue.empty():  # 队列不空就一直取数据存数据库
-                database.save_db(db_conn, table_name, rx_queue.get())  # 将结果存入数据库中
+                        # 进行下一层子域爆破的限制条件
+                        if subdomain.count('.') - self.domain.count('.') == layer_num:
+                            loop.run_until_complete(self.main(subdomain,
+                                                              rx_queue))
+            # 队列不空就一直取数据存数据库
+            while not rx_queue.empty():
+                source, results = rx_queue.get()
+                # 将结果存入数据库中
+                database.save_db(db_conn, table_name, results, source)
             database.copy_table(db_conn, table_name)
             database.deduplicate_subdomain(db_conn, table_name)
             database.remove_invalid(db_conn, table_name)
@@ -254,8 +286,11 @@ class AIOBrute(Module):
             end = time.time()
             self.elapsed = round(end - start, 1)
             logger.log('INFOR', f'结束执行{self.source}模块爆破域名{self.domain}')
-            logger.log('INFOR', f'{self.source}模块耗时{self.elapsed}秒发现{self.domain}的域名{len(self.subdomains)}个')
-            logger.log('DEBUG', f'{self.source}模块发现{self.domain}的的域名 {self.subdomains}')
+            length = len(self.subdomains)
+            logger.log('INFOR', f'{self.source}模块耗时{self.elapsed}秒'
+                                f'发现{self.domain}的域名{length}个')
+            logger.log('DEBUG', f'{self.source}模块发现{self.domain}的域名:\n'
+                                f'{self.subdomains}')
 
 
 def do(domain, result):  # 统一入口名字 方便多线程调用
@@ -270,6 +305,6 @@ def do(domain, result):  # 统一入口名字 方便多线程调用
 
 
 if __name__ == '__main__':
-    # fire.Fire(AIOBrute)
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    fire.Fire(AIOBrute)
+    # result_queue = queue.Queue()
+    # do('example.com', result_queue)

oneforall/collect.py

@@ -9,6 +9,7 @@ import importlib
 import config
 import dbexport
 from common import database
+from config import logger
 
 
 class Collect(object):
@@ -30,13 +31,17 @@ class Collect(object):
         :return: None
         """
         if config.enable_all_module:
-            # modules = ['brute', 'certificates', 'crawl', 'datasets', 'intelligence', 'search']
-            modules = ['certificates', 'check', 'datasets', 'dnsquery', 'intelligence', 'search']  # crawl模块还有点问题
+            # modules = ['brute', 'certificates', 'crawl',
+            # 'datasets', 'intelligence', 'search']
+            # crawl模块还有点问题
+            modules = ['certificates', 'check', 'datasets',
+                       'dnsquery', 'intelligence', 'search']
             # modules = ['intelligence']  # crawl模块还有点问题
             for module in modules:
                 module_path = config.oneforall_module_path.joinpath(module)
                 for path in module_path.rglob('*.py'):
-                    import_module = ('modules.' + module, path.stem)  # 需要导入的类
+                    # 需要导入的类
+                    import_module = ('modules.' + module, path.stem)
                     self.modules.append(import_module)
         else:
             self.modules = config.enable_partial_module
@@ -54,15 +59,16 @@ class Collect(object):
         类运行入口
         """
         start = time.time()
+        logger.log('INFOR', f'开始收集{self.domain}的子域')
         self.get_mod()
         self.import_func()
 
-        if not rx_queue:
-            rx_queue = queue.Queue(maxsize=len(self.collect_func))  # 结果集队列
         threads = []
         # 创建多个子域收集线程
         for collect_func in self.collect_func:
-            thread = threading.Thread(target=collect_func, args=(self.domain, rx_queue), daemon=True)
+            thread = threading.Thread(target=collect_func,
+                                      args=(self.domain,),
+                                      daemon=True)
             threads.append(thread)
         # 启动所有线程
         for thread in threads:
@@ -81,7 +87,8 @@ class Collect(object):
         # 数据库导出
         if self.export:
             if not self.path:
-                self.path = config.result_save_path.joinpath(f'{self.domain}.{self.format}')
+                name = f'{self.domain}.{self.format}'
+                self.path = config.result_save_path.joinpath(name)
             dbexport.export(table_name, path=self.path, format=self.format)
         end = time.time()
         self.elapsed = round(end - start, 1)

oneforall/common/database.py

@@ -40,7 +40,7 @@ def create_table(db_conn, table_name):
     """
     logger.log('DEBUG', f'正在创建{table_name}表')
     try:
-        db_conn.query(f'create table if not exists {table_name} ('
+        db_conn.query(f'create table if not exists "{table_name}" ('
                       f'id integer primary key,'
                       f'url text,'
                       f'subdomain text,'
@@ -71,7 +71,7 @@ def save_db(db_conn, table_name, results, module_name=None):
     logger.log('DEBUG', f'正在将{module_name}模块发现{table_name}的子域结果存入数据库')
     if results:
         try:
-            db_conn.bulk_query(f'insert into {table_name} (id, url, subdomain, port, ips, status,'
+            db_conn.bulk_query(f'insert into "{table_name}" (id, url, subdomain, port, ips, status,'
                                f'reason, valid, title, banner, module, source, elapsed, count)'
                                f'values (:id, :url, :subdomain, :port, :ips, :status, :reason, :valid,'
                                f':title, :banner, :module, :source, :elapsed, :count)', results)
@@ -89,8 +89,8 @@ def copy_table(db_conn, table_name):
     new_table_name = table_name + '_bak'
     logger.log('DEBUG', f'正在将{table_name}表复制到{new_table_name}新表')
     try:
-        db_conn.query(f'drop table if exists {new_table_name}')
-        db_conn.query(f'create table {new_table_name} as select * from {table_name}')
+        db_conn.query(f'drop table if exists "{new_table_name}"')
+        db_conn.query(f'create table "{new_table_name}" as select * from "{table_name}"')
     except Exception as e:
         logger.log('ERROR', e)
 
@@ -104,7 +104,7 @@ def clear_table(db_conn, table_name):
     """
     logger.log('DEBUG', f'正在清空{table_name}表中的数据')
     try:
-        db_conn.query(f'delete from {table_name}')
+        db_conn.query(f'delete from "{table_name}"')
     except Exception as e:
         logger.log('ERROR', e)
 
@@ -118,7 +118,7 @@ def deduplicate_subdomain(db_conn, table_name):
     """
     logger.log('DEBUG', f'正在去重{table_name}表中的子域')
     try:
-        db_conn.query(f'delete from {table_name} where id not in (select min(id) from {table_name} group by subdomain)')
+        db_conn.query(f'delete from "{table_name}" where id not in (select min(id) from "{table_name}" group by subdomain)')
     except Exception as e:
         logger.log('ERROR', e)
 
@@ -132,7 +132,7 @@ def remove_invalid(db_conn, table_name):
         """
     logger.log('DEBUG', f'正在去除{table_name}表中的无效子域')
     try:
-        db_conn.query(f'delete from {table_name} where subdomain is null or valid == 0')
+        db_conn.query(f'delete from "{table_name}" where subdomain is null or valid == 0')
     except Exception as e:
         logger.log('ERROR', e)
 
@@ -146,7 +146,7 @@ def get_data(db_conn, table_name):
     """
     logger.log('DEBUG', f'获取{table_name}表中的所有数据')
     try:
-        rows = db_conn.query(f'select * from {table_name}')
+        rows = db_conn.query(f'select * from "{table_name}"')
     except Exception as e:
         logger.log('ERROR', e)
     else:
@@ -163,7 +163,7 @@ def get_subdomain(db_conn, table_name, valid):
     """
     logger.log('DEBUG', f'获取{table_name}表中的所有数据')
     try:
-        rows = db_conn.query(f'select * from {table_name} where valid = {valid}')
+        rows = db_conn.query(f'select * from "{table_name}" where valid = {valid}')
     except Exception as e:
         logger.log('ERROR', e)
     else:

oneforall/common/module.py

@@ -6,6 +6,7 @@
 import json
 import re
 import threading
+import time
 
 import requests
 import config
@@ -32,7 +33,38 @@ class Module(object):
         self.subdomains = set()  # 存放发现的子域
         self.records = dict()  # 存放子域解析记录
         self.results = list()  # 存放模块结果
-        self.elapsed = 0.0  # 模块执行耗时
+        self.start = time.time()  # 模块开始执行时间
+        self.end = None
+        self.elapsed = time.time() - self.start  # 模块执行耗时
+
+    def check(self, *apis):
+        """
+        简单检查是否配置了api信息
+        :param apis: api信息元组
+        :return: 检查结果
+        """
+        if not all(apis):
+            logger.log('ALERT', f'{self.source}模块API配置有误跳过执行')
+            return False
+        return True
+
+    def begin(self):
+        """
+        输出模块开始信息
+        """
+        logger.log('DEBUG', f'开始执行{self.source}模块收集{self.domain}的子域')
+
+    def finish(self):
+        """
+        输出模块结束信息
+        """
+        self.end = time.time()
+        self.elapsed = round(self.end - self.start, 1)
+        logger.log('DEBUG', f'结束执行{self.source}模块收集{self.domain}的子域')
+        logger.log('INFOR', f'{self.source}模块耗时{self.elapsed}秒发现子域'
+                   f'{len(self.subdomains)}个')
+        logger.log('DEBUG', f'{self.source}模块发现{self.domain}的子域\n'
+                   f'{self.subdomains}')
 
     def get(self, url, params=None, **kwargs):
         """
@@ -44,19 +76,27 @@ class Module(object):
         :return: requests响应对象
         """
         try:
-            resp = requests.get(url, params=params, cookies=self.cookie, headers=self.header,
-                                proxies=self.proxy, timeout=self.timeout, verify=self.verify, **kwargs)
+            resp = requests.get(url,
+                                params=params,
+                                cookies=self.cookie,
+                                headers=self.header,
+                                proxies=self.proxy,
+                                timeout=self.timeout,
+                                verify=self.verify,
+                                **kwargs)
         except Exception as e:
             logger.log('ERROR', e)
             return None
-        if resp.status_code != 200:
-            logger.log('ALERT', f'GET {resp.url} {resp.status_code} - {resp.reason} {len(resp.content)}')
+        # 状态码非200或者响应体为空
+        if resp.status_code != 200 or not resp.content:
+            logger.log('ALERT', f'GET {resp.url} {resp.status_code} - '
+                       f'{resp.reason} {len(resp.content)}')
             content_type = resp.headers.get('Content-Type')
-            if content_type:
-                if 'json' in content_type:
-                    logger.log('ALERT', resp.json())
+            if content_type and 'json' in content_type and resp.content:
+                logger.log('ALERT', resp.json())
             return None
-        logger.log('DEBUG', f'GET {resp.url} {resp.status_code} - {resp.reason} {len(resp.content)}')
+        logger.log('DEBUG', f'GET {resp.url} {resp.status_code} - '
+                   f'{resp.reason} {len(resp.content)}')
         return resp
 
     def post(self, url, data=None, **kwargs):
@@ -69,18 +109,25 @@ class Module(object):
         :return: requests响应对象
         """
         try:
-            resp = requests.post(url, data=data, cookies=self.cookie, headers=self.header,
-                                 proxies=self.proxy, timeout=self.timeout, verify=self.verify, **kwargs)
+            resp = requests.post(url,
+                                 data=data,
+                                 cookies=self.cookie,
+                                 headers=self.header,
+                                 proxies=self.proxy,
+                                 timeout=self.timeout,
+                                 verify=self.verify,
+                                 **kwargs)
         except Exception as e:
             logger.log('ERROR', e)
             return None
-        if resp.status_code != 200:
+        # 状态码非200或者响应体为空
+        if resp.status_code != 200 or not resp.content:
             content_type = resp.headers.get('Content-Type')
-            if content_type:
-                if 'json' in content_type:
-                    logger.log('ALERT', resp.json())
+            if content_type and 'json' in content_type and resp.content:
+                logger.log('ALERT', resp.json())
             return None
-        logger.log('DEBUG', f'POST {resp.url} {resp.status_code} - {resp.reason} {len(resp.content)}')
+        logger.log('DEBUG', f'POST {resp.url} {resp.status_code} - '
+                   f'{resp.reason} {len(resp.content)}')
         return resp
 
     def get_header(self):
@@ -127,12 +174,14 @@ class Module(object):
         :rtype: set or list
         """
         logger.log('DEBUG', f'正则匹配响应体中的子域')
-        regexp = r'(?:\>|\"|\'|\=|\,)(?:http\:\/\/|https\:\/\/)?(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.){0,}' \
+        regexp = r'(?:\>|\"|\'|\=|\,)(?:http\:\/\/|https\:\/\/)?' \
+                 r'(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.){0,}' \
                  + domain.replace('.', r'\.')
         result = re.findall(regexp, html, re.I)
         if not result:
             return set()
-        deal = map(lambda s: re.sub(r'(?:http://|https://)', '', s[1:].lower(), flags=re.I), result)
+        regexp = r'(?:http://|https://)'
+        deal = map(lambda s: re.sub(regexp, '', s[1:].lower()), result)
         if distinct:
             return set(deal)
         else:
@@ -154,30 +203,57 @@ class Module(object):
         """
         logger.log('DEBUG', f'将{self.source}模块发现的子域结果保存为json文件')
         if config.save_module_result:
-            dirpath = config.result_save_path.joinpath(self.domain, self.module)
-            dirpath.mkdir(parents=True, exist_ok=True)
+            dpath = config.result_save_path.joinpath(self.domain, self.module)
+            dpath.mkdir(parents=True, exist_ok=True)
             name = self.source + '.json'
-            path = dirpath.joinpath(name)
+            path = dpath.joinpath(name)
             with open(path, mode='w', encoding='utf-8') as file:
-                result = {'domain': self.domain, 'name': self.module, 'source': self.source, 'elapsed': self.elapsed,
-                          'count': len(self.subdomains), 'subdomains': list(self.subdomains), 'records': self.records}
+                result = {'domain': self.domain,
+                          'name': self.module,
+                          'source': self.source,
+                          'elapsed': self.elapsed,
+                          'count': len(self.subdomains),
+                          'subdomains': list(self.subdomains),
+                          'records': self.records}
                 json.dump(result, file, ensure_ascii=False, indent=4)
 
     def gen_result(self):
         results = list()
         if not len(self.subdomains):  # 一个子域都没有发现的情况
-            result = {'id': None, 'url': None, 'subdomain': None, 'port': None, 'ips': None, 'status': None,
-                      'reason': None, 'valid': 1, 'title': None, 'banner': None, 'module': self.module,
-                      'source': self.source, 'elapsed': self.elapsed, 'count': 0}
+            result = {'id': None,
+                      'url': None,
+                      'subdomain': None,
+                      'port': None,
+                      'ips': None,
+                      'status': None,
+                      'reason': None,
+                      'valid': 1,
+                      'title': None,
+                      'banner': None,
+                      'module': self.module,
+                      'source': self.source,
+                      'elapsed': self.elapsed,
+                      'count': 0}
             results.append(result)
             self.results = (self.source, results)
         else:
             for subdomain in self.subdomains:
                 url = 'http://' + subdomain
                 ips = self.records.get(subdomain)
-                result = {'id': None, 'url': url, 'subdomain': subdomain, 'port': None, 'ips': ips, 'status': None,
-                          'reason': None, 'valid': 1, 'title': None, 'banner': None, 'module': self.module,
-                          'source': self.source, 'elapsed': self.elapsed, 'count': len(self.subdomains)}
+                result = {'id': None,
+                          'url': url,
+                          'subdomain': subdomain,
+                          'port': None,
+                          'ips': ips,
+                          'status': None,
+                          'reason': None,
+                          'valid': 1,
+                          'title': None,
+                          'banner': None,
+                          'module': self.module,
+                          'source': self.source,
+                          'elapsed': self.elapsed,
+                          'count': len(self.subdomains)}
                 results.append(result)
             self.results = (self.source, results)
 
@@ -187,5 +263,6 @@ class Module(object):
         table_name = self.domain.replace('.', '_')
         database.create_table(db_conn, table_name)
         source, results = self.results
-        database.save_db(db_conn, table_name, results, source)  # 将结果存入数据库中
+        # 将结果存入数据库中
+        database.save_db(db_conn, table_name, results, source)
         lock.release()

oneforall/common/request.py

@@ -1,7 +1,6 @@
 # coding=utf-8
 
 import asyncio
-import functools
 import aiohttp
 from aiohttp import ClientSession
 from aiohttp.resolver import AsyncResolver
@@ -52,43 +51,49 @@ async def fetch(session, url, semaphore):
 
     :param session: session对象
     :param url: url地址
-    :param semaphore: 同步对象（控制并发量）
+    :param semaphore: 同步对象(控制并发量)
     :return: 响应对象和响应文本
     """
     timeout = aiohttp.ClientTimeout(total=config.get_timeout)
     async with semaphore:
-        async with session.get(url, allow_redirects=config.get_redirects,
-                               timeout=timeout, proxy=config.get_proxy) as resp:
+        async with session.get(url,
+                               ssl=config.verify_ssl,
+                               allow_redirects=config.get_redirects,
+                               timeout=timeout,
+                               proxy=config.get_proxy) as resp:
             text = await resp.text()
             return resp, text
 
 
-def request_callback(future, index, datas):
-    try:
-        resp, text = future.result()
-    except Exception as e:
-        logger.log('DEBUG', e.args)
-        datas[index]['reason'] = str(e.args)
-        datas[index]['valid'] = 0
-    else:
-        datas[index]['reason'] = resp.reason
-        datas[index]['status'] = resp.status
-        if resp.status == 400 or resp.status >= 500:
+def deal_results(datas, results):
+    for index, result in enumerate(results):
+        if isinstance(result, Exception):
+            logger.log('DEBUG', result.args)
+            datas[index]['reason'] = str(result.args)
             datas[index]['valid'] = 0
-        else:
-            headers = resp.headers
-            banner = str({'Server': headers.get('Server'), 'Via': headers.get('Via'),
-                          'X-Powered-By': headers.get('X-Powered-By')})
-            datas[index]['banner'] = banner
-            soup = BeautifulSoup(text, 'lxml')
-            title = soup.title
-            head = soup.head
-            if title:
-                datas[index]['title'] = title.text
-            elif head:
-                datas[index]['title'] = head.text
+            continue
+        if isinstance(result, tuple):
+            resp, text = result
+            datas[index]['reason'] = resp.reason
+            datas[index]['status'] = resp.status
+            if resp.status == 400 or resp.status >= 500:
+                datas[index]['valid'] = 0
             else:
-                datas[index]['title'] = text
+                headers = resp.headers
+                banner = str({'Server': headers.get('Server'),
+                              'Via': headers.get('Via'),
+                              'X-Powered-By': headers.get('X-Powered-By')})
+                datas[index]['banner'] = banner
+                soup = BeautifulSoup(text, 'lxml')
+                title = soup.title
+                head = soup.head
+                if title:
+                    datas[index]['title'] = title.text
+                elif head:
+                    datas[index]['title'] = head.text
+                else:
+                    datas[index]['title'] = text
+    return datas
 
 
 async def bulk_get_request(datas, port):
@@ -98,18 +103,23 @@ async def bulk_get_request(datas, port):
     header = None
     if config.fake_header:
         header = utils.gen_fake_header()
-    resolver = AsyncResolver(nameservers=config.resolver_nameservers)  # 使用异步域名解析器 自定义域名服务器
-    conn = aiohttp.TCPConnector(verify_ssl=config.verify_ssl, limit=config.limit_open_conn,
-                                limit_per_host=config.limit_per_host, resolver=resolver)
+    # 使用异步域名解析器 自定义域名服务器
+    resolver = AsyncResolver(nameservers=config.resolver_nameservers)
+    conn = aiohttp.TCPConnector(ssl=config.verify_ssl,
+                                limit=config.limit_open_conn,
+                                limit_per_host=config.limit_per_host,
+                                resolver=resolver)
     semaphore = asyncio.Semaphore(utils.get_semaphore())
     async with ClientSession(connector=conn, headers=header) as session:
         tasks = []
         for i, data in enumerate(new_datas):
             url = data.get('url')
             task = asyncio.ensure_future(fetch(session, url, semaphore))
-            task.add_done_callback(functools.partial(request_callback, index=i, datas=new_datas))
             tasks.append(task)
         if tasks:  # 任务列表里有任务不空时才进行解析
-            await asyncio.wait(tasks)  # 等待所有task完成
+            # 等待所有task完成 错误聚合到结果列表里
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            new_datas = deal_results(new_datas, results)
+
     logger.log('INFOR', f'完成异步进行子域的GET请求')
     return new_datas

oneforall/common/resolve.py

@@ -39,7 +39,7 @@ def aiodns_resolver():
                               timeout=config.resolver_timeout)
 
 
-async def aiodns_query_a(hostname, semaphore):
+async def aiodns_query_a(hostname, semaphore=None):
     """
     异步查询A记录
 
@@ -47,10 +47,15 @@ async def aiodns_query_a(hostname, semaphore):
     :param semaphore: 并发查询数量
     :return: 主机名或查询结果或查询异常
     """
-    async with semaphore:
+    if semaphore is None:
         resolver = aiodns_resolver()
         answers = await resolver.query(hostname, 'A')
         return hostname, answers
+    else:
+        async with semaphore:
+            resolver = aiodns_resolver()
+            answers = await resolver.query(hostname, 'A')
+            return hostname, answers
 
 
 def resolve_callback(future, index, datas):
@@ -80,7 +85,9 @@ async def bulk_query_a(datas):
         if not data.get('ips'):
             subdomain = data.get('subdomain')
             task = asyncio.ensure_future(aiodns_query_a(subdomain, semaphore))
-            task.add_done_callback(functools.partial(resolve_callback, index=i, datas=datas))  # 回调
+            task.add_done_callback(functools.partial(resolve_callback,
+                                                     index=i,
+                                                     datas=datas))  # 回调
             tasks.append(task)
     if tasks:  # 任务列表里有任务不空时才进行解析
         await asyncio.wait(tasks)  # 等待所有task完成

oneforall/common/search.py

@@ -28,16 +28,18 @@ class Search(Module):
         :rtype: str
         """
         statements_list = []
-        subdomains_temp = set(map(lambda x: x + '.' + domain, config.subdomains_common))
+        subdomains_temp = set(map(lambda x: x + '.' + domain,
+                                  config.subdomains_common))
         subdomains_temp = list(subdomain.intersection(subdomains_temp))
         for i in range(0, len(subdomains_temp), 2):  # 同时排除2个子域
-            statements_list.append(''.join(set(map(lambda s: ' -site:' + s, subdomains_temp[i:i + 2]))))
+            statements_list.append(''.join(set(map(lambda s: ' -site:' + s,
+                                                   subdomains_temp[i:i + 2]))))
         return statements_list
 
     def match_location(self, domain, url):
         """
         匹配跳转之后的url
-        针对部分搜索引擎（如百度搜索）搜索展示url时有显示不全的情况
+        针对部分搜索引擎(如百度搜索)搜索展示url时有显示不全的情况
         此函数会向每条结果的链接发送head请求获取响应头的location值并做子域匹配
 
         :param str domain: 域名
@@ -45,6 +47,7 @@ class Search(Module):
         :return: 匹配的子域
         :rtype set
         """
-        resp = requests.head(url, headers=self.header, proxies=self.proxy, timeout=self.timeout, allow_redirects=False)
+        resp = requests.head(url, headers=self.header, proxies=self.proxy,
+                             timeout=self.timeout, allow_redirects=False)
         location = resp.headers.get('location')
         return set(utils.match_subdomain(domain, location))

oneforall/common/utils.py

@@ -5,10 +5,21 @@ import random
 import ipaddress
 import platform
 import config
-from fake_useragent import UserAgent
 from common.domain import Domain
 from config import logger
 
+user_agents = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:54.0) Gecko/20100101 Firefox/68.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:61.0) '
+    'Gecko/20100101 Firefox/68.0',
+    'Mozilla/5.0 (X11; Linux i586; rv:31.0) Gecko/20100101 Firefox/68.0']
+
 
 def match_subdomain(domain, text, distinct=True):
     """
@@ -20,7 +31,8 @@ def match_subdomain(domain, text, distinct=True):
     :return: 匹配结果
     :rtype: set or list
     """
-    regexp = r'(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.){0,}' + domain.replace('.', r'\.')
+    regexp = r'(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.){0,}' \
+             + domain.replace('.', r'\.')
     result = re.findall(regexp, text, re.I)
     if not result:
         return set()
@@ -45,10 +57,11 @@ def gen_fake_header():
     """
     生成伪造请求头
     """
-    ua = UserAgent()
+    ua = random.choice(user_agents)
     ip = gen_random_ip()
     headers = {
-        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept': 'text/html,application/xhtml+xml,'
+                  'application/xml;q=0.9,*/*;q=0.8',
         'Accept-Encoding': 'gzip, deflate, br',
         'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7',
         'Cache-Control': 'max-age=0',
@@ -56,7 +69,7 @@ def gen_fake_header():
         'DNT': '1',
         'Referer': 'https://www.google.com/',
         'Upgrade-Insecure-Requests': '1',
-        'User-Agent': ua.random,
+        'User-Agent': ua,
         'X-Forwarded-For': ip,
         'X-Real-IP': ip
     }
@@ -86,7 +99,7 @@ def split_list(ls, size):
     """
     if size == 0:
         return ls
-    return [ls[i:i+size] for i in range(0, len(ls), size)]
+    return [ls[i:i + size] for i in range(0, len(ls), size)]
 
 
 def get_domains(target):
@@ -127,4 +140,3 @@ def get_semaphore():
         return 1000
     elif system == 'Darwin':
         return 1000
-

oneforall/config.py

@@ -2,7 +2,7 @@
 """
 OneForAll配置
 """
-
+import os
 import sys
 import pathlib
 from loguru import logger
@@ -18,36 +18,48 @@ result_save_path = oneforall_relpath.joinpath('results')  # 结果保存目录
 save_module_result = True  # 保存模块中各脚本结果 默认保存
 enable_all_module = True  # 启用所有模块 默认启用
 enable_partial_module = []  # 启用部分模块 必须禁用enable_all_module才能生效
-# enable_partial_module = [('modules.search', 'google')]  # 启用部分模块 必须禁用enable_all_module才能生效
+# 只使用ask和baidu搜索引擎收集子域
+# enable_partial_module = [('modules.search', 'ask')
+#                          ('modules.search', 'baidu')]
 
 
 # 爆破模块设置
-enable_brute_module = False  # 使用爆破模块（默认禁用）
+enable_brute_module = False  # 使用爆破模块(默认禁用)
 enable_wildcard_check = True  # 开启泛解析检测 会去掉泛解析的子域
-brute_processes_num = None  # 爆破时使用的进程数（根据系统中CPU数量情况设置 不宜大于CPU数量 默认None为系统中的CPU数量）
-brute_coroutine_num = 128  # 爆破时每个进程下的协程数（不宜大于1000）
-brute_wordlist_path = None  # 爆破所使用的字典路径 默认data/subdomains.dict
-use_general_wordlist = False  # 是否使用通用字典（默认禁用）
-enable_recursive_brute = False  # 是否使用递归爆破（默认禁用）
-brute_recursive_depth = 2  # 递归爆破深度（默认2层）
-recursive_namelist_path = None  # 爆破下一层子域所使用的字典路径 默认data/next_subdomains.dict
+# 爆破时使用的进程数(根据系统中CPU数量情况设置 不宜大于CPU数量 默认为系统中的CPU数量)
+brute_processes_num = os.cpu_count()
+brute_coroutine_num = 128  # 爆破时每个进程下的协程数(不宜大于1000)
+# 爆破所使用的字典路径 默认data/subdomains.txt
+brute_wordlist_path = 'data/subdomains.txt'
+brute_task_segment = 500
+# 参数segment的设置受CPU性能，网络带宽，运营商限制等问题影响，默认设置500个子域为一任务组，
+# 当你觉得你的环境不受以上因素影响，当前爆破速度较慢，那么强烈建议根据字典大小调整大小：
+# 十万字典建议设置为5000，百万字典设置为50000
+enable_recursive_brute = False  # 是否使用递归爆破(默认禁用)
+brute_recursive_depth = 2  # 递归爆破深度(默认2层)
+# 爆破下一层子域所使用的字典路径 默认data/next_subdomains.txt
+recursive_namelist_path = 'data/next_subdomains.txt'
 enable_fuzz = False  # 是否使用fuzz模式枚举域名
 fuzz_rule = ''  # fuzz域名的正则 示例：[a-z][0-9] 第一位是字母 第二位是数字
 ips_appear_maximum = 10  # 同一IP集合出现次数超过10认为是泛解析
 
 # 代理设置
-enable_proxy = True  # 是否使用代理 全局开关
+enable_proxy = False  # 是否使用代理 全局开关
 proxy_all_module = False  # 代理所有模块
-proxy_partial_module = ['GoogleQuery', 'AskSearch', 'DuckDuckGoSearch', 'GoogleAPISearch',
-                        'GoogleSearch', 'YahooSearch', 'YandexSearch']  # 代理自定义的模块
-proxy_pool = [{'http': 'http://127.0.0.1:1080', 'https': 'https://127.0.0.1:1080'}]  # 代理池
-# proxy_pool = [{'http': 'socks5://127.0.0.1:10808', 'https': 'socks5://127.0.0.1:10808'}]  # 代理池
+proxy_partial_module = ['GoogleQuery', 'AskSearch', 'DuckDuckGoSearch',
+                        'GoogleAPISearch', 'GoogleSearch', 'YahooSearch',
+                        'YandexSearch', 'CrossDomainXml',
+                        'ContentSecurityPolicy']  # 代理自定义的模块
+proxy_pool = [{'http': 'http://127.0.0.1:1080',
+               'https': 'https://127.0.0.1:1080'}]  # 代理池
+# proxy_pool = [{'http': 'socks5://127.0.0.1:10808',
+#                'https': 'socks5://127.0.0.1:10808'}]  # 代理池
 
 
 # 网络请求设置
 enable_fake_header = True  # 启用伪造请求头
 request_delay = 1  # 请求时延
-request_timeout = 30  # 请求超时(AskSearch和YahooSearch比较慢)
+request_timeout = 30  # 请求超时
 request_verify = True  # 请求SSL验证
 
 # 搜索模块设置
@@ -80,14 +92,17 @@ xlarge_ports = {80, 81, 300, 443, 591, 593, 832, 981, 1010, 1311, 2082,
                 8500, 8834, 8880, 8888, 8983, 9000, 9043, 9060, 9080, 9090,
                 9091, 9200, 9443, 9800, 9981, 12443, 16080, 18091, 18092,
                 20720, 28017}
-ports = {'small': small_ports, 'medium': medium_ports, 'large': large_ports, 'xlarge': xlarge_ports}
+ports = {'small': small_ports, 'medium': medium_ports,
+         'large': large_ports, 'xlarge': xlarge_ports}
 verify_ssl = False
-get_proxy = None  # aiohttp 支持 HTTP/HTTPS形式的代理 proxy="http://user:pass@some.proxy.com"
+# aiohttp 支持 HTTP/HTTPS形式的代理
+get_proxy = None  # proxy="http://user:pass@some.proxy.com"
 get_timeout = 10  # http请求探测总超时时间 None或者0则表示不检测超时
 get_redirects = True  # 允许请求跳转
 fake_header = True  # 使用伪造请求头
-limit_open_conn = 100  # 限制同一时间打开的连接数（默认100），0表示不限制
-limit_per_host = 0  # 限制同一时间在同一个端点((host, port, is_ssl) 3者都一样的情况)打开的连接数（默认0表示不限制）
+limit_open_conn = 100  # 限制同一时间打开的连接数(默认100)，0表示不限制
+# 限制同一时间在同一个端点((host, port, is_ssl) 3者都一样的情况)打开的连接数
+limit_per_host = 0  # 默认0表示不限制
 
 
 # 模块API配置
@@ -102,7 +117,8 @@ binaryedge_api = ''
 # Binaryedge可以免费注册获取API：http://api.chinaz.com/ApiDetails/Alexa
 chinaz_api = ''
 
-# Bing可以免费注册获取API：https://azure.microsoft.com/zh-cn/services/cognitive-services/bing-web-search-api/#web-json
+# Bing可以免费注册获取API：https://azure.microsoft.com/zh-cn/services/
+# cognitive-services/bing-web-search-api/#web-json
 bing_api_id = ''
 bing_api_key = ''
 
@@ -113,7 +129,8 @@ securitytrails_api = ''
 fofa_api_email = ''  # fofa用户邮箱
 fofa_api_key = ''  # fofa用户key
 
-# Google可以免费注册获取API: https://developers.google.com/custom-search/v1/overview
+# Google可以免费注册获取API:
+# https://developers.google.com/custom-search/v1/overview
 # 免费的API只能查询前100条结果
 google_api_key = ''  # Google API搜索key
 google_api_cx = ''  # Google API搜索cx
@@ -149,11 +166,17 @@ dnsdb_api_key = ''
 # 免费的API有效期只有2天，到期之后可以再次生成，每天可以查询50次。
 ipv4info_api_key = ''
 
-subdomains_common = {'i', 'w', 'm', 'en', 'us', 'zh', 'w3', 'app', 'bbs', 'web', 'www', 'job', 'docs', 'news', 'blog',
-                     'data', 'help', 'live', 'mall', 'blogs', 'files', 'forum', 'store', 'mobile'}
+subdomains_common = {'i', 'w', 'm', 'en', 'us', 'zh', 'w3', 'app', 'bbs',
+                     'web', 'www', 'job', 'docs', 'news', 'blog', 'data',
+                     'help', 'live', 'mall', 'blogs', 'files', 'forum',
+                     'store', 'mobile'}
 
 # 日志配置
-log_fmt = '<light-green>{time:HH:mm:ss,SSS}</light-green> ' \
+stdout_fmt = '<cyan>{time:HH:mm:ss,SSS}</cyan> ' \
+          '[<level>{level: <5}</level>] ' \
+          '<blue>{module}</blue>:<cyan>{line}</cyan> - ' \
+          '<level>{message}</level>'
+logfile_fmt = '<light-green>{time:YYYY-MM-DD HH:mm:ss,SSS}</light-green> ' \
           '[<level>{level: <5}</level>] ' \
           '<cyan>{process.name}</cyan>:<cyan>{thread.name: <10}</cyan> | ' \
           '<blue>{module}</blue>.<blue>{function}</blue>:<blue>{line}</blue> - ' \
@@ -169,13 +192,9 @@ logger.level(name='ALERT', no=30, color='<yellow><bold>', icon='⚠️')
 logger.level(name='ERROR', no=40, color='<red><bold>', icon='❌️')
 logger.level(name='FATAL', no=50, color='<RED><bold>', icon='☠️')
 
-logger.add(sys.stdout, level='INFOR', format=log_fmt, enqueue=True)
-logger.add(log_path, level='TRACE', format=log_fmt, enqueue=True, encoding='utf-8')
+if not os.environ.get('PYTHONIOENCODING'):  # 设置编码
+    os.environ['PYTHONIOENCODING'] = 'utf-8'
 
-# 调试模式
-# import urllib3
-# urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-# request_proxy = [{'http': 'http://127.0.0.1:8080', 'https': 'https://127.0.0.1:8080'}]
-# request_verify = False
-# enable_all_module = False  # 启用所有模块 默认启用
-# enable_partial_module = [('modules.certificates', 'censys_api')]  # 启用部分模块 必须禁用enable_all_module才能生效
+logger.add(sys.stderr, level='INFOR', format=stdout_fmt, enqueue=True)
+logger.add(log_path, level='TRACE', format=logfile_fmt, enqueue=True,
+           encoding='utf-8')

oneforall/dbexport.py

@@ -1,5 +1,13 @@
+#!/usr/bin/python3
 # coding=utf-8
 
+"""
+OneForAll数据库导出模块
+
+:copyright: Copyright (c) 2019, Jing Ling. All rights reserved.
+:license: GNU General Public License v3.0, see LICENSE for more details.
+"""
+
 import fire
 from common import database
 from config import logger
@@ -7,23 +15,23 @@ from config import logger
 
 def export(table, db=None, valid=None, path=None, format='xlsx', output=False):
     """
-    将数据库导出为指定格式文件
-
-    :param str table:   要导出的表
-    :param str db:      要导出的数据库路径（默认为results/result.sqlite3）
-    :param int valid:   导出子域的有效性（默认None）
-    :param str format:  导出格式（默认xlsx）
-    :param str path:    导出路径(默认None)
-    :param bool output: 是否将导出数据输出到终端（默认False）
-
-    Note:
-        参数valid可选值1，0，None，分别表示导出有效，无效，全部子域
-        参数format可选格式：'csv','tsv','json','yaml','html','xls','xlsx','dbf','latex','ods'
-        参数path为None会根据format参数和域名名称在项目结果目录生成相应文件
+    OneForAll数据库导出模块
 
     Example:
         python dbexport.py --db result.db --table name --format csv --output False
         python dbexport.py --db result.db --table name --format csv --path= ./result.csv
+
+    Note:
+        参数valid可选值1，0，None，分别表示导出有效，无效，全部子域
+        参数format可选格式：'csv', 'tsv', 'json', 'yaml', 'html', 'xls', 'xlsx', 'dbf', 'latex', 'ods'
+        参数path为None会根据format参数和域名名称在项目结果目录生成相应文件
+
+    :param str table:   要导出的表
+    :param str db:      要导出的数据库路径(默认为results/result.sqlite3)
+    :param int valid:   导出子域的有效性(默认None)
+    :param str format:  导出格式(默认xlsx)
+    :param str path:    导出路径(默认None)
+    :param bool output: 是否将导出数据输出到终端(默认False)
     """
     db_conn = database.connect_db(db)
     if valid is None:
@@ -36,15 +44,17 @@ def export(table, db=None, valid=None, path=None, format='xlsx', output=False):
         print(rows.dataset)
     if not path:
         path = 'export.' + format
-    logger.log('INFOR', f'正在将数据库中{table}表导出到{path}')
+    logger.log('INFOR', f'正在将数据库中{table}表导出')
     try:
         with open(path, 'w') as file:
             file.write(rows.export(format))
             logger.log('INFOR', '成功完成导出')
+            logger.log('INFOR', path)
     except TypeError:
         with open(path, 'wb') as file:
             file.write(rows.export(format))
             logger.log('INFOR', '成功完成导出')
+            logger.log('INFOR', path)
     except Exception as e:
         logger.log('ERROR', e)
 

oneforall/example.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# coding=utf-8
+
+"""
+示例
+"""
+
+import oneforall
+
+test = oneforall.OneForAll(target='example.com')
+test.run()

oneforall/modules/__init__.py

@@ -1 +0,0 @@
-# coding=utf-8

oneforall/modules/certificates/censys_api.py

@@ -1,6 +1,4 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.query import Query
 from config import logger
@@ -24,11 +22,10 @@ class CensysAPI(Query):
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
         data = {
-            'query': 'parsed.names: owasp.org',
+            'query': 'parsed.names: example.com',
             'page': 1,
             'fields': ['parsed.subject_dn'],
             'flatten': True}
-
         resp = self.post(self.addr, json=data, auth=(self.id, self.secret))
         if not resp:
             return
@@ -40,7 +37,7 @@ class CensysAPI(Query):
         subdomains_find = self.match(self.domain, str(resp_json))
         self.subdomains = self.subdomains.union(subdomains_find)
         pages = resp_json.get('metadata').get('pages')
-        for page in range(2, pages+1):
+        for page in range(2, pages + 1):
             time.sleep(self.delay)
             data['page'] = page
             resp = self.post(self.addr, json=data, auth=(self.id, self.secret))
@@ -49,39 +46,29 @@ class CensysAPI(Query):
             subdomains_find = self.match(self.domain, str(resp.json()))
             self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not (self.id and self.secret):
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.id, self.secret):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = CensysAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/certificates/certdb_api.py

@@ -1,10 +1,7 @@
-# coding=utf-8
 import time
-import queue
 import config
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class CertDBAPI(Query):
@@ -25,50 +22,44 @@ class CertDBAPI(Query):
             time.sleep(self.delay)
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
-            params = {'domain': self.domain, 'api_token': self.token, 'page': page_num}
+            params = {'domain': self.domain,
+                      'api_token': self.token,
+                      'page': page_num}
             resp = self.get(self.addr, params)
             if not resp:
                 return
-            resp_json = resp.json()
-            subdomains_find = utils.match_subdomain(self.domain, str(resp_json))
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            json = resp.json()
+            subdomains_find = utils.match_subdomain(self.domain, str(json))
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             page_num += 1
-            if resp_json.get('count') < 30:  # 默认每次查询最多返回30条 当前条数小于30条说明已经查完
+            # 默认每次查询最多返回30条 当前条数小于30条说明已经查完
+            if json.get('count') < 30:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.token:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.token):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):   # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = CertDBAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/certificates/certspotter.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class CertSpotter(Query):
@@ -21,42 +18,37 @@ class CertSpotter(Query):
         time.sleep(self.delay)
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
-        params = {'domain': self.domain, 'include_subdomains': 'true', 'expand': 'dns_names'}
+        params = {'domain': self.domain, 'include_subdomains': 'true',
+                  'expand': 'dns_names'}
         resp = self.get(self.addr, params)
         if not resp:
             return
         subdomains_find = utils.match_subdomain(self.domain, str(resp.json()))
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
+
     """
     query = CertSpotter(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/certificates/crtsh.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class Crtsh(Query):
@@ -28,35 +25,27 @@ class Crtsh(Query):
         subdomains_find = utils.match_subdomain(self.domain, str(resp.json()))
         self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Crtsh(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/certificates/entrust.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class Entrust(Query):
@@ -21,42 +18,35 @@ class Entrust(Query):
         time.sleep(self.delay)
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
-        params = {'fields': 'subjectDN', 'domain': self.domain, 'includeExpired': 'true'}
+        params = {'fields': 'subjectDN', 'domain': self.domain,
+                  'includeExpired': 'true'}
         resp = self.get(self.addr, params)
         if not resp:
             return
         subdomains_find = utils.match_subdomain(self.domain, str(resp.json()))
         self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Entrust(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/certificates/google.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class Google(Query):
@@ -12,7 +9,8 @@ class Google(Query):
         self.domain = self.register(domain)
         self.module = 'Certificate'
         self.source = 'GoogleQuery'
-        self.addr = 'https://transparencyreport.google.com/transparencyreport/api/v3/httpsreport/ct/certsearch'
+        self.addr = 'https://transparencyreport.google.com/' \
+                    'transparencyreport/api/v3/httpsreport/ct/certsearch'
 
     def query(self):
         """
@@ -21,42 +19,36 @@ class Google(Query):
         time.sleep(self.delay)
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
-        params = {'include_expired': 'true', 'include_subdomains': 'true', 'domain': self.domain}
+        params = {'include_expired': 'true', 'include_subdomains': 'true',
+                  'domain': self.domain}
         resp = self.get(self.addr, params)
         if not resp:
             return
         subdomains_find = utils.match_subdomain(self.domain, resp.text)
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Google(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/check/axfr.py

@@ -1,19 +1,17 @@
-# coding=utf-8
 """
-查询域名的NS记录（域名服务器记录，记录该域名由哪台域名服务器解析），
+查询域名的NS记录(域名服务器记录，记录该域名由哪台域名服务器解析)，
 检查查出的域名服务器是否开启DNS域传送，如果开启且没做访问控制和身份验证便加以利用获取域名的所有记录
 
-DNS域传送（DNS zone transfer）指的是一台备用域名服务器使用来自主域名服务器的数据刷新自己的域数据库，
+DNS域传送(DNS zone transfer)指的是一台备用域名服务器使用来自主域名服务器的数据刷新自己的域数据库，
 目的是为了做冗余备份，防止主域名服务器出现故障时 dns 解析不可用。
 当主服务器开启DNS域传送同时又对来请求的备用服务器未作访问控制和身份验证便可以利用此漏洞获取某个域的所有记录。
 """
-import time
-import queue
 import dns.resolver
 import dns.zone
-from config import logger
-from common import utils, resolve
+
+from common import resolve, utils
 from common.module import Module
+from config import logger
 
 
 class CheckAXFR(Module):
@@ -31,7 +29,6 @@ class CheckAXFR(Module):
     def check(self):
         """
         正则匹配响应头中的内容安全策略字段以发现子域名
-        :return: None
         """
         resolver = resolve.dns_resolver()
         try:
@@ -50,49 +47,43 @@ class CheckAXFR(Module):
                 zone = dns.zone.from_xfr(xfr)
             except Exception as e:
                 logger.log('DEBUG', str(e))
-                logger.log('INFOR', f'对{self.domain}的域名服务器{nsserver}进行域传送失败')
+                logger.log('DEBUG', f'对{self.domain}的域名服务器{nsserver}进行域传送失败')
                 continue
             else:
                 names = zone.nodes.keys()
                 for name in names:
-                    subdomain = utils.match_subdomain(self.domain, str(name)+'.'+self.domain)
+                    subdomain = utils.match_subdomain(self.domain, str(name) + '.' + self.domain)
                     self.subdomains = self.subdomains.union(subdomain)
                     record = zone[name].to_text(name)
                     self.results.append(record)
             if self.results:
-                logger.log('INFOR', f'发现{self.domain}在{nsserver}上的域传送记录')
+                logger.log('DEBUG', f'发现{self.domain}在{nsserver}上的域传送记录')
                 logger.log('DEBUG', '\n'.join(self.results))
                 self.results = []
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
+        self.begin()
         logger.log('DEBUG', f'开始执行{self.source}检查{self.domain}的域传送漏洞')
-        start = time.time()
         self.check()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}的域传送漏洞')
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
+        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}的域传送漏洞')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
+
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     check = CheckAXFR(domain)
-    check.run(rx_queue)
-    logger.log('INFOR', f'{check.source}模块耗时{check.elapsed}秒发现子域{len(check.subdomains)}个')
-    logger.log('DEBUG', f'{check.source}模块发现的子域 {check.subdomains}')
+    check.run()
 
 
 if __name__ == '__main__':
-    # do('ZoneTransfer.me')
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('ZoneTransfer.me')

oneforall/modules/check/cdx.py

@@ -1,18 +1,17 @@
-# coding=utf-8
 """
 检查crossdomain.xml文件收集子域名
 """
-import time
-import queue
-from config import logger
-from common.utils import match_subdomain
+
 from common.module import Module
+from common.utils import match_subdomain
+from config import logger
 
 
 class CheckCDX(Module):
     """
     检查crossdomain.xml文件收集子域名
     """
+
     def __init__(self, domain: str):
         Module.__init__(self)
         self.domain = self.register(domain)
@@ -24,41 +23,44 @@ class CheckCDX(Module):
         检查crossdomain.xml收集子域名
         :return:
         """
-        url = f'http://{self.domain}/crossdomain.xml'
-        self.header = self.get_header()
-        self.proxy = self.get_proxy(self.source)
-        resp = self.get(url)
-        if not resp:
+        urls = [f'http://{self.domain}/crossdomain.xml',
+                f'https://{self.domain}/crossdomain.xml',
+                f'http://www.{self.domain}/crossdomain.xml',
+                f'https://www.{self.domain}/crossdomain.xml']
+        response = None
+        for url in urls:
+            self.header = self.get_header()
+            self.proxy = self.get_proxy(self.source)
+            response = self.get(url)
+            if response:
+                break
+        if not response:
             return
-        self.subdomains = match_subdomain(self.domain, resp.text)
+        self.subdomains = match_subdomain(self.domain, response.text)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}检查{self.domain}域的crossdomain.xml')
-        start = time.time()
+        self.begin()
+        logger.log('DEBUG', f'开始执行{self.source}检查{self.domain}域的跨域策略')
         self.check()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域的crossdomain.xml')
+        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域的跨域策略')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
+
     :param domain: 域名
-    :param rx_queue: 结果集队列
     """
     check = CheckCDX(domain)
-    check.run(rx_queue)
-    logger.log('INFOR', f'{check.source}模块耗时{check.elapsed}秒发现子域{len(check.subdomains)}个')
-    logger.log('DEBUG', f'{check.source}模块发现的子域 {check.subdomains}')
+    check.run()
 
 
 if __name__ == '__main__':
-    do('163.com')
+    do('example.com')

oneforall/modules/check/cert.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python3
-# coding=utf-8
 
 """
 检查域名证书收集子域名
 """
-import ssl
-import time
-import queue
 import socket
-from config import logger
+import ssl
+
 from common import utils
 from common.module import Module
+from config import logger
 
 
 class CheckCert(Module):
@@ -36,35 +34,28 @@ class CheckCert(Module):
         subdomains_find = utils.match_subdomain(self.domain, str(cert_dict))
         self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
         logger.log('DEBUG', f'开始执行{self.source}检查{self.domain}域的证书中的子域')
-        start = time.time()
         self.check()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域的证书中的子域')
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
+        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域的证书中的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     check = CheckCert(domain)
-    check.run(rx_queue)
-    logger.log('INFOR', f'{check.source}模块耗时{check.elapsed}秒发现子域{len(check.subdomains)}个')
-    logger.log('DEBUG', f'{check.source}模块发现的子域 {check.subdomains}')
+    check.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/check/csp.py

@@ -1,23 +1,23 @@
-# coding=utf-8
 """
 检查内容安全策略收集子域名收集子域名
 """
-import time
-import queue
-from config import logger
+import requests
+
 from common import utils
 from common.module import Module
+from config import logger
 
 
 class CheckCSP(Module):
     """
     检查内容安全策略收集子域名
     """
+
     def __init__(self, domain, header):
         Module.__init__(self)
         self.domain = self.register(domain)
         self.module = 'Check'
-        self.source = 'Content-Security-Policy'
+        self.source = 'ContentSecurityPolicy'
         self.header = header
 
     def check(self):
@@ -25,11 +25,18 @@ class CheckCSP(Module):
         正则匹配响应头中的内容安全策略字段以发现子域名
         """
         if not self.header:
-            url = f'http://www.{self.domain}'
-            resp = self.get(url)
-            if not resp:
+            urls = [f'http://{self.domain}', f'https://{self.domain}',
+                    f'http://www.{self.domain}', f'https://www.{self.domain}']
+            response = None
+            for url in urls:
+                self.header = self.get_header()
+                self.proxy = self.get_proxy(self.source)
+                response = self.get(url)
+                if response:
+                    break
+            if not response:
                 return
-            self.header = resp.headers
+            self.header = response.headers
         csp = self.header.get('Content-Security-Policy')
         if not csp:
             logger.log('DEBUG', f'{self.domain}域的响应头不存在内容安全策略字段')
@@ -37,39 +44,30 @@ class CheckCSP(Module):
         logger.log('DEBUG', f'{self.domain}域的响应头存在内容安全策略字段')
         self.subdomains = utils.match_subdomain(self.domain, csp)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
         logger.log('DEBUG', f'开始执行{self.source}检查{self.domain}域响应头中的内容安全策略字段')
-        start = time.time()
         self.check()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域响应头中的内容安全策略字段')
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
+        logger.log('DEBUG', f'结束执行{self.source}检查{self.domain}域响应头中的内容安全策略字段')
+        self.finish()
 
 
-def do(domain, rx_queue, header=None):  # 统一入口名字 方便多线程调用
+def do(domain, header=None):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     :param dict or None header: 响应头
     """
     check = CheckCSP(domain, header)
-    check.run(rx_queue)
-    logger.log('INFOR', f'{check.source}模块耗时{check.elapsed}秒发现子域{len(check.subdomains)}个')
-    logger.log('DEBUG', f'{check.source}模块发现的子域 {check.subdomains}')
+    check.run()
 
 
 if __name__ == '__main__':
-    import requests
-    # resp = requests.get('https://content-security-policy.com/')
-    result_queue = queue.Queue()
-    resp = requests.get('https://www.baidu.com/')
-    do('google-analytics.com', result_queue, resp.headers)
+    resp = requests.get('https://content-security-policy.com/')
+    do('google-analytics.com', resp.headers)

oneforall/modules/crawl/archivecrawl.py

@@ -1,6 +1,3 @@
-# coding=utf-8
-import time
-import queue
 import cdx_toolkit
 from common.crawl import Crawl
 from config import logger
@@ -30,42 +27,34 @@ class ArchiveCrawl(Crawl):
             if resp.data.get('status') not in ['301', '302']:
                 url = resp.data.get('url')
                 subdomains_find = self.match(self.register(domain), url + resp.text)
-                self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                # 合并搜索子域名搜索结果
+                self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.crawl(self.domain, 50)
-
         # 爬取已发现的子域以发现新的子域
         for subdomain in self.subdomains:
             if subdomain != self.domain:
                 self.crawl(subdomain, 10)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     crawl = ArchiveCrawl(domain)
-    crawl.run(result)
-    logger.log('INFOR', f'{crawl.source}模块耗时{crawl.elapsed}秒发现{crawl.domain}的子域{len(crawl.subdomains)}个')
-    logger.log('DEBUG', f'{crawl.source}模块发现{crawl.domain}的子域 {crawl.subdomains}')
+    crawl.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/crawl/commoncrawl.py

@@ -1,8 +1,6 @@
-# coding=utf-8
-import time
-import queue
-from tqdm import tqdm
 import cdx_toolkit
+from tqdm import tqdm
+
 from common.crawl import Crawl
 from config import logger
 
@@ -30,42 +28,34 @@ class CommonCrawl(Crawl):
         for resp in tqdm(cdx.iter(url, limit=limit), total=limit):
             if resp.data.get('status') not in ['301', '302']:
                 subdomains_find = self.match(self.register(domain), resp.text)
-                self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                # 合并搜索子域名搜索结果
+                self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.crawl(self.domain, 50)
-
         # 爬取已发现的子域以发现新的子域
         for subdomain in self.subdomains:
             if subdomain != self.domain:
                 self.crawl(subdomain, 10)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     crawl = CommonCrawl(domain)
-    crawl.run(result)
-    logger.log('INFOR', f'{crawl.source}模块耗时{crawl.elapsed}秒发现{crawl.domain}的子域{len(crawl.subdomains)}个')
-    logger.log('DEBUG', f'{crawl.source}模块发现{crawl.domain}的子域 {crawl.subdomains}')
+    crawl.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/binaryedge_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class BinaryEdgeAPI(Query):
@@ -30,39 +27,29 @@ class BinaryEdgeAPI(Query):
         subdomains_find = self.match(self.domain, str(resp.json()))
         self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.api:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.api):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = BinaryEdgeAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/bufferover.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.query import Query
-from config import logger
 
 
 class BufferOver(Query):
@@ -25,37 +22,30 @@ class BufferOver(Query):
         if not resp:
             return
         subdomains_find = self.match(self.domain, resp.text)
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = BufferOver(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/chinaz.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.query import Query
-from config import logger
 
 
 class Chinaz(Query):
@@ -25,37 +22,30 @@ class Chinaz(Query):
         if not resp:
             return
         subdomains_find = self.match(self.domain, resp.text)
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Chinaz(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/chinaz_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class ChinazAPI(Query):
@@ -27,41 +24,32 @@ class ChinazAPI(Query):
         if not resp:
             return
         subdomains_find = self.match(self.domain, str(resp.json()))
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.api:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.api):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = ChinazAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/circl_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class CirclAPI(Query):
@@ -27,38 +24,32 @@ class CirclAPI(Query):
         if not resp:
             return
         subdomains_find = self.match(self.domain, str(resp.json()))
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        if self.user and self.pwd:
-            start = time.time()
-            self.query()
-            end = time.time()
-            self.elapsed = round(end - start, 1)
-            self.save_json()
-            self.gen_result()
-            self.save_db()
-            rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        if not self.check(self.user, self.pwd):
+            return
+        self.begin()
+        self.query()
+        self.save_json()
+        self.gen_result()
+        self.save_db()
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = CirclAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/dnsdb.py

@@ -1,10 +1,7 @@
-# coding=utf-8
 import random
 import time
-import queue
 from bs4 import BeautifulSoup
 from common.query import Query
-from config import logger
 
 
 class DNSdb(Query):
@@ -31,46 +28,43 @@ class DNSdb(Query):
                 soup = BeautifulSoup(resp.text, features='lxml')
                 index_urls = set(map(lambda x: self.addr + self.domain + x.text, soup.find_all('a')))
                 for url in index_urls:
-                    self.delay = random.randint(2, 5)  # 休眠绕过CloudFlare的DDoS保护
+                    # 休眠绕过CloudFlare的DDoS保护
+                    self.delay = random.randint(2, 5)
                     time.sleep(self.delay)
                     resp = self.get(url)
                     if not resp:
                         return
                     subdomains_find = self.match(self.domain, resp.text)
-                    self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                    # 合并搜索子域名搜索结果
+                    self.subdomains = self.subdomains.union(subdomains_find)
             else:
                 subdomains_find = self.match(self.domain, resp.text)
-                self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                # 合并搜索子域名搜索结果
+                self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
+
     """
     query = DNSdb(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+
+    do('example.com')

oneforall/modules/datasets/dnsdb_api.py

@@ -1,10 +1,7 @@
-# coding=utf-8
 import time
-import queue
 import config
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class DNSdbAPI(Query):
@@ -30,41 +27,33 @@ class DNSdbAPI(Query):
             return
         if resp.status_code == 200:
             subdomains_find = utils.match_subdomain(self.domain, resp.text)
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.api:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.api):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
+
     """
     query = DNSdbAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/dnsdumpster.py

@@ -1,15 +1,9 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class DNSdumpster(Query):
-    """
-
-    """
     def __init__(self, domain):
         Query.__init__(self)
         self.domain = self.register(domain)
@@ -35,37 +29,31 @@ class DNSdumpster(Query):
             return
         subdomains_find = utils.match_subdomain(self.domain, resp.text)
         if subdomains_find:
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = DNSdumpster(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+
+    do('example.com')

oneforall/modules/datasets/hackertarget.py

@@ -1,9 +1,5 @@
-# coding=utf-8
-import time
-import queue
-from common.query import Query
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class HackerTarget(Query):
@@ -27,37 +23,30 @@ class HackerTarget(Query):
         if resp.status_code == 200:
             subdomains_find = utils.match_subdomain(self.domain, resp.text)
             if subdomains_find:
-                self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                # 合并搜索子域名搜索结果
+                self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = HackerTarget(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/ipv4info.py

@@ -1,9 +1,5 @@
-# coding=utf-8
-import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class IPv4InfoAPI(Query):
@@ -23,7 +19,8 @@ class IPv4InfoAPI(Query):
         while True:
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
-            params = {'type': 'SUBDOMAINS', 'key': self.api, 'value': self.domain, 'page': page}
+            params = {'type': 'SUBDOMAINS', 'key': self.api,
+                      'value': self.domain, 'page': page}
             resp = self.get(self.addr, params)
             if not resp:
                 return
@@ -33,43 +30,38 @@ class IPv4InfoAPI(Query):
             subdomains_find = self.match(self.domain, str(resp_json))
             if not subdomains_find:
                 break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
-            subdomains = resp_json.get('Subdomains')  # 不直接使用subdomains是因为可能里面会出现不符合标准的子域名
-            if len(subdomains) < 300:  # ipv4info子域查询接口每次最多返回300个 用来判断是否还有下一页
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
+            # 不直接使用subdomains是因为可能里面会出现不符合标准的子域名
+            subdomains = resp_json.get('Subdomains')
+            # ipv4info子域查询接口每次最多返回300个 用来判断是否还有下一页
+            if len(subdomains) < 300:
                 break
             page += 1
             if page >= 50:  # ipv4info子域查询接口最多允许查询50页
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = IPv4InfoAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/netcraft.py

@@ -1,11 +1,9 @@
-# coding=utf-8
+import hashlib
 import re
 import time
-import queue
-import hashlib
 from urllib import parse
+
 from common.query import Query
-from config import logger
 
 
 class NetCraft(Query):
@@ -24,16 +22,21 @@ class NetCraft(Query):
         绕过NetCraft的JS验证
         """
         self.header = self.get_header()  # Netcraft会检查User-Agent
+        resp = self.get(self.init)
+        if not resp:
+            return None
         self.cookie = self.get(self.init).cookies
         cookie_value = self.cookie['netcraft_js_verification_challenge']
-        verify_taken = hashlib.sha1(parse.unquote(cookie_value).encode('utf-8')).hexdigest()
+        cookie_encode = parse.unquote(cookie_value).encode('utf-8')
+        verify_taken = hashlib.sha1(cookie_encode).hexdigest()
         self.cookie['netcraft_js_verification_response'] = verify_taken
 
     def query(self):
         """
         向接口查询子域并做子域匹配
         """
-        self.bypass_verification()
+        if not self.bypass_verification():
+            return
         last = ''
         while True:
             time.sleep(self.delay)
@@ -46,41 +49,34 @@ class NetCraft(Query):
             subdomains_find = self.match(self.domain, resp.text)
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             if 'Next page' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
                 break
             last = re.search(r'&last=.*' + self.domain, resp.text).group(0)
             self.page_num += self.per_page_num
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = NetCraft(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/ptrarchive.py

@@ -1,10 +1,7 @@
-# coding=utf-8
-import time
-import queue
 import random
-from common.query import Query
+
 from common import utils
-from config import logger
+from common.query import Query
 
 
 class PTRArchive(Query):
@@ -21,7 +18,8 @@ class PTRArchive(Query):
         """
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
-        self.cookie = {'pa_id': str(random.randint(0, 1000000000))}  # 绕过主页前端JS验证
+        # 绕过主页前端JS验证
+        self.cookie = {'pa_id': str(random.randint(0, 1000000000))}
         params = {'label': self.domain, 'date': 'ALL'}
         resp = self.get(self.addr, params)
         if not resp:
@@ -29,37 +27,30 @@ class PTRArchive(Query):
         if resp.status_code == 200:
             subdomains_find = utils.match_subdomain(self.domain, resp.text)
             if subdomains_find:
-                self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                # 合并搜索子域名搜索结果
+                self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = PTRArchive(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/riddler.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.query import Query
-from config import logger
 
 
 class Riddler(Query):
@@ -25,37 +22,30 @@ class Riddler(Query):
         if not resp:
             return
         subdomains_find = self.match(self.domain, resp.text)
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Riddler(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/robtex.py

@@ -1,9 +1,7 @@
-# coding=utf-8
-import time
-import queue
 import json
+import time
+
 from common.query import Query
-from config import logger
 
 
 class Robtex(Query):
@@ -36,37 +34,30 @@ class Robtex(Query):
                     return
                 subdomains_find = self.match(self.domain, resp.text)
                 if subdomains_find:
-                    self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+                    # 合并搜索子域名搜索结果
+                    self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = Robtex(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/securitytrails_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class SecurityTrailsAPI(Query):
@@ -28,44 +25,35 @@ class SecurityTrailsAPI(Query):
         resp = self.get(url, params)
         if not resp:
             return
-        subdomains_prefix = resp.json()['subdomains']
-        subdomains_find = [f'{prefix}.{self.domain}' for prefix in subdomains_prefix]
+        prefixs = resp.json()['subdomains']
+        subdomains_find = [f'{prefix}.{self.domain}' for prefix in prefixs]
         if subdomains_find:
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.api:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.api):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = SecurityTrailsAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/datasets/sitedossier.py

@@ -1,8 +1,6 @@
-# coding=utf-8
 import time
-import queue
+
 from common.query import Query
-from config import logger
 
 
 class SiteDossier(Query):
@@ -31,40 +29,34 @@ class SiteDossier(Query):
             subdomains_find = self.match(self.domain, resp.text)
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
-            if 'Show next 100 items' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
+            # 搜索页面没有出现下一页时停止搜索
+            if 'Show next 100 items' not in resp.text:
                 break
             self.page_num += self.per_page_num
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = SiteDossier(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/dnsquery/srv.py

@@ -1,18 +1,17 @@
 #!/usr/bin/env python3
-# coding=utf-8
 
 """
 通过枚举域名常见的SRV记录并做查询来发现子域
 """
 
-import time
-import queue
-import json
 import asyncio
+import json
+
 import aiodns
-from common.module import Module
+
 from common import utils
-from config import logger, data_storage_path, resolver_nameservers
+from common.module import Module
+from config import data_storage_path, logger, resolver_nameservers
 
 
 class BruteSRV(Module):
@@ -69,34 +68,30 @@ class BruteSRV(Module):
         if not len(self.subdomains):
             logger.log('DEBUG', f'没有找到{self.domain}的SRV记录')
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
+        self.begin()
         logger.log('DEBUG', f'开始枚举{self.domain}域的SRV记录')
-        start = time.time()
         self.brute()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
         logger.log('DEBUG', f'结束枚举{self.domain}域的SRV记录')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
+
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     brute = BruteSRV(domain)
-    brute.run(rx_queue)
-    logger.log('INFOR', f'{brute.source}模块耗时{brute.elapsed}秒发现{brute.domain}的子域{len(brute.subdomains)}个')
-    logger.log('DEBUG', f'{brute.source}模块发现{brute.domain}的子域 {brute.subdomains}')
+    brute.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+
+    do('example.com')

oneforall/modules/intelligence/riskiq_api.py

@@ -1,66 +1,55 @@
-# coding=utf-8
-import time
-import queue
-import config
-from common.query import Query
-from config import logger
-
-
-class RiskIQ(Query):
-    def __init__(self, domain):
-        Query.__init__(self)
-        self.domain = self.register(domain)
-        self.module = 'Intelligence'
-        self.source = 'RiskIQQuery'
-        self.addr = 'https://api.passivetotal.org/v2/enrichment/subdomains'
-        self.username = config.riskiq_api_username
-        self.key = config.riskiq_api_key
-
-    def query(self):
-        """
-        向接口查询子域并做子域匹配
-        """
-        self.header = self.get_header()
-        self.proxy = self.get_proxy(self.source)
-        params = {'query': self.domain}
-        resp = self.get(url=self.addr, params=params, auth=(self.username, self.key))
-        if not resp:
-            return
-        resp_json = resp.json()
-        subdomains_find = resp_json.get('subdomains')
-        if subdomains_find:
-            self.subdomains = set(map(lambda x: x + '.' + self.domain, subdomains_find))
-
-    def run(self, rx_queue):
-        """
-        类执行入口
-        """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
-        self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        self.save_json()
-        self.gen_result()
-        self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
-
-
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
-    """
-    类统一调用入口
-
-    :param str domain: 域名
-    :param rx_queue: 结果集队列
-    """
-    return
-    query = RiskIQ(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
-
-
-if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+import config
+from common.query import Query
+
+
+class RiskIQ(Query):
+    def __init__(self, domain):
+        Query.__init__(self)
+        self.domain = self.register(domain)
+        self.module = 'Intelligence'
+        self.source = 'RiskIQQuery'
+        self.addr = 'https://api.passivetotal.org/v2/enrichment/subdomains'
+        self.user = config.riskiq_api_username
+        self.key = config.riskiq_api_key
+
+    def query(self):
+        """
+        向接口查询子域并做子域匹配
+        """
+        self.header = self.get_header()
+        self.proxy = self.get_proxy(self.source)
+        params = {'query': self.domain}
+        resp = self.get(url=self.addr, params=params, auth=(self.user, self.key))
+        if not resp:
+            return
+        resp_json = resp.json()
+        subdomains_find = resp_json.get('subdomains')
+        if subdomains_find:
+            self.subdomains = set(map(lambda x: x + '.' + self.domain, subdomains_find))
+
+    def run(self):
+        """
+        类执行入口
+        """
+        if not self.check(self.user, self.key):
+            return
+        self.begin()
+        self.query()
+        self.save_json()
+        self.gen_result()
+        self.save_db()
+        self.finish()
+
+
+def do(domain):  # 统一入口名字 方便多线程调用
+    """
+    类统一调用入口
+
+    :param str domain: 域名
+    """
+    query = RiskIQ(domain)
+    query.run()
+
+
+if __name__ == '__main__':
+    do('example.com')

oneforall/modules/intelligence/threatbook_api.py

@@ -1,66 +1,52 @@
-# coding=utf-8
-import time
-import queue
-import config
-from common.query import Query
-from config import logger
-
-
-class ThreatBookAPI(Query):
-    def __init__(self, domain):
-        Query.__init__(self)
-        self.domain = self.register(domain)
-        self.module = 'Intelligence'
-        self.source = 'ThreatBookAPIQuery'
-        self.addr = 'https://x.threatbook.cn/api/v1/domain/query'
-        self.key = config.threatbook_api_key
-
-    def query(self, domain):
-        """
-        向接口查询子域并做子域匹配
-        """
-        self.header = self.get_header()
-        self.proxy = self.get_proxy(self.source)
-        params = {'apikey': self.key, 'domain': domain, 'field': 'sub_domains'}
-        resp = self.post(self.addr, params)
-        if not resp:
-            return
-        subdomain_find = self.match(self.domain, str(resp.json()))
-        self.subdomains = self.subdomains.union(subdomain_find)
-
-    def run(self, rx_queue):
-        """
-        类执行入口
-        """
-        if not self.key:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
-            return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
-        self.query(self.domain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        self.save_json()
-        self.gen_result()
-        self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
-
-
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
-    """
-    类统一调用入口
-
-    :param str domain: 域名
-    :param rx_queue: 结果集队列
-    """
-    query = ThreatBookAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
-
-
-if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+import config
+from common.query import Query
+
+
+class ThreatBookAPI(Query):
+    def __init__(self, domain):
+        Query.__init__(self)
+        self.domain = self.register(domain)
+        self.module = 'Intelligence'
+        self.source = 'ThreatBookAPIQuery'
+        self.addr = 'https://x.threatbook.cn/api/v1/domain/query'
+        self.key = config.threatbook_api_key
+
+    def query(self, domain):
+        """
+        向接口查询子域并做子域匹配
+        """
+        self.header = self.get_header()
+        self.proxy = self.get_proxy(self.source)
+        params = {'apikey': self.key, 'domain': domain, 'field': 'sub_domains'}
+        resp = self.post(self.addr, params)
+        if not resp:
+            return
+        subdomain_find = self.match(self.domain, str(resp.json()))
+        self.subdomains = self.subdomains.union(subdomain_find)
+
+    def run(self):
+        """
+        类执行入口
+        """
+        if not self.check(self.key):
+            return
+        self.begin()
+        self.query(self.domain)
+        self.save_json()
+        self.gen_result()
+        self.save_db()
+        self.finish()
+
+
+def do(domain):  # 统一入口名字 方便多线程调用
+    """
+    类统一调用入口
+
+    :param str domain: 域名
+    """
+    query = ThreatBookAPI(domain)
+    query.run()
+
+
+if __name__ == '__main__':
+    do('example.com')

oneforall/modules/intelligence/threatminer.py

@@ -1,8 +1,6 @@
-# coding=utf-8
 import time
-import queue
+
 from common.query import Query
-from config import logger
 
 
 class ThreatMiner(Query):
@@ -20,42 +18,36 @@ class ThreatMiner(Query):
         time.sleep(self.delay)
         self.header = self.get_header()
         self.proxy = self.get_proxy(self.source)
-        params = {'e': 'subdomains_container', 'q': self.domain, 't': 0, 'rt': 10}
+        params = {'e': 'subdomains_container',
+                  'q': self.domain, 't': 0, 'rt': 10}
         resp = self.get(self.addr, params)
         if not resp:
             return
         subdomains_find = self.match(self.domain, resp.text)
-        self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+        # 合并搜索子域名搜索结果
+        self.subdomains = self.subdomains.union(subdomains_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = ThreatMiner(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/intelligence/virustotal.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.query import Query
-from config import logger
 
+from common.query import Query
 
 '''
 最多查询100条
@@ -51,35 +48,27 @@ class VirusTotal(Query):
             else:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query(self.domain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     query = VirusTotal(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/intelligence/virustotal_api.py

@@ -1,9 +1,5 @@
-# coding=utf-8
-import time
-import queue
 import config
 from common.query import Query
-from config import logger
 
 
 class VirusTotalAPI(Query):
@@ -29,40 +25,29 @@ class VirusTotalAPI(Query):
         subdomain_find = set(resp_json.get('subdomains'))
         self.subdomains = self.subdomains.union(subdomain_find)
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.key:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.key):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块查询{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.query(self.domain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块查询{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
-    return
     query = VirusTotalAPI(domain)
-    query.run(rx_queue)
-    logger.log('INFOR', f'{query.source}模块耗时{query.elapsed}秒发现{query.domain}的子域{len(query.subdomains)}个')
-    logger.log('DEBUG', f'{query.source}模块发现{query.domain}的子域 {query.subdomains}')
+    query.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/ask.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.search import Search
-from config import logger
 
 
 class Ask(Search):
@@ -37,53 +34,48 @@ class Ask(Search):
             if not subdomain_find:
                 break
             if not full_search:
-                if subdomain_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomain_find.issubset(self.subdomains):
                     break
             self.subdomains = self.subdomains.union(subdomain_find)
             self.page_num += 1
             if '>Next<' not in resp.text:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search(self.domain, full_search=True)
-
         # 排除同一子域搜索结果过多的子域以发现新的子域
         for statement in self.filter(self.domain, self.subdomains):
             self.search(self.domain, filtered_subdomain=statement)
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Ask(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/baidu.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
-from common.search import Search
 from bs4 import BeautifulSoup
-from config import logger
+from common.search import Search
 
 
 class Baidu(Search):
@@ -25,7 +22,8 @@ class Baidu(Search):
         """
         bs = BeautifulSoup(html, features='lxml')
         subdomains_all = set()
-        for find_res in bs.find_all('a', {'class': 'c-showurl'}):  # 获取搜索结果中所有的跳转URL地址
+        # 获取搜索结果中所有的跳转URL地址
+        for find_res in bs.find_all('a', {'class': 'c-showurl'}):
             url = find_res.get('href')
             subdomain = self.match_location(domain, url)
             subdomains_all = subdomains_all.union(subdomain)
@@ -45,32 +43,37 @@ class Baidu(Search):
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
             query = 'site:' + domain + filtered_subdomain
-            params = {'wd': query, 'pn': self.page_num, 'rn': self.per_page_num}
+            params = {'wd': query, 'pn': self.page_num,
+                      'rn': self.per_page_num}
             resp = self.get(self.addr, params)
             if not resp:
                 return
             if len(domain) > 12:  # 解决百度搜索结果中域名过长会显示不全的问题
-                subdomains_find = self.redirect_match(domain, resp.text)  # 获取百度跳转URL响应头的Location字段获取直链
+                # 获取百度跳转URL响应头的Location字段获取直链
+                subdomains_find = self.redirect_match(domain, resp.text)
             else:
                 subdomains_find = self.match(domain, resp.text)
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
             if not full_search:
-                if subdomains_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomains_find.issubset(self.subdomains):
                     break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             self.page_num += self.per_page_num
-            if '&pn={next_pn}&'.format(next_pn=self.page_num) not in resp.text:  # 搜索页面没有出现下一页时停止搜索
+            # 搜索页面没有出现下一页时停止搜索
+            if '&pn={next_pn}&'.format(next_pn=self.page_num) not in resp.text:
                 break
             if self.page_num >= self.limit_num:  # 搜索条数限制
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -79,32 +82,29 @@ class Baidu(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Baidu(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/bing.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.search import Search
-from config import logger
 
 
 class Bing(Search):
@@ -34,7 +31,8 @@ class Bing(Search):
             time.sleep(self.delay)
             self.proxy = self.get_proxy(self.source)
             query = 'site:' + domain + filtered_subdomain
-            params = {'q': query, 'first': self.page_num, 'count': self.per_page_num}
+            params = {'q': query, 'first': self.page_num,
+                      'count': self.per_page_num}
             resp = self.get(self.addr, params)
             if not resp:
                 return
@@ -42,21 +40,23 @@ class Bing(Search):
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
             if not full_search:
-                if subdomains_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomains_find.issubset(self.subdomains):
                     break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
-            if '<div class="sw_next>' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
+            # 搜索页面没有出现下一页时停止搜索
+            if '<div class="sw_next>' not in resp.text:
                 break
             self.page_num += self.per_page_num
             if self.page_num >= self.limit_num:  # 搜索条数限制
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -65,32 +65,29 @@ class Bing(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Bing(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/bing_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.search import Search
-from config import logger
 
 
 class BingAPI(Search):
@@ -42,23 +39,22 @@ class BingAPI(Search):
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
             if not full_search:
-                if subdomains_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomains_find.issubset(self.subdomains):
                     break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             self.page_num += self.per_page_num
             if self.page_num >= self.limit_num:  # 搜索条数限制
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not (self.id and self.key):
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.id, self.key):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -67,32 +63,29 @@ class BingAPI(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = BingAPI(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/duckduckgo.py

@@ -1,7 +1,5 @@
-# coding=utf-8
 import re
 import time
-import queue
 from common.search import Search
 from config import logger
 
@@ -36,7 +34,8 @@ class DuckDuckGO(Search):
             if not subdomain_find:
                 break
             if not full_search:
-                if subdomain_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomain_find.issubset(self.subdomains):
                     break
             self.subdomains = self.subdomains.union(subdomain_find)
             try:
@@ -45,14 +44,15 @@ class DuckDuckGO(Search):
             except Exception as e:
                 logger.error(e)
                 break
-            data.update({'s': s, 'nextParams': '', 'o': 'json', 'dc': dc, 'api': '/d.js'})
+            data.update({'s': s, 'nextParams': '', 'o': 'json',
+                         'dc': dc, 'api': '/d.js'})
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -61,33 +61,31 @@ class DuckDuckGO(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     # return  # 暂时还有点问题
     search = DuckDuckGO(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+
+    do('example.com')

oneforall/modules/search/exalead.py

@@ -1,9 +1,6 @@
-# coding=utf-8
-import time
-import queue
 import random
+import time
 from common.search import Search
-from config import logger
 
 
 class Exalead(Search):
@@ -30,7 +27,8 @@ class Exalead(Search):
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
             query = 'site:' + domain + filtered_subdomain
-            params = {'q': query, 'elements_per_page': '30', "start_index": self.page_num}
+            params = {'q': query, 'elements_per_page': '30',
+                      "start_index": self.page_num}
             resp = self.get(url=self.addr, params=params)
             if not resp:
                 return
@@ -47,12 +45,12 @@ class Exalead(Search):
             if 'title="Go to the next page"' not in resp.text:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -62,32 +60,29 @@ class Exalead(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Exalead(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/fofa_api.py

@@ -1,71 +1,64 @@
-# coding=utf-8
-import time
-import queue
-import json
-import base64
-import config
-from common.search import Search
-from config import logger
-
-
-class FoFa(Search):
-    def __init__(self, domain):
-        Search.__init__(self)
-        self.domain = domain
-        self.module = 'Search'
-        self.source = 'FoFaSearch'
-        self.addr = 'https://fofa.so/api/v1/search/all'
-        self.delay = 1
-        self.email = config.fofa_api_email
-        self.key = config.fofa_api_key
-
-    def search(self):
-        """
-        发送搜索请求并做子域匹配
-        """
-        self.page_num = 1
-        query_base64 = base64.b64encode(f'domain={self.domain}'.encode('utf-8'))
-        while True:
-            time.sleep(self.delay)
-            self.header = self.get_header()
-            self.proxy = self.get_proxy(self.source)
-            query = {'email': self.email, 'key': self.key, 'qbase64': query_base64, 'page': self.page_num}
-            resp = self.get(self.addr, query)
-            if not resp:
-                return
-            subdomain_find = self.match(self.domain, resp.text)
-            self.subdomains = self.subdomains.union(subdomain_find)
-            self.page_num += 1
-
-    def run(self, rx_queue):
-        """
-        类执行入口
-        """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
-        self.search()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
-        self.save_json()
-        self.gen_result()
-        self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
-
-
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
-    """
-    类统一调用入口
-
-    :param str domain: 域名
-    :param rx_queue: 结果集队列
-    """
-    search = FoFa(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
-
-
-if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+import base64
+import time
+
+import config
+from common.search import Search
+from config import logger
+
+
+class FoFa(Search):
+    def __init__(self, domain):
+        Search.__init__(self)
+        self.domain = domain
+        self.module = 'Search'
+        self.source = 'FoFaSearch'
+        self.addr = 'https://fofa.so/api/v1/search/all'
+        self.delay = 1
+        self.email = config.fofa_api_email
+        self.key = config.fofa_api_key
+
+    def search(self):
+        """
+        发送搜索请求并做子域匹配
+        """
+        self.page_num = 1
+        query_data = base64.b64encode(f'domain={self.domain}'.encode('utf-8'))
+        while True:
+            time.sleep(self.delay)
+            self.header = self.get_header()
+            self.proxy = self.get_proxy(self.source)
+            query = {'email': self.email, 'key': self.key,
+                     'qbase64': query_data, 'page': self.page_num}
+            resp = self.get(self.addr, query)
+            if not resp:
+                return
+            subdomain_find = self.match(self.domain, resp.text)
+            self.subdomains = self.subdomains.union(subdomain_find)
+            self.page_num += 1
+
+    def run(self):
+        """
+        类执行入口
+        """
+        if not self.check(self.email, self.key):
+            return
+        self.begin()
+        self.search()
+        self.save_json()
+        self.gen_result()
+        self.save_db()
+        self.finish()
+
+
+def do(domain):  # 统一入口名字 方便多线程调用
+    """
+    类统一调用入口
+
+    :param str domain: 域名
+    """
+    search = FoFa(domain)
+    search.run()
+
+
+if __name__ == '__main__':
+    do('example.com')

oneforall/modules/search/google.py

@@ -1,9 +1,6 @@
-# coding=utf-8
-import time
-import queue
 import random
+import time
 from common.search import Search
-from config import logger
 
 
 class Google(Search):
@@ -51,17 +48,17 @@ class Google(Search):
                     break
             self.subdomains = self.subdomains.union(subdomain_find)
             page_num += per_page_num
-            if 'start='+str(page_num) not in resp.text:
+            if 'start=' + str(page_num) not in resp.text:
                 break
             if '302 Moved' in resp.text:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -70,32 +67,29 @@ class Google(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Google(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/google_api.py

@@ -1,9 +1,6 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.search import Search
-from config import logger
 
 
 class GoogleAPI(Search):
@@ -32,7 +29,8 @@ class GoogleAPI(Search):
             time.sleep(self.delay)
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
-            params = {'key': self.key, 'cx': self.cx, 'q': word, 'fields': 'items/link',
+            params = {'key': self.key, 'cx': self.cx,
+                      'q': word, 'fields': 'items/link',
                       'start': self.page_num, 'num': self.per_page_num}
             resp = self.get(self.addr, params)
             if not resp:
@@ -48,16 +46,13 @@ class GoogleAPI(Search):
             if self.page_num > 100:  # 免费的API只能查询前100条结果
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not (self.cx and self.key):
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.cx, self.key):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -66,32 +61,29 @@ class GoogleAPI(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = GoogleAPI(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/shodan_api.py

@@ -1,11 +1,5 @@
-# coding=utf-8
-import time
-import queue
-import queue
 import config
-# from shodan import Shodan
 from common.search import Search
-from config import logger
 
 
 class ShodanAPI(Search):
@@ -26,7 +20,8 @@ class ShodanAPI(Search):
         query = 'hostname:.' + self.domain
         page = 1
         while True:
-            params = {'key': self.key, 'page': page, 'query': query, 'minify': True, 'facets': {'hostnames'}}
+            params = {'key': self.key, 'page': page, 'query': query,
+                      'minify': True, 'facets': {'hostnames'}}
             resp = self.get(self.addr, params)
             if not resp:
                 return
@@ -35,39 +30,29 @@ class ShodanAPI(Search):
                 self.subdomains = self.subdomains.union(subdomain_find)
             page += 1
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not self.key:
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.key):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = ShodanAPI(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    results = queue.Queue()
-    do('qq.com', results)
+    do('example.com')

oneforall/modules/search/so.py

@@ -1,8 +1,6 @@
-# coding=utf-8
 import time
-import queue
+
 from common.search import Search
-from config import logger
 
 
 class So(Search):
@@ -37,21 +35,23 @@ class So(Search):
             if not subdomain_find:
                 break
             if not full_search:
-                if subdomain_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomain_find.issubset(self.subdomains):
                     break
             self.subdomains = self.subdomains.union(subdomain_find)
             page_num += 1
-            if '<a id="snext"' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
+            # 搜索页面没有出现下一页时停止搜索
+            if '<a id="snext"' not in resp.text:
                 break
-            if self.page_num * self.per_page_num >= self.limit_num:  # 搜索条数限制
+            # 搜索条数限制
+            if self.page_num * self.per_page_num >= self.limit_num:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -60,32 +60,29 @@ class So(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = So(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/sogou.py

@@ -1,8 +1,4 @@
-# coding=utf-8
-import time
-import queue
 from common.search import Search
-from config import logger
 
 
 class Sogou(Search):
@@ -27,7 +23,8 @@ class Sogou(Search):
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
             word = 'site:' + domain + filtered_subdomain
-            payload = {'query': word, 'page': self.page_num, "num": self.per_page_num}
+            payload = {'query': word, 'page': self.page_num,
+                       "num": self.per_page_num}
             resp = self.get(self.addr, payload)
             if not resp:
                 return
@@ -35,21 +32,24 @@ class Sogou(Search):
             if not subdomain_find:
                 break
             if not full_search:
-                if subdomain_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomain_find.issubset(self.subdomains):
                     break
             self.subdomains = self.subdomains.union(subdomain_find)
             self.page_num += 1
-            if '<a id="sogou_next"' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
+            # 搜索页面没有出现下一页时停止搜索
+            if '<a id="sogou_next"' not in resp.text:
                 break
-            if self.page_num * self.per_page_num >= self.limit_num:  # 搜索条数限制
+            # 搜索条数限制
+            if self.page_num * self.per_page_num >= self.limit_num:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -58,32 +58,29 @@ class Sogou(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Sogou(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/yahoo.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.search import Search
-from config import logger
 
 
 class Yahoo(Search):
@@ -11,8 +8,8 @@ class Yahoo(Search):
         self.domain = domain
         self.module = 'Search'
         self.source = 'YahooSearch'
-        self.init = 'https://hk.search.yahoo.com/'
-        self.addr = 'https://hk.search.yahoo.com/search'
+        self.init = 'https://search.yahoo.com/'
+        self.addr = 'https://search.yahoo.com/search'
         self.limit_num = 1000  # 限制搜索条数
         self.delay = 5
         self.per_page_num = 40
@@ -43,21 +40,23 @@ class Yahoo(Search):
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
             if not full_search:
-                if subdomains_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomains_find.issubset(self.subdomains):
                     break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             if '>Next</a>' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
                 break
             self.page_num += self.per_page_num
             if self.page_num >= self.limit_num:  # 搜索条数限制
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -66,32 +65,29 @@ class Yahoo(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Yahoo(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/yandex.py

@@ -1,8 +1,5 @@
-# coding=utf-8
 import time
-import queue
 from common.search import Search
-from config import logger
 
 
 class Yandex(Search):
@@ -25,13 +22,17 @@ class Yandex(Search):
         :param bool full_search: 全量搜索
         """
         self.page_num = 0  # 二次搜索重新置0
-        self.cookie = self.get(self.init).cookies  # 获取cookie bing在搜索时需要带上cookie
+        resp = self.get(self.init)
+        if not resp:
+            return
+        self.cookie = resp.cookies  # 获取cookie
         while True:
             time.sleep(self.delay)
             self.header = self.get_header()
             self.proxy = self.get_proxy(self.source)
             query = 'site:' + domain + filtered_subdomain
-            params = {'text': query, 'p': self.page_num, 'numdoc': self.per_page_num}
+            params = {'text': query, 'p': self.page_num,
+                      'numdoc': self.per_page_num}
             resp = self.get(self.addr, params)
             if not resp:
                 return
@@ -39,21 +40,23 @@ class Yandex(Search):
             if not subdomains_find:  # 搜索没有发现子域名则停止搜索
                 break
             if not full_search:
-                if subdomains_find.issubset(self.subdomains):  # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                # 搜索中发现搜索出的结果有完全重复的结果就停止搜索
+                if subdomains_find.issubset(self.subdomains):
                     break
-            self.subdomains = self.subdomains.union(subdomains_find)  # 合并搜索子域名搜索结果
+            # 合并搜索子域名搜索结果
+            self.subdomains = self.subdomains.union(subdomains_find)
             if '>next</a>' not in resp.text:  # 搜索页面没有出现下一页时停止搜索
                 break
             self.page_num += 1
             if self.page_num >= self.limit_num:  # 搜索条数限制
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
+
         self.search(self.domain, full_search=True)
 
         # 排除同一子域搜索结果过多的子域以发现新的子域
@@ -62,32 +65,29 @@ class Yandex(Search):
 
         # 递归搜索下一层的子域
         if self.recursive_search:
-            for layer_num in range(1, self.recursive_times):  # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            # 从1开始是之前已经做过1层子域搜索了,当前实际递归层数是layer+1
+            for layer_num in range(1, self.recursive_times):
                 for subdomain in self.subdomains:
-                    if subdomain.count('.') - self.domain.count('.') == layer_num:  # 进行下一层子域搜索的限制条件
+                    # 进行下一层子域搜索的限制条件
+                    count = subdomain.count('.') - self.domain.count('.')
+                    if count == layer_num:
                         self.search(subdomain)
-        end = time.time()
-        self.elapsed = round(end - start, 1)
+
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = Yandex(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/modules/search/zoomeye_api.py

@@ -1,6 +1,4 @@
-# coding=utf-8
 import time
-import queue
 import config
 from common.search import Search
 from config import logger
@@ -20,7 +18,6 @@ class ZoomEyeAPI(Search):
     def login(self):
         """
         登陆获取查询taken
-        :return:
         """
         url = 'https://api.zoomeye.org/user/login'
         data = {'username': self.user, 'password': self.pwd}
@@ -30,7 +27,7 @@ class ZoomEyeAPI(Search):
             return
         resp_json = resp.json()
         if resp.status_code == 200:
-            # print('登陆成功')
+            logger.log('DEBUG', f'{self.source}模块登录成功')
             return resp_json.get('access_token')
         else:
             logger.log('ALERT', resp_json.get('message'))
@@ -59,39 +56,29 @@ class ZoomEyeAPI(Search):
             if resp.status_code == 403:
                 break
 
-    def run(self, rx_queue):
+    def run(self):
         """
         类执行入口
         """
-        if not (self.user and self.pwd):
-            logger.log('ERROR', f'{self.source}模块API配置错误')
-            logger.log('ALERT', f'不执行{self.source}模块')
+        if not self.check(self.user, self.pwd):
             return
-        logger.log('DEBUG', f'开始执行{self.source}模块搜索{self.domain}的子域')
-        start = time.time()
+        self.begin()
         self.search()
-        end = time.time()
-        self.elapsed = round(end - start, 1)
         self.save_json()
         self.gen_result()
         self.save_db()
-        rx_queue.put(self.results)
-        logger.log('DEBUG', f'结束执行{self.source}模块搜索{self.domain}的子域')
+        self.finish()
 
 
-def do(domain, rx_queue):  # 统一入口名字 方便多线程调用
+def do(domain):  # 统一入口名字 方便多线程调用
     """
     类统一调用入口
 
     :param str domain: 域名
-    :param rx_queue: 结果集队列
     """
     search = ZoomEyeAPI(domain)
-    search.run(rx_queue)
-    logger.log('INFOR', f'{search.source}模块耗时{search.elapsed}秒发现{search.domain}的子域{len(search.subdomains)}个')
-    logger.log('DEBUG', f'{search.source}模块发现{search.domain}的子域 {search.subdomains}')
+    search.run()
 
 
 if __name__ == '__main__':
-    result_queue = queue.Queue()
-    do('owasp.org', result_queue)
+    do('example.com')

oneforall/oneforall.py

@@ -2,52 +2,59 @@
 # coding=utf-8
 
 """
-OneForAll是一款强大的子域收集神器
+OneForAll是一款功能强大的子域收集工具
+
+:copyright: Copyright (c) 2019, Jing Ling. All rights reserved.
+:license: GNU General Public License v3.0, see LICENSE for more details.
 """
 
 import asyncio
 import fire
 import config
 import dbexport
+from datetime import datetime
 from config import logger
 from collect import Collect
 from aiobrute import AIOBrute
 from common import utils, database, resolve, request
 
-__author__ = 'Jing Ling, Black Star'
-__contact__ = 'admin@hackfun.org'
-__copyright__ = 'Copyright (c) 2019, Jing Ling. All rights reserved.'
-__license__ = 'GNU General Public License v3.0'
-__version__ = '0.0.1'
+
+banner = """\033[01;33m
+             ___             _ _ 
+ ___ ___ ___|  _|___ ___ ___| | | \033[01;37m{\033[1;31mv0.0.3#dev\033[01;37m}\033[01;32m
+| . |   | -_|  _| . |  _| .'| | | \033[01;34m
+|___|_|_|___|_| |___|_| |__,|_|_| \033[0m\033[4;37mgit.io/fjHT1\033[0m\n
+        """
 
 
 class OneForAll(object):
     """
-    OneForAll是一款强大的子域收集神器
+    OneForAll是一款功能强大的子域收集工具
 
-    Version: 0.0.1
+    Version: 0.0.3
     Project: https://github.com/shmilylty/OneForAll/
 
-    :param str target:  单个域名或者每行一个域名的文件路径
-    :param bool brute:  是否使用爆破模块（默认禁用）
-    :param str port:    HTTP请求验证的端口范围（默认medium）
-    :param int valid:   导出子域的有效性（默认1）
-    :param str format:  导出格式（默认xlsx）
-    :param str path:    导出路径(默认None)
-    :param bool output: 是否将导出数据输出到终端（默认False）
+    Example:
+        python oneforall.py --target example.com run
+        python oneforall.py --target example.com --brute True --port medium valid 1 run
+        python oneforall.py --target ./domains.txt --format csv --path= ./result.csv  --output True run
 
     Note:
         参数valid可选值有1，0，None，分别表示导出有效，无效，全部子域
         参数port可选值有'small', 'medium', 'large', 'xlarge'，详见config.py配置
-        参数format可选格式有'csv','tsv','json','yaml','html','xls','xlsx','dbf','latex','ods'
+        参数format可选格式有'csv', 'tsv', 'json', 'yaml', 'html', 'xls', 'xlsx', 'dbf', 'latex', 'ods'
         参数path为None会根据format参数和域名名称在项目结果目录生成相应文件
 
-    Example:
-    python oneforall.py --target example.com run
-    python oneforall.py --target example.com --brute True --port medium valid 1 run
-    python oneforall.py --target ./domains.txt --format csv --path= ./result.csv  --output True run
+    :param str target:  单个域名或者每行一个域名的文件路径
+    :param bool brute:  是否使用爆破模块(默认禁用)
+    :param str port:    HTTP请求验证的端口范围(默认medium)
+    :param int valid:   导出子域的有效性(默认1)
+    :param str format:  导出格式(默认xlsx)
+    :param str path:    导出路径(默认None)
+    :param bool output: 是否将导出数据输出到终端(默认False)
     """
-    def __init__(self, target, brute=False, port='medium', valid=1, path=None, format='xlsx', output=False):
+    def __init__(self, target, brute=False, port='medium', valid=1, path=None,
+                 format='xlsx', output=False):
         self.target = target
         self.port = port
         self.domains = set()
@@ -60,6 +67,9 @@ class OneForAll(object):
         self.output = output
 
     def run(self):
+        print(banner)
+        dt = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        print(f'[*] Starting OneForAll @ {dt}\n')
         logger.log('INFOR', f'开始运行OneForAll')
         self.domains = utils.get_domains(self.target)
         if self.domains:
@@ -77,12 +87,11 @@ class OneForAll(object):
                 asyncio.set_event_loop(loop)
                 self.datas = loop.run_until_complete(resolve.bulk_query_a(self.datas))
                 self.datas = loop.run_until_complete(request.bulk_get_request(self.datas, self.port))
-                loop.run_until_complete(asyncio.sleep(0.25))  # 在关闭事件循环前加入一小段延迟让底层连接得到关闭的缓冲时间
+                # 在关闭事件循环前加入一小段延迟让底层连接得到关闭的缓冲时间
+                loop.run_until_complete(asyncio.sleep(0.25))
                 loop.close()
                 database.clear_table(db_conn, table_name)
                 database.save_db(db_conn, table_name, self.datas)
-                # database.deduplicate_subdomain(db_conn, table_name)
-                # database.remove_invalid(db_conn, table_name)
                 # 数据库导出
                 if not self.path:
                     self.path = config.result_save_path.joinpath(f'{self.domain}.{self.format}')
@@ -95,4 +104,4 @@ class OneForAll(object):
 
 if __name__ == '__main__':
     fire.Fire(OneForAll)
-    # OneForAll('owasp.org').run()
+    # OneForAll('example.com').run()