Python:跳板机审计服务器

import base64
from binascii import hexlify
import getpass
import os
import select
import socket
import sys
import threading
import time
import traceback

import paramiko
import interactive

#define host   
print("\033[34;1mWelcome zhengshun‘s Fort Machine\nThere have those machines:\033[0m")
dictroy = {
        "vc-app01":"192.168.101.131",
        "vc-app02":"192.168.101.130",
	"vc-app03":"192.168.101.132"
}
while 1:
	try:
		print(‘‘)
		for k,v in dictroy.items():
			print k,v
		print(‘‘)
		hostname = raw_input(‘please input IP:‘)
		if hostname == ‘‘:continue
		elif hostname == ‘exit‘:break
		elif hostname == ‘quit‘:break
		
		def agent_auth(transport, username):
		    """
		    Attempt to authenticate to the given transport using any of the private
		    keys available from an SSH agent.
		    """
		    
		    agent = paramiko.Agent()
		    agent_keys = agent.get_keys()
		    if len(agent_keys) == 0:
		        return
		        
		    for key in agent_keys:
		        print ‘Trying ssh-agent key %s‘ % hexlify(key.get_fingerprint()),
		        try:
		            transport.auth_publickey(username, key)
		            print ‘... success!‘
		            return
		        except paramiko.SSHException:
		            print ‘... nope.‘
		
		
		def manual_auth(username, hostname):
		    default_auth = ‘p‘
		    auth = ‘p‘
		    if len(auth) == 0:
		        auth = default_auth
		
		    if auth == ‘r‘:
		        default_path = os.path.join(os.environ[‘HOME‘], ‘.ssh‘, ‘id_rsa‘)
		        path = raw_input(‘RSA key [%s]: ‘ % default_path)
		        if len(path) == 0:
		            path = default_path
		        try:
		            key = paramiko.RSAKey.from_private_key_file(path)
		        except paramiko.PasswordRequiredException:
		            password = getpass.getpass(‘RSA key password: ‘)
		            key = paramiko.RSAKey.from_private_key_file(path, password)
		        t.auth_publickey(username, key)
		    elif auth == ‘d‘:
		        default_path = os.path.join(os.environ[‘HOME‘], ‘.ssh‘, ‘id_dsa‘)
		        path = raw_input(‘DSS key [%s]: ‘ % default_path)
		        if len(path) == 0:
		            path = default_path
		        try:
		            key = paramiko.DSSKey.from_private_key_file(path)
		        except paramiko.PasswordRequiredException:
		            password = getpass.getpass(‘DSS key password: ‘)
		            key = paramiko.DSSKey.from_private_key_file(path, password)
		        t.auth_publickey(username, key)
		    else:
		        pw = ‘123456‘
		        t.auth_password(username, pw)
		
		
		# setup logging
		paramiko.util.log_to_file(‘demo.log‘)
		
		username = ‘root‘
		if len(hostname) == 0:
		    print ‘*** Hostname required.‘
		    sys.exit(1)
		port = 22
		if hostname.find(‘:‘) >= 0:
		    hostname, portstr = hostname.split(‘:‘)
		    port = int(portstr)
		
		# now connect
		try:
		    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		    sock.connect((hostname, port))
		except:
		    print(‘\033[31;1minvalid value\033[0m‘)
		    continue
		#except Exception, e:
		#    print ‘*** Connect failed: ‘ + str(e)
		#    traceback.print_exc()
		#    sys.exit(1)
		
		try:
		    t = paramiko.Transport(sock)
		    try:
		        t.start_client()
		    except paramiko.SSHException:
		        print ‘*** SSH negotiation failed.‘
		        sys.exit(1)
		
		    try:
		        keys = paramiko.util.load_host_keys(os.path.expanduser(‘~/.ssh/known_hosts‘))
		    except IOError:
		        try:
		            keys = paramiko.util.load_host_keys(os.path.expanduser(‘~/ssh/known_hosts‘))
		        except IOError:
		            print ‘*** Unable to open host keys file‘
		            keys = {}
		
		    # check server‘s host key -- this is important.
		    key = t.get_remote_server_key()
		    if not keys.has_key(hostname):
		        print ‘*** WARNING: Unknown host key!‘
		    elif not keys[hostname].has_key(key.get_name()):
		        print ‘*** WARNING: Unknown host key!‘
		    elif keys[hostname][key.get_name()] != key:
		        print ‘*** WARNING: Host key has changed!!!‘
		        sys.exit(1)
		    else:
		        print ‘*** Host key OK.‘
		
		    # get username
		    if username == ‘‘:
		        default_username = getpass.getuser()
		        username = raw_input(‘Username [%s]: ‘ % default_username)
		        if len(username) == 0:
		            username = default_username
		
		    agent_auth(t, username)
		    if not t.is_authenticated():
		        manual_auth(username, hostname)
		    if not t.is_authenticated():
		        print ‘*** Authentication failed. :(‘
		        t.close()
		        sys.exit(1)
		
		    chan = t.open_session()
		    chan.get_pty()
		    chan.invoke_shell()
		    print ‘*** Here we go!‘
		    print
		    interactive.interactive_shell(chan)
		    chan.close()
		    t.close()
		
		except Exception, e:
		    print ‘*** Caught exception: ‘ + str(e.__class__) + ‘: ‘ + str(e)
		    traceback.print_exc()
		    try:
		        t.close()
		    except:
		        pass
		    sys.exit(1)
	except:
		continue