Newshot

打造有针对性的 MP4 模糊测试器

Translation(model translation, not the source's own text)

文章标题:Crafting Targeted MP4 Fuzzers

正文: 在这篇博客文章中,我将讨论围绕使用传统基于变异的策略对 MP4 容器格式进行模糊测试时所面临的一些挑战,我如何为 GStreamer 的 MP4 demuxer(即 qtdemux 元素)开发定向模糊测试器,以及我发现的漏洞。本文面向有兴趣为 MP4 格式、GStreamer 及其他类似目标开发更有效模糊测试技术的安全研究人员。

我最初开展这项研究的灵感来自 GitHub Security Lab 的博客文章 Uncovering GStreamer secrets,该文作者通过开发 MP4 语料生成器在 GStreamer 中发现了 29 个漏洞。虽然他们生成小型、结构有效的种子文件的策略是成功的,但并未尝试解决对该格式进行模糊测试的一个根本性难题,而这正是本文的主题。

背景

GStreamer 是一个被广泛使用的开源多媒体框架,其插件集支持数百种媒体格式。它由若干命令行工具和一个 C 库(以及面向许多其他语言的绑定)组成,使高级用户和开发者能够创建任意复杂的编码、解码和流媒体管线。

从对抗的角度来看,GStreamer 庞大且已有数十年历史的媒体处理代码是用内存不安全的语言编写的,是一片丰富的攻击面。因此,任何将不可信数据送入 GStreamer 管线的系统都是攻击者的有希望的目标。此类系统的著名例子包括 GNOME 桌面环境、WebKitGTK 浏览器引擎、webOS 智能电视操作系统,以及 Comcast 用于机顶盒开发的 RDK 平台——它们都使用 GStreamer 来处理来自潜在恶意远程源的媒体。

由于 MP4 是互联网上最常见的媒体容器格式,将我的工作范围限定在 GStreamer 的 isomp4 插件(默认包含在 Good 插件集中)是合乎逻辑的。

传统模糊测试的挑战

当面对对 MP4 这类二进制格式进行模糊测试的任务时,大多数研究人员会求助于覆盖率引导的变异型模糊测试器,例如 AFL++ 或 libFuzzer。这是一种好的直觉,通常也是正确的答案。然而,正如我们将在下文看到的,这些模糊测试器所使用的默认变异策略往往无法为 MP4 解析器实现深度覆盖。

MP4 文件可以表示为一棵 n 叉树,由携带不同类型数据和元数据的节点(在规范中称为 atom 或 box)组成。有些 atom 是子 atom 的父节点,而另一些则是仅包含自身负载的叶子节点。

Figure 1: Example MP4 Tree
Figure 1: Example MP4 Tree

要在二进制文件中实现这种结构,atom 按深度优先顺序排列,每个 atom 都有一个 4 字节的 size 字段,后跟一个 4 字节的 atom 标签。size 字段涵盖该 atom 的头部、数据以及所有后代。当模糊测试器通过在某个 atom 内插入或删除数据来变异文件时,除非修正被修改 atom 的 size 字段以及其每一个祖先的 size 字段,否则这棵树可能会变得无效。

Figure 2: Fuzzer Mutation Invalidates MP4 Structure
Figure 2: Fuzzer Mutation Invalidates MP4 Structure

因此,一个执行朴素插入和删除(即使基于覆盖率引导)的模糊测试器,很快会在检查文件结构完整性的早期验证代码上失败。例如,如果从 mdia atom 中删除了一个数据块,但顶层 moov atom 仍声称原始总大小,MP4 解析器可能会因为文件明显无效而拒绝整个文件。一段时间后,模糊测试器可能会达到一个平台期,很少能通过那些早期例程,更深层、更有趣的代码路径仍然未被触及。目标 atom 嵌套得越深,这个问题就越严重;随机、改变长度的变异被相关解析代码看到的概率随着 atom 的深度呈指数下降。

对抗这种低效的一种方法是结构感知模糊测试,在这种测试中,模糊测试器理解它正在处理的格式,并使用自定义变异器确保输入文件在馈送给被测系统之前至少大致结构有效(关于结构感知模糊测试的良好入门资料可以在这里找到)。开发一个对整个 MP4 格式建模的模糊测试器在技术上是可能的,但实现起来很复杂,而且很可能比只针对规范中狭窄、易出错的子集的模糊测试器慢得多。这样的模糊测试器还需要决定在众多格式不变量中哪些要强制执行,哪些要破坏。如果结构有效性太多,讽刺的是,模糊测试器可能会错过一些依赖于畸形输入的 bug。如果太少,它可能又会遇到原来的问题。

建立基线

在尝试开发结构感知模糊测试器之前,我首先想回答两个问题:isomp4 有多少已经被传统变异模糊测试器覆盖,以及是否还有任何容易摘到的果子?由于 GStreamer 由 OSS-Fuzz 服务持续进行模糊测试,我前往 OSS-Fuzz 的代码覆盖率报告来回答第一个问题。令我惊讶的是,之前(现在仍然)没有任何 MP4 覆盖率,因为 GStreamer 的模糊测试目标是在没有 Good 插件集(其中包括 isomp4)的情况下编译的。因此,我需要在本地构建一个模糊测试器,并手动启用那些插件,以便建立基线。

我决定使用通用的 gst-discoverer 模糊测试器,它调用 GStreamer API 来扫描(“发现”)媒体 URI,并使用适当的插件从中提取尽可能多的元数据。harness 的核心逻辑如下面的代码片段所示(注释是我自己加的)。libFuzzer 将单个变异输入(由 data 和 size 表示)传递给 LLVMFuzzerTestOneInput 函数。每个变异都是覆盖率引导的,但与格式无关;libFuzzer 和 harness 都没有对 MP4 结构的内置感知。然后 LLVMFuzzerTestOneInput 将输入原样发送给 GStreamer API 的 gst_discoverer_discover_uri 函数进行元数据发现。

图表:Figure 3: Stock Fuzzer’s Core Logic


        // Receives a mutated payload from libFuzzer
int
LLVMFuzzerTestOneInput (const guint8 * data, size_t size)
{
  // ...
  dc = gst_discoverer_new (timeout * GST_SECOND, &err);
  // ...
  // Set global payload variables. Passed to GStreamer API via appsrc_configuration
  fuzztesting_data = data;
  fuzztesting_size = size;

// Discover mutated payload with GStreamer API
  g_signal_connect (dc, "source-setup", (GCallback) appsrc_configuration, NULL);
  info = gst_discoverer_discover_uri (dc, "appsrc://", &err);
  g_clear_error (&err);
  if (info)
    gst_discoverer_info_unref (info);

g_object_unref (dc);

return 0;
}
      

文章标题:Crafting Targeted MP4 Fuzzers

正文: 在使用 -Dgood=enabled 构建 fuzzer(以启用 Good 插件集)之后,我在自己硬件(Ryzen 9 3950X,32GB RAM)上的虚拟机中运行了它大约 16-24 CPU 周。输入语料库既以我在各种在线语料库中找到的完整 MP4 文件作为种子,也以 GitHub Security Lab 的语料库生成器生成的最小文件作为种子。除了针对 isomp4 进行测试之外,这个 fuzzer 与在 OSS-Fuzz 上持续运行的那个在功能上没有差异。

尽管该 fuzzer 缺乏结构感知能力,这一轮仍然成功发现了下面列出的五个内存安全漏洞。前两个漏洞可能允许攻击者通过精心构造的 MP4 文件泄露堆内容,尤其是针对以非标准方式使用 GStreamer API 的应用程序。其余三个漏洞则可对 GStreamer 或任何使用其 API 解析 TMPlayer 或 SubRip 字幕文件的应用程序造成拒绝服务。

  • qtdemux_parse_tree 中的堆越界读取(CVE-2025-47183)
  • qtdemux_parse_trak 中的堆越界读取(CVE-2025-47219)
  • tmplayer_parse_line 中的空指针解引用(CVE-2025-47808)
  • subrip_unescape_formatting 中的空指针解引用(CVE-2025-47807)
  • parse_subrip_time 中的栈缓冲区溢出(CVE-2025-47806)

请注意,该 fuzzer 从未以字幕文件作为种子;它完全自行发现了 TMPlayer 和 SubRip 格式。这是覆盖率引导型 fuzzer 固有的一种现象,下一节将对此进行更详细的讨论。

基于管道的 fuzzing

第一个 fuzzer 在两种它从未被作为种子输入的文件类型中发现了漏洞,原因是 libFuzzer 随着时间推移对 TMPlayer 和 SubRip 格式进行随机变异,并受到覆盖率反馈的鼓励——反馈告诉它这些是需要探索的新代码路径。对于任何支持多种格式的目标,这种漂移在结构不感知、覆盖率引导的 fuzzing 中都很常见,但它是否可取取决于研究者的目标。对于这个项目,我更感兴趣的是 MP4 覆盖的深度而非格式的广度,因此在其他文件类型中发现 bug 是一个反目标。

防止格式漂移的一种方法是在编译时禁用除 isomp4 之外所有插件的支持。然而,为了保持构建系统能与其他 fuzz 目标兼容,同时不必为每个目标维护不同的选项,我转而利用了 GStreamer 的管道特性。管道允许用户指定应该为解复用、解码和播放等操作而链接的确切元素序列。通过定义一个仅以 qtdemux 作为解复用器的管道,就可以构造一个 fuzz 目标,使其变异在运行时收敛于 MP4 格式。这样做之所以有效,是因为管道在解复用非 MP4 输入时会提前失败,因此 libFuzzer 看不到新的代码路径,也就不会认为那些输入值得进一步变异。

Figure 4: GStreamer Pipeline Architecture
Figure 4: GStreamer Pipeline Architecture

为实现这一点,我编写了一个 LLVMFuzzerTestOneInput 函数,将测试用例传递给定义为 appsrc name=src ! qtdemux ! fakesink 的管道,如下所示。fakesink 元素是一个哑 sink,它会丢弃其输入,是完成管道所必需的。

图表:Figure 5: Pipeline-Based MP4 Fuzzer


        int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    // ...
    fuzz_decode_mp4(data, size);
    return 0;
}

int fuzz_decode_mp4(const uint8_t *data, size_t size)
{
    GstElement *pipeline = gst_parse_launch(
        "appsrc name=src ! qtdemux ! fakesink",
        NULL);
    if (!pipeline)
        return 0;

GstElement *src = gst_bin_get_by_name(GST_BIN(pipeline), "src");

GstBuffer *buf = gst_buffer_new();
    GstMemory *mem =
        gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY,
                               (gpointer)data,
                               size,
                               0,
                               size,
                               NULL,
                               NULL);
    gst_buffer_append_memory(buf, mem);

gst_element_set_state(pipeline, GST_STATE_PLAYING);

GstFlowReturn flow;
    g_signal_emit_by_name(src, "push-buffer", buf, &flow);
    gst_buffer_unref(buf);

g_signal_emit_by_name(src, "end-of-stream", &flow);
    // ...
    return 0;
}
      

这个基于 pipeline 的 fuzzer 比自带的那个更快,并且发现了后者漏掉的一个 bug:通过一个带有精心构造的 PlayReady DRM 元数据的 MP4 文件,在 qtdemux_parse_uuid 函数中触发堆越界读取(CVE-2026-46471)。攻击者可以利用这个漏洞绕过地址空间布局随机化(ASLR),或泄露此前由 GStreamer 支撑的进程加载过的文件内容(参见 Atredis 的公告)。

结构感知 fuzzing

在研究了传统 fuzzing 能做到什么之后,我开始构思一个结构感知的 MP4 fuzzer。为了避开对整个 MP4 格式建模所涉及的复杂性,我聚焦于规范中一个虽小但有价值的子集:sample description(stsd)atom。这个深度嵌套的 atom 富含可变大小的 sample 解码元数据,这些元数据包含在若干子 atom 中,而它们在技术上是一个名为 sample description table 的字段的条目。

Figure 6: stsd 祖先树
Figure 6: stsd 祖先树
Figure 7: stsd Atom 布局
Figure 7: stsd Atom 布局

在 GStreamer 内部,stsd 由 qtdemux_parse_trak 函数处理,该函数遍历 sample description table 的条目,并用内联代码和辅助函数的混合方式解析每一个条目。这段代码往往依赖手工指针运算和临时性的边界检查,因此很可能是漏洞的来源。此外,我在运行此前的 fuzzing 活动后生成的覆盖率报告显示,这段代码中大片有趣区域从未被命中。例如,下面这段解析视频 sample description 一部分的代码,在长时间运行自带 fuzzer 后仍然没有覆盖率。

Figure 8: 未被覆盖的 stsd 解析代码示例
Figure 8: 未被覆盖的 stsd 解析代码示例

因此,一个理解 stsd 如何嵌入更大的 MP4 文件、并注意保留其周围结构的 fuzzer,可能有助于在这段代码中发现 bug。

作为概念验证,我开发了一个部分结构感知的 fuzzer,设计如下:它不像自带 fuzzer 那样变异整个 MP4 文件再传给 GStreamer,而是只变异 stsd。然后它会把变异后的数据随机拼接进两个静态模板 MP4 文件之一(视频轨或音频轨),这些模板包含 stsd 的完整祖先树,并相应地更新祖先的 size 字段。这样一来,传给 qtdemux 的每个 MP4 文件的整体结构都保证有效,而只有目标 atom 被 fuzz。我的假设是,这会提高上面这类代码段的覆盖率。

Figure 9: 结构感知 stsd Fuzzer 概览
Figure 9: 结构感知 stsd Fuzzer 概览

这个 fuzzer 的基本实现如下所示。在接收输入(一个变异后的 stsd atom)并做最小限度校验后,LLVMFuzzerTestOneInput 函数会调用 fix_outer_structure_and_fuzz 辅助函数,根据变异后 atom 的大小与它在模板中原始大小的差值来调整祖先树。

图表:Figure 10: 结构感知 stsd Fuzzer 的 LLVMFuzzerTestOneInput 函数

文章标题:Crafting Targeted MP4 Fuzzers

正文:


        int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    // ...
    if (size < MIN_DATA_SIZE)
    {
        // Input too small to hold stsd header and metadata; tell libFuzzer to reject it
        return -1;
    }
    // Update ancestors' sizes to match new stsd atom
    fix_outer_structure_and_fuzz(data, size);
    return 0;
}
      

图表:Figure 11: fix_outer_structure_and_fuzz Helper


        static void fix_outer_structure_and_fuzz(const uint8_t *data, size_t size)
{
    uint8_t trak_type = data[0];
    uint8_t *stsd_data = data + 1;
    size_t stsd_size = size - 1;

if (trak_type >= sizeof(TRAK_TYPES))
    {
        fprintf(stderr, "unexpected trak type %d\n", trak_type);
        exit(1);
    }

int diff = 0;
    // Update parent box sizes to match new stsd atom
    switch (trak_type)
    {
    case 0:
        diff = stsd_size - TRAK_1_ORIG_STSD_SIZE;
        write_uint32_be(TRAK_1_BEFORE_DATA + MOOV_OFFSET, TRAK_1_ORIG_MOOV_SIZE + diff);
        write_uint32_be(TRAK_1_BEFORE_DATA + TRAK_1_TRAK_OFFSET, TRAK_1_ORIG_TRAK_SIZE + diff);
        write_uint32_be(TRAK_1_BEFORE_DATA + TRAK_1_MDIA_OFFSET, TRAK_1_ORIG_MDIA_SIZE + diff);
        write_uint32_be(TRAK_1_BEFORE_DATA + TRAK_1_MINF_OFFSET, TRAK_1_ORIG_MINF_SIZE + diff);
        write_uint32_be(TRAK_1_BEFORE_DATA + TRAK_1_STBL_OFFSET, TRAK_1_ORIG_STBL_SIZE + diff);

fuzz_decode_mp4(TRAK_1_BEFORE_DATA, sizeof(TRAK_1_BEFORE_DATA),
                        TRAK_1_AFTER_DATA, sizeof(TRAK_1_AFTER_DATA),
                        stsd_data, stsd_size);
        break;

// ... Handle other track types ...
    }
}
      

fix_outer_structure_and_fuzz 将更新后的祖先树、变异后的 atom 以及尾部模板数据传给 fuzz_decode_mp4 辅助函数,该函数将这些片段封装进一个 GstBuffer 对象,构成完整的 MP4 容器。随后它把该 buffer 推送到一个定义为 appsrc name=src ! qtdemux ! decodebin ! fakesink sync=false 的 qtdemux 管线中。

图表:Figure 12: fuzz_decode_mp4 Helper


        int fuzz_decode_mp4(uint8_t *head, size_t head_size, uint8_t *tail, size_t tail_size, const uint8_t *data, size_t size)
{
    GstElement *pipeline = gst_parse_launch(
        "appsrc name=src ! qtdemux ! decodebin ! fakesink sync=false",
        NULL);
    if (!pipeline)
    {
        fprintf(stderr, "error creating pipeline");
        exit(1);
    }

GstElement *src = gst_bin_get_by_name(GST_BIN(pipeline), "src");

GstBuffer *buf = gst_buffer_new();
    GstMemory *mem_head =
        gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY,
                               head,
                               head_size,
                               0,
                               head_size,
                               NULL,
                               NULL);
    gst_buffer_append_memory(buf, mem_head);

GstMemory *mem_middle =
        gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY,
                               data,
                               size,
                               0,
                               size,
                               NULL,
                               NULL);
    gst_buffer_append_memory(buf, mem_middle);

GstMemory *mem_tail =
        gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY,
                               tail,
                               tail_size,
                               0,
                               tail_size,
                               NULL,
                               NULL);
    gst_buffer_append_memory(buf, mem_tail);

GST_BUFFER_OFFSET(buf) = 0;
    GST_BUFFER_OFFSET_END(buf) = head_size + size;

g_object_set(G_OBJECT(src), "size", head_size + size, NULL);
    gst_element_set_state(pipeline, GST_STATE_PLAYING);

GstFlowReturn flow;
    g_signal_emit_by_name(src, "push-buffer", buf, &flow);
    gst_buffer_unref(buf);

g_signal_emit_by_name(src, "end-of-stream", &flow);

// ... Cleanup ...
    return 0;
}
      

文章标题:Crafting Targeted MP4 Fuzzers

正文: 虽然基本概念本身可行,但总是对 stsd 内的所有内容进行变异在某种程度上适得其反。因为目标是结构感知,像 atom 类型(label)、大小和条目计数这样的字段应该至少在一定比例的时间内保持正确,否则我们会在 stsd 层面重新遇到上图中第三步所解决的问题。另一个极端是,100% 保持头部有效可能会让我们错过源于大小或条目计数字段与载荷内容(sample description table)之间不一致的 bug。

我们可以折中,添加一个 libFuzzer 自定义变异器,在 50% 的情况下修复 atom 的 size 和 entry count 字段(这个比例是任意选的;可能存在更优值):


        size_t LLVMFuzzerCustomMutator(uint8_t *Data, size_t Size, size_t MaxSize, unsigned int Seed)
{
    size_t mutated_size = LLVMFuzzerMutate(Data, Size, MaxSize);
    if (mutated_size < MIN_DATA_SIZE)
    {
        mutated_size = MIN_DATA_SIZE;
    }

uint8_t new_trak_type = rand() % 2;
    Data[0] = new_trak_type;

uint8_t *stsd_data = Data + 1;

// Restore type field in case it was mutated
    stsd_data[4] = 's';
    stsd_data[5] = 't';
    stsd_data[6] = 's';
    stsd_data[7] = 'd';

int should_fix_stsd = ((rand() % 2) == 0);
    if (should_fix_stsd)
    {
        size_t stsd_size = mutated_size - 1;
        // Update stsd size field
        write_uint32_be(stsd_data, stsd_size);

size_t stsd_entry_count = read_uint32_be(stsd_data + 12);
        if (stsd_entry_count == 0 || stsd_entry_count > (stsd_size / 8))
        {
            write_uint32_be(stsd_data + 12, (rand() % (stsd_size / 16)) + 1);
        }
    }

return mutated_size;
}
      

这个 fuzzer 不是以完整的 MP4 文件作为种子,而是以多样采样的 stsd atom 作为种子,这些是我从早期运行的语料库中提取的。所有崩溃文件和其他 libFuzzer 产物也都是 stsd atom,无法直接在 GStreamer 下复现;它们必须先拼接回正确的模板,或者作为位置参数传递给 fuzzer 二进制(它会自动完成拼接)。

这个 fuzzer 最终产生了三个新 bug:两个除零漏洞,可通过精心构造的音轨导致拒绝服务(CVE-2026-46469 和 CVE-2026-46470),以及一个可利用性不明确的全局缓冲区越界读取(CVE-2026-46472)。正如假设的那样,使用此 harness 进行长时间测试活动后生成的覆盖率报告显示,qtdemux_parse_trak 的覆盖率大幅增加,特别是在负责处理 stsd 的部分。

披露与修复

在我验证并对累积的崩溃进行根因分析后,我按照项目的披露政策将它们报告给了 GStreamer 开发者。这一过程包括在 https://gitlab.freedesktop.org 上创建账户,并在 GStreamer/gstreamer 仓库下提交一个机密 GitLab issue。

第一批漏洞是在常规 fuzzer 测试活动中发现的,已于 2025 年 5 月 29 日在 1.26.2 版本中修复。基于流水线的 fuzzer 发现的单个问题已于 2026 年 2 月 26 日在 1.28.1 版本中修复。最后,结构感知 fuzzer 提出的三个 bug 已于 2026 年 4 月 7 日在 1.28.2 版本中修复。除了这些点版本发布外,GStreamer 还发布了补丁文件,允许最终用户手动将修复纳入旧版本软件中。有关披露和修复时间线的更多细节,请参见 Atredis 的公告。

我想强调 GStreamer 无摩擦的披露流程以及维护者对我的报告的快速响应。开发者在 24 小时内确认了我的每一次提交,内部修复提交有时甚至更快。这种响应速度在供应商中很少见,我赞扬 GStreamer 团队对安全问题的关注。

局限性与未来工作

文章标题:Crafting Targeted MP4 Fuzzers

正文: 这篇博文已经表明,即使在使用与格式无关的方法进行了长时间模糊测试之后,仍然可以通过部分结构感知的 fuzzer 从处理 MP4 的目标中提取更多的代码覆盖率和漏洞。然而,我构建的 fuzzer 存在若干设计局限,该领域未来的研究应当加以解决。这些局限包括(但不限于)以下内容:

  • 单 atom 聚焦:该 fuzzer 只对 stsd 进行变异,对其他所有 atom 保持不变。stsd 并不是唯一复杂的 atom,它与 MP4 文件格式其他片段中的数据之间的交互,可能会发现本工作尚未探索到的代码路径。一个能够对格式中更大子集进行建模、并变异不同 atom 组合(同时保持整体文件结构有效)的 fuzzer,将搜索指数级更大的输入空间,并很可能覆盖更多代码。
  • 静态模板:虽然将 stsd 拼接进一对固定不变的 MP4 模板简化了 fuzzer 的开发,但它也很可能阻断了依赖于 stsd 祖先 atom 所设状态的代码路径。一种在多种模板之间轮换、并向被变异 atom 的祖先注入随机性的方法非常值得探索。
  • 有限的 track 子集:该 fuzzer 只在两种 MP4 track 类型内变异 stsd:vide(视频)和 soun(音频)。将 fuzzer 扩展到支持 isomp4 所识别的全部 track 类型并不困难,并且如果同时支持不同的 atom 类型,可能会产生多得多的 bug。
  • 仅聚焦 demux:如引言所述,本研究孤立地聚焦于 GStreamer 的 MP4 demuxer。编解码器解析、解码、编码以及完整 MP4 流水线的其他环节不在范围内,但预期它们同样会包含漏洞。未来的工作应当尝试将结构变异后的输入传递给不同的流水线配置,以覆盖 GStreamer 更广泛的 MP4 功能。

此外,本研究是在 2025 年 1 月至 2026 年 1 月之间的数周内进行的,恰在 AI agent harness 被广泛用于安全研究之前。因此,所有的开发、测试、调试、模糊测试和 bug 分类都是在没有 LLM 帮助的情况下完成的。过去一年里,这一领域已发生显著变化。前沿模型如今不仅能够快速实现并迭代自定义 fuzzer,还能仅通过阅读就在复杂代码库中发现细微的漏洞。我强烈建议任何接手这项工作的人借助一个 AI agent,让它同时尝试静态和动态两种方法。

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Lobsters
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗