day13_堡垒机

堡垒机介绍

前景介绍

到目前为止，很多公司对堡垒机依然不太感冒，其实是没有充分认识到堡垒机在IT管理中的重要作用的，很多人觉得，堡垒机就是跳板机，其实这个认识是不全面的，跳板功能只是堡垒机所具备的功能属性中的其中一项而已，下面我就给大家介绍一下堡垒机的重要性，以帮助大家参考自己公司的业务是否需要部署堡垒机。
堡垒机有以下两个至关重要的功能：

1、权限管理

当你公司的服务器变的越来越多后，需要操作这些服务器的人就肯定不只是一个运维人员，同时也可能包括多个开发人员，那么这么多的人操作业务系统，如果权限分配不当就会存在很大的安全风险，举几个场景例子：

1. 设想你们公司有300台Linux服务器，A开发人员需要登录其中5台WEB服务器查看日志或进行问题追踪等事务，同时对另外10台hadoop服务器有root权限，在有300台服务器规模的网络中，按常理来讲你是已经使用了ldap权限统一认证的，你如何使这个开发人员只能以普通用户的身份登录5台web服务器，并且同时允许他以管理员的身份登录另外10台hadoop服务器呢？并且同时他对其它剩下的200多台服务器没有访问权限。
2. 目前据我了解，很多公司的运维团队为了方面，整个运维团队的运维人员还是共享同一套root密码，这样内部信任机制虽然使大家的工作方便了，但同时存在着极大的安全隐患，很多情况下，一个运维人员只需要管理固定数量的服务器，毕竟公司分为不同的业务线，不同的运维人员管理的业务线也不同，但如果共享一套root密码，其实就等于无限放大了每个运维人员的权限，也就是说，如果某个运维人员想干坏事的话，他可以在几分钟内把整个公司的业务停转，甚至数据都给删除掉。为了降低风险，于是有人想到，把不同业务线的root密码改掉就ok了么，也就是每个业务线的运维人员只知道自己的密码，这当然是最简单有效的方式，但问题是如果你同时用了ldap,这样做又比较麻烦，即使你设置了root不通过ldap认证，那新问题就是，每次有运维人员离职，他所在的业务线的密码都需要重新改一次。

其实上面的问题，我觉得可以很简单的通过堡垒机来实现，收回所有人员的直接登录服务器的权限，所有的登录动作都通过堡垒机授权，运维人员或开发人员不知道远程服务器的密码，这些远程机器的用户信息都绑定在了堡垒机上，堡垒机用户只能看到他能用什么权限访问哪些远程服务器。
在回收了运维或开发人员直接登录远程服务器的权限后，其实就等于你们公司生产系统的所有认证过程都通过堡垒机来完成了，堡垒机等于成了你们生产系统的SSO(single sign on)模块了。你只需要在堡垒机上添加几条规则就能实现以下权限控制了：
1.允许A开发人员通过普通用户登录5台web服务器，通过root权限登录10台hadoop服务器，但对其余的服务器无任务访问权限
2.多个运维人员可以共享一个root账户，但是依然能分辨出分别是谁在哪些服务器上操作了哪些命令，因为堡垒机账户是每个人独有的，也就是说虽然所有运维人员共享了一同一个远程root账户，但由于他们用的堡垒账户都是自己独有的，因此依然可以通过堡垒机控制每个运维人员访问不同的机器。

2、审计管理

审计管理其实很简单，就是把用户的所有操作都纪录下来，以备日后的审计或者事故后的追责。在纪录用户操作的过程中有一个问题要注意，就是这个纪录对于操作用户来讲是不可见的，什么意思？就是指，无论用户愿不愿意，他的操作都会被纪录下来，并且，他自己如果不想操作被纪录下来，或想删除已纪录的内容，这些都是他做不到的，这就要求操作日志对用户来讲是不可见和不可访问的，通过堡垒机就可以很好的实现。

堡垒机架构

堡垒机的主要作用权限控制和用户行为审计，堡垒机就像一个城堡的大门，城堡里的所有建筑就是你不同的业务系统 ， 每个想进入城堡的人都必须经过城堡大门并经过大门守卫的授权，每个进入城堡的人必须且只能严格按守卫的分配进入指定的建筑，且每个建筑物还有自己的权限访问控制，不同级别的人可以到建筑物里不同楼层的访问级别也是不一样的。还有就是，每个进入城堡的人的所有行为和足迹都会被严格的监控和纪录下来，一旦发生犯罪事件，城堡管理人员就可以通过这些监控纪录来追踪责任人。

堡垒要想成功完全记到他的作用，只靠堡垒机本身是不够的， 还需要一系列安全上对用户进行限制的配合，堡垒机部署上后，同时要确保你的网络达到以下条件：
1、所有人包括运维、开发等任何需要访问业务系统的人员，只能通过堡垒机访问业务系统。回收所有对业务系统的访问权限，做到除了堡垒机管理人员，没有人知道业务系统任何机器的登录密码。网络上限制所有人员只能通过堡垒机的跳转才能访问业务系统 。
2、确保除了堡垒机管理员之外，所有其它人对堡垒机本身无任何操作权限，只有一个登录跳转功能。
3、确保用户的操作纪录不能被用户自己以任何方式获取到并篡改。

---

paramiko源码修改

paramiko下载

paramiko的源码的下载地址：https://github.com/paramiko/paramiko
改动的内容是在demos文件夹下，执行文件是python demos.py文件

源码修改

1、支持python3.0的源码修改

说明：由于python3.0支持所有的socket的都是bytes类型，所以，这边需要解码一下，转成str类型

2、demo.py

import base64
from binascii import hexlify
import getpass
import os
import select
import socket
import sys
import time
import traceback
from paramiko.py3compat import input

import paramiko
try:
    import interactive
except ImportError:
    from . import interactive


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 = input('Auth by (p)assword, (r)sa key, or (d)ss key? [%s] ' % default_auth)
    if len(auth) == 0:
        auth = default_auth

    if auth == 'r':
        default_path = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
        path = 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 = 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 = getpass.getpass('Password for %s@%s: ' % (username, hostname))
        t.auth_password(username, pw)


# setup logging
paramiko.util.log_to_file('demo.log')

username = ''
if len(sys.argv) > 1:
    hostname = sys.argv[1]
    if hostname.find('@') >= 0:
        username, hostname = hostname.split('@')
else:
    hostname = input('Hostname: ')
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 Exception as e:
    print('*** Connect failed: ' + str(e))
    traceback.print_exc()  #traceback模块是追踪异常，出现异常，打印出异常出现在哪一行
    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('**f* Unable to open host keys ile')
            keys = {}

    # check server's host key -- this is important.
    key = t.get_remote_server_key()
    if hostname not in keys:
        print('*** WARNING: Unknown host key!')
    elif key.get_name() not in keys[hostname]:
        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 = 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()  #生成一个ssh session
    chan.get_pty()
    chan.invoke_shell()
    print('*** Here we go!\n')
    interactive.interactive_shell(chan)
    chan.close()
    t.close()

except Exception as e:
    print('*** Caught exception: ' + str(e.__class__) + ': ' + str(e))
    traceback.print_exc()
    try:
        t.close()
    except:
        pass
    sys.exit(1)

3、修改interactive.py文件

说明：修改posix_shell函数中的内容，来获取用户执行的命令，我们需要把这些命令放入到数据库中，以便查看，到底是谁，操作了哪些命令

import socket
import sys
from paramiko.py3compat import u

# windows does not have termios...
try:
    import termios  #代表的是Linux的操作系统
    import tty
    has_termios = True
except ImportError:
    has_termios = False


def interactive_shell(chan):
    if has_termios:
        posix_shell(chan)
    else:
        windows_shell(chan)  #windows的，暂时在这边被我删掉了


def posix_shell(chan):
    import select

    oldtty = termios.tcgetattr(sys.stdin)    #终端标准输入
    try:
        tty.setraw(sys.stdin.fileno())
        tty.setcbreak(sys.stdin.fileno())
        chan.settimeout(0.0)
        cmd_list = []  #获取cmd的命令
        while True:
            r, w, e = select.select([chan, sys.stdin], [], [])
            if chan in r:
                try:
                    x = chan.recv(1024)
                    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 len(x) == 0:
                    break

                if x == '\r':  #判断x是否是空格
                    cmd_str = ''.join(cmd_list)  #拼接一个完整的命令
                    cmd_list = []  #清空列表
                    print("-->",cmd_str)
                else:
                    cmd_list.append(x)  #加入字符到命令列表中
                chan.send(x)

    finally:
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)

小结

1、下载的paramkio只需要执行demos文件夹下的demo.py文件
2、我们修改的目的是我们通过堡垒机操作远程机器的时，需要记录在机器上执行的命令，记录到数据中，以便查阅

---

堡垒机表结构设计

我们之前谈到的堡垒机，进行了paramiko源码修改，接下来我们来设置堡垒机的表结构

表结构设计图

代码

from sqlalchemy import  ForeignKey,Column,String,Integer,UniqueConstraint,Table
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy_utils import ChoiceType

Base = declarative_base()


user_m2m_bindhost = Table("user_m2m_bindhost",Base.metadata,
                          Column("userprofile_id",Integer,ForeignKey("userprofile.id")),
                          Column("bindhost_id",Integer,ForeignKey("bind_host.id"))
                          )

bindhost_m2m_hostgroup=Table("bindhost_m2m_hostgroup",Base.metadata,
                            Column("bindhost_id",Integer,ForeignKey("bindhost.id")),
                            Column("hostgroup_id",Integer,ForeignKey("hostgroup.id"))
                            )

userprofile_m2m_hostgroup=Table("userprofile_m2m_hostgroup",Base.metadata,
                            Column("userprofile_id",Integer,ForeignKey("user_profile.id")),
                            Column("hostgroup_id",Integer,ForeignKey("host_group.id"))
                            )

class Host(Base):
    __tablename__ = "host"
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True)
    ip = Column(String(64),unique=True)
    port = Column(Integer,unique=True)

    def __repr__(self):
        return self.hostname

class HostGroup(Base):
    __tablename__ = "host_group"
    id = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(64),unique=True)

    bind_hosts = relationship("BindHost",secondary="bindhost_m2m_hostgroup",backref="host_groups")
    def __repr__(self):
        return self.name


class RemoteUser(Base):
    __tablename__ = "remote_user"
    __table_args__ = (UniqueConstraint("auth_type","username","password",name="_user_password_uc"))
    id = Column(Integer,primary_key=True,autoincrement=True)
    AuthTypes = [
        ("ssh-password","SSH/Password"), #第1个值存数据库，第2个值是sqlalchemy显示的
        ("ssh-key","SSH/KEY")
    ]  #设置枚举值
    auth_type = Column(ChoiceType(AuthTypes))
    username = Column(String(64))
    password = Column(String(128))

    def __repr__(self):
        return  self.username

class BindHost(Base):
    "ip + 主机用户名 + 组名"
    __tablename__ = "bind_host"
    __table_args__ = (UniqueConstraint("host_id","group_id","remoteuser_id",name="_host_group_remoteuser_uc"))  #组合唯一

    id = Column(Integer,primary_key=True)
    host_id = Column(Integer,ForeignKey("host.id"))
    #group_id = Column(Integer,ForeignKey("group.id"))
    remoteuser_id = Column(Integer,ForeignKey("remoteuser.id"))

    host = relationship("Host",backref="bind_hosts")
    #host_group = relationship("HostGroup",backref="bind_hosts")
    remote_user = relationship("RemoteUser",backref="bind_hosts")

    def __repr__(self):
        return "<{0}--{1}--{2}>".format(self.host.ip,self.remote_user.username,self.host_group.name)



class UserProfile(Base):
    __tablename__ = "user_profile"
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(32),unique=True)
    password = Column(String(128))
    bind_hosts = relationship("BindHost",secondary="user_m2m_bindhost",backref="user_profiles")
    host_groups = relationship("HostGroup",secondary="userprofile_m2m_hostgroup",backref="user_profiles")
    def __repr__(self):
        return self.username