From 04e2b69d9d79cb2b6ba6e8bc35f69a574fccf616 Mon Sep 17 00:00:00 2001
From: ss <shishi.dong@deltaww.com>
Date: Tue, 9 Apr 2024 15:15:21 +0800
Subject: [PATCH] Site updated: 2024-04-09 15:15:18

---
 .../index.html"                                        |  4 ++--
 .../index.html"                                        |  4 ++--
 .../index.html"                                        |  4 ++--
 .../index.html"                                        |  4 ++--
 .../index.html"                                        |  4 ++--
 .../02/27/Symbion\345\210\235\346\216\242/index.html"  | 10 +++++-----
 6 files changed, 15 insertions(+), 15 deletions(-)

diff --git "a/2023/05/19/Linux\344\273\216\345\205\245\351\227\250\345\210\260\347\206\237\347\273\203/index.html" "b/2023/05/19/Linux\344\273\216\345\205\245\351\227\250\345\210\260\347\206\237\347\273\203/index.html"
index 529c4f6..3cd5af5 100644
--- "a/2023/05/19/Linux\344\273\216\345\205\245\351\227\250\345\210\260\347\206\237\347\273\203/index.html"
+++ "b/2023/05/19/Linux\344\273\216\345\205\245\351\227\250\345\210\260\347\206\237\347\273\203/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、引言  操作系统有个内核，负责管理系统的进程、内存、设备、文件和网络等资源。操作系统还有个 shell，为用户提供与内核交互的途径。shell 可以分为 GUI（图形界面）和 CLI（命令行）两种，GUI 以 windows 为代表，CLI 以 linux 为代表。linux 也有 Gnome 桌面，但效率和性能不如 CLI，学 linux 必学 CLI。\nCLI 是用户与内核打交道的工具。用户日常使用操作系统，最频繁的场景就是文件操作和网络访问。故而基础篇笔记主要记录 CLI 基本操作、文件系统、网络配置、权限管理等相关知识点。\n二、CLI 基本操作（一）查看目录\nls：显示指定目录下的文件及属性信息\npwd：显示当前工作目录的路径\n\n（二）查看内容\necho：输出字符串或变量值（变量前加 $ 符号）\ncat：输出文件内容\nhead：查看文件头部内容\ntail：查看文件尾部内容，-f 将持续追踪文件尾部追加的内容\nmore：分页显示文件内容，只能向后翻页，不能往前回翻\nless：分页显示文件内容，可以向后看，也可以向前看\n\n（三）开关机\nshutdown：按指定方式关闭系统\npoweroff：关机\nreboot：重启\n\n（四）归档压缩\nzip：打包成 zip 文件\nunzip：zip 文件解包\ntar：压缩和解压缩文件\n\n（五）文件和目录操作\nlocate：基于数据库快速查找文件和目录，手动更新数据库使用 updatedb 命令\nfind：根据条件在指定目录下查找文件和目录\ncp：复制文件或目录\nmv：移动文件或目录\ncd：切换目录\nmkdir：创建目录\ntouch：创建空文件\nrm：删除文件或目录\nrmdir：删除空目录\n\n（六）进程操作\n&amp;：命令 + 空格 +&amp;，会将任务置于后台执行\njobs：查看后台任务\nfg：将后台任务放到前台执行\nbg：将前台任务放到后台执行，前台任务可通过 ctrl+z 暂停\nps：查看系统当前的进程状态\nkill：终止进程\n\n（七）命令帮助\nhistory：查看历史命令记录\nman：查看命令的帮助手册，一般情况下命令加 -h 或–help 够用了\n\n（八）文本编辑\ngrep：搜索文本，可使用关键字或正则表达式\nsed：编辑文本，可使用正则表达式或脚本\ncut：基于列处理文件内容\nwc：统计文件行数、单词数、字符数等信息\ndiff：比较文件内容差异\nvim：linux 最常用的文本编辑工具，使用时分为三种模式（命令模式，插入模式，末行模式），各种模式切换方式如图：\n\ngraph TB\n    A[命令模式] --> |i| B[插入模式]\n    B[插入模式] --> |Esc| A[命令模式]\n    A[命令模式] --> |:| C[末行模式]\n    C[末行模式] --> |Esc| A[命令模式]\n\n(1) vim 命令模式常用命令：\n\ndd：剪切光标所在整行\nyy：复制光标所在整行\np：将剪切或复制内容粘贴到光标处\no：插入新行\nu：撤销上一步操作\nn：定位到搜索结果的下一个字符串\nN：定位到搜索结果的上一个字符串\n\n(2) vim 末行模式常用命令：\n\n:w 保存修改\n:q 退出 vim\n:q! 放弃修改，强制退出 vim\n:x 保存并退出 vim\n:set nu 显示行号\n:set nonu 不显示行号\n: 整数 跳转到指定行\n:&#x2F; 字符串 搜索字符串\n\n（九）管道和重定向linux 的标准数据流包括输入流 stdin(0)、输出流 stdout(1)、错误流 stderr(2)，默认情况下 stdin 接受键盘输入，stdout 和 stderr 将结果和错误输出到命令行终端。\n通过管道和重定向操作符，可以控制标准数据流的来源和去向：\n\n\n\n分类\n操作符\n定义\n示例\n\n\n\n重定向\n&gt;\n将 stdout 输出到文件（覆盖模式）\necho ‘test’ &gt; file\n\n\n重定向\n&gt;&gt;\n将 stdout 输出到文件（追加模式）\necho ‘test’ &gt;&gt; file\n\n\n重定向\n2&gt;\n将 stderr 输出到文件（覆盖模式）\ncd &#x2F;dev&#x2F;null &gt; file\n\n\n重定向\n2&gt;&amp;1\n将 stderr 和 stdout 输出到文件（覆盖模式）\ncd &#x2F;dev&#x2F;null 2&gt;&amp;1 file\n\n\n重定向\n&lt;\n将文件输入到 stdin\ngrep user &lt; file\n\n\n管道\n&amp;#124\n将前一个命令的 stdout 作为后一个命令的 stdin\necho ‘hello world’ &amp;#124 grep ‘hello’\n\n\n三、文件系统（一）linux 文件目录结构linux 下一切皆文件（普通文件、目录文件、设备文件、管道文件……），linux 文件系统不区分磁盘（windows 通常分 C 盘 D 盘，cmd 切换跨盘目录时，需要先切换盘符），整个 linux 系统目录是以 &#x2F; 为根节点的单根树结构，遵循 FHS 标准规范：\ngraph TB\n    A[\"/\"] --> B[bin] & C[boot] & D[dev] & E[etc] & F[home] & G[lib] & H[mnt] & I[opt] & J[proc] & K[root] & L[sbin] & M[tmp] & N[usr] & O[var]\n    N[usr] --> N1[bin] & N2[lib] & N3[local]\n    O[var] --> O1[cache] & O2[log]\n\n各目录的简要说明如下：\n\n&#x2F;: 根目录&#x2F;bin: 存放二进制可执行文件，root 用户和普通用户都能使用&#x2F;boot: 存放 linux 启动时的引导程序&#x2F;dev: linux 的设备也是以文件形式组织，存放在此目录下&#x2F;etc: 存放 linux 的系统管理和配置文件&#x2F;home: 存放普通用户的家目录，类似于 windows 下 C 盘 Users 用户文件夹&#x2F;lib: 存放程序运行依赖的库文件和内核驱动模块&#x2F;mnt: 设备挂载目录&#x2F;opt: 三方软件或大型软件的安装目录&#x2F;proc: 虚拟文件系统，记录系统实时信息，只存在内存中，不占用磁盘空间&#x2F;root: root 用户的家目录&#x2F;sbin: 存放二进制文件，仅 root 用户有权限使用&#x2F;tmp: 临时目录，重启系统会自动删除&#x2F;usr: 不是 user 缩写，是 unix software resource 缩写，存放系统上安装的软件资源&#x2F;var: 存放系统中经常变动的文件，如缓存 cache、日志 log、邮件 mail 等\n\n（二）分区 - 格式化 - 挂载linux 添加一个新的磁盘设备时，由于 linux 一切皆文件，需要将磁盘格式化为指定的文件系统，然后挂载到 linux 的系统目录中才能使用。相关的常用命令如下：\n\ndf：查看系统上磁盘的使用情况\nfdisk：磁盘分区工具，只支持 MBR 类型\nparted：磁盘分区工具，支持 MBR 和 GPT\nmkfs：格式化文件系统（包括 ext2、ext3、ext4、xfs、btrfs 等）\nmount：把文件系统挂载到指定系统目录，重启后挂载失效，永久挂载需修改 &#x2F;etc&#x2F;fstab 配置\numount：卸载文件系统，如果文件系统正在使用，会出现 device busy 问题\nfuser：查看使用文件系统的进程\nlsof：查看被打开的文件\n\n四、权限管理（一）用户和组linux 是服务器的主流操作系统，服务器通常由很多人同时使用。为不同的用户分配各自的操作权限，对维护系统的安全和稳定来说是十分必要的。\nlinux 的用户分为 root 用户、系统用户和普通用户，每个用户用唯一的 uid 标识，root 用户的 uid 为 0，系统用户的 uid 通常在 1~999，普通用户的 uid 通常 &gt;&#x3D;1000。系统用户主要用于执行系统程序，无法使用 shell 登录。\n为了便于对用户进行管理，每个用户还有对应的用户组，包括主组和附加组，主组只能有一个，附加组可以有多个。默认情况下，创建用户时，会将用户归属于同名的主组。\nlinux 上用户和用户组的信息都保存在 &#x2F;etc 目录下，相关命令和文件说明如下：\n\nid：显示用户与用户组信息\npasswd：修改用户密码\nuseradd：创建用户\ngroupadd：创建用户组\nuserdel：删除用户\ngroupdel：删除用户组\n&#x2F;etc&#x2F;passwd：用户账号信息\n&#x2F;etc&#x2F;shadow：用户密码信息（已加密）\n&#x2F;etc&#x2F;group：用户组信息\n\n（二）普通权限linux 定义的普通权限有 r（读）w（写）x（执行）三种，对文件来说很容易理解，对文件夹来说，要浏览目录需要同时开启 r 和 x 权限，x 表示可以通过 cd 进入目录。\nlinux 通过 UGO 模型对文件进行权限控制，其中 U（user）表示文件所属用户，G（group）表示文件所属用户组，O（other）表示既不是所属用户也不是所属用户组的其他群体。\n\n\n通过 ls -l 查看文件权限如上图所示，第一列权限信息包含 10 位字符，第三列表示文件所属用户（属主），第四列表示文件所属用户组（属组）。权限信息中，第 1 个字符表示文件类型（- 表示文件，d 表示文件夹，l 表示符号链接），后面 9 个字符每 3 个一组，分别描述属主（user）权限、属组（group）权限、其他（other）权限。权限位是 rwx 表示具有相应权限，权限位是 - 表示没有相应权限。除了以字符的方式，每组权限还可以用 3 个 bit 位来表示，r 在高位，w 在中位，x 在低位，于是 rwx&#x3D;b111&#x3D;4+2+1&#x3D;7。在修改权限时，可以使用任一种表达方式。\n在创建文件或文件夹时，系统会设定默认的权限，通过原始权限减去权限掩码的方式，可以得到默认权限。文件夹的原始权限是 777（rwxrwxrwx），文件的原始权限是 666（rw-rw-rw-）。普通用户的默认掩码是 002，root 用户的默认掩码是 022。因此，对普通用户来说，新建文件夹的权限是 775（rwxrwxr-x），新建文件的权限是 664（rw-rw-r–）。\n常用的权限修改命令如下：\n\nchown：修改文件的属主\nchgrp：修改文件的属组\nchmod：修改文件的权限\numask：管理权限掩码\n\n（三）特殊权限  除了 rwx 三种普通权限外，还有三种特殊权限：\n\n\n\n权限\n对文件影响\n对目录影响\n\n\n\nsuid\n以文件所属用户的权限执行，而非执行文件的用户权限\n无\n\n\nsgid\n以文件所属用户组的权限执行（用法较少）\n该目录中创建的任意新文件的所属组与该目录的所属组相同\n\n\nsticky\n无\n对目录拥有写入权限的用户仅能删除该用户拥有的文件，无法删除其他用户拥有的文件\n\n\n特殊权限设置方式：\n\nchmod u+s file  # user 组权限 x-&gt;s\nchmod g+s folder  # group 组权限 x-&gt;s\nchmod o+t folder  # other 组权限 x-&gt;t\nchmod 7777 folder  # drwsrwsrwt，suid&#x3D;4，sgid&#x3D;2，sticky&#x3D;1\n\n五、网络配置 (一)IP- 子网掩码 - 网关 -DNSIP(v4) 编码用来标识互联网中的机器地址，它包含 32 个 bit 位，由网络地址 + 主机地址两部分组成。\n子网掩码用来将 IP 地址切分为网络地址和主机地址，它也由 32 个 bit 位构成，且高位为连续的 1。子网掩码与 IP 地址成对出现，子网掩码与 IP 地址进行按位与运算可得网络地址。例如 IP 地址 192.168.1.1，子网掩码 255.255.255.0，可以算出网络地址为 192.168.1.0，可分配的主机地址包括 1~254（255 转换成 bit 位全为 1，全 1 的主机地址保留为广播地址），这一网段可以记为 192.168.1.0&#x2F;24。同一网段的机器通信使用 ARP 协议，将 IP 地址解析为 MAC 地址，再基于 MAC 通信。\n不同网络的主机之间进行通信需要使用网关，比如常见的路由器。网络 A 中的主机 A1 要跟网络 B 中的主机 B1 通信，主机 A1 需要先将数据包发送到 A 的网关，再由 A 的网关转发到 B 的网关，然后 B 的网关把数据包发送到主机 B1。现实中，跨域网络通信可能经过很多次路由器转发。\n在互联网冲浪的时候，敲在地址栏里的是一串字符组成的域名。访问一个域名，实际上访问的也是互联网的一台主机。域名和 IP 的映射关系，通过 DNS 服务器进行解析，DNS 协议可以将域名解析为 IP 地址。\n(二)相关命令和配置文件\nifconfig：查看和设置网络设备，重启后会失效，永久配置需要修改配置文件\nhostname：查看和设置系统的主机名\nping：测试本机与目标主机之间的网络连通性\nhost：解析域名的 IP 地址\ntraceroute：追踪网络数据包的传输路径\nmtr：网络诊断工具\nip route：查看路由表\n&#x2F;etc&#x2F;sysconfig&#x2F;network-scripts&#x2F;ifcfg-eth0：网卡 eth0 的配置信息\n&#x2F;etc&#x2F;resolv.conf：DNS 配置文件\n&#x2F;etc&#x2F;sysconfig&#x2F;network：主机名配置文件\n&#x2F;etc&#x2F;hosts：静态主机名配置文件\n","dateCreated":"2023-05-19T12:33:22+08:00","dateModified":"2024-04-08T10:47:51+08:00","datePublished":"2023-05-19T12:33:22+08:00","description":"常用的各类 Linux 操作命令","headline":"Linux 从入门到熟练","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/05/19/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/05/19/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/","keywords":"开发, Linux, 命令"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、引言  操作系统有个内核，负责管理系统的进程、内存、设备、文件和网络等资源。操作系统还有个 shell，为用户提供与内核交互的途径。shell 可以分为 GUI（图形界面）和 CLI（命令行）两种，GUI 以 windows 为代表，CLI 以 linux 为代表。linux 也有 Gnome 桌面，但效率和性能不如 CLI，学 linux 必学 CLI。\nCLI 是用户与内核打交道的工具。用户日常使用操作系统，最频繁的场景就是文件操作和网络访问。故而基础篇笔记主要记录 CLI 基本操作、文件系统、网络配置、权限管理等相关知识点。\n二、CLI 基本操作（一）查看目录\nls：显示指定目录下的文件及属性信息\npwd：显示当前工作目录的路径\n\n（二）查看内容\necho：输出字符串或变量值（变量前加 $ 符号）\ncat：输出文件内容\nhead：查看文件头部内容\ntail：查看文件尾部内容，-f 将持续追踪文件尾部追加的内容\nmore：分页显示文件内容，只能向后翻页，不能往前回翻\nless：分页显示文件内容，可以向后看，也可以向前看\n\n（三）开关机\nshutdown：按指定方式关闭系统\npoweroff：关机\nreboot：重启\n\n（四）归档压缩\nzip：打包成 zip 文件\nunzip：zip 文件解包\ntar：压缩和解压缩文件\n\n（五）文件和目录操作\nlocate：基于数据库快速查找文件和目录，手动更新数据库使用 updatedb 命令\nfind：根据条件在指定目录下查找文件和目录\ncp：复制文件或目录\nmv：移动文件或目录\ncd：切换目录\nmkdir：创建目录\ntouch：创建空文件\nrm：删除文件或目录\nrmdir：删除空目录\n\n（六）进程操作\n&amp;：命令 + 空格 +&amp;，会将任务置于后台执行\njobs：查看后台任务\nfg：将后台任务放到前台执行\nbg：将前台任务放到后台执行，前台任务可通过 ctrl+z 暂停\nps：查看系统当前的进程状态\nkill：终止进程\n\n（七）命令帮助\nhistory：查看历史命令记录\nman：查看命令的帮助手册，一般情况下命令加 -h 或–help 够用了\n\n（八）文本编辑\ngrep：搜索文本，可使用关键字或正则表达式\nsed：编辑文本，可使用正则表达式或脚本\ncut：基于列处理文件内容\nwc：统计文件行数、单词数、字符数等信息\ndiff：比较文件内容差异\nvim：linux 最常用的文本编辑工具，使用时分为三种模式（命令模式，插入模式，末行模式），各种模式切换方式如图：\n\ngraph TB\n    A[命令模式] --> |i| B[插入模式]\n    B[插入模式] --> |Esc| A[命令模式]\n    A[命令模式] --> |:| C[末行模式]\n    C[末行模式] --> |Esc| A[命令模式]\n\n(1) vim 命令模式常用命令：\n\ndd：剪切光标所在整行\nyy：复制光标所在整行\np：将剪切或复制内容粘贴到光标处\no：插入新行\nu：撤销上一步操作\nn：定位到搜索结果的下一个字符串\nN：定位到搜索结果的上一个字符串\n\n(2) vim 末行模式常用命令：\n\n:w 保存修改\n:q 退出 vim\n:q! 放弃修改，强制退出 vim\n:x 保存并退出 vim\n:set nu 显示行号\n:set nonu 不显示行号\n: 整数 跳转到指定行\n:&#x2F; 字符串 搜索字符串\n\n（九）管道和重定向linux 的标准数据流包括输入流 stdin(0)、输出流 stdout(1)、错误流 stderr(2)，默认情况下 stdin 接受键盘输入，stdout 和 stderr 将结果和错误输出到命令行终端。\n通过管道和重定向操作符，可以控制标准数据流的来源和去向：\n\n\n\n分类\n操作符\n定义\n示例\n\n\n\n重定向\n&gt;\n将 stdout 输出到文件（覆盖模式）\necho ‘test’ &gt; file\n\n\n重定向\n&gt;&gt;\n将 stdout 输出到文件（追加模式）\necho ‘test’ &gt;&gt; file\n\n\n重定向\n2&gt;\n将 stderr 输出到文件（覆盖模式）\ncd &#x2F;dev&#x2F;null &gt; file\n\n\n重定向\n2&gt;&amp;1\n将 stderr 和 stdout 输出到文件（覆盖模式）\ncd &#x2F;dev&#x2F;null 2&gt;&amp;1 file\n\n\n重定向\n&lt;\n将文件输入到 stdin\ngrep user &lt; file\n\n\n管道\n&amp;#124\n将前一个命令的 stdout 作为后一个命令的 stdin\necho ‘hello world’ &amp;#124 grep ‘hello’\n\n\n三、文件系统（一）linux 文件目录结构linux 下一切皆文件（普通文件、目录文件、设备文件、管道文件……），linux 文件系统不区分磁盘（windows 通常分 C 盘 D 盘，cmd 切换跨盘目录时，需要先切换盘符），整个 linux 系统目录是以 &#x2F; 为根节点的单根树结构，遵循 FHS 标准规范：\ngraph TB\n    A[\"/\"] --> B[bin] & C[boot] & D[dev] & E[etc] & F[home] & G[lib] & H[mnt] & I[opt] & J[proc] & K[root] & L[sbin] & M[tmp] & N[usr] & O[var]\n    N[usr] --> N1[bin] & N2[lib] & N3[local]\n    O[var] --> O1[cache] & O2[log]\n\n各目录的简要说明如下：\n\n&#x2F;: 根目录&#x2F;bin: 存放二进制可执行文件，root 用户和普通用户都能使用&#x2F;boot: 存放 linux 启动时的引导程序&#x2F;dev: linux 的设备也是以文件形式组织，存放在此目录下&#x2F;etc: 存放 linux 的系统管理和配置文件&#x2F;home: 存放普通用户的家目录，类似于 windows 下 C 盘 Users 用户文件夹&#x2F;lib: 存放程序运行依赖的库文件和内核驱动模块&#x2F;mnt: 设备挂载目录&#x2F;opt: 三方软件或大型软件的安装目录&#x2F;proc: 虚拟文件系统，记录系统实时信息，只存在内存中，不占用磁盘空间&#x2F;root: root 用户的家目录&#x2F;sbin: 存放二进制文件，仅 root 用户有权限使用&#x2F;tmp: 临时目录，重启系统会自动删除&#x2F;usr: 不是 user 缩写，是 unix software resource 缩写，存放系统上安装的软件资源&#x2F;var: 存放系统中经常变动的文件，如缓存 cache、日志 log、邮件 mail 等\n\n（二）分区 - 格式化 - 挂载linux 添加一个新的磁盘设备时，由于 linux 一切皆文件，需要将磁盘格式化为指定的文件系统，然后挂载到 linux 的系统目录中才能使用。相关的常用命令如下：\n\ndf：查看系统上磁盘的使用情况\nfdisk：磁盘分区工具，只支持 MBR 类型\nparted：磁盘分区工具，支持 MBR 和 GPT\nmkfs：格式化文件系统（包括 ext2、ext3、ext4、xfs、btrfs 等）\nmount：把文件系统挂载到指定系统目录，重启后挂载失效，永久挂载需修改 &#x2F;etc&#x2F;fstab 配置\numount：卸载文件系统，如果文件系统正在使用，会出现 device busy 问题\nfuser：查看使用文件系统的进程\nlsof：查看被打开的文件\n\n四、权限管理（一）用户和组linux 是服务器的主流操作系统，服务器通常由很多人同时使用。为不同的用户分配各自的操作权限，对维护系统的安全和稳定来说是十分必要的。\nlinux 的用户分为 root 用户、系统用户和普通用户，每个用户用唯一的 uid 标识，root 用户的 uid 为 0，系统用户的 uid 通常在 1~999，普通用户的 uid 通常 &gt;&#x3D;1000。系统用户主要用于执行系统程序，无法使用 shell 登录。\n为了便于对用户进行管理，每个用户还有对应的用户组，包括主组和附加组，主组只能有一个，附加组可以有多个。默认情况下，创建用户时，会将用户归属于同名的主组。\nlinux 上用户和用户组的信息都保存在 &#x2F;etc 目录下，相关命令和文件说明如下：\n\nid：显示用户与用户组信息\npasswd：修改用户密码\nuseradd：创建用户\ngroupadd：创建用户组\nuserdel：删除用户\ngroupdel：删除用户组\n&#x2F;etc&#x2F;passwd：用户账号信息\n&#x2F;etc&#x2F;shadow：用户密码信息（已加密）\n&#x2F;etc&#x2F;group：用户组信息\n\n（二）普通权限linux 定义的普通权限有 r（读）w（写）x（执行）三种，对文件来说很容易理解，对文件夹来说，要浏览目录需要同时开启 r 和 x 权限，x 表示可以通过 cd 进入目录。\nlinux 通过 UGO 模型对文件进行权限控制，其中 U（user）表示文件所属用户，G（group）表示文件所属用户组，O（other）表示既不是所属用户也不是所属用户组的其他群体。\n\n\n通过 ls -l 查看文件权限如上图所示，第一列权限信息包含 10 位字符，第三列表示文件所属用户（属主），第四列表示文件所属用户组（属组）。权限信息中，第 1 个字符表示文件类型（- 表示文件，d 表示文件夹，l 表示符号链接），后面 9 个字符每 3 个一组，分别描述属主（user）权限、属组（group）权限、其他（other）权限。权限位是 rwx 表示具有相应权限，权限位是 - 表示没有相应权限。除了以字符的方式，每组权限还可以用 3 个 bit 位来表示，r 在高位，w 在中位，x 在低位，于是 rwx&#x3D;b111&#x3D;4+2+1&#x3D;7。在修改权限时，可以使用任一种表达方式。\n在创建文件或文件夹时，系统会设定默认的权限，通过原始权限减去权限掩码的方式，可以得到默认权限。文件夹的原始权限是 777（rwxrwxrwx），文件的原始权限是 666（rw-rw-rw-）。普通用户的默认掩码是 002，root 用户的默认掩码是 022。因此，对普通用户来说，新建文件夹的权限是 775（rwxrwxr-x），新建文件的权限是 664（rw-rw-r–）。\n常用的权限修改命令如下：\n\nchown：修改文件的属主\nchgrp：修改文件的属组\nchmod：修改文件的权限\numask：管理权限掩码\n\n（三）特殊权限  除了 rwx 三种普通权限外，还有三种特殊权限：\n\n\n\n权限\n对文件影响\n对目录影响\n\n\n\nsuid\n以文件所属用户的权限执行，而非执行文件的用户权限\n无\n\n\nsgid\n以文件所属用户组的权限执行（用法较少）\n该目录中创建的任意新文件的所属组与该目录的所属组相同\n\n\nsticky\n无\n对目录拥有写入权限的用户仅能删除该用户拥有的文件，无法删除其他用户拥有的文件\n\n\n特殊权限设置方式：\n\nchmod u+s file  # user 组权限 x-&gt;s\nchmod g+s folder  # group 组权限 x-&gt;s\nchmod o+t folder  # other 组权限 x-&gt;t\nchmod 7777 folder  # drwsrwsrwt，suid&#x3D;4，sgid&#x3D;2，sticky&#x3D;1\n\n五、网络配置 (一)IP- 子网掩码 - 网关 -DNSIP(v4) 编码用来标识互联网中的机器地址，它包含 32 个 bit 位，由网络地址 + 主机地址两部分组成。\n子网掩码用来将 IP 地址切分为网络地址和主机地址，它也由 32 个 bit 位构成，且高位为连续的 1。子网掩码与 IP 地址成对出现，子网掩码与 IP 地址进行按位与运算可得网络地址。例如 IP 地址 192.168.1.1，子网掩码 255.255.255.0，可以算出网络地址为 192.168.1.0，可分配的主机地址包括 1~254（255 转换成 bit 位全为 1，全 1 的主机地址保留为广播地址），这一网段可以记为 192.168.1.0&#x2F;24。同一网段的机器通信使用 ARP 协议，将 IP 地址解析为 MAC 地址，再基于 MAC 通信。\n不同网络的主机之间进行通信需要使用网关，比如常见的路由器。网络 A 中的主机 A1 要跟网络 B 中的主机 B1 通信，主机 A1 需要先将数据包发送到 A 的网关，再由 A 的网关转发到 B 的网关，然后 B 的网关把数据包发送到主机 B1。现实中，跨域网络通信可能经过很多次路由器转发。\n在互联网冲浪的时候，敲在地址栏里的是一串字符组成的域名。访问一个域名，实际上访问的也是互联网的一台主机。域名和 IP 的映射关系，通过 DNS 服务器进行解析，DNS 协议可以将域名解析为 IP 地址。\n(二)相关命令和配置文件\nifconfig：查看和设置网络设备，重启后会失效，永久配置需要修改配置文件\nhostname：查看和设置系统的主机名\nping：测试本机与目标主机之间的网络连通性\nhost：解析域名的 IP 地址\ntraceroute：追踪网络数据包的传输路径\nmtr：网络诊断工具\nip route：查看路由表\n&#x2F;etc&#x2F;sysconfig&#x2F;network-scripts&#x2F;ifcfg-eth0：网卡 eth0 的配置信息\n&#x2F;etc&#x2F;resolv.conf：DNS 配置文件\n&#x2F;etc&#x2F;sysconfig&#x2F;network：主机名配置文件\n&#x2F;etc&#x2F;hosts：静态主机名配置文件\n","dateCreated":"2023-05-19T12:33:22+08:00","dateModified":"2024-04-08T10:47:51+08:00","datePublished":"2023-05-19T12:33:22+08:00","description":"常用的各类 Linux 操作命令","headline":"Linux 从入门到熟练","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/05/19/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/05/19/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/","keywords":"开发, 命令, Linux"}</script>
     <meta name="description" content="常用的各类 Linux 操作命令">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="Linux 从入门到熟练">
@@ -26,8 +26,8 @@
 <meta property="article:modified_time" content="2024-04-08T02:47:51.689Z">
 <meta property="article:author" content="一瓢清浅">
 <meta property="article:tag" content="开发">
-<meta property="article:tag" content="Linux">
 <meta property="article:tag" content="命令">
+<meta property="article:tag" content="Linux">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://jiliguluss.github.io/2023/05/19/Linux%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%86%9F%E7%BB%83/%E6%96%87%E4%BB%B6%E6%9D%83%E9%99%90.png">
     
diff --git "a/2023/06/08/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html" "b/2023/06/08/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html"
index b144c83..dee384f 100644
--- "a/2023/06/08/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html"
+++ "b/2023/06/08/Docker\345\277\205\347\237\245\345\277\205\344\274\232/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、基本概念Docker 是一种轻量级的虚拟化技术，可以让开发者非常便捷地实现应用程序的打包、移植、启动等操作，在软件开发、交付和部署中，有非常广泛的应用。\nDocker 容器与传统虚拟机的架构对比如下：\n\n\n传统 VM 使用 Hypervisor 通过对物理主机的硬件资源进行协调和管理，为每个 GuestOS 分配独立的资源，让每个 GuestOS 成为一个虚拟主机，不同的 GuestOS 中的应用程序互不影响。Docker 容器直接运行在物理主机的 HostOS 上，共用物理主机的硬件资源，Container Engine 负责实现容器之间的资源隔离，让每个容器的应用独立地运行。\n可以看出，容器比虚拟机少了一层 GuestOS，容器占用资源更少，启动更快，但隔离程度不如虚拟机。容器和虚拟机简要对比如下：\n\n\n\n维度\n容器\n虚拟机\n\n\n\n隔离级别\n进程级\n操作系统级\n\n\n镜像大小\nK-M 级\nM-G 级\n\n\n启动时间\n秒级\n分钟级\n\n\n性能表现\n接近原生\n有损耗\n\n\n移植性\n轻量\n重量\n\n\n隔离性\n弱\n强\n\n\n安全性\n弱\n强\n\n\nDocker 中有三个常见的名词：镜像、容器和仓库。这里先简单介绍下概念，知道是什么就行，后面再详细说明。\n（一）镜像（Image）镜像是一个特殊的文件系统，提供容器运行时所需的环境和配置，例如程序、库、资源、配置等文件，以及环境变量、匿名卷、用户等配置参数。镜像是静态的，不包含任何动态数据，在镜像构建之后，其内容不会发生改变。\n（二）容器（Container）容器和镜像的关系，类似于面向对象编程中对象和类的关系，容器是运行镜像后得到的实例，运行镜像就相当于类的实例化，多次运行镜像，可以得到多个容器。容器是动态的，可以对容器进行创建、删除、启动、停止、暂停等操作。\n容器实质上是运行在宿主机上的进程，Docker 是用特殊的技术将容器与宿主机上的其他进程隔离开来，使得容器内的应用看起来是运行在一个独立的环境中。\n（三）仓库（Repository）仓库类似 github，对镜像进行存储和分发。在任一宿主机上，都可以从仓库拉取指定镜像，也可以把自己打包好的镜像上传到仓库，供他人访问。默认的是官方仓库 Docker Hub，拥有众多官方镜像，国内访问需要配加速器，如阿里云的镜像仓。也可以自行搭建本地私有镜像仓。\n二、基础原理  前面提到，容器是宿主机用特殊机制隔离出来的进程。为了实现容器进程的互不干扰，这个机制需要解决两个基本问题：\n\n容器内屏蔽容器外的情况，使用 Linux 的 Namespace 机制\n容器拥有独立的资源，使用 Linux 的 Cgroups 机制\n\n（一）Namespace顾名思义，Namespace 就是命名空间。C++ 使用命名空间解决了类型、变量和函数的冲突问题。Docker 容器也具有自己的命名空间，通过命名空间对资源对象进行隔离，使得不同的容器进程号、用户、文件目录等相互屏蔽。Linux 支持的命名空间有以下几种：\n\n\n\nNamespace\nFlag\nIsolates\n\n\n\nMount\nCLONE_NEWNS\n隔离文件系统挂载点\n\n\nIPC\nCLONE_NEWIPC\n隔离进程间通信\n\n\nNetwork\nCLONE_NEWNET\n隔离网络\n\n\nPID\nCLONE_NEWPID\n隔离进程 ID\n\n\nUSER\nCLONE_NEWUSER\n隔离用户和用户组\n\n\nUTS\nCLONE_NEWUTS\n隔离主机名和域名\n\n\nTime\nCLONE_NEWTIME\n隔离系统时间\n\n\n（二）CgroupsLinux Cgroups 的全称是 Linux Control Group，主要用于对共享资源进行隔离、限制、审计。通过 Cgroups 限制容器能够使用的资源上限，包括 cpu、内存、磁盘、网络带宽等，可以避免多个容器之间的资源竞争。Linux 一切皆文件，Cgroups 也是通过树状的文件系统来对资源进行限制。\n\n查看 cgroup 挂载的目录，可以看到 cgroup 挂在 sys&#x2F;fs&#x2F;cgroup 节点，该路径下还有很多子目录（又称子系统），如 cpu、memory 等，每个子系统对应一种可以被限制的资源类型。\n\n\n以 cpu 为例，查看 cpu 子系统。其中有两个参数 cfs_period_us 和 cfs_quota_us 通常组合使用，用于限制进程在长度为 cfs_period_us 的时间内，只能被分配到总量为 cfs_quota_us 的 cpu 时间。还有一个 tasks 文件，其中存放的是受限制的进程编号。\n\n  \n\ncpu 子系统中有个 docker 子目录，docker 目录中的文件与 cpu 目录中的文件一样。当我们拉起一个容器，比如运行 redis 镜像，可以看到 docker 目录中又多了一层以容器 id 为名称的子目录。\n\n\n\n综上两点，容器其实是一个启用了多种 Namespace 的进程，它能够使用的资源量收到 Cgroups 的限制。截至目前，我们使用 Namespace 和 Cgroups 为容器开辟了一个独立的运行环境，接下来我们再剖析一下容器里运行的镜像。\n前面提到，容器镜像是一个文件系统，我们运行 ubuntu 的镜像，可以通过命令行查看根目录内容，也可以创建并执行脚本文件：\n\n\n我们还可以把改动之后的文件系统打包成我们自己的镜像，下次直接执行：\n\n\n可以看到，我们以 ubuntu 文件系统为基础，加了一层我们自己的修改，打包了一个新的镜像。容器镜像实际上就是以 Linux 的联合文件系统机制（UnionFS）实现分层文件系统。\n（三）UnionFSUnionFS（联合文件系统），可以将不同目录挂载到同一个虚拟文件系统下。Docker 利用 UnionFS 的功能，在基础文件系统上以增量的方式，叠加一层又一层新的文件系统，通过联合挂载，最终得到一个完整的 Docker 镜像文件系统。\nDocker 分层镜像的示例图如下，除了最顶层（称为容器层）是可写的，其他层（称为镜像层）都是只读的。UnoinFS 将所有层都叠加起来，形成最后我们在容器中所看到的文件系统。\n\n\n由于镜像层都是只读的，所有对文件的修改操作都发生在容器层中，Docker 采用了 Copy-On-Write（写时复制） 的机制，具体来说：\n\n新增文件：在容器层中创建文件\n读取文件：自上而下在各层中查找文件，一旦找到，打开并读入内存\n修改文件：自上而下在各层中查找文件，找到后，将文件复制到容器层，在容器层中修改对应文件\n删除文件：自上而下在各层中查找文件，找到后，在容器层中记录删除操作\n\n通过这种分层且只读的设计，使得每一个镜像层都是唯一且不变的，同一个镜像层可以在不同 docker 镜像中共享，只需要下载一次，存储一份，从而节省了大量的资源消耗和占用。\n（四）Volumes由前所述，启动容器后，在容器内执行的所有文件的修改，都保存在容器层中，在删除容器时，对应的修改也会被删除。当我们需要保存修改的结果时，就需要用到数据卷（Data Volume），换句话说，数据卷提供了一种数据持久化的方式，使得在容器中产生的修改能永久的保留到宿主机上。数据卷的使用也很简单，在启动容器时，将宿主机的目录映射到容器中即可。\n三、使用方法 （一）命令行 与 Linux 一样，Docker 主要通过命令行操作，Docker 提供了非常多的命令，可以通过如下命令查看说明文档：\n1docker command --help\n\nDocker 命令主要涉及到镜像、容器、仓库的操作和使用，下图可以概览全貌：\n\n\n以下列举一些常用的 docker 命令，各命令详细用法可以通过 help 查看：\n1. 镜像相关\n搜索镜像：search\n1docker search python\n\n拉取镜像：pull，不指定标签时，默认拉取 lastest 版本\n1docker pull python\n\n推送镜像：push\n1docker push python\n\n构建镜像：build，根据 Dockerfile 构建镜像，Dockerfile 见下一节内容。以下这条命令是指在根据当前目录的 Dockerfile 文件，构建一个名为 my_python 的镜像\n1docker build -t my_python .\n\n列出镜像：images，等同于 image ls\n1docker images\n\n删除镜像：rmi，等同于 image rm\n1docker rmi python\n\n2. 容器相关\n运行容器：run，创建一个容器，运行镜像文件\n1docker run ubuntu\n\n查看容器：ps，默认只列出运行中的容器，加 -a 参数可以列出所有容器，显示结果中第一列为 CONTAINER ID，是容器的唯一标识\n1docker ps -a\n\n启动容器：start\n1docker start 369dde08ff20\n\n停止容器：stop\n1docker stop 369dde08ff20\n\n删除容器：rm\n1docker rm 369dde08ff20\n\n重启容器：restart\n1docker restart 369dde08ff20\n\n链接容器：attach，连接一个正在运行的容器\n1docker attach 369dde08ff20\n\n执行命令：exec，在正在运行的容器中执行命令。以下这条命令在 ID 为 369dde08ff20 的容器中，开启一个交互式命令行终端\n1docker exec -it 369dde08ff20 /bin/bash\n\n查看信息：inspect，查看镜像或容器的具体配置信息\n1docker inspect 369dde08ff20\n\n提交镜像：commit，将当前容器的修改保存为镜像\n1docker commit -m &quot;container to image&quot; 369dde08ff20 my_ubuntu\n\n查看变更：diff，将容器创建以来，文件系统中发生变更的文件和目录\n1docker diff 369dde08ff20\n\n拷贝文件：cp，用于在容器和宿主机之间拷贝数据。以下这条命令将容器中的 &#x2F;tmp 目录，拷贝到宿主机中的 &#x2F;tmp 目录\n1docker cp 369dde08ff20:/tmp/ /tmp/\n\n（二）镜像制作  制作 Docker 镜像有两种方法，一种是在容器中使用 commit 提交修改，另一种是使用 Dockfile 进行 build，后一种是主流做法。\nDockerfile 是由一行行指令组成的脚本文件，每一行命令都会生成一个镜像层，多行命令生成多个镜像层，叠加生成最终的镜像文件。Dockerfile 的常见指令及含义如图所示：\n\n\n最后看个 Dockerfile 的小例子：\n\n编写 Dockerfile 文件\n\n\n生成镜像文件\n\n\n查看并运行镜像文件\n\n\n四、参考资料\nDocker 原理（图解 + 秒懂 + 史上最全） \nDocker 命令行官方手册 \nDockerfile 文件详解\n","dateCreated":"2023-06-08T16:10:21+08:00","dateModified":"2024-04-08T10:47:43+08:00","datePublished":"2023-06-08T16:10:21+08:00","description":"Docker 基本原理以及常用命令","headline":"Docker 必知必会","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/06/08/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/06/08/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/","keywords":"开发, 命令, Docker"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、基本概念Docker 是一种轻量级的虚拟化技术，可以让开发者非常便捷地实现应用程序的打包、移植、启动等操作，在软件开发、交付和部署中，有非常广泛的应用。\nDocker 容器与传统虚拟机的架构对比如下：\n\n\n传统 VM 使用 Hypervisor 通过对物理主机的硬件资源进行协调和管理，为每个 GuestOS 分配独立的资源，让每个 GuestOS 成为一个虚拟主机，不同的 GuestOS 中的应用程序互不影响。Docker 容器直接运行在物理主机的 HostOS 上，共用物理主机的硬件资源，Container Engine 负责实现容器之间的资源隔离，让每个容器的应用独立地运行。\n可以看出，容器比虚拟机少了一层 GuestOS，容器占用资源更少，启动更快，但隔离程度不如虚拟机。容器和虚拟机简要对比如下：\n\n\n\n维度\n容器\n虚拟机\n\n\n\n隔离级别\n进程级\n操作系统级\n\n\n镜像大小\nK-M 级\nM-G 级\n\n\n启动时间\n秒级\n分钟级\n\n\n性能表现\n接近原生\n有损耗\n\n\n移植性\n轻量\n重量\n\n\n隔离性\n弱\n强\n\n\n安全性\n弱\n强\n\n\nDocker 中有三个常见的名词：镜像、容器和仓库。这里先简单介绍下概念，知道是什么就行，后面再详细说明。\n（一）镜像（Image）镜像是一个特殊的文件系统，提供容器运行时所需的环境和配置，例如程序、库、资源、配置等文件，以及环境变量、匿名卷、用户等配置参数。镜像是静态的，不包含任何动态数据，在镜像构建之后，其内容不会发生改变。\n（二）容器（Container）容器和镜像的关系，类似于面向对象编程中对象和类的关系，容器是运行镜像后得到的实例，运行镜像就相当于类的实例化，多次运行镜像，可以得到多个容器。容器是动态的，可以对容器进行创建、删除、启动、停止、暂停等操作。\n容器实质上是运行在宿主机上的进程，Docker 是用特殊的技术将容器与宿主机上的其他进程隔离开来，使得容器内的应用看起来是运行在一个独立的环境中。\n（三）仓库（Repository）仓库类似 github，对镜像进行存储和分发。在任一宿主机上，都可以从仓库拉取指定镜像，也可以把自己打包好的镜像上传到仓库，供他人访问。默认的是官方仓库 Docker Hub，拥有众多官方镜像，国内访问需要配加速器，如阿里云的镜像仓。也可以自行搭建本地私有镜像仓。\n二、基础原理  前面提到，容器是宿主机用特殊机制隔离出来的进程。为了实现容器进程的互不干扰，这个机制需要解决两个基本问题：\n\n容器内屏蔽容器外的情况，使用 Linux 的 Namespace 机制\n容器拥有独立的资源，使用 Linux 的 Cgroups 机制\n\n（一）Namespace顾名思义，Namespace 就是命名空间。C++ 使用命名空间解决了类型、变量和函数的冲突问题。Docker 容器也具有自己的命名空间，通过命名空间对资源对象进行隔离，使得不同的容器进程号、用户、文件目录等相互屏蔽。Linux 支持的命名空间有以下几种：\n\n\n\nNamespace\nFlag\nIsolates\n\n\n\nMount\nCLONE_NEWNS\n隔离文件系统挂载点\n\n\nIPC\nCLONE_NEWIPC\n隔离进程间通信\n\n\nNetwork\nCLONE_NEWNET\n隔离网络\n\n\nPID\nCLONE_NEWPID\n隔离进程 ID\n\n\nUSER\nCLONE_NEWUSER\n隔离用户和用户组\n\n\nUTS\nCLONE_NEWUTS\n隔离主机名和域名\n\n\nTime\nCLONE_NEWTIME\n隔离系统时间\n\n\n（二）CgroupsLinux Cgroups 的全称是 Linux Control Group，主要用于对共享资源进行隔离、限制、审计。通过 Cgroups 限制容器能够使用的资源上限，包括 cpu、内存、磁盘、网络带宽等，可以避免多个容器之间的资源竞争。Linux 一切皆文件，Cgroups 也是通过树状的文件系统来对资源进行限制。\n\n查看 cgroup 挂载的目录，可以看到 cgroup 挂在 sys&#x2F;fs&#x2F;cgroup 节点，该路径下还有很多子目录（又称子系统），如 cpu、memory 等，每个子系统对应一种可以被限制的资源类型。\n\n\n以 cpu 为例，查看 cpu 子系统。其中有两个参数 cfs_period_us 和 cfs_quota_us 通常组合使用，用于限制进程在长度为 cfs_period_us 的时间内，只能被分配到总量为 cfs_quota_us 的 cpu 时间。还有一个 tasks 文件，其中存放的是受限制的进程编号。\n\n  \n\ncpu 子系统中有个 docker 子目录，docker 目录中的文件与 cpu 目录中的文件一样。当我们拉起一个容器，比如运行 redis 镜像，可以看到 docker 目录中又多了一层以容器 id 为名称的子目录。\n\n\n\n综上两点，容器其实是一个启用了多种 Namespace 的进程，它能够使用的资源量收到 Cgroups 的限制。截至目前，我们使用 Namespace 和 Cgroups 为容器开辟了一个独立的运行环境，接下来我们再剖析一下容器里运行的镜像。\n前面提到，容器镜像是一个文件系统，我们运行 ubuntu 的镜像，可以通过命令行查看根目录内容，也可以创建并执行脚本文件：\n\n\n我们还可以把改动之后的文件系统打包成我们自己的镜像，下次直接执行：\n\n\n可以看到，我们以 ubuntu 文件系统为基础，加了一层我们自己的修改，打包了一个新的镜像。容器镜像实际上就是以 Linux 的联合文件系统机制（UnionFS）实现分层文件系统。\n（三）UnionFSUnionFS（联合文件系统），可以将不同目录挂载到同一个虚拟文件系统下。Docker 利用 UnionFS 的功能，在基础文件系统上以增量的方式，叠加一层又一层新的文件系统，通过联合挂载，最终得到一个完整的 Docker 镜像文件系统。\nDocker 分层镜像的示例图如下，除了最顶层（称为容器层）是可写的，其他层（称为镜像层）都是只读的。UnoinFS 将所有层都叠加起来，形成最后我们在容器中所看到的文件系统。\n\n\n由于镜像层都是只读的，所有对文件的修改操作都发生在容器层中，Docker 采用了 Copy-On-Write（写时复制） 的机制，具体来说：\n\n新增文件：在容器层中创建文件\n读取文件：自上而下在各层中查找文件，一旦找到，打开并读入内存\n修改文件：自上而下在各层中查找文件，找到后，将文件复制到容器层，在容器层中修改对应文件\n删除文件：自上而下在各层中查找文件，找到后，在容器层中记录删除操作\n\n通过这种分层且只读的设计，使得每一个镜像层都是唯一且不变的，同一个镜像层可以在不同 docker 镜像中共享，只需要下载一次，存储一份，从而节省了大量的资源消耗和占用。\n（四）Volumes由前所述，启动容器后，在容器内执行的所有文件的修改，都保存在容器层中，在删除容器时，对应的修改也会被删除。当我们需要保存修改的结果时，就需要用到数据卷（Data Volume），换句话说，数据卷提供了一种数据持久化的方式，使得在容器中产生的修改能永久的保留到宿主机上。数据卷的使用也很简单，在启动容器时，将宿主机的目录映射到容器中即可。\n三、使用方法 （一）命令行 与 Linux 一样，Docker 主要通过命令行操作，Docker 提供了非常多的命令，可以通过如下命令查看说明文档：\n1docker command --help\n\nDocker 命令主要涉及到镜像、容器、仓库的操作和使用，下图可以概览全貌：\n\n\n以下列举一些常用的 docker 命令，各命令详细用法可以通过 help 查看：\n1. 镜像相关\n搜索镜像：search\n1docker search python\n\n拉取镜像：pull，不指定标签时，默认拉取 lastest 版本\n1docker pull python\n\n推送镜像：push\n1docker push python\n\n构建镜像：build，根据 Dockerfile 构建镜像，Dockerfile 见下一节内容。以下这条命令是指在根据当前目录的 Dockerfile 文件，构建一个名为 my_python 的镜像\n1docker build -t my_python .\n\n列出镜像：images，等同于 image ls\n1docker images\n\n删除镜像：rmi，等同于 image rm\n1docker rmi python\n\n2. 容器相关\n运行容器：run，创建一个容器，运行镜像文件\n1docker run ubuntu\n\n查看容器：ps，默认只列出运行中的容器，加 -a 参数可以列出所有容器，显示结果中第一列为 CONTAINER ID，是容器的唯一标识\n1docker ps -a\n\n启动容器：start\n1docker start 369dde08ff20\n\n停止容器：stop\n1docker stop 369dde08ff20\n\n删除容器：rm\n1docker rm 369dde08ff20\n\n重启容器：restart\n1docker restart 369dde08ff20\n\n链接容器：attach，连接一个正在运行的容器\n1docker attach 369dde08ff20\n\n执行命令：exec，在正在运行的容器中执行命令。以下这条命令在 ID 为 369dde08ff20 的容器中，开启一个交互式命令行终端\n1docker exec -it 369dde08ff20 /bin/bash\n\n查看信息：inspect，查看镜像或容器的具体配置信息\n1docker inspect 369dde08ff20\n\n提交镜像：commit，将当前容器的修改保存为镜像\n1docker commit -m &quot;container to image&quot; 369dde08ff20 my_ubuntu\n\n查看变更：diff，将容器创建以来，文件系统中发生变更的文件和目录\n1docker diff 369dde08ff20\n\n拷贝文件：cp，用于在容器和宿主机之间拷贝数据。以下这条命令将容器中的 &#x2F;tmp 目录，拷贝到宿主机中的 &#x2F;tmp 目录\n1docker cp 369dde08ff20:/tmp/ /tmp/\n\n（二）镜像制作  制作 Docker 镜像有两种方法，一种是在容器中使用 commit 提交修改，另一种是使用 Dockfile 进行 build，后一种是主流做法。\nDockerfile 是由一行行指令组成的脚本文件，每一行命令都会生成一个镜像层，多行命令生成多个镜像层，叠加生成最终的镜像文件。Dockerfile 的常见指令及含义如图所示：\n\n\n最后看个 Dockerfile 的小例子：\n\n编写 Dockerfile 文件\n\n\n生成镜像文件\n\n\n查看并运行镜像文件\n\n\n四、参考资料\nDocker 原理（图解 + 秒懂 + 史上最全） \nDocker 命令行官方手册 \nDockerfile 文件详解\n","dateCreated":"2023-06-08T16:10:21+08:00","dateModified":"2024-04-08T10:47:43+08:00","datePublished":"2023-06-08T16:10:21+08:00","description":"Docker 基本原理以及常用命令","headline":"Docker 必知必会","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/06/08/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/06/08/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/","keywords":"开发, Docker, 命令"}</script>
     <meta name="description" content="Docker 基本原理以及常用命令">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="Docker 必知必会">
@@ -39,8 +39,8 @@
 <meta property="article:modified_time" content="2024-04-08T02:47:43.707Z">
 <meta property="article:author" content="一瓢清浅">
 <meta property="article:tag" content="开发">
-<meta property="article:tag" content="命令">
 <meta property="article:tag" content="Docker">
+<meta property="article:tag" content="命令">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://jiliguluss.github.io/2023/06/08/Docker%E5%BF%85%E7%9F%A5%E5%BF%85%E4%BC%9A/vm-vs-docker.jpg">
     
diff --git "a/2023/09/17/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html" "b/2023/09/17/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
index 56afe5f..e272be5 100644
--- "a/2023/09/17/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
+++ "b/2023/09/17/LibFuzzer\344\275\277\347\224\250\350\257\264\346\230\216/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n按照  官方定义，LibFuzzer 是一个in-process（进程内的），coverage-guided（以覆盖率为引导的），evolutionary（进化的） 的 fuzz 引擎，是 LLVM 项目的一部分，主要用于对 C&#x2F;C++ 程序进行 Fuzz 测试。LibFuzzer 三个特性的具体含义为：\n\nin-process：不会为每个测试用例启动一个进程，而是将所有的测试数据投放在同一个进程的内存空间中\n\ncoverage-guided：对每一个测试输入都进行代码覆盖率计算，不断累积测试用例使得代码覆盖率最大化\n\nevolutionary：结合了变异和生成两种形势的 Fuzz 引擎\n\n变异：基于已有的数据样本，通过一些变异规则，产生新的测试用例\n\n生成：通过对目标协议或接口规范进行建模，从零开始产生测试用例\n\n\n\n\nLibFuzzer 与待测的 library 进行链接，通过向指定的 fuzzing 入口（即target 函数）发送测试数据，并跟踪被触达的代码区域，然后对输入的数据进行变异，以达到代码覆盖率最大的目的，其中代码覆盖率的信息由 LLVM 的 SanitizerCoverage 工具提供。\n一、使用方法 1. 安装环境Clang 是一个类似 GCC 的 C&#x2F;C++ 语言编译工具，此处 简介。LibFuzzer 现在已被集成到 Clang 6.0 之后的版本中，在 Linux 环境下，只需直接安装 Clang 即可：\n1apt install clang\n\n安装完毕之后，可以通过如下命令查看 clang 版本：\n1clang --version\n\n2. 构建 target使用 LibFuzzer 时，第一步就是要实现 target 函数——LLVMFuzzerTestOneInput，该函数以 bytes 数组作为输入，函数体内使用待测 API 对这个 bytes 数组进行处理：\n12345// fuzz_target.ccextern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  DoSomethingInterestingWithMyAPI(Data, Size);  return 0;  // Values other than 0 and -1 are reserved for future use.&#125;\n\ntarget 函数的名称、参数类型、返回值类型都不能改变。此外，官方文档中还有如下说明：\n\ntarget 函数在同一个进程中被多次执行，被不同的输入循环调用；\n\ntarget 函数需要容忍任何形势的输入，比如空数据、很长的数据、格式错误的数据等；\n\ntarget 函数不允许调用 exit 函数，否则将导致 Fuzz 终止执行；\n\ntarget 函数中可以使用线程，但是子线程要在函数体结束前 join，即进入下一次循环前，结束上一次循环的子线程；\n\ntarget 函数的结果必须是确定性的，即两次的 Data 如果一致，两次的执行结果也必须一致；\n\ntarget 函数执行速度必须快，避免三阶及以上的复杂度、日志记录和过多的内存消耗；\n\ntarget 函数应尽量避免修改全局状态，因为在同一个进程中修改全局变量，会导致下一次运行与上一次运行的上下文不同，可能影响程序确定性；\n\ntarget 函数的处理范围越窄越好，如果函数要处理多种数据格式，那最好拆分成多个子函数，每个子函数处理一种格式。\n\n\ntarget 函数编写完成后，通过以下命令编译成可执行文件：\n1234clang -g -O1 -fsanitize=fuzzer                         fuzz_target.cc # Builds the fuzz target w/o sanitizersclang -g -O1 -fsanitize=fuzzer,address                 fuzz_target.cc # Builds the fuzz target with ASANclang -g -O1 -fsanitize=fuzzer,signed-integer-overflow fuzz_target.cc # Builds the fuzz target with a part of UBSANclang -g -O1 -fsanitize=fuzzer,memory                  fuzz_target.cc # Builds the fuzz target with MSAN\n\nClang 支持的编译选项可以  参考文档  或者通过–help 查看，构建 LibFuzzer target 时常用的  编译选项  如下：\n\n-g：生成调试信息\n\n-O：设置编译器优化等级，可以是 1&#x2F;2&#x2F;3，默认为 1，数字越大，优化越多，注意2 和 3 有可能导致 Fuzz 找不到 crash\n\n-o：指定输出文件名\n\n-I：uppercase i，添加头文件搜索路径\n\n-L：添加库文件搜索路径\n\n-l：lowercase L，指定库文件名称，动态库和静态库同时存在时，动态库优先\n\n-fsanitize：启用 LibFuzzer，对源码进行插桩，并添加各种  消毒器 sanitizer，对程序进行运行时检查。\n\n-fsanitize&#x3D;fuzzer  编译时对源码插桩，链接 libFuzzer 库文件（使用 libFuzzer 的 main 函数）\n\n-fsanitize&#x3D;fuzzer-no-link  编译时对源码插桩，不链接 libFuzzer，适用于拥有 main 函数的源码。对大型项目来说，构建效率更高\n\n-fsanitize&#x3D;address  地址消毒器（AddressSanitizer），用于检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n-fsanitize&#x3D;memory  内存消毒器（MemorySanitizer），用于检测未初始化的内存访问\n\n-fsanitize&#x3D;undefined  未定义行为消毒器（UndefinedBehaviorSanitizer），用于检测程序运行中未定义行为，如越界访问、整数溢出、空指针解引用等\n\n\n\n-fsanitize-coverage：启用代码覆盖率的统计，包括 function 级别，basic block 级别和 edge 级别，详情可  参考文档 。但需要注意的是， 高版本的 clang 中，已经取消了对 -fsanitize-coverage&#x3D;trace-pc-guard 的支持，建议改用 -fsanitize&#x3D;fuzzer 替代，否则会出现报错，参见第二章节使用示例。\n\n-fsanitize-coverage&#x3D;trace-pc-guard,edge  使用 edge 级别代码覆盖率，edge 为默认级别，可省略\n\n-fsanitize-coverage&#x3D;trace-pc-guard,func  使用 function 级别代码覆盖率\n\n-fsanitize-coverage&#x3D;trace-pc-guard,bb  使用 basic block 级别代码覆盖率\n\n\n\n\n关于添加 LibFuzzer 相关选项后的详细构建过程，有兴趣可以参考libFuzzer 编译链接。\n关于 LibFuzzer 通过插桩统计代码覆盖率的具体实现，有兴趣可以参考Coverage Control in libFuzzer。\n3. 执行 fuzz在 target 函数构建成功后，会生成一个可执行的 fuzz 二进制文件，该文件通过命令行方式执行，可以接受指定的参数选项。执行格式为：\n1./fuzz-target -flag1=val1 -flag2=val2 ... path1 path2 ...\n\n在不限制运行时长的情况下，Fuzz 将会一直执行下去，直到出现 crash（通常是因为触发 sanitizer 异常）才会终止。导致 crash 的输入将会作为能触发 bug 的 testcase 保存到磁盘上，并根据 crash 的类型，用不同的文件名前缀进行区分，比如 crash-XXX，leak-XXX，timeout-XXX 等。\n(1) 参数说明  常见的 flag 选项及作用列举如下，使用 flag 时必须以 -flag&#x3D;val 的格式：\n\n\n\nflag\n默认值\n作用\n\n\n\nverbosity\n1\n运行时输出详细日志\n\n\nseed\n0\n随机种子。如果为 0，则自动生成随机种子\n\n\nruns\n-1\n测试运行的次数（-1 表示无限）\n\n\nmax_len\n0\n测试输入的最大长度。若为 0，libFuzzer 会自行猜测\n\n\nshuffle\n1\n为 1 表示启动时打乱初始语料库\n\n\nprefer_small\n1\n为 1 表示打乱语料库时，较小输入更优先\n\n\ntimeout\n1200\n超时时长，单位为秒。如果单次运行超过时长，Fuzz 将被终止\n\n\nmax_total_time\n0\n最大运行时长，单位为秒。若为正，表示 Fuzz 最长运行时间\n\n\nhelp\n0\n为 1 表示打印帮助信息\n\n\nmerge\n0\n为 1 表示在不损失代码覆盖率的情况下，进行语料库合并\n\n\nmerge_control_file\n0\n指定合并进程的控制文件，用于恢复合并状态\n\n\nminimize_crash\n0\n为 1 表示将提供的崩溃输入进行最小化。与 -runs &#x3D; N 或 -max_total_time &#x3D; N 一起使用以限制尝试次数\n\n\njobs\n0\njob 的数量，多个 job 将被分配到 workers 上执行，每个 job 的 stdout&#x2F;stderr 被重定向到 fuzz-&lt;JOB&gt;.log\n\n\nworkers\n0\nworker 的数量，为 0 将使用 min(jobs, number_of_cpu_cores&#x2F;2)\n\n\nreload\n1\n设置重新加载主语料库的间隔秒数。在并行模式下，在多个 job 中同步语料集。为 0 表示禁止\n\n\nreduce_inputs\n1\n为 1 表示尝试减少输入数据的大小，同时保留其完整的特征集\n\n\nrss_limit_mb\n2048\nRSS 内存用量限制，单位为 Mb。为 0 表示无限制\n\n\npurge_allocator_interval\n1\n清理缓存的建个时长，单位为秒。当指定 rss_limit_mb 且 rss 使用率超过 50% 时，开始清理。为 -1 表示禁止\n\n\nmalloc_limit_mb\n0\n单次 malloc 申请内存的大小限制，单位为 Mb。为 0 则采用 rss_limit_mb 进行限制\n\n\ndetect_leaks\n1\n为 1，且启用 LeakSanitizer 消毒器时，将在 Fuzz 过程中检测内存泄漏，而不仅是在 Fuzz 结束时才检测\n\n\nprint_coverage\n0\n退出时打印覆盖率信息\n\n\nprint_corpus_stats\n0\n退出时打印语料信息\n\n\nprint_final_stats\n0\n退出时打印统计信息\n\n\nonly_ascii\n0\n为 1 表示只生成 ASCII（isprint + isspace）字符作为输入\n\n\nartifact_prefix\n0\n将 fuzzing artifacts（crash、timeout 等 file）保存为文件时所使用的前缀，即文件将保存为 $(artifact_prefix)file\n\n\nexact_artifact_path\n0\n将单个 fuzz artfifact 保存为文件时所使用的前缀。将覆盖 -artifact_prefix，并行任务中不要使用相同取值\n\n\n(2) 语料使用  模糊测试通过随机的方式变异或生成测试用例。提供种子语料库作为随机变异的基础用例，避免从头开始生完全随机地生成用例，在待测函数接受复杂或结构化输入的情况下，能显著提升 Fuzz 测试的效率和覆盖率。\nLibFuzzer 是以覆盖率为引导的，当提供种子语料库时，LibFuzzer 从语料库中读取语料，通过随机变异产生新的测试数据，输入到 Fuzz Target。由于在构建 Fuzz Target 时，通过编译参数进行了代码插桩，因此可以跟踪 Fuzz Target 在接收到输入后，具体执行了哪些代码。如果某个测试输入能执行到之前从未执行的代码，那么这个测试输入就是一个有效变异，将被纳入到语料库，作为后续变异的基础。整体流程大致如下，仅做原理示意，不等于具体实现。\ngraph LR\n    A[从语料库中读取样本] --> B[随机变异生成新样本]\n    B --> C[新样本输入 Fuzz Target]\n    C --> D[跟踪代码执行路径]\n    D --> E{是否覆盖新的代码}\n    E -->| 是 | F[测试数据加入语料库]\n    E -->| 否 | B\n    F --> A\n\n使用 corpus 时，需要提供一个或多个存放种子语料的路径，命令为：\n1./fuzz_target -max_len=1000 -jobs=20 corpus_dir  # 种子语料存放在 corpus_dir 目录下\n\n当语料库很大时，可以在保持代码覆盖率的情况下进行精简操作，这时需要用 -merge 参数，命令为：\n1./fuzz_target -merge=1 mini_corpus_dir corpus_dir  # 原始语料集存放在 corpus_dir 目录下，精简后的语料集存放在 mini_corpus_dir 目录下\n\n利用 -merge 参数，还可以实现有效语料的提取，即从一批候选语料中，找到能够触发新代码路径的语料，命令为：\n1./fuzz_target -merge=1 interesting_corpus_dir candidate_corpus_dir  # 候选语料放在 candidate_corpus_dir，有效语料放在 interesting_corpus_dir\n\n总的来说，语料集的路径可以有一个、两个或更多，当使用 -merge 参数时，这些语料集中发现的有效语料，都会被保存到第一个路径下。需要注意的是，合并语料是一个非常耗时的过程，通过使用 -merge_control_file 参数，可以实现无缝恢复的多阶段合并，即通过 killall -SIGUSR1 /path/to/fuzzer/binary 中断合并操作后，下次还能继续上一次的合并进度，继续开始合并操作。示例如下：\n123456789101112131415% rm -f SomeLocalPath% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-INNER: using the control file &#x27;SomeLocalPath&#x27;...# While this is running, do `killall -SIGUSR1 my_fuzzer` in another console==9015== INFO: libFuzzer: exiting as requested# This will leave the file SomeLocalPath with the partial state of the merge.# Now, you can continue the merge by executing the same command. The merge will continue from where it has been interrupted.% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-OUTER: non-empty control file provided: &#x27;SomeLocalPath&#x27;MERGE-OUTER: control file ok, 32 files total, first not processed file 20...\n\n语料库除了用于提高 Fuzz 效率，还可用于回归测试。在回归测试和复现 crash 时，还可以具体指定某一个 testcase，命令为：\n1./fuzz_target testcase_path  # testcase_path 就是 fuzz crash 时保存的 testcase file 的文件路径\n\n4. 输出解读  在 Fuzz 执行过程中，标准错误流 stderr 中，通常会输出以下格式的内容：\n12345678910111213INFO: Seed: 1523017872INFO: Loaded 1 modules (16 guards): [0x744e60, 0x744ea0),INFO: -max_len is not provided, using 64INFO: A corpus is not provided, starting from an empty corpus#0    READ units: 1#1    INITED cov: 3 ft: 2 corp: 1/1b exec/s: 0 rss: 24Mb#3811 NEW    cov: 4 ft: 3 corp: 2/2b exec/s: 0 rss: 25Mb L: 1 MS: 5 ChangeBit-ChangeByte-ChangeBit-ShuffleBytes-ChangeByte-#3827 NEW    cov: 5 ft: 4 corp: 3/4b exec/s: 0 rss: 25Mb L: 2 MS: 1 CopyPart-#3963 NEW    cov: 6 ft: 5 corp: 4/6b exec/s: 0 rss: 25Mb L: 2 MS: 2 ShuffleBytes-ChangeBit-#4167 NEW    cov: 7 ft: 6 corp: 5/9b exec/s: 0 rss: 25Mb L: 3 MS: 1 InsertByte-==31511== ERROR: libFuzzer: deadly signal...artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-b13e8756b13a00cf168300179061fb4b91fefbed\n\n第一行显示 Fuzz 测试使用的随机种子，可以通过 -seed 参数来设置。\n第二行显示插桩后的 PC guards 数量（PC 指 Program Counter），可理解为 Fuzz 识别出来的 edge 总数，参考  此处脚注说明。\n第三行显示输入数据的长度限制，示例中 -max_len 参数没有设置，Fuzz 程序将 -max_len 定为 64，即最大数据长度不超过 64kb。\n第四行显示语料库信息，示例中没有提供 corpus，Fuzz 程序从头开始生成语料。\n第五行到第十行，每行开头的 #N 表示 Fuzz 已执行了 N 次测试输入，后面的内容为测试过程中的事件代码和统计信息：\n\n\n\n事件代码\n含义\n\n\n\nREAD\nFuzz 已从语料库中读取所有初始输入样本\n\n\nINITED\nFuzz 已完成初始化，包括通过被测代码运行每个初始输入样本\n\n\nNEW\nFuzz 生成了一个测试输入样本，它能触发被测代码的新路径，将被保存到主语料库目录\n\n\nREDUCE\nFuzz 找到了一个更好的输入样本，它能保持原有样本的特征集（参考下表 ft 含义），但是 size 更小\n\n\npulse\nFuzz 已生成 2 的 n 次方个输入（定期生成以使用户确信 Fuzz 仍在工作）\n\n\nDONE\nFuzz 已完成操作，因为它已达到指定的迭代限制（-runs）或时间限制（-max_total_time）\n\n\nRELOAD\nFuzz 正在定期重新加载语料库目录中的输入样本，这使它能够发现其他 Fuzz 进程发现的任何输入\n\n\n\n\n\n统计指标\n含义\n\n\n\ncov\n执行当前语料库所覆盖的 block 或 edge 的总数\n\n\nft\nLibFuzzer 使用不同的信号来评估代码覆盖率：边缘覆盖率、边缘计数器、间接调用者 &#x2F; 被调用者对等。这些信号组合起来称为特征\n\n\ncorp\n当前内存测试语料库中的条目数及其大小（单位为 byte）\n\n\nlim\n当前语料库中新样本的长度限制。 随着时间的推移而增加，直到达到最大长度 (-max_len)\n\n\nexec&#x2F;s\n每秒 Fuzz 执行次数\n\n\nrss\n当前内存消耗（单位为 Mb）\n\n\nL\n新样本的大小（单位为 byte）。只用于 NEW 和 REDUCE 事件\n\n\nMS: &lt;n&gt; &lt;operations&gt;\n生成新样本时的变异次数和变异方法。只用于 NEW 和 REDUCE 事件\n\n\n第十一行开始，显示 Fuzz 遇到 crash 并终止执行，导致 crash 的用例被保存为.&#x2F;crash-&lt;sha1&gt; 文件，保存路径和名称可以通过 -artifact_prefix 参数修改。\n二、使用示例  以CVE-2016-5180为例，演示 LibFuzzer 的使用过程。CVE-2016-5180是在 c-ares 中出现的堆溢出问题，是使得 ChromeOS 被攻击（重启后以访客模式执行代码）的漏洞之一。\n1. 下载源码  最新的 c-ares 代码已修复漏洞，为了复现漏洞，clone 代码后，需要恢复到漏洞修复之前。\n123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n\n2. 编写 Fuzz 主函数  实现 LLVMFuzzerTestOneInput 函数，将 LibFuzzer 输入的字节流进行转换，调用 ares_create_query 函数，并将代码保存为 target.cc 文件。\n1234567891011121314151617// Copyright 2016 Google Inc. All Rights Reserved.// Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);#include &lt;stdint.h&gt;#include &lt;stdlib.h&gt;#include &lt;string&gt;#include &lt;arpa/nameser.h&gt;#include &lt;ares.h&gt;extern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  unsigned char *buf;  int buflen;  std::string s(reinterpret_cast&lt;const char *&gt;(Data), Size);  ares_create_query(s.c_str(), ns_c_in, ns_t_a, 0x1234, 0, &amp;buf, &amp;buflen, 0);  free(buf);  return 0;&#125;\n\n3. 编译 Fuzz target使用 fuzzer-test-suite 提供的编译脚本，执行 build.sh 脚本，会自动调用 custom-build.sh 和 common.sh 进行编译。三个 shell 脚本和 Fuzz 函数的存放路径如下，脚本中会自动使用 git 拉取代码，这里将第 1 步手动拉取的代码删掉了：\n123456789sqa@twtpesqa03:~/dss/fuzz$ tree.├── cares│   ├── build.sh│   └── target.cc├── common.sh└── custom-build.sh1 directory, 4 files\n\n注意需要将原始脚本中的 -fsanitize-coverage&#x3D;trace-pc-guard 替换为 -fsanitize&#x3D;fuzzer，否则执行 Fuzz 时会出现错误：-fsanitize-coverage&#x3D;trace-pc-guard is no longer supported by libFuzzer。\n1234sqa@twtpesqa03:~/dss/fuzz$ ./cares-fsanitize_fuzzer-fsanitize-coverage=trace-pc-guard is no longer supported by libFuzzer.Please either migrate to a compiler that supports -fsanitize=fuzzeror use an older version of libFuzzer\n\n执行脚本进行编译（也可以自己编写命令进行编译，编译相关的内容之后会单独写文章进行说明）：\n1sqa@twtpesqa03:~/dss/fuzz$ ./cares/build.sh\n\n编译完后，可以看到目录下多了一个二进制文件 cares-fsanitize_fuzzer，两个目录 BUILD 和 SRC。cares-fsanitize_fuzzer 是可执行的 Fuzz 程序，SRC 目录存放 c-ares 含漏洞的源码，BUILD 目录用于存放编译产生的中间文件和最终文件：\n12345678910sqa@twtpesqa03:~/dss/fuzz$ tree -L 1.├── BUILD├── cares├── cares-fsanitize_fuzzer├── common.sh├── custom-build.sh└── SRC3 directories, 3 files\n\n4. 执行 Fuzz 测试  直接运行编译得到的二进制文件，如需附带参数，可参考第一章节执行 fuzz 的参数说明。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778sqa@twtpesqa03:~/dss/fuzz$ ./cares-fsanitize_fuzzerINFO: Seed: 817252946INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#3      NEW    cov: 4 ft: 4 corp: 2/5b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#10     REDUCE cov: 4 ft: 4 corp: 2/4b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 2 ChangeByte-CrossOver-#11     REDUCE cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 1 EraseBytes-#1368   REDUCE cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-InsertRepeatedBytes-#1524   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 1 EraseBytes-===================================================================3049145==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6030012599c2 at pc 0x000000550e1c bp 0x7fffbad826d0 sp 0x7fffbad826c8WRITE of size 1 at 0x6030012599c2 thread T0    #0 0x550e1b in ares_create_query (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/sqa/dss/fuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x44973e)    #7 0x472582 in main (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x472582)    #8 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x41e4dd)0x6030012599c2 is located 0 bytes to the right of 18-byte region [0x6030012599b0,0x6030012599c2)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/sqa/dss/fuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x44973e)    #8 0x472582 in main (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x472582)    #9 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c06802432e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c06802432f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243300: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243310: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243320: fa fa fa fa fa fa fa fa fa fa fd fd fd fa fa fa=&gt;0x0c0680243330: fd fd fd fa fa fa 00 00[02]fa fa fa fd fd fd fa  0x0c0680243340: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243350: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c0680243360: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c0680243370: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243380: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==3049145==ABORTINGMS: 4 ChangeByte-InsertByte-CopyPart-ChangeByte-; base unit: 00b28ff06b788b9b67c6b259800f404f9f3761fd0x5c,0x2e,0x0,0x6b,0x0,\\\\.\\x00k\\x00artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-edef708d314ed627eba0ef2b042e47aa96a9b899Base64: XC4AawA=\n\n可以看到，LibFuzzer 发现了 c-ares 中的 heap-buffer-overflow 漏洞，触发 crash 的用例保存为 crash-edef708d314ed627eba0ef2b042e47aa96a9b899 文件，该用例包含 5 个字节，字节码分别为：0x5c,0x2e,0x0,0x6b,0x0，其中 0x0 为空字符 NULL，属于不可见字符。\n5. 提取语料  执行 Fuzz 时，传入一个空文件夹作为 copus 路径，执行完后，可以在文件夹中看到 LibFuzzer 执行过程中，生成的有效语料。\n123456789101112131415161718192021222324252627282930313233343536373839404142sqa@twtpesqa03:~/dss/fuzz/cares$ mkdir corpussqa@twtpesqa03:~/dss/fuzz/cares$ lsBUILD  build.sh  cares_fuzzer  corpus  target.ccsqa@twtpesqa03:~/dss/fuzz/cares$ ./cares_fuzzer corpus/INFO: Seed: 4140748905INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO:        0 files found in corpus/INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 13 ft: 14 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 16 ft: 20 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeByte-InsertByte-#9      NEW    cov: 16 ft: 26 corp: 3/6b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 5 ChangeBit-ChangeByte-ChangeByte-CopyPart-InsertByte-#10     NEW    cov: 16 ft: 32 corp: 4/10b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#25     NEW    cov: 18 ft: 34 corp: 5/11b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 5 ChangeBit-ChangeASCIIInt-CMP-CrossOver-EraseBytes- DE: &quot;\\x01\\x00&quot;-#94     NEW    cov: 19 ft: 35 corp: 6/15b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 4 CrossOver-ShuffleBytes-ChangeByte-ChangeBit-#108    NEW    cov: 21 ft: 37 corp: 7/16b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 4 ChangeByte-ShuffleBytes-ChangeBit-ChangeByte-#125    NEW    cov: 22 ft: 38 corp: 8/18b lim: 4 exec/s: 0 rss: 27Mb L: 2/4 MS: 2 ShuffleBytes-InsertByte-...==3237059==ABORTINGMS: 2 InsertRepeatedBytes-ChangeByte-; base unit: 1bef8aac927d18852642a96c20e50efba80fdfae0x5c,0x5,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x5c,0x2e,\\\\\\x05\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7Base64: XAWYmJiYmJiYmJiYmFwusqa@twtpesqa03:~/dss/fuzz/cares$ ls -altotal 2244drwxrwxr-x 4 sqa sqa    4096 Sep 26 17:47 .drwxrwxr-x 5 sqa sqa    4096 Sep 26 15:25 ..drwxrwxr-x 9 sqa sqa   20480 Sep 26 17:18 BUILD-rw-rw-r-- 1 sqa sqa     722 Sep 26 17:13 build.sh-rwxrwxr-x 1 sqa sqa 2250720 Sep 26 17:18 cares_fuzzerdrwxrwxr-x 2 sqa sqa    4096 Sep 26 17:47 corpus-rw-rw-r-- 1 sqa sqa      15 Sep 26 17:47 crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7-rw-rw-r-- 1 sqa sqa     499 Sep 26 17:14 target.ccsqa@twtpesqa03:~/dss/fuzz/cares$ ls corpus/08534f33c201a45017b502e90a800f1b708ebcb3  5175b74bd75b8d90a01f77709deba3982fbbdcb2  78bdce51613f555049a9937095bf469bcb77e94f  be566cb17d3bce0b2a8e5e710b3779df720db1f50f1c5448bf80343eeac759f8adcbdc2720533d15  5318c4ac20dac95a702bee2e27834d39ea6bc2b6  8e54ed049741d7cf6fb8ef7f4288ef0be3b54f17  be5c29e07560abcf094c3419712a01590bbe85940fe509b10d833be6eb3d5ed4947cbe0fbb64ed84  5ba93c9db0cff93f52b521d7420e43f6eda2784f  8ea51a3719d7cbfc3e2dcd3edf6109918d5aad55  caea31b9ef76b9be352ad1054956efbb86d4451a1bef8aac927d18852642a96c20e50efba80fdfae  60321f72401b49b895535045eb8d3b9ca7db7c7c  91a3f7c503955600f5dac12c1c1a3c5b674a4d98  dea712be0e801f4502a21e04dfbec5bd0cbc677c24792aa3923c4cd185519d3d445ecfd0801db1c1  6380a9a2d2701df0cb53d880842747cbefef8a5d  9f64357cb30f24cf567513e140e9fb0cbf1a2be5  e716589d09e16cf4a48d2c7f1d357bb481aaf3bc3a52ce780950d4d969792a2559cd519d7ee8c727  6414bd7955e39106721edf7cc29efdb82f7007ac  b534844fd943d8b338025ad82d68283f1bcdb5c0\n\n6. 合并语料  当 Fuzz 执行很久之后，会产生大量语料。为了减少语料数量，可以使用 merge 参数进行合并。创建一个 min_corpus 目录，执行 Fuzz 时，启动 merge 参数，传入 min_corpus 目录和 corpus 目录，合并完后，可以在 min_corpus 目录下看到缩减之后的语料。以下示例显示预料数据从 31 个减少到 29 个：\n1234567891011121314151617181920212223sqa@twtpesqa03:~/dss/fuzz/cares$ mkdir min_corpussqa@twtpesqa03:~/dss/fuzz/cares$ ./cares_fuzzer -merge=1 min_corpus/ corpus/INFO: Seed: 1671146211INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),MERGE-OUTER: 31 files, 0 in the initial corpus, 0 processed earlierMERGE-OUTER: attempt 1INFO: Seed: 1671165588INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytesMERGE-INNER: using the control file &#x27;/tmp/libFuzzerTemp.3327149.txt&#x27;MERGE-INNER: 31 total files; 0 processed earlier; will process 31 files now#1      pulse  cov: 9 ft: 10 exec/s: 0 rss: 27Mb#2      pulse  cov: 13 ft: 14 exec/s: 0 rss: 27Mb#4      pulse  cov: 20 ft: 22 exec/s: 0 rss: 27Mb#8      pulse  cov: 28 ft: 38 exec/s: 0 rss: 27Mb#16     pulse  cov: 29 ft: 56 exec/s: 0 rss: 27Mb#31     DONE   cov: 29 ft: 82 exec/s: 0 rss: 28MbMERGE-OUTER: succesfull in 1 attempt(s)MERGE-OUTER: the control file has 2691 bytesMERGE-OUTER: consumed 0Mb (27Mb rss) to parse the control fileMERGE-OUTER: 29 new files with 82 new features added; 29 new coverage edges\n\n三、优化技巧  整体优化思路分两种：\n\n找到 crash 更快 –&gt; 并行化，多个实例一起运行\n覆盖 edge 更多 –&gt; 加强语料，让输入能走到更深的分支\n\n（一）并行化1、LibFuzzer(1) jobs 和 workers\n\njobs：指定 fuzz 实例的数量。在不设置运行时长的情况下，每个 fuzz 实例找到 crash 才会停止。理论上有多少 jobs，最后会产生多少个 crash 文件。但实际上，不同的 job 可能找到同样的 crash，最后 crash 文件个数少于 job 个数。\nworks：执行 fuzz 进程的数量。在多个 jobs 的情况下，平均每个 woker 执行 #jobs&#x2F;#workers 个 job。\n\n简单来说，使用 workers 能提升 fuzz 运行速度，使用 jobs 能增加 crash 数量（仅根据输入去重，没有对调用栈去重）。 只使用 jobs 的情况下，默认开启 min(#jobs, #cores) &#x2F;&#x2F; 2 个 workers。\n(2) fork\n目前 fork 是实验阶段的参数，计划最终使用 fork 代替 jobs 和 workers 来实现 LibFuzzer 的并行化。\n\nfork：父进程不直接执行 fuzz，而是开启 N 个子进程，每个子进程使用语料库的随机子集进行 fuzz，当子进程退出后，该子进程的语料将被合并到主语料库中。子进程可以通过设置参数，来实现对指定错误的容错能力：\n\n-ignore_ooms：默认为 True。子进程发生内存溢出时，保存输入用于重现，但 fuzz 继续执行。\n\n-ignore_timeouts：默认为 True。子进程发生超时时，保留输入用于重现，但 fuzz 继续执行。\n\n-ignore_crashes：默认为 False。子进程发生其他类型 crash 时，保留输入用于重现，但 fuzz 继续执行。\n\n\n2、LibFuzzer 结合 AFLAFL 可以支持 LibFuzzer 的 target，编译方法参考  此处说明。\n12afl-fuzz -i testcase_dir -o findings_dir ./fuzz-target @@ ./fuzz-target testcase_dir findings_dir # Will write new tests to testcase_dir\n\n需要定期重启 AFL 和 LibFuzzer，以完成语料同步。\n（二）加强语料 1、字典 运行时使用 -dict 参数指定字典（Dictionary）文件的路径，字典用于指定和控制模糊测试中输入数据的一部分，从而提高模糊测试的效果。\n字典文件：\n12345678910# Lines starting with &#x27;#&#x27; and empty lines are ignored.# Adds &quot;blah&quot; (w/o quotes) to the dictionary.kw1=&quot;blah&quot;# Use \\\\ for backslash and \\&quot; for quotes.kw2=&quot;\\&quot;ac\\\\dc\\&quot;&quot;# Use \\xAB for hex valueskw3=&quot;\\xF7\\xF8&quot;# the name of the keyword followed by &#x27;=&#x27; may be omitted:&quot;foo\\x0Abar&quot;\n\n使用方法（运行时）：\n1./fuzz-target -dict=dict_file\n\n2、CMP编译时使用 -fsanitize-coverage&#x3D;trace-cmp 参数，让 fuzz 拦截 CMP 指令（例如 if 语句中的 compare 条件）并根据拦截到的 CMP 指令的参数来引导变异。这可能会减慢模糊测试的速度，但很可能会改善测试结果。\n使用方法（编译时）：\n1clang++ buggy.cc -fsanitize=fuzzer,address -fsanitize-coverage=trace-cmp -g -o buggy-fuzzer\n\n3、Value Profile需要与 -fsanitize-coverage=trace-cmp 一起使用，让 fuzz 收集 CMP 指令的参数值进行分析，用于发现更多的有效输入。但是有两个缺点：首先可能会导致速度降低 2 倍。 其次语料库可能增长数倍。\n使用方法（运行时）：\n1./fuzz-target -use_value_profile=1\n\n4、Fuzzer-friendly build mode程序中可能存在某些对 fuzz 不友好的特性，例如：\n\n随机化：同一个输入，可能走不同的路径\n校验和：拦截无效输入\n\n此时可以用构建宏 FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 来编译一个对 fuzz 友好的版本，使用时需要对源码进行修改。例如：\n12345678void MyInitPRNG() &#123;#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  // In fuzzing mode the behavior of the code should be deterministic.  srand(0);#else  srand(time(0));#endif&#125;\n\n四、 参考资料\nlibFuzzer – a library for coverage-guided fuzz testing\nlibFuzzer 使用总结教程\nEfficient Fuzzing Guide\nThe art of fuzzing-A Step-by-Step Guide to Coverage-Guided Fuzzing with LibFuzzer\nAn introduction to LLVM libFuzzer\nAn informative guide on using AFL and libFuzzer\nlibfuzzer-workshop\nSanitizers\nThe Magic Behind Feedback-Based Fuzzing\n","dateCreated":"2023-09-17T18:30:15+08:00","dateModified":"2024-04-09T14:20:43+08:00","datePublished":"2023-09-17T18:30:15+08:00","description":"模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完","headline":"LibFuzzer 使用说明","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/09/17/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/09/17/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/","keywords":"Fuzz, 安全, 教程, LibFuzzer"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n按照  官方定义，LibFuzzer 是一个in-process（进程内的），coverage-guided（以覆盖率为引导的），evolutionary（进化的） 的 fuzz 引擎，是 LLVM 项目的一部分，主要用于对 C&#x2F;C++ 程序进行 Fuzz 测试。LibFuzzer 三个特性的具体含义为：\n\nin-process：不会为每个测试用例启动一个进程，而是将所有的测试数据投放在同一个进程的内存空间中\n\ncoverage-guided：对每一个测试输入都进行代码覆盖率计算，不断累积测试用例使得代码覆盖率最大化\n\nevolutionary：结合了变异和生成两种形势的 Fuzz 引擎\n\n变异：基于已有的数据样本，通过一些变异规则，产生新的测试用例\n\n生成：通过对目标协议或接口规范进行建模，从零开始产生测试用例\n\n\n\n\nLibFuzzer 与待测的 library 进行链接，通过向指定的 fuzzing 入口（即target 函数）发送测试数据，并跟踪被触达的代码区域，然后对输入的数据进行变异，以达到代码覆盖率最大的目的，其中代码覆盖率的信息由 LLVM 的 SanitizerCoverage 工具提供。\n一、使用方法 1. 安装环境Clang 是一个类似 GCC 的 C&#x2F;C++ 语言编译工具，此处 简介。LibFuzzer 现在已被集成到 Clang 6.0 之后的版本中，在 Linux 环境下，只需直接安装 Clang 即可：\n1apt install clang\n\n安装完毕之后，可以通过如下命令查看 clang 版本：\n1clang --version\n\n2. 构建 target使用 LibFuzzer 时，第一步就是要实现 target 函数——LLVMFuzzerTestOneInput，该函数以 bytes 数组作为输入，函数体内使用待测 API 对这个 bytes 数组进行处理：\n12345// fuzz_target.ccextern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  DoSomethingInterestingWithMyAPI(Data, Size);  return 0;  // Values other than 0 and -1 are reserved for future use.&#125;\n\ntarget 函数的名称、参数类型、返回值类型都不能改变。此外，官方文档中还有如下说明：\n\ntarget 函数在同一个进程中被多次执行，被不同的输入循环调用；\n\ntarget 函数需要容忍任何形势的输入，比如空数据、很长的数据、格式错误的数据等；\n\ntarget 函数不允许调用 exit 函数，否则将导致 Fuzz 终止执行；\n\ntarget 函数中可以使用线程，但是子线程要在函数体结束前 join，即进入下一次循环前，结束上一次循环的子线程；\n\ntarget 函数的结果必须是确定性的，即两次的 Data 如果一致，两次的执行结果也必须一致；\n\ntarget 函数执行速度必须快，避免三阶及以上的复杂度、日志记录和过多的内存消耗；\n\ntarget 函数应尽量避免修改全局状态，因为在同一个进程中修改全局变量，会导致下一次运行与上一次运行的上下文不同，可能影响程序确定性；\n\ntarget 函数的处理范围越窄越好，如果函数要处理多种数据格式，那最好拆分成多个子函数，每个子函数处理一种格式。\n\n\ntarget 函数编写完成后，通过以下命令编译成可执行文件：\n1234clang -g -O1 -fsanitize=fuzzer                         fuzz_target.cc # Builds the fuzz target w/o sanitizersclang -g -O1 -fsanitize=fuzzer,address                 fuzz_target.cc # Builds the fuzz target with ASANclang -g -O1 -fsanitize=fuzzer,signed-integer-overflow fuzz_target.cc # Builds the fuzz target with a part of UBSANclang -g -O1 -fsanitize=fuzzer,memory                  fuzz_target.cc # Builds the fuzz target with MSAN\n\nClang 支持的编译选项可以  参考文档  或者通过–help 查看，构建 LibFuzzer target 时常用的  编译选项  如下：\n\n-g：生成调试信息\n\n-O：设置编译器优化等级，可以是 1&#x2F;2&#x2F;3，默认为 1，数字越大，优化越多，注意2 和 3 有可能导致 Fuzz 找不到 crash\n\n-o：指定输出文件名\n\n-I：uppercase i，添加头文件搜索路径\n\n-L：添加库文件搜索路径\n\n-l：lowercase L，指定库文件名称，动态库和静态库同时存在时，动态库优先\n\n-fsanitize：启用 LibFuzzer，对源码进行插桩，并添加各种  消毒器 sanitizer，对程序进行运行时检查。\n\n-fsanitize&#x3D;fuzzer  编译时对源码插桩，链接 libFuzzer 库文件（使用 libFuzzer 的 main 函数）\n\n-fsanitize&#x3D;fuzzer-no-link  编译时对源码插桩，不链接 libFuzzer，适用于拥有 main 函数的源码。对大型项目来说，构建效率更高\n\n-fsanitize&#x3D;address  地址消毒器（AddressSanitizer），用于检测缓冲区溢出、UAF、Double Free、内存泄漏等内存问题\n\n-fsanitize&#x3D;memory  内存消毒器（MemorySanitizer），用于检测未初始化的内存访问\n\n-fsanitize&#x3D;undefined  未定义行为消毒器（UndefinedBehaviorSanitizer），用于检测程序运行中未定义行为，如越界访问、整数溢出、空指针解引用等\n\n\n\n-fsanitize-coverage：启用代码覆盖率的统计，包括 function 级别，basic block 级别和 edge 级别，详情可  参考文档 。但需要注意的是， 高版本的 clang 中，已经取消了对 -fsanitize-coverage&#x3D;trace-pc-guard 的支持，建议改用 -fsanitize&#x3D;fuzzer 替代，否则会出现报错，参见第二章节使用示例。\n\n-fsanitize-coverage&#x3D;trace-pc-guard,edge  使用 edge 级别代码覆盖率，edge 为默认级别，可省略\n\n-fsanitize-coverage&#x3D;trace-pc-guard,func  使用 function 级别代码覆盖率\n\n-fsanitize-coverage&#x3D;trace-pc-guard,bb  使用 basic block 级别代码覆盖率\n\n\n\n\n关于添加 LibFuzzer 相关选项后的详细构建过程，有兴趣可以参考libFuzzer 编译链接。\n关于 LibFuzzer 通过插桩统计代码覆盖率的具体实现，有兴趣可以参考Coverage Control in libFuzzer。\n3. 执行 fuzz在 target 函数构建成功后，会生成一个可执行的 fuzz 二进制文件，该文件通过命令行方式执行，可以接受指定的参数选项。执行格式为：\n1./fuzz-target -flag1=val1 -flag2=val2 ... path1 path2 ...\n\n在不限制运行时长的情况下，Fuzz 将会一直执行下去，直到出现 crash（通常是因为触发 sanitizer 异常）才会终止。导致 crash 的输入将会作为能触发 bug 的 testcase 保存到磁盘上，并根据 crash 的类型，用不同的文件名前缀进行区分，比如 crash-XXX，leak-XXX，timeout-XXX 等。\n(1) 参数说明  常见的 flag 选项及作用列举如下，使用 flag 时必须以 -flag&#x3D;val 的格式：\n\n\n\nflag\n默认值\n作用\n\n\n\nverbosity\n1\n运行时输出详细日志\n\n\nseed\n0\n随机种子。如果为 0，则自动生成随机种子\n\n\nruns\n-1\n测试运行的次数（-1 表示无限）\n\n\nmax_len\n0\n测试输入的最大长度。若为 0，libFuzzer 会自行猜测\n\n\nshuffle\n1\n为 1 表示启动时打乱初始语料库\n\n\nprefer_small\n1\n为 1 表示打乱语料库时，较小输入更优先\n\n\ntimeout\n1200\n超时时长，单位为秒。如果单次运行超过时长，Fuzz 将被终止\n\n\nmax_total_time\n0\n最大运行时长，单位为秒。若为正，表示 Fuzz 最长运行时间\n\n\nhelp\n0\n为 1 表示打印帮助信息\n\n\nmerge\n0\n为 1 表示在不损失代码覆盖率的情况下，进行语料库合并\n\n\nmerge_control_file\n0\n指定合并进程的控制文件，用于恢复合并状态\n\n\nminimize_crash\n0\n为 1 表示将提供的崩溃输入进行最小化。与 -runs &#x3D; N 或 -max_total_time &#x3D; N 一起使用以限制尝试次数\n\n\njobs\n0\njob 的数量，多个 job 将被分配到 workers 上执行，每个 job 的 stdout&#x2F;stderr 被重定向到 fuzz-&lt;JOB&gt;.log\n\n\nworkers\n0\nworker 的数量，为 0 将使用 min(jobs, number_of_cpu_cores&#x2F;2)\n\n\nreload\n1\n设置重新加载主语料库的间隔秒数。在并行模式下，在多个 job 中同步语料集。为 0 表示禁止\n\n\nreduce_inputs\n1\n为 1 表示尝试减少输入数据的大小，同时保留其完整的特征集\n\n\nrss_limit_mb\n2048\nRSS 内存用量限制，单位为 Mb。为 0 表示无限制\n\n\npurge_allocator_interval\n1\n清理缓存的建个时长，单位为秒。当指定 rss_limit_mb 且 rss 使用率超过 50% 时，开始清理。为 -1 表示禁止\n\n\nmalloc_limit_mb\n0\n单次 malloc 申请内存的大小限制，单位为 Mb。为 0 则采用 rss_limit_mb 进行限制\n\n\ndetect_leaks\n1\n为 1，且启用 LeakSanitizer 消毒器时，将在 Fuzz 过程中检测内存泄漏，而不仅是在 Fuzz 结束时才检测\n\n\nprint_coverage\n0\n退出时打印覆盖率信息\n\n\nprint_corpus_stats\n0\n退出时打印语料信息\n\n\nprint_final_stats\n0\n退出时打印统计信息\n\n\nonly_ascii\n0\n为 1 表示只生成 ASCII（isprint + isspace）字符作为输入\n\n\nartifact_prefix\n0\n将 fuzzing artifacts（crash、timeout 等 file）保存为文件时所使用的前缀，即文件将保存为 $(artifact_prefix)file\n\n\nexact_artifact_path\n0\n将单个 fuzz artfifact 保存为文件时所使用的前缀。将覆盖 -artifact_prefix，并行任务中不要使用相同取值\n\n\n(2) 语料使用  模糊测试通过随机的方式变异或生成测试用例。提供种子语料库作为随机变异的基础用例，避免从头开始生完全随机地生成用例，在待测函数接受复杂或结构化输入的情况下，能显著提升 Fuzz 测试的效率和覆盖率。\nLibFuzzer 是以覆盖率为引导的，当提供种子语料库时，LibFuzzer 从语料库中读取语料，通过随机变异产生新的测试数据，输入到 Fuzz Target。由于在构建 Fuzz Target 时，通过编译参数进行了代码插桩，因此可以跟踪 Fuzz Target 在接收到输入后，具体执行了哪些代码。如果某个测试输入能执行到之前从未执行的代码，那么这个测试输入就是一个有效变异，将被纳入到语料库，作为后续变异的基础。整体流程大致如下，仅做原理示意，不等于具体实现。\ngraph LR\n    A[从语料库中读取样本] --> B[随机变异生成新样本]\n    B --> C[新样本输入 Fuzz Target]\n    C --> D[跟踪代码执行路径]\n    D --> E{是否覆盖新的代码}\n    E -->| 是 | F[测试数据加入语料库]\n    E -->| 否 | B\n    F --> A\n\n使用 corpus 时，需要提供一个或多个存放种子语料的路径，命令为：\n1./fuzz_target -max_len=1000 -jobs=20 corpus_dir  # 种子语料存放在 corpus_dir 目录下\n\n当语料库很大时，可以在保持代码覆盖率的情况下进行精简操作，这时需要用 -merge 参数，命令为：\n1./fuzz_target -merge=1 mini_corpus_dir corpus_dir  # 原始语料集存放在 corpus_dir 目录下，精简后的语料集存放在 mini_corpus_dir 目录下\n\n利用 -merge 参数，还可以实现有效语料的提取，即从一批候选语料中，找到能够触发新代码路径的语料，命令为：\n1./fuzz_target -merge=1 interesting_corpus_dir candidate_corpus_dir  # 候选语料放在 candidate_corpus_dir，有效语料放在 interesting_corpus_dir\n\n总的来说，语料集的路径可以有一个、两个或更多，当使用 -merge 参数时，这些语料集中发现的有效语料，都会被保存到第一个路径下。需要注意的是，合并语料是一个非常耗时的过程，通过使用 -merge_control_file 参数，可以实现无缝恢复的多阶段合并，即通过 killall -SIGUSR1 /path/to/fuzzer/binary 中断合并操作后，下次还能继续上一次的合并进度，继续开始合并操作。示例如下：\n123456789101112131415% rm -f SomeLocalPath% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-INNER: using the control file &#x27;SomeLocalPath&#x27;...# While this is running, do `killall -SIGUSR1 my_fuzzer` in another console==9015== INFO: libFuzzer: exiting as requested# This will leave the file SomeLocalPath with the partial state of the merge.# Now, you can continue the merge by executing the same command. The merge will continue from where it has been interrupted.% ./my_fuzzer CORPUS1 CORPUS2 -merge=1 -merge_control_file=SomeLocalPath...MERGE-OUTER: non-empty control file provided: &#x27;SomeLocalPath&#x27;MERGE-OUTER: control file ok, 32 files total, first not processed file 20...\n\n语料库除了用于提高 Fuzz 效率，还可用于回归测试。在回归测试和复现 crash 时，还可以具体指定某一个 testcase，命令为：\n1./fuzz_target testcase_path  # testcase_path 就是 fuzz crash 时保存的 testcase file 的文件路径\n\n4. 输出解读  在 Fuzz 执行过程中，标准错误流 stderr 中，通常会输出以下格式的内容：\n12345678910111213INFO: Seed: 1523017872INFO: Loaded 1 modules (16 guards): [0x744e60, 0x744ea0),INFO: -max_len is not provided, using 64INFO: A corpus is not provided, starting from an empty corpus#0    READ units: 1#1    INITED cov: 3 ft: 2 corp: 1/1b exec/s: 0 rss: 24Mb#3811 NEW    cov: 4 ft: 3 corp: 2/2b exec/s: 0 rss: 25Mb L: 1 MS: 5 ChangeBit-ChangeByte-ChangeBit-ShuffleBytes-ChangeByte-#3827 NEW    cov: 5 ft: 4 corp: 3/4b exec/s: 0 rss: 25Mb L: 2 MS: 1 CopyPart-#3963 NEW    cov: 6 ft: 5 corp: 4/6b exec/s: 0 rss: 25Mb L: 2 MS: 2 ShuffleBytes-ChangeBit-#4167 NEW    cov: 7 ft: 6 corp: 5/9b exec/s: 0 rss: 25Mb L: 3 MS: 1 InsertByte-==31511== ERROR: libFuzzer: deadly signal...artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-b13e8756b13a00cf168300179061fb4b91fefbed\n\n第一行显示 Fuzz 测试使用的随机种子，可以通过 -seed 参数来设置。\n第二行显示插桩后的 PC guards 数量（PC 指 Program Counter），可理解为 Fuzz 识别出来的 edge 总数，参考  此处脚注说明。\n第三行显示输入数据的长度限制，示例中 -max_len 参数没有设置，Fuzz 程序将 -max_len 定为 64，即最大数据长度不超过 64kb。\n第四行显示语料库信息，示例中没有提供 corpus，Fuzz 程序从头开始生成语料。\n第五行到第十行，每行开头的 #N 表示 Fuzz 已执行了 N 次测试输入，后面的内容为测试过程中的事件代码和统计信息：\n\n\n\n事件代码\n含义\n\n\n\nREAD\nFuzz 已从语料库中读取所有初始输入样本\n\n\nINITED\nFuzz 已完成初始化，包括通过被测代码运行每个初始输入样本\n\n\nNEW\nFuzz 生成了一个测试输入样本，它能触发被测代码的新路径，将被保存到主语料库目录\n\n\nREDUCE\nFuzz 找到了一个更好的输入样本，它能保持原有样本的特征集（参考下表 ft 含义），但是 size 更小\n\n\npulse\nFuzz 已生成 2 的 n 次方个输入（定期生成以使用户确信 Fuzz 仍在工作）\n\n\nDONE\nFuzz 已完成操作，因为它已达到指定的迭代限制（-runs）或时间限制（-max_total_time）\n\n\nRELOAD\nFuzz 正在定期重新加载语料库目录中的输入样本，这使它能够发现其他 Fuzz 进程发现的任何输入\n\n\n\n\n\n统计指标\n含义\n\n\n\ncov\n执行当前语料库所覆盖的 block 或 edge 的总数\n\n\nft\nLibFuzzer 使用不同的信号来评估代码覆盖率：边缘覆盖率、边缘计数器、间接调用者 &#x2F; 被调用者对等。这些信号组合起来称为特征\n\n\ncorp\n当前内存测试语料库中的条目数及其大小（单位为 byte）\n\n\nlim\n当前语料库中新样本的长度限制。 随着时间的推移而增加，直到达到最大长度 (-max_len)\n\n\nexec&#x2F;s\n每秒 Fuzz 执行次数\n\n\nrss\n当前内存消耗（单位为 Mb）\n\n\nL\n新样本的大小（单位为 byte）。只用于 NEW 和 REDUCE 事件\n\n\nMS: &lt;n&gt; &lt;operations&gt;\n生成新样本时的变异次数和变异方法。只用于 NEW 和 REDUCE 事件\n\n\n第十一行开始，显示 Fuzz 遇到 crash 并终止执行，导致 crash 的用例被保存为.&#x2F;crash-&lt;sha1&gt; 文件，保存路径和名称可以通过 -artifact_prefix 参数修改。\n二、使用示例  以CVE-2016-5180为例，演示 LibFuzzer 的使用过程。CVE-2016-5180是在 c-ares 中出现的堆溢出问题，是使得 ChromeOS 被攻击（重启后以访客模式执行代码）的漏洞之一。\n1. 下载源码  最新的 c-ares 代码已修复漏洞，为了复现漏洞，clone 代码后，需要恢复到漏洞修复之前。\n123git clone https://github.com/c-ares/c-ares.gitcd c-ares/git reset --hard 51fbb479f7948fca2ace3ff34a15ff27e796afdd\n\n2. 编写 Fuzz 主函数  实现 LLVMFuzzerTestOneInput 函数，将 LibFuzzer 输入的字节流进行转换，调用 ares_create_query 函数，并将代码保存为 target.cc 文件。\n1234567891011121314151617// Copyright 2016 Google Inc. All Rights Reserved.// Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);#include &lt;stdint.h&gt;#include &lt;stdlib.h&gt;#include &lt;string&gt;#include &lt;arpa/nameser.h&gt;#include &lt;ares.h&gt;extern &quot;C&quot; int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) &#123;  unsigned char *buf;  int buflen;  std::string s(reinterpret_cast&lt;const char *&gt;(Data), Size);  ares_create_query(s.c_str(), ns_c_in, ns_t_a, 0x1234, 0, &amp;buf, &amp;buflen, 0);  free(buf);  return 0;&#125;\n\n3. 编译 Fuzz target使用 fuzzer-test-suite 提供的编译脚本，执行 build.sh 脚本，会自动调用 custom-build.sh 和 common.sh 进行编译。三个 shell 脚本和 Fuzz 函数的存放路径如下，脚本中会自动使用 git 拉取代码，这里将第 1 步手动拉取的代码删掉了：\n123456789sqa@twtpesqa03:~/dss/fuzz$ tree.├── cares│   ├── build.sh│   └── target.cc├── common.sh└── custom-build.sh1 directory, 4 files\n\n注意需要将原始脚本中的 -fsanitize-coverage&#x3D;trace-pc-guard 替换为 -fsanitize&#x3D;fuzzer，否则执行 Fuzz 时会出现错误：-fsanitize-coverage&#x3D;trace-pc-guard is no longer supported by libFuzzer。\n1234sqa@twtpesqa03:~/dss/fuzz$ ./cares-fsanitize_fuzzer-fsanitize-coverage=trace-pc-guard is no longer supported by libFuzzer.Please either migrate to a compiler that supports -fsanitize=fuzzeror use an older version of libFuzzer\n\n执行脚本进行编译（也可以自己编写命令进行编译，编译相关的内容之后会单独写文章进行说明）：\n1sqa@twtpesqa03:~/dss/fuzz$ ./cares/build.sh\n\n编译完后，可以看到目录下多了一个二进制文件 cares-fsanitize_fuzzer，两个目录 BUILD 和 SRC。cares-fsanitize_fuzzer 是可执行的 Fuzz 程序，SRC 目录存放 c-ares 含漏洞的源码，BUILD 目录用于存放编译产生的中间文件和最终文件：\n12345678910sqa@twtpesqa03:~/dss/fuzz$ tree -L 1.├── BUILD├── cares├── cares-fsanitize_fuzzer├── common.sh├── custom-build.sh└── SRC3 directories, 3 files\n\n4. 执行 Fuzz 测试  直接运行编译得到的二进制文件，如需附带参数，可参考第一章节执行 fuzz 的参数说明。\n123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778sqa@twtpesqa03:~/dss/fuzz$ ./cares-fsanitize_fuzzerINFO: Seed: 817252946INFO: Loaded 1 modules   (10 inline 8-bit counters): 10 [0x5a90e0, 0x5a90ea),INFO: Loaded 1 PC tables (10 PCs): 10 [0x56c278,0x56c318),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 3 ft: 3 corp: 1/1b exec/s: 0 rss: 27Mb#3      NEW    cov: 4 ft: 4 corp: 2/5b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#10     REDUCE cov: 4 ft: 4 corp: 2/4b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 2 ChangeByte-CrossOver-#11     REDUCE cov: 4 ft: 4 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 1 EraseBytes-#1368   REDUCE cov: 6 ft: 6 corp: 3/20b lim: 17 exec/s: 0 rss: 27Mb L: 17/17 MS: 2 InsertByte-InsertRepeatedBytes-#1524   REDUCE cov: 6 ft: 6 corp: 3/19b lim: 17 exec/s: 0 rss: 27Mb L: 16/16 MS: 1 EraseBytes-===================================================================3049145==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6030012599c2 at pc 0x000000550e1c bp 0x7fffbad826d0 sp 0x7fffbad826c8WRITE of size 1 at 0x6030012599c2 thread T0    #0 0x550e1b in ares_create_query (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x550e1b)    #1 0x55053c in LLVMFuzzerTestOneInput /home/sqa/dss/fuzz/cares/target.cc:14:3    #2 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #3 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x457de5)    #4 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45a087)    #5 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #6 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x44973e)    #7 0x472582 in main (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x472582)    #8 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)    #9 0x41e4dd in _start (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x41e4dd)0x6030012599c2 is located 0 bytes to the right of 18-byte region [0x6030012599b0,0x6030012599c2)allocated by thread T0 here:    #0 0x51e20d in malloc (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x51e20d)    #1 0x5508f6 in ares_create_query (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x5508f6)    #2 0x55053c in LLVMFuzzerTestOneInput /home/sqa/dss/fuzz/cares/target.cc:14:3    #3 0x4586a1 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x4586a1)    #4 0x457de5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x457de5)    #5 0x45a087 in fuzzer::Fuzzer::MutateAndTestOne() (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45a087)    #6 0x45ad85 in fuzzer::Fuzzer::Loop(std::__Fuzzer::vector&lt;fuzzer::SizedFile, fuzzer::fuzzer_allocator&lt;fuzzer::SizedFile&gt; &gt;&amp;) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x45ad85)    #7 0x44973e in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x44973e)    #8 0x472582 in main (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x472582)    #9 0x7fd31481c082 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x24082)SUMMARY: AddressSanitizer: heap-buffer-overflow (/home/sqa/dss/fuzz/cares-fsanitize_fuzzer+0x550e1b) in ares_create_queryShadow bytes around the buggy address:  0x0c06802432e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c06802432f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243300: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243310: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa  0x0c0680243320: fa fa fa fa fa fa fa fa fa fa fd fd fd fa fa fa=&gt;0x0c0680243330: fd fd fd fa fa fa 00 00[02]fa fa fa fd fd fd fa  0x0c0680243340: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243350: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa fa  0x0c0680243360: fd fd fd fa fa fa fd fd fd fa fa fa fd fd fd fa  0x0c0680243370: fa fa fd fd fd fa fa fa fd fd fd fa fa fa fd fd  0x0c0680243380: fd fa fa fa fd fd fd fa fa fa fd fd fd fa fa faShadow byte legend (one shadow byte represents 8 application bytes):  Addressable:           00  Partially addressable: 01 02 03 04 05 06 07  Heap left redzone:       fa  Freed heap region:       fd  Stack left redzone:      f1  Stack mid redzone:       f2  Stack right redzone:     f3  Stack after return:      f5  Stack use after scope:   f8  Global redzone:          f9  Global init order:       f6  Poisoned by user:        f7  Container overflow:      fc  Array cookie:            ac  Intra object redzone:    bb  ASan internal:           fe  Left alloca redzone:     ca  Right alloca redzone:    cb  Shadow gap:              cc==3049145==ABORTINGMS: 4 ChangeByte-InsertByte-CopyPart-ChangeByte-; base unit: 00b28ff06b788b9b67c6b259800f404f9f3761fd0x5c,0x2e,0x0,0x6b,0x0,\\\\.\\x00k\\x00artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-edef708d314ed627eba0ef2b042e47aa96a9b899Base64: XC4AawA=\n\n可以看到，LibFuzzer 发现了 c-ares 中的 heap-buffer-overflow 漏洞，触发 crash 的用例保存为 crash-edef708d314ed627eba0ef2b042e47aa96a9b899 文件，该用例包含 5 个字节，字节码分别为：0x5c,0x2e,0x0,0x6b,0x0，其中 0x0 为空字符 NULL，属于不可见字符。\n5. 提取语料  执行 Fuzz 时，传入一个空文件夹作为 copus 路径，执行完后，可以在文件夹中看到 LibFuzzer 执行过程中，生成的有效语料。\n123456789101112131415161718192021222324252627282930313233343536373839404142sqa@twtpesqa03:~/dss/fuzz/cares$ mkdir corpussqa@twtpesqa03:~/dss/fuzz/cares$ lsBUILD  build.sh  cares_fuzzer  corpus  target.ccsqa@twtpesqa03:~/dss/fuzz/cares$ ./cares_fuzzer corpus/INFO: Seed: 4140748905INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO:        0 files found in corpus/INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytesINFO: A corpus is not provided, starting from an empty corpus#2      INITED cov: 13 ft: 14 corp: 1/1b exec/s: 0 rss: 27Mb#4      NEW    cov: 16 ft: 20 corp: 2/3b lim: 4 exec/s: 0 rss: 27Mb L: 2/2 MS: 2 ChangeByte-InsertByte-#9      NEW    cov: 16 ft: 26 corp: 3/6b lim: 4 exec/s: 0 rss: 27Mb L: 3/3 MS: 5 ChangeBit-ChangeByte-ChangeByte-CopyPart-InsertByte-#10     NEW    cov: 16 ft: 32 corp: 4/10b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver-#25     NEW    cov: 18 ft: 34 corp: 5/11b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 5 ChangeBit-ChangeASCIIInt-CMP-CrossOver-EraseBytes- DE: &quot;\\x01\\x00&quot;-#94     NEW    cov: 19 ft: 35 corp: 6/15b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 4 CrossOver-ShuffleBytes-ChangeByte-ChangeBit-#108    NEW    cov: 21 ft: 37 corp: 7/16b lim: 4 exec/s: 0 rss: 27Mb L: 1/4 MS: 4 ChangeByte-ShuffleBytes-ChangeBit-ChangeByte-#125    NEW    cov: 22 ft: 38 corp: 8/18b lim: 4 exec/s: 0 rss: 27Mb L: 2/4 MS: 2 ShuffleBytes-InsertByte-...==3237059==ABORTINGMS: 2 InsertRepeatedBytes-ChangeByte-; base unit: 1bef8aac927d18852642a96c20e50efba80fdfae0x5c,0x5,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x98,0x5c,0x2e,\\\\\\x05\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\x98\\\\.artifact_prefix=&#x27;./&#x27;; Test unit written to ./crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7Base64: XAWYmJiYmJiYmJiYmFwusqa@twtpesqa03:~/dss/fuzz/cares$ ls -altotal 2244drwxrwxr-x 4 sqa sqa    4096 Sep 26 17:47 .drwxrwxr-x 5 sqa sqa    4096 Sep 26 15:25 ..drwxrwxr-x 9 sqa sqa   20480 Sep 26 17:18 BUILD-rw-rw-r-- 1 sqa sqa     722 Sep 26 17:13 build.sh-rwxrwxr-x 1 sqa sqa 2250720 Sep 26 17:18 cares_fuzzerdrwxrwxr-x 2 sqa sqa    4096 Sep 26 17:47 corpus-rw-rw-r-- 1 sqa sqa      15 Sep 26 17:47 crash-157768d6f06d94325fe0e6bcf66cbd2d27dd8db7-rw-rw-r-- 1 sqa sqa     499 Sep 26 17:14 target.ccsqa@twtpesqa03:~/dss/fuzz/cares$ ls corpus/08534f33c201a45017b502e90a800f1b708ebcb3  5175b74bd75b8d90a01f77709deba3982fbbdcb2  78bdce51613f555049a9937095bf469bcb77e94f  be566cb17d3bce0b2a8e5e710b3779df720db1f50f1c5448bf80343eeac759f8adcbdc2720533d15  5318c4ac20dac95a702bee2e27834d39ea6bc2b6  8e54ed049741d7cf6fb8ef7f4288ef0be3b54f17  be5c29e07560abcf094c3419712a01590bbe85940fe509b10d833be6eb3d5ed4947cbe0fbb64ed84  5ba93c9db0cff93f52b521d7420e43f6eda2784f  8ea51a3719d7cbfc3e2dcd3edf6109918d5aad55  caea31b9ef76b9be352ad1054956efbb86d4451a1bef8aac927d18852642a96c20e50efba80fdfae  60321f72401b49b895535045eb8d3b9ca7db7c7c  91a3f7c503955600f5dac12c1c1a3c5b674a4d98  dea712be0e801f4502a21e04dfbec5bd0cbc677c24792aa3923c4cd185519d3d445ecfd0801db1c1  6380a9a2d2701df0cb53d880842747cbefef8a5d  9f64357cb30f24cf567513e140e9fb0cbf1a2be5  e716589d09e16cf4a48d2c7f1d357bb481aaf3bc3a52ce780950d4d969792a2559cd519d7ee8c727  6414bd7955e39106721edf7cc29efdb82f7007ac  b534844fd943d8b338025ad82d68283f1bcdb5c0\n\n6. 合并语料  当 Fuzz 执行很久之后，会产生大量语料。为了减少语料数量，可以使用 merge 参数进行合并。创建一个 min_corpus 目录，执行 Fuzz 时，启动 merge 参数，传入 min_corpus 目录和 corpus 目录，合并完后，可以在 min_corpus 目录下看到缩减之后的语料。以下示例显示预料数据从 31 个减少到 29 个：\n1234567891011121314151617181920212223sqa@twtpesqa03:~/dss/fuzz/cares$ mkdir min_corpussqa@twtpesqa03:~/dss/fuzz/cares$ ./cares_fuzzer -merge=1 min_corpus/ corpus/INFO: Seed: 1671146211INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),MERGE-OUTER: 31 files, 0 in the initial corpus, 0 processed earlierMERGE-OUTER: attempt 1INFO: Seed: 1671165588INFO: Loaded 1 modules   (57 inline 8-bit counters): 57 [0x5a9100, 0x5a9139),INFO: Loaded 1 PC tables (57 PCs): 57 [0x5a9140,0x5a94d0),INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 1048576 bytesMERGE-INNER: using the control file &#x27;/tmp/libFuzzerTemp.3327149.txt&#x27;MERGE-INNER: 31 total files; 0 processed earlier; will process 31 files now#1      pulse  cov: 9 ft: 10 exec/s: 0 rss: 27Mb#2      pulse  cov: 13 ft: 14 exec/s: 0 rss: 27Mb#4      pulse  cov: 20 ft: 22 exec/s: 0 rss: 27Mb#8      pulse  cov: 28 ft: 38 exec/s: 0 rss: 27Mb#16     pulse  cov: 29 ft: 56 exec/s: 0 rss: 27Mb#31     DONE   cov: 29 ft: 82 exec/s: 0 rss: 28MbMERGE-OUTER: succesfull in 1 attempt(s)MERGE-OUTER: the control file has 2691 bytesMERGE-OUTER: consumed 0Mb (27Mb rss) to parse the control fileMERGE-OUTER: 29 new files with 82 new features added; 29 new coverage edges\n\n三、优化技巧  整体优化思路分两种：\n\n找到 crash 更快 –&gt; 并行化，多个实例一起运行\n覆盖 edge 更多 –&gt; 加强语料，让输入能走到更深的分支\n\n（一）并行化1、LibFuzzer(1) jobs 和 workers\n\njobs：指定 fuzz 实例的数量。在不设置运行时长的情况下，每个 fuzz 实例找到 crash 才会停止。理论上有多少 jobs，最后会产生多少个 crash 文件。但实际上，不同的 job 可能找到同样的 crash，最后 crash 文件个数少于 job 个数。\nworks：执行 fuzz 进程的数量。在多个 jobs 的情况下，平均每个 woker 执行 #jobs&#x2F;#workers 个 job。\n\n简单来说，使用 workers 能提升 fuzz 运行速度，使用 jobs 能增加 crash 数量（仅根据输入去重，没有对调用栈去重）。 只使用 jobs 的情况下，默认开启 min(#jobs, #cores) &#x2F;&#x2F; 2 个 workers。\n(2) fork\n目前 fork 是实验阶段的参数，计划最终使用 fork 代替 jobs 和 workers 来实现 LibFuzzer 的并行化。\n\nfork：父进程不直接执行 fuzz，而是开启 N 个子进程，每个子进程使用语料库的随机子集进行 fuzz，当子进程退出后，该子进程的语料将被合并到主语料库中。子进程可以通过设置参数，来实现对指定错误的容错能力：\n\n-ignore_ooms：默认为 True。子进程发生内存溢出时，保存输入用于重现，但 fuzz 继续执行。\n\n-ignore_timeouts：默认为 True。子进程发生超时时，保留输入用于重现，但 fuzz 继续执行。\n\n-ignore_crashes：默认为 False。子进程发生其他类型 crash 时，保留输入用于重现，但 fuzz 继续执行。\n\n\n2、LibFuzzer 结合 AFLAFL 可以支持 LibFuzzer 的 target，编译方法参考  此处说明。\n12afl-fuzz -i testcase_dir -o findings_dir ./fuzz-target @@ ./fuzz-target testcase_dir findings_dir # Will write new tests to testcase_dir\n\n需要定期重启 AFL 和 LibFuzzer，以完成语料同步。\n（二）加强语料 1、字典 运行时使用 -dict 参数指定字典（Dictionary）文件的路径，字典用于指定和控制模糊测试中输入数据的一部分，从而提高模糊测试的效果。\n字典文件：\n12345678910# Lines starting with &#x27;#&#x27; and empty lines are ignored.# Adds &quot;blah&quot; (w/o quotes) to the dictionary.kw1=&quot;blah&quot;# Use \\\\ for backslash and \\&quot; for quotes.kw2=&quot;\\&quot;ac\\\\dc\\&quot;&quot;# Use \\xAB for hex valueskw3=&quot;\\xF7\\xF8&quot;# the name of the keyword followed by &#x27;=&#x27; may be omitted:&quot;foo\\x0Abar&quot;\n\n使用方法（运行时）：\n1./fuzz-target -dict=dict_file\n\n2、CMP编译时使用 -fsanitize-coverage&#x3D;trace-cmp 参数，让 fuzz 拦截 CMP 指令（例如 if 语句中的 compare 条件）并根据拦截到的 CMP 指令的参数来引导变异。这可能会减慢模糊测试的速度，但很可能会改善测试结果。\n使用方法（编译时）：\n1clang++ buggy.cc -fsanitize=fuzzer,address -fsanitize-coverage=trace-cmp -g -o buggy-fuzzer\n\n3、Value Profile需要与 -fsanitize-coverage=trace-cmp 一起使用，让 fuzz 收集 CMP 指令的参数值进行分析，用于发现更多的有效输入。但是有两个缺点：首先可能会导致速度降低 2 倍。 其次语料库可能增长数倍。\n使用方法（运行时）：\n1./fuzz-target -use_value_profile=1\n\n4、Fuzzer-friendly build mode程序中可能存在某些对 fuzz 不友好的特性，例如：\n\n随机化：同一个输入，可能走不同的路径\n校验和：拦截无效输入\n\n此时可以用构建宏 FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 来编译一个对 fuzz 友好的版本，使用时需要对源码进行修改。例如：\n12345678void MyInitPRNG() &#123;#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  // In fuzzing mode the behavior of the code should be deterministic.  srand(0);#else  srand(time(0));#endif&#125;\n\n四、 参考资料\nlibFuzzer – a library for coverage-guided fuzz testing\nlibFuzzer 使用总结教程\nEfficient Fuzzing Guide\nThe art of fuzzing-A Step-by-Step Guide to Coverage-Guided Fuzzing with LibFuzzer\nAn introduction to LLVM libFuzzer\nAn informative guide on using AFL and libFuzzer\nlibfuzzer-workshop\nSanitizers\nThe Magic Behind Feedback-Based Fuzzing\n","dateCreated":"2023-09-17T18:30:15+08:00","dateModified":"2024-04-09T14:20:43+08:00","datePublished":"2023-09-17T18:30:15+08:00","description":"模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完","headline":"LibFuzzer 使用说明","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/09/17/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/09/17/LibFuzzer%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E/","keywords":"安全, Fuzz, 教程, LibFuzzer"}</script>
     <meta name="description" content="模糊测试工具 LibFuzzer 从 0 到 1，原理 + 安装 + 使用 + 优化，一篇讲完">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="LibFuzzer 使用说明">
@@ -24,8 +24,8 @@
 <meta property="article:published_time" content="2023-09-17T10:30:15.000Z">
 <meta property="article:modified_time" content="2024-04-09T06:20:43.205Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="安全">
+<meta property="article:tag" content="Fuzz">
 <meta property="article:tag" content="教程">
 <meta property="article:tag" content="LibFuzzer">
 <meta name="twitter:card" content="summary">
diff --git "a/2023/10/15/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html" "b/2023/10/15/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
index 109a0fa..4d7cfd8 100644
--- "a/2023/10/15/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
+++ "b/2023/10/15/AFL\345\216\237\347\220\206\344\270\216\345\256\236\350\267\265/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n\n在软件开发的世界里，质量和安全性是评估产品成败的重要指标。模糊测试作为一种高效的自动化测试方法，专门用来发现程序中的错误和安全漏洞。本文旨在详细介绍 AFL（American Fuzzy Lop）的基本原理和使用方法。\n一、AFL 的原理介绍  模糊测试是一种通过向软件输入异常或随机数据的自动化技术，目的是发现程序在处理意外或边缘情况输入时的错误。AFL 是这一测试策略中的杰出代表，它通过不断学习程序反应来改进测试用例，提高测试的覆盖率和发现漏洞的概率。\nAFL 利用遗传算法，不断生成测试用例，并通过动态插桩技术监控程序的行为，特别是程序的代码覆盖情况。当新的输入能触发新的代码路径时，这个输入会被保存以供进一步的测试。该过程可以形成一个反馈循环，不断优化测试用例以探索更多程序状态。\n下面是 AFL 工作流程图，展示了从准备测试用例到监控程序行为的步骤：\ngraph TD\n    A[Compile with afl-gcc] --> B[Initialize seed corpus] --> C[Fuzzing loop] --> D[Select seed from corpus queue]\n    D[Select seed from corpus queue] --> E[Mutate selected seed] --> F[Execute with mutated testcase]\n    F[Execute with mutated testcase] --> G[Monitor for crashes and coverage update] --> H{Check for new coverage}\n    H{Check for new coverage} -- YES --> I[Save mutated testcase to queue] --> D\n    H{Check for new coverage} -- NO --> D\n\n流程图详细展示了 AFL 在模糊测试中的核心步骤：\n\n编译（Compile with afl-gcc） - 使用 AFL 提供的编译器 afl-gcc，对目标程序进行编译，实现程序的动态插桩。\n\n初始化种子库（Initialize seed corpus） - 创建初始测试用例集（种子库），这些测试用例将作为模糊测试的起点。\n\n模糊测试循环（Fuzzing loop） - 一个不断循环的过程，根据测试结果更新种子库，并反复执行下列子步骤：a. 选择种子（Select seed from corpus queue） - 从种子库中选择一个种子文件作为当前测试的输入。b. 突变种子（Mutate selected seed） - 对选中的种子文件应用突变算法，生成新的测试用例。c. 执行测试（Execute with mutated test case） - 将变异后的测试用例作为输入执行已插桩的目标程序。d. 监控结果（Monitor for crashes and coverage update） - 监控程序的执行情况，记录崩溃和代码覆盖率的变化。\n\n覆盖率检查（Check for new coverage） - 判断是否出现新的代码覆盖，如果有，则将其保存为新测试用例。\n\n保存新测试用例（Save new testcase to queue） - 将触发新代码覆盖的测试用例保存到队列中，用于后续的测试。\n\n\nAFL 采用了 fork 的运行模式，这使得当待测程序出现崩溃时，fuzz 进程不会终止，这一点相较于 LibFuzzer 更具优势。然而，频繁的 fork 操作也导致了 AFL 的效率不如 LibFuzzer。\n二、AFL 安装和运行1. 支持的系统和架构AFL 设计之初主要针对 UNIX-like 系统，其在 Linux 系统上有最好的支持。然而，在社区的努力下，也有 Windows 版本的 AFL，如 winafl，其可以在 Windows 进行模糊测试。\nAFL 还支持多种 CPU 架构，其中对 x86 和 x64 架构的支持最好。如果要支持 ARM 架构，则需要使用 AFL 的 QEMU 模式。\n2. 安装步骤AFL 可以通过源码进行安装：\n123apt install git make gccgit clone https://github.com/google/AFL.git cd AFL &amp;&amp; make\n\n3. 运行参数  在安装并编译完 AFL 之后，可以使用 afl-fuzz 命令来启动模糊测试。一个基本的 AFL fuzz 命令如下：\n1afl-fuzz -i input_dir -o output_dir -- /path/to/program [options] @@\n\n这里：\n\nafl-fuzz 是启动 AFL 模糊测试的程序。\n-i input_dir 指定包含初始化测试用例的目录。\n-o output_dir 指定存放的 fuzzing 结果的目录。\n\n-- 之后的部分是运行被测试程序的命令行，其中 /path/to/program 替换为需要进行模糊测试的程序的路径，[options] 是运行该程序的任何选项或参数。\n如果测试程序需要从文件中读取输入，可以在实际输入文件路径的位置使用 @@ 占位符。AFL 将替换 @@ 来插入它正在测试的输入文件。如果省略这个占位符，AFL 将会把模糊测试用例通过 stdin 传递给测试程序。\n三、AFL 的使用示例  本节使用一个简单的示例，演示 AFL 的操作步骤。\n这是待测源码，其功能是接受一行命令行输入，进行四则运算。其中使用了不安全的 gets 函数，可能导致缓冲区溢出：\n1234567891011121314151617181920212223242526272829303132#include &lt;stdio.h&gt;#include &lt;string.h&gt;int calculate(int a, int b, char op) &#123;    switch (op) &#123;        case &#x27;+&#x27;: return a + b;        case &#x27;-&#x27;: return a - b;        case &#x27;x&#x27;: return a * b;        case &#x27;/&#x27;: return b ? a / b : 0;        default: return 0;    &#125;&#125;int main() &#123;    char input[100];    // unsafe method that may cause buffer overflow    gets(input);    int a, b, result;    char op;    if (sscanf(input, &quot;%d %c %d&quot;, &amp;a, &amp;op, &amp;b) != 3)        return 1;    result = calculate(a, b, op);    printf(&quot;Result: %d\\n&quot;, result);    return 0;&#125;\n\n1. 编译源码  使用 AFL 的编译器 afl-gcc 或afl-clang对源文件 hello.c 进行编译，添加所需要的代码覆盖插桩。afl-gcc或 afl-clang 实际上是对常规的 gcc 或clang编译器进行了封装，通过在编译时进行插桩，来统计 fuzz 过程中的代码覆盖率：\n1afl-gcc -o hello hello.c\n\n2. 准备种子语料库  不论程序是从 file 还是从 stdin 获取数据，AFL 都需要一个初始语料库来启动模糊测试过程。输入（无论是来自 file 或 stdin）是 AFL 用来开始探索程序行为的基础。初始语料库（seed corpus）是一组文件，其中包含了各种有效的输入示例，这些输入会被 AFL 用作模糊测试的起始点。\n从 stdin 读取输入时，AFL 会将语料库中的每个文件内容作为输入在每次测试运行时送到程序的标准输入流中。使用 AFL 时，必须要有初始语料库。注意这一点 AFL 与 Libfuzzer 不同，Libfuzzer 只接受 stdin，不接受 file，初始语料库为可选项。\n12mkdir inecho &#x27;abc&#x27; &gt; in/seed\n\n3. 执行测试  在运行 AFL 之前，需要执行下面的系统设置命令，将字符串”core”写入到文件 /proc/sys/kernel/core_pattern 中。\n在 Linux 系统中，/proc/sys/kernel/core_pattern 文件用于指定当程序崩溃时，内核转储文件（core dump）的文件名模式。通过修改这个文件，可以控制内核生成 core 文件的行为。\n通过执行这个命令，生成的核心转储文件将以”core”命名，这使得 AFL 更容易检测和处理目标程序的崩溃情况，从而更好地进行模糊测试。\n1echo core | tee /proc/sys/kernel/core_pattern\n\n在 hello 中使用 gets 函数从 stdin 中读取数据，因此在运行 AFL 时，不需要添加 @@。是否使用@@ 取决于待测程序接受的输入来自 file 还是 stdin。\n1afl-fuzz -i in -o out -- ./hello\n\n4. 结果解读AFL 开始运行后，将会看到如下的界面显示：\n\n\n从这个界面上可以看到 AFL 找到了多少 crash，但还不能直观地显示覆盖率。pythia是一款 AFL 的扩展工具，可以查看代码覆盖率的情况。\nAFL 在运行过程中，会不断地产生输出。输出目录结构如下：\n123456789101112131415161718192021222324out|-- crashes|   |-- README.txt|   |-- id:000000,sig:06,src:000000,op:havoc,rep:64|   |-- id:000001,sig:06,src:000002+000003,op:splice,rep:128|   |-- id:000002,sig:06,src:000003,op:havoc,rep:32|   |-- id:000003,sig:06,src:000002+000003,op:splice,rep:16|   |-- id:000004,sig:06,src:000004,op:havoc,rep:32|   |-- id:000005,sig:11,src:000003+000002,op:splice,rep:64|   `-- id:000006,sig:06,src:000004+000005,op:splice,rep:2|-- fuzz_bitmap|-- fuzzer_stats|-- hangs|-- plot_data`-- queue    |-- id:000000,orig:seed    |-- id:000001,src:000000,op:havoc,rep:16,+cov    |-- id:000002,src:000000+000001,op:splice,rep:4,+cov    |-- id:000003,src:000001,op:arith8,pos:1,val:-5,+cov    |-- id:000004,src:000001,op:arith8,pos:1,val:-9,+cov    `-- id:000005,src:000002+000003,op:splice,rep:4,+cov3 directories, 17 files\n\n\nqueue&#x2F; - 存放 AFL 生成的触发新代码路径的测试样本\n\ncrashes&#x2F; - 存放能触发待测程序崩溃的测试样本\n\nhangs&#x2F; - 存发导致待测程序超时的测试样本\n\nfuzzer_stats - 文本文件，包含了 fuzzer 的实时统计信息，如执行速度、路径覆盖等度量指标。这个文件不断更新以反映当前的 fuzzing 状态。\n\nplot_data - 文本文件，包含了 AFL 执行过程中的统计数据。使用 AFL 的 afl-plot 工具处理 plot_data 文件，可以生成 fuzz 过程的可视化图像。\n\nfuzz_bitmap - 这是用来记录路径覆盖率的位图（coverage bitmap），非人类可读。AFL 使用这个位图来跟踪程序在处理不同输入时执行的不同分支，用来帮助 AFL 识别新的、唯一的代码路径，以便后续生成更具有探索性的测试样本。\n\n\n四、AFL 的 QEMU 模式  前面的例子中，AFL 在对待测程序的源码进行编译时插桩。实际中，我们不一定能拿到待测源码，我们要测的可能是一个已经编译好的二进制文件。这种情况下 Libfuzzer 就无能为力了，但 AFL 还能用，这依赖于 AFL 的 QEMU 模式。\nAFL 的 QEMU 模式，也称为 AFL-QEMU，允许你在二进制模糊测试中使用 AFL，即使源代码不可用。这在对闭源应用进行模糊测试时非常有用。这种模式使用 QEMU 的用户模式仿真，来运行并分析非原生的二进制文件。以下是安装 AFL 的 QEMU 模式和使用步骤的指南：\n1. 编译 QEMU 支持  在 AFL 主目录下有一个专门的 QEMU 模式目录。进入该目录并编译 QEMU 模式，过程中可能缺少依赖项，根据提示进行安装即可：\n12cd qemu_mode./build_qemu_support.sh\n\n2. AFL-QEMU 使用步骤  用法很简单，在 AFL 运行命令中添加 -Q 参数即可：\n1afl-fuzz -i input -o output -Q -- /path/to/binary @@\n\n\n五、AFL 的升级版——AFL++AFL++ 可以看作是原始 AFL 的”增强版”，对 AFL 的调度策略和变异算法进行了很多改进，同时还引入了很多新特性，如 CMPLOG 和持久化这样的特性。\n1. CMPLOGCMPLOG 是 AFL++ 引入的一个新功能，类似于 Libfuzzer 中的 trace-cmp，它可以极大地提高代码覆盖率。CMPLOG 的主要作用是对程序中的所有比较操作进行记录，包括等于、不等于、小于等逻辑比较。当 fuzzer 执行时，CMPLOG 能够捕获比较操作的参数，并将对应的值添加到 fuzzer 的输入测试用例中。这个过程实际上帮助 fuzzer 更好地理解代码中期待的输入，特别是那些用于逻辑分支的字面值和魔法数字。这种理解能够导向更深入的路径覆盖，进而揭露隐藏更深的潜在缺陷。\n2. 持久化模式AFL 的持久化（persistent）模式允许目标程序在单个进程周期内重复执行多次模糊测试用例。这对性能产生了显著的提升，因为它减少了程序启动和终止的开销，特别是当测试的目标程序需要很大的初始化成本时。在 AFL++ 中，持久化模式的执行更为高效，它允许模糊器在目标程序中一次性执行多个测试用例，而非每次执行一个用例都重启目标程序。有了持久化模式，AFL++ 能够在相同的时间内执行更多的测试迭代，从而提高漏洞检测的速度。\n六、小结AFL 是一款强大的模糊测试工具，实践中 AFL++ 的应用非常广泛。相比 Libfuzzer，AFL++ 不局限于源码，并且支持多种 cpu 架构，还有丰富的插件生态可以使用。\n但模糊测试本身存在覆盖率瓶颈的问题，难以探索复杂的程序路径，这时候可以结合其他的技术，如符号执行来突破。","dateCreated":"2023-10-15T11:23:55+08:00","dateModified":"2024-04-09T14:20:44+08:00","datePublished":"2023-10-15T11:23:55+08:00","description":"模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用","headline":"AFL 原理与实践","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/10/15/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/10/15/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/","keywords":"AFL, Fuzz, 安全, 教程"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n\n在软件开发的世界里，质量和安全性是评估产品成败的重要指标。模糊测试作为一种高效的自动化测试方法，专门用来发现程序中的错误和安全漏洞。本文旨在详细介绍 AFL（American Fuzzy Lop）的基本原理和使用方法。\n一、AFL 的原理介绍  模糊测试是一种通过向软件输入异常或随机数据的自动化技术，目的是发现程序在处理意外或边缘情况输入时的错误。AFL 是这一测试策略中的杰出代表，它通过不断学习程序反应来改进测试用例，提高测试的覆盖率和发现漏洞的概率。\nAFL 利用遗传算法，不断生成测试用例，并通过动态插桩技术监控程序的行为，特别是程序的代码覆盖情况。当新的输入能触发新的代码路径时，这个输入会被保存以供进一步的测试。该过程可以形成一个反馈循环，不断优化测试用例以探索更多程序状态。\n下面是 AFL 工作流程图，展示了从准备测试用例到监控程序行为的步骤：\ngraph TD\n    A[Compile with afl-gcc] --> B[Initialize seed corpus] --> C[Fuzzing loop] --> D[Select seed from corpus queue]\n    D[Select seed from corpus queue] --> E[Mutate selected seed] --> F[Execute with mutated testcase]\n    F[Execute with mutated testcase] --> G[Monitor for crashes and coverage update] --> H{Check for new coverage}\n    H{Check for new coverage} -- YES --> I[Save mutated testcase to queue] --> D\n    H{Check for new coverage} -- NO --> D\n\n流程图详细展示了 AFL 在模糊测试中的核心步骤：\n\n编译（Compile with afl-gcc） - 使用 AFL 提供的编译器 afl-gcc，对目标程序进行编译，实现程序的动态插桩。\n\n初始化种子库（Initialize seed corpus） - 创建初始测试用例集（种子库），这些测试用例将作为模糊测试的起点。\n\n模糊测试循环（Fuzzing loop） - 一个不断循环的过程，根据测试结果更新种子库，并反复执行下列子步骤：a. 选择种子（Select seed from corpus queue） - 从种子库中选择一个种子文件作为当前测试的输入。b. 突变种子（Mutate selected seed） - 对选中的种子文件应用突变算法，生成新的测试用例。c. 执行测试（Execute with mutated test case） - 将变异后的测试用例作为输入执行已插桩的目标程序。d. 监控结果（Monitor for crashes and coverage update） - 监控程序的执行情况，记录崩溃和代码覆盖率的变化。\n\n覆盖率检查（Check for new coverage） - 判断是否出现新的代码覆盖，如果有，则将其保存为新测试用例。\n\n保存新测试用例（Save new testcase to queue） - 将触发新代码覆盖的测试用例保存到队列中，用于后续的测试。\n\n\nAFL 采用了 fork 的运行模式，这使得当待测程序出现崩溃时，fuzz 进程不会终止，这一点相较于 LibFuzzer 更具优势。然而，频繁的 fork 操作也导致了 AFL 的效率不如 LibFuzzer。\n二、AFL 安装和运行1. 支持的系统和架构AFL 设计之初主要针对 UNIX-like 系统，其在 Linux 系统上有最好的支持。然而，在社区的努力下，也有 Windows 版本的 AFL，如 winafl，其可以在 Windows 进行模糊测试。\nAFL 还支持多种 CPU 架构，其中对 x86 和 x64 架构的支持最好。如果要支持 ARM 架构，则需要使用 AFL 的 QEMU 模式。\n2. 安装步骤AFL 可以通过源码进行安装：\n123apt install git make gccgit clone https://github.com/google/AFL.git cd AFL &amp;&amp; make\n\n3. 运行参数  在安装并编译完 AFL 之后，可以使用 afl-fuzz 命令来启动模糊测试。一个基本的 AFL fuzz 命令如下：\n1afl-fuzz -i input_dir -o output_dir -- /path/to/program [options] @@\n\n这里：\n\nafl-fuzz 是启动 AFL 模糊测试的程序。\n-i input_dir 指定包含初始化测试用例的目录。\n-o output_dir 指定存放的 fuzzing 结果的目录。\n\n-- 之后的部分是运行被测试程序的命令行，其中 /path/to/program 替换为需要进行模糊测试的程序的路径，[options] 是运行该程序的任何选项或参数。\n如果测试程序需要从文件中读取输入，可以在实际输入文件路径的位置使用 @@ 占位符。AFL 将替换 @@ 来插入它正在测试的输入文件。如果省略这个占位符，AFL 将会把模糊测试用例通过 stdin 传递给测试程序。\n三、AFL 的使用示例  本节使用一个简单的示例，演示 AFL 的操作步骤。\n这是待测源码，其功能是接受一行命令行输入，进行四则运算。其中使用了不安全的 gets 函数，可能导致缓冲区溢出：\n1234567891011121314151617181920212223242526272829303132#include &lt;stdio.h&gt;#include &lt;string.h&gt;int calculate(int a, int b, char op) &#123;    switch (op) &#123;        case &#x27;+&#x27;: return a + b;        case &#x27;-&#x27;: return a - b;        case &#x27;x&#x27;: return a * b;        case &#x27;/&#x27;: return b ? a / b : 0;        default: return 0;    &#125;&#125;int main() &#123;    char input[100];    // unsafe method that may cause buffer overflow    gets(input);    int a, b, result;    char op;    if (sscanf(input, &quot;%d %c %d&quot;, &amp;a, &amp;op, &amp;b) != 3)        return 1;    result = calculate(a, b, op);    printf(&quot;Result: %d\\n&quot;, result);    return 0;&#125;\n\n1. 编译源码  使用 AFL 的编译器 afl-gcc 或afl-clang对源文件 hello.c 进行编译，添加所需要的代码覆盖插桩。afl-gcc或 afl-clang 实际上是对常规的 gcc 或clang编译器进行了封装，通过在编译时进行插桩，来统计 fuzz 过程中的代码覆盖率：\n1afl-gcc -o hello hello.c\n\n2. 准备种子语料库  不论程序是从 file 还是从 stdin 获取数据，AFL 都需要一个初始语料库来启动模糊测试过程。输入（无论是来自 file 或 stdin）是 AFL 用来开始探索程序行为的基础。初始语料库（seed corpus）是一组文件，其中包含了各种有效的输入示例，这些输入会被 AFL 用作模糊测试的起始点。\n从 stdin 读取输入时，AFL 会将语料库中的每个文件内容作为输入在每次测试运行时送到程序的标准输入流中。使用 AFL 时，必须要有初始语料库。注意这一点 AFL 与 Libfuzzer 不同，Libfuzzer 只接受 stdin，不接受 file，初始语料库为可选项。\n12mkdir inecho &#x27;abc&#x27; &gt; in/seed\n\n3. 执行测试  在运行 AFL 之前，需要执行下面的系统设置命令，将字符串”core”写入到文件 /proc/sys/kernel/core_pattern 中。\n在 Linux 系统中，/proc/sys/kernel/core_pattern 文件用于指定当程序崩溃时，内核转储文件（core dump）的文件名模式。通过修改这个文件，可以控制内核生成 core 文件的行为。\n通过执行这个命令，生成的核心转储文件将以”core”命名，这使得 AFL 更容易检测和处理目标程序的崩溃情况，从而更好地进行模糊测试。\n1echo core | tee /proc/sys/kernel/core_pattern\n\n在 hello 中使用 gets 函数从 stdin 中读取数据，因此在运行 AFL 时，不需要添加 @@。是否使用@@ 取决于待测程序接受的输入来自 file 还是 stdin。\n1afl-fuzz -i in -o out -- ./hello\n\n4. 结果解读AFL 开始运行后，将会看到如下的界面显示：\n\n\n从这个界面上可以看到 AFL 找到了多少 crash，但还不能直观地显示覆盖率。pythia是一款 AFL 的扩展工具，可以查看代码覆盖率的情况。\nAFL 在运行过程中，会不断地产生输出。输出目录结构如下：\n123456789101112131415161718192021222324out|-- crashes|   |-- README.txt|   |-- id:000000,sig:06,src:000000,op:havoc,rep:64|   |-- id:000001,sig:06,src:000002+000003,op:splice,rep:128|   |-- id:000002,sig:06,src:000003,op:havoc,rep:32|   |-- id:000003,sig:06,src:000002+000003,op:splice,rep:16|   |-- id:000004,sig:06,src:000004,op:havoc,rep:32|   |-- id:000005,sig:11,src:000003+000002,op:splice,rep:64|   `-- id:000006,sig:06,src:000004+000005,op:splice,rep:2|-- fuzz_bitmap|-- fuzzer_stats|-- hangs|-- plot_data`-- queue    |-- id:000000,orig:seed    |-- id:000001,src:000000,op:havoc,rep:16,+cov    |-- id:000002,src:000000+000001,op:splice,rep:4,+cov    |-- id:000003,src:000001,op:arith8,pos:1,val:-5,+cov    |-- id:000004,src:000001,op:arith8,pos:1,val:-9,+cov    `-- id:000005,src:000002+000003,op:splice,rep:4,+cov3 directories, 17 files\n\n\nqueue&#x2F; - 存放 AFL 生成的触发新代码路径的测试样本\n\ncrashes&#x2F; - 存放能触发待测程序崩溃的测试样本\n\nhangs&#x2F; - 存发导致待测程序超时的测试样本\n\nfuzzer_stats - 文本文件，包含了 fuzzer 的实时统计信息，如执行速度、路径覆盖等度量指标。这个文件不断更新以反映当前的 fuzzing 状态。\n\nplot_data - 文本文件，包含了 AFL 执行过程中的统计数据。使用 AFL 的 afl-plot 工具处理 plot_data 文件，可以生成 fuzz 过程的可视化图像。\n\nfuzz_bitmap - 这是用来记录路径覆盖率的位图（coverage bitmap），非人类可读。AFL 使用这个位图来跟踪程序在处理不同输入时执行的不同分支，用来帮助 AFL 识别新的、唯一的代码路径，以便后续生成更具有探索性的测试样本。\n\n\n四、AFL 的 QEMU 模式  前面的例子中，AFL 在对待测程序的源码进行编译时插桩。实际中，我们不一定能拿到待测源码，我们要测的可能是一个已经编译好的二进制文件。这种情况下 Libfuzzer 就无能为力了，但 AFL 还能用，这依赖于 AFL 的 QEMU 模式。\nAFL 的 QEMU 模式，也称为 AFL-QEMU，允许你在二进制模糊测试中使用 AFL，即使源代码不可用。这在对闭源应用进行模糊测试时非常有用。这种模式使用 QEMU 的用户模式仿真，来运行并分析非原生的二进制文件。以下是安装 AFL 的 QEMU 模式和使用步骤的指南：\n1. 编译 QEMU 支持  在 AFL 主目录下有一个专门的 QEMU 模式目录。进入该目录并编译 QEMU 模式，过程中可能缺少依赖项，根据提示进行安装即可：\n12cd qemu_mode./build_qemu_support.sh\n\n2. AFL-QEMU 使用步骤  用法很简单，在 AFL 运行命令中添加 -Q 参数即可：\n1afl-fuzz -i input -o output -Q -- /path/to/binary @@\n\n\n五、AFL 的升级版——AFL++AFL++ 可以看作是原始 AFL 的”增强版”，对 AFL 的调度策略和变异算法进行了很多改进，同时还引入了很多新特性，如 CMPLOG 和持久化这样的特性。\n1. CMPLOGCMPLOG 是 AFL++ 引入的一个新功能，类似于 Libfuzzer 中的 trace-cmp，它可以极大地提高代码覆盖率。CMPLOG 的主要作用是对程序中的所有比较操作进行记录，包括等于、不等于、小于等逻辑比较。当 fuzzer 执行时，CMPLOG 能够捕获比较操作的参数，并将对应的值添加到 fuzzer 的输入测试用例中。这个过程实际上帮助 fuzzer 更好地理解代码中期待的输入，特别是那些用于逻辑分支的字面值和魔法数字。这种理解能够导向更深入的路径覆盖，进而揭露隐藏更深的潜在缺陷。\n2. 持久化模式AFL 的持久化（persistent）模式允许目标程序在单个进程周期内重复执行多次模糊测试用例。这对性能产生了显著的提升，因为它减少了程序启动和终止的开销，特别是当测试的目标程序需要很大的初始化成本时。在 AFL++ 中，持久化模式的执行更为高效，它允许模糊器在目标程序中一次性执行多个测试用例，而非每次执行一个用例都重启目标程序。有了持久化模式，AFL++ 能够在相同的时间内执行更多的测试迭代，从而提高漏洞检测的速度。\n六、小结AFL 是一款强大的模糊测试工具，实践中 AFL++ 的应用非常广泛。相比 Libfuzzer，AFL++ 不局限于源码，并且支持多种 cpu 架构，还有丰富的插件生态可以使用。\n但模糊测试本身存在覆盖率瓶颈的问题，难以探索复杂的程序路径，这时候可以结合其他的技术，如符号执行来突破。","dateCreated":"2023-10-15T11:23:55+08:00","dateModified":"2024-04-09T14:20:44+08:00","datePublished":"2023-10-15T11:23:55+08:00","description":"模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用","headline":"AFL 原理与实践","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2023/10/15/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2023/10/15/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/","keywords":"安全, AFL, Fuzz, 教程"}</script>
     <meta name="description" content="模糊测试工具 AFL（American Fuzzy Lop）的原理介绍与实践应用">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="AFL 原理与实践">
@@ -25,9 +25,9 @@
 <meta property="article:published_time" content="2023-10-15T03:23:55.000Z">
 <meta property="article:modified_time" content="2024-04-09T06:20:44.547Z">
 <meta property="article:author" content="一瓢清浅">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="AFL">
 <meta property="article:tag" content="Fuzz">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="教程">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://jiliguluss.github.io/2023/10/15/AFL%E5%8E%9F%E7%90%86%E4%B8%8E%E5%AE%9E%E8%B7%B5/AFL%E8%BF%90%E8%A1%8C%E7%95%8C%E9%9D%A2.png">
diff --git "a/2024/01/23/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html" "b/2024/01/23/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
index 4975f03..eca9a3c 100644
--- "a/2024/01/23/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
+++ "b/2024/01/23/Angr\351\233\266\345\237\272\347\241\200\345\205\245\351\227\250/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、Angr 简介Angr 是一个由 Python 语言编写的开源二进制分析框架，它主要用于静态分析、符号执行、逆向工程等安全研究领域。Angr 支持多种操作系统和硬件架构，包括 Windows、Linux、macOS 以及 x86、ARM 等。\n二、Angr 整体架构1、核心组件Angr 是一个复杂的二进制分析框架，其初始的整体架构设计如下图：\n\n\nAngr 的核心组件自下而上依次为：\n\nCLE：加载可执行文件和库文件\n\narchinfo：获取架构信息\n\nPyVEX：将指令转换成 VEX 这种中间语言（IR）\n\nSimuVEX：模拟执行引擎，负责在虚拟环境中执行 VEX\n\nClaripy：用于创建和管理符号变量及条件约束，传递给 Z3 求解器进行求解\n\nAngr：将各个组件集成起来，提供一套整体的二进制分析和符号执行框架\n\nanalysis：提供一套分析工具，通过 CFG、DDG 等对程序进行分析\n\nsurveyors：用于记录和跟踪程序的可执行路径\n\n\n随着 Angr 的发展，部分组件有更新和迭代：\n\nSimuVEX 被移除，其组件已集成到 Angr 中\n\nsurveyors 被移除，被 SimulationManager 所取代\n\n\n2、运作流程Angr 的整体运作流程如图：\n\n\n使用 Angr 进行二进制分析时，各组件的运行步骤为：\n\nCLE 加载二进制，获取机器指令\n\nArchinfo 分析二进制的架构类型\n\nPyVEX 根据架构类型，将机器指令转换为 VEX 中间表达\n\nSimEngine 基于 VEX 来模拟程序执行\n\nClarify 创建和管理执行过程中的符号变量和约束条件，转化为 SMT 表达式，传递给 Z3 求解\n\nSimOS（SimProcedures） 模拟程序与系统的交互，如标准 io 流、文件读写、系统调用等操作\n\n\n三、Angr 使用说明1. 安装Angr 需要 python 3.8 以上的运行环境，需要先装 3.8 版本以上的 python。\n安装 Angr 有两种推荐方式：\n\npip 安装\n1pip install Angr\n\n源码安装\n123git clone https://github.com/Angr/Angr-dev.gitcd Angr-dev./setup.sh -i -e Angr\n\n2. 运行  建议在虚拟环境中运行 Angr。源码安装的方式可以自动创建名为 Angr 的虚拟环境。手动创建虚拟环境的命令为：\n1python3 -m venv Angr\n\n启动虚拟环境：\n1source Angr/bin/active\n\n3. 使用Angr 作为 python 的三方库，通过 import 进行调用：\n1import Angr\n\nAngr 的顶层 API 围绕着 Angr 的核心组件来设计，包含一组常用的 Python 类和对象，它们提供了二进制分析、符号执行和其他功能。\n以下是 Angr 的一些常用 API 组件：\n\nProject（项目）：\n\nProject是 Angr 的中心组件，它代表了用户所要处理的二进制文件。\n创建一个 Project 实例是使用 Angr 进行分析的第一步，Project对象提供了对二进制文件的操作和分析的接口。\n\n\nFactory（工厂）：\n\nFactory对象通过 Project 的factory属性来访问，它提供了快速访问 Angr 的各种分析技术的接口，避免复杂的实例化操作。\n\n\nSimState（模拟状态）：\n\nSimState代表程序的一个瞬时状态，它包含寄存器、内存、堆栈、文件系统等运行时的上下文环境状态，可用于执行符号执行和具体执行。\nSimState对象通过 Project 的factory属性的方法来访问，这些方法包括 entry_state、blank_state、full_init_state 等。\n\n\nSimulationManager（模拟管理器）：\n\nSimulationManager用来跟踪程序执行过程中的路径探索和 SimState 演化，并对这些路径和 SimState 进行管理。\nSimulationManager对象通过 Project 的factory属性的 simulation_manager 方法实例化。\n\n\nLoader（加载器）：\n\nLoader负责将二进制文件载入内存，并处理符号以及它们的地址空间，为后续分析提供详细信息，如入口点、可执行段、符号表等。\nLoader对象通过 Project 的loader属性的方法来访问。\n\n\nBlock（块）：\n\nBlock表示程序基本块，是 Angr 分析的基本单位。每个 Block 是一组顺序执行代码片段，具有原子性，以分支或跳转结尾。\nBlock对象通过 Project 的factory属性的 block 方法实例化。\n\n\n\n四、Angr 实践应用example.c 源码：\n12345678910111213141516171819202122232425262728293031323334#include &lt;stdio.h&gt;#include &lt;string.h&gt;#include &lt;stdint.h&gt;#include &lt;assert.h&gt;#define MAX_LEN 100int calculate(int number)&#123;    return number * number;&#125;int main()&#123;    char input[MAX_LEN];    printf(&quot;Enter the string: &quot;);    fgets(input, MAX_LEN, stdin);    int len = strlen(input);    int num = 0;    for(int i = 0; i &lt; len; i++) &#123;        if(input[i] &gt;= &#x27;0&#x27; &amp;&amp; input[i] &lt;= &#x27;9&#x27;)&#123;            num = num * 10 + (input[i] - &#x27;0&#x27;);        &#125;    &#125;    int res = calculate(num);    assert(res != 65536);    return 0;&#125;\n\n将 example.c 编译为 example_binary ：\n1gcc example.c -o example_binary\n\n以 example_binary 为例，演示 Angr 用法。\n1. 静态程序分析  首先用 Angr 定位程序入口：\n12345678910111213&gt;&gt;&gt; import angr&gt;&gt;&gt; project = angr.Project(&#x27;example_binary&#x27;, load_options=&#123;&#x27;auto_load_libs&#x27;: False&#125;)&gt;&gt;&gt; project.filename&#x27;example_binary&#x27;&gt;&gt;&gt; project.arch&lt;Arch AMD64 (LE)&gt;&gt;&gt;&gt; project.entry4198624&gt;&gt;&gt; bb = project.factory.block(4198624)&gt;&gt;&gt; bb.instructions12&gt;&gt;&gt; hex(bb.addr)&#x27;0x4010e0&#x27;\n\n这个 0x4010e0 地址对应的是程序的入口 block ，包括 12 条指令，在 CFG 中表示为如下节点，可以看到 block 的名字并不是 main，而是 _start ：\n\n\n接着从 _start 开始执行，执行一次后到达 ___libc_start_main ，然而再执行一次后并没有到达 main ：\n123456789101112&gt;&gt;&gt; st_0 = project.factory.entry_state()&gt;&gt;&gt; hex(st_0.addr)&#x27;0x4010e0&#x27;&gt;&gt;&gt; nx  = st_0.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x500000&gt;]&gt;&gt;&gt; st_1 = nx.successors[0]&gt;&gt;&gt; hex(st_1.addr)&#x27;0x500000&#x27;&gt;&gt;&gt; nx = st_1.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x4012e0&gt;]\n\n为了获取 main 这个 block 的状态，可以使用 SimulationManager 来执行：\n12345678&gt;&gt;&gt; simgr = project.factory.simulation_manager(st_0)&gt;&gt;&gt; main_obj = project.loader.main_object.get_symbol(&#x27;main&#x27;)&gt;&gt;&gt; hex(main_obj.rebased_addr)&#x27;0x4011dc&#x27;&gt;&gt;&gt; simgr.explore(find=main_obj.rebased_addr)&lt;SimulationManager with 1 found&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4011dc&gt;]\n\n\n\n2. 静态符号执行example_binary 接受一个最长为 100 位的字符串作为输入，提取字符串中的数字，转换成数值，然后进行平方运算，结果等于 65536 时出现断言错误。反推回来，当输入字符串中包含 2、5、6 这三个数字时，就能导致AssertionError。\n要让程序自动找到触发 example_binary 中 AssertionError 的 input，可以用 Angr 符号执行来求解。\n首先引入claripy，创建符号变量：\n1234&gt;&gt;&gt; import claripy&gt;&gt;&gt; input_size = 100&gt;&gt;&gt; symbolic_buffer = claripy.BVS(&#x27;input&#x27;, 8 * (input_size - 1))&gt;&gt;&gt; entry_state = project.factory.entry_state(stdin=claripy.Concat(symbolic_buffer, claripy.BVV(b&#x27;\\n&#x27;)))\n\n通过 CFG 可以找到 AssertionError 的 block 地址为0x4010c0：\n\n\n然后用 SimulationManager 控制程序朝 AssertionError 开始探索：\n1234567891011121314151617181920212223&gt;&gt;&gt; simgr = project.factory.simulation_manager(entry_state)&gt;&gt;&gt; simgr.explore(find=0x4010c0)WARNING  | 2024-03-11 17:27:02,034 | angr.storage.memory_mixins.default_filler_mixin | The program is accessing memory with an unspecified value. This could indicate unwanted behavior.WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | angr will cope with this by generating an unconstrained symbolic variable and continuing. You can resolve this by:WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 1) setting a value to the initial stateWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 2) adding the state option ZERO_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to make unknown regions hold nullWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 3) adding the state option SYMBOL_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to suppress these messages.WARNING  | 2024-03-11 17:27:03,994 | angr.storage.memory_mixins.default_filler_mixin | Filling memory at 0x7fffffffffeff70 with 1 unconstrained bytes referenced from 0x500010 (strlen+0x0 in extern-address space (0x10))&lt;SimulationManager with 829 active, 20 deadended, 1 found&gt;&gt;&gt;&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4010c0&gt;]&gt;&gt;&gt; found_state = simgr.found[0]&gt;&gt;&gt; found_state&lt;SimState @ 0x4010c0&gt;&gt;&gt;&gt; found_state.solver.eval(symbolic_buffer, cast_to=bytes)b&#x27;256\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x80\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00@ \\x08\\x08\\x00\\x02\\x00 \\x00\\x00\\x80\\x00\\x00\\x00@\\x00\\x01 \\x02\\x10\\x00\\x01 \\x10\\x00@\\x04\\x80\\x80\\x01\\x80\\x01@\\x02\\x08\\x08\\x04\\x80\\x01@\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&#x27;&gt;&gt;&gt; len(found_state.solver.eval(symbolic_buffer, cast_to=bytes))99&gt;&gt;&gt; found_state.solver.constraints[&lt;Bool !(input_3_792[791:784] == 10)&gt;, &lt;Bool !(input_3_792[783:776] == 10)&gt;, &lt;Bool !(input_3_792[775:768] == 10)&gt;, &lt;Bool !(input_3_792[767:760] == 10)&gt;, &lt;Bool !(input_3_792[759:752] == 10)&gt;, &lt;Bool !(input_3_792[751:744] == 10)&gt;, &lt;Bool !(input_3_792[743:736] == 10)&gt;, &lt;Bool !(input_3_792[735:728] == 10)&gt;, &lt;Bool !(input_3_792[727:720] == 10)&gt;, &lt;Bool !(input_3_792[719:712] == 10)&gt;, &lt;Bool !(input_3_792[711:704] == 10)&gt;, &lt;Bool !(input_3_792[703:696] == 10)&gt;, &lt;Bool !……\n\n可以看到虽然很慢，但是 Angr 成功地算出了一个可以触发 AssertionError 的输入。计算结果保存在 SimulationManager 的found属性中，每个结果是一个 SimState 实例，通过 SimState 的solver属性可以查看可行解与约束条件。\n五、同类工具\n\n\n特性 \\ 工具\nAngr\nBAP\nTriton\nBinary Ninja\nGhidra\n\n\n\n发布年份\n2015\n2011\n2015\n2016\n2019\n\n\n开发语言\nPython\nOCaml (接口: C&#x2F;Python)\nC++ (接口: Python)\nC++\nJava\n\n\n模块化\n✅\n✅\n❌\n✅\n✅\n\n\n插件系统\n✅\n✅\n❌\n✅\n✅\n\n\n符号执行\n✅\n✅\n✅\n❌\n✅\n\n\n污点分析\n✅\n部分支持\n✅\n✅\n✅\n\n\n动静态分析\n均支持\n主要是静态分析\n主要是动态分析\n主要静态分析\n均支持\n\n\n形式化验证\n有限支持\n✅\n❌\n❌\n通过插件\n\n\n中间表示\nVEX IR\nMicrocode\nTriton IR\nLLIL&#x2F;MLIL&#x2F;HLIL\nP-Code\n\n\n社区活跃度\n高\n中\n低\n高\n高\n\n\n专长领域\n全栈式分析\n可扩展性与形式化验证\n动态分析与污点追踪\n逆向工程\n逆向工程\n\n\n跨平台支持\n广泛\n广泛\n有限\n广泛\n广泛\n\n\n学习曲线\n中等\n较高\n中等\n中等\n中等\n\n\n应用场景\nCTF&#x2F; 漏洞研究 &#x2F; 二进制加固\n安全研究 &#x2F; 形式化验证\n精确污点追踪 &#x2F; 变量跟踪\n逆向工程\n逆向工程\n\n\n开源\n✅\n部分开源\n✅\n社区版开源\n✅\n\n","dateCreated":"2024-01-23T13:45:08+08:00","dateModified":"2024-04-09T15:09:59+08:00","datePublished":"2024-01-23T13:45:08+08:00","description":"Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域","headline":"符号执行工具——Angr 零基础入门","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2024/01/23/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2024/01/23/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/","keywords":"安全, Angr, CTF, 符号执行"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、Angr 简介Angr 是一个由 Python 语言编写的开源二进制分析框架，它主要用于静态分析、符号执行、逆向工程等安全研究领域。Angr 支持多种操作系统和硬件架构，包括 Windows、Linux、macOS 以及 x86、ARM 等。\n二、Angr 整体架构1、核心组件Angr 是一个复杂的二进制分析框架，其初始的整体架构设计如下图：\n\n\nAngr 的核心组件自下而上依次为：\n\nCLE：加载可执行文件和库文件\n\narchinfo：获取架构信息\n\nPyVEX：将指令转换成 VEX 这种中间语言（IR）\n\nSimuVEX：模拟执行引擎，负责在虚拟环境中执行 VEX\n\nClaripy：用于创建和管理符号变量及条件约束，传递给 Z3 求解器进行求解\n\nAngr：将各个组件集成起来，提供一套整体的二进制分析和符号执行框架\n\nanalysis：提供一套分析工具，通过 CFG、DDG 等对程序进行分析\n\nsurveyors：用于记录和跟踪程序的可执行路径\n\n\n随着 Angr 的发展，部分组件有更新和迭代：\n\nSimuVEX 被移除，其组件已集成到 Angr 中\n\nsurveyors 被移除，被 SimulationManager 所取代\n\n\n2、运作流程Angr 的整体运作流程如图：\n\n\n使用 Angr 进行二进制分析时，各组件的运行步骤为：\n\nCLE 加载二进制，获取机器指令\n\nArchinfo 分析二进制的架构类型\n\nPyVEX 根据架构类型，将机器指令转换为 VEX 中间表达\n\nSimEngine 基于 VEX 来模拟程序执行\n\nClarify 创建和管理执行过程中的符号变量和约束条件，转化为 SMT 表达式，传递给 Z3 求解\n\nSimOS（SimProcedures） 模拟程序与系统的交互，如标准 io 流、文件读写、系统调用等操作\n\n\n三、Angr 使用说明1. 安装Angr 需要 python 3.8 以上的运行环境，需要先装 3.8 版本以上的 python。\n安装 Angr 有两种推荐方式：\n\npip 安装\n1pip install Angr\n\n源码安装\n123git clone https://github.com/Angr/Angr-dev.gitcd Angr-dev./setup.sh -i -e Angr\n\n2. 运行  建议在虚拟环境中运行 Angr。源码安装的方式可以自动创建名为 Angr 的虚拟环境。手动创建虚拟环境的命令为：\n1python3 -m venv Angr\n\n启动虚拟环境：\n1source Angr/bin/active\n\n3. 使用Angr 作为 python 的三方库，通过 import 进行调用：\n1import Angr\n\nAngr 的顶层 API 围绕着 Angr 的核心组件来设计，包含一组常用的 Python 类和对象，它们提供了二进制分析、符号执行和其他功能。\n以下是 Angr 的一些常用 API 组件：\n\nProject（项目）：\n\nProject是 Angr 的中心组件，它代表了用户所要处理的二进制文件。\n创建一个 Project 实例是使用 Angr 进行分析的第一步，Project对象提供了对二进制文件的操作和分析的接口。\n\n\nFactory（工厂）：\n\nFactory对象通过 Project 的factory属性来访问，它提供了快速访问 Angr 的各种分析技术的接口，避免复杂的实例化操作。\n\n\nSimState（模拟状态）：\n\nSimState代表程序的一个瞬时状态，它包含寄存器、内存、堆栈、文件系统等运行时的上下文环境状态，可用于执行符号执行和具体执行。\nSimState对象通过 Project 的factory属性的方法来访问，这些方法包括 entry_state、blank_state、full_init_state 等。\n\n\nSimulationManager（模拟管理器）：\n\nSimulationManager用来跟踪程序执行过程中的路径探索和 SimState 演化，并对这些路径和 SimState 进行管理。\nSimulationManager对象通过 Project 的factory属性的 simulation_manager 方法实例化。\n\n\nLoader（加载器）：\n\nLoader负责将二进制文件载入内存，并处理符号以及它们的地址空间，为后续分析提供详细信息，如入口点、可执行段、符号表等。\nLoader对象通过 Project 的loader属性的方法来访问。\n\n\nBlock（块）：\n\nBlock表示程序基本块，是 Angr 分析的基本单位。每个 Block 是一组顺序执行代码片段，具有原子性，以分支或跳转结尾。\nBlock对象通过 Project 的factory属性的 block 方法实例化。\n\n\n\n四、Angr 实践应用example.c 源码：\n12345678910111213141516171819202122232425262728293031323334#include &lt;stdio.h&gt;#include &lt;string.h&gt;#include &lt;stdint.h&gt;#include &lt;assert.h&gt;#define MAX_LEN 100int calculate(int number)&#123;    return number * number;&#125;int main()&#123;    char input[MAX_LEN];    printf(&quot;Enter the string: &quot;);    fgets(input, MAX_LEN, stdin);    int len = strlen(input);    int num = 0;    for(int i = 0; i &lt; len; i++) &#123;        if(input[i] &gt;= &#x27;0&#x27; &amp;&amp; input[i] &lt;= &#x27;9&#x27;)&#123;            num = num * 10 + (input[i] - &#x27;0&#x27;);        &#125;    &#125;    int res = calculate(num);    assert(res != 65536);    return 0;&#125;\n\n将 example.c 编译为 example_binary ：\n1gcc example.c -o example_binary\n\n以 example_binary 为例，演示 Angr 用法。\n1. 静态程序分析  首先用 Angr 定位程序入口：\n12345678910111213&gt;&gt;&gt; import angr&gt;&gt;&gt; project = angr.Project(&#x27;example_binary&#x27;, load_options=&#123;&#x27;auto_load_libs&#x27;: False&#125;)&gt;&gt;&gt; project.filename&#x27;example_binary&#x27;&gt;&gt;&gt; project.arch&lt;Arch AMD64 (LE)&gt;&gt;&gt;&gt; project.entry4198624&gt;&gt;&gt; bb = project.factory.block(4198624)&gt;&gt;&gt; bb.instructions12&gt;&gt;&gt; hex(bb.addr)&#x27;0x4010e0&#x27;\n\n这个 0x4010e0 地址对应的是程序的入口 block ，包括 12 条指令，在 CFG 中表示为如下节点，可以看到 block 的名字并不是 main，而是 _start ：\n\n\n接着从 _start 开始执行，执行一次后到达 ___libc_start_main ，然而再执行一次后并没有到达 main ：\n123456789101112&gt;&gt;&gt; st_0 = project.factory.entry_state()&gt;&gt;&gt; hex(st_0.addr)&#x27;0x4010e0&#x27;&gt;&gt;&gt; nx  = st_0.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x500000&gt;]&gt;&gt;&gt; st_1 = nx.successors[0]&gt;&gt;&gt; hex(st_1.addr)&#x27;0x500000&#x27;&gt;&gt;&gt; nx = st_1.step()&gt;&gt;&gt; nx.successors[&lt;SimState @ 0x4012e0&gt;]\n\n为了获取 main 这个 block 的状态，可以使用 SimulationManager 来执行：\n12345678&gt;&gt;&gt; simgr = project.factory.simulation_manager(st_0)&gt;&gt;&gt; main_obj = project.loader.main_object.get_symbol(&#x27;main&#x27;)&gt;&gt;&gt; hex(main_obj.rebased_addr)&#x27;0x4011dc&#x27;&gt;&gt;&gt; simgr.explore(find=main_obj.rebased_addr)&lt;SimulationManager with 1 found&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4011dc&gt;]\n\n\n\n2. 静态符号执行example_binary 接受一个最长为 100 位的字符串作为输入，提取字符串中的数字，转换成数值，然后进行平方运算，结果等于 65536 时出现断言错误。反推回来，当输入字符串中包含 2、5、6 这三个数字时，就能导致AssertionError。\n要让程序自动找到触发 example_binary 中 AssertionError 的 input，可以用 Angr 符号执行来求解。\n首先引入claripy，创建符号变量：\n1234&gt;&gt;&gt; import claripy&gt;&gt;&gt; input_size = 100&gt;&gt;&gt; symbolic_buffer = claripy.BVS(&#x27;input&#x27;, 8 * (input_size - 1))&gt;&gt;&gt; entry_state = project.factory.entry_state(stdin=claripy.Concat(symbolic_buffer, claripy.BVV(b&#x27;\\n&#x27;)))\n\n通过 CFG 可以找到 AssertionError 的 block 地址为0x4010c0：\n\n\n然后用 SimulationManager 控制程序朝 AssertionError 开始探索：\n1234567891011121314151617181920212223&gt;&gt;&gt; simgr = project.factory.simulation_manager(entry_state)&gt;&gt;&gt; simgr.explore(find=0x4010c0)WARNING  | 2024-03-11 17:27:02,034 | angr.storage.memory_mixins.default_filler_mixin | The program is accessing memory with an unspecified value. This could indicate unwanted behavior.WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | angr will cope with this by generating an unconstrained symbolic variable and continuing. You can resolve this by:WARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 1) setting a value to the initial stateWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 2) adding the state option ZERO_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to make unknown regions hold nullWARNING  | 2024-03-11 17:27:03,808 | angr.storage.memory_mixins.default_filler_mixin | 3) adding the state option SYMBOL_FILL_UNCONSTRAINED_&#123;MEMORY,REGISTERS&#125;, to suppress these messages.WARNING  | 2024-03-11 17:27:03,994 | angr.storage.memory_mixins.default_filler_mixin | Filling memory at 0x7fffffffffeff70 with 1 unconstrained bytes referenced from 0x500010 (strlen+0x0 in extern-address space (0x10))&lt;SimulationManager with 829 active, 20 deadended, 1 found&gt;&gt;&gt;&gt;&gt;&gt;&gt; simgr.found[&lt;SimState @ 0x4010c0&gt;]&gt;&gt;&gt; found_state = simgr.found[0]&gt;&gt;&gt; found_state&lt;SimState @ 0x4010c0&gt;&gt;&gt;&gt; found_state.solver.eval(symbolic_buffer, cast_to=bytes)b&#x27;256\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x80\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00@ \\x08\\x08\\x00\\x02\\x00 \\x00\\x00\\x80\\x00\\x00\\x00@\\x00\\x01 \\x02\\x10\\x00\\x01 \\x10\\x00@\\x04\\x80\\x80\\x01\\x80\\x01@\\x02\\x08\\x08\\x04\\x80\\x01@\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&#x27;&gt;&gt;&gt; len(found_state.solver.eval(symbolic_buffer, cast_to=bytes))99&gt;&gt;&gt; found_state.solver.constraints[&lt;Bool !(input_3_792[791:784] == 10)&gt;, &lt;Bool !(input_3_792[783:776] == 10)&gt;, &lt;Bool !(input_3_792[775:768] == 10)&gt;, &lt;Bool !(input_3_792[767:760] == 10)&gt;, &lt;Bool !(input_3_792[759:752] == 10)&gt;, &lt;Bool !(input_3_792[751:744] == 10)&gt;, &lt;Bool !(input_3_792[743:736] == 10)&gt;, &lt;Bool !(input_3_792[735:728] == 10)&gt;, &lt;Bool !(input_3_792[727:720] == 10)&gt;, &lt;Bool !(input_3_792[719:712] == 10)&gt;, &lt;Bool !(input_3_792[711:704] == 10)&gt;, &lt;Bool !(input_3_792[703:696] == 10)&gt;, &lt;Bool !……\n\n可以看到虽然很慢，但是 Angr 成功地算出了一个可以触发 AssertionError 的输入。计算结果保存在 SimulationManager 的found属性中，每个结果是一个 SimState 实例，通过 SimState 的solver属性可以查看可行解与约束条件。\n五、同类工具\n\n\n特性 \\ 工具\nAngr\nBAP\nTriton\nBinary Ninja\nGhidra\n\n\n\n发布年份\n2015\n2011\n2015\n2016\n2019\n\n\n开发语言\nPython\nOCaml (接口: C&#x2F;Python)\nC++ (接口: Python)\nC++\nJava\n\n\n模块化\n✅\n✅\n❌\n✅\n✅\n\n\n插件系统\n✅\n✅\n❌\n✅\n✅\n\n\n符号执行\n✅\n✅\n✅\n❌\n✅\n\n\n污点分析\n✅\n部分支持\n✅\n✅\n✅\n\n\n动静态分析\n均支持\n主要是静态分析\n主要是动态分析\n主要静态分析\n均支持\n\n\n形式化验证\n有限支持\n✅\n❌\n❌\n通过插件\n\n\n中间表示\nVEX IR\nMicrocode\nTriton IR\nLLIL&#x2F;MLIL&#x2F;HLIL\nP-Code\n\n\n社区活跃度\n高\n中\n低\n高\n高\n\n\n专长领域\n全栈式分析\n可扩展性与形式化验证\n动态分析与污点追踪\n逆向工程\n逆向工程\n\n\n跨平台支持\n广泛\n广泛\n有限\n广泛\n广泛\n\n\n学习曲线\n中等\n较高\n中等\n中等\n中等\n\n\n应用场景\nCTF&#x2F; 漏洞研究 &#x2F; 二进制加固\n安全研究 &#x2F; 形式化验证\n精确污点追踪 &#x2F; 变量跟踪\n逆向工程\n逆向工程\n\n\n开源\n✅\n部分开源\n✅\n社区版开源\n✅\n\n","dateCreated":"2024-01-23T13:45:08+08:00","dateModified":"2024-04-09T15:09:59+08:00","datePublished":"2024-01-23T13:45:08+08:00","description":"Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域","headline":"符号执行工具——Angr 零基础入门","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2024/01/23/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2024/01/23/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/","keywords":"Angr, CTF, 安全, 符号执行"}</script>
     <meta name="description" content="Angr 是一款二进制分析和符号执行工具，常用于 CTF 和安全测试领域">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="符号执行工具——Angr 零基础入门">
@@ -28,9 +28,9 @@
 <meta property="article:published_time" content="2024-01-23T05:45:08.000Z">
 <meta property="article:modified_time" content="2024-04-09T07:09:59.608Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Angr">
 <meta property="article:tag" content="CTF">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="符号执行">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://jiliguluss.github.io/2024/01/23/Angr%E9%9B%B6%E5%9F%BA%E7%A1%80%E5%85%A5%E9%97%A8/Angr%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6.png">
diff --git "a/2024/02/27/Symbion\345\210\235\346\216\242/index.html" "b/2024/02/27/Symbion\345\210\235\346\216\242/index.html"
index de8d9e7..d4ef3b5 100644
--- "a/2024/02/27/Symbion\345\210\235\346\216\242/index.html"
+++ "b/2024/02/27/Symbion\345\210\235\346\216\242/index.html"
@@ -13,7 +13,7 @@
     
     
     
-    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、原理  原始论文：SYMBION: Interleaving Symbolic with Concrete Execution\n官方博客：symbion: fusing concrete and symbolic execution\n1. 背景  符号执行可以用来获取走到指定程序区块的可行输入，但是符号执行在实际应用中面临很多挑战：\n\n路径爆炸问题：符号执行从程序入口开始探索，当程序中出现分支和循环时，会导致路径状态呈指数增长。\n\n环境交互问题：当程序与系统或三方库进行交互时，由于缺失源码或交互复杂等原因，会阻碍符号执行的状态更新。\n\n\n2. 方案Symbion 通过具体执行环境与符号执行环境的同步与切换，实现具体值和符号值交替执行。通过这种交替执行机制，减少符号执行探索的路径状态，并解决程序对外部环境的依赖问题。\n图中演示了具体执行环境与符号执行环境相互切换的过程：\n\n\n目标是对从 PoI 到TP的路径进行符号推理，CSP节点是程序入口。从 CSP 到PoI要经过复杂的运算和交互，这导致直接从 CSP 开始符号推理，将无法向后演进到PoI。\n使用 Symbion 时，首先将具体值输入给 CSP，在具体执行后到达PoI。然后在PoI 切换到符号执行环境，算出到达 TP 所需的变量取值。再将算出来的结果同步给具体执行环境，在 PoI 恢复具体执行，即可到达TP。\n3. 实现Symbion 的架构设计如下：\n\n\nSymbion 在 Angr 的基础上，增加了如下组件：\n\nConcrete Target：定义了与具体执行环境交互的方法，通过实现这些方法可以让 Symbion 支持特定的交互环境。例如 Symbion 实现的GDBConcreteTarget，它通过 gdbsever 控制远程目标程序的交互。\n\nread_memory(address, nbytes)：从具体进程内存中 address 开始读取 nbytes 字节。\nwrite_memory(address, value)：在具体进程内存中 address 处写入value。\nread_register(register)：返回具体进程中指定 register 的内容。\nwrite_register(register, value)：在具体进程的 register 中写入value。\nset_breakpoint(address)：在具体进程中的 address 处设置断点。\nremove_breakpoint(address)：移除之前在 address 处设置的断点。\nrun()：恢复具体进程的执行。\n\n\nSimEngineConcrete：利用 Concrete Target 的方法执行以下步骤，实现 Symbolic 环境到 Concrete 环境的切换。\n\n用用户提供的值修改具体进程的内存。\n用用户提供的值修改具体进程的寄存器。\n通过断点来设置新的PoI。\n恢复程序的具体执行，直到到达新的PoI，并将控制权交还给 Angr。\n\n\nConcrete SimPlugin：当具体执行到达 PoI，这个插件实现Concrete 环境到 Symbolic 环境的切换，它将具体状态导入 Angr 来创建SimState。\n\n将 SimState 的内存后端重定向到具体进程的内存，即在符号执行过程中，SimState的内存读取都是从具体进程中来操作。\n\n将具体进程中的寄存器值复制到 SimState 中。\n\n将具体进程的内存映射与 Angr 在启动期间加载的内存映射同步。\n\n\n\nSYMBION Exploration Technique：提供用户使用 Symbion 的 API ，通过这些 API ，用户指定 PoI 的地址，在具体执行到达 PoI 后，Symbion 切换为符号执行。\n\n\n简而言之，在 Symbion 的工作流程中，各组件的作用为：\n\n用户通过 SYMBION Exploration Technique 指定PoI。\n\n程序经过具体执行到达到 PoI 后暂停， Concrete SimPlugin 根据具体执行环境来创建一个SimState。\n\nAngr 通过符号执行，计算到达下一个 PoI 的可行解。\n\nSimEngineConcrete 用 Angr 算出来的结果修改具体进程中的变量，恢复具体执行直到下一个PoI。\n\n\n二、示例Symbion 官方示例：test_concrete_not_packed_elf64\n示例使用的二进制：not_packed_elf64\n二进制没有给源码，通过 IDA 逆向源码，并用 AI 改写，得到 C 源码如下，源码中取 dest 变量中的一串数值做判断，不同的分支触发不同的print。\n\n\n在 Symbion 的示例代码中，首先通过具体执行到达 BINARY_DECISION_ADDRESS，然后用符号执行探索从BINARY_DECISION_ADDRESS 到DROP_STAGE2_V2的路径。\n\n\n在符号执行求解成功后，再将求解结果传递给具体执行环境，并启动具体执行，即可到达DROP_STAGE2_V2：\n\n\n结合 CFG 和源码可以看到，符号执行的起点 BINARY_DECISION_ADDRESS 对应源码图右侧 55 行，符号执行的终点 DROP_STAGE2_V2 对应源码图右侧 77 行。通过 Symbion，实现了对二进制按指定路径的进行分析的目的。\n\n\nSymbion 的示例代码中，涉及到很多内存地址操作，需要结合 IDA 的反编译源码来看：\n\n\n\nline 2：启动具体执行，到 BINARY_DECISION_ADDRESS 停下，即 IDA 反编译源码第 67 行代码\n\nline 3：从具体执行环境的获取寄存器中的栈指针sp，指向栈顶（即栈开始的位置）\n\nline 4：从栈顶 sp 开始读取 20 个字节的内存，这块内存包括反编译源码中的变量 i 和v5\n\nline 5：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 7：定义符号变量，变量名为arg0，大小为 32 字节\n\nline 8：用 symbolic_buffer_memory 指向具体执行环境中 rbp-0xc0 的内存地址，它对应 IDA 反编译源码中的数组 s 的起始地址。\n\nline 10：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 11：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 12：将 angr0 存储到symbolic_buffer_memory，将符号变量与具体执行环境的内存地址关联起来\n\nline 15：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 16：判断是否为符号变量，因为 把 angr0 保存到这块内存，所以是符号变量\n\nline 19：符号执行状态初始化\n\nline 37：启动符号执行\n\n\n可以看到，Symbion 在切换具体执行环境和符号执行环境时，是通过内存地址把变量的具体值和符号值对应起来。需要结合 IDA 反编译的源码中给出的变量地址和内存大小，人工设置符号执行中所需要的符号变量，难以实现自动化。","dateCreated":"2024-02-27T16:33:24+08:00","dateModified":"2024-04-09T15:00:01+08:00","datePublished":"2024-02-27T16:33:24+08:00","description":"Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行","headline":"交替符号执行工具——Symbion 初探","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/","keywords":"安全, Angr, 符号执行"}</script>
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","author":{"@type":"Person","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg"},"articleBody":"\n\n一、原理介绍  原始论文：SYMBION: Interleaving Symbolic with Concrete Execution\n官方博客：symbion: fusing concrete and symbolic execution\n1. 背景  符号执行可以用来获取走到指定程序区块的可行输入，但是符号执行在实际应用中面临很多挑战：\n\n路径爆炸问题：符号执行从程序入口开始探索，当程序中出现分支和循环时，会导致路径状态呈指数增长。\n\n环境交互问题：当程序与系统或三方库进行交互时，由于缺失源码或交互复杂等原因，会阻碍符号执行的状态更新。\n\n\n2. 方案Symbion 通过具体执行环境与符号执行环境的同步与切换，实现具体值和符号值交替执行。通过这种交替执行机制，减少符号执行探索的路径状态，并解决程序对外部环境的依赖问题。\n图中演示了具体执行环境与符号执行环境相互切换的过程：\n\n\n目标是对从 PoI 到TP的路径进行符号推理，CSP节点是程序入口。从 CSP 到PoI要经过复杂的运算和交互，这导致直接从 CSP 开始符号推理，将无法向后演进到PoI。\n使用 Symbion 时，首先将具体值输入给 CSP，在具体执行后到达PoI。然后在PoI 切换到符号执行环境，算出到达 TP 所需的变量取值。再将算出来的结果同步给具体执行环境，在 PoI 恢复具体执行，即可到达TP。\n3. 实现Symbion 的架构设计如下：\n\n\nSymbion 在 Angr 的基础上，增加了如下组件：\n\nConcrete Target：定义了与具体执行环境交互的方法，通过实现这些方法可以让 Symbion 支持特定的交互环境。例如 Symbion 实现的GDBConcreteTarget，它通过 gdbsever 控制远程目标程序的交互。\n\nread_memory(address, nbytes)：从具体进程内存中 address 开始读取 nbytes 字节。\nwrite_memory(address, value)：在具体进程内存中 address 处写入value。\nread_register(register)：返回具体进程中指定 register 的内容。\nwrite_register(register, value)：在具体进程的 register 中写入value。\nset_breakpoint(address)：在具体进程中的 address 处设置断点。\nremove_breakpoint(address)：移除之前在 address 处设置的断点。\nrun()：恢复具体进程的执行。\n\n\nSimEngineConcrete：利用 Concrete Target 的方法执行以下步骤，实现 Symbolic 环境到 Concrete 环境的切换。\n\n用用户提供的值修改具体进程的内存。\n用用户提供的值修改具体进程的寄存器。\n通过断点来设置新的PoI。\n恢复程序的具体执行，直到到达新的PoI，并将控制权交还给 Angr。\n\n\nConcrete SimPlugin：当具体执行到达 PoI，这个插件实现Concrete 环境到 Symbolic 环境的切换，它将具体状态导入 Angr 来创建SimState。\n\n将 SimState 的内存后端重定向到具体进程的内存，即在符号执行过程中，SimState的内存读取都是从具体进程中来操作。\n\n将具体进程中的寄存器值复制到 SimState 中。\n\n将具体进程的内存映射与 Angr 在启动期间加载的内存映射同步。\n\n\n\nSYMBION Exploration Technique：提供用户使用 Symbion 的 API ，通过这些 API ，用户指定 PoI 的地址，在具体执行到达 PoI 后，Symbion 切换为符号执行。\n\n\n简而言之，在 Symbion 的工作流程中，各组件的作用为：\n\n用户通过 SYMBION Exploration Technique 指定PoI。\n\n程序经过具体执行到达到 PoI 后暂停， Concrete SimPlugin 根据具体执行环境来创建一个SimState。\n\nAngr 通过符号执行，计算到达下一个 PoI 的可行解。\n\nSimEngineConcrete 用 Angr 算出来的结果修改具体进程中的变量，恢复具体执行直到下一个PoI。\n\n\n二、示例分析Symbion 官方示例：test_concrete_not_packed_elf64\n示例使用的二进制：not_packed_elf64\n二进制没有给源码，通过 IDA 逆向源码，并用 AI 改写，得到 C 源码如下，源码中取 dest 变量中的一串数值做判断，不同的分支触发不同的print。\n\n\n在 Symbion 的示例代码中，首先通过具体执行到达 BINARY_DECISION_ADDRESS，然后用符号执行探索从BINARY_DECISION_ADDRESS 到DROP_STAGE2_V2的路径。\n\n\n在符号执行求解成功后，再将求解结果传递给具体执行环境，并启动具体执行，即可到达DROP_STAGE2_V2：\n\n\n结合 CFG 和源码可以看到，符号执行的起点 BINARY_DECISION_ADDRESS 对应源码图右侧 55 行，符号执行的终点 DROP_STAGE2_V2 对应源码图右侧 77 行。通过 Symbion，实现了对二进制按指定路径的进行分析的目的。\n\n\nSymbion 的示例代码中，涉及到很多内存地址操作，需要结合 IDA 的反编译源码来看：\n\n\n\nline 2：启动具体执行，到 BINARY_DECISION_ADDRESS 停下，即 IDA 反编译源码第 67 行代码\n\nline 3：从具体执行环境的获取寄存器中的栈指针sp，指向栈顶（即栈开始的位置）\n\nline 4：从栈顶 sp 开始读取 20 个字节的内存，这块内存包括反编译源码中的变量 i 和v5\n\nline 5：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 7：定义符号变量，变量名为arg0，大小为 32 字节\n\nline 8：用 symbolic_buffer_memory 指向具体执行环境中 rbp-0xc0 的内存地址，它对应 IDA 反编译源码中的数组 s 的起始地址。\n\nline 10：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 11：判断是否为符号变量，此时为具体执行环境，所以不是符号变量\n\nline 12：将 angr0 存储到symbolic_buffer_memory，将符号变量与具体执行环境的内存地址关联起来\n\nline 15：从 symbolic_buffer_memory 开始加载 36 个字节的内存\n\nline 16：判断是否为符号变量，因为 把 angr0 保存到这块内存，所以是符号变量\n\nline 19：符号执行状态初始化\n\nline 37：启动符号执行\n\n\n可以看到，Symbion 在切换具体执行环境和符号执行环境时，是通过内存地址把变量的具体值和符号值对应起来。需要结合 IDA 反编译的源码中给出的变量地址和内存大小，人工设置符号执行中所需要的符号变量，难以实现自动化。","dateCreated":"2024-02-27T16:33:24+08:00","dateModified":"2024-04-09T15:14:40+08:00","datePublished":"2024-02-27T16:33:24+08:00","description":"Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行","headline":"交替符号执行工具——Symbion 初探","image":[],"mainEntityOfPage":{"@type":"WebPage","@id":"https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/"},"publisher":{"@type":"Organization","name":"一瓢清浅","sameAs":["#about","https://github.com/"],"image":"photo.jpg","logo":{"@type":"ImageObject","url":"photo.jpg"}},"url":"https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/","keywords":"Angr, 安全, 符号执行"}</script>
     <meta name="description" content="Symbion 是 Angr 的一款插件，可以实现具体执行与符号执行交替运行">
 <meta property="og:type" content="blog">
 <meta property="og:title" content="交替符号执行工具——Symbion 初探">
@@ -29,10 +29,10 @@
 <meta property="og:image" content="https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/not_packed_elf64%E6%8C%87%E5%AE%9A%E8%B7%AF%E5%BE%84.png">
 <meta property="og:image" content="https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/not_packed_elf64%E7%A4%BA%E4%BE%8B%E4%BB%A3%E7%A0%81%E5%88%86%E6%9E%90.png">
 <meta property="article:published_time" content="2024-02-27T08:33:24.000Z">
-<meta property="article:modified_time" content="2024-04-09T07:00:01.486Z">
+<meta property="article:modified_time" content="2024-04-09T07:14:40.547Z">
 <meta property="article:author" content="一瓢清浅">
-<meta property="article:tag" content="安全">
 <meta property="article:tag" content="Angr">
+<meta property="article:tag" content="安全">
 <meta property="article:tag" content="符号执行">
 <meta name="twitter:card" content="summary">
 <meta name="twitter:image" content="https://jiliguluss.github.io/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/symbion%E4%B8%8A%E4%B8%8B%E6%96%87%E5%88%87%E6%8D%A2.png">
@@ -280,7 +280,7 @@ <h1 class="post-title">
         <div class="main-content-wrap">
             <!--excerpt-->
 
-<h2 id="一、原理"><a href="# 一、原理" class="headerlink" title="一、原理"></a>一、原理 </h2><p> 原始论文：<a target="_blank" rel="noopener" href="https://seclab.cs.ucsb.edu/files/publications/gritti2020_symbion.pdf">SYMBION: Interleaving Symbolic with Concrete Execution</a></p>
+<h2 id="一、原理介绍"><a href="# 一、原理介绍" class="headerlink" title="一、原理介绍"></a>一、原理介绍 </h2><p> 原始论文：<a target="_blank" rel="noopener" href="https://seclab.cs.ucsb.edu/files/publications/gritti2020_symbion.pdf">SYMBION: Interleaving Symbolic with Concrete Execution</a></p>
 <p>官方博客：<a target="_blank" rel="noopener" href="https://angr.io/blog/angr_symbion/">symbion: fusing concrete and symbolic execution</a></p>
 <h3 id="1- 背景"><a href="#1- 背景" class="headerlink" title="1. 背景"></a>1. 背景 </h3><p> 符号执行可以用来获取走到指定程序区块的可行输入，但是符号执行在实际应用中面临很多挑战：</p>
 <ol>
@@ -343,7 +343,7 @@ <h3 id="3- 实现"><a href="#3- 实现" class="headerlink" title="3. 实现"></a
 <li><p>SimEngineConcrete 用 Angr 算出来的结果修改具体进程中的变量，恢复具体执行直到下一个<code>PoI</code>。</p>
 </li>
 </ol>
-<h2 id="二、示例"><a href="# 二、示例" class="headerlink" title="二、示例"></a>二、示例</h2><p>Symbion 官方示例：<a target="_blank" rel="noopener" href="https://github.com/angr/angr-targets/blob/master/tests/test_concrete_not_packed_elf64.py">test_concrete_not_packed_elf64</a></p>
+<h2 id="二、示例分析"><a href="# 二、示例分析" class="headerlink" title="二、示例分析"></a>二、示例分析</h2><p>Symbion 官方示例：<a target="_blank" rel="noopener" href="https://github.com/angr/angr-targets/blob/master/tests/test_concrete_not_packed_elf64.py">test_concrete_not_packed_elf64</a></p>
 <p>示例使用的二进制：<a target="_blank" rel="noopener" href="https://github.com/angr/binaries/blob/master/tests/x86_64/not_packed_elf64">not_packed_elf64</a></p>
 <p>二进制没有给源码，通过 IDA 逆向源码，并用 AI 改写，得到 C 源码如下，源码中取 <code>dest</code> 变量中的一串数值做判断，不同的分支触发不同的<code>print</code>。</p>
 <img src="/2024/02/27/Symbion%E5%88%9D%E6%8E%A2/%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%80%86%E5%90%91%E6%BA%90%E7%A0%81.png" class="">