# 汇编和内存

你已经开了汇编学习的旅程,并且在前几章中你已经学习了汇编调用的一些黑魔法,你现在知道了,当一个函数被调用,他的参数和返回值是如何传递的。但是您还没学到的是将代码加载到内存后如何执行代码。

在本章中,您将探索程序的执行方式。 您将看到一个特殊的寄存器,该寄存器用于告诉处理器应该从何处读取下一条指令,以及不同大小和内存分组如何产生截然不同的结果。

# 设置英特尔风格汇编体验™

如上一章所述,显示汇编有两种主要方法。 一种类型是 AT&T 程序集,这个也是 LLDB 的默认程序集。 这种格式具有以下格式:

opcode(操作码)  source(源)  destination(目的地)

看一个具体的例子

movq  $0x78, %rax

这个操作会将十六进制值 0x78 移动到 RAX 寄存器中。 尽管这种汇编形式对某些人来说很不错,但从现在开始,您将使用英特尔的表示形式。

注意:汇编的选择有点像一场大战,有的人说用 Inter 的格式,有的说是用 AT&T 的格式,在 StackOverflow 中查看以下讨论
选择使用英特尔是因为大家都觉得英特尔在阅读方面更好,但有时在写作方面更差。 由于您正在学习调试,因此大部分时间是在阅读汇编而不是编写汇编。

把以下的两行内容添加进 ~/.lldbinit file 文件底部

  • settings set target.x86-disassembly-flavor intel
  • settings set target.skip-prologue false

第一行告诉 LLDB 以 Intel 风格显示 x86 汇编(32 位和 64 位)。
第二行告诉 LLDB 不要跳过函数序言。 您在本书的前面已经了解了这一点,从现在开始,请不要跳过序言,因为您将直接从函数的第一条指令检查汇编。

<font color=#0099ff size=3 face="黑体"> 关于函数序言和函数尾声可以再参考这篇文章 </font>

<font color=#DC143C size=3 face="黑体"> 注意:在编辑〜/.lldbinit 文件时,请确保您不使用 TextEdit 之类的程序,因为它将在文件中添加不必要的字符,这可能导致 LLDB 无法正确解析该文件。 一种简单(尽管很危险)的添加方法是通过如下的 Terminal 命令:echo“ settings set target.x86-disassembly-flavor intel” >>〜/.lldbinit。
确保其中有两个 “>>”,否则将覆盖〜/.lldbinit 文件中的所有先前内容。 如果您对终端机不满意,最好的选择是 nano(您之前使用过的编辑器)。</font>

英特尔风格将交换源值和目标值,删除 '%' 和 '$' 字符以及进行许多其他许多更改。 由于您还不会使用 AT&T 语法,因此这里就不解释全部的差异,我们只单单学习 Inter 程序集就够了。

看下面的示例,就是以 Inter 风格来展示,他看起来比较干净,比较好阅读。

mov  rax, 0x78

同样,这会将十六进制值 0x78 移到 RAX 寄存器中。
与前面显示的 AT&T 风格相比,Intel 风格交换了源操作数和目标操作。 现在,目标操作数在源操作数之前。 在进行汇编时,务必始终确定正确的风格,这很重要,因为如果您不清楚要使用的风格,则可能会采取不同的操作。

从现在开始,我们就开始使用 Inter 的汇编格式了。 如果您看到以 $ 字符开头的数字十六进制常量或以%开头的寄存器,你就要把他们转换成 Inter 的形式

注:笔者反而觉得 AT&T 的风格更适合中国汉语的语法,只是前面的 % 和 $ 有些奇怪罢了

# 创建 cpx 命令

首先,您将创建自己的 LLDB 命令,之后会用到。
再次打开〜/.lldbinit(vim)。 然后将以下内容添加到文件底部:

  • command alias -H "Print value in ObjC context in hexadecimal" -h "Print in hex" -- cpx expression -f x -l objc --

cpx 是一个便捷命令,您可以使用 Objective-C 上下文以十六进制格式打印出某些内容。 尤其是在打印出寄存器内容时会用到。
请记住,寄存器在 Swift 上下文中不可用,因此您需要使用 Objective-C 上下文。
现在,您已经具有从汇编的角度探讨本章内容所需的工具!

# 位,字节和其他术语

在开始探索内存之前,您需要了解一些有关内存分组方式的词汇。

  • 位 :可以包含 1 或 0 的值称为位。您可以说在 64 位体系结构中每个地址有 64 位。很简单。
  • 字节:当 8 位组合在一起时,它们称为字节。一个字节可以容纳多少个唯一值?您可以通过计算 2 ^ 8(从 0 开始到 255 的 256 个值)来确定。

许多信息以字节表示。例如,C 语言中 sizeof()函数以字节为单位返回对象的大小。

如果您熟悉 ASCII 字符编码,您会想起所有 ASCII 字符都可以保存在一个字节中。
现在是时候看看实际操作中的术语并学习一些技巧。
打开 Registers macOS 应用程序,您将在本章的资源文件夹中找到该应用程序。接下来,构建并运行该应用程序。一旦运行,请暂停程序并启动 LLDB 控制台。这将导致使用非 Swift 调试上下文,因为默认情况下暂停应用程序会带来非 Swift 上下文。
在 LLDB 中键入以下内容:

  • p sizeof('A')

这将打印出组成 'A' 字符所需的字节数

(unsigned long) $0 = 1

然后输入如下命令

  • p/t 'A'

你会得到

(char) $1 = 0b01000001

这是 ASCII 中字符 A 的二进制表示。
显示信息字节的另一种更常见的方法是使用十六进制值。 需要两个十六进制数字以十六进制表示一个信息字节。

然后我们输入以下命令来打印出 “A” 的十六进制表示形式:

  • p/x 'A'

你将会得到

(char) $2 = 0x41

十六进制非常适合查看内存,因为一个十六进制数字恰好代表 4 位。 因此,如果您有 2 个十六进制数字,则您有 1 个字节。 如果您有 8 个十六进制数字,则您有 4 个字节。 等等。
这里还有一些适用于您的术语,这些术语在以后的章节中会很有用:

  • Nybble:4 位,十六进制单个值
  • Half word:16 位或 2 个字节
  • Word:32 位或 4 个字节
  • Double word or Giant word:64 位或 8 字节。

使用此术语,您将可以探索不同的内存块。

# RIP 寄存器

当程序执行时,将要执行的代码加载到内存中。 程序中接下来要执行的代码的位置由一个非常重要的寄存器决定:RIP 或指令指针寄存器。
让我们来看看实际情况。 再次打开 “register demo” 应用程序,然后导航到 AppDelegate.swift 文件。 修改文件,使其包含以下代码:

@NSApplicationMain
class AppDelegate: NSObject, NSApplicationDelegate {

func applicationWillBecomeActive(
    _ notification: Notification) {
    print("\(#function)")
    self.aBadMethod()
}

func aBadMethod() {
    print("\(#function)")
}

func aGoodMethod() {
    print("\(#function)")
}
}

构建并运行该应用程序。 毫无疑问,控制台将会输出 该方法名 applicationWillBecomeActive(_ :) ,然后输出 aBadMethod 。我们在在 aBadMethod 的开始处创建一个断点:

再次构建并运行。 在 aBadMethod 的开头命中断点后,导航至 Debug \ Debug Workflow \ Always Show Disassembly in Xcode。 现在,您将看到程序的实际汇编!

然后我们在控制台输入以下命令:

cpx $rip

这将使用您先前创建的 cpx 命令打印出指令指针寄存器。
您会注意到输出 LLDB 的地址与 Xcode 中绿线突出显示的地址是一样的:

(unsigned long) $1 = 0x0000000100008910

当然了每个人的电脑上显示的地址是不同的,而且每次执行时候的地址都可能不一样,但是在单次运行中绿线和控制台上显示的肯定是完全一样的。你试着在控制台下打以下命令:

(lldb) image lookup -vrn ^Registers.*aGoodMethod

这是一个很常用的查找命令,其中包含典型的正则表达式参数以及添加的参数 -v ,该参数输出详细信息就像 --verbose
您会看到很多的东西。 在控制台中使用 command + F 来搜索关键字 range = [ 其中范围中的第一个值便是

该地址称为加载地址。 这是此函数在内存中的实际物理地址!这与您在 image lookup 命令中看到的常规输出不同,它仅显示函数相对于可执行文件的偏移量,也称为实现偏移量。 寻找函数地址时,区分加载地址和可执行文件中的实现偏移很重要,因为它会有所不同。

将这个新地址复制到范围括号的开头。 对于此特定示例,aGoodMethod 的加载地址位于 0x0000000100008910。 现在将 aGoodMethod 的地址指向 RIP 寄存器。输入以下指令

  • register write rip 0x0000000100008910

单击继续,使用 Xcode 调试按钮单击 “继续”。 请一定用 Xcode 的按钮来继续,不要是用 continue 命令,因为在修改 RIP 寄存器并在控制台中继续操作时就会崩溃。按下 Xcode 继续按钮后,您会看到神奇的事情 -> 未执行 aBadMethod(),而是执行了 aGoodMethod()。 通过查看控制台日志中的输出来验证这一点。

注意:修改 RIP 寄存器实际上非常危险。 您需要确 RIP 寄存器上的数据不会再被使用了,因为新功能将对 RIP 寄存器做出不正确的假设。 由于 aGoodMethod 和 aBadMethod 在功能上非常相似,因此您从一开始就停了下来,并且由于没有对 Registers 应用程序进行任何修改,因此不必担心。

# 寄存器和比特分解

如上一章所述,x64 具有 16 个通用寄存器:RDI,RSI,RAX,RDX,RBP,RSP,RCX,RDX,R8,R9,R10,R11,R12,R13,R14 和 R15。
为了保持与 i386 的 32 位架构等以前的体系结构的兼容性,可以将寄存器分为 32 位,16 位或 8 位值。

对于具有不同体系结构历史的寄存器,寄存器名称中的最前面的字符确定寄存器的大小。 例如,RIP 寄存器以 R 开头,它表示 64 位。 如果您希望使用等效于 RIP 寄存器的 32 位,则可以将 R 字符换成 E,以获得 EIP 寄存器。

为什么这些有用? 因为使用寄存器时,有时传递到寄存器的值不需要全部使用 64 位。 例如,考虑布尔数据类型:您真正需要的只是 1 或 0 以指示是或否(尽管实际上,布尔值将占用寄存器一个字节)。 基于语言的功能和约束,编译器知道这一点,有时只会将信息写入寄存器的某些部分。
让我们来看看实际情况。
删除 Registers 项目中的所有断点。 生成并运行项目。 现在,让程序暂停。输入以下内容:

  • register write rdx 0x0123456789ABCDEF

这会将值写入 RDX 寄存器。让我们停一分钟。 <font color=red size=3> 提示:您应该注意,写入寄存器可能会导致程序崩溃,尤其是当您希望写入的寄存器具有某种类型的数据时 </font>。 但是你现在是在 demo 上做调试,所以请不要担心您的程序是否崩溃!
确认此值已成功写入 RDX 寄存器:

  • p/x $rdx

输出

(unsigned long) $0 = 0x0123456789abcdef

然后输入

  • p/x $dx

这将打印出 DX 寄存器,该寄存器是 EDX 寄存器的最低有效部分。 因此,这是一个半字。 您应该看到以下内容:

0xcdef

再输入

  • p/x $dl

这将打印出 DL 寄存器,它是 DX 寄存器的最低有效位 - 这次是一个字节。 您应该看到以下内容

0xef

最后输出如下指令

  • p/x $dh

这为您提供了 DX 寄存器的最高有效部分,即 DL 给出的另一半。 DL 中的 L 代表 “低” 而 DH 中的 H 代表 “高” 也就不足为奇了。
探索汇编时,请注意不同尺寸的寄存器。 寄存器的大小可以为其中包含的值提供线索。 例如,您可以轻松地查找通过 AL 寄存器返回布尔值的函数,因为布尔值将使用 8 个字节,<font color=red size=3> 而 AL 是 64 位 “返回值寄存器” RAX 的 8 位部分 </font>

# 寄存器 R8 到 R15

由于 R8 至 R15 系列寄存器仅针对 64 位架构而创建,因此它们使用完全不同的格式表示较小的寄存器。

现在,您将看下 R9 的不同大小如何选择。生成并运行 Registers 应用程序,然后暂停调试器。像以前一样,将相同的十六进制值写入 R9 寄存器:

  • register write $r9 0x0123456789abcdef

输入以下内容,以确认您已设置 R9 寄存器成功:

  • p/x $ r9

输入以下内容,这将打印 R9 寄存器的低 32 位。请注意,它与您为 RDX 指定低 32 位(即 EDX)的方式有何不同。

  • p/x $ r9d

然后输入以下内容,这次您获得 R9 的低 16 位。同样,这与您为 RDX 进行此操作的方式不同

  • p/x $ r9w

再输入以下内容,打印出 R9 的低 8 位

  • p/x $ r9l

尽管这看起来有些乏味,但是您正在建立阅读汇编语言的技巧。

# 内存中断

现在,您已经了解了指令指针,是时候进一步探索其背后的内存了。顾名思义,指令指针实际上是一个指针。它不执行 RIP 寄存器中存储的指令,而是执行 RIP 寄存器中指向的指令。

在 LLDB 中看到这一点也许会更好地描述它。返回 Registers 应用程序中,打开 AppDelegate.swift 并再次在 aBadMethod 上设置一个断点。生成并运行该应用程序。

命中断点并停止程序后,导航回到汇编视图。如果您忘记了该操作,但尚未为其创建键盘快捷键,则可以在 Debug \ Debug Workflow \ Always Show Disassembly 下找到它。
您会看到一堆汇编指令。看一下 RIP 寄存器的位置,该位置应指向函数的最开始。
对于该项目,aBadMethod 的起始地址始于 0x100008910。和往常一样,您的地址可能会有所不同。
在 LLDB 控制台中,键入以下内容:

  • cpx $rip

到现在为止,这将打印出指令指针寄存器的内容。如预期的那样,您将获得 aBadMethod 起始地址。 但是同样,RIP 寄存器指向内存中的值。 它指的是什么? 嗯,您可以摆脱疯狂的 C 编码技巧(您还记得吗?)并取消引用指针,但是使用 LLDB 可以找到一种更为优雅的方法。
输入以下内容,将地址替换为您的 aBadMethod 函数的地址:

  • memory read -fi -c1 0x100008910

哇,该命令到底能做什么? memory read 采用一个值,并读取您提供的内存地址所指向的内容。 -f 命令是一个格式参数。 在这种情况下,它是汇编指令格式。 最后,您说的是只希望使用 count 或 - c 参数打印一条汇编指令。
您将获得类似于以下内容的输出:

->  0x1000017c0: 55  pushq  %rbp

这是一些很好的输出。 它告诉您十六进制(0x55)中提供的汇编指令以及操作码,这些指令是 pushq %rbp 操作

注意:等等,您看到 '%' 吗?! LLDB 中存在一个错误,当您以指令格式打印代码时,该错误不符合您的汇编风格。 请记住,如果您看到这种情况,则源和目标操作数将被反转!这就是 inter 指令集和 AT&T 指令集的区别。

让我们再看一下输出中的 “55”。 这是整个指令(即整个 pushq %rbp)的编码。 不相信我吗? 您可以验证它。 在 LLDB 中输入以下内容:

  • expression -f i -l objc -- 0x55

这实际上要求 LLDB 将 0x55 解释为 x64 操作码。 您将获得以下输出:

$1 = 55 pushq%rbp

该命令有点长,但这是因为如果您在 Swift 调试上下文中,则需要切换到 Objective-C 上下文。 但是,如果移至 Objective-C 调试上下文,则可以使用简短得多的便捷表达式。

尝试单击 Xcode 左侧面板中的其他框架,以进入一个不包含 Swift 或 Objective-C / Swift 桥接代码的 Objective-C 上下文。 单击 Objective-C 函数中的任何框架。

下一步,在 LLDB 控制台中键入以下内容:

  • p/i 0x55

好多了,对吧?
现在,回到手中的应用程序。 在 LLDB 中键入以下内容,再次用 aBadMethod 函数地址替换地址:

  • memory read -fi -c10 0x1000017c0

你讲获得以下输出:

-> 0x100008910: 55                    pushq  %rbp
0x100008911: 48 89 e5              movq   %rsp, %rbp
0x100008914: 48 81 ec c0 00 00 00  subq   $0xc0, %rsp
0x10000891b: 4c 89 6d f8           movq   %r13, -0x8(%rbp)
0x10000891f: b8 01 00 00 00        movl   $0x1, %eax
0x100008924: 89 c7                 movl   %eax, %edi
0x100008926: e8 d5 05 00 00        callq  0x100008f00               ; symbol stub for: generic specialization <preserving fragile attribute, Any> of Swift._allocateUninitializedArray<A>(Builtin.Word) -> (Swift.Array<A>, Builtin.RawPointer)
0x10000892b: 48 89 c7              movq   %rax, %rdi
0x10000892e: 48 89 45 a8           movq   %rax, -0x58(%rbp)
0x100008932: 48 89 55 a0           movq   %rdx, -0x60(%rbp)

这里需要注意一些有趣的事情:汇编指令的长度可以变化。 看一下第一条指令,然后看输出中的其余指令。 第一条指令的长度为 1 个字节,用 0x55 表示。 以下指令的长度为三个字节。
确保您仍在 Objective-C 上下文中,并尝试打印出负责此指令的操作码。 它只有三个字节,所以您只需将它们连接在一起

  • p/i 0x4889e5

您将获得与 mov %rsp,%rbp 指令完全无关的另一条指令! 您会看到以下内容:

e5 89  inl    $0x89, %eax

是怎么做到的呢? 也许现在是谈论字节序的好时机。

# 字节序... 这东西倒过来了

x64 以及 ARM 系列体系结构设备均使用低位字节序,这意味着数据以最低有效字节在先的形式存储在内存中。 如果要将数字 0xabcd 存储在内存中,则会先存储 0xcd 字节,然后再存储 0xab 字节。
回到指令示例,这意味着指令 0x4889e5 将以 0xe5、0x89、0x48 的形式存储在存储器中。
返回到您先前遇到的 mov 指令,请尝试反转用于构成汇编指令的字节。 在 LLDB 中输入以下内容:

  • p/i 0xe58948

您现在将获得预期的汇编表示:

$2 = 48 89 e5  movq   %rsp, %rbp

让我们再看看一些小端实践的例子。 在 LLDB 中输入以下内容:

  • memory read -s1 -c20 -fx 0x100008910

此命令读取地址为 0x100008910 的内存。 -s1 选项可读取 1 个字节的大小块,-c20 选项可读取 20 个字节的大小块。 您会看到类似这样的内容:

0x100008910: 0x55 0x48 0x89 0xe5 0x48 0x81 0xec 0xc0
0x100008918: 0x00 0x00 0x00 0x4c 0x89 0x6d 0xf8 0xb8
0x100008920: 0x01 0x00 0x00 0x00

现在,将大小增加一倍,数量减少一半,就像这样:

  • memory read -s2 -c10 -fx 0x100008910

你会看到这样的输出

0x100008910: 0x4855 0xe589 0x8148 0xc0ec 0x0000 0x4c00 0x6d89 0xb8f8
0x100008920: 0x0001 0x0000

请注意,当将内存值分组在一起时,由于使用了低位字节序,它们将被颠倒。
现在,将大小再增加一倍,数量再减少一半:

  • memory read -s4 -c5 -fx 0x100008910

然后你会看到如下输出

0x100008910: 0xe5894855 0xc0ec8148 0x4c000000 0xb8f86d89
0x100008920: 0x00000001

与之前的输出相比,这些值再次被颠倒。
记住这一点非常重要,但在探索你自己的记忆时,这会让你变得很混乱。不仅内存的大小会给您一个潜在的错误答案,而且顺序也会给您一个潜在的错误答案。当你开始对着电脑大喊大叫时,当你试图弄清楚某样东西应该如何工作时,请记住这一点!

更新于 阅读次数

请我喝[茶]~( ̄▽ ̄)~*

Molier 微信支付

微信支付

Molier 支付宝

支付宝