FSOP，glibc-2.23攻击IO_list_all

news2024/9/22 20:24:14

文章目录

  • FSOP
    • 介绍：
    • FOSP链执行流程：
      • 源码调试过程

FSOP

介绍：

  1. FSOP 是 File Stream Oriented Programming 的缩写，根据前面对 FILE 的介绍得知进程内所有的 _ IO_FILE 结构会使用 _ chain 域相互连接形成一个链表，这个链表的头部由_IO_list_all 维护。

  2. FSOP 的核心思想就是劫持_IO_list_all 的值来伪造链表和其中的_IO_FILE 项，但是单纯的伪造只是构造了数据还需要某种方法进行触发。FSOP 选择的触发方法是调用_IO_flush_all_lockp，这个函数会刷新_IO_list_all 链表中所有项的文件流，相当于对每个 FILE 调用 fflush，也对应着会调用_IO_FILE_plus.vtable 中的_IO_overflow。

  3. 关键函数**_IO_flush_all_lockp**：

    int
_IO_flush_all_lockp (int do_lock)
{
  ...
  fp = (_IO_FILE *) _IO_list_all;
  while (fp != NULL)
  {
       ...
       if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base))
               && _IO_OVERFLOW (fp, EOF) == EOF)
           {
               result = EOF;
          }
        ...
  }
}

FOSP链执行流程：

malloc中unsorted bin出错会调用malloc_printerr 输出错误：

image-20240813114500591

malloc_printerr 函数：

image-20240812174218150

跟进__libc_message函数，最后也调用了abort函数：

/* Abort with an error message.  */
void
__libc_message (int do_abort, const char *fmt, ...)
{
  va_list ap;
  int fd = -1;

  va_start (ap, fmt);

#ifdef FATAL_PREPARE
  FATAL_PREPARE;
#endif

  /* Open a descriptor for /dev/tty unless the user explicitly
     requests errors on standard error.  */
  const char *on_2 = __libc_secure_getenv ("LIBC_FATAL_STDERR_");
  if (on_2 == NULL || *on_2 == '\0')
    fd = open_not_cancel_2 (_PATH_TTY, O_RDWR | O_NOCTTY | O_NDELAY);

  if (fd == -1)
    fd = STDERR_FILENO;

  struct str_list *list = NULL;
  int nlist = 0;

  const char *cp = fmt;
  while (*cp != '\0')
    {
      /* Find the next "%s" or the end of the string.  */
      const char *next = cp;
      while (next[0] != '%' || next[1] != 's')
	{
	  next = __strchrnul (next + 1, '%');

	  if (next[0] == '\0')
	    break;
	}

      /* Determine what to print.  */
      const char *str;
      size_t len;
      if (cp[0] == '%' && cp[1] == 's')
	{
	  str = va_arg (ap, const char *);
	  len = strlen (str);
	  cp += 2;
	}
      else
	{
	  str = cp;
	  len = next - cp;
	  cp = next;
	}

      struct str_list *newp = alloca (sizeof (struct str_list));
      newp->str = str;
      newp->len = len;
      newp->next = list;
      list = newp;
      ++nlist;
    }

  bool written = false;
  if (nlist > 0)
    {
      struct iovec *iov = alloca (nlist * sizeof (struct iovec));
      ssize_t total = 0;

      for (int cnt = nlist - 1; cnt >= 0; --cnt)
	{
	  iov[cnt].iov_base = (char *) list->str;
	  iov[cnt].iov_len = list->len;
	  total += list->len;
	  list = list->next;
	}

      written = WRITEV_FOR_FATAL (fd, iov, nlist, total);

      if (do_abort)
	{
	  total = ((total + 1 + GLRO(dl_pagesize) - 1)
		   & ~(GLRO(dl_pagesize) - 1));
	  struct abort_msg_s *buf = __mmap (NULL, total,
					    PROT_READ | PROT_WRITE,
					    MAP_ANON | MAP_PRIVATE, -1, 0);
	  if (__glibc_likely (buf != MAP_FAILED))
	    {
	      buf->size = total;
	      char *wp = buf->msg;
	      for (int cnt = 0; cnt < nlist; ++cnt)
		wp = mempcpy (wp, iov[cnt].iov_base, iov[cnt].iov_len);
	      *wp = '\0';

	      /* We have to free the old buffer since the application might
		 catch the SIGABRT signal.  */
	      struct abort_msg_s *old = atomic_exchange_acq (&__abort_msg,
							     buf);
	      if (old != NULL)
		__munmap (old, old->size);
	    }
	}
    }
  va_end (ap);
  if (do_abort)
    {
      BEFORE_ABORT (do_abort, written, fd);

      /* Kill the application.  */
      abort ();
    }
}

跟进abort函数，其中调用了fflush函数：

/* Cause an abnormal program termination with core-dump.  */
void
abort (void)
{
  struct sigaction act;
  sigset_t sigs;

  /* First acquire the lock.  */
  __libc_lock_lock_recursive (lock);

  /* Now it's for sure we are alone.  But recursive calls are possible.  */

  /* Unlock SIGABRT.  */
  if (stage == 0)
    {
      ++stage;
      if (__sigemptyset (&sigs) == 0 &&
	  __sigaddset (&sigs, SIGABRT) == 0)
	__sigprocmask (SIG_UNBLOCK, &sigs, (sigset_t *) NULL);
    }

  /* Flush all streams.  We cannot close them now because the user
     might have registered a handler for SIGABRT.  */
  if (stage == 1)
    {
      ++stage;
      fflush (NULL);
    }
······
}

跟进fflush函数，fflush是一个宏定义，调用了IO_fflush函数，且参数是NULL：

image-20240812174952791

继续跟进IO_fflush(NULL)，由于传入的参数为NULL，所以会调用_IO_flush_all函数:

int
_IO_fflush (_IO_FILE *fp)
{
  if (fp == NULL)
    return _IO_flush_all ();
  else
    {
      int result;
      CHECK_FILE (fp, EOF);
      _IO_acquire_lock (fp);
      result = _IO_SYNC (fp) ? EOF : 0;
      _IO_release_lock (fp);
      return result;
    }
}

跟进_IO_flush_all函数，_IO_flush_all_lockp调用了_IO_flush_all_lockp(1)：

int
_IO_flush_all (void)
{
  /* We want locking.  */
  return _IO_flush_all_lockp (1);
}

跟进_IO_flush_all_lockp(1)，而 _IO_flush_all_lockp就是这条FILE终点:

image-20240812175836473

int
_IO_flush_all_lockp (int do_lock)
{
  int result = 0;
  struct _IO_FILE *fp;
  int last_stamp;

#ifdef _IO_MTSAFE_IO
  __libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
  if (do_lock)
    _IO_lock_lock (list_all_lock);
#endif

  last_stamp = _IO_list_all_stamp;
  fp = (_IO_FILE *) _IO_list_all;//这里fp取到了_IO_list_all 这里fp直接指向了_IO_2_1_stderr_首地址
  while (fp != NULL)//进入循环
    {
      run_fp = fp;
      if (do_lock)
	_IO_flockfile (fp);

      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
	   || (_IO_vtable_offset (fp) == 0
	       && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
				    > fp->_wide_data->_IO_write_base))
#endif
	   )
	  && _IO_OVERFLOW (fp, EOF) == EOF)//这里经过前面的判断后调用了_IO_OVERFLOW(fp,EOF)
	result = EOF;

      if (do_lock)
	_IO_funlockfile (fp);
      run_fp = NULL;

      if (last_stamp != _IO_list_all_stamp)
	{
	  /* Something was added to the list.  Start all over again.  */
	  fp = (_IO_FILE *) _IO_list_all;
	  last_stamp = _IO_list_all_stamp;
	}
      else
	fp = fp->_chain;//这里使用FILE结构中的_chain来更新fp，直到fp为空才退出循环，所以会刷新_IO_list_all 链表中所有项的文件流
    }

#ifdef _IO_MTSAFE_IO
  if (do_lock)
    _IO_lock_unlock (list_all_lock);
  __libc_cleanup_region_end (0);
#endif

  return result;
}

查看_IO_OVERFLOW(fp, EOF)定义，以及最后的：

//libc_2.23 的定义
define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)
define _IO_JUMPS_FUNC(THIS) (*(struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (THIS) + (THIS)->_vtable_offset))
    
//结合传入的参数转化后如下：相当于调用了fp的__overflow函数
define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
define JUMP1(__overflow, FP, CH) (_IO_JUMPS_FUNC(FP)->__overflow) (FP, CH)
define _IO_JUMPS_FUNC(FP) (*(struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (FP) + (FP)->_vtable_offset))
    

    
//在libc_2.24后：_IO_JUMPS_FUNC的宏定义变化
define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)
define _IO_JUMPS_FUNC(THIS) (IO_validate_vtable (_IO_JUMPS_FILE_plus (THIS)))
    
/* Check if unknown vtable pointers are permitted; otherwise,
   terminate the process.  */
void _IO_vtable_check (void) attribute_hidden; //提前声明

/* Perform vtable pointer validation.  If validation fails, terminate
   the process.  */
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
  /* Fast path: The vtable pointer is within the __libc_IO_vtables
     section.  */
  uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
  const char *ptr = (const char *) vtable;
  uintptr_t offset = ptr - __start___libc_IO_vtables;
  if (__glibc_unlikely (offset >= section_length))
    /* The vtable pointer is not in the expected section.  Use the
       slow path, which will terminate the process if necessary.  */
    _IO_vtable_check ();
  return vtable;
}

void attribute_hidden _IO_vtable_check (void)
{
#ifdef SHARED
  /* Honor the compatibility flag.  */
  void (*flag) (void) = atomic_load_relaxed (&IO_accept_foreign_vtables);
#ifdef PTR_DEMANGLE
  PTR_DEMANGLE (flag);
#endif
  if (flag == &_IO_vtable_check)
    return;

  /* In case this libc copy is in a non-default namespace, we always
     need to accept foreign vtables because there is always a
     possibility that FILE * objects are passed across the linking
     boundary.  */
  {
    Dl_info di;
    struct link_map *l;
    if (_dl_open_hook != NULL
        || (_dl_addr (_IO_vtable_check, &di, &l, NULL) != 0
            && l->l_ns != LM_ID_BASE))
      return;
  }

#else /* !SHARED */
  /* We cannot perform vtable validation in the static dlopen case
     because FILE * handles might be passed back and forth across the
     boundary.  Therefore, we disable checking in this case.  */
  if (__dlopen != NULL)
    return;
#endif

  __libc_fatal ("Fatal error: glibc detected an invalid stdio handle\n");
}

最后找函数地址时，使用了_vtable_offset 即 _IO_FILE 结构体的 vtable 指针，而vtable 指针指向的是一个虚表，所以相当于最后调用到了下面的_IO_file_overflow函数，并且传入的参数是fp指针，即文件的地址：

image-20240812181423518

image-20240812180745597

随意最后IO_FILE链为：malloc报错 ==> malloc_printerr ==> __libc_message ==> abort ==> fflush ==> IO_fflush ==> _IO_flush_all ==> _IO_flush_all_lockp ==> _IO_OVERFLOW(最后使用vtable 指向的虚表中的指针)，

最后在_IO_flush_all_lockp中时有两个判断条件需要绕过，才能调用到_IO_OVERFLOW ：

  • fp->_mode <= 0
  • fp-> _IO_write_ptr > fp->_IO_write_base

image-20240816210105503

所以，在unsorted bin中构造的IO_FILE要满足这两个条件即可，最后伪造虚表，并用system地址覆盖掉_OVERFLOW指针，并在vtable位置伪造指针 ，指向这个虚表即可 。

源码调试过程

  1. 下面结合题目来调试这个过程，题目解析参考的这篇文章：House of Orange-CSDN博客，脚本和这篇文章完全一样，直接到最后一部调试malloc，直接断点到malloc：

  2. 此时堆上的布局如下，并且顺利进入malloc函数：

    image-20240816210302070

  3. 经过free_hook检查后进入到 _ int_malloc中分配chunk，传入的参数为main_arena地址，和申请的chunk大小：

    image-20240816210519531

  4. 进入 _int_malloc函数，先转化size的大小：

    image-20240816210815961

    随后检查实际分配的大小与get_max_fast(0x80)比较，先访问fastbin：

    image-20240816211101226

    fatbin中没有剩余的chunk，接下来就访问small bin：

    image-20240816211317124

    small bin中也没有剩余的chunk，下面进入到unsorted bin中查询：

    image-20240816212435339

    在unsorted bin中找到空闲chunk：

    image-20240816213402495

    size != nb，所以先放入到small bin中：

    image-20240816214425524

    image-20240816215039109

    修改后的main_arena，覆盖的IO_list_all的file中的_chain正好衔接到fake_chunk：

    image-20240816220849827

    查看到fake_chunk中伪造的file结构：

    image-20240816221330642

  5. 下面会因为unsorted bin的完整性报错 ，从而调用malloc_printerr函数：

    image-20240816222223675

  6. 再调用**__libc_message**函数：

    image-20240816222513599

  7. 再调用abort函数：

    image-20240816223308411

  8. 调用发flush(NULL)，这里传入的参数是NULL：

    image-20240816223639380

  9. 成功进入到_IO_flush_all_lockp函数，来刷新所有文件流：

    第一个文件流，被我们覆盖掉IO_list_all后，移动到了main_arena_88:

    image-20240816224156379

    通过_chain取到第二个文件，即为我们伪造的fake_chunk：

    image-20240816224646684

    image-20240816224827261

    image-20240816225023786

  10. 最后成功拿到flag：

    image-20240816225050904

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2047070.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

景联文科技：一文详解如何构建高质量SFT数据

景联文科技：一文详解如何构建高质量SFT数据

在图像处理和计算机视觉领域中&#xff0c;将一张图像转化为可用于训练机器学习模型的数据是一项复杂而重要的任务。SFT&#xff08;Supervised Fine-Tuning&#xff0c;监督微调&#xff09;是一种常见的深度学习策略&#xff0c;在这一过程中发挥着核心作用。 SFT是指在一个预…
阅读更多...
【云备份】服务端模块-热点管理

【云备份】服务端模块-热点管理

文章目录 0.回顾extern1.介绍2.实现思想3.代码测试代码 0.回顾extern extern cloudBackup::DataManager *_dataManager extern 关键字用于声明一个全局变量或对象&#xff0c;而不定义它。这意味着 _dataManager 是一个指向 cloudBackup::DataManager 类型的指针&#xff0c;但…
阅读更多...
外部接入tensorboard和Jupyter Notebook

外部接入tensorboard和Jupyter Notebook

本地端打开服务器端jupyter Notebook 1:服务器端在目标文件夹下输入jupyter notebook --no-browser --port8888&#xff08;留意下token&#xff09; 2&#xff1a;本地端打开git 的bash窗口输入ssh -L 8888:localhost:8888 warren10.12.14.187 warren为用户名&#xff0c;10…
阅读更多...
get 请求获取不到参数，但是post参数可以获取到

get 请求获取不到参数，但是post参数可以获取到

一&#xff1a;测试代码时发现&#xff0c;get请求一直获取不到参数。最终原因如下&#xff0c;nginx配置中需求有下面的配置 $args&#xff1a;代表接受到的参数
阅读更多...
MemFire Cloud是否真的可以取代后端

MemFire Cloud是否真的可以取代后端

近年来&#xff0c;随着前端技术的迅速发展&#xff0c;前端工程师们越来越多地开始思考一个问题&#xff1a;“我还能不能不依赖后端&#xff1f;” 这种想法并非空穴来风&#xff0c;尤其是随着像MemFire Cloud这样的工具出现&#xff0c;它不仅能让开发者在没有后端的情况下…
阅读更多...
2. springboot集成kafka入门使用教程

2. springboot集成kafka入门使用教程

项目demo地址 : https://mp.weixin.qq.com/s?__bizMzkzODQyNzE3 1. 项目结构 ─src├─main│ ├─java│ │ └─org│ │ └─example│ │ │ KafkaApplication.java│ │ ││ │ └─demo│ │ KafkaConsume…
阅读更多...
跟李沐学AI：目标检测、锚框

跟李沐学AI：目标检测、锚框

边缘框 用于表示物体的位置&#xff0c;一个边缘框通过四个数字定义&#xff1a;(坐上x, 左上y, 右下x, 右下y)或&#xff08;左上x, 左上y, 宽, 高&#xff09; 通常物体检测或目标检测的数据集比图片分类的数据集小很多&#xff0c;因为物体检测数据集标注成本高很多。 目…
阅读更多...
音视频相关知识

音视频相关知识

H.264编码格式 音频 PCM就是要把声音从模拟信号转换成数字信号的一种技术&#xff0c;他的原理简单地说就是利用一个固定的频率对模拟信号进行采样。 pcm是无损音频音频文件格式
阅读更多...
【Qt】QWidget的font属性

【Qt】QWidget的font属性

QWidget的font属性 API说明 font() 获取当前 widget 的字体信息. 返回 QFont 对象. setFont(const QFont& font) 设置当前 widget 的字体信息. 关于Qfont 属性说明 family 字体家族. ⽐如 "楷体", "宋体", "微软雅⿊" 等. pointSiz…
阅读更多...
“面试通关秘籍：高频题目与算法整理”

“面试通关秘籍：高频题目与算法整理”

干货分享&#xff0c;感谢您的阅读&#xff01; &#xff08;暂存篇---后续会删除&#xff0c;完整版和持续更新见高频面试题基本总结回顾&#xff08;含笔试高频算法整理&#xff09;&#xff09; 备注&#xff1a;引用请标注出处&#xff0c;同时存在的问题请在相关博客留言…
阅读更多...
Postman断言

Postman断言

目录 概述 断言工作原理 常用断言方法 Status code: Code is 200 Status code: Successful POST request Status code: Code name has string Response body: Contains string Response body: JSON value check Response body: ls equal to a string Response headers…
阅读更多...
鸿萌数据恢复服务：SQL Server 中的 GAM、SGAM、IAM，及数据库损坏的修复方法

鸿萌数据恢复服务：SQL Server 中的 GAM、SGAM、IAM，及数据库损坏的修复方法

天津鸿萌科贸发展有限公司从事数据安全服务二十余年&#xff0c;致力于为各领域客户提供专业的数据恢复、数据备份、网络及终端数据安全等解决方案与服务。 同时&#xff0c;鸿萌是国际主流数据恢复软件(Stellar、UFS、R-Studio、ReclaiMe Pro 等)的授权代理商&#xff0c;为专…
阅读更多...
开源的数据库增量订阅和消费的中间件——Cancl

开源的数据库增量订阅和消费的中间件——Cancl

目录 工作原理 MySQL主备复制原理 Canal 工作原理 主要功能和特点 应用场景 实验准备 安装JDK11 下载MySQL8.0 配置canal.admin 配置canal-deployer 测试数据读取 新增一台主机用做被同步的目标机器测试 官方地址&#xff1a;https://github.com/alibaba/canal?ta…
阅读更多...
极狐 GitLab 依赖扫描：助力开发者管理软件供应链

极狐 GitLab 依赖扫描：助力开发者管理软件供应链

极狐GitLab 是 GitLab 在中国的发行版&#xff0c;专门面向中国程序员和企业提供企业级一体化 DevOps 平台&#xff0c;用来帮助用户实现需求管理、源代码托管、CI/CD、安全合规&#xff0c;而且所有的操作都是在一个平台上进行&#xff0c;省事省心省钱。可以一键安装极狐GitL…
阅读更多...
LeetCode.22。括号生成

LeetCode.22。括号生成

题目描述&#xff1a; 数字 n 代表生成括号的对数&#xff0c;请你设计一个函数&#xff0c;用于能够生成所有可能的并且 有效的 括号组 输入输出实例&#xff1a; 思路&#xff1a;对于这道题目我们可以用回溯法&#xff0c;创建一个函数backtrack(当前字符&#xff0c;左括…
阅读更多...
解锁 Starknet 的深层洞察：利用 Dune 构建动态数据可视化

解锁 Starknet 的深层洞察：利用 Dune 构建动态数据可视化

原文&#xff1a;https://dev.to/lordghostx/queries-to-insights-visualizing-starknet-data-with-dune-j8p 作者&#xff1a;LordGhostX 编译&#xff1a;TinTinLand Starknet 的链上数据为其区块链生态系统提供了丰富的洞察。它为用户活动、交易模式和网络交互提供了全面…
阅读更多...
【k8s从节点报错】error: You must be logged in to the server (Unauthorized)

【k8s从节点报错】error: You must be logged in to the server (Unauthorized)

k8s主节点可以获取nodes节点信息&#xff0c;但是从节点无法获取&#xff0c;且报错“error: You must be logged in to the server (Unauthorized)” 排查思路&#xff1a; 当时证书过期了&#xff0c;只处理的主节点的证书过期&#xff0c;没有处理从节点的 kubeadm alpha …
阅读更多...
ctfshow-web入门-sql注入（web221、web222、web223）limit 注入与 group 注入

ctfshow-web入门-sql注入（web221、web222、web223）limit 注入与 group 注入

目录 1、web221 2、web222 3、web223 1、web221 limit 注入 分页 sql 格式&#xff1a;select * from table limit (start-1)*pageSize,pageSize; 其中 start 是页码&#xff0c;pageSize 是每页显示的条数。 比如&#xff1a; 查询第1条到第10条的数据的sql是&#xff…
阅读更多...
倒计时启动！2024东北医院信息网络大会即将在这里举办！

倒计时启动！2024东北医院信息网络大会即将在这里举办！

随着全球医疗行业步入信息化转型的新时代&#xff0c;2024年8月24日至25日&#xff0c;以“科技赋能&#xff0c;重塑未来医疗”为主题的2024东北医院信息网络大会将在长春开曼宴都酒店&#xff08;长春市高新区海外街1号&#xff09;隆重举行。此次大会与国家卫健委、中医药管…
阅读更多...
Python青少年简明教程：输入输出

Python青少年简明教程：输入输出

Python青少年简明教程&#xff1a;输入输出 Python的输入输出是编程中的基本操作。Python的标准输入输出主要通过内置的input()函数和print()函数来实现。这两个函数使得从用户那里接收输入和向用户展示输出变得非常简单。 输入&#xff08;Input&#xff09;函数 input()函数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023