Tempw - 安全文档集散地

Android 中的 Dalvik Heap 和 Native Heap

https://cloud.tencent.com/developer/article/1004843

https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/

https://manybutfinite.com/post/anatomy-of-a-program-in-memory/

使用边信道读取特权内存 （Reading privileged memory with a side-channel）

本文机器翻译自：https://googleprojectzero.blogspot.com/2018/01/reading-privileged-memory-with-side.html

我们发现CPU数据缓存的定时可能被滥用于错误推测的执行中，从而导致(最坏情况下)任意虚拟内存读取漏洞在不同的上下文中跨越本地安全边界。
这个问题的变体已知影响许多现代处理器，包括英特尔，AMD和ARM的某些处理器。
对于一些英特尔和AMD的CPU模型，我们已经利用了实际生产系统中的硬件环境。
我们在2017-06-01[1]向英特尔、AMD和ARM报告了这一问题.。

到目前为止，这个问题有三个已知的变体：
变体1：边界检查旁路(CVE-2017-5753)。
变体2：分支目标注入(CVE-2017-5715)。
变体3：恶意数据缓存负载(CVE-2017-5754)。

在公开披露此处所述问题之前，Daniel Gruss、Moritz Lipp、Yuval Yarom、Paul Kocher、Daniel Genkin、Michael Schwarz、Mike汉堡、Stefan Mangard、Thomas Prescher和Werner Haas也报告了这些问题；他们[撰写/博客/纸面草稿]也报告了这些问题：
spectre(variant 1和2)。
meltdown(variant 3)

在我们的研究过程中，我们开发了以下概念证明(POCS)：
一个PoC，它演示了在测试的Intel Haswell Xeon CPU、AMD FX CPU、AMD Pro CPU和ARM Cortex A57[2]上，在用户空间中的变体1背后的基本原理。
此PoC只测试在同一进程内错误推测的执行中读取数据的能力，而不跨越任何特权边界。
变体1的PoC，当在具有发行版标准配置的现代Linux内核下以正常用户权限运行时，可以在Intel Haswell Xeon CPU上的内核虚拟内存中执行4GiB范围内的任意读取。

如果内核的BPF JIT被启用(非默认配置)，它也可以在AMD PRO CPU上工作。
在Intel Haswell Xeon CPU上，内核虚拟内存可以在大约4秒的启动时间后以每秒2000字节的速度读取。[4]。

用于变体2的PoC，当在使用Intel Haswell Xeon CPU上的virt管理器创建的KVM客户机中以root权限运行时，在主机上运行Debian发行版的特定版本(现在已经过时)，可以以每秒1500字节的速度读取主机内核内存，并有优化的空间。
在执行攻击之前，必须执行一些初始化操作，对于拥有64 GiB RAM的机器，大约需要10到30分钟；所需时间应该与主机RAM的数量大致成线性关系。
(如果客户可以使用2MB的Hugepage，那么初始化应该会更快，但还没有经过测试。)。

变体3的PoC，当以正常的用户权限运行时，可以在某些前提条件下读取Intel Haswell Xeon CPU上的内核内存。
我们认为这个前提条件是目标内核内存存在于L1D缓存中。

关于这个主题的有趣资源，请向下看“文献”部分。
关于这个博客中关于处理器内部的解释的一个警告：这个博客包含了很多关于基于观察到的行为的硬件内部的推测，这可能不一定符合处理器实际在做什么。
我们有一些关于可能的缓解措施的想法，并向处理器供应商提供了其中的一些想法；然而，我们认为处理器供应商比我们设计和评估缓解措施的情况要好得多，我们希望它们能够成为权威指导的来源。
我们发送给CPU供应商的PoC代码和写程序将在稍后的日期提供。

测试处理器。

Intel(R)Xeon(R)CPU E5-1650 v3@3.50GHz(本文件其余部分称为“Intel Haswell Xeon CPU”)。
AMD FX(Tm)-8320八核处理器(本文件其余部分称为“AMD FX CPU”)。
AMD PRO A8-9600 R7，10个计算核心4C+6G(在本文档的其余部分称为“AMD pro CPU”)。
GoogleNexus5x电话的ARM Cortex A57核心[6](本文件其余部分称为“ARM Cortex A57”)。

术语表。
退出：当指令的结果(例如寄存器写入和内存写入)被提交并使系统的其他部分可见时，指令就会退出。指令可以按顺序执行，但必须总是按顺序退出。

逻辑处理器核心：逻辑处理器核心是操作系统认为的处理器核心。在启用超线程的情况下，逻辑核的数量是物理核数的倍数。

缓存/非缓存数据：在这个博客中，“未缓存”数据是只存在于主内存中的数据，而不是CPU的任何高速缓存级别中的数据。加载未加载的数据通常需要超过100个CPU周期的时间。

推测执行：处理器可以在不知道是否会执行分支或其目标所在的情况下执行分支，因此在知道是否应该执行指令之前执行指令。如果这一推测被证明是不正确的，CPU可以在没有架构效果的情况下放弃结果状态，并在正确的执行路径上继续执行。在知道它们在正确的执行路径之前，指令不会退出。

错误推测窗口：CPU推测执行错误代码的时间窗口，但尚未检测到错误投机的发生。

变式1：边界检查旁路。
本节解释了所有三个变体背后的一般理论和变体1的POC背后的理论，在Debian发行版内核下运行在用户空间中时，至少可以在以下配置中对内核内存的4GiB区域执行任意读取：

Intel Haswell Xeon CPU，eBPF JIT关闭(默认状态)。
Intel Haswell Xeon CPU，eBPF JIT已开启(非默认状态)。
AMDpro CPU，eBPF JIT处于开启状态(非默认状态)。

可以使用net.core.bpf_jit_Enablesysctl切换eBPF JIT的状态。

理论解释。
英特尔优化参考手册在第2.3.2.3节(“分支预测”)中提到了关于SandyBridge(以及后来的微结构修订)的以下内容：

分支预测预测分支目标，并启用。
处理器在分支之前很久就开始执行指令。
真正的执行路径是已知的。

第2.3.5.2节(“L1 DCache”)：

负载可以：
[…]。

在前面的分支被解决之前，先进行推测。
以重叠的方式将缓存错误排除在顺序之外。

英特尔软件开发人员手册。[7]第3A卷第11.7节(“隐式缓存(奔腾4、Intel Xeon和P6系列处理器”)中规定：

隐式缓存发生在内存元素可能是可缓存的时候，尽管该元素可能从未按正常的vonNeumann序列被访问过。隐式缓存发生在P6和最近的处理器家族上，原因是主动预取、分支预测和TLB丢失处理。隐式缓存是现有Intel 386、Intel486和奔腾处理器系统行为的扩展，因为在这些处理器系列上运行的软件也无法确定地预测指令预取的行为。
考虑下面的代码示例。如果arr 1->length未被缓存，处理器可以从arr 1->data中推测加载数据。[不可信的_偏移量]。这是一个越界的读取。这不重要，因为当分支执行时，处理器将有效地回滚执行状态；任何投机性执行的指令都不会退出(例如，导致寄存器等受到影响)。

 struct array {
 unsigned long length;
 unsigned char data[];
};
struct array *arr1 = ...;
unsigned long untrusted_offset_from_caller = ...;
if (untrusted_offset_from_caller < arr1->length) {
 unsigned char value = arr1->data[untrusted_offset_from_caller];
 ...
}

但是，在下面的代码示例中，存在一个问题。如果arr 1->length，arr 2->data。和ARR 2->data[0×200]。[0×300]，但是所有其他访问的数据都是这样，并且将分支条件预测为真，处理器可以在加载arr 1->length和重定向执行之前推测地执行以下操作：

加载 value = arr1->data[untrusted_offset_from_caller]
从arr 2->data中的依赖于数据的偏移开始加载，将相应的缓存行加载到l1缓存中。

 struct array {
 unsigned long length;
 unsigned char data[];
};
struct array *arr1 = ...; /* small array */
struct array *arr2 = ...; /* array of size 0x400 */
/* >0x400 (OUT OF BOUNDS!) */
unsigned long untrusted_offset_from_caller = ...;
if (untrusted_offset_from_caller < arr1->length) {
 unsigned char value = arr1->data[untrusted_offset_from_caller];
 unsigned long index2 = ((value&1)*0x100)+0x200;
 if (index2 < arr2->length) {
   unsigned char value2 = arr2->data[index2];
 }
}

在执行返回到非推测路径后，因为处理器注意到【不可信_偏移量】大于arr 1->length，包含arr 2->data的缓存行。arr2->data[index2]停留在L1缓存中。通过测量加载arr 2->data[0×200]所需的时间。和arr2->data[0×300]，然后攻击者就可以确定在投机执行期间index2的值是0×200还是0×300，这就揭示了arr 1->data[不可信_偏移量] & 1为0或1。

要能够实际使用此行为进行攻击，攻击者需要能够在目标上下文中执行这种具有外部索引的易受攻击的代码模式。
为此，易受攻击的代码模式必须存在于现有代码中，或者必须有一个解释器或JIT引擎来生成易受攻击的代码模式。
到目前为止，我们还没有发现任何现有的、可利用的易受攻击的代码模式实例；使用变体1泄漏内核内存的PoC使用eBPF解释器或eBPF JIT引擎，这些解释器或eBPF JIT引擎内置于内核中，并可供普通用户访问。
这方面的一个次要变体可能是使用对函数指针的越界读取来获得错误推测路径中的执行控制。
我们没有进一步调查这种变异。

攻击内核。

本节将更详细地描述变体1如何使用eBPF字节码解释器和JIT引擎泄漏Linux内核内存。
虽然有许多有趣的潜在目标可用于变体1攻击，但我们选择攻击Linux内核内eBPF JIT/解释器，因为它比大多数其他JIT为攻击者提供了更多的控制。
Linux内核自3.18版以来就支持eBPF。

非特权用户空间代码可以向内核提供字节码，内核将对其进行验证，然后：
或由内核内字节码解释器解释。
或者转换成本机代码，这些代码也使用JIT引擎在内核上下文中运行(这可以翻译单个字节码指令而不执行任何进一步的优化)。

字节码的执行可以通过将eBPF字节码附加到套接字作为过滤器，然后通过套接字的另一端发送数据来触发。
是否启用JIT引擎取决于运行时配置设置，但至少在经过测试的Intel处理器上，攻击的工作方式与该设置无关。
与传统的BPF不同，eBPF有数据类型，如数据数组和函数指针数组，eBPF字节码可以在其中进行索引。
因此，可以使用eBPF字节码在内核中创建上面描述的代码模式。

eBPF的数据数组比它的函数指针数组效率低，因此攻击将在可能的情况下使用后者。
测试的两台机器都没有SMAP，PoC依赖于这一点(但原则上它不应该是先决条件)。
此外，至少在英特尔的机器上测试这一点，反弹修改后的高速缓存线之间的核心是缓慢的，显然是因为MESI协议是用于缓存一致性[8]。
改变一个物理CPU核上的eBPF数组的参考计数器使包含参考计数器的高速缓存线被反弹到该CPU核，使所有其他CPU核上的参考计数器的读取速度减慢，直到改变的参考计数器被写回存储器。
由于eBPF数组的长度和引用计数器存储在同一缓存行中，这也意味着更改一个物理CPU核心上的引用计数器会导致在其他物理CPU核上读取eBPF数组的长度变慢(故意错误共享)。

攻击使用两个eBPF程序。
二尾调用通过可配置索引处的对页对ebpf函数指针数组prog_map进行。
在简化的术语中，该程序通过猜测prog_map到用户空间地址的偏移量以及在猜测的偏移量处通过prog_map进行尾调用来确定prog_map的地址。
为了使分支预测预测偏移量低于prog_map的长度，在中间执行对内界索引的尾调用。
为了增加错误推测窗口，包含prog_map长度的缓存行被弹到另一个核心。
要测试偏移量猜测是否成功，可以测试用户空间地址是否已加载到缓存中。

由于这种直接的蛮力猜测地址的速度很慢，因此使用了以下优化：在userspace地址user_map_area中创建了215个相邻的用户空间内存映射[9]，每个映射由24页组成，覆盖231个字节的总面积。
每个映射映射相同的物理页面，所有映射都存在于可分页中。

ZIGBEE EXPLOITED The good, the bad and the ugly

https://www.blackhat.com/docs/us-15/materials/us-15-Zillner-ZigBee-Exploited-The-Good-The-Bad-And-The-Ugly-wp.pdf
机器翻译而来

摘要。
物联网(物联网)是一种新兴的趋势。物联网涉及到数字和无线技术在物理对象和系统中的集成，特别是那些历史上没有连接的技术，这些技术应该使我们的日常生活变得简单和方便。连接物联网设备的最广泛使用的无线技术之一是ZigBee标准。这种新兴技术需要跟上客户对廉价、长寿和可用设备的需求。除了用户和行业的认可外，安全也是一个主要的挑战。然而，由于担心可用性降低或限制，或者担心破坏向后兼容性，安全性常常被牺牲或忽略。

本文介绍了ZigBee的实际应用安全措施，指出了其中存在的不足，介绍了一个可用于ZigBee通信自动审计的软件框架和ZigBee安全服务的实现方法，并对其进行了利用。

导言。
物联网被认为是互联网革命的下一个阶段。将现实世界中的物理对象与虚拟世界连接起来，使任何时间、任何地点和任何东西都能进行交流。(Santucci 2010，第11页)。

设备之间的通信主要是通过无线信道进行的，这就带来了各种安全问题。其中一些弱点是新的，但大多数实际上已经存在了很长时间。一个理想的短期上市时间，以及向后兼容性和未来的校对考虑导致了已知问题的持续存在。ZigBee标准是物联网设备间无线通信的主流标准之一。尽管ZigBee标准的创建考虑到了安全性，但低的单位成本和可用性以及兼容性因素会导致安全控制的执行不力，这会带来安全风险。随着消费者准备、可编程无线电系统和具有足够计算能力的低成本设备的提供，软件无线电(Sdr)领域正在经历快速增长，使研究人员能够审计传统wifi以外的无线通信。本文重点介绍了ZigBee实现中的主要安全风险，这些设备受到影响，并描述了对启用ZigBee的设备进行的实际评估的结果。ZigBee标准ZigBee是ZigBee联盟(包括三星、飞利浦、摩托罗拉、德州仪器等公司)开发的个人区域网络标准，目的是为短程应用提供低成本、低功耗、双向、可靠的无线通信标准。(ZigBee Alliance 2008，第29页)。

该标准完全开放，并于2003获得电气和电子工程师协会(Ieee)的批准。ZigBee的协议栈基于IEEE802.15.4。选择ZigBee的优点是电池寿命长、支持网络中的大量节点(高达65000)、部署简单、成本低和全局使用。(Kaur&Sharma，2013年)(ZigBee联盟，2014年)ZigBee被用于以下领域(ZigBee联盟，2014年)：
遥控。
输入装置。
家庭自动化。
楼宇自动化。
卫生保健。
电信业务。
零售服务。
智能能源。

ZigBee堆栈由四层组成：(ZigBee Alliance 2008，第35页)。
物理层(PHY)。
介质访问控制层(MAC)。
网络层(NWK)。
应用层(APL)。

IEEE802.15.4-2003标准适用于物理层(PHY)和介质访问控制层(MAC)这两个最低层。另外两个层由ZigBee协议栈定义。从安全的角度来看，网络和应用层具有最高的相关性，因此在下一章中将更详细地描述。

ZigBee安全。

ZigBee标准包括复杂的安全措施，以确保密钥建立、安全网络、密钥传输和帧安全。(ZigBee Alliance 2008，第419页f)。这些服务在网络和应用程序支持子层(APS)上实现，APS是应用层的一个子层。ZigBee协议基于“开放信任”模型。这意味着所有协议栈层相互信任。因此，密码保护只发生在设备之间。每个层负责各自帧的安全性。ZigBee网络的安全性是基于它们的加密密钥。可以区分两种类型的安全密钥。(ZigBee Alliance 2008，第422页)。

网络密钥被用来保护广播通信。这个128位密钥在网络中的所有设备之间共享.。信任中心通常存储多个网络密钥，但只有一个网络密钥是活动网络密钥。当前活动网络密钥由序列号标识，并可由设备的NWK和APL层使用。设备必须通过密钥传输或预安装获得网络密钥.。链路密钥用于保护应用层上的单播通信。这个128位的密钥只在两个设备之间共享.。链接密钥是通过密钥传输、密钥建立或预安装(例如，在工厂安装期间)获得的，并且只能由APS子层使用。网络层安全ZigBee网络层通过使用AES加密(AES CCM模式)保证传输帧的完整性和加密，密钥长度为128位，并使用密码块链接消息认证码(CBC-MAC)确保其完整性。(ZigBee Alliance 2008，第423页)

应用程序支持子层安全性如果需要保护由APS层发起的帧，则APS层负责对帧进行适当的保护。APS层允许帧安全基于链路密钥或网络密钥。如果应该使用主动网络密钥进行帧保护，则APS层首先检查该帧是否在NWK层上受到保护。如果是这样的话，帧就被传递到NWK层，并且在NWK层上执行帧保护。APS层还负责为应用程序和ZDO提供密钥设置、密钥传输和设备管理服务。(ZigBee Alliance 2008，第424页)ZigBee标准对ZigBee装置的安全性规定如下：“ZigBee安全架构提供的安全级别取决于对称密钥的安全保存，取决于所使用的保护机制。以及密码机制和相关安全策略的正确实现。对安全架构的信任最终会减少到对密钥材料的安全初始化和安装的信任，以及对密钥处理和存储的信任。“。(ZigBee Alliance 2008，第420页)。

如前所述，ZigBee安全性是基于这样的假设：密钥是安全存储的，设备预先装载对称密钥，因此它们永远不会未经加密而传输。但这一政策也有例外。如果非预先配置的设备加入网络，则可以不受保护地发送单个密钥并启用加密通信。这种一次性传输不受保护的密钥会导致短时间的可利用性，攻击者可以在此时间框架内嗅探密钥。由于安全依赖于加密密钥的安全保存，因此，这种密钥截获将导致严重的安全威胁，并危及整个网络的安全。即使时间似乎很窄，攻击者也可以使用干扰技术来欺骗用户启动工厂重置或其他重新连接的方式，从而重新建立攻击时间框架。另一个例外是由于某些类型的设备，如电灯开关或温度传感器的低成本性质。由于它们的能力有限，不能假定硬件是防篡改的.。因此，如果攻击者能够对此类设备进行物理访问，则可能会访问秘密密钥材料和其他特权信息，以及访问安全软件和硬件。(ZigBee Alliance 2008，第420页)。

ZigBee应用程序简介。

ZigBee网络上设备之间通信的关键是应用程序配置文件的使用。应用程序配置文件是消息、消息格式和处理操作的协议，使开发人员能够使用驻留在不同设备上的应用程序实体创建可互操作的分布式应用程序。这些应用程序配置文件使应用程序能够发送命令、请求数据以及处理命令和请求。由于ZigBee设备可能是一个多用途的设备，因此会创建不同的配置文件，以允许不同供应商的设备使用这些预定义的配置文件进行适当的通信。ZigBee家庭自动化公共应用程序配置文件(HAPAP)–一个配置文件的示例–将是家庭自动化配置文件。此ZigBee配置文件允许一系列设备类型交换控制消息，以形成无线家庭自动化应用程序。这些设备被设计用来交换众所周知的信息来实现控制，例如打开或关闭灯，向照明控制器发送光传感器测量，或者如果占位传感器检测到移动，则发送警报消息。这意味着，如果制造商希望设备与其他制造商的其他认证设备兼容，则设备必须实现此配置文件的标准接口和实践。为了提供这种互操作性，所有ZigBee家庭自动化设备都应该实现所谓的启动属性集(SAS)。从安全的角度来看，以下两个属性特别重要：

默认信任中心链接密钥。
0×5A 0×69 0×67 0×42 0×65 0×65 0×41 0×6C 0×6C 0×69 0×61 0×6E 0×63 0×65 0×30 0×39。

注意：链接键以Littleendian格式列出。

默认链接键连接。
0×01(真)。
此标志允许在启动时使用默认链接键联接作为后备情况。

默认TC链接密钥“ZigBeeAlliance09”的使用给网络密钥的保密性带来了很高的风险。家庭自动化公共应用程序配置文件声明：“在连接设备未知或没有与其关联的特定授权的情况下，应使用默认TC链接密钥传输当前网络密钥。这就允许在这样的情况下，也可以使用与设备特别相关的可选预配置的链接密钥。“。(ZigBee Alliance 2013，第44页)由于如上所述，ZigBee的安全高度依赖密钥材料的保密，因此依赖加密密钥的安全初始化和传输，因此必须将这种默认回退机制视为关键风险。如果攻击者能够使用默认的TC链接密钥嗅探设备连接，活动网络密钥就会受到破坏，整个网络通信的机密性也会被视为已泄露。这可能是一个较低的风险，如果只使用灯泡，但由于暖通空调系统和门锁也使用家庭自动化配置文件，这一配置文件要求的影响大大增加。

ZigBee轻型链路剖面图(ZLL)。
ZigBeeLightLink(ZLL)配置文件在柜台外，消费者照明应用领域中定位设备和功能。(ZigBee Alliance 2012，第1页)ZLL中的设备应使用ZigBee网络层安全。在经典的ZigBee调试中，一个非ZLL设备被连接到一个没有信任中心的ZLL网络中，在认证时使用一个预先安装的链接密钥来保护网络密钥的传输。ZLL预装的链接密钥是所有认证的ZLL设备共享的秘密.。它将只分发给经认证的制造商，并受保管合同的约束。此外，如果APS消息的解密与上述密钥一起失败，ZLL设备将尝试使用已知的默认信任中心链接密钥来解码APS消息。与HAPAP一样，ZLL配置文件还指定“ZigBeeAlliance09”作为SAS中默认的信任中心链接键，并要求支持不安全的连接作为后盾。这也导致了相同的脆弱的初始密钥交换。即使制造商实现了安全密钥交换，并分发了适当的密钥材料，外部攻击者也有可能通过选择性干扰干扰网络连接，然后等待不安全的连接来访问交换的密钥材料。

由于每个连接到ZLL网络的ZLL设备都应使用ZLL主密钥来导出活动网络密钥，因此，掌握ZLL主密钥的知识使攻击者能够截获密钥交换并获取当前的活动网络密钥。这样攻击者就可以控制ZigBee网络中的所有设备。由于ZLL主密钥据推测已经在互联网上泄露(例如在reddit和一些在线论坛上)，因此ZLL设备的安全性必须被视为受到了损害。除了泄露的密钥，ZLL设备还支持一个名为“Touchlink调试”的功能，它允许设备与控制器配对。由于使用默认和公开的TC链接密钥，设备可以被“窃取”。测试表明，业余无线电硬件使用普通偶极子(RasperryPI扩展板)天线已经允许Touchlink委员会从几米之外，而出于安全原因，这应该只能在附近工作。使用专业的无线电设备将使这样一个成功的设备接管的距离更远。

一种新的ZigBee安全测试工具。
由于ZigBee提供了一些非常具体的安全服务和攻击向量，因此开发了一个工具，使安全研究人员、测试人员和开发人员能够检查他们产品的安全服务的配置和实现。与ZigBee测试的其他工具不同，它使测试人员能够检查加密的网络，并自动执行ZigBee特定的测试，例如网络离开/连接、重置到工厂默认值或搜索不安全的密钥传输。SecBee是基于替罪羊-无线电和杀手蜜蜂，但大大增强了功能，并修正了这些工具的一些限制。

现实世界的评估和查明的脆弱性。
为了验证ZigBee安全在现实世界设备中的实施情况，使用新开发的ZigBee安全测试工具SecBee对家庭自动化系统、智能照明解决方案和ZigBee启用门锁进行了评估。对每个评估设备的实际安全性分析表明，这些解决方案是为易于设置和使用而设计的，但缺乏安全配置的可能性，并且执行了允许外部各方嗅探交换网络密钥的脆弱设备配对过程。即使利用该漏洞的时间非常有限，让用户发挥作用也很容易避免这种情况。ZigBee通讯可以很容易被干扰。由于ZigBee是为低功率通信和节能而设计的，这可以很容易地通过在目标ZigBee信道上发送噪声来实现，从而防止通信的成功。典型的用户会注意到连接丢失，因此只需执行重新配对过程来解决此问题。针对用户级别，攻击者可以强制执行重解析并嗅探传输的网络密钥。这将使攻击者能够完全控制系统，因为解决方案的安全性完全依赖于此密钥的保密。此外，被测试的家庭自动化系统无法重置或更改应用的网络密钥，因此，即使用户注意到网络中不需要的行为，也绝对不可能将入侵者锁定在外。此外，在11个月的时间框架内也无法确定自动钥匙轮换。智能照明解决方案也容易受到来自任何外部方的设备接管。在不知道活动密钥的情况下，有可能窃取灯泡并将它们连接到一个假网络中。攻击者只需向灯泡发送“重置到工厂默认”命令，然后等待灯泡搜索ZigBee网络加入。灯泡将连接到第一个可用的网络，而不需要任何用户的进一步交互。无需按下按钮或类似的按钮。灯泡总是发送信标请求寻找一个新的网络加入。

此外。应该注意的是，不推荐使用无线通信系统来进行安全应用，例如监视，因为简单的干扰很容易干扰通信，而且没有经过测试的设备实现像心跳消息这样的功能来向中心设备提供有关实际情况的信息。现状。随着无线电硬件的价格越来越低，硬件是公开可用的，并且存在着提供在无线网络上执行攻击所需的必要功能的开源工具，这种攻击场景变得越来越有可能发生。第一次真实世界事件将公之于众只是时间问题。

结语。
ZigBee标准提供的安全特性可以被认为是非常强大和健壮的。ZigBee加密基于著名的AES数据加密和数据认证算法。安全性取决于加密密钥的保密性以及加密密钥的安全初始化和分发。ZigBee家庭自动化系统的主要风险是实施失败和不足。在ZigBee无线网络中实现安全特性的主要限制因素还有有限的资源。节点以电池供电为主，计算能力和内存容量有限。因此，安全必须满足执行方面的一些先决条件，这些先决条件如下：

设备篡改：ZigBee是针对低成本的应用程序，节点硬件可能无法抵抗篡改。如果入侵者从没有防篡改措施的操作网络中获取节点，则可以简单地从设备内存中获取实际密钥。如果检测到篡改，则抗篡改节点可以删除包括安全密钥在内的敏感信息。

密钥传输：不应使用默认的TC链接密钥，因为此密钥被视为公共知识，并提供与未加密密钥传输相同级别的安全性。

密钥设置：密钥建立期间使用的主密钥应通过带外通道分发.。例如，可以将带有预配置主键的贴纸附加到设备上，并在设备安装期间由用户输入。

密钥旋转：通信的安全性取决于网络密钥和链路密钥的保密性。网络密钥应定期更换。
密钥管理应以在有意义的时间内或在一定数量的消息之后更改网络密钥的形式进行。否则，已知的明文或对AES安全的其他攻击可能是可能的。

用灯泡甚至门锁进行的测试表明，测试设备的供应商实现了所需认证的最小功能，包括默认的TC后备键。没有实现其他选项，也没有提供给最终用户。

另外，正如ZLL配置文件所要求的那样，也依赖于仅分布在有限的人群中的密钥的保密性，这是一种已知已失败的安全方法。特拉维斯·古斯斯皮尔展示了对ZigBee硬件的成功攻击，以提取密钥(固特异2009，第1F页)，因此如果没有适当的硬件，密钥保密不应成为ZigBee产品安全架构的基础。

desc. in objects.h

//
// Most object types in the V8 JavaScript are described in this file.
//
// Inheritance hierarchy:
// - Object
//   - Smi          (immediate small integer)
//   - HeapObject   (superclass for everything allocated in the heap)
//     - JSReceiver  (suitable for property access)
//       - JSObject
//         - JSArray
//         - JSArrayBuffer
//         - JSArrayBufferView
//           - JSTypedArray
//           - JSDataView
//         - JSBoundFunction
//         - JSCollection
//           - JSSet
//           - JSMap
//         - JSStringIterator
//         - JSSetIterator
//         - JSMapIterator
//         - JSWeakCollection
//           - JSWeakMap
//           - JSWeakSet
//         - JSRegExp
//         - JSFunction
//         - JSGeneratorObject
//         - JSGlobalObject
//         - JSGlobalProxy
//         - JSValue
//           - JSDate
//         - JSMessageObject
//         - JSModuleNamespace
//       - JSProxy
//     - FixedArrayBase
//       - ByteArray
//       - BytecodeArray
//       - FixedArray
//         - DescriptorArray
//         - FrameArray
//         - HashTable
//           - Dictionary
//           - StringTable
//           - StringSet
//           - CompilationCacheTable
//           - CodeCacheHashTable
//           - MapCache
//         - OrderedHashTable
//           - OrderedHashSet
//           - OrderedHashMap
//         - Context
//         - FeedbackMetadata
//         - FeedbackVector
//         - TemplateList
//         - TransitionArray
//         - ScopeInfo
//         - ModuleInfo
//         - ScriptContextTable
//         - WeakFixedArray
//       - FixedDoubleArray
//     - Name
//       - String
//         - SeqString
//           - SeqOneByteString
//           - SeqTwoByteString
//         - SlicedString
//         - ConsString
//         - ThinString
//         - ExternalString
//           - ExternalOneByteString
//           - ExternalTwoByteString
//         - InternalizedString
//           - SeqInternalizedString
//             - SeqOneByteInternalizedString
//             - SeqTwoByteInternalizedString
//           - ConsInternalizedString
//           - ExternalInternalizedString
//             - ExternalOneByteInternalizedString
//             - ExternalTwoByteInternalizedString
//       - Symbol
//     - HeapNumber
//     - Cell
//     - PropertyCell
//     - Code
//     - AbstractCode, a wrapper around Code or BytecodeArray
//     - Map
//     - Oddball
//     - Foreign
//     - SharedFunctionInfo
//     - Struct
//       - AccessorInfo
//       - PromiseResolveThenableJobInfo
//       - PromiseReactionJobInfo
//       - AccessorPair
//       - AccessCheckInfo
//       - InterceptorInfo
//       - CallHandlerInfo
//       - TemplateInfo
//         - FunctionTemplateInfo
//         - ObjectTemplateInfo
//       - Script
//       - DebugInfo
//       - BreakPointInfo
//       - CodeCache
//       - PrototypeInfo
//       - Module
//       - ModuleInfoEntry
//     - WeakCell
//
// Formats of Object*:
//  Smi:        [31 bit signed int] 0
//  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01

v8 bailout related

bailout reasons
https://github.com/vhf/v8-bailout-reasons

Optimization-killers
https://github.com/petkaantonov/bluebird/wiki/Optimization-killers

21种v8的元素类型

enum ElementsKind {
  // The "fast" kind for elements that only contain SMI values. Must be first
  // to make it possible to efficiently check maps for this kind.
  FAST_SMI_ELEMENTS,
  FAST_HOLEY_SMI_ELEMENTS,

  // The "fast" kind for tagged values. Must be second to make it possible to
  // efficiently check maps for this and the FAST_SMI_ONLY_ELEMENTS kind
  // together at once.
  FAST_ELEMENTS,
  FAST_HOLEY_ELEMENTS,

  // The "fast" kind for unwrapped, non-tagged double values.
  FAST_DOUBLE_ELEMENTS,
  FAST_HOLEY_DOUBLE_ELEMENTS,

  // The "slow" kind.
  DICTIONARY_ELEMENTS,

  // Elements kind of the "arguments" object (only in sloppy mode).
  FAST_SLOPPY_ARGUMENTS_ELEMENTS,
  SLOW_SLOPPY_ARGUMENTS_ELEMENTS,

  // For string wrapper objects ("new String('...')"), the string's characters
  // are overlaid onto a regular elements backing store.
  FAST_STRING_WRAPPER_ELEMENTS,
  SLOW_STRING_WRAPPER_ELEMENTS,

  // Fixed typed arrays.
  UINT8_ELEMENTS,
  INT8_ELEMENTS,
  UINT16_ELEMENTS,
  INT16_ELEMENTS,
  UINT32_ELEMENTS,
  INT32_ELEMENTS,
  FLOAT32_ELEMENTS,
  FLOAT64_ELEMENTS,
  UINT8_CLAMPED_ELEMENTS,

  // Sentinel ElementsKind for objects with no elements.
  NO_ELEMENTS,

  // Derived constants from ElementsKind.
  FIRST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
  LAST_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
  FIRST_FAST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
  LAST_FAST_ELEMENTS_KIND = FAST_HOLEY_DOUBLE_ELEMENTS,
  FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS,
  LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
  TERMINAL_FAST_ELEMENTS_KIND = FAST_HOLEY_ELEMENTS
};

AT command

https://www.diafaan.com/sms-tutorials/gsm-modem-tutorial/

General SMS Commands
AT+CMGF – Set SMS Text Mode or SMS PDU Mode
AT+CMGD – Delete a Received Message

PDU Mode SMS Commands
AT+CMGL – List Received Messages

Text Mode SMS Commands
AT+CMGS – Send SMS Message
AT+CMGL – List Received Messages

————————

AT + CMGF - 设置短信模式或SMS PDU模式
AT + CMGF命令将GSM调制解调器设置为SMS文本模式或SMS PDU模式。

在文本模式下，SMS消息被表示为可读文本。 在PDU模式下，所有SMS消息都表示为十六进制字符编码的二进制字符串，如31020B911326880736F40000A900。

虽然文本模式更容易使用，但PDU模式在不同的GSM调制解调器上更为一致。

命令 回应
AT+ CMGF= OK
参数
：0 = PDU模式，1 =文本模式
= ASCII字符13

例

将GSM调制解调器设置为文本模式短信，并向GSM号码+31628870634发送消息。

AT+CMGF=1
OK
AT+CMGS="+31628870634"
> This is the text message.→
+CMGS: 198
OK

————————
AT + CMGD - 删除接收到的消息
AT + CMGD命令从GSM调制解调器中删除接收到的SMS消息。 您可以使用AT + CMGL命令检索消息的索引号。

命令 回应
AT + CMGD=<索引>行
参数
：消息的索引号
：ASCII字符13

例
将GSM调制解调器设置为文本模式SMS，列出所有接收到的消息，并从GSM调制解调器中删除消息。

AT+CMGF=1
OK
AT+CMGL="ALL"
+CMGL: 1,"REC UNREAD","+31628870634",,"11/01/09,10:26:26+04"
This is text message 1
+CMGL: 2,"REC UNREAD","+31628870634",,"11/01/09,10:26:49+04"
This is text message 2
OK
AT+CMGD=1
OK
AT+CMGD=2
OK

————————
AT + CMGL - 在PDU模式下列出接收到的消息
AT + CMGL命令列出在GSM调制解调器上接收到的消息。 它可以用于获取所有收到的消息，所有未读消息或所有读消息。

命令 回应
AT + CMGL = + CMGL：，，[alpha]，
…
OK
参数
：Status = 0 - 未读，1 - 读取，4 - 全部
：消息的索引号
发件人名称（如果在电话簿中可用）
：PDU的长度

AT+CMGF=0
OK
AT+CMGL=4
+CMGL: 1,0,,39
07911326040011F5240B911326880736F40000111081017362401654747A0E4ACF41F4329E0E6A97E7F3F0B90C8A01
+CMGL: 2,0,,39
07911326040011F5240B911326880736F40000111081017323401654747A0E4ACF41F4329E0E6A97E7F3F0B90C9201
OK
AT+CMGD=1
OK
AT+CMGD=2
OK

AT+CMGF=1
OK
AT+CMGS="+31628870634"
> This is the text message.→
+CMGS: 198
OK

AT+CMGF=1
OK
AT+CMGL="ALL"
+CMGL: 1,"REC UNREAD","+31628870634",,"11/01/09,10:26:26+04"
This is text message 1
+CMGL: 2,"REC UNREAD","+31628870634",,"11/01/09,10:26:49+04"
This is text message 2
OK
AT+CMGD=1
OK
AT+CMGD=2
OK

note

https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/example-12—using-page-heap-verification-to-find-a-bug

SIMD128_TYPES

// V has parameters (TYPE, Type, type, lane count, lane type)
#define SIMD128_TYPES(V)
V(FLOAT32X4, Float32×4, float32×4, 4, float)
V(INT32X4, Int32×4, int32×4, 4, int32_t)
V(UINT32X4, Uint32×4, uint32×4, 4, uint32_t)
V(BOOL32X4, Bool32×4, bool32×4, 4, bool)
V(INT16X8, Int16×8, int16×8, 8, int16_t)
V(UINT16X8, Uint16×8, uint16×8, 8, uint16_t)
V(BOOL16X8, Bool16×8, bool16×8, 8, bool)
V(INT8X16, Int8×16, int8×16, 16, int8_t)
V(UINT8X16, Uint8×16, uint8×16, 16, uint8_t)
V(BOOL8X16, Bool8×16, bool8×16, 16, bool)

INTERNALIZED_STRING_LIST

#define INTERNALIZED_STRING_LIST(V)
V(anonymous_string, “anonymous”)
V(apply_string, “apply”)
V(assign_string, “assign”)
V(arguments_string, “arguments”)
V(Arguments_string, “Arguments”)
V(Array_string, “Array”)
V(arguments_to_string, “[object Arguments]”)
V(array_to_string, “[object Array]”)
V(boolean_to_string, “[object Boolean]”)
V(date_to_string, “[object Date]”)
V(error_to_string, “[object Error]”)
V(function_to_string, “[object Function]”)
V(number_to_string, “[object Number]”)
V(object_to_string, “[object Object]”)
V(regexp_to_string, “[object RegExp]”)
V(string_to_string, “[object String]”)
V(bind_string, “bind”)
V(bool16×8_string, “bool16×8”)
V(Bool16×8_string, “Bool16×8”)
V(bool32×4_string, “bool32×4”)
V(Bool32×4_string, “Bool32×4”)
V(bool8×16_string, “bool8×16”)
V(Bool8×16_string, “Bool8×16”)
V(boolean_string, “boolean”)
V(Boolean_string, “Boolean”)
V(bound__string, “bound “)
V(buffer_string, “buffer”)
V(byte_length_string, “byteLength”)
V(byte_offset_string, “byteOffset”)
V(call_string, “call”)
V(callee_string, “callee”)
V(caller_string, “caller”)
V(cell_value_string, “%cell_value”)
V(char_at_string, “CharAt”)
V(closure_string, “(closure)”)
V(column_string, “column”)
V(compare_ic_string, “==”)
V(configurable_string, “configurable”)
V(constructor_string, “constructor”)
V(construct_string, “construct”)
V(create_string, “create”)
V(Date_string, “Date”)
V(default_string, “default”)
V(defineProperty_string, “defineProperty”)
V(deleteProperty_string, “deleteProperty”)
V(display_name_string, “displayName”)
V(done_string, “done”)
V(dot_result_string, “.result”)
V(dot_string, “.”)
V(entries_string, “entries”)
V(enumerable_string, “enumerable”)
V(Error_string, “Error”)
V(eval_string, “eval”)
V(EvalError_string, “EvalError”)
V(false_string, “false”)
V(float32×4_string, “float32×4”)
V(Float32×4_string, “Float32×4”)
V(for_api_string, “for_api”)
V(for_string, “for”)
V(function_string, “function”)
V(Function_string, “Function”)
V(Generator_string, “Generator”)
V(getOwnPropertyDescriptor_string, “getOwnPropertyDescriptor”)
V(getOwnPropertyDescriptors_string, “getOwnPropertyDescriptors”)
V(getPrototypeOf_string, “getPrototypeOf”)
V(get_string, “get”)
V(global_string, “global”)
V(has_string, “has”)
V(illegal_access_string, “illegal access”)
V(illegal_argument_string, “illegal argument”)
V(index_string, “index”)
V(infinity_string, “Infinity”)
V(input_string, “input”)
V(int16×8_string, “int16×8”)
V(Int16×8_string, “Int16×8”)
V(int32×4_string, “int32×4”)
V(Int32×4_string, “Int32×4”)
V(int8×16_string, “int8×16”)
V(Int8×16_string, “Int8×16”)
V(isExtensible_string, “isExtensible”)
V(isView_string, “isView”)
V(KeyedLoadMonomorphic_string, “KeyedLoadMonomorphic”)
V(KeyedStoreMonomorphic_string, “KeyedStoreMonomorphic”)
V(last_index_string, “lastIndex”)
V(length_string, “length”)
V(line_string, “line”)
V(Map_string, “Map”)
V(message_string, “message”)
V(minus_infinity_string, “-Infinity”)
V(minus_zero_string, “-0”)
V(name_string, “name”)
V(nan_string, “NaN”)
V(next_string, “next”)
V(not_equal, “not-equal”)
V(null_string, “null”)
V(null_to_string, “[object Null]”)
V(number_string, “number”)
V(Number_string, “Number”)
V(object_string, “object”)
V(Object_string, “Object”)
V(ok, “ok”)
V(ownKeys_string, “ownKeys”)
V(position_string, “position”)
V(preventExtensions_string, “preventExtensions”)
V(private_api_string, “private_api”)
V(Promise_string, “Promise”)
V(proto_string, “__proto__”)
V(prototype_string, “prototype”)
V(Proxy_string, “Proxy”)
V(query_colon_string, “(?:)”)
V(RangeError_string, “RangeError”)
V(ReferenceError_string, “ReferenceError”)
V(RegExp_string, “RegExp”)
V(script_string, “script”)
V(setPrototypeOf_string, “setPrototypeOf”)
V(set_string, “set”)
V(Set_string, “Set”)
V(source_mapping_url_string, “source_mapping_url”)
V(source_string, “source”)
V(sourceText_string, “sourceText”)
V(source_url_string, “source_url”)
V(stack_string, “stack”)
V(stackTraceLimit_string, “stackTraceLimit”)
V(strict_compare_ic_string, “===”)
V(string_string, “string”)
V(String_string, “String”)
V(symbol_string, “symbol”)
V(Symbol_string, “Symbol”)
V(SyntaxError_string, “SyntaxError”)
V(this_string, “this”)
V(throw_string, “throw”)
V(timed_out, “timed-out”)
V(toJSON_string, “toJSON”)
V(toString_string, “toString”)
V(true_string, “true”)
V(TypeError_string, “TypeError”)
V(uint16×8_string, “uint16×8”)
V(Uint16×8_string, “Uint16×8”)
V(uint32×4_string, “uint32×4”)
V(Uint32×4_string, “Uint32×4”)
V(uint8×16_string, “uint8×16”)
V(Uint8×16_string, “Uint8×16”)
V(undefined_string, “undefined”)
V(undefined_to_string, “[object Undefined]”)
V(URIError_string, “URIError”)
V(valueOf_string, “valueOf”)
V(values_string, “values”)
V(value_string, “value”)
V(WeakMap_string, “WeakMap”)
V(WeakSet_string, “WeakSet”)
V(writable_string, “writable”)