个人中心
gpt4 book ai didi

linux下system函数的简单分析

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 64 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章linux下system函数的简单分析由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

简单分析了linux下system函数的相关内容，具体内容如下 。

?
1
2
3
4
5
6
7
8
9
10
11
int
__libc_system (const char *line)
{
  if (line == NULL)
   /* Check that we have a command processor available. It might
     not be available after a chroot(), for example. */
   return do_system ( "exit 0" ) == 0;
 
  return do_system (line);
}
weak_alias (__libc_system, system)

代码位于glibc/sysdeps/posix/system.c，这里system是__libc_system的弱别名，而__libc_system是do_system的前端函数，进行了参数的检查，接下来看do_system函数.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
static int
do_system (const char *line)
{
  int status, save;
  pid_t pid;
  struct sigaction sa;
#ifndef _LIBC_REENTRANT
  struct sigaction intr, quit;
#endif
  sigset_t omask;
 
  sa.sa_handler = SIG_IGN;
  sa.sa_flags = 0;
  __sigemptyset (&sa.sa_mask);
 
  DO_LOCK ();
  if (ADD_REF () == 0)
   {
    if (__sigaction (SIGINT, &sa, &intr) < 0)
   {
    (void) SUB_REF ();
    goto out;
   }
    if (__sigaction (SIGQUIT, &sa, &quit) < 0)
   {
    save = errno;
    (void) SUB_REF ();
    goto out_restore_sigint;
   }
   }
  DO_UNLOCK ();
 
  /* We reuse the bitmap in the 'sa' structure. */
  __sigaddset (&sa.sa_mask, SIGCHLD);
  save = errno;
  if (__sigprocmask (SIG_BLOCK, &sa.sa_mask, &omask) < 0)
   {
#ifndef _LIBC
    if (errno == ENOSYS)
   __set_errno (save);
    else
#endif
   {
    DO_LOCK ();
    if (SUB_REF () == 0)
     {
      save = errno;
      (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
     out_restore_sigint:
      (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
      __set_errno (save);
     }
   out:
    DO_UNLOCK ();
    return -1;
   }
   }
 
#ifdef CLEANUP_HANDLER
  CLEANUP_HANDLER;
#endif
 
#ifdef FORK
  pid = FORK ();
#else
  pid = __fork ();
#endif
  if (pid == (pid_t) 0)
   {
    /* Child side. */
    const char *new_argv[4];
    new_argv[0] = SHELL_NAME;
    new_argv[1] = "-c" ;
    new_argv[2] = line;
    new_argv[3] = NULL;
 
    /* Restore the signals. */
    (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
    (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
    (void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
    INIT_LOCK ();
 
    /* Exec the shell. */
    (void) __execve (SHELL_PATH, (char *const *) new_argv, __environ);
    _exit (127);
   }
  else if (pid < (pid_t) 0)
   /* The fork failed. */
   status = -1;
  else
   /* Parent side. */
   {
    /* Note the system() is a cancellation point. But since we call
    waitpid() which itself is a cancellation point we do not
    have to do anything here. */
    if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, 0)) != pid)
   status = -1;
   }
 
#ifdef CLEANUP_HANDLER
  CLEANUP_RESET;
#endif
 
  save = errno;
  DO_LOCK ();
  if ((SUB_REF () == 0
     && (__sigaction (SIGINT, &intr, (struct sigaction *) NULL)
     | __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL)) != 0)
    || __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL) != 0)
   {
#ifndef _LIBC
    /* glibc cannot be used on systems without waitpid. */
    if (errno == ENOSYS)
   __set_errno (save);
    else
#endif
   status = -1;
   }
  DO_UNLOCK ();
 
  return status;
}
 
do_system

首先函数设置了一些信号处理程序，来处理SIGINT和SIGQUIT信号，此处我们不过多关心，关键代码段在这里 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#ifdef FORK
  pid = FORK ();
#else
  pid = __fork ();
#endif
  if (pid == (pid_t) 0)
   {
    /* Child side. */
    const char *new_argv[4];
    new_argv[0] = SHELL_NAME;
    new_argv[1] = "-c" ;
    new_argv[2] = line;
    new_argv[3] = NULL;
 
    /* Restore the signals. */
    (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
    (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
    (void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
    INIT_LOCK ();
 
    /* Exec the shell. */
    (void) __execve (SHELL_PATH, (char *const *) new_argv, __environ);
    _exit (127);
   }
  else if (pid < (pid_t) 0)
   /* The fork failed. */
   status = -1;
  else
   /* Parent side. */
   {
    /* Note the system() is a cancellation point. But since we call
    waitpid() which itself is a cancellation point we do not
    have to do anything here. */
    if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, 0)) != pid)
   status = -1;
   }

首先通过前端函数调用系统调用fork产生一个子进程，其中fork有两个返回值，对父进程返回子进程的pid，对子进程返回0。所以子进程执行6-24行代码，父进程执行30-35行代码.

子进程的逻辑非常清晰，调用execve执行SHELL_PATH指定的程序，参数通过new_argv传递，环境变量为全局变量__environ.

其中SHELL_PATH和SHELL_NAME定义如下 。

?
1
2
#define  SHELL_PATH  "/bin/sh"  /* Path of the shell. */
#define  SHELL_NAME  "sh"    /* Name to give it. */

其实就是生成一个子进程调用/bin/sh -c "命令"来执行向system传入的命令。  。

下面其实是我研究system函数的原因与重点:

在CTF的pwn题中，通过栈溢出调用system函数有时会失败，听师傅们说是环境变量被覆盖，但是一直都是懵懂，今天深入学习了一下，总算搞明白了.

在这里system函数需要的环境变量储存在全局变量__environ中，那么这个变量的内容是什么呢.

__environ是在glibc/csu/libc-start.c中定义的，我们来看几个关键语句.

?
1
# define LIBC_START_MAIN __libc_start_main

__libc_start_main是_start调用的函数，这涉及到程序开始时的一些初始化工作，对这些名词不了解的话可以看一下这篇文章。接下来看LIBC_START_MAIN函数.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
STATIC int
LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
      int argc, char **argv,
#ifdef LIBC_START_MAIN_AUXVEC_ARG
      ElfW(auxv_t) *auxvec,
#endif
      __typeof (main) init,
      void (*fini) (void),
      void (*rtld_fini) (void), void *stack_end)
{
  /* Result of the 'main' function . */
  int result;
 
  __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up;
 
#ifndef SHARED
  char **ev = &argv[argc + 1];
 
  __environ = ev;
 
  /* Store the lowest stack address. This is done in ld.so if this is
    the code for the DSO. */
  __libc_stack_end = stack_end;
 
　　　　......
  /* Nothing fancy, just call the function . */
  result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
#endif
 
  exit (result);
}

我们可以看到，在没有define SHARED的情况下，在第19行定义了__environ的值。启动程序调用LIBC_START_MAIN之前，会先将环境变量和argv中的字符串保存起来（其实是保存到栈上），然后依次将环境变量中各项字符串的地址，argv中各项字符串的地址和argc入栈，所以环境变量数组一定位于argv数组的正后方，以一个空地址间隔。所以第17行的&argv[argc + 1]语句就是取环境变量数组在栈上的首地址，保存到ev中，最终保存到__environ中。第203行调用main函数，会将__environ的值入栈，这个被栈溢出覆盖掉没什么问题，只要保证__environ中的地址处不被覆盖即可.

所以，当栈溢出的长度过大，溢出的内容覆盖了__environ中地址中的重要内容时，调用system函数就会失败。具体环境变量距离溢出地址有多远，可以通过在_start中下断查看.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

最后此篇关于linux下system函数的简单分析的文章就讲到这里了,如果你想了解更多关于linux下system函数的简单分析的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

64 4 0
文章推荐： Git 删除远程服务器文件同时保留本地文件实例详解
文章推荐： 如何用Python保存语音、图片、视频等信息转发给好友
文章推荐： 壁纸神器登陆安卓！Wallpaper Engine新体验
文章推荐： GitHub标星10.8K！快速搭建私人网盘
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com