././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617538525.007963 dnsgen-1.0.4/0002755000174500001730000000000000000000000012511 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/LICENSE0000644000174500001730000000203500000000000013514 0ustar00janitorsbuildCopyright 2019, Patrik Hudak Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/MANIFEST.in0000644000174500001730000000007300000000000014245 0ustar00janitorsbuildinclude requirements.txt LICENSE include dnsgen/words.txt ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617538525.007963 dnsgen-1.0.4/PKG-INFO0000644000174500001730000001055700000000000013614 0ustar00janitorsbuildMetadata-Version: 2.1 Name: dnsgen Version: 1.0.4 Summary: Generates DNS possibilities from existing domain names. Home-page: https://github.com/me/myproject Author: Patrik Hudak Author-email: pato.hudak@gmail.com License: MIT Description: # :cyclone: dnsgen (DNS generator) This tool generates a combination of domain names from the provided input. Combinations are created based on wordlist. Custom words are extracted per execution. Refer to [Techniques](#techniques) section to learn more. `dnsgen` is very similar to [altdns](https://github.com/infosec-au/altdns). It does not contain DNS resolver. You should use [massdns](https://github.com/blechschmidt/massdns) for DNS resolution. ![dnsgen](https://0xpatrik.com/content/images/2019/09/dnsgen-1.png) ## Installation ```pip3 install dnsgen``` ..or from GitHub directly: ``` git clone https://github.com/ProjectAnte/dnsgen cd dnsgen pip3 install -r requirements.txt python3 setup.py install ``` ## Usage ```$ dnsgen domains.txt``` (`domains.txt` contains a list of active domain names) * `-l` / `--wordlen`: minimum size of custom words to be extracted * `-w` / `--wordlist`: path to custom wordlist * `-f` / `--fast`: Generate lower amount of domains with most probable words only * `filename`: required parameter for an input list of domains. The input file should contain domain names separated by newline character (`\n`). You can also use STDIN as an input method, providing `-` to this argument. **Combination with massdns:** `$ cat domains.txt | dnsgen - | massdns -r /path/to/resolvers.txt -t A -o J --flush 2>/dev/null` ## Techniques *(For demo purposes, let's say that wordlist contains just one word: `stage`)* * **Insert word on every index** — Creates new subdomain levels by inserting the words between existing levels. `foo.example.com` -> `stage.foo.example.com`, `foo.stage.example.com` * **Increase/Decrease num found** — *(In development)* If number is found in an existing subdomain, increase/decrease this number without any other alteration. `foo01.example.com` -> `foo02.example.com`, `foo03.example.com`, `...` * **Prepend word on every index** — On every subdomain level, prepend existing content with `WORD` and `WORD-`. `foo.example.com` -> `stagefoo.example.com`, `stage-foo.example.com` * **Append word on every index** — On every subdomain level, append existing content with `WORD` and `WORD-`. `foo.example.com` -> `foostage.example.com`, `foo-stage.example.com` * **Replace the word with word** — If word longer than 3 is found in an existing subdomain, replace it with other words from the wordlist. *(If we have more words than one in our wordlist)*. `stage.foo.example.com` -> `otherword.foo.example.com`, `anotherword.foo.example.com`, `...` * **Extract custom words** — Extend the wordlist based on target's domain naming conventions. Such words are either whole subdomain levels, or `-` is used for a split on some subdomain level. For instance `mapp1-current.datastream.example.com` has `mapp1`, `current`, `datastream` words. To prevent the overflow, user-defined *word length* is used for word extraction. The default value is set to **6**. This means that only words strictly longer than **5** characters are included (from the previous example, `mapp1` does not satisfy this condition). ## Resources - [Subdomain Enumeration: 2019 Workflow](https://0xpatrik.com/subdomain-enumeration-2019/) - [Subdomain Enumeration: Doing it a Bit Smarter](https://0xpatrik.com/subdomain-enumeration-smarter/) ## TO DO - Improve README - Tests Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Requires-Python: >=3.6.0 Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/README.md0000644000174500001730000000637500000000000014001 0ustar00janitorsbuild# :cyclone: dnsgen (DNS generator) This tool generates a combination of domain names from the provided input. Combinations are created based on wordlist. Custom words are extracted per execution. Refer to [Techniques](#techniques) section to learn more. `dnsgen` is very similar to [altdns](https://github.com/infosec-au/altdns). It does not contain DNS resolver. You should use [massdns](https://github.com/blechschmidt/massdns) for DNS resolution. ![dnsgen](https://0xpatrik.com/content/images/2019/09/dnsgen-1.png) ## Installation ```pip3 install dnsgen``` ..or from GitHub directly: ``` git clone https://github.com/ProjectAnte/dnsgen cd dnsgen pip3 install -r requirements.txt python3 setup.py install ``` ## Usage ```$ dnsgen domains.txt``` (`domains.txt` contains a list of active domain names) * `-l` / `--wordlen`: minimum size of custom words to be extracted * `-w` / `--wordlist`: path to custom wordlist * `-f` / `--fast`: Generate lower amount of domains with most probable words only * `filename`: required parameter for an input list of domains. The input file should contain domain names separated by newline character (`\n`). You can also use STDIN as an input method, providing `-` to this argument. **Combination with massdns:** `$ cat domains.txt | dnsgen - | massdns -r /path/to/resolvers.txt -t A -o J --flush 2>/dev/null` ## Techniques *(For demo purposes, let's say that wordlist contains just one word: `stage`)* * **Insert word on every index** — Creates new subdomain levels by inserting the words between existing levels. `foo.example.com` -> `stage.foo.example.com`, `foo.stage.example.com` * **Increase/Decrease num found** — *(In development)* If number is found in an existing subdomain, increase/decrease this number without any other alteration. `foo01.example.com` -> `foo02.example.com`, `foo03.example.com`, `...` * **Prepend word on every index** — On every subdomain level, prepend existing content with `WORD` and `WORD-`. `foo.example.com` -> `stagefoo.example.com`, `stage-foo.example.com` * **Append word on every index** — On every subdomain level, append existing content with `WORD` and `WORD-`. `foo.example.com` -> `foostage.example.com`, `foo-stage.example.com` * **Replace the word with word** — If word longer than 3 is found in an existing subdomain, replace it with other words from the wordlist. *(If we have more words than one in our wordlist)*. `stage.foo.example.com` -> `otherword.foo.example.com`, `anotherword.foo.example.com`, `...` * **Extract custom words** — Extend the wordlist based on target's domain naming conventions. Such words are either whole subdomain levels, or `-` is used for a split on some subdomain level. For instance `mapp1-current.datastream.example.com` has `mapp1`, `current`, `datastream` words. To prevent the overflow, user-defined *word length* is used for word extraction. The default value is set to **6**. This means that only words strictly longer than **5** characters are included (from the previous example, `mapp1` does not satisfy this condition). ## Resources - [Subdomain Enumeration: 2019 Workflow](https://0xpatrik.com/subdomain-enumeration-2019/) - [Subdomain Enumeration: Doing it a Bit Smarter](https://0xpatrik.com/subdomain-enumeration-smarter/) ## TO DO - Improve README - Tests ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617538525.0039628 dnsgen-1.0.4/dnsgen/0002755000174500001730000000000000000000000013767 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/dnsgen/__init__.py0000644000174500001730000000005100000000000016072 0ustar00janitorsbuild# python3 from . dnsgen import generate ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/dnsgen/cli.py0000644000174500001730000000145600000000000015114 0ustar00janitorsbuild# python3 import os import sys import click from . import dnsgen @click.command() @click.option('-l', '--wordlen', default=6, help='Min length of custom words extracted from domains.', required=False, type=click.IntRange(1, 100)) @click.option('-w', '--wordlist', default=None, help='Path to custom wordlist.', type=click.Path(exists=True, readable=True), required=False) @click.option('-f', '--fast', default=None, help='Fast generation.', is_flag=True, required=False) @click.argument('filename', required=True, type=click.File(mode='r')) def main(wordlen, wordlist, filename, fast): # read the input domains = filename.read().splitlines() for r in dnsgen.generate(domains, wordlist, wordlen, fast=fast): click.echo(r) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/dnsgen/dnsgen.py0000644000174500001730000001433300000000000015621 0ustar00janitorsbuild# coding=utf-8 import itertools import pathlib import re import tldextract WORDS = None NUM_COUNT = 3 def create_registrar(): ''' Create function registration decorator ''' registry = [] def registrar(func): registry.append(func) return func registrar.members = registry return registrar # Create two types of permutator classes # PERMUTATOR -> used as basic class, includes every possible permutator # FAST_PERMUTATOR -> used for quick enumerations, mainly for huge scopes PERMUTATOR = create_registrar() FAST_PERMUTATOR = create_registrar() def partiate_domain(domain): ''' Split domain base on subdomain levels. Root+TLD is taken as one part, regardless of its levels (example.co.uk, example.com, ...) ''' # test.1.foo.example.com -> [test, 1, foo, example.com] # test.2.foo.example.com.cn -> [test, 2, foo, example.com.cn] # test.example.co.uk -> [test, example.co.uk] ext = tldextract.extract(domain.lower()) parts = (ext.subdomain.split('.') + [ext.registered_domain]) return parts @PERMUTATOR def insert_word_every_index(parts): ''' Create new subdomain levels by inserting the words between existing levels ''' # test.1.foo.example.com -> WORD.test.1.foo.example.com, test.WORD.1.foo.example.com, # test.1.WORD.foo.example.com, test.1.foo.WORD.example.com, ... domains = [] for w in WORDS: for i in range(len(parts)): tmp_parts = parts[:-1] tmp_parts.insert(i, w) domains.append('.'.join(tmp_parts + [parts[-1]])) return domains @FAST_PERMUTATOR @PERMUTATOR def increase_num_found(parts): ''' If number is found in existing subdomain, increase this number without any other alteration. ''' # test.1.foo.example.com -> test.2.foo.example.com, test.3.foo.example.com, ... # test1.example.com -> test2.example.com, test3.example.com, ... # test01.example.com -> test02.example.com, test03.example.com, ... domains = [] parts_joined = '.'.join(parts[:-1]) digits = re.findall(r'\d{1,3}', parts_joined) for d in digits: for m in range(NUM_COUNT): replacement = str(int(d) + 1 + m).zfill(len(d)) tmp_domain = parts_joined.replace(d, replacement) domains.append('{}.{}'.format(tmp_domain, parts[-1])) return domains @FAST_PERMUTATOR @PERMUTATOR def decrease_num_found(parts): ''' If number is found in existing subdomain, decrease this number without any other alteration. ''' # test.4.foo.example.com -> test.3.foo.example.com, test.2.foo.example.com, ... # test4.example.com -> test3.example.com, test2.example.com, ... # test04.example.com -> test03.example.com, test02.example.com, ... domains = [] parts_joined = '.'.join(parts[:-1]) digits = re.findall(r'\d{1,3}', parts_joined) for d in digits: for m in range(NUM_COUNT): new_digit = (int(d) - 1 - m) if new_digit < 0: break replacement = str(new_digit).zfill(len(d)) tmp_domain = parts_joined.replace(d, replacement) domains.append('{}.{}'.format(tmp_domain, parts[-1])) return domains @PERMUTATOR def prepend_word_every_index(parts): ''' On every subdomain level, prepend existing content with `WORD` and `WORD-` ''' # test.1.foo.example.com -> WORDtest.1.foo.example.com, test.WORD1.foo.example.com, # test.1.WORDfoo.example.com, WORD-test.1.foo.example.com, # test.WORD-1.foo.example.com, test.1.WORD-foo.example.com, ... domains = [] for w in WORDS: for i in range(len(parts[:-1])): # Prepend normal tmp_parts = parts[:-1] tmp_parts[i] = '{}{}'.format(w, tmp_parts[i]) domains.append('.'.join(tmp_parts + [parts[-1]])) # Prepend with `-` tmp_parts = parts[:-1] tmp_parts[i] = '{}-{}'.format(w, tmp_parts[i]) domains.append('.'.join(tmp_parts + [parts[-1]])) return domains @PERMUTATOR def append_word_every_index(parts): ''' On every subdomain level, append existing content with `WORD` and `WORD-` ''' # test.1.foo.example.com -> testWORD.1.foo.example.com, test.1WORD.foo.example.com, # test.1.fooWORD.example.com, test-WORD.1.foo.example.com, # test.1-WORD.foo.example.com, test.1.foo-WORD.example.com, ... domains = [] for w in WORDS: for i in range(len(parts[:-1])): # Append Normal tmp_parts = parts[:-1] tmp_parts[i] = '{}{}'.format(tmp_parts[i], w) domains.append('.'.join(tmp_parts + [parts[-1]])) # Append with `-` tmp_parts = parts[:-1] tmp_parts[i] = '{}-{}'.format(tmp_parts[i], w) domains.append('.'.join(tmp_parts + [parts[-1]])) return domains @FAST_PERMUTATOR @PERMUTATOR def replace_word_with_word(parts): ''' If word longer than 3 is found in existing subdomain, replace it with other words from the dictionary ''' # WORD1.1.foo.example.com -> WORD2.1.foo.example.com, WORD3.1.foo.example.com, # WORD4.1.foo.example.com, ... # TODO: consider if the same word is found multiple times in one string domains = [] for w in WORDS: if w in '.'.join(parts[:-1]): for w_alt in WORDS: if w == w_alt: continue domains.append('{}.{}'.format('.'.join(parts[:-1]).replace(w, w_alt), parts[-1])) return domains def extract_custom_words(domains, wordlen): ''' Extend the dictionary based on target's domain naming conventions ''' valid_tokens = set() for domain in domains: partition = partiate_domain(domain)[:-1] tokens = set(itertools.chain(*[word.lower().split('-') for word in partition])) tokens = tokens.union({word.lower() for word in partition}) for t in tokens: if len(t) >= wordlen: valid_tokens.add(t) return valid_tokens def init_words(domains, wordlist, wordlen, fast): ''' Initiaze wordlist ''' global WORDS if wordlist is None: wordlist = pathlib.Path(__file__).parent / 'words.txt' WORDS = open(wordlist).read().splitlines() if fast: WORDS = WORDS[:10] WORDS = list(set(WORDS).union(extract_custom_words(domains, wordlen))) def generate(domains, wordlist=None, wordlen=5, fast=False, skip_init=False): ''' Generate permutations from provided domains ''' if not skip_init: init_words(domains, wordlist, wordlen, fast) for domain in set(domains): parts = partiate_domain(domain) for perm in (FAST_PERMUTATOR.members if fast else PERMUTATOR.members): for possible_domain in perm(parts): yield possible_domain ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/dnsgen/words.txt0000644000174500001730000000270300000000000015666 0ustar00janitorsbuilddev test stg svc staging stage prod secure trial admin acc account accounting active adm administrator administrators admins alpha analytics apac apache api apidocs apiserver app apps application applications assets asana auth authenticate authentication authorization aws azure backend beta billing bitbucket brand bucket cdn cert cgi chd chef ci client cloud cloudapp cloudfront cms confluence container control controller ctl customer cvs data dashboard demo developer development devops develop devs disabled docker docs docsapi document documents documentation edge elastic elasticbeanstalk ebs email emea engine engineering europe europewest events ext file firewall frontpage fw gateway gh get getter gist git github gitlab global gw help history hw hwcdn iad ids internal ingress internals jenkins k8s k8s-dev k8s-prd k8s-prod kube kubectl kubernetes lab latin legacy loadbalancer login machine manage management mgmt mail marketing market metrics metric merchant mirror mobile mobileclient nautilus net nginx node northamerica oid old ops org origin page panel partner pass pay payment paywall php portal preview priv private prd production productions profile profiles promo proxy raw redir redirect redirector region repo repository reset restricted rpc s3 sandbox scm search security server service signed skins ssl staff static stats support swagger swag system team testing tester traffic tomcat toolbar train training upload uploads v1 v2 v3 vpn w3 web webapp ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617538525.007963 dnsgen-1.0.4/dnsgen.egg-info/0002755000174500001730000000000000000000000015461 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/PKG-INFO0000644000174500001730000001055700000000000016564 0ustar00janitorsbuildMetadata-Version: 2.1 Name: dnsgen Version: 1.0.4 Summary: Generates DNS possibilities from existing domain names. Home-page: https://github.com/me/myproject Author: Patrik Hudak Author-email: pato.hudak@gmail.com License: MIT Description: # :cyclone: dnsgen (DNS generator) This tool generates a combination of domain names from the provided input. Combinations are created based on wordlist. Custom words are extracted per execution. Refer to [Techniques](#techniques) section to learn more. `dnsgen` is very similar to [altdns](https://github.com/infosec-au/altdns). It does not contain DNS resolver. You should use [massdns](https://github.com/blechschmidt/massdns) for DNS resolution. ![dnsgen](https://0xpatrik.com/content/images/2019/09/dnsgen-1.png) ## Installation ```pip3 install dnsgen``` ..or from GitHub directly: ``` git clone https://github.com/ProjectAnte/dnsgen cd dnsgen pip3 install -r requirements.txt python3 setup.py install ``` ## Usage ```$ dnsgen domains.txt``` (`domains.txt` contains a list of active domain names) * `-l` / `--wordlen`: minimum size of custom words to be extracted * `-w` / `--wordlist`: path to custom wordlist * `-f` / `--fast`: Generate lower amount of domains with most probable words only * `filename`: required parameter for an input list of domains. The input file should contain domain names separated by newline character (`\n`). You can also use STDIN as an input method, providing `-` to this argument. **Combination with massdns:** `$ cat domains.txt | dnsgen - | massdns -r /path/to/resolvers.txt -t A -o J --flush 2>/dev/null` ## Techniques *(For demo purposes, let's say that wordlist contains just one word: `stage`)* * **Insert word on every index** — Creates new subdomain levels by inserting the words between existing levels. `foo.example.com` -> `stage.foo.example.com`, `foo.stage.example.com` * **Increase/Decrease num found** — *(In development)* If number is found in an existing subdomain, increase/decrease this number without any other alteration. `foo01.example.com` -> `foo02.example.com`, `foo03.example.com`, `...` * **Prepend word on every index** — On every subdomain level, prepend existing content with `WORD` and `WORD-`. `foo.example.com` -> `stagefoo.example.com`, `stage-foo.example.com` * **Append word on every index** — On every subdomain level, append existing content with `WORD` and `WORD-`. `foo.example.com` -> `foostage.example.com`, `foo-stage.example.com` * **Replace the word with word** — If word longer than 3 is found in an existing subdomain, replace it with other words from the wordlist. *(If we have more words than one in our wordlist)*. `stage.foo.example.com` -> `otherword.foo.example.com`, `anotherword.foo.example.com`, `...` * **Extract custom words** — Extend the wordlist based on target's domain naming conventions. Such words are either whole subdomain levels, or `-` is used for a split on some subdomain level. For instance `mapp1-current.datastream.example.com` has `mapp1`, `current`, `datastream` words. To prevent the overflow, user-defined *word length* is used for word extraction. The default value is set to **6**. This means that only words strictly longer than **5** characters are included (from the previous example, `mapp1` does not satisfy this condition). ## Resources - [Subdomain Enumeration: 2019 Workflow](https://0xpatrik.com/subdomain-enumeration-2019/) - [Subdomain Enumeration: Doing it a Bit Smarter](https://0xpatrik.com/subdomain-enumeration-smarter/) ## TO DO - Improve README - Tests Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Requires-Python: >=3.6.0 Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/SOURCES.txt0000644000174500001730000000046000000000000017343 0ustar00janitorsbuildLICENSE MANIFEST.in README.md requirements.txt setup.py dnsgen/__init__.py dnsgen/cli.py dnsgen/dnsgen.py dnsgen/words.txt dnsgen.egg-info/PKG-INFO dnsgen.egg-info/SOURCES.txt dnsgen.egg-info/dependency_links.txt dnsgen.egg-info/entry_points.txt dnsgen.egg-info/requires.txt dnsgen.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/dependency_links.txt0000644000174500001730000000000100000000000021525 0ustar00janitorsbuild ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/entry_points.txt0000644000174500001730000000005400000000000020754 0ustar00janitorsbuild[console_scripts] dnsgen = dnsgen.cli:main ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/requires.txt0000644000174500001730000000002100000000000020050 0ustar00janitorsbuildClick tldextract ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538524.0 dnsgen-1.0.4/dnsgen.egg-info/top_level.txt0000644000174500001730000000000700000000000020206 0ustar00janitorsbuilddnsgen ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/requirements.txt0000644000174500001730000000003600000000000015772 0ustar00janitorsbuildClick==7.0 tldextract==2.2.0 ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1617538525.007963 dnsgen-1.0.4/setup.cfg0000644000174500001730000000004600000000000014330 0ustar00janitorsbuild[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617538510.0 dnsgen-1.0.4/setup.py0000644000174500001730000000563100000000000014226 0ustar00janitorsbuild#!/usr/bin/env python # -*- coding: utf-8 -*- import io import os import sys from shutil import rmtree from setuptools import find_packages, setup, Command # Package meta-data. NAME = 'dnsgen' DESCRIPTION = 'Generates DNS possibilities from existing domain names.' URL = 'https://github.com/me/myproject' EMAIL = 'pato.hudak@gmail.com' AUTHOR = 'Patrik Hudak' REQUIRES_PYTHON = '>=3.6.0' VERSION = '1.0.4' REQUIRED = ['Click', 'tldextract'] EXTRAS = {} here = os.path.abspath(os.path.dirname(__file__)) try: with io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f: long_description = '\n' + f.read() except FileNotFoundError: long_description = DESCRIPTION # Load the package's __version__.py module as a dictionary. about = {} if not VERSION: project_slug = NAME.lower().replace("-", "_").replace(" ", "_") with open(os.path.join(here, project_slug, '__version__.py')) as f: exec(f.read(), about) else: about['__version__'] = VERSION class UploadCommand(Command): """Support setup.py upload.""" description = 'Build and publish the package.' user_options = [] @staticmethod def status(s): """Prints things in bold.""" print('\033[1m{0}\033[0m'.format(s)) def initialize_options(self): pass def finalize_options(self): pass def run(self): try: self.status('Removing previous builds…') rmtree(os.path.join(here, 'dist')) except OSError: pass self.status('Building Source and Wheel (universal) distribution…') os.system('{0} setup.py sdist bdist_wheel --universal'.format(sys.executable)) self.status('Uploading the package to PyPI via Twine…') os.system('twine upload dist/*') self.status('Pushing git tags…') os.system('git tag v{0}'.format(about['__version__'])) os.system('git push --tags') sys.exit() # Where the magic happens: setup( name=NAME, version=about['__version__'], description=DESCRIPTION, long_description=long_description, long_description_content_type='text/markdown', author=AUTHOR, author_email=EMAIL, python_requires=REQUIRES_PYTHON, url=URL, packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]), entry_points={ 'console_scripts': ['dnsgen=dnsgen.cli:main'], }, install_requires=REQUIRED, extras_require=EXTRAS, include_package_data=True, license='MIT', classifiers=[ 'License :: OSI Approved :: MIT License', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy' ], # $ setup.py publish support. cmdclass={ 'upload': UploadCommand, }, )