Python之堡壘機

時間 2019-12-13

標籤 python 堡壘欄目 Python 简体版

原文原文鏈接

本節內容html

項目實戰：運維堡壘機開發mysql

前景介紹

到目前爲止，不少公司對堡壘機依然不太感冒，實際上是沒有充分認識到堡壘機在IT管理中的重要做用的，不少人以爲，堡壘機就是跳板機，其實這個認識是不全面的，跳板功能只是堡壘機所具有的功能屬性中的其中一項而已，下面我就給你們介紹一下堡壘機的重要性，以幫助你們參考本身公司的業務是否須要部署堡壘機。git

堡壘機有如下兩個相當重要的功能：github

權限管理

當你公司的服務器變的愈來愈多後，須要操做這些服務器的人就確定不僅是一個運維人員，同時也可能包括多個開發人員，那麼這麼多的人操做業務系統，若是權限分配不當就會存在很大的安全風險，舉幾個場景例子：web

設想大家公司有300臺Linux服務器，A開發人員須要登陸其中5臺WEB服務器查看日誌或進行問題追蹤等事務，同時對另外10臺hadoop服務器有root權限，在有300臺服務器規模的網絡中，按常理來說你是已經使用了ldap權限統一認證的，你如何使這個開發人員只能以普通用戶的身份登陸5臺web服務器，而且同時容許他以管理員的身份登陸另外10臺hadoop服務器呢？而且同時他對其它剩下的200多臺服務器沒有訪問權限sql
目前據我瞭解，不少公司的運維團隊爲了方面，整個運維團隊的運維人員仍是共享同一套root密碼，這樣內部信任機制雖然使你們的工做方便了，但同時存在着極大的安全隱患，不少狀況下，一個運維人員只須要管理固定數量的服務器，畢竟公司分爲不一樣的業務線，不一樣的運維人員管理的業務線也不一樣，但若是共享一套root密碼，其實就等於無限放大了每一個運維人員的權限，也就是說，若是某個運維人員想幹壞事的話，他能夠在幾分鐘內把整個公司的業務停轉，甚至數據都給刪除掉。爲了下降風險，因而有人想到，把不一樣業務線的root密碼改掉就ok了麼，也就是每一個業務線的運維人員只知道本身的密碼，這固然是最簡單有效的方式，但問題是若是你同時用了ldap,這樣作又比較麻煩，即便你設置了root不經過ldap認證，那新問題就是，每次有運維人員離職，他所在的業務線的密碼都須要從新改一次。shell

其實上面的問題，我以爲能夠很簡單的經過堡壘機來實現，收回全部人員的直接登陸服務器的權限，全部的登陸動做都經過堡壘機受權，運維人員或開發人員不知道遠程服務器的密碼，這些遠程機器的用戶信息都綁定在了堡壘機上，堡壘機用戶只能看到他能用什麼權限訪問哪些遠程服務器。數據庫

在回收了運維或開發人員直接登陸遠程服務器的權限後，其實就等於大家公司生產系統的全部認證過程都經過堡壘機來完成了，堡壘機等於成了大家生產系統的SSO(single sign on)模塊了。你只須要在堡壘機上添加幾條規則就能實現如下權限控制了：ubuntu

容許A開發人員經過普通用戶登陸5臺web服務器，經過root權限登陸10臺hadoop服務器，但對其他的服務器無任務訪問權限安全
多個運維人員能夠共享一個root帳戶，可是依然能分辨出分別是誰在哪些服務器上操做了哪些命令，由於堡壘機帳戶是每一個人獨有的，也就是說雖然全部運維人員共享了一同一個遠程root帳戶，但因爲他們用的堡壘帳戶都是本身獨有的，所以依然能夠經過堡壘機控制每一個運維人員訪問不一樣的機器。

審計管理

審計管理其實很簡單，就是把用戶的全部操做都紀錄下來，以備往後的審計或者事故後的追責。在紀錄用戶操做的過程當中有一個問題要注意，就是這個紀錄對於操做用戶來說是不可見的，什麼意思？就是指，不管用戶願不肯意，他的操做都會被紀錄下來，而且，他本身若是不想操做被紀錄下來，或想刪除已紀錄的內容，這些都是他作不到的，這就要求操做日誌對用戶來說是不可見和不可訪問的，經過堡壘機就能夠很好的實現。

堡壘機架構

堡壘機的主要做用權限控制和用戶行爲審計，堡壘機就像一個城堡的大門，城堡裏的全部建築就是你不一樣的業務系統，每一個想進入城堡的人都必須通過城堡大門並通過大門守衛的受權，每一個進入城堡的人必須且只能嚴格按守衛的分配進入指定的建築，且每一個建築物還有本身的權限訪問控制，不一樣級別的人能夠到建築物裏不一樣樓層的訪問級別也是不同的。還有就是，每一個進入城堡的人的全部行爲和足跡都會被嚴格的監控和紀錄下來，一旦發生犯罪事件，城堡管理人員就能夠經過這些監控紀錄來追蹤責任人。

堡壘要想成功徹底記到他的做用，只靠堡壘機自己是不夠的，還須要一系列安全上對用戶進行限制的配合，堡壘機部署上後，同時要確保你的網絡達到如下條件：

全部人包括運維、開發等任何須要訪問業務系統的人員，只能經過堡壘機訪問業務系統
- 回收全部對業務系統的訪問權限，作到除了堡壘機管理人員，沒有人知道業務系統任何機器的登陸密碼
- 網絡上限制全部人員只能經過堡壘機的跳轉才能訪問業務系統
確保除了堡壘機管理員以外，全部其它人對堡壘機自己無任何操做權限，只有一個登陸跳轉功能
確保用戶的操做紀錄不能被用戶本身以任何方式獲取到並篡改

堡壘機功能實現需求

業務需求:

兼顧業務安全目標與用戶體驗，堡壘機部署後，不該使用戶訪問業務系統的訪問變的複雜，不然工做將很難推動，由於沒人喜歡改變現狀，尤爲是改變後生活變得更艱難
保證堡壘機穩定安全運行，沒有100%的把握，不要上線任何新系統，即便有100%把握，也要作好最壞的打算，想好故障預案

功能需求：

全部的用戶操做日誌要保留在數據庫中
每一個用戶登陸堡壘機後，只須要選擇具體要訪問的設置，就鏈接上了，不須要再輸入目標機器的訪問密碼
容許用戶對不一樣的目標設備有不一樣的訪問權限，例:

對10.0.2.34 有mysql 用戶的權限
對192.168.3.22 有root用戶的權限
對172.33.24.55 沒任何權限

分組管理，便可以對設置進行分組，容許用戶訪問某組機器，但對組裏的不一樣機器依然有不一樣的訪問權限

設計表結構:

  1 #_*_coding:utf-8_*_
  2 __author__ = 'Alex Li'
  3  
  4 from sqlalchemy import create_engine,Table
  5 from sqlalchemy.ext.declarative import declarative_base
  6 from sqlalchemy import Column, Integer, String,ForeignKey,UniqueConstraint
  7 from sqlalchemy.orm import relationship
  8 from  sqlalchemy.orm import sessionmaker
  9 from sqlalchemy import or_,and_
 10 from sqlalchemy import func
 11 from sqlalchemy_utils import ChoiceType,PasswordType
 12  
 13 Base = declarative_base() #生成一個SqlORM 基類
 14  
 15  
 16 engine = create_engine("mysql+mysqldb://root@localhost:3306/test",echo=False)
 17  
 18  
 19 BindHost2Group = Table('bindhost_2_group',Base.metadata,
 20     Column('bindhost_id',ForeignKey('bind_host.id'),primary_key=True),
 21     Column('group_id',ForeignKey('group.id'),primary_key=True),
 22 )
 23  
 24 BindHost2UserProfile = Table('bindhost_2_userprofile',Base.metadata,
 25     Column('bindhost_id',ForeignKey('bind_host.id'),primary_key=True),
 26     Column('uerprofile_id',ForeignKey('user_profile.id'),primary_key=True),
 27 )
 28  
 29 Group2UserProfile = Table('group_2_userprofile',Base.metadata,
 30     Column('userprofile_id',ForeignKey('user_profile.id'),primary_key=True),
 31     Column('group_id',ForeignKey('group.id'),primary_key=True),
 32 )
 33  
 34  
 35 class UserProfile(Base):
 36     __tablename__ = 'user_profile'
 37     id = Column(Integer,primary_key=True,autoincrement=True)
 38     username = Column(String(32),unique=True,nullable=False)
 39     password = Column(String(128),unique=True,nullable=False)
 40     groups = relationship('Group',secondary=Group2UserProfile)
 41     bind_hosts = relationship('BindHost',secondary=BindHost2UserProfile)
 42  
 43     def __repr__(self):
 44         return "<UserProfile(id='%s',username='%s')>" % (self.id,self.username)
 45  
 46 class RemoteUser(Base):
 47     __tablename__ = 'remote_user'
 48     AuthTypes = [
 49         (u'ssh-passwd',u'SSH/Password'),
 50         (u'ssh-key',u'SSH/KEY'),
 51     ]
 52     id = Column(Integer,primary_key=True,autoincrement=True)
 53     auth_type = Column(ChoiceType(AuthTypes))
 54     username = Column(String(64),nullable=False)
 55     password = Column(String(255))
 56  
 57     __table_args__ = (UniqueConstraint('auth_type', 'username','password', name='_user_passwd_uc'),)
 58  
 59     def __repr__(self):
 60         return "<RemoteUser(id='%s',auth_type='%s',user='%s')>" % (self.id,self.auth_type,self.username)
 61  
 62  
 63 class Host(Base):
 64     __tablename__ = 'host'
 65     id = Column(Integer,primary_key=True,autoincrement=True)
 66     hostname = Column(String(64),unique=True,nullable=False)
 67     ip_addr = Column(String(128),unique=True,nullable=False)
 68     port = Column(Integer,default=22)
 69     bind_hosts = relationship("BindHost")
 70     def __repr__(self):
 71         return "<Host(id='%s',hostname='%s')>" % (self.id,self.hostname)
 72  
 73 class Group(Base):
 74     __tablename__  = 'group'
 75     id = Column(Integer,primary_key=True,autoincrement=True)
 76     name = Column(String(64),nullable=False,unique=True)
 77     bind_hosts = relationship("BindHost",secondary=BindHost2Group, back_populates='groups' )
 78     user_profiles = relationship("UserProfile",secondary=Group2UserProfile )
 79  
 80     def __repr__(self):
 81         return "<HostGroup(id='%s',name='%s')>" % (self.id,self.name)
 82  
 83  
 84 class BindHost(Base):
 85     '''Bind host with different remote user,
 86        eg. 192.168.1.1 mysql passAbc123
 87        eg. 10.5.1.6    mysql pass532Dr!
 88        eg. 10.5.1.8    mysql pass532Dr!
 89        eg. 192.168.1.1 root
 90     '''
 91     __tablename__ = 'bind_host'
 92     id = Column(Integer,primary_key=True,autoincrement=True)
 93     host_id = Column(Integer,ForeignKey('host.id'))
 94     remoteuser_id = Column(Integer,ForeignKey('remote_user.id'))
 95     host = relationship("Host")
 96     remoteuser = relationship("RemoteUser")
 97     groups = relationship("Group",secondary=BindHost2Group,back_populates='bind_hosts')
 98     user_profiles = relationship("UserProfile",secondary=BindHost2UserProfile)
 99  
100     __table_args__ = (UniqueConstraint('host_id', 'remoteuser_id', name='_bindhost_and_user_uc'),)
101  
102     def __repr__(self):
103         return "<BindHost(id='%s',name='%s',user='%s')>" % (self.id,
104                                                            self.host.hostname,
105                                                            self.remoteuser.username
106                                                                       )
107  
108  
109 Base.metadata.create_all(engine) #建立全部表結構
110  
111 if __name__ == '__main__':
112     SessionCls = sessionmaker(bind=engine) #建立與數據庫的會話session class ,注意,這裏返回給session的是個class,不是實例
113     session = SessionCls()
114     #h1 = session.query(Host).filter(Host.hostname=='ubuntu4').first()
115     #hg1 = session.query(HostGroup).filter(HostGroup.name=='t2').first()
116  
117     #h2 = Host(hostname='ubuntu4',ip_addr='192.168.1.21')
118     #h3 = Host(hostname='ubuntu5',ip_addr='192.168.1.24',port=20000)
119     #hg= HostGroup(name='TestServers3',host_id=h3.id)
120     #hg2= HostGroup(name='TestServers2',host_id=h2.id)
121     #hg3= HostGroup(name='TestServers3')
122     #hg4= HostGroup(name='TestServers4')
123     #session.add_all([hg3,hg4])
124     #h2.host_groups = [HostGroup(name="t1"),HostGroup(name="t2")]
125     #h3.host_groups = [HostGroup(name="t2")]
126     #h1.host_groups.append(HostGroup(name="t3") )
127     #print(h1.host_groups)
128     #print("hg1:",hg1.host.hostname)
129     #join_res = session.query(Host).join(Host.host_groups).filter(HostGroup.name=='t1').group_by("Host").all()
130     #print('join select:',join_res)
131     #group_by_res = session.query(HostGroup, func.count(HostGroup.name )).group_by(HostGroup.name).all()
132     #print("-------------group by res-----")
133  
134     '''
135     h1=Host(hostname='h1',ip_addr='1.1.1.1')
136     h2=Host(hostname='h2',ip_addr='1.1.1.2')
137     h3=Host(hostname='h3',ip_addr='1.1.1.3')
138     r1=RemoteUser(auth_type=u'ssh-passwd',username='alex',password='abc123')
139     r2=RemoteUser(auth_type=u'ssh-key',username='alex')
140  
141     g1 = Group(name='g1')
142     g2 = Group(name='g2')
143     g3 = Group(name='g3')
144     session.add_all([h1,h2,h3,r1,r2])
145     session.add_all([g1,g2,g3])
146  
147  
148  
149     b1 = BindHost(host_id=1,remoteuser_id=1)
150     b2 = BindHost(host_id=1,remoteuser_id=2)
151     b3 = BindHost(host_id=2,remoteuser_id=2)
152     b4 = BindHost(host_id=3,remoteuser_id=2)
153     session.add_all((b1,b2,b3,b4))
154      
155     all_groups = session.query(Group).filter().all() #first()
156     all_bindhosts = session.query(BindHost).filter().all()
157  
158     #h1 = session.query(BindHost).filter(BindHost.host_id==1).first()
159     #h1.groups.append(all_groups[1])
160     #print("h1:",h1)
161     #print("----------->",all_groups.name,all_groups.bind_hosts)
162     u1 = session.query(UserProfile).filter(UserProfile.id==1).first()
163     print('--user:',u1.bind_hosts)
164     print('--user:',u1.groups[0].bind_hosts)
165     #u1.groups = [all_groups[1] ]
166     #u1.bind_hosts.append(all_bindhosts[1])
167     #u1 = UserProfile(username='alex',password='123')
168     #u2 = UserProfile(username='rain',password='abc!23')
169     #session.add_all([u1,u2])
170     #b1 = BindHost()
171     session.commit()
172     #print(h2.host_groups)
173     '''