linux下system函数的简单分析,Linux上程序执行的入
分类:pc28.am神测网

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

main()函数,想必我们都不面生了,从刚最初写程序的时候,大家便起先写main(),大家都清楚main是前后相继的入口。那main作为八个函数,又是谁调用的它,它是怎么被调用的,再次回到给何人,再次来到的又是哪些?此次我们来探究一下那些难点。

代码位于glibc/sysdeps/posix/system.c,这里system是__libc_system的弱外号,而__libc_system是do_system的前端函数,实行了参数的检查,接下去看do_system函数。

  1. main()函数的花样
    先来讲说main函数的概念,较早起始写C程序的一定都用过那样的概念void main(){},其实翻翻C/C 规范,平昔未有定义过void main()。
    在C规范中main的概念唯有二种:
            int main(void)
            int main(int argc, char *pc28.am神测网,argv[])
            在C 规范中main的定义也仅有二种:
            int main( )
            int main(int argc, char *argv[])
       
        换句话说:当您的程序不供给命令行参数的时候用int main(), 当须求命令行参数的时候请使用int main(int argc, char *argv[])
       
        可是正统归专门的职业,在不相同的平台上,不一致的编写翻译器中对main()的定义方式总有投机的落到实处,例如早期编写翻译器对void main()的协助(今后gcc也帮助,可是会付出二个warning)。特别的,因为历史的原因,在Unix-like平台上,多数还扶助
            int main(int argc, char *argv[], char *envp[])
        其使用方法我们稍后再谈。

  2. main()函数的归来    
        int main(...) 意味着须求return贰个int值,如若不写,有的编写翻译器会自动帮您加多三个return 0;,而一些则会重回三个随机值。为了制止不须求的难点,建议写的时候依旧增进壹个return 0;,浪费不了你有个别时间,不是吧?
        所以一个完好的test.c文件应当为:
        int main(int argc, char *argv[])
        {
            return 0;
        }
        当然我们也得以品尝着让main重临一个long, double以至是struct,改良main函数中的形参定义。那在有个别编写翻译器上是能编写翻译通过的,可是或然会有局地警告(如GCC)。不过运转的时候借使编写翻译器能做转变的辛亏,如重返long,float. 倘诺不能够的话(如再次来到struct,可能main(int argc, char *argv0,char *argv1,char *argv2))会造成segmentation fault。        

  3. main()的调用和重返
        在通晓了main()函数的定义和再次来到格局后,大家再来看看main函数是怎么被调用的,它又"return"给了什么人。在"gcc的编写翻译进程"一中,大家回顾了前后相继从源码到可执路程序的经过,在"应用程序在linux上是怎么样被履行的"一文中,大家回看了可实行文件怎么被操作系统加载的,明日我们继承那几个历程。
    上文提到不管是在load_elf_binary()中要么应用了动态链接库,说起底都施行到了应用程序的入口。但是那几个进口不是main.而是_start()
    执行
        gcc -o test test.c
        readelf -a test
        能够见到test文件的Entry point address是0x80482e0,在现在看,这一个地址是.text的地址(代码段的起首),也是_start()的地址。在_start()中又会调用__libc_start_main(),首要做一些主次的初步化专业,感兴趣的同校能够读读glibc中的源码,注释很理解。然后主演登台了,在__libc_start_main()中最终会调用
        int result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);//那是Unix-like下main函数的调用方式,那下大家精通main函数中形参的由来了吗。
        result中放着main函数的重回值,然后带着那一个值脱离。
        exit (result);

pc28.am神测网 1pc28.am神测网 2

小心:即便main函数是贰个异样的函数,是程序运行的进口,但它终归也是四个函数,是足以被调用的。如:
    int   main()  
    {  
        if(...)  
            return   0;  
        main();  
        return   0;  
    }  
    可是要小心调用情势,和分离规范,制止无穷递归。

  1 static int
  2 do_system (const char *line)
  3 {
  4   int status, save;
  5   pid_t pid;
  6   struct sigaction sa;
  7 #ifndef _LIBC_REENTRANT
  8   struct sigaction intr, quit;
  9 #endif
 10   sigset_t omask;
 11 
 12   sa.sa_handler = SIG_IGN;
 13   sa.sa_flags = 0;
 14   __sigemptyset (&sa.sa_mask);
 15 
 16   DO_LOCK ();
 17   if (ADD_REF () == 0)
 18     {
 19       if (__sigaction (SIGINT, &sa, &intr) < 0)
 20     {
 21       (void) SUB_REF ();
 22       goto out;
 23     }
 24       if (__sigaction (SIGQUIT, &sa, &quit) < 0)
 25     {
 26       save = errno;
 27       (void) SUB_REF ();
 28       goto out_restore_sigint;
 29     }
 30     }
 31   DO_UNLOCK ();
 32 
 33   /* We reuse the bitmap in the 'sa' structure.  */
 34   __sigaddset (&sa.sa_mask, SIGCHLD);
 35   save = errno;
 36   if (__sigprocmask (SIG_BLOCK, &sa.sa_mask, &omask) < 0)
 37     {
 38 #ifndef _LIBC
 39       if (errno == ENOSYS)
 40     __set_errno (save);
 41       else
 42 #endif
 43     {
 44       DO_LOCK ();
 45       if (SUB_REF () == 0)
 46         {
 47           save = errno;
 48           (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
 49         out_restore_sigint:
 50           (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
 51           __set_errno (save);
 52         }
 53     out:
 54       DO_UNLOCK ();
 55       return -1;
 56     }
 57     }
 58 
 59 #ifdef CLEANUP_HANDLER
 60   CLEANUP_HANDLER;
 61 #endif
 62 
 63 #ifdef FORK
 64   pid = FORK ();
 65 #else
 66   pid = __fork ();
 67 #endif
 68   if (pid == (pid_t) 0)
 69     {
 70       /* Child side.  */
 71       const char *new_argv[4];
 72       new_argv[0] = SHELL_NAME;
 73       new_argv[1] = "-c";
 74       new_argv[2] = line;
 75       new_argv[3] = NULL;
 76 
 77       /* Restore the signals.  */
 78       (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
 79       (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
 80       (void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
 81       INIT_LOCK ();
 82 
 83       /* Exec the shell.  */
 84       (void) __execve (SHELL_PATH, (char *const *) new_argv, __environ);
 85       _exit (127);
 86     }
 87   else if (pid < (pid_t) 0)
 88     /* The fork failed.  */
 89     status = -1;
 90   else
 91     /* Parent side.  */
 92     {
 93       /* Note the system() is a cancellation point.  But since we call
 94      waitpid() which itself is a cancellation point we do not
 95      have to do anything here.  */
 96       if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, 0)) != pid)
 97     status = -1;
 98     }
 99 
100 #ifdef CLEANUP_HANDLER
101   CLEANUP_RESET;
102 #endif
103 
104   save = errno;
105   DO_LOCK ();
106   if ((SUB_REF () == 0
107        && (__sigaction (SIGINT, &intr, (struct sigaction *) NULL)
108        | __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL)) != 0)
109       || __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL) != 0)
110     {
111 #ifndef _LIBC
112       /* glibc cannot be used on systems without waitpid.  */
113       if (errno == ENOSYS)
114     __set_errno (save);
115       else
116 #endif
117     status = -1;
118     }
119   DO_UNLOCK ();
120 
121   return status;
122 }
  1. shell中实施顺序
        通过前一遍和方面包车型客车深入分析,我们算是基本弄清了应用程序的奉行过程,再回首三回: 在某些交互作用式shell中敲入./test, 此shell fork()/clone()出三个子经过,这一个子进程实行
        
        execve("./test",char * const argv[], char * const envp[])
        
        execve加载./test,并把参数argv[],envp[]一步一步传递下去。加载了./test之后,从./test的入口起始选行,即ELF文件中的_start(),_start()调用__libc_start_main(),最终到了main。
        
        int main(int argc, char *argv[], char *envp[])
        
        看着这一个main的定义和execve相仿吧,对的main中的参数都以execve一步步传递下去的。argc是命令行参数个数,argv[]积存着豆蔻年华风流洒脱参数的指针(注意argv[0]平时是程序名,argv[1]最早才是命令行参数。那是由shell设置的),envp[]积攒着情形变量表。然则在规范C中只定义了int main(int argc, char *argv[]),所以unix-like平台也提供了大局变量environ指向蒙受变量表。
        extern char **environ;
        当然也得以用getenv和putenv来访谈特定的情状变量。

do_system

    对了,父shell还在wait()./test的甘休吧,不错,test中main函数return的值,在被__libc_start_main() exit之后,终于被父shell抓住了,能够用$?访谈。
    如$> ./test
      $> echo $?
    能够得到test再次回到的值。那样,你就知道main()函数中return的意思,以至哪些在shell中运用了吗。固然能够return任何值,也提出用return 0来代表程序不荒谬结束。那样别人用shell脚本调用你写的主次的时候,就足以$?等于0来判定你的次序是或不是平常实行了。

率先函数设置了有个别时域信号处理程序,来拍卖SIGINT和SIGQUIT能量信号,此处大家只是多关切,关键代码段在这里间

末尾计算一下:

 1 #ifdef FORK
 2   pid = FORK ();
 3 #else
 4   pid = __fork ();
 5 #endif
 6   if (pid == (pid_t) 0)
 7     {
 8       /* Child side.  */
 9       const char *new_argv[4];
10       new_argv[0] = SHELL_NAME;
11       new_argv[1] = "-c";
12       new_argv[2] = line;
13       new_argv[3] = NULL;
14 
15       /* Restore the signals.  */
16       (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
17       (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
18       (void) __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL);
19       INIT_LOCK ();
20 
21       /* Exec the shell.  */
22       (void) __execve (SHELL_PATH, (char *const *) new_argv, __environ);
23       _exit (127);
24     }
25   else if (pid < (pid_t) 0)
26     /* The fork failed.  */
27     status = -1;
28   else
29     /* Parent side.  */
30     {
31       /* Note the system() is a cancellation point.  But since we call
32      waitpid() which itself is a cancellation point we do not
33      have to do anything here.  */
34       if (TEMP_FAILURE_RETRY (__waitpid (pid, &status, 0)) != pid)
35     status = -1;
36     }
  1. 幸免使用void main(),尽量利用int main() 恐怕 int main(int argc, char *argv[])。
    2. 在main的末尾记得 return int;, 最棒用return 0;表示程序的例行甘休。
  2. main函数和平日函数相符也是能被调用的。
  3. main return的值末了会重返给其调用者,如shell中实施的次序,能够在shell中用$?获得其重临值。
  4. 在unix-like遭逢中,能够运用int main(int argc, char *argv[], char *envp[]), extern char **environ; , getenv()等措施来得到景况变量。

先是通过前端函数调用系统调用fork产生一个子进程,个中fork有四个再次回到值,对父进度再次回到子进程的pid,对子进度重回0。所以子进度推行6-24行代码,父进程履行30-35行代码。

子进度的逻辑非常显然,调用execve试行SHELL_PATH钦赐的顺序,参数通过new_argv传递,碰到变量为全局变量__environ。

其中SHELL_PATH和SHELL_NAME定义如下

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

 

实际上就是生成三个子进度调用/bin/sh -c "命令"来实践向system传入的指令。

 

上面其实是自身商讨system函数的原故与注重:

在CTF的pwn题中,通过栈溢出调用system函数有的时候会倒闭,听师傅们正是情状变量被覆盖,然而一向都是懵懂,后天深切学习了一下,总算搞精通了。

在这里间system函数须求的情形变量积攒在全局变量__environ中,那么那一个变量的源委是什么啊。

__environ是在glibc/csu/libc-start.c中定义的,大家来看多少个重要语句。

# define LIBC_START_MAIN __libc_start_main

 

__libc_start_main是_start调用的函数,这件事关到程序领头时的一些开端化工作,对这一个名词不明白的话能够看一下那篇小说。接下来看LIBC_START_MAIN函数。

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

    ......

202   /* Nothing fancy, just call the function.  */
203   result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
204 #endif
205 
206   exit (result);
207 }

我们能够观望,在并未有define SHARED的景况下,在第19行概念了__environ的值。运营程序调用LIBC_START_MAIN在此以前,会先将情况变量和argv中的字符串保存起来(其实是保留到栈上卡塔尔,然后依次将情况变量中各队字符串的地点,argv中各个字符串的地址和argc入栈,所以意况变量数组一定位于argv数组的正后方,以三个空地址间距。所以第17行的&argv[argc

  • 1]话语就是取情况变量数组在栈上的首地址,保存到ev中,最后保存到__environ中。第203行调用main函数,会将__environ的值入栈,这么些被栈溢出覆盖掉没什么难点,只要保险__environ中的地址处不被遮住就可以。

故此,当栈溢出的长迈过大,溢出的内容覆盖了__environ中地址中的首要内容时,调用system函数就能够退步。具体境况变量间距溢出地址有多少间距,能够由此在_start中下断查看。

本文由pc28.am发布于pc28.am神测网,转载请注明出处:linux下system函数的简单分析,Linux上程序执行的入

上一篇:nodejs API(一卡塔 尔(英语:State of Qatar) 下一篇:没有了
猜你喜欢
热门排行
精彩图文