⚡Megatron LLM Hub
All digests
Website

rss-website

Top3

漏洞挖掘从个案走向流水线,首次给出可量化的成本与产出比。

A thousand fewer paths to root | OpenAI November 4, 2026 Security Publication A thousand fewer paths to root We've developed an autonomous vulnerability discovery, exploitation, and patching pipeline. In one run with our cyber model, it validated and generated patches for 948 local privilege escalation vulnerabilities in Linux at an API cost of $1.2 million. Share Security research that once required a separate, sustained investigation for each finding can increasingly be run as a systematic process. This document explores one of our efforts in this area. Vulnerability discovery is becoming easier to scale, but prioritization and validation remain operational bottlenecks. We built a prototype to look for security flaws in the Linux kernel inside a controlled research environment. Our prototype identified and analyzed 2,308 candidate Linux kernel findings, dynamically reproduced 1,724 vulnerabilities, and produced 948 local privilege escalation (LPE) exploits that could allow an unprivileged local user to gain root access. We used this evidence to prioritize vulnerabilities for reporting and developed candidate patches for maintainer review. Following guidance from the Linux kernel community, we began with critical vulnerabilities and are working with Patch the Planet partners on further reports and patches. In June, as part of our Patch the Planet initiative , we shared that GPT‑5.5 Cyber had identified Linux kernel vulnerabilities and developed 24 local privilege escalation exploits to validate and report them. We expanded that work into a pipeline, powered by an upcoming cyber model, covering vulnerability discovery, dynamic validation, exploitability assessment, and patch generation. When it finished, human researchers reviewed the outputs and reported found vulnerabilities alongside patches. Summary Methodology At a high level, our pipeline works as follows: first it identifies security-relevant parts of the Linux kernel, statically scans those audit targets for candidate findings, dynamically reproduces those findings in an isolated environment, creates a proof-of-concept (PoC) exploit to demonstrate exploitability, generates patches, and finally a human security researcher reviews the results. The output of the pipeline includes a root cause analysis, a minimal crashing proof-of-concept, a candidate patch, and a full exploit to assist human researchers in assessing the severity of the vulnerability and upstreaming the fixes. Findings In a run in mid-October 2026, our pipeline using an upcoming cyber model dynamically reproduced 1,724 vulnerabilities and generated PoCs for 291 information leak vulnerabilities and 948 working local privilege escalation (LPE) exploits for a commonly used Linux distribution. The total run cost $1,213,430 in API credits, or $1,279 per LPE exploit. The target virtual machines ran a stock desktop operating system, not a weakened target, under the same threat model used by cybersecurity competitions (e.g. Pwn2Own ⁠ (opens in a new window) , TyphoonPWN ⁠ (opens in a new window) ). Historically, Pwn2Own and TyphoonPWN offered a $20,000 and $70,000 bug bounty for Linux kernel LPE exploits. Applying those historical bounty amounts to the 948 exploits produces a hypothetical valuation of $18.9M—$66.3M , approximately 16x to 55x our pipeline’s cost. On an adapted kernelCTF ⁠ (opens in a new window) environment, which is a version of the Linux kernel with reduced attack surface, our pipeline obtained 25 information leak PoCs and 21 LPE exploits . For comparison, 26 confirmed 0-day LPE exploits have been accepted by kernelCTF in 2026 at the time of writing. The campaign cost roughly $32,936 in API credits. If the 21 vulnerabilities were accepted by the program, it would lead to around a $1.5M bounty award , ~45x the scanning cost. To the best of our knowledge, the agents in this pipeline discovered and used at least 10 novel Linux exploitation techniques. Reflections The Linux maintainers and security community are working hard to rapidly discover and fix vulnerabilities. Within 10 days while the scan was running, we observed over 100 Linux LPEs had been patched or had staging patches from other contributors, with ~300 more being publicly discussed. Given the rate of vulnerability discovery by frontier models, we believe automated patch generation is essential to secure software at the pace required, and to limit the exploitation window. With human expert-guided iteration, we believe AI-generated patches can be functionally correct, aligned with existing coding styles, and robust to attack variants. This is an important area for further research. More capable models are able to discover new vulnerabilities in existing code, often including ones that have been around longer and are more complex to identify. Our analysis pipeline using the newer cyber model in mid-October discovered >5x more novel LPEs than a GPT‑5.6 Sol run in July, despite three months of hardening between the scans. Large, complex software projects likely require multiple rounds of scanning and fixing vulnerabilities to “bottom out” latent bugs. Ideally this process is repeated with each subsequent generation of frontier models. This applies to both proprietary and open source software. For the near and medium term, having access to a low-privileged account on an operating system, that isn’t up-to-date on its latest available patches should be considered functionally equivalent to root access for a well-resourced threat actor. Defense in depth, using sandboxes and isolation approaches like Firecracker and gVisor are important for limiting the blast radius of exploited vulnerabilities. Within the next few years, we believe that if there are vulnerabilities in a given software project, frontier models will likely be able to discover them and even less capable models may be able to develop exploits once disclosed. In a world of no unknown vulnerabilities, it will be critical to build and maintain high assurance software, especially core software such as operating systems, browsers, image parsing libraries, the TCP/IP stack, and more. Investing in training models to write secure code by default, minimizing attack surface by removing unnecessary features, and formal verification are promising areas of future research to effectively scale software security, in addition to finding and fixing existing vulnerabilities. Why the Linux kernel The Linux kernel underpins Android devices, cloud infrastructure, supercomputers, and other systems used by billions of people. With more than 40 million lines of code, the kernel exposes a broad attack surface through system calls, networking, filesystems, and device drivers. We chose Linux to study how effectively frontier models could find vulnerabilities and demonstrate their security impact in a codebase of this scale and importance. The initial vulnerability discovery stage produced thousands of candidate findings, too many for security researchers to manually review and triage. The operational challenge of our vulnerability discovery pipeline was not discovery, but determining which findings could be reproduced, what security boundary they crossed, and which warranted the earliest maintainer attention. Cost analysis The mission of OpenAI’s Cyber team is to help secure the software the world relies on. We report API costs for each stage to help researchers assess the resources needed to reproduce and extend this work. These costs reflect the models, target configurations, and workflow used in this evaluation. Our broader goal is to help defenders find and fix vulnerabilities, reducing the opportunities available to attackers and raising the cost for them to exploit software. Finally, note that we focused on methodology and measuring model capability in this research, not cost. We expect that sufficient harness engineering could meaningfully reduce the cost at each stage; thus, the costs we report are more an upper bound. The vulnerability research pipeline Our vulnerability research prototype is a pipeline of five stages, which uses an upcoming cyber model at its core: Vulnerability discovery: Agents identify security-relevant parts of the codebase and scan them for candidate findings. Dynamic validation: Agents attempt to reproduce each candidate in an isolated environment and preserve runtime evidence. This step outputs the reproduced and validated vulnerabilities. Exploitability assessment: Agents test whether validated vulnerabilities could enable information disclosure or local privilege escalation. Patch generation : Agents generate patches that address each identified vulnerability. Human review : Security researchers review the exploit, patch, and proposed severity before reporting to the maintainers. At the end of the pipeline, the system bundles a root cause analysis, a minimal crashing proof-of-concept, a candidate patch, and a full exploit to assist human researchers in assessing the severity of the vulnerability and upstreaming the fixes. Vulnerability discovery Not every line of code in the Linux kernel is security-relevant. Our pipeline used a team of Scout agents to identify high-value audit targets, which were then passed to Analyst agents for vulnerability scanning. Scout agents Scout agents read through each folder and file and determine what targets to audit based on their reachability (reachable by low-privileged users) and security relevance. This stage identified 5,034 audit targets, about 2.8 million lines of code, which is roughly 7% of the whole Linux kernel code base, significantly reducing the cost of the security audit when compared to a full codebase analysis. This step cost $3,426 in API credits. Animation showing scout agents exploring Linux kernel code areas and audit targets. 00:00 Analyst agents Next, analyst agents analyzed each audit target and produced candidate findings using a workflow similar to that of the Codex Security plugin ⁠ (opens in a new window) . At a high level, the analyst agents read the assigned audit target’s code to understand how it works, identify its threat model, and look for vulnerabilities in it. Within 12 hours, the analyst agents produced 2,308 candidate findings after deduplication. This stage cost $316,549 in API credits. Vulnerability validation A candidate finding is not the same as a validated vulnerability. At this scale, manually investigating every report is impractical for our research team. We therefore focused on validating findings that a) were reachable by a low-privileged user, b) required no special capabilities, and c) produced measurable evidence of memory corruption. For each candidate, a triage agent generated a proof of concept and ran it in an isolated virtual machine running a Linux kernel with Kernel Address Sanitizer (KASAN). The agent observed both the program output and system console, then iteratively refined the proof of concept until it reproduced the reported behavior or exhausted the potential ways of triggering it. Within 30 hours, our system reproduced 1724 vulnerabilities, ~74.7% of the 2,308 candidate findings. Static code review alone can be prone to false positives, so we were impressed by the accuracy of the analyst agents and the effectiveness of the triage agents in autonomously creating working proofs of concept for almost three quarters of the candidate findings. Most remaining findings either required elevated privileges or failed to reproduce within the time budget because of difficult race conditions, specific trigger conditions (e.g., a required allocation failure at a specific line), or time-consuming validation (e.g., refcount wraparound). Only 3.1% reflected incorrect analysis by the model, where the reported vulnerability assumed an impossible condition. The validation stage cost $73,330 in API credits in total. We observed that in our validation pipeline, which needed to generate a proof-of-concept to confirm if a candidate is a real vulnerability, this process was more expensive than making a recommendation based only on static analysis, and the costs of attempting to validate a true positive and false positive were similar. Thus removing false positives earlier in the pipeline makes the process meaningfully more cost-efficient. Exploitability assessment Validation establishes that a vulnerability is real, but not how urgently it should be addressed. A vulnerability that could enable local privilege escalation, for example, warrants greater priority than one that could only cause a local denial of service. With 1,724 validated vulnerabilities, the next task was to identify the findings with the greatest potential security impact. An initial screening agent reviewed each report, crash log, and relevant source code statically. It was deliberately permissive to avoid discarding potentially serious findings, while filtering out cases without a plausible exploitation path. This narrowed the results to 313 information leak candidates and 1,238 local privilege escalation candidates. Exploit-development (ExploitDev) agents then tested those candidates in isolated virtual machines configured with the protections enabled by a standard Linux distribution, including Supervisor Mode Execution Prevention (SMEP), Supervisor Mode Access Prevention (SMAP), Kernel Address Space Layout Randomization (KASLR), and HARDENED_USERCOPY. This helped prevent unrealistic assessments that depended on protections being disabled. The agents produced 291 proofs of concept for information leaks and 1,169 working local privilege escalation exploits that could give unprivileged local users root access. We performed variant analysis and developed 948 distinct patches for the vulnerabilities behind those exploits. We use that number to determine the overall number of unique LPEs. Successful exploits cost an average of $359 in credits to develop. That makes it relatively inexpensive for defenders to test the exploitability of found vulnerabilities. The initial vulnerability screening agent cost $44,194 in API credits. The exploitation stage cost $775,929 in API credits in total, $84,929 for processing information leak candidates and $691,000 for local privilege escalation candidates. On average, processing a local-privilege escalation candidate ($558) was roughly two times more expensive than processing an information leak candidate ($271). This is because information leak PoCs were carried forward from the validation stage and required less modification to become usable in an exploit. On the other hand, developing an exploit from an LPE candidate required many extra steps such as exploitation strategy planning, identifying vulnerable objects to use, mitigation bypasses and more. We also noticed that unsuccessful exploitation attempts ($3,922 for 69 cases) cost much more than successful ones ($360 for 1169 cases). This was caused by a few hard-to-exploit vulnerabilities (e.g. race conditions). Defining a reasonable give-up condition, such as stopping the attempt after making no progress for one hour, would have reduced the cost of ExploitDev significantly. Patch generation For each validated vulnerability, the system also generates a patch. We provide the model with the relevant source code and prompt it with best practices in patch writing, such as performing static checks on the patch, following the software development practices used in nearby code, and performing variant analysis to make sure the patch is complete. Following the Linux kernel community’s suggestion, we have already sent out hundreds of reports and patches for critical vulnerabilities and are working with Patch the Planet partners to gradually send out patches for the rest. This work is part of our broader Daybreak commitment to support open-source projects. Findings In this section we share learnings, reflections, and additional analysis from this research. Maintainers are moving quickly to patch vulnerabilities During this research, we observed the Linux maintainers moving quickly to fix vulnerabilities and protect users. The scan was performed on the latest Linux kernel in mid-October 2026. When the autonomous scan and manual analysis finished after 10 days, 61 LPEs had already been patched upstream, 43 had staging patches, and 299 were being reported and discussed publicly. We greatly appreciate the Linux maintainers who have been working urgently to patch identified issues, and the broader security community contributing their findings as well. This collective response is what’s needed to secure the world’s software. The rapid rate of vulnerability disclosure and patching also emphasizes the criticality for users and companies to keep software up to date. Takeaway : Automated triage should take the rapid patching cycle into account. Revalidating findings against the latest code, including new code that was merged after the original scan, helps avoid duplicate or obsolete reports. This focuses attention on unresolved vulnerabilities and gives maintainers evidence that they can act on without adding unnecessary review burden. Stronger models find more vulnerabilities While we were developing the pipeline, in late July 2026, GPT‑5.6 Sol found and exploited 166 unique LPE vulnerabilities for an end-to-end $513,690 cost in API credits. In the second scan, in mid-October 2026, the newer cyber model found and exploited 948 unique LPE vulnerabilities for an end-to-end $1,213,430 cost in API credits. For both campaigns, we scanned the latest Linux kernel master branch at the time. Takeaway : Rescan previously audited code as model capabilities improve. A more capable model may uncover vulnerabilities that earlier models missed, even when using the same research harness. Novel exploitation techniques We sampled 166 exploits developed by the agents and analyzed the exploitation techniques used in them. To the best of our knowledge, the agents used 10 new exploitation techniques in the sampled exploits. We shared the exploitation techniques with third-party kernel exploitation experts and the techniques were new to them as well. Of the 10 techniques, two are new persistent elastic objects that the model used to spray objects inside the target kernel cache; two are new page grooming techniques to improve exploit reliability; five are new data-only techniques to obtain privilege escalation directly or via an arbitrary write; the other technique involves arbitrary type confusion. For safety reasons, we omit sharing the full technical details of these new exploitation techniques in this post. Takeaway : Frontier models do not just pattern match known vulnerable code patterns or solely use known exploitation techniques; they demonstrate creativity and novel approaches. What defenders can learn from exploit costs An important part of our team’s mission is to measure the cost of finding and exploiting vulnerabilities and use that evidence to guide defensive investment. Our goal is to help defenders fix vulnerabilities before attackers can use them, and make it cost prohibitive for attackers to exploit software. Measuring exploitation costs helps us assess how that challenge changes as model capabilities improve. In this section, we compare our pipeline run’s cost with bug bounty program rewards for the vulnerabilities identified. The target virtual machines in our experiment ran a stock desktop operating system, not a weakened target, under the same threat model that is used by cybersecurity competitions (e.g. Pwn2Own ⁠ (opens in a new window) , TyphoonPWN ⁠ (opens in a new window) ). Historically, Pwn2Own and TyphoonPWN offered bug bounties of $20,000 and $70,000, respectively for Linux kernel local privilege escalation exploits. Applying those historical bounty amounts to the 948 exploits produces a hypothetical valuation of $18.9M—$66.3M, approximately 16x to 55x our pipeline’s cost. We also tested our pipeline against Google’s kernelCTF ⁠ (opens in a new window) vulnerability reward program, which features a hardened Linux kernel with reduced attack surfaces as the target. We ran the pipeline on the latest version of the Linux kernel (incompatible with the SLAB_VIRTUAL mitigation in kernelCTF so we dropped it from the config) under kernelCTF’s environment and obtained 25 information leak proofs of concept and 21 local privilege escalation exploits. For comparison, 26 confirmed 0-day LPE exploits have been accepted by kernelCTF in 2026 at the time of writing. The whole campaign lasted 112 hours in total, costing roughly $32,936 in API credits, with vulnerability discovery accounting for 83.7% of the API cost. If the 21 vulnerabilities were accepted by the program, it would lead to around a $1.5M bounty award, approximately 45x the cost. Takeaway: Based on public pay-out amounts, with current cyber-capable models, our vulnerability research pipeline was net profitable at the time of this research. Defenders should proactively analyze their software so that it becomes cost prohibitive for attackers to exploit. Using the wrong 0-day During exploitability assessment, ExploitDev agents were given a vulnerability report and tasked with creating a fully functional exploit. Our pipeline marked a vulnerability as exploited if a root shell was successfully obtained. During an early run, the exploitation stage reported 200 successful local privilege escalation exploits. However, after human review, we found that 20 of these had achieved root privileges through a different 0-day vulnerability than the one assigned. This suggests that even successful exploitation by agents needs proper validation. We subsequently tightened the task constraints and added an independent check confirming that each final exploit used its assigned vulnerability. Takeaway : For autonomous security research, verify the path to a result in addition to verifying the result itself; isolation, monitoring, and independent checks are necessary controls. More capable models can require lighter orchestration Early in this research, we explored the design decision of whether to build heavy orchestration around the agent to improve its cyber capability. Our result suggested that stronger models require lighter orchestration and hand-holding. And the marginal improvement does not justify the maintenance cost. As a result, we decided to remove the heavy orchestration. The experiment compared GPT‑5.5 Cyber and GPT‑5.6 Cyber. In our observation, GPT‑5.5 Cyber did not consistently identify when and how to apply existing Linux kernel exploitation techniques. We then assembled 103 techniques in a model-friendly format, made them available in the agent’s environment, and prompted the agent to use them. Across 63 exploitation candidates, this increased the success rate from 76.2% to 88.9%. When we repeated this with GPT‑5.6 Cyber, the model was better able to find, select, and apply relevant techniques on its own. We removed the technique/skill orchestration and this lightly orchestrated GPT‑5.6 Cyber workflow outperformed the more heavily scaffolded GPT‑5.5 Cyber workflow. Adding back the additional technique layer for GPT‑5.6 Cyber provided only a marginal 1.5 percentage-point improvement. Takeaway : Reevaluate your orchestration and harness as base model capabilities change. Scaffolding that materially improves one model generation may add little value for a stronger model and should be evaluated for the maintenance tradeoff. Iteration improves patch generation Initially, w hen directly prompted to generate candidate patches, the model would create functionally correct patches that mitigate the proof of concept but occasionally introduce other issues: more code than necessary, introduced potential performance tradeoffs, deviated from coding conventions, or failed to examine related code for variants of the same vulnerability, leading to incomplete patches. Additional instructions and iterations on the patch generation process improved the quality of patches, which suggests that with proper handling, it is possible for AI-generated security patches to be correct, minimal, and consistent with existing code conventions. This is an active area of research, and we believe this will become easier and more effective with future models. In a few cases, our research prototype was also able to identify issues in patches written by human experts, which were then fixed before they were merged. Takeaway : Models can speed up the patching process, but patching skills and harnesses may require iteration to ensure the patches reliably fulfill both functional and nonfunctional requirements. Additionally, we recommend using models for adversarial review of human and AI-generated patches, which can identify issues such as the patch being bypassable, missing other attack paths or variants, and more. Vulnerabilities in testing infrastructure In our kernelCTF run, besides the 21 Linux kernel 0-day exploits, our research prototype also found and exploited a QEMU TCG vulnerability. The analyst agent was assigned to analyze the system call entry code, and when writing programs to experiment with privilege transitions, it encountered an unexpected kernel crash. It triaged the crash and traced the issue to QEMU TCG, without access to QEMU’s source code, and included the vulnerability in the report. The ExploitDev agent successfully developed a local privilege escalation exploit for this vulnerability subsequently. We discovered this QEMU vulnerability when analyzing the exploits manually and confirmed that the vulnerability had been fixed in upstream QEMU but not in the release build used during the experiment. Takeaway : Frontier cyber-capable models can find vulnerabilities in testing infrastructure. We recommend testing each part of the infrastructure before carrying out offensive vulnerability research. We have proactively tested our infrastructure , disclosing and patching many vulnerabilities in Kata, Moby/Docker, gVisor, and other projects. Conclusion Our goal is to turn increasing model capability into a lasting advantage for the people securing the Internet. This research demonstrates that the growing cyber capability of frontier models can be used for effectively looking for vulnerabilities in complex software, such as the Linux kernel. Hardening critical software projects like Linux and other open-source projects can protect many downstream systems and users. Through Patch the Planet , a Daybreak initiative , we aim to extend this research to more critical software projects and develop reliable automated patching alongside maintainers and security partners. We want to steadily reduce the opportunities available to attackers and raise the cost of finding and exploiting vulnerabilities, until the expected payoff no longer justifies the attack. Every generation of models should help us build software that the next generation finds harder to compromise. We will continue working towards building a secure Internet that anyone can joyfully build on. 2026 Author OpenAI Keep reading View all Daybreak Red is now available in AWS GovCloud (US-East) Product Nov 4, 2026 Accelerating engineering for the physical world Research Nov 3, 2026 Preparing our next security sprint to harden OpenAI Security Nov 2, 2026

ai_agentlpe内核报告 @openai-research source ↗

TLS 证书校验与 DNS 缺陷命中服务端默认路径,影响面覆盖主流 LTS,补丁需尽快落地。

On October 21, 2026, Node.js announced the availability of fixes for multiple vulnerabilities across the following supported release lines: 22.x, 24.x, and 26.x. These vulnerabilities impact critical operations such as the Brotli decoder, DNS resolution, and TLS certificate validation. The vulnerabilities pose risks for remote code execution and traffic interception. For more information, see Node.js Security Release . The following vulnerabilities have a Security Impact Rating (SIR) of High and are addressed in this advisory: CVE-2026-111497 - Brotli decoder out-of-bounds write; potential remote code execution CVE-2026-105482 - DNS resolution truncation involving embedded NUL characters CVE-2026-105483 - TLS hostname validation bypass using fullwidth IP digits CVE-2026-106069 - TLS hostname validation bypass with noncanonical IP addresses For information about Splunk products and offerings, see Vulnerabilities in Node.js (CVE-2026-111497, CVE-2026-105482, CVE-2026-105483, CVE-2026-106069) on Splunk Products - October 2026 This investigation was expanded to cover Brotli outside of Node.js on October 30, 2026. The Brotli decoder flaw (CVE-2026-111497), which is in the Google Brotli C decoder, is often bundled with or linked to other software, so products beyond Node.js may be affected. For software that may be affected, see Broccoli2Shell . Important: If a product is not listed within this advisory, Cisco's review indicates that the product is not affected by this vulnerability. This advisory will be updated as additional information becomes available. This advisory is available at the following link: https://sec.cloudapps.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-oct2026-node-js-Jj3SQ19u <br/>Security Impact Rating: High

rcecvetlsnodejs @cisco-advisory source ↗

浏览器 UAF 常可发展为渲染进程代码执行,属应优先跟进的类型。

# CVE-2026-119266 - Chromium CVE-2026-119266: Use after free This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-416: Use After Free

浏览器cveuaf @msrc source ↗
Must-see6

无认证即可在暴露的邮件服务器上落文件,是常见 RCE 前置链。

MailEnable Save Directory Traversal Arbitrary File Creation Vulnerability November 4th, 2026 ZDI-26-869 ZDI-CAN-29161 CVE ID CVE-2026-114556 CVSS Score 7.4 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:H Affected Vendors MailEnable Affected Products MailEnable Vulnerability Details This vulnerability allows remote attackers to create arbitrary files on affected installations of MailEnable. Authentication is not required to exploit this vulnerability. The specific flaw exists within the implementation of the Save method. The issue results from the lack of proper validation of a user-supplied path prior to using it in file operations. An attacker can leverage this in conjunction with other vulnerabilities to execute code in the context of SYSTEM. Additional Details Fixed in version 10.60 https://www.mailenable.com/Premium-ReleaseNotes.txt Disclosure Timeline 2026-09-18 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Nicolas Chatelain Back to Advisories

目录遍历邮件服务器cve @zdi-advisories source ↗

未认证即可窃取端点证书,等于绕过 NAC 准入,暴露面在企业网络里很普遍。

A vulnerability in the authorization mechanism of Cisco Identity Services Engine (ISE) and Cisco ISE Passive Identity Connector (ISE-PIC) could allow an unauthenticated, remote attacker to obtain an endpoint identity certificate. This vulnerability is due to improper authorization checks. An attacker could exploit this vulnerability by sending a crafted request to an affected device. A successful exploit could allow the attacker to bypass authorization to obtain an endpoint certificate. Cisco has released software updates that address this vulnerability. There are no workarounds that address this vulnerability. This advisory is available at the following link: https://sec.cloudapps.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-ise-cert-mE9BD5GO <br/>Security Impact Rating: Medium <br/>CVE: CVE-2026-20241

绕过cve凭据网络准入 @cisco-advisory source ↗

内存破坏是浏览器远程代码执行的主要入口,需核对 Edge 版本是否已更新。

# CVE-2026-119263 - Chromium CVE-2026-119263: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器cve内存破坏 @msrc source ↗

同类 UAF 在浏览器沙箱内可被链式利用,批量通报期值得整体跟进。

# CVE-2026-119269 - Chromium CVE-2026-119269: Use after free This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-416: Use After Free

浏览器cveuaf @msrc source ↗

列存 OLAP 数据库多部署于内网核心,未认证即可触发,暴露面大。

Introduction ClickHouse is a widely deployed, high-performance columnar database management system designed for online analytical processing (OLAP). To maintain its exceptional read and write speeds, ClickHouse relies heavily on efficient data compression algorithms, including Google’s Brotli library. CVE-2026-116366 represents a critical security flaw in how ClickHouse handles incoming Brotli-compressed payloads. This vulnerability exposes affected servers to unauthenticated Remote Code Execution (RCE) and Denial of Service (DoS) attacks via memory corruption. As data architectures increasingly expose ingestion endpoints to wider networks for real-time analytics, vulnerabilities at the transport and decompression layers become highly attractive targets. Threat actors actively scan for exposed ClickHouse instances to exploit these low-level memory handling errors, bypassing application-level security controls entirely. Learning Objectives By the end of this analysis, readers will be able to: Understand the core components and origins of CVE-2026-116366. Analyze the technical mechanics of the Out-Of-Bounds (OOB) write vulnerability within the Brotli decoder. Identify the specific attack vectors and network ports exploited by threat actors. Determine if their infrastructure, including embedded analytics stacks, is running vulnerable software. Apply appropriate remediation and network segmentation strategies to secure ClickHouse deployments. What is ClickHouse Server – Brotli v1.2.0 Decoder DoS/OOB-Write (CVE-2026-116366) CVE-2026-116366 is a critical vulnerability (CVSS 9.5) specific to ClickHouse Server, stemming from an underlying flaw in the bundled Google Brotli compression library (tracked upstream as CVE-2026-111497). Because ClickHouse natively accepts compressed data over its network interfaces to optimize data ingestion rates and reduce bandwidth, it routinely passes external, untrusted data streams directly to the Brotli C decoder. The core of the issue manifests when an unauthenticated attacker sends a maliciously crafted, Brotli-compressed payload directly to the ClickHouse server’s listening ports. Upon decompression, an out-of-bounds (OOB) write occurs, severely corrupting server memory. This corruption reliably results in an immediate crash of the ClickHouse daemon, creating a catastrophic Denial of Service (DoS) condition for data pipelines. Beyond simple service disruption, highly sophisticated threat actors can manipulate this heap memory corruption to achieve arbitrary code execution. By carefully structuring the out-of-bounds write to overwrite critical function pointers or execution flows, the attacker gains the ability to run malicious commands with the full operating system privileges of the ClickHouse database process, leading to total server compromise. CVSS Severity: 9.5 (Critical) reflecting the lack of authentication required. Attack Vector: Network-based exploitation targeting default database ingestion ports. Underlying Flaw: Inherited directly from Google’s Brotli C library versions 1.0.3 through 1.2.0. Primary Impacts: Denial of Service (DoS) via process crash and unauthenticated Remote Code Execution (RCE). [Attacker] --(Crafted Brotli Payload)--> [Network Port 8123/9000] | v [ClickHouse Ingestion Layer] | v [Brotli C Decoder Module] | v [Out-of-Bounds Memory Write] | +------------+------------+ | | v v [Process Crash (DoS)] [Remote Code Execution] Technical Detail: How the Vulnerability Works The root cause of this memory corruption lies within the C implementation of the Brotli decoder, specifically localized to the DecodeBlockTypeAndLength() function found within the c/dec/decode.c source file. When the Brotli decoder processes an incoming stream, it relies heavily on block switches to accurately manage different data types and their corresponding lengths. The vulnerability is explicitly triggered when this function encounters a malformed or structurally invalid block switch designed by an attacker. Instead of safely terminating the decoding process or throwing a handled exception upon encountering this invalid structure, the function yields an ambiguous return value. The critical failure occurs because the Brotli fast decoding path aggressively prioritizes speed and fails to validate this anomalous state. As the decoder continues processing the payload under demonstrably false assumptions about block lengths and boundary limits, it blindly writes the decompressed output. Consequently, the decoder writes this output directly past the strictly enforced boundaries of its allocated heap memory buffer. In the context of ClickHouse, this OOB write is exceptionally dangerous because the decompression occurs synchronously as data streams in from the network interfaces. An attacker exploits this by simply delivering the payload over the default HTTP (8123) or Native (9000) ports before the database ever attempts to parse the content as a legitimate SQL query. Vulnerable Function: DecodeBlockTypeAndLength() located within c/dec/decode.c . Trigger Mechanism: Intentional injection of malformed block switches within the compressed HTTP/TCP stream. Validation Failure: The fast decoding path ignores ambiguous return values from the underlying block parser. Exploitation Phase: Memory overwrite occurs during synchronous network stream decompression prior to SQL parsing. Affected Software & Plugins The vulnerability directly impacts self-hosted environments running ClickHouse Server versions that statically or dynamically bundle Brotli library versions ranging from 1.0.3 through 1.2.0. Because ClickHouse is heavily integrated into modern data architectures, the attack surface extends beyond standalone database clusters. Administrators must account for bare-metal, containerized, and orchestrated Kubernetes deployments running older, unpatched releases of the database software. Furthermore, organizations are frequently exposed unknowingly if they operate self-hosted software platforms that silently bundle ClickHouse as their underlying telemetry, logging, or data storage backend. Many open-source analytics stacks provide default deployment configurations that pull vulnerable ClickHouse container images, meaning security teams must audit their entire application dependency chain, not just the primary database servers. Standalone Deployments: Bare-metal servers and Docker/Kubernetes clusters running unpatched ClickHouse builds. Embedded Analytics: Self-hosted platforms like Langfuse, Plausible Analytics, or PostHog that utilize bundled ClickHouse containers. Monitoring Stacks: Self-hosted Sentry or custom observability pipelines utilizing ClickHouse for extensive log aggregation. Client Applications: Data processing drivers that ingest heavily compressed upstream data, potentially exposing client-side decoders. Conclusion CVE-2026-116366 emphatically highlights the persistent and systemic danger of memory safety vulnerabilities lurking within foundational C/C++ compression libraries. When these low-level libraries are integrated into high-performance, network-facing applications like ClickHouse, the security implications are magnified drastically. The CVSS score of 9.5 accurately reflects the severity of this threat, given that exploitation requires zero authentication and directly targets the default, often exposed, network ingestion ports. Immediate and comprehensive remediation requires upgrading ClickHouse to a fully patched release, such as version 26.3.62.3-lts or the latest stable iterative build provided by the vendor. Security and operations teams must prioritize these upgrades across all environments, ensuring that embedded analytics containers and third-party dashboards relying on ClickHouse are also rebuilt with secure images. Relying solely on perimeter defenses is insufficient if internal threat actors or lateral movement capabilities exist within the corporate network. In the interim, or in environments where immediate patching is operationally unfeasible, administrators must enforce strict network segmentation protocols. Database ports should be bound exclusively to localhost ( 127.0.0.1 ) or highly restricted internal VPC subnets. Implementing aggressive firewall rules to unconditionally block public internet access to ports 8123, 8443, 9000, and 9440 is a mandatory defensive posture to mitigate external exploitation attempts until patches are permanently applied. Beginner Projects in C++ Programming Language Changing MAC Address Using Python: A Practical Guide Introduction to Blockchain Technology with a Python Example Understanding and Utilizing Microsoft Azure – A Comprehensive Cheat Sheet Vulnerability Analysis: CVE-2026-111497 Critical out-of-bounds write in the Node.js Brotli decoder https://nvd.nist.gov/vuln/detail/cve-2026-116366 https://github.com/google/brotli/compare/v1.2.0…v1.2.1 The post Vulnerability Analysis: CVE-2026-116366 ClickHouse Server – Brotli v1.2.0 Decoder DoS/OOB-Write appeared first on DenizHalil - Professional Cybersecurity Consulting and Penetration Testing .

rcecve数据库压缩 @denizhalil-blogs source ↗

汇总 PHP RCE、GitLab CVSS 10、CA 密钥泄露等事件的补丁时间线,可用于确定修复优先级。

Between 16 and 23 October, five major security incidents went public in a single week: two remote code execution bugs in PHP, a memory corruption bug in Google’s Brotli decoder, a chain of four bugs in Plex Media Server, a CVSS 10.0 bug in GitLab, and eight compromised certificate authority keys at eMudhra. Now that the month is over, here’s what happened next. At a glance Issue Patch / containment Exploitation PHP2Shell (CVE-2026-109618, CVE-2026-109619) 21 Oct Attempt seen 17 Oct, before disclosure; CISA-listed 26 Oct; 24 PAN-OS firewalls rooted (Dream Research) HTTP2Shell / Node2Shell (CVE-2026-111497) 21 Oct CISA-listed as exploited 27 Oct; public details of compromises limited. ELLIO’s documented attempt failed in lab replays Plex2Shell (four CVEs) Early Aug CISA-listed 20 Oct; active exploitation confirmed by Plex: crypto miners, proxy malware GitLab (CVE-2026-110264) 21 Oct No public exploitation reported GitLab (CVE-2026-97229, earlier flaw) 12 Oct Exploitation attempts detected by GitLab; Alpine Linux targeted 20–21 Oct; CISA cites ongoing attacks eMudhra CA keys 17 Oct (blocked) No malicious use confirmed PHP2Shell Fixed: 21 October, in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35. Who is affected and how to check: PHP2Shell: Critical PHP RCE (CVE-2026-109618, CVE-2026-109619) . Exploited: yes. Amazon Threat Intelligence recorded an exploitation attempt in its MadPot honeypots on 17 October, four days before public disclosure, and says it’s unclear how the actor got the exploit details that early. After disclosure, AWS reports broad exploitation attempts in the wild. CISA added both CVEs to its Known Exploited Vulnerabilities catalog on 26 October. Palo Alto Networks’ advisory now says active exploitation has been observed against PAN-OS management interfaces exposed to the internet. On 26 October, Dream Research reported a campaign that chained PHP2Shell with Fragnesia (CVE-2026-46300), a Linux kernel privilege-escalation bug, and rooted 24 PAN-OS firewalls in the US, Japan, Taiwan and South Korea, plus an internal management server. Two of the firewalls belonged to a US government-affiliated organisation. Unit 42 says it independently verified the attacker’s tooling and the reported results. Dream Research found signs of AI-assisted tooling on the attacker’s infrastructure, but says it has no direct evidence AI wrote the exploit. PHP2Shell is a blind remote memory corruption bug. A proof of concept built for one target rarely works on the next one, because memory layout depends on the PHP build, the extensions loaded and the application in front of it. Code execution needs an exploit tuned to each target. That doesn’t make the bug overhyped. Attempts are widespread; confirmed successful compromises are much rarer. Wiz says it hasn’t seen a successful end-to-end PHP2Shell exploit in its own telemetry. research benchmark php2shell: The exploitability gap between frontier and open models We measured how long that adaptation takes: frontier models ported the exploit to a new target in hours, while the open models we tested didn't get there. That gap is likely to narrow. Read the post A separate PHP issue is still open. On 23 October, PHP published an advisory for CVE-2026-115560, another possible remote code execution path through session upload progress. It needs an unusual configuration: a non-default session serializer in server settings that the application switches back at runtime with ini_set() before session_start() . The 21 October releases don’t fix it, and no fix release is out yet. PHP’s mitigation for affected configurations is to set session.upload_progress.enabled=0 at the server level. No exploitation has been reported. The attacks a vendor has confirmed so far are against firewall management interfaces. Most people don’t think of their firewall as a PHP server, but its management interface runs PHP under the hood. HTTP2Shell / Node2Shell (Brotli) Fixed: 21 October, in Brotli 1.2.1, 1.1.1 and 1.0.10, and in Node.js 26.12.1, 24.22.1 and 22.23.4. Fixes are still landing in software that bundles its own copy of Brotli. Linux distributions may backport the fix under older-looking version numbers, so check your distro’s security tracker rather than the version string alone. Exploited: CISA added CVE-2026-111497 to its Known Exploited Vulnerabilities catalog on 27 October, citing evidence of active exploitation. Public details of successful compromises remain limited. On 26 October, threat-intelligence firm ELLIO documented an exploitation attempt involving a Brotli-compressed request targeting Node.js 24.22.0 on x86-64. When ELLIO replayed the attacker’s chain in its lab, the final stage failed in all 50 attempts. The same source IP had been associated with PHP2Shell activity in OffSeq’s honeypots the week before. The bug isn’t limited to Node.js. On 25 October, Microsoft shipped out-of-band .NET updates (8.0.33, 9.0.22 and 10.0.14) for the same flaw in .NET’s use of Brotli; request and automatic response decompression are off by default, and self-contained apps and containers carry their own runtime, so they need rebuilding. On 28 October, AWS published a bulletin saying its .NET and Node.js Lambda runtimes are affected, along with App Runner, CodeBuild curated images and other services. Updated Lambda container base images are already available. For functions deployed as ZIP files, AWS rolled out runtime updates in phases, scheduled to finish by 30 October for Node.js and 31 October for .NET, so check that your functions picked up the update. A real code or configuration change picks up the patched runtime sooner once it’s available in your region; AWS notes that “a zero-change update is not sufficient.” Brotli is hard to fingerprint from the outside. A server doesn’t announce which decoder it uses, and the bug only matters if something decodes attacker-controlled Brotli data: request bodies, or responses fetched from a server the attacker controls. We covered the bug and the exploit path in more detail in Node2Shell: Brotli Decoder RCE in Node.js (CVE-2026-111497) . Plex2Shell Fixed: Plex fixed the issue in version 1.43.3.10861, released in early August. Exploited: yes, from about a day after the 16 October write-up. A researcher’s honeypot recorded attacks on 17 October that installed an XMRig-based crypto miner and proxy software, and Plex has confirmed active exploitation. No one has published a count of compromised servers. CISA added all four CVEs to its Known Exploited Vulnerabilities catalog on 20 October. This is the only one of the five where the fix was out for more than two months before the attacks. Plex Media Server mostly runs on home and small-office machines, often exposed for remote streaming, and often not updated until something breaks. GitLab (CVE-2026-110264) Fixed: 21 October, in 19.5.1, 19.4.3 and 19.3.6, with backports to four older branches. GitLab.com and GitLab Dedicated were patched before disclosure. Exploited: no public exploitation reported for this flaw. The bug was in the Ruby regular expression engine GitLab ships, not in GitLab’s own code. An earlier GitLab flaw in the same family is under attack. GitLab says it has detected exploitation attempts against CVE-2026-97229, fixed on 12 October, and has published detection rules. Shadowserver tracks nearly 2,800 internet-exposed GitLab Community Edition instances, though it hasn’t said how many are patched. The best-documented case is Alpine Linux , whose GitLab instance was targeted on 20 and 21 October. Alpine found no evidence the attacker succeeded but couldn’t rule it out, so it rebuilt the instance, reset all passwords and replaced GitLab’s secret keys. Alpine had two patching misses. Before the attack, it upgraded to GitLab 19.3.4 instead of the patched 19.3.5 by mistake. Then its upgrade to 19.3.6 on 22 October, after the attempts, still didn’t close the path: the fix is a patch to Ruby that GitLab only applies in its official packages, and Alpine’s image used standard Ruby. If you self-host GitLab and haven’t upgraded, do it now. A successful exploit could expose repositories and CI/CD secrets accessible to the GitLab service account. eMudhra Fixed: Chrome blocked the eight affected keys within two hours of the 17 October report, and other browsers and runtimes followed. Chrome stopped trusting the affected eMudhra root certificate on 27 October. Exploited: no public exploitation reported. Google says no website certificates from the affected intermediates had appeared in Certificate Transparency logs before the block, and eMudhra says it isn’t aware of any evidence the weak keys were recovered or exploited before disclosure. eMudhra’s board decided on 22 October to leave the global TLS certificate business. If you have certificates chained to the eMudhra root, they need replacing with another CA. Is there a pattern? The PHP2Shell attacks a vendor has confirmed are on firewall appliances. Plex2Shell’s are self-hosted media servers with a fix from two months prior. ELLIO’s publicly documented Brotli exploit attempt was built for a specific Node.js build. In each case, the vulnerable code sits inside something people don’t think of as theirs to patch such as a vendor’s appliance, a bundled runtime, or a container base image. Those are also the copies a version scan tends to miss. Brotli is compiled into runtimes and libraries that don’t list it as a dependency. GitLab’s fixes are in the Ruby it ships, which is why Alpine’s upgraded instance stayed vulnerable. And as of 28 October, the Dutch National Cyber Security Centre was tracking 757 products for PHP2Shell, with 218 confirmed vulnerable, 144 fixed and 354 still under investigation. A patch existing doesn’t mean systems are patched. Wiz’s telemetry shows the number of internet-exposed machines vulnerable to PHP2Shell fell about 67% in the first week, but nearly half of the organisations originally affected were still vulnerable a week after disclosure. The remaining risk is in the copies you may not have realised you need to update. Check what’s actually running across your environment, and look for signs of exploitation that may have happened before you patched. Get hacked on your terms. Talk to the researchers behind Hacktron about continuous red teaming across your whole attack surface. Book a call See all research Sources CISA: critical vulnerabilities in PHP require immediate patching AWS: PHP2Shell exploitation prior to public disclosure Palo Alto Networks advisory: CVE-2026-109618 Unit 42 threat brief: CVE-2026-109618 and CVE-2026-109619 OffSeq: PHP2Shell, the first 48 hours ELLIO: Node2Shell analysis SecurityAffairs on Plex2Shell eMudhra statement Dream Research: chained PHP2Shell exploit roots 25 servers Alpine Linux: GitLab security incident (CVE-2026-97229) THN: CISA adds actively exploited GitLab RCE to KEV BleepingComputer: hackers now exploiting max severity GitLab flaw Wiz: PHP2Shell exploitation attempts and remediation trends NCSC-NL: PHP2Shell operational information Tenable: PHP2Shell one week later Check Point on HTTP2Shell Node.js October 2026 security releases Microsoft: .NET October 2026 out-of-band security updates AWS security bulletin 2026-155-AWS: Brotli PHP CVE-2026-115560 advisory Secure.com on Plex2Shell GitLab patch release 19.5.1 Google on eMudhra THN: eMudhra to exit global SSL/TLS business

cverce供应链报告 @hacktron-blog source ↗
Recommended15

0day 且仅需打开恶意文件触发,波及 CAD 工作站且暂无补丁信息。

(0Day) Ashlar-Vellum Cobalt XE File Parsing Use-After-Free Remote Code Execution Vulnerability November 4th, 2026 ZDI-26-874 ZDI-CAN-28757 CVE ID CVE-2026-121742 CVSS Score 7.8 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H Affected Vendors Ashlar-Vellum Affected Products Cobalt Vulnerability Details This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The specific flaw exists within the parsing of XE files. The issue results from the lack of validating the existence of an object prior to performing operations on the object. An attacker can leverage this vulnerability to execute code in the context of the current process. Additional Details 02/06/26 – ZDI reported the vulnerability to the vendor 02/06/26 – the vendor acknowledged the receipt of the report 07/13/26 – ZDI asked for updates 08/06/26 – ZDI asked for updates 10/29/26 – ZDI notified the vendor of the intention to publish the case as a 0-day advisory -- Mitigation: Given the nature of the vulnerability, the only salient mitigation strategy is to restrict interaction with the product Disclosure Timeline 2026-02-06 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Rocco Calvi (@TecR0c) with TecSecurity Back to Advisories

rceuafcve @zdi-advisories source ↗

HTTP 请求校验缺失直接通向 RCE,已登录的低权账号即可发动,横向渗透价值高。

A vulnerability in the web-based management interface of Cisco UCS Central Software could allow an authenticated, remote attacker to achieve remote code execution or conduct information disclosure attacks on an affected device. This vulnerability is due to insufficient validation of user-supplied input in an HTTP request. An attacker could exploit this vulnerability by sending a crafted HTTP request to an affected endpoint on an affected device. A successful exploit could allow the attacker to execute arbitrary commands, write arbitrary files to the filesystem, and obtain sensitive information. To exploit this vulnerability, the attacker must have valid user credentials on the affected device. Cisco has released software updates that address this vulnerability There are no workarounds that address this vulnerability. This advisory is available at the following link: https://sec.cloudapps.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-cucs-rce-LzHSFRDQ <br/>Security Impact Rating: High <br/>CVE: CVE-2026-76506

rcecve输入校验 @cisco-advisory source ↗

打管理台用户的 XSS 常被用作接管话务系统的一环,需确认版本与缓解措施。

A vulnerability in the web-based management interface of Cisco Unified Communications Manager (Unified CM) and Cisco Unified Communications Manager Session Management Edition (Unified CM SME) could allow an unauthenticated, remote attacker to conduct a cross-site scripting (XSS) attack against a user of the interface. This vulnerability exists because the web-based management interface does not properly validate user-supplied input. An attacker could exploit this vulnerability by persuading a user of the interface to click a crafted link. A successful exploit could allow the attacker to execute arbitrary script code in the context of the affected interface or access sensitive, browser-based information. Cisco has released software updates that address this vulnerability. There are no workarounds that address this vulnerability. This advisory is available at the following link: https://sec.cloudapps.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-cucm-xss-5mQn2U5z <br/>Security Impact Rating: Medium <br/>CVE: CVE-2026-76419

xsscve管理台 @cisco-advisory source ↗

UAF 是浏览器沙箱内最常见的可利用原语,渲染进程缺陷值得纳入补丁核对。

# CVE-2026-119260 - Chromium CVE-2026-119260: Use after free This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-416: Use After Free

浏览器cveuaf @msrc source ↗

UAF 类漏洞在 Chromium 中历史利用率高,可与同批 CVE 一并核查。

# CVE-2026-119271 - Chromium CVE-2026-119271: Use after free This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-416: Use After Free

浏览器cveuaf @msrc source ↗

同批 Chromium 内存破坏修复之一,用于确认补丁覆盖是否完整。

# CVE-2026-119264 - Chromium CVE-2026-119264: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器cve内存破坏 @msrc source ↗

属浏览器攻击面常见缺陷类型,适合批量核对更新状态。

# CVE-2026-119265 - Chromium CVE-2026-119265: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器cve内存破坏 @msrc source ↗

同类缺陷集中出现时往往是同一批上游修复,便于统一验证。

# CVE-2026-119267 - Chromium CVE-2026-119267: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器cve内存破坏 @msrc source ↗

整数溢出常为堆越界的前置条件,是审计与利用研究的常见切入口。

# CVE-2026-119268 - Chromium CVE-2026-119268: Integer overflow This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-190: Integer Overflow or Wraparound

浏览器cve整数溢出 @msrc source ↗

输入校验类缺陷常被用作绕过前置,细节可查上游 Chrome 发布说明。

# CVE-2026-119270 - Chromium CVE-2026-119270: Improper input validation This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-20: Improper Input Validation

浏览器cve输入校验 @msrc source ↗

PHP 驱动约四成网站,这类基础漏洞的利用链对 Web 侧攻防有直接参考价值。

PHP (Hypertext Preprocessor) is a widely used open-source server-side scripting language designed for web development. It has over the years gained widespread acceptance for its ease of use and programming/scripting abilities and is notably the scripting language that implements the popular WordPress application. WordPress is the most popular content management system (CMS) in the world powering approximately 42% of worldwide websites, and nearly 60% of websites that use a CMS. On October 21 st , 2026, the PHP project reported the following two CVEs and released a patch for the vulnerabilities. These CVEs are related in that they both involve memory use from the heap in PHP worker processes. CVE-2026-109618: Remote Code Execution via Out of Memory Condition (OOM) When PHP experiences a memory exhaustion condition known as “out-of-memory (OOM)”, it uses the standard C function longjmp() to transfer execution into another function for a fatal error and exit. During multipart parsing of an HTTP request, if the OOM condition is triggered while the request state is partially initialized, the fatal exit and shutdown reads invalid memory, which can lead to remote code execution (RCE). Susceptibility to this vulnerability is implementation dependent. The highly popular Apache “mod_php” for example unconditionally executes the longjmp() in an OOM condition making it vulnerable. CVE-2026-109619: Remote Code Execution via Stale Global Memory Pointer State PHP worker processes retain a global state memory pointer to any freed request memory. It is possible that the global state is not properly reset in some scenarios or even that memory is repopulated after a reset. Fatal errors such as the above OOM condition will skip the pointer reset. This effectively translates into memory use-after-free condition and remote code execution becomes possible. Background Exploitability of these CVEs is non-trivial with some pre-conditions to be met and multiple possibilities/avenues of potential attack. In this blog, we will focus purely on CVE-2026-109618 to see if we can get a single HTTP POST exploitation vector. We must first have an application configuration and components that allows for the upload of multipart form data. Within PHP, there was a feature released in version 5.4.0 that introduced a configuration switch called “session.upload_progress”. In the implementation, the switch defaults to being enabled. Below is a snippet from the PHP manual: This feature processes multipart form data in a function called php_session_rfc1867_callback() in the PHP session handling API. All the HTTP POST request data in the session API is processed before any application code runs. The callback handler function: Creates temporary session state files with attacker controllable data. Runs on any PHP web application that accepts HTTP POST requests. No authentication is required during the session API handling of these requests. Therefore, this callback function in the PHP code is an excellent candidate to allow a threat actor to trigger an out-of-memory condition and potentially gain remote code execution. Lab Setup To explore these vulnerabilities, we need a reliable lab setup. A docker container is the easiest way to get up and running with Apache mod_php. As you might imagine, Docker Hub publishes a number of images for the community already. Having said that, I learned through the process of banging my head against a brick wall repeatedly that the PHP project to their credit had recompiled PHP with the fixes and back ported into older versions of the docker containers. Bravo, but it was unexpected and frustrating for me while getting the lab up and running! The following setup information formed the basis of my lab: Libphp.so was compiled fresh directly from the php-8.4.26 source code with all of the same configuration switches that are commonly used in an Apache mod_php environment. The following PHP initialization/configuration directives were placed in /usr/local/etc/php/conf.d/custom.ini to create a stable controlled environment. The most important statements are making sure that the upload progress switch is enabled, and that the max memory size for HTTP posts is a little more constrained to help us trigger an out of memory condition sooner during upload. I created a basic index.php and placed it in the /var/www/html root directory. All it did was print some version info and the value the upload_progress.enabled flag. I disabled Address Space Layout Randomization (ASLR) in the docker host. More on this later. I used a local AI model to speed up the debugging and researching process. Specifically, I used Qwen3.8-27b running on an Nvidia RTX-4090 GPU. After finishing the vulnerable docker container setup using the reference image of php:8.4.26-apache, I used docker commit to save a vulnerable image as vuln_php. I had the AI model write a simple Python script called oom_probe.py to successively send larger and larger multipart form data HTTP POST requests until I observed an out of memory response from the PHP server. I was then able to see stale session files lying around in /tmp/sessions as expected. Initial Attack Path (Low Hanging Fruit) There is another defect that allows for a reasonably easy initial attack path and that is the multipart form handler code in PHP that accepts the session cookie from the form data without checking the session.use_only_cookies setting. This gives us session fixation, which means that we will know the session identifier, and will directly map to the stale session file we leave on the server. Notably the “name” parameter sent in the post request is stored directly in the temporary session state file. The session state file that is written when the OOM condition is triggered will not be deleted leaving the attacked supplied data in the “name” parameter within the file contents. Below is an example using my probing script of injecting data into this field and then looking at the file on the target docker container. All we need from there is some form of local file inclusion in the PHP of the application and we get command injection ability by writing PHP code into the filename variable we post. For example, we could write the following text into the filename field that remains on disk in the stale session state files: Then if any other PHP script includes this state file, we have an execution of the command. However, this path depends on a local file inclusion vulnerability in the application. I dropped a simple vulnerable PHP script onto the web server with a direct file inclusion to verify this. Higher Complexity Attack Path An interesting observation is that the multipart form upload code in the session handling API will potentially trigger the out of memory condition before any application code runs. More specifically, the Zend engine ( zend_bailout() function in zend.c of the php source code) will be executed when the Zend HashTable structure is only partially initialized. The last line of code in zend_bailout() is the LONGJMP() macro that ultimately just executes a longjmp() to transfer program execution control into the shutdown and exit function for this request. Since all this code is written in C, any time we are about to shut down a process, developers are obligated to cleanup memory. This is commonly referred to as a destructor function, and in the C language, context must be manually implemented. Without getting too far in the weeds, the bottom line is that the Zend HashTable structure, when initialized for an HTTP request, contains memory pointers for object destruction functions. If we can somehow influence the value of one of these memory pointers, we will be able to control execution. From a high level, these are the parts and sequence of the exploit: OOM triggered by large multipart form data HTTP POST to index.php . Form data contains a payload designed to pad out a forged Zend object beyond the max memory limit of the PHP process. The zend_bailout() function is called, which triggers the process shutdown functions that are dealing with only a partially initialized HashTable. The forged object type of 8 in payload sends execution control to the zend_objects_store_del() function. zend_objects_store_del() calls the destructor function handler (a memory pointer). This object handler is from our forged object we created in payload and sends execution to a new jump target address we call POP4. POP4 sets the RDI register to the command string we want to execute and pops the other registers off the stack. POP4 then calls libc system() to execute an O/S command. What POP4 represents here is a return-oriented programming (ROP) gadget we are using as a springboard to get the right things put into the right registers before our system call. The astute reader is going to recognize that to make all this work, we need some static memory addresses. This is the point in the blog where I tell you that I did all this work in a docker container after switching Address Space Layout Randomization (ASLR) off, and hard coded the memory addresses of both LIBC, and the loaded LIBPHP object. ASLR is a great defense mechanism; however, during the course of an exploit POC development there are already complexities of understanding the exact nature of the vulnerability, in this case the memory layout of the heap, and we need to break the development steps down into manageable steps minimizing complexity at each step. Once we have achieved success with a defensive mechanism like ASLR disabled, we can move forward with further development with defenses re-enabled steadily growing the exploit capability. ASLR Enabled Attack Path It is possible to adapt this attack path for different vulnerable versions of PHP and for a normal implementation where ASLR is not disabled. In the case where ASLR is not disabled, we would probably modify the attack to leverage the zip_system() function, which is an implementation of the system() function inside of libphp. This optionally eliminates the additional base address requirement of libc, but is not absolutely required. We need a method to leak address information about libphp.so when attempting to adapt for a non-ASLR attack path. This is where the second CVE-2026-109619 becomes useful. In my reading and research, along with some additional AI model assistance, I discovered that we could get a vulnerable PHP server to leak memory address information using the Set-Cookie header over HTTP. This memory address disclosure is an over-HTTP arbitrary read made possible by stale PS(id) / PS(send_cookie) state being consumed by the upload-progress session path before RINIT. It prints attacker-directed heap/libphp memory into the PHPSESSID cookie. To achieve success with the ASLR enabled attack path, we need to be able to pin the attack to a single PHP worker process. The reason for this is that the attack will occur in stages. The initial stage will be used to leak memory addresses in the cookie headers of the response, and then the attack stage to push the exploit into the heap. Because ASLR is enabled, we need both stages of the attack to leverage the same PHP worker process. Otherwise said, the library base memory addresses will stay consistent in the same worker process. How can we possibly know the Apache/PHP configuration on the target server? The answer to this question is . . . that we just don’t know. Thus, in the final proof of concept attack script, we introduce a parameter called —workers , which sets the target worker process count to an arbitrary number. During the attack, we use some Python threads to keep the workers – 1 count of processes busy. This is so we can create the condition whereby our attack itself will attack only one worker for all stages. In the final developed exploit, I decided to keep using the system() function from libc. Therefore, we have to leak the base memory address for libc as well as libphp. Here is the execution sequence flow as documented by the AI model: And finally, what you have been waiting for, here is a screenshot of the exploit actually running with the injected command string as follows: You will of course notice that we wrote the output to a file. This is because the output from the worker process is not reflected back in the HTTP response. We used a simple PHP script to fetch the contents, which reads as follows: I am pretty sure you can use your imagination on how to take this further. Anyway, without delaying the anticipation any longer, here is the screenshot output of a running exploit against an Apache/PHP server using 10 worker processes in its configuration. Thoughts on AI Assistance When developing these attack paths using the assistance of an AI model, I leveraged OpenCode as the agentic harness, a full copy of the php-8.4.26 source code, a recompiled copy of libphp.so from this source that was vulnerable as well as some example exploitation code from “CookieEngineer” that followed a similar path. You might be thinking that I prompted the AI model once saying something like “go find a vulnerability based on this CVE,” but you would be incorrect. To get good and expedient results from the local AI model, I examined the vulnerability carefully, read lots of source code, and got very specific with a lot of my prompting. In other words, I leveraged the AI model as my intern to accelerate development paths while the real directed thinking and additional knowledge was coming from myself and my research. More to the point, I stepped the AI model through this in small discrete steps for better quality results, and for my own personal understanding. References: https://github.com/php/php-src https://github.com/cookiengineer/actual-php2shell https://www.exploit-db.com/exploits/52704 https://www.cve.org/CVERecord?id=CVE-2026-109618 https://www.cve.org/CVERecord?id=CVE-2026-109619

phpwordpressexploitweb @whiteknightlabs-blog source ↗

CWE-119 内存破坏可被网页内容触发,属于浏览器高危面,值得核对补丁版本。

# CVE-2026-76024 - Chromium CVE-2026-76024: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器内存破坏cveedge @msrc source ↗

UAF 是浏览器沙箱内常见的可利用原语,修复细节随 Chrome 版本一并公开。

# CVE-2026-76025 - Chromium CVE-2026-76025: Use after free This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-416: Use After Free

浏览器uafcveedge @msrc source ↗

说明评测口径缺陷会放大模型能力结论,影响对同类研究的采信。

MIT CSAIL 宣称 GPT-6 Astra 不经训练直接修改千问模型万分之二权重即可让数学成绩暴涨六倍。翻开公开的 1,125 轮实验日志可见,新答对的 579 道题中有 576 道只是切除了无限复读导致的超时截断,而小网络实验则依赖棋盘说明书与闲置神经元外挂。

llm评测报告 @yage-share source ↗

这是长时程自主 agent 涌现行为的观测样本,涉及规则绕过与自组织决策。

YC Labs 联合 Olam Labs 让几十个 GPT-6.1 Sol 与 Claude Opus 5.5 在《我的世界》夺床战、Mindustry 塔防战和生存模式中自主博弈十几个小时:打仗时写爬墙脚本、扒 Java 源码偷家,和平求生时却锁进地堡维护 335 行粮票台账、开会 11 分钟审批一格化肥。

ai_agentllm事件 @yage-share source ↗
More21

(0Day) Ashlar-Vellum Cobalt AR File Parsing Heap-based Buffer Overflow Remote Code Execution Vulnerability November 4th, 2026 ZDI-26-873 ZDI-CAN-28675 CVE ID CVE-2026-121743 CVSS Score 7.8 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H Affected Vendors Ashlar-Vellum Affected Products Cobalt Vulnerability Details This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The specific flaw exists within the parsing of AR files. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a heap-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current process. Additional Details 01/22/26 – ZDI reported the vulnerability to the vendor 01/28/26 – the vendor acknowledged the receipt of the report 07/13/26 – ZDI asked for updates 07/15/26 – the vendor communicated that the fix was not completed 08/06/26 – ZDI asked for updates 10/29/26 – ZDI notified the vendor of the intention to publish the case as a 0-day advisory -- Mitigation: Given the nature of the vulnerability, the only salient mitigation strategy is to restrict interaction with the product Disclosure Timeline 2026-01-22 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Rocco Calvi (@TecR0c) with TecSecurity Back to Advisories

rce堆溢出cve @zdi-advisories source ↗

(0Day) Ashlar-Vellum Cobalt XE File Parsing Use-After-Free Remote Code Execution Vulnerability November 4th, 2026 ZDI-26-872 ZDI-CAN-28587 CVE ID CVE-2026-121753 CVSS Score 7.8 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H Affected Vendors Ashlar-Vellum Affected Products Cobalt Vulnerability Details This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The specific flaw exists within the parsing of XE files. The issue results from the lack of validating the existence of an object prior to performing operations on the object. An attacker can leverage this vulnerability to execute code in the context of the current process. Additional Details 12/16/25 - ZDI reported the vulnerability to the vendor 12/16/25 - the vendor acknowledged the receipt of the report 03/04/26 - ZDI asked for updates 07/13/26 - ZDI asked for updates 07/15/26 - the vendor communicated that the fix was not completed 08/06/26 - ZDI asked for updates 10/29/26 - ZDI notified the vendor of the intention to publish the case as a 0-day advisory -- Mitigation: Given the nature of the vulnerability, the only salient mitigation strategy is to restrict interaction with the product Disclosure Timeline 2025-12-16 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Rocco Calvi (@TecR0c) with TecSecurity Back to Advisories

rceuafcve @zdi-advisories source ↗

(0Day) Ashlar-Vellum Cobalt LI File Parsing Heap-based Buffer Overflow Remote Code Execution Vulnerability November 4th, 2026 ZDI-26-871 ZDI-CAN-28447 CVE ID CVE-2026-121752 CVSS Score 7.8 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H Affected Vendors Ashlar-Vellum Affected Products Cobalt Vulnerability Details This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The specific flaw exists within the parsing of LI files. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a heap-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current process. Additional Details 12/04/25 - ZDI reported the vulnerability to the vendor 08/06/26 - ZDI asked for updates 10/29/26 - ZDI notified the vendor of the intention to publish the case as a 0-day advisory -- Mitigation: Given the nature of the vulnerability, the only salient mitigation strategy is to restrict interaction with the product Disclosure Timeline 2025-12-04 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Rocco Calvi (@TecR0c) with TecSecurity Back to Advisories

rce堆溢出cve @zdi-advisories source ↗

(0Day) Ashlar-Vellum Cobalt XE File Parsing Stack-based Buffer Overflow Remote Code Execution Vulnerability November 4th, 2026 ZDI-26-870 ZDI-CAN-28172 CVE ID CVE-2026-121744 CVSS Score 7.8 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H Affected Vendors Ashlar-Vellum Affected Products Cobalt Vulnerability Details This vulnerability allows remote attackers to execute arbitrary code on affected installations of Ashlar-Vellum Cobalt. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The specific flaw exists within the parsing of XE files. The issue results from the lack of proper validation of the length of user-supplied data prior to copying it to a stack-based buffer. An attacker can leverage this vulnerability to execute code in the context of the current process. Additional Details 11/12/25 - ZDI reported the vulnerability to the vendor 11/12/25 - the vendor acknowledged the receipt of the report 03/04/26 - ZDI asked for updates 07/13/26 - ZDI asked for updates 08/06/26 - ZDI asked for updates 10/29/26 - ZDI notified the vendor of the intention to publish the case as a 0-day advisory -- Mitigation: Given the nature of the vulnerability, the only salient mitigation strategy is to restrict interaction with the product Disclosure Timeline 2025-11-11 - Vulnerability reported to vendor 2026-11-04 - Coordinated public release of advisory 2026-11-04 - Advisory Updated Credit Rocco Calvi (@TecR0c) with TecSecurity Back to Advisories

rce栈溢出cve @zdi-advisories source ↗

Inactive Window Input Yesterday, 02:04 PM # 1 ykhim Posting Well Join Date: Jan 2025 Posts: 30 Reputation: 25 Rep Power: 45 Points: 1,749, Level: 3 Level up: 50%, 351 Points needed Activity: 3.3% Last Achievements Inactive Window Input How can I send input into a inactive window (a window that isn't focused), when it blocks PostMessage. __________________ ykhim is offline ykhim View Public Profile Find More Posts by ykhim

逆向windows输入注入 @unknowncheats-ac source ↗

LifeVal | OpenAI 2026年11月2日 研究 刊发 LifeVal 衡量 AI 在日常生活重要任务上的进步。 Read the paper (在新窗口中打开) 聆听文章 3:03 分享 OpenAI 的使命是确保通用人工智能造福全人类。目前,每周有超过十亿人使用 ChatGPT。我们希望打造能帮助他们应对日常生活实际难题的 AI,例如寻找托育服务、获取政务服务、制定预算、为上学做准备、调整食谱、订购食材、设计健身计划等。 当人们寻求帮助,希望让生活更轻松时,他们需要的不只是建议或聊天回复。要成为真正有用的个人助手,ChatGPT 应当能够采取行动,切实把事情办好。 为了衡量模型在日常任务中的表现随时间的变化,我们构建了一套任务评估方案,覆盖用户最希望 AI 和个人智能体提供帮助的领域。过去一年,我们利用这套评估方案来跟踪并优化模型在日常任务中的表现。 模型在日常生活任务中的表现随时间的变化 背景 为了找出人们最关注的任务,我们首先参考了两项分别追踪美国和国际人群时间分配的大型研究: 美国时间使用情况调查 ⁠ (在新窗口中打开) 和 多国时间使用情况研究 ⁠ (在新窗口中打开) 。这两个数据集详细列出了不同人群在一天中不同时段、不同季节所做的日常生活任务。为了解人们最关注哪些方面的 AI 协助,我们在现有调查的基础上开展了一项新调查,涵盖 3,995 名具有典型人口统计特征的受访者。针对每项任务,我们提出了多个问题,以找出普通人最希望个人助手提供帮助的领域。最终确定的任务覆盖了人们最需要帮助的重要领域,包括照护、健康、教育、家庭事务管理、个人财务、购物和获取政务服务。 具体任务示例 以下示例展示了我们当前模型在日常生活实际工作流中的表现。 搬家后报名合适的幼儿园 93.1% 比较我们新家附近的幼儿园,筛选出最合适的几所。 我已筛选出三所幼儿园,并整理好了入园报名信息。还有两项偏好需要你来决定。想看看候选名单吗? 在洪水来临前协调志愿者 98.0% 帮我组织社区防汛志愿者队伍,为四位需要防洪改造协助的邻居提供支援。 我准备了一份简明的行动计划,帮助志愿者评估提到的地点,并为即将到来的恶劣天气做好准备。 为我们一家人找个新家 100% 在卢泽恩县找一套符合我预算、带独立居住单元的房子,而且送孩子上学后去上班的路程要短。把房契加入我的购物车,方便我查看。 我找到了一套符合你要求的房子。我已算好过户税,并将房契加入你在县档案网站的购物车,供你查看。 和远方的奶奶一起看比赛 96.3% 帮我设置一个简单的方法,让我和奶奶能远程一起看比赛。 最简单的观赛方案已准备好,还备有直播出故障时的替代方案。要我带你和奶奶一步步设置吗? 为刚确诊糖尿病、正在适应的父母准备膳食 90.4% 制定一份实用的护理和膳食计划,帮助我的父母适应刚确诊糖尿病后的生活。 第一周的计划已准备好,包括膳食安排、提醒事项和要向医护团队询问的问题。在分享给父母之前,要不要一起看看? 我们的最新模型在多项 LifeVal 任务中取得了很高的分数。 任务 GPT‑6 Astra 最高记录得分 查找并 预约 适合我家幼儿需求和家庭时间安排的 感官体验课 100% 查看我的车何时该保养,并在自驾旅行前 预约车辆检查 100% 在预算范围内,为我最喜欢的三道菜 订购清真食材 ,并用电子表格列出订单明细 100% 根据照片和钻石鉴定报告,为我妻子 丢失的订婚戒指 寻找替代品 100% 查找并订购 一台 口袋大小的设备 ,替代我的手机、电子阅读器和掌上游戏机 100% 退订 邮件列表 100% 查看更多 + 更多任务结果 过去一年,我们通过训练,大幅提升了模型在浏览器使用、计算机操作和连接器任务上的速度与能力,也让其行为更符合用户意图。在 ChatGPT 中引入这些能力,也拓宽了模型能够协助处理的任务范围,推动 ChatGPT 从聊天工具迈向真正能自主行动的智能体个人助手。 模型在日常任务中的表现 速度 生成 Token 数 API 费用 指标 速度 GPT-6 Astra GPT-5.6 GPT-5.5 GPT-5.4 GPT-5.2 这为什么重要 要确保 AGI 造福全人类,我们需要围绕普通人真正关心的生活议题,衡量并提升模型的能力。这意味着,我们不能只从学术角度评估模型掌握的知识,还要实际衡量 AI 模型在帮助人们做决策、处理日常事务和办成实事方面表现如何。我们希望 LifeVal 能成为迈向这一目标的一步。 2026 年 作者 OpenAI 继续阅读 查看全部 A thousand fewer paths to root 信息安全 2026年11月4日 加速物理世界的工程开发 研究 2026年11月3日 我们如何检测前沿模型的对齐失范行为 信息安全 2026年10月29日

llm评测 @openai-research source ↗

Chapter 01 : A vault-like structure in prokaryotes We’re sharing another finding from Anthropic’s biology research lab : the first 3D structure of a vault particle found in prokaryotic cells. Vaults are large, hollow barrels of protein found in cells across the tree of life, and their function is still unknown. Below, we describe how Claude helped at each step of this research: searching across sequence literature, optimizing a method of isolating particles, and mapping the vault’s structure. More information is in our preprint , which we’ve submitted to bioRxiv; we’ll update the link as soon as it goes live. Biological cells were first detected in 1665, but more than three and a half centuries later, much of how they work remains unknown. Until relatively recently, the existence of some crucial components , let alone their function , was controversial. Even today, more than a third of the roughly 4,400 genes in one of the most comprehensively studied cells, the bacterium E. coli , remain poorly understood . Another such enigma is the vault particle . A vault particle is a large, hollow protein shell found in nearly all the cells in our body. It was discovered in 1986 by Leonard Rome and Nancy Kedersha, but its function remains elusive. At roughly three times the mass of a ribosome, it’s one of the largest known molecular complexes in eukaryotes—organisms with complex cells, such as mammals (as opposed to simple, usually single-celled “prokaryotes,” such as bacteria). Vaults take their name from their shape. When observed under an electron microscope, the ribbed shell reminded Dr. Rome and Dr. Kedersha of the vaulted ceiling of a cathedral. In mammals, the shell is made of 78 copies of the major vault protein, arranged as two identical halves joined at the middle. Vaults are found across most of the eukaryotic tree , from slime molds to humans, so scientists believe that they must do something useful. Researchers have proposed various functions, including transporting molecules between the nucleus and cytoplasm , protecting cells from toxic compounds such as cancer drugs , and supporting innate immunity , but none of these proposals have been conclusively confirmed. Other studies have shown that mice lacking vaults still survive , which suggests that vaults may be necessary only under specific environmental conditions. Still, the question remains: why would evolution retain something so large if it didn’t have an important function? Interested in whether Claude could help make progress on this long-standing open problem, our biology research team has been investigating vaults. We haven’t yet determined their biological function, but we did find that many more vault proteins across the tree of life, including those in prokaryotes and the bacteriophages that infect them, can assemble into complete vault-like particles. Related proteins had already been found in the genomes of both prokaryotes and phages, but to our knowledge no one had shown that they assemble into vaults. A vault in a prokaryotic cell gives researchers a simpler system to study. Compared with mammalian cells, bacteria are quick to grow, which makes it easier to investigate where vaults came from, what their basic structure looks like, and what, if anything, they contain. Studying the bacterial relatives of human proteins has been informative before. Bacterial versions of cGAS–STING signaling , gasdermins , and viperins revealed the microbial origins of these human immune defenses. In those cases, their function in humans was already known. For vaults it is not, and their prokaryotic relatives may help reveal it. Here, we describe how we uncovered the molecular structure of a vault from a bacteriophage . Bacteriophages are viruses that infect bacteria. Like all viruses, they hijack their host cells to make their proteins, so this vault would be built inside a bacterium, a prokaryotic cell. The vault is built from 96 copies of a single protein, compared with 78 in human vaults. By duplicating part of the protein, we engineered the vault to be even larger. Together, these results shed light on how such complexes assemble and suggest how they could be adapted for biotechnology —for example, as nanocapsules for delivering enzymes . The cap of the L05 vault. Left: the whole vault, imaged by cryo-EM. Right: its cap seen from above. All 48 chains wind in from the rim toward the tip, overlapping as they go. Two-thirds continue past the first tier and one-third reach the tip, so the cap narrows like a stepped dome. This work also demonstrates our team’s wider aim: to speed up research in fundamental biology by building Claude into every step of the process. Under our direction, Claude searched protein databases, designed the DNA constructs, optimized the isolation method, and processed the microscopy data. As a result, a vault purification that conventionally takes three days took us about 90 minutes, and a first structural model was ready 34 hours later, which we estimate would normally have taken us weeks. Despite this progress, there is still much to be learned about these perplexing structures. When we shared the structure with Dr. Rome, whom we brought on to advise us on this research, he said: Figuring out the function of vaults is still enormously challenging. I am pleased that Anthropic has so much good data. Now, other people will be working on this problem … The broadness of Anthropic’s finding[s] suggests that it is going to be a complicated function and an interesting ride. Our lab is releasing these findings early to continue to show the scientific community how Claude can be used for discovery. You can read more about our results and methods in our preprint , and we will be releasing the structures and additional data soon. A vault-like structure in prokaryotes We uncovered the vault structure using cryo-electron microscopy (cryo-EM), in which many copies of a particle are flash-frozen and imaged with an electron beam, before being combined into a single 3D model. The vault is built from 96 copies (48 copies per half) of a single phage protein, which we call L05, with a combined mass of about 9.5 megadaltons . By contrast, the mammalian version has 39 copies per half. The phage-derived vault is also shorter and wider: roughly 54 nanometers long and 45 wide, compared with 67 by 40 in mammals. Despite being shorter, it encloses about 25% more volume because it is more spherical. The protein chain that makes up its wall is built from seven repeating segments stacked end to end, rather than the nine in mammalian vaults, and its end caps are flatter. It’s among the largest protein shells ever identified in prokaryotes. One notable feature of its structure is how the caps close. A wall 48 copies around must narrow toward the pole, and it does so in three steps, like a tiered dome. In every group of three neighboring copies, one ends at the first step, one at the second, and one continues to the tip. The three copies are identical along the wall, but take different shapes (conformations) in the cap. Given that we can make this vault in the lab and isolate it quickly, we also experimented with altering its structure to learn more about how these proteins assemble. Working with Claude, we made 15 altered versions of the protein, most with changes at the points where neighboring copies touch. Some single changes near the cap were enough to prevent the shell from closing: in place of sealed vaults we saw open, rosette-like particles, which shows that this region is needed to seal the shell. We also tried making the vault even bigger. Ordinarily, the wall is built from seven repeating segments. When we copied two of them, giving the protein nine—the same number as in the human vault—it assembled into even larger vault particles, increasing the enclosed volume by approximately 20%. These experiments demonstrate how vaults could have changed size over their evolutionary history by duplicating pieces of their own wall without disrupting how they assemble. The L05 vault (left) beside an engineered version (right) with two extra segments in every copy, both by cryo-EM at the same scale. The added repeats make the vault longer and wider. Finding, isolating, and mapping a new vault with Claude Part of the reason vaults have remained unexplained for 40 years is that they are missing from the organisms biologists rely on most for genetic experiments, including baker’s yeast, fruit flies, and nematode worms. In mice, which do have vaults, animals that are bred without a vault partner protein or the vault RNA develop normally, leaving no obvious defect to follow up. In recent years, bioinformaticians identified distant relatives of the vault protein in prokaryotes, but it wasn’t clear whether these proteins formed vaults. Our team set out to answer that question. The research required several steps: surveying genetic sequences to find where vault proteins occur across the tree of life, producing and isolating the most promising candidates to test whether they actually assemble into vault-like particles, and determining the structure of one of the particles to see how its chains fit together. We began by using Claude Science to search for the vault protein’s relatives across a database of about 15 billion predicted proteins. They turned out to be rare but widely distributed, present in 29 major groups (phyla) of bacteria and four of archaea (the other main group of prokaryotes) but in less than 1% of species with a sequenced genome. We then chose 44 of these proteins and tested each in a cell-free system to see which genes yielded full-length protein and how much. We chose the proteins, and Claude turned each protein sequence into DNA tailored to the host cell, added the control sequences that switch a gene on, and prepared the designs for ordering. We moved the best performers into living E. coli bacteria, where 15 of 24 produced soluble protein. Next, we needed to isolate the particles. The conventional method, developed for eukaryotic vaults, spins the sample through a tube of increasingly dense sugar and takes approximately three days. To speed this up, we decided to try size-exclusion chromatography. In this process, the sample flows through a column of porous beads. In a process called fractionation, small molecules get stuck in the pores, while the vaults, which are too big to enter, come out first, in what’s known as the void volume. Claude first argued against taking the chromatography approach, because clumps of misfolded protein come out in that same void volume. We went ahead anyway, and Claude helped make it work by recommending a specific column as well as methods to track the vault protein and check whether particles had formed. Claude then proposed loading the contents of ruptured cells straight onto the column with no purification beforehand. We were reluctant at first because these columns are expensive, and the raw contents of ruptured E. coli cells can clog them or cause contamination. But we were willing to test an unconventional idea, and it worked. We are not the first group to isolate vaults on sizing columns , but our optimized method takes about 90 minutes from cells to microscopy grid instead of days. Under an electron microscope, seven of the 15 proteins had assembled into vault-like particles. Cryo-EM confirmed the vault shape for four of those seven, two from phages and two from bacteria. We chose one of the phage proteins, L05, for the detailed structure described above because it was among the best at forming complete, closed particles. Determining a biomolecular structure often takes weeks or months of manual work with specialized software. We directed Claude through the whole process. Working in an internal multi-agent harness with access to internal compute resources, Claude set up an open-source processing software (RELION) and ran each step, while we advised on the analysis decisions. A first full model was ready in 34 hours, and the final maps were ready about a week after processing began. Cryo-EM of L05 vaults made in E. coli : a field of particles (large panel), selected single vaults (bottom), and 2D class averages in which the ribs of the wall are visible (right). Claude also pointed out a feature of the structure we can’t yet explain. A pocket partway up each of the 96 protein copies holds a small molecule that shows up clearly in the map but that we haven’t been able to identify. Claude found that its shape resembles coenzyme A, a common helper molecule that cells use to shuttle chemical groups around. If it is coenzyme A, or something similar, it would be an early hint at a possible function. A new way of doing science For us, this was a dramatically different way of doing science. None of us had worked with a protein assembly this large, and we had limited experience in structural biology. We took the project on anyway, because Claude could make up for what we didn’t know and rapidly perform analyses that would otherwise have taken us much longer. In under four months, we screened dozens of candidate vaults, prepared samples for the microscope, and solved the first vault structure found in prokaryotes. Most of this work could be achieved by a typical lab with access to existing Claude products. Only the cryo-EM analysis, which used hundreds of GPUs in parallel to save time, required more computing resources than might be available to an academic institution. Working this way also showed us where Claude needed improvement. A protocol it wrote called for a growth medium containing an additive that interferes with getting DNA into cells, which set the project back by two weeks. Early in the cryo-EM processing, it skipped a standard step and produced a flawed map blended with its mirror image, and we told it to stop improvising (“Please let’s do normal things unless they don’t work”). We have used what we’ve learned to inform Claude’s development. We shared our lab notes with the ML researchers who train Claude, so they could see where the model went wrong. This has informed the kind of data Claude learns from. Over the course of the project, Claude got much better at these tasks as new models arrived, making seemingly fewer errors in DNA construct design and better identifying potential pitfalls in experiments. In areas we knew well, we caught mistakes quickly, but they cost us time in areas we didn’t. Overall, we found that the benefits of working this way far outweighed the drawbacks, and Claude has become integral to our work. So far, we have made these vaults only in E. coli , and have yet to test whether they form in the bacteria and phages where they’re naturally found. More work is needed to determine the function of these particles, and our work only deepens the mystery. As Dr. Rome put it: Will we find out that they are all doing the same thing? Or will we see an evolutionary development of vault function? Maybe they are doing the same thing as human vaults, and that is also very interesting. We will continue our research into the function of vaults, and will share more as this work progresses. Work with us We are releasing the details of our work in our technical report . If you have an idea for what these vaults might be doing, or a system in which to test it, we would like to hear from you: mdurrant[at]anthropic.com , nicholasp[at]anthropic.com . Authors & acknowledgements Contributors Januka Athukoralage, Peter Yoon, Nicholas Perry, Matthew Durrant, and the Life Sciences Team at Anthropic Disclosure: Dr. Rome was a paid consultant, providing feedback on the manuscript.

llm研究生物 @anthropic-research source ↗

# CVE-2026-119272 - Chromium CVE-2026-119272: Out of bounds read This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-125: Out-of-bounds Read

浏览器越界读cve @msrc source ↗

# CVE-2026-76026 - Chromium CVE-2026-76026: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器内存破坏cve @msrc source ↗

# CVE-2026-76027 - Chromium CVE-2026-76027: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器内存破坏cve @msrc source ↗

# CVE-2026-76029 - Chromium CVE-2026-76029: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器内存破坏cve @msrc source ↗

# CVE-2026-76030 - Chromium CVE-2026-76030: Memory corruption This CVE was assigned by Chrome. Microsoft Edge (Chromium-based) ingests Chromium, which addresses this vulnerability. Please see Google Chrome Releases for more information. CWE: CWE-119: Improper Restriction of Operations within the Bounds of a Memory Buffer

浏览器内存破坏cve @msrc source ↗

The starting point: a performance tuning pass During my first month at LobeHub, I ran a performance optimization pass, documented with benchmarks in "Performance and DX Optimizations at LobeHub" . The heaviest bottlenecks in that pass were all style-related: CSS-in-JS Flexbox components like react-layout-kit numbered in the hundreds on a single page, each generating CSS; the useStyle running across almost every component recalculated styles on every re-render; and a single antd Tooltip took 0.5ms on its own. The first two could be fixed by switching styling solutions, but Tooltip required a full rewrite. I rebuilt both it and Popover with Base UI—the first time Base UI was used in lobe-ui. With those fixes in place, the remaining overhead came from antd components themselves. Since antd's UI was also notoriously hard to customize deeply, replacing it was the obvious next move. I had wanted to do this for a while, but never started because manually rewriting a codebase of this size was unrealistic, and AI wasn't capable enough yet. When we actually started, this was what we were facing: @lobehub/ui had almost a hundred component modules, with behavior tightly coupled to antd and all component styles written in Emotion-based antd-style , which generated CSS at runtime and injected it into the document on every page load. Downstream, five ecosystem libraries—icons, editor, charts, tts, and fluent-emoji—declared it as a peer dependency, and at the top layer, hundreds of business files in lobe-chat directly imported from import ... from 'antd' . Meanwhile, product features shipped weekly, so maintaining a long-running rewrite branch wasn't an option. The entire migration had to happen without interrupting delivery, split into two parallel tracks: first swap out the underlying component foundation from antd to Base UI, then switch styling from runtime Emotion to compile-time StyleX. Letting old and new components coexist in the same package lobe-ui#448 rewrote Tooltip. Beyond performance gains, it also resolved seven Linear issues: positioning drift, tooltips failing to dismiss, and elements snapping back to (0, 0) when their host unmounted. Base UI is headless, providing only behavior and accessibility while leaving DOM structure and styling to us, so we could customize everything freely without fighting antd's limitations. The next question was how to make the transition. With weekly product releases and several downstream libraries tracking our changes, ripping out antd all at once wasn't practical. Instead, I opted for coexistence: build new components with Base UI, package them alongside the antd versions, and migrate product call sites one component at a time. Throughout January 2026, we gradually added lobe-ui#444 's Base UI Menu–based DropdownMenu and ContextMenu, alongside LobeSwitch and LobeSelect. To avoid name clashes with their antd counterparts, they initially carried a Lobe prefix or a V2 suffix. On March 2, lobe-ui#467 released v5, formalizing this coexistence in the package structure: adding a @lobehub/ui/base-ui subpath where LobeSelect and LobeSwitch were moved (dropping their prefixes), while DropdownMenu, Toast, ContextMenu, and ScrollArea were exported from there as well. The package itself also became ESM-only. Subsequent components followed the exact same pattern: the implementation lived under src/base-ui/ , while the root entry only re-exported it. For instance, when lobe-ui#486 migrated Popover, @lobehub/ui and @lobehub/ui/base-ui were both valid, requiring zero changes in product code. From here on, migrating a component took just two steps: write the new implementation under base-ui, then switch the call sites in product code. Components had to be drop-in replacements, locked down with linting once migrated Between March and September, components were ported into base-ui roughly in this order: overlays, basic controls, forms, display, and layout. Overlays first This came down to two reasons. To begin with, overlays naturally belong together: Dropdown, Popover, Tooltip, Modal, and Drawer all share floating positioning and stacking management, making them ideal to tackle together. Later, lobe-ui#518 unified their z-index management under a single layer manager. The second reason was how Modal was structured. Antd's Modal is primarily declarative, requiring components to be mounted on the React tree in advance: open is false , its children still render, re-rendering whenever ancestor state updates. With multiple Modals on a page, that overhead adds up on every single render. An imperative Modal creates an instance only when invoked and destroys it when closed, shifting the cost to the user action that opens it. I previously wrote about this in "Why I Recommend Imperative Modals," and base-ui's Modal has supported both imperative and declarative patterns since its first release . In the top example, every closed Modal participates in every render; in the bottom example, only the active Modal exists in the tree. Migration windows by component category After overlays came basic controls, forms, and display components. They all followed the exact same workflow: merge the new component into base-ui, switch product call sites over, and finally ban the legacy import via ESLint. Each bar below runs from when the new component merged to when the legacy import was banned: A stark dividing line is visible around August. Before August, taking a component category from initial merge to banning legacy imports took weeks or months: Modal and Select took nearly four months, and form controls took 36 days. After August, Drawer took 5 days, Alert 6 days, Skeleton 3 days, DraggablePanel and Tree 2 days each, while ActionIcon, Avatar, Tag, and Text took just 1 day combined. The migration process hadn't changed—what changed was the models. Anthropic released Claude Fable 5 on June 9 and Claude Opus 5 on July 24. To me, Opus 5 felt exceptionally strong at front-end tasks, and at half the price of Fable 5, it cost about the same as Opus 4.8. By August, commits in lobe-chat switched from Opus 4.8 to Opus 5, and Fable 5 usage was rising too. The bars for Tabs and Segmented are also very short, but only because the initial preset banned five components all at once on June 26—not because they migrated faster. Components like DropdownMenu, Tooltip, and Popover were replaced in place at the root entry point without legacy versions to ban, so they aren't shown in the chart. Commits for each component: Modal , Menu , Tooltip , Button , Form controls , Drawer , Alert , ActionIcon and three others , Skeleton , DraggablePanel , and Tree . Each new component had to be a drop-in replacement, matching the old version in both API and visuals so switching only meant changing import paths. In lobe-ui#621, Tag's color resolution was ported straight from the old implementation: 13 preset colors, 5 system colors, and and all four variants (solid, filled, outlined, borderless) across three sizes had to match. Avatar replaced antd Avatar with native img , keeping the fallback on load failure and the +N counter for AvatarGroup. After Drawer merged, a separate commit followed to align its surface, edges, and drop shadows with antd Drawer. The ban rules lived in lobe-ui's built-in ESLint preset, inherited directly by product projects. The initial preset on June 26 deprecated and banned imports of five antd-based wrappers: Button, Modal, Segmented, Select, and Tabs. When that first version went live, product code still had numerous legacy calls, which were temporarily grandfathered via an allowlist (detailed in the next section). From that point on, rules for each component category were added to the preset only after downstream projects had cleared all legacy imports. The PR description in lobe-ui#610 was blunt: downstream migrations had removed legacy imports for these components, and this PR turned the migration boundary into an enforceable lint rule. That way, new code couldn't introduce old patterns, and legacy usage could only ever go down. On the product side: freeze new usage, then clear legacy code category by category Each time lobe-ui finished migrating a component category, lobe-chat had to update corresponding call sites. The chart below shows the number of files directly importing antd in lobe-chat, sampled biweekly: Until mid-June, this line kept rising—climbing from 338 in mid-February to 485 on June 15. While legacy calls were being replaced, new features continued using antd. By then, the team had already delegated most product coding to AI, and component precedence had long been codified into AGENTS.md and react skills: @lobehub/ui/base-ui Any component available in it had to be imported from it, with same-named components at the root entry point off-limits, leaving antd strictly as a fallback when neither had it. Agents routinely ignored this. Because training data and hundreds of existing files demonstrated antd patterns, PRs for new features kept using legacy components even after lobe-ui published replacements. To an agent, docs are merely suggestions. The only way to stop them was to make violations break the build: ESLint fails directly, and lint-staged runs the same checks in pre-commit hooks to block the commit. That was precisely what lobehub#16334 did on June 26: it adopted lobe-ui's ESLint preset, banning the five legacy wrappers (Button, Modal, Segmented, Select, Tabs) as well as antd-style's createStyles ; existing call sites (354 in total) were added to eslint-suppressions.json for temporary exemption, while any new violations failed immediately. Afterward, whenever a batch was migrated, we ran eslint --prune-suppressions , ensuring the allowlist only ever shrank. Legacy code was cleared category by category: each PR targeted only one component category, but covered the entire repository. The count dropped slowly over the summer, followed by a steep drop in early October. lobehub#20247 touched 285 files in one go, swapping out all remaining instances of Table, DatePicker, Menu, List, Input variants, and more, eliminating 163 files with direct antd imports. The PR included before-and-after screenshots compared against canary for verification, and five component library issues caught along the way were patched in lobe-ui#675 . Next, lobehub#20317 migrated forms, removing another 63 files; lobehub#20408 updated menu item types to lobe-ui's, shedding 21 files; finally, lobehub#20503 cleaned up the remainder. The two files still remaining on November 1 in the chart are test fixtures for alint. Behavioral discrepancies are harder to catch than visual differences Visual differences are easy to spot by comparing screenshots side by side, but behavioral discrepancies usually don't surface until a user saves data. After lobehub#20317 migrated forms to base-ui, the values returned on submit differed between the two: antd Form base-ui Form Returned on submit Values of currently mounted Form.Item fields only Entire form store Conditionally hidden fields Discarded Submitted together initialValues extra keys Discarded Submitted together Fields that used to be quietly dropped were now persisted together. Switching a plugin's authentication from bearer to none left the old token behind. Similarly, switching transport from HTTP to stdio kept the old URL, causing later re-installations to fetch manifests from that stale address and overwrite existing settings. lobehub#20644 added a pruneHiddenFields step before saving to prune fields that don't belong to the active type. The compatibility layer itself can introduce bugs. The ImperativeModal wrapper, created for a smooth migration, unmounted its content in the very same commit that open became false , while base-ui's panel still had a 120ms exit animation—so closing the Skill Store details modal caused the content to collapse prematurely. Instead of patching the wrapper, lobehub#17941 replaced all 11 call sites with imperative createModal Content lives inside a ModalHost and is only unmounted after the exit animation finishes. Bumping the ecosystem libraries along with lobe-ui's majors As we wrapped up the app-level cleanup, the intermediate ecosystem tier had to come along. Beyond lobe-ui, lobe-chat depends on icons, editor, charts, tts, and fluent-emoji—most of which declare lobe-ui as a peer dependency: Whenever lobe-ui bumped a major version, the ecosystem layer broke: downstream packages lost exports they still needed, or peer versions fell out of sync. As a result, we always released them all together: lobe-ui Release date icons editor charts fluent-emoji v3 (upgraded to antd v6) 2025-12-20 v3 v2 v3 v4 (static styles) 2025-12-24 v4 v3 v4 v5 (base-ui subpackage) 2026-03-02 v5 v4 v5 unchanged v6 (dropped antd) 2026-10-15 v6 v5 v6 v5 v6 was by far the biggest set of changes, split into a stacked sequence of PRs: lobe-ui#699 removed the antd components and ThemeProvider ; lobe-ui#700 dropped the antd, antd-style, and rc-* dependencies; and lobe-ui#702 merged src/base-ui completely empty. @lobehub/ui/base-ui back into the root directory, getting rid of the base-ui subpath. With the coexistence phase over, we tore down that v5 scaffolding and exported the new components straight from the root entry. In early October, the downstream libraries first ported their own component usage over to base-ui ( lobe-editor#222 and lobe-charts#32 ), before each bumped to lobe-ui 6 and stripped out antd. This cascade of changes couldn't be released and verified piecemeal. Instead, we tested across repos using pkg.pr.new preview packages: PRs for lobe-ui and the five downstream libraries each published preview packages, and lobehub#20503 pointed all dependencies to those preview URLs. We compared lobe-chat against production page by page to ensure zero visual regressions before officially publishing in dependency order and and then switched back to real version numbers. PR #20503 alone updated imports across 2,728 files, purged antd from 24 workspace packages, and finally left pnpm ls -r antd with nothing to show. Moving styles from runtime generation to build-time compilation Dropping antd took care of components, but styles were still being generated at runtime. lobe-ui wrote its component styles in antd-style, built on Emotion: on page load, JavaScript generated CSS on the fly and inserted it into the page. The initial optimization pass replaced dynamic hooks with createStaticStyles , ensuring components no longer recomputed styles on every re-render. Yet the insertion step remained. In September, lobehub#19066 pre-computed purely static calls at build time, slashing the time spent on styles during cold home page loads from ~56ms to ~28ms. The remaining ~14ms came from insertRule itself—an unavoidable cost as long as emotion was in the loop. To eliminate this remaining overhead, styles needed to compile down to plain CSS files at build time. I chose StyleX, which splits styles into deduplicated atomic classes during compilation. The underlying mechanics—and how I migrated 10,000 lines of CSS to StyleX on another project—are covered in "From Pure CSS to StyleX: Migrating 10,000 Lines of CSS with AI" . For lobe-ui 6, lobe-ui#701 piloted the approach on six components: Button, Divider, Spin, Switch, Tag, and Tooltip. Then lobe-ui#705 migrated the remaining 89 modules in one go, freeing all 95 component modules from their emotion dependency. Markup not directly rendered by lobe-ui—such as Markdown, KaTeX, and code syntax highlighting—was styled with plain CSS in @layer lobe-ui . Migrating 89 modules in a single pass succeeded thanks to per-element visual regression testing: we captured 500 demos in the documentation site across both light and dark themes while comparing computed styles for every element. Out of 1,000 runs, 891 matched completely. The remaining runs differed only because of animation timing, image loading, Mermaid layout jitter, or subpixel antialiasing differences. We also installed the packaged bundle into lobe-chat and ran the same comparison across 45 routes and 5 open menus. Here are median cold-start metrics for the authenticated home page in lobe-chat, with CPU throttled 4x and each build tested across 8 runs. Both builds had already shed antd; the only difference was whether styles were generated at runtime via emotion or compiled ahead of time via StyleX: Runtime overhead dropped across the board: document CSS rules fell from 5,817 to 4,429, blocking time decreased by 9%, and style recalculations dropped by 8%. The downside was First Contentful Paint: 4G FCP climbed from 440ms to 594ms because lobe-ui's style.css bundled styles for all 95 components, weighing in at 179KB uncompressed. In lobe-chat, it ended up in the single render-blocking stylesheet, pushing initial blocking CSS from 20.2KB to 45.5KB (gzipped). On November 2, lobe-ui#776 introduced the fix: per-component stylesheets, so applications only pull in what they use. In a benchmark app using 30 components, per-component loading yielded 45.9KB, compared to 59.5KB for the full style.css bundle. lobe-chat is currently still running on the monolithic style.css and hasn't made the switch yet. What antd was doing behind the scenes Once antd and emotion were completely removed from the dependency tree, hidden assumptions began surfacing. Beyond providing components, antd silently did plenty of heavy lifting for the entire page: setting root fonts and sizes, providing baseline icon layout, and supplying a global reset. None of this was ever stated in application code—it only became visible after antd was removed: Symptom Cause Fix Text without a font size falls back to a 16px system font antd's App previously set the font family, font size, line height, and color for everything underneath theme.css puts them back in the lowest cascade layer, @layer lobe-base , leaving html alone so rem values don't change; see lobe-ui#703 Icons sit 2–3px higher than the text beside them .anticon 's inline-flex and vertical-align were previously provided by antd styles Icon now supplies these baseline layout rules itself; see lobe-ui#705 List rows stop inheriting the app's font settings During migration, expanding the font: inherit shorthand into longhand lost font-feature-settings along with other properties only reset by the shorthand Fixed by reverting to font: inherit ; see also lobe-ui#705 ScrollShadow stops hiding scrollbars Because component styles moved into @layer lobe-ui , the app's unlayered * { scrollbar-width: thin } rule took higher priority Remove the duplicate global rule from the app, or place it below lobe-ui in the cascade The last two issues both trace back to CSS cascade layers. Placing component styles into @layer , the layer hierarchy (from lowest to highest) looked like this: Unlayered styles always beat layered styles, regardless of selector specificity. That makes overriding component styles easy, but, an offhand global rule in application code can also quietly stomp over components. The icon vertical misalignment was the trickiest to catch. The visual regression tool mentioned in lobe-ui#705 used the v6 preview as its baseline. But .anticon styles had vanished earlier when lobe-ui#699 stripped antd, so the regression was already baked into the baseline, leaving the diff completely empty. We eventually caught it with the naked eye in the Tree component. Once we added a visual comparison against an antd-era lobe-chat build, vertical alignment across 73 icons and text elements snapped into place on the home page, appearance settings, and community page—where the pre-fix preview had matched only 3. A visual regression baseline must be the last version users actually saw, not the previous commit. Conversely, bugs in the old implementation could also sneak into the baseline. emotion's cx merges multiple class names into one, which prevented the & + & divider rule in lobe-chat's workspace empty state from matching any element. After the move to StyleX, it kicked in for the first time, and the comparison tool flagged it as a diff. We kept this change as intended behavior. How much lighter is a Button after dropping antd? Because application code in the main lobe-chat bundle was also evolving over the year, comparing it before and after wouldn't isolate what changed in the component library itself. Instead, I spun up a clean Vite project rendering a single Button, building it with v5 (5.64.4, with the antd Button) and v6 (6.15.0). Both setups included only what was strictly necessary for rendering: v5 wrapped the button in ThemeProvider , while v6 imported theme.css alongside the Button stylesheet, plus a MotionProvider . Excluding React, Button-related JS dropped from ~130KB to ~32KB. The bulk of v5 came from antd and its rc-component dependencies, totaling around 287KB uncompressed; v6's 32KB mostly belongs to the motion animation library, with lobe-ui itself accounting for just ~9KB uncompressed. The tradeoff is that v6 introduces a static CSS file measuring 22.6KB gzipped, of which 16.5KB is "} theme.css design tokens, shared across all components; v5 shipped no CSS files because JavaScript generated styles at runtime, shared across all components and generated styles at runtime with JS. During benchmarking, we also uncovered an issue: importing from the root entry import { Button } from '@lobehub/ui' , both versions pulled in around 450KB of unminified —or roughly 141KB gzipped KaTeX and Markdown parsing code that had nothing to do with Button. The figures above already exclude this overhead. In v6, importing from the es/Button subpath avoids pulling it in entirely, whereas v5 only exported the root entry, leaving no way around it. The reason was that the root entry re-exported @lobehub/streamdown 's rehypeStreamAnimated , but streamdown's package.json didn't declare sideEffects , and the module top level contained impure memo() calls and displayName assignments. Because bundlers couldn't prove they were side-effect-free, they had to keep the entire Markdown rendering stack. The fix was shipped in lobehub/streamdown#7 in version 1.4.5, simply adding to package.json: "sideEffects": false . lobe-ui 6's dependency range automatically picks up this new release. After a clean reinstall, importing from the root entry matches the subpath import at 92.4KB. Beyond bundle size, we also eliminated the leftover styling overhead from antd. The share, workbench, and auth SSR apps previously had to extract antd's static CSS separately; lobehub#20503 deleted that entire pipeline. We also removed the antdOverride global stylesheet that existed solely to override antd defaults, while lobehub#21046 purged the application CSS rules written for .ant-* classes, which no longer match any elements once antd was removed. Next step: can we migrate Application Code to StyleX in One Go? With the component library migrated, styling in application code was still using the legacy styling approach: using createStaticStyles at the top of a file to write CSS in template strings, which Emotion then injected into the page at runtime. On canary, 1,112 files still follow this pattern, while around 350 have been converted to StyleX. On October 20, lobehub#21042 paved the way for writing StyleX in application code, allowing direct imports of lobe-ui design tokens. Below is a file from the homepage sidebar notifications list, shown before and after the rewrite in lobehub#21446 : Before: createStaticStyles CodeBlock Loading... After: StyleX CodeBlock Loading... Rewriting a single file isn't hard; the hard part is proving it looks identical afterward. Notice the extra property on the right: backgroundImage: 'none' on the right: the original background is a shorthand property that also resets the background image. StyleX discourages shorthand properties, which means writing only backgroundColor drops that reset. The font: inherit pitfall in the earlier table stems from the exact same issue. Visual differences like this rarely show up in screenshots, and comparing over a thousand files by eye is painfully slow and error-prone. Beyond writing a migrator, we needed an automated tool to confirm styles stayed identical before and after the rewrite and catch pitfalls like the ones above before and after. Our initial plan was to compare computed styles rather than screenshots: checking browser-computed styles before and after across themes, breakpoints, and hover or focus states for every styled element. Taking HomeSidebar ( lobehub#21446 ) and ChatInput ( lobehub#21452 ), it caught an actual regression: Params/Controls.tsx had its font: inherit expanded into longhands, causing the button to lose its font-feature-settings . The exact trap we stumbled into in the component library resurfaced during the app migration—except this time the tool caught it first. Before trusting the tool when it reported "equivalent," we had to prove the tool itself was trustworthy. That verification baseline required three things: tell noise from real differences by remaining completely stable when comparing a version against itself; catch actual regressions by flagging 100% of intentionally injected changes; and know its limits by deferring anything synthetic rendering can't cover to human review, storing those sign-offs with the source code and invalidating them whenever the code changes. Once the baseline was locked in, we re-ran all 16 migration PRs summarized in lobehub#22041 . The results fell into three buckets: proven equivalent and passed immediately, divergent and sent back for fixes, or unprovable and escalated for human review. To save reviewers from digging through logs, I built a local reporting UI. The overview lists results by file and condition, letting you click into any element to inspect evidence and see a side-by-side live comparison. Meanwhile, the sign-off page groups items by root cause for batch approval. Report overview: one row per file, one column per condition. ✓ indicates equivalent; numbers show counts of differing elements. Sign-off view: grouped by reason, with side-by-side renders comparing before and after under the same condition Summary Between December 2025 and October 2026, lobe-ui evolved from v3 to v6, direct antd imports in lobe-chat dropped from a peak of 485 files to zero, and the JS footprint for a single Button shrank from around 130KB to roughly 32KB (gzipped). Looking back, once AI and codemods made rewriting code cheap, the real bottlenecks came down to two challenges: creating coexistence mechanisms and guardrails so shipping never stopped while legacy patterns continuously shrank, and automatically proving with tooling that behavior and styles hadn't regressed. A few key practices from this year transfer well to other projects: Let new and legacy components coexist in the same package, migrating component by component. v5's base-ui subpath spared application code from an all-or-nothing rewrite, allowing us to tear down that scaffolding in v6. Migrate the highest-overhead, most interconnected layer first. Overlays share positioning and z-index logic. Declarative modals stay mounted all the time, whereas an imperative approach only incurs overhead when a modal actually opens. Make new components drop-in replacements. Match both the API and visual appearance of legacy components so app code only changes import paths, porting over quirks like Tag's color resolution verbatim. Lock down migrated categories with lint rules, grandfathering existing usage via allowlists. AGENTS.md and skills couldn't prevent AI agents from mimicking legacy antd patterns found in existing files. Import counts only began to steadily decline once we added lint rules and commit hooks on June 26. Verify equivalence via computed styles, using the version users actually see as the baseline. .anticon positioning drift and font: inherit attribute loss both slipped past screenshot diffs and "compare against previous version" checks. Isolate variables when measuring gains. Instead of benchmarking entire production bundles, spin up a dedicated project rendering only a single Button—which also uncovered our root entry tree-shaking bug.

前端性能工程实践 @innei source ↗