Beispiel #1
0
 def __init__(self, email_admin=None, url_doc=None, url_css=None, url_opensearch=None,
              file_favicon=None,
              encoding=default_encoding, base_url=default_base_url,
              bucket_size=default_bucket_size,
              whitelist=default_whitelist, edns_size=default_edns_size,
              handle_wk_files=default_handle_wk_files,
              google_code=None, description=None, description_html=None, 
              forbidden_suffixes=[]):
     self.resolver = Resolver.Resolver(edns_payload=edns_size)
     self.buckets = {}
     self.base_url = base_url
     self.whitelist = whitelist
     self.handle_wk_files = handle_wk_files
     self.email_admin = email_admin
     self.url_doc = url_doc
     self.url_css = url_css
     self.url_opensearch = url_opensearch
     if file_favicon:
         self.favicon = open(file_favicon).read()
     else:
         self.favicon = None
     self.encoding = encoding
     self.bucket_size = default_bucket_size
     self.google_code = google_code
     self.description = description
     self.description_html = description_html
     self.forbidden_suffixes = []
     for suffix in forbidden_suffixes:
         if suffix != '':
             if not suffix.endswith('.'):
                 suffix += '.'
             self.forbidden_suffixes.append(suffix)
     self.resolver.reset()
def main():
    args = ArgumentParser.ArgumentParser()
    parser = Resolver.Resolver(args.ipaddr, args.verbosity)

    resolved_ips = parser.getResolvedIps()
    if args.output:
        outfile = args.output
    else:
        outfile = False

    try:

        if (isinstance(resolved_ips, list)):

            if not resolved_ips:
                sys.stderr.write(
                    '[-] Could not resolve any ips... Exiting...\n\n')
                exit()
            ipsTraced = []
            locations = []
            lattitudes = []
            longtitudes = []
            orgs = []
            print('\n\n[*] Resolved Ips: {0}'.format(len(resolved_ips)))
            for ip in resolved_ips:
                loc, lat, lon, org = printResults(ip, args.verbosity,
                                                  args.accurate, outfile)
                if args.visual:
                    ipsTraced.append(ip)
                    locations.append(loc)
                    lattitudes.append(lat)
                    longtitudes.append(lon)
                    orgs.append(org)
            if args.visual:
                visualcreator.create(ipsTraced, locations, lattitudes,
                                     longtitudes, orgs, args.visual,
                                     args.mobile)

        else:
            if not resolved_ips:
                sys.stderr.write(
                    '[-] Could not resolve any ips... Exiting...\n\n')
                exit()

            print('\n\nResolved Ip: {0}'.format(resolved_ips))
            loc, lat, lon, org = printResults(resolved_ips, args.verbosity,
                                              args.accurate, outfile)
            if args.visual:
                visualcreator.create(resolved_ips, loc, lat, lon, org,
                                     args.visual, args.mobile)

        print('\n\n')
        printBannerPadding()
        print('\n\n')
        print('[+]  Trace Completed Successfully!')
    finally:
        if outfile:
            outfile.close()
Beispiel #3
0
    def run(cls, source: str) -> None:
        scanner = Scanner.Scanner(source)
        tokens = scanner.scanTokens()
        parser = Parser.Parser(tokens)
        statements = parser.parse()

        if LoxError.hadError:
            return

        resolver = Resolver.Resolver(cls.interpreter)
        resolver.resolve(statements)

        if LoxError.hadError:
            return

        cls.interpreter.interpret(statements)
Beispiel #4
0
def run(source: str) -> None:
    scanner = Scanner.Scanner(source)
    tokens = scanner.scan_tokens()

    _parser = Parser.Parser(tokens)
    statements = _parser.parse()

    if had_error:
        return

    resolver = Resolver.Resolver(interpreter)
    resolver.resolve(statements)

    if had_error:
        return

    interpreter.interpret(statements)