堡壘機

本文轉載自查看原文 2016-07-29 14:19 8474

前景介紹

到目前為止，很多公司對堡壘機依然不太感冒，其實是沒有充分認識到堡壘機在IT管理中的重要作用的，很多人覺得，堡壘機就是跳板機，其實這個認識是不全面的，跳板功能只是堡壘機所具備的功能屬性中的其中一項而已，下面我就給大家介紹一下堡壘機的重要性，以幫助大家參考自己公司的業務是否需要部署堡壘機。

堡壘機有以下兩個至關重要的功能：

權限管理

當你公司的服務器變的越來越多后，需要操作這些服務器的人就肯定不只是一個運維人員，同時也可能包括多個開發人員，那么這么多的人操作業務系統，如果權限分配不當就會存在很大的安全風險，舉幾個場景例子：

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

其實上面的問題，我覺得可以很簡單的通過堡壘機來實現，收回所有人員的直接登錄服務器的權限，所有的登錄動作都通過堡壘機授權，運維人員或開發人員不知道遠程服務器的密碼，這些遠程機器的用戶信息都綁定在了堡壘機上，堡壘機用戶只能看到他能用什么權限訪問哪些遠程服務器。

在回收了運維或開發人員直接登錄遠程服務器的權限后，其實就等於你們公司生產系統的所有認證過程都通過堡壘機來完成了，堡壘機等於成了你們生產系統的SSO(single sign on)模塊了。你只需要在堡壘機上添加幾條規則就能實現以下權限控制了：

允許A開發人員通過普通用戶登錄5台web服務器，通過root權限登錄10台hadoop服務器，但對其余的服務器無任務訪問權限
多個運維人員可以共享一個root賬戶，但是依然能分辨出分別是誰在哪些服務器上操作了哪些命令，因為堡壘機賬戶是每個人獨有的，也就是說雖然所有運維人員共享了一同一個遠程root賬戶，但由於他們用的堡壘賬戶都是自己獨有的，因此依然可以通過堡壘機控制每個運維人員訪問不同的機器。

審計管理

審計管理其實很簡單，就是把用戶的所有操作都紀錄下來，以備日后的審計或者事故后的追責。在紀錄用戶操作的過程中有一個問題要注意，就是這個紀錄對於操作用戶來講是不可見的，什么意思？就是指，無論用戶願不願意，他的操作都會被紀錄下來，並且，他自己如果不想操作被紀錄下來，或想刪除已紀錄的內容，這些都是他做不到的，這就要求操作日志對用戶來講是不可見和不可訪問的，通過堡壘機就可以很好的實現。

堡壘機架構

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

壘要想成功完全記到他的作用，只靠堡壘機本身是不夠的，還需要一系列安全上對用戶進行限制的配合，堡壘機部署上后，同時要確保你的網絡達到以下條件：

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

堡壘機執行流程：

管理員為用戶在服務器上創建賬號（將公鑰放置服務器，或者使用用戶名密碼）
用戶登陸堡壘機，輸入堡壘機用戶名密碼，現實當前用戶管理的服務器列表
用戶選擇服務器，並自動登陸
執行操作並同時將用戶操作記錄

堡壘機功能實現需求

業務需求:

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

功能需求：

所有的用戶操作日志要保留在數據庫中
每個用戶登錄堡壘機后，只需要選擇具體要訪問的設置，就連接上了，不需要再輸入目標機器的訪問密碼
允許用戶對不同的目標設備有不同的訪問權限，例:

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

分組管理，即可以對設置進行分組，允許用戶訪問某組機器，但對組里的不同機器依然有不同的訪問權限

設計表結構:

實現過程

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 什么是堡壘機小白接觸堡壘機跳板機和堡壘機堡壘機介紹用paramiko寫堡壘機 Web堡壘機搭建jumpserver堡壘機 Jumpserver堡壘機部署 teleport堡壘機-簡單堡壘機的使用