def interactive(idx=0, DongleClass=RfCat, intro=''): global d import rflib.chipcon_nic as rfnic import atexit d = DongleClass(idx=idx) d.setModeIDLE() # this puts the dongle into Idle mode atexit.register(cleanupInteractiveAtExit) gbls = globals() lcls = locals() try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) print intro ipsh.mainloop(intro) except ImportError, e: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop(intro) except ImportError, e: print e shell = code.InteractiveConsole(gbls) shell.interact(intro)
def dbg_interact(lcls, gbls): intro = "Let's interact!" try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) print(intro) ipsh.mainloop() except ImportError as e: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! print(intro) ipsh.mainloop() except ImportError as e: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! print(intro) ipsh.mainloop() except ImportError as e: print(e) shell = code.InteractiveConsole(gbls) print(intro) shell.interact()
def dbg_interact(lcls, gbls, intro=None): shelltype = STYPE_NONE if intro is None: intro = "Let's interact!" print(intro) try: from IPython import embed shelltype = STYPE_IPYTHON_NEW except ImportError as e: try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) shelltype = STYPE_IPYTHON except ImportError as e: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! shelltype = STYPE_IPYTHON except ImportError as e: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! shelltype = STYPE_IPYTHON except ImportError as e: print(e) shell = code.InteractiveConsole(gbls) shelltype = STYPE_IPYTHON if shelltype == STYPE_IPYTHON_NEW: globals().update(gbls) locals().update(lcls) embed() elif shelltype == STYPE_IPYTHON: ipsh.mainloop() elif shelltype == STYPE_CODE_INTERACT: shell.interact() else: print("SORRY, NO INTERACTIVE OPTIONS AVAILABLE!! wtfo?")
def main(): os.environ.setdefault("DJANGO_SETTINGS_MODULE", "cto_tree.settings") try: if len(sys.argv) >= 2 and sys.argv[1] == '--plain': raise ImportError user_ns = locals() if has_ushell: app = UmengIPythonApp.instance() app.initialize() app.shell.user_ns.update(user_ns) sys.exit(app.start()) else: from IPython.terminal.interactiveshell import TerminalInteractiveShell shell = TerminalInteractiveShell(user_ns=user_ns) shell.mainloop() except ImportError: import code shell = code.InteractiveConsole(locals=locals()) shell.interact()
def __call__(self): from IPython.terminal.prompts import Prompts, Token from IPython.terminal.interactiveshell import TerminalInteractiveShell token = self._token class RFQuackShellPrompts(Prompts): def in_prompt_tokens(self, cli=None): return [(Token, token), (Token.Prompt, '> ')] TerminalInteractiveShell.prompts_class = RFQuackShellPrompts shell = TerminalInteractiveShell() shell.autocall = 2 shell.show_banner(self._banner) q = RFQuack(self._transport, shell) q.idle() shell.push(dict(q=q, rfquack_pb2=rfquack_pb2)) shell.mainloop()
def interactive(idx=0, DongleClass=RfCat, intro=''): global d import rflib.chipcon_nic as rfnic import atexit d = DongleClass(idx=idx) d.setModeRX() # this puts the dongle into receive mode atexit.register(cleanupInteractiveAtExit) gbls = globals() lcls = locals() try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) print intro ipsh.mainloop(intro) except ImportError, e: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop(intro) except ImportError, e: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop(intro) except ImportError, e: print e shell = code.InteractiveConsole(gbls) shell.interact(intro)
def main(): url = sys.argv[1] context['url'] = url pkg = app.dispatch_url(url) context['pkg'] = pkg for item in pkg.to_dict().items(): print '{} = {}'.format(*item) def prepare_readline(): import os import readline import atexit readline.parse_and_bind('tab: complete') histfile = os.path.expanduser("~/.daenerys_history") try: readline.read_history_file(histfile) except IOError: pass def savehist(histfile): readline.write_history_file(histfile) atexit.register(savehist, histfile) del atexit try: from IPython.terminal.interactiveshell import TerminalInteractiveShell shell = TerminalInteractiveShell(user_ns=context) shell.mainloop() except ImportError: import code shell = code.InteractiveConsole(locals=context) shell.runcode(prepare_readline.__code__) shell.interact()
def interactive(port='/dev/ttyACM0', InterfaceClass=CanInterface, intro='', load_filename=None): global c import atexit c = InterfaceClass(port=port, load_filename=load_filename) atexit.register(cleanupInteractiveAtExit) gbls = globals() lcls = locals() try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) print intro ipsh.mainloop(intro) except ImportError, e: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop(intro) except ImportError, e: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop(intro) except ImportError, e: print e shell = code.InteractiveConsole(gbls) shell.interact(intro)
def interactive(idx=0, DongleClass=RfCat, intro=''): global d import rflib.chipcon_nic as rfnic import atexit d = DongleClass(idx=idx) d.setModeRX() # this puts the dongle into receive mode atexit.register(cleanupInteractiveAtExit) gbls = globals() lcls = locals() shellfailed = False try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! print(intro) ipsh.mainloop() except ImportError as e: shellfailed = True if shellfailed: try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) print(intro) ipsh.mainloop() except ImportError as e: shellfailed = True if shellfailed: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! print(intro) ipsh.mainloop() except ImportError as e: shellfailed = True if shellfailed: print("falling back to straight Python... (%r)" % e) shell = code.InteractiveConsole(gbls) print(intro) shell.interact()
def interact(lcls, gbls): shellexception = None try: from IPython.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop() except ImportError as e: shellexception = e if shellexception: try: import IPython.Shell ipsh = IPython.Shell.IPShell(argv=[''], user_ns=lcls, user_global_ns=gbls) ipsh.mainloop() except ImportError as e: shellexception = e if shellexception: try: from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell ipsh = TerminalInteractiveShell() ipsh.user_global_ns.update(gbls) ipsh.user_global_ns.update(lcls) ipsh.autocall = 2 # don't require parenthesis around *everything*. be smart! ipsh.mainloop() except ImportError as e: shellexception = e if shellexception: print("falling back to straight Python... (%r)" % shellexception) shell = code.InteractiveConsole(gbls) shell.interact()
def main(): # pylint: disable=too-many-statements # Set up a simple argument parser. parser = binhoArgumentParser( description="Convenience shell for working with Binho host adapters.") parser.add_argument( "-e", "--exec", metavar="code", type=str, help="Executes the provided code as though it were passed " + "to a Binho host adapter shell, and then terminates.", dest="code", ) parser.add_argument( "-E", "--pre-exec", metavar="code", type=str, help="Executes the provided code as though it were passed " + "to a Binho host adapter shell, but does not explicitly terminate.", dest="prelude", ) parser.add_argument( "-f", "--file", metavar="file", type=str, help="Executes the relevant file before starting the given shell.", ) parser.add_argument( "-M", "--automagic", dest="automagic", action="store_true", help="Enable automagic, so lazy developers don't have to type %%.", ) parser.add_argument( "-P", "--avoid-parens", dest="avoidparens", action="store_true", help= "Enable full autocall, so bare methods are executed, rather than printed.", ) parser.add_argument( "-A", "--autoreload", dest="autoreload", action="store_true", help= "Attempts to reload python modules automatically as they change; so current objects import new \ functionality. This may sometimes break your shell.", ) parser.add_argument( "-S", "--singleton", dest="singleton", action="store_true", help= "Connect via a singleton that persists across device reconnects. Note: device state is not preserved.", ) args = parser.parse_args() if args.singleton: connect_function = parser.get_singleton_for_specified_device else: connect_function = parser.find_specified_device binho = connect_function() if binho.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(binho.productName, binho.commPort)) sys.exit(errno.ENODEV) elif binho.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(binho.productName, binho.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) # Break into IPython for the shell. if not args.code: print( "Spawning an IPython shell for easy access to your Binho host adapter." ) print( "Like normal python, you can use help(object) to get help for that object.\n" ) print( "Try help(binho.gpio) to see the documentation for the Binho host adapter GPIO;" ) print( "try dir(binho) to see a list of properties on the Binho Host Adapter object, and" ) print( "try binho.available_interfaces() and binho.available_programmers() to see" ) print( "the interfaces you can work with, and the programmers you can create.\n" ) singleton_text = "singleton " if args.singleton else "" print( "A Binho host adapter {}object has been created for you as 'binho'. Have fun!\n" .format(singleton_text)) # Create a new shell, and give it access to our created Binho object. shell = TerminalInteractiveShell() shell.push("binho") # Create nice aliases for our primary interfaces. # pylint: disable=unused-variable i2c = binho.i2c spi = binho.spi dac = binho.dac adc = binho.adc oneWire = binho.oneWire # uart = binho.uart gpio = binho.gpio # shell.push(('i2c', 'spi', 'adc', 'uart', 'gpio',)) shell.push(("i2c", "spi", "gpio", "dac", "adc", "oneWire")) # pylint: enable=unused-variable # Make the autoreload extension available. shell.extension_manager.load_extension("autoreload") # Add our magic commands, to make execution more 'fun'. shell.register_magics(binhoShellMagics) # If the user has requested automagic, let them have their automagic. if args.automagic: shell.automagic = True # If we're in avoid parenthesis mode if args.avoidparens: shell.autocall = 2 # If we're using autoreload, enable that. if args.autoreload: shell.run_cell("%autoreload 2") print( "Heads up: you've enabled autoreload. Things make break in unexpected ways as your code changes." ) print( "You can fix this by adjusting your expectations regarding breakage.\n" ) # Handle any inline execution requested. if args.code or args.prelude: # Replace any ;'s with newlines, so we can execute more than one # statement. code = args.code or args.prelude code = re.sub(r";\s*", "\n", code) lines = code.split("\n") # If we're in execute-and-quit mode, do so. for line in lines: shell.run_cell(line, shell_futures=True) # If we're to exit after running the relevant code, do so. if args.code: sys.exit(0) # If we have a file to execute, execute it. if args.file: shell.safe_execfile_ipy(args.file, shell_futures=True, raise_exceptions=True) # Run the shell itself. shell.connect_function = connect_function shell.mainloop() # close the connection to the device binho.close()
def console(**kwargs): """ An REPL fully configured for experimentation. usage: blueberrypy console [options] options: -e ENVIRONMENT, --environment=ENVIRONMENT apply the given config environment -C ENV_VAR_NAME, --env-var ENV_VAR_NAME add the given config from environment variable name [default: BLUEBERRYPY_CONFIG] --ipython use IPython shell instead of Python one -h, --help show this help message and exit """ banner = """ ***************************************************************************** * If the configuration file you specified contains a [sqlalchemy_engine*] * * section, a default SQLAlchemy engine and session should have been created * * for you automatically already. * ***************************************************************************** """ environment = kwargs.get("environment") config_dir = kwargs.get("config_dir") environment and cherrypy.config.update({"environment": environment}) configuration = BlueberryPyConfiguration( config_dir=config_dir, environment=environment, env_var_name=kwargs.get('env_var'), ) use_ipython = kwargs.get("ipython", False) package_name = shell.get_package_name(configuration) if use_ipython: try: from IPython.terminal.interactiveshell import TerminalInteractiveShell except ImportError as e: print(e) print("""Cannot import iPython. Did you install it?""") return try: app_package = import_module(package_name) except ImportError as e: print(e) app_package = None repl = TerminalInteractiveShell( user_ns=shell.get_user_namespace(configuration), user_module=app_package, display_completions='multicolumn', # oldstyle is 'readlinelike' mouse_support=True, space_for_menu=10, # reserve N lines for the completion menu ) repl.show_banner(banner) repl.mainloop() else: try: import readline except ImportError as e: print(e) else: import rlcompleter sys.ps1 = "[%s]>>> " % package_name sys.ps2 = "[%s]... " % package_name ns = shell.get_user_namespace(configuration, include_pkg=True) repl = InteractiveConsole(locals=ns) repl.prompt = package_name repl.interact(banner)
def main(): import optparse parser = optparse.OptionParser() # Shall we fuzz the request, response, or both? # Set via optparse in main global sr_request # search/replace tuple for requests - (True, [search, replace]) where true means to use regex global sr_response # search/replace tuple for responses - (True, [search, replace]) where true means to use regex global fuzz_request global fuzz_response # Other module-wide variables global debug global term global logger global fwdr parser.add_option("-l", "--local-addr", dest="local_addr", default="127.0.0.1", help="Local address to bind to") parser.add_option("-p", "--local-port", type="int", dest="local_port", default=1234, help="Local port to bind to") parser.add_option("-r", "--remote-addr", dest="remote_addr", help="Remote address to bind to") parser.add_option("-P", "--remote-port", type="int", dest="remote_port", default=80, help="Remote port to bind to") parser.add_option( "--search-request", dest="search_request", default="", help="String that if found will be replaced by --replace-request's value", ) parser.add_option( "--replace-request", dest="replace_request", default="", help="String to replace the value of --search-request" ) parser.add_option( "--search-response", dest="search_response", default="", help="String that if found will be replaced by --replace-request's value", ) parser.add_option( "--replace-response", dest="replace_response", default="", help="String to replace the value of --search-request", ) parser.add_option( "--regex-request", action="store_true", dest="request_use_regex", help="Requests: Use regular expressions for search and replace instead of string constants", ) parser.add_option( "--regex-response", action="store_true", dest="response_use_regex", help="Responses: Use regular expressions for search and replace instead of string constants", ) parser.add_option( "--fuzz-request", action="store_true", dest="fuzz_request", help="Fuzz the request which the proxy gets from the connecting client \ prior to sending it to the remote host", ) parser.add_option( "--fuzz-response", action="store_true", dest="fuzz_response", help="Fuzz the response which the proxy gets from the remote host prior \ to sending it to the conecting client", ) parser.add_option( "-i", "--run-info", dest="run_info", default="", help="Additional information string to add to database run_info entry", ) parser.add_option( "-d", "--debug", type="int", dest="debug", default=0, help="Debug level (0-5, 0: No debugging; 1: Simple conneciton \ information; 2: Simple data information; 3: Listener data display; 4: \ Sender data display; 5: All data display)", ) (options, args) = parser.parse_args() if not options.remote_addr or not options.remote_port: parser.print_help() exit(1) # Validate options for search/replace if (options.search_request and not options.replace_request) or ( options.replace_request and not options.search_request ): print >> sys.stderr, "Both --search-request and --replace-request must be provided together" exit(1) if (options.search_response and not options.replace_response) or ( options.replace_response and not options.search_response ): print >> sys.stderr, "Both --search-response and --replace-response must be provided together" exit(1) # Setup a TerminalController for formatted output term = TerminalController() # Print the current run information print ( term.render( """\nSetting up asynch. TCP proxy with the following settings: ${GREEN}Local binding Address: %s Local binding Port: %s${NORMAL} ${RED}Remote host address: %s Remote host port: %s${NORMAL} """ ) % (options.local_addr, options.local_port, options.remote_addr, options.remote_port) ) # Set the debug value debug = options.debug # If run info was passed in on the command line, use that for the run_info table # additional info field (It will have what's being fuzzed prepended to it as well) run_additional_info = options.run_info # Print the selected debug value if debug > 0: if debug == 1: print (" Debug: Level 1 (Show simple connection information)") elif debug == 2: print (" Debug: Level 2 (Show simple data information, such as the size of sent/received messages)") elif debug == 3: print (" Debug: Level 3 (Show listener data and size of sent/received messages)") elif debug == 4: print (" Debug: Level 4 (Show sender data and size of sent/received messages)") elif debug == 5: print ( " Debug: Level 5 (Show all possible information, including the size of sent/received messages, and their data for listener and sender)" ) print ("") # Display and setup search/replace things if options.search_request and options.replace_request: sr_request = [ None, options.search_request.decode("string-escape"), options.replace_request.decode("string-escape"), ] # Check if we want to use regex instead of string constants if options.request_use_regex: # Use regex instead of string replace print ( term.render( "Running regex search/replace on ${BOLD}REQUESTS${NORMAL} with regex: 's/%s/%s'" % (sr_request[1], sr_request[2]) ) ) sr_request[0] = True else: print ( term.render( "Running string search/replace on ${BOLD}REQUESTS${NORMAL} with search/replace: 's/%s/%s'" % (sr_request[1], sr_request[2]) ) ) sr_request[0] = False else: sr_request = None if options.search_response and options.replace_response: sr_response = [ None, options.search_response.decode("string-escape"), options.replace_response.decode("string-escape"), ] # Check if we want to use regex instead of string constants if options.response_use_regex: print ( term.render( "Running regex search/replace on ${BOLD}RESPONSES${NORMAL} with regex: 's/%s/%s'" % (sr_response[1], sr_response[2]) ) ) sr_response[0] = True else: print ( term.render( "Running string search/replace on ${BOLD}RESPONSES${NORMAL} with search/replace: 's/%s/%s'" % (sr_response[1], sr_response[2]) ) ) sr_response[0] = False else: sr_response = None # Setup which to fuzz - request, response, neither, both? if options.fuzz_request: fuzz_request = options.fuzz_request run_additional_info = "Fuzzing REQUESTS; " + run_additional_info print (term.render("Fuzzing ${BOLD}REQUESTS${NORMAL}")) else: fuzz_request = False if options.fuzz_response: fuzz_response = options.fuzz_response run_additional_info = "Fuzzing RESPONSES; " + run_additional_info print (term.render("Fuzzing ${BOLD}RESPONSES${NORMAL}")) else: fuzz_response = False if not (options.fuzz_response or options.fuzz_request): run_additional_info = "Fuzzing NONE; " + run_additional_info print ( term.render( "Fuzzing ${BOLD}<NOTHING>${NORMAL} (Maybe you wanted ${BOLD}--fuzz-request or --fuzz-response${NORMAL}?)" ) ) if fuzz_request and fuzz_response: print ( term.render( "${YELLOW}\nWARNING! WARNING!\n${BOLD}Fuzzing BOTH the request and response is probably a bad idea, ensure this is what you want to do!${NORMAL}${YELLOW}\nWARNING! WARNING!\n${NORMAL}" ) ) # host, db, username, passwd if logging_enabled: logger = postgresLogger("postgreshost", "dbname", "dbuser", "dbpass") logger.log_run_info("CompanyName", "ProjectName-v1.2.3", run_additional_info) # create object that spawns reciever/sender pairs upon connection fwdr = forwarder(options.local_addr, options.local_port, options.remote_addr, options.remote_port) print ("Listener running...") # asyncore.loop() # A quick hack to be able to control fuzz on/off while running # separate asyncore.loop into its own thread so we can have terminal control asyncThread = Thread(target=asyncore.loop) asyncThread.start() # start a console (ipython) from IPython.terminal.interactiveshell import TerminalInteractiveShell shell = TerminalInteractiveShell(user_ns=globals()) shell.mainloop() # cleanup otherwise thread wont die and program hangs fwdr.close() # asyncore.close_all() asyncThread._Thread__stop()
def main(): # Set up a simple argument parser. parser = GreatFETArgumentParser( description="Convenience shell for working with GreatFET devices.") parser.add_argument( '-e', '--exec', metavar="code", type=str, help="Executes the provided code as though it were passed " + "to a greatfet shell, and then terminates.", dest="code") parser.add_argument( '-E', '--pre-exec', metavar="code", type=str, help="Executes the provided code as though it were passed " + "to a greatfet shell, but does not explicitly terminate.", dest="prelude") parser.add_argument( '-f', '--file', metavar="file", type=str, help="Executes the relevant file before starting the given shell.") parser.add_argument( '-M', '--automagic', dest="automagic", action='store_true', help="Enable automagic, so lazy developers don't have to type %%.") parser.add_argument( '-P', '--avoid-parens', dest="avoidparens", action='store_true', help= "Enable full autocall, so bare methods are executed, rather than printed." ) parser.add_argument( '-A', '--autoreload', dest="autoreload", action='store_true', help= "Attempts to reload python modules automatically as they change; so current objects import new functionality. This may sometimes break your shell." ) parser.add_argument( '-S', '--singleton', dest="singleton", action='store_true', help= "Connect via a singleton that persists across device reconnects. Note: device state is not preserved." ) args = parser.parse_args() if args.singleton: connect_function = parser.get_singleton_for_specified_device else: connect_function = parser.find_specified_device gf = connect_function() # Break into IPython for the shell. if not args.code: print( "Spawning an IPython shell for easy access to your GreatFET board." ) print( "Like normal python, you can use help(object) to get help for that object.\n" ) print( "Try help(gf.gpio) to see the documentation for the GreatFET GPIO;" ) print( "try dir(gf) to see a list of properties on the GreatFET object, and" ) print( "try gf.available_interfaces() and gf.available_programmers() to see" ) print( "the interfaces you can work with, and the programmers you can create.\n" ) print( "This GreatFET shell is *magical*. Try some of our IPython magics:\n" ) print("\t %dmesg -- prints the GreatFET's debug ring (log)") print("\t %reconnect -- tries to reconnect to the current GreatFET") print( "\t %makeflash -- when run from a firmware build dir, builds and flashes your GreatFET" ) print( "\t %reload -- tries to reload your host python code; useful with $PYTHONPATH" ) print( "\t %refet -- (not %reset) resets and reconnects to the current GreatFET" ) print("\t [hey, %reset was taken!]\n\n") singleton_text = "singleton " if args.singleton else "" print( "A GreatFET {}object has been created for you as 'gf'. Have fun!\n" .format(singleton_text)) # Create a new shell, and give it access to our created GreatFET object. shell = TerminalInteractiveShell() shell.push('gf') # Create nice aliases for our primary interfaces. i2c = gf.i2c spi = gf.spi adc = gf.adc uart = gf.uart gpio = gf.gpio shell.push(( 'i2c', 'spi', 'adc', 'uart', 'gpio', )) # Make the autoreload extension available. shell.extension_manager.load_extension('autoreload') # Add our magic commands, to make execution more 'fun'. shell.register_magics(GreatFETShellMagics) # If the user has requested automagic, let them have their automagic. if args.automagic: shell.automagic = True # If we're in avoid parenthesis mode if args.avoidparens: shell.autocall = 2 # If we're using autoreload, enable that. if args.autoreload: shell.run_cell('%autoreload 2') print( "Heads up: you've enabled autoreload. Things make break in unexpected ways as your code changes." ) print( "You can fix this by adjusting your expectations regarding breakage.\n" ) # Handle any inline execution requested. if args.code or args.prelude: # Replace any ;'s with newlines, so we can execute more than one statement. code = args.code or args.prelude code = re.sub(r";\s*", "\n", code) lines = code.split("\n") # If we're in execute-and-quit mode, do so. for line in lines: shell.run_cell(line, shell_futures=True) # If we're to exit after running the relevant code, do so. if args.code: sys.exit(0) # If we have a file to execute, execute it. if args.file: shell.safe_execfile_ipy(args.file, shell_futures=True, raise_exceptions=True) # Run the shell itself. shell.connect_function = connect_function shell.mainloop()
def main(): import optparse parser = optparse.OptionParser() # Shall we fuzz the request, response, or both? # Set via optparse in main global sr_request # search/replace tuple for requests - (True, [search, replace]) where true means to use regex global sr_response # search/replace tuple for responses - (True, [search, replace]) where true means to use regex global fuzz_request global fuzz_response # Other module-wide variables global debug global term global logger global fwdr parser.add_option( '-l','--local-addr', dest='local_addr',default='127.0.0.1', help='Local address to bind to') parser.add_option( '-p','--local-port', type='int',dest='local_port',default=1234, help='Local port to bind to') parser.add_option( '-r','--remote-addr',dest='remote_addr', help='Remote address to bind to') parser.add_option( '-P','--remote-port', type='int',dest='remote_port',default=80, help='Remote port to bind to') parser.add_option( '--search-request', dest='search_request',default='', help='String that if found will be replaced by --replace-request\'s value') parser.add_option( '--replace-request', dest='replace_request',default='', help='String to replace the value of --search-request') parser.add_option( '--search-response', dest='search_response',default='', help='String that if found will be replaced by --replace-request\'s value') parser.add_option( '--replace-response', dest='replace_response',default='', help='String to replace the value of --search-request') parser.add_option( '--regex-request', action='store_true' ,dest='request_use_regex', help='Requests: Use regular expressions for search and replace instead of string constants') parser.add_option( '--regex-response', action='store_true' ,dest='response_use_regex', help='Responses: Use regular expressions for search and replace instead of string constants') parser.add_option( '--fuzz-request', action='store_true' ,dest='fuzz_request', help='Fuzz the request which the proxy gets from the connecting client \ prior to sending it to the remote host') parser.add_option( '--fuzz-response', action='store_true' ,dest='fuzz_response', help='Fuzz the response which the proxy gets from the remote host prior \ to sending it to the conecting client') parser.add_option( '-i','--run-info', dest='run_info',default='', help='Additional information string to add to database run_info entry') parser.add_option( '-d','--debug', type='int',dest='debug',default=0, help='Debug level (0-5, 0: No debugging; 1: Simple conneciton \ information; 2: Simple data information; 3: Listener data display; 4: \ Sender data display; 5: All data display)') (options, args) = parser.parse_args() if not options.remote_addr or not options.remote_port: parser.print_help() exit(1) # Validate options for search/replace if (options.search_request and not options.replace_request) or (options.replace_request and not options.search_request): print >>sys.stderr, "Both --search-request and --replace-request must be provided together" exit(1) if (options.search_response and not options.replace_response) or (options.replace_response and not options.search_response): print >>sys.stderr, "Both --search-response and --replace-response must be provided together" exit(1) # Setup a TerminalController for formatted output term = TerminalController() # Print the current run information print(term.render("""\nSetting up asynch. TCP proxy with the following settings: ${GREEN}Local binding Address: %s Local binding Port: %s${NORMAL} ${RED}Remote host address: %s Remote host port: %s${NORMAL} """) % (options.local_addr, options.local_port, options.remote_addr, options.remote_port)) # Set the debug value debug = options.debug # If run info was passed in on the command line, use that for the run_info table # additional info field (It will have what's being fuzzed prepended to it as well) run_additional_info = options.run_info # Print the selected debug value if(debug > 0): if(debug == 1): print(" Debug: Level 1 (Show simple connection information)") elif(debug == 2): print(" Debug: Level 2 (Show simple data information, such as the size of sent/received messages)") elif(debug == 3): print(" Debug: Level 3 (Show listener data and size of sent/received messages)") elif(debug == 4): print(" Debug: Level 4 (Show sender data and size of sent/received messages)") elif(debug == 5): print(" Debug: Level 5 (Show all possible information, including the size of sent/received messages, and their data for listener and sender)") print("") # Display and setup search/replace things if options.search_request and options.replace_request: sr_request = [None, options.search_request.decode('string-escape'), options.replace_request.decode('string-escape')] # Check if we want to use regex instead of string constants if options.request_use_regex: # Use regex instead of string replace print(term.render("Running regex search/replace on ${BOLD}REQUESTS${NORMAL} with regex: 's/%s/%s'" % (sr_request[1], sr_request[2]))) sr_request[0] = True else: print(term.render("Running string search/replace on ${BOLD}REQUESTS${NORMAL} with search/replace: 's/%s/%s'" % (sr_request[1], sr_request[2]))) sr_request[0] = False else: sr_request = None if options.search_response and options.replace_response: sr_response = [None, options.search_response.decode('string-escape'), options.replace_response.decode('string-escape')] # Check if we want to use regex instead of string constants if options.response_use_regex: print(term.render("Running regex search/replace on ${BOLD}RESPONSES${NORMAL} with regex: 's/%s/%s'" % (sr_response[1], sr_response[2]))) sr_response[0] = True else: print(term.render("Running string search/replace on ${BOLD}RESPONSES${NORMAL} with search/replace: 's/%s/%s'" % (sr_response[1], sr_response[2]))) sr_response[0] = False else: sr_response = None # Setup which to fuzz - request, response, neither, both? if(options.fuzz_request): fuzz_request = options.fuzz_request run_additional_info = "Fuzzing REQUESTS; " + run_additional_info print(term.render("Fuzzing ${BOLD}REQUESTS${NORMAL}")) else: fuzz_request = False if(options.fuzz_response): fuzz_response = options.fuzz_response run_additional_info = "Fuzzing RESPONSES; " + run_additional_info print(term.render("Fuzzing ${BOLD}RESPONSES${NORMAL}")) else: fuzz_response = False if(not(options.fuzz_response or options.fuzz_request)): run_additional_info = "Fuzzing NONE; " + run_additional_info print(term.render("Fuzzing ${BOLD}<NOTHING>${NORMAL} (Maybe you wanted ${BOLD}--fuzz-request or --fuzz-response${NORMAL}?)")) if(fuzz_request and fuzz_response): print(term.render("${YELLOW}\nWARNING! WARNING!\n${BOLD}Fuzzing BOTH the request and response is probably a bad idea, ensure this is what you want to do!${NORMAL}${YELLOW}\nWARNING! WARNING!\n${NORMAL}")) # host, db, username, passwd if logging_enabled: logger = postgresLogger("postgreshost", "dbname", "dbuser", "dbpass") logger.log_run_info("CompanyName", "ProjectName-v1.2.3", run_additional_info) # create object that spawns reciever/sender pairs upon connection fwdr = forwarder(options.local_addr,options.local_port,options.remote_addr,options.remote_port) print("Listener running...") #asyncore.loop() # A quick hack to be able to control fuzz on/off while running # separate asyncore.loop into its own thread so we can have terminal control asyncThread = Thread(target=asyncore.loop) asyncThread.start() # start a console (ipython) from IPython.terminal.interactiveshell import TerminalInteractiveShell shell = TerminalInteractiveShell(user_ns=globals()) shell.mainloop() # cleanup otherwise thread wont die and program hangs fwdr.close() #asyncore.close_all() asyncThread._Thread__stop()