import getpass

import os

import socket

import select

import sys

import threading

from optparse import OptionParser

import paramiko

SSH_PORT = 22

DEFAULT_PORT = 4000

g_verbose = True

def handler(chan, host, port):

sock = socket.socket()

try:

sock.connect((host, port))

except Exception as e:

verbose('Forwarding request to %s:%d failed: %r' % (host, port, e))

return

verbose('Connected! Tunnel open %r -> %r -> %r' % (chan.origin_addr,

chan.getpeername(), (host, port)))

while True:

r, w, x = select.select([sock, chan], [], [])

if sock in r:

data = sock.recv(1024)

if len(data) == 0:

break

chan.send(data)

if chan in r:

data = chan.recv(1024)

if len(data) == 0:

break

sock.send(data)

chan.close()

sock.close()

verbose('Tunnel closed from %r' % (chan.origin_addr,))

def reverse_forward_tunnel(server_port, remote_host, remote_port, transport):

transport.request_port_forward('', server_port)

while True:

chan = transport.accept(1000)

if chan is None:

continue

thr = threading.Thread(target=handler, args=(chan, remote_host, remote_port))

thr.setDaemon(True)

thr.start()

def verbose(s):

if g_verbose:

print(s)

HELP = """\

def get_host_port(spec, default_port):

"parse 'hostname:22' into a host and port, with the port optional"

args = (spec.split(':', 1) + [default_port])[:2]

args[1] = int(args[1])

return args[0], args[1]

def parse_options():

global g_verbose

parser = OptionParser(usage='usage: %prog [options] <ssh-server>[:<server-port>]',

version='%prog 1.0', description=HELP)

parser.add_option('-q', '--quiet', action='store_false', dest='verbose', default=True,

help='squelch all informational output')

parser.add_option('-p', '--remote-port', action='store', type='int', dest='port',

default=DEFAULT_PORT,

help='port on server to forward (default: %d)' % DEFAULT_PORT)

parser.add_option('-u', '--user', action='store', type='string', dest='user',

default=getpass.getuser(),

help='username for SSH authentication (default: %s)' % getpass.getuser())

parser.add_option('-K', '--key', action='store', type='string', dest='keyfile',

default=None,

help='private key file to use for SSH authentication')

parser.add_option('', '--no-key', action='store_false', dest='look_for_keys', default=True,

help='don\'t look for or use a private key file')

parser.add_option('-P', '--password', action='store_true', dest='readpass', default=False,

help='read password (for key or password auth) from stdin')

parser.add_option('-r', '--remote', action='store', type='string', dest='remote', default=None, metavar='host:port',

help='remote host and port to forward to')

options, args = parser.parse_args()

if len(args) != 1:

parser.error('Incorrect number of arguments.')

if options.remote is None:

parser.error('Remote address required (-r).')

g_verbose = options.verbose

server_host, server_port = get_host_port(args[0], SSH_PORT)

remote_host, remote_port = get_host_port(options.remote, SSH_PORT)

return options, (server_host, server_port), (remote_host, remote_port)

def main():

options, server, remote = parse_options()

password = None

if options.readpass:

password = getpass.getpass('Enter SSH password: ')

client = paramiko.SSHClient()

client.load_system_host_keys()

client.set_missing_host_key_policy(paramiko.WarningPolicy())

verbose('Connecting to ssh host %s:%d ...' % (server[0], server[1]))

try:

client.connect(server[0], server[1], username=options.user, key_filename=options.keyfile,

look_for_keys=options.look_for_keys, password=password)

except Exception as e:

print('*** Failed to connect to %s:%d: %r' % (server[0], server[1], e))

sys.exit(1)

verbose('Now forwarding remote port %d to %s:%d ...' % (options.port, remote[0], remote[1]))

try:

reverse_forward_tunnel(options.port, remote[0], remote[1], client.get_transport())

except KeyboardInterrupt:

print('C-c: Port forwarding stopped.')

sys.exit(0)

if __name__ == '__main__':

main()

def ssh_command(ip, user, passwd, command, port = 22):

client.connect(ip, port, username=user, password=passwd) #连接

except Exception, e:

ssh_command('10.10.10.145', 'root', 'lovepython', 'ClientConnected', 2222)

import socket

import paramiko

import threading

import sys

host_key = paramiko.RSAKey(filename='/root/.ssh/id_rsa')

class Server(paramiko.ServerInterface):

def __init__(self):

self.event = threading.Event()

def check_channel_request(self, kind, chanid):

if kind == 'session':

return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED

def check_auth_password(self, username, password):

if (username == 'root') and (password == 'lovepython'):

return paramiko.AUTH_SUCCESSFUL

return paramiko.AUTH_FAILED

server = sys.argv[1]

ssh_port = int(sys.argv[2])

try:

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #TCP socket

#这里value设置为1，表示将SO_REUSEADDR标记为TRUE，操作系统会在服务器socket被关闭或服务器进程终止后马上释放该服务器的端口，否则操作系统会保留几分钟该端口。

sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

sock.bind((server, ssh_port)) #绑定ip和端口

sock.listen(100) #最大连接数为100

print '[+] Listening for connection ...'

client, addr = sock.accept()

except Exception, e:

print '[-] Listen failed: ' + str(e)

sys.exit(1)

print '[+] Got a connection!'

try:

bhSession = paramiko.Transport(client)

bhSession.add_server_key(host_key)

server = Server()

try:

bhSession.start_server(server=server)

except paramiko.SSHException, x:

print '[-] SSH negotiation failed'

chan = bhSession.accept(20) #设置超时值为20

print '[+] Authenticated!'

print chan.recv(1024)

chan.send("Welcome to my ssh")

while True:

try:

command = raw_input("Enter command:").strip("\n") #strip移除字符串头尾指定的字符（默认为空格）,这里是换行

if command != 'exit':

chan.send(command)

print chan.recv(1024) + '\n'

else:

chan.send('exit')

print 'exiting'

bhSession.close()

raise Exception('exit')

except KeyboardInterrupt:

bhSession.close()

except Exception, e:

print '[-] Caught exception: ' + str(e)

try:

bhSession.close()

except:

pass

sys.exit(1)