Exemple #1
0
def gen_fuzz_domains(domain, rule):
    domains = set()
    if '{fuzz}' not in domain:
        logger.log('FATAL', f'没有指定fuzz位置')
        return domains
    if not rule:
        logger.log('FATAL', f'没有指定fuzz规则')
        return domains
    fuzz_count = exrex.count(rule)
    if fuzz_count > 2000000:
        logger.log('FATAL', f'fuzz规则范围太大:{fuzz_count} > 2000000')
        return domains
    logger.log('INFOR', f'fuzz字典大小:{fuzz_count}')
    for i in range(3):
        random_domain = domain.replace('{fuzz}', exrex.getone(rule))
        logger.log('ALERT', f'请注意检查随机生成的{random_domain}是否正确')
    logger.log('ALERT', f'你有10秒检查时间退出使用`CTRL+C`')
    try:
        time.sleep(5)
    except KeyboardInterrupt:
        logger.log('INFOR', '爆破终止')
        exit(0)
    parts = domain.split('{fuzz}')
    for fuzz in exrex.generate(rule):
        fuzz_domain = parts[0] + fuzz + parts[1]
        domains.add(fuzz_domain)
    return domains
Exemple #2
0
def gen_fuzz_subdomains(expression, rule):
    """
    Generate subdomains based on fuzz mode

    :param  str  expression: generate subdomains's expression
    :param  str  rule: regexp rule
    :return list subdomains: list of subdomains
    """
    subdomains = list()
    fuzz_count = exrex.count(rule)
    if fuzz_count > 10000000:
        logger.log(
            'ALERT',
            f'The dictionary generated by this rule is too large:{fuzz_count} > 10000000'
        )
    logger.log('DEBUG', f'Dictionary size based on fuzz mode: {fuzz_count}')
    for fuzz_string in exrex.generate(rule):
        fuzz_string = fuzz_string.lower()
        if not fuzz_string.isalnum():
            continue
        fuzz_domain = expression.replace('*', fuzz_string)
        subdomains.append(fuzz_domain)
    random_domain = random.choice(subdomains)
    logger.log('ALERT',
               f'Please check whether {random_domain} is correct or not')
    return subdomains
Exemple #3
0
def gen_fuzz_subdomains(expression, rule, fuzzlist):
    """
    Generate subdomains based on fuzz mode

    :param  str  expression: generate subdomains's expression
    :param  str  rule: regexp rule
    :param  str  fuzzlist: fuzz dictionary
    :return set  subdomains: list of subdomains
    """
    subdomains = set()
    if fuzzlist:
        fuzz_domain = gen_subdomains(expression, fuzzlist)
        subdomains.update(fuzz_domain)
    if rule:
        fuzz_count = exrex.count(rule)
        if fuzz_count > 10000000:
            logger.log(
                'ALERT',
                f'The dictionary generated by this rule is too large: '
                f'{fuzz_count} > 10000000')
        for fuzz_string in exrex.generate(rule):
            fuzz_string = fuzz_string.lower()
            if not fuzz_string.isalnum():
                continue
            fuzz_domain = expression.replace('*', fuzz_string)
            subdomains.add(fuzz_domain)
        utils.check_random_subdomain(subdomains)
    logger.log('DEBUG',
               f'Dictionary size based on fuzz mode: {len(subdomains)}')
    return subdomains
Exemple #4
0
def count_test():
    for regex, result in RS.items():
        c = count(regex)
        l = len(result)
        try:
            assert c == l
        except:
            print '[E] Assertion error! "%s"\n\t%d != %d' % (regex, c, l)
Exemple #5
0
def count_test():
    for regex, result in RS.items():
        c = count(regex)
        l = len(result)
        try:
            assert c == l
        except:
            print '[E] Assertion error! "%s"\n\t%d != %d' % (regex, c, l)
Exemple #6
0
def regex_exrex(pattern, count):
    count = int(count) if int(count) > 0 and int(count) < 10 else 10
    return objdict({
        "pattern":
        pattern,
        "data":
        sorted(set([exrex.getone(pattern) for _ in range(count)])),
        "count":
        exrex.count(pattern)
    })
Exemple #7
0
def count_matches(include_malpedia: bool = False):
    if exrex is None:
        print("Error: Python module exrex is needed but not available.",
              file=sys.stderr)
        return 2
    replace = re.compile(
        r'\{[0-9]*,?([0-9]{2,}|[3-9])(,[0-9]*)?\}'
    )  # either more than one digit or greater than 2. Match also '{..,n}' or '{n,...}'
    print(
        sum(
            exrex.count(replace.sub('', expression))
            for expression, _, _ in load_mapping(
                include_malpedia=include_malpedia) if '*' not in expression))
Exemple #8
0
def count_test():
    for regex, result in RS.items():
        c = count(regex)
        l = len(result)
        try:
            assert c == l
        except:
            if IS_PY3:
                print('[E] Assertion error! "%s"\n\t%d != %d' % (regex, c, l))
                return -1
            else:
                print('[E] Assertion error! "%s"\n\t%d != %d' % (regex.decode("utf-8"), c, l))
                return -1
    return 0
Exemple #9
0
    def _get_primary_keys(self, table_name, num_rows):
        """Return the primary key and amount of values for the requested table.

        Args:
            table_name(str): Name of the table to get the primary keys.
            num_rowd(str): Number of primary_keys to generate.

        Returns:
            tuple(str,pandas.Series): If the table has a primary key.
            tuple(None, None): If the table doesn't have a primary key.

        Raises:
            ValueError: If there aren't enough remaining values to generate.

        """
        meta = self.dn.get_meta_data(table_name)
        primary_key = meta.get('primary_key')
        primary_key_values = None

        if primary_key:
            node = meta['fields'][primary_key]
            regex = node['regex']

            generator = self.primary_key.get(table_name)

            if generator is None:
                generator = exrex.generate(regex)
                self.primary_key[table_name] = generator

                remaining = exrex.count(regex)
                self.remaining_primary_key[table_name] = remaining

            else:
                remaining = self.remaining_primary_key[table_name]

            if remaining < num_rows:
                raise ValueError(
                    'Not enough unique values for primary key of table {} with regex {}'
                    ' to generate {} samples.'.format(table_name, regex,
                                                      num_rows))

            self.remaining_primary_key[table_name] -= num_rows
            primary_key_values = pd.Series(
                [x for i, x in zip(range(num_rows), generator)])

            if (node['type'] == 'number') and (node['subtype'] == 'integer'):
                primary_key_values = primary_key_values.astype(int)

        return primary_key, primary_key_values
Exemple #10
0
def count_test():
    for regex, result in RS.items():
        c = count(regex)
        l = len(result)
        try:
            assert c == l
        except:
            if IS_PY3:
                print('[E] Assertion error! "%s"\n\t%d != %d' % (regex, c, l))
                return -1
            else:
                print('[E] Assertion error! "%s"\n\t%d != %d' %
                      (regex.decode('utf-8'), c, l))
                return -1
    return 0
Exemple #11
0
        def __init__(self, name, regex, limit=20):
            if isinstance(name, str) and name:
                self.name = name
            else:
                raise DizzyParseException("Name must be str and not empty.")

            if isinstance(regex, str):
                self.regex = regex
            else:
                raise DizzyParseException("regex must be str.")

            if isinstance(limit, int):
                self.limit = limit
            else:
                raise DizzyParseException("limit must be int.")

            self.len = count(self.regex, self.limit)
def generate(str_length=10, patterns=[]):
    print("# total possible strings: ", exrex.count('(a|b|c|d|e|f){{{}}}'.format(str_length)))
    data = {
        "pos": [],
        "neg": []
    }
    for str in exrex.generate('(a|b|c|d|e|f){{{}}}'.format(str_length)):
        label = False
        latest = -1
        for p in patterns:
            if p[0].match(str):
                label = p[1]
                latest = p[0]
        if label:
            data["pos"].append((str, label, latest))
        else:
            data["neg"].append((str, label, latest))
    return data
Exemple #13
0
def gen_fuzz_subdomains(expression, rule):
    """
    生成基于fuzz模式的爆破子域

    :param str expression: 子域域名生成表达式
    :param str rule: 生成子域所需的正则规则
    :return: 用于爆破的子域
    """
    subdomains = list()
    fuzz_count = exrex.count(rule)
    if fuzz_count > 10000000:
        logger.log('ALERT', f'请注意该规则生成的字典太大:{fuzz_count} > 10000000')
    logger.log('DEBUG', f'fuzz模式下生成的字典大小:{fuzz_count}')
    for fuzz_string in exrex.generate(rule):
        fuzz_string = fuzz_string.lower()
        if not fuzz_string.isalnum():
            continue
        fuzz_domain = expression.replace('*', fuzz_string)
        subdomains.append(fuzz_domain)
    random_domain = random.choice(subdomains)
    logger.log('ALERT', f'请注意检查基于fuzz模式生成的{random_domain}是否正确')
    return subdomains
Exemple #14
0
# Python3.7.3

import exrex
 
exrex.getone('(ex)r\\1')

 
list(exrex.generate('((hai){2}|world!)'))
 
exrex.getone('\d{4}-\d{4}-\d{4}-[0-9]{4}')
 
exrex.getone('(1[0-2]|0[1-9])(:[0-5]\d){2} (A|P)M')
 
exrex.count('[01]{0,9}')
 
print('\n'.join(exrex.generate('This is (a (secret|test|whisper)|an (code|lie|truth))\.')))
 
print(exrex.simplify('(ab|c|d)'))
# -*- coding: utf-8 -*-
import exrex

#填入正则表达式的代码会生成对应的内容
print exrex.getone('(ex)r\\1')

#转换列表 匹配2个hai或word
num = list(exrex.generate('((hai){2}|word!)'))
print num

#数字 如3575-7048-5984-2471
print exrex.getone('\d{4}-\d{4}-\d{4}-[0-9]{4}')

#时间
print exrex.getone('(1[0-2]|0[1-9])(:[0-5]\d){2} (A|P)M')

#计数
print exrex.count('[01]{0,9}')

#假设知道某个密码的组合方式,需要将所有的密码都列举出来
num = list(exrex.generate('[Pp][a@]ssw[Oo]rd'))
print num
Exemple #16
0
from tests import *
import shutil

dir_path = os.path.dirname(os.path.realpath(__file__))

if not os.path.isfile(dir_path + "/config.py"):
    shutil.copy2(dir_path + "/defaults.py", dir_path + "/config.py")

from config import *


def command(tup):
    return "(" + tup[0] + ")" + PLACEHOLDER + "(" + tup[1] + ")"


t_count = count(command(AUTO_TESTER))
DIR = "* = expected   - = actual\n"


def run_tests(tests, source, reference, force_strict, leng=None):
    total_errors = []
    total_tested = 0
    for key, test_pool in tests.items():
        print("running", key, "tests..")
        errors = test_pool.run_tests(source, reference, force_strict, key,
                                     leng)
        l = len(errors)
        total_tested += len(test_pool)
        if l > 0:
            total_errors += errors
            if reinput(
Exemple #17
0
    def _get_primary_keys(self, table_name, num_rows):
        """Return the primary key and amount of values for the requested table.

        Args:
            table_name (str):
                Name of the table to get the primary keys from.
            num_rows (str):
                Number of ``primary_keys`` to generate.

        Returns:
            tuple (str, pandas.Series):
                primary key name and primary key values. If the table has no primary
                key, ``(None, None)`` is returned.

        Raises:
            ValueError:
                If the ``metadata`` contains invalid types or subtypes, or if
                there are not enough primary keys left on any of the generators.
            NotImplementedError:
                If the primary key subtype is a ``datetime``.
        """
        primary_key = self.metadata.get_primary_key(table_name)
        primary_key_values = None

        if primary_key:
            field = self.metadata.get_fields(table_name)[primary_key]

            generator = self.primary_key.get(table_name)

            if generator is None:
                if field['type'] != 'id':
                    raise ValueError(
                        'Only columns with type `id` can be primary keys')

                subtype = field.get('subtype', 'integer')
                if subtype == 'integer':
                    generator = itertools.count()
                    remaining = np.inf
                elif subtype == 'string':
                    regex = field.get('regex', r'^[a-zA-Z]+$')
                    generator = exrex.generate(regex)
                    remaining = exrex.count(regex)
                elif subtype == 'datetime':
                    raise NotImplementedError(
                        'Datetime ids are not yet supported')
                else:
                    raise ValueError(
                        'Only `integer` or `string` id columns are supported.')

                self.primary_key[table_name] = generator
                self.remaining_primary_key[table_name] = remaining

            else:
                remaining = self.remaining_primary_key[table_name]

            if remaining < num_rows:
                raise ValueError(
                    'Not enough unique values for primary key of table {}'
                    ' to generate {} samples.'.format(table_name, num_rows))

            self.remaining_primary_key[table_name] -= num_rows
            primary_key_values = pd.Series(
                [x for i, x in zip(range(num_rows), generator)])

        return primary_key, primary_key_values
Exemple #18
0
	sys.exit(1)

FuckyHandle = win32file.CreateFile(
	"\\\\.\\PhysicalDrive4", # Change this according to: wmic diskdrive list brief
	0xC0000000, 
	win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE, 
	None, 
	win32con.OPEN_EXISTING, 
	0, 
	0
)

OutBuffer = bytearray(b"\x00"*80)

CHARSET = r"[a-zA-Z0-9]{6}" 
Combinations = exrex.count(CHARSET)

for N, Password in enumerate(exrex.generate(CHARSET)):

	InBuffer = (
		b"\x2c\x00\x00\x00\x00\x00\x10\x18\x00\x00\x00\x00\x20\x00\x00\x00\x0A\x00\x00\x00\x50\x00\x00\x00\x30\x00\x00\x00\xf4\x01" + 
		b"\x00" * 50 + 
		Password.encode("ascii") + 
		b"\x00" * 60
	)
	
	try:
		win32file.DeviceIoControl(FuckyHandle, 0x4D004, InBuffer, OutBuffer)
	except Exception as Error:
		print(Error)
		print()
    def gen_packet(self):
        """
        Infinite generator
        Generates all combinations of n_bits that matches the given pattern and repeats
        them again.

        Returns:
            A list with the generated combination
        """
        n = self.n
        spacing = self.spacing
        repetitions = self.repetitions
        pattern = self.pattern

        # Substitues '.' for '[01]', as packets are a binary string
        pattern = re.sub("[.]", "[01]", pattern)
        # Python's regex substitutes '*' for {0, 4294967295}, and '+' for {1, 4294967295}.
        # To reduce the output of exrex, 4294967295 is changed for n
        pattern = re.sub("[*]", "{0," + str(n) + "}", pattern)
        pattern = re.sub("[+]", "{1," + str(n) + "}", pattern)

        if exrex.count(pattern, limit=n + 1) < (2**self.n):

            # Generated with exrex (reversing the regular expression)

            while True:
                for b in exrex.generate(pattern, limit=n + 1):

                    # Spacing between packets
                    yield [2] * self.comb_spacing

                    if len(b) == n:
                        # Repeats the current combination 'repetitions' times, if it matches
                        for i in xrange(repetitions):

                            yield [int(x) for x in b] + [2] * spacing
                            print b

        else:
            # Normal generation (pure bruteforcing)

            regex = re.compile(pattern)
            b = 0
            while True:

                s = "{0:b}".format(b).zfill(n)

                if regex.match(s):
                    # Spacing between packets
                    yield [2] * self.comb_spacing

                    # Repeats the current combination 'repetitions' times, if it matches
                    for i in xrange(repetitions):

                        yield [int(x) for x in s] + [2] * spacing
                        print s

                # Restarts the counter
                if b >= ((2**n) - 1):
                    b = 0
                else:
                    b += 1