लॉगिन के बाद कमांड के पूर्वनिर्धारित सेट में SSH उपयोगकर्ताओं को कैसे प्रतिबंधित करें?

Question 1

यह एक सुरक्षा के लिए एक विचार है। हमारे कर्मचारियों के पास लिनक्स सर्वर पर कुछ कमांड्स तक पहुंच होगी लेकिन सभी नहीं। वे उदाहरण के लिए एक लॉग फ़ाइल ( less logfile) का उपयोग करने या विभिन्न कमांड ( shutdown.sh/ run.sh) शुरू करने की संभावना रख सकते हैं ।

पृष्ठभूमि की जानकारी:

सभी कर्मचारी एक ही उपयोगकर्ता नाम के साथ सर्वर का उपयोग करते हैं: हमारा उत्पाद "सामान्य" उपयोगकर्ता अनुमतियों के साथ चलता है, कोई "स्थापना" की आवश्यकता नहीं है। बस इसे अपने उपयोगकर्ता में अनज़िप करें और इसे चलाएं। हम कई सर्वरों का प्रबंधन करते हैं जहां हमारा एप्लिकेशन "इंस्टॉल" है। हर मशीन पर एक उपयोगकर्ता है johndoe। हमारे कर्मचारियों को कभी-कभी लॉग फ़ाइलों तक पहुंचने और जांचने या हाथ से आवेदन को पुनः आरंभ करने के लिए कमांड लाइन पर एप्लिकेशन तक पहुंच की आवश्यकता होती है। केवल कुछ लोगों को पूर्ण कमांड लाइन का उपयोग करना होगा।

हम सर्वर पर ppk प्रमाणीकरण का उपयोग कर रहे हैं।

यह बहुत अच्छा होगा अगर कर्मचारी 1 केवल लॉगफ़ाइल का उपयोग कर सकता है और कर्मचारी 2 एक्स आदि भी कर सकता है ...

समाधान: एक समाधान के रूप में मैं commandविकल्प का उपयोग स्वीकार किए गए उत्तर में बताऊंगा। मैं अपनी खुद की एक छोटी सी शेल स्क्रिप्ट बनाऊंगा जो कुछ कर्मचारियों के लिए निष्पादित की जा सकने वाली एकमात्र फ़ाइल होगी । स्क्रिप्ट कई कमांड की पेशकश करेगी जिसे निष्पादित किया जा सकता है, लेकिन कोई अन्य नहीं। मैं यहाँauthorized_keys कहे अनुसार निम्नलिखित मापदंडों का उपयोग करूँगा :

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

यह हमारे लिए पर्याप्त सुरक्षा है। धन्यवाद, समुदाय!

Question 2

आप अनुमतियों को भी अनुमति दे सकते हैं अनुमेय कमांड (अधिकृत_की फ़ाइल में)।

यानी उपयोगकर्ता ssh के माध्यम से लॉग इन नहीं करेगा और फिर आदेशों का एक प्रतिबंधित सेट होगा, बल्कि केवल ssh के माध्यम से उन आदेशों को निष्पादित करने की अनुमति दी जाएगी (जैसे "ssh somehost bin / showlogfile")

Question 3

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, तो आप suकमांड में शेल को ओवरराइड करके भी इस तरह लॉग इन कर सकते हैं su -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]।

Question 4

जिसे आप ढूंढ रहे हैं उसे Restricted Shell कहा जाता है । बैश एक ऐसी विधा प्रदान करता है जिसमें उपयोगकर्ता केवल अपने घरेलू निर्देशिका में मौजूद आदेशों को निष्पादित कर सकते हैं (और वे अन्य निर्देशिकाओं में नहीं जा सकते हैं), जो आपके लिए काफी अच्छा हो सकता है।

अगर मुझे थोड़ा सा दिनांक दिया गया है, तो मुझे यह धागा बहुत ही निराशाजनक लग रहा है।

Question 5

आपको प्रतिबंधित शेल का अधिग्रहण करना चाहिए

आप ऊपर वर्णित प्रतिबंध गाइड का पालन कर सकते हैं, वे सभी आत्म-व्याख्यात्मक हैं, और सरल का पालन करें। शर्तों को समझें 'चेरोट जेल', और प्रभावी ढंग से sshd / टर्मिनल कॉन्फ़िगरेशन को कैसे लागू किया जाए, इत्यादि।

जैसा कि आपके अधिकांश उपयोगकर्ता sshd के माध्यम से आपके टर्मिनलों तक पहुँचते हैं, आपको SSH के माध्यम से कुछ प्रतिबंध लगाने के लिए, संभवतः sshd_conifg, SSH डेमॉन कॉन्फ़िगरेशन फ़ाइल को भी देखना चाहिए। हालाँकि, सावधान रहें। ठीक से समझें कि आप क्या लागू करने की कोशिश करते हैं, गलत विन्यास के प्रभाव के लिए शायद गंभीर हैं।

Question 6

आप अपना लॉगिन-शेल क्यों नहीं लिखते हैं? इसके लिए बैश का उपयोग करना काफी सरल होगा, लेकिन आप किसी भी भाषा का उपयोग कर सकते हैं।

बाश में उदाहरण

फ़ाइल बनाने के लिए अपने पसंदीदा संपादक का उपयोग करें /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।

खबरदार , पूरे कमांड का मिलान करना सुनिश्चित करें, और वाइल्डकार्ड के साथ सावधान रहें! बेहतर को बाहर जैसे बैश-प्रतीकों ;, &, &&, ||, $, और बैकटिक सुनिश्चित करने के लिए।

उपयोगकर्ता को आप जो स्वतंत्रता देते हैं, उसके आधार पर, यह इससे अधिक सुरक्षित नहीं होगा। मैंने पाया है कि अक्सर मुझे केवल एक उपयोगकर्ता बनाने की आवश्यकता होती है, जिसके पास केवल कुछ प्रासंगिक कमांड तक पहुंच होती है, और उस मामले में यह वास्तव में बेहतर समाधान है। हालाँकि, क्या आप अधिक स्वतंत्रता देना चाहते हैं, एक जेल और अनुमतियाँ अधिक उपयुक्त हो सकती हैं। गलतियाँ आसानी से हो जाती हैं, और केवल तब ही ध्यान दिया जाता है जब पहले से ही बहुत देर हो चुकी होती है।

Question 7

आप जेल की स्थापना को देखना चाहते हैं ।

Question 8

इसे पूरा करने के लिए GNU रश सबसे लचीला और सुरक्षित तरीका हो सकता है:

GNU रश एक प्रतिबंधित उपयोगकर्ता शेल है, जो उन साइटों के लिए डिज़ाइन किया गया है जो अपने संसाधनों तक सीमित रिमोट एक्सेस प्रदान करते हैं, जैसे कि svn या git रिपॉजिटरी, scp, या जैसे। परिष्कृत कॉन्फ़िगरेशन फ़ाइल का उपयोग करते हुए, GNU रश आपको उन कमांड लाइनों पर पूर्ण नियंत्रण प्रदान करता है जो उपयोगकर्ता निष्पादित करते हैं, साथ ही सिस्टम संसाधनों के उपयोग पर, जैसे कि वर्चुअल मेमोरी, सीपीयू समय, आदि।

Question 9

इसे देखने का एक अन्य तरीका POSIX ACL का उपयोग कर रहा है, इसे आपकी फ़ाइल प्रणाली द्वारा समर्थित होने की आवश्यकता है, हालाँकि आपके पास लिनक्स में सभी कमांडों की ठीक-ठीक ट्यूनिंग हो सकती है जिस तरह से आपके पास विंडोज पर एक ही नियंत्रण है (बस बिना अच्छे UI के) )। संपर्क

एक और बात पर गौर करना चाहिए ।

आपको काम करने के लिए काफी कुछ करना होगा क्योंकि यह निश्चित रूप से इस समय लिनक्स की ताकत नहीं है।

Question 10

[प्रकटीकरण: मैंने sshdo लिखा है जो नीचे वर्णित है]

अगर आप चाहते हैं कि लॉगिन इंटरेक्टिव हो तो प्रतिबंधित शेल सेट करना शायद सही जवाब है। लेकिन अगर कोई ऐसी आज्ञा है, जिसे आप अनुमति देना चाहते हैं (और कुछ नहीं) और इन आदेशों को व्यक्तिगत रूप से ssh (जैसे ssh user @ host cmd arg blah blah) द्वारा निष्पादित किया जाना ठीक है, तो इसके लिए एक सामान्य कमांड श्वेतसूची नियंत्रण ssh हो सकता है कि आपको क्या चाहिए। यह तब उपयोगी होता है जब कमांड को क्लाइंट अंत में किसी तरह से स्क्रिप्ट किया जाता है और उपयोगकर्ता को वास्तव में ssh कमांड में टाइप करने की आवश्यकता नहीं होती है।

ऐसा करने के लिए sshdo नामक एक कार्यक्रम है। यह नियंत्रित करता है कि आने वाले ssh कनेक्शन के माध्यम से किन कमांड्स को निष्पादित किया जा सकता है। यह डाउनलोड के लिए उपलब्ध है:

http://raf.org/sshdo/ (मैनुअल पेज यहां पढ़ें) https://github.com/raforg/sshdo/

इसमें सभी आदेशों का प्रयास करने के लिए एक प्रशिक्षण मोड है, और स्थायी रूप से सीखे गए आदेशों को अनुमति देने के लिए आवश्यक कॉन्फ़िगरेशन का उत्पादन करने के लिए एक -learn विकल्प है। फिर प्रशिक्षण मोड को बंद किया जा सकता है और किसी भी अन्य कमांड को निष्पादित नहीं किया जाएगा।

समय के साथ आवश्यकताओं में परिवर्तन के रूप में सख्त कम से कम विशेषाधिकार बनाए रखने के लिए इसका उपयोग करने की अनुमति देने वाले आदेशों को रोकने के लिए भी एक --unlearn विकल्प है।

यह बहुत ही उधम मचाता है कि यह क्या अनुमति देता है। यह किसी भी तर्क के साथ एक कमांड की अनुमति नहीं देगा। केवल पूर्ण शेल कमांड की अनुमति दी जा सकती है।

लेकिन यह समान आदेशों का प्रतिनिधित्व करने के लिए सरल पैटर्न का समर्थन करता है जो केवल कमांड लाइन पर दिखाई देने वाले अंकों में भिन्न होते हैं (जैसे अनुक्रम संख्या या दिनांक / समय टिकटों)।

यह एक फ़ायरवॉल या ssh कमांड के लिए श्वेतसूची नियंत्रण की तरह है।

और यह विभिन्न उपयोगकर्ताओं के लिए अनुमति दी जा रही विभिन्न कमांड का समर्थन करता है।