ICode9

精准搜索请尝试: 精确搜索
首页 > 系统相关> 文章详细

linux 服务端热升级 备份

2020-09-16 17:04:08  阅读:12  来源: 互联网

标签:real effective 备份 printf user linux root ID 服务端


转: https://zhuanlan.zhihu.com/p/37278278

网络编程中的SO_REUSEADDR和SO_REUSEPORT参数详解

SO_REUSEADDR:

目前为止我见到的设置SO_REUSEADDR的使用场景:server端在调用bind函数时

setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,(const void *)&reuse , sizeof(int));

目的:当服务端出现timewait状态的链接时,确保server能够重启成功。

注意:SO_REUSEADDR只有针对time-wait链接(linux系统time-wait连接持续时间为1min),确保server重启成功的这一个作用,至于网上有文章说:如果有socket绑定了0.0.0.0:port;设置该参数后,其他socket可以绑定本机ip:port。本人经过试验后均提示“Address already in use”错误,绑定失败。

举个例子:

server监听9980端口,由于主动关闭链接,产生了一个time-wait状态的链接:

如果此时server重启,并且server没有设置SO_REUSEADDR参数,server重启失败,报错:“Address already in use”

如果设置SO_REUSEADDR,重启ok;

 

SO_REUSEPORT:

SO_REUSEPORT使用场景:linux kernel 3.9 引入了最新的SO_REUSEPORT选项,使得多进程或者多线程创建多个绑定同一个ip:port的监听socket,提高服务器的接收链接的并发能力,程序的扩展性更好;此时需要设置SO_REUSEPORT(注意所有进程都要设置才生效)。

setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT,(const void *)&reuse , sizeof(int));

目的:每一个进程有一个独立的监听socket,并且bind相同的ip:port,独立的listen()和accept();提高接收连接的能力。(例如nginx多进程同时监听同一个ip:port)

解决的问题:

(1)避免了应用层多线程或者进程监听同一ip:port的“惊群效应”。

(2)内核层面实现负载均衡,保证每个进程或者线程接收均衡的连接数。

(3)只有effective-user-id相同的服务器进程才能监听同一ip:port (安全性考虑)

代码示例:server_128.c

#include <stdio.h>                                                                                                               
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <sys/wait.h>
void work () {
        int listenfd = socket(AF_INET, SOCK_STREAM, 0);
        if (listenfd < 0) {
                perror("listen socket");
                _exit(-1);
        }
        int ret = 0;
        int reuse = 1;
        ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,(const void *)&reuse , sizeof(int));
        if (ret < 0) {
                perror("setsockopt");
                _exit(-1);
        }
        ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT,(const void *)&reuse , sizeof(int));
        if (ret < 0) {
            perror("setsockopt");
            _exit(-1);
        }
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        //addr.sin_addr.s_addr = inet_addr("10.95.118.221");
        addr.sin_addr.s_addr = inet_addr("0.0.0.0");                                                                             
        addr.sin_port = htons(9980);
        ret = bind(listenfd, (struct sockaddr *)&addr, sizeof(addr));
        if (ret < 0) {
                perror("bind addr");
                _exit(-1);
       }
        printf("bind success\n");
        ret = listen(listenfd,10);
        if (ret < 0) {
                perror("listen");
                _exit(-1);
        }
        printf("listen success\n");
        struct sockaddr clientaddr;
        int len = 0;
        while(1) {
                printf("process:%d accept...\n", getpid());
                int clientfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
                if (clientfd < 0) {
                        printf("accept:%d %s", getpid(),strerror(errno));
                        _exit(-1);
                }
                close(clientfd);
                printf("process:%d close socket\n", getpid());
        }
}
int main(){
        printf("uid:%d euid:%d\n", getuid(),geteuid());
        int i = 0;
        for (i = 0; i< 6; i++) {
                pid_t pid = fork();
                if (pid == 0) {
                        work();
                }
                if(pid < 0) {
                        perror("fork");
                        continue;
                }
        }
        int status,id;
        while((id=waitpid(-1, &status, 0)) > 0) {
                printf("%d exit\n", id);
        }
        if(errno == ECHILD) {
                printf("all child exit\n");
        }
        return 0;
}                              

上述示例程序,启动了6个子进程,每个子进程创建自己的监听socket,bind相同的ip:port;独立的listen(),accept();如果每个子进程不设置SO_REUSEADDR选项,会提示“Address already in use”错误。

安全性:是不是只要设置了SO_REUSEPORT选项的服务器程序,就能够监听相同的ip:port;并获取报文呢?当然不是,当前linux内核要求后来启动的服务器程序与前面启动的服务器程序的effective-user-id要相同。

举个例子:

上图中的server_127和server128两个服务器程序都设置了SO_REUSEPORT,监听同一ip:port,用root用户启动两个服务器程序,因为effective-user-id相等,都为0,所以启动没问题。

修改server127的权限chmod u+s server_127

启动完server_128后,在启动server_127,提示错误:

 

参考网站:

https://blog.csdn.net/taiyang1987912/article/details/40651623

chmod u+s用法和setuid(),seteuid()

在使用 setuid() 函数时会遇到 3 个关于 ID 的概念:
real user ID -- 真实用户 ID
effective user ID -- 有效用户 ID
saved set-user-ID -- 保存了的设置用户 ID。

真实用户 ID (real user ID) 就是通常所说的 UID,在 /etc/passwd 中能看到它的身影,如:

beyes:x:1000:1000:beyes,206,26563288,63230688:/home/beyes:/bin/bash

它用来标识系统中各个不同的用户。普通用户无法改变这个 ID 值。

有效用户 ID (effective) 表明,在运行一个程序时,你是以哪种有效身份运行它的。一般而言,有效用户ID 等于 真实用户 ID。这两个 ID 值可以用 geteuid() 和 getuid() 函数获取。

 

 

  1.   #include <sys/types.h>
  2.   #include <unistd.h>
  3.   #include <stdio.h>
  4.   #include <stdlib.h>
  5.    
  6.   int main(void)
  7.   {
  8.   printf ("The real user ID is: %d\n", getuid());
  9.   printf ("The effective user ID is :%d\n", geteuid());
  10.   return (0);
  11.   }

编译程序后,查看生成的可执行文件权限:

 

$ls -l getuid.exe
-rwxr-xr-x 1 beyes beyes 4775 Jun  9 15:38 getuid.exe

普通用户运行:

$ ./getuid.exe
The real user ID is: 1000
The effective user ID is :1000

root 用户运行:

# ./getuid.exe
The real user ID is: 0
The effective user ID is :0

这就是所说的一般情况:实际用户ID == 有效用户 ID

下面看不一致的情况:
使用 chmod 改变该程序的有效权限位(suid):

$ chmod u+s getuid.exe
$ ls -l getuid.exe
-rwsr-xr-x 1 beyes beyes 4775 Jun  9 15:38 getuid.exe


再使用普通用户运行:

$ ./getuid.exe
The real user ID is: 1000
The effective user ID is :1000

切换到 root 用户运行:

# ./getuid.exe
The real user ID is: 0
The effective user ID is :1000

从 root 运行输出来看,有效用户 ID 的值为 1000 。也就是说,root 运行这个程序时,是没有 root 的权限的,它只有 beyes 这个普通用户(实际用户 ID 为 1000)的权限。关于设置有效权限位可以参考:http://www.groad.net/bbs/read.php?tid-367.html

下面用一个实例来验证 root 运行此程序时只有 beyes 这个普通用户的权限,按下面步骤来进行:

1. 现在 /root 目录下创建一个普通的文本文件 rootfile.txt :

# echo "hello world" > /root/rootfile.txt
# ls -l /root/rootfile.txt
-rw-r--r-- 1 root root 12 Jun  9 15:48 /root/rootfile.txt


2. 修改上面的程序代码为:

  1.   #include <sys/types.h>
  2.   #include <unistd.h>
  3.   #include <stdio.h>
  4.   #include <stdlib.h>
  5.    
  6.   int main(void)
  7.   {
  8.   const char *file = "/root/rootfile.txt";
  9.    
  10.   printf ("The real user ID is: %d\n", getuid());
  11.   printf ("The effective user ID is :%d\n", geteuid());
  12.    
  13.   if (!unlink (file))
  14.   printf ("Ok, I am root, and I can delete the file which in /root directory.\n");
  15.   else
  16.   perror ("unlink error");
  17.    
  18.   return (0);
  19.   }

在上面的代码中所要做的事情很简单,就是要尝试删除 /root/rootfile.txt 这个文件。使用普通用户来编译该程序。

现在先使用普通用户来运行该程序:

$ ./getuid.exe
The real user ID is: 1000
The effective user ID is :1000
unlink error: Permission denied

很自然,普通用户没有权限删除 /root 下的文件。

下面使用 root 来运行该程序:

# ./getuid.exe
The real user ID is: 0
The effective user ID is :0
Ok, I am root, and I can delete the file which in /root directory.

也很正常,root 有权限删除它目录下的文件。

现在为这个程序添加有效权限位,注意这里是用普通用户运行的 chmod 命令:

beyes@debian:~$ chmod u+s getuid.exe
beyes@debian:~$ ls -l getuid.exe
-rwsr-xr-x 1 beyes beyes 5211 Jun 10 10:45 getuid.exe

再次分别以 普通用户 和 root 用户运行上面的程序:

普通用户:

$ ./getuid.exe
The real user ID is: 1000
The effective user ID is :1000
unlink error: Permission denied

还是一样,普通用户并没有权限删除 /root 下的文件。

root 用户:

# ./getuid.exe
The real user ID is: 0
The effective user ID is :1000
unlink error: Permission denied

由输出可见,root 用户也没法删除该文件!同时我们看到,此时的 有效用户 ID 值为 1000,所以我们知道,这个程序所赋予操作文件的权限不但要检查实际用户ID,更重要的是要考虑 有效用户ID ;如果 有效用户 没有权限删除,那么换成 root 用户它也相当于被降权了,当然这个降权仅限于在这个程序的空间中。



下面通过 setuid() 和 seteuid() 这两个函数来考察一下 saved set-user-ID (保存的设置用户ID)这个概念。

在使用 setuid() 时会遇到如下情况:
1. 若进程有 root 权限,则函数将实际用户 ID、有效用户 ID 设置为参数 uid  。见如下代码:

 

 

  1.   #include <stdio.h>
  2.   #include <stdlib.h>
  3.   #include <sys/types.h>
  4.   #include <unistd.h>
  5.    
  6.   void show_ids(void)
  7.   {
  8.   printf ("real uid: %d\n", getuid());
  9.   printf ("effective uid: %d\n", geteuid());
  10.   }
  11.    
  12.   int main(int argc, char *argv[])
  13.   {
  14.    
  15.   int uid;
  16.   show_ids();
  17.   uid = atoi(argv[1]);
  18.    
  19.   if (setuid (uid) < 0)
  20.   perror ("setuid error");
  21.    
  22.   show_ids();
  23.    
  24.   return (0);
  25.   }

下面使用 root 用户来运行上面的程序:

 

# ./setuid.exe 1001
real uid: 0
effective uid: 0
real uid: 1001
effective uid: 1001

由此可见,在 root 下,实际用户 ID 和有效用户 ID 均被设为 setuid() 的参数 uid 的值。

2. 若进程不具有 root 权限,那么普通用户使用 setuid() 时参数 uid 只能是自己的,没有权限设置别的数值,否则返回失败:
使用普通用户来运行:

$ ./setuid.exe 1001
real uid: 1000
effective uid: 1000
setuid error: Operation not permitted
real uid: 1000
effective uid: 1000

由以上可以看出,只有超级用户进程才能更改实际用户 ID 。所以一个非特权用户进程不能通过 setuid 或 seteuid 得到特权用户权限。

这里考虑 su 这个程序,su 可以将普通用户切换到 root 用户。这是因为,su 被设置了 有效权限位:

# ll /bin/su
-rwsr-xr-x 1 root root 29152 Feb 16 04:50 /bin/su

如上面所做实验描述的一样,普通用户在运行 su 时,它也就拥有了 root 的权限。

对于调用了 setuid() 函数的程序要格外小心,当进程的有效用户 ID 即 euid 是 root 用户时(设置了有效权限位),如果调用了 setuid() ,那么它会与它相关的所有 ID (real user ID, effective user ID,saved set-user-ID) 都变成它参数里所设的 ID,这样该进程就变成了普通用户进程,也就再也恢复不了 root 权限了。看下面代码:

 

 

  1.   #include <stdio.h>
  2.   #include <stdlib.h>
  3.    
  4.   void show_ids (void)
  5.   {
  6.   printf ("The real user ID is: %d\n", getuid());
  7.   printf ("The effective user ID is :%d\n", geteuid());
  8.   }
  9.    
  10.   int main(void)
  11.   {
  12.   const char *file = "/root/rootfile3.txt";  
  13.           setuid (0)
  14.   show_ids();
  15.   if (!unlink (file)) {
  16.   printf ("Ok, I am root, and I can delete the file which in /root directory.\n");
  17.   system ("echo hello world > /root/rootfile3.txt");
  18.   printf ("Now, drop the root privileges.\n");
  19.   if (setuid (1000) < 0) {
  20.   perror ("setuid");
  21.   exit (EXIT_FAILURE);
  22.   }
  23.   show_ids();
  24.   if (unlink (file) < 0) {
  25.   printf ("Ok, we have no privilege to delete rootfile.txt.\n");
  26.   }
  27.   printf ("try to regain root power again...\n");
  28.   if (seteuid (0)) {
  29.   perror ("seteuid");
  30.   show_ids();
  31.   exit (EXIT_FAILURE);
  32.   }
  33.   }

 


我们使用 root 编译上面的程序,并运行 chmod u+s 给程序添加 suid 位,然后以普通用户来运行它:

# ./getuid3 The real user ID is: 0The effective user ID is :0Ok, I am root, and I can delete the file which in /root directory.Now, drop the root privileges.The real user ID is: 1000The effective user ID is :1000Ok, we have no privilege to delete rootfile.txt.try to regain root power again...seteuid: Operation not permittedThe real user ID is: 1000The effective user ID is :1000

由输出可见,在运行 setuid (1000) 函数时,我们还是具有 root 权限的,所以该函数会设置成功。正是因为有了 root 权限,所以 3 个 ID (真实用户ID,已保存用户ID,有效用户ID)都会被设置为 1000。所以在运行完 setuid(1000) 后,进程已经被降权为普通用户,此时想再  seteuid (0) 提高权限已经不可能。这里需要提到一点,对于 show_ids() 函数里,我们无法获取 保存的设置用户ID(saved set-user-ID),这是因为没有这种 API 。但是我们知道这个约定:当用户是 root 时,使用 setuid() 来修改 uid,这 3 个 ID 是会被同时都修改的。但是有没有办法,先使进程降权后在某些时候再恢复 root 权力呢?办法是使用 seteuid() 而不是 setuid() 。那 setuid() 和 seteuid() 有什么不同么?在 seteuid() 的 man 手册里提到:

seteuid() sets the effective user ID of the calling process.  Unprivileged user processes may only set the effective user ID to the real user ID, the effec‐tive user ID or the saved set-user-ID.

setedui() 用来设置调用进程的有效用户 ID。普通用户进程只能将 有效用户ID 设置为 实际用户ID,有效用户ID,保存的设置用户ID。这里比较重要的是,seteuid() 中的参数可以被设置为 保存的设置用户 ID 。保存的设置用户 ID 是这样的一种概念:它是从 exec 复制有效用户 ID 而得来的。具体的说,当我们从一个 shell 里执行一个外部命令时(这里就当做是执行上面的 getuid3 这个),如果该程序设置了用户ID位(有效权限位),那么在 exec 根据文件的用户ID设置了进程的有效用户 ID 后,就会将这个副本保存起来。简单的说,saved set-user-ID 保存了 有效用户ID 的值。比如对于 getuid3 这个程序,saved set-user-ID 保存的值就是 0 。据此,我们修改上面的 getuid3 程序代码为:

  1.   #include <sys/types.h>
  2.   #include <unistd.h>
  3.   #include <stdio.h>
  4.   #include <stdlib.h>
  5.    
  6.   void show_ids (void)
  7.   {
  8.   printf ("The real user ID is: %d\n", getuid());
  9.   printf ("The effective user ID is :%d\n", geteuid());
  10.   }
  11.    
  12.   int main(void)
  13.   {
  14.   const char *file = "/root/rootfile3.txt";
  15.    
  16.   show_ids();
  17.   if (!unlink (file)) {
  18.   printf ("Ok, I am root, and I can delete the file which in /root directory.\n");
  19.   system ("echo hello world > /root/rootfile3.txt");
  20.   printf ("Now, drop the root privileges.\n");
  21.   if (seteuid (1000) < 0) {
  22.   perror ("setuid");
  23.   exit (EXIT_FAILURE);
  24.   }
  25.   show_ids();
  26.   if (unlink (file) < 0) {
  27.   printf ("Ok, we have no privilege to delete rootfile3.txt.\n");
  28.   }
  29.   printf ("try to regain root power again...\n");
  30.   if (seteuid (0)) {
  31.   perror ("seteuid");
  32.   show_ids();
  33.   exit (EXIT_FAILURE);
  34.   }
  35.   }
  36.   show_ids();
  37.    
  38.   printf ("try to delete rootfile3.txt again\n");
  39.   if (!unlink(file)) {
  40.   printf ("Ok, regain root power successful!\n");
  41.   system ("echo hello world > /root/rootfile3.txt");
  42.   return (0);
  43.   }
  44.    
  45.   return (0);
  46.   }

在上面的代码中,我们将原来的 setuid(1000) 替换为 seteuid(1000); 。并且在此后,再次尝试删除 /root/rootfile3.txt 这个文件。下面在普通用户下运行该程序:

beyes@debian:~/C/syscall/getuid$ ./getuid3
The real user ID is: 1000
The effective user ID is :0
Ok, I am root, and I can delete the file which in /root directory.
Now, drop the root privileges.
The real user ID is: 1000
The effective user ID is :1000
Ok, we have no privilege to delete rootfile3.txt.
try to regain root power again...
The real user ID is: 1000
The effective user ID is :0
try to delete rootfile.txt again
Ok, regain root power successful!

此时我们看到整个过程:
先是普通用户执行了具有 root 有效权限位设置的程序,它成功的删除了 /root 下面的一个文本文件;然后使用 system() 系统调用恢复了该文件,目的是方便下面继续实验。接着,它使用 seteuid() 函数时该进程降权为普通用户权限进程。此后,正是因为有了 saved set-user-ID 的保存,所以当再次使用 seteuid() 恢复 进程的 root 权限时可以恢复成功!

所以再次看到,setuid() 会改变 saved set-user-ID 的值而不能恢复权限;而 seteuid() 不会改变 saved set-user-ID 这个值,所以它能够恢复。

 

上述文章来自于:http://www.groad.net/bbs/read.php?tid-3743.html

 

其他:

在使用setuid,seteuid,chmod u+s filename,chmod u-s filename等命令前,先弄清楚四个概念,分别是:文件拥有者,real user ID, effective user ID, saved set-user-ID。

文件拥有者:当你输入 ls -l命令,可以查看一个文件的属性,其中有该文件的拥有者。

          -rw-rw-rw- 1 xy xy 1760 Jun  5 19:44 luoxuan.c

         上面这一栏就是ls -l命令的输出,第三栏就是文件拥有者,在这里是xy。

 

real user ID:实际上进程的执行者,标志系统中不同的用户,普通用户无法修改其值,某一个用户的real user ID==他的uid,使用命令“id username"来查看某用户uid。

 

再来区分一下,real user ID与文件所有者的概念,以下面代码作为范例。

复制代码
#include <stdio.h>
#include <stdlib.h>

int main(){
        int i;
        printf("The real user ID is: %d\n",getuid());
        printf("The effective  user ID is: %d\n",geteuid());
        i=setuid(100);
        if(0==i){
                printf(".......................\n");
                printf("The real user ID is: %d\n",getuid());
                printf("The effective  user ID is: %d\n",geteuid());
                printf(".......................\n");
        }
        else{
                perror("failed to setuid");
                printf("The real user ID is: %d\n",getuid());
                printf("The effective  user ID is: %d\n",geteuid());
                exit(1);
        }
        return 0;
}
复制代码

假设代码以普通用户编译,生成a.out可执行文件,输入“ls -l a.out",可以看见输出为“-rwxr-xr-x 1 xy xy 7567 Jul  8 14:10 a.out”,a.out的所有者是xy。

          然后,运行./a.out命令,得到结果1:

                                  The real user ID is: 1003
                                  The effective  user ID is: 1003
                                  failed to setuid: Operation not permitted
                                  The real user ID is: 1003
                                  The effective  user ID is: 1003
          再运行sudo ./a.out命令,得到结果2:

                                  The real user ID is: 0
                                  The effective  user ID is: 0
                                  .......................
                                  The real user ID is: 100
                                  The effective  user ID is: 100

 

从输出结果来看,先不理会effective user ID,当以普通用户运行时,real user ID 为1003,无法setuid,也改变不了real user ID 的值;而使用了sudo 后,改变实际执行用户为root权限执行进程,real user ID的值也变为0,0是root的uid值,此时a.out这个文件的所有者仍然是xy(1003),只不过使用了sudo 超级用户权限导致real user ID不一样。

 

effective user ID: 主要用于检验该进程在执行时所获得的访问文件权限,当进程在访问文件时,检查权限,实际上是检查effective user ID。有时候,real user ID==effective user ID,但很多时候又不一样,具体情况后面再解释。

仍以上面的代码作为例子,此时以普通用户身份对a.out执行命令:chmod u+s a.out,再以"ls -l a.out"查看a.out的文件属性,为"-rwsr-xr-x 1  xy xy 7567 Jul  8 14:10 a.out"。文件属性中多了一个s符号。
              再执行sudo ./a.out,得到结果3:

                                  The real user ID is: 0
                                  The effective  user ID is: 1003
                                  failed to setuid: Operation not permitted
                                  The real user ID is: 0
                                  The effective  user ID is: 1003

 对比结果2,尽管real user ID 是0(root uid),却无法setuid,因为我们使用chmod u+s设置了effective user ID为1003(因为以普通用户运行chmod u+s命令,所以effective user ID为1003),effective user id为1003时,即普通用户,是无法使用setuid修改real user ID和effective user ID的值。所以此时,运行a.out程序的real user ID为0,而effective user ID为1003。

 

saved set-user ID: 当effective user ID修改时,保存effective user ID的值。具体作用,我还不清楚,请看本文第一段的链接,那里有详细介绍。

从上面例子,观察到一个事实,通过getuid()和geteuid()可以获得real user ID和effective user ID的值,却没有函数获得saved set-user-ID的值。

 

再来区分一下setuid和chmod u+s。

setuid : 修改real user ID和effective user ID。

chmod u+s filename: 将filename的effective user ID 改为当前登录用户的权限,比如上例结果3中,effective user ID为1003,即uid。即使使用sudo chmod u+s,结果也一样,effective user ID仍为1003。

 

为了更加清晰地说明这个概念,我们再以上面的代码进行另一个试验。假设以sudo cc test.c tuo.a编译上述代码,生成tuo.a二进制文件,使用"ls -l tuo.a"查看tuo.a的属性,得到-rwxr-xr-x 1 root root 7567 Jul  8 14:53 tuo.a,uid是root。

      再以普通用户运行./tuo.a,得到结果4:

      The real user ID is: 1003
      The effective  user ID is: 1003
      failed to setuid: Operation not permitted
      The real user ID is: 1003
      The effective  user ID is: 1003

      尽管这个文件所有者(owner)是root,但实际运行用户是普通用户,所以real user ID和effective user ID都是1003,因此也无法运行setuid。

      再以sudo ./tuo.a运行,得到结果5:     

      The real user ID is: 0
      The effective  user ID is: 0
      .......................
      The real user ID is: 100
      The effective  user ID is: 100
      .......................
      这里以root权限运行。

      再来使用chmod u+s tuo.a,得到结果“chmod: changing permissions of `tuo.a': Operation not permitted”,因为chmod此时是普通用户,无法修改root用户的文件(tuo.a),所以我们换成sudo chmod u+s tuo.a,再"ls -l tuo.a",可以看见“-rwsr-xr-x 1 root root 7567 Jul  8 14:53 tuo.a",注意红色的s字幕,这就是chmod u+s的效力。现在再以普通用户来运行一下tuo.a二进制文件,得到结果6:

      The real user ID is: 1003
      The effective  user ID is: 0
      .......................
      The real user ID is: 100
      The effective  user ID is: 100
       .......................
      此时,real user ID为1003, effective user ID为0,即使是普通用户运行,还是可以setuid,因为effective user ID被chmod u+s 赋予了0(root权限)。

 

这一类典型的文件有/usr/bin/passwd,使用"ls -l /usr/bin/passwd"文件查看到“-rwsr-xr-x 1 root root 35696 Feb  8  2011 /usr/bin/passwd”,正是这个s标志(也就是effective user ID)可以让普通用户以root权限做一些事情,如登陆时密码匹配。

如果不希望该文件继续拥有u+s权限,可使用chmod u-s filename消除影响。

       

最后再来说一说sticky bit粘滞位。

sticky bit: 文件写权限的一种扩展,当文件被设置了sticky bit位,同一组的其他用户他可以为该文件添加内容,但不能删除该文件。使用命令chmod o+t filename,或者chmod 八进制方式设置sticky bit位。设置好之后,用ls -l filename,可以看见一个标记“t"。请注意一个地方,即使添加了stickybit,文件所有者也是可以随意删改这个文件的。

 

标签:real,effective,备份,printf,user,linux,root,ID,服务端
来源: https://www.cnblogs.com/20170722-kong/p/13680045.html

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有