搜索

[15049] 2020-02-23_如何编写一个Androidinlinehook框架

文档创建者：s7ckTeam
浏览次数：5
最后更新：2025-01-18
2020-02-23_如何编写一个Androidinlinehook框架 如 何 编 写 一 个 A n d r o i d   i n l i n e   h o o k 框 架 f i x t h i n g   F r e e B u f   2 0 2 0 - 0 2 - 2 3 A n d r o i d   I n l i n e _ H o o k h t t p s : / / g i t h u b . c o m / G T o a d / A n d r o i d I n l i n e H o o k _ A R M 6 4 有 3 2 和 6 4 的 实 现 ， 但 是 是 分 离 的 ， 要 用 的 话 还 要 自 己 把 两 份 代 码 合 并 在 一 起 。 缺 点 ： 1 、 不 支 持 函 数 替 换 （ 即 h o o k 后 不 执 行 原 函 数 ） ， 现 在 只 能 修 改 参 数 寄 存 器 ， 无 法 修 改 返 回 值 。 2 、 不 支 持 定 义 同 类 型 的 h o o k 函 数 来 接 受 处 理 参 数 ， 只 能 通 过 修 改 寄 存 器 的 方 式 修 改 参 数 。 多 余 4 个 / 或 者 占 两 个 字 节 的 参 数 ， 那 么 参 数 还 要 自 己 从 栈 上 捞 取 。 所 以 i s s u e s 中 说 的 把 m o v   r 0 ， s p 去 掉 用 来 接 收 参 数 也 是 有 问 题 的 ， 就 是 参 数 在 栈 上 的 情 况 ， 传 过 来 的 时 候 s p 不 是 原 来 的 s p 了 。 因 为 以 上 的 两 个 缺 点 ， 想 来 没 太 多 人 用 也 是 情 理 之 中 了 ， 因 为 自 己 解 析 参 数 、 不 能 修 改 返 回 值 、 不 能 不 执 行 原 函 数 ， 局 限 太 大 了 。 看 来 要 想 用 起 来 ， 还 得 自 己 修 改 代 码 。 w h a l e h t t p s : / / g i t h u b . c o m / a s L o d y / w h a l e 移 植 好 像 比 较 简 单 ， 记 得 好 像 移 植 过 ， 但 是 h o o k 了 某 个 系 统 函 数 回 调 原 函 数 就 崩 溃 了 。 所 以 用 之 前 可 能 要 先 帮 他 找 一 遍 b u g 、 修 复 。 l o d y 的 代 码 b u g 一 直 很 多 。 。 。 后 记 ： a r t   h o o k 的 之 前 看 过 ， 应 该 说 是 x p o s e d / f r i d a 的 另 一 份 代 码 ， f r i d a 也 是 用 的 x p o s e d 的 方 式 ， 只 不 过 不 修 改 系 统 文 件 、 通 过 动 态 调 用 系 统 函 数 实 现 。 f r i d a 是 j s 的 代 码 ， 这 个 是 c / c + + 的 实 现 。 内 联 h o o k 大 概 看 了 下 其 实 也 是 一 样 的 套 路 ， 3 2 位 采 用 l d r   p c 的 方 式 跳 到 h o o k 函 数 ， 6 4 位 使 用 x 1 7 寄 存 器 跳 到 h o o k 函 数 。 剩 下 的 修 复 原 函 数 也 是 一 样 的 。 只 是 没 时 间 完 整 看 一 遍 定 位 b u g 了 。 H o o k Z z h t t p s : / / g i t h u b . c o m / j m p e w s / H o o k Z z 对 于 安 卓 程 序 员 来 说 不 太 友 好 ， 编 译 需 要 c m a k e 。 w i n d o w s ： m k d i r   b u i l d f o r a n d r o i d a r m 6 4   & &   c d   b u i l d f o r a n d r o i d a r m 6 4 需 要 指 定 - G   " U n i x   M a k e f i l e s " ， 默 认 的 N M a k e   M a k e f i l e s 编 译 不 过 ， 指 定 m a k e ， 因 为 未 设 置 环 境 变 量 ， - D " C M A K E M A K E P R O G R A M : P A T H = " 编 译 动 态 库 ， - D S H A R E D = O N ； 编 译 静 态 库 ， - D S H A R E D = O F F 。 接 下 来 为 了 方 便 还 是 移 植 到 A n d r o i d 工 程 中 吧 。 呃 。 。 。 基 本 不 可 用 ！ A n d r o i d ： a r m / a r m 6 4 均 c r a c h ， a r m 6 4 可 以 修 复 ， h t t p s : / / w w w . g i t m e m o r y . c o m / f o u n d k e y ， 在 O n e L i b s t d c x x L i t e I t e r a t o r . c c 中 函 数 i n i t W i t h C o l l e c t i o n 添 加 i n C o l l e c t i o n - > i n i t I t e r a t o r ( i n n e r I t e r a t o r ) ; 但 是 a r m 还 是 c r a s h ， 且 通 过 a r m 6 4 测 试 来 看 ， o p e n 、 f o p e n 可 以 h o o k 成 功 。 _ s y s t e m p r o p e r t y _ g e t 函 数 ， 第 二 个 参 数 既 是 入 参 也 做 返 回 参 数 的 情 况 无 法 正 确 h o o k ， 可 以 h o o k 到 ， 但 是 回 调 原 函 数 ， 无 论 是 使 用 第 二 个 参 数 还 是 n e w 参 数 均 无 法 得 到 值 ， 所 以 肯 定 哪 里 存 在 b u g 。 一 个 函 数 只 能 被 h o o k 一 次 ， 再 次 h o o k 调 用 原 函 数 ( 备 份 的 第 一 个 h o o k 函 数 ) 崩 溃 ， 所 以 两 次 h o o k 不 能 再 调 用 原 函 数 。 基 于 以 上 种 种 情 况 ， 可 能 还 是 自 己 实 现 A n d r o i d I n l i n e H o o k 比 较 好 ， 毕 竟 A n d r o i d I n l i n e H o o k 代 码 易 懂 ， h o o k Z z 太 多 无 关 代 码 ， 没 时 间 看 架 构 了 。 后 记 ： 后 来 大 概 看 了 一 下 ， 3 2 位 也 是 l d r   p c 实 现 ， 好 像 也 做 了 保 存 寄 存 器 等 操 作 ， 和 A n d r o i d I n l i n e H o o k 基 本 是 一 样 的 ， 6 4 位 好 像 也 是 使 用 x 1 7 寄 存 器 。 其 他 也 都 是 大 同 小 异 。 所 以 也 是 没 时 间 完 整 看 一 遍 定 位 b u g 了 。 自 实 现 自 实 现 i n l i n e   h o o k 因 为 以 上 的 问 题 ， 目 前 / 或 者 之 前 用 过 的 一 些 h o o k 框 架 或 多 或 少 都 有 些 较 大 的 b u g ( h o o k z z 之 前 的 某 个 版 本 应 该 是 可 以 的 ) ， 而 对 其 进 行 修 复 成 本 较 高 ， 还 不 如 自 己 写 一 个 。 首 先 统 一 一 些 概 念 。 把 覆 盖 被 h o o k 函 数 的 指 令 称 为 跳 板 0 ， 因 为 这 部 分 指 令 越 短 越 好 ， 所 以 其 大 多 数 情 况 下 只 是 一 个 跳 板 ， 跳 到 真 正 的 用 于 h o o k 指 令 处 ， 这 部 分 指 令 称 为 s h e l l c o d e ( s h e l l c o d e 不 是 必 须 的 ， 比 如 跳 板 0 直 接 跳 到 h o o k 函 数 去 执 行 ， 那 么 就 不 需 要 s h e l l c o d e ) 。 这 里 假 设 都 有 一 些 a r m 指 令 的 基 础 了 ， 或 者 对 h o o k 已 经 有 些 理 解 了 。 后 来 我 想 了 下 我 这 篇 更 偏 向 于 怎 么 写 一 个 稳 定 可 用 h o o k 框 架 ， 更 偏 向 设 计 、 编 程 ， 所 以 适 合 已 经 有 些 基 础 的 ， 不 是 从 0 讲 述 h o o k 到 实 现 ， 虽 然 接 下 来 的 部 分 也 会 有 很 细 节 的 部 分 ， 但 是 是 针 对 一 些 特 定 的 点 。 建 议 可 以 先 看 下 其 他 人 ， 比 如 e l e 7 e n x x h 、 G T o a d 写 的 一 些 文 章 。 i n l i n e   h o o k 这 种 东 西 ， 我 是 感 觉 当 你 掌 握 汇 编 、 自 己 有 需 求 的 情 况 下 ， 不 经 过 学 习 也 是 可 以 从 0 写 出 一 个 h o o k 框 架 的 ， 确 实 是 原 理 很 简 单 的 。 最 简 单 的 实 现 最 简 单 的 实 现 最 容 易 想 到 的 一 种 实 现 方 式 ， 使 用 跳 板 0 覆 盖 一 个 函 数 的 指 令 ， 当 执 行 到 这 个 函 数 的 时 候 其 实 就 是 执 行 跳 板 0 ， 跳 板 0 在 不 修 改 寄 存 器 的 情 况 跳 到 执 行 h o o k 函 数 。 如 果 在 h o o k 函 数 内 不 需 要 执 行 原 函 数 是 最 简 单 的 ， 到 这 h o o k 就 是 一 个 完 整 的 h o o k 。 如 果 需 要 执 行 原 函 数 ， 那 么 在 跳 板 0 覆 盖 指 令 之 前 先 备 份 指 令 ， 执 行 原 函 数 之 前 把 备 份 的 指 令 再 覆 盖 回 去 ， 执 行 之 后 再 覆 盖 回 跳 板 0 。 确 实 是 最 简 单 的 方 法 、 也 确 实 可 以 ， 但 是 也 有 一 个 很 大 的 问 题 ， 就 是 多 线 程 的 问 题 ， 在 把 备 份 的 指 令 覆 盖 回 去 之 后 ， 其 他 线 程 执 行 到 这 里 不 就 h o o k 不 到 了 ， 甚 至 c r a s h 。 因 为 无 法 加 锁 ( 真 正 有 效 的 锁 ) ， 而 暂 停 所 有 线 程 的 太 重 了 ， 所 以 基 本 上 只 有 自 己 确 定 某 个 函 数 不 存 在 多 线 程 问 题 或 者 无 需 调 用 原 函 数 才 可 用 。 写 个 d e m o ， 熟 悉 下 h o o k 还 行 ， 真 的 实 际 使 用 是 不 行 的 。 也 是 因 为 这 个 问 题 ， 基 本 上 目 前 的 i n l i n e   h o o k 都 会 避 免 再 次 覆 盖 指 令 。 不 能 覆 盖 回 去 ， 那 么 就 直 接 执 行 备 份 的 指 令 ， 执 行 后 再 跳 到 跳 板 0 之 后 再 继 续 执 行 。 s e t   A N D R O I D _ N D K = D : a n d r o i d N D K a n d r o i d - n d k - r 1 6 b C : U s e r s E D Z A p p D a t a L o c a l A n d r o i d S d k c m a k e 3 . 1 0 . 2 . 4 9 8 8 4 0 4 b i n c m a k e   . .   - D C M A K E _ T O O L C H A I N _ F I L E = % A N D R O I D _ N D K % / b u i l d / c m a k e / a n d r o i d . t o o l c h a i n . c m a k e   - D C M A K E _ B U I L D _ T Y P E = R e l e a s e   - D A N D R O I D _ A B I = # 0 0     p c   0 0 0 2 5 e f 0     [ a n o n : l i b c _ m a l l o c ] 1 2 - 1 2   1 5 : 1 2 : 5 3 . 6 8 5   1 8 1 - 1 8 1 / ?   I / D E B U G :           # 0 1     p c   0 0 0 0 8 1 f 1     / d a t a / a p p - l i b / c o m . z h u o t o n g . m y h k z z - 1 / l i b h o o k z z . s o   ( L i t e C o l l e c t i o n I t e r a t o r : : g e t N e x t O b j e c t ( ) + 2 8 ) 1 2 - 1 2   1 5 : 1 2 : 5 3 . 6 8 5   1 8 1 - 1 8 1 / ?   I / D E B U G :           # 0 2     p c   0 0 0 0 7 5 3 1     / d a t a / a p p - l i b / c o m . z h u o t o n g . m y h k z z - 1 / l i b h o o k z z . s o   ( g e n _ t h u m b _ r e l o c a t e _ c o d e ( v o i d * ,   i n t * ,   u n s i g n e d   i n t ,   u n s i g n e d   i n t ) + 3 1 2 ) 1 2 - 1 2   1 5 : 1 2 : 5 3 . 6 8 5   1 8 1 - 1 8 1 / ?   I / D E B U G :           # 0 3     p c   0 0 0 0 7 a c 1     / d a t a / a p p - l i b / c o m . z h u o t o n g . m y h k z z - 1 / l i b h o o k z z . s o   ( I n t e r c e p t R o u t i n g : : P r e p a r e ( ) + 5 6 ) 1 2 - 1 2   1 5 : 1 2 : 5 3 . 6 8 5   1 8 1 - 1 8 1 / ?   I / D E B U G :           # 0 4     p c   0 0 0 0 7 c c 1     / d a t a / a p p - l i b / c o m . z h u o t o n g . m y h k z z - 1 / l i b h o o k z z . s o   ( F u n c t i o n I n l i n e R e p l a c e R o u t i n g : : D i s p a t c h ( ) + 1 2 ) 1 2 - 1 2   1 5 : 1 2 : 5 3 . 6 8 5   1 8 1 - 1 8 1 / ?   I / D E B U G :           # 0 5     p c   0 0 0 0 7 d 4 d     / d a t a / a p p - l i b / c o m . z h u o t o n g . m y h k z z - 1 / l i b h o o k z z . s o   ( Z z R e p l a c e + 1 2 0 )
也 确 实 是 可 行 的 ， 大 部 分 指 令 是 可 以 这 么 做 的 ， 但 是 也 有 例 外 。 比 如 备 份 的 指 令 中 有 b / b l 指 令 跳 到 一 个 偏 移 地 址 ， 跳 转 到 的 地 址 等 于 当 前 地 址 + 偏 移 。 而 备 份 后 的 指 令 取 得 当 前 地 址 肯 定 是 不 等 于 原 来 的 当 前 地 址 的 ， 所 以 就 跳 到 错 误 的 地 址 去 执 行 了 。 好 在 我 们 可 以 进 行 修 复 ， 计 算 出 原 来 要 跳 到 的 绝 对 地 址 ， 把 这 条 b 指 令 替 换 成 l d r   p c 指 令 。 其 他 指 令 的 一 些 修 复 也 是 类 似 的 道 理 。 四 种 四 种 h o o k 形 式 应 用 不 同 的 场 景 形 式 应 用 不 同 的 场 景 d u m p 读 写 寄 存 器 、 堆 栈 读 写 寄 存 器 、 堆 栈 - - 一 种 一 种 h o o k 形 式 形 式 A n d r o i d I n l i n e H o o k 就 是 这 样 的 实 现 ， 只 能 接 收 读 写 寄 存 器 和 堆 栈 ， 原 函 数 还 运 行 。 那 么 其 实 这 种 方 式 主 要 作 用 就 是 读 写 参 数 寄 存 器 、 栈 ， 不 能 读 写 函 数 返 回 值 ， 如 果 是 不 受 参 数 控 制 流 程 的 函 数 就 无 能 为 力 了 （ 当 然 是 可 以 逆 向 分 析 ， 在 已 经 得 到 返 回 值 的 指 令 处 h o o k ， 但 是 应 用 场 景 太 小 了 ） 。 那 么 实 现 的 核 心 就 是 ， 跳 板 0 - > d u m p s h e l l c o d e 。 d u m p s h e l l c o d e 把 寄 存 器 以 数 组 的 形 式 存 放 （ 栈 就 是 天 然 的 数 组 ） ， 把 这 个 数 组 传 递 给 d u m p 函 数 ， d u m p 函 数 接 收 处 理 寄 存 器 ( 未 生 效 ) 。 d u m p 函 数 返 回 s h e l l c o d e ， 恢 复 数 组 数 据 到 寄 存 器 ， 完 成 恢 复 或 者 修 改 。 执 行 b a c k u p s h e l l c o d e ( 备 份 的 原 函 数 的 开 头 部 分 ， 修 复 p c ， 跳 回 原 函 数 之 后 的 部 分 ) 完 成 原 函 数 的 执 行 流 程 。 替 换 替 换 / 拦 截 函 数 ， 接 收 处 理 参 数 ， 调 用 原 函 数 、 读 写 返 回 值 拦 截 函 数 ， 接 收 处 理 参 数 ， 调 用 原 函 数 、 读 写 返 回 值 - - 一 种 一 种 h o o k 形 式 形 式 最 常 用 、 最 符 合 使 用 习 惯 的 的 方 式 。 实 现 的 核 心 ， 跳 板 0 - > f u n s h e l l c o d e 。 f u n s h e l l c o d e 可 以 在 上 面 的 d u m p s h e l l c o d e 基 础 上 实 现 也 可 以 全 新 实 现 。 在 d u m p s h e l l c o d e 基 础 上 可 以 取 巧 一 些 ， 前 面 的 保 存 d u m p 寄 存 器 保 留 ， 把 后 面 的 执 行 b a c k u p s h e l l c o d e 换 成 执 行 h o o k 函 数 。 全 新 实 现 就 是 不 保 存 寄 存 器 ， 那 么 就 可 以 把 h o o k 函 数 放 在 跳 板 s h e l l c o d e 中 ， 直 接 跳 到 h o o k 函 数 ； 也 可 以 跳 板 0 - > f u n s h e l l c o d e ， f u n s h e l l c o d e 中 再 跳 转 到 h o o k 函 数 。 之 后 就 进 入 h o o k 函 数 ， 如 果 不 调 用 原 函 数 ， 直 接 返 回 一 个 返 回 值 或 者 v o i d 函 数 什 么 都 不 做 即 可 ( 如 果 是 参 数 也 做 返 回 值 的 情 况 就 修 改 参 数 ) 。 如 果 调 用 原 函 数 ， 就 通 过 一 个 结 构 体 / m a p 等 查 询 被 h o o k 函 数 地 址 对 应 的 b a c k u p s h e l l c o d e ， 把 b a c k u p s h e l l c o d e 转 成 函 数 指 针 ， 传 参 调 用 ， 即 可 完 成 原 函 数 的 调 用 、 或 者 返 回 值 。 d u m p 读 写 寄 存 器 、 堆 栈 ， 调 用 原 函 数 、 读 写 返 回 值 读 写 寄 存 器 、 堆 栈 ， 调 用 原 函 数 、 读 写 返 回 值 / 寄 存 器 寄 存 器 - - 一 种 一 种 h o o k 形 式 形 式 在 d u m p 的 基 础 上 ， 执 行 b a c k u p s h e l l c o d e ( 备 份 的 原 函 数 的 开 头 部 分 ， 修 复 p c ， 跳 回 原 函 数 之 后 的 部 分 ) 完 成 原 函 数 的 执 行 流 程 之 后 返 回 到 d u m p s h e l l c o d e ， 调 用 另 一 个 d u m p 函 数 ， 读 写 返 回 值 ( r 0 / x 0 , r 1 / x 1 寄 存 器 ) 。 不 同 于 d u m p 的 地 方 在 于 如 果 要 返 回 到 d u m p s h e l l c o d e ， 那 么 在 调 用 b a c k u p s h e l l c o d e 之 前 应 该 备 份 原 来 的 l r 寄 存 器 。 考 虑 到 多 线 程 的 问 题 ， 肯 定 是 不 能 用 一 个 固 定 的 变 量 / 地 址 去 存 储 l r 寄 存 器 的 ， 可 能 被 覆 盖 ， 同 一 个 线 程 哪 怕 是 递 归 调 用 函 数 也 是 有 顺 序 的 ， 所 以 每 个 线 程 的 被 h o o k 函 数 使 用 一 个 顺 序 的 容 器 保 存 l r ， 后 进 先 出 。 d u m p 读 写 寄 存 器 、 堆 栈 ， 读 写 返 回 值 读 写 寄 存 器 、 堆 栈 ， 读 写 返 回 值 / 寄 存 器 寄 存 器 - - 一 种 一 种 h o o k 形 式 形 式 在 d u m p 的 基 础 上 ， 不 执 行 b a c k u p s h e l l c o d e ( 备 份 的 原 函 数 的 开 头 部 分 ， 修 复 p c ， 跳 回 原 函 数 之 后 的 部 分 ) ， 直 接 修 改 r 0 / x 0 、 r 1 / x 1 寄 存 器 ， 返 回 。 和 d u m p 函 数 很 多 地 方 是 一 致 的 ， 应 用 于 只 需 要 返 回 值 ， 并 不 需 要 原 函 数 执 行 的 情 况 。 以 上 四 种 场 景 应 该 是 足 够 满 足 h o o k 的 需 要 了 。 a r m 6 4   实 现 难 点 实 现 难 点 因 为 无 法 直 接 操 作 p c ， 那 么 实 现 跳 转 ( 通 用 情 况 ) 需 要 占 用 一 个 寄 存 器 。 要 么 使 用 一 个 不 会 被 使 用 的 寄 存 器 ( 哪 有 绝 对 不 会 被 使 用 的 寄 存 器 ) ， 要 么 先 保 存 这 个 寄 存 器 ， 通 过 栈 保 存 ( 之 前 就 是 忽 略 了 这 个 问 题 在 固 定 地 址 保 存 寄 存 器 ， 那 么 多 线 程 情 况 下 就 可 能 被 覆 盖 ) ， 跳 过 去 之 后 先 恢 复 这 个 寄 存 器 。 例 如 ： 对 应 s h e l l c o d e 我 们 很 容 易 实 现 ， 但 是 如 果 是 c / c + + 函 数 ( 我 们 的 h o o k 函 数 ) 就 麻 烦 了 ， 直 接 在 函 数 开 头 插 代 码 肯 定 是 不 行 的 。 在 源 码 中 函 数 第 一 行 内 嵌 汇 编 恢 复 寄 存 器 ？ 很 可 惜 ， 这 种 只 在 无 参 、 无 返 回 值 ( 空 实 现 ) 、 只 有 内 嵌 汇 编 的 情 况 会 成 功 ， 其 他 情 况 下 源 码 中 的 第 一 行 并 不 是 汇 编 中 的 第 一 行 。 。 。 所 以 似 乎 陷 入 了 无 解 的 状 态 ， 在 l l v m 中 函 数 开 头 插 指 令 ？ 似 乎 太 重 了 。 所 以 回 到 原 点 了 ， 就 要 考 虑 真 的 没 有 不 使 用 寄 存 器 跳 转 的 可 能 吗 ？ 其 实 还 是 有 的 ， b 或 者 b l 到 偏 移 A R M 6 4 : B : 0 x 1 7 向 前 跳 转 ， 0 x 1 4 向 后 跳 转 B L : 0 x 9 7 向 前 跳 转   0 x 9 4 向 后 跳 转 偏 移 地 址 计 算 过 程 ： （ 目 标 地 址   -   指 令 地 址 ） /   4   =   偏 移 / /   减 8 ， 指 令 流 水 造 成 。 / /   除 4 ， 因 为 指 令 定 长 ， 存 储 指 令 个 数 差 ， 而 不 是 地 址 差 。 完 整 指 令 ： . t e x t : 0 0 0 0 0 0 0 0 0 0 0 8 C C 8 4   8 D   B 3   F F   9 7   B L   j e a r e n a m a l l o c _ h a r d . t e x t : 0 0 0 0 0 0 0 0 0 0 0 7 9 A B 8   j e a r e n a m a l l o c _ h a r d 计 算 偏 移 ： ( 7 9 A B 8 - 8 C C 8 4 )   /   4   =   F F F F F F F F F F F F B 3 8 D F F B 3 8 D   |   0 x 9 7 0 0 0 0 0 0   =   9 7 F F B 3 8 D 所 以 理 论 上 ， 如 果 被 h o o k 的 函 数 和 h o o k 函 数 / 跳 板 / s h e l l c o d e 的 距 离 在 正 负 6 7 1 0 8 8 6 0 / 6 4 m 的 范 围 内 ， 6 4 m = 6 7 1 0 8 8 6 4 ， 还 有 0 ， 比 如 B L   0 = 0 0 0 0 0 0 9 4 。 那 么 这 样 就 可 以 省 一 个 寄 存 器 了 ， 针 对 a r m 6 4 不 能 直 接 操 作 p c 的 问 题 ， 这 应 该 是 一 个 解 决 方 案 。 那 么 单 指 令 h o o k 除 了 异 常 的 方 式 是 不 是 就 是 指 的 这 种 方 式 呢 ？ 只 需 要 覆 盖 一 条 指 令 ， 关 键 是 怎 么 确 保 被 h o o k 函 数 和 h o o k 函 数 地 址 在 正 负 6 4 m 内 呢 。 怎 么 能 申 请 到 这 块 地 址 的 内 存 呢 。 也 许 可 以 查 看 p r o c / p i d / m a p s ， 在 要 h o o k 的 s o 附 近 寻 找 未 使 用 的 空 间 ， 然 后 使 用 m m a p 申 请 ， 不 确 定 是 否 可 行 。 暂 时 可 用 的 一 些 方 式 如 下 ( 最 终 未 采 用 ) ： 自 定 义 自 定 义 s e c t i o n ， 增 加 蹦 床 ， 可 读 写 执 行 ， 增 加 蹦 床 ， 可 读 写 执 行 实 际 上 到 内 存 中 还 是 被 和 代 码 段 放 在 一 起 都 是 可 读 可 执 行 ， 没 有 写 的 权 限 。 s t p           X 1 ,   X 0 ,   [ S P ,   # - 0 x 1 0 ] ; / / 保 存 寄 存 器 . . . l d r           x 0 ,   [ s p ,   # - 0 x 8 ] ; / / 恢 复 x 0 寄 存 器 . s e c t i o n   " . m y _ s e c " ,   " a w x " . g l o b a l   _ m y o p e n _ s t a r t / / . t e x t
s h e l l c o d e 如 下 ， a w x 指 定 读 写 执 行 ， 在 e l f 中 ( i d a 查 看 ) 确 实 是 读 写 执 行 。 如 果 这 个 s e c t i o n 中 仅 包 含 变 量 ， 那 么 在 内 存 中 放 在 可 读 写 的 段 ； 如 果 存 在 代 码 或 者 代 码 和 变 量 均 存 在 ， 都 是 和 代 码 段 一 样 仅 可 读 执 行 。 那 么 在 单 独 的 s e c t i o n 中 存 放 蹦 床 代 码 意 义 也 不 大 了 ， 还 是 需 要 调 用 m p r o t e c t 修 改 内 存 权 限 。 不 过 考 虑 到 如 果 放 在 仅 可 读 写 的 段 中 ， 那 么 万 一 映 射 后 的 r w - p 和 r - x p 超 过 了 6 4 m ， 不 就 白 瞎 了 ， 所 以 还 是 以 代 码 或 者 至 少 这 个 s e c t i o n 中 存 在 一 个 函 数 ， 保 证 和 被 h o o k 的 函 数 都 在 r - x p 。 而 如 果 直 接 和 . t e x t 一 起 ， 主 要 是 怕 对 这 块 内 存 修 改 权 限 引 发 什 么 异 常 ， 不 确 定 如 果 代 码 正 在 执 行 ， 修 改 权 限 是 否 会 出 问 题 ， 所 以 最 好 能 仅 修 改 蹦 床 的 区 间 。 而 且 不 确 定 是 否 有 只 能 修 改 为 读 写 和 读 执 行 的 系 统 ， 所 以 可 能 要 先 修 改 成 读 写 ， 写 了 之 后 再 修 改 成 读 执 行 ？ 这 样 会 不 会 也 有 几 率 触 发 问 题 ， 但 是 如 果 每 个 蹦 床 都 分 配 一 个 页 的 内 存 也 不 现 实 。 。 。 内 嵌 汇 编 ， 在 自 定 义 内 嵌 汇 编 ， 在 自 定 义 s e c t i o n 中 增 加 蹦 床 中 增 加 蹦 床 这 样 定 义 一 个 无 参 无 返 回 的 函 数 ， 倒 是 可 以 使 这 个 函 数 就 是 内 嵌 汇 编 ， 但 是 不 确 定 如 果 o l l v m 混 淆 等 是 否 会 被 拆 分 、 加 入 垃 圾 代 码 等 。 而 且 问 题 在 于 怎 么 自 动 生 成 一 个 蹦 床 函 数 。 宏 定 义 ？ 那 这 个 宏 要 在 函 数 之 外 ， 不 太 容 易 自 动 化 实 现 ， 包 括 蹦 床 的 函 数 名 称 、 b 后 面 的 函 数 名 称 。 和 上 面 的 汇 编 中 添 加 一 个 蹦 床 一 样 的 问 题 ， 除 非 自 己 实 现 预 处 理 之 类 的 自 动 插 入 汇 编 代 码 、 宏 等 ， 似 乎 不 太 现 实 。 。 。 似 乎 很 难 实 现 自 动 化 ， 手 动 写 代 码 太 麻 烦 且 和 a r m 的 部 分 接 口 、 行 为 不 一 致 。 但 是 如 果 自 己 简 单 测 试 、 不 在 乎 这 些 也 是 可 以 的 。 在 自 定 义 在 自 定 义 s e c t i o n 中 预 留 蹦 床 空 间 中 预 留 蹦 床 空 间 2 5 6 个 蹦 床 。 动 态 生 成 蹦 床 代 码 ， 第 一 条 指 令 固 定 ， 第 二 条 指 令 计 算 生 成 。 需 要 h k A r r y 修 改 为 读 写 执 行 。 / / . t e x t _ m y o p e n _ s t a r t :         l d r           x 0 ,   [ s p ,   # - 0 x 8 ] ;         b               m y _ o p e n ; . e n d / / 用 于 手 动 生 成 蹦 床 代 码 ， 因 为 h o o k 代 码 和 这 个 蹦 床 一 起 编 译 的 ， 所 以 基 本 上 不 会 超 出 加 减 6 4 m ， 那 么 就 可 以 使 用 b 跳 转 / / 到 偏 移 ， 就 不 用 占 用 一 个 寄 存 器 了 。 需 要 每 增 加 一 个 h o o k 函 数 ， 就 加 一 个 蹦 床 ， 相 应 的 生 成 s h e l l c o d e 中 跳 转 到 h o o k / / 函 数 的 地 方 都 要 改 成 这 个 蹦 床 的 地 址 。 难 就 难 在 这 个 不 好 通 过 内 嵌 汇 编 实 现 ， 因 为 b 跟 的 是 个 偏 移 值 ， 在 汇 编 中 可 以 使 用 / / 函 数 名 称 ， 编 译 器 替 换 ， 但 是 内 嵌 汇 编 中 不 行 。 而 自 己 计 算 / / 用 于 演 示 ， 因 为 不 是 最 终 方 案 ， 不 写 完 整 代 码 了 。 / / 修 改 t r a m p o l i n e 指 向 蹦 床 即 可 . d a t a r e p l a c e _ s t a r t :         l d r           x 0 ,   t r a m p o l i n e ;                           / / 如 果 每 一 个 函 数 都 在 源 码 中 新 建 一 个 s h e l l c o d e 的 话 ， 而 不 是 动 态 复 制 生 成 ， 那 么 这 个 s h e l l c o d e 和 蹦 床 可 以 合 为 一 个 。         b r             x 0 ;                                                   / / 不 能 改 变 l r 寄 存 器 t r a m p o l i n e :                                                       / / 蹦 床 的 地 址 . d o u b l e   0 x f f f f f f f f f f f f f f f f r e p l a c e _ e n d : 7 7 c 5 5 4 5 0 0 0 - 7 7 c 5 5 7 c 0 0 0   r - x p   0 0 0 0 0 0 0 0   1 0 3 : 3 7   5 3 3 3 5 3                                                 / d a t a / a p p / c o m . z h u o t o n g . m y i n h k - T R v q t 0 R e H R j Q e e A n p X D n F Q = = / l i b / a r m 6 4 / l i b I n l i n e H o o k . s o 7 7 c 5 5 8 b 0 0 0 - 7 7 c 5 5 8 e 0 0 0   r - - p   0 0 0 3 6 0 0 0   1 0 3 : 3 7   5 3 3 3 5 3                                                 / d a t a / a p p / c o m . z h u o t o n g . m y i n h k - T R v q t 0 R e H R j Q e e A n p X D n F Q = = / l i b / a r m 6 4 / l i b I n l i n e H o o k . s o 7 7 c 5 5 8 e 0 0 0 - 7 7 c 5 5 8 f 0 0 0   r w - p   0 0 0 3 9 0 0 0   1 0 3 : 3 7   5 3 3 3 5 3                                                 / d a t a / a p p / c o m . z h u o t o n g . m y i n h k - T R v q t 0 R e H R j Q e e A n p X D n F Q = = / l i b / a r m 6 4 / l i b I n l i n e H o o k . s o u n s i g n e d   i n t   h k A r r y [ 2 5 6 * 2 ]   _ _ a t t r i b u t e _ _   ( ( s e c t i o n ( " . m y _ s e c " ) ) ) ; / / 下 面 为 伪 代 码 ， 通 过 这 样 也 可 以 实 现 不 修 改 / 保 存 寄 存 器 、 不 修 改 h o o k 函 数 ， 动 态 生 成 蹦 床 完 成 h o o k 。 / / 优 点 是 不 用 保 存 寄 存 器 ， 缺 点 是 因 为 正 负 6 4 m 的 限 制 ， h o o k 函 数 应 该 和 h o o k 库 是 一 起 编 译 成 动 态 库 / 可 执 行 文 件 的 。 不 能 单 独 使 用 h o o k 库 。 / / 2 5 6 个 蹦 床 ， 实 际 使 用 可 能 要 考 虑 这 个 h k A r r y 内 存 对 齐 的 问 题 ( 如 果 编 译 器 未 做 内 存 对 齐 ) 。 / / u n s i g n e d   i n t   h k A r r y [ 2 5 6   *   2 ]   _ _ a t t r i b u t e _ _   ( ( s e c t i o n ( " . m y _ s e c " ) ) ) ; / / v o i d   t e s t _ t r a m p o l i n e ( ) {         / / 仅 用 于 演 示 ， 应 该 先 设 置 内 存 为 可 读 写 / 执 行 ， / /         h k A r r y [ 0 ]   =   0 x f 8 5 f 8 3 e 0 ; / / 或 者 m e m c p y ,   l d r           x 0 ,   [ s p ,   # - 0 x 8 ] ;         / / 例 如 这 样 计 算 偏 移 ， 组 合 b 指 令 。 / /         u n s i g n e d   l o n g   o f f s e t   =   ( u n s i g n e d   l o n g )   m y _ o p e n   -   ( ( u n s i g n e d   l o n g )   h k A r r y   +   1   *   4 ) ; / /         h k A r r y [ 1 ]   =   0 x 1 4 0 0 0 0 0 0 ; / / 计 算 偏 移 ， 生 成 指 令 ， b               0 ; / / }
未 实 现 未 实 现 s o 的 r - x p 中 应 该 是 有 未 使 用 的 多 余 的 内 存 的 ， 为 了 对 齐 、 页 面 等 ， 所 以 怎 么 确 定 多 余 的 空 间 大 小 和 位 置 ， 然 后 蹦 床 代 码 存 放 其 中 。 为 什 么 尽 量 不 使 用 为 什 么 尽 量 不 使 用 x 1 6 、 、 x 1 7 等 不 用 保 存 的 寄 存 器 ？ 等 不 用 保 存 的 寄 存 器 ？ 因 为 种 种 限 制 ， 所 以 最 后 采 用 的 还 是 保 存 一 个 寄 存 器 ， 而 使 用 哪 个 寄 存 器 呢 ， 我 是 选 的 l r 寄 存 器 。 为 什 么 不 用 x 1 6 、 x 1 7 等 不 用 保 存 的 寄 存 器 ？ 这 里 就 涉 及 到 一 个 标 准 和 规 范 的 问 题 。 理 论 上 编 译 器 编 译 的 c / c + + 函 数 是 遵 守 这 个 规 范 的 ， 要 么 不 使 用 x 1 6 、 x 1 7 寄 存 器 ， 要 么 只 是 临 时 中 转 ， 不 会 在 调 用 其 他 函 数 之 后 再 从 x 1 6 、 x 1 7 寄 存 器 取 值 ( 因 为 其 他 函 数 可 能 改 变 x 1 6 、 x 1 7 ) ， 但 是 内 嵌 汇 编 ( 虽 然 指 定 不 使 用 x 1 6 、 x 1 7 寄 存 器 ， 但 还 是 被 编 译 器 使 用 了 ) 或 者 人 工 写 的 汇 编 ， 虽 然 不 常 见 ， 但 确 实 存 在 。 而 最 常 见 的 是 p l t 函 数 内 都 是 使 用 x 1 6 、 x 1 7 做 中 转 。 所 以 使 用 一 个 不 一 定 会 被 保 存 的 寄 存 器 不 如 使 用 一 个 会 被 保 存 的 寄 存 器 。 而 因 为 l r 寄 存 器 的 特 殊 性 ， 一 般 使 用 的 话 都 会 先 压 栈 保 存 ， 结 束 恢 复 ( 3 2 位 不 一 定 恢 复 ， 6 4 位 是 会 恢 复 l r 寄 存 器 的 ， 因 为 不 能 直 接 操 作 p c ， 多 数 都 是 恢 复 l r ， 再 r e t ) 所 以 其 实 主 要 还 是 兼 容 性 考 虑 ， 尽 量 采 用 一 些 绕 弯 的 方 式 不 改 变 任 何 寄 存 器 ， 实 在 没 办 法 的 情 况 下 或 者 标 准 c / c + + 函 数 、 非 函 数 任 意 位 置 h o o k 的 情 况 下 才 使 用 x 1 6 、 x 1 7 寄 存 器 。 解 析 寄 存 器 、 栈 取 出 参 数 ， 调 用 解 析 寄 存 器 、 栈 取 出 参 数 ， 调 用 h o o k 函 数 函 数 难 点 在 于 ： 1 、 不 知 道 参 数 个 数 、 参 数 类 型 。 2 、 需 要 确 定 各 种 类 型 参 数 占 几 个 寄 存 器 、 可 变 参 数 等 其 实 在 源 码 中 定 义 h o o k 函 数 的 时 候 是 有 函 数 原 型 的 ， 但 是 运 行 时 拿 不 到 。 忽 然 想 到 " c + + " 函 数 名 的 规 则 ， 里 面 包 含 参 数 、 返 回 值 类 型 ， 似 乎 可 行 ， 但 是 很 多 情 况 并 不 希 望 导 出 函 数 ， 而 且 也 并 不 一 定 都 是 c + + 实 现 的 。 那 么 如 果 定 义 一 个 接 口 ， 传 入 函 数 原 型 也 不 是 不 行 ， 基 本 类 型 就 用 相 应 的 字 符 或 者 枚 举 标 识 ， 其 他 所 有 的 都 是 v o i d * 指 针 。 可 还 是 怕 碰 见 可 变 参 数 函 数 ， 不 确 定 参 数 个 数 ， 参 数 类 型 ， 只 有 接 收 / 实 现 函 数 才 知 道 。 所 以 似 乎 不 太 可 行 。 而 l i b f f i 似 乎 不 太 适 合 这 个 情 况 ， 也 是 需 要 明 确 指 令 参 数 和 返 回 类 型 ， 还 要 传 输 参 数 。 目 前 的 实 现 没 有 经 过 自 己 解 析 参 数 ， 只 是 中 转 ， 通 过 定 义 一 致 的 函 数 原 型 ， 让 编 译 器 帮 助 我 们 解 析 参 数 。 代 码 实 现 代 码 实 现 a r m 6 4 统 一 的 跳 板 统 一 的 跳 板 0 因 为 a r m 6 4 限 制 条 件 最 多 ， 那 么 应 该 先 实 现 a r m 6 4 ， 这 样 才 能 更 好 的 保 证 a p i 的 通 用 / 一 致 性 ， 因 为 a r m 6 4 不 能 操 作 p c 不 得 不 这 么 做 ， a r m 3 2 同 样 也 可 以 这 么 做 ， 但 是 如 果 先 实 现 a r m 3 2 ， 可 能 就 先 入 为 主 的 设 计 一 些 a r m 3 2 可 用 的 a p i 。 这 算 是 一 种 架 构 思 维 吧 ， 或 者 多 思 考 一 下 就 明 白 了 。 其 实 很 简 单 ， 注 释 基 本 都 说 明 了 ， 使 用 了 2 4 字 节 ， 所 以 如 果 能 确 定 要 h o o k 的 函 数 是 标 准 的 c / c + + 函 数 ， 不 会 使 用 x 1 6 、 x 1 7 去 保 存 值 的 话 也 可 以 这 样 ， 使 用 1 6 字 节 ， 降 低 被 h o o k 函 数 太 短 失 败 的 概 率 。 代 码 实 现 代 码 实 现 a r m 6 4 d u m p 函 数 函 数 S T P   X 1 ,   X 0 ,   [ S P ,   # - 0 x 1 0 ] ; / / 因 为 要 使 用 一 个 寄 存 器 ， 所 以 先 保 存 ， 当 然 不 一 定 是 x 0 L D R   X 0 ,   8 ;         / / 把 s h e l l c o d e / h o o k 函 数 地 址 存 到 x 0 B R   X 0 ;         / / 执 行 s h e l l c o d e / h o o k 函 数 A D D R ( 6 4 ) L D R   X 0 ,   [ S P ,   - 0 x 8 ] ; / / 因 为 不 能 操 作 p c ， 所 以 跳 回 来 的 时 候 免 不 了 也 要 使 用 一 个 寄 存 器 L D R         X 1 7 ,   8 ; B R         x 1 7 ; A D D R ( 6 4 ) . i n c l u d e   " . . / . . / a s m / b a s e . s " / / . e x t e r n   _ d u m p _ s t a r t / / . e x t e r n   _ d u m p _ e n d / / . e x t e r n   _ h k _ i n f o / / . s e t   _ d u m p _ s t a r t ,   r _ d u m p _ s t a r t / / . s e t   _ d u m p _ e n d ,   r _ _ d u m p _ e n d / / . s e t   _ h k _ i n f o ,   r _ _ h k _ i n f o / / . g l o b a l   _ d u m p _ s t a r t / / . g l o b a l   _ d u m p _ e n d / / . g l o b a l   _ h k _ i n f o / / . h i d d e n   _ d u m p _ s t a r t / / . h i d d e n   _ d u m p _ e n d / / . h i d d e n   _ h k _ i n f o
基 本 上 注 释 已 经 说 明 了 。 h k i n f 为 如 下 结 构 体 的 指 针 ， o n P r e C a l l B a c k 函 数 原 型 如 下 。 / / . h i d d e n   _ h k _ i n f o / / 可 用 于 标 准 的 c / c + + 函 数 、 非 标 准 函 数 、 函 数 的 一 部 分 ( 用 于 读 写 寄 存 器 ) ， 前 提 都 是 字 节 长 度 足 够 / / 非 标 准 函 数 即 非 c / c + + 编 译 的 函 数 ， 那 么 手 写 汇 编 可 能 存 在 并 不 遵 守 约 定 的 情 况 ， 比 如 我 们 使 用 了 s p 寄 存 器 ， 并 在 未 使 用 的 栈 上 保 存 寄 存 器 / / 但 是 可 能 不 是 满 递 减 而 是 反 过 来 满 递 增 ， 或 者 不 遵 守 栈 平 衡 ， 往 栈 上 写 数 据 ， 但 是 并 不 改 变 s p 寄 存 器 。 当 然 应 该 是 很 少 见 的 。 . d a t a _ d u m p _ s t a r t :                                         / / 用 于 读 写 寄 存 器 / 栈 ， 需 要 自 己 解 析 参 数 ， 不 能 读 写 返 回 值 ， 不 能 阻 止 原 函 数 ( 被 h o o k 函 数 ) 的 执 行                                                                 / / 从 行 为 上 来 我 觉 得 更 偏 向 d u m p ， 所 以 起 名 为 d u m p 。         s u b           s p ,   s p ,   # 0 x 2 0 ;             / / 跳 板 在 栈 上 存 储 了 x 0 、 x 1 ， 但 是 未 改 变 s p 的 值         m r s           x 0 ,   N Z C V         s t r           x 0 ,   [ s p ,   # 0 x 1 0 ] ;         / / 覆 盖 跳 板 存 储 的 x 1 ， 存 储 状 态 寄 存 器         s t r           x 3 0 ,   [ s p ] ;                     / / 存 储 x 3 0         a d d           x 3 0 ,   s p ,   # 0 x 2 0         s t r           x 3 0 ,   [ s p ,   # 0 x 8 ] ;         / / 存 储 真 实 的 s p         l d r           x 0 ,   [ s p ,   # 0 x 1 8 ] ;         / / 取 出 跳 板 存 储 的 x 0 s a v e _ x 0 _ x 2 9 : / / 保 存 寄 存 器 x 0 - x 2 9         s u b           s p ,   s p ,   # 0 x f 0 ;             / / 分 配 栈 空 间         s t p           X 0 ,   X 1 ,   [ S P ] ;               / / 存 储 x 0 - x 2 9         s t p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         s t p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         s t p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         s t p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]         s t p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         s t p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         s t p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         s t p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         s t p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         s t p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         s t p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         s t p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         s t p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         s t p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ] c a l l _ o n P r e C a l l B a c k : / / 调 用 o n P r e C a l l B a c k 函 数 ， 第 一 个 参 数 是 s p ， 第 二 个 参 数 是 S T R _ H K _ I N F O 结 构 体 指 针         m o v           x 0 ,   s p ;                                   / / x 0 作 为 第 一 个 参 数 ， 那 么 操 作 x 0 = s p ， 即 操 作 栈 读 写 保 存 的 寄 存 器         l d r           x 1 ,   _ h k _ i n f o ;         l d r           x 3 ,   [ x 1 ] ;                               / / o n P r e C a l l B a c k         b l             g e t _ l r _ p c ;                             / / l r 为 下 条 指 令         a d d           l r ,   l r ,   # 8 ;                             / / l r 为 b l r   x 3 的 地 址         s t r           l r ,   [ s p ,   # 0 x 1 0 8 ] ;                 / / l r 当 作 p c ， 覆 盖 栈 上 的 x 0         b l r           x 3 r e s t o r e _ r e g s : / / 恢 复 寄 存 器         l d r           x 0 ,   [ s p ,   # 0 x 1 0 0 ] ;               / / 取 出 状 态 寄 存 器         m s r           N Z C V ,   x 0         l d p           X 0 ,   X 1 ,   [ S P ] ;                       / / 恢 复 x 0 - x 2 9 寄 存 器         l d p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         l d p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         l d p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         l d p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]         l d p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         l d p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         l d p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         l d p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         l d p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         l d p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         l d p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         l d p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         l d p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         l d p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ]         a d d           s p ,   s p ,   # 0 x f 0         l d r           x 3 0 ,   [ s p ] ;                             / / 恢 复 x 3 0         a d d           s p ,   s p ,   # 0 x 2 0 ;                     / / 恢 复 为 真 实 s p c a l l _ o r i F u n :         s t p           X 1 ,   X 0 ,   [ S P ,   # - 0 x 1 0 ] ;       / / 因 为 跳 转 还 要 占 用 一 个 寄 存 器 ， 所 以 保 存         l d r           x 0 ,   _ h k _ i n f o ;         l d r           x 0 ,   [ x 0 ,   # 8 ] ;                       / / p O r i F u n c A d d r         b r             x 0 g e t _ l r _ p c :         r e t ;                                                         / / 仅 用 于 获 取 L R / P C _ h k _ i n f o :                                                       / / 结 构 体 S T R _ H K _ I N F O . d o u b l e   0 x f f f f f f f f f f f f f f f f _ d u m p _ e n d : . e n d / / h o o k 信 息 t y p e d e f   s t r u c t   S T R _ H K _ I N F O {         v o i d   ( * o n P r e C a l l B a c k ) ( s t r u c t   m y _ p t _ r e g s   * ,   s t r u c t   S T R _ H K _ I N F O   * p I n f o ) ;               / / 回 调 函 数 ， 在 执 行 原 函 数 之 前 获 取 参 数 / 寄 存 器 的 函 数         v o i d   *   p O r i F u n c A d d r ;                           / / 存 放 备 份 / 修 复 后 原 函 数 的 地 址         v o i d   ( * p r e _ c a l l b a c k ) ( s t r u c t   m y _ p t _ r e g s   * ,   s t r u c t   S T R _ H K _ I N F O   * p I n f o ) ;             / / p r e _ c a l l b a c k , 内 部 做 保 存 l r 的 操 作 ， 之 后 回 调 o n P r e C a l l B a c k ， 不 能 被 用 户 操 作         v o i d   ( * o n C a l l B a c k ) ( s t r u c t   m y _ p t _ r e g s   * ,   s t r u c t   S T R _ H K _ I N F O   * p I n f o ) ;                         / / 回 调 函 数 ， 执 行 原 函 数 之 后 获 取 返 回 值 / 寄 存 器 的 函 数         v o i d   ( * a f t _ c a l l b a c k ) ( s t r u c t   m y _ p t _ r e g s   * ,   s t r u c t   S T R _ H K _ I N F O   * p I n f o ) ;               / / a f t _ c a l l b a c k ， 内 部 做 恢 复 l r 的 操 作 ， 之 后 回 调 o n C a l l B a c k ， 不 能 被 用 户 操 作         v o i d   * p H k F u n A d d r ;                                   / / h o o k 函 数 ， 即 自 定 义 按 照 被 h o o k 的 函 数 原 型 构 造 ， 处 理 参 数 / 返 回 值 的 函 数
m y p t r e g s 对 应 在 栈 上 存 放 的 寄 存 器 。 这 里 面 其 他 寄 存 器 都 容 易 保 存 ， p c 寄 存 器 因 为 不 能 直 接 操 作 ， 所 以 要 取 巧 一 些 。 我 是 利 用 b l 跳 转 之 前 会 把 下 一 条 指 令 的 地 址 存 放 到 l r 寄 存 器 ， 那 么 再 跳 回 读 取 l r 寄 存 器 即 可 。 当 然 这 里 保 存 p c 寄 存 器 其 实 也 不 是 必 须 的 。 d u m p _ d e m o         v o i d   * p H k F u n A d d r ;                                   / / h o o k 函 数 ， 即 自 定 义 按 照 被 h o o k 的 函 数 原 型 构 造 ， 处 理 参 数 / 返 回 值 的 函 数         / / 以 上 为 在 s h e l l c o d e 中 通 过 偏 移 直 接 或 间 接 用 到 的 ， 所 以 如 果 有 变 动 ， 相 应 的 s h e l l c o d e 也 要 跟 着 变 动         v o i d   * * p p H k F u n A d d r ;                                           / / 上 面 p H k F u n A d d r 函 数 在 s h e l l c o d e 中 的 地 址 , 已 废 弃 ;         v o i d   * * h k _ i n f o A d d r ;                                           / / s h e l l c o d e 中 H K _ I N F O 的 地 址         v o i d   * p B e H o o k A d d r ;                                             / / 被 h o o k 的 地 址 / 函 数         v o i d   * p S t u b S h e l l C o d e A d d r ;                               / / 跳 过 去 的 s h e l l c o d e   s t u b 的 地 址         s i z e _ t   s h e l l C o d e L e n g t h ;                                   / / 上 面 p S t u b S h e l l C o d e A d d r 的 字 节 数         v o i d   * *   p p O r i F u n c A d d r ;                                     / / s h e l l c o d e   中 存 放 备 份 / 修 复 后 原 函 数 的 地 址 ， 已 废 弃 ， 待 去 除 ； 改 成 上 面 p H k F u n A d d r 函 数 的 指 针 ， 应 用 于 解 除 h o o k         v o i d   * p N e w E n t r y F o r O r i F u n c A d d r ;                     / / 和 p O r i F u n c A d d r 一 致         B Y T E   s z b y B a c k u p O p c o d e s [ O P C O D E M A X L E N ] ;       / / 原 来 的 o p c o d e s         i n t   b a c k U p L e n g t h ;                                               / / 备 份 代 码 的 长 度 ， a r m 6 4 模 式 下 为 2 4         i n t   b a c k U p F i x L e n g t h L i s t [ B A C K U P _ C O D E _ N U M _ M A X ] ;   / / 保 存         c o n s t   c h a r *   m e t h o d N a m e ; }   H K _ I N F O ; # i f   d e f i n e d ( _ _ a a r c h 6 4 _ _ ) s t r u c t   m y _ p t _ r e g s   {         _ _ u 6 4   u r e g s [ 3 1 ] ;         _ _ u 6 4   s p ;         _ _ u 6 4   p s t a t e ;               / / 有 时 间 应 该 修 复 ， p c 在 前 ， 但 是 涉 及 到 栈 和 生 成 s h e l l c o d e 都 要 改 ， 先 这 么 用 吧 ， 和 系 统 结 构 体 有 这 点 不 同         _ _ u 6 4   p c ; } ; # d e f i n e   A R M _ l r   u r e g s [ 3 0 ] # d e f i n e   A R M _ s p   s p / / # d e f i n e   S P   ( _ _ u 6 4 * ) s p / / # d e f i n e   S P _ 3 2 ( i )   * ( _ _ u 3 2 * ) ( ( _ _ u 6 4 ) ( r e g s - > s p )   +   i * 4 ) / / # d e f i n e   S P _ 3 2 ( i )   * ( ( _ _ u 3 2 * ) r e g s - > s p + i ) / / # d e f i n e   S P _ 3 2 ( i )   * ( ( _ _ u 6 4 * ) r e g s - > s p + i ) # d e f i n e   S P ( i )   * ( ( _ _ u 6 4 * ) r e g s - > s p + i ) # e l i f   d e f i n e d ( _ _ a r m _ _ ) s t r u c t   m y _ p t _ r e g s   {     l o n g   u r e g s [ 1 8 ] ; } ; # i f n d e f   _ _ A S S E M B L Y _ _ # d e f i n e   A R M _ c p s r   u r e g s [ 1 6 ] # d e f i n e   A R M _ p c   u r e g s [ 1 5 ] # d e f i n e   A R M _ l r   u r e g s [ 1 4 ] # d e f i n e   A R M _ s p   u r e g s [ 1 3 ] # d e f i n e   A R M _ i p   u r e g s [ 1 2 ] # d e f i n e   A R M _ f p   u r e g s [ 1 1 ] # d e f i n e   A R M _ r 1 0   u r e g s [ 1 0 ] # d e f i n e   A R M _ r 9   u r e g s [ 9 ] # d e f i n e   A R M _ r 8   u r e g s [ 8 ] # d e f i n e   A R M _ r 7   u r e g s [ 7 ] # d e f i n e   A R M _ r 6   u r e g s [ 6 ] # d e f i n e   A R M _ r 5   u r e g s [ 5 ] # d e f i n e   A R M _ r 4   u r e g s [ 4 ] # d e f i n e   A R M _ r 3   u r e g s [ 3 ] # d e f i n e   A R M _ r 2   u r e g s [ 2 ] # d e f i n e   A R M _ r 1   u r e g s [ 1 ] # d e f i n e   A R M _ r 0   u r e g s [ 0 ] # d e f i n e   A R M _ O R I G _ r 0   u r e g s [ 1 7 ] # d e f i n e   A R M _ V F P R E G S _ S I Z E   ( 3 2   *   8   +   4 ) # e n d i f # d e f i n e   S P ( i )   * ( ( _ _ u 3 2 * ) r e g s - > A R M _ s p + i ) # e n d i f         b l             g e t _ l r _ p c ;                             / / l r 为 下 条 指 令         a d d           l r ,   l r ,   # 8 ;                             / / l r 为 b l r   x 3 的 地 址         s t r           l r ,   [ s p ,   # 0 x 1 0 8 ] ;                 / / l r 当 作 p c ， 覆 盖 栈 上 的 x 0         b l r           x 3         . . . g e t _ l r _ p c :         r e t ;                                                         / / 仅 用 于 获 取 L R / P C / * *   *     用 户 自 定 义 的 s t u b 函 数 ， 嵌 入 在 h o o k 点 中 ， 可 直 接 操 作 寄 存 器 等   *   @ p a r a m   r e g s             寄 存 器 结 构 ， 保 存 寄 存 器 当 前 h o o k 点 的 寄 存 器 信 息   *   @ p a r a m   p I n f o           保 存 了 被 h o o k 函 数 、 h o o k 函 数 等 的 结 构 体   * / v o i d   o n P r e C a l l B a c k ( m y _ p t _ r e g s   * r e g s ,   H K _ I N F O   * p I n f o )   / / 参 数 r e g s 就 是 指 向 栈 上 的 一 个 数 据 结 构 ， 由 第 二 部 分 的 m o v   r 0 ,   s p 所 传 递 。 {         c o n s t   c h a r *   n a m e   =   " n u l l " ;         i f   ( p I n f o )   {                 i f   ( p I n f o - > m e t h o d N a m e )   {                         n a m e   =   p I n f o - > m e t h o d N a m e ;                 }   e l s e   {
自 定 义 o n P r e C a l l B a c k 修 改 寄 存 器 即 可 。 如 果 是 一 个 函 数 ， 那 么 能 控 制 的 是 参 数 ， 不 能 阻 止 原 函 数 的 调 用 。 代 码 实 现 代 码 实 现 a r m 6 4 d u m p w i t h r e t 函 数 函 数                 }   e l s e   {                         c h a r   b u f [ 2 0 ] ;                         s p r i n t f ( b u f ,   " % p " ,   p I n f o - > p B e H o o k A d d r ) ;                         n a m e   =   b u f ;                 }         } / /         L E ( " t i d = % d   o n P r e C a l l B a c k : % s " ,   g e t t i d ( ) ,   n a m e ) ; # i f   d e f i n e d ( _ _ a a r c h 6 4 _ _ )         L E ( " t i d = % d ,   o n P r e C a l l B a c k : % s ,   "               " x 0 = 0 x % l l x ,   x 1 = 0 x % l l x ,   x 2 = 0 x % l l x ,   x 3 = 0 x % l l x ,   x 4 = 0 x % l l x ,   x 5 = 0 x % l l x ,   x 6 = 0 x % l l x ,   x 7 = 0 x % l l x ,   x 8 = 0 x % l l x ,   x 9 = 0 x % l l x ,   x 1 0 = 0 x % l l x , "               "   x 1 1 = 0 x % l l x ,   x 1 2 = 0 x % l l x ,   x 1 3 = 0 x % l l x ,   x 1 4 = 0 x % l l x ,   x 1 5 = 0 x % l l x ,   x 1 6 = 0 x % l l x ,   x 1 7 = 0 x % l l x ,   x 1 8 = 0 x % l l x ,   x 1 9 = 0 x % l l x ,   x 2 0 = 0 x % l l x ,   "               " x 2 1 = 0 x % l l x ,   x 2 2 = 0 x % l l x ,   x 2 3 = 0 x % l l x ,   x 2 4 = 0 x % l l x ,   x 2 5 = 0 x % l l x ,   x 2 6 = 0 x % l l x ,   x 2 7 = 0 x % l l x ,   x 2 8 = 0 x % l l x ,   x 2 9 / F P = 0 x % l l x ,   x 3 0 / L R = 0 x % l l x ,   "               " c u r _ s p = % p ,   o r i _ s p = % p ,   o r i _ s p / 3 1 = 0 x % l l x ,   N Z C V / 3 2 = 0 x % l l x ,   x 0 / p c / 3 3 = 0 x % l l x ,   c u r _ p c = % l l x ,   a r g 8 = % x ,   a r g 9 = % x ,   a r g 1 0 = % x ,   a r g 1 1 = % x ,   "               " a r g 1 2 = % x ,   a r g 1 3 = % x ; "               ,   g e t t i d ( ) ,   n a m e ,               r e g s - > u r e g s [ 0 ] ,   r e g s - > u r e g s [ 1 ] ,   r e g s - > u r e g s [ 2 ] ,   r e g s - > u r e g s [ 3 ] ,   r e g s - > u r e g s [ 4 ] ,   r e g s - > u r e g s [ 5 ] ,               r e g s - > u r e g s [ 6 ] ,   r e g s - > u r e g s [ 7 ] ,   r e g s - > u r e g s [ 8 ] ,   r e g s - > u r e g s [ 9 ] ,   r e g s - > u r e g s [ 1 0 ] ,   r e g s - > u r e g s [ 1 1 ] ,               r e g s - > u r e g s [ 1 2 ] ,   r e g s - > u r e g s [ 1 3 ] ,   r e g s - > u r e g s [ 1 4 ] ,   r e g s - > u r e g s [ 1 5 ] ,   r e g s - > u r e g s [ 1 6 ] ,   r e g s - > u r e g s [ 1 7 ] ,               r e g s - > u r e g s [ 1 8 ] ,   r e g s - > u r e g s [ 1 9 ] ,   r e g s - > u r e g s [ 2 0 ] ,   r e g s - > u r e g s [ 2 1 ] ,   r e g s - > u r e g s [ 2 2 ] ,   r e g s - > u r e g s [ 2 3 ] ,               r e g s - > u r e g s [ 2 4 ] ,   r e g s - > u r e g s [ 2 5 ] ,   r e g s - > u r e g s [ 2 6 ] ,   r e g s - > u r e g s [ 2 7 ] ,   r e g s - > u r e g s [ 2 8 ] ,   r e g s - > u r e g s [ 2 9 ] ,   r e g s - > u r e g s [ 3 0 ] ,               r e g s ,   ( ( c h a r * ) r e g s   +   0 x 1 1 0 ) ,   r e g s - > u r e g s [ 3 1 ] ,   r e g s - > u r e g s [ 3 2 ] ,   r e g s - > u r e g s [ 3 3 ] ,   r e g s - > p c ,               S P ( 0 ) ,   S P ( 1 ) ,   S P ( 2 ) ,   S P ( 3 ) ,   S P ( 4 ) ,   S P ( 5 )         ) ; # e l i f   d e f i n e d ( _ _ a r m _ _ )         L E ( " t i d = % d ,   o n P r e C a l l B a c k : % s ,   "               " r 0 = 0 x % l x ,   r 1 = 0 x % l x ,   r 2 = 0 x % l x ,   r 3 = 0 x % l x ,   r 4 = 0 x % l x ,   r 5 = 0 x % l x ,   r 6 = 0 x % l x ,   r 7 = 0 x % l x ,   r 8 = 0 x % l x ,   r 9 = 0 x % l x ,   r 1 0 = 0 x % l x ,   r 1 1 = 0 x % l x ,   r 1 2 = 0 x % l x ,   "               " c u r _ s p = % p ,   o r i _ s p = % p ,   o r i _ s p / 1 3 = 0 x % l x ,   l r = 0 x % l x ,   c u r _ p c = 0 x % l x ,   c p s r = 0 x % l x ,   "               " a r g 4 = 0 x % l x ,   a r g 5 = 0 x % l x ,   a r g 4 = 0 x % l x ,   a r g 5 = 0 x % l x ; "         ,   g e t t i d ( ) ,   n a m e ,               r e g s - > u r e g s [ 0 ] ,   r e g s - > u r e g s [ 1 ] ,   r e g s - > u r e g s [ 2 ] ,   r e g s - > u r e g s [ 3 ] ,   r e g s - > u r e g s [ 4 ] ,   r e g s - > u r e g s [ 5 ] ,               r e g s - > u r e g s [ 6 ] ,   r e g s - > u r e g s [ 7 ] ,   r e g s - > u r e g s [ 8 ] ,   r e g s - > u r e g s [ 9 ] ,   r e g s - > u r e g s [ 1 0 ] ,   r e g s - > u r e g s [ 1 1 ] ,               r e g s - > u r e g s [ 1 2 ] ,               r e g s ,   ( ( c h a r * ) r e g s   +   0 x 4 4 ) ,   r e g s - > u r e g s [ 1 3 ] ,   r e g s - > u r e g s [ 1 4 ] ,   r e g s - > u r e g s [ 1 5 ] ,   r e g s - > u r e g s [ 1 6 ] ,               r e g s - > u r e g s [ 1 7 ] ,   r e g s - > u r e g s [ 1 8 ] ,   S P ( 0 ) ,   S P ( 1 )         ) ; # e n d i f         i f   ( p I n f o )   {                 L E ( " o n P r e C a l l B a c k :   H K _ I N F O = % p " ,   p I n f o ) ;                 i f   ( p I n f o - > p B e H o o k A d d r   = =   o p e n   & &   r e g s - > u r e g s [ 0 ] )   {                         c o n s t   c h a r *   n a m e   =   ( c o n s t   c h a r   * ) ( r e g s - > u r e g s [ 0 ] ) ;                         L E ( " o n P r e C a l l B a c k :   o p e n :   % s   ,   % o ,   % o " ,   n a m e ,   r e g s - > u r e g s [ 1 ] ,   ( m o d e _ t ) r e g s - > u r e g s [ 2 ] ) ;                 }         } } v o i d   t e s t _ d u m p ( ) {         L E ( " o p e n = % p ,   c a l l b a c k = % p " ,   o p e n ,   o n P r e C a l l B a c k ) ;         i f   ( d u m p ( ( v o i d   * ) ( o p e n ) ,   o n P r e C a l l B a c k ,   N U L L ,   " o p e n " )   ! =   s u c c e s s )   {                 L E ( " h o o k   o p e n   e r r o r " ) ;         }         i n t   f d   =   o p e n ( " / s y s t e m / l i b / l i b c . s o " ,   O _ R D O N L Y ) ;         L E ( " o p e n   / s y s t e m / l i b / l i b c . s o ,   f d = % d " ,   f d ) ; } / / . i n c l u d e   " . . / . . / a s m / b a s e . s " . g l o b a l   r _ d u m p _ s t a r t . g l o b a l   r _ d u m p _ e n d . g l o b a l   r _ h k _ i n f o . h i d d e n   r _ d u m p _ s t a r t . h i d d e n   r _ d u m p _ e n d . h i d d e n   r _ h k _ i n f o . d a t a r _ d u m p _ s t a r t :                                         / / 用 于 读 写 寄 存 器 / 栈 ， 需 要 自 己 解 析 参 数 ， 不 能 读 写 返 回 值 ， 不 能 阻 止 原 函 数 ( 被 h o o k 函 数 ) 的 执 行                                                                 / / 从 行 为 上 来 我 觉 得 更 偏 向 d u m p ， 所 以 起 名 为 d u m p 。         s u b           s p ,   s p ,   # 0 x 2 0 ;             / / 跳 板 在 栈 上 存 储 了 x 0 、 x 1 ， 但 是 未 改 变 s p 的 值         m r s           x 0 ,   N Z C V         s t r           x 0 ,   [ s p ,   # 0 x 1 0 ] ;         / / 覆 盖 跳 板 存 储 的 x 1 ， 存 储 状 态 寄 存 器         s t r           x 3 0 ,   [ s p ] ;                     / / 存 储 x 3 0         a d d           x 3 0 ,   s p ,   # 0 x 2 0         s t r           x 3 0 ,   [ s p ,   # 0 x 8 ] ;         / / 存 储 真 实 的 s p         l d r           x 0 ,   [ s p ,   # 0 x 1 8 ] ;         / / 取 出 跳 板 存 储 的 x 0 s a v e _ x 0 _ x 2 9 : / / 保 存 寄 存 器 x 0 - x 2 9         s u b           s p ,   s p ,   # 0 x f 0 ;             / / 分 配 栈 空 间         s t p           X 0 ,   X 1 ,   [ S P ] ;               / / 存 储 x 0 - x 2 9         s t p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         s t p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         s t p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         s t p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]
        s t p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         s t p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         s t p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         s t p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         s t p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         s t p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         s t p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         s t p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         s t p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         s t p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ] c a l l _ o n P r e C a l l B a c k : / / 调 用 o n P r e C a l l B a c k 函 数 ， 第 一 个 参 数 是 s p ， 第 二 个 参 数 是 S T R _ H K _ I N F O 结 构 体 指 针         m o v           x 0 ,   s p ;                                   / / x 0 作 为 第 一 个 参 数 ， 那 么 操 作 x 0 = s p ， 即 操 作 栈 读 写 保 存 的 寄 存 器         l d r           x 1 ,   r _ h k _ i n f o ;         l d r           x 3 ,   [ x 1 ,   # 0 x 1 0 ] ;                 / / p r e _ c a l l b a c k         b l             g e t _ l r _ p c ;                             / / l r 为 下 条 指 令         a d d           l r ,   l r ,   8 ;                             / / l r 为 b l r   x 3 的 地 址         s t r           l r ,   [ s p ,   # 0 x 1 0 8 ] ;                 / / l r 当 作 p c ， 覆 盖 栈 上 的 x 0         b l r           x 3 t o _ c a l l _ o r i F u n :         l d r           x 0 ,   [ s p ,   # 0 x 1 0 0 ] ;               / / 取 出 状 态 寄 存 器         m s r           N Z C V ,   x 0         l d p           X 0 ,   X 1 ,   [ S P ] ;                       / / 恢 复 x 0 - x 2 9 寄 存 器         l d p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         l d p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         l d p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         l d p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]         l d p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         l d p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         l d p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         l d p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         l d p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         l d p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         l d p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         l d p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         l d p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         l d p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ]         a d d           s p ,   s p ,   # 0 x f 0         l d r           x 3 0 ,   [ s p ] ;                             / / 恢 复 x 3 0         a d d           s p ,   s p ,   # 0 x 2 0 ;                     / / 恢 复 为 真 实 s p         s t p           X 1 ,   X 0 ,   [ S P ,   # - 0 x 1 0 ] ;       / / 因 为 跳 转 还 要 占 用 一 个 寄 存 器 ， 所 以 保 存         l d r           x 0 ,   r _ h k _ i n f o ;         l d r           x 0 ,   [ x 0 ,   # 8 ] ;                       / / p O r i F u n c A d d r         b l r           x 0 ; t o _ a f t _ c a l l b a c k :                                 / / 有 时 间 再 把 这 部 分 代 码 优 化 掉 ， 是 可 以 再 跳 转 到 开 头 的 ， 因 为 这 部 分 代 码 都 是 一 样 的 ， 判 断 l r 可 以 区 分 出 来 的         S T P           X 1 ,   X 0 ,   [ S P ,   # - 0 x 1 0 ]         s u b           s p ,   s p ,   # 0 x 2 0 ;             / / 跳 板 在 栈 上 存 储 了 x 0 、 x 1 ， 但 是 未 改 变 s p 的 值         m r s           x 0 ,   N Z C V         s t r           x 0 ,   [ s p ,   # 0 x 1 0 ] ;         / / 覆 盖 跳 板 存 储 的 x 1 ， 存 储 状 态 寄 存 器         s t r           x 3 0 ,   [ s p ] ;                     / / 存 储 x 3 0         a d d           x 3 0 ,   s p ,   # 0 x 2 0         s t r           x 3 0 ,   [ s p ,   # 0 x 8 ] ;         / / 存 储 真 实 的 s p         l d r           x 0 ,   [ s p ,   # 0 x 1 8 ] ;         / / 取 出 跳 板 存 储 的 x 0         s u b           s p ,   s p ,   # 0 x f 0 ;             / / 分 配 栈 空 间         s t p           X 0 ,   X 1 ,   [ S P ] ;               / / 存 储 x 0 - x 2 9         s t p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         s t p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         s t p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         s t p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]         s t p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         s t p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         s t p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         s t p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         s t p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         s t p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         s t p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         s t p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         s t p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         s t p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ]         m o v           x 0 ,   s p ;                                   / / x 0 作 为 第 一 个 参 数 ， 那 么 操 作 x 0 = s p ， 即 操 作 栈 读 写 保 存 的 寄 存 器         l d r           x 1 ,   r _ h k _ i n f o ;         l d r           x 3 ,   [ x 1 ,   # 0 x 2 0 ] ;                 / / a f t _ c a l l b a c k         b l             g e t _ l r _ p c ;                             / / l r 为 下 条 指 令         a d d           l r ,   l r ,   8 ;                             / / l r 为 b l r   x 3 的 地 址         s t r           l r ,   [ s p ,   # 0 x 1 0 8 ] ;                 / / l r 当 作 p c ， 覆 盖 栈 上 的 x 0         b l r           x 3 ;                                           / / 执 行 a f t _ c a l l b a c k t o _ p o p r e g :         l d r           x 0 ,   [ s p ,   # 0 x 1 0 0 ] ;               / / 取 出 状 态 寄 存 器         m s r           N Z C V ,   x 0         l d p           X 0 ,   X 1 ,   [ S P ] ;                       / / 恢 复 x 0 - x 2 9 寄 存 器         l d p           X 2 ,   X 3 ,   [ S P , # 0 x 1 0 ]         l d p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]
和 d u m p 不 同 ， 在 原 函 数 执 行 后 可 以 对 返 回 值 进 行 读 写 ， 且 可 以 只 处 理 参 数 或 者 只 处 理 返 回 值 。 因 为 要 读 写 返 回 值 ， 所 以 执 行 原 函 数 之 前 需 要 修 改 l r 寄 存 器 ， 而 读 写 返 回 值 之 后 还 要 恢 复 正 常 的 流 程 ， 那 么 l r 寄 存 器 是 需 要 保 存 的 。 在 这 个 s h e l l c o d e 或 者 结 构 体 的 一 个 字 段 存 储 l r 都 存 在 多 线 程 覆 盖 的 问 题 ， 所 以 使 用 和 线 程 绑 定 的 容 器 存 储 。 那 么 何 时 保 存 呢 ？ 考 虑 到 代 码 复 用 和 最 小 的 更 改 ， 那 么 可 以 在 调 用 o n P r e C a l l B a c k 函 数 内 保 存 ， 但 是 这 个 函 数 是 用 户 创 建 的 ， 不 应 该 让 用 户 参 与 保 存 ， 而 且 这 个 o n P r e C a l l B a c k 不 一 定 存 在 。 所 以 做 一 次 中 转 ， s h e l l c o d e 中 先 跳 到 一 个 一 定 存 在 的 函 数 p r e C a l l B a c k , p r e C a l l B a c k 内 保 存 l r ， 并 调 用 o n P r e C a l l B a c k ( 如 果 存 在 ) 。 恢 复 l r 也 是 同 样 的 思 路 。         l d p           X 4 ,   X 5 ,   [ S P , # 0 x 2 0 ]         l d p           X 6 ,   X 7 ,   [ S P , # 0 x 3 0 ]         l d p           X 8 ,   X 9 ,   [ S P , # 0 x 4 0 ]         l d p           X 1 0 ,   X 1 1 ,   [ S P , # 0 x 5 0 ]         l d p           X 1 2 ,   X 1 3 ,   [ S P , # 0 x 6 0 ]         l d p           X 1 4 ,   X 1 5 ,   [ S P , # 0 x 7 0 ]         l d p           X 1 6 ,   X 1 7 ,   [ S P , # 0 x 8 0 ]         l d p           X 1 8 ,   X 1 9 ,   [ S P , # 0 x 9 0 ]         l d p           X 2 0 ,   X 2 1 ,   [ S P , # 0 x a 0 ]         l d p           X 2 2 ,   X 2 3 ,   [ S P , # 0 x b 0 ]         l d p           X 2 4 ,   X 2 5 ,   [ S P , # 0 x c 0 ]         l d p           X 2 6 ,   X 2 7 ,   [ S P , # 0 x d 0 ]         l d p           X 2 8 ,   X 2 9 ,   [ S P , # 0 x e 0 ]         a d d           s p ,   s p ,   # 0 x f 0         l d r           x 3 0 ,   [ s p ] ;                             / / 恢 复 x 3 0         a d d           s p ,   s p ,   # 0 x 2 0 ;                     / / 恢 复 为 真 实 s p                                                                         / / 巧 的 是 下 条 指 令 也 是 r e t 或 者 b r   l r ， 共 用 一 条 指 令 。 g e t _ l r _ p c :         r e t ;                                                         / / 仅 用 于 获 取 L R / P C r _ h k _ i n f o :                                                       / / 结 构 体 S T R _ H K _ I N F O . d o u b l e   0 x f f f f f f f f f f f f f f f f r _ d u m p _ e n d : . e n d / / 头 文 件 # i n c l u d e   < m a p > # i n c l u d e   < p t h r e a d . h > # i n c l u d e   < v e c t o r > t y p e d e f   s t d : : v e c t o r < u n s i g n e d   l o n g >   L R S ; / / s t a t i c   L R S   l r s ; s t r u c t   S T R _ L R   { } ; t y p e d e f   s t d : : m a p < c o n s t   v o i d * ,   L R S * >   L R _ M A P ; / / t y p e d e f   s t d : : m a p < p i d _ t ,   L R _ M A P * >   T I D _ M A P ; t y p e d e f   s t d : : m a p < p i d _ t ,   L R _ M A P * >   T I D _ M A P ; s t a t i c   T I D _ M A P   *   g e t T i d _ m a p ( ) ; s t a t i c   v o i d   s a v e L R ( v o i d *   k e y _ f u n ,   u n s i g n e d   l o n g   l r ) ; s t a t i c   u n s i g n e d   l o n g   g e t L R ( v o i d *   k e y _ f u n ) ; # e n d i f # i f d e f   _ _ c p l u s p l u s e x t e r n   " C "   { # e n d i f # i n c l u d e   " m h k . h " / / 因 为 会 被 导 出 ， 所 以 两 个 静 态 库 中 存 在 两 个 同 名 函 数 ， 另 一 个 被 覆 盖 了 。 / / e x t e r n   v o i d   p r e _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) ; s t a t i c   v o i d   p r e _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) ; / / e x t e r n   v o i d   a f t _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) ; s t a t i c   v o i d   a f t _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) ; t y p e d e f   v o i d   ( * c a l l b a c k ) ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) ; e x t e r n   c a l l b a c k   d _ p r e _ c a l l b a c k ; / /   =   p r e _ c a l l b a c k ; e x t e r n   c a l l b a c k   d _ a f t _ c a l l b a c k ; / /   =   a f t _ c a l l b a c k ; # i f d e f   _ _ c p l u s p l u s } # e n d i f / / 头 文 件 结 束 s t a t i c   T I D _ M A P *   t i d _ m a p ; s t a t i c   p t h r e a d _ m u t e x _ t   m u t e x   =   P T H R E A D _ M U T E X _ I N I T I A L I Z E R ; T I D _ M A P   *   g e t T i d _ m a p ( ) { / /         p t h r e a d _ m u t e x _ i n i t ( & m u t e x ,   N U L L ) ;         p t h r e a d _ m u t e x _ l o c k ( & m u t e x ) ;         i f   ( t i d _ m a p   = =   N U L L )   {                 t i d _ m a p   =   n e w   T I D _ M A P ;         }         p t h r e a d _ m u t e x _ u n l o c k ( & m u t e x ) ;         r e t u r n   t i d _ m a p ; } / / 因 为 不 清 楚 t i d 分 配 机 制 ， 是 否 存 在 已 死 亡 线 程 的 t i d 重 新 分 配 给 新 建 线 程 ， 所 以 可 以 l s   - l a   / p r o c / 8 2 0 5 / t a s k / 根 据 线 程 时 间 / / 判 断 是 不 是 一 个 新 线 程 ， 若 是 使 用 旧 t i d 的 新 线 程 可 以 清 空 m a p ， 不 过 其 实 使 用 的 栈 结 构 存 数 据 ， 理 论 上 不 区 分 也 应 该 没 问 题 的 。 v o i d   s a v e L R ( v o i d *   k e y _ f u n ,   u n s i g n e d   l o n g   l r ) {         p i d _ t   t i d   =   g e t t i d ( ) ;         T I D _ M A P   * m a p   =   g e t T i d _ m a p ( ) ;         p t h r e a d _ m u t e x _ l o c k ( & m u t e x ) ;         a u t o   i t   =   m a p - > f i n d ( t i d ) ;         i f   ( i t   = =   m a p - > e n d ( ) )   {                 a u t o   l r _ m a p   =   n e w   L R _ M A P ;                 a u t o   l s   =   n e w   L R S ;
目 前 是 使 用 " c + + " 容 器 实 现 的 ， 考 虑 到 有 些 项 目 可 能 不 能 用 c + + ， 有 时 间 再 用 c 实 现 m a p 、 v e c t o r 。 d u m p w i t h r e t _ d e m o                 a u t o   l s   =   n e w   L R S ;                 l s - > p u s h _ b a c k ( l r ) ;                 l r _ m a p - > i n s e r t ( s t d : : m a k e _ p a i r ( k e y _ f u n ,   l s ) ) ;                 m a p - > i n s e r t ( s t d : : m a k e _ p a i r ( t i d ,   l r _ m a p ) ) ;         }   e l s e   {                 a u t o   l r _ m a p   =   i t - > s e c o n d ;                 a u t o   i t _ v t   =   l r _ m a p - > f i n d ( k e y _ f u n ) ;                 i f   ( i t _ v t   = =   l r _ m a p - > e n d ( ) )   {                         a u t o   l s   =   n e w   L R S ;                         l s - > p u s h _ b a c k ( l r ) ;                         l r _ m a p - > i n s e r t ( s t d : : m a k e _ p a i r ( k e y _ f u n ,   l s ) ) ;                 }   e l s e   {                         s t d : : v e c t o r < u n s i g n e d   l o n g >   * v t   =   i t _ v t - > s e c o n d ;                         v t - > p u s h _ b a c k ( l r ) ;                 }         }         p t h r e a d _ m u t e x _ u n l o c k ( & m u t e x ) ; } u n s i g n e d   l o n g   g e t L R ( v o i d *   k e y _ f u n ) {         u n s i g n e d   l o n g   l r   =   0 ;         p i d _ t   t i d   =   g e t t i d ( ) ;         T I D _ M A P   * m a p   =   g e t T i d _ m a p ( ) ;         p t h r e a d _ m u t e x _ l o c k ( & m u t e x ) ;         a u t o   i t   =   m a p - > f i n d ( t i d ) ;         i f   ( i t   = =   m a p - > e n d ( ) )   {                 L E ( " w h a t ' s   h a p p e n e d   ?   n o t   f o u n d   t i d = % d " ,   t i d ) ; / / 理 论 上 不 应 该 出 现         }   e l s e   {                 a u t o   l r _ m a p   =   i t - > s e c o n d ;                 a u t o   i t _ v t   =   l r _ m a p - > f i n d ( k e y _ f u n ) ;                 i f   ( i t _ v t   = =   l r _ m a p - > e n d ( ) )   {                         L E ( " w h a t ' s   h a p p e n e d   ?   n o t   f o u n d   L R   f o r = % p   i n   t i d = % d " ,   k e y _ f u n ,   t i d ) ; / / 理 论 上 不 应 该 出 现                 }   e l s e   {                         s t d : : v e c t o r < u n s i g n e d   l o n g >   * v t   =   i t _ v t - > s e c o n d ;                         i f   ( ! v t   | |   / * v t - > s i z e ( )   < =   0 * /   v t - > e m p t y ( ) )   {                                 L E ( " w h a t ' s   h a p p e n e d   ?   n u l l   L R   f o r = % p   i n   t i d = % d " ,   k e y _ f u n ,   t i d ) ;                         }   e l s e   {                                 u n s i g n e d   l o n g   s i z e   =   v t - > s i z e ( ) ;                                 l r   =   ( * v t ) [ s i z e   -   1 ] ;                                 v t - > p o p _ b a c k ( ) ;                         }                 }         }         p t h r e a d _ m u t e x _ u n l o c k ( & m u t e x ) ;         r e t u r n   l r ; } v o i d   p r e _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) {         L E ( " d u m p _ w i t h _ r e t   p r e _ c a l l b a c k " ) ;         s a v e L R ( i n f o - > p B e H o o k A d d r ,   r e g s - > A R M _ l r ) ;         i f   ( i n f o - > o n P r e C a l l B a c k )                 i n f o - > o n P r e C a l l B a c k ( r e g s ,   i n f o ) ; } v o i d   a f t _ c a l l b a c k ( s t r u c t   m y _ p t _ r e g s   * r e g s ,   H K _ I N F O *   i n f o ) {         L E ( " d u m p _ w i t h _ r e t   a f t _ c a l l b a c k " ) ;         u n s i g n e d   l o n g   l r   =   g e t L R ( i n f o - > p B e H o o k A d d r ) ;         r e g s - > A R M _ l r   =   l r ;         i f   ( i n f o - > o n C a l l B a c k )                 i n f o - > o n C a l l B a c k ( r e g s ,   i n f o ) ; } c a l l b a c k   d _ p r e _ c a l l b a c k   =   p r e _ c a l l b a c k ; c a l l b a c k   d _ a f t _ c a l l b a c k   =   a f t _ c a l l b a c k ; v o i d   t e s t _ d u m p _ w i t h _ r e t ( ) {         L E ( " o p e n = % p ,   c a l l b a c k = % p " ,   o p e n ,   o n P r e C a l l B a c k ) ;         i f   ( d u m p ( ( v o i d   * ) ( o p e n ) ,   o n P r e C a l l B a c k ,   o n C a l l B a c k ,   " o p e n " )   ! =   s u c c e s s )   {                 L E ( " h o o k   o p e n   e r r o r " ) ;         }         i n t   f d   =   o p e n ( " / s y s t e m / l i b / l i b c . s o " ,   O _ R D O N L Y ) ;         L E ( " o p e n   / s y s t e m / l i b / l i b c . s o ,   f d = % d " ,   f d ) ; } v o i d   t e s t _ d u m p _ r e t ( ) {         L E ( " o p e n = % p ,   c a l l b a c k = % p " ,   o p e n ,   o n P r e C a l l B a c k ) ;         i f   ( d u m p ( ( v o i d   * ) ( o p e n ) ,   N U L L ,   o n C a l l B a c k ,   " o p e n " )   ! =   s u c c e s s )   {                 L E ( " h o o k   o p e n   e r r o r " ) ;         }         i n t   f d   =   o p e n ( " / s y s t e m / l i b / l i b c . s o " ,   O _ R D O N L Y ) ;         L E ( " o p e n   / s y s t e m / l i b / l i b c . s o ,   f d = % d " ,   f d ) ; }
回复

举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

使用Markdown编辑器编辑 使用富文本编辑器编辑

Archiver| 手机版| 小黑屋|
Powered by Discuz! X3.4 Copyright © 2001-2020, Tencent Cloud. 商业源码建议获取授权，如侵犯您的权益，请联系客服处理