fix(core): flash F4 firmware parts to their own addresses
What changed, and why it matters
This commit fixes a bug in Trezor's internal firmware flashing tools. Previously, when flashing or combining firmware for STM32F4-based devices, the second half of the firmware image was written to the wrong flash address (0x08100000) and could overwrite the 'secret sector'—a protected area that holds sensitive device secrets. The fix splits the firmware image into two parts and writes part 2 to its correct address (0x08120000). The bug is in developer/flash tooling, not in the device firmware itself, so ordinary users are not directly affected unless they use these internal tools.
Treat this as a security-relevant tooling fix. Verify that any prior STM32F4 firmware flashes performed with the affected xtask tooling did not corrupt or overwrite the secret sector. Review internal CI/release pipelines that use `xtask flash` or `xtask combine` for F4 devices. No end-user device update is required, but developers should adopt the patched tooling immediately.
Security signals we found
Incorrect flash address caused firmware part 2 to overwrite the secret sector
Fix explicitly relocates part 2 to FIRMWARE_P2_START (0x08120000)
Tooling-only fix; no runtime device firmware change
New validation ensures combined image fits within P1+P2 bounds
OpenOCD flash instructions now support multiple segments per session
Evidence from the diff
The patch changes xtask flashing/combining logic for STM32F4 models. Before, the firmware upload image was treated as one contiguous blob starting at FIRMWARE_START and padded/split to 0x08100000. That placed the second half of the firmware (.flash2 / part 2) over the secret sector. The fix introduces helpers::project_segments, which, for FIRMWARE_START projects on split-layout models, returns two segments: bytes [0..FIRMWARE_P1_MAXSIZE] at FIRMWARE_P1_START and the tail at FIRMWARE_P2_START (0x08120000). flash.rs now writes each segment to its own address in one OpenOCD session, and combine.rs uses the same segment logic when building combined images. Unit tests cover the split behavior and multi-segment OpenOCD instructions.
Changed components
core/embed/xtask/src/flash.rscore/embed/xtask/src/combine.rscore/embed/xtask/src/helpers.rscore/embed/projects/firmware/project.tomlcore/embed/xtask/src/main.rsInspect captured patch +281 / −95
### core/embed/projects/firmware/project.toml
@@ -50,7 +50,9 @@ uses = [
# The order of sections is important.
elf_sections = [".vendorheader", ".header", ".flash", ".data"]
-# STM32F4: firmware spans two non-contiguous flash banks (bank2 starts at 0x08100000)
+# STM32F4: firmware spans two non-contiguous flash areas. The image is the
+# bootloader's upload format: part 1 padded to FIRMWARE_P1_MAXSIZE, followed by
+# part 2, which belongs at FIRMWARE_P2_START (0x08120000), not 0x08100000.
split_pad_to = "0x08100000"
split_part2_sections = [".flash2"]
### core/embed/xtask/src/combine.rs
@@ -16,6 +16,19 @@ pub fn combined_artifact(model: Model, project: Project) -> Result<PathBuf> {
.join(format!("{COMBINED_PREFIX}{}.bin", project.binary_name())))
}
+/// The flash address a combined image starts at: the boardloader's, since
+/// the image runs from the bottom of the boot chain up.
+fn combined_start(memory_ld: &str) -> Result<u32> {
+ helpers::read_symbol_from_content(memory_ld, "BOARDLOADER_START")
+}
+
+/// Where a combined image lands in flash, as `(address, bytes)` pairs: one
+/// segment from [`combined_start`], gaps included, exactly as [`combine`] laid
+/// it out.
+pub fn combined_segments<'a>(memory_ld: &str, image: &'a [u8]) -> Result<Vec<(u32, &'a [u8])>> {
+ Ok(vec![(combined_start(memory_ld)?, image)])
+}
+
/// Byte used to pad the gaps between combined sections. Matches the original
/// `combine_firmware.py`, which padded with zero bytes.
const SECTION_PADDING: u8 = 0x00;
@@ -79,36 +92,30 @@ fn place_section(binary: &mut Vec<u8>, offset: usize, data: &[u8]) -> Result<()>
Ok(())
}
-/// The sections a combined image holds ABOVE the boardloader, in flash order:
-/// the linker symbol naming where the section starts, paired with the project
-/// whose binary goes there. `None` if the project cannot head a combined image.
+/// The projects a combined image holds ABOVE the boardloader, in flash order.
+/// Where each one lands comes from [`helpers::project_segments`]. `None` if the
+/// project cannot head a combined image.
///
/// This is the single source of truth for what can be combined. `flash
/// --combined` asks the same question through [`supported`] rather than keeping
/// its own list, so the two cannot disagree about which projects are valid.
-fn sections(project: Project) -> Option<&'static [(&'static str, Project)]> {
+fn projects(project: Project) -> Option<&'static [Project]> {
Some(match project {
- Project::Bootloader => &[("BOOTLOADER_START", Project::Bootloader)],
- Project::BootloaderCi => &[("BOOTLOADER_START", Project::BootloaderCi)],
- Project::Firmware => &[
- ("BOOTLOADER_START", Project::Bootloader),
- ("FIRMWARE_START", Project::Firmware),
- ],
- Project::Prodtest => &[
- ("BOOTLOADER_START", Project::Bootloader),
- ("FIRMWARE_START", Project::Prodtest),
- ],
+ Project::Bootloader => &[Project::Bootloader],
+ Project::BootloaderCi => &[Project::BootloaderCi],
+ Project::Firmware => &[Project::Bootloader, Project::Firmware],
+ Project::Prodtest => &[Project::Bootloader, Project::Prodtest],
_ => return None,
})
}
-/// Whether a combined image can be built for `project` -- see [`sections`].
+/// Whether a combined image can be built for `project` -- see [`projects`].
pub fn supported(project: Project) -> bool {
- sections(project).is_some()
+ projects(project).is_some()
}
/// The projects that can head a combined image, as a comma-separated list.
-/// Derived from [`sections`] so error messages cannot name a stale set.
+/// Derived from [`projects`] so error messages cannot name a stale set.
pub fn supported_projects() -> String {
Project::value_variants()
.iter()
@@ -121,40 +128,32 @@ pub fn supported_projects() -> String {
/// Combines multiple firmware projects into a single binary for flashing.
///
/// The combined image starts at `BOARDLOADER_START` (the address it is flashed
-/// to) and places every section at its real offset within flash, padding the
-/// gaps between sections. Which sections those are comes from [`sections`].
+/// to) and places every project at its real offset within flash, padding the
+/// gaps between them. Which projects those are comes from [`projects`].
pub fn combine(args: CombineArgs) -> Result<()> {
let memory_ld = args.model.model_memory_ld()?;
+ let content = fs::read_to_string(&memory_ld)
+ .with_context(|| format!("Failed to read `{}`", memory_ld.display()))?;
// All offsets are relative to the boardloader, which sits at the start of
// the combined image.
- let base = helpers::read_symbol(&memory_ld, "BOARDLOADER_START")?;
- let offset_of = |symbol: &str| -> Result<usize> {
- Ok((helpers::read_symbol(&memory_ld, symbol)? - base) as usize)
- };
-
- let mut binary = Vec::new();
+ let base = combined_start(&content)?;
- place_section(
- &mut binary,
- 0,
- &load_binary(args.model, Project::Boardloader)?,
- )?;
-
- let sections = sections(args.project).ok_or_else(|| {
+ let projects = projects(args.project).ok_or_else(|| {
anyhow::anyhow!(
"Combining is not supported for `{}` -- only {}",
args.project.binary_name(),
supported_projects()
)
})?;
- for (symbol, project) in sections {
- place_section(
- &mut binary,
- offset_of(symbol)?,
- &load_binary(args.model, *project)?,
- )?;
+ let mut binary = Vec::new();
+
+ for project in [Project::Boardloader].iter().chain(projects) {
+ let data = load_binary(args.model, *project)?;
+ for (address, segment) in helpers::project_segments(&content, *project, &data)? {
+ place_section(&mut binary, (address - base) as usize, segment)?;
+ }
}
erase_boot_ucb(&mut binary, &memory_ld, base)?;
@@ -188,7 +187,18 @@ pub fn combine(args: CombineArgs) -> Result<()> {
#[cfg(test)]
mod tests {
- use super::{ERASED_PADDING, SECTION_PADDING, erase_boot_ucb, place_section};
+ use super::{
+ ERASED_PADDING, SECTION_PADDING, combined_segments, erase_boot_ucb, place_section,
+ };
+
+ /// A combined image is written whole from the boardloader, gaps included.
+ #[test]
+ fn combined_image_is_one_segment_from_the_boardloader() {
+ let image = [1u8; 32];
+ let segments = combined_segments("BOARDLOADER_START = 0xc004000;\n", &image).unwrap();
+
+ assert_eq!(segments, vec![(0x0c00_4000, &image[..])]);
+ }
#[test]
fn places_sections_at_their_offsets_and_pads_gaps() {
### core/embed/xtask/src/flash.rs
@@ -1,29 +1,23 @@
-use std::path::Path;
+use std::io::Write;
+use std::path::{Path, PathBuf};
use std::{fs, process};
use anyhow::{Context, Result, ensure};
-use crate::args::{FlashArgs, FlashEraseArgs, FlashSection, Model, Project, ResetArgs};
+use crate::args::{FlashArgs, FlashEraseArgs, FlashSection, Model, ResetArgs};
use crate::{combine, helpers};
/// Flashes the specified project to the device using OpenOCD.
-pub fn flash(args: FlashArgs) -> Result<()> {
+pub fn flash_project(args: FlashArgs) -> Result<()> {
ensure!(
args.project.flashable(),
"Flashing is not supported for `{}`",
args.project.binary_name()
);
- // A combined image already holds the whole boot chain, assembled by
- // `xtask combine`, so it is written as-is from the boardloader address --
- // before any single-project binary is resolved, since it is not one.
- if args.combined {
- return flash_combined(&args);
- }
-
- // An explicitly given file replaces the build artifact; the address below is
- // still derived from the project + model, so a prebuilt binary lands exactly
- // where that project belongs.
+ // An explicitly given file replaces the build artifact; the addresses below
+ // are still derived from the project + model, so a prebuilt binary lands
+ // exactly where that project belongs.
let binary = match args.file {
Some(ref file) => file.clone(),
None => {
@@ -35,28 +29,24 @@ pub fn flash(args: FlashArgs) -> Result<()> {
.canonicalize()
.with_context(|| format!("Failed to locate `{}` for flashing", binary.display()))?;
- let flash_start = args.project.flash_start_symbol()?;
let memory_ld = args.model.model_memory_ld()?;
- let address = helpers::read_symbol(&memory_ld, flash_start)?;
-
- println!(
- "Flashing `{}` to address 0x{:08X}",
- binary.display(),
- address
- );
-
- let flash_instruction = build_flash_write_instruction(&binary, address)?;
-
- run_openocd(args.model, &flash_instruction)
+ let content = fs::read_to_string(&memory_ld)
+ .with_context(|| format!("Failed to read `{}`", memory_ld.display()))?;
+ let image =
+ fs::read(&binary).with_context(|| format!("Failed to read `{}`", binary.display()))?;
+ let segments = helpers::project_segments(&content, args.project, &image)?;
+
+ println!("Flashing `{}`", binary.display());
+ flash_segments(args.model, &segments)
}
/// Flash the combined image: the whole boot chain in one write.
///
-/// Written byte for byte as `xtask combine` produced it, starting at the
-/// boardloader. The project name only says WHICH combined image; the image
-/// always starts at the bottom of the chain, so nothing about its contents is
-/// decided here.
-fn flash_combined(args: &FlashArgs) -> Result<()> {
+/// Written byte for byte as `xtask combine` produced it, placed by
+/// [`combine::combined_segments`]. The project name only says WHICH combined
+/// image; the image always starts at the bottom of the chain, so nothing about
+/// its contents is decided here.
+pub fn flash_combined(args: FlashArgs) -> Result<()> {
ensure!(
combine::supported(args.project),
"there is no combined image for `{}` -- a combined image runs from the \
@@ -66,9 +56,7 @@ fn flash_combined(args: &FlashArgs) -> Result<()> {
);
// `--file` names the combined image to write, the same way it replaces the
- // artifact on the single-project path: WHAT is written, never WHERE. The
- // address below stays the boardloader's, because that is what a combined
- // image starts at whatever produced it.
+ // artifact on the single-project path: WHAT is written, never WHERE.
let binary = match args.file {
Some(ref file) => file
.canonicalize()
@@ -88,19 +76,18 @@ fn flash_combined(args: &FlashArgs) -> Result<()> {
};
let memory_ld = args.model.model_memory_ld()?;
- let address = helpers::read_symbol(&memory_ld, Project::Boardloader.flash_start_symbol()?)?;
+ let content = fs::read_to_string(&memory_ld)
+ .with_context(|| format!("Failed to read `{}`", memory_ld.display()))?;
+ let image =
+ fs::read(&binary).with_context(|| format!("Failed to read `{}`", binary.display()))?;
+ let segments = combine::combined_segments(&content, &image)?;
println!(
- "Flashing the combined `{}` image `{}` to address 0x{:08X}",
+ "Flashing the combined `{}` image `{}`",
args.project.binary_name(),
- binary.display(),
- address
+ binary.display()
);
-
- // `?`: quoting the path is fallible since the Tcl-quoting validation landed
- // (a path that would break out of the braced word is rejected).
- let flash_instruction = build_flash_write_instruction(&binary, address)?;
- run_openocd(args.model, &flash_instruction)
+ flash_segments(args.model, &segments)
}
/// Erase specified flash section using OpenOCD. The section boundaries are
@@ -121,6 +108,63 @@ pub fn reset(args: ResetArgs) -> Result<()> {
run_openocd(args.model, "init; reset; exit")
}
+/// Flashes `(address, bytes)` segments, each written to its own address in a
+/// single OpenOCD session.
+///
+/// Every segment goes through a temporary file, since `flash write_image` takes
+/// a whole file.
+fn flash_segments(model: Model, segments: &[(u32, &[u8])]) -> Result<()> {
+ let dir = TempDir::new()?;
+ let mut files = Vec::new();
+ for (i, (address, data)) in segments.iter().enumerate() {
+ let path = dir.0.join(format!("segment-{i}.bin"));
+ fs::File::create_new(&path)
+ .and_then(|mut file| file.write_all(data))
+ .with_context(|| format!("Failed to write `{}`", path.display()))?;
+ println!(
+ "Writing segment {}/{} ({} bytes) to address 0x{:08X}",
+ i + 1,
+ segments.len(),
+ data.len(),
+ address
+ );
+ files.push((path, *address));
+ }
+
+ let instruction = build_flash_write_instruction(&files)?;
+ run_openocd(model, &instruction)
+}
+
+/// A freshly created directory under the system temp dir, removed on drop.
+///
+/// `create` fails if the path already exists, so nothing planted there
+/// beforehand (a file, or a symlink elsewhere) is ever written through. On Unix
+/// the directory is owner-only from the start, so no other user can swap a
+/// segment file before OpenOCD reads it.
+struct TempDir(PathBuf);
+
+impl TempDir {
+ fn new() -> Result<Self> {
+ let nanos = std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .map_or(0, |d| d.subsec_nanos());
+ let path = std::env::temp_dir().join(format!("xtask-flash-{}-{nanos:08x}", process::id()));
+ let mut builder = fs::DirBuilder::new();
+ #[cfg(unix)]
+ std::os::unix::fs::DirBuilderExt::mode(&mut builder, 0o700);
+ builder
+ .create(&path)
+ .with_context(|| format!("Failed to create `{}`", path.display()))?;
+ Ok(Self(path))
+ }
+}
+
+impl Drop for TempDir {
+ fn drop(&mut self) {
+ let _ = fs::remove_dir_all(&self.0);
+ }
+}
+
/// Runs OpenOCD instructions against the connected device for the given model.
fn run_openocd(model: Model, instructions: &str) -> Result<()> {
let model_config = model.config()?;
@@ -180,12 +224,17 @@ fn tcl_quote_path(path: &Path) -> Result<String> {
Ok(format!("{{{path}}}"))
}
-fn build_flash_write_instruction(binary: &Path, address: u32) -> Result<String> {
- Ok(format!(
- "init; reset halt; flash write_image erase {} 0x{:X}; exit",
- tcl_quote_path(binary)?,
- address
- ))
+fn build_flash_write_instruction(files: &[(PathBuf, u32)]) -> Result<String> {
+ let mut instr = String::from("init; reset halt; ");
+ for (path, address) in files {
+ instr.push_str(&format!(
+ "flash write_image erase {} 0x{:X}; ",
+ tcl_quote_path(path)?,
+ address
+ ));
+ }
+ instr.push_str("exit");
+ Ok(instr)
}
fn build_flash_erase_instruction(content: &str, section: FlashSection) -> Result<String> {
@@ -226,30 +275,47 @@ fn build_flash_erase_instruction(content: &str, section: FlashSection) -> Result
#[cfg(test)]
mod tests {
- use std::path::Path;
+ use std::path::{Path, PathBuf};
use super::{build_flash_erase_instruction, build_flash_write_instruction, tcl_quote_path};
use crate::args::FlashSection;
#[test]
fn builds_flash_write_instruction() {
let instruction =
- build_flash_write_instruction(Path::new("/tmp/fw.bin"), 0x0800_4000).unwrap();
+ build_flash_write_instruction(&[(PathBuf::from("/tmp/fw.bin"), 0x0800_4000)]).unwrap();
assert_eq!(
instruction,
"init; reset halt; flash write_image erase {/tmp/fw.bin} 0x8004000; exit"
);
}
+ #[test]
+ fn builds_flash_write_instruction_for_several_segments() {
+ let instruction = build_flash_write_instruction(&[
+ (PathBuf::from("/tmp/p1.bin"), 0x0804_0000),
+ (PathBuf::from("/tmp/p2.bin"), 0x0812_0000),
+ ])
+ .unwrap();
+
+ assert_eq!(
+ instruction,
+ "init; reset halt; flash write_image erase {/tmp/p1.bin} 0x8040000; \
+ flash write_image erase {/tmp/p2.bin} 0x8120000; exit"
+ );
+ }
+
/// `--file` accepts any path the user types, and openocd parses the `-c`
/// script as Tcl: unquoted, a space would split the filename into two Tcl
/// words and `[...]` would be command substitution.
#[test]
fn quotes_paths_that_tcl_would_otherwise_reparse() {
- let instruction =
- build_flash_write_instruction(Path::new("/my builds/fw [v2].bin"), 0x0800_4000)
- .unwrap();
+ let instruction = build_flash_write_instruction(&[(
+ PathBuf::from("/my builds/fw [v2].bin"),
+ 0x0800_4000,
+ )])
+ .unwrap();
assert_eq!(
instruction,
### core/embed/xtask/src/helpers.rs
@@ -186,6 +186,49 @@ pub fn read_symbol_from_content(content: &str, symbol: &str) -> Result<u32> {
parse_address(value).with_context(|| format!("Invalid address `{value}` for `{symbol}`"))
}
+/// Splits a project's image into the flash segments it occupies, as
+/// `(address, bytes)` pairs in ascending address order.
+///
+/// Most images are one contiguous segment at the project's flash start symbol.
+/// The exception is the firmware area on models where it is split into two
+/// parts (`FIRMWARE_P1_*` and `FIRMWARE_P2_*` in memory.ld, STM32F4): the
+/// image is still one file, the same one the bootloader receives on upload,
+/// but the bytes past `FIRMWARE_P1_MAXSIZE` belong at `FIRMWARE_P2_START`, not
+/// right after part 1 -- between the two parts lie the secret, assets and
+/// storage sectors.
+pub fn project_segments<'a>(
+ memory_ld: &str,
+ project: Project,
+ image: &'a [u8],
+) -> Result<Vec<(u32, &'a [u8])>> {
+ let start_symbol = project.flash_start_symbol()?;
+ let start = read_symbol_from_content(memory_ld, start_symbol)?;
+
+ if start_symbol != "FIRMWARE_START" {
+ return Ok(vec![(start, image)]);
+ }
+ let Ok(p1_size) = read_symbol_from_content(memory_ld, "FIRMWARE_P1_MAXSIZE") else {
+ return Ok(vec![(start, image)]);
+ };
+
+ let p1_start = read_symbol_from_content(memory_ld, "FIRMWARE_P1_START")?;
+ if image.len() <= p1_size as usize {
+ return Ok(vec![(p1_start, image)]);
+ }
+
+ let p2_start = read_symbol_from_content(memory_ld, "FIRMWARE_P2_START")?;
+ let p2_size = read_symbol_from_content(memory_ld, "FIRMWARE_P2_MAXSIZE")?;
+ let (part1, part2) = image.split_at(p1_size as usize);
+ anyhow::ensure!(
+ part2.len() <= p2_size as usize,
+ "firmware image ({} bytes) does not fit FIRMWARE_P1 + FIRMWARE_P2 ({} bytes)",
+ image.len(),
+ p1_size as usize + p2_size as usize
+ );
+
+ Ok(vec![(p1_start, part1), (p2_start, part2)])
+}
+
/// Parses a string as a u32 address, supporting both decimal and
/// hexadecimal formats.
fn parse_address(value: &str) -> Result<u32> {
@@ -216,7 +259,71 @@ pub fn print_version(args: PrintVersionArgs) -> Result<()> {
mod tests {
use std::fs;
- use super::{parse_address, parse_version_file, read_symbol_from_content};
+ use super::{parse_address, parse_version_file, project_segments, read_symbol_from_content};
+ use crate::args::Project;
+
+ const SPLIT_MEMORY_LD: &str = "FIRMWARE_START = 0x8040000;\n\
+ FIRMWARE_P1_START = 0x8040000;\nFIRMWARE_P1_MAXSIZE = 0x10;\n\
+ FIRMWARE_P2_START = 0x8120000;\nFIRMWARE_P2_MAXSIZE = 0x8;\n";
+
+ #[test]
+ fn segments_without_split_is_one_segment() {
+ let image = [1u8; 32];
+ let segments =
+ project_segments("FIRMWARE_START = 0x8010000;\n", Project::Firmware, &image).unwrap();
+
+ assert_eq!(segments, vec![(0x0801_0000, &image[..])]);
+ }
+
+ #[test]
+ fn segments_fitting_part1_is_one_segment() {
+ let image = [1u8; 0x10];
+ let segments = project_segments(SPLIT_MEMORY_LD, Project::Firmware, &image).unwrap();
+
+ assert_eq!(segments, vec![(0x0804_0000, &image[..])]);
+ }
+
+ #[test]
+ fn segments_places_tail_at_part2() {
+ let image: Vec<u8> = (0..0x14).collect();
+ let segments = project_segments(SPLIT_MEMORY_LD, Project::Firmware, &image).unwrap();
+
+ assert_eq!(
+ segments,
+ vec![(0x0804_0000, &image[..0x10]), (0x0812_0000, &image[0x10..])]
+ );
+ }
+
+ #[test]
+ fn segments_rejects_image_larger_than_both_parts() {
+ let image = [1u8; 0x19];
+ let error = project_segments(SPLIT_MEMORY_LD, Project::Firmware, &image).unwrap_err();
+
+ assert!(error.to_string().contains("does not fit"));
+ }
+
+ /// Prodtest shares the firmware area, so the same split applies to it.
+ #[test]
+ fn segments_split_prodtest_like_firmware() {
+ let image: Vec<u8> = (0..0x14).collect();
+ let segments = project_segments(SPLIT_MEMORY_LD, Project::Prodtest, &image).unwrap();
+
+ assert_eq!(
+ segments,
+ vec![(0x0804_0000, &image[..0x10]), (0x0812_0000, &image[0x10..])]
+ );
+ }
+
+ /// Only the firmware area is split; other projects stay one segment at
+ /// their own start symbol, however large.
+ #[test]
+ fn segments_of_other_projects_are_never_split() {
+ let memory_ld = format!("{SPLIT_MEMORY_LD}BOOTLOADER_START = 0x8020000;\n");
+ let image = [1u8; 0x20];
+ let segments = project_segments(&memory_ld, Project::Bootloader, &image).unwrap();
+
+ assert_eq!(segments, vec![(0x0802_0000, &image[..])]);
+ }
#[test]
fn parses_version_file_symbols() {
### core/embed/xtask/src/main.rs
@@ -13,7 +13,8 @@ fn main() -> Result<()> {
Cmd::Test(args) => cargo::test(args),
Cmd::Clean => cargo::clean(),
Cmd::Fmt => cargo::fmt(),
- Cmd::Flash(args) => flash::flash(args),
+ Cmd::Flash(args) if args.combined => flash::flash_combined(args),
+ Cmd::Flash(args) => flash::flash_project(args),
Cmd::FlashErase(args) => flash::flash_erase(args),
Cmd::Reset(args) => flash::reset(args),
Cmd::Upload(args) => upload::upload(args),Why this scored 57/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.