精通机器学习渗透测试（全）

精通机器学习渗透测试（全）

原文：annas-archive.org/md5/74E92091FA78BD2C9635BCA05C8FE700

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

目前，机器学习技术是信息技术中最热门的趋势之一。它们影响着我们生活的方方面面，影响着每个行业和领域。机器学习是信息安全专业人员的网络武器。在本书中，你不仅将探索机器学习技术的基础知识，还将学习构建一个完全功能的机器学习安全系统的秘诀；我们不仅仅停留在构建防御层面。我们还将探讨如何使用对抗学习攻击机器学习模型。《精通机器学习渗透测试》将提供教育和实践价值。

本书适合谁

《精通机器学习渗透测试》适用于对打破智能安全系统技术感兴趣的渗透测试人员和安全专业人员。需要有 Python 的基础知识，但不需要有机器学习的先验知识。

本书涵盖的内容

第一章《渗透测试中的机器学习简介》向读者介绍了不同机器学习模型和算法的基本概念，以及如何评估它们。然后，它向我们展示了如何使用许多数据科学 Python 库准备机器学习开发环境。

第二章《钓鱼域名检测》指导我们如何使用不同的算法和自然语言处理（NLP）构建机器学习模型来检测钓鱼邮件和垃圾邮件。

第三章《使用 API 调用和 PE 头部检测恶意软件》解释了分析恶意软件和恶意软件的不同方法，并介绍了一些构建基于机器学习的恶意软件检测器的不同技术。

第四章《使用深度学习进行恶意软件检测》扩展了前一章的内容，探讨了如何构建人工神经网络和深度学习来检测恶意软件。

第五章《使用机器学习检测僵尸网络》演示了如何使用先前讨论的技术和公开可用的僵尸网络流量数据集构建僵尸网络检测器。

第六章《异常检测系统中的机器学习》向我们介绍了异常检测中最重要的术语，并指导我们构建机器学习异常检测系统。

第七章《检测高级持续威胁》向我们展示了如何使用已经加载了机器学习功能的 ELK 堆栈构建一个完全工作的真实威胁追踪平台。

第八章《使用对抗机器学习规避入侵检测系统》演示了如何使用对抗学习规避机器学习系统，并研究了一些真实案例，包括规避下一代入侵检测系统。

第九章《绕过机器学习恶意软件检测器》教会我们如何使用对抗学习和生成对抗网络绕过基于机器学习的恶意软件检测器。

第十章《机器学习和特征工程的最佳实践》探讨了不同的特征工程技术，同时向读者介绍了构建可靠系统的机器学习最佳实践。

如何充分利用本书

我们假设本书的读者熟悉基本的信息安全概念和 Python 编程。本书中的一些演示需要更多的练习和在线研究来深入讨论的概念。

如果您遇到任何错误、错别字或错误，请始终检查本书的 GitHub 存储库以查找更新的代码。

下载示例代码文件

您可以从www.packtpub.com的帐户中下载本书的示例代码文件。如果您在其他地方购买了本书，您可以访问www.packtpub.com/support并注册，以便文件直接发送到您的邮箱。

您可以按照以下步骤下载代码文件：

  1. 在www.packtpub.com登录或注册。

  2. 选择“支持”选项卡。

  3. 单击“代码下载和勘误”。

  4. 在搜索框中输入书名，然后按照屏幕上的说明操作。

下载文件后，请确保使用以下最新版本解压或提取文件夹：

  • WinRAR/7-Zip for Windows

  • Zipeg/iZip/UnRarX for Mac

  • 7-Zip/PeaZip for Linux

本书的代码捆绑包也托管在 GitHub 上，网址为github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing。如果代码有更新，将在现有的 GitHub 存储库上进行更新。

我们还有来自我们丰富书籍和视频目录的其他代码捆绑包，可在github.com/PacktPublishing/上找到。去看看吧！

下载彩色图片

我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图片。您可以从www.packtpub.com/sites/default/files/downloads/MasteringMachineLearningforPenetrationTesting_ColorImages.pdf下载。

使用的约定

本书中使用了许多文本约定。

CodeInText：指示文本中的代码字词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄。这是一个例子：“首先，使用python --version命令检查您的 Python 版本。”

代码块设置如下：

from keras import [what_to_use]
from keras.models import Sequential
from keras.layers import Dense

当我们希望引起您对代码块的特定部分的注意时，相关行或项目将以粗体显示：

model = Sequential()
# N = number of neurons
# V = number of variable
model.add(Dense(N, input_dim=V, activation='relu'))
# S = number of neurons in the 2nd layer
model.add(Dense(S, activation='relu'))
model.add(Dense(1, activation='sigmoid')) # 1 output

任何命令行输入或输出都以以下方式编写：

>>> import tensorflow as tf
>>> Message = tf.constant("Hello, world!")
>>> sess = tf.Session()
>>> print(sess.run(Message))

粗体：表示新术语、重要单词或屏幕上看到的单词。

警告或重要说明会显示为这样。

提示和技巧会显示为这样。

第一章：渗透测试中的机器学习简介

目前，机器学习技术是信息技术中最热门的趋势之一。它们影响着我们生活的方方面面，影响着每个行业和领域。机器学习是信息安全专业人员的网络武器。在本书中，读者不仅将探索机器学习技术背后的基本原理，还将学习构建完全功能的机器学习安全系统的秘诀。我们不仅会停留在构建防御层，还将说明如何构建攻击和绕过安全防御的攻击工具。通过本书，您将能够绕过机器学习安全系统，并在渗透测试任务中使用构建的模型。

在本章中，我们将涵盖：

  • 机器学习模型和算法

  • 性能评估指标

  • 降维

  • 集成学习

  • 机器学习开发环境和 Python 库

  • 渗透测试中的机器学习-承诺和挑战

技术要求

在这一章中，我们将建立一个开发环境。因此，我们将安装以下 Python 机器学习库：

  • NumPy

  • SciPy

  • TensorFlow

  • Keras

  • pandas

  • MatplotLib

  • scikit-learn

  • NLTK

  • Theano

您还可以在此 GitHub 存储库中找到本书中使用的所有脚本和安装指南：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter01。

人工智能和机器学习

让机器像人一样思考是最古老的梦想之一。机器学习技术用于基于经验和数据进行预测。

机器学习模型和算法

为了教会机器如何自己解决大量问题，我们需要考虑不同的机器学习模型。正如您所知，我们需要向模型提供数据；这就是为什么机器学习模型根据输入的数据集被分为四个主要类别：监督学习、半监督学习、无监督学习和强化学习。在本节中，我们将详细描述每个模型，以及探索每个机器学习模型中使用的最知名的算法。在构建机器学习系统之前，我们需要了解表面下的工作原理。

监督

当我们既有输入变量又有输出变量时，我们谈论监督机器学习。在这种情况下，我们需要映射两方之间的函数（或模式）。以下是一些最常用的监督机器学习算法。

贝叶斯分类器

根据剑桥英语词典的定义，偏见是以不公平的方式支持或反对特定的人或事物，允许个人意见影响您的判断。贝叶斯机器学习是指先前的信念，并通过使用数据进行更新。在数学上，它基于贝叶斯公式：

最简单的贝叶斯问题之一是随机抛硬币并尝试预测输出是正面还是反面。这就是为什么我们可以将贝叶斯方法论识别为概率的原因。当您使用少量数据时，朴素贝叶斯非常有用。

支持向量机

支持向量机（SVM）是一种监督机器学习模型，通过在表示的数据之间识别一个超平面来工作。数据可以在多维空间中表示。因此，SVM 广泛用于分类模型。在 SVM 中，将使用最佳分离不同类别的超平面。在某些情况下，当我们有不同的超平面分离不同的类别时，将通过称为间隔或间隙的东西执行正确的超平面的识别。间隔是超平面和数据位置之间的最近距离。您可以查看以下表示以检查间隔：

将选择具有最大间隙的超平面。如果选择具有最短间隔的超平面，我们可能会在以后面临错误分类问题。不要被前面的图形分散注意力；超平面并不总是线性的。考虑以下情况：

在前面的情况下，我们可以添加一个新的轴，称为z轴，并使用一个称为核函数的核技巧应用变换，其中z=x²+y²。如果应用变换，新图将如下所示：

现在，我们可以确定正确的超平面。这个转换被称为核。在现实世界中，找到一个超平面是非常困难的。因此，称为正则化和伽玛的两个重要参数在确定正确的超平面以及在每个 SVM 分类器中获得非线性超平面情况下的更好准确性方面起着巨大作用。

决策树

决策树是监督学习算法，通过将数据表示为树，根在顶部，用于决策制定。以下是决策树的图形表示：

数据是通过迭代二分 3 算法表示的。用于分类和回归问题的决策树称为 CARTs。它们由 Leo Breiman 引入。

半监督

半监督学习是在前面讨论的两个模型之间的一个领域。换句话说，如果您使用少量标记数据以及未标记数据的情况，那么您正在执行半监督学习。半监督学习广泛应用于现实世界的应用，如语音分析，蛋白质序列分类和网页内容分类。有许多半监督方法，包括生成模型，低密度分离和基于图的方法（离散马尔可夫随机场，流形正则化和最小割）。

无监督

在无监督学习中，我们对模型的输出没有明确的信息。以下是一些众所周知的无监督机器学习算法。

人工神经网络

人工网络是人工智能中一些最热门的应用，特别是机器学习。人工神经网络的主要目标是构建可以像人类大脑一样学习的模型；换句话说，我们试图模仿人类大脑。这就是为什么为了学习如何构建神经网络系统，我们需要清楚地了解人类大脑实际上是如何工作的。人类大脑是一个令人惊奇的实体。大脑由神经元组成和连接。神经元负责传输和处理信息。

我们都知道人类大脑可以执行很多任务，如听觉、视觉、味觉和许多其他复杂的任务。因此，从逻辑上讲，人们可能会认为大脑由许多不同的区域组成，每个区域负责特定的任务，都归功于特定的算法。但这是完全错误的。根据研究，人类大脑的所有不同部分都是由一个算法而不是不同的算法来实现功能的。这个假设被称为一个算法假设。

现在我们知道大脑是通过使用一个算法工作的。但是这个算法是什么？它是如何使用的？信息是如何用它处理的？

为了回答前面的问题，我们需要看一下神经元的逻辑表示。人工神经元的人工表示称为感知器。感知器由以下图表示：

有许多使用的激活函数。你可以把它们看作是逻辑门：

  • 阶跃函数：预定义的阈值。

  • Sigmoid 函数：

  • Tanh 函数：

  • ReLu 函数：

许多全连接的感知器组成了我们所谓的多层感知器（MLP）网络。典型的神经网络包括以下内容：

  • 一个输入层

  • 隐藏层

  • 输出层

一旦我们有了三个以上的隐藏层，我们将讨论术语深度学习。世界上使用许多类型的深度学习网络：

  • 卷积神经网络（CNNs）

  • 递归神经网络（RNNs）

  • 长短期记忆（LSTM）

  • 浅层神经网络

  • 自动编码器（AEs）

  • 受限玻尔兹曼机

不要担心；我们将在未来的章节中详细讨论前述算法。

为了构建深度学习模型，我们遵循由 Dr. Jason Brownlee 建议的五个步骤。这五个步骤如下：

  1. 网络定义

  2. 网络编译

  3. 网络拟合

  4. 网络评估

  5. 预测

线性回归

线性回归是一种统计和机器学习技术。它被广泛用于理解输入和输出之间的关系。当我们有数值数值时，我们使用线性回归。

逻辑回归

逻辑回归也是一种统计和机器学习技术，用作二元分类器 - 换句话说，当输出是类别（是/否，真/假，0/1 等）时。

使用 k 均值进行聚类

k-最近邻（kNN）是一种著名的聚类方法。它基于在数据点中找到相似性，或者我们称之为特征相似性。因此，这个算法很简单，并且被广泛用于解决许多分类问题，比如推荐系统、异常检测、信用评级等。然而，它需要大量的内存。虽然它是一个监督学习模型，但它应该由标记数据提供，并且输出是已知的。我们只需要映射关联两方的函数。kNN 算法是非参数的。数据被表示为特征向量。你可以把它看作是一个数学表示：

分类就像投票一样；要知道所选数据的类别，必须首先计算所选项与其他训练项之间的距离。但是我们如何计算这些距离呢？

通常，我们有两种主要的计算方法。我们可以使用欧几里得距离：

或者，我们可以使用余弦相似度：

第二步是选择k个最近的距离（k可以任意选择）。最后，我们根据置信水平进行投票。换句话说，数据将被分配给具有最大概率的类别。

强化

在强化机器学习模型中，代理与其环境互动，因此它通过在过程中收集数据来从经验中学习；目标是优化我们所谓的长期奖励。你可以把它看作是一个带有评分系统的游戏。以下图表说明了一个强化模型：

性能评估

评估是每个方法操作中的关键步骤。在构建产品或系统，尤其是机器学习模型之后，我们需要清晰地了解其性能，以确保它将来能够按预期运行。为了评估机器学习的性能，我们需要使用明确定义的参数和见解。为了计算不同的评估指标，我们需要使用四个重要的参数：

  • 真阳性

  • 假阳性

  • 真阴性

  • 假阴性

前述参数的符号如下：

  • tp：真阳性

  • fp：假阳性

  • tn：真阴性

  • fn：假阴性

有许多机器学习评估指标，例如以下内容：

  • 精度：精度，或者叫做阳性预测值，是指被正确分类的阳性样本数量与总体被分类为阳性的样本数量的比值：

  • 召回率：召回率，或者真阳性率，是指真阳性分类的比率除以数据集中的阳性样本总数：

  • F-分数：F-分数，或者 F-度量，是将精度和召回率结合在一个谐波公式中的度量。

  • 准确度：准确度是指总体被正确分类的样本数量与总体样本数量的比值。这个度量本身是不够的，因为它在我们有相等数量的类时使用。

  • 混淆矩阵：混淆矩阵是对给定机器学习模型性能的图形化表示。它总结了分类问题中每个类的性能。

降维

降维用于减少数据集的维度。在变量数量增加时，这对于处理问题变得困难时非常有帮助。通过使用“维度”，我们指的是特征。基本的降维技术之一是特征工程。

通常，我们有许多降维算法：

  • 低方差过滤器：删除与其他变量相比方差较低的变量。

  • 高相关性过滤器：通过使用 Pearson 或 Polychoric 识别具有高相关性的变量，并使用方差膨胀因子（VIF）选择其中之一。

  • 向后特征消除：通过在消除每个变量n次后计算平方误差和（SSE）来实现。

  • 线性判别分析（LDA）：这将维度的数量n从原始数量减少到类别数量-1 的特征数量。

  • 主成分分析（PCA）：这是一种将变量转换为新变量（主成分）的统计过程。

通过集成学习改善分类

在许多情况下，当构建机器学习模型时，我们会得到低准确度和低结果。为了获得良好的结果，我们可以使用集成学习技术。这可以通过将许多机器学习技术组合成一个预测模型来实现。

我们可以将集成学习技术分为两类：

  • 并行集成方法—以下图表说明了并行集成学习的工作原理：

  • 顺序集成方法—以下图表说明了顺序集成学习的工作原理：

以下是三种最常用的集成学习技术：

  • 自助聚合（bagging）：这涉及构建单独的模型，并通过使用模型平均技术（如加权平均和多数投票）将它们组合起来。

  • 提升：这是一种顺序集成学习技术。梯度提升是最常用的提升技术之一。

  • 堆叠：这类似于提升，但它使用新模型来组合子模型。

机器学习开发环境和 Python 库

到目前为止，我们已经了解了最常用的机器学习算法背后的基本知识。从这一部分开始，我们将更深入地学习，通过实践构建基于机器学习的安全项目。我们不会止步于此；在接下来的章节中，我们将学习恶意攻击者如何绕过智能安全系统。现在，让我们把到目前为止学到的东西付诸实践。如果您正在阅读本书，您可能对 Python 有一些经验。这对您很有好处，因为您有一个学习如何构建机器学习安全系统的基础。

我敢打赌您正在想，为什么选择 Python？这是一个很好的问题。根据最新研究，Python 是数据科学中最常用的编程语言之一，尤其是机器学习。最知名的机器学习库是为 Python 编写的。让我们发现构建机器学习模型所需的 Python 库和实用程序。

NumPy

数值 Python 库是数学和数组逻辑操作中最常用的库之一。它加载了许多线性代数功能，在机器学习中非常有用。当然，它是开源的，并受到许多操作系统的支持。

要安装 NumPy，请使用pip实用程序，输入以下命令：

#pip install numpy

现在，您可以通过导入它来开始使用它。以下脚本是一个简单的数组打印示例：

此外，您可以使用许多数学函数，如cosine，sine等。

SciPy

科学 Python（SciPy）就像 NumPy 一样，是一个令人惊叹的 Python 包，加载了大量科学函数和实用程序。有关更多详细信息，您可以访问www.scipy.org/getting-started.html：

TensorFlow

如果您已经从事机器学习一段时间，您将听说过 TensorFlow，甚至使用它构建了机器学习模型或为人工神经网络提供数据。这是一个令人惊叹的开源项目，基本上由 Google 开发和支持：

以下是 TensorFlow 的主要架构，根据官方网站：

如果这是您第一次使用 TensorFlow，强烈建议访问项目的官方网站www.tensorflow.org/get_started/。让我们在我们的机器上安装它，并发现一些其功能。有许多安装它的可能性；您可以使用本机 PIP、Docker、Anaconda 或 Virtualenv。

假设我们要在 Ubuntu 机器上安装它（它也支持其他操作系统）。首先，使用python --version命令检查您的 Python 版本：

使用以下命令安装 PIP 和 Virtualenv：

sudo apt-get install python-pip python-dev python-virtualenv

现在，包已安装：

使用mkdir命令创建一个新的存储库：

#mkdir TF-project

通过输入以下命令创建一个新的 Virtualenv：

 virtualenv --system-site-packages TF-project

然后，键入以下命令：

source  <Directory_Here>/bin/activate

通过使用pip install -upgrade tensorflow命令升级 TensorFlow：

>>> import tensorflow as tf
>>> Message = tf.constant("Hello, world!")
>>> sess = tf.Session()
>>> print(sess.run(Message))

以下是显示Hello World!消息的完整步骤：

Keras

Keras 是一个广泛使用的 Python 库，用于构建深度学习模型。这很容易，因为它是建立在 TensorFlow 之上的。构建深度学习模型的最佳方法是遵循先前讨论的步骤：

  1. 加载数据

  2. 定义模型

  3. 编译模型

  4. 拟合

  5. 评估

  6. 预测

在构建模型之前，请确保已预配置 SciPy 和 NumPy。要检查，请打开 Python 命令行界面并键入，例如，以下命令以检查 NumPy 版本：

 >>>print numpy.__version__

要安装 Keras，只需使用 PIP 实用程序：

$ pip install keras

当然，要检查版本，请键入以下命令：

>>> print keras.__version__

要从 Keras 导入，请使用以下命令：

from keras import [what_to_use]
from keras.models import Sequential
from keras.layers import Dense

现在，我们需要加载数据：

dataset = numpy.loadtxt("DATASET_HERE", delimiter=",")
I = dataset[:,0:8]
O = dataset[:,8]  
#the data is splitted into Inputs (I) and Outputs (O)

您可以使用任何公开可用的数据集。接下来，我们需要创建模型：

model = Sequential()
# N = number of neurons
# V = number of variable
model.add(Dense(N, input_dim=V, activation='relu'))
# S = number of neurons in the 2nd layer
model.add(Dense(S, activation='relu'))
model.add(Dense(1, activation='sigmoid')) # 1 output

现在，我们需要编译模型：

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

我们需要拟合模型：

model.fit(I, O, epochs=E, batch_size=B)

如前所述，评估是机器学习中的关键步骤；因此，为了评估我们的模型，我们使用：

scores = model.evaluate(I, O)
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

要进行预测，请添加以下一行：

predictions = model.predict(Some_Input_Here)

pandas

pandas 是一个开源的 Python 库，以其高性能而闻名；它是由 Wes McKinney 开发的。它可以快速操作数据。这就是为什么它在学术界和商业活动的许多领域被广泛使用。与之前的包一样，它受到许多操作系统的支持。

要在 Ubuntu 机器上安装它，请输入以下命令：

sudo apt-get install python-pandas

基本上，它操作三种主要数据结构-数据框、系列和面板：

>> import pandas as pd
>>>import numpy as np
 data = np.array(['p','a','c','k',’t’])
 SR = pd.Series(data)
 print SR

我在这个截图中总结了所有之前的行：

Matplotlib

如您所知，可视化在从数据中获得洞察力方面起着重要作用，也在机器学习中非常重要。Matplotlib 是数据科学家用于绘图的可视化库。您可以通过访问其官方网站matplotlib.org来更清楚地了解：

要在 Ubuntu 机器上安装它，请使用以下命令：

sudo apt-get install python3-matplotlib

要导入所需的包，请使用import：

import matplotlib.pyplot as plt
import numpy as np

使用此示例准备数据：

x = np.linspace(0, 20, 50)

要绘制它，请添加这一行：

plt.plot(x, x, label='linear')

要添加图例，请使用以下命令：

plt.legend()

现在，让我们显示图表：

plt.show()

看吧！这是我们的图表：

scikit-learn

我强烈推荐这个令人惊叹的 Python 库。scikit-learn 功能齐全，具有各种功能，包括机器学习功能。scikit-learn 的官方网站是scikit-learn.org/。要下载它，请使用之前讨论过的 PIP：

pip install -U scikit-learn

NLTK

自然语言处理是机器学习项目中最常用的应用之一。NLTK 是一个 Python 包，可以帮助开发人员和数据科学家管理和操作大量文本。可以使用以下命令安装 NLTK：

pip install -U nltk

现在，导入nltk：

>>> import nltk

使用以下命令安装nltk包：

> nltk.download()

您可以安装所有的包：

如果您正在使用命令行环境，您只需要按照以下步骤进行：

如果您键入all，您将下载所有的包：

Theano

优化和速度是构建机器学习模型的两个关键因素。Theano 是一个 Python 包，优化实现并使您能够利用 GPU。要安装它，请使用以下命令：

 pip install theano

要导入所有 Theano 模块，请键入：

>>> from theano import *

在这里，我们导入了一个名为tensor的子包：

>>> import theano.tensor as T

假设我们想要添加两个数字：

>>> from theano import function
>>> a = T.dscalar('a')
>>> b = T.dscalar('b')
>>> c = a + b
>>> f = function([a, b], c)

以下是完整的步骤：

到目前为止，我们已经掌握了安装和使用机器学习项目中最常用的 Python 库的基本技能。我假设您已经在您的机器上安装了所有之前的包。在接下来的章节中，我们将使用这些包中的大部分来构建完全可用的信息安全机器学习项目。

渗透测试中的机器学习-承诺和挑战

机器学习现在是每个现代项目中必不可少的一个方面。结合数学和尖端优化技术和工具可以提供惊人的结果。将机器学习和分析应用于信息安全是在防御先进的现实世界攻击和威胁方面迈出的一步。

黑客总是试图使用新的复杂技术来攻击现代组织。因此，作为安全专业人员，我们需要保持更新并部署所需的防护措施来保护资产。许多研究人员已经提出了成千上万的建立基于机器学习技术的防御系统的建议。例如，以下是一些信息安全模型：

  • 监督学习：

  • 网络流量分析

  • 垃圾邮件过滤

  • 恶意软件检测

  • 半监督学习：

  • 网络异常检测

  • C2 检测

  • 无监督学习：

  • 用户行为分析

  • 内部威胁检测

  • 恶意软件家族识别

正如你所看到的，有很多应用程序可以帮助保护现代组织的宝贵资产。但一般来说，黑帽骇客不再使用传统技术。如今，机器学习技术的使用正在从防御性技术转向进攻性系统。我们正在从防御性转向进攻性。事实上，仅仅使用人工智能和机器学习构建防御层是不够的；需要了解如何利用这些技术进行凶猛的攻击，并在进行渗透测试任务时将其添加到您的技术技能中。在模拟尖端攻击时，将进攻性机器学习工具添加到您的渗透测试工具库中非常有用。虽然很多这些进攻性应用程序仍然是为研究目的而存在，但我们将尝试构建我们自己的项目，以了解攻击者是如何构建进攻性工具和网络武器来攻击现代公司的。也许您以后可以在渗透测试操作中使用它们。

深度利用

最近出现了许多出色的公开可用工具，利用机器学习能力将渗透测试提升到另一个水平。其中一个工具就是 Deep Exploit。它在 2018 年黑帽大会上展示。它是一个与 metasploit 相关联的全自动渗透测试工具。这个出色的工具使用了强化学习（自学习）。

它能够执行以下任务：

  • 情报收集

  • 威胁建模

  • 漏洞分析

  • 利用

  • 后利用

  • 报告

要下载 Deep Exploit，请访问其官方 GitHub 存储库：github.com/13o-bbr-bbq/machine_learning_security/tree/master/DeepExploit。

它由一个机器学习模型（A3C）和 metasploit 组成。这是 Deep Exploit 架构的高级概述：

使 Deep Exploit 正常工作所需的环境如下：

  • Kali Linux 2017.3（VMWare 上的客户操作系统）

  • 内存：8.0GB

  • Metasploit 框架 4.16.15-dev

  • Windows 10 Home 64 位（主机操作系统）

  • CPU：Intel(R) Core(TM) i7-6500U 2.50GHz

  • 内存：16.0GB

  • Python 3.6.1（Anaconda3）

  • TensorFlow 1.4.0

  • Keras 2.1.2

总结

现在我们已经学习了最常用的机器学习技术；在深入实验室之前，我们需要对这些模型的实际工作原理有一个公平的理解。我们的实际经验将从下一章开始。

阅读完本章后，我认为我们可以构建我们自己的开发环境。第二章将向我们展示如何抵御先进的基于计算机的社会工程攻击，我们将学习如何构建一个智能的钓鱼检测器。就像每一章一样，我们将从攻击背后的技术开始学习，并逐步学习构建一个钓鱼检测系统的实际步骤。

问题

  1. 尽管机器学习是一个有趣的概念，但在有用的有限商业应用中使用它。 （是 | 否）

  2. 机器学习应用程序太复杂，无法在云中运行。（是 | 否）

  3. 对于两次 k 均值聚类运行，预期会得到相同的聚类结果吗？（是 | 否）

  4. 具有离散值目标属性的预测模型可以称为：

(a) 回归模型

(b) 分类模型

  1. 以下哪些技术执行类似于神经网络中的辍学操作？

(a) 堆叠

(b) 裹袋

(c) 提升

  1. 哪种神经网络架构最适合解决图像识别问题？

(a) 卷积神经网络

(b) 循环神经网络

(c) 多层感知器

(d) 感知器

  1. 深度学习与传统机器学习有何不同？

(a) 深度学习算法可以处理更多数据，并且需要更少的数据科学家监督。

(b) 机器学习更简单，需要更少的数据分析师监督，而深度学习则不然。

(c) 两者之间没有真正的区别；它们是相同的工具，只是名称不同。

  1. 以下哪项是机器学习项目中经常使用的技术？

(a) 将数据分类。

(b) 将相似的对象分组成簇。

(c) 识别事件之间的关系，以预测一个事件将在另一个事件之后发生。

(d) 以上全部。

进一步阅读

为了节省您的一些努力，我已经准备了一份有用的资源列表，以帮助您更深入地探索我们讨论过的技术。

推荐书籍：

推荐网站和在线课程：

第二章：钓鱼域名检测

社会工程是每个个人和现代组织面临的最危险的威胁之一。钓鱼是一种众所周知的基于计算机的社会工程技术。攻击者使用伪装的电子邮件地址作为武器来瞄准大公司。由于每天收到大量的钓鱼邮件，公司无法检测到所有这些邮件。这就是为什么需要新的技术和防护措施来防御钓鱼。本章将介绍构建三个不同基于机器学习的项目以检测钓鱼尝试所需的步骤，使用尖端的 Python 机器学习库。

在本章中，我们将涵盖：

  • 社会工程概述

  • 社会工程渗透测试的步骤

  • 使用不同的机器学习模型构建实时钓鱼攻击检测器：

  • 使用逻辑回归进行钓鱼检测

  • 使用决策树进行钓鱼检测

  • 使用自然语言处理（NLP）进行垃圾邮件检测。

技术要求

在本章中，我们将使用以下 Python 库：

  • scikit-learn Python（≥2.7 或≥3.3）

  • NumPy（≥1.8.2）

  • NLTK

如果您尚未安装它们，请确保在继续本章之前安装它们。您可以在github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter02找到代码文件。

社会工程概述

社会工程，根据定义，是对一个人的心理操纵，以从他们那里获取有用和敏感的信息，这些信息以后可以用来破坏系统。换句话说，罪犯利用社会工程从人们那里获取机密信息，利用人类行为。

社会工程参与框架

社会工程参与框架（SEEF）是由 Dominique C. Brack 和 Alexander Bahmram 开发的框架。它总结了信息安全和防御社会工程多年的经验。该框架的利益相关者是组织、政府和个人（个人）。社会工程参与管理经历三个步骤：

  1. 预先参与过程：准备社会工程操作

  2. 在参与过程中：参与发生

  3. 在参与过程后：提交报告

罪犯使用许多社会工程技术：

  • 诱饵：说服受害者透露信息，承诺给他奖励或礼物。

  • 冒充：假装成别人。

  • 垃圾箱潜水：从垃圾箱中收集有价值的信息（包括地址、电子邮件等）。

  • 窥视：在别人背后窥视他们的机器，当他们在打字时。

  • 钓鱼：这是最常用的技术；当攻击者假扮成受信任的实体，欺骗受害者打开电子邮件、即时消息或短信时，就会发生这种情况。

社会工程渗透测试步骤

渗透测试模拟黑客的攻击，以评估公司的安全姿态，以部署所需的防护措施。渗透测试是一个有方法的过程，它经过明确定义的步骤。有许多类型的渗透测试：

  • 白盒渗透测试

  • 黑盒渗透测试

  • 灰盒渗透测试

要执行社会工程渗透测试，您需要按照以下步骤进行：

使用不同的机器学习模型构建实时钓鱼攻击检测器

在接下来的章节中，我们将学习如何构建机器学习钓鱼检测器。我们将涵盖以下两种方法：

  • 使用逻辑回归进行钓鱼检测

  • 使用决策树进行钓鱼检测

使用逻辑回归进行钓鱼检测

在本节中，我们将使用逻辑回归算法从头开始构建一个钓鱼网站检测器。逻辑回归是一种用于进行二项预测（两类）的众所周知的统计技术。

就像在每个机器学习项目中一样，我们需要数据来供给我们的机器学习模型。对于我们的模型，我们将使用 UCI 机器学习库（钓鱼网站数据集）。您可以在archive.ics.uci.edu/ml/datasets/Phishing+Websites上查看它：

数据集以arff文件的形式提供：

以下是数据集的快照：

为了更好地操作，我们已经将数据集组织成了csv文件：

您可能已经注意到，从属性中，数据集的每一行都以以下格式表示 - {30 个属性（具有 IP 地址 URL 长度，异常 URL 等）} + {1 个属性（结果）}：

对于我们的模型，我们将导入两个机器学习库，NumPy 和 scikit-learn，这两个库我们已经在第一章中安装了，渗透测试中的机器学习简介。

让我们打开 Python 环境并加载所需的库：

>>> import numpy as np
>>> from sklearn import *
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.metrics import accuracy_score

接下来，加载数据：

training_data = np.genfromtxt('dataset.csv', delimiter=',', dtype=np.int32)

确定inputs（除最后一个属性外的所有属性）和outputs（最后一个属性）：

>>> inputs = training_data[:,:-1]
>>> outputs = training_data[:, -1]

在上一章中，我们讨论了如何将数据集分成训练数据和测试数据：

training_inputs = inputs[:2000]
training_outputs = outputs[:2000] 
testing_inputs = inputs[2000:]
testing_outputs = outputs[2000:]

创建 scikit-learn 逻辑回归分类器：

classifier = LogisticRegression()

训练分类器：

classifier.fit(training_inputs, training_outputs)

进行预测：

predictions = classifier.predict(testing_inputs)

让我们打印出我们的钓鱼网站检测器模型的准确率：

accuracy = 100.0 * accuracy_score(testing_outputs, predictions) 
print ("The accuracy of your Logistic Regression on testing data is: " + str(accuracy))

我们的模型准确率约为 85%。这是一个很好的准确率，因为我们的模型在 100 个中检测出了 85 个钓鱼网址。但让我们尝试使用相同的数据，用决策树来构建一个更好的模型。

使用决策树进行钓鱼检测

为了构建第二个模型，我们将使用相同的机器学习库，因此无需再次导入它们。但是，我们将从sklearn导入决策树分类器：

>>> from sklearn import tree

创建tree.DecisionTreeClassifier() scikit-learn 分类器：

classifier = tree.DecisionTreeClassifier()

训练模型：

classifier.fit(training_inputs, training_outputs)

计算预测：

predictions = classifier.predict(testing_inputs)

计算准确率：

accuracy = 100.0 * accuracy_score(testing_outputs, predictions)

然后，打印出结果：

print ("The accuracy of your decision tree on testing data is: " + str(accuracy))

第二个模型的准确率约为 90.4%，与第一个模型相比，这是一个很好的结果。我们现在已经学会了如何使用两种机器学习技术构建两个钓鱼网站检测器。

NLP 深入概述

NLP 是机器分析和理解人类语言的艺术。根据许多研究，超过 75%的使用数据是非结构化的。非结构化数据没有预定义的数据模型，也没有按预定义的方式组织。电子邮件、推文、日常消息甚至我们记录的演讲都是非结构化数据的形式。NLP 是机器分析、理解和从自然语言中获取含义的一种方式。NLP 广泛应用于许多领域和应用程序，例如：

  • 实时翻译

  • 自动摘要

  • 情感分析

  • 语音识别

  • 构建聊天机器人

通常，NLP 有两个不同的组成部分：

  • 自然语言理解（NLU）：这指的是将输入映射为有用的表示。

  • 自然语言生成（NLG）：这指的是将内部表示转换为有用的表示。换句话说，它是将数据转换为书面或口头叙述。商业智能仪表板的书面分析是 NLG 应用之一。

每个 NLP 项目都经历五个步骤。构建 NLP 项目的第一步是识别和分析单词的结构。这一步涉及将数据分成段落、句子和单词。然后我们分析句子中的单词以及它们之间的关系。第三步涉及检查文本的意义。然后，分析连续句子的含义。最后，我们通过实用分析完成项目。

开源 NLP 库

有许多开源的 Python 库提供了构建实际 NLP 应用所需的结构，例如：

  • Apache OpenNLP

  • GATE NLP 库

  • Stanford NLP

  • 当然，自然语言工具包（NLTK）

在上一章中，我们学习了如何安装许多开源的机器学习 Python 库，包括 NLTK。让我们启动我们的 Linux 机器并尝试一些实际技术。

打开 Python 终端并导入nltk：

>>> import nltk

下载书籍类型，如下所示：

>>> nltk.download()

如果要列出我们在上一章中已经下载的可用资源，请输入l：

您也可以输入：

>> from nltk.book import *

要从链接中获取文本，建议使用urllib模块来爬取网站：

>>> from urllib import urlopen
>>> url = "http://www.URL_HERE/file.txt"

作为演示，我们将加载一个名为Security.in.Wireless.Ad.Hoc.and.Sensor.Networks的文本：

我们爬取了文本文件，并使用len检查其长度和raw[:50]显示一些内容。从屏幕截图中可以看到，文本包含许多对我们的项目无用的符号。为了只获取我们需要的内容，我们使用标记化：

>>> tokens = nltk.word_tokenize(raw)
>>> len(tokens)
> tokens[:10]

总结一下我们在上一节学到的内容，我们看到了如何下载网页，对文本进行标记化，并对单词进行规范化。

使用 NLTK 进行垃圾邮件检测

现在是时候使用 NLTK 构建我们的垃圾邮件检测器了。这种分类器的原理很简单；我们需要检测垃圾邮件发送者使用的单词。我们将使用 Python 和nltk库构建一个垃圾邮件/非垃圾邮件二元分类器，以检测电子邮件是否为垃圾邮件。首先，我们需要像往常一样导入该库：

>>> import nltk

我们需要加载数据并用电子邮件数据集来训练我们的模型。为了实现这一点，我们可以使用Internet CONtent FIltering Group提供的数据集。您可以访问该网站labs-repos.iit.demokritos.gr/skel/i-config/：

基本上，该网站提供了四个数据集：

  • Ling-spam

  • PU1

  • PU123A

  • Enron-spam

对于我们的项目，我们将使用 Enron-spam 数据集：

让我们使用wget命令下载数据集：

使用tar -xzf enron1.tar.gz命令提取tar.gz文件：

洗牌cp spam/* emails && cp ham/* emails对象：

要洗牌电子邮件，让我们编写一个小的 Python 脚本Shuffle.py来完成这项工作：

import os
import random
#initiate a list called emails_list
emails_list = []
Directory = '/home/azureuser/spam_filter/enron1/emails/'
Dir_list  = os.listdir(Directory)
for file in Dir_list:
    f = open(Directory + file, 'r')
    emails_list.append(f.read())
f.close()

只需更改目录变量，它将对文件进行洗牌：

准备数据集后，您应该知道，正如我们之前学到的那样，我们需要对电子邮件进行标记化：

>> from nltk import word_tokenize

此外，我们还需要执行另一个步骤，称为词形还原。词形还原将连接具有不同形式的单词，如 hacker/hackers 和 is/are。我们需要导入WordNetLemmatizer：

>>> from nltk import WordNetLemmatizer

创建一个用于演示的句子，并打印出词形还原器的结果：

>>> [lemmatizer.lemmatize(word.lower()) for word in word_tokenize(unicode(sentence, errors='ignore'))]

然后，我们需要去除停用词，如of，is，the等：

from nltk.corpus import stopwords
stop = stopwords.words('english')

为了处理电子邮件，必须创建一个名为Process的函数，以对我们的数据集进行词形还原和标记化：

def Process(data):
 lemmatizer = WordNetLemmatizer()
 return [lemmatizer.lemmatize(word.lower()) for word in word_tokenize(unicode(sentence,   errors='ignore'))]

第二步是通过阅读电子邮件的单词进行特征提取：

from collections import Counter
def Features_Extraction(text, setting):
 if setting=='bow':
# Bow means  bag-of-words
 return {word: count for word, count in Counter(Process(text)).items() if not word in stop}
 else:
 return {word: True for word in Process(text) if not word in stop}

提取特征：

features = [(Features_Extraction(email, 'bow'), label) for (email, label) in emails]

现在，让我们定义训练模型的 Python 函数：

def training_Model (Features, samples):
 Size = int(len(Features) * samples)
 training , testing = Features[:Size], Features[Size:]
 print ('Training = ' + str(len(training)) + ' emails')
 print ('Testing = ' + str(len(testing)) + ' emails')

作为分类算法，我们将使用NaiveBayesClassifier：

from nltk import NaiveBayesClassifier, classify
classifier = NaiveBayesClassifier.train(training)

最后，我们定义评估 Python 函数：

def evaluate(training, tesing, classifier):
 print ('Training Accuracy is ' + str(classify.accuracy(classifier, train_set)))
 print ('Testing Accuracy i ' + str(classify.accuracy(classifier, test_set)))

总结

在本章中，我们学习了如何通过从头开始构建三个不同的项目来检测网络钓鱼尝试。首先，我们发现如何利用两种不同的机器学习技术开发网络钓鱼检测器，这要归功于尖端的 Python 机器学习库。第三个项目是一个基于 NLP 和朴素贝叶斯分类的垃圾邮件过滤器。在下一章中，我们将使用不同的技术和 Python 机器学习库构建各种项目来检测恶意软件。

问题

希望您能轻松地阅读完本章。现在，像往常一样，是练习时间了。您的任务是尝试构建自己的垃圾邮件检测系统。我们将通过问题来指导您。

在本章的 GitHub 存储库中，您将找到由 Androutsopoulos、J. Koutsias、K.V. Chandrinos、George Paliouras 和 C.D. Spyropoulos 进行的研究收集的数据集：朴素贝叶斯反垃圾邮件过滤的评估。机器学习在新信息时代的研讨会论文集，G. Potamias，V. Moustakis 和 M. van Someren（编辑），第 11 届欧洲机器学习大会，西班牙巴塞罗那，第 9-17 页，2000 年。

现在可以准备数据了：

  1. 以下是一些要执行的文本清理任务：

  • 清理文本中的停用词、数字和标点符号。

  • 执行词形还原。

  1. 创建一个单词字典，包括它们的频率。

在电子邮件文本中，您会注意到第一行是电子邮件的主题，第三行是电子邮件的正文（我们只需要电子邮件正文）。

  1. 从字典中删除非单词。

  2. 从数据中提取特征。

  3. 准备特征向量及其标签。

  4. 使用线性支持向量机分类器对模型进行训练。

  5. 打印出模型的混淆矩阵。

第三章：使用 API 调用和 PE 头部进行恶意软件检测

信息安全中最烦人的威胁之一是恶意程序。每天，我们都会听到关于数据泄露和恶意软件的网络攻击的新闻。攻击者正在提高他们的开发技能，并构建新的恶意软件，能够绕过公司的安全防护和杀毒产品。本章将介绍一些新的技术和解决方案，使用尖端的数据科学、Python 库和机器学习算法来打败恶意软件。

在本章中，我们将涵盖：

  • 恶意软件分析方法

  • 机器学习辅助的恶意软件分析技术，带有实际的、真实世界的 Python 项目

技术要求

在本章中，我们将使用已经安装的相同 Python 库。我们将在本书的大部分章节中使用这些库。这就是为什么我们在第一章中教你如何安装所有所需的库。

你会发现所有讨论过的代码，以及一些其他有用的脚本，都在存储库中github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter03。

恶意软件概述

恶意软件是设计用来在用户不知情的情况下渗透和破坏信息系统的恶意软件。术语恶意软件涵盖了许多类别。有许多不同类型的恶意软件：

  • 病毒

  • 勒索软件

  • 蠕虫

  • 特洛伊木马

  • 后门

  • 间谍软件

  • 键盘记录器

  • 广告软件、机器人和 rootkits

恶意软件分析

作为恶意软件分析员，你的工作是发现系统发生了什么，并确保受恶意软件损害的机器与组织的网络隔离。为了进行恶意软件分析，我们需要遵循特定的操作和方法。在进行恶意软件分析时，我们必须执行三种技术：静态恶意软件分析、动态恶意软件分析和内存恶意软件分析。我们将逐一看看它们。

静态恶意软件分析

恶意软件分析的第一步是收集有关恶意软件的所有信息。静态分析是使用不同的技术和实用程序收集有关恶意二进制文件的所有可用信息的艺术。在这个阶段，分析人员在不真正执行它的情况下检查恶意软件。一些常见的静态恶意软件分析方法如下：

  • 在线杀毒扫描：使用在线扫描器扫描可疑文件是检查文件的好方法，这要归功于在线环境，让你能够使用许多杀毒产品扫描文件。最著名的在线扫描器是 VirusTotal。如果你想扫描一个文件，只需访问www.virustotal.com/#/home/upload并上传文件：

为了自动化任务，VirusTotal 提供了一些有用的 API。因此，你可以用几行代码构建自己的 Python 脚本：

要扫描file.exe，你可以使用来自 VirusTotal 的以下代码片段：

import requests
 url = 'https://www.virustotal.com/vtapi/v2/file/scan'
 params = {'apikey': '<apikey>'}
 files = {'file': ('myfile.exe', open('myfile.exe', 'rb'))}
 response = requests.post(url, files=files, params=params)
 print(response.json())

要获取密钥，只需创建一个 VirusTotal 社区帐户。

  • 哈希：这是一种识别文件的技术。每个哈希文件都有一个唯一的哈希。最常用的哈希函数是 MD5 和 SHA256。

  • 字符串：这些也是信息的重要来源。从恶意程序中提取字符串将为我们提供有关恶意软件的重要信息。一些字符串包括 URI、URL、错误消息和注释。

动态恶意软件分析

收集有关恶意软件的信息后，你应该在一个隔离和安全的环境中运行它。一般来说，这些环境被称为恶意软件分析沙盒。沙盒加载了分析和监控工具，以在恶意软件运行时收集有关恶意软件的信息。恶意软件分析人员可以收集以下信息，以及更多：

  • TCP 连接

  • DNS 摘要

  • 恶意软件行为

  • 系统调用

内存恶意软件分析

多年前，使用前两种技术就足以分析恶意软件，但攻击者现在正在使用新的、更复杂的技术来避免检测。我敢打赌你已经听说过无文件恶意软件。需要内存恶意软件分析来检测新一波的恶意软件。内存恶意软件分析是通过分析从感染的机器收集的内存转储来进行的。为了进行内存分析，分析师首先需要获取内存（转储内存），然后可以使用许多实用程序和技术来进行后续分析。

最常用的框架之一是 volatility 框架。如果你安装了 Kali Linux 发行版，你可以在机器上直接使用 volatility 而不需要安装它。以下截图是从 Kali Linux 内置的 volatility 框架中获取的：

Volatility 帮助分析师从内存转储中收集信息，包括以下内容等等：

  • Bash 历史

  • API 钩子

  • 网络信息

  • 内核加载模块

规避技术

攻击者和恶意软件开发者不断想出新的技术和方法来避免检测。一些最常见的技术包括：

  • 混淆：这是使恶意软件更难以检测或分析的做法。死代码插入、寄存器重新分配和加密是三种混淆技术。

  • 绑定：这是将恶意软件与合法文件绑定在一起的做法，导致形成一个可执行文件。

  • 打包：打包器，有时被称为自解压缩存档，是一种软件，当执行打包文件时，在内存中解压缩自身。

可移植可执行文件格式文件

可移植可执行文件（PE）文件是用于 32 位和 64 位 Windows 版本的可执行文件、DDL 和目标代码的文件格式。它们包含了许多对恶意软件分析师有用的信息，包括导入、导出、时间戳、子系统、部分和资源。以下是 PE 文件的基本结构：

PE 文件的一些组件如下：

  • DOS 头部：这从每个 PE 文件的前 64 个字节开始，因此 DOS 可以验证可执行文件，并在 DOS stub 模式下运行它。

  • PE 头部：这包含了信息，包括代码的位置和大小。

  • PE 部分：它们包含文件的主要内容。

要探索 PE 头部的信息，可以使用许多工具，如 PE EXPLORER、PEview 和 PEstudio。

使用 PE 头部进行机器学习恶意软件检测

为了训练我们的机器学习模型来查找恶意软件数据集，有许多公开可用的数据源供数据科学家和恶意软件分析师使用。例如，以下网站为安全研究人员和机器学习爱好者提供了下载许多不同恶意软件样本的能力：

要处理 PE 文件，我强烈推荐使用一个名为pefile的惊人 Python 库。pefile让你能够检查头部、分析部分、检索数据，以及其他功能，如打包器检测和 PEiD 签名生成。你可以在 GitHub 项目中查看github.com/erocarrera/pefile。

你也可以像我们使用其他机器学习库一样使用 PIP 安装它：

# pip install pefile

现在我们成功安装了pefile：

让我们开始构建我们的第一个恶意软件分类器。对于这个模型，我们将使用三种不同的技术：

  • 随机森林

  • 梯度提升分类

  • AdaBoost 分类

正如你可能从本书中的分类算法中注意到的那样，我们正在尝试使用许多不同的技术。在某些情况下，您可以使用先前讨论过的算法之一，但我正在尝试在每一章中使用不同的技术，以便您可以清楚地了解如何使用每种机器学习技术。

到目前为止，您已经意识到构建机器学习模型的第一步（在研究项目需求和要求之后，当然）是下载数据集。在本节中，我们将下载由安全博主 Prateek Lalwani 提供的恶意软件数据集。恶意软件数据集包含从以下提取的特征：

  • 41,323 个 Windows 二进制文件（可执行文件.exe和.dlls），作为合法文件。

  • 从 VirusShare 网站下载的 96,724 个恶意软件文件。因此，数据集总共包含 138,048 行。

数据集分为如下：

让我们从pandas Python 库中加载恶意软件数据集开始：

import pandas as pd
MalwareDataset = pd.read_csv('MalwareData.csv', sep='|')
Legit = MalwareDataset[0:41323].drop(['legitimate'], axis=1)
Malware = MalwareDataset[41323::].drop(['legitimate'], axis=1)

为了确保数据集已正确加载，请打印重要特征的数量：

print('The Number of important features is  %i \n' % Legit.shape[1])

重要特征的数量为 56将是结果行：

为了提高估计器的准确度分数，我们将使用sklearn.feature_selection模块。该模块用于特征选择或数据集的降维。

要计算特征的重要性，在我们的情况下，我们将使用基于树的特征选择。加载sklearn.feature_selection模块：

import sklearn
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
from sklearn import cross_validation 
Data = MalwareDataset.drop(['Name', 'md5', 'legitimate'], axis=1).values
Target = MalwareDataset['legitimate'].values
FeatSelect =  sklearn.ensemble.ExtraTreesClassifier().fit(Data, Target)
Model = SelectFromModel(FeatSelect, prefit=True)
Data_new = Model.transform(Data)
print (Data.shape)
print (Data_new.shape)

因此，算法已为我们选择了九个重要特征。要打印它们，请使用以下命令：

Features = Data_new.shape[1]
Index = np.argsort(ske.ExtraTreesClassifier().fit(Data,Target).feature_importances_)[::-1][:Features]
for feat  in range(Features):
print(MalwareDataset.columns[2+index[feat]])

最重要的特征如下：

现在，是时候用随机森林分类器训练我们的模型了。不要忘记像我们之前学到的那样分割数据集：

Legit_Train, Legit_Test, Malware_Train, Malware_Test = cross_validation.train_test_split(Data_new, Target ,test_size=0.2) 
clf =  sklearn.ensemble.RandomForestClassifier(n_estimators=50)
clf.fit(Legit_Train, Malware_Train)
score = clf.score(Legit_Test, Malware_Test)

让我们看看最终结果：

print("The score of Random Forest Algorithm is," score*100))

得分看起来非常有希望。该模型以 99%的成功率检测到了恶意软件，这是一个很好的结果。要获取有关我们的恶意软件分类器的假阳性和假阴性率的更多信息，请导入 scikit-learnconfusion_matrix模块：

from sklearn.metrics import confusion_matrix

添加以下行：

Result = clf.predict(Legit_Test)
CM = confusion_matrix(Malware_Test, Result)
print("False positive rate : %f %%" % ((CM[0][1] / float(sum(CM[0])))*100)) print('False negative rate : %f %%' % ( (CM[1][0] / float(sum(CM[1]))*100)))

假阳性率为 0.6%，假阴性率为 1.4%。

要使用另一个分类器训练模型，请重复上述步骤，但是选择随机森林分类器的代替，选择一种机器学习算法。例如，我将选择梯度提升：

Clf = sklearn.ensemble.GradientBoostingClassifier(n_estimators=50)
Clf.fit(Legit_Train, Malware_Train)
Score = Clf.score(Legit_Test, Malware_Test)

让我们检查第二个分数：

print ("The Model score using Gradient Boosting is", Score * 100)

这有 98.8%的检测率。使用 AdaBoost 分类器的得分如下：

Classifiers =
{ "RandomForest": ske.RandomForestClassifier(n_estimators=50), "GradientBoosting": ske.GradientBoostingClassifier(n_estimators=50), "AdaBoost": ske.AdaBoostClassifier(n_estimators=100),}

for Classif in Classifiers:
clf = Classifiers[Classif]
clf.fit(Legit_Train,Malware_Train)
score = clf.score(Legit_test, Malware_test)
print("%s : %f %%" % (Classif, score*100))

使用 API 调用的机器学习恶意软件检测

使用 API 调用分析恶意软件在恶意软件分析中起着重要作用。因此，API 可以让恶意软件分析人员了解恶意软件行为，特别是在基本的静态分析由于混淆技术（如打包程序、加密程序和保护程序）而失败时。通过研究 API 调用，恶意软件分析人员可以了解恶意文件的工作原理。有许多在线工具可以让您在安全环境中分析恶意软件。这些实用程序和环境被称为沙箱。检测到的恶意软件由哈希函数（MD5 或 SHA256）标识。恶意软件分析人员使用哈希对文件进行签名。例如，以下 API 是从www.hybrid-analysis.com的在线恶意软件扫描报告中获取的。

这是关于恶意软件“PE32 可执行文件（GUI）Intel 80386，用于 MS Windows”的一些细节。它的哈希是：4c510779ab6a58a3bdbbe8d5f3ec568fcf33df81b0f1a5bdacabf78a9c62f492

根据微软网站，msdn.microsoft.com/，GetProcAddress从指定的动态链接库（DLL）中检索导出函数或变量的地址。因此，如果您想了解更多关于其他调用的信息，只需访问微软开发者网络并搜索 API 调用函数：

报告包括对发现的完整总结，不仅包括 API 调用。它包括：

  • 一般信息

  • 恶意指标

  • 异常特征

  • 反检测/隐蔽性

  • 反向工程

  • 网络相关信息

以下是有关扫描的恶意软件的信息。我们之前讨论了大部分所需的发现（静态分析工件：大小、类型等）：

对于我们的第二个恶意软件分类器，我们将使用 API 调用来构建一个机器学习恶意软件检测器。为了从恶意软件二进制文件中提取 API，恶意软件分析师需要按照明确定的步骤进行：

  1. 恶意软件解包

  2. 汇编程序检索

  3. API 调用提取

  4. 使用官方微软网站分析 API 调用

您可以将恶意软件行为分为不同组。例如，巴拉瑞特大学在文章《通过提取 API 调用来理解恶意软件行为》中将 API 调用分为六类。您可以使用它来分析您的发现：

作为演示，让我们使用支持向量机学习算法和 API 调用数据集构建一个 Android 恶意软件检测项目。本章的 GitHub 文件夹包含一个准备好的数据集来构建我们的模型：

在构建模型之前，我们需要导入一些有用的模块：

>>> from sklearn.feature_selection import mutual_info_classif
>>> from sklearn import preprocessing
>>> import numpy as np
>>> from sklearn.svm import SVC, LinearSVC
>>> from sklearn import svm
>>> import csv
>>> import random

首先，让我们预处理我们的 CSV 文件（Android_Feats.csv）：

>>> PRatio = 0.7
>>> Dataset =  open('Android_Feats.csv')
>>> Reader = csv.reader(Dataset)
>>> Data = list(Reader)
>>> Data = random.sample(Data, len(Data))
>>> Data = np.array(Data)
> Dataset.close()

使用 NumPy 标识文件中的数据和标签：

>>> cols = np.shape(Data)[1]
>>> Y = Data[:,cols-1]
>>> Y = np.array(Y)
>>> Y = np.ravel(Y,order='C')
>>> X = Data[:,:cols-1]
>>> X = X.astype(np.float)
>>> X = preprocessing.scale(X)

到目前为止，处理阶段已经完成。如前所述，我们需要提取最重要的特征，因为计算所有可用的特征将是一项繁重的任务：

Features = [i.strip() for i in open("Android_Feats.csv").readlines()]
Features = np.array(Features)
MI= mutual_info_classif(X,Y)
Featureind = sorted(range(len(MI)), key=lambda i: MI[i], reverse=True)[:50]
SelectFeats = Features[Featureind]

现在，将数据集（数据和标签）分成训练集和测试集：

PRows = int(PRatio*len(Data))
TrainD = X[:PRows,Featureind]
TrainL = Y[:PRows]
TestD = X[PRows:,Featureind]
TestL = Y[PRows:]

特征选择已成功完成。为了训练模型，我们将使用支持向量机分类器：

>>> clf = svm.SVC()
>>> clf.fit(TrainD,TrainL)
>>> score = clf.score(TestD,TestL)
>>> print (score * 100)

哇！我们新模型的准确率为 98%，这是一个很高的检测率。

总结

恶意软件是困扰现代组织安全的最普遍的网络威胁之一。黑客不断改进，因此传统的检测技术已经过时，杀毒产品通常无法检测到高级持久性威胁。这就是为什么机器学习技术可以帮助我们检测恶意软件。

在本章中，我们学习了如何使用许多机器学习算法和开源 Python 库构建恶意软件分类器。下一章将教我们如何使用与人类思维相同的算法构建更加健壮的系统来检测恶意软件。我们将学习如何使用深度学习来检测恶意软件，使用本书中一直使用的 Python 库。

问题

现在您可以构建一个机器学习模型。让我们练习一下，将我们的新技能付诸实践。在本章的 GitHub 存储库中，您将找到一个包含有关 Android 恶意软件样本信息的数据集。现在您需要按照这些说明构建自己的模型。

在Chapter3-Practice GitHub 存储库中，您将找到一个包含超过 11,000 个良性和恶意 Android 应用程序特征向量的数据集：

  1. 使用pandas python 库加载数据集，并且这次添加low_memory=False参数。搜索该参数的作用。

  2. 准备用于训练的数据。

  3. 使用test_size=0.33参数拆分数据。

  4. 创建一个包含DecisionTreeClassifier()、RandomForestClassifier(n_estimators=100)和AdaBoostClassifier()的分类器集合。

  5. AdaBoostClassifier()是什么？

  6. 使用这三个分类器训练模型，并打印出每个分类器的指标。

进一步阅读

欲了解更多信息，请查看以下日志帖子和文档：

第四章：使用深度学习进行恶意软件检测

人类大脑是一个迷人的实体。我们的潜意识和无意识思维的力量是不可思议的。使这种力量变得真实的是我们不断自学和快速适应的能力。这种自然的惊人天赋可以在你意识到之前计算数十亿个任务。几十年来，科学家一直在努力构建能够像人类大脑一样同时执行任务的机器，换句话说，能够高效地以令人难以置信的速度执行大量任务的系统。一个名为深度学习（DL）的机器学习子领域应运而生，帮助我们构建像人类大脑一样工作并受其结构启发的算法。信息安全专业人员也对这些技术感兴趣，因为它们在防御重大网络威胁和攻击方面取得了有希望的结果。深度学习的最佳实施候选之一是恶意软件分析。

在本章中，我们将发现：

  • 人工神经网络：深入概述

  • 如何使用 Python 构建你的第一个神经网络

  • 如何使用多层感知器构建恶意软件检测器

  • 恶意软件可视化技术以及如何使用卷积神经网络构建恶意软件分类器

技术要求

基本上，在本章中，我们将使用已经安装的相同的 Python 库。通常情况下，我们将在本书的大多数章节中使用这些库。因此，我们在第一章花了时间教你如何安装我们在大多数章节和项目中将要使用的所有必需库。在此链接找到代码文件：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter04。

人工神经网络概述

我们的大脑在眨眼之间执行许多复杂的功能。因此，为了构建能够执行和学习使用与人类思维相同的技术的算法，我们必须了解大脑的工作原理是至关重要的。通过对人类大脑功能的公平理解，我们将更好地理解深度学习。三个主要的独特的大脑功能是：

  • 思考（分析、比较和判断）

  • 情感（快乐、悲伤和兴奋）

  • 渴望（动机、欲望和目标）

这三个功能在一个动态的过程中不断地相互作用。

大脑主要由三个部分组成：大脑皮层，它是大脑的最大部分，控制着视觉、听觉和味觉等高级功能；小脑，它负责协调肌肉运动和人体的一般姿势，包括平衡；第三部分称为脑干，它连接了前两部分并控制许多其他任务，包括打喷嚏、咳嗽和消化。

大脑通过其不同的部分执行复杂的操作。从逻辑上讲，人类大脑的解剖结构由许多区域组成，因此每个区域都基于特定的算法工作。尽管大脑的每个部分都使用自己的算法工作，但令人惊讶的是，人类大脑基本上使用相同的算法来理解许多不同的输入模式。这个假设被称为一个学习算法假设。1992 年Roe 等人进行的许多研究证明了这一点，特别是雪貂实验，其中视觉输入被插入到雪貂大脑的听觉部分，听觉皮层学会了如何看。

以下图表描述了人工智能（AI）、机器学习（ML）和深度学习（DL）之间的关系：

从生物学上讲，人类大脑由数十亿个称为神经元的小器官组成。神经元是通过电信号和化学信号处理和传递信息的单位。这些神经细胞主要由以下组成：

  • 树突

  • 轴突

  • 突触

  • 细胞体

  • 细胞核

以下图表说明了生物神经元的不同组成部分：

生物神经元的类比表示被称为感知器。感知器可以分解为：

  • 输入

  • 权重

  • 净输入函数

  • 激活函数

  • 输出

感知器和人类神经元之间的类比并不完全正确。它只是用来让人们对感知器的工作有所了解。人类大脑比人工神经网络复杂得多。有一些相似之处，但直接将大脑和神经网络进行比较是不合适的。

在 Python 中实现神经网络

经典的计算机程序在基于一系列指令和算术的计算操作方面表现出色，但在许多其他情况下都面临困难和挑战；例如，手写识别。作为热身，让我们构建一个手写数字识别器，以便有机会安装下一节中所需的 Python 库，并学习如何在 Python 中构建和实现我们的第一个神经网络。要训练模型，我们需要用数据来喂养它。在我们的实现中，我们将使用 MNIST 数据集：

首先，让我们使用pip install命令安装keras库，如下所示：

# pip install keras

然后，使用以下命令安装 TensorFlow（tensorflow）：

# pip install tensorflow

最后，安装np_utils：

# pip install np_utils

打开 Python 命令行界面，并使用导入命令导入以下模块：

  • mnist 数据集

  • Sequential 模型

  • Dense 和 Dropout 层

  • np_utils 模块

>>> from keras.models import Sequential
>>> from keras.layers import Dense
>>> from keras.layers import Dropout
>>> from keras.utils import np_utils

以下图表说明了前面的代码：

使用种子是因为我们希望结果是可重复的。numpy.random.seed(seed)用于给生成器设定种子：

>>> seed = 7
>>> numpy.random.seed(seed)
>>> (X_train, y_train), (X_test, y_test) = mnist.load_data()

从s3.amazonaws.com/img-datasets/mnist.pkl.gz下载数据：

>>> num_pixels = X_train.shape[1] * X_train.shape[2]
>>> X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32')
>>> X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
>>> X_train = X_train / 255
>>> X_test = X_test / 255

>>> y_train = np_utils.to_categorical(y_train)
>>> y_test = np_utils.to_categorical(y_test)
>>> num_classes = y_test.shape[1]
>>> model = Sequential()
>>>model.add(Dense(num_pixels, input_dim=num_pixels, activation='relu'))
>>>model.add(Dense(num_classes,activation='softmax'))
>>>model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

这里，.astype()用于转换变量，.reshape()用于给数组一个新的形状而不改变数据：

我们手写数字分类器的准确率为 99.8%，这是一个惊人的结果。现在我们已经学会了如何构建我们的第一个神经网络程序，是时候利用我们的技能并亲自体验如何使用人工神经网络构建恶意软件分类器，特别是 DL 网络了。

使用 PE 头构建深度学习模型

根据我们学到的概念，我们将使用人工神经网络构建一个恶意软件检测器。让我们从识别我们的数据集开始。到目前为止，您已经熟悉了构建机器学习模型所需的步骤。对于这个模型，我们将使用可移植可执行文件（PE）文件作为输入数据。正如您在上一章中注意到的，我们安装了一个名为pefile的 Python 库。现在是时候在这个模型中使用它了。一旦我们使用 Python 包安装管理器 PIP 安装了pefile，我们就可以开始使用pefile从任何 PE 文件中提取信息。为了从 PE 文件中收集信息，导入os和pefile库。os库允许您与 Python 正在运行的底层操作系统进行交互。

作为演示，我们将下载由 Palo Alto 网络提供的用于实验目的的恶意软件 PE 文件。使用wget命令下载如下：

# wget https://wildfire.paloaltonetworks.com/publicapi/test/pe

安装 PE 文件后，打开 Python 环境并导入所需的库，如下所示：

>>> import os
>>> import pefile

使用以下命令加载文件：

>>> PEfile = pefile.PE("pe", fast_load=True)

现在我们能够从 PE 文件中提取PE_HEADER_OPTIONAL信息，包括MajorLinkerVersion、MajorLinkerVersion、SizeOfImage和DllCharacteristics。您可以通过查看微软文档找到完整的列表：

在下面的脚本中，我提取了关于的信息：

  • LinkerVersion

  • NumberOfSections

  • ImageVersion

我们知道，训练模型在计算方面是一个高消耗的任务。因此，处理和提供所有头信息给模型并不是一个明智的决定。因此，我们需要对其进行特征工程。选择好的特征是每个数据科学任务中需要的技能。Adobe Systems 的产品安全事件响应团队（PSIRT）的 Karthik Raman 进行的一项名为选择用于分类恶意软件的特征的研究提出了解决这个问题的建议，建议我们选择最重要的 PE 头部，它们如下：

  • DebugSize

  • DebugRVA

  • ImageVersion

  • OperatingSystemVersion

  • SizeOfStackReserve

  • LinkerVersion

  • DllCharacteristics

  • IatRVA

  • ExportSize

  • ExportRVA

  • ExportNameLen

  • ResourceSize

  • ExportFunctionsCount

要提取它们，您可以像之前一样使用导入的PEfile模块：

DebugSize = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[6].Size
print (DebugSize)
DebugRVA = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[6].VirtualAddress
print (DebugRVA)
 ImageVersion = PEfile.OPTIONAL_HEADER.MajorImageVersion
 print (ImageVersion)
OSVersion = PEfile.OPTIONAL_HEADER.MajorOperatingSystemVersion
print (OSVersion)
ExportRVA = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[0].VirtualAddress
 print (ExportRVA)
ExportSize = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[0].Size
print (ExportSize)
IATRVA = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[12].VirtualAddress
 print (IATRVA)
ResSize = PEfile.OPTIONAL_HEADER.DATA_DIRECTORY[2].Size
 print (ResSize)
LinkerVersion = PEfile.OPTIONAL_HEADER.MajorLinkerVersion
 print (LinkerVersion)
NumberOfSections = PEfile.FILE_HEADER.NumberOfSections
 print (NumberOfSections)
StackReserveSize = PEfile.OPTIONAL_HEADER.SizeOfStackReserve
 print (StackReserveSize)
Dll = PEfile.OPTIONAL_HEADER.DllCharacteristics
print (Dll)

为了训练模型，有许多公开可用的来源。您可以从大量的组织和教育机构的列表中下载不同类型的文件（清洁和恶意）：

您的数据集应包含两类 PE 文件：清洁和恶意文件。我们需要至少 10,000 个文件来训练模型。您将需要开始使用先前的脚本提取头信息。您可以通过自己开发自动化脚本来自动化任务。可以使用任何编程语言。最好的方法是将所有文件的选定特征导出到 CSV 文件中，这样我们可以使用前几章学到的知识，以后可以使用 pandas 加载它们：

Malware  = pd.read_csv("Malware.csv")
Clean_Files = pd.read_csv("Clean_Files.csv")

准备好特征后，我们需要将两种类型的数据合并为一种。例如，我们可以使用pd.concat来合并这两个文件。为了训练模型，我们需要导入所需的模块：

>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.metrics import confusion_matrix
>>> from sklearn.neural_network import MLPClassifier
>>> from sklearn.preprocessing import StandardScaler

数据准备：

y = dataset['Clean_Files']
X = dataset.drop('Clean_Files',axis = 1)
X = np.asarray(X)
y = np.asarray(y)

这行是用于分割，就像我们在其他模型中做的那样：

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.3,random_state=0)

为了更好的预测，我们可以使用StandScaler()；它用于通过去除均值和缩放到单位方差来标准化特征：

scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

准备和特征工程数据后，我们必须构建多层感知器（MLP）网络：

MLP = MLPClassifier(hidden_layer_sizes=(12,12,12,12,12,12))

这里，12是层数和特征数。让我们训练模型并计算预测：

MLP.fit(X_train,y_train)
Predictions = MLP.predict(X_test)

要检查评估指标，请添加以下行：

TN, FP, FN TP = confusion_matrix(y_test,predictions).ravel()

在这里使用ravel()返回一个连续的扁平数组。它相当于reshape(-1, order=order)：

print ("True Positive:" , TP)
print ("True Negative:" , TN)
print ("False Positive:" , FP)
print ("False Negative:" , FN)

使用卷积神经网络和恶意软件可视化的深度学习模型

上一节是用 MLP 网络来检测恶意软件的真实实现。现在，我们将探索其他人工网络架构，并学习如何使用其中之一来帮助恶意软件分析师和信息安全专业人员检测和分类恶意代码。在深入技术细节和 DL 方法的实际实施步骤之前，了解和发现其他不同的人工神经网络架构是至关重要的。我们在第一章中简要讨论了其中一些。现在讨论主要的人工神经网络。

卷积神经网络（CNN）

卷积神经网络（CNNs）是解决图像分类问题的深度学习方法，或者我们称之为计算机视觉问题，因为经典的计算机程序面临许多挑战和困难，无法识别对象，包括光照，视角，变形和分割。这种技术受到了眼睛工作的启发，特别是动物视觉皮层功能算法。在 CNN 中，以宽度，高度和深度为特征排列成三维结构。对于图像，高度是图像高度，宽度是图像宽度，深度是 RGB 通道。要构建 CNN，我们需要三种主要类型的层：

  • 卷积层：卷积操作是指从输入图像中提取特征，并将滤波器中的值与原始像素值相乘

  • 池化层：池化操作减少每个特征图的维度

  • 全连接层：全连接层是具有 softmax 激活函数的经典多层感知器

要使用 Python 实现 CNN，可以使用以下 Python 脚本：

import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend 
backend.set_image_dim_ordering('th')

model = Sequential()
model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

循环神经网络（RNNs）

循环神经网络（RNNs）是人工神经网络，我们可以利用序列信息，例如句子。换句话说，RNN 对序列的每个元素执行相同的任务，输出取决于先前的计算。RNN 广泛用于语言建模和文本生成（机器翻译，语音识别等许多应用）。RNN 不能长时间记住事情。

长短期记忆网络

长短期记忆（LSTM）通过构建一个记忆块来解决循环神经网络中的短期记忆问题。这个块有时被称为记忆单元。

Hopfield 网络

Hopfield 网络是由 John Hopfield 于 1982 年开发的。Hopfield 网络的主要目标是自动关联和优化。我们有两类 Hopfield 网络：离散和连续。

玻尔兹曼机网络

玻尔兹曼机网络使用循环结构，只使用局部可用信息。它们是由 Geoffrey Hinton 和 Terry Sejnowski 于 1985 年开发的。此外，玻尔兹曼机的目标是优化解决方案。

使用 CNN 进行恶意软件检测

对于这个新模型，我们将探讨如何使用 CNN 构建恶意软件分类器。但我敢打赌，你一定想知道我们如何做到这一点，因为 CNN 是以图像作为输入的。答案很简单，这里的诀窍是将恶意软件转换为图像。这可能吗？是的，是可能的。在过去几年中，恶意软件可视化是许多研究课题之一。其中一种提出的解决方案来自一项名为Malware Images: Visualization and Automatic Classification的研究，作者是加州大学圣巴巴拉分校的 Vision Research Lab 的Lakshmanan Nataraj。

以下图表详细说明了如何将恶意软件转换为图像：

以下是Alueron.gen!J恶意软件的图像：

这种技术还使我们能够以详细的方式可视化恶意软件部分：

通过解决如何通过图像为使用 CNN 的恶意软件机器学习分类器提供数据的问题，信息安全专业人员可以利用 CNN 的力量来训练模型。最经常用来为 CNN 提供数据的恶意软件数据集之一是Malimg 数据集。这个恶意软件数据集包含来自 25 个不同恶意软件家族的 9,339 个恶意软件样本。您可以从 Kaggle（一个用于预测建模和分析竞赛的平台）下载它，访问以下链接：www.kaggle.com/afagarap/malimg-dataset/data。

这些是恶意软件家族：

  • Allaple.L

  • Allaple.A

  • Yuner.A

  • Lolyda.AA 1

  • Lolyda.AA 2

  • Lolyda.AA 3

  • C2Lop.P

  • C2Lop.gen!G

  • 即时访问

  • Swizzor.gen!I

  • Swizzor.gen!E

  • VB.AT

  • Fakerean

  • Alueron.gen!J

  • Malex.gen!J

  • Lolyda.AT

  • Adialer.C

  • Wintrim.BX

  • Dialplatform.B

  • Dontovo.A

  • Obfuscator.AD

  • Agent.FYI

  • Autorun.K

  • Rbot!gen

  • Skintrim.N

将恶意软件转换为灰度图像后，您可以获得以下恶意软件表示，以便以后用于为机器学习模型提供数据：

将每个恶意软件转换为灰度图像可以使用以下 Python 脚本完成：

import os
import scipy
import array
 filename = '<Malware_File_Name_Here>';
 f = open(filename,'rb');
 ln = os.path.getsize(filename);
width = 256;
 rem = ln%width;
 a = array.array("B");
 a.fromfile(f,ln-rem);
 f.close();
 g = numpy.reshape(a,(len(a)/width,width));
 g = numpy.uint8(g);
 scipy.misc.imsave('<Malware_File_Name_Here>.png',g);

对于特征选择，您可以提取或使用任何图像特征，比如纹理模式、图像中的频率、强度或颜色特征，使用不同的技术，比如欧几里得距离，或者均值和标准差，以后生成特征向量。在我们的情况下，我们可以使用诸如颜色布局描述符、均匀纹理描述符或全局图像描述符（GIST）等算法。假设我们选择了 GIST；pyleargist是一个很棒的 Python 库来计算它。要安装它，像往常一样使用 PIP：

# pip install pyleargist==1.0.1

作为一个用例，要计算 GIST，您可以使用以下 Python 脚本：

import Image
Import leargist
 image = Image.open('<Image_Name_Here>.png');
 New_im = image.resize((64,64));
des = leargist.color_gist(New_im);
Feature_Vector = des[0:320];

这里，320指的是我们使用灰度图像时的前320个值。不要忘记将它们保存为NumPy 数组，以便以后用于训练模型。

在获得特征向量之后，我们可以训练许多不同的模型，包括 SVM、k-means 和人工神经网络。其中一个有用的算法是 CNN 的算法。

特征选择和工程完成后，我们可以构建 CNN。例如，对于我们的模型，我们将构建一个具有两个卷积层的卷积网络，输入为32 * 32。使用 Python 库构建模型时，我们可以使用之前安装的 TensorFlow 和 utils 库来实现它。

因此，整体的 CNN 架构将如下图所示：

这种 CNN 架构不是构建模型的唯一提议，但目前我们将用它来实现。

要构建模型和一般的 CNN，我强烈推荐 Keras。所需的导入如下：

import keras
 from keras.models import Sequential,Input,Model
 from keras.layers import Dense, Dropout, Flatten
 from keras.layers import Conv2D, MaxPooling2D
 from keras.layers.normalization import BatchNormalization
 from keras.layers.advanced_activations import LeakyReLU

正如我们之前讨论的，灰度图像的像素值范围从 0 到 255，我们需要将32 * 32 * 1维度的图像作为结果输入到网络中：

train_X = train_X.reshape(-1, 32,32, 1)
test_X = test_X.reshape(-1, 32,32, 1)

我们将使用以下参数训练我们的网络：

batch_size = 64
epochs = 20
num_classes = 25

要构建架构，关于其格式，使用以下内容：

Malware_Model = Sequential()
Malware_Model.add(Conv2D(32, kernel_size=(3,3),activation='linear',input_shape=(32,32,1),padding='same'))
Malware_Model.add(LeakyReLU(alpha=0.1))
Malware_model.add(MaxPooling2D(pool_size=(2, 2),padding='same'))
Malware_Model.add(Conv2D(64, (3, 3), activation='linear',padding='same'))
Malware_Model.add(LeakyReLU(alpha=0.1))
Malware_Model.add(Dense(1024, activation='linear'))
Malware_Model.add(LeakyReLU(alpha=0.1))
Malware_Model.add(Dropout(0.4))
Malware_Model.add(Dense(num_classes, activation='softmax'))

要编译模型，使用以下内容：

Malware_Model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(),metrics=['accuracy'])

适应并训练模型：

Malware_Model.fit(train_X, train_label, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X, valid_label))

正如您注意到的，我们尊重了在前几章中讨论的训练神经网络的流程。要评估模型，使用以下代码：

Malware_Model.evaluate(test_X, test_Y_one_hot, verbose=0)
print('The accuracy of the Test is:', test_eval[1])

将深度学习应用于恶意软件检测的承诺和挑战

机器学习从业者和恶意软件分析师提出了许多不同的深度网络架构，用于检测已知和未知的恶意软件；一些提出的架构包括受限玻尔兹曼机和混合方法。您可以在进一步阅读部分中查看其中一些。检测恶意软件和恶意软件的新方法显示出许多有希望的结果。然而，恶意软件分析师在使用深度学习网络检测恶意软件时面临许多挑战，特别是在分析 PE 文件时，因为要分析 PE 文件，我们将每个字节作为一个输入单元，因此我们需要处理包含数百万步的序列分类，另外还需要保持由于函数调用和跳转命令而产生的复杂的空间相关性。

总结

恶意软件对每个现代组织来说都是一场噩梦。攻击者和网络犯罪分子总是想出新的恶意软件来攻击他们的目标。安全供应商正在尽力防御恶意软件攻击，但不幸的是，每月发现数百万种恶意软件，他们无法做到。因此，需要新的方法，这正是我们在本章和上一章中研究的内容。我们发现了如何使用不同的机器学习算法构建恶意软件检测器，特别是利用深度学习技术的力量。在下一章中，我们将学习如何通过构建和开发强大的智能系统来检测僵尸网络。

问题

  1. MLP 网络和深度学习网络之间有什么区别？

  2. 为什么最近 DL 开始起飞？

  3. 为什么我们需要通过不同的模型进行多次迭代？

  4. 翻译英语到法语语言需要哪种 DL 类型？

  5. 为什么恶意软件可视化是分类恶意软件的好方法？

  6. 激活函数的作用是什么？

  7. 你能提到三种 DL 架构吗？

进一步阅读

第五章：机器学习下的僵尸网络检测

如今，连接设备在现代生活中扮演着重要角色。从智能家居电器、计算机、咖啡机和摄像头，到连接的汽车，我们生活方式的巨大转变使我们的生活变得更加轻松。不幸的是，这些暴露的设备可能会受到攻击，并且攻击者和网络犯罪分子可能会稍后使用它们来实施更大规模的攻击。安全供应商提供了许多解决方案和产品来防御僵尸网络，但在本章中，就像我们在之前的章节中所做的那样，我们将学习如何使用 Python 和机器学习技术构建新颖的僵尸网络检测系统。

在本章中，我们将看到：

  • 僵尸网络概述

  • 如何使用不同的机器学习算法构建僵尸网络检测器

  • 如何构建 Twitter 僵尸网络检测器

技术要求

您将在以下存储库中找到所有讨论的代码，以及其他一些有用的脚本：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter5。

僵尸网络概述

僵尸网络是bot和net两个术语的组合。bot 部分表示这种恶意软件自动化事物和任务，就像机器人一样。第二部分指的是网络，换句话说，是一组受损设备的网络。因此，根据定义，僵尸网络是一种恶意软件，它攻击互联网上的计算机，并通过命令和控制服务器控制它们执行各种自动化任务，包括发送垃圾邮件和执行分布式拒绝服务（DDoS）攻击。受攻击的机器加入了一个庞大的受损机器网络。以前几年最引人注目的僵尸网络之一是Mirai 僵尸网络。Mirai 在日语中意为未来。这个僵尸网络攻击了数百万在线设备，特别是物联网（IoT）设备，通过扫描和识别易受攻击的机器，利用大多数设备使用默认登录凭据的事实。僵尸网络执行的一些任务包括：

  • 广告欺诈和发送垃圾邮件

  • 加密货币挖矿

  • 窃取个人数据和敏感信息

  • 执行 DDoS 攻击

  • 执行暴力攻击

以下图表描述了僵尸网络生态系统的不同参与者：

黑客是一项有方法的任务。罪犯和网络攻击者通常使用相同的定义步骤。作为渗透测试人员和信息安全专业人员，您了解黑客阶段，即信息收集，或者我们所说的侦察；扫描；获取访问权限；保持访问权限；最后清除痕迹。因此，僵尸网络通常遵循一些定义的步骤。僵尸网络基于四个不同的阶段工作：

  • 感染：在这个阶段，攻击者通过发送恶意软件感染目标机器。

  • 连接：在这个阶段，僵尸网络与控制和命令服务器建立互联网连接，以接收命令和自动任务。

  • 控制：在这个阶段，攻击发生，例如发送垃圾邮件。

  • 繁殖：在这个阶段，僵尸网络将尝试感染更多的机器加入网络，并成为我们所说的僵尸：

使用多种机器学习技术构建僵尸网络检测器模型

在本节中，我们将学习如何使用许多机器学习算法构建不同的僵尸网络检测系统。作为第一个实验室的开始，让我们通过使用不同的分类器构建基于机器学习的僵尸网络检测器。到目前为止，我希望您已经清楚地了解了构建机器学习系统的主要步骤。因此，我相信您已经知道，作为第一步，我们需要寻找一个数据集。许多教育机构和组织都提供了从内部实验室收集的数据集。最知名的僵尸网络数据集之一称为CTU-13数据集。这是捷克共和国 CTU 大学提供的带有僵尸网络、正常和背景流量的标记数据集。在他们的工作中，他们试图捕获真实的僵尸网络流量与正常流量和背景流量混合在一起。要下载数据集并查看更多信息，您可以访问以下链接：mcfp.weebly.com/the-ctu-13-dataset-a-labeled-dataset-with-botnet-normal-and-background-traffic.html。

数据集是双向 NetFlow 文件。但是什么是双向 NetFlow 文件？Netflow 是由思科开发的互联网协议。该协议的目标是收集 IP 流量信息并监视网络流量，以便更清晰地了解网络流量流动。NetFlow 架构的主要组件是NetFlow Exporter、Netflow 收集器和流存储。以下图示了 NetFlow 基础设施的不同组件：

就 NetFlow 而言，当主机 A 向主机 B发送信息，然后从主机 B回复给主机 A时，该操作被称为单向 NetFlow。发送和回复被视为不同的操作。在双向 NetFlow 中，我们将来自主机 A和主机 B的流视为一个流。通过以下命令下载数据集：

$ wget --no-check-certificate https://mcfp.felk.cvut.cz/publicDatasets/CTU-13-Dataset/CTU-13-Dataset.tar.bz2

通过以下命令提取下载的tar.bz2文件：

# tar xvjf  CTU-13-Dataset.tar.bz2

该文件包含所有数据集，具有不同的场景。为了演示，我们将使用数据集 8（场景 8）。您可以选择任何场景，也可以使用自己收集的数据，或者其他机构提供的任何其他.binetflow文件：

使用 pandas 通常加载数据：

>>> import pandas as pd
>>> data = pd.read_csv("capture20110816-3.binetflow")
>>> data['Label'] = data.Label.str.contains("Botnet")

在任何数据中心项目中，探索数据是至关重要的。例如，您可以从检查特征或列的名称开始：

>> data.columns

该命令会显示数据集的列：StartTime、Dur、Proto、SrcAddr、Sport、Dir、DstAddr、Dport、State、sTos、dTos、TotPkts、TotBytes、SrcBytes和Label。这些列代表数据集中使用的特征；例如，Dur代表持续时间，Sport代表源端口，依此类推。您可以在本章的 GitHub 存储库中找到特征的完整列表。

在训练模型之前，我们需要构建一些脚本来准备数据。这一次，我们将构建一个单独的 Python 脚本来准备数据，稍后我们可以将其导入到主脚本中。

我将称第一个脚本为DataPreparation.py。有许多提案可以帮助提取特征并准备数据以构建使用机器学习的僵尸网络检测器。在我们的案例中，我根据NagabhushanS构建的数据加载脚本定制了两个新脚本：

from __future__ import division
import os, sys
import threading

在导入所需的 Python 包后，我们创建了一个名为Prepare的类来选择训练和测试数据：

class Prepare(threading.Thread): 
def __init__(self, X, Y, XT, YT, accLabel=None):
 threading.Thread.__init__(self)
 self.X = X
 self.Y = Y
 self.XT=XT
 self.YT=YT
 self.accLabel= accLabel

def run(self):
 X = np.zeros(self.X.shape)
 Y = np.zeros(self.Y.shape)
 XT = np.zeros(self.XT.shape)
 YT = np.zeros(self.YT.shape)
 np.copyto(X, self.X)
 np.copyto(Y, self.Y)
 np.copyto(XT, self.XT)
 np.copyto(YT, self.YT)
 for i in range(9):
 X[:, i] = (X[:, i] - X[:, i].mean()) / (X[:, i].std())
 for i in range(9):
 XT[:, i] = (XT[:, i] - XT[:, i].mean()) / (XT[:, i].std())

第二个脚本称为LoadData.py。您可以在 GitHub 上找到它，并直接在您的项目中使用它来从.binetflow文件中加载数据并生成一个pickle文件。

让我们使用之前开发的内容来训练模型。构建数据加载器并准备我们将要使用的机器学习算法后，是时候训练和测试模型了。

首先，从pickle文件中加载数据，这就是为什么我们需要导入pickle Python 库。不要忘记使用以下代码导入之前的脚本：

import LoadData
import DataPreparation
import pickle
file = open('flowdata.pickle', 'rb')
data  = pickle.load(file)

选择数据部分：

Xdata = data[0]
Ydata =  data[1]
XdataT = data[2]
YdataT = data[3]

作为机器学习分类器，我们将尝试许多不同的算法，以便稍后可以选择最适合我们模型的算法。导入所需的模块以使用sklearn中的四种机器学习算法：

from sklearn.linear_model import *
from sklearn.tree import *
from sklearn.naive_bayes import *
from sklearn.neighbors import *

通过使用之前的模块构建数据。不要忘记通过输入import DataPreparation来导入DataPreparation：

>>> DataPreparation.Prepare(Xdata,Ydata,XdataT,YdataT)

现在，我们可以训练模型了；为此，我们将使用不同的技术来训练模型，以便稍后可以选择最合适的机器学习技术用于我们的项目。步骤与我们在以前的项目中学到的一样：在准备数据并选择特征之后，定义机器学习算法，拟合模型，并在定义其变量后打印出得分。

作为机器学习分类器，我们将测试其中许多。让我们从决策树开始：

  • 决策树模型：
>>> clf = DecisionTreeClassifier()
>>> clf.fit(Xdata,Ydata)
>>> Prediction = clf.predict(XdataT)
>>> Score = clf.score(XdataT,YdataT)
>>> print (“The Score of the Decision Tree Classifier is”, Score * 100)

决策树分类器的得分为 99%

  • 逻辑回归模型：
>>> clf = LogisticRegression(C=10000)
>>> clf.fit(Xdata,Ydata)
>>> Prediction = clf.predict(XdataT) >>> Score = clf.score(XdataT,YdataT)

>>> print ("The Score of the Logistic Regression Classifier is", Score * 100)

逻辑回归分类器的得分为 96%

  • 高斯朴素贝叶斯模型：
>>> clf = GaussianNB()
>>> clf.fit(Xdata,Ydata)
>>> Prediction = clf.predict(XdataT)
>>> Score = clf.score(XdataT,YdataT)
>>> print("The Score of the Gaussian Naive Bayes classifier is", Score * 100)

高斯朴素贝叶斯分类器的得分为 72%

  • k-最近邻模型：
>>> clf = KNeighborsClassifier()
>>> clf.fit(Xdata,Ydata)
>>> Prediction = clf.predict(XdataT)
>>> Score = clf.score(XdataT,YdataT)
>>> print("The Score of the K-Nearest Neighbours classifier is", Score * 100)

k-最近邻分类器的得分为 96%

  • 神经网络模型：

要构建神经网络模型，请使用以下代码：

>>> from keras.models import *
>>> from keras.layers import Dense, Activation
>>> from keras.optimizers import *

model = Sequential()
model.add(Dense(10, input_dim=9, activation="sigmoid")) model.add(Dense(10, activation='sigmoid'))
model.add(Dense(1))
sgd = SGD(lr=0.01, decay=0.000001, momentum=0.9, nesterov=True) 
model.compile(optimizer=sgd, loss='mse')
model.fit(Xdata, Ydata, nb_epoch=200, batch_size=100)
Score = model.evaluate(XdataT, YdataT, verbose=0)
Print(“The Score of the Neural Network is”, Score * 100  )

使用这段代码，我们导入了所需的 Keras 模块，构建了层，用 SGD 优化器编译了模型，拟合了模型，并打印出了模型的得分。

如何构建 Twitter 机器人检测器

在之前的部分中，我们看到了如何构建基于机器学习的僵尸网络检测器。在这个新项目中，我们将处理一个不同的问题，而不是防御僵尸网络恶意软件。我们将检测 Twitter 机器人，因为它们也是危险的，可以执行恶意操作。对于模型，我们将使用NYU Tandon Spring 2017 Machine Learning Competition: Twitter Bot classification数据集。你可以从这个链接下载它：www.kaggle.com/c/twitter-bot-classification/data。导入所需的 Python 包：

>>> import pandas as pd
>>> import numpy as np
>>> import seaborn

让我们使用 pandas 加载数据并突出显示机器人和非机器人数据：

>>> data = pd.read_csv('training_data_2_csv_UTF.csv')
>>> Bots = data[data.bot==1]
>> NonBots = data[data.bot==0]

使用 seaborn 进行可视化

在每个项目中，我都想帮助你发现新的数据可视化 Python 库，因为正如你所看到的，数据工程和可视化对于每个现代数据中心项目都是至关重要的。这一次，我选择了 seaborn 来可视化数据并在开始训练阶段之前探索数据。Seaborn 是一个用于制作统计可视化的 Python 库。以下是使用 seaborn 生成图表的示例：

>>> data = np.random.multivariate_normal([0, 0], [[5, 2], [2, 2]], size=2000)
>>> data = pd.DataFrame(data, columns=['x', 'y'])
>>> for col in 'xy':
... seaborn.kdeplot(data[col], shade=True)

例如，在我们的情况下，如果我们想要识别缺失的数据：

matplotlib.pyplot.figure(figsize=(10,6))
 seaborn.heatmap(data.isnull(), yticklabels=False, cbar=False, cmap='viridis')
 matplotlib.pyplot.tight_layout()

前两个代码片段是一些学习如何可视化数据的示例。可视化帮助数据科学家探索并了解更多关于数据的信息。现在，让我们回去继续构建我们的模型。

通过选择一些 Twitter 机器人使用的坏词来识别词袋。以下是机器人使用的坏词的示例。当然，你可以添加更多的词：

bag_of_words_bot = r'bot|b0t|cannabis|tweet me|mishear|follow me|updates every|gorilla|yes_ofc|forget' \
r'expos|kill|bbb|truthe|fake|anony|free|virus|funky|RNA|jargon' \                 r'nerd|swag|jack|chick|prison|paper|pokem|xx|freak|ffd|dunia|clone|genie|bbb' \                r'ffd|onlyman|emoji|joke|troll|droop|free|every|wow|cheese|yeah|bio|magic|wizard|face'
  • 现在，是时候识别训练特征了：
data['screen_name_binary'] = data.screen_name.str.contains(bag_of_words_bot, case=False, na=False)
data['name_binary'] = data.name.str.contains(bag_of_words_bot, case=False, na=False)
data['description_binary'] = data.description.str.contains(bag_of_words_bot, case=False, na=False)
data['status_binary'] = data.status.str.contains(bag_of_words_bot, case=False, na=False)
  • 特征提取：让我们选择在我们的模型中使用的features：
data['listed_count_binary'] = (data.listed_count>20000)==False
 features = ['screen_name_binary', 'name_binary', 'description_binary', 'status_binary', 'verified', 'followers_count', 'friends_count', 'statuses_count', 'listed_count_binary', 'bot']
  • 现在，用决策树分类器训练模型：
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, roc_curve, auc
from sklearn.model_selection import train_test_split
  • 我们导入一些先前讨论过的模块：
 X = data[features].iloc[:,:-1]
 y = data[features].iloc[:,-1]
  • 我们定义分类器：
clf = DecisionTreeClassifier(criterion='entropy', min_samples_leaf=50, min_samples_split=10)
  • 我们分割分类器：
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=101)
  • 我们拟合模型：
clf.fit(X_train, y_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
  • 我们打印出准确率分数：
print("Training Accuracy: %.5f" %accuracy_score(y_train, y_pred_train))
print("Test Accuracy: %.5f" %accuracy_score(y_test, y_pred_test))

我们的模型以 88%的检测率检测到了 Twitter 机器人，这是一个很高的准确率。

这种技术并非检测僵尸网络的唯一可能方式。研究人员提出了许多基于不同机器学习算法的其他模型，例如线性 SVM 和决策树。所有这些技术的准确率都达到了 90%。大多数研究表明，特征工程是改进机器学习模型的关键因素。

要研究一个真实案例，可以查看一篇名为从学习中学到的东西 - 了解机器学习在僵尸网络攻击中的能力和局限性的论文（arxiv.org/pdf/1805.01333.pdf），作者是 David Santana，Shan Suthaharan 和 Somya Mohanty。

总结

本章是一个轻量级指南，介绍了有关僵尸网络基础知识以及如何使用不同技术构建基于机器学习的检测器。此外，我们还讨论了如何识别 Twitter 机器人。下一章将深入探讨异常情况以及如何使用新方法构建多个项目来识别异常情况。

问题

在每章结束后，我们都会给你机会练习所学的知识并评估你的技能。本章的 GitHub 存储库中包含了Practice文件夹中的一个僵尸网络流量数据集的链接：

  1. 下载数据集并使用 pandas 库加载它

  2. 选择合适的特征

  3. 识别训练集和测试集，然后将它们导出到一个 pickle 文件中

  4. 加载 pickle 文件

  5. 导入支持向量机分类器并拟合模型

  6. 训练 SVM 模型

  7. 打印出构建的模型的准确率

进一步阅读

要了解更多关于僵尸网络以及如何使用机器学习检测它们的知识，我强烈建议你查看这些有用的外部链接：

第六章：异常检测系统中的机器学习

对于任何企业来说，网络上的未经授权活动可能是一场噩梦。保护客户数据是最重要的问题，也是每个企业所有者的责任。部署入侵检测系统是现代组织可以采取的明智决定，以防御恶意入侵。不幸的是，攻击者和黑客总是在想出新的技术来绕过保护，以获取对网络的未经授权访问。这就是为什么机器学习技术是保护网络免受甚至复杂和攻击的良好解决方案。

本章将是发现网络异常并学习如何从头开始构建入侵检测系统的一站式指南，使用公开可用的数据集和尖端的开源 Python 数据科学库。

在本章中，我们将涵盖以下内容：

  • 异常检测技术概述

  • 网络攻击

  • 检测网络异常

  • 基于主机的入侵检测系统（HIDS）

  • 基于网络的入侵检测系统（NIDS）

技术要求

本章需要以下要求：

异常检测技术概述

我们现在将讨论网络异常（这是我们主要关注的内容）及其检测方法。根据定义，异常是指数据中的异常模式，即超出正常范围的意外模式。异常这个术语在数据挖掘中被广泛使用，有时被称为异常值。异常检测技术通常用于欺诈检测和发现恶意活动。在网络中，异常可能由于许多原因而发生，但对我们来说，重要的是恶意活动的检测。通常，我们看到三种类型的异常：

  • 点异常：与其余数据相比，异常的个别数据实例。

  • 上下文异常：仅在特定上下文（时间段、地区等）中发生的异常行为。

  • 集体异常：与其余数据相比，一系列异常活动。

这些异常可以使用许多技术来检测，这些技术基于可用的数据。

静态规则技术

如果我们有训练数据，那么我们需要检查数据是否平衡。如果没有训练数据，决策将基于异常类型进行；要检测点异常，建议使用百分位数和直方图。要检测集体异常，决策将基于异常的方差；要检测单变量异常，可以使用马尔可夫链，或者可以构建模型并查看残差。在多变量情况下，我们可以使用聚类和马尔可夫模型（如果异常是有序的），或者 k-最近邻（如果异常是无序的）。

不同的技术在下图中表示：

网络攻击分类

在网络异常方面，我们的工作是保护组织的网络免受入侵者的侵害。网络入侵是威胁网络安全的恶意活动。信息安全专业人员已经提出了许多分类来对网络攻击进行更好的研究。例如，他们已经将网络攻击分类为以下几类：

  • 感染（恶意软件）

  • 爆炸（缓冲区溢出）

  • 探测（嗅探）

  • 作弊（欺骗）

  • 遍历（暴力破解）

  • 并发（DDoS）

攻击也可以分为被动和主动攻击。主动攻击是指攻击者对网络产生直接影响。国防高级研究计划局（DARPA）在其入侵检测评估计划中将主动攻击分为四大类。这四类如下：

  • 拒绝服务（DoS）：DoS 攻击是试图中断授权用户对网络的访问的尝试。换句话说，它们阻止用户访问在线服务，如电子邮件。

  • 用户到根（U2R）攻击：U2R 攻击很难检测；它们试图获得高（超级用户）权限。这是通过以普通用户的身份访问系统，并尝试后来利用系统的弱点来提升权限来实现的。

  • 远程到本地（R2L）：R2L 攻击是尝试与远程机器交互以获取访问权限。使用的一种技术是猜测密码。

  • 探测：探测是获取有关网络中主机的信息的尝试，包括有效的 IP 地址、运行的服务和开放的端口。通常是通过扫描完成的。如您所知，收集的信息将稍后用于识别漏洞以利用它们。

网络异常的检测

网络入侵检测系统（IDSs）并不是一个新的想法。自最早的网络攻击以来就提出了 IDS。IDS 可以根据其部署分为两大类：HIDS 和 NIDS。以下图表说明了 IDS 架构的高级概述：

HIDS

HIDS 能够收集和监视计算机系统（特别是它们的内部），以便为安全分析人员提供对关键系统（如工作站、服务器和移动设备）发生的情况的深入可见性。HIDS 的主要目标是检测入侵。

NIDS

NIDS 负责检测网络数据中的入侵。基本上，检测是基于顺序数据中的特定模式进行的。换句话说，NIDS 读取所有传入的数据包，并尝试在其中找到异常。

基于异常的 IDS

在谈到 IDS 时，我们通常谈论两类：基于主机和基于网络的。但也出现了一种新的 IDS 类别。新类别是基于异常的。这些系统通过使用机器学习技术来识别数据中的入侵和异常。在以前的章节中，特别是在第一章，渗透测试中的机器学习简介中，我们看到了不同的机器学习模型：受监督的、无监督的、半监督的和强化学习。基于异常的 IDS 也根据用于检测网络入侵的机器学习模型被分类为受监督和无监督系统。信息安全社区经过多年的研究，已成功提供了 IDS 中使用的不同方法的分类。其中一项提议，名为浅层和深层网络入侵检测系统：分类和调查，由 Elike Hodo、Xavier J. A. Bellekens、Andrew Hamilton、Christos Tachtatzis 和 Robert C. Atkinson 提出，对可靠入侵检测的许多机器学习技术进行了详细概述。以下图表中呈现了一些技术：

正如您所看到的，我们在前几章讨论了许多建议的技术。通常，在受监督的异常检测中，输入数据和异常类是已知的。换句话说，所有数据都是标记的；即使收集标记的数据也是一项繁重和耗时的任务。捕获的数据将在发送到检测引擎之前进行处理。无监督的异常检测系统可能是新颖的解决方案，即使数据没有标记也可以工作。

聚类是无监督系统中最常用的技术之一。这两种不同的系统可以合并成一个混合入侵检测系统。下面显示了一个总体混合异常入侵检测系统：

如果您想要构建一个成功和可靠的基于异常的网络入侵检测系统，您需要考虑许多重要因素。其中之一是接近度测量；根据定义，接近度意味着对对象的相似性或不相似性进行测量。因此，正如之前讨论的那样，这些系统试图将数据分类或分组，因此相应地测量对象之间的接近度。相似性度量的取值范围在0和1之间，其中1是最大的相似性值。欧几里得距离和曼哈顿距离是一些常见的接近度测量。合适的测量方法的选择取决于数据的类型（数值或分类）。异常不是任意检测的，而是基于评分系统。子样本由称为异常分数的入侵分数标记。这种评分系统对信息安全分析人员非常有益；基于有序和排名的异常列表，他们可以选择根据严重性来工作的阈值。以下是异常网络入侵检测系统使用的一些常见异常评分技术：

  • 基于距离的异常分数估计：

  • 演变数据集中基于链接的离群值和异常检测：数据集包含连续和分类属性。它使用相似性度量来衡量链接强度和两个点之间的关联程度。

  • 减少内存负载：这将异常定义为具有子集属性的数据点，这些属性具有不寻常的值。

  • 基于密度的异常分数估计：

  • 混合属性数据集的离群检测：通过计算值的不规则性和不同类型属性之间的关系来检测异常。

构建您自己的 IDS

到目前为止，您已经了解了不同的网络异常检测技术。现在我们将使用 Python 从头开始构建我们自己的网络 IDS。加利福尼亚大学举办了一场名为《第三届国际知识发现和数据挖掘工具竞赛》的比赛，他们提供了一个名为KDD Cup 1999 Data或KDD 1990的数据集。您可以在kdd.ics.uci.edu/databases/kddcup99/kddcup99.html找到它。

比赛的主要目的是构建一个能够区分恶意（攻击）和良好（正常）连接的系统。许多现代提案和机器学习解决方案都使用了数据集。但是正如你所看到的，数据集已经过时；这些模型无法检测到现代网络攻击，除了其他问题，如数据冗余。一项名为《KDD CUP 99 数据集的详细分析》的研究，由 Mahbod Tavallaee、Ebrahim Bagheri、Wei Lu 和 Ali A. Ghorbani 完成，突出了 KDD99 数据集中的许多问题。出现了一个新的数据集来解决这些问题，名为 NSL-KDD（www.unb.ca/cic/datasets/nsl.html）。即使这也没有解决所有问题，但是进行了许多改进。这些改进减少了大约 75%的数据。

以下是一些额外的公开可用数据集，可以帮助您构建自己的入侵检测系统：

对于我们的模型，我们将使用NSL_KDD作为训练和测试的数据集。要获得它，只需从 GitHub 克隆它，或者直接使用它，因为我们在书的 GitHub 存储库中提供了本书中讨论的所有数据集。你可以在Chapter 06文件夹中找到它：

# git clone https://github.com/defcom17/NSL_KDD

数据集包含不同的文件：

  • KDDTrain+.arff：带有二进制标签的完整 NSL-KDD 训练集，以 ARFF 格式。

  • KDDTrain+.txt：包含攻击类型标签和 CSV 格式的完整 NSL-KDD 训练集。

  • KDDTrain+_20Percent.ARFF：KDDTrain+.arff文件的 20%子集。

  • KDDTrain+_20Percent.TXT：KDDTrain+.txt文件的 20%子集。

  • KDDTest+.ARFF：带有二进制标签的完整 NSL-KDD 测试集，以 ARFF 格式。

  • KDDTest+.TXT：包含攻击类型标签和 CSV 格式的难度级别的完整 NSL-KDD 测试集。

  • KDDTest-21.ARFF：KDDTest+.arff文件的子集，不包括记录，难度级别为 21/21。

  • KDDTest-21.TXT：KDDTest+.txt文件的子集，不包括记录，难度级别为 21/21。

如果你打开Field Names.csv，你会看到所有的 40 个字段：

导入这个数据集，我们将使用pandas：

>>> import pandas as pd
>>> Data = pd.read_csv("KDDTrain+.csv", header=None)

如果我们检查Data.columns中的列，我们会看到列或字段被表示为数字：

为了使我们的特征分析更容易，让我们为更好的特征表示给一个字段名称分配一个数字。为了做到这一点，我们将创建一个名为Columns的数组，其中填充了字段名称，并用它加载数据集：

Columns = ["duration","protocol_type","service","flag","src_bytes",
 "dst_bytes","land","wrong_fragment","urgent","hot","num_failed_logins",
 "logged_in","num_compromised","root_shell","su_attempted","num_root",
 "num_file_creations","num_shells","num_access_files","num_outbound_cmds",
 "is_host_login","is_guest_login","count","srv_count","serror_rate",
 "srv_serror_rate","rerror_rate","srv_rerror_rate","same_srv_rate",
 "diff_srv_rate","srv_diff_host_rate","dst_host_count","dst_host_srv_count",
 "dst_host_same_srv_rate","dst_host_diff_srv_rate","dst_host_same_src_port_rate",
 "dst_host_srv_diff_host_rate","dst_host_serror_rate","dst_host_srv_serror_rate",
 "dst_host_rerror_rate","dst_host_srv_rerror_rate","label","difficulty"]

加载数据：

Data = pd.read_csv("KDDTrain+.csv", header=None, names = Columns)
Data.columns

这些是特征名称：

为了更好地理解数据集，我们可以使用pandas.DataFrame.describe：

Data.describe()

在训练模型之前，需要进行一些额外的处理。sklearn.preprocessing.LabelEncoder将标签编码为介于0和n_classes-1之间的值，并fit_transform(y)。适应标签编码器并返回编码标签。在我们的情况下，我们正在将非数字标签转换为数字标签。此外，我们需要预处理四个标签：protocol_type、service、flag和label。

为了做到这一点，我们使用fit.transform()，它校准我们的测量：

from sklearn import preprocessing 
Data.protocol_type = preprocessing.LabelEncoder().fit_transform(Data["protocol_type"])
 Data.service = preprocessing.LabelEncoder().fit_transform(Data["service"])
 Data.flag = preprocessing.LabelEncoder().fit_transform(Data["flag"])
 Data.label = preprocessing.LabelEncoder().fit_transform(Data["label"])

在 scikit-learn 中，有两种不同的方法：fit和fit_transform。这两种方法之间的区别在于，fit计算参数（μ和σ，其中μ是总体的平均值，σ是总体的标准差）并在内部保存它们，而fit_transform做同样的任务，但也对特定的样本集应用了转换。

让我们识别我们的数据。在下面的行中，我们使用了一个额外的 NumPy 方法as_matrix()，将框架转换为它的 NumPy 数组表示。在 NumPy 数组中，返回的不是 NumPy 矩阵，而是 NumPy 数组，根据官方文档的说法：

X = Data[Columns].as_matrix()
y = Data.label.as_matrix()

通常，在这一步之后，我们会进行模型训练；但这一次，我们将花更多时间来分析和可视化我们的数据和特征。数据科学的一个任务是获得洞察和知识，可视化对于数据科学和机器学习至关重要。我的建议是尽可能多地玩弄数据，并尝试不同的技术。正如你已经注意到的，机器学习系统通常遵循相同的技术，作为数据科学家或机器学习专家，你的工作是从数据中选择正确的特征。机器学习算法是基于数学的，通常情况下，你不会改变算法本身；相反，你会希望进行一些良好的特征工程，以构建一个可靠且准确度高的模型，以满足你的目标。

Yellowbrick 是一个很棒的可视化库和一套视觉诊断工具（可视化器）。这个库依赖于 scikit-learn 和 Matplotlib。你可以使用pip来安装它：

pip install yellowbrick

这个库非常丰富，让您可以可视化特征、分类、回归、聚类，甚至文本（例如，可视化语料库中术语的频率分布）：

visualizer = Rank1D(features=Columns, algorithm='shapiro')
visualizer.fit(X, y) 
visualizer.transform(X) 
visualizer.poof()

visualizer.poof()将显示绘图如下：

要保存绘图，您可以添加outpath，就像下面这样：

visualizer.poof(outpath="Figure1.png")

您甚至可以将其导出为 PDF 文件。 您可能已经注意到，在visualizer = Rank1D(features=Columns, algorithm='shapiro')一行中，我们使用了一个名为Rank1D的方法和一个名为shapiro的算法，以对特征进行排名并检测它们之间的关系。 Rank1D和Rank2D评估单个特征或特征对。 在我们的案例中，我们使用了特征的一维排名。

Rank2D是特征的二维排名。 以下显示了如何实现它：

visualizer = Rank2D(features=Columns, algorithm='covariance')

您可以从pearson或covariance中进行选择：

visualizer.fit(X, y)
visualizer.transform(X)
visualizer.poof()

让我们回到我们使用的排名算法。 shapiro参数是指 Shapiro-Wilk 排名算法。 您可以选择您的排名算法：

我们之前发现了主成分分析（PCA）。 Yellowbrick 使您能够将高维数据分解为二维或三维，并将其绘制出来：

visualizer = PCADecomposition(scale=True, center=False, col=y)
visualizer.fit_transform(X,y)
visualizer.poof()

此外，绘图可以是 3D 的：

visualizer = PCADecomposition(scale=True, center=False, color=y, proj_dim=3)
 visualizer.fit_transform(X,y)
 visualizer.poof()

上述代码在此图中呈现：

现在是时候训练我们的入侵检测机器学习模型了。 与往常一样，我们拆分数据，选择使用的分类器，拟合模型并获得评分结果：

clf = RandomForestClassifier(max_depth=2, random_state=0)
clf.fit(X, y)
Score = clf.score(X_test,y_test)
print(Score*100)

我们入侵检测系统的得分为 85.7％。 有关更多详细信息，您可以输出评估指标（TF，FP，TN，FN 和 Recall），就像在以前的模型中所做的那样。

Kale 堆栈

监控是一项艰巨的任务，特别是在涉及数百名工程师的团队中，可能会发生指标过载。 为了解决这个问题，除了基于时间序列的异常检测能力之外，还有许多项目可以使用。 其中之一是 Kale 堆栈。 它由两部分组成：Skyline 和 Oculus。 Skyline 的作用是检测异常指标（异常检测系统），而 Oculus 是异常相关组件。 要下载这两个组件，您可以查看以下存储库：

您将需要以下内容：

  • 至少 8 GB RAM

  • 四核 Xeon 5620 CPU，或同等配置

  • 1 GB 磁盘空间

总结

在本章中，我们探讨了网络异常检测技术的基础知识以及其背后的理论。 您学会了如何使用 Python 构建基于机器学习的网络异常检测器。 您可以使用许多其他技术来构建机器学习 IDS。 下一章将通过引导您部署一个完全工作的威胁猎杀平台来增强您的技能，该平台使用了一个名为 ELK stack 的开源项目堆栈。

问题

  1. 什么是异常？

  2. 马尔可夫链是什么？

  3. 隐藏的马尔可夫模型是什么？

  4. 我们如何使用隐藏的马尔可夫模型检测异常？

  5. 时间序列异常检测与其他类型的异常检测有什么区别？

  6. 时间序列异常检测与其他类型的异常检测有什么区别？

  7. 监督和无监督机器学习异常检测有什么区别？

进一步阅读

第七章：检测高级持续威胁

现代组织每天都面临网络威胁。黑帽黑客并没有显示出他们要停止的迹象。新的黑客技术经常出现。检测高级持续威胁（APT）是一项艰巨的任务，因为这些攻击的目标是长时间保持不被发现，并窃取数据，而不是对系统造成损害。

根据多份信息安全报告，APT 攻击的数量正在显著增加，瞄准国家防御、制造业和金融行业。因此，传统的保护技术在许多情况下是无用的。部署合适的平台和解决方案可以帮助组织和公司抵御网络攻击，特别是 APT 攻击。

本章将为您提供逐步指导，教您如何构建威胁狩猎平台，使用一系列知名的开源项目来保护您的客户数据。您将学习如何创建一个机器学习模块来增强您的平台，并自动检测异常，以便您可以专注于团队内的其他问题。

在本章中，我们将涵盖：

  • 高级威胁格局

  • 威胁狩猎方法论

  • 狩猎成熟度模型

  • 网络杀伤链

  • 入侵检测的钻石模型

  • 使用机器学习进行威胁狩猎，使用Elasticsearch、Logstash和Kibana（ELK）堆栈

技术要求

在本章中，我们将使用在前几章中使用过的相同的 Python 库。建议您具备以下内容：

  • 4 GB RAM

  • 2 GB CPU

威胁和风险分析

威胁是对您组织资产的潜在危险。根据 2017 年欧洲网络和信息安全局（ENISA）威胁形势报告，现代组织面临着数百万的网络威胁，包括：恶意软件、基于网络的攻击、网络钓鱼、勒索软件、僵尸网络等。对于安全专业人员，尤其是风险管理人员，威胁在分析风险中起着巨大的作用。风险是威胁和漏洞的组合，可以用数学表示为风险=威胁 x 漏洞。

威胁狩猎方法论

威胁狩猎是一种寻找、识别和理解 APT 的方法。威胁狩猎，就像任何方法论的信息安全任务一样，不是关于工具和实用程序。它是一种过程、人员和技术的结合。

威胁狩猎涉及以下步骤：

  • 创建假设

  • 使用工具和技术进行调查

  • 发现新的模式

  • 信息和丰富的分析

以下步骤构成了威胁狩猎循环：

您可以通过从以下选择一个级别来评估您的威胁狩猎计划的成熟度：

  • 等级 1：初始（几乎没有数据收集，依赖自动警报）

  • 等级 2：最低（高水平的数据收集）

  • 等级 3：程序化（高水平的数据收集，遵循数据分析程序）

  • 等级 4：创新（高水平的数据收集，遵循新的数据分析程序）

  • 等级 5：领先（高水平的数据收集，自动化成功的数据分析程序）

以下两个部分包括威胁狩猎中最重要的术语。

网络杀伤链

像信息安全的许多方面一样，网络杀伤链是一个受军事启发的模型，用于描述网络攻击中使用的步骤。

网络杀伤链的七个步骤如下：

  • 侦察：收集信息，如电子邮件地址

  • 武器化：将漏洞与后门结合到可交付的有效载荷中，换句话说，使用漏洞和后门构建可交付的有效载荷

  • 交付：通过不同方式向受害者交付武器化的捆绑包，例如电子邮件或 USB

  • 利用：利用漏洞在目标机器上执行代码

  • 安装：安装恶意软件

  • 命令和控制（C2）：远程操纵受害者的命令通道

  • 行动和目标：完成原始目标

入侵分析的钻石模型

入侵分析的钻石模型是一种用于验证网络威胁的方法论。每个事件都可以表示为一个钻石。许多信息安全分析师使用这种认知模型来一致地表征有组织的威胁，并在其演变过程中跟踪它们。

钻石的四个节点如下：

  • 对手（坏人角色）

  • 基础设施（如 IP 地址、域名和电子邮件地址）

  • 能力（如恶意软件、漏洞利用和被盗证书）

  • 受害者（如人员和网络资产）

使用 ELK Stack 进行威胁狩猎

您现在已经清楚地了解了威胁狩猎中最重要的术语。因此，让我们构建我们的威胁狩猎平台。在接下来的几节中，我们将学习如何使用开源项目构建威胁狩猎系统。在我们的实践指南中，我们将使用其中一个最有前途的解决方案——ELK Stack。它包括三个开源项目，是当今最受欢迎的日志管理平台之一。

ELK Stack 广泛应用于许多领域，包括：

  • 商业智能

  • 网络分析

  • 信息安全

  • 合规性

ELK Stack 由以下组件组成：

  • Elasticsearch：搜索和分析数据

  • Logstash：收集和转换数据

  • Kibana：可视化数据

以下图表说明了 ELK Stack 中的主要组件：

因此，根据主要架构，为了构建威胁狩猎平台，我们需要：收集日志，分析和搜索合适的数据，并管理我们发现的可视化。让我们看看如何准备 ELK Stack 环境。

Elasticsearch

Elasticsearch 是一个令人惊叹的开源项目。它是一个基于 RESTful、分布式和基于 JSON 的搜索引擎。换句话说，您可以将其视为 NoSQL 搜索服务器。您可以在其官方网站上查看：www.elastic.co/

要下载它，转到www.elastic.co/downloads/elasticsearch

选择合适的软件包。在我的情况下，我将在 Ubuntu 14.04 机器上安装它。因此，我将选择.deb版本。建议您具有以下内容：

  • 4GB RAM

  • 2GB CPU

Elasticsearch 是用 Java 编写的。因此，我们需要确保它已安装在我们的环境中（如果没有，则应下载）。将 Java 添加到apt如下：

sudo add-apt-repository -y ppa:webupd8team/java

现在 Java 源已添加到list.sources文件中：

更新list.sources文件：

现在，安装 Java installer：

sudo apt-get -y install oracle-java8-installer

然后，进行配置：

太好了！我们已经成功安装了。通过输入java -version命令来检查：

让我们安装 Elasticsearch。导入elasticsearch公钥如下：

wget -qO - https://packages.elastic.co/GPG-KEY-elasticsearch | sudo
apt-key add -

将 Elasticsearch 添加到源列表中：

echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" |
sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

通过使用apt-get update和install elasticsearch来更新源列表：

apt-get install elasticsearch

要配置 Elasticsearch，使用文本编辑器编辑/etc/elasticsearch/elasticsearch.yml：

vi /etc/elasticsearch/elasticsearch.yml

配置文件后，重新启动 Elasticsearch 服务：

sudo service elasticsearch restart

Kibana

安装和配置 Elasticsearch 后，是时候安装 Kibana 了，以在设计良好的仪表板中可视化数据。Kibana 是一个带有不同类型图表的 Web 界面。您可以将其视为我们堆栈的可视化层。

像往常一样使用apt-get install命令安装 Kibana：

apt-get install kibana

安装不会花费太长时间：

安装完成后，我们可以使用文本编辑器配置它，修改/opt/kibana/config/kibana.yml配置文件：

sudo vi /opt/kibana/config/kibana.yml

使用以下命令启用 Kibana 服务：

sudo update-rc.d kibana defaults 96 9

使用以下命令启动服务：

sudo service kibana start

如果您想要使用公共 IP 地址从外部访问仪表板，您可以使用反向代理。例如，在这种情况下，Nginx将是一个很好的选择。

您可以在/usr/share/kibana找到 Kibana 文件夹：

要检查仪表板，请输入<Address>: 5601并输入您的凭据：

Logstash

此时，我们已经安装了 Elasticsearch 和 Kibana；现在我们需要安装 Logstash 来收集和转换数据。Logstash 管道包含三个组件：

  • 输入

  • 过滤器

  • 输出

让我们将 Logstash 添加到源列表中，然后更新它：

echo 'deb http://packages.elastic.co/logstash/2.2/debian stable main' |
sudo tee /etc/apt/sources.list.d/logstash-2.2.x.list

按照以下方式安装 Logstash：

apt-get install logstash

安装 Logstash 后，您可以编辑其配置文件<Parent_Directory>/logstash/conf/logstash.conf。正如您将注意到的那样，配置文件包含两个部分 - input 和 output：

等等！我打赌您一定想知道为什么我们只有两个部分，尽管 Logstash 包含三个部分，就像我们之前讨论的那样。您完全正确。我们需要添加一个自定义部分，称为filters。Logstash 提供了很好的功能，包括创建个性化过滤器的能力。例如，要创建一个过滤器，您可以使用以下格式（我们将在我们的指南中稍后使用它）：

filter {
     grok {
         match => { "message" => "COMBINEDAPACHELOG %{COMMONAPACHELOG} %{QS:referrer} %{QS:agent}" }
     }
     date {
         match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
    }
 }

gork过滤器用于将非结构化的日志数据解析为结构化且可查询的数据。根据官方的过滤器插件部分（www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html），Logstash 默认提供了 120 多种模式。

使用 X-Pack 插件进行 ELK Stack 的机器学习

我们现在已经安装了 ELK Stack 的三个主要组件。如果您想要一种有效的部署 ELK Stack 的方式，特别是用于测试目的，我建议您使用基于云的堆栈。例如，在以下演示中，我将使用 Bitnami 预定义的云 ELK Stack。

Bitnami ELK Stack 随附以下软件版本：

  • Apache 2.4.29

  • Elasticsearch 6.2.2

  • Logstash 6.2.2

  • Kibana 6.2.2

在几分钟内，您的堆栈将准备就绪。以下屏幕截图显示了 ELK Stack 文件：

要获取 Bitnami 环境的密码，请转到 Azure 门户中的 Boot 诊断部分，并检查日志文件；您将在文件底部找到密码：

在添加机器学习插件之前，让我们配置我们的 ELK Stack。使用以下命令加载 ELK 环境并登录到 ELK 服务器：

sudo /opt/bitnami/use_elk

让我们通过输入sudo /opt/bitnami/ctlscript.sh stop logstash来停止 Logstash

创建一个配置文件/opt/bitnami/logstash/conf/access-log.conf：

input {
     file {
         path => "/opt/bitnami/apache2/logs/access_log"
         start_position => beginning
     }
 }

 filter {
     grok {
         match => { "message" => "COMBINEDAPACHELOG %{COMMONAPACHELOG} %{QS:referrer} %{QS:agent}" }
     }
     date {
         match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
    }
 }

 output {
     elasticsearch {
         hosts => [ "127.0.0.1:9200" ]
     }
 }

检查/opt/bitnami/logstash/bin/logstash -f /opt/bitnami/logstash/conf/ --config.test_and_exit的配置：

按照以下方式启动 Logstash：

sudo /opt/bitnami/ctlscript.sh start logstash

检查 Elasticsearch 是否正常工作：

现在，让我们去 Kibana。正如您可能已经注意到的，我们还没有索引模式：

配置 Logstash 后，我们可以创建一个新的索引模式：

输入*并点击下一步：

选择@timestamp 并点击Create Index pattern按钮。您现在可以在 Kibana 中查看新的索引模式页面：

当您点击 Discover 选项时，您可以检查日志：

现在，让我们自定义一个可添加到主仪表板的可视化。在侧边栏上点击可视化，然后创建一个新的可视化：

对于我们的演示，我们将使用垂直条形图。您可以从一系列图表和可视化工具中进行选择：

对于 X 轴，选择日期直方图作为聚合和@timestamp 作为字段：

然后，您将看到您图表的可视化，如下面的截图所示：

创建可视化后，让我们添加到我们的仪表板。点击仪表板链接并创建一个新的仪表板。然后，添加您的可视化：

保存仪表板。现在，您可以检查任何指标：

ELK Stack 威胁平台已准备好帮助您追踪多种高级威胁。让我们将项目提升一个档次，并通过利用机器学习的力量来自动化追踪操作，为其增加智能化的触角。ELK Stack 让您有能力向您的追踪平台添加一个名为 X-Pack 的插件，它将帮助您检测您的文物和日志中的异常。

要获得 X-Pack 插件，我们需要在堆栈的每一层上安装它，正如官方插图所示：

要在 Elasticsearch 上安装插件，请转到binaries文件夹，并输入以下命令：

./elasticsearch-plugin install x-pack

相同的操作也适用于 Kibana：

sudo bin/kibana-plugin install x-pack

这也适用于 Logstash：

sudo bin/logstash-plugin install x-pack

重新启动所有服务并转到 Kibana 仪表板；您将注意到一个新选项，称为机器学习：

最后，由于 X-Pack，您可以添加时间序列异常检测功能。在上一章中，我们详细讨论了异常检测。我们深入研究了异常检测的基本原理以及如何使用机器学习来检测这些异常。X-Pack 正在使用相同的技术来发现异常。

总结

在之前的章节中，我们看到如何使用不同的机器学习算法和 Python 库从头开始构建异常检测系统。本章包括了一份逐步指南，帮助您构建一个完全功能的威胁追踪平台，使用了三个令人惊叹的开源项目。我们还实施了一个机器学习插件，以优化和增强威胁追踪平台的能力。到目前为止，您已经学会了如何使用机器学习的力量构建许多防御系统。如果您想学习如何绕过机器学习保障，下一章是必读的。

问题

  1. 以下哪一项不是网络攻击杀伤链中的步骤？

（a）扫描

（b）控制和命令

（c）发现和传播

  1. 以下哪个选项不是入侵分析钻石模型的节点？

（a）受害者

（b）基础设施

（c）程序

  1. Logstash 配置文件需要多少部分？

（a）2

（b）3

（c）4

  1. 在 Elasticsearch 中，索引是什么？

（a）在索引中存储数据的过程

（b）识别数据的过程

（c）以上都不是

  1. 在 Elasticsearch 中，什么是节点？

（a）Elasticsearch 模块

（b）Elasticsearch 的一个实例

（c）以上都不是

  1. 在 Elasticsearch 中，什么是分片？

（a）共享文件

（b）共享数据

（c）共享资源（RAM、vCPU 等）

  1. Elasticsearch 有模式吗？（是 | 否）

第八章：规避入侵检测系统

部署入侵检测系统对于每家现代公司来说都是必不可少的，以防御攻击者。在前几章中，我们学习了如何构建基于机器学习的入侵检测系统。现在，是时候学习如何通过对抗学习来绕过这些系统了；为了保护您的系统，您需要先学会如何攻击它们。

在本章中，我们将涵盖以下内容：

  • 对抗机器学习算法

  • 机器学习威胁模型

  • 使用对抗网络系统规避入侵检测系统

技术要求

在本章中，您将需要以下库：

  • PyYAML

  • NumPy

  • SciPy

  • CVXPY

  • Python 3

  • Matplotlib

  • scikit-learn

  • 进展

  • Pathos

  • CVXOPT（作为 CVXPY 求解器的可选项）

  • Jupyter Notebook

您可以在以下网址找到代码文件：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter08。

对抗机器学习算法

在学习对抗机器学习之前，让我们探讨两个重要的术语：过拟合和欠拟合。

过拟合和欠拟合

过拟合是机器学习从业者面临的最大障碍之一。知道如何发现过拟合是构建健壮的机器学习模型所必需的技能，因为达到 99%的准确率并不是故事的结束。在机器学习中，我们进行预测。根据定义，拟合是我们对目标函数的逼近程度。正如我们在第一章中看到的，监督学习的目标是映射输入数据和目标之间的函数。因此，一个良好的拟合是对该函数的良好逼近。

过拟合发生在模型学习训练数据中的细节和噪音，以至于负面影响了模型的性能。换句话说，模型学习到了噪音，因此在输入新数据时无法很好地进行泛化。下图说明了过拟合的情况。您会注意到模型已经训练得太好，这使得在向模型输入数据时很难实现准确性。

另一个障碍是欠拟合。当机器学习模型不足够拟合数据时就会发生这种情况。换句话说，当模型过于简单时：

使用 Python 进行过拟合和欠拟合

让我们用 scikit-learn 来看一下过拟合和欠拟合的真实演示。导入所需的模块：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score

我们现在将构建一个小模型，并可视化模型、样本和true函数，以查看过拟合和欠拟合。我们将使用以下代码：

np.random.seed(0)
n_samples = 30
degrees = [1, 4, 15]
X = np.sort(np.random.rand(n_samples))
y = np.cos(1.5 * np.pi * X) + np.random.randn(n_samples) * 0.1
plt.figure(figsize=(14, 5))

for i in range(len(degrees)):
 ax = plt.subplot(1, len(degrees), i + 1)
 plt.setp(ax, xticks=(), yticks=())

 polynomial_features = PolynomialFeatures(degree=degrees[i],
 include_bias=False)
 linear_regression = LinearRegression()
 pipeline = Pipeline([("polynomial_features", polynomial_features),
 ("linear_regression", linear_regression)])
 pipeline.fit(X[:, np.newaxis], y)

 # Evaluate the models using crossvalidation
 scores = cross_val_score(pipeline, X[:, np.newaxis], y,
 scoring="neg_mean_squared_error", cv=10)

 X_test = np.linspace(0, 1, 100)
 plt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label="Model")
 plt.plot(X_test, true_fun(X_test), label="True function")
 plt.scatter(X, y, edgecolor='b', s=20, label="Samples")
 plt.xlabel("x")
 plt.ylabel("y")
 plt.xlim((0, 1))
 plt.ylim((-2, 2))
 plt.legend(loc="best")
 plt.title("Degree {}\nMSE = {:.2e}(+/- {:.2e})".format(
 degrees[i], -scores.mean(), scores.std()))
plt.show()

通过运行前面的脚本，我们绘制了以下图表，说明了 3 种情况：欠拟合、良好拟合和过拟合（从左到右）：

以下表格是使用前面代码中突出显示的术语和相应的 URL 创建的：

模块 URL
plt.subplot matplotlib.org/api/_as-gen/matplotlib.pyplot.subplot.html#matplotlib.pyplot.subplot
plt.setp matplotlib.org/api/_as-gen/matplotlib.pyplot.setp.html#matplotlib.pyplot.setp
PolynomialFeatures scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html#sklearn.preprocessing.PolynomialFeatures
LinearRegression scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression
Pipeline scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline
np.newaxis docs.scipy.org/doc/numpy-1.8.1/reference/arrays.indexing.html#numpy.newaxis
cross_val_score scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score
np.newaxis docs.scipy.org/doc/numpy-1.8.1/reference/arrays.indexing.html#numpy.newaxis
np.linspace docs.scipy.org/doc/numpy-1.8.1/reference/generated/numpy.linspace.html#numpy.linspace
plt.plot matplotlib.org/api/_as-gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot
plt.scatter matplotlib.org/api/_as-gen/matplotlib.pyplot.scatter.html#matplotlib.pyplot.scatter
plt.xlabel matplotlib.org/api/_as-gen/matplotlib.pyplot.xlabel.html#matplotlib.pyplot.xlabel
plt.ylabel matplotlib.org/api/_as-gen/matplotlib.pyplot.ylabel.html#matplotlib.pyplot.ylabel
plt.xlim matplotlib.org/api/_as-gen/matplotlib.pyplot.xlim.html#matplotlib.pyplot.xlim
plt.ylim matplotlib.org/api/_as-gen/matplotlib.pyplot.ylim.html#matplotlib.pyplot.ylim
plt.legend matplotlib.org/api/legend_api.html#matplotlib.legend
plt.title matplotlib.org/api/_as-gen/matplotlib.pyplot.title.html#matplotlib.pyplot.title
plt.show matplotlib.org/api/_as-gen/matplotlib.pyplot.show.html#matplotlib.pyplot.show

检测过拟合

为了检测过拟合，强烈建议将初始数据集分成训练集和测试集。如果训练集的表现远远好于测试集，那么我们就有问题。此外，强烈建议从简单的算法开始，然后再转向更复杂的模型，检查升级复杂度是否值得。为了防止过拟合，我们可以使用交叉验证。交叉验证是通过使用不同子集（k子集）训练模型来评估许多机器学习技术的过程。

对抗机器学习

对抗机器学习是研究如何破解和保护机器学习模型的艺术。您可以将其视为机器学习和信息安全之间的交集。作为安全专业人士，学习如何使用机器学习构建防御层很重要，但了解如何破解它们也是您技能组合的一个很棒的补充：

2006 年，Barreno 等人提出了针对机器学习系统的威胁模型的分类法。该模型基于三个轴：

  • 影响

  • 安全违规

  • 特异性

2011 年，黄等人扩展了该模型，包括另一个称为隐私的轴。2016 年，Papernot，McDaniel，Jha，Fredrikson，Celik 和 Swami 引入了一个专注于两个轴的新分类法：

  • 攻击的复杂性

  • 攻击者的知识

以下图表说明了机器学习威胁分类：

为了攻击机器学习模型，攻击者可以执行许多技术，这些技术在以下部分中进行了讨论。

规避攻击

为执行机器学习规避攻击，网络犯罪分子尝试通过观察模型的工作方式，尤其是结果，尝试许多不同的样本，只需向模型提供不同的输入并尝试找到学习模式。这种技术非常流行。例如，如果攻击者想要规避机器学习垃圾邮件过滤器，他需要向系统提供不同的电子邮件并搜索使垃圾邮件通过（未被检测为垃圾邮件）并通过仅对先前检测到的电子邮件进行少量修改来规避检测的模式。

以下工作流说明了规避攻击的工作原理：

毒害攻击

在机器学习中毒攻击中，攻击者通过在模型训练阶段添加恶意数据来毒害模型，以改变学习结果。例如，可以通过在网络操作期间进行数据收集时发送和注入精心设计的样本来执行此方法，以训练网络入侵检测系统模型。以下工作流说明了毒害攻击的发生过程：

在意大利模式识别与应用实验室进行的一些最重要的对抗机器学习研究包括针对支持向量机的毒害攻击，当 Battista Biggio 及其团队提出了一个攻击支持向量机系统的重要框架。步骤如下：

  1. 确定适当的对手目标

  2. 定义对手的知识

  3. 制定相应的优化问题

  4. 相应地重新采样收集的（训练和测试）数据

  5. 评估在重新采样数据上的分类器安全性

  6. 针对不同水平的对手知识重复评估

如果您熟悉 MATLAB，我强烈建议您尝试ALFASVMLib。这是一个关于 SVM 上对抗性标签翻转攻击的 MATLAB 库。您可以从github.com/feuerchop/ALFASVMLib下载它。

对抗聚类

聚类技术广泛应用于许多实际应用中。攻击者正在提出新的技术来攻击聚类模型。其中之一是对抗聚类，攻击者通过操纵输入数据（添加少量攻击样本），使新添加的样本可以隐藏在现有的聚类中。

对抗特征

特征选择是每个机器学习项目中的重要步骤。攻击者也在使用对抗性特征选择来攻击模型。我强烈建议您阅读同一团队（意大利模式识别与应用实验室研究人员）在一篇名为特征选择对训练数据毒害是否安全？的论文中所做的研究。

团队表明，通过污染嵌入式特征选择算法，包括 LASSO、岭回归和 ElasticNet，他们愚弄了 PDF 恶意软件检测器。

有许多 Python 框架和开源项目是由研究人员开发的，用于攻击和评估机器学习模型，例如CleverHans，对抗机器学习（AML）库和EvadeML-Zoo。

CleverHans

CleverHans 正在不断发展； 它是一个对抗性示例库，用于构建攻击、构建防御和评估机器学习系统对对抗性攻击的脆弱性。

您可以从github.com/tensorflow/cleverhans克隆它：

或者，您可以使用pip实用程序进行安装，如下所示：

AML 库

AML 库是由范德堡大学计算经济研究实验室开发的博弈论对抗机器学习库。 通过博弈论，我们指的是智能决策代理之间合作的数学模型的研究。 您可以从github.com/vu-aml/adlib克隆该库。

EvadeML-Zoo

EvadeML-Zoo 是由弗吉尼亚大学的机器学习组和安全研究组开发的对抗机器学习基准测试和可视化工具。 您可以从github.com/mzweilin/EvadeML-Zoo下载它。

使用对抗网络系统规避入侵检测系统

到目前为止，您已经对对抗性机器学习有了相当的了解，以及如何攻击机器学习模型。 现在是时候深入了解更多技术细节，学习如何使用 Python 绕过基于机器学习的入侵检测系统。 您还将学习如何防御这些攻击。

在这个演示中，您将学习如何使用污染攻击攻击模型。 正如之前讨论的，我们将注入恶意数据，以便影响模型的学习结果。 以下图表说明了污染攻击的发生方式：

在这次攻击中，我们将使用基于雅可比显著图攻击（JSMA）。 这是通过仅修改输入中有限数量的像素来搜索对抗性示例。

让我们看看如何使用 Python 攻击基于机器的入侵检测系统。 代码有点长，所以我只会包含一些重要的片段；稍后，您可以在本章的 GitHub 存储库中找到完整的代码。

对于这个项目，我们需要 NumPy、pandas、Keras、CleverHans、TensorFlow、scikit-learn 和 matplotlib Python 库。

这些是一些导入的库：

import numpy as np
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense , Dropout
from keras.optimizers import RMSprop , adam
from cleverhans.attacks import fgsm , jsma
from cleverhans.utils_tf import model_train , model_eval , batch_eval
from cleverhans.attacks_tf import jacobian_graph
from cleverhans.utils import other_classes
import tensorflow as tf
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score , roc_curve , auc , f1_score
from sklearn.preprocessing import LabelEncoder , MinMaxScaler
import matplotlib.pyplot as plt

下一步是预处理数据：

names = ['duration', 'protocol', 'service ', 'flag', 'src_bytes', 'dst_bytes', 'land',
'wrong_fragment ','urgent ', 'hot', 'num_failed_logins ', 'logged_in ', 'num_compromised ', 'root_shell ', 'su_attempted ','num_root ', 'num_file_creations ', 'num_shells ', 'num_access_files ', 'num_outbound_cmds ','is_host_login ', 'is_guest_login ', 'count', 'srv_count ', 'serror_rate', 'srv_serror_rate ','rerror_rate ', 'srv_rerror_rate ', 'same_srv_rate ', 'diff_srv_rate', 'srv_diff_host_rate ','dst_host_count ', 'dst_host_srv_count ', 'dst_host_same_srv_rate ', 'dst_host_diff_srv_rate ','dst_host_same_src_port_rate ', 'dst_host_srv_diff_host_rate ', 'dst_host_serror_rate ','dst_host_srv_serror_rate ','dst_host_rerror_rate ', 'dst_host_srv_rerror_rate ','attack_type ', 'other ']

然后，我们将使用 pandas 加载数据：

TrainingData = pd.read_csv('KDDTrain+.txt', names=names , header=None)
TestingData = pd.read_csv('KDDTest+.txt', names=names , header=None)

然后，连接训练和测试集：

All = pd.concat ([TrainingData, TestingData])
assert full.shape[0] == TrainingData.shape[0] + TestingData.shape[0]

选择数据并识别特征：

All['label'] = full['attack_type']

要识别 DoS 攻击，请使用以下内容：

All.loc[All.label == 'neptune ', 'label'] = 'dos'
All.loc[All.label == 'back', 'label '] = 'dos'
All.loc[All.label == 'land', 'label '] = 'dos'
All.loc[All.label == 'pod', 'label'] = 'dos'
All.loc[All.label == 'smurf ', 'label'] = 'dos'
All.loc[All.label == 'teardrop ', 'label '] = 'dos'
All.loc[All.label == 'mailbomb ', 'label '] = 'dos'
All.loc[All.label == 'processtable ', 'label'] = 'dos'
All.loc[All.label == 'udpstorm ', 'label '] = 'dos'
All.loc[All.label == 'apache2 ', 'label'] = 'dos'
All.loc[All.label == 'worm', 'label '] = 'dos'

使用相同技术识别其他攻击（User-to-Root（U2R）、Remote-to-Local（R2L）和Probe）。

要生成一热编码，请使用以下内容：

full = pd.get_dummies(All , drop_first=False)

再次识别训练和测试集：

features = list(full.columns [:-5])
y_train = np.array(full[0:TrainingData.shape[0]][[ 'label_normal ', 'label_dos ', 'label_probe
label_r2l ', 'label_u2r ']])
X_train = full[0:TrainingData.shape[0]][ features]
y_test = np.array(full[TrainingData.shape[0]:][[ 'label_normal ', 'label_dos ', 'label_probe ', '
label_r2l ', 'label_u2r ']])
X_test = full[TrainingData.shape[0]:][features]

要缩放数据，请使用以下命令：

scaler = MinMaxScaler().fit(X_train)

scale X_train的示例如下：

X_train_scaled = np.array(scaler.transform(X_train))

假设我们要攻击逻辑回归模型； 我们需要处理数据以训练该模型并生成标签编码：

labels = All.label.unique()
En = LabelEncoder()
En.fit(labels)
y_All = En.transform(All.label)
y_train_l = y_All[0:TrainingData.shape[0]]
y_test_l = y_All[TrainingData.shape[0]:]

我们现在已经完成了预处理阶段。

对于基于雅可比显著图攻击，我们将使用以下 Python 实现：

results = np.zeros((FLAGS.nb_classes , source_samples), dtype='i')
perturbations = np.zeros((FLAGS.nb_classes , source_samples), dtype='f')
grads = jacobian_graph(predictions , x, FLAGS.nb_classes)
X_adv = np.zeros(( source_samples , X_test_scaled.shape [1]))
for sample_ind in range(0, source_samples):
current_class = int(np.argmax(y_test[sample_ind ]))
for target in [0]:
if current_class == 0:
Break
adv_x , res , percent_perturb = jsma(sess , x, predictions , grads,X_test_scaled[sample_ind: (sample_ind+1)],target , theta=1, gamma =0.1,increase=True , back='tf',clip_min=0, clip_max =1)
X_adv[sample_ind] = adv_x
results[target , sample_ind] = res
perturbations[target , sample_ind] = percent_perturb

要构建MultiLayer Perceptron网络，请使用以下代码片段：

def mlp_model ():
    Generate a MultiLayer Perceptron model
    model = Sequential ()
    model.add(Dense (256, activation='relu', input_shape =( X_train_scaled.shape [1],)))
    model.add(Dropout (0.4))
    model.add(Dense (256, activation='relu'))
    model.add(Dropout (0.4))
    model.add(Dense(FLAGS.nb_classes , activation='softmax '))model.compile(loss='categorical_crossentropy ',optimizer='adam',metrics =['accuracy '])
    model.summary ()
    return model

对于对抗性预测，请使用以下内容：

y_pred_adv = dt.predict(X_adv)
fpr_dt_adv , tpr_dt_adv , _ = roc_curve(y_test[:, 0], y_pred_adv [:, 0])
roc_auc_dt_adv = auc(fpr_dt_adv , tpr_dt_adv)
print("Accuracy score adversarial:", accuracy_score(y_test , y_pred_adv))
print("F1 score adversarial:", f1_score(y_test , y_pred_adv , average='micro '))
print("AUC score adversarial:", roc_auc_dt_adv)

最后，我们需要通过提供对抗性测试数据来评估模型：

如果出现错误，请检查本章的 GitHub 存储库。代码可能在出版后进行更新和增强。

摘要

在本章中，我们概述了对抗性学习技术，并描述了攻击者和网络犯罪分子如何对机器学习模型进行攻击。

下一章将是一个很好的补充指南，探讨如何攻击人工神经网络和深度学习网络。您将了解攻击者如何通过使用对抗性深度学习和强化学习来绕过现代反恶意软件系统。

问题

  1. 您能简要解释一下为什么过度训练机器学习模型不是一个好主意吗？

  2. 过拟合和欠拟合之间有什么区别？

  3. 规避攻击和中毒攻击之间有什么区别？

  4. 对抗性聚类是如何工作的？

  5. 用于规避入侵检测系统的对抗性攻击类型是什么？

  6. 前面的攻击是规避还是中毒攻击？

进一步阅读

第九章：绕过机器学习恶意软件检测器

在上一章中，您了解到可以通过使用对抗性机器学习技术攻击机器学习模型并使其执行恶意活动。在本章中，我们将进一步探讨如何欺骗人工神经网络和深度学习网络等技术。我们将以反恶意软件系统规避为案例研究。

在本章中，我们将涵盖以下内容：

  • 对抗性深度学习

  • 如何使用生成对抗网络绕过下一代恶意软件检测器

  • 使用强化学习绕过机器学习

技术要求

本章的代码文件可以在github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter09找到。

对抗性深度学习

信息安全专业人员正在尽力提出新技术来检测恶意软件和恶意软件。其中一种流行的技术是使用机器学习算法来检测恶意软件。另一方面，攻击者和网络犯罪分子也在想出新方法来绕过下一代系统。在上一章中，我们看了如何攻击机器学习模型以及如何绕过入侵检测系统。

恶意软件开发人员使用许多技术来绕过机器学习恶意软件检测器。之前，我们探讨了一种通过使用灰度图像向量训练系统来构建恶意软件分类器的方法。在由** SARVAM （恶意软件搜索和检索**）研究单位在 UCSB 的 Vision Research Lab 进行的演示中，研究人员说明了通过更改几个字节，模型可以将恶意软件分类为良性软件。攻击者可以通过更改几个字节和像素来绕过恶意软件分类器执行此技术。在演示中，研究人员使用了 NETSTAT 程序的变体，这是一个显示网络连接的命令行网络实用工具。在下图中，左侧是NETSTAT.EXE恶意软件的表示，第二个被检测为良性软件。如您所见，两个程序之间的差异是不可察觉的（36,864 字节中的 88 字节：0.78%），在将两种文件类型转换为灰度图像并检查它们之间的差异后：

这种技术只是一个开始；在本章中，我们将深入探讨如何欺骗它们（在我们的案例中是恶意软件分类器的机器学习模型）执行恶意活动。

上一章是对对抗性机器学习的概述。我们了解了攻击者如何绕过机器学习。在本章中，我们将更深入地了解如何绕过基于机器学习的恶意软件检测器；在此之前，我们将学习如何欺骗人工神经网络并避开 Python、开源库和开源项目的深度学习网络。神经网络可以被对抗样本欺骗。对抗样本被用作神经网络的输入，以影响学习结果。由 Ian J. Goodfellow、Jonathon Shlens 和 Christian Szegedy（在 Google）进行的一项开创性研究项目，名为解释和利用对抗网络，显示了一小部分精心构造的噪音可以欺骗神经网络，使其认为输入的图像是长臂猿而不是熊猫，且置信度为 99.3%。神经网络最初认为提供的图像是熊猫，置信度为 57.7%，这是正确的；但在第二个例子中，欺骗网络后情况并非如此：

许多电子设备和系统依赖深度学习作为保护机制，包括人脸识别；想象一下攻击者可以对它们进行的攻击，并未授权地访问关键系统。

现在，让我们试图愚弄一个神经网络。我们将使用著名的 MNIST 数据集愚弄手写数字检测系统。在第四章中，使用深度学习进行恶意软件检测，我们学习了如何构建一个。为了演示，我们将愚弄 Michael Nielsen 的一个预训练神经网络。他使用了 5 万张训练图像和 1 万张测试图像。或者，您也可以使用自己的神经网络。您可以在本章的 GitHub 存储库中找到训练信息。文件名为trained_network.pkl；您还会找到 MNIST 文件（mnist.pkl.gz）：

import network.network as network
import network.mnist_loader as mnist_loader
# To serialize data
import pickle
import matplotlib.pyplot as plt
import numpy as np

让我们检查模型是否训练良好。加载pickle文件。使用pickle.load()加载数据，并识别训练、验证和测试数据：

Model = pickle.load( open( "trained_network.pkl", "rb" ) )    trainData, valData, testData =mnist_loader.load_data_wrapper()

例如，要检查数字 2，我们将选择test_data[1][0]：

>>> data = test_data[1][0]
>>> activations = Model.feedforward(data)
>>> prediction = np.argmax(activations)

以下屏幕截图说明了前面的代码：

！

通过使用matplotlib.pyplot (plt)绘制结果以进一步检查：

>>> plt.imshow(data.reshape((28,28)), cmap='Greys')
>>> plt.show()

如您所见，我们生成了数字2，所以模型训练得很好：

！

一切都设置正确。现在，我们将用两种类型的攻击来攻击神经网络：有目标的和无目标的。

对于无目标攻击，我们将生成一个对抗样本，并使网络给出特定输出，例如6：

！

在这次攻击中，我们希望神经网络认为输入的图像是6。目标图像（我们称之为X）是一个784维向量，因为图像尺寸是28×28像素。我们的目标是找到一个向量*⃗x*，使成本C最小化，从而得到一个神经网络预测为我们目标标签的图像。成本函数C定义如下：

！

以下代码块是导数函数的实现：

def input_derivative(net, x, y):
    """ Calculate derivatives wrt the inputs"""
    nabla_b = [np.zeros(b.shape) for b in net.biases]
    nabla_w = [np.zeros(w.shape) for w in net.weights]

    # feedforward
    activation = x
    activations = [x] # list to store all the activations, layer by layer
    zs = [] # list to store all the z vectors, layer by layer
    for b, w in zip(net.biases, net.weights):
        z = np.dot(w, activation)+b
        zs.append(z)
        activation = sigmoid(z)
        activations.append(activation)

    # backward pass
    delta = net.cost_derivative(activations[-1], y) * \
        sigmoid_prime(zs[-1])
    nabla_b[-1] = delta
    nabla_w[-1] = np.dot(delta, activations[-2].transpose())

    for l in xrange(2, net.num_layers):
        z = zs[-l]
        sp = sigmoid_prime(z)
        delta = np.dot(net.weights[-l+1].transpose(), delta) * sp
        nabla_b[-l] = delta
        nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
    return net.weights[0].T.dot(delta)

要生成对抗样本，我们需要设定目标：

goal = np.zeros((10, 1))
goal[n] = 1

创建一个随机图像以进行梯度下降初始化，如下所示：

x = np.random.normal(.5, .3, (784, 1))

计算梯度下降，如下所示：

for i in range(steps):
        # Calculate the derivative
        d = input_derivative(net,x,goal)       
        x -= eta * d       
    return x

现在，您可以生成样本：

a = adversarial(net, n, 1000, 1)
x = np.round(net.feedforward(a), 2)
Print ("The input is:", str(x))
Print ("The prediction is", str(np.argmax(x)))

绘制对抗样本，如下所示：

plt.imshow(a.reshape(28,28), cmap='Greys')
plt.show()

！

在有目标的攻击中，我们使用相同的技术和相同的代码，但是我们在成本函数中添加了一个新项。因此，它将如下所示：

！

Foolbox

Foolbox 是一个用于评估机器学习模型鲁棒性的 Python 工具包。它受到许多框架的支持，包括以下：

  • TensorFlow

  • PyTorch

  • Theano

  • Keras

  • Lasagne

  • MXNet

要安装 Foolbox，请使用pip实用程序：

pip install foolbox

！

以下是一些 Foolbox 攻击：

  • 基于梯度的攻击：通过在输入x周围线性化损失

  • 梯度符号攻击（FGSM）：通过计算梯度g(x0)，然后寻找最小步长

  • 迭代梯度攻击：通过在梯度方向上的小步骤中最大化损失g(x)

  • 迭代梯度符号攻击：通过在上升方向上的小步骤中最大化损失sign(g(x))

  • DeepFool L2 攻击：通过计算每个类的最小距离d(ℓ, ℓ0)，以达到类边界

  • DeepFool L∞攻击：类似于 L2 攻击，但最小化L∞-范数

  • 基于 Jacobian 的显著性图攻击：通过计算每个输入特征的显著性分数

  • 单像素攻击：通过将单个像素设置为白色或黑色

要使用 Foolbox 实施攻击，请使用以下方法：

import foolbox
import keras
import numpy as np
from keras.applications.resnet50 import ResNet50

keras.backend.set_learning_phase(0)
kmodel = ResNet50(weights='imagenet')
preprocessing = (np.array([104, 116, 123]), 1)
fmodel = foolbox.models.KerasModel(kmodel, bounds=(0, 255), preprocessing=preprocessing)

image, label = foolbox.utils.imagenet_example()
attack = foolbox.attacks.FGSM(fmodel)
adversarial = attack(image[:, :, ::-1], label)

如果您收到错误消息，ImportError('load_weights requires h5py.')，请通过安装h5py库来解决（pip install h5py）。

要绘制结果，请使用以下代码：

import matplotlib.pyplot as plt
plt.figure()
plt.subplot(1, 3, 1)
plt.title('Original')
plt.imshow(image / 255) 
plt.axis('off')
plt.subplot(1, 3, 2)
plt.title('Adversarial')
plt.imshow(adversarial[:, :, ::-1] / 255)  # ::-1 to convert BGR to RGB
plt.axis('off')
plt.subplot(1, 3, 3)
plt.title('Difference')
difference = adversarial[:, :, ::-1] - image
plt.imshow(difference / abs(difference).max() * 0.2 + 0.5)
plt.axis('off')
plt.show()

！

Deep-pwning

Deep-pwning 是一个轻量级框架，用于实验机器学习模型，旨在评估其对抗性对抗有动机的对手。它被称为机器学习的 metasploit。您可以从 GitHub 仓库克隆它：github.com/cchio/deep-pwning。

不要忘记安装所有的要求：

pip install -r requirements.txt

以下是与 Deep-pwning 一起使用所需的 Python 库：

  • Tensorflow 0.8.0

  • Matplotlib >= 1.5.1

  • Numpy >= 1.11.1

  • Pandas >= 0.18.1

  • Six >= 1.10.0

EvadeML

EvadeML (evademl.org )是基于遗传编程的进化框架，用于自动查找能够逃避基于机器学习的恶意软件分类器检测的变体。它是由弗吉尼亚大学的机器学习组和安全研究组开发的。

要下载 EvadeML，请从github.com/uvasrg/EvadeML克隆它。

要安装 EvadeML，您需要安装这些必需的工具：

要配置项目，请复制模板，并使用编辑器进行配置：

cp project.conf.template project.conf
Vi  project.conf

在运行主程序./gp.py之前，运行带有预定义恶意软件签名的集中式检测代理，如文档中所示：

./utils/detection_agent_server.py ./utils/36vms_sigs.pickle

选择几个良性 PDF 文件：

./utils/generate_ext_genome.py [classifier_name] [benign_sample_folder] [file_number]

要向逃避添加新的分类器，只需在./classifiers/中添加一个包装器。

使用生成对抗网络绕过下一代恶意软件检测器

2014 年，Ian Goodfellow、Yoshua Bengio 及其团队提出了一个名为生成对抗网络（GAN）的框架。生成对抗网络能够从随机噪声生成图像。例如，我们可以训练一个生成网络，从 MNIST 数据集生成手写数字的图像。

生成对抗网络由两个主要部分组成：生成器和鉴别器。

生成器

生成器以潜在样本作为输入；它们是随机生成的数字，并且它们被训练以生成图像：

例如，要生成手写数字，生成器将是一个完全连接的网络，它接受潜在样本并生成784个数据点，将它们重塑为28x28像素图像（MNIST 数字）。强烈建议使用tanh作为激活函数：

generator = Sequential([
Dense(128, input_shape=(100,)),
LeakyReLU(alpha=0.01),
Dense(784),
Activation('tanh')
], name='generator')

鉴别器

鉴别器只是一个使用监督学习技术训练的分类器，用于检查图像是否为真（1）或假（0）。它通过 MNIST 数据集和生成器样本进行训练。鉴别器将把 MNIST 数据分类为真实的，生成器样本分类为假的：

discriminator = Sequential([
Dense(128, input_shape=(784,)),
LeakyReLU(alpha=0.01),
Dense(1),
Activation('sigmoid')], name='discriminator')

通过连接两个网络，生成器和鉴别器，我们产生了一个生成对抗网络：

gan = Sequential([
generator,
discriminator])

这是生成对抗网络的高级表示：

要训练 GAN，我们需要训练生成器（鉴别器在后续步骤中设置为不可训练）；在训练中，反向传播更新生成器的权重以生成逼真的图像。因此，要训练 GAN，我们使用以下步骤作为循环：

  • 用真实图像训练鉴别器（鉴别器在这里是可训练的）

  • 将鉴别器设置为不可训练

  • 训练生成器

训练循环将持续进行，直到两个网络都无法进一步改进。

使用 Python 构建 GAN，请使用以下代码：

import pickle as pkl
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
batch_size = 100
epochs = 100
samples = []
losses = []
saver = tf.train.Saver(var_list=g_vars)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for e in range(epochs):
        for ii in range(mnist.train.num_examples//batch_size):
            batch = mnist.train.next_batch(batch_size)

            batch_images = batch[0].reshape((batch_size, 784))
            batch_images = batch_images*2 - 1

            batch_z = np.random.uniform(-1, 1, size=(batch_size, z_size))

            _ = sess.run(d_train_opt, feed_dict={input_real: batch_images, input_z: batch_z})
            _ = sess.run(g_train_opt, feed_dict={input_z: batch_z})

        train_loss_d = sess.run(d_loss, {input_z: batch_z, input_real: batch_images})
        train_loss_g = g_loss.eval({input_z: batch_z})

        print("Epoch {}/{}...".format(e+1, epochs),
              "Discriminator Loss: {:.4f}...".format(train_loss_d),
              "Generator Loss: {:.4f}".format(train_loss_g))    

        losses.append((train_loss_d, train_loss_g))

        sample_z = np.random.uniform(-1, 1, size=(16, z_size))
        gen_samples = sess.run(
                       generator(input_z, input_size, n_units=g_hidden_size, reuse=True, alpha=alpha),
                       feed_dict={input_z: sample_z})
        samples.append(gen_samples)
        saver.save(sess, './checkpoints/generator.ckpt')
with open('train_samples.pkl', 'wb') as f:
    pkl.dump(samples, f)

使用 Python 构建 GAN，我们将使用 NumPy 和 TensorFlow。

MalGAN

为了生成恶意软件样本来攻击机器学习模型，攻击者现在正在使用 GAN 来实现他们的目标。使用我们之前讨论过的相同技术（生成器和鉴别器），网络犯罪分子对下一代反恶意软件系统进行攻击，甚至不知道使用的机器学习技术（黑盒攻击）。其中一种技术是 MalGAN，它是由魏伟胡和应潭从机器感知（MOE）重点实验室和机器智能系进行的名为“基于 GAN 的黑盒攻击生成对抗性恶意软件示例”的研究项目中提出的。MalGAN 的架构如下：

生成器通过接受恶意软件（特征向量m）和噪声向量z作为输入来创建对抗性恶意软件样本。替代检测器是一个多层前馈神经网络，它以程序特征向量X作为输入。它对程序进行良性程序和恶意软件之间的分类。

为了训练生成对抗网络，研究人员使用了这个算法：

While not converging do:
    Sample a minibatch of Malware M
    Generate adversarial samples M' from the generator
    Sample a minibatch of Goodware B
    Label M' and B using the detector
    Update the weight of the detector
    Update the generator weights
End while

生成的许多样本可能不是有效的 PE 文件。为了保留变异和格式，系统需要一个沙盒来确保功能得到保留。

生成对抗网络训练不能简单地产生出优秀的结果；这就是为什么需要许多技巧来实现更好的结果。Soumith Chintala、Emily Denton、Martin Arjovsky 和 Michael Mathieu 引入了一些技巧来获得改进的结果：

  • 将图像归一化在-1和1之间

  • 使用最大对数D作为损失函数，以优化G而不是最小化(log 1-D)

  • 从高斯分布中抽样，而不是均匀分布

  • 为真实和虚假构建不同的小批量

  • 避免 ReLU 和 MaxPool，而使用 LeakyReLU 和平均池化

  • 如果可能的话，使用深度卷积 GAN（DCGAN）

  • 使用ADAM优化器

通过强化学习绕过机器学习

在先前的技术中，我们注意到如果我们生成对抗性样本，特别是如果结果是二进制的，我们将面临一些问题，包括生成无效样本。信息安全研究人员提出了一种绕过机器学习反恶意软件系统的新技术。

强化学习

以前（特别是在第一章），我们探讨了不同的机器学习模型：监督、半监督、无监督和强化模型。强化机器学习模型是构建智能机器的重要方法。在强化学习中，代理通过与环境的交互来学习，根据状态和奖励函数选择最佳决策：

强化学习的一个著名例子是基于 AI 的 Atari Breakout。在这种情况下，环境包括以下内容：

  • 球和砖块

  • 移动挡板（左或右）

  • 消除砖块的奖励

下图展示了用于教授模型如何玩 Atari Breakout 的强化模型的高级概述：

以 Atari Breakout 环境作为学习如何避开反恶意软件系统的类比，我们的环境将如下：

对于代理，它需要环境状态（一般文件信息、头信息、导入和导出函数、字符串等）来优化其性能和来自反病毒报告的奖励输入，以及结果行动（创建入口点和新部分，修改部分等）。换句话说，为了执行和学习，代理正在接受两个输入（状态和奖励）。

作为我们讨论的概念的实现，信息安全专业人员致力于 OpenAI 环境，以利用强化学习技术构建可以逃避检测的恶意软件。其中一个环境是Gym-malware。这个出色的环境是由 endgame 开发的。

OpenAI gym 包含一个开源的 Python 框架，由非营利性人工智能研究公司 OpenAI（openai.com/）开发，用于开发和评估强化学习算法。要安装 OpenAI Gym，请使用以下代码（您需要安装 Python 3.5+）：

git clone https://github.com/openai/gym
cd gym
pip install -e

OpenAI Gym 加载了预先制作的环境。您可以在gym.openai.com/envs/上检查所有可用的环境：

CartPole-v0 environment:

import gym
 env = gym.make('CartPole-v0')
 env.reset()
 for _ in range(1000): # run for 1000 steps
    env.render()
    action = env.action_space.sampe() # pick a random action
    env.step(action) # take action

要使用 Gym-malware 环境，您需要安装 Python 3.6 和一个名为LIEF的库，它可以通过输入以下内容来添加：

pip install https://github.com/lief-project/LIEF/releases/download/0.7.0/linux_lief-0.7.0_py3.6.tar.gz

从github.com/endgameinc/gym-malware下载 Gym-malware。将安装的 Gym-malware 环境移动到gym_malware/gym_malware/envs/utils/samples/。

要检查您是否在正确的目录中拥有样本，请输入以下内容：

python test_agent_chainer.py

此环境中可用的操作如下：

  • append_zero

  • append_random_ascii

  • append_random_bytes

  • remove_signature

  • upx_pack

  • upx_unpack

  • change_section_names_from_list

  • change_section_names_to random

  • modify_export

  • remove_debug

  • break_optional_header_checksum

总结

在本章中，我们继续学习如何绕过机器学习模型。在上一章中，我们发现了对抗机器学习；在这一延续中，我们探讨了对抗深度学习以及如何欺骗深度学习网络。我们查看了一些真实案例，以了解如何使用最先进的技术逃避反恶意软件系统。在接下来的最后一章中，我们将获得更多知识，学习如何构建强大的模型。

问题

  1. 生成对抗网络的组成部分是什么？

  2. 生成器和鉴别器之间有什么区别？

  3. 在生成对抗样本时，我们如何确保恶意软件对抗样本仍然有效？

  4. 进行一些研究，然后简要解释如何检测对抗样本。

  5. 强化学习与深度学习有何不同？

  6. 监督学习和强化学习之间有什么区别？

  7. 在强化学习中，代理如何学习？

进一步阅读

以下资源包含大量信息：

第十章：机器学习和特征工程的最佳实践

在前几章中，我们学习了机器学习的基础知识，并学习了如何使用一套令人惊叹的开源 Python 库构建许多不同的 Python 项目。此外，我们深入研究了如何打破机器学习模型。

本章将通过说明项目各个方面的许多技巧和最佳实践，帮助您构建更好的模型。

在本章中，我们将涵盖以下内容：

  • 机器学习中特征工程的深入概述

  • 机器学习的最佳实践

技术要求

您可以在此章节的代码文件中找到此代码：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter10。

机器学习中的特征工程

通过在本书中构建和开发所有项目和原型，您肯定已经注意到特征工程和特征选择对于每个现代数据科学产品，特别是基于机器学习的项目至关重要。根据研究，构建模型所花费的时间中，超过 50%的时间用于清理、处理和选择训练模型所需的数据。您有责任设计、表示和选择特征。

大多数机器学习算法无法处理原始数据。它们不够聪明。因此，需要特征工程，将原始状态的数据转换为算法可以理解和消化的数据。安德鲁·吴教授曾经说过：

“构建特征是困难的，耗时的，需要专业知识。‘应用机器学习’基本上就是特征工程。”

特征工程是数据准备阶段的一个过程，根据数据挖掘的跨行业标准流程：

“特征工程”本身并没有正式定义的术语。它将所有设计特征以构建智能系统的任务组合在一起。它在系统中扮演着重要的角色。如果您参加数据科学竞赛，我敢打赌您已经注意到，竞争者们都使用相同的算法，但获胜者表现最佳的是特征工程。如果您想提高数据科学和机器学习技能，我强烈建议您访问并参加www.kaggle.com：

在搜索机器学习资源时，您将面临许多不同的术语。为了避免混淆，我们需要区分特征选择和特征工程。特征工程将原始数据转换为合适的特征，而特征选择从工程化的数据中提取必要的特征。特征工程是选择所有特征的子集，而不包括冗余或无关的特征。

特征选择算法

为了使算法能够更快地训练，并减少模型的复杂性和过拟合，除了提高准确性之外，您可以使用许多特征选择算法和技术。我们将看一下三种不同的特征选择方法：过滤方法、包装方法和嵌入方法。让我们讨论各种方法和技术。

过滤方法

在过滤方法中，每个特征将被分配一个分数，由不同的统计量计算得出。换句话说，这些方法通过考虑特征与目标之间的关系来对特征进行排名。过滤方法通常用于预处理阶段：

皮尔逊相关系数

Pearson 相关是一种用于测量两个变量x和y之间线性相关的统计方法。它的范围在+1和-1之间；+1表示有正相关。你需要知道x和y应该是连续变量。Pearson 相关系数的公式如下：

！

Cov是协方差，dx和dy是x和y的标准差：

！

要使用 Python 计算这个，你可以使用scipy.stats.pearsonr(x, y)，来自scipy库。

线性判别分析

在以前的章节中，特别是在第一章，渗透测试中的机器学习简介中，我们看到了主成分分析（PCA）的统计程序。线性判别分析（LDA）也是一种降维技术。它用于找到将类别分开的特征的线性组合：

！

要在 scikit-learn 中使用 LDA，请使用以下行导入：

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA

使用方法如下：

sklearn_lda = LDA(n_components=2)
 X_lda_sklearn = sklearn_lda.fit_transform(X, y)

方差分析

方差分析（ANOVA）类似于 LDA，但它使用分类特征来检查几个类的均值是否相等，通过分析它们之间的差异。

卡方

卡方用于确定子集数据是否与总体相匹配。值应该是在类别中。换句话说，卡方检验用于检查不同类别或类别之间的相关性和关联。

卡方检验的公式如下：

！

以下是使用 scikit-learn 的卡方的示例，由 Jason Brownlee，博士提供：

import pandas
import numpy
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
# load data
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
# feature extraction
test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X, Y)
# summarize scores
numpy.set_printoptions(precision=3)
print(fit.scores_)
features = fit.transform(X)
# summarize selected features
print(features[0:5,:])

以下图表说明了前面的代码：

！

包装方法

包装方法是通过取子集和训练学习算法来执行的。根据训练的结果，我们可以选择我们模型的最佳特征。而且，你可能已经猜到，这些方法在计算上非常昂贵：

！

有许多包装技术，包括以下部分中列出的技术。

前向选择

前向选择使用搜索作为选择最佳特征的技术。这是一种迭代方法。在每次迭代中，我们添加更多特征以改进模型，直到我们没有进一步的改进为止：

！

向后消除

向后消除与前一种方法类似，但是这次我们从所有特征开始，并且在每次迭代中消除一些特征，直到模型停止改进：

！

递归特征消除

你可以看到递归特征消除作为一种贪婪的优化算法。这种技术是通过创建具有不同子集的模型并计算最佳执行特征来执行的，根据消除排名对它们进行评分。

这个脚本与前一个类似，但它使用递归特征消除作为特征选择方法：

from pandas import read_csv
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
# load data
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
# feature extraction
model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Num Features: %d") % fit.n_features_print("Selected Features: %s") % fit.support_
print("Feature Ranking: %s") % fit.ranking_

以下图表说明了前面的代码：

！

嵌入方法

特征选择嵌入方法的主要目标是学习哪些特征对机器学习模型的准确性贡献最大。它们具有内置的惩罚函数以减少过拟合：

！

一些嵌入技术列在以下部分。

Lasso 线性回归 L1

在统计学中，Lasso 是一种回归分析方法。Lasso 线性回归 L1 简单地增加了一个与系数大小的绝对值等价的惩罚。以下是 Python 和 sckit-learn 中该方法的实现：

>>> from sklearn.svm import LinearSVC
>>> from sklearn.datasets import load_iris
>>> from sklearn.feature_selection import SelectFromModel
>>> iris = load_iris()
>>> X, y = iris.data, iris.target
>>> X.shape
>>> lsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X, y)
>>> model = SelectFromModel(lsvc, prefit=True)
>>> X_new = model.transform(X)
>>> X_new.shape

！

岭回归 L2

岭回归 L2 方法增加了一个与系数大小的平方等价的惩罚。换句话说，它执行 L2 正则化。

基于树的特征选择

基于树的特征选择方法用于检查和计算特征的重要性。以下是一个示例，展示了如何使用 scikit-learn 官方文档提供的基于树的特征选择技术：

>>> from sklearn.ensemble import ExtraTreesClassifier
>>> from sklearn.datasets import load_iris
>>> from sklearn.feature_selection import SelectFromModel
>>> iris = load_iris()
>>> X, y = iris.data, iris.target
>>> X.shape
>>> clf = ExtraTreesClassifier()
>>> clf = clf.fit(X, y)
>>> clf.feature_importances_ 
>>> model = SelectFromModel(clf, prefit=True)
>>> X_new = model.transform(X)
>>> X_new.shape

正如我之前所说，特征选择是在预处理阶段使用的，因此您可以使用 scikit-learn 来构建一个流水线，就像以下示例中的那样：

Classifier = Pipeline([
  ('feature_selection', SelectFromModel(<SelectionTechniqueHere>))),
  ('classification', <ClassificationAlgorithmHere>)
 ])
 Classifier.fit(X, y)

一本名为An Introduction to Variable and Feature Selection的好书，作者是 Isabelle Guyon 和 Andre Elisseeff，其中包括了一个更好的特征选择清单。

要了解更多有关完整清单的信息，您可以浏览machinelearningmastery.com/an-introduction-to-feature-selection/。

机器学习的最佳实践

在之前的章节中，我们看到了如何进行特征工程来增强我们的机器学习系统的性能。现在，我们将讨论一些建立健壮智能系统的技巧和最佳实践。让我们探索机器学习项目不同方面的一些最佳实践。

信息安全数据集

数据是每个机器学习模型的重要组成部分。为了训练模型，我们需要提供数据集。在阅读之前的章节时，您可能已经注意到，要构建准确和高效的机器学习模型，您需要大量的数据，即使在清理数据之后也是如此。拥有大量可用数据的大公司使用其内部数据集来构建模型，但是像初创公司这样的小组织通常很难获取这么多的数据。国际规则和法规使这一任务变得更加困难，因为数据隐私是信息安全的重要方面。每个现代企业都必须保护其用户的数据。为了解决这个问题，许多机构和组织提供了公开可用的数据集，以便其他人可以下载并构建用于教育或商业用途的模型。一些信息安全数据集如下：

Jupyter 项目

Jupyter Notebook 是一个开源的 Web 应用程序，用于创建和共享编码文档。我强烈推荐它，特别是对于新手数据科学家，原因有很多。它将使您能够直接编写和可视化输出。它非常适合发现和处理数据；探索数据是构建机器学习模型的重要步骤。

Jupyter 的官方网站是jupyter.org/：

要使用pip安装它，只需输入以下内容：

python -m pip install --upgrade pip
python -m pip install jupyter

使用 GPU 加速训练

正如你所知，即使进行了良好的特征工程，机器学习训练在计算上是昂贵的。训练学习算法的最快方法是使用图形处理单元（GPU）。一般来说，虽然不是所有情况，使用 GPU 是训练模型的明智决定。为了克服 CPU 性能瓶颈，最好使用聚集/分散 GPU 架构，执行并行操作以加快计算速度。

TensorFlow 支持使用 GPU 来训练机器学习模型。因此，设备被表示为字符串；以下是一个例子：

"/device:GPU:0" : Your device GPU
"/device:GPU:1" : 2nd GPU device on your Machine

要在 TensorFlow 中使用 GPU 设备，可以添加以下行：

with tf.device('/device:GPU:0'):
    <What to Do Here>

你可以使用单个 GPU 或多个 GPU。不要忘记安装 CUDA 工具包，使用以下命令：

Wget "http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_8.0.44-1_amd64.deb"

sudo dpkg -i cuda-repo-ubuntu1604_8.0.44-1_amd64.deb

sudo apt-get update

sudo apt-get install cuda

按照以下方式安装 cuDNN：

sudo tar -xvf cudnn-8.0-linux-x64-v5.1.tgz -C /usr/local

export PATH=/usr/local/cuda/bin:$PATH

export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64"
export CUDA_HOME=/usr/local/cuda

选择模型和学习曲线

为了提高机器学习模型的性能，有许多超参数需要调整。使用的数据越多，出现的错误就越多。为了处理这些参数，有一种称为GridSearchCV的方法。它通过迭代在预定义的参数值上执行搜索。GridSearchCV默认使用score()函数。要在 scikit-learn 中使用它，可以使用以下行导入：

from sklearn.grid_search import GridSearchCV

学习曲线用于了解机器学习模型的性能。要在 scikit-learn 中使用学习曲线，可以将其导入到 Python 项目中，如下所示：

from sklearn.learning_curve import learning_curve

机器学习架构

在现实世界中，数据科学家并不认为数据像公开可用的数据集那样干净。现实世界的数据以不同的方式存储，数据本身也以不同的类别呈现。因此，机器学习从业者需要构建自己的系统和流程来实现他们的目标并训练模型。典型的机器学习项目遵循以下架构：

编码

良好的编码技能对于数据科学和机器学习非常重要。除了使用有效的线性代数、统计学和数学，数据科学家还应该学会如何正确编码。作为一名数据科学家，你可以选择许多编程语言，比如 Python、R、Java 等。

尊重编码的最佳实践非常有帮助，也强烈推荐。通过以下提示可以编写优雅、清晰和易懂的代码：

  • 注释对于可理解的代码非常重要。因此，不要忘记一直对代码进行注释。

  • 为变量、函数、方法、包和模块选择正确的名称。

  • 每个缩进级别使用四个空格。

  • 正确结构化你的存储库。

  • 遵循常见的样式指南。

如果你使用 Python，你可以遵循这个伟大的格言，称为Python 之禅，由传奇人物 Tim Peters 撰写：

"美丽胜过丑陋。

显式胜于隐式。

简单胜于复杂。

复杂胜于复杂。

扁平胜于嵌套。

稀疏胜于密集。

可读性很重要。

特殊情况并不特别到足以打破规则。

尽管实用性胜过纯粹性。

错误不应该悄悄地传递。

除非明确地被压制。

面对模棱两可的情况，拒绝猜测的诱惑。

应该有一种——最好只有一种——明显的方法来做到这一点。

虽然这种方式一开始可能不太明显，除非你是荷兰人。

现在胜于永远。

虽然从来没有比现在更好。

如果实现难以解释，那就是一个坏主意。

如果实现容易解释，那可能是一个好主意。

命名空间是一个伟大的想法——让我们做更多这样的事情！

数据处理

良好的数据处理有助于成功构建机器学习项目。加载数据集后，请确保所有数据都已正确加载，并且读取过程正在正确执行。在对数据集执行任何操作后，请检查生成的数据集。

商业背景

智能系统与业务方面高度相关，毕竟您正在使用数据科学和机器学习来解决业务问题或构建商业产品，或者从获取的数据中获得有用的见解，以做出明智的决策。在构建机器学习模型时，识别正确的问题并提出正确的问题是重要的，以解决业务问题。

总结

这本书是一个实用指南，教你如何使用开源库、Python 和一套开源项目来构建机器学习项目，以抵御网络威胁和恶意活动。我们不止于此；我们还向您展示了如何使用对抗机器学习来攻击这些模型。通过这样做，您获得了一套分析数据、构建防御系统和突破下一代安全防护的技能。我们在书中讨论了许多观点，以帮助您构建更好的模型。

问题

  1. 特征工程和特征选择有什么区别？

  2. 主成分分析（PCA）和特征选择有什么区别？

  3. 我们如何对日期和小时等特征进行编码？

  4. 为什么打印出训练和测试准确性很有用？

  5. 我们如何部署机器学习模型并在产品中使用它？

  6. 为什么特征工程比其他步骤花费更多时间？

  7. 虚拟变量的作用是什么？

进一步阅读

论文和幻灯片：

博客文章：

书籍：

第十一章：评估

第一章：- 机器学习入门

  1. 尽管机器学习是一个有趣的概念，但在有用的有限业务应用中。

假

  1. 机器学习应用程序太复杂，无法在云中运行。

假

  1. 对于两次 k 均值聚类运行，预期得到相同的聚类

结果？

不

  1. 具有离散值目标属性的预测模型可以称为：

分类模型

  1. 以下哪种技术执行与退出类似的操作

神经网络？

装袋

  1. 神经网络的哪种架构最适合解决图像识别问题？

卷积神经网络

  1. 深度学习与传统机器学习有何不同？

深度学习算法可以处理更多数据，并且在较少的数据科学家监督下运行。

  1. 以下哪种技术在机器学习项目中经常使用？

以上所有

第二章：- 钓鱼域名检测

  1. 以下是一些文本清理任务：

  • 清除文本中的停用词、数字和标点符号。

  • 执行词形还原。

  1. 创建一个包括它们频率的单词字典。

  2. 从字典中删除非单词。

  3. 从数据中提取特征。

查看Chapter2-Practice文件夹以获取答案：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter%202/Chaptre2-Practice。

  1. 准备特征向量及其标签。
train_labels = np.zeros(702)
train_labels[351:701] = 1
train_matrix = extract_features(train_dir)
  1. 使用线性支持向量机分类器训练模型。
model = LinearSVC()
model.fit(train_matrix,train_labels)
  1. 打印模型的混淆矩阵。
result = model.predict(test_matrix)
print (confusion_matrix(test_labels,result))

第三章：- 使用 API 调用和 PE 标头检测恶意软件

  1. 使用 pandas python 库加载数据集，这次添加

low_memory=False参数。搜索该参数的作用。

df = pd.read_csv(file_name, low_memory=False)
  1. 准备用于训练的数据。
original_headers = list(df.columns.values)
total_data = df[original_headers[:-1]]
total_data = total_data.as_matrix()
target_strings = df[original_headers[-1]]
  1. 使用test_size=0.33参数拆分数据。
train, test, target_train, target_test = train_test_split(total_data, target_strings, test_size=0.33, random_state=int(time.time()))
  1. 创建一个包含DecisionTreeClassifier()、RandomForestClassifier(n_estimators=100)和AdaBoostClassifier()的分类器集合：
classifiers = [
RandomForestClassifier(n_estimators=100),
DecisionTreeClassifier(),
AdaBoostClassifier()]
  1. 什么是AdaBoostClassifier()？

AdaBoost 分类器是一个元估计器，它首先在原始数据集上拟合一个分类器，然后在相同数据集上拟合额外的分类器副本。

  1. 使用三个分类器训练模型，并打印每个分类器的指标。

请查看Chapter3-Practice文件夹以获取解决方案：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter%203/Chapter3-Practice.

第四章：- 使用深度学习检测恶意软件

  1. MLP 网络和深度学习网络之间有什么区别？

深度网络已经是多层感知器网络，但至少有三个隐藏层。

  1. 为什么最近 DL 开始起飞？

因为我们可以访问更多的计算能力和数据。

  1. 为什么我们需要通过不同模型进行多次迭代？

因为没有人可以在没有迭代的情况下总是找到最佳模型或超参数。

  1. 需要哪种类型的深度学习来将英语翻译成法语？

循环神经网络（RNN）

  1. 为什么恶意软件可视化是分类恶意软件的好方法？

因为我们可以使用最先进的图像识别来构建恶意软件分类器。

  1. 激活函数的作用是什么？

它定义了给定节点的输出。换句话说，它将 A-NN 的节点的输入信号转换为输出信号。

  1. 你能提到三种 DL 架构吗？

  • 卷积神经网络（CNNs）

  • 循环神经网络（RNNs）

  • 长/短期记忆网络（LSTMs）

第五章：- 机器学习中的僵尸网络检测

与每章结束后一样，我们将给您机会练习所学内容并评估您的技能。本章的 GitHub 存储库包含练习文件夹中的僵尸网络流量数据集的链接：github.com/PacktPublishing/Mastering-Machine-Learning-for-Penetration-Testing/tree/master/Chapter5：

  1. 下载数据集，并使用 pandas 库加载它

  2. 选择合适的特征

  3. 识别训练和测试集，然后将它们导出到.pickle文件中

  4. 加载.pickle文件

  5. 使用第五章的相同代码块，使用机器学习进行僵尸网络检测。

导入支持向量机分类器：

from sklearn.svm import *

训练 SVM 模型：

clf= SVC(kernel='rbf')
clf.fit(Xdata, Ydata)

打印出构建模型的准确性：

Score = clf.score(XdataT,YdataT)
print (“The Score of the SVM Classifier is”, Score * 100)

第六章：- 异常检测系统中的机器学习

  1. 什么是异常？

异常是指偏离标准、正常或预期的事物。

  1. 什么是马尔可夫链？

马尔可夫链，或者我们所说的马尔可夫过程，是用于任何根据固定概率改变其状态的随机系统的随机模型。

  1. 隐马尔可夫模型是什么？

隐藏马尔可夫模型是一个马尔可夫过程，我们无法直接观察系统的状态。每个状态都有一个固定的发射概率。HMM 模型或分类器的主要目标是为一系列序列分配标签，这意味着将一系列观察链接到一系列标签。

  1. 我们如何使用隐藏马尔可夫模型检测异常？

根据隐藏马尔可夫模型的定义，我们可以使用它来区分网络流量的正常行为和异常行为。

  1. 时间序列异常检测和其他类型的异常检测有什么区别？

时间序列是在连续时间获得的值，通常它们之间的间隔是相等的。在时间序列异常检测中，我们正在检测在特定时间记录的数据点序列中的异常。在大多数其他检测方法中，我们使用诸如基于图的技术。

  1. 监督和无监督机器学习异常检测有什么区别？

这两种模型的区别在于所使用的机器学习算法。例如，在监督机器学习异常检测中，我们可以使用分类；而在无监督机器学习异常检测中，我们可以使用聚类。

第七章：- 检测高级持续威胁

  1. 以下哪个不是网络攻击的钻石模型中的步骤？

(a) 扫描

  1. 以下哪个选项不是入侵的钻石模型的节点？

分析？

(c) 程序

  1. Logstash 配置文件需要多少部分？

(b) 3

  1. 在 ElasticSearch 中，什么是索引？

(a) 将数据存储在索引中的过程

  1. 在 Elasticsearch 中，什么是节点？

(a) Elasticsearch 的一个实例

  1. 在 Elasticsearch 中，什么是分片？

(c) 共享资源（RAM，vCPU）

  1. Elasticsearch 有模式吗？

(a) 是的

第八章：- 使用对抗机器学习规避入侵检测系统

  1. 您能简要解释一下为什么过度训练机器学习模型不是一个好主意吗？

好主意？

通过过度训练机器学习模型，我们过度训练模型，使其在新数据上的性能受到负面影响。这也被称为过拟合。

  1. 过拟合和欠拟合有什么区别？

过拟合是指过度训练模型，而欠拟合是指模型既不能对训练数据建模，也不能推广到新数据。

  1. 规避和毒化攻击有什么区别？

在规避对抗攻击中，攻击者尝试许多不同的样本来识别绕过学习模式；而在毒化攻击中，攻击者在训练阶段中毒化模型。

  1. 对抗聚类是如何工作的？

当攻击者操纵输入数据（添加小部分攻击样本）时，对抗性聚类发生，以便新添加的样本可以隐藏在现有的聚类中。

  1. 用于避免入侵检测系统的对抗攻击类型是什么？

演示中使用的攻击称为基于雅可比显著性图的攻击。

  1. 前述攻击是规避还是毒化攻击？

这是一种毒化对抗攻击。

第九章：- 绕过机器学习恶意软件检测器

  1. 生成对抗网络的组件是什么？

生成对抗网络的两个主要组件是生成器和鉴别器。

  1. 生成器和鉴别器之间有什么区别？

生成器以潜在样本作为输入。它们是随机生成的数字，并且经过训练以生成图像，而鉴别器只是一个使用监督学习技术训练的分类器，用于检查图像是真实的（1）还是伪造的（0）。

  1. 我们如何确保恶意软件对抗样本在…时仍然有效？

我们正在生成它们吗？

为了避免无效样本，我们可以使用沙盒/Oracle。

  1. 进行一些研究，然后简要解释如何检测对抗样本

要检测对抗样本，我们可以使用二值阈值处理来去除噪音。

  1. 强化学习与深度学习有何不同？

强化学习通过探索从某些状态可用的动作来学习如何最大化奖励函数，而深度学习则是从它所展示的示例中学习。

  1. 监督学习和强化学习之间有什么区别？

在监督学习中，给定输入数据 X 和标签 Y，我们正在学习一个将 X 映射到 Y 的函数 f：X→Y。在强化学习中，代理在经历了一定数量的经验后变得更加智能。

  1. 在强化学习中，代理如何学习？

在强化学习中，代理通过与基于奖励函数的环境交互来学习，以优化其性能。

第十章：- 机器学习和特征工程的最佳实践

  1. 特征工程和特征选择之间有什么区别？

特征选择是特征工程的一部分。

  1. 主成分分析（PCA）和特征选择之间有什么区别？

特征选择获取数据集并为我们提供最佳的特征集，而主成分分析是一种降维方法。

  1. 我们如何对日期和小时等特征进行编码？

其中一种技术是添加时间变量的（正弦，余弦）变换。

  1. 为什么打印出训练和测试准确度很有用？

通过比较这两个指标来检测过拟合是很有用的。

  1. 我们如何部署机器学习模型并在产品中使用它？

有许多将机器学习模型投入生产的方法，例如基于您的模型（在线、离线？深度学习、支持向量机、朴素贝叶斯？）的网络服务和容器化。

  1. 为什么特征工程比其他步骤花费更多时间？

因为分析、清理和处理特征比构建模型需要更多时间。

  1. 虚拟变量的作用是什么？

虚拟变量是在回归分析中使用的数值变量，用于表示研究中样本的子组。在研究设计中，虚拟变量通常用于区分不同的处理组。

posted @ 2024-05-04 14:58  绝不原创的飞龙  阅读(46)  评论(0)  编辑  收藏  举报