def __init__( self, paths, extensions, suffixes=[], prefixes=[], lowercase=False, uppercase=False, capitalization=False, force_extensions=False, exclude_extensions=[], no_extension=False, only_selected=False, ): self.entries = () self.current_index = 0 self.condition = threading.Lock() self._extensions = extensions self._exclude_extensions = exclude_extensions self._prefixes = prefixes self._suffixes = suffixes self._paths = paths self._force_extensions = force_extensions self._no_extension = no_extension self._only_selected = only_selected self.lowercase = lowercase self.uppercase = uppercase self.capitalization = capitalization self.dictionary_files = [File(path) for path in self.paths] self.generate()
def __init__(self, path, extensions=None, lowercase=False, forcedExtensions=False): self.entries = [] self.currentIndex = 0 self.condition = threading.Lock() self._extensions = [] if extensions: if isinstance(extensions, str): self._extensions.append(extensions) elif isinstance(extensions, list): self._extensions = extensions else: raise Exception('TODO: extensions type error!') self._path = path self._forcedExtensions = forcedExtensions self.lowercase = lowercase self.dictionaryFile = File(self.path) self.generate()
def access_file(self, path, name): with File(path) as file: if not file.exists(): print("The {} does not exist".format(name)) exit(1) if not file.is_valid(): print("The {} is invalid".format(name)) exit(1) if not file.can_read(): print("The {} cannot be read".format(name)) exit(1) return file
def access_file(path, name): with File(path) as fd: if not fd.exists(): print(f"The {name} does not exist") exit(1) if not fd.is_valid(): print(f"The {name} is invalid") exit(1) if not fd.can_read(): print(f"The {name} cannot be read") exit(1) return fd
def parse_raw(raw_file): with File(raw_file) as content: raw_content = content.read() head = raw_content.split(NEW_LINE * 2)[0].splitlines(0) method, path = head[0].split()[:2] try: headers = HeadersParser(head[1:]) host = headers.get("host").strip() except KeyError: print("Can't find the Host header in the raw request") exit(1) except Exception: print("Invalid headers in the raw request") exit(1) try: body = raw_content.split(NEW_LINE * 2)[1] except IndexError: body = None return [host + path], method, dict(headers), body
class Dictionary(object): def __init__(self, path, extensions=None, lowercase=False, forcedExtensions=False): self.entries = [] self.currentIndex = 0 self.condition = threading.Lock() self._extensions = [] if extensions: if isinstance(extensions, str): self._extensions.append(extensions) elif isinstance(extensions, list): self._extensions = extensions else: raise Exception('TODO: extensions type error!') self._path = path self._forcedExtensions = forcedExtensions self.lowercase = lowercase self.dictionaryFile = File(self.path) self.generate() @property def extensions(self): return self._extensions @extensions.setter def extensions(self, value): self._extensions = value @property def path(self): return self._path @path.setter def path(self, path): self._path = path @classmethod def quote(cls, string): return urllib.parse.quote(string, safe=":/~?%&+-=$") """ Dictionary.generate() behaviour Classic dirsearch wordlist: 1. If %EXT% keyword is present, append one with each extension REPLACED. 2. If the special word is no present, append line unmodified. Forced extensions wordlist (NEW): This type of wordlist processing is a mix between classic processing and DirBuster processing. 1. If %EXT% keyword is present in the line, immediately process as "classic dirsearch" (1). 2. If the line does not include the special word AND is NOT terminated by a slash, append one with each extension APPENDED (line.ext) and ONLYE ONE with a slash. 3. If the line does not include the special word and IS ALREADY terminated by slash, append line unmodified. """ def generate(self): result = [] for line in self.dictionaryFile.getLines(): # Skip comments if line.lstrip().startswith("#"): continue # No extensions if self._extensions is None: result.append(self.quote(line)) # Classic dirsearch wordlist processing (with %EXT% keyword) elif '%EXT%' in line or '%ext%' in line: for extension in self._extensions: if '%EXT%' in line: newline = line.replace('%EXT%', extension) if '%ext%' in line: newline = line.replace('%ext%', extension) quote = self.quote(newline) result.append(quote) # If forced extensions is used and the path is not a directory ... (terminated by /) # process line like a forced extension. elif self._forcedExtensions and not line.rstrip().endswith("/"): quoted = self.quote(line) for extension in self._extensions: # Why? check https://github.com/maurosoria/dirsearch/issues/70 if extension.strip() == '': result.append(quoted) else: result.append(quoted + '.' + extension) if quoted.strip() not in ['']: result.append(quoted + "/") else: # Append line unmodified. result.append(self.quote(line)) # oset library provides inserted ordered and unique collection. if self.lowercase: self.entries = list(oset(map(lambda l: l.lower(), result))) else: self.entries = list(oset(result)) del (result) def regenerate(self): self.generate(lowercase=self.lowercase) self.reset() def nextWithIndex(self, basePath=None): self.condition.acquire() try: result = self.entries[self.currentIndex] except IndexError: self.condition.release() raise StopIteration self.currentIndex = self.currentIndex + 1 currentIndex = self.currentIndex self.condition.release() return currentIndex, result def __next__(self, basePath=None): _, path = self.nextWithIndex(basePath) return path def reset(self): self.condition.acquire() self.currentIndex = 0 self.condition.release() def __len__(self): return len(self.entries)
def __init__(self, raw_file, scheme): with File(raw_file) as raw_content: self.raw_content = raw_content.read() self.scheme = scheme self.parse()