นี่เป็นแนวคิดสำหรับการรักษาความปลอดภัย พนักงานของเราจะสามารถเข้าถึงคำสั่งบางอย่างบนเซิร์ฟเวอร์ linux ได้ แต่ไม่ใช่ทั้งหมด พวกเขาจะต้องมีความเป็นไปได้ในการเข้าถึงไฟล์บันทึก ( less logfile) หรือเริ่มคำสั่งต่างๆ ( shutdown.sh/ run.sh)

ข้อมูลพื้นฐาน:

พนักงานทุกคนเข้าถึงเซิร์ฟเวอร์ด้วยชื่อผู้ใช้เดียวกัน: ผลิตภัณฑ์ของเราทำงานโดยใช้สิทธิ์ผู้ใช้ "ปกติ" ไม่จำเป็นต้อง "ติดตั้ง" เพียงแค่เปิดเครื่องรูดในผู้ใช้ของคุณและเรียกใช้ เราจัดการเซิร์ฟเวอร์หลายเครื่องที่ "ติดตั้ง" แอปพลิเคชันของเรา johndoeทุกเครื่องมีการใช้ บางครั้งพนักงานของเราจำเป็นต้องเข้าถึงแอปพลิเคชันบนบรรทัดคำสั่งเพื่อเข้าถึงและตรวจสอบไฟล์บันทึกหรือเพื่อเริ่มต้นแอปพลิเคชันด้วยมือ มีเพียงบางคนเท่านั้นที่สามารถเข้าถึงบรรทัดคำสั่งได้

เรากำลังใช้การพิสูจน์ตัวตน ppk บนเซิร์ฟเวอร์

จะดีมากถ้าพนักงาน 1 สามารถเข้าถึงไฟล์บันทึกได้เท่านั้นและพนักงาน 2 ก็สามารถทำ X ได้เช่นกัน ...

วิธีแก้ปัญหา: ฉันจะใช้commandตัวเลือกตามที่ระบุไว้ในคำตอบที่ยอมรับ ฉันจะสร้างเชลล์สคริปต์เล็ก ๆ ของฉันเองซึ่งจะเป็นไฟล์เดียวที่สามารถเรียกใช้งานได้สำหรับพนักงานบางคน สคริปต์จะเสนอคำสั่งหลายคำสั่งที่สามารถดำเนินการได้ แต่ไม่มีคำสั่งอื่น ฉันจะใช้พารามิเตอร์ต่อไปนี้authorized_keysจากที่ระบุไว้ที่นี่ :

command="/bin/myscript.sh",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty
ssh-dss AAAAB3....o9M9qz4xqGCqGXoJw= user@host

นี่คือความปลอดภัยเพียงพอสำหรับเรา ขอบคุณชุมชน!

คุณยังสามารถ จำกัด คีย์เฉพาะคำสั่งที่อนุญาตได้ (ในไฟล์ Author_keys)

กล่าวคือผู้ใช้จะไม่เข้าสู่ระบบผ่าน ssh จากนั้นมีชุดคำสั่งที่ จำกัด แต่จะได้รับอนุญาตให้ดำเนินการคำสั่งเหล่านั้นผ่าน ssh เท่านั้น (เช่น "ssh somehost bin / showlogfile")

sshทำตามrshประเพณีโดยใช้โปรแกรมเชลล์ของผู้ใช้จากไฟล์รหัสผ่านเพื่อดำเนินการคำสั่ง

ซึ่งหมายความว่าเราสามารถแก้ปัญหานี้ได้โดยไม่ต้องเกี่ยวข้องกับsshการกำหนดค่า แต่อย่างใด

หากคุณไม่ต้องการให้ผู้ใช้สามารถเข้าถึงเชลล์ได้ให้แทนที่เชลล์ของผู้ใช้นั้นด้วยสคริปต์ หากคุณมองเข้าไป/etc/passwdคุณจะเห็นว่ามีฟิลด์ที่กำหนดตัวแปลคำสั่งเชลล์ให้กับผู้ใช้แต่ละคน สคริปต์ที่ใช้เป็นเปลือกทั้งสำหรับการเข้าสู่ระบบแบบโต้ตอบของพวกเขาเช่นเดียวกับคำสั่งssh user@host ssh user@host command arg ...

นี่คือตัวอย่าง ฉันสร้างผู้ใช้fooที่มีเชลล์เป็นสคริปต์ สคริปต์จะพิมพ์ข้อความmy arguments are:ตามด้วยอาร์กิวเมนต์ (แต่ละบรรทัดแยกจากกันและในวงเล็บเหลี่ยม) และยุติ ในกรณีล็อกอินไม่มีข้อโต้แย้ง นี่คือสิ่งที่เกิดขึ้น:

webserver:~# ssh foo@localhost
foo@localhost's password:
Linux webserver [ snip ]
[ snip ]
my arguments are:
Connection to localhost closed.

หากผู้ใช้พยายามเรียกใช้คำสั่งจะมีลักษณะดังนี้:

webserver:~# ssh foo@localhost cat /etc/passwd
foo@localhost's password:
my arguments are:
<-c>
<cat /etc/passwd>

"เปลือก" ของเราได้รับ -cเรียกใช้สไตล์โดยคำสั่งทั้งหมดเป็นอาร์กิวเมนต์เดียวเช่นเดียวกับที่/bin/shจะได้รับ

อย่างที่คุณเห็นสิ่งที่เราทำได้ในตอนนี้คือพัฒนาสคริปต์ให้ไกลขึ้นเพื่อให้จดจำกรณีที่ถูกเรียกใช้ด้วย -cอาร์กิวเมนต์จากนั้นแยกวิเคราะห์สตริง (พูดโดยการจับคู่รูปแบบ) สตริงเหล่านั้นที่ได้รับอนุญาตสามารถส่งผ่านไปยังเชลล์จริงได้โดยการเรียกซ้ำ/bin/bash -c <string>สตริงผู้ที่ได้รับอนุญาตให้สามารถส่งผ่านไปยังเปลือกจริงโดยกล่าวอ้างซ้ำกรณีการปฏิเสธสามารถพิมพ์ข้อความแสดงข้อผิดพลาดและยุติ (รวมถึงกรณีที่-cหายไป)

คุณต้องระวังว่าคุณเขียนสิ่งนี้อย่างไร ฉันขอแนะนำให้เขียนเฉพาะการจับคู่เชิงบวกซึ่งอนุญาตเฉพาะสิ่งที่เฉพาะเจาะจงเท่านั้นและไม่อนุญาตอย่างอื่น

หมายเหตุ:หากคุณเป็นrootเช่นนั้นคุณยังสามารถเข้าสู่ระบบบัญชีนี้ได้โดยการลบล้างเชลล์ในไฟล์susu -s /bin/bash fooคำสั่งเช่นนี้ (แทนเชลล์ที่เลือก) ผู้ที่ไม่ใช่รูทไม่สามารถทำได้

นี่คือสคริปต์ตัวอย่างเช่น จำกัด ผู้ใช้ในการใช้เพียงsshสำหรับการเข้าถึงไปยังที่เก็บภายใต้git/git

#!/bin/sh

if [ $# -ne 2 ] || [ "$1" != "-c" ] ; then
  printf "interactive login not permitted\n"
  exit 1
fi

set -- $2

if [ $# != 2 ] ; then
  printf "wrong number of arguments\n"
  exit 1
fi

case "$1" in
  ( git-upload-pack | git-receive-pack )
    ;; # continue execution
  ( * )
    printf "command not allowed\n"
    exit 1
    ;;
esac

# Canonicalize the path name: we don't want escape out of
# git via ../ path components.

gitpath=$(readlink -f "$2")  # GNU Coreutils specific

case "$gitpath" in
  ( /git/* )
     ;; # continue execution
  ( * )
    printf "access denied outside of /git\n"
    exit 1
    ;;
esac

if ! [ -e "$gitpath" ] ; then
   printf "that git repo doesn't exist\n"
   exit 1
fi

"$1" "$gitpath"

แน่นอนเราเชื่อมั่นว่าโปรแกรม Git เหล่านี้git-upload-packและgit-receive-packไม่มีช่องโหว่หรือช่องโหว่ที่จะทำให้ผู้ใช้เข้าถึงระบบได้

ซึ่งมีอยู่ในรูปแบบข้อ จำกัด ประเภทนี้ ผู้ใช้ได้รับการรับรองความถูกต้องในการรันโค้ดในโดเมนความปลอดภัยบางโดเมนและเรากำลังยกเลิกข้อ จำกัด ที่จะ จำกัด โดเมนนั้นไว้ที่โดเมนย่อย ตัวอย่างเช่นหากคุณอนุญาตให้ผู้ใช้รันvimคำสั่งบนไฟล์เฉพาะเพื่อแก้ไขผู้ใช้ก็สามารถรับเชลล์:!sh[Enter]ได้

สิ่งที่คุณกำลังมองหาเรียกว่าเชลล์ที่ จำกัดเชลล์ Bash จัดเตรียมโหมดที่ผู้ใช้สามารถดำเนินการคำสั่งที่มีอยู่ในโฮมไดเร็กทอรีของตนเท่านั้น (และไม่สามารถย้ายไปยังไดเร็กทอรีอื่นได้) ซึ่งอาจดีพอสำหรับคุณ

ฉันพบว่ากระทู้นี้เป็นตัวอย่างมากหากล้าสมัยไปหน่อย

ทำไมคุณไม่เขียนล็อกอินเชลล์ของคุณเอง การใช้ Bash นั้นค่อนข้างง่าย แต่คุณสามารถใช้ภาษาใดก็ได้

ตัวอย่างใน Bash

ใช้โปรแกรมแก้ไขที่คุณชื่นชอบเพื่อสร้างไฟล์/root/rbash.sh(อาจเป็นชื่อหรือพา ธ ก็ได้ แต่ควรเป็นchown root:rootและchmod 700):

#!/bin/bash

commands=("man" "pwd" "ls" "whoami")
timestamp(){ date +'%Y-%m-%s %H:%M:%S'; }
log(){ echo -e "$(timestamp)\t$1\t$(whoami)\t$2" > /var/log/rbash.log; }
trycmd()
{
    # Provide an option to exit the shell
    if [[ "$ln" == "exit" ]] || [[ "$ln" == "q" ]]
    then
        exit
        
    # You can do exact string matching for some alias:
    elif [[ "$ln" == "help" ]]
    then
        echo "Type exit or q to quit."
        echo "Commands you can use:"
        echo "  help"
        echo "  echo"
        echo "${commands[@]}" | tr ' ' '\n' | awk '{print "  " $0}'
    
    # You can use custom regular expression matching:
    elif [[ "$ln" =~ ^echo\ .*$ ]]
    then
        ln="${ln:5}"
        echo "$ln" # Beware, these double quotes are important to prevent malicious injection
        
        # For example, optionally you can log this command
        log COMMAND "echo $ln"
    
    # Or you could even check an array of commands:
    else
        ok=false
        for cmd in "${commands[@]}"
        do
            if [[ "$cmd" == "$ln" ]]
            then
                ok=true
            fi
        done
        if $ok
        then
            $ln
        else
            log DENIED "$cmd"
        fi
    fi
}

# Optionally show a friendly welcome-message with instructions since it is a custom shell
echo "$(timestamp) Welcome, $(whoami). Type 'help' for information."

# Optionally log the login
log LOGIN "$@"

# Optionally log the logout
trap "trap=\"\";log LOGOUT;exit" EXIT

# Optionally check for '-c custom_command' arguments passed directly to shell
# Then you can also use ssh user@host custom_command, which will execute /root/rbash.sh
if [[ "$1" == "-c" ]]
then
    shift
    trycmd "$@"
else
    while echo -n "> " && read ln
    do
        trycmd "$ln"
    done
fi

สิ่งที่คุณต้องทำคือตั้งค่าไฟล์ปฏิบัติการนี้เป็นเชลล์ล็อกอินของคุณ ยกตัวอย่างเช่นการแก้ไข/etc/passwdไฟล์และแทนที่เปลือกเข้าสู่ระบบของคุณในปัจจุบันของผู้ใช้ที่มี/bin/bash/root/rbash.sh

นี่เป็นเพียงตัวอย่างง่ายๆ แต่คุณสามารถทำให้ขั้นสูงได้ตามที่คุณต้องการความคิดอยู่ที่นั่น ระวังอย่าล็อกตัวเองโดยเปลี่ยนล็อกอินเชลล์ของคุณเองและผู้ใช้เพียงคนเดียว และทดสอบสัญลักษณ์และคำสั่งแปลก ๆ เสมอเพื่อดูว่าปลอดภัยจริงหรือไม่

คุณสามารถทดสอบได้ด้วย: su -s /root/rbash.sh.

ระวังตรวจสอบให้แน่ใจว่าได้จับคู่คำสั่งทั้งหมดและระวังสัญลักษณ์แทน! ดีกว่าไม่รวมทุบตีสัญลักษณ์เช่น;, &, &&, ||, $และ backticks เพื่อให้แน่ใจว่า

ขึ้นอยู่กับอิสระที่คุณให้กับผู้ใช้มันจะไม่ปลอดภัยไปกว่านี้อีกแล้ว ฉันพบว่าบ่อยครั้งฉันต้องการให้ผู้ใช้ที่สามารถเข้าถึงคำสั่งที่เกี่ยวข้องได้เพียงไม่กี่คำสั่งและในกรณีนี้นี่เป็นทางออกที่ดีกว่าจริงๆ อย่างไรก็ตามคุณต้องการให้อิสระมากขึ้นการจำคุกและการอนุญาตอาจเหมาะสมกว่า ความผิดพลาดเกิดขึ้นได้ง่ายและสังเกตได้ก็ต่อเมื่อสายเกินไปแล้ว

คุณควรได้รับ `` rssh 'ซึ่งเป็นเชลล์ที่ถูก จำกัด

คุณสามารถทำตามคำแนะนำข้อ จำกัด ที่กล่าวถึงข้างต้นทั้งหมดนี้ค่อนข้างอธิบายตนเองได้และง่ายต่อการปฏิบัติตาม ทำความเข้าใจคำว่า `` chroot jail '' และวิธีใช้การกำหนดค่า sshd / terminal อย่างมีประสิทธิภาพและอื่น ๆ

ในฐานะที่เป็นผู้ใช้ส่วนใหญ่ของคุณเข้าถึงเทอร์มินัลของคุณผ่าน sshd คุณควรดูที่ sshd_conifg ไฟล์คอนฟิกูเรชัน SSH daemon เพื่อใช้ข้อ จำกัด บางอย่างผ่าน SSH ระวังอย่างไรก็ตาม ทำความเข้าใจกับสิ่งที่คุณพยายามนำไปใช้อย่างถูกต้องเนื่องจากการแบ่งส่วนของการกำหนดค่าที่ไม่ถูกต้องอาจค่อนข้างเลวร้าย

GNU Rushอาจเป็นวิธีที่ยืดหยุ่นและปลอดภัยที่สุดในการทำสิ่งนี้:

GNU Rush เป็นเชลล์ผู้ใช้ที่ถูก จำกัด ออกแบบมาสำหรับไซต์ที่ให้การเข้าถึงทรัพยากรจากระยะไกลอย่าง จำกัด เช่นที่เก็บ svn หรือ git, scp หรืออื่น ๆ ด้วยการใช้ไฟล์คอนฟิกูเรชันที่ซับซ้อน GNU Rush ช่วยให้คุณสามารถควบคุมบรรทัดคำสั่งที่ผู้ใช้เรียกใช้งานตลอดจนการใช้ทรัพยากรระบบเช่นหน่วยความจำเสมือนเวลาของ CPU เป็นต้น

คุณอาจต้องการที่จะดูที่การตั้งค่าคุก

อีกวิธีหนึ่งในการดูสิ่งนี้คือการใช้ POSIX ACL ซึ่งจำเป็นต้องได้รับการสนับสนุนจากระบบไฟล์ของคุณอย่างไรก็ตามคุณสามารถปรับแต่งคำสั่งทั้งหมดใน linux ได้อย่างละเอียดเช่นเดียวกับที่คุณมีการควบคุมเดียวกันบน Windows (เพียงแค่ไม่มี UI ที่ดีกว่า ). ลิงค์

สิ่งที่จะมองเข้าไปก็คือPolicyKit

คุณจะต้องทำ googling เล็กน้อยเพื่อให้ทุกอย่างทำงานได้เนื่องจากนี่ไม่ใช่จุดแข็งของ Linux ในขณะนี้

[การเปิดเผยข้อมูล: ฉันเขียน sshdo ซึ่งอธิบายไว้ด้านล่าง]

หากคุณต้องการให้ล็อกอินเป็นแบบโต้ตอบการตั้งค่าเชลล์ที่ จำกัด น่าจะเป็นคำตอบที่ถูกต้อง แต่ถ้ามีชุดคำสั่งจริงที่คุณต้องการอนุญาต (และไม่มีอะไรอื่น) และมันก็โอเคสำหรับคำสั่งเหล่านี้ที่จะดำเนินการทีละรายการผ่าน ssh (เช่น ssh user @ host cmd arg blah blah) ดังนั้นคำสั่งทั่วไปที่อนุญาตพิเศษสำหรับ ssh อาจเป็นสิ่งที่คุณต้องการ สิ่งนี้มีประโยชน์เมื่อคำสั่งถูกเขียนสคริปต์ที่ส่วนท้ายไคลเอนต์และไม่ต้องการให้ผู้ใช้พิมพ์คำสั่ง ssh

มีโปรแกรมชื่อ sshdo สำหรับทำสิ่งนี้ มันควบคุมคำสั่งที่อาจถูกเรียกใช้ผ่านการเชื่อมต่อ ssh ที่เข้ามา สามารถดาวน์โหลดได้ที่:

http://raf.org/sshdo/ (อ่านหน้าคู่มือที่นี่) https://github.com/raforg/sshdo/

มีโหมดการฝึกอบรมเพื่ออนุญาตคำสั่งทั้งหมดที่พยายามและตัวเลือก - เรียนรู้เพื่อสร้างการกำหนดค่าที่จำเป็นเพื่อให้คำสั่งที่เรียนรู้อย่างถาวร จากนั้นสามารถปิดโหมดการฝึกอบรมและคำสั่งอื่น ๆ จะไม่ถูกดำเนินการ

นอกจากนี้ยังมีตัวเลือก - unlearn เพื่อหยุดการอนุญาตคำสั่งที่ไม่ได้ใช้งานอีกต่อไปเพื่อรักษาสิทธิ์ขั้นต่ำที่เข้มงวดเนื่องจากความต้องการเปลี่ยนแปลงไปตามกาลเวลา

มันจุกจิกมากเกี่ยวกับสิ่งที่อนุญาต จะไม่อนุญาตคำสั่งที่มีอาร์กิวเมนต์ใด ๆ อนุญาตให้ใช้คำสั่งเชลล์ที่สมบูรณ์เท่านั้น

แต่สนับสนุนรูปแบบง่ายๆในการแสดงคำสั่งที่คล้ายกันซึ่งแตกต่างกันไปเฉพาะตัวเลขที่ปรากฏบนบรรทัดคำสั่งเท่านั้น (เช่นหมายเลขลำดับหรือการประทับวันที่ / เวลา)

มันเหมือนกับไฟร์วอลล์หรือการควบคุมรายการที่อนุญาตพิเศษสำหรับคำสั่ง ssh

และรองรับคำสั่งต่างๆที่อนุญาตสำหรับผู้ใช้ที่แตกต่างกัน