👎


### BLE Protocol in IoT Devices and Smart Wearable Devices: Security and Privacy Threats

---



#### Abstract

由于其超低能耗、良好的网络范围和数据传输速度,蓝牙低功耗(BLE)已成为物联网(IoT)和智能可穿戴设备的主要传输媒介。随着物联网(IoT)和蓝牙低功耗(BLE)连接协议的指数级增长,需要发现实际的安全分析来保护它的防御技术。不幸的是,IoT-BLE面临着欺骗攻击的风险,其中攻击者可以扮演一个设备并向其用户提供有害信息。此外,由于该协议的简化策略,存在许多安全和隐私漏洞。用STRIDE方法学对此量化安全分析进行证明改变来创建一个框架来处理IoT-BLE传感器的保护问题。因此,为这份分析中的各种曝光提供可能的攻击场景,并提供缓解策略。鉴于此,作者对支持BLE的智能可穿戴设备执行了STRIDE威胁建模,以了解攻击面。该研究评估了不同的利用场景:拒绝服务(DoS)、特权提升、信息披露、欺骗、篡改和否认对MI Band、One plus Band、Boat Storm智能手表和Fire Bolt Invincible的影响。



#### I. INTRODUCTION

所有物联网设备至少具有一个传感器单元,通过诸如BLE、Wi-Fi和ZigBee之类的通信协议,使计算机系统与自然环境之间实现更直接的集成[1]、[2]。 BLE是一种物联网通信协议,侧重于低功耗需求、较少的信道跳变以及对早期版本的改进安全性。BLE通常被称为蓝牙智能(BS),是最广泛使用的物联网通信技术[3]。它是无线个人区域网(WPAN)时代的BLE,最初于2010年6月包含在BCS(蓝牙核心规范)中,并且与普通蓝牙相比具有几个优越的功能。物联网越来越多地应用于企业系统、医疗保健系统、军事用品、信标、新型家用物品和各种软件包中。到2022年,将有150亿台连接的物联网设备[4]。几乎所有现代操作系统都支持蓝牙和BLE,包括Windows 10、Linux、Android和Mac OS [5]。

BLE配对过程分为三个步骤，如图2所示。首先，两个设备互相通知使用哪种配对技术，并在初始阶段说明BLE设备可以做什么和期望什么。第二阶段生成和处理一个短期密钥（STK）。为了生成STK，两个设备必须就一个临时密钥（TK）达成一致，该密钥与随机整数结合。STK不在设备之间传输。由于BLE现在在数十亿设备中使用，因此审视安全漏洞非常重要。

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812181642.png)

可穿戴设备，如小米手环4、Boat Storm智能手表、OnePlus手环和Firebolt Invincible智能手表，这些个人和工业设备使我们的生活更加便利，但它们也具有很高的威胁。由于BLE在医疗应用中的广泛使用，其漏洞可能具有致命的后果。我们发现，像小米手环4、Boat Storm智能手表、OnePlus手环和Firebolt Invincible智能手表这样的可穿戴设备存在不安全的配对、不适当的身份验证和糟糕的协议实现，使它们容易受到窃听、PIN破解和其他攻击的威胁[6]。安全风险包括泄露个人信息[7]。他们写道，个人安全风险、可识别信息以及对互联物联网关键基础设施的攻击令人担忧，例如会计和金融数据存储[8]。他写道，围绕物联网信任和传感器集成的担忧包括安全的物联网节点容易受到传感器威胁的影响[5]。关于BLE安全和隐私风险的多项独立研究已经发表，一些研究人员关注协议的安全设计，并执行特定攻击，利用协议的不足实现[9]，[10]，[11]。此外，学术界和工业界的安全研究人员在各种安全会议上提出了针对物联网BLE设备的多个攻击场景，通过使用btlejack、adafruit、ubertooth one等攻击工具对物联网BLE设备进行攻击[12]，[13]。本研究旨在评估可穿戴设备的威胁范围。

这篇论文的贡献可以总结如下：

- 借助可穿戴设备的STRIDE威胁分析，我们利用在多个知名（最近的）BLE协议版本中识别出的几个漏洞来对BLE风险进行分类。
- 介绍在BLE可穿戴设备上的各种攻击示例，以及用于进行这些攻击的工具，并讨论所得到的教训。
- 为观察到的攻击威胁表面提供缓解技术建议。



#### II. TOOLS USED FOR ATTACKING AND ANALYSING BLE

本节详细介绍了开源安全研究人员创建的硬件和软件工具，用于分析各种BLE漏洞。安全研究人员使用了MITM、被动窃听和蓝牙加密。这些工具展示了标准物联网设备上的安全漏洞，如在思维导图分析中所示。这份开源、免费的工具清单有助于安全研究人员、BLE开发人员和测试人员构建低成本的应用组件，识别和评估漏洞，并保护BLE启用的物联网设备。本节列举了各种工具，用于对BLE可穿戴设备进行攻击。



##### A. Hardware tools

1. Ubertooth: 一款用于探索蓝牙的免费工具称为Ubertooth。Ubertooth提供了能够 passively检测蓝牙和BLE设备通信的设备。2011年1月发布的Ubertooth One能够检测和解调2.4GHz频段的传输，带宽为1MHz [15]。Ubertooth可以嗅探数据并显示本地流量的可视化，按频率和传输强度（以dBm表示）进行排序。该研究大致估算了该地区的整体蓝牙流量，包括寻找超出该项目范围的物品的距离诊断 [4]，[14]。信道频率上的信号强度用于构建Ubertooth频谱分析仪，如图12所示。绿色线显示了该识别频率的最强信号，而白色线显示当前的活动。无线技术通过空中传输数据，使得拦截或篡改这些数据包变得简单。
2. ADA-FRUIT BLE Sniffer：Adafruit是一个类似于Ubertooth的蓝牙低能耗（BLE）数据包捕获设备。Adafruit由Adafruit工业创建[16]。它具有拦截发送的数据包的能力。可以使用此工具分析两个BLE设备。通过Wireshark收集数据。



##### B. Software tools

1. Btlejack: Btlejack用于监视、干扰和劫持蓝牙低功耗设备。目前支持一个或多个此类设备，并且其中一个或多个正在运行特殊固件。基于BBC Micro: Bit开发。此实用程序的最新版本（2.0）支持BLE 4.0和5.0。然而，BLE 5.0仅支持1Mbps未编码的物理层（PHY）[14]。BtleJack通过主动断开主设备的连接并在连接中移动它来控制连接，进行拦截和嗅探。
2. Wireshark: Wireshark是一款免费的数据包分析器。它是一个开源的网络协议分析器，经常用于数据包分析的软件。为了帮助数据收集，它可以通过以太网、蓝牙、USB端口和其他通信介质来收集信息。使用特定的过滤器，Wireshark的图形用户界面（GUI）用户可以在一些可穿戴设备的图4中看到捕获的数据包，其中供应商无法使用加密技术，数据以明文直接传输。
3. Btlejuice: Cauquil创建了BtleJuice，并在2016年的DefCon24会议上展示了它作为针对BLE设备的中间人攻击。Btlejuice有四个组件，包括拦截分数、拦截代理、专用的web界面、Python和Node JS绑定。关键组件是拦截核心和代理。这两个组件独立运行，并通过Web Socket协议进行通信，Btlejuice作为BLE配件和移动应用程序之间的代理。

![Sniffed Packets in Wireshark](/Users/du4t/Library/Application Support/typora-user-images/image-20230812202951123.png)



#### III. SECURITY PREREQUISITES FROM STRIDE THREAT ANALYSIS

通过查看可穿戴设备的数据流图（DFD），我们可以得出安全需求，并评估从分析小米手环4、Boat Storm智能手表、OnePlus手环和Firebolt Invincible智能手表等可穿戴设备中获得的攻击场景。由于在确定安全需求时，我们考虑从DFD图中得出的攻击场景，因为安全需求旨在阻止攻击者达到他们的目标，以下是一些提高安全性的方法。

1. 在数据包中添加时间戳：在所有数据交换和连接过程中将时间戳纳入传输中，应在数据包中包含时间戳以避免重放攻击。
2. 身份验证：即使攻击者编辑了消息，消息认证机制可以识别更改并防止其被插入。此外，为了避免连接到攻击者的设备、窃取账户和规避登录程序，应该使用用户身份验证过程。
3. 加密：加密可以阻止攻击者读取和更改原始通信。因此，应通过数据包加密过程来防止消息更改和网络数据包嗅探。此外，在将任何敏感数据保存到数据库之前，必须对其进行加密。即使攻击者物理访问存储，也无法访问数据。
4. 流量分析和入侵检测：攻击检测和流量分析很难完全停止过多的数据传输。因此，我们必须在服务器端使用流量分析和渗透测试来减轻这种情况。
5. 安全的账户管理：为了避免账户被盗，所有用户必须安全地管理他们的账户。服务提供商应该向用户提供有关账户被盗可能性的信息，并保护数据存储。

Microsoft的威胁建模工具根据我们的模型生成了基于数据流程图（如图5所示）的威胁建模报告。它自动生成了111个威胁。根据对智能手环安全性的先前研究，我们确定了44个可能实现攻击者目标的重要威胁。此外，在攻击分析部分A和B中提供了以下实际分析，其中涵盖了IoT-BLE可穿戴设备上的所有攻击场景。

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812203553.png)



#### IV. ATTACK ANALYSIS OF WEARABLE DEVICE

BLE的安全架构与经典蓝牙不同。BLE支持低功耗、计算能力受限的传感器以及与物联网设备的连接。在使用BLE时，我们必须在性能、安全性、隐私问题和低功耗之间做出选择。BLE标准中包含了不同的安全连接方式。设备绑定、链路层加密和设备安全列表。然而，很多IoT-BLE设备没有正确地实施这些安全方法。因此，由于许多这些风险是由于共同的底层架构或协议中的漏洞引起的，导致了众多的安全威胁，相同的缓解措施适用。一些攻击是相互关联的。本节重点介绍如何使用威胁模型序列来安排和执行攻击。用户信息在智能手机和智能手环之间传递，如图5的DFD中所示。还在表格中为特定的BLE可穿戴设备（小米手环4、Boat Storm智能手表、Oneplus手环和Firebolt Invincible）显示了每个威胁，如在识别的威胁分析中所示。应该在重点关注用户数据和智能手环服务的情况下，对系统进行检查，以克服BLE设备中的安全问题。

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812204124.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812204135.png)



##### A. Passive Attack

在任何攻击场景中，第一步是被动监听。攻击者秘密地监视连接设备之间的每一次通信，从而导致各种破坏性攻击。通过某种方式干扰数据传输，我们可以窃听和拦截每个传递的数据。被动窃听攻击尤其容易受到攻击，因为数据是通过无线方式传输的，攻击者只需要一个拦截器，比如Micro:bit V2，就可以拦截设备（小米手环4、OnePlus手环和Firebolt Invincible）的无线通信。由于IoT-BLE可穿戴设备的通道切换是可预测且明显的，因此这些设备对这种攻击特别容易受到影响。

大多数像小米手环4、Firebolt Invincible智能手表和Boat Storm这样的BLE系统都容易受到这种攻击的威胁，这是因为它们对BLE标准的保护不足，加密算法较差，以及几个关键的交换机制使得攻击者能够轻松解码数据。



![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812204716.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812204724.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812205333.png)



##### B. Active Attacks

进行主动监听时，攻击者会干扰通信并在这些攻击中获取信息。中间人攻击（MITM）和重放攻击（Replay）是两种主动窃听攻击的版本，用于破坏数据完整性。在中间人攻击中，攻击者积极参与通信过程 [11]。与中间人攻击相比，重放攻击不会损害发送方或接收方，相反，攻击者会捕获数据包并重新发送它。

1. 爆破BD-ADDR攻击：如前所述，蓝牙协议采用频率跳频扩频（FHSS）来避免干扰，通过在2.4GHz ISM无线电频段的独特频道之间进行跳频 [5]。用于时钟这种跳频行为的伪随机记录来自于BD-ADDR的“主设备”，要从设备中窃取数据，必须考虑跳频，这需要知道BD-ADDR的格式。蓝牙帧并不携带整个BD-ADDR，但包括较低地址部分（LAP），它是24位（三字节）的缩减。BD-ADDR实际上是LAP和组成上部地址部分（UAP）的1字节的组合。由于LAP在每个帧中都会广播，Ubertooth One可以被动捕获它们，以计算UAP和LAP部分。随着时间的推移，使用Ubertooth-Rx在扫描模式下（使用-z标志）从UAP和LAP嗅探设备获得的MAC地址（MAC ID）的发现，让设备在几分钟内紧密地进行通信。Ubertooth可以在隐藏和非可发现模式下寻找设备。在这里，Ubertooth并不是一个完整的BTLE设备；它只是一个嗅探器，收集LAP和UAP以形成地址，并向适当的BTLE设备发送查询。

   ![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812205053.png)

2. 蓝牙中间人攻击：对于传统蓝牙和BLE，对IoT系统中的MITM攻击策略已经进行了研究，MITM是一种常见的无线通信威胁 [6]。通过将自己置于BLE外围设备的中心，攻击者可能对它们进行中间人攻击。攻击者会拦截和修改多个设备提供的数据包，然后再发送给另一个设备。两个设备都不知道它们的数据被一个可疑的设备阻塞或修改了。

   为了防止中间人攻击，BLE设备制造商必须严格遵守BLE协议的绑定和加密要求。最好不要使用不更新的设备进行匹配。对于开发人员来说，建议使用安全连接，因为它们比旧连接提供更强大的加密保护。如果Master设备（手机）意识到匹配设备（小米手环4）具有I/O能力，则在配对过程中应该提供MITM标志。

   ![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812205445.png)

3. 蓝图攻击（Blueprinting）：蓝图攻击收集设备的详细信息，包括型号、制造商、唯一标识符（IMEI）和软件版本，重点关注用户隐私问题。这种攻击影响传统蓝牙和BLE。尽管这种攻击可能不会造成重大损害，但它用于组织对受害者设备的未来攻击。蓝图攻击不是一种严重的攻击，但它确实会暴露个人信息。根据BLE标准，IoT-BLE设备必须公开广播其GATT服务，以便攻击者可以获取这些数据[17]。此外，攻击者还可以获得特定制造商部署的设备数量的数据。如果设备存在已知的安全漏洞，这种攻击可能会造成相当大的损害。为了执行这种攻击，有几个开源工具可供使用。这些工具可以收集关于蓝牙协议栈的数据。另一个可以快速执行这种攻击的强大应用程序是nRF Connect for smartphones，它可以直接向IoT-BLE设备编写服务。

​	![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812205819.png)

4. 设备指纹识别：设备指纹识别是通过利用仅属于该设备的数据来识别特定设备，例如MAC地址、UUID、广播数据包和GATT服务。如上图12所示，设备指纹识别侵犯了用户的隐私。许多BLE设备的固定MAC地址可用于识别它们。通过分析IoT移动应用程序并从广告中识别静态UUID，许多基于BLE的IoT和可穿戴设备容易受到指纹识别攻击[17]。

   - UUIDs具有分层结构，需要分析值集以确定UUID层次结构以进行指纹识别。同时，它可以确定应用层面的缺陷，比如不适当的加密使用。
   - 嗅探到的广播UUID会导致IoT设备的指纹识别[13]。因此，一个单一的UUID可能会被多个应用程序使用。确实需要连接到设备。
   - 这个可预测的值集实施层次的弱点，导致了对那些看起来容易受到嗅探或未经授权访问的设备的识别。

   为了阻止这种攻击，我们需要修复应用程序级的漏洞。开发人员必须提供具有加密功能的密码保护。为了伪装UUID，可以实施加密技术，因为广播信号必须具有通道级别的度量[13]。因此，攻击者只能接收到令人讨厌的信号。

5. 蓝色搜寻（Blue Stumbling）：寻找具有已知安全问题的设备被称为蓝色搜寻。这是为了以后更重大的攻击而设置，而不是主动攻击。攻击者使用微型嗅探器（例如Microbit V2）在拥挤的区域中搜索易受攻击的设备，以保持不被察觉。攻击者以安全性弱点为目标的设备。当不需要BLE连接时，设备必须保持不可见或非可发现模式，以防止攻击者发现它。未经身份验证的设备只需提供最基本的信息。

6. DOS（拒绝服务）攻击：蓝牙设备可以使用L2CAP协议请求和接收回显，从而进行DOS攻击。通过L2CAPping可以实现DOS攻击。L2CAPping允许查看与其他蓝牙设备建立的连接和往返时间。对智能手机的攻击范围最小约为10米。对于笔记本电脑的强大传输范围可以达到100米。使用像l2ping这样的标准工具，它包含在Linux Bluex utils软件包中。l2ping程序中的几个指令允许黑客指定数据包长度。黑客可以将恶意程序传播到蓝牙设备上，使它们对其用户无用。这种攻击可能会干扰受害者设备的正常运行，甚至可能损坏其功能。标准BlueZ实用程序分发中的l2ping中的-s number选项允许用户选择l2ping的数据包长度。许多设备使用600字节的数据包大小。它会创建一个所请求大小的数据包，并将其发送到提供的MAC地址。因此，被攻击设备的响应时间变得越来越长，被攻击设备的蓝牙功能停止工作。

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812210359.png)



#### V. SUMMARY OF BLE ATTACKS

使用BLE协议的IoT设备和可穿戴设备存在多种漏洞。然而，很多问题都要归咎于糟糕的协议设计。一些BLE安全策略设备容易受到加密攻击配对技术和BLE隐私漏洞的影响。美国国家标准与技术研究所（NIST）和其他安全系统研究人员已经针对一些设备提供了相当旧版本的（BLE v4.0和v4.1）。根据作者在图15的思维导图中所示的分析，IoT-BLE面临来自三个OSI层次（例如物理层、数据链路层和应用层）的威胁。物理层攻击伴随着在无线电频谱中的攻击。蓝牙数据连接层是大多数攻击发生的地方。通过数据传输层进行数据传输，攻击者可以捕获链路层数据包，并通过链路层发送恶意数据包，因此链路层安全对于BLE开发者来说是一个重要问题。一些漏洞被描述为由设备制造商或开发人员错误实现的应用层漏洞。

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230812204124.png)



#### VI. FUTURE SCOPE

启用BLE的智能可穿戴设备和物联网（IoT）设备已经成为我们日常生活的一部分。对于数据IoT设备的管理和访问控制需要非常安全。此外，可以通过服务器而不是用户连接到IoT设备。这种方式大大增强了设备管理和用户隐私的效果。这个服务器被设计用于防止IoT设备获得个人数据的访问权限。然而，如果网络/服务器受到损害，与之连接的所有设备都会面临风险。因此，研究人员可能会开始考虑使用分布式区块链技术来保护连接的IoT设备。各行各业都可以从BLE网状网络中受益。

[Paper] BLE Protocol in IoT Devices and Smart Wearable Devices: Security and Privacy Threats

😃



### Fuzz Farm

---



#### Fuzz Farm #1

项目1 主要是复现 GEGL 开源库的漏洞挖掘过程

> 项目版本: a566b738331757cf25118af5bdc65218ae5eb3b2



##### 环境配置

```bash
$ git clone https://gitlab.gnome.org/GNOME/gegl.git
$ git checkout a566b
$ sudo pip3 install meson
$ CC=afl-gcc CXX=afl-g++ meson _build
$ ASAN_OPTIONS=detect_leaks=0 AFL_USE_ASAN=1 ninja -C _build
$ ninja -C _build install
```



##### Fuzz 配置

虽然GEGL 提供了一个二进制文件`gegl`但是如果直接对二进制文件进行 Fuzz 可能会出现效率低下的问题 所以这里采用编写harness 的方式来进行`Fuzz`

```c
gint main(gint argc, gchar **argv) {
  GeglNode    *gegl      = NULL;
  gchar       *script    = NULL;
  GError      *err       = NULL;
  gchar       *path_root = NULL;

  // [1]
  gegl_init(NULL, NULL);
  path_root = g_get_current_dir ();

  // [2]
  g_file_get_contents (argv[1], &script, NULL, &err);
  if (err != NULL) {
    return 1;
  }

  // [3]
  gegl = gegl_node_new_from_xml (script, path_root);
  if (!gegl) {
    return 1;
  }

  // [4]
  GeglNode *output = gegl_node_new_child (gegl,
                                          "operation", "gegl:save",
                                          "path", "out.png",
                                          NULL);                              
  gegl_node_connect_from (output, "input", gegl, "output");
  gegl_node_process (output);

  // [5]
  g_object_unref (output);
  g_object_unref (gegl);

  g_free (script);
  g_clear_error (&err);
  g_free (path_root);
  gegl_exit ();

  return 0;
}
```



使用`afl-clang-fast`进行编译即可

```bash
$ afl-clang-fast -o test test.c `pkg-config --cflags --libs gegl-0.4 glib-2.0`
```



语料库使用的是项目内的`tests/compositions`内的文件

```bash
$ afl-fuzz -i ./compositions -o ./out -m none -t 20000 -- ./test @@
```



一会就能跑出 crash (虽然 harness 也快不到哪里去就对了..)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811111459.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811111604.png)



这个时候可以编译出来一版包含 ASAN 的 harness 看看到底是哪里 crash 了

```bash
$ AFL_USE_ASAN=1 afl-clang-fast -o test1 test.c `pkg-config --cflags --libs gegl-0.4 glib-2.0`
```



可以看到与预估漏洞一致 是 crash 在`gegl_path_parse_string`中

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811112129.png)



##### 漏洞 1 - SEGV



可以根据 ASAN 爆出的信息直接定位漏洞所在地 根据GDB 动态调试复现 漏洞实际触发于`../gegl/property-type/gegl-path.c:817`

```c
void
gegl_path_parse_string (GeglPath    *vector,
                        const gchar *path)
{
  GeglPathPrivate *priv = GEGL_PATH_GET_PRIVATE (vector);
  const gchar *p = path;
  InstructionInfo *previnfo = NULL;
  gdouble x0, y0, x1, y1, x2, y2;

  while (*p)
    {
      gchar            type = *p;
      InstructionInfo *info = lookup_instruction_info(type);

      if (!info && ((type>= '0' && type <= '9') || type == '-')) // [1]
        {
          if (previnfo->type == 'M') // here
            {
              info = lookup_instruction_info(type = 'L');
            }
          else if (previnfo->type == 'm')
            {
              info = lookup_instruction_info(type = 'l');
            }
          else if (previnfo->type == ' ')
            g_warning ("EEEK");
        }

      ...
        if (*p)
        p++;
    }

  gegl_path_dirty (vector);
}
```



漏洞成因也很简单`gegl_path_parse_string`主要的作用是针对 xml 中传入的路径 对传入的路径进行上色 例如`<gegl:fill-path path='M100,100 L200,100 L200,200 Z' color=ff0000>` 就是针对`路径 "M100,100 L200,100 L200,200 Z" 定义的区域上红色` 

如果我们传入`<gegl:fill-path path="0">` 可以发现`*p = path = type` 那么此时`type = 0` 可以顺利通过`[1]`处的 if 语句 然后到达 crash 处 

至于为什么 crash 可以发现在函数刚开始`InstructionInfo *previnfo = NULL;`且后面没有对`previnfo`进行赋值导致访问`0x0`地址 导致`SEGV`



##### 漏洞 2 - 资源耗尽漏洞

经过继续的`Fuzz`发现一个资源耗尽漏洞 可以申请`0xfffffffffffd9d7c`大小的堆块 很显然这是一个地址 肯定是在申请堆块之前存在问题

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811114216.png)



可以看到是`g_malloc`之前的问题 直接上`GDB`然后查栈帧

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811145620.png)



很明显问题的调用存在于`datauri_parse_header -> g_strndup -> g_malloc` 重点就是这个`datauri_parse_header`

```c
static gchar **
datauri_parse_header(const gchar *uri, 
                     gchar      **raw_data_out, 
                     gint        *header_items_no_out)
{
  // Determine data format
  const gchar * header_end = g_strstr_len (uri, -1, ","); 
  const gint data_prefix_len = strlen("data:");

  const gint header_len = header_end - uri - data_prefix_len;
  gchar *header = g_strndup(uri+data_prefix_len, header_len);   // here

  gchar **header_items = g_strsplit(header, ";", 3);
  gint header_items_no = -1;
  while (header_items[++header_items_no]) {
  }
  g_free(header);

  if (header_items_no_out)
    {
      *header_items_no_out = header_items_no;
    }

  if (raw_data_out)
    {
      *raw_data_out = (gchar *)uri+data_prefix_len+header_len;
    }
  return header_items;
}
```



经过动态调试很明显问题是出在`header_end`这个值上

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811150058.png)



其中`g_strstr_len(const gchar* haystack, gssize haystack_len, const gchar* needle)`的作用是从`haystack`字符串中搜索`needle`其中最大搜索长度为`haystack_len`

很显然传入的参数`uri`并没有问题 问题主要出现在`g_strstr_len`的调用上

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811150428.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230811151739.png)



因为匹配长度是`-1` 也就是`0xffffffffffffffff` 可以简单理解成无穷大 因为 uri 是一个存在栈上的参数 如果 uri 中没有匹配到`,`那近乎就是实现了全栈的搜索 很显然这是不合理的 返回回来的地址自然也是预料之外的 那么当后面调用`str_dup`时 因为长度过大 会申请一个堆块用于存放输出的字符串 很显然这时候申请的堆块长度是不合理的 自然也就造成了资源耗尽

[Fuzz] Fuzz Farm

👍



###  CVE-2023-37176
---
 
##### 版本

```bash
commit 231df822d2ec2096d4ccf8d0b9e6a9c6bbfd3b69 (HEAD -> master, origin/master, origin/HEAD)
Author: Thomas Bernard <miniupnp@free.fr>
Date:   Sat Mar 4 11:48:58 2023 +0100
```



##### 综述

在输入特定构造的gif文件之后可以导致目标`segment fault`





##### 编译方式

```bash
$ CC="${CarpetFuzz}/fuzzer/afl-clang-fast -fsanitize=address -g" CFLAGS+=-DNGIFLIB_NO_FILE make
```



##### 触发方式

```
$ ./gif2tga -i ./poc
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627180451.png)



##### 效果

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172116.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172136.png)



##### 漏洞分析

漏洞存在于158行中 要求条件使用`NGIFLIB_MODE_INDEXED`其实就是加上`-i`参数 可以看到本身只是一个写入操作 将当前GIF图像的`palette`写入到目标的tga文件中 

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172247.png)



其中`img`来自113行的`gif->cur_img` 而`gif`来自107行的`err = LoadGif(gif)` 之前的`gif`变量只是一个初始化 对其进行分配内存空间 追入`LoadGif`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172428.png)



其中的`cur_img`相关的操作在`ngiflib.c::864`附近 没有看到`palette`相关操作 追入`DecodeGifImg`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627172946.png)



追入`DecodeGifImg`后 关于`palette`相关操作在494行附近 其分支是由`flags&128`决定的 经过动态调试发现`flags == 0` 直接进入下面的分支 也就是`i->palette = i->parent->palette` 而这个`i->parent`就是上级函数中的`g`

![image-20230627173441273](/Users/du4t/Library/Application Support/typora-user-images/image-20230627173441273.png)

> 经过查询资料 每个GIF图片中都可能包含多个图片信息(废话 不然为啥有GIF动图) 所以为了区分每一帧的图片信息 采用标志位`0x2C`标志着每个图像的开始 然后前4个WORD分别为x偏移量 y偏移量 图像宽 图像高 经过审阅DecodeGIFImg内容发现在483行之前已经读取过相应数据 而`GetByte`和`GetWord`内部有个计数器 类似`fseek`的作用 指定当前读到哪里防止越界读 本来是好心 但是内部审查不严 当可能越界读时不抛出异常而是直接返回0 造成了`flags == 0`



返回上级查看`g->palette` 相关操作在714行附近 分支决定了相关值直接是`NULL`还是从文件中取 

![image-20230627174815393](/Users/du4t/Library/Application Support/typora-user-images/image-20230627174815393.png)



`tmp`相关操作在694行 在此之前对于文件流的操作有`校验文件头和版本` `取宽` `取高` 

![image-20230627174923203](/Users/du4t/Library/Application Support/typora-user-images/image-20230627174923203.png)



那么就是文件中的此位置 经过动态调试确认正确 程序会流向`g->palette = NULL`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627175043.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230627175256.png)



##### 总结

那么至此 因为特定的`flag`导致`GIF的palette属性为NULL` 进而搭配`GetByte`的审查不严格 导致了`GIF下每帧的palette属性都为NULL` 最终在生成tga文件时造成了无效访问 且由此发现该程序对GIF文件结尾特定标志位`0x3B`校验不严格

```c
static u8 GetByte(struct ngiflib_gif * g) {
#ifndef NGIFLIB_NO_FILE
	if(g->mode & NGIFLIB_MODE_FROM_MEM) {
#endif /* NGIFLIB_NO_FILE */
		if (g->input.buffer.count > 0) {
			g->input.buffer.count--;
			return *(g->input.buffer.bytes++);
		} else {
			return 0;
		}
#ifndef NGIFLIB_NO_FILE
	} else {
#ifdef DEBUG
		int c = getc(g->input.file);
		if (c != EOF)
			return (u8)c;
		else {
			if(g->log) fprintf(g->log, "getc() returned EOF !\n");
			return 0;
		}
#else
		return (u8)(getc(g->input.file));
#endif
	}
#endif /* NGIFLIB_NO_FILE */
}
```

[CVE] ngiflib CVE-2023-37176 漏洞分析

[Paper] Blacktooth: Breaking through the Defense of Bluetooth in Silence

🤔




#### 手写数字判断

> 数据集: mnist

##### 简单全连接神经网络

最基础的如果不使用卷积神经网络 而使用全连接神经网络的话 可以简单设计一个架构

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723111034.jpeg)

```python
def simple_network2():
    EPOCHS = 50
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2

    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    model = tf.keras.models.Sequential() # 层与层之间顺序执行
    model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
    '''
    N_HIDDEN: 神经元数量
    input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
    name: 指定了该层的名称
    activation: 激活函数
    '''
    model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
    model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
    model.summary()
    model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    '''
    compile() 设定训练参数 将所有层编译到一起
    optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
    loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
    metrics: 衡量指标 这里使用的是准确率(accuracy)
    '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

可以看到随着训练次数的增加 准确率在不断上升 虽然最后通过总览来看 发生了过拟合 但是影响不大 后面我们再改善这个问题

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722161134.png)

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722161237.png)

此时在测试集上的准确率为`96%`左右

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723105149.png)



这里就可以引入Dropout机制 在训练时随机使神经元失效 这样可以让其他神经元认为"除自己之外的神经元状况都不可靠" 即尽最大能力提高鲁棒性 代码层面改变很简单 在层与层之间新加Dropout层即可

```python
def simple_network2():
    EPOCHS = 50
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    model = tf.keras.models.Sequential() # 层与层之间顺序执行
    model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
    '''
    N_HIDDEN: 神经元数量
    input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
    name: 指定了该层的名称
    activation: 激活函数
    '''
    model.add(keras.layers.Dropout(DROPOUT))
    model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
    model.add(keras.layers.Dropout(DROPOUT)) # dropout层 防止过拟合
    model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
    model.summary()
    model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    '''
    compile() 设定训练参数 将所有层编译到一起
    optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
    loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
    metrics: 衡量指标 这里使用的是准确率(accuracy)
    '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230722163645.png)



很显然我们成功抑制了过拟合现象 提高了模型的泛化能力 此时验证集准确率全程高于训练集是使用Dropout层正常现象 这里稍微修改一下源码 让其可以直接加载之前存在的模型进行训练 当然此时的模型准确率依然堪忧

```python
def simple_network2():
    EPOCHS = 200
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    N_HIDDEN = 128
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    X_train = X_train.reshape(60000, RESHAPED) # 将训练集重新reshape成为一个一维数组 便于输入到神经网络中
    X_test = X_test.reshape(10000, RESHAPED) # 将测试集进行相同操作
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)
    try:
        model = tf.keras.models.load_model('mnist_model.h5')
    except:
        model = tf.keras.models.Sequential() # 层与层之间顺序执行
        model.add(keras.layers.Dense(N_HIDDEN, input_shape=(RESHAPED,), name='dense_layer', activation='relu'))
        '''
        N_HIDDEN: 神经元数量
        input_shape: 指定了输入数据的形状 这里我们输入的肯定是上面已经reshape成一维数组的训练集数据
        name: 指定了该层的名称
        activation: 激活函数
        '''
        model.add(keras.layers.Dropout(DROPOUT))
        model.add(keras.layers.Dense(N_HIDDEN, name='dense_layer2', activation='relu')) # 后续的层会自动推断输入形状
        model.add(keras.layers.Dropout(DROPOUT)) # dropout层 防止过拟合
        model.add(keras.layers.Dense(NB_CLASSES, name='dense_layer3', activation='softmax')) # 输出层 神经元个数为数据种类
        model.summary()
        model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
        '''
        compile() 设定训练参数 将所有层编译到一起
        optimizer: 优化器类型 这里使用的是随机梯度下降(SGD)
        loss: 损失函数 这里使用的是分类交叉熵(categorical_crossentropy)
        metrics: 衡量指标 这里使用的是准确率(accuracy)
        '''

    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    '''
    fit() 开始训练
    X_train: 输入的训练集数据
    Y_train: 对应训练集的标签数据
    batch_size: 单次输入到神经网络的数据个数
    epochs: 数据集重复次数
    verbose: 日志详细程度 0-2
    validation_split: 从训练集中划分一部分为测试集
    '''
    model.save('mnist_model.h5') # 保存模型
    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723105451.png)



##### 卷积神经网络

可以简单设计一个架构 即 卷积层 -> 池化层 -> 卷积层 -> 池化层 -> Flatten层 -> 全连接层

> 卷积层: 卷积网络内最重要的层 利用卷积核对图像特征进行识别 用于学习特征
>
> 池化层: 降低特征图的空间分辨率 减少计算量
>
> Flatten层: 在卷积神经网络内 图像是二维数组的形式进行传递学习 在传入全连接层之前需要将其平展为一维数组

```python
def con_network():
    EPOCHS = 200
    BATCH_SIZE = 128
    VERBOSE = 1
    NB_CLASSES = 10
    VALIDATION_SPLIT = 0.2
    DROPOUT = 0.3
    mnist = keras.datasets.mnist
    (X_train, Y_train), (X_test, Y_test) = mnist.load_data() # 此时X_train的shape为(60000, 28, 28) 也就是每张图像为一个二维数组 表示对应位置的像素值

    RESHAPED = 784
    

    X_train, X_test = X_train / 255.0, X_test / 255.0 # 归一化处理 将一个像素值的范围缩小到0~1之间 这样做的好处是提高模型的收敛速度和稳定性
    X_train = X_train[..., tf.newaxis]
    X_test = X_test[..., tf.newaxis]

    Y_train = tf.keras.utils.to_categorical(Y_train, NB_CLASSES) # 将其转化为one_hot类型
    Y_test = tf.keras.utils.to_categorical(Y_test, NB_CLASSES)

    try:
        model = tf.keras.models.load_model('con_mnist_model.h5')
    except:
        model = tf.keras.models.Sequential() # 层与层之间顺序执行
        model.add(keras.layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
        model.add(keras.layers.MaxPool2D(pool_size=(2, 2)))
        model.add(keras.layers.Conv2D(64, kernel_size=(3, 3), activation='relu'))
        model.add(keras.layers.MaxPool2D(pool_size=(2, 2)))
        model.add(keras.layers.Flatten())
        model.add(keras.layers.Dense(64, activation='relu'))
        model.add(keras.layers.Dense(10, activation='softmax'))
        model.summary()
        model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['accuracy'])
    history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=VERBOSE, validation_split=VALIDATION_SPLIT)
    model.save('con_mnist_model.h5') # 保存模型

    train_acc = history.history['accuracy']
    val_acc = history.history['val_accuracy']
    train_loss = history.history['loss']
    val_loss = history.history['val_loss']

    # 绘制准确率曲线
    plt.plot(range(1, len(train_acc) + 1), train_acc, label='Training Accuracy')
    plt.plot(range(1, len(val_acc) + 1), val_acc, label='Validation Accuracy')
    plt.title('Training and Validation Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()

    # 绘制损失曲线
    plt.plot(range(1, len(train_loss) + 1), train_loss, label='Training Loss')
    plt.plot(range(1, len(val_loss) + 1), val_loss, label='Validation Loss')
    plt.title('Training and Validation Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()

    test_loss, test_acc = model.evaluate(X_test, Y_test)
    '''
    evaluate() 使用测试集对训练出来的模型进行评估
    X_test: 测试集数据
    Y_test: 测试集标签
    '''
    print("Accuracy: ", test_acc)
```

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723110710.png)



此时准确率提升到了`98%`

![](https://blogdownload.oss-cn-hangzhou.aliyuncs.com/20230723110722.png)