堡垒机
windows ,linux 都通过测试
初始化说明：
#进入根目录
1、初始化表结构 #python3 bin/start.py syncdb
2、创建堡垒机用户 #python3 bin/start.py create_users -f share/examples/new_user.yml
3、创建分组 #python3 bin/start.py create_groups -f share/examples/new_groups.yml
4、创建远程主机 #python3 bin/start.py create_hosts -f share/examples/new_hosts.yml
5、创建远程主机用户（绑定堡垒机用户与分组）#python3 bin/start.py create_remoteusers -f share/examples/new_remoteusers.yml
6、绑定远程主机与远程主机用户【远程绑定组合】（关联远程绑定组合与堡垒机用户、关联远程绑定组合与分组）
#python3 bin/start.py create_bindhosts -f share/examples/new_bindhosts.yml
7、登陆堡垒机 #python3 bin/start.py start_session （示例用户： uge3 密码：uge3）
8、查看用户日志 #python3 bin/start.py audit -n uge3 plj/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
| |- - -__init__.py
| |- - -start.py#启动
|
|- - -conf/#配置目录
| |- - -__init__.py
| |- - -action_registers.py#开始参数配置文件
| |- - -settings.py#配置文件
|
|- - -modules/#主逻辑目录
| |- - -__init__.py
| |- - -actions.py#开始函数 帮助信息
| |- - -db_conn.py#数据库连接配置
| |- - -interactive.py#ssh命令重写
| |- - -models.py#表结构 类
| |- - -ssh_login.py#登陆远程主机调用
| |- - -utils.py#工具函数
| |- - -views.py#主要逻辑函数
|
|- - -REDMAE
|
|- - -share/#添加堡垒机用户\远程主机\分组\远程主机用户 目录
| |- - -examples/#文件目录
| |- - -new_bindhosts.yml/#远程主机用户与远程主机 组合表（组合表与 分组）（堡垒机用户与组合表） 创建 示例
| |- - -new_groups.yml/#分组创建 示例（ 堡垒机用户与 分组）
| |- - -new_hosts.yml/#远程主机创建 示例
| |- - -new_remoteusers.yml/#远程主机用户创建 示例
| |- - -new_user.yml/#堡垒机用户机创建 示例
plj/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
| |- - -__init__.py
| |- - -start.py#启动
#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python
#17-7-14 下午6:22
#__author__='Administrator' import os,sys BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #print(BASE_DIR)
sys.path.append(BASE_DIR)#加入环境变量 if __name__ == '__main__':
from modules.actions import excute_from_command_line
excute_from_command_line(sys.argv)
|- - -conf/#配置目录
| |- - -__init__.py
| |- - -action_registers.py#开始参数配置文件
#_*_coding:utf-8_*_
import os,sys BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(BASE_DIR)#加入环境变量 from modules import views '''
actions = {
'start_session': views.start_session,#开始程序
'stop': views.stop_server,#停止
'syncdb': views.syncdb,#创建表结构
'create_users': views.create_users,
'create_groups': views.create_groups,
'create_hosts': views.create_hosts,
'create_bindhosts': views.create_bindhosts,
'create_remoteusers': views.create_remoteusers,
}
'''
actions = {
'audit':views.audit,#查看日志
'start_session': views.start_session,#开始程序
'stop': views.stop_server,#停止
'syncdb': views.syncdb,#创建表结构
'create_users': views.create_users,#创建堡垒机用户
'create_groups': views.create_groups,#创建分组
'create_hosts': views.create_hosts,#创建远程主机
'create_remoteusers': views.create_remoteusers,# #创建远程主机用户
'create_bindhosts': views.create_bindhosts,# 远程主机与远程主机用户 绑定 关联堡垒机用户与
#'ass_bind_group': views.ass_bindhost_group,#远程主机与远程主机用户组合 与 分组 } actionses = {
'audit [查看日志]':views.audit,#查看日志
'start_session [开始程序]': views.start_session,#开始程序
'stop [停止]': views.stop_server,#停止
'syncdb [创建表结构]': views.syncdb,#创建表结构
'create_users [创建堡垒机用户]': views.create_users,#创建堡垒机用户
'create_groups [创建分组]': views.create_groups,#创建分组
'create_hosts [创建远程主机]': views.create_hosts,#创建远程主机
'create_remoteusers [创建远程主机用户]': views.create_remoteusers,# #创建远程主机用户
'create_bindhosts [绑定堡垒机用户与远程主机用户]': views.create_bindhosts,#绑定堡垒机用户与远程主机用户
#'ass_bind_group [绑定远程主机+远程主机用户组合与分组]': views.ass_bindhost_group,#远程主机与远程主机用户组合 与 分组 }
| |- - -settings.py#配置文件
import os,sys BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) USER='root'#用户名
PASSWORD='root'#密码
HOST_IP='127.0.0.1'#数据库地址
PORT=""#数据库端口
DB='little_finger'#库名
DB_CONN ="mysql+pymysql://"+USER+":"+PASSWORD+"@"+HOST_IP+":"+PORT+"/"+DB+"?charset=utf8"#连接参数
#DB_CONN ="mysql+pymysql://root:root@localhost:3306/"+DB+"?charset=utf8"#连接参数
|- - -modules/#主逻辑目录
| |- - -__init__.py
| |- - -actions.py#开始函数 帮助信息
#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python
#17-7-14 下午6:25
#__author__='Administrator'
import os,sys BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(BASE_DIR)#加入环境变量 from conf import settings
from conf import action_registers
from modules import utils def help_msg():#帮助信息
'''
print help msgs
:return:
'''
print("\033[31;1mAvailable commands:\033[0m")
for key in action_registers.actionses:#打印配置文件中的帮助信息
print("\t",key) def excute_from_command_line(argvs):#接收输入的命令
if len(argvs) < 2: #如果小于两个词
help_msg()#打印帮助信息
exit()
if argvs[1] not in action_registers.actions:
utils.print_err("Command [%s] does not exist!" % argvs[1], quit=True)
action_registers.actions[argvs[1]](argvs[1:])#获取到命令
| |- - -db_conn.py#数据库连接配置
from sqlalchemy import create_engine,Table
from sqlalchemy.orm import sessionmaker from conf import settings #engine = create_engine(settings.DB_CONN)
engine = create_engine(settings.DB_CONN,echo=True)#数据库连接通道 SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = SessionCls()
| |- - -interactive.py#ssh命令重写
import socket
import sys
from paramiko.py3compat import u
from modules import models
import datetime # windows does not have termios...
try:
import termios
import tty
has_termios = True
except ImportError:
has_termios = False #记录日志相关 堡垒机用户 连接主机 命令 写入日志
def interactive_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording):
if has_termios:
posix_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording)
else:
windows_shell(chan) def posix_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording):
import select oldtty = termios.tcgetattr(sys.stdin)
try:
tty.setraw(sys.stdin.fileno())
tty.setcbreak(sys.stdin.fileno())
chan.settimeout(0.0)
cmd = ''
tab_key = False
while True:
r, w, e = select.select([chan, sys.stdin], [], [])#select 连接传入命令返回 三个变量
if chan in r:#如果命令存在
try:
x = u(chan.recv(1024))#连接返回数据
if tab_key:
if x not in ('\x07' , '\r\n'): #判断空格 和回车
#print('tab:',x)
cmd += x
tab_key = False
if len(x) == 0:
sys.stdout.write('\r\n*** EOF\r\n')
break
sys.stdout.write(x)
sys.stdout.flush()#实时输出到屏幕
except socket.timeout:
pass
if sys.stdin in r:
x = sys.stdin.read(1)
if '\r' != x:
cmd +=x
else: print('cmd->:',cmd)#命令
log_item = models.AuditLog(user_id=user_obj.id,
bind_host_id=bind_host_obj.id,
action_type='cmd',
cmd=cmd ,
date=datetime.datetime.now()
)
cmd_caches.append(log_item)#添加到列表
cmd = '' if len(cmd_caches)>=10:#每十条写入日志
log_recording(user_obj,bind_host_obj,cmd_caches)
cmd_caches = []
if '\t' == x:
tab_key = True
if len(x) == 0:
break
chan.send(x)#发送命令 finally:
termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty) # thanks to Mike Looijmans for this code
def windows_shell(chan):
import threading sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n") def writeall(sock):
while True:
data = sock.recv(256)
if not data:
sys.stdout.write('\r\n*** EOF ***\r\n\r\n')
sys.stdout.flush()
break
sys.stdout.write(data.decode())##windows下要转成str
sys.stdout.flush()#实时输出到屏幕 writer = threading.Thread(target=writeall, args=(chan,))
writer.start() try:
while True:
d = sys.stdin.read(1)
if not d:
break
chan.send(d)
except EOFError:
# user hit ^Z or F6
pass
| |- - -models.py#表结构 类
#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python
#17-7-12 上午10:54
#__author__='Administrator' # 创建表
import os ,sys
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
sys.path.append(BASE_DIR)#增加环境变量
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,Table,DATE,DateTime
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy import func #统计
from sqlalchemy_utils import ChoiceType,PasswordType #
from conf import settings
Base = declarative_base()#生成orm 基类 # #创建堡垒机用户关联－－联合表,自动维护
user_profile_m2m_bind_host = Table('user_profile_m2m_bind_host', Base.metadata,
Column('user_profile_id',Integer,ForeignKey('user_profile.id')),#关联,用户id
Column('bind_host_id',Integer,ForeignKey('bind_host.id')),#关联,联合表id
)
# #创建联合表－－分组,自动维护
bind_host_m2m_host_group = Table('bind_host_m2m_host_group', Base.metadata,
Column('bind_host_id',Integer,ForeignKey('bind_host.id')),#关联,联合表id
Column('host_group_id',Integer,ForeignKey('host_group.id')),#关联,分组id
)
# #创建堡垒机用户－－分组,自动维护
user_profile_m2m_host_group = Table('user_profile_m2m_host_group', Base.metadata,
Column('user_profile_id',Integer,ForeignKey('user_profile.id')),#关联,堡垒机用户id
Column('host_group_id',Integer,ForeignKey('host_group.id')),#关联,分组id
)
#主机表
class Host(Base):#主机表
__tablename__='host'
id=Column(Integer,primary_key=True)
hostname=Column(String(64),unique=True)#主机名
ip=Column(String(64),unique=True)#ip
port=Column(Integer,default=22)#端口默认为22
def __repr__(self):
return self.hostname#输出主机名 #服务器远程主机用户名密码
class RemoteUser(Base):
__tablename__='remote_user' id=Column(Integer,primary_key=True)
AuthType=[
('ssh-passwd','SSH-Password'),
('ssh-key','SSH-Key'),
]
auth_type=Column(ChoiceType(AuthType))#认证类型
username=Column(String(64))#用户名 不用唯一
password=Column(String(64))
__table_args__=(UniqueConstraint('auth_type','username','password',name='user_password_type'),)#联合只唯一
def __repr__(self):
return self.username#用户名 #绑定远程主机-远程用户关联表
class BindHost(Base):
__tablename__='bind_host'
__table_args__=(UniqueConstraint('host_id',"remote_user_id",name='host_id_remote'),)#联合唯一
id=Column(Integer,primary_key=True)
host_id=Column(Integer,ForeignKey('host.id'))#外键－－〉主机表
remote_user_id=Column(Integer,ForeignKey('remote_user.id'))#外键－－〉主机用户表
host=relationship('Host',backref='bind_hosts')#外键 主机表 查询与反查
remote_user=relationship('RemoteUser',backref='bind_hosts')#外键 用户表 查询与反查
def __repr__(self):
return '[主机：%s----->登陆用户：%s]'%(self.host.ip,self.remote_user.username)# #主机分组
class HostGroup(Base):
__tablename__='host_group'
id=Column(Integer,primary_key=True)
group_name=Column(String(64),unique=True)#主机分组名
bind_host=relationship('BindHost',secondary=bind_host_m2m_host_group,backref='host_groups')#分组表 远程联合表 查询与反查
def __repr__(self):
return self.group_name#输出主机名 #堡垒机用户,
class UserProfile(Base):
__tablename__='user_profile'
id=Column(Integer,primary_key=True)
username=Column(String(64),unique=True)#用户名
password=Column(String(256))
bind_hosts = relationship('BindHost',secondary=user_profile_m2m_bind_host,backref='user_profiles')#调用关联绑定表查看 堡垒机用户名
host_group = relationship('HostGroup',secondary=user_profile_m2m_host_group,backref='user_profiles')#调用关联 分组查看 堡垒机用户名
#audit_logs = relationship('AuditLog')#查日志
def __repr__(self):
return self.username#用户名 #日志类
class AuditLog(Base):
__tablename__ = 'audit_log'
id = Column(Integer,primary_key=True)
user_id = Column(Integer,ForeignKey('user_profile.id'))#外键 堡垒机用户ID
bind_host_id = Column(Integer,ForeignKey('bind_host.id'))#外键 远程主机ID
action_choices = [
(u'cmd',u'CMD'),#命令
(u'login',u'Login'),#登陆
(u'logout',u'Logout'),#退出
]
action_type = Column(ChoiceType(action_choices))#日志类型
cmd = Column(String(255))#命令
date = Column(DateTime)#日期时间
user_profile = relationship("UserProfile",backref='audit_logs')#关联堡垒机用户 查询
bind_host = relationship("BindHost",backref='audit_logs')#关联远程主机 查询
| |- - -ssh_login.py#登陆远程主机调用
#!usr/bin/env python
#-*-coding:utf-8-*-
# Author calmyan
#python
#2017/7/15 19:44
#__author__='Administrator' import base64
import getpass
import os
import socket
import sys
import traceback
from paramiko.py3compat import input
from modules import models
import datetime import paramiko
try:
import interactive
except ImportError:
from . import interactive #登陆远程主机
def ssh_login(user_obj,bind_host_obj,mysql_engine,log_recording):#ssh进入远程主机
# now, connect and use paramiko Client to negotiate SSH2 across the connection
try:
client = paramiko.SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(paramiko.WarningPolicy())
print('*** Connecting...')#开始连接
#client.connect(hostname, port, username, password)
client.connect(bind_host_obj.host.ip,
bind_host_obj.host.port,
bind_host_obj.remote_user.username,
bind_host_obj.remote_user.password,
timeout=30)#超时30秒 cmd_caches = []#定义一个列表,暂时保存命令
chan = client.invoke_shell()
print(repr(client.get_transport()))
print('*** Here we go!\n')
cmd_caches.append(models.AuditLog(user_id=user_obj.id,
bind_host_id=bind_host_obj.id,
action_type='login',
date=datetime.datetime.now()
))
log_recording(user_obj,bind_host_obj,cmd_caches)
interactive.interactive_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording)#传入 堡垒机用户, 连接远程主机 命令 记当日志函数
chan.close()
client.close() except Exception as e:
print('*** Caught exception: %s: %s' % (e.__class__, e))
traceback.print_exc()
try:
client.close()
except:
pass
sys.exit(1)
| |- - -utils.py#工具函数
from conf import settings
import yaml
try:
from yaml import CLoader as Loader, CDumper as Dumper
except ImportError:
from yaml import Loader, Dumper def print_err(msg,quit=False):#错误提示输出
output = "\033[31;1mError: %s\033[0m" % msg
if quit:
exit(output)
else:
print(output) def yaml_parser(yml_filename):
'''
load yaml file and return
:param yml_filename:
:return:
'''
#yml_filename = "%s/%s.yml" % (settings.StateFileBaseDir,yml_filename)
try:
yaml_file = open(yml_filename,'r')#打开文件
data = yaml.load(yaml_file)#load 成一个对象
return data#返回数据
except Exception as e:
print_err(e)
| |- - -views.py#主要逻辑函数
#_*_coding:utf-8_*_
import os,sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(BASE_DIR)#加入环境变量
from modules import models
from modules.db_conn import engine,session
from modules.utils import print_err,yaml_parser
#from modules import common_filt
from modules import ssh_login
from sqlalchemy import create_engine,Table
from sqlalchemy.orm import sessionmaker from conf import settings #用户登陆函数
def auth():
'''
do the user login authentication
:return:
'''
count = 0
while count <3:#用户输入三次机会
username = input("\033[32;1mUsername:\033[0m").strip()
if len(username) ==0:continue
password = input("\033[32;1mPassword:\033[0m").strip()
if len(password) ==0:continue
user_obj = session.query(models.UserProfile).filter(models.UserProfile.username==username,
models.UserProfile.password==password).first()#从数据库中获取堡垒机用户信息
if user_obj:
return user_obj
else:
print("wrong username or password, you have %s more chances." %(3-count-1))
count +=1
else:
print_err("too many attempts.") #欢迎界面
def welcome_msg(user):
WELCOME_MSG = '''\033[32;1m
------------- Welcome [%s] login LittleFinger -------------
\033[0m'''% user.username
print(WELCOME_MSG) #写入数据库 日志
def log_recording(user_obj,bind_host_obj,logs):
'''
flush user operations on remote host into DB
:param user_obj:
:param bind_host_obj:
:param logs: list format [logItem1,logItem2,...]
:return:
'''
print("\033[41;1m--logs:\033[0m",logs)
session.add_all(logs)
session.commit() #开始函数
def start_session(argvs):
print('going to start sesssion ')
user = auth()#判断用户名 并返回用户对应信息
if user:
welcome_msg(user)#打印欢迎界面
#print(user.id)#用户ID
#print(user.bind_hosts)#绑定主机
#print(user.host_group)#所在组
#log_recording(user,user.bind_hosts,user.host_group,logs)
exit_flag = False#设定点 为假
while not exit_flag:#如果设定点 为假 说明登陆成功
if user.bind_hosts:#有绑定远程主机 打印远程主机
print('\033[32;1mz.\tungroupped hosts (%s)\033[0m' %len(user.bind_hosts) )
for index,group in enumerate(user.host_group):#打印当前用户所在组
print('\033[32;1m%s.\t%s (%s)\033[0m' %(index,group.group_name, len(group.bind_host)) ) print('(q)=quit')
choice = input("[%s]:" % user.username).strip()#开始获取输入的命令 if len(choice) == 0:continue#如果没有输入跳过
if choice == 'q':
exit_flag=True
#if choice=='exit': exit()#退出
if choice == 'z':#如果输入 z
print("------ Group: ungroupped hosts ------" )#输出所有的未分组的主机
for index,bind_host in enumerate(user.bind_hosts):
print(" %s.\t%s@%s(%s)"%(index,
bind_host.remote_user.username,#绑定的用户名
bind_host.host.hostname,#主机名
bind_host.host.ip,#IP地址
))
print("----------- END -----------" )
elif choice.isdigit():#如果是选择数字
choice = int(choice)
if choice < len(user.host_group):
print("------ Group: %s ------" % user.host_group[choice].group_name )
for index,bind_host in enumerate(user.host_group[choice].bind_host):#打印出选择组的包括的
print(" %s.\t%s@%s(%s)"%(index,
bind_host.remote_user.username,#绑定的用户名
bind_host.host.hostname,#主机名
bind_host.host.ip,#IP地址
))
print("----------- END -----------" ) #host selection
while not exit_flag:
user_option = input("[(b)back, (q)quit, select host to login]:").strip()
if len(user_option)==0:continue
if user_option == 'b':break
if user_option == 'q':
exit_flag=True
if user_option.isdigit():
user_option = int(user_option)
if user_option < len(user.host_group[choice].bind_host) :#查看分组所绑定的远程 主机
print('host:',user.host_group[choice].bind_host[user_option])
print('audit log:',user.host_group[choice].bind_host[user_option].audit_logs)
ssh_login.ssh_login(user,
user.host_group[choice].bind_host[user_option],
session,
log_recording)
else:
print("no this option..") #停止退出
def stop_server(argvs):
exit() #创建表结构
def syncdb(argvs):
print("Syncing DB....[创建所有表结构]")
models.Base.metadata.create_all(engine) #创建所有表结构 '''======创建四个基础表==== '''
#堡垒机用户添加
def create_users(argvs):
if '-f' in argvs:#判断参数 -f 是否存在
user_file = argvs[argvs.index("-f") +1 ]#获取文件位置
else:
print_err("invalid usage, should be:\ncreateusers -f <the new users file>",quit=True)
source = yaml_parser(user_file)#获取文件内容数据
if source:#如果获取成功
for key,val in source.items():
print(key,val)
obj = models.UserProfile(username=key,password=val.get('password'))#创建新数据
session.add(obj)
session.commit() #分组添加
def create_groups(argvs):
if '-f' in argvs:#判断参数 -f 是否存在
group_file = argvs[argvs.index("-f") +1 ]
else:
print_err("invalid usage, should be:\ncreategroups -f <the new groups file>",quit=True)
source = yaml_parser(group_file)#通过yaml 获取文件中的数据,
if source:
for key,val in source.items():
print(key,val)
obj = models.HostGroup(group_name=key)#创建一条新数据
if val.get('bind_hosts'):#
bind_hosts = bind_hosts_filter(val)#绑定的远程主机组合表
obj.bind_host = bind_hosts
if val.get('user_profiles'):#堡垒机用户
user_profiles = user_profiles_filter(val)#堡垒机用户
obj.user_profiles = user_profiles
session.add(obj)
session.commit() #远程主机添加
def create_hosts(argvs):
if '-f' in argvs:#判断参数 -f 是否存在
hosts_file = argvs[argvs.index("-f") +1 ]
else:
print_err("invalid usage, should be:\ncreate_hosts -f <the new hosts file>",quit=True)#退出函数
source = yaml_parser(hosts_file)#通过yaml 获取文件中的数据,
if source:#如果获取成功,不为空
for key,val in source.items():#进行数据的解析
print(key)
print(val)
obj = models.Host(hostname=key,ip=val.get('ip'), port=val.get('port') or 22)#port 端口默认为22
session.add(obj)#写入到数据库
session.commit()#关闭 确认写入 #创建远程主机用户
def create_remoteusers(argvs):
if '-f' in argvs:
remoteusers_file = argvs[argvs.index("-f") +1 ]
else:
print_err("invalid usage, should be:\ncreate_remoteusers -f <the new remoteusers file>",quit=True)
source = yaml_parser(remoteusers_file)#通过yaml 获取文件中的数据,
if source:
for key,val in source.items():#进行数据的解析
print(key,val)
obj = models.RemoteUser(username=val.get('username'),auth_type=val.get('auth_type'),password=val.get('password'))
session.add(obj)#写入数据库
session.commit() '''====远程主机与远程主机用户组合表====='''
##远程主机用户名密码与远程主机组合绑定 关联 到堡垒机用户
def create_bindhosts(argvs):
if '-f' in argvs:
bindhosts_file = argvs[argvs.index("-f") +1 ]
else:
print_err("invalid usage, should be:\ncreate_hosts -f <the new bindhosts file>",quit=True)
source = yaml_parser(bindhosts_file)#通过yaml 获取文件中的数据,
if source:
for key,val in source.items():
print(key,val)
host_obj = session.query(models.Host).filter(models.Host.hostname==val.get('hostname')).first()#获取对应主机数据
assert host_obj#断言 当前主机一定要存在才能往下执行
for item in val['remote_users']:#输出存在的远程主机用户
print(item )
assert item.get('auth_type')#断言 一定要存在才能往下执行
if item.get('auth_type') == 'ssh-passwd':#判断ssh连接类型 从数据库选出合条件的数据
remoteuser_obj = session.query(models.RemoteUser).filter(
models.RemoteUser.username==item.get('username'),
models.RemoteUser.password==item.get('password')
).first()#获取主机数据 返回对象
else:
remoteuser_obj = session.query(models.RemoteUser).filter(
models.RemoteUser.username==item.get('username'),
models.RemoteUser.auth_type==item.get('auth_type'),
).first()
if not remoteuser_obj:#如果远程主机用户不存在
print_err("RemoteUser obj %s does not exist." % item,quit=True )
bindhost_obj = models.BindHost(host_id=host_obj.id,remote_user_id=remoteuser_obj.id)#创建一条新数据
session.add(bindhost_obj)
#for groups this host binds to
if source[key].get('groups'):#如果有分组标志
#获取分组信息
group_objs = session.query(models.HostGroup).filter(models.HostGroup.group_name.in_(source[key].get('groups') )).all()
assert group_objs#断言 分组一定要存在才能往下执行
print('groups:', group_objs)
bindhost_obj.host_groups = group_objs#主机加到分组
#for user_profiles this host binds to
if source[key].get('user_profiles'):#如果有堡垒机用户标志
#获取堡垒机用信息
userprofile_objs = session.query(models.UserProfile).filter(models.UserProfile.username.in_(
source[key].get('user_profiles')
)).all()
assert userprofile_objs#断言 堡垒机用户一定要存在才能往下执行
print("userprofiles:",userprofile_objs)
bindhost_obj.user_profiles = userprofile_objs#主机与堡垒机用户绑定
#print(bindhost_obj)
session.commit() #远程主机组合表查看
def bind_hosts_filter(vals):#远程主机组合表查看
print('**>',vals.get('bind_hosts') )
bind_hosts = session.query(models.BindHost).filter(models.Host.hostname.in_(vals.get('bind_hosts'))).all()
if not bind_hosts:
print_err("none of [%s] exist in bind_host table." % vals.get('bind_hosts'),quit=True)
return bind_hosts #堡垒机用户查看
def user_profiles_filter(vals):
user_profiles = session.query(models.UserProfile).filter(models.UserProfile.username.in_(vals.get('user_profiles'))).all()
if not user_profiles:
print_err("none of [%s] exist in user_profile table." % vals.get('user_profiles'),quit=True)
return user_profiles #查看用户日志
def audit(argvs):
if '-n' in argvs:
user_name = argvs[argvs.index("-n") +1 ]#获取要查看的用户名
else:
print_err("invalid usage, should be:\n输入参数 -n <用户名/user_name >",quit=True)
print(user_name)
user_obj = session.query(models.UserProfile).filter(models.UserProfile.username==user_name).first()#取到
print(user_obj.id)
log_obj = session.query(models.AuditLog).filter(models.AuditLog.user_id==user_obj.id).all()
for i in log_obj:
print('堡垒机用户：【%s】,远程主机【%s】,远程用户：【%s】命令：【%s】,日期：【%s】'%(i.user_profile,i.bind_host.host,i.bind_host.remote_user,i.cmd,i.date))
input('========')
|- - -share/#添加堡垒机用户\远程主机\分组\远程主机用户 目录
| |- - -examples/#文件目录
| |- - -new_bindhosts.yml/#远程主机用户与远程主机 组合表（组合表与 分组）（堡垒机用户与组合表） 创建 示例
bind0:
hostname: ubuntu test
remote_users:
- user0:
username: root
auth_type: ssh-passwd
password: root
groups:
- test_group
user_profiles:
- uge3
- alex bind1:
hostname: server1
remote_users:
- user1:
username: root
auth_type: ssh-key
#password: 123
- user0:
username: root
auth_type: ssh-passwd
password: root
- user4:
username: calmyan
auth_type: ssh-passwd
password: yjj
groups:
- bj_group
user_profiles:
- uge3 bind2:
hostname: server2
remote_users:
- user1:
username: alex
auth_type: ssh-passwd
password: alex3714
groups:
- bj_group
- sh_group
user_profiles:
- rain
| |- - -new_groups.yml/#分组创建 示例（ 堡垒机用户与 分组）
bj_group:
user_profiles:
- alex
- uge3 sh_group:
user_profiles:
- jack
- alex
- rain
- uge3
test_group:
user_profiles:
- uge3
| |- - -new_hosts.yml/#远程主机创建 示例
ubuntu test:
ip: 192.168.11.50
port: 22 server1:
ip: 192.168.11.51 server2:
ip: 10.4.4.22
port: 30000
| |- - -new_remoteusers.yml/#远程主机用户创建 示例
user0:
auth_type: ssh-passwd
username: root
password: root user1:
auth_type: ssh-passwd
username: root
password: alex!34321 user2:
auth_type: ssh-key
username: root
#password: abc!23 user3:
auth_type: ssh-passwd
username: alex
password: alex3714 user4:
auth_type: ssh-passwd
username: calmyan
password: yjj
| |- - -new_user.yml/#堡垒机用户机创建 示例
alex:
password: alex123
uge3:
password: uge3 jack:
password: jack123 rain:
password: rain123