linux 服务端热升级 备份

linux、windows 下,

linux 下的close() / windows 下的 closesocket()  操作只是使相应socket描述字的引用计数-1,只有当引用计数为0的时候,才会触发TCP客户端向服务器发送终止连接请求。

 

转: 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,提示错误:

 

 

socket fd 没有父子关系的不通进程之间,不能简单地使用共享内存保存fd 来收发数据;这样是不行的!!!!

 

Linux下的socket编程实践(六)Unix域协议和socketpair传递文件描述符

https://blog.csdn.net/nk_test/article/details/49105435

 

UNIX域协议并不是一个实际的协议族,而是在单个主机上执行客户/服务器通信的一种方法,所用API与在不同主机上执行客户/服务器通信所使用的API相同。UNIX域协议可以视为IPC方法之一,Unix域协议主要用在同一台机子(仅能用于本地进程间的通信)的不同进程之间传递套接字。为什么不用TCP或者UDP套接字呢?

1)在同一台主机上, UNIX域套接字更有效率, 几乎是TCP的两倍(由于UNIX域套接字不需要经过网络协议栈,不需要打包/拆包,计算校验和,维护序号和应答等,只是将应用层数据从一个进程拷贝到另一个进程, 而且UNIX域协议机制本质上就是可靠的通讯, 而网络协议是为不可靠的通讯设计的)。

2)UNIX域套接字可以在同一台主机上各进程之间传递文件描述符。

3)UNIX域套接字较新的实现把客户的凭证(用户ID和组ID)提供给服务器,从而能够提供额外的安全检查措施。

注意:UNIX域套接字也提供面向流和面向数据包两种API接口,类似于TCP和UDP,但是面向消息的UNIX套接字也是可靠的,消息既不会丢失也不会顺序错乱。Unix域协议表示协议地址的是路径名,而不是Internet域的IP地址和端口号。

UNIX域套接字地址结构:

 

  1.  
    #define UNIX_PATH_MAX 108
  2.  
    struct sockaddr_un
  3.  
    {
  4.  
    sa_family_t sun_family; /* AF_UNIX */
  5.  
    char sun_path[UNIX_PATH_MAX]; /* pathname */
  6.  
    };

至于通信程序的话,和使用TCP的通信并没有很大的区别,下面给出基于UNIX域套接字的server/client程序源码:

 

 

  1.  
    /**Server端**/
  2.  
     
  3.  
    int main()
  4.  
    {
  5.  
    int listenfd = socket(AF_UNIX, SOCK_STREAM, 0); //使用AF_UNIX 或者AF_LOCAL
  6.  
    if (listenfd == -1)
  7.  
    err_exit("socket error");
  8.  
     
  9.  
    char pathname[] = "/tmp/test_for_unix";
  10.  
    unlink(pathname);//如果文件系统中已存在该路径名,bind将会失败。为此我们先调用unlink删除这个路径名,以防止它已经存在
  11.  
    struct sockaddr_un servAddr;
  12.  
    servAddr.sun_family = AF_UNIX;
  13.  
    strcpy(servAddr.sun_path, pathname);
  14.  
    if (bind(listenfd, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1)
  15.  
    err_exit("bind error");
  16.  
    if (listen(listenfd, SOMAXCONN) == -1)
  17.  
    err_exit("listen error");
  18.  
     
  19.  
    while (1)
  20.  
    {
  21.  
    int connfd = accept(listenfd, NULL, NULL);
  22.  
    if (connfd == -1)
  23.  
    {
  24.  
    if(connfd==EINTR)
  25.  
    continue;
  26.  
    err_exit("accept");
  27.  
    }
  28.  
    }
  29.  
    return 0;
  30.  
    }

 

 

 

  1.  
    /**Client端代码**/
  2.  
     
  3.  
    int main()
  4.  
    {
  5.  
    int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
  6.  
    if (sockfd == -1)
  7.  
    err_exit("socket error");
  8.  
     
  9.  
    char pathname[] = "/tmp/test_for_unix";
  10.  
    struct sockaddr_un servAddr;
  11.  
    servAddr.sun_family = AF_UNIX;
  12.  
    strcpy(servAddr.sun_path, pathname);
  13.  
    if (connect(sockfd, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1)
  14.  
    err_exit("connect error");
  15.  
    return 0;
  16.  
    }

 

UNIX域套接字编程注意点

 

 1.bind成功将会创建一个文件,是一个套接字类型,使用ls -l可以查看到是s开头的文件,权限为0777 & ~umask

 2.sun_path最好用一个/tmp目录下的文件的绝对路径,再次启动的时候最好使用unlink删除这个文件,否则会提示地址正在使用。

 3.UNIX域协议支持流式套接口(需要处理粘包问题)与报式套接口(基于数据报)

 4.UNIX域流式套接字connect发现监听队列满时,会立刻返回一个ECONNREFUSED,这和TCP不同,如果监听队列满,会忽略到来的SYN,这导致对方重传SYN

5.如果使用流式套接字的话,还是要处理粘包问题的。

 

传递文件描述符

socketpair

  1.  
    #include <sys/types.h>
  2.  
    #include <sys/socket.h>
  3.  
    int socketpair(int domain, int type, int protocol, int sv[2]);

 

创建一个全双工的流管道

参数:

   domain: 协议家族, 可以使用AF_UNIX(AF_LOCAL)UNIX域协议, 而且在Linux上, 该函数也就只支持这一种协议;

   type: 套接字类型, 可以使用SOCK_STREAM

   protocol: 协议类型, 一般填充为0,表示内核自动选择协议类型。

   sv: 返回套接字对sv[0],sv[1];

socketpair 函数跟pipe 函数是类似: 只能在具有亲缘关系的进程间通信,但pipe 创建的匿名管道是半双工的,而socketpair 可以认为是创建一个全双工的管道。

可以使用socketpair 创建返回的套接字对进行父子进程通信, 如下例:

  1.  
    int main()
  2.  
    {
  3.  
    int sockfds[2];
  4.  
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfds) == -1)
  5.  
    err_exit("socketpair error");
  6.  
     
  7.  
    pid_t pid = fork();
  8.  
    if (pid == -1)
  9.  
    err_exit("fork error");
  10.  
    // 父进程
  11.  
    else if (pid > 0)
  12.  
    {
  13.  
    close(sockfds[1]); //和pipe类似,先关闭一端
  14.  
    int iVal = 0;
  15.  
    while (true)
  16.  
    {
  17.  
    cout << "value = " << iVal << endl;
  18.  
    write(sockfds[0], &iVal, sizeof(iVal)); //发送给子进程
  19.  
    read(sockfds[0], &iVal, sizeof(iVal));
  20.  
    sleep(1);
  21.  
    }
  22.  
    }
  23.  
    // 子进程
  24.  
    else if (pid == 0)
  25.  
    {
  26.  
    close(sockfds[0]);
  27.  
    int iVal = 0;
  28.  
    while (read(sockfds[1], &iVal, sizeof(iVal)) > 0)
  29.  
    {
  30.  
    ++ iVal;
  31.  
    write(sockfds[1], &iVal, sizeof(iVal)); //发送给父进程
  32.  
    }
  33.  
    }
  34.  
    }

sendmsg/recvmsg

 

  1.  
    #include <sys/types.h>
  2.  
    #include <sys/socket.h>
  3.  
    ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
  4.  
    ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

它们与sendto/send 和 recvfrom/recv 函数类似,只不过可以传输更复杂的数据结构,功能更强大,不仅可以传输一般数据,还可以传输额外的数据,如文件描述符。

 

 

  1.  
    //msghdr结构体
  2.  
    struct msghdr
  3.  
    {
  4.  
    void *msg_name; /* optional address */
  5.  
    socklen_t msg_namelen; /* size of address */
  6.  
    struct iovec *msg_iov; /* scatter/gather array */
  7.  
    size_t msg_iovlen; /* # elements in msg_iov */
  8.  
    void *msg_control; /* ancillary data, see below */
  9.  
    size_t msg_controllen; /* ancillary data buffer len */
  10.  
    int msg_flags; /* flags on received message */
  11.  
    };
  12.  
    struct iovec /* Scatter/gather array items */
  13.  
    {
  14.  
    void *iov_base; /* Starting address */
  15.  
    size_t iov_len; /* Number of bytes to transfer */
  16.  
    };

 

 

msghdr结构体成员解释:

   1)msg_name :即对等方的地址指针,不关心时设为NULL即可;

   2)msg_namelen:地址长度,不关心时设置为0即可;

   3)msg_iov:是结构体iovec 的指针, 指向需要发送的普通数据, 见下图。   

      成员iov_base 可以认为是传输正常数据时的buf;

      成员iov_len 是buf 的大小;

   4)msg_iovlen:当有n个iovec 结构体时,此值为n;

   5)msg_control:是一个指向cmsghdr 结构体的指针(见下图), 当需要发送辅助数据(如控制信息/文件描述符)时, 需要设置该字段, 当发送正常数据时, 就不需要关心该字段, 并且msg_controllen可以置为0;

   6)msg_controllen:cmsghdr 结构体可能不止一个(见下图):

   7)flags: 不用关心;



填充字节是用来进行对齐的,4的整数倍,缓冲区的大小就是辅助数据的大小,为了对齐,可能存在一些填充字节(见下图),跟系统的实现有关,但我们不必关心,可以通过一些函数宏来获取相关的值,如下:

 

  1.  
    #include <sys/socket.h>
  2.  
    struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *msgh);
  3.  
    //获取辅助数据的第一条消息
  4.  
    struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg); //获取辅助数据的下一条信息
  5.  
    size_t CMSG_ALIGN(size_t length);
  6.  
    size_t CMSG_SPACE(size_t length);
  7.  
    size_t CMSG_LEN(size_t length); //length使用的是的(实际)数据的长度, 见下图(两条填充数据的中间部分)
  8.  
    unsigned char *CMSG_DATA(struct cmsghdr *cmsg);


 

 

进程间传递文件描述符

结构体的填充是重点和难点:

 

  1.  
    /**示例: 封装两个函数send_fd/recv_fd用于在进程间传递文件描述符**/
  2.  
    int send_fd(int sockfd, int sendfd)
  3.  
    {
  4.  
    // 填充 name 字段
  5.  
    struct msghdr msg;
  6.  
    msg.msg_name = NULL;
  7.  
    msg.msg_namelen = 0;
  8.  
     
  9.  
    // 填充 iov 字段
  10.  
    struct iovec iov;
  11.  
    char sendchar = '\0';
  12.  
    iov.iov_base = &sendchar;
  13.  
    iov.iov_len = 1;
  14.  
    msg.msg_iov = &iov;
  15.  
    msg.msg_iovlen = 1;
  16.  
     
  17.  
    // 填充 cmsg 字段
  18.  
    struct cmsghdr cmsg;
  19.  
    cmsg.cmsg_len = CMSG_LEN(sizeof(int));
  20.  
    cmsg.cmsg_level = SOL_SOCKET;
  21.  
    cmsg.cmsg_type = SCM_RIGHTS;
  22.  
    *(int *)CMSG_DATA(&cmsg) = sendfd;
  23.  
    msg.msg_control = &cmsg;
  24.  
    msg.msg_controllen = CMSG_LEN(sizeof(int));
  25.  
     
  26.  
    // 发送
  27.  
    if (sendmsg(sockfd, &msg, 0) == -1)
  28.  
    return -1;
  29.  
    return 0;
  30.  
    }

 

  1.  
    int recv_fd(int sockfd)
  2.  
    {
  3.  
    // 填充 name 字段
  4.  
    struct msghdr msg;
  5.  
    msg.msg_name = NULL;
  6.  
    msg.msg_namelen = 0;
  7.  
     
  8.  
    // 填充 iov 字段
  9.  
    struct iovec iov;
  10.  
    char recvchar;
  11.  
    iov.iov_base = &recvchar;
  12.  
    iov.iov_len = 1;
  13.  
    msg.msg_iov = &iov;
  14.  
    msg.msg_iovlen = 1;
  15.  
     
  16.  
    // 填充 cmsg 字段
  17.  
    struct cmsghdr cmsg;
  18.  
    msg.msg_control = &cmsg;
  19.  
    msg.msg_controllen = CMSG_LEN(sizeof(int));
  20.  
     
  21.  
    // 接收
  22.  
    if (recvmsg(sockfd, &msg, 0) == -1)
  23.  
    return -1;
  24.  
    return *(int *)CMSG_DATA(&cmsg);
  25.  
    }

 

来解释一下send_fd 函数:
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = &vec;
msg.msg_iovlen = 1; //主要目的不是传递数据,故只传1个字符
msg.msg_flags = 0;
vec.iov_base = &sendchar;
vec.iov_len = sizeof(sendchar);
这几行中需要注意的是我们现在的目的不是传输正常数据,而是为了传递文件描述符,所以只定义一个1字节的char,其余参照前面对参数的解释可以理解。
现在我们只有一个cmsghdr 结构体,把需要传递的文件描述符send_fd 长度,也就是需要传输的额外数据大小,当作参数传给CMSG_SPACE 宏,可以得到整个结构体的大小,包括一些填充字节,如上图所示,也即
char cmsgbuf[CMSG_SPACE(sizeof(send_fd))];
也就可以进一步得出以下两行:
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);

接着,需要填充cmsghdr 结构体,传入msghdr 指针,CMSG_FIRSTHDR宏可以得到首个cmsghdr 结构体的指针,即

p_cmsg = CMSG_FIRSTHDR(&msg);

然后使用指针来填充各字段,如下:
p_cmsg->cmsg_level = SOL_SOCKET;
p_cmsg->cmsg_type = SCM_RIGHTS;
p_cmsg->cmsg_len = CMSG_LEN(sizeof(send_fd));

传入send_fd 的大小,CMSG_LEN宏可以得到cmsg_len 字段的大小。
最后,传入结构体指针 p_cmsg ,宏CMSG_DATA 可以得到准备存放send_fd 的位置指针,将send_fd 放进去,如下:

p_fds = (int*)CMSG_DATA(p_cmsg);
*p_fds = send_fd; // 通过传递辅助数据的方式传递文件描述符
recv_fd 函数就类似了,不再赘述。

 

  1.  
    int main()
  2.  
    {
  3.  
    int sockfds[2];
  4.  
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfds) == -1)
  5.  
    err_exit("socketpair error");
  6.  
     
  7.  
    pid_t pid = fork();
  8.  
    if (pid == -1)
  9.  
    err_exit("fork error");
  10.  
    // 子进程以只读方式打开文件, 将文件描述符发送给子进程
  11.  
    else if (pid == 0)
  12.  
    {
  13.  
    close(sockfds[1]);
  14.  
    int fd = open("read.txt", O_RDONLY);
  15.  
    if (fd == -1)
  16.  
    err_exit("open error");
  17.  
    cout << "In child, fd = " << fd << endl;
  18.  
    send_fd(sockfds[0], fd);
  19.  
    }
  20.  
    // 父进程从文件描述符中读取数据
  21.  
    else if (pid > 0)
  22.  
    {
  23.  
    close(sockfds[0]);
  24.  
    int fd = recv_fd(sockfds[1]);
  25.  
    if (fd == -1)
  26.  
    err_exit("recv_fd error");
  27.  
    cout << "In parent, fd = " << fd << endl;
  28.  
     
  29.  
    char buf[BUFSIZ] = {0};
  30.  
    int readBytes = read(fd, buf, sizeof(buf));
  31.  
    if (readBytes == -1)
  32.  
    err_exit("read fd error");
  33.  
    cout << buf;
  34.  
    }
  35.  
    }

 

我们知道,父进程在fork 之前打开的文件描述符,子进程是可以共享的,但是子进程打开的文件描述符,父进程是不能共享的,上述程序就是举例在子进程中打开了一个文件描述符,然后通过send_fd 函数将文件描述符传递给父进程,父进程可以通过recv_fd 函数接收到这个文件描述符。先建立一个文件read.txt 后输入几个字符,然后运行程序。

 

注意:

   (1)只有UNIX域协议才能在本机进程间传递文件描述符;

   (2)进程间传递文件描述符并不是传递文件描述符的值(其实send_fd/recv_fd的两个值也是不同的), 而是要在接收进程中创建一个新的文件描述符, 并且该文件描述符和发送进程中被传递的文件描述符指向内核中相同的文件表项.

 

 

 

 

 

参考网站:

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,文件所有者也是可以随意删改这个文件的。

 

posted @ 2020-09-16 16:53  雪域蓝心  阅读(338)  评论(0编辑  收藏  举报