libbpf: fix fuzzer-reported issues
cover libbpf: fix fuzzer-reported issues
Hi, this patch set fixes several fuzzer-reported issues of libbpf when dealing with (malformed) BPF object file.
The 1st patch fix out-of-bound heap write reported by oss-fuzz (currently incorrectly marked as fixed). The 2nd and 3rd patch fix null-pointer dereference found by locally-run fuzzer.
Suggest at least taking the 1st fix in this patch set or apply an alternative fix for it (see the extra note after its commit message for detail).
Shung-Hsi Yu (3):
libbpf: use elf_getshdrnum() instead of e_shnum
libbpf: fix null-pointer dereference in find_prog_by_sec_insn()
libbpf: deal with section with no data gracefully
tools/lib/bpf/libbpf.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)
base-commit: 0326074ff4652329f2a1a9c8685104576bd8d131 --
2.37.3
PATCH 1/3 libbpf: use elf_getshdrnum() instead of e_shnum
This commit replace e_shnum with the elf_getshdrnum() helper to fix two oss-fuzz-reported heap-buffer overflow in __bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.
# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704
libbpf: loading object 'fuzz-object' from buffer
libbpf: sec_cnt is 0
libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2
libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1
=================================================================
==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8
WRITE of size 4 at 0x6020000000c0 thread T0
SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds)
#0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24
#1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16
#2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20
...The issue lie in libbpf's direct use of e_shnum field in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, when e_shnum is zero and e_shoff is not zero, will use sh_size member of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger than SHN_LORESERVE).
The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using e_shnum directly, use the elf_getshdrnum() helper provided by libelf to retrieve the section header counter into sec_cnt.
---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 && e_shoff !=0 case is encountered.
While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
tools/lib/bpf/libbpf.c +8 -2
@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;
@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; } +if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) { +pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",
@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));if (!obj->efile.secs)return -ENOMEM ;
--
2.37.3
Re: [PATCH bpf 1/3] libbpf: use elf_getshdrnum() instead of e_shnum
Quoted 64 lines · Shung-Hsi Yu
This commit replace
e_shnumwith theelf_getshdrnum()helper to fix two oss-fuzz-reported heap-buffer overflow in__bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704 libbpf: loading object 'fuzz-object' from buffer libbpf: sec_cnt is 0 libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2 libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1 ================================================================= ==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8 WRITE of size 4 at 0x6020000000c0 thread T0 SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds) #0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24 #1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16 #2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20 ...The issue lie in libbpf's direct use of
e_shnumfield in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, whene_shnumis zero ande_shoffis not zero, will usesh_sizemember of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger thanSHN_LORESERVE).The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using
e_shnumdirectly, use theelf_getshdrnum()helper provided by libelf to retrieve the section header counter intosec_cnt.Fixes 0d6988e16a12 ("libbpf: Fix section counting logic")Fixes 25bbbd7a444b ("libbpf: Remove assumptions about uniqueness of .rodata/.data/.bss maps")Signed-off-by Shung-Hsi Yu <[email protected]>---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 &&
e_shoff!=0 case is encountered.While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)tools/lib/bpf/libbpf.c +1
-1@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;
tools/lib/bpf/libbpf.c static int bpf_object__elf_init(struct bpf_object *obj) · line 1372
Quoted 4 lines
tools/lib/bpf/libbpf.c +1
-0@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; } +if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) {
It bothers me that sec_cnt is initialized in bpf_object__elf_init, but secs are allocated a bit later in bpf_object__elf_collect(). What if we move elf_getshdrnum() call and sec_cnt initialization into bpf_object__elf_collect()?
Quoted 20 lines
tools/lib/bpf/libbpf.c +6
-2+pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));if (!obj->efile.secs)return -ENOMEM ; --2.37.3
Re: [PATCH bpf 1/3] libbpf: use elf_getshdrnum() instead of e_shnum
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Shung-Hsi Yu
This commit replace
e_shnumwith theelf_getshdrnum()helper to fix two oss-fuzz-reported heap-buffer overflow in__bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704 libbpf: loading object 'fuzz-object' from buffer libbpf: sec_cnt is 0 libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2 libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1 ================================================================= ==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8 WRITE of size 4 at 0x6020000000c0 thread T0 SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds) #0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24 #1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16 #2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20 ...The issue lie in libbpf's direct use of
e_shnumfield in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, whene_shnumis zero ande_shoffis not zero, will usesh_sizemember of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger thanSHN_LORESERVE).The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using
e_shnumdirectly, use theelf_getshdrnum()helper provided by libelf to retrieve the section header counter intosec_cnt.Fixes 0d6988e16a12 ("libbpf: Fix section counting logic")Fixes 25bbbd7a444b ("libbpf: Remove assumptions about uniqueness of .rodata/.data/.bss maps")Signed-off-by Shung-Hsi Yu <[email protected]>---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 &&
e_shoff!=0 case is encountered.While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)tools/lib/bpf/libbpf.c +1
-1@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; }
Quoted 6 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_init(struct bpf_object *obj) · line 1372
Quoted 1 line
tools/lib/bpf/libbpf.c +1
-0+if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) {It bothers me that
sec_cntis initialized inbpf_object__elf_init, but secs are allocated a bit later inbpf_object__elf_collect(). What if we moveelf_getshdrnum()call andsec_cntinitialization intobpf_object__elf_collect()?
Ack.
My rational for placing it there was that it's closer to other elf_*() helper calls, but having it close to the allocation where it's used seems like a better option.
Will change accordingly and send a v2 based on top of bpf-next.
Quoted 20 lines
Quoted 20 lines
tools/lib/bpf/libbpf.c +6
-2+pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));if (!obj->efile.secs)return -ENOMEM ; --2.37.3
Re: [PATCH bpf 1/3] libbpf: use elf_getshdrnum() instead of e_shnum
Quoted 84 lines · Shung-Hsi Yu
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Shung-Hsi Yu
This commit replace
e_shnumwith theelf_getshdrnum()helper to fix two oss-fuzz-reported heap-buffer overflow in__bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704 libbpf: loading object 'fuzz-object' from buffer libbpf: sec_cnt is 0 libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2 libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1 ================================================================= ==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8 WRITE of size 4 at 0x6020000000c0 thread T0 SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds) #0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24 #1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16 #2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20 ...The issue lie in libbpf's direct use of
e_shnumfield in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, whene_shnumis zero ande_shoffis not zero, will usesh_sizemember of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger thanSHN_LORESERVE).The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using
e_shnumdirectly, use theelf_getshdrnum()helper provided by libelf to retrieve the section header counter intosec_cnt.Fixes 0d6988e16a12 ("libbpf: Fix section counting logic")Fixes 25bbbd7a444b ("libbpf: Remove assumptions about uniqueness of .rodata/.data/.bss maps")Signed-off-by Shung-Hsi Yu <[email protected]>---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 &&
e_shoff!=0 case is encountered.While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)tools/lib/bpf/libbpf.c +1
-1@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; }Quoted 6 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_init(struct bpf_object *obj) · line 1372
Quoted 1 line
tools/lib/bpf/libbpf.c +1
-0+if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) {It bothers me that
sec_cntis initialized inbpf_object__elf_init, but secs are allocated a bit later inbpf_object__elf_collect(). What if we moveelf_getshdrnum()call andsec_cntinitialization intobpf_object__elf_collect()?Ack.
My rational for placing it there was that it's closer to other elf_*() helper calls, but having it close to the allocation where it's used seems like a better option.
Will change accordingly and send a v2 based on top of bpf-next.
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
tools/lib/bpf/libbpf.c +6
-0+pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ Quoted 8 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_collect(struct bpf_object *obj) · line 3325
Quoted 8 lines
tools/lib/bpf/libbpf.c +0
-1if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));
Looking again I realized we're still allocation one more section than necessary, even after 0d6988e16a12 ("libbpf: Fix section counting logic").
elf_nextscn() skips sec #0, so (sec_cnt - 1) * sizeof(secs) should suffice.
/* In elfutils/libelf/elf_nextscn.c */
Elf_Scn *elf_nextscn (Elf *elf, Elf_Scn *scn)
{
... if (scn == NULL)
{
/* If no section handle is given return the first (not 0th) section.
Set scn to the 0th section and perform nextscn. */
if (elf->class == ELFCLASS32 || (offsetof (Elf, state.elf32.scns)
== offsetof (Elf, state.elf64.scns)))
list = &elf->state.elf32.scns;
else
list = &elf->state.elf64.scns;
scn = &list->data[0];
}
...}
What do you think? If it make sense then I'll place the sec_cnt - 1 change before the current patch unless otherwise suggested.
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c +0
-1if (!obj->efile.secs)return -ENOMEM ; --2.37.3
Re: [PATCH bpf 1/3] libbpf: use elf_getshdrnum() instead of e_shnum
Quoted 96 lines · Shung-Hsi Yu
Quoted 94 lines · Shung-Hsi Yu
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Shung-Hsi Yu
This commit replace
e_shnumwith theelf_getshdrnum()helper to fix two oss-fuzz-reported heap-buffer overflow in__bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704 libbpf: loading object 'fuzz-object' from buffer libbpf: sec_cnt is 0 libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2 libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1 ================================================================= ==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8 WRITE of size 4 at 0x6020000000c0 thread T0 SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds) #0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24 #1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16 #2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20 ...The issue lie in libbpf's direct use of
e_shnumfield in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, whene_shnumis zero ande_shoffis not zero, will usesh_sizemember of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger thanSHN_LORESERVE).The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using
e_shnumdirectly, use theelf_getshdrnum()helper provided by libelf to retrieve the section header counter intosec_cnt.Fixes 0d6988e16a12 ("libbpf: Fix section counting logic")Fixes 25bbbd7a444b ("libbpf: Remove assumptions about uniqueness of .rodata/.data/.bss maps")Signed-off-by Shung-Hsi Yu <[email protected]>---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 &&
e_shoff!=0 case is encountered.While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)tools/lib/bpf/libbpf.c +1
-1@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; }Quoted 6 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_init(struct bpf_object *obj) · line 1372
Quoted 1 line
tools/lib/bpf/libbpf.c +1
-0+if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) {It bothers me that
sec_cntis initialized inbpf_object__elf_init, but secs are allocated a bit later inbpf_object__elf_collect(). What if we moveelf_getshdrnum()call andsec_cntinitialization intobpf_object__elf_collect()?Ack.
My rational for placing it there was that it's closer to other elf_*() helper calls, but having it close to the allocation where it's used seems like a better option.
Will change accordingly and send a v2 based on top of bpf-next.
Quoted 10 lines
Quoted 10 lines
tools/lib/bpf/libbpf.c +6
-0+pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_collect(struct bpf_object *obj) · line 3325
Quoted 5 lines
tools/lib/bpf/libbpf.c +0
-1* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));Looking again I realized we're still allocation one more section than necessary, even after
0d6988e16a12("libbpf: Fix section counting logic").
Yes, that's by design so to preserve ELF's 1-based indexing and not have to constantly adjust section index by -1 to do a lookup. Please keep it as is.
Quoted 32 lines
elf_nextscn()skips sec #0, so (sec_cnt- 1) * sizeof(secs) should suffice./* In elfutils/libelf/elf_nextscn.c */ Elf_Scn *elf_nextscn (Elf *elf, Elf_Scn *scn) { ...if (scn == NULL) { /* If no section handle is given return the first (not 0th) section. Set scn to the 0th section and perform nextscn. */ if (elf->class == ELFCLASS32 || (offsetof (Elf, state.elf32.scns) == offsetof (Elf, state.elf64.scns))) list = &elf->state.elf32.scns; else list = &elf->state.elf64.scns; scn = &list->data[0]; } ...}
What do you think? If it make sense then I'll place the
sec_cnt- 1 change before the current patch unless otherwise suggested.Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c +0
-1if (!obj->efile.secs)return -ENOMEM ; --2.37.3
Re: [PATCH bpf 1/3] libbpf: use elf_getshdrnum() instead of e_shnum
Quoted 106 lines · Andrii Nakryiko
Quoted 96 lines · Shung-Hsi Yu
Quoted 94 lines · Shung-Hsi Yu
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Shung-Hsi Yu
This commit replace
e_shnumwith theelf_getshdrnum()helper to fix two oss-fuzz-reported heap-buffer overflow in__bpf_object__open. Both reports are incorrectly marked as fixed and while still being reproducible in the latest libbpf.# clusterfuzz-testcase-minimized-bpf-object-fuzzer-5747922482888704 libbpf: loading object 'fuzz-object' from buffer libbpf: sec_cnt is 0 libbpf: elf: section(1) .data, size 0, link 538976288, flags 2020202020202020, type=2 libbpf: elf: section(2) .data, size 32, link 538976288, flags 202020202020ff20, type=1 ================================================================= ==13==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000c0 at pc 0x0000005a7b46 bp 0x7ffd12214af0 sp 0x7ffd12214ae8 WRITE of size 4 at 0x6020000000c0 thread T0 SCARINESS: 46 (4-byte-write-heap-buffer-overflow-far-from-bounds) #0 0x5a7b45 in bpf_object__elf_collect /src/libbpf/src/libbpf.c:3414:24 #1 0x5733c0 in bpf_object_open /src/libbpf/src/libbpf.c:7223:16 #2 0x5739fd in bpf_object__open_mem /src/libbpf/src/libbpf.c:7263:20 ...The issue lie in libbpf's direct use of
e_shnumfield in ELF header as the section header count. Where as libelf, on the other hand, implemented an extra logic that, whene_shnumis zero ande_shoffis not zero, will usesh_sizemember of the initial section header as the real section header count (part of ELF spec to accommodate situation where section header counter is larger thanSHN_LORESERVE).The above inconsistency lead to libbpf writing into a zero-entry calloc area. So intead of using
e_shnumdirectly, use theelf_getshdrnum()helper provided by libelf to retrieve the section header counter intosec_cnt.Fixes 0d6988e16a12 ("libbpf: Fix section counting logic")Fixes 25bbbd7a444b ("libbpf: Remove assumptions about uniqueness of .rodata/.data/.bss maps")Signed-off-by Shung-Hsi Yu <[email protected]>---
To be honest I'm not sure if any of the BPF toolchain will produce such ELF binary. Tools like readelf simply refuse to dump section header table when e_shnum==0 &&
e_shoff!=0 case is encountered.While we can use same approach as readelf, opting for a coherent view with libelf for now since that should be less confusing.
--- tools/lib/bpf/libbpf.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)tools/lib/bpf/libbpf.c +1
-1@@ -597,7 +597,7 @@ struct elf_state {size_t shstrndx;/* section index for section name strings */ size_t strtabidx;struct elf_sec_desc *secs; -int sec_cnt; +size_t sec_cnt;int btf_maps_shndx;__u32 btf_maps_sec_btf_id;int text_shndx;@@ -1369,6 +1369,13 @@ static int bpf_object__elf_init(struct bpf_object *obj) goto errout; }Quoted 6 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_init(struct bpf_object *obj) · line 1372
Quoted 1 line
tools/lib/bpf/libbpf.c +1
-0+if (elf_getshdrnum (obj->efile.elf, &obj->efile.sec_cnt)) {It bothers me that
sec_cntis initialized inbpf_object__elf_init, but secs are allocated a bit later inbpf_object__elf_collect(). What if we moveelf_getshdrnum()call andsec_cntinitialization intobpf_object__elf_collect()?Ack.
My rational for placing it there was that it's closer to other elf_*() helper calls, but having it close to the allocation where it's used seems like a better option.
Will change accordingly and send a v2 based on top of bpf-next.
Quoted 10 lines
Quoted 10 lines
tools/lib/bpf/libbpf.c +6
-0+pr_warn ("elf: failed to get the number of sections for %s: %s\n" , + obj->path,elf_errmsg (-1 )); + err = -LIBBPF_ERRNO__FORMAT ; + goto errout; + } +/* Elf is corrupted/truncated, avoid calling elf_strptr. */ if (!elf_rawdata (elf_getscn (elf, obj->efile.shstrndx),NULL )) { pr_warn("elf: failed to get section names strings from %s: %s\n",@@ -3315,7 +3322,6 @@ static int bpf_object__elf_collect(struct bpf_object *obj)Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c static int bpf_object__elf_collect(struct bpf_object *obj) · line 3325
Quoted 5 lines
tools/lib/bpf/libbpf.c +0
-1* section. e_shnum does include sec #0, so e_shnum is the necessary * size of an array to keep all the sections. */ - obj->efile.sec_cnt = obj->efile.ehdr->e_shnum; obj->efile.secs =calloc (obj->efile.sec_cnt,sizeof (*obj->efile.secs));Looking again I realized we're still allocation one more section than necessary, even after
0d6988e16a12("libbpf: Fix section counting logic").
Quoted 3 lines
Yes, that's by design so to preserve ELF's 1-based indexing and not have to constantly adjust section index by -1 to do a lookup. Please keep it as is.
Understood, I'll leave it as is. Thanks!
Quoted 31 lines
Quoted 31 lines
elf_nextscn()skips sec #0, so (sec_cnt- 1) * sizeof(secs) should suffice./* In elfutils/libelf/elf_nextscn.c */ Elf_Scn *elf_nextscn (Elf *elf, Elf_Scn *scn) { ...if (scn == NULL) { /* If no section handle is given return the first (not 0th) section. Set scn to the 0th section and perform nextscn. */ if (elf->class == ELFCLASS32 || (offsetof (Elf, state.elf32.scns) == offsetof (Elf, state.elf64.scns))) list = &elf->state.elf32.scns; else list = &elf->state.elf64.scns; scn = &list->data[0]; } ...}
What do you think? If it make sense then I'll place the
sec_cnt- 1 change before the current patch unless otherwise suggested.Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c +0
-1if (!obj->efile.secs)return -ENOMEM ; --2.37.3
PATCH 2/3 libbpf: fix null-pointer dereference in find_prog_by_sec_insn()
In reply to Shung-Hsi YuWhen there are no program sections, obj->programs is left unallocated, and find_prog_by_sec_insn()'s search lands on &obj->programs[0] == NULL, and will cause null-pointer dereference in the following access to prog->sec_idx.
Guard the search with obj->nr_programs similar to what's being done in __bpf_program__iter() to prevent null-pointer access from happening.
--- tools/lib/bpf/libbpf.c | 3 +++ 1 file changed, 3 insertions(+)
tools/lib/bpf/libbpf.c +3 -0
@@ -4112,6 +4112,9 @@ static struct bpf_program *find_prog_by_sec_insn(const struct bpf_object *obj,int l =0 , r = obj->nr_programs -1 , m;struct bpf_program *prog; +if (!obj->nr_programs) +return NULL ; +while (l < r) { m = l + (r - l +1 ) /2 ; prog = &obj->programs[m];
--
2.37.3
PATCH 3/3 libbpf: deal with section with no data gracefully
In reply to Shung-Hsi YuELF section data pointer returned by libelf may be NULL (if section has SHT_NOBITS), so null check section data pointer before attempting to copy license and kversion section.
--- tools/lib/bpf/libbpf.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
tools/lib/bpf/libbpf.c +5 -1
@@ -1415,6 +1415,10 @@ static int bpf_object__check_endianness(struct bpf_object *obj)static int bpf_object__init_license (struct bpf_object *obj,void *data,size_t size) { +if (!data) { +pr_warn ("invalid license section in %s\n" , obj->path); +return -LIBBPF_ERRNO__FORMAT ; + }/* libbpf_strlcpy() only copies first N - 1 bytes, so size + 1 won't * go over allowed ELF data section buffer */
@@ -1428,7 +1432,7 @@ bpf_object__init_kversion(struct bpf_object *obj, void *data, size_t size) {__u32 kver; -if (size !=sizeof (kver)) { +if (!data || size !=sizeof (kver)) {pr_warn ("invalid kver section in %s\n" , obj->path);return -LIBBPF_ERRNO__FORMAT ; }
--
2.37.3
Quoted 17 lines · Shung-Hsi Yu
Hi, this patch set fixes several fuzzer-reported issues of libbpf when dealing with (malformed) BPF object file.
The 1st patch fix out-of-bound heap write reported by oss-fuzz (currently incorrectly marked as fixed). The 2nd and 3rd patch fix null-pointer dereference found by locally-run fuzzer.
Suggest at least taking the 1st fix in this patch set or apply an alternative fix for it (see the extra note after its commit message for detail).
Shung-Hsi Yu (3):
libbpf: useelf_getshdrnum()instead ofe_shnum
libbpf: fix null-pointer dereference infind_prog_by_sec_insn()
libbpf: deal with section with no data gracefully
Quoted 8 lines
tools/lib/bpf/libbpf.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)base-commit:
0326074ff4652329f2a1a9c8685104576bd8d131--
2.37.3
LGTM, but see my comment on patch #1. If that suggestion makes sense and will work, please send v2. But base it on top of bpf-next, I don't think there is any need to base this on bpf tree. Thanks.