Automatic Reverse SSH Tunnel

import pty, re, os, sys, stat, signal
global pty, re, os, sys, stat, signal
global REMOTE_SSH_PORT, LOCAL_SSH_PORT, IP_PW_USR_PORT, ENABLE, SSHError, SSH

REMOTE_SSH_PORT = 1300
LOCAL_SSH_PORT = 22
IP_PW_USR_PORT = ('mycoolhost.com', 'mysecretpassword', 'rasp', 22)
#ENABLE = False
ENABLE = True


class SSHError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)

class SSH:
    def __init__(self, ip, passwd, user, port):
        self.ip = ip
        self.passwd = passwd
        self.user = user
        self.port = port

    def rev_ssh(self, local_port, remote_port):
        # ssh -f -N -T -R 1100:localhost:22 [email protected]
        (pid, f) = pty.fork()
        if pid == 0:
            os.execlp("ssh", "ssh", '-p %d' % self.port,
                      self.user + '@' + self.ip, '-f', '-N', '-T', '-R' , '%d:localhost:%d' % (remote_port, local_port))
        else:
            return (pid, f)

    def run_cmd(self, c):
        (pid, f) = pty.fork()
        if pid == 0:
            os.execlp("ssh", "ssh", '-p %d' % self.port,
                      self.user + '@' + self.ip, '-R',
                      '%d:localhost:%d' % (REMOTE_SSH_PORT, LOCAL_SSH_PORT) ,c)
        else:
            return (pid, f)

    def push_file(self, src, dst):
        (pid, f) = pty.fork()
        if pid == 0:
            os.execlp("scp", "scp", '-P %d' % self.port,
                      src, self.user + '@' + self.ip + ':' + dst)
        else:
            return (pid, f)

    def push_dir(self, src, dst):
        (pid, f) = pty.fork()
        if pid == 0:
            os.execlp("scp", "scp", '-P %d' % self.port, "-r", src,
                      self.user + '@' + self.ip + ':' + dst)
        else:
            return (pid, f)

    def _read(self, f):
        x = ''
        try:
            x = os.read(f, 1024)
        except Exception, e:
            # this always fails with io error
            pass
        return x

    def ssh_results(self, pid, f, read_after_password=True):
        output = ""
        got = self._read(f)         # check for authenticity of host request
        m = re.search("authenticity of host", got)
        if m:
            os.write(f, 'yes\n')
            # Read until we get ack
            while True:
                got = self._read(f)
                m = re.search("Permanently added", got)
                if m:
                    break
            got = self._read(f)         # check for passwd request
        m = re.search("assword:", got)
        if m:
            # send passwd
            os.write(f, self.passwd + '\n')
            # read two lines
            if read_after_password:
                tmp = self._read(f)
                tmp += self._read(f)
                m = re.search("Permission denied", tmp)
                if m:
                    raise Exception("Invalid passwd")
                # passwd was accepted
                got = tmp
            else:
                got = ''

        while got and len(got) > 0:
            output += got
            got = self._read(f)
        os.waitpid(pid, 0)
        os.close(f)
        return output

    def revssh(self, local, remote):
        (pid, f) = self.rev_ssh(local, remote)
        return self.ssh_results(pid, f, False)

    def cmd(self, c):
        (pid, f) = self.run_cmd(c)
        return self.ssh_results(pid, f)

    def push(self, src, dst):
        s = os.stat(src)
        if stat.S_ISDIR(s[stat.ST_MODE]):
            (pid, f) = self.push_dir(src, dst)
        else:
            (pid, f) = self.push_file(src, dst)
        return self.ssh_results(pid, f)

def ssh_cmd(ip, passwd, user, port, cmd):
    s = SSH(ip, passwd, user, port)
    return s.cmd(cmd)

def rev_ssh(ip, passwd, user, port, local_port=22, rem_port=1100):
    s = SSH(ip, passwd, user, port)
    return s.revssh(local_port, rem_port)

def ssh_push(ip, passwd, src, dst, user, port=22):
    s = SSH(ip, passwd, user, port)
    return s.push(src, dst)


def getSshPids():
    pids= [pid for pid in os.listdir('/proc') if pid.isdigit()]
    sshpids = []
    for pid in pids:
        try:
            cmdl =  open(os.path.join('/proc', pid, 'cmdline'), 'rb').read()
            if '\x00-R\x00' in cmdl:
                sshpids.append(pid)
        except:
            pass
    return sshpids

def killPids(sshpids):
    for pid in sshpids:
        try:
            os.kill(int(pid), signal.SIGTERM)
        except:
            pass

#############################################################################
#                        Programa Principal                                 #
#############################################################################

ssh_pids = getSshPids()

# Desabilitando ssh reverso
if ssh_pids and not ENABLE:
    killPids(ssh_pids)
    log.info('Disabled')

# Criando ssh reverso
elif not ssh_pids and ENABLE:
    # estabelece primeira conexao
    log.info('enabled')
    reg(69)
    ret = ssh_cmd(*IP_PW_USR_PORT, cmd='ls; time sleep 300;')
    log.info(ret)
    # estabelece conexao abrindo porta reversa
    #cfgs = IP_PW_USR_PORT + (LOCAL_SSH_PORT, REMOTE_SSH_PORT)
    #ret = rev_ssh(*cfgs)
    log.info('closed')

else:
    log.info('No action')