堡壘機

前景介紹

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

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

權限管理

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

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帳戶，但因爲他們用的堡壘帳戶都是本身獨有的，所以依然能夠經過堡壘機控制每一個運維人員訪問不一樣的機器。

審計管理

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

堡壘機架構 

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

 

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

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

堡壘機執行流程：

1. 管理員爲用戶在服務器上建立帳號（將公鑰放置服務器，或者使用用戶名密碼）
2. 用戶登錄堡壘機，輸入堡壘機用戶名密碼，現實當前用戶管理的服務器列表
3. 用戶選擇服務器，並自動登錄
4. 執行操做並同時將用戶操做記錄

堡壘機功能實現需求

業務需求:

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

功能需求：

1. 全部的用戶操做日誌要保留在數據庫中
2. 每一個用戶登陸堡壘機後，只須要選擇具體要訪問的設置，就鏈接上了，不須要再輸入目標機器的訪問密碼
3. 容許用戶對不一樣的目標設備有不一樣的訪問權限，例:
1. 對10.0.2.34 有mysql 用戶的權限
2. 對192.168.3.22 有root用戶的權限
3. 對172.33.24.55 沒任何權限
4. 分組管理，便可以對設置進行分組，容許用戶訪問某組機器，但對組裏的不一樣機器依然有不一樣的訪問權限　

設計表結構:

實現過程

import paramiko
import sys
import os
import socket
import select
import getpass
 
tran = paramiko.Transport(('10.211.55.4', 22,))
tran.start_client()
tran.auth_password('wupeiqi', '123')
 
# 打開一個通道
chan = tran.open_session()
# 獲取一個終端
chan.get_pty()
# 激活器
chan.invoke_shell()
 
#########
# 利用sys.stdin,肆意妄爲執行操做
# 用戶在終端輸入內容，並將內容發送至遠程服務器
# 遠程服務器執行命令，並將結果返回
# 用戶終端顯示內容
#########
 
chan.close()
tran.close()

基礎一

import paramiko
import sys
import os
import socket
import select
import getpass
from paramiko.py3compat import u
 
tran = paramiko.Transport(('10.211.55.4', 22,))
tran.start_client()
tran.auth_password('wupeiqi', '123')
 
# 打開一個通道
chan = tran.open_session()
# 獲取一個終端
chan.get_pty()
# 激活器
chan.invoke_shell()
 
while True:
    # 監視用戶輸入和服務器返回數據
    # sys.stdin 處理用戶輸入
    # chan 是以前建立的通道，用於接收服務器返回信息
    readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1)
    if chan in readable:
        try:
            x = u(chan.recv(1024))
            if len(x) == 0:
                print('\r\n*** EOF\r\n')
                break
            sys.stdout.write(x)
            sys.stdout.flush()
        except socket.timeout:
            pass
    if sys.stdin in readable:
        inp = sys.stdin.readline()
        chan.sendall(inp)
 
chan.close()
tran.close()

密碼登陸簡單版

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import paramiko
import sys
import os
import socket
import select
import getpass
from paramiko.py3compat import u


default_username = getpass.getuser()
username = input('Username [%s]: ' % default_username)
if len(username) == 0:
    username = default_username


hostname = input('Hostname: ')
if len(hostname) == 0:
    print('*** Hostname required.')
    sys.exit(1)

tran = paramiko.Transport((hostname, 22,))
tran.start_client()

default_auth = "p"
auth = input('Auth by (p)assword or (r)sa 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)
    tran.auth_publickey(username, key)
else:
    pw = getpass.getpass('Password for %s@%s: ' % (username, hostname))
    tran.auth_password(username, pw)



# 打開一個通道
chan = tran.open_session()
# 獲取一個終端
chan.get_pty()
# 激活器
chan.invoke_shell()

while True:
    # 監視用戶輸入和服務器返回數據
    # sys.stdin 處理用戶輸入
    # chan 是以前建立的通道，用於接收服務器返回信息
    readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1)
    if chan in readable:
        try:
            x = u(chan.recv(1024))
            if len(x) == 0:
                print('\r\n*** EOF\r\n')
                break
            sys.stdout.write(x)
            sys.stdout.flush()
        except socket.timeout:
            pass
    if sys.stdin in readable:
        inp = sys.stdin.readline()
        chan.sendall(inp)

chan.close()
tran.close()

完整示例（一）

簡易完整版

import paramiko
import sys
import os
import socket
import select
import getpass
import termios
import tty
from paramiko.py3compat import u
 
tran = paramiko.Transport(('10.211.55.4', 22,))
tran.start_client()
tran.auth_password('wupeiqi', '123')
 
# 打開一個通道
chan = tran.open_session()
# 獲取一個終端
chan.get_pty()
# 激活器
chan.invoke_shell()
 
 
# 獲取原tty屬性
oldtty = termios.tcgetattr(sys.stdin)
try:
    # 爲tty設置新屬性
    # 默認當前tty設備屬性：
    #   輸入一行回車，執行
    #   CTRL+C 進程退出，遇到特殊字符，特殊處理。
 
    # 這是爲原始模式，不認識全部特殊符號
    # 放置特殊字符應用在當前終端，如此設置，將全部的用戶輸入均發送到遠程服務器
    tty.setraw(sys.stdin.fileno())
    chan.settimeout(0.0)
 
    while True:
        # 監視 用戶輸入 和 遠程服務器返回數據（socket）
        # 阻塞，直到句柄可讀
        r, w, e = select.select([chan, sys.stdin], [], [], 1)
        if chan in r:
            try:
                x = u(chan.recv(1024))
                if len(x) == 0:
                    print('\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
            chan.send(x)
 
finally:
    # 從新設置終端屬性
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
 
 
chan.close()
tran.close()

進階一密碼登陸

import paramiko
import sys
import os
import socket
import select
import getpass
import termios
import tty
from paramiko.py3compat import u


default_username = getpass.getuser()
username = input('Username [%s]: ' % default_username)
if len(username) == 0:
    username = default_username


hostname = input('Hostname: ')
if len(hostname) == 0:
    print('*** Hostname required.')
    sys.exit(1)

tran = paramiko.Transport((hostname, 22,))
tran.start_client()

default_auth = "p"
auth = input('Auth by (p)assword or (r)sa 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)
    tran.auth_publickey(username, key)
else:
    pw = getpass.getpass('Password for %s@%s: ' % (username, hostname))
    tran.auth_password(username, pw)

# 打開一個通道
chan = tran.open_session()
# 獲取一個終端
chan.get_pty()
# 激活器
chan.invoke_shell()


# 獲取原tty屬性
oldtty = termios.tcgetattr(sys.stdin)
try:
    # 爲tty設置新屬性
    # 默認當前tty設備屬性：
    #   輸入一行回車，執行
    #   CTRL+C 進程退出，遇到特殊字符，特殊處理。

    # 這是爲原始模式，不認識全部特殊符號
    # 放置特殊字符應用在當前終端，如此設置，將全部的用戶輸入均發送到遠程服務器
    tty.setraw(sys.stdin.fileno())
    chan.settimeout(0.0)

    while True:
        # 監視 用戶輸入 和 遠程服務器返回數據（socket）
        # 阻塞，直到句柄可讀
        r, w, e = select.select([chan, sys.stdin], [], [], 1)
        if chan in r:
            try:
                x = u(chan.recv(1024))
                if len(x) == 0:
                    print('\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
            chan.send(x)

finally:
    # 從新設置終端屬性
    termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)


chan.close()
tran.close()

絕對不改版本

進階二密碼祕鑰登陸完整版

import paramiko
import sys
import os
import socket
import getpass

from paramiko.py3compat import u

# windows does not have termios...
try:
    import termios
    import tty
    has_termios = True
except ImportError:
    has_termios = False


def interactive_shell(chan):
    if has_termios:
        posix_shell(chan)
    else:
        windows_shell(chan)


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)
        log = open('handle.log', 'a+', encoding='utf-8')
        flag = False
        temp_list = []
        while True:
            r, w, e = select.select([chan, sys.stdin], [], [])
            if chan in r:
                try:
                    x = u(chan.recv(1024))
                    if len(x) == 0:
                        sys.stdout.write('\r\n*** EOF\r\n')
                        break
                    if flag:
                        if x.startswith('\r\n'):
                            pass
                        else:
                            temp_list.append(x)
                        flag = False
                    sys.stdout.write(x)
                    sys.stdout.flush()
                except socket.timeout:
                    pass
            if sys.stdin in r:
                x = sys.stdin.read(1)
                import json

                if len(x) == 0:
                    break

                if x == '\t':
                    flag = True
                else:
                    temp_list.append(x)
                if x == '\r':
                    log.write(''.join(temp_list))
                    log.flush()
                    temp_list.clear()
                chan.send(x)

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


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)
            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


def run():
    tran = paramiko.Transport(('10.211.55.4', 22,))
    tran.start_client()
    tran.auth_password('wupeiqi', '123')

    # 打開一個通道
    chan = tran.open_session()
    # 獲取一個終端
    chan.get_pty()
    # 激活器
    chan.invoke_shell()

    interactive_shell(chan)

    chan.close()
    tran.close()


if __name__ == '__main__':
    run()

打死也不改版本

進階二密碼登陸完整版

 

import paramiko
import sys
import os
import socket
import getpass

from paramiko.py3compat import u

# windows does not have termios...
try:
    import termios
    import tty
    has_termios = True
except ImportError:
    has_termios = False


def interactive_shell(chan):
    if has_termios:
        posix_shell(chan)
    else:
        windows_shell(chan)


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)
        log = open('handle.log', 'a+', encoding='utf-8')
        flag = False
        temp_list = []
        while True:
            r, w, e = select.select([chan, sys.stdin], [], [])
            if chan in r:
                try:
                    x = u(chan.recv(1024))
                    if len(x) == 0:
                        sys.stdout.write('\r\n*** EOF\r\n')
                        break
                    if flag:
                        if x.startswith('\r\n'):
                            pass
                        else:
                            temp_list.append(x)
                        flag = False
                    sys.stdout.write(x)
                    sys.stdout.flush()
                except socket.timeout:
                    pass
            if sys.stdin in r:
                x = sys.stdin.read(1)
                import json

                if len(x) == 0:
                    break

                if x == '\t':
                    flag = True
                else:
                    temp_list.append(x)
                if x == '\r':
                    log.write(''.join(temp_list))
                    log.flush()
                    temp_list.clear()
                chan.send(x)

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


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)
            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


def run():
    default_username = getpass.getuser()
    username = input('Username [%s]: ' % default_username)
    if len(username) == 0:
        username = default_username


    hostname = input('Hostname: ')
    if len(hostname) == 0:
        print('*** Hostname required.')
        sys.exit(1)

    tran = paramiko.Transport((hostname, 22,))
    tran.start_client()

    default_auth = "p"
    auth = input('Auth by (p)assword or (r)sa 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)
        tran.auth_publickey(username, key)
    else:
        pw = getpass.getpass('Password for %s@%s: ' % (username, hostname))
        tran.auth_password(username, pw)

    # 打開一個通道
    chan = tran.open_session()
    # 獲取一個終端
    chan.get_pty()
    # 激活器
    chan.invoke_shell()

    interactive_shell(chan)

    chan.close()
    tran.close()


if __name__ == '__main__':
    run()

終極

Final Version