जब कोई गैर-रूट उपयोगकर्ता रूट उपयोगकर्ता की प्रक्रिया के लिए संकेत भेजता है तो क्या होता है?

Question

मैं UNIX संकेतों की सुरक्षा के बारे में सोच रहा हूं।

SIGKILLप्रक्रिया को मार देगा। तो, क्या होता है जब एक गैर रूट उपयोगकर्ता की प्रक्रिया रूट उपयोगकर्ता की प्रक्रिया को संकेत भेजती है? क्या प्रक्रिया अभी भी सिग्नल हैंडलर को अंजाम देती है?

मैं स्वीकृत उत्तर (गॉलम) का पालन करता हूं, और मैं टाइप करता हूं man capabilites, और मुझे लिनक्स कर्नेल के बारे में बहुत सारी चीजें मिलती हैं। से man capabilities:

NAME

   capabilities - overview of Linux capabilities
DESCRIPTION

   For the purpose of performing permission checks, traditional UNIX
   implementations distinguish two categories of processes: privileged
   processes (whose effective user ID is 0, referred to as superuser or
   root), and unprivileged processes (whose effective UID is nonzero).
   Privileged processes bypass all kernel permission checks, while
   unprivileged processes are subject to full permission checking based
   on the process's credentials (usually: effective UID, effective GID,
   and supplementary group list).

   Starting with kernel 2.2, Linux divides the privileges traditionally
   associated with superuser into distinct units, known as capabilities,
   which can be independently enabled and disabled.  Capabilities are a
   per-thread attribute.

Comments

इसके अलावा SIGKILL, जो एक विशेष मामला है और कर्नेल द्वारा पूरी तरह से प्रबंधित किया जाता है, संकेत केवल एक अनुरोध है। प्राप्त करने की प्रक्रिया उनके साथ कुछ भी कर सकती है जो वे चाहते हैं।

— 21

@chepner इसके अलावा SIGKILL और SIGSTOP ...

— jlliagre

@chepner प्राप्त करने की प्रक्रिया को सक्रिय रूप से तय करना है कि वह सिग्नल को संभालना चाहता है। यदि प्राप्त करने की प्रक्रिया ने ऐसा नहीं किया है, तो बहुत सारे सिग्नल डिफ़ॉल्ट रूप से प्रक्रिया को उसी तरह से मार देंगे, जिस तरह SIGKILLसे। प्रारंभ SIGINTमें SIGKILL, और SIGTERMसटीक एक ही प्रभाव होगा, केवल अंतर यह है कि प्राप्त करने की प्रक्रिया उनमें से कुछ के लिए इस डिफ़ॉल्ट को बदल सकती है।

— कास्परड

Answer 1

लिनक्स पर यह फ़ाइल क्षमताओं पर निर्भर करता है।

निम्नलिखित सरल लें mykill.c स्रोत :

#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>

void exit_usage(const char *prog) {
        printf("usage: %s -<signal> <pid>\n", prog);
        exit(1);
}

int main(int argc, char **argv) {
        pid_t pid;
        int sig;

        if (argc != 3)
                exit_usage(argv[0]);

        sig = atoi(argv[1]);
        pid = atoi(argv[2]);

        if (sig >= 0 || pid < 2)
                exit_usage(argv[0]);

        if (kill(pid, -sig) == -1) {
                perror("failed");
                return 1;
        }
        printf("successfully sent signal %d to process %d\n", -sig, pid);

        return 0;
}

इसे बनाओ:

gcc -Wall mykill.c -o /tmp/mykill

अब उपयोगकर्ता रूट के रूप में पृष्ठभूमि में एक नींद की प्रक्रिया शुरू करते हैं:

root@horny:/root# /bin/sleep 3600 &
[1] 16098

अब सामान्य उपयोगकर्ता इसे मारने की कोशिश करते हैं:

demouser@horny:/home/demouser$ ps aux | grep sleep
root     16098  0.0  0.0  11652   696 pts/20   S    15:06   0:00 sleep 500

demouser@horny:/home/demouser$ /tmp/mykill -9 16098
failed: Operation not permitted

अब जैसे ही रूट यूजर /tmp/mykillकैप बदलता है :

root@horny:/root# setcap cap_kill+ep /tmp/mykill

और फिर से सामान्य उपयोगकर्ता की तरह प्रयास करें:

demouser@horny:/home/demouser$ /tmp/mykill -9 16098
successfully sent signal 9 to process 16098

अंत में /tmp/mykillस्पष्ट कारणों के लिए हटा दें ;)

Comments

अपने सुराग का पालन करें, मैं "आदमी क्षमताओं" लिखते हैं और मैं के बारे में बात की एक बहुत कुछ मिल लिनक्स कर्नेल

— lovespring

Answer 2

कुछ भी तो नहीं:

strace kill -HUP 1
[...]
kill(1, SIGHUP)    = -1 EPERM (Operation not permitted)
[...]

Comments

क्या इस तरह की सुरक्षा ओएस स्तर द्वारा की जाती है या उपयोगकर्ता के सिग्नल हैंडलर में हार्ड कोडित है?

— lovespring

@lovespring कर्नेल लक्ष्य प्रक्रिया को संकेत नहीं देता है। Syscall को एक त्रुटि के साथ और इसके अलावा अनदेखा किया गया है।

— हाऊक लाजिंग

यह सामान्य रूप से सही नहीं है। यह क्षमताओं पर निर्भर करता है।

— गोलू

@psmears हाँ, लेकिन दूसरों के समान अवधारणाएं हैं (जैसे सोलारिस पर "विशेषाधिकार")। तो जवाब "कुछ भी नहीं" निश्चित रूप से गलत है।

— गोलम ३१'१६ को १५:०२

@ गोलम: यह बिल्कुल गलत नहीं है (आखिरकार, यह सभी यूनिक्स-परिवार के ओएस पर डिफ़ॉल्ट व्यवहार है, और उदाहरण के लिए पुराने लिनक्स कर्नेल सहित कई पर केवल एक ही संभव है) लेकिन आप सही हैं कि यह अधूरा है - लेकिन सिर्फ उल्लेख करना "क्षमताओं" के बारे में अधिक विस्तार में जाने के बिना, जहां वे

— सुपरसाइड होते हैं

Answer 3

kill(2) आदमी पृष्ठ बताते हैं:

लिनक्स नोट्स

अलग-अलग कर्नेल संस्करणों के अलावा, लिनक्स ने किसी अन्य प्रक्रिया को सिग्नल भेजने के लिए एक अनपेक्षित प्रक्रिया के लिए आवश्यक अनुमतियों के लिए अलग-अलग नियम लागू किए हैं। 1.0 से 1.2.2 के कर्नेल में, एक संकेत भेजा जा सकता है यदि प्रेषक की प्रभावी उपयोगकर्ता आईडी रिसीवर के मेल से मेल खाती है, या प्रेषक की वास्तविक उपयोगकर्ता आईडी रिसीवर से मेल खाती है। कर्नेल 1.2.3 से 1.3.77 तक, एक संकेत भेजा जा सकता है यदि प्रेषक की प्रभावी उपयोगकर्ता आईडी रिसीवर के वास्तविक या प्रभावी उपयोगकर्ता आईडी से मेल खाती है। वर्तमान नियम, जो POSIX.1-2001 के अनुरूप हैं, कर्नेल 1.3.78 में अपनाया गया था।

Comments

१.३..7 1.3 अत्यंत प्राचीन इतिहास है, १.३ के रूप में। 1995 या उसके बाद की तारीखें। 1.3 विकास श्रृंखला 2.0 (1996 में) तक

— चली

Answer 4

संकेत ले जाएगा, लेकिन प्रक्रिया के मालिक जड़ से संबंधित हैं। इसलिए, दूसरे उपयोगकर्ता को प्रक्रिया को समाप्त करने का अधिकार नहीं है, इसलिए आपको अनुमति त्रुटि समस्या प्राप्त होगी।

समाप्ति प्रक्रिया केवल तभी संभव है जब आप प्रक्रिया के स्वामित्व (उचित अधिकार) के मालिक हों।

Comments

नहीं, sys_kill वापस -1 देता है और इरान-पेमेंट होगा।

— पीटर कहते हैं कि मोनिका