Branch data Line data Source code
1 : : /* Pedantic checking of ELF files compliance with gABI/psABI spec.
2 : : Copyright (C) 2001-2015, 2017, 2018 Red Hat, Inc.
3 : : Copyright (C) 2023 Mark J. Wielaard <mark@klomp.org>
4 : : This file is part of elfutils.
5 : : Written by Ulrich Drepper <drepper@redhat.com>, 2001.
6 : :
7 : : This file is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3 of the License, or
10 : : (at your option) any later version.
11 : :
12 : : elfutils is distributed in the hope that it will be useful, but
13 : : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 : :
20 : : #ifdef HAVE_CONFIG_H
21 : : # include <config.h>
22 : : #endif
23 : :
24 : : #include <argp.h>
25 : : #include <assert.h>
26 : : #include <byteswap.h>
27 : : #include <endian.h>
28 : : #include <fcntl.h>
29 : : #include <gelf.h>
30 : : #include <inttypes.h>
31 : : #include <locale.h>
32 : : #include <stdbool.h>
33 : : #include <stdlib.h>
34 : : #include <string.h>
35 : : #include <unistd.h>
36 : : #include <sys/stat.h>
37 : :
38 : : #include <elf-knowledge.h>
39 : : #include <libeu.h>
40 : : #include <system.h>
41 : : #include <printversion.h>
42 : : #include "../libelf/libelfP.h"
43 : : #include "../libelf/common.h"
44 : : #include "../libebl/libeblP.h"
45 : : #include "../libdw/libdwP.h"
46 : : #include "../libdwfl/libdwflP.h"
47 : : #include "../libdw/memory-access.h"
48 : :
49 : :
50 : : /* Name and version of program. */
51 : : ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
52 : :
53 : : /* Bug report address. */
54 : : ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
55 : :
56 : : #define ARGP_strict 300
57 : : #define ARGP_gnuld 301
58 : :
59 : : /* Definitions of arguments for argp functions. */
60 : : static const struct argp_option options[] =
61 : : {
62 : : { "strict", ARGP_strict, NULL, 0,
63 : : N_("Be extremely strict, flag level 2 features."), 0 },
64 : : { "quiet", 'q', NULL, 0, N_("Do not print anything if successful"), 0 },
65 : : { "debuginfo", 'd', NULL, 0, N_("Binary is a separate debuginfo file"), 0 },
66 : : { "gnu-ld", ARGP_gnuld, NULL, 0,
67 : : N_("Binary has been created with GNU ld and is therefore known to be \
68 : : broken in certain ways"), 0 },
69 : : { NULL, 0, NULL, 0, NULL, 0 }
70 : : };
71 : :
72 : : /* Short description of program. */
73 : : static const char doc[] = N_("\
74 : : Pedantic checking of ELF files compliance with gABI/psABI spec.");
75 : :
76 : : /* Strings for arguments in help texts. */
77 : : static const char args_doc[] = N_("FILE...");
78 : :
79 : : /* Prototype for option handler. */
80 : : static error_t parse_opt (int key, char *arg, struct argp_state *state);
81 : :
82 : : /* Data structure to communicate with argp functions. */
83 : : static struct argp argp =
84 : : {
85 : : options, parse_opt, args_doc, doc, NULL, NULL, NULL
86 : : };
87 : :
88 : :
89 : : /* Declarations of local functions. */
90 : : static void process_file (int fd, Elf *elf, const char *prefix,
91 : : const char *suffix, const char *fname, size_t size,
92 : : bool only_one);
93 : : static void process_elf_file (Elf *elf, const char *prefix, const char *suffix,
94 : : const char *fname, size_t size, bool only_one);
95 : : static void check_note_section (Ebl *ebl, GElf_Ehdr *ehdr,
96 : : GElf_Shdr *shdr, int idx);
97 : :
98 : :
99 : : /* Report an error. */
100 : : #define ERROR(str, args...) \
101 : : do { \
102 : : printf (str, ##args); \
103 : : ++error_count; \
104 : : } while (0)
105 : : static unsigned int error_count;
106 : :
107 : : /* True if we should perform very strict testing. */
108 : : static bool be_strict;
109 : :
110 : : /* True if no message is to be printed if the run is successful. */
111 : : static bool be_quiet;
112 : :
113 : : /* True if binary is from strip -f, not a normal ELF file. */
114 : : static bool is_debuginfo;
115 : :
116 : : /* True if binary is assumed to be generated with GNU ld. */
117 : : static bool gnuld;
118 : :
119 : : /* Index of section header string table. */
120 : : static uint32_t shstrndx;
121 : :
122 : : /* Array to count references in section groups. */
123 : : static int *scnref;
124 : :
125 : : /* Numbers of sections and program headers. */
126 : : static unsigned int shnum;
127 : : static unsigned int phnum;
128 : :
129 : :
130 : : int
131 : 386 : main (int argc, char *argv[])
132 : : {
133 : : /* Set locale. */
134 : 386 : setlocale (LC_ALL, "");
135 : :
136 : : /* Initialize the message catalog. */
137 : 386 : textdomain (PACKAGE_TARNAME);
138 : :
139 : : /* Parse and process arguments. */
140 : 386 : int remaining;
141 : 386 : argp_parse (&argp, argc, argv, 0, &remaining, NULL);
142 : :
143 : : /* Before we start tell the ELF library which version we are using. */
144 : 386 : elf_version (EV_CURRENT);
145 : :
146 : : /* Now process all the files given at the command line. */
147 : 386 : bool only_one = remaining + 1 == argc;
148 : 386 : do
149 : : {
150 : : /* Open the file. */
151 : 386 : int fd = open (argv[remaining], O_RDONLY);
152 [ - + ]: 386 : if (fd == -1)
153 : : {
154 : 0 : error (0, errno, _("cannot open input file '%s'"), argv[remaining]);
155 : 0 : continue;
156 : : }
157 : :
158 : : /* Create an `Elf' descriptor. */
159 : 386 : Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
160 [ - + ]: 386 : if (elf == NULL)
161 : 0 : ERROR (_("cannot generate Elf descriptor for '%s': %s\n"),
162 : : argv[remaining], elf_errmsg (-1));
163 : : else
164 : : {
165 : 386 : unsigned int prev_error_count = error_count;
166 : 386 : struct stat st;
167 : :
168 [ - + ]: 386 : if (fstat (fd, &st) != 0)
169 : : {
170 : 0 : printf ("cannot stat '%s': %m\n", argv[remaining]);
171 : 0 : close (fd);
172 : 0 : continue;
173 : : }
174 : :
175 : 386 : process_file (fd, elf, NULL, NULL, argv[remaining], st.st_size,
176 : : only_one);
177 : :
178 : : /* Now we can close the descriptor. */
179 [ - + ]: 386 : if (elf_end (elf) != 0)
180 : 0 : ERROR (_("error while closing Elf descriptor: %s\n"),
181 : : elf_errmsg (-1));
182 : :
183 [ + + + + ]: 386 : if (prev_error_count == error_count && !be_quiet)
184 : 276 : puts (_("No errors"));
185 : : }
186 : :
187 : 386 : close (fd);
188 : : }
189 [ - + ]: 386 : while (++remaining < argc);
190 : :
191 : 386 : return error_count != 0;
192 : : }
193 : :
194 : :
195 : : /* Handle program arguments. */
196 : : static error_t
197 : 2446 : parse_opt (int key, char *arg __attribute__ ((unused)),
198 : : struct argp_state *state __attribute__ ((unused)))
199 : : {
200 [ - + + + : 2446 : switch (key)
- + ]
201 : : {
202 : 0 : case ARGP_strict:
203 : 0 : be_strict = true;
204 : 0 : break;
205 : :
206 : 108 : case 'q':
207 : 108 : be_quiet = true;
208 : 108 : break;
209 : :
210 : 40 : case 'd':
211 : 40 : is_debuginfo = true;
212 : 40 : break;
213 : :
214 : 368 : case ARGP_gnuld:
215 : 368 : gnuld = true;
216 : 368 : break;
217 : :
218 : 0 : case ARGP_KEY_NO_ARGS:
219 : 0 : fputs (_("Missing file name.\n"), stderr);
220 : 0 : argp_help (&argp, stderr, ARGP_HELP_SEE, program_invocation_short_name);
221 : 0 : exit (EXIT_FAILURE);
222 : :
223 : : default:
224 : : return ARGP_ERR_UNKNOWN;
225 : : }
226 : : return 0;
227 : : }
228 : :
229 : :
230 : : /* Process one file. */
231 : : static void
232 : 386 : process_file (int fd, Elf *elf, const char *prefix, const char *suffix,
233 : : const char *fname, size_t size, bool only_one)
234 : : {
235 : : /* We can handle two types of files: ELF files and archives. */
236 : 386 : Elf_Kind kind = elf_kind (elf);
237 : :
238 [ + - - ]: 386 : switch (kind)
239 : : {
240 : 386 : case ELF_K_ELF:
241 : : /* Yes! It's an ELF file. */
242 : 386 : process_elf_file (elf, prefix, suffix, fname, size, only_one);
243 : 386 : break;
244 : :
245 : 0 : case ELF_K_AR:
246 : 0 : {
247 : 0 : Elf *subelf;
248 : 0 : Elf_Cmd cmd = ELF_C_READ_MMAP;
249 [ # # ]: 0 : size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
250 : 0 : size_t fname_len = strlen (fname) + 1;
251 : 0 : char new_prefix[prefix_len + 1 + fname_len];
252 [ # # ]: 0 : char new_suffix[(suffix == NULL ? 0 : strlen (suffix)) + 2];
253 : 0 : char *cp = new_prefix;
254 : :
255 : : /* Create the full name of the file. */
256 [ # # ]: 0 : if (prefix != NULL)
257 : : {
258 : 0 : cp = mempcpy (cp, prefix, prefix_len);
259 : 0 : *cp++ = '(';
260 : 0 : strcpy (stpcpy (new_suffix, suffix), ")");
261 : : }
262 : : else
263 : 0 : new_suffix[0] = '\0';
264 : 0 : memcpy (cp, fname, fname_len);
265 : :
266 : : /* It's an archive. We process each file in it. */
267 [ # # ]: 0 : while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
268 : : {
269 : 0 : kind = elf_kind (subelf);
270 : :
271 : : /* Call this function recursively. */
272 [ # # ]: 0 : if (kind == ELF_K_ELF || kind == ELF_K_AR)
273 : : {
274 : 0 : Elf_Arhdr *arhdr = elf_getarhdr (subelf);
275 [ # # ]: 0 : assert (arhdr != NULL);
276 : :
277 : 0 : process_file (fd, subelf, new_prefix, new_suffix,
278 : 0 : arhdr->ar_name, arhdr->ar_size, false);
279 : : }
280 : :
281 : : /* Get next archive element. */
282 : 0 : cmd = elf_next (subelf);
283 [ # # ]: 0 : if (elf_end (subelf) != 0)
284 : 0 : ERROR (_(" error while freeing sub-ELF descriptor: %s\n"),
285 : : elf_errmsg (-1));
286 : : }
287 : : }
288 : 0 : break;
289 : :
290 : 0 : default:
291 : : /* We cannot do anything. */
292 : 0 : ERROR (_("\
293 : : Not an ELF file - it has the wrong magic bytes at the start\n"));
294 : 0 : break;
295 : : }
296 : 386 : }
297 : :
298 : :
299 : : static const char *
300 : 340 : section_name (Ebl *ebl, int idx)
301 : : {
302 : 340 : GElf_Shdr shdr_mem;
303 : 340 : GElf_Shdr *shdr;
304 : 340 : const char *ret;
305 : :
306 [ - + ]: 340 : if ((unsigned int) idx > shnum)
307 : : return "<invalid>";
308 : :
309 : 340 : shdr = gelf_getshdr (elf_getscn (ebl->elf, idx), &shdr_mem);
310 [ - + ]: 340 : if (shdr == NULL)
311 : : return "<invalid>";
312 : :
313 : 340 : ret = elf_strptr (ebl->elf, shstrndx, shdr->sh_name);
314 [ - + ]: 340 : if (ret == NULL)
315 : : return "<invalid>";
316 : : return ret;
317 : : }
318 : :
319 : :
320 : : static const int valid_e_machine[] =
321 : : {
322 : : EM_M32, EM_SPARC, EM_386, EM_68K, EM_88K, EM_860, EM_MIPS, EM_S370,
323 : : EM_MIPS_RS3_LE, EM_PARISC, EM_VPP500, EM_SPARC32PLUS, EM_960, EM_PPC,
324 : : EM_PPC64, EM_S390, EM_V800, EM_FR20, EM_RH32, EM_RCE, EM_ARM,
325 : : EM_FAKE_ALPHA, EM_SH, EM_SPARCV9, EM_TRICORE, EM_ARC, EM_H8_300,
326 : : EM_H8_300H, EM_H8S, EM_H8_500, EM_IA_64, EM_MIPS_X, EM_COLDFIRE,
327 : : EM_68HC12, EM_MMA, EM_PCP, EM_NCPU, EM_NDR1, EM_STARCORE, EM_ME16,
328 : : EM_ST100, EM_TINYJ, EM_X86_64, EM_PDSP, EM_FX66, EM_ST9PLUS, EM_ST7,
329 : : EM_68HC16, EM_68HC11, EM_68HC08, EM_68HC05, EM_SVX, EM_ST19, EM_VAX,
330 : : EM_CRIS, EM_JAVELIN, EM_FIREPATH, EM_ZSP, EM_MMIX, EM_HUANY, EM_PRISM,
331 : : EM_AVR, EM_FR30, EM_D10V, EM_D30V, EM_V850, EM_M32R, EM_MN10300,
332 : : EM_MN10200, EM_PJ, EM_OPENRISC, EM_ARC_A5, EM_XTENSA, EM_ALPHA,
333 : : EM_TILEGX, EM_TILEPRO, EM_AARCH64, EM_BPF, EM_RISCV, EM_CSKY, EM_LOONGARCH,
334 : : EM_ARCV2, EM_QDSP6
335 : : };
336 : : #define nvalid_e_machine \
337 : : (sizeof (valid_e_machine) / sizeof (valid_e_machine[0]))
338 : :
339 : :
340 : : static void
341 : 386 : check_elf_header (Ebl *ebl, GElf_Ehdr *ehdr, size_t size)
342 : : {
343 : 386 : char buf[512];
344 : 386 : size_t cnt;
345 : :
346 : : /* Check e_ident field. */
347 [ - + ]: 386 : if (ehdr->e_ident[EI_MAG0] != ELFMAG0)
348 : 0 : ERROR ("e_ident[%d] != '%c'\n", EI_MAG0, ELFMAG0);
349 [ - + ]: 386 : if (ehdr->e_ident[EI_MAG1] != ELFMAG1)
350 : 0 : ERROR ("e_ident[%d] != '%c'\n", EI_MAG1, ELFMAG1);
351 [ - + ]: 386 : if (ehdr->e_ident[EI_MAG2] != ELFMAG2)
352 : 0 : ERROR ("e_ident[%d] != '%c'\n", EI_MAG2, ELFMAG2);
353 [ - + ]: 386 : if (ehdr->e_ident[EI_MAG3] != ELFMAG3)
354 : 0 : ERROR ("e_ident[%d] != '%c'\n", EI_MAG3, ELFMAG3);
355 : :
356 : 386 : if (ehdr->e_ident[EI_CLASS] != ELFCLASS32
357 [ - + ]: 386 : && ehdr->e_ident[EI_CLASS] != ELFCLASS64)
358 : 0 : ERROR (_("e_ident[%d] == %d is no known class\n"),
359 : : EI_CLASS, ehdr->e_ident[EI_CLASS]);
360 : :
361 : 386 : if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB
362 [ - + ]: 386 : && ehdr->e_ident[EI_DATA] != ELFDATA2MSB)
363 : 0 : ERROR (_("e_ident[%d] == %d is no known data encoding\n"),
364 : : EI_DATA, ehdr->e_ident[EI_DATA]);
365 : :
366 [ - + ]: 386 : if (ehdr->e_ident[EI_VERSION] != EV_CURRENT)
367 : 0 : ERROR (_("unknown ELF header version number e_ident[%d] == %d\n"),
368 : : EI_VERSION, ehdr->e_ident[EI_VERSION]);
369 : :
370 : : /* We currently don't handle any OS ABIs other than Linux and the
371 : : kFreeBSD variant of Debian. */
372 : 386 : if (ehdr->e_ident[EI_OSABI] != ELFOSABI_NONE
373 [ - + ]: 386 : && ehdr->e_ident[EI_OSABI] != ELFOSABI_LINUX
374 [ # # ]: 0 : && ehdr->e_ident[EI_OSABI] != ELFOSABI_FREEBSD)
375 : 0 : ERROR (_("unsupported OS ABI e_ident[%d] == '%s'\n"),
376 : : EI_OSABI,
377 : : ebl_osabi_name (ebl, ehdr->e_ident[EI_OSABI], buf, sizeof (buf)));
378 : :
379 : : /* No ABI versions other than zero are supported either. */
380 [ - + ]: 386 : if (ehdr->e_ident[EI_ABIVERSION] != 0)
381 : 0 : ERROR (_("unsupported ABI version e_ident[%d] == %d\n"),
382 : : EI_ABIVERSION, ehdr->e_ident[EI_ABIVERSION]);
383 : :
384 [ + + ]: 3088 : for (cnt = EI_PAD; cnt < EI_NIDENT; ++cnt)
385 [ - + ]: 2702 : if (ehdr->e_ident[cnt] != 0)
386 : 2702 : ERROR (_("e_ident[%zu] is not zero\n"), cnt);
387 : :
388 : : /* Check the e_type field. */
389 : 386 : if (ehdr->e_type != ET_REL && ehdr->e_type != ET_EXEC
390 [ - + ]: 386 : && ehdr->e_type != ET_DYN && ehdr->e_type != ET_CORE)
391 : 0 : ERROR (_("unknown object file type %d\n"), ehdr->e_type);
392 : :
393 : : /* Check the e_machine field. */
394 [ + - ]: 9718 : for (cnt = 0; cnt < nvalid_e_machine; ++cnt)
395 [ + + ]: 9718 : if (valid_e_machine[cnt] == ehdr->e_machine)
396 : : break;
397 [ - + ]: 386 : if (cnt == nvalid_e_machine)
398 : 0 : ERROR (_("unknown machine type %d\n"), ehdr->e_machine);
399 : :
400 : : /* Check the e_version field. */
401 [ - + ]: 386 : if (ehdr->e_version != EV_CURRENT)
402 : 0 : ERROR (_("unknown object file version\n"));
403 : :
404 : : /* Check the e_phoff and e_phnum fields. */
405 [ + + ]: 386 : if (ehdr->e_phoff == 0)
406 : : {
407 [ - + ]: 70 : if (ehdr->e_phnum != 0)
408 : 0 : ERROR (_("invalid program header offset\n"));
409 [ - + ]: 70 : else if (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
410 : 0 : ERROR (_("\
411 : : executables and DSOs cannot have zero program header offset\n"));
412 : : }
413 [ - + ]: 316 : else if (ehdr->e_phnum == 0)
414 : 0 : ERROR (_("invalid number of program header entries\n"));
415 : :
416 : : /* Check the e_shoff field. */
417 : 386 : shnum = ehdr->e_shnum;
418 : 386 : shstrndx = ehdr->e_shstrndx;
419 [ - + ]: 386 : if (ehdr->e_shoff == 0)
420 : : {
421 [ # # ]: 0 : if (ehdr->e_shnum != 0)
422 : 0 : ERROR (_("invalid section header table offset\n"));
423 : 0 : else if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN
424 [ # # ]: 0 : && ehdr->e_type != ET_CORE)
425 : 0 : ERROR (_("section header table must be present\n"));
426 : : }
427 : : else
428 : : {
429 [ + + ]: 386 : if (ehdr->e_shnum == 0)
430 : : {
431 : : /* Get the header of the zeroth section. The sh_size field
432 : : might contain the section number. */
433 : 12 : GElf_Shdr shdr_mem;
434 : 12 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
435 [ + - ]: 12 : if (shdr != NULL)
436 : : {
437 : : /* The error will be reported later. */
438 [ - + ]: 12 : if (shdr->sh_size == 0)
439 : 0 : ERROR (_("\
440 : : invalid number of section header table entries\n"));
441 : : else
442 : 12 : shnum = shdr->sh_size;
443 : : }
444 : : }
445 : :
446 [ + + ]: 386 : if (ehdr->e_shstrndx == SHN_XINDEX)
447 : : {
448 : : /* Get the header of the zeroth section. The sh_size field
449 : : might contain the section number. */
450 : 12 : GElf_Shdr shdr_mem;
451 : 12 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
452 [ + - + - ]: 12 : if (shdr != NULL && shdr->sh_link < shnum)
453 : 12 : shstrndx = shdr->sh_link;
454 : : }
455 [ - + ]: 374 : else if (shstrndx >= shnum)
456 : 0 : ERROR (_("invalid section header index\n"));
457 : : }
458 : :
459 : : /* Check the shdrs actually exist. And uncompress them before
460 : : further checking. Indexes between sections reference the
461 : : uncompressed data. */
462 : : unsigned int scnt;
463 : : Elf_Scn *scn = NULL;
464 [ + + ]: 799156 : for (scnt = 1; scnt < shnum; ++scnt)
465 : : {
466 : 798770 : scn = elf_nextscn (ebl->elf, scn);
467 [ + - ]: 798770 : if (scn == NULL)
468 : : break;
469 : : /* If the section wasn't compressed this does nothing, but
470 : : returns an error. We don't care. */
471 : 798770 : if (elf_compress (scn, 0, 0) < 0) { ; }
472 : : }
473 [ - + ]: 386 : if (scnt < shnum)
474 : 0 : ERROR (_("Can only check %u headers, shnum was %u\n"), scnt, shnum);
475 : 386 : shnum = scnt;
476 : :
477 : 386 : phnum = ehdr->e_phnum;
478 [ - + ]: 386 : if (ehdr->e_phnum == PN_XNUM)
479 : : {
480 : : /* Get the header of the zeroth section. The sh_info field
481 : : might contain the phnum count. */
482 : 0 : GElf_Shdr shdr_mem;
483 : 0 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
484 [ # # ]: 0 : if (shdr != NULL)
485 : : {
486 : : /* The error will be reported later. */
487 [ # # ]: 0 : if (shdr->sh_info < PN_XNUM)
488 : 0 : ERROR (_("\
489 : : invalid number of program header table entries\n"));
490 : : else
491 : 0 : phnum = shdr->sh_info;
492 : : }
493 : : }
494 : :
495 : : /* Check the phdrs actually exist. */
496 : : unsigned int pcnt;
497 [ + + ]: 2338 : for (pcnt = 0; pcnt < phnum; ++pcnt)
498 : : {
499 : 1952 : GElf_Phdr phdr_mem;
500 : 1952 : GElf_Phdr *phdr = gelf_getphdr (ebl->elf, pcnt, &phdr_mem);
501 [ + - ]: 1952 : if (phdr == NULL)
502 : : break;
503 : : }
504 [ - + ]: 386 : if (pcnt < phnum)
505 : 0 : ERROR (_("Can only check %u headers, phnum was %u\n"), pcnt, phnum);
506 : 386 : phnum = pcnt;
507 : :
508 : : /* Check the e_flags field. */
509 [ - + ]: 386 : if (!ebl_machine_flag_check (ebl, ehdr->e_flags))
510 : 0 : ERROR (_("invalid machine flags: %s\n"),
511 : : ebl_machine_flag_name (ebl, ehdr->e_flags, buf, sizeof (buf)));
512 : :
513 : : /* Check e_ehsize, e_phentsize, and e_shentsize fields. */
514 [ + + ]: 386 : if (gelf_getclass (ebl->elf) == ELFCLASS32)
515 : : {
516 [ - + ]: 154 : if (ehdr->e_ehsize != 0 && ehdr->e_ehsize != sizeof (Elf32_Ehdr))
517 : 0 : ERROR (_("invalid ELF header size: %hd\n"), ehdr->e_ehsize);
518 : :
519 [ - + ]: 154 : if (ehdr->e_phentsize != 0 && ehdr->e_phentsize != sizeof (Elf32_Phdr))
520 : 0 : ERROR (_("invalid program header size: %hd\n"),
521 : : ehdr->e_phentsize);
522 [ - + ]: 154 : else if (ehdr->e_phoff + phnum * ehdr->e_phentsize > size)
523 : 0 : ERROR (_("invalid program header position or size\n"));
524 : :
525 [ - + ]: 154 : if (ehdr->e_shentsize != 0 && ehdr->e_shentsize != sizeof (Elf32_Shdr))
526 : 0 : ERROR (_("invalid section header size: %hd\n"),
527 : : ehdr->e_shentsize);
528 [ - + ]: 154 : else if (ehdr->e_shoff + shnum * ehdr->e_shentsize > size)
529 : 0 : ERROR (_("invalid section header position or size\n"));
530 : : }
531 [ + - ]: 232 : else if (gelf_getclass (ebl->elf) == ELFCLASS64)
532 : : {
533 [ - + ]: 232 : if (ehdr->e_ehsize != 0 && ehdr->e_ehsize != sizeof (Elf64_Ehdr))
534 : 0 : ERROR (_("invalid ELF header size: %hd\n"), ehdr->e_ehsize);
535 : :
536 [ - + ]: 232 : if (ehdr->e_phentsize != 0 && ehdr->e_phentsize != sizeof (Elf64_Phdr))
537 : 0 : ERROR (_("invalid program header size: %hd\n"),
538 : : ehdr->e_phentsize);
539 [ - + ]: 232 : else if (ehdr->e_phoff + phnum * ehdr->e_phentsize > size)
540 : 0 : ERROR (_("invalid program header position or size\n"));
541 : :
542 [ - + ]: 232 : if (ehdr->e_shentsize != 0 && ehdr->e_shentsize != sizeof (Elf64_Shdr))
543 : 0 : ERROR (_("invalid section header size: %hd\n"),
544 : : ehdr->e_shentsize);
545 [ - + ]: 232 : else if (ehdr->e_shoff + shnum * ehdr->e_shentsize > size)
546 : 0 : ERROR (_("invalid section header position or size\n"));
547 : : }
548 : 386 : }
549 : :
550 : :
551 : : /* Check that there is a section group section with index < IDX which
552 : : contains section IDX and that there is exactly one. */
553 : : static void
554 : 88016 : check_scn_group (Ebl *ebl, int idx)
555 : : {
556 [ - + ]: 88016 : if (scnref[idx] == 0)
557 : : {
558 : : /* No reference so far. Search following sections, maybe the
559 : : order is wrong. */
560 : 0 : size_t cnt;
561 : :
562 [ # # ]: 0 : for (cnt = idx + 1; cnt < shnum; ++cnt)
563 : : {
564 : 0 : Elf_Scn *scn = elf_getscn (ebl->elf, cnt);
565 : 0 : GElf_Shdr shdr_mem;
566 : 0 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
567 [ # # ]: 0 : if (shdr == NULL)
568 : : /* We cannot get the section header so we cannot check it.
569 : : The error to get the section header will be shown
570 : : somewhere else. */
571 : 0 : continue;
572 : :
573 [ # # ]: 0 : if (shdr->sh_type != SHT_GROUP)
574 : 0 : continue;
575 : :
576 : 0 : Elf_Data *data = elf_getdata (scn, NULL);
577 [ # # # # ]: 0 : if (data == NULL || data->d_buf == NULL
578 [ # # ]: 0 : || data->d_size < sizeof (Elf32_Word))
579 : : /* Cannot check the section. */
580 : 0 : continue;
581 : :
582 : : Elf32_Word *grpdata = (Elf32_Word *) data->d_buf;
583 [ # # ]: 0 : for (size_t inner = 1; inner < data->d_size / sizeof (Elf32_Word);
584 : 0 : ++inner)
585 [ # # ]: 0 : if (grpdata[inner] == (Elf32_Word) idx)
586 : 0 : goto out;
587 : : }
588 : :
589 : 0 : out:
590 [ # # ]: 0 : if (cnt == shnum)
591 : 0 : ERROR (_("\
592 : : section [%2d] '%s': section with SHF_GROUP flag set not part of a section group\n"),
593 : : idx, section_name (ebl, idx));
594 : : else
595 : 0 : ERROR (_("\
596 : : section [%2d] '%s': section group [%2zu] '%s' does not precede group member\n"),
597 : : idx, section_name (ebl, idx),
598 : : cnt, section_name (ebl, cnt));
599 : : }
600 : 88016 : }
601 : :
602 : :
603 : : static void
604 : 508 : check_symtab (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
605 : : {
606 : 508 : bool no_xndx_warned = false;
607 : 508 : int no_pt_tls = 0;
608 : 508 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
609 [ - + ]: 508 : if (data == NULL)
610 : : {
611 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
612 : : idx, section_name (ebl, idx));
613 : 0 : return;
614 : : }
615 : :
616 : 508 : GElf_Shdr strshdr_mem;
617 : 508 : GElf_Shdr *strshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
618 : : &strshdr_mem);
619 [ + - ]: 508 : if (strshdr == NULL)
620 : : return;
621 : :
622 [ - + ]: 508 : if (strshdr->sh_type != SHT_STRTAB)
623 : : {
624 : 0 : ERROR (_("section [%2d] '%s': referenced as string table for section [%2d] '%s' but type is not SHT_STRTAB\n"),
625 : : shdr->sh_link, section_name (ebl, shdr->sh_link),
626 : : idx, section_name (ebl, idx));
627 : 0 : strshdr = NULL;
628 : : }
629 : :
630 : : /* Search for an extended section index table section. */
631 : 508 : Elf_Data *xndxdata = NULL;
632 : 508 : Elf32_Word xndxscnidx = 0;
633 : 508 : bool found_xndx = false;
634 [ + + ]: 671880 : for (size_t cnt = 1; cnt < shnum; ++cnt)
635 [ + + ]: 671372 : if (cnt != (size_t) idx)
636 : : {
637 : 670864 : Elf_Scn *xndxscn = elf_getscn (ebl->elf, cnt);
638 : 670864 : GElf_Shdr xndxshdr_mem;
639 : 670864 : GElf_Shdr *xndxshdr = gelf_getshdr (xndxscn, &xndxshdr_mem);
640 [ - + ]: 670864 : if (xndxshdr == NULL)
641 : 0 : continue;
642 : :
643 [ + + ]: 670864 : if (xndxshdr->sh_type == SHT_SYMTAB_SHNDX
644 [ + - ]: 4 : && xndxshdr->sh_link == (GElf_Word) idx)
645 : : {
646 [ - + ]: 4 : if (found_xndx)
647 : 0 : ERROR (_("\
648 : : section [%2d] '%s': symbol table cannot have more than one extended index section\n"),
649 : : idx, section_name (ebl, idx));
650 : :
651 : 4 : xndxdata = elf_getdata (xndxscn, NULL);
652 : 4 : xndxscnidx = elf_ndxscn (xndxscn);
653 : 4 : found_xndx = true;
654 : : }
655 : : }
656 : :
657 : 508 : size_t sh_entsize = gelf_fsize (ebl->elf, ELF_T_SYM, 1, EV_CURRENT);
658 [ - + ]: 508 : if (shdr->sh_entsize != sh_entsize)
659 : 0 : ERROR (_("\
660 : : section [%2u] '%s': entry size is does not match ElfXX_Sym\n"),
661 : : idx, section_name (ebl, idx));
662 [ - + ]: 508 : else if (shdr->sh_info > shdr->sh_size / sh_entsize)
663 : 0 : ERROR (_("\
664 : : section [%2u] '%s': number of local entries in 'st_info' larger than table size\n"),
665 : : idx, section_name (ebl, idx));
666 : :
667 : : /* Test the zeroth entry. */
668 : 508 : GElf_Sym sym_mem;
669 : 508 : Elf32_Word xndx;
670 : 508 : GElf_Sym *sym = gelf_getsymshndx (data, xndxdata, 0, &sym_mem, &xndx);
671 [ - + ]: 508 : if (sym == NULL)
672 : 0 : ERROR (_("section [%2d] '%s': cannot get symbol %d: %s\n"),
673 : : idx, section_name (ebl, idx), 0, elf_errmsg (-1));
674 : : else
675 : : {
676 [ - + ]: 508 : if (sym->st_name != 0)
677 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
678 : : idx, section_name (ebl, idx), "st_name");
679 [ - + ]: 508 : if (sym->st_value != 0)
680 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
681 : : idx, section_name (ebl, idx), "st_value");
682 [ - + ]: 508 : if (sym->st_size != 0)
683 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
684 : : idx, section_name (ebl, idx), "st_size");
685 [ - + ]: 508 : if (sym->st_info != 0)
686 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
687 : : idx, section_name (ebl, idx), "st_info");
688 [ - + ]: 508 : if (sym->st_other != 0)
689 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
690 : : idx, section_name (ebl, idx), "st_other");
691 [ - + ]: 508 : if (sym->st_shndx != 0)
692 : 0 : ERROR (_("section [%2d] '%s': '%s' in zeroth entry not zero\n"),
693 : : idx, section_name (ebl, idx), "st_shndx");
694 [ + + - + ]: 508 : if (xndxdata != NULL && xndx != 0)
695 : 0 : ERROR (_("\
696 : : section [%2d] '%s': XINDEX for zeroth entry not zero\n"),
697 : : xndxscnidx, section_name (ebl, xndxscnidx));
698 : : }
699 : :
700 [ + + ]: 355470 : for (size_t cnt = 1; cnt < shdr->sh_size / sh_entsize; ++cnt)
701 : : {
702 : 354962 : sym = gelf_getsymshndx (data, xndxdata, cnt, &sym_mem, &xndx);
703 [ - + ]: 354962 : if (sym == NULL)
704 : : {
705 : 0 : ERROR (_("section [%2d] '%s': cannot get symbol %zu: %s\n"),
706 : : idx, section_name (ebl, idx), cnt, elf_errmsg (-1));
707 : 0 : continue;
708 : : }
709 : :
710 : 354962 : const char *name = "<invalid>";
711 [ - + ]: 354962 : if (strshdr == NULL)
712 : : name = "";
713 [ - + ]: 354962 : else if (sym->st_name >= strshdr->sh_size)
714 : 0 : ERROR (_("\
715 : : section [%2d] '%s': symbol %zu: invalid name value\n"),
716 : : idx, section_name (ebl, idx), cnt);
717 : : else
718 : : {
719 : 354962 : name = elf_strptr (ebl->elf, shdr->sh_link, sym->st_name);
720 [ - + ]: 354962 : if (name == NULL)
721 : 0 : name = "";
722 : : }
723 : :
724 [ + + ]: 354962 : if (sym->st_shndx == SHN_XINDEX)
725 : : {
726 [ - + ]: 1922 : if (xndxdata == NULL)
727 : : {
728 [ # # ]: 0 : if (!no_xndx_warned)
729 : 0 : ERROR (_("\
730 : : section [%2d] '%s': symbol %zu (%s): too large section index but no extended section index section\n"),
731 : : idx, section_name (ebl, idx), cnt, name);
732 : : no_xndx_warned = true;
733 : : }
734 [ + - ]: 1922 : else if (xndx < SHN_LORESERVE)
735 : 0 : ERROR (_("\
736 : : section [%2d] '%s': symbol %zu (%s): XINDEX used for index which would fit in st_shndx (%" PRIu32 ")\n"),
737 : : xndxscnidx, section_name (ebl, xndxscnidx), cnt, name,
738 : : xndx);
739 : : }
740 : 353040 : else if ((sym->st_shndx >= SHN_LORESERVE
741 : : // && sym->st_shndx <= SHN_HIRESERVE always true
742 [ - + ]: 353040 : && sym->st_shndx != SHN_ABS
743 [ # # ]: 0 : && sym->st_shndx != SHN_COMMON)
744 [ + + ]: 353040 : || (sym->st_shndx >= shnum
745 [ - + ]: 11670 : && (sym->st_shndx < SHN_LORESERVE
746 : : /* || sym->st_shndx > SHN_HIRESERVE always false */)))
747 : 0 : ERROR (_("\
748 : : section [%2d] '%s': symbol %zu (%s): invalid section index\n"),
749 : : idx, section_name (ebl, idx), cnt, name);
750 : : else
751 : 353040 : xndx = sym->st_shndx;
752 : :
753 [ - + ]: 354962 : if (GELF_ST_TYPE (sym->st_info) >= STT_NUM
754 [ # # ]: 0 : && !ebl_symbol_type_name (ebl, GELF_ST_TYPE (sym->st_info), NULL, 0))
755 : 0 : ERROR (_("section [%2d] '%s': symbol %zu (%s): unknown type\n"),
756 : : idx, section_name (ebl, idx), cnt, name);
757 : :
758 [ - + ]: 354962 : if (GELF_ST_BIND (sym->st_info) >= STB_NUM
759 [ # # ]: 0 : && !ebl_symbol_binding_name (ebl, GELF_ST_BIND (sym->st_info), NULL,
760 : : 0))
761 : 0 : ERROR (_("\
762 : : section [%2d] '%s': symbol %zu (%s): unknown symbol binding\n"),
763 : : idx, section_name (ebl, idx), cnt, name);
764 [ - + ]: 354962 : if (GELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE
765 [ # # ]: 0 : && GELF_ST_TYPE (sym->st_info) != STT_OBJECT)
766 : 0 : ERROR (_("\
767 : : section [%2d] '%s': symbol %zu (%s): unique symbol not of object type\n"),
768 : : idx, section_name (ebl, idx), cnt, name);
769 : :
770 [ + + ]: 354962 : if (xndx == SHN_COMMON)
771 : : {
772 : : /* Common symbols can only appear in relocatable files. */
773 [ - + ]: 4 : if (ehdr->e_type != ET_REL)
774 : 0 : ERROR (_("\
775 : : section [%2d] '%s': symbol %zu (%s): COMMON only allowed in relocatable files\n"),
776 : : idx, section_name (ebl, idx), cnt, name);
777 [ - + ]: 4 : if (cnt < shdr->sh_info)
778 : 0 : ERROR (_("\
779 : : section [%2d] '%s': symbol %zu (%s): local COMMON symbols are nonsense\n"),
780 : : idx, section_name (ebl, idx), cnt, name);
781 [ - + ]: 4 : if (GELF_R_TYPE (sym->st_info) == STT_FUNC)
782 : 0 : ERROR (_("\
783 : : section [%2d] '%s': symbol %zu (%s): function in COMMON section is nonsense\n"),
784 : : idx, section_name (ebl, idx), cnt, name);
785 : : }
786 [ + + + + ]: 354958 : else if (xndx > 0 && xndx < shnum)
787 : : {
788 : 326830 : GElf_Shdr destshdr_mem;
789 : 326830 : GElf_Shdr *destshdr;
790 : :
791 : 326830 : destshdr = gelf_getshdr (elf_getscn (ebl->elf, xndx), &destshdr_mem);
792 [ - + ]: 326830 : if (destshdr != NULL)
793 : : {
794 : 653660 : GElf_Addr sh_addr = (ehdr->e_type == ET_REL ? 0
795 [ + + ]: 326830 : : destshdr->sh_addr);
796 : 326830 : GElf_Addr st_value;
797 : 326830 : if (GELF_ST_TYPE (sym->st_info) == STT_FUNC
798 [ + + ]: 326830 : || (GELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
799 : 53552 : st_value = sym->st_value & ebl_func_addr_mask (ebl);
800 : : else
801 : 273278 : st_value = sym->st_value;
802 [ + + ]: 326830 : if (GELF_ST_TYPE (sym->st_info) != STT_TLS)
803 : : {
804 [ + + ]: 326698 : if (! ebl_check_special_symbol (ebl, sym, name,
805 : : destshdr))
806 : : {
807 [ + + ]: 326494 : if (st_value - sh_addr > destshdr->sh_size)
808 : : {
809 : : /* GNU ld has severe bugs. When it decides to remove
810 : : empty sections it leaves symbols referencing them
811 : : behind. These are symbols in .symtab or .dynsym
812 : : and for the named symbols have zero size. See
813 : : sourceware PR13621. */
814 [ + - ]: 334 : if (!gnuld
815 [ - + ]: 334 : || (strcmp (section_name (ebl, idx), ".symtab")
816 [ # # ]: 0 : && strcmp (section_name (ebl, idx),
817 : : ".dynsym"))
818 [ + - ]: 334 : || sym->st_size != 0
819 [ - + ]: 334 : || (strcmp (name, "__preinit_array_start") != 0
820 [ - + ]: 334 : && strcmp (name, "__preinit_array_end") != 0
821 [ - + ]: 334 : && strcmp (name, "__init_array_start") != 0
822 [ - + ]: 334 : && strcmp (name, "__init_array_end") != 0
823 [ - + ]: 334 : && strcmp (name, "__fini_array_start") != 0
824 [ - + ]: 334 : && strcmp (name, "__fini_array_end") != 0
825 [ + + ]: 334 : && strcmp (name, "__bss_start") != 0
826 [ - + ]: 232 : && strcmp (name, "__bss_start__") != 0
827 [ + + ]: 232 : && strcmp (name, "__TMC_END__") != 0
828 [ - + ]: 228 : && strcmp (name, ".TOC.") != 0
829 [ + + ]: 228 : && strcmp (name, "_edata") != 0
830 [ - + ]: 126 : && strcmp (name, "__edata") != 0
831 [ + + ]: 126 : && strcmp (name, "_end") != 0
832 [ + - ]: 24 : && strcmp (name, "__end") != 0))
833 : 0 : ERROR (_("\
834 : : section [%2d] '%s': symbol %zu (%s): st_value out of bounds\n"),
835 : : idx, section_name (ebl, idx), cnt, name);
836 : : }
837 : 326160 : else if ((st_value - sh_addr
838 [ + - ]: 326160 : + sym->st_size) > destshdr->sh_size)
839 : 0 : ERROR (_("\
840 : : section [%2d] '%s': symbol %zu (%s) does not fit completely in referenced section [%2d] '%s'\n"),
841 : : idx, section_name (ebl, idx), cnt, name,
842 : : (int) xndx, section_name (ebl, xndx));
843 : : }
844 : : }
845 : : else
846 : : {
847 [ - + ]: 132 : if ((destshdr->sh_flags & SHF_TLS) == 0)
848 : 0 : ERROR (_("\
849 : : section [%2d] '%s': symbol %zu (%s): referenced section [%2d] '%s' does not have SHF_TLS flag set\n"),
850 : : idx, section_name (ebl, idx), cnt, name,
851 : : (int) xndx, section_name (ebl, xndx));
852 : :
853 [ - + ]: 132 : if (ehdr->e_type == ET_REL)
854 : : {
855 : : /* For object files the symbol value must fall
856 : : into the section. */
857 [ # # ]: 0 : if (st_value > destshdr->sh_size)
858 : 0 : ERROR (_("\
859 : : section [%2d] '%s': symbol %zu (%s): st_value out of bounds of referenced section [%2d] '%s'\n"),
860 : : idx, section_name (ebl, idx), cnt, name,
861 : : (int) xndx, section_name (ebl, xndx));
862 [ # # ]: 0 : else if (st_value + sym->st_size
863 : : > destshdr->sh_size)
864 : 0 : ERROR (_("\
865 : : section [%2d] '%s': symbol %zu (%s) does not fit completely in referenced section [%2d] '%s'\n"),
866 : : idx, section_name (ebl, idx), cnt, name,
867 : : (int) xndx, section_name (ebl, xndx));
868 : : }
869 : : else
870 : : {
871 : : GElf_Phdr phdr_mem;
872 : : GElf_Phdr *phdr = NULL;
873 : : unsigned int pcnt;
874 : :
875 [ + - ]: 1264 : for (pcnt = 0; pcnt < phnum; ++pcnt)
876 : : {
877 : 1264 : phdr = gelf_getphdr (ebl->elf, pcnt, &phdr_mem);
878 [ + - + + ]: 1264 : if (phdr != NULL && phdr->p_type == PT_TLS)
879 : : break;
880 : : }
881 : :
882 [ - + ]: 132 : if (pcnt == phnum)
883 : : {
884 [ # # ]: 0 : if (no_pt_tls++ == 0)
885 : 0 : ERROR (_("\
886 : : section [%2d] '%s': symbol %zu (%s): TLS symbol but no TLS program header entry\n"),
887 : : idx, section_name (ebl, idx), cnt, name);
888 : : }
889 [ - + ]: 132 : else if (phdr == NULL)
890 : : {
891 : 0 : ERROR (_("\
892 : : section [%2d] '%s': symbol %zu (%s): TLS symbol but couldn't get TLS program header entry\n"),
893 : : idx, section_name (ebl, idx), cnt, name);
894 : : }
895 [ + + ]: 132 : else if (!is_debuginfo)
896 : : {
897 : 130 : if (st_value
898 [ - + ]: 130 : < destshdr->sh_offset - phdr->p_offset)
899 : 0 : ERROR (_("\
900 : : section [%2d] '%s': symbol %zu (%s): st_value short of referenced section [%2d] '%s'\n"),
901 : : idx, section_name (ebl, idx), cnt, name,
902 : : (int) xndx, section_name (ebl, xndx));
903 : 130 : else if (st_value
904 : : > (destshdr->sh_offset - phdr->p_offset
905 [ - + ]: 130 : + destshdr->sh_size))
906 : 0 : ERROR (_("\
907 : : section [%2d] '%s': symbol %zu (%s): st_value out of bounds of referenced section [%2d] '%s'\n"),
908 : : idx, section_name (ebl, idx), cnt, name,
909 : : (int) xndx, section_name (ebl, xndx));
910 [ + - ]: 130 : else if (st_value + sym->st_size
911 : : > (destshdr->sh_offset - phdr->p_offset
912 : : + destshdr->sh_size))
913 : 132 : ERROR (_("\
914 : : section [%2d] '%s': symbol %zu (%s) does not fit completely in referenced section [%2d] '%s'\n"),
915 : : idx, section_name (ebl, idx), cnt, name,
916 : : (int) xndx, section_name (ebl, xndx));
917 : : }
918 : : }
919 : : }
920 : : }
921 : : }
922 : :
923 [ + + ]: 354962 : if (GELF_ST_BIND (sym->st_info) == STB_LOCAL)
924 : : {
925 [ - + ]: 135254 : if (cnt >= shdr->sh_info)
926 : 0 : ERROR (_("\
927 : : section [%2d] '%s': symbol %zu (%s): local symbol outside range described in sh_info\n"),
928 : : idx, section_name (ebl, idx), cnt, name);
929 : : }
930 : : else
931 : : {
932 [ - + ]: 219708 : if (cnt < shdr->sh_info)
933 : 0 : ERROR (_("\
934 : : section [%2d] '%s': symbol %zu (%s): non-local symbol outside range described in sh_info\n"),
935 : : idx, section_name (ebl, idx), cnt, name);
936 : : }
937 : :
938 [ + + ]: 354962 : if (GELF_ST_TYPE (sym->st_info) == STT_SECTION
939 [ - + ]: 5062 : && GELF_ST_BIND (sym->st_info) != STB_LOCAL)
940 : 0 : ERROR (_("\
941 : : section [%2d] '%s': symbol %zu (%s): non-local section symbol\n"),
942 : : idx, section_name (ebl, idx), cnt, name);
943 : :
944 : 354962 : if (name != NULL)
945 : : {
946 [ + + ]: 354962 : if (strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
947 : : {
948 : : /* Check that address and size match the global offset table. */
949 : :
950 : 166 : GElf_Shdr destshdr_mem;
951 : 166 : GElf_Shdr *destshdr = gelf_getshdr (elf_getscn (ebl->elf, xndx),
952 : : &destshdr_mem);
953 : :
954 [ + + + - ]: 166 : if (destshdr == NULL && xndx == SHN_ABS)
955 : : {
956 : : /* In a DSO, we have to find the GOT section by name. */
957 : : Elf_Scn *gotscn = NULL;
958 : : Elf_Scn *gscn = NULL;
959 [ + + ]: 1366 : while ((gscn = elf_nextscn (ebl->elf, gscn)) != NULL)
960 : : {
961 : 1328 : destshdr = gelf_getshdr (gscn, &destshdr_mem);
962 [ - + ]: 1328 : assert (destshdr != NULL);
963 : 2656 : const char *sname = elf_strptr (ebl->elf,
964 : : shstrndx,
965 : 1328 : destshdr->sh_name);
966 [ + - ]: 1328 : if (sname != NULL)
967 : : {
968 [ + + ]: 1328 : if (strcmp (sname, ".got.plt") == 0)
969 : : break;
970 [ + + ]: 1320 : if (strcmp (sname, ".got") == 0)
971 : : /* Do not stop looking.
972 : : There might be a .got.plt section. */
973 : 1320 : gotscn = gscn;
974 : : }
975 : :
976 : : destshdr = NULL;
977 : : }
978 : :
979 [ + + ]: 46 : if (destshdr == NULL && gotscn != NULL)
980 : 38 : destshdr = gelf_getshdr (gotscn, &destshdr_mem);
981 : : }
982 : :
983 [ + - ]: 166 : const char *sname = ((destshdr == NULL || xndx == SHN_UNDEF)
984 : : ? NULL
985 [ + - ]: 46 : : elf_strptr (ebl->elf, shstrndx,
986 : 166 : destshdr->sh_name));
987 [ - + ]: 166 : if (sname == NULL)
988 : : {
989 [ # # # # ]: 0 : if (xndx != SHN_UNDEF || ehdr->e_type != ET_REL)
990 : 0 : ERROR (_("\
991 : : section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to \
992 : : bad section [%2d]\n"),
993 : : idx, section_name (ebl, idx), xndx);
994 : : }
995 [ + + ]: 166 : else if (strcmp (sname, ".got.plt") != 0
996 [ + - ]: 98 : && strcmp (sname, ".got") != 0)
997 : 0 : ERROR (_("\
998 : : section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to \
999 : : section [%2d] '%s'\n"),
1000 : : idx, section_name (ebl, idx), xndx, sname);
1001 : :
1002 [ + - ]: 166 : if (destshdr != NULL)
1003 : : {
1004 : : /* Found it. */
1005 [ + + ]: 166 : if (!ebl_check_special_symbol (ebl, sym, name,
1006 : : destshdr))
1007 : : {
1008 [ + - ]: 142 : if (ehdr->e_type != ET_REL
1009 [ - + ]: 142 : && sym->st_value != destshdr->sh_addr)
1010 : : /* This test is more strict than the psABIs which
1011 : : usually allow the symbol to be in the middle of
1012 : : the .got section, allowing negative offsets. */
1013 : 0 : ERROR (_("\
1014 : : section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol value %#" PRIx64 " does not match %s section address %#" PRIx64 "\n"),
1015 : : idx, section_name (ebl, idx),
1016 : : (uint64_t) sym->st_value,
1017 : : sname, (uint64_t) destshdr->sh_addr);
1018 : :
1019 [ - + - - ]: 142 : if (!gnuld && sym->st_size != destshdr->sh_size)
1020 : 0 : ERROR (_("\
1021 : : section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol size %" PRIu64 " does not match %s section size %" PRIu64 "\n"),
1022 : : idx, section_name (ebl, idx),
1023 : : (uint64_t) sym->st_size,
1024 : : sname, (uint64_t) destshdr->sh_size);
1025 : : }
1026 : : }
1027 : : else
1028 : 166 : ERROR (_("\
1029 : : section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol present, but no .got section\n"),
1030 : : idx, section_name (ebl, idx));
1031 : : }
1032 [ + + ]: 354796 : else if (strcmp (name, "_DYNAMIC") == 0)
1033 : : /* Check that address and size match the dynamic section.
1034 : : We locate the dynamic section via the program header
1035 : : entry. */
1036 [ + - ]: 892 : for (unsigned int pcnt = 0; pcnt < phnum; ++pcnt)
1037 : : {
1038 : 892 : GElf_Phdr phdr_mem;
1039 : 892 : GElf_Phdr *phdr = gelf_getphdr (ebl->elf, pcnt, &phdr_mem);
1040 : :
1041 [ + - + + ]: 892 : if (phdr != NULL && phdr->p_type == PT_DYNAMIC)
1042 : : {
1043 [ - + ]: 182 : if (sym->st_value != phdr->p_vaddr)
1044 : 0 : ERROR (_("\
1045 : : section [%2d] '%s': _DYNAMIC_ symbol value %#" PRIx64 " does not match dynamic segment address %#" PRIx64 "\n"),
1046 : : idx, section_name (ebl, idx),
1047 : : (uint64_t) sym->st_value,
1048 : : (uint64_t) phdr->p_vaddr);
1049 : :
1050 [ - + - - ]: 182 : if (!gnuld && sym->st_size != phdr->p_memsz)
1051 : 0 : ERROR (_("\
1052 : : section [%2d] '%s': _DYNAMIC symbol size %" PRIu64 " does not match dynamic segment size %" PRIu64 "\n"),
1053 : : idx, section_name (ebl, idx),
1054 : : (uint64_t) sym->st_size,
1055 : : (uint64_t) phdr->p_memsz);
1056 : :
1057 : 182 : break;
1058 : : }
1059 : : }
1060 : : }
1061 : :
1062 [ + + ]: 354962 : if (GELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
1063 [ - + ]: 1174 : && shdr->sh_type == SHT_DYNSYM)
1064 : 0 : ERROR (_("\
1065 : : section [%2d] '%s': symbol %zu (%s): symbol in dynamic symbol table with non-default visibility\n"),
1066 : : idx, section_name (ebl, idx), cnt, name);
1067 [ + - ]: 354962 : if (! ebl_check_st_other_bits (ebl, sym->st_other))
1068 : 354962 : ERROR (_("\
1069 : : section [%2d] '%s': symbol %zu (%s): unknown bit set in st_other\n"),
1070 : : idx, section_name (ebl, idx), cnt, name);
1071 : :
1072 : : }
1073 : : }
1074 : :
1075 : :
1076 : : static bool
1077 : 0 : is_rel_dyn (Ebl *ebl, const GElf_Ehdr *ehdr, int idx, const GElf_Shdr *shdr,
1078 : : bool is_rela)
1079 : : {
1080 : : /* If this is no executable or DSO it cannot be a .rel.dyn section. */
1081 [ # # ]: 0 : if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
1082 : : return false;
1083 : :
1084 : : /* Check the section name. Unfortunately necessary. */
1085 [ # # # # ]: 0 : if (strcmp (section_name (ebl, idx), is_rela ? ".rela.dyn" : ".rel.dyn"))
1086 : : return false;
1087 : :
1088 : : /* When a .rel.dyn section is used a DT_RELCOUNT dynamic section
1089 : : entry can be present as well. */
1090 : : Elf_Scn *scn = NULL;
1091 [ # # ]: 0 : while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
1092 : : {
1093 : 0 : GElf_Shdr rcshdr_mem;
1094 : 0 : const GElf_Shdr *rcshdr = gelf_getshdr (scn, &rcshdr_mem);
1095 : :
1096 [ # # ]: 0 : if (rcshdr == NULL)
1097 : : break;
1098 : :
1099 [ # # # # ]: 0 : if (rcshdr->sh_type == SHT_DYNAMIC && rcshdr->sh_entsize != 0)
1100 : : {
1101 : : /* Found the dynamic section. Look through it. */
1102 : 0 : Elf_Data *d = elf_getdata (scn, NULL);
1103 : 0 : size_t cnt;
1104 : :
1105 [ # # ]: 0 : if (d == NULL)
1106 : 0 : ERROR (_("\
1107 : : section [%2d] '%s': cannot get section data.\n"),
1108 : : idx, section_name (ebl, idx));
1109 : :
1110 [ # # ]: 0 : for (cnt = 1; cnt < rcshdr->sh_size / rcshdr->sh_entsize; ++cnt)
1111 : : {
1112 : 0 : GElf_Dyn dyn_mem;
1113 : 0 : GElf_Dyn *dyn = gelf_getdyn (d, cnt, &dyn_mem);
1114 : :
1115 [ # # ]: 0 : if (dyn == NULL)
1116 : : break;
1117 : :
1118 [ # # ]: 0 : if (dyn->d_tag == DT_RELCOUNT)
1119 : : {
1120 : : /* Found it. Does the type match. */
1121 [ # # ]: 0 : if (is_rela)
1122 : 0 : ERROR (_("\
1123 : : section [%2d] '%s': DT_RELCOUNT used for this RELA section\n"),
1124 : : idx, section_name (ebl, idx));
1125 : : else
1126 : : {
1127 : : /* Does the number specified number of relative
1128 : : relocations exceed the total number of
1129 : : relocations? */
1130 [ # # ]: 0 : if (shdr->sh_entsize != 0
1131 : 0 : && dyn->d_un.d_val > (shdr->sh_size
1132 [ # # ]: 0 : / shdr->sh_entsize))
1133 : 0 : ERROR (_("\
1134 : : section [%2d] '%s': DT_RELCOUNT value %d too high for this section\n"),
1135 : : idx, section_name (ebl, idx),
1136 : : (int) dyn->d_un.d_val);
1137 : :
1138 : : /* Make sure the specified number of relocations are
1139 : : relative. */
1140 : 0 : Elf_Data *reldata = elf_getdata (elf_getscn (ebl->elf,
1141 : : idx), NULL);
1142 [ # # # # ]: 0 : if (reldata != NULL && shdr->sh_entsize != 0)
1143 : : for (size_t inner = 0;
1144 [ # # ]: 0 : inner < shdr->sh_size / shdr->sh_entsize;
1145 : 0 : ++inner)
1146 : : {
1147 : 0 : GElf_Rel rel_mem;
1148 : 0 : GElf_Rel *rel = gelf_getrel (reldata, inner,
1149 : : &rel_mem);
1150 [ # # ]: 0 : if (rel == NULL)
1151 : : /* The problem will be reported elsewhere. */
1152 : : break;
1153 : :
1154 [ # # ]: 0 : if (ebl_relative_reloc_p (ebl,
1155 : 0 : GELF_R_TYPE (rel->r_info)))
1156 : : {
1157 [ # # ]: 0 : if (inner >= dyn->d_un.d_val)
1158 : 0 : ERROR (_("\
1159 : : section [%2d] '%s': relative relocations after index %d as specified by DT_RELCOUNT\n"),
1160 : : idx, section_name (ebl, idx),
1161 : : (int) dyn->d_un.d_val);
1162 : : }
1163 [ # # ]: 0 : else if (inner < dyn->d_un.d_val)
1164 : 0 : ERROR (_("\
1165 : : section [%2d] '%s': non-relative relocation at index %zu; DT_RELCOUNT specified %d relative relocations\n"),
1166 : : idx, section_name (ebl, idx),
1167 : : inner, (int) dyn->d_un.d_val);
1168 : : }
1169 : : }
1170 : : }
1171 : :
1172 [ # # ]: 0 : if (dyn->d_tag == DT_RELACOUNT)
1173 : : {
1174 : : /* Found it. Does the type match. */
1175 [ # # ]: 0 : if (!is_rela)
1176 : 0 : ERROR (_("\
1177 : : section [%2d] '%s': DT_RELACOUNT used for this REL section\n"),
1178 : : idx, section_name (ebl, idx));
1179 : : else
1180 : : {
1181 : : /* Does the number specified number of relative
1182 : : relocations exceed the total number of
1183 : : relocations? */
1184 [ # # ]: 0 : if (shdr->sh_entsize != 0
1185 [ # # ]: 0 : && dyn->d_un.d_val > shdr->sh_size / shdr->sh_entsize)
1186 : 0 : ERROR (_("\
1187 : : section [%2d] '%s': DT_RELCOUNT value %d too high for this section\n"),
1188 : : idx, section_name (ebl, idx),
1189 : : (int) dyn->d_un.d_val);
1190 : :
1191 : : /* Make sure the specified number of relocations are
1192 : : relative. */
1193 : 0 : Elf_Data *reldata = elf_getdata (elf_getscn (ebl->elf,
1194 : : idx), NULL);
1195 [ # # # # ]: 0 : if (reldata != NULL && shdr->sh_entsize != 0)
1196 : : for (size_t inner = 0;
1197 [ # # ]: 0 : inner < shdr->sh_size / shdr->sh_entsize;
1198 : 0 : ++inner)
1199 : : {
1200 : 0 : GElf_Rela rela_mem;
1201 : 0 : GElf_Rela *rela = gelf_getrela (reldata, inner,
1202 : : &rela_mem);
1203 [ # # ]: 0 : if (rela == NULL)
1204 : : /* The problem will be reported elsewhere. */
1205 : : break;
1206 : :
1207 [ # # ]: 0 : if (ebl_relative_reloc_p (ebl,
1208 : 0 : GELF_R_TYPE (rela->r_info)))
1209 : : {
1210 [ # # ]: 0 : if (inner >= dyn->d_un.d_val)
1211 : 0 : ERROR (_("\
1212 : : section [%2d] '%s': relative relocations after index %d as specified by DT_RELCOUNT\n"),
1213 : : idx, section_name (ebl, idx),
1214 : : (int) dyn->d_un.d_val);
1215 : : }
1216 [ # # ]: 0 : else if (inner < dyn->d_un.d_val)
1217 : 0 : ERROR (_("\
1218 : : section [%2d] '%s': non-relative relocation at index %zu; DT_RELCOUNT specified %d relative relocations\n"),
1219 : : idx, section_name (ebl, idx),
1220 : : inner, (int) dyn->d_un.d_val);
1221 : : }
1222 : : }
1223 : : }
1224 : : }
1225 : :
1226 : : break;
1227 : : }
1228 : : }
1229 : :
1230 : : return true;
1231 : : }
1232 : :
1233 : :
1234 : : struct loaded_segment
1235 : : {
1236 : : GElf_Addr from;
1237 : : GElf_Addr to;
1238 : : bool read_only;
1239 : : struct loaded_segment *next;
1240 : : };
1241 : :
1242 : :
1243 : : /* Check whether binary has text relocation flag set. */
1244 : : static bool textrel;
1245 : :
1246 : : /* Keep track of whether text relocation flag is needed. */
1247 : : static bool needed_textrel;
1248 : :
1249 : :
1250 : : static bool
1251 : 834 : check_reloc_shdr (Ebl *ebl, const GElf_Ehdr *ehdr, const GElf_Shdr *shdr,
1252 : : int idx, int reltype, GElf_Shdr **destshdrp,
1253 : : GElf_Shdr *destshdr_memp, struct loaded_segment **loadedp)
1254 : : {
1255 : 834 : bool reldyn = false;
1256 : :
1257 : : /* Check whether the link to the section we relocate is reasonable. */
1258 [ - + ]: 834 : if (shdr->sh_info >= shnum)
1259 : 0 : ERROR (_("section [%2d] '%s': invalid destination section index\n"),
1260 : : idx, section_name (ebl, idx));
1261 [ + + ]: 834 : else if (shdr->sh_info != 0)
1262 : : {
1263 : 692 : *destshdrp = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_info),
1264 : : destshdr_memp);
1265 [ - + ]: 692 : if (*destshdrp != NULL)
1266 : : {
1267 [ + - ]: 692 : if(! ebl_check_reloc_target_type (ebl, (*destshdrp)->sh_type))
1268 : : {
1269 : 0 : reldyn = is_rel_dyn (ebl, ehdr, idx, shdr, true);
1270 [ # # ]: 0 : if (!reldyn)
1271 : 0 : ERROR (_("\
1272 : : section [%2d] '%s': invalid destination section type\n"),
1273 : : idx, section_name (ebl, idx));
1274 : : else
1275 : : {
1276 : : /* There is no standard, but we require that .rel{,a}.dyn
1277 : : sections have a sh_info value of zero. */
1278 [ # # ]: 0 : if (shdr->sh_info != 0)
1279 : 0 : ERROR (_("\
1280 : : section [%2d] '%s': sh_info should be zero\n"),
1281 : : idx, section_name (ebl, idx));
1282 : : }
1283 : : }
1284 : :
1285 : 692 : if ((((*destshdrp)->sh_flags & SHF_MERGE) != 0)
1286 [ + - ]: 692 : && ((*destshdrp)->sh_flags & SHF_STRINGS) != 0)
1287 : 0 : ERROR (_("\
1288 : : section [%2d] '%s': no relocations for merge-able string sections possible\n"),
1289 : : idx, section_name (ebl, idx));
1290 : : }
1291 : : }
1292 : :
1293 : 834 : size_t sh_entsize = gelf_fsize (ebl->elf, reltype, 1, EV_CURRENT);
1294 [ - + ]: 834 : if (shdr->sh_entsize != sh_entsize)
1295 : : {
1296 [ # # ]: 0 : if (reltype == ELF_T_RELA)
1297 : 0 : ERROR ("\
1298 : : section [%2d] '%s': section entry size does not match ElfXX_Rela\n",
1299 : : idx, section_name (ebl, idx));
1300 [ # # ]: 0 : else if (reltype == ELF_T_REL)
1301 : 0 : ERROR ("\
1302 : : section [%2d] '%s': section entry size does not match ElfXX_Rel\n",
1303 : : idx, section_name (ebl, idx));
1304 : : else
1305 : 0 : ERROR ("\
1306 : : section [%2d] '%s': section entry size does not match ElfXX_Relr\n",
1307 : : idx, section_name (ebl, idx));
1308 : : }
1309 : :
1310 : : /* In preparation of checking whether relocations are text
1311 : : relocations or not we need to determine whether the file is
1312 : : flagged to have text relocation and we need to determine a) what
1313 : : the loaded segments are and b) which are read-only. This will
1314 : : also allow us to determine whether the same reloc section is
1315 : : modifying loaded and not loaded segments. */
1316 [ + + ]: 3996 : for (unsigned int i = 0; i < phnum; ++i)
1317 : : {
1318 : 3162 : GElf_Phdr phdr_mem;
1319 : 3162 : GElf_Phdr *phdr = gelf_getphdr (ebl->elf, i, &phdr_mem);
1320 [ - + ]: 3162 : if (phdr == NULL)
1321 : 0 : continue;
1322 : :
1323 [ + + ]: 3162 : if (phdr->p_type == PT_LOAD)
1324 : : {
1325 : 946 : struct loaded_segment *newp = xmalloc (sizeof (*newp));
1326 : 946 : newp->from = phdr->p_vaddr;
1327 : 946 : newp->to = phdr->p_vaddr + phdr->p_memsz;
1328 : 946 : newp->read_only = (phdr->p_flags & PF_W) == 0;
1329 : 946 : newp->next = *loadedp;
1330 : 946 : *loadedp = newp;
1331 : : }
1332 [ + + ]: 2216 : else if (phdr->p_type == PT_DYNAMIC)
1333 : : {
1334 : 356 : Elf_Scn *dynscn = gelf_offscn (ebl->elf, phdr->p_offset);
1335 : 356 : GElf_Shdr dynshdr_mem;
1336 : 356 : GElf_Shdr *dynshdr = gelf_getshdr (dynscn, &dynshdr_mem);
1337 : 356 : Elf_Data *dyndata = elf_getdata (dynscn, NULL);
1338 [ + - + - ]: 356 : if (dynshdr != NULL && dynshdr->sh_type == SHT_DYNAMIC
1339 [ + - + - ]: 356 : && dyndata != NULL && dynshdr->sh_entsize != 0)
1340 [ + + ]: 10300 : for (size_t j = 0; j < dynshdr->sh_size / dynshdr->sh_entsize; ++j)
1341 : : {
1342 : 9944 : GElf_Dyn dyn_mem;
1343 : 9944 : GElf_Dyn *dyn = gelf_getdyn (dyndata, j, &dyn_mem);
1344 [ + - ]: 9944 : if (dyn != NULL
1345 [ + - ]: 9944 : && (dyn->d_tag == DT_TEXTREL
1346 [ - + ]: 9944 : || (dyn->d_tag == DT_FLAGS
1347 [ # # ]: 0 : && (dyn->d_un.d_val & DF_TEXTREL) != 0)))
1348 : : {
1349 : 0 : textrel = true;
1350 : 0 : break;
1351 : : }
1352 : : }
1353 : : }
1354 : : }
1355 : :
1356 : : /* A quick test which can be easily done here (although it is a bit
1357 : : out of place): the text relocation flag makes only sense if there
1358 : : is a segment which is not writable. */
1359 [ - + ]: 834 : if (textrel)
1360 : : {
1361 : 0 : struct loaded_segment *seg = *loadedp;
1362 [ # # # # ]: 0 : while (seg != NULL && !seg->read_only)
1363 : 0 : seg = seg->next;
1364 [ # # ]: 0 : if (seg == NULL)
1365 : 0 : ERROR (_("\
1366 : : text relocation flag set but there is no read-only segment\n"));
1367 : : }
1368 : :
1369 : 834 : return reldyn;
1370 : : }
1371 : :
1372 : :
1373 : : enum load_state
1374 : : {
1375 : : state_undecided,
1376 : : state_loaded,
1377 : : state_unloaded,
1378 : : state_error
1379 : : };
1380 : :
1381 : :
1382 : : static void
1383 : 300716 : check_one_reloc (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *relshdr, int idx,
1384 : : size_t cnt, const GElf_Shdr *symshdr, Elf_Data *symdata,
1385 : : GElf_Addr r_offset, GElf_Xword r_info,
1386 : : const GElf_Shdr *destshdr, bool reldyn,
1387 : : struct loaded_segment *loaded, enum load_state *statep)
1388 : : {
1389 : 300716 : bool known_broken = gnuld;
1390 : :
1391 [ - + ]: 300716 : if (!ebl_reloc_type_check (ebl, GELF_R_TYPE (r_info)))
1392 : 0 : ERROR (_("section [%2d] '%s': relocation %zu: invalid type\n"),
1393 : : idx, section_name (ebl, idx), cnt);
1394 [ + + ]: 300716 : else if (((ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
1395 : : /* The executable/DSO can contain relocation sections with
1396 : : all the relocations the linker has applied. Those sections
1397 : : are marked non-loaded, though. */
1398 [ + - ]: 218160 : || (relshdr->sh_flags & SHF_ALLOC) != 0)
1399 [ - + ]: 300716 : && !ebl_reloc_valid_use (ebl, GELF_R_TYPE (r_info)))
1400 : 0 : ERROR (_("\
1401 : : section [%2d] '%s': relocation %zu: relocation type invalid for the file type\n"),
1402 : : idx, section_name (ebl, idx), cnt);
1403 : :
1404 [ + - ]: 300716 : if (symshdr != NULL
1405 : 601432 : && ((GELF_R_SYM (r_info) + 1)
1406 : 300716 : * gelf_fsize (ebl->elf, ELF_T_SYM, 1, EV_CURRENT)
1407 [ - + ]: 300716 : > symshdr->sh_size))
1408 : 0 : ERROR (_("\
1409 : : section [%2d] '%s': relocation %zu: invalid symbol index\n"),
1410 : : idx, section_name (ebl, idx), cnt);
1411 : :
1412 : : /* No more tests if this is a no-op relocation. */
1413 [ + + ]: 300716 : if (ebl_none_reloc_p (ebl, GELF_R_TYPE (r_info)))
1414 : 4 : return;
1415 : :
1416 [ - + ]: 300712 : if (ebl_gotpc_reloc_check (ebl, GELF_R_TYPE (r_info)))
1417 : : {
1418 : 0 : const char *name;
1419 : 0 : char buf[64];
1420 : 0 : GElf_Sym sym_mem;
1421 : 0 : GElf_Sym *sym = gelf_getsym (symdata, GELF_R_SYM (r_info), &sym_mem);
1422 [ # # ]: 0 : if (sym != NULL
1423 : : /* Get the name for the symbol. */
1424 [ # # ]: 0 : && (name = elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name))
1425 [ # # ]: 0 : && strcmp (name, "_GLOBAL_OFFSET_TABLE_") !=0 )
1426 : 0 : ERROR (_("\
1427 : : section [%2d] '%s': relocation %zu: only symbol '_GLOBAL_OFFSET_TABLE_' can be used with %s\n"),
1428 : : idx, section_name (ebl, idx), cnt,
1429 : : ebl_reloc_type_name (ebl, GELF_R_SYM (r_info),
1430 : : buf, sizeof (buf)));
1431 : : }
1432 : :
1433 [ + - ]: 300712 : if (reldyn)
1434 : : {
1435 : : // XXX TODO Check .rel.dyn section addresses.
1436 : : }
1437 [ + + ]: 300712 : else if (!known_broken)
1438 : : {
1439 [ + + ]: 384 : if (destshdr != NULL
1440 [ + - ]: 372 : && GELF_R_TYPE (r_info) != 0
1441 : 744 : && (r_offset - (ehdr->e_type == ET_REL ? 0
1442 [ + + - + ]: 372 : : destshdr->sh_addr)) >= destshdr->sh_size)
1443 : 0 : ERROR (_("\
1444 : : section [%2d] '%s': relocation %zu: offset out of bounds\n"),
1445 : : idx, section_name (ebl, idx), cnt);
1446 : : }
1447 : :
1448 : 300712 : GElf_Sym sym_mem;
1449 : 300712 : GElf_Sym *sym = gelf_getsym (symdata, GELF_R_SYM (r_info), &sym_mem);
1450 : :
1451 [ + + ]: 300712 : if (ebl_copy_reloc_p (ebl, GELF_R_TYPE (r_info))
1452 : : /* Make sure the referenced symbol is an object or unspecified. */
1453 [ + - ]: 134 : && sym != NULL
1454 [ + - ]: 134 : && GELF_ST_TYPE (sym->st_info) != STT_NOTYPE
1455 [ + + ]: 134 : && GELF_ST_TYPE (sym->st_info) != STT_OBJECT)
1456 : : {
1457 : 2 : char buf[64];
1458 : 2 : ERROR (_("section [%2d] '%s': relocation %zu: copy relocation against symbol of type %s\n"),
1459 : : idx, section_name (ebl, idx), cnt,
1460 : : ebl_symbol_type_name (ebl, GELF_ST_TYPE (sym->st_info),
1461 : : buf, sizeof (buf)));
1462 : : }
1463 : :
1464 [ + + ]: 300712 : if ((ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
1465 [ + - ]: 218156 : || (relshdr->sh_flags & SHF_ALLOC) != 0)
1466 : : {
1467 : : bool in_loaded_seg = false;
1468 [ + + ]: 1169312 : while (loaded != NULL)
1469 : : {
1470 [ + + ]: 868600 : if (r_offset < loaded->to
1471 [ + - + - ]: 218156 : && r_offset + (sym == NULL ? 0 : sym->st_size) >= loaded->from)
1472 : : {
1473 : : /* The symbol is in this segment. */
1474 [ - + ]: 218156 : if (loaded->read_only)
1475 : : {
1476 [ # # ]: 0 : if (textrel)
1477 : 0 : needed_textrel = true;
1478 : : else
1479 : 0 : ERROR (_("section [%2d] '%s': relocation %zu: read-only section modified but text relocation flag not set\n"),
1480 : : idx, section_name (ebl, idx), cnt);
1481 : : }
1482 : :
1483 : : in_loaded_seg = true;
1484 : : }
1485 : :
1486 : 868600 : loaded = loaded->next;
1487 : : }
1488 : :
1489 [ + + ]: 300712 : if (*statep == state_undecided)
1490 [ + + ]: 1310 : *statep = in_loaded_seg ? state_loaded : state_unloaded;
1491 [ + + + - ]: 299880 : else if ((*statep == state_unloaded && in_loaded_seg)
1492 [ + + - + ]: 299880 : || (*statep == state_loaded && !in_loaded_seg))
1493 : : {
1494 : 0 : ERROR (_("\
1495 : : section [%2d] '%s': relocations are against loaded and unloaded data\n"),
1496 : : idx, section_name (ebl, idx));
1497 : 0 : *statep = state_error;
1498 : : }
1499 : : }
1500 : : }
1501 : :
1502 : :
1503 : : static void
1504 : 724 : check_rela (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
1505 : : {
1506 : 724 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
1507 [ - + ]: 724 : if (data == NULL)
1508 : : {
1509 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
1510 : : idx, section_name (ebl, idx));
1511 : 0 : return;
1512 : : }
1513 : :
1514 : : /* Check the fields of the section header. */
1515 : 724 : GElf_Shdr destshdr_mem;
1516 : 724 : GElf_Shdr *destshdr = NULL;
1517 : 724 : struct loaded_segment *loaded = NULL;
1518 : 724 : bool reldyn = check_reloc_shdr (ebl, ehdr, shdr, idx, ELF_T_RELA, &destshdr,
1519 : : &destshdr_mem, &loaded);
1520 : :
1521 : 724 : Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
1522 : 724 : GElf_Shdr symshdr_mem;
1523 : 724 : GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
1524 : 724 : Elf_Data *symdata = elf_getdata (symscn, NULL);
1525 : 724 : enum load_state state = state_undecided;
1526 : :
1527 : 724 : size_t sh_entsize = gelf_fsize (ebl->elf, ELF_T_RELA, 1, EV_CURRENT);
1528 [ + + ]: 294124 : for (size_t cnt = 0; cnt < shdr->sh_size / sh_entsize; ++cnt)
1529 : : {
1530 : 293400 : GElf_Rela rela_mem;
1531 : 293400 : GElf_Rela *rela = gelf_getrela (data, cnt, &rela_mem);
1532 [ - + ]: 293400 : if (rela == NULL)
1533 : : {
1534 : 0 : ERROR (_("\
1535 : : section [%2d] '%s': cannot get relocation %zu: %s\n"),
1536 : : idx, section_name (ebl, idx), cnt, elf_errmsg (-1));
1537 : 0 : continue;
1538 : : }
1539 : :
1540 : 293400 : check_one_reloc (ebl, ehdr, shdr, idx, cnt, symshdr, symdata,
1541 : : rela->r_offset, rela->r_info, destshdr, reldyn, loaded,
1542 : : &state);
1543 : : }
1544 : :
1545 [ + + ]: 1510 : while (loaded != NULL)
1546 : : {
1547 : 786 : struct loaded_segment *old = loaded;
1548 : 786 : loaded = loaded->next;
1549 : 786 : free (old);
1550 : : }
1551 : : }
1552 : :
1553 : :
1554 : : static void
1555 : 110 : check_rel (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
1556 : : {
1557 : 110 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
1558 [ - + ]: 110 : if (data == NULL)
1559 : : {
1560 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
1561 : : idx, section_name (ebl, idx));
1562 : 0 : return;
1563 : : }
1564 : :
1565 : : /* Check the fields of the section header. */
1566 : 110 : GElf_Shdr destshdr_mem;
1567 : 110 : GElf_Shdr *destshdr = NULL;
1568 : 110 : struct loaded_segment *loaded = NULL;
1569 : 110 : bool reldyn = check_reloc_shdr (ebl, ehdr, shdr, idx, ELF_T_REL, &destshdr,
1570 : : &destshdr_mem, &loaded);
1571 : :
1572 : 110 : Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
1573 : 110 : GElf_Shdr symshdr_mem;
1574 : 110 : GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
1575 : 110 : Elf_Data *symdata = elf_getdata (symscn, NULL);
1576 : 110 : enum load_state state = state_undecided;
1577 : :
1578 : 110 : size_t sh_entsize = gelf_fsize (ebl->elf, ELF_T_REL, 1, EV_CURRENT);
1579 [ + + ]: 7426 : for (size_t cnt = 0; cnt < shdr->sh_size / sh_entsize; ++cnt)
1580 : : {
1581 : 7316 : GElf_Rel rel_mem;
1582 : 7316 : GElf_Rel *rel = gelf_getrel (data, cnt, &rel_mem);
1583 [ - + ]: 7316 : if (rel == NULL)
1584 : : {
1585 : 0 : ERROR (_("\
1586 : : section [%2d] '%s': cannot get relocation %zu: %s\n"),
1587 : : idx, section_name (ebl, idx), cnt, elf_errmsg (-1));
1588 : 0 : continue;
1589 : : }
1590 : :
1591 : 7316 : check_one_reloc (ebl, ehdr, shdr, idx, cnt, symshdr, symdata,
1592 : : rel->r_offset, rel->r_info, destshdr, reldyn, loaded,
1593 : : &state);
1594 : : }
1595 : :
1596 [ + + ]: 270 : while (loaded != NULL)
1597 : : {
1598 : 160 : struct loaded_segment *old = loaded;
1599 : 160 : loaded = loaded->next;
1600 : 160 : free (old);
1601 : : }
1602 : : }
1603 : :
1604 : : static void
1605 : 0 : check_relr (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
1606 : : {
1607 : 0 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
1608 [ # # ]: 0 : if (data == NULL)
1609 : : {
1610 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
1611 : : idx, section_name (ebl, idx));
1612 : 0 : return;
1613 : : }
1614 : :
1615 : : /* Check the fields of the section header. */
1616 : 0 : GElf_Shdr destshdr_mem;
1617 : 0 : GElf_Shdr *destshdr = NULL;
1618 : 0 : struct loaded_segment *loaded = NULL;
1619 : 0 : check_reloc_shdr (ebl, ehdr, shdr, idx, ELF_T_RELR, &destshdr,
1620 : : &destshdr_mem, &loaded);
1621 : :
1622 : : /* Just throw them away. */
1623 [ # # ]: 0 : while (loaded != NULL)
1624 : : {
1625 : 0 : struct loaded_segment *old = loaded;
1626 : 0 : loaded = loaded->next;
1627 : 0 : free (old);
1628 : : }
1629 : : }
1630 : :
1631 : : /* Number of dynamic sections. */
1632 : : static int ndynamic;
1633 : :
1634 : :
1635 : : static void
1636 : 186 : check_dynamic (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
1637 : : {
1638 : 186 : Elf_Data *data;
1639 : 186 : GElf_Shdr strshdr_mem;
1640 : 186 : GElf_Shdr *strshdr;
1641 : 186 : size_t cnt;
1642 : 186 : static const bool dependencies[DT_NUM][DT_NUM] =
1643 : : {
1644 : : [DT_NEEDED] = { [DT_STRTAB] = true },
1645 : : [DT_PLTRELSZ] = { [DT_JMPREL] = true },
1646 : : [DT_HASH] = { [DT_SYMTAB] = true },
1647 : : [DT_STRTAB] = { [DT_STRSZ] = true },
1648 : : [DT_SYMTAB] = { [DT_STRTAB] = true, [DT_SYMENT] = true },
1649 : : [DT_RELA] = { [DT_RELASZ] = true, [DT_RELAENT] = true },
1650 : : [DT_RELASZ] = { [DT_RELA] = true },
1651 : : [DT_RELAENT] = { [DT_RELA] = true },
1652 : : [DT_STRSZ] = { [DT_STRTAB] = true },
1653 : : [DT_SYMENT] = { [DT_SYMTAB] = true },
1654 : : [DT_SONAME] = { [DT_STRTAB] = true },
1655 : : [DT_RPATH] = { [DT_STRTAB] = true },
1656 : : [DT_REL] = { [DT_RELSZ] = true, [DT_RELENT] = true },
1657 : : [DT_RELSZ] = { [DT_REL] = true },
1658 : : [DT_RELENT] = { [DT_REL] = true },
1659 : : [DT_JMPREL] = { [DT_PLTRELSZ] = true, [DT_PLTREL] = true },
1660 : : [DT_RUNPATH] = { [DT_STRTAB] = true },
1661 : : [DT_PLTREL] = { [DT_JMPREL] = true },
1662 : : };
1663 : 186 : bool has_dt[DT_NUM];
1664 : 186 : bool has_val_dt[DT_VALNUM];
1665 : 186 : bool has_addr_dt[DT_ADDRNUM];
1666 : 186 : static const bool level2[DT_NUM] =
1667 : : {
1668 : : [DT_RPATH] = true,
1669 : : [DT_SYMBOLIC] = true,
1670 : : [DT_TEXTREL] = true,
1671 : : [DT_BIND_NOW] = true
1672 : : };
1673 : 186 : static const bool mandatory[DT_NUM] =
1674 : : {
1675 : : [DT_NULL] = true,
1676 : : [DT_STRTAB] = true,
1677 : : [DT_SYMTAB] = true,
1678 : : [DT_STRSZ] = true,
1679 : : [DT_SYMENT] = true
1680 : : };
1681 : :
1682 [ - + ]: 186 : memset (has_dt, '\0', sizeof (has_dt));
1683 : 186 : memset (has_val_dt, '\0', sizeof (has_val_dt));
1684 : 186 : memset (has_addr_dt, '\0', sizeof (has_addr_dt));
1685 : :
1686 [ - + ]: 186 : if (++ndynamic == 2)
1687 : 0 : ERROR (_("more than one dynamic section present\n"));
1688 : :
1689 : 186 : data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
1690 [ - + ]: 186 : if (data == NULL)
1691 : : {
1692 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
1693 : : idx, section_name (ebl, idx));
1694 : 0 : return;
1695 : : }
1696 : :
1697 : 186 : strshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &strshdr_mem);
1698 [ + - - + ]: 186 : if (strshdr != NULL && strshdr->sh_type != SHT_STRTAB)
1699 : 0 : ERROR (_("\
1700 : : section [%2d] '%s': referenced as string table for section [%2d] '%s' but type is not SHT_STRTAB\n"),
1701 : : shdr->sh_link, section_name (ebl, shdr->sh_link),
1702 : : idx, section_name (ebl, idx));
1703 : 0 : else if (strshdr == NULL)
1704 : : {
1705 : 0 : ERROR (_("\
1706 : : section [%2d]: referenced as string table for section [%2d] '%s' but section link value is invalid\n"),
1707 : : shdr->sh_link, idx, section_name (ebl, idx));
1708 : 0 : return;
1709 : : }
1710 : :
1711 : 186 : size_t sh_entsize = gelf_fsize (ebl->elf, ELF_T_DYN, 1, EV_CURRENT);
1712 [ - + ]: 186 : if (shdr->sh_entsize != sh_entsize)
1713 : 0 : ERROR (_("\
1714 : : section [%2d] '%s': section entry size does not match ElfXX_Dyn\n"),
1715 : : idx, section_name (ebl, idx));
1716 : :
1717 [ - + ]: 186 : if (shdr->sh_info != 0)
1718 : 0 : ERROR (_("section [%2d] '%s': sh_info not zero\n"),
1719 : : idx, section_name (ebl, idx));
1720 : :
1721 : : bool non_null_warned = false;
1722 [ + + ]: 5360 : for (cnt = 0; cnt < shdr->sh_size / sh_entsize; ++cnt)
1723 : : {
1724 : 5174 : GElf_Dyn dyn_mem;
1725 : 5174 : GElf_Dyn *dyn = gelf_getdyn (data, cnt, &dyn_mem);
1726 [ - + ]: 5174 : if (dyn == NULL)
1727 : : {
1728 : 0 : ERROR (_("\
1729 : : section [%2d] '%s': cannot get dynamic section entry %zu: %s\n"),
1730 : : idx, section_name (ebl, idx), cnt, elf_errmsg (-1));
1731 : 0 : continue;
1732 : : }
1733 : :
1734 [ + + - + : 5174 : if (has_dt[DT_NULL] && dyn->d_tag != DT_NULL && ! non_null_warned)
- - ]
1735 : : {
1736 : 0 : ERROR (_("\
1737 : : section [%2d] '%s': non-DT_NULL entries follow DT_NULL entry\n"),
1738 : : idx, section_name (ebl, idx));
1739 : 0 : non_null_warned = true;
1740 : : }
1741 : :
1742 [ - + ]: 5174 : if (!ebl_dynamic_tag_check (ebl, dyn->d_tag))
1743 : 0 : ERROR (_("section [%2d] '%s': entry %zu: unknown tag\n"),
1744 : : idx, section_name (ebl, idx), cnt);
1745 : :
1746 [ + + ]: 5174 : if (dyn->d_tag >= 0 && dyn->d_tag < DT_NUM)
1747 : : {
1748 [ + + ]: 4308 : if (has_dt[dyn->d_tag]
1749 [ + + ]: 958 : && dyn->d_tag != DT_NEEDED
1750 [ - + ]: 684 : && dyn->d_tag != DT_NULL
1751 : : && dyn->d_tag != DT_POSFLAG_1)
1752 : : {
1753 : 0 : char buf[50];
1754 : 0 : ERROR (_("\
1755 : : section [%2d] '%s': entry %zu: more than one entry with tag %s\n"),
1756 : : idx, section_name (ebl, idx), cnt,
1757 : : ebl_dynamic_tag_name (ebl, dyn->d_tag,
1758 : : buf, sizeof (buf)));
1759 : : }
1760 : :
1761 [ - + - - ]: 4308 : if (be_strict && level2[dyn->d_tag])
1762 : : {
1763 : 0 : char buf[50];
1764 : 0 : ERROR (_("\
1765 : : section [%2d] '%s': entry %zu: level 2 tag %s used\n"),
1766 : : idx, section_name (ebl, idx), cnt,
1767 : : ebl_dynamic_tag_name (ebl, dyn->d_tag,
1768 : : buf, sizeof (buf)));
1769 : : }
1770 : :
1771 : 4308 : has_dt[dyn->d_tag] = true;
1772 : : }
1773 [ - + ]: 866 : else if (dyn->d_tag >= 0 && dyn->d_tag <= DT_VALRNGHI
1774 [ # # ]: 0 : && DT_VALTAGIDX (dyn->d_tag) < DT_VALNUM)
1775 : 0 : has_val_dt[DT_VALTAGIDX (dyn->d_tag)] = true;
1776 [ + + ]: 866 : else if (dyn->d_tag >= 0 && dyn->d_tag <= DT_ADDRRNGHI
1777 [ + - ]: 116 : && DT_ADDRTAGIDX (dyn->d_tag) < DT_ADDRNUM)
1778 : 116 : has_addr_dt[DT_ADDRTAGIDX (dyn->d_tag)] = true;
1779 : :
1780 [ + + + + ]: 5174 : if (dyn->d_tag == DT_PLTREL && dyn->d_un.d_val != DT_REL
1781 [ - + ]: 144 : && dyn->d_un.d_val != DT_RELA)
1782 : 0 : ERROR (_("\
1783 : : section [%2d] '%s': entry %zu: DT_PLTREL value must be DT_REL or DT_RELA\n"),
1784 : : idx, section_name (ebl, idx), cnt);
1785 : :
1786 : : /* Check that addresses for entries are in loaded segments. */
1787 [ + + + + ]: 5174 : switch (dyn->d_tag)
1788 : : {
1789 : 186 : size_t n;
1790 : 186 : case DT_STRTAB:
1791 : : /* We require the referenced section is the same as the one
1792 : : specified in sh_link. */
1793 [ - + ]: 186 : if (strshdr->sh_addr != dyn->d_un.d_val)
1794 : : {
1795 : 0 : ERROR (_("\
1796 : : section [%2d] '%s': entry %zu: pointer does not match address of section [%2d] '%s' referenced by sh_link\n"),
1797 : : idx, section_name (ebl, idx), cnt,
1798 : : shdr->sh_link, section_name (ebl, shdr->sh_link));
1799 : 0 : break;
1800 : : }
1801 : 186 : goto check_addr;
1802 : :
1803 : 2762 : default:
1804 [ + + ]: 2762 : if (dyn->d_tag < DT_ADDRRNGLO || dyn->d_tag > DT_ADDRRNGHI)
1805 : : /* Value is no pointer. */
1806 : : break;
1807 : : FALLTHROUGH;
1808 : :
1809 : : case DT_AUXILIARY:
1810 : : case DT_FILTER:
1811 : : case DT_FINI:
1812 : : case DT_FINI_ARRAY:
1813 : : case DT_HASH:
1814 : : case DT_INIT:
1815 : : case DT_INIT_ARRAY:
1816 : : case DT_JMPREL:
1817 : : case DT_PLTGOT:
1818 : : case DT_REL:
1819 : : case DT_RELA:
1820 : : case DT_RELR:
1821 : : case DT_SYMBOLIC:
1822 : : case DT_SYMTAB:
1823 : : case DT_VERDEF:
1824 : : case DT_VERNEED:
1825 : : case DT_VERSYM:
1826 : 116 : check_addr:
1827 [ + - ]: 5980 : for (n = 0; n < phnum; ++n)
1828 : : {
1829 : 5980 : GElf_Phdr phdr_mem;
1830 : 5980 : GElf_Phdr *phdr = gelf_getphdr (ebl->elf, n, &phdr_mem);
1831 [ + - + + ]: 5980 : if (phdr != NULL && phdr->p_type == PT_LOAD
1832 [ + - ]: 2934 : && phdr->p_vaddr <= dyn->d_un.d_ptr
1833 [ + + ]: 2934 : && phdr->p_vaddr + phdr->p_memsz > dyn->d_un.d_ptr)
1834 : : break;
1835 : : }
1836 [ - + ]: 2052 : if (unlikely (n >= phnum))
1837 : : {
1838 : 0 : char buf[50];
1839 : 0 : ERROR (_("\
1840 : : section [%2d] '%s': entry %zu: %s value must point into loaded segment\n"),
1841 : : idx, section_name (ebl, idx), cnt,
1842 : : ebl_dynamic_tag_name (ebl, dyn->d_tag, buf,
1843 : : sizeof (buf)));
1844 : : }
1845 : : break;
1846 : :
1847 : 476 : case DT_NEEDED:
1848 : : case DT_RPATH:
1849 : : case DT_RUNPATH:
1850 : : case DT_SONAME:
1851 [ - + ]: 476 : if (dyn->d_un.d_ptr >= strshdr->sh_size)
1852 : : {
1853 : 0 : char buf[50];
1854 : 0 : ERROR (_("\
1855 : : section [%2d] '%s': entry %zu: %s value must be valid offset in section [%2d] '%s'\n"),
1856 : : idx, section_name (ebl, idx), cnt,
1857 : : ebl_dynamic_tag_name (ebl, dyn->d_tag, buf,
1858 : : sizeof (buf)),
1859 : : shdr->sh_link, section_name (ebl, shdr->sh_link));
1860 : : }
1861 : : break;
1862 : : }
1863 : : }
1864 : :
1865 [ + + ]: 7068 : for (cnt = 1; cnt < DT_NUM; ++cnt)
1866 [ + + ]: 6882 : if (has_dt[cnt])
1867 : : {
1868 [ + + ]: 123396 : for (int inner = 0; inner < DT_NUM; ++inner)
1869 [ + + - + ]: 120232 : if (dependencies[cnt][inner] && ! has_dt[inner])
1870 : : {
1871 : 0 : char buf1[50];
1872 : 0 : char buf2[50];
1873 : :
1874 : 0 : ERROR (_("\
1875 : : section [%2d] '%s': contains %s entry but not %s\n"),
1876 : : idx, section_name (ebl, idx),
1877 : : ebl_dynamic_tag_name (ebl, cnt, buf1, sizeof (buf1)),
1878 : : ebl_dynamic_tag_name (ebl, inner, buf2, sizeof (buf2)));
1879 : : }
1880 : : }
1881 : : else
1882 : : {
1883 [ - + ]: 3718 : if (mandatory[cnt])
1884 : : {
1885 : 0 : char buf[50];
1886 : 0 : ERROR (_("\
1887 : : section [%2d] '%s': mandatory tag %s not present\n"),
1888 : : idx, section_name (ebl, idx),
1889 : : ebl_dynamic_tag_name (ebl, cnt, buf, sizeof (buf)));
1890 : : }
1891 : : }
1892 : :
1893 : : /* Make sure we have an hash table. */
1894 [ + + - + ]: 186 : if (!has_dt[DT_HASH] && !has_addr_dt[DT_ADDRTAGIDX (DT_GNU_HASH)])
1895 : 0 : ERROR (_("\
1896 : : section [%2d] '%s': no hash section present\n"),
1897 : : idx, section_name (ebl, idx));
1898 : :
1899 : : /* The GNU-style hash table also needs a symbol table. */
1900 [ + + + - ]: 186 : if (!has_dt[DT_HASH] && has_addr_dt[DT_ADDRTAGIDX (DT_GNU_HASH)]
1901 [ - + ]: 108 : && !has_dt[DT_SYMTAB])
1902 : 0 : ERROR (_("\
1903 : : section [%2d] '%s': contains %s entry but not %s\n"),
1904 : : idx, section_name (ebl, idx),
1905 : : "DT_GNU_HASH", "DT_SYMTAB");
1906 : :
1907 : : /* Check the rel/rela tags. At least one group must be available. */
1908 [ + + + - : 186 : if ((has_dt[DT_RELA] || has_dt[DT_RELASZ] || has_dt[DT_RELAENT])
- + ]
1909 [ + - + - : 134 : && (!has_dt[DT_RELA] || !has_dt[DT_RELASZ] || !has_dt[DT_RELAENT]))
- + ]
1910 : 0 : ERROR (_("\
1911 : : section [%2d] '%s': not all of %s, %s, and %s are present\n"),
1912 : : idx, section_name (ebl, idx),
1913 : : "DT_RELA", "DT_RELASZ", "DT_RELAENT");
1914 : :
1915 [ + + + - : 186 : if ((has_dt[DT_REL] || has_dt[DT_RELSZ] || has_dt[DT_RELENT])
- + ]
1916 [ + - + - : 38 : && (!has_dt[DT_REL] || !has_dt[DT_RELSZ] || !has_dt[DT_RELENT]))
- + ]
1917 : 0 : ERROR (_("\
1918 : : section [%2d] '%s': not all of %s, %s, and %s are present\n"),
1919 : : idx, section_name (ebl, idx),
1920 : : "DT_REL", "DT_RELSZ", "DT_RELENT");
1921 : :
1922 : : /* Check that all prelink sections are present if any of them is. */
1923 [ + - ]: 186 : if (has_val_dt[DT_VALTAGIDX (DT_GNU_PRELINKED)]
1924 [ - + ]: 186 : || has_val_dt[DT_VALTAGIDX (DT_CHECKSUM)])
1925 : : {
1926 [ # # ]: 0 : if (!has_val_dt[DT_VALTAGIDX (DT_GNU_PRELINKED)])
1927 : 0 : ERROR (_("\
1928 : : section [%2d] '%s': %s tag missing in DSO marked during prelinking\n"),
1929 : : idx, section_name (ebl, idx), "DT_GNU_PRELINKED");
1930 [ # # ]: 0 : if (!has_val_dt[DT_VALTAGIDX (DT_CHECKSUM)])
1931 : 0 : ERROR (_("\
1932 : : section [%2d] '%s': %s tag missing in DSO marked during prelinking\n"),
1933 : : idx, section_name (ebl, idx), "DT_CHECKSUM");
1934 : :
1935 : : /* Only DSOs can be marked like this. */
1936 [ # # ]: 0 : if (ehdr->e_type != ET_DYN)
1937 : 0 : ERROR (_("\
1938 : : section [%2d] '%s': non-DSO file marked as dependency during prelink\n"),
1939 : : idx, section_name (ebl, idx));
1940 : : }
1941 : :
1942 [ + - ]: 186 : if (has_val_dt[DT_VALTAGIDX (DT_GNU_CONFLICTSZ)]
1943 [ + - ]: 186 : || has_val_dt[DT_VALTAGIDX (DT_GNU_LIBLISTSZ)]
1944 [ + - ]: 186 : || has_addr_dt[DT_ADDRTAGIDX (DT_GNU_CONFLICT)]
1945 [ - + ]: 186 : || has_addr_dt[DT_ADDRTAGIDX (DT_GNU_LIBLIST)])
1946 : : {
1947 [ # # ]: 0 : if (!has_val_dt[DT_VALTAGIDX (DT_GNU_CONFLICTSZ)])
1948 : 0 : ERROR (_("\
1949 : : section [%2d] '%s': %s tag missing in prelinked executable\n"),
1950 : : idx, section_name (ebl, idx), "DT_GNU_CONFLICTSZ");
1951 [ # # ]: 0 : if (!has_val_dt[DT_VALTAGIDX (DT_GNU_LIBLISTSZ)])
1952 : 0 : ERROR (_("\
1953 : : section [%2d] '%s': %s tag missing in prelinked executable\n"),
1954 : : idx, section_name (ebl, idx), "DT_GNU_LIBLISTSZ");
1955 [ # # ]: 0 : if (!has_addr_dt[DT_ADDRTAGIDX (DT_GNU_CONFLICT)])
1956 : 0 : ERROR (_("\
1957 : : section [%2d] '%s': %s tag missing in prelinked executable\n"),
1958 : : idx, section_name (ebl, idx), "DT_GNU_CONFLICT");
1959 [ # # ]: 0 : if (!has_addr_dt[DT_ADDRTAGIDX (DT_GNU_LIBLIST)])
1960 : 186 : ERROR (_("\
1961 : : section [%2d] '%s': %s tag missing in prelinked executable\n"),
1962 : : idx, section_name (ebl, idx), "DT_GNU_LIBLIST");
1963 : : }
1964 : : }
1965 : :
1966 : :
1967 : : static void
1968 : 4 : check_symtab_shndx (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
1969 : : {
1970 [ - + ]: 4 : if (ehdr->e_type != ET_REL)
1971 : : {
1972 : 0 : ERROR (_("\
1973 : : section [%2d] '%s': only relocatable files can have extended section index\n"),
1974 : : idx, section_name (ebl, idx));
1975 : 0 : return;
1976 : : }
1977 : :
1978 : 4 : Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
1979 : 4 : GElf_Shdr symshdr_mem;
1980 : 4 : GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
1981 [ + - - + ]: 4 : if (symshdr != NULL && symshdr->sh_type != SHT_SYMTAB)
1982 : 0 : ERROR (_("\
1983 : : section [%2d] '%s': extended section index section not for symbol table\n"),
1984 : : idx, section_name (ebl, idx));
1985 : 0 : else if (symshdr == NULL)
1986 : 0 : ERROR (_("\
1987 : : section [%2d] '%s': sh_link extended section index [%2d] is invalid\n"),
1988 : : idx, section_name (ebl, idx), shdr->sh_link);
1989 : 4 : Elf_Data *symdata = elf_getdata (symscn, NULL);
1990 [ - + ]: 4 : if (symdata == NULL)
1991 : 0 : ERROR (_("cannot get data for symbol section\n"));
1992 : :
1993 [ - + ]: 4 : if (shdr->sh_entsize != sizeof (Elf32_Word))
1994 : 0 : ERROR (_("\
1995 : : section [%2d] '%s': entry size does not match Elf32_Word\n"),
1996 : : idx, section_name (ebl, idx));
1997 : :
1998 [ + - ]: 4 : if (symshdr != NULL
1999 [ + - ]: 4 : && shdr->sh_entsize != 0
2000 [ + - ]: 4 : && symshdr->sh_entsize != 0
2001 : 4 : && (shdr->sh_size / shdr->sh_entsize
2002 [ - + ]: 4 : < symshdr->sh_size / symshdr->sh_entsize))
2003 : 0 : ERROR (_("\
2004 : : section [%2d] '%s': extended index table too small for symbol table\n"),
2005 : : idx, section_name (ebl, idx));
2006 : :
2007 [ - + ]: 4 : if (shdr->sh_info != 0)
2008 : 0 : ERROR (_("section [%2d] '%s': sh_info not zero\n"),
2009 : : idx, section_name (ebl, idx));
2010 : :
2011 [ + + ]: 8 : for (size_t cnt = idx + 1; cnt < shnum; ++cnt)
2012 : : {
2013 : 4 : GElf_Shdr rshdr_mem;
2014 : 4 : GElf_Shdr *rshdr = gelf_getshdr (elf_getscn (ebl->elf, cnt), &rshdr_mem);
2015 [ + - - + ]: 4 : if (rshdr != NULL && rshdr->sh_type == SHT_SYMTAB_SHNDX
2016 [ # # ]: 0 : && rshdr->sh_link == shdr->sh_link)
2017 : : {
2018 : 0 : ERROR (_("\
2019 : : section [%2d] '%s': extended section index in section [%2zu] '%s' refers to same symbol table\n"),
2020 : : idx, section_name (ebl, idx),
2021 : : cnt, section_name (ebl, cnt));
2022 : 0 : break;
2023 : : }
2024 : : }
2025 : :
2026 : 4 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
2027 [ + - - + ]: 4 : if (data == NULL || data->d_buf == NULL)
2028 : : {
2029 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
2030 : : idx, section_name (ebl, idx));
2031 : 0 : return;
2032 : : }
2033 : :
2034 [ + - ]: 4 : if (data->d_size < sizeof (Elf32_Word)
2035 [ - + ]: 4 : || *((Elf32_Word *) data->d_buf) != 0)
2036 : 0 : ERROR (_("symbol 0 should have zero extended section index\n"));
2037 : :
2038 [ + + ]: 176004 : for (size_t cnt = 1; cnt < data->d_size / sizeof (Elf32_Word); ++cnt)
2039 : : {
2040 : 176000 : Elf32_Word xndx = ((Elf32_Word *) data->d_buf)[cnt];
2041 : :
2042 [ + + ]: 176000 : if (xndx != 0)
2043 : : {
2044 : 1922 : GElf_Sym sym_data;
2045 : 1922 : GElf_Sym *sym = gelf_getsym (symdata, cnt, &sym_data);
2046 [ - + ]: 1922 : if (sym == NULL)
2047 : : {
2048 : 0 : ERROR (_("cannot get data for symbol %zu\n"), cnt);
2049 : 0 : continue;
2050 : : }
2051 : :
2052 [ - + ]: 1922 : if (sym->st_shndx != SHN_XINDEX)
2053 : 1922 : ERROR (_("\
2054 : : extended section index is %" PRIu32 " but symbol index is not XINDEX\n"),
2055 : : (uint32_t) xndx);
2056 : : }
2057 : : }
2058 : : }
2059 : :
2060 : :
2061 : : static void
2062 : 70 : check_sysv_hash (Ebl *ebl, GElf_Shdr *shdr, Elf_Data *data, int idx,
2063 : : GElf_Shdr *symshdr)
2064 : : {
2065 : 70 : Elf32_Word nbucket = ((Elf32_Word *) data->d_buf)[0];
2066 : 70 : Elf32_Word nchain = ((Elf32_Word *) data->d_buf)[1];
2067 : :
2068 [ - + ]: 70 : if (shdr->sh_size < (2ULL + nbucket + nchain) * sizeof (Elf32_Word))
2069 : : {
2070 : 0 : ERROR (_("\
2071 : : section [%2d] '%s': hash table section is too small (is %ld, expected %ld)\n"),
2072 : : idx, section_name (ebl, idx), (long int) shdr->sh_size,
2073 : : (long int) ((2 + nbucket + nchain) * sizeof (Elf32_Word)));
2074 : 0 : return;
2075 : : }
2076 : :
2077 : 70 : size_t maxidx = nchain;
2078 : :
2079 [ + - + - ]: 70 : if (symshdr != NULL && symshdr->sh_entsize != 0)
2080 : : {
2081 : 70 : size_t symsize = symshdr->sh_size / symshdr->sh_entsize;
2082 : :
2083 [ - + ]: 70 : if (nchain > symshdr->sh_size / symshdr->sh_entsize)
2084 : 0 : ERROR (_("section [%2d] '%s': chain array too large\n"),
2085 : : idx, section_name (ebl, idx));
2086 : :
2087 : : maxidx = symsize;
2088 : : }
2089 : :
2090 : 70 : Elf32_Word *buf = (Elf32_Word *) data->d_buf;
2091 : 70 : Elf32_Word *end = (Elf32_Word *) ((char *) data->d_buf + shdr->sh_size);
2092 : 70 : size_t cnt;
2093 [ + + ]: 1976 : for (cnt = 2; cnt < 2 + nbucket; ++cnt)
2094 : : {
2095 [ - + ]: 1906 : if (buf + cnt >= end)
2096 : : break;
2097 [ - + ]: 1906 : else if (buf[cnt] >= maxidx)
2098 : 1906 : ERROR (_("\
2099 : : section [%2d] '%s': hash bucket reference %zu out of bounds\n"),
2100 : : idx, section_name (ebl, idx), cnt - 2);
2101 : : }
2102 : :
2103 [ + + ]: 2468 : for (; cnt < 2 + nbucket + nchain; ++cnt)
2104 : : {
2105 [ + - ]: 2398 : if (buf + cnt >= end)
2106 : : break;
2107 [ - + ]: 2398 : else if (buf[cnt] >= maxidx)
2108 : 2398 : ERROR (_("\
2109 : : section [%2d] '%s': hash chain reference %zu out of bounds\n"),
2110 : : idx, section_name (ebl, idx), cnt - 2 - nbucket);
2111 : : }
2112 : : }
2113 : :
2114 : :
2115 : : static void
2116 : 8 : check_sysv_hash64 (Ebl *ebl, GElf_Shdr *shdr, Elf_Data *data, int idx,
2117 : : GElf_Shdr *symshdr)
2118 : : {
2119 : 8 : Elf64_Xword nbucket = ((Elf64_Xword *) data->d_buf)[0];
2120 : 8 : Elf64_Xword nchain = ((Elf64_Xword *) data->d_buf)[1];
2121 : :
2122 : 8 : uint64_t maxwords = shdr->sh_size / sizeof (Elf64_Xword);
2123 [ + - ]: 8 : if (maxwords < 2
2124 [ + - ]: 8 : || maxwords - 2 < nbucket
2125 [ - + ]: 8 : || maxwords - 2 - nbucket < nchain)
2126 : : {
2127 : 0 : ERROR (_("\
2128 : : section [%2d] '%s': hash table section is too small (is %ld, expected %ld)\n"),
2129 : : idx, section_name (ebl, idx), (long int) shdr->sh_size,
2130 : : (long int) ((2 + nbucket + nchain) * sizeof (Elf64_Xword)));
2131 : 0 : return;
2132 : : }
2133 : :
2134 : 8 : size_t maxidx = nchain;
2135 : :
2136 [ + - + - ]: 8 : if (symshdr != NULL && symshdr->sh_entsize != 0)
2137 : : {
2138 : 8 : size_t symsize = symshdr->sh_size / symshdr->sh_entsize;
2139 : :
2140 [ - + ]: 8 : if (nchain > symshdr->sh_size / symshdr->sh_entsize)
2141 : 0 : ERROR (_("section [%2d] '%s': chain array too large\n"),
2142 : : idx, section_name (ebl, idx));
2143 : :
2144 : : maxidx = symsize;
2145 : : }
2146 : :
2147 : 8 : Elf64_Xword *buf = (Elf64_Xword *) data->d_buf;
2148 : 8 : Elf64_Xword *end = (Elf64_Xword *) ((char *) data->d_buf + shdr->sh_size);
2149 : 8 : size_t cnt;
2150 [ + + ]: 32 : for (cnt = 2; cnt < 2 + nbucket; ++cnt)
2151 : : {
2152 [ - + ]: 24 : if (buf + cnt >= end)
2153 : : break;
2154 [ - + ]: 24 : else if (buf[cnt] >= maxidx)
2155 : 24 : ERROR (_("\
2156 : : section [%2d] '%s': hash bucket reference %zu out of bounds\n"),
2157 : : idx, section_name (ebl, idx), cnt - 2);
2158 : : }
2159 : :
2160 [ + + ]: 52 : for (; cnt < 2 + nbucket + nchain; ++cnt)
2161 : : {
2162 [ + - ]: 44 : if (buf + cnt >= end)
2163 : : break;
2164 [ - + ]: 44 : else if (buf[cnt] >= maxidx)
2165 : 44 : ERROR (_("\
2166 : : section [%2d] '%s': hash chain reference %" PRIu64 " out of bounds\n"),
2167 : : idx, section_name (ebl, idx), (uint64_t) cnt - 2 - nbucket);
2168 : : }
2169 : : }
2170 : :
2171 : :
2172 : : static void
2173 : 116 : check_gnu_hash (Ebl *ebl, GElf_Shdr *shdr, Elf_Data *data, int idx,
2174 : : GElf_Shdr *symshdr)
2175 : : {
2176 [ - + ]: 116 : if (data->d_size < 4 * sizeof (Elf32_Word))
2177 : : {
2178 : 0 : ERROR (_("\
2179 : : section [%2d] '%s': not enough data\n"),
2180 : : idx, section_name (ebl, idx));
2181 : 0 : return;
2182 : : }
2183 : :
2184 : 116 : Elf32_Word nbuckets = ((Elf32_Word *) data->d_buf)[0];
2185 : 116 : Elf32_Word symbias = ((Elf32_Word *) data->d_buf)[1];
2186 : 116 : Elf32_Word bitmask_words = ((Elf32_Word *) data->d_buf)[2];
2187 : :
2188 [ + - - + ]: 116 : if (bitmask_words == 0 || !powerof2 (bitmask_words))
2189 : : {
2190 : 0 : ERROR (_("\
2191 : : section [%2d] '%s': bitmask size zero or not power of 2: %u\n"),
2192 : : idx, section_name (ebl, idx), bitmask_words);
2193 : 0 : return;
2194 : : }
2195 : :
2196 : 116 : size_t bitmask_idxmask = bitmask_words - 1;
2197 [ + + ]: 116 : if (gelf_getclass (ebl->elf) == ELFCLASS64)
2198 : 92 : bitmask_words *= 2;
2199 : 116 : Elf32_Word shift = ((Elf32_Word *) data->d_buf)[3];
2200 : :
2201 : : /* Is there still room for the sym chain?
2202 : : Use uint64_t calculation to prevent 32bit overflow. */
2203 : 116 : uint64_t used_buf = (4ULL + bitmask_words + nbuckets) * sizeof (Elf32_Word);
2204 [ - + ]: 116 : if (used_buf > data->d_size)
2205 : : {
2206 : 0 : ERROR (_("\
2207 : : section [%2d] '%s': hash table section is too small (is %ld, expected at least %ld)\n"),
2208 : : idx, section_name (ebl, idx), (long int) shdr->sh_size,
2209 : : (long int) used_buf);
2210 : 0 : return;
2211 : : }
2212 : :
2213 [ - + ]: 116 : if (shift > 31)
2214 : : {
2215 : 0 : ERROR (_("\
2216 : : section [%2d] '%s': 2nd hash function shift too big: %u\n"),
2217 : : idx, section_name (ebl, idx), shift);
2218 : 0 : return;
2219 : : }
2220 : :
2221 : 116 : size_t maxidx = shdr->sh_size / sizeof (Elf32_Word) - (4 + bitmask_words
2222 : 116 : + nbuckets);
2223 : :
2224 [ + - + - ]: 116 : if (symshdr != NULL && symshdr->sh_entsize != 0)
2225 : 116 : maxidx = MIN (maxidx, symshdr->sh_size / symshdr->sh_entsize);
2226 : :
2227 : : /* We need the symbol section data. */
2228 : 116 : Elf_Data *symdata = elf_getdata (elf_getscn (ebl->elf, shdr->sh_link), NULL);
2229 : :
2230 : 116 : union
2231 : : {
2232 : : Elf32_Word *p32;
2233 : : Elf64_Xword *p64;
2234 : 116 : } bitmask = { .p32 = &((Elf32_Word *) data->d_buf)[4] },
2235 : 116 : collected = { .p32 = xcalloc (bitmask_words, sizeof (Elf32_Word)) };
2236 : :
2237 [ + + ]: 116 : size_t classbits = gelf_getclass (ebl->elf) == ELFCLASS32 ? 32 : 64;
2238 : :
2239 : 116 : size_t cnt;
2240 [ + + ]: 1390 : for (cnt = 4 + bitmask_words; cnt < 4 + bitmask_words + nbuckets; ++cnt)
2241 : : {
2242 : 1274 : Elf32_Word symidx = ((Elf32_Word *) data->d_buf)[cnt];
2243 : :
2244 [ + + ]: 1274 : if (symidx == 0)
2245 : 392 : continue;
2246 : :
2247 [ - + ]: 882 : if (symidx < symbias)
2248 : : {
2249 : 0 : ERROR (_("\
2250 : : section [%2d] '%s': hash chain for bucket %zu lower than symbol index bias\n"),
2251 : : idx, section_name (ebl, idx), cnt - (4 + bitmask_words));
2252 : 0 : continue;
2253 : : }
2254 : :
2255 [ + - ]: 1720 : while (symidx - symbias < maxidx)
2256 : : {
2257 : 1720 : Elf32_Word chainhash = ((Elf32_Word *) data->d_buf)[4
2258 : : + bitmask_words
2259 : : + nbuckets
2260 : 1720 : + symidx
2261 : 1720 : - symbias];
2262 : :
2263 [ + - ]: 1720 : if (symdata != NULL)
2264 : : {
2265 : : /* Check that the referenced symbol is not undefined. */
2266 : 1720 : GElf_Sym sym_mem;
2267 : 1720 : GElf_Sym *sym = gelf_getsym (symdata, symidx, &sym_mem);
2268 [ + - + + ]: 1720 : if (sym != NULL && sym->st_shndx == SHN_UNDEF
2269 [ - + ]: 224 : && GELF_ST_TYPE (sym->st_info) != STT_FUNC)
2270 : 0 : ERROR (_("\
2271 : : section [%2d] '%s': symbol %u referenced in chain for bucket %zu is undefined\n"),
2272 : : idx, section_name (ebl, idx), symidx,
2273 : : cnt - (4 + bitmask_words));
2274 : :
2275 : 0 : const char *symname = (sym != NULL
2276 : 1720 : ? elf_strptr (ebl->elf, symshdr->sh_link,
2277 : 1720 : sym->st_name)
2278 : : : NULL);
2279 [ + - ]: 1720 : if (symname != NULL)
2280 : : {
2281 : 1720 : Elf32_Word hval = elf_gnu_hash (symname);
2282 [ - + ]: 1720 : if ((hval & ~1u) != (chainhash & ~1u))
2283 : 0 : ERROR (_("\
2284 : : section [%2d] '%s': hash value for symbol %u in chain for bucket %zu wrong\n"),
2285 : : idx, section_name (ebl, idx), symidx,
2286 : : cnt - (4 + bitmask_words));
2287 : :
2288 : : /* Set the bits in the bitmask. */
2289 : 1720 : size_t maskidx = (hval / classbits) & bitmask_idxmask;
2290 [ - + ]: 1720 : if (maskidx >= bitmask_words)
2291 : : {
2292 : 0 : ERROR (_("\
2293 : : section [%2d] '%s': mask index for symbol %u in chain for bucket %zu wrong\n"),
2294 : : idx, section_name (ebl, idx), symidx,
2295 : : cnt - (4 + bitmask_words));
2296 : 0 : free (collected.p32);
2297 : 0 : return;
2298 : : }
2299 [ + + ]: 1720 : if (classbits == 32)
2300 : : {
2301 : 194 : collected.p32[maskidx]
2302 : 194 : |= UINT32_C (1) << (hval & (classbits - 1));
2303 : 194 : collected.p32[maskidx]
2304 : 194 : |= UINT32_C (1) << ((hval >> shift) & (classbits - 1));
2305 : : }
2306 : : else
2307 : : {
2308 : 1526 : collected.p64[maskidx]
2309 : 1526 : |= UINT64_C (1) << (hval & (classbits - 1));
2310 : 1526 : collected.p64[maskidx]
2311 : 1526 : |= UINT64_C (1) << ((hval >> shift) & (classbits - 1));
2312 : : }
2313 : : }
2314 : : }
2315 : :
2316 [ + + ]: 1720 : if ((chainhash & 1) != 0)
2317 : : break;
2318 : :
2319 : 838 : ++symidx;
2320 : : }
2321 : :
2322 [ - + ]: 882 : if (symidx - symbias >= maxidx)
2323 : 0 : ERROR (_("\
2324 : : section [%2d] '%s': hash chain for bucket %zu out of bounds\n"),
2325 : : idx, section_name (ebl, idx), cnt - (4 + bitmask_words));
2326 [ + - + - ]: 882 : else if (symshdr != NULL && symshdr->sh_entsize != 0
2327 [ - + ]: 882 : && symidx > symshdr->sh_size / symshdr->sh_entsize)
2328 : 1274 : ERROR (_("\
2329 : : section [%2d] '%s': symbol reference in chain for bucket %zu out of bounds\n"),
2330 : : idx, section_name (ebl, idx), cnt - (4 + bitmask_words));
2331 : : }
2332 : :
2333 [ - + ]: 116 : if (memcmp (collected.p32, bitmask.p32, bitmask_words * sizeof (Elf32_Word)))
2334 : 0 : ERROR (_("\
2335 : : section [%2d] '%s': bitmask does not match names in the hash table\n"),
2336 : : idx, section_name (ebl, idx));
2337 : :
2338 : 116 : free (collected.p32);
2339 : : }
2340 : :
2341 : :
2342 : : static void
2343 : 194 : check_hash (int tag, Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
2344 : : {
2345 [ - + ]: 194 : if (ehdr->e_type == ET_REL)
2346 : : {
2347 : 0 : ERROR (_("\
2348 : : section [%2d] '%s': relocatable files cannot have hash tables\n"),
2349 : : idx, section_name (ebl, idx));
2350 : 0 : return;
2351 : : }
2352 : :
2353 : 194 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
2354 [ + - - + ]: 194 : if (data == NULL || data->d_buf == NULL)
2355 : : {
2356 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
2357 : : idx, section_name (ebl, idx));
2358 : 0 : return;
2359 : : }
2360 : :
2361 : 194 : GElf_Shdr symshdr_mem;
2362 : 194 : GElf_Shdr *symshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
2363 : : &symshdr_mem);
2364 [ + - - + ]: 194 : if (symshdr != NULL && symshdr->sh_type != SHT_DYNSYM)
2365 : 0 : ERROR (_("\
2366 : : section [%2d] '%s': hash table not for dynamic symbol table\n"),
2367 : : idx, section_name (ebl, idx));
2368 : 0 : else if (symshdr == NULL)
2369 : 0 : ERROR (_("\
2370 : : section [%2d] '%s': invalid sh_link symbol table section index [%2d]\n"),
2371 : : idx, section_name (ebl, idx), shdr->sh_link);
2372 : :
2373 : 388 : size_t expect_entsize = (tag == SHT_GNU_HASH
2374 : 116 : ? (gelf_getclass (ebl->elf) == ELFCLASS32
2375 [ + + ]: 116 : ? sizeof (Elf32_Word) : 0)
2376 [ + + ]: 194 : : (size_t) ebl_sysvhash_entrysize (ebl));
2377 : :
2378 [ - + ]: 194 : if (shdr->sh_entsize != expect_entsize)
2379 : 0 : ERROR (_("\
2380 : : section [%2d] '%s': hash table entry size incorrect\n"),
2381 : : idx, section_name (ebl, idx));
2382 : :
2383 [ - + ]: 194 : if ((shdr->sh_flags & SHF_ALLOC) == 0)
2384 : 0 : ERROR (_("section [%2d] '%s': not marked to be allocated\n"),
2385 : : idx, section_name (ebl, idx));
2386 : :
2387 [ + + + + : 364 : if (shdr->sh_size < (tag == SHT_GNU_HASH ? 4 : 2) * (expect_entsize ?: 4))
- + ]
2388 : : {
2389 : 0 : ERROR (_("\
2390 : : section [%2d] '%s': hash table has not even room for initial administrative entries\n"),
2391 : : idx, section_name (ebl, idx));
2392 : 0 : return;
2393 : : }
2394 : :
2395 [ + + - ]: 194 : switch (tag)
2396 : : {
2397 : 78 : case SHT_HASH:
2398 [ + + ]: 78 : if (ebl_sysvhash_entrysize (ebl) == sizeof (Elf64_Xword))
2399 : 8 : check_sysv_hash64 (ebl, shdr, data, idx, symshdr);
2400 : : else
2401 : 70 : check_sysv_hash (ebl, shdr, data, idx, symshdr);
2402 : : break;
2403 : :
2404 : 116 : case SHT_GNU_HASH:
2405 : 116 : check_gnu_hash (ebl, shdr, data, idx, symshdr);
2406 : 116 : break;
2407 : :
2408 : : default:
2409 : 0 : assert (! "should not happen");
2410 : : }
2411 : : }
2412 : :
2413 : :
2414 : : /* Compare content of both hash tables, it must be identical. */
2415 : : static void
2416 : 8 : compare_hash_gnu_hash (Ebl *ebl, GElf_Ehdr *ehdr, size_t hash_idx,
2417 : : size_t gnu_hash_idx)
2418 : : {
2419 : 8 : Elf_Scn *hash_scn = elf_getscn (ebl->elf, hash_idx);
2420 : 8 : Elf_Data *hash_data = elf_getdata (hash_scn, NULL);
2421 : 8 : GElf_Shdr hash_shdr_mem;
2422 : 8 : GElf_Shdr *hash_shdr = gelf_getshdr (hash_scn, &hash_shdr_mem);
2423 : 8 : Elf_Scn *gnu_hash_scn = elf_getscn (ebl->elf, gnu_hash_idx);
2424 : 8 : Elf_Data *gnu_hash_data = elf_getdata (gnu_hash_scn, NULL);
2425 : 8 : GElf_Shdr gnu_hash_shdr_mem;
2426 : 8 : GElf_Shdr *gnu_hash_shdr = gelf_getshdr (gnu_hash_scn, &gnu_hash_shdr_mem);
2427 : :
2428 [ + - ]: 8 : if (hash_shdr == NULL || gnu_hash_shdr == NULL
2429 [ + - + - ]: 8 : || hash_data == NULL || hash_data->d_buf == NULL
2430 [ + - + - ]: 8 : || gnu_hash_data == NULL || gnu_hash_data->d_buf == NULL)
2431 : : /* None of these pointers should be NULL since we used the
2432 : : sections already. We are careful nonetheless. */
2433 : 0 : return;
2434 : :
2435 : : /* The link must point to the same symbol table. */
2436 [ - + ]: 8 : if (hash_shdr->sh_link != gnu_hash_shdr->sh_link)
2437 : : {
2438 : 0 : ERROR (_("\
2439 : : sh_link in hash sections [%2zu] '%s' and [%2zu] '%s' not identical\n"),
2440 : : hash_idx, elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name),
2441 : : gnu_hash_idx,
2442 : : elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
2443 : 0 : return;
2444 : : }
2445 : :
2446 : 8 : Elf_Scn *sym_scn = elf_getscn (ebl->elf, hash_shdr->sh_link);
2447 : 8 : Elf_Data *sym_data = elf_getdata (sym_scn, NULL);
2448 : 8 : GElf_Shdr sym_shdr_mem;
2449 : 8 : GElf_Shdr *sym_shdr = gelf_getshdr (sym_scn, &sym_shdr_mem);
2450 : :
2451 [ + - + - ]: 8 : if (sym_data == NULL || sym_data->d_buf == NULL
2452 [ + - + - ]: 8 : || sym_shdr == NULL || sym_shdr->sh_entsize == 0)
2453 : : return;
2454 : :
2455 : 8 : const char *hash_name;
2456 : 8 : const char *gnu_hash_name;
2457 : 8 : hash_name = elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name);
2458 : 8 : gnu_hash_name = elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name);
2459 : :
2460 [ - + ]: 8 : if (gnu_hash_data->d_size < 4 * sizeof (Elf32_Word))
2461 : : {
2462 : 0 : ERROR (_("\
2463 : : hash section [%2zu] '%s' does not contain enough data\n"),
2464 : : gnu_hash_idx, gnu_hash_name);
2465 : 0 : return;
2466 : : }
2467 : :
2468 : 8 : uint32_t nentries = sym_shdr->sh_size / sym_shdr->sh_entsize;
2469 : 8 : char *used = alloca (nentries);
2470 [ + + ]: 8 : memset (used, '\0', nentries);
2471 : :
2472 : : /* First go over the GNU_HASH table and mark the entries as used. */
2473 : 8 : const Elf32_Word *gnu_hasharr = (Elf32_Word *) gnu_hash_data->d_buf;
2474 : 8 : Elf32_Word gnu_nbucket = gnu_hasharr[0];
2475 : 8 : Elf32_Word gnu_symbias = gnu_hasharr[1];
2476 [ + + ]: 8 : const int bitmap_factor = ehdr->e_ident[EI_CLASS] == ELFCLASS32 ? 1 : 2;
2477 : 8 : const Elf32_Word *gnu_bucket = (gnu_hasharr
2478 : 8 : + (4 + gnu_hasharr[2] * bitmap_factor));
2479 : 8 : const Elf32_Word *gnu_chain = gnu_bucket + gnu_hasharr[0];
2480 : :
2481 [ - + ]: 8 : if (gnu_hasharr[2] == 0)
2482 : : {
2483 : 0 : ERROR (_("\
2484 : : hash section [%2zu] '%s' has zero bit mask words\n"),
2485 : : gnu_hash_idx, gnu_hash_name);
2486 : 0 : return;
2487 : : }
2488 : :
2489 : 8 : uint64_t used_buf = ((4ULL + gnu_hasharr[2] * bitmap_factor + gnu_nbucket)
2490 : : * sizeof (Elf32_Word));
2491 : 8 : uint32_t max_nsyms = (gnu_hash_data->d_size - used_buf) / sizeof (Elf32_Word);
2492 [ - + ]: 8 : if (used_buf > gnu_hash_data->d_size)
2493 : : {
2494 : 0 : ERROR (_("\
2495 : : hash section [%2zu] '%s' uses too much data\n"),
2496 : : gnu_hash_idx, gnu_hash_name);
2497 : 0 : return;
2498 : : }
2499 : :
2500 [ + + ]: 24 : for (Elf32_Word cnt = 0; cnt < gnu_nbucket; ++cnt)
2501 : : {
2502 [ + + ]: 16 : if (gnu_bucket[cnt] != STN_UNDEF)
2503 : : {
2504 : 10 : Elf32_Word symidx = gnu_bucket[cnt] - gnu_symbias;
2505 : 12 : do
2506 : : {
2507 [ + - - + ]: 12 : if (symidx >= max_nsyms || symidx + gnu_symbias >= nentries)
2508 : : {
2509 : 0 : ERROR (_("\
2510 : : hash section [%2zu] '%s' invalid symbol index %" PRIu32 " (max_nsyms: %" PRIu32 ", nentries: %" PRIu32 "\n"),
2511 : : gnu_hash_idx, gnu_hash_name, symidx, max_nsyms, nentries);
2512 : 0 : return;
2513 : : }
2514 : 12 : used[symidx + gnu_symbias] |= 1;
2515 : : }
2516 [ + + ]: 12 : while ((gnu_chain[symidx++] & 1u) == 0);
2517 : : }
2518 : : }
2519 : :
2520 : : /* Now go over the old hash table and check that we cover the same
2521 : : entries. */
2522 [ + + ]: 8 : if (hash_shdr->sh_entsize == sizeof (Elf32_Word))
2523 : : {
2524 : 4 : const Elf32_Word *hasharr = (Elf32_Word *) hash_data->d_buf;
2525 [ - + ]: 4 : if (hash_data->d_size < 2 * sizeof (Elf32_Word))
2526 : : {
2527 : 0 : ERROR (_("\
2528 : : hash section [%2zu] '%s' does not contain enough data\n"),
2529 : : hash_idx, hash_name);
2530 : 0 : return;
2531 : : }
2532 : :
2533 : 4 : Elf32_Word nbucket = hasharr[0];
2534 : 4 : Elf32_Word nchain = hasharr[1];
2535 : 4 : uint64_t hash_used = (2ULL + nchain + nbucket) * sizeof (Elf32_Word);
2536 [ - + ]: 4 : if (hash_used > hash_data->d_size)
2537 : : {
2538 : 0 : ERROR (_("\
2539 : : hash section [%2zu] '%s' uses too much data\n"),
2540 : : hash_idx, hash_name);
2541 : 0 : return;
2542 : : }
2543 : :
2544 : 4 : const Elf32_Word *bucket = &hasharr[2];
2545 : 4 : const Elf32_Word *chain = &hasharr[2 + nbucket];
2546 : :
2547 [ + + ]: 12 : for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
2548 : : {
2549 : 8 : Elf32_Word symidx = bucket[cnt];
2550 [ + + + - ]: 18 : while (symidx != STN_UNDEF && symidx < nentries && symidx < nchain)
2551 : : {
2552 : 10 : used[symidx] |= 2;
2553 : 10 : symidx = chain[symidx];
2554 : : }
2555 : : }
2556 : : }
2557 [ + - ]: 4 : else if (hash_shdr->sh_entsize == sizeof (Elf64_Xword))
2558 : : {
2559 : 4 : const Elf64_Xword *hasharr = (Elf64_Xword *) hash_data->d_buf;
2560 [ - + ]: 4 : if (hash_data->d_size < 2 * sizeof (Elf32_Word))
2561 : : {
2562 : 0 : ERROR (_("\
2563 : : hash section [%2zu] '%s' does not contain enough data\n"),
2564 : : hash_idx, hash_name);
2565 : 0 : return;
2566 : : }
2567 : :
2568 : 4 : Elf64_Xword nbucket = hasharr[0];
2569 : 4 : Elf64_Xword nchain = hasharr[1];
2570 : 4 : uint64_t maxwords = hash_data->d_size / sizeof (Elf64_Xword);
2571 [ + - ]: 4 : if (maxwords < 2
2572 [ + - ]: 4 : || maxwords - 2 < nbucket
2573 [ - + ]: 4 : || maxwords - 2 - nbucket < nchain)
2574 : : {
2575 : 0 : ERROR (_("\
2576 : : hash section [%2zu] '%s' uses too much data\n"),
2577 : : hash_idx, hash_name);
2578 : 0 : return;
2579 : : }
2580 : :
2581 : 4 : const Elf64_Xword *bucket = &hasharr[2];
2582 : 4 : const Elf64_Xword *chain = &hasharr[2 + nbucket];
2583 : :
2584 [ + + ]: 16 : for (Elf64_Xword cnt = 0; cnt < nbucket; ++cnt)
2585 : : {
2586 : 12 : Elf64_Xword symidx = bucket[cnt];
2587 [ + + + - : 32 : while (symidx != STN_UNDEF && symidx < nentries && symidx < nchain)
+ - ]
2588 : : {
2589 : 20 : used[symidx] |= 2;
2590 : 20 : symidx = chain[symidx];
2591 : : }
2592 : : }
2593 : : }
2594 : : else
2595 : : {
2596 : 0 : ERROR (_("\
2597 : : hash section [%2zu] '%s' invalid sh_entsize\n"),
2598 : : hash_idx, hash_name);
2599 : 0 : return;
2600 : : }
2601 : :
2602 : : /* Now see which entries are not set in one or both hash tables
2603 : : (unless the symbol is undefined in which case it can be omitted
2604 : : in the new table format). */
2605 [ - + ]: 8 : if ((used[0] & 1) != 0)
2606 : 0 : ERROR (_("section [%2zu] '%s': reference to symbol index 0\n"),
2607 : : gnu_hash_idx,
2608 : : elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
2609 [ - + ]: 8 : if ((used[0] & 2) != 0)
2610 : 0 : ERROR (_("section [%2zu] '%s': reference to symbol index 0\n"),
2611 : : hash_idx, elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name));
2612 : :
2613 [ + + ]: 38 : for (uint32_t cnt = 1; cnt < nentries; ++cnt)
2614 [ + + ]: 30 : if (used[cnt] != 0 && used[cnt] != 3)
2615 : : {
2616 [ - + ]: 18 : if (used[cnt] == 1)
2617 : 0 : ERROR (_("\
2618 : : symbol %d referenced in new hash table in [%2zu] '%s' but not in old hash table in [%2zu] '%s'\n"),
2619 : : cnt, gnu_hash_idx,
2620 : : elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name),
2621 : : hash_idx,
2622 : : elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name));
2623 : : else
2624 : : {
2625 : 18 : GElf_Sym sym_mem;
2626 : 18 : GElf_Sym *sym = gelf_getsym (sym_data, cnt, &sym_mem);
2627 : :
2628 [ + - - + ]: 18 : if (sym != NULL && sym->st_shndx != STN_UNDEF)
2629 : 18 : ERROR (_("\
2630 : : symbol %d referenced in old hash table in [%2zu] '%s' but not in new hash table in [%2zu] '%s'\n"),
2631 : : cnt, hash_idx,
2632 : : elf_strptr (ebl->elf, shstrndx, hash_shdr->sh_name),
2633 : : gnu_hash_idx,
2634 : : elf_strptr (ebl->elf, shstrndx, gnu_hash_shdr->sh_name));
2635 : : }
2636 : : }
2637 : : }
2638 : :
2639 : :
2640 : : static void
2641 : 0 : check_null (Ebl *ebl, GElf_Shdr *shdr, int idx)
2642 : : {
2643 : : #define TEST(name, extra) \
2644 : : if (extra && shdr->sh_##name != 0) \
2645 : : ERROR (_("section [%2d] '%s': nonzero sh_%s for NULL section\n"), \
2646 : : idx, section_name (ebl, idx), #name)
2647 : :
2648 [ # # ]: 0 : TEST (name, 1);
2649 [ # # ]: 0 : TEST (flags, 1);
2650 [ # # ]: 0 : TEST (addr, 1);
2651 [ # # ]: 0 : TEST (offset, 1);
2652 [ # # # # ]: 0 : TEST (size, idx != 0);
2653 [ # # ]: 0 : TEST (link, idx != 0);
2654 [ # # ]: 0 : TEST (info, 1);
2655 [ # # ]: 0 : TEST (addralign, 1);
2656 [ # # ]: 0 : TEST (entsize, 1);
2657 : 0 : }
2658 : :
2659 : :
2660 : : static void
2661 : 44016 : check_group (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
2662 : : {
2663 [ - + ]: 44016 : if (ehdr->e_type != ET_REL)
2664 : : {
2665 : 0 : ERROR (_("\
2666 : : section [%2d] '%s': section groups only allowed in relocatable object files\n"),
2667 : : idx, section_name (ebl, idx));
2668 : 0 : return;
2669 : : }
2670 : :
2671 : : /* Check that sh_link is an index of a symbol table. */
2672 : 44016 : Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
2673 : 44016 : GElf_Shdr symshdr_mem;
2674 : 44016 : GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
2675 [ - + ]: 44016 : if (symshdr == NULL)
2676 : 0 : ERROR (_("section [%2d] '%s': cannot get symbol table: %s\n"),
2677 : : idx, section_name (ebl, idx), elf_errmsg (-1));
2678 : : else
2679 : : {
2680 [ - + ]: 44016 : if (symshdr->sh_type != SHT_SYMTAB)
2681 : 0 : ERROR (_("\
2682 : : section [%2d] '%s': section reference in sh_link is no symbol table\n"),
2683 : : idx, section_name (ebl, idx));
2684 : :
2685 [ - + ]: 44016 : if (shdr->sh_info >= symshdr->sh_size / gelf_fsize (ebl->elf, ELF_T_SYM,
2686 : : 1, EV_CURRENT))
2687 : 0 : ERROR (_("\
2688 : : section [%2d] '%s': invalid symbol index in sh_info\n"),
2689 : : idx, section_name (ebl, idx));
2690 : :
2691 [ - + ]: 44016 : if (shdr->sh_flags != 0)
2692 : 0 : ERROR (_("section [%2d] '%s': sh_flags not zero\n"),
2693 : : idx, section_name (ebl, idx));
2694 : :
2695 : 44016 : GElf_Sym sym_data;
2696 : 44016 : GElf_Sym *sym = gelf_getsym (elf_getdata (symscn, NULL), shdr->sh_info,
2697 : : &sym_data);
2698 [ - + ]: 44016 : if (sym == NULL)
2699 : 0 : ERROR (_("\
2700 : : section [%2d] '%s': cannot get symbol for signature\n"),
2701 : : idx, section_name (ebl, idx));
2702 [ - + ]: 44016 : else if (elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name) == NULL)
2703 : 0 : ERROR (_("\
2704 : : section [%2d] '%s': cannot get symbol name for signature\n"),
2705 : : idx, section_name (ebl, idx));
2706 [ - + ]: 44016 : else if (strcmp (elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name),
2707 : : "") == 0)
2708 : 0 : ERROR (_("\
2709 : : section [%2d] '%s': signature symbol cannot be empty string\n"),
2710 : : idx, section_name (ebl, idx));
2711 : :
2712 [ - + ]: 44016 : if (be_strict
2713 [ # # ]: 0 : && shdr->sh_entsize != elf32_fsize (ELF_T_WORD, 1, EV_CURRENT))
2714 : 44016 : ERROR (_("section [%2d] '%s': sh_flags not set correctly\n"),
2715 : : idx, section_name (ebl, idx));
2716 : : }
2717 : :
2718 : 44016 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
2719 [ + - - + ]: 44016 : if (data == NULL || data->d_buf == NULL)
2720 : 0 : ERROR (_("section [%2d] '%s': cannot get data: %s\n"),
2721 : : idx, section_name (ebl, idx), elf_errmsg (-1));
2722 : : else
2723 : : {
2724 : 44016 : size_t elsize = elf32_fsize (ELF_T_WORD, 1, EV_CURRENT);
2725 : 44016 : size_t cnt;
2726 : 44016 : Elf32_Word val;
2727 : :
2728 [ - + ]: 44016 : if (data->d_size % elsize != 0)
2729 : 0 : ERROR (_("\
2730 : : section [%2d] '%s': section size not multiple of sizeof(Elf32_Word)\n"),
2731 : : idx, section_name (ebl, idx));
2732 : :
2733 [ - + ]: 44016 : if (data->d_size < elsize)
2734 : : {
2735 : 0 : ERROR (_("\
2736 : : section [%2d] '%s': section group without flags word\n"),
2737 : : idx, section_name (ebl, idx));
2738 : 0 : return;
2739 : : }
2740 [ - + ]: 44016 : else if (be_strict)
2741 : : {
2742 [ # # ]: 0 : if (data->d_size < 2 * elsize)
2743 : 0 : ERROR (_("\
2744 : : section [%2d] '%s': section group without member\n"),
2745 : : idx, section_name (ebl, idx));
2746 [ # # ]: 0 : else if (data->d_size < 3 * elsize)
2747 : 0 : ERROR (_("\
2748 : : section [%2d] '%s': section group with only one member\n"),
2749 : : idx, section_name (ebl, idx));
2750 : : }
2751 : :
2752 : : #if ALLOW_UNALIGNED
2753 : 44016 : val = *((Elf32_Word *) data->d_buf);
2754 : : #else
2755 : : memcpy (&val, data->d_buf, elsize);
2756 : : #endif
2757 [ - + ]: 44016 : if ((val & ~GRP_COMDAT) != 0)
2758 : 0 : ERROR (_("section [%2d] '%s': unknown section group flags\n"),
2759 : : idx, section_name (ebl, idx));
2760 : :
2761 [ + + ]: 132032 : for (cnt = elsize; cnt + elsize <= data->d_size; cnt += elsize)
2762 : : {
2763 : : #if ALLOW_UNALIGNED
2764 : 88016 : val = *((Elf32_Word *) ((char *) data->d_buf + cnt));
2765 : : #else
2766 : : memcpy (&val, (char *) data->d_buf + cnt, elsize);
2767 : : #endif
2768 : :
2769 [ - + ]: 88016 : if (val > shnum)
2770 : 0 : ERROR (_("\
2771 : : section [%2d] '%s': section index %zu out of range\n"),
2772 : : idx, section_name (ebl, idx), cnt / elsize);
2773 : : else
2774 : : {
2775 : 88016 : GElf_Shdr refshdr_mem;
2776 : 88016 : GElf_Shdr *refshdr = gelf_getshdr (elf_getscn (ebl->elf, val),
2777 : : &refshdr_mem);
2778 [ - + ]: 88016 : if (refshdr == NULL)
2779 : 0 : ERROR (_("\
2780 : : section [%2d] '%s': cannot get section header for element %zu: %s\n"),
2781 : : idx, section_name (ebl, idx), cnt / elsize,
2782 : : elf_errmsg (-1));
2783 : : else
2784 : : {
2785 [ - + ]: 88016 : if (refshdr->sh_type == SHT_GROUP)
2786 : 0 : ERROR (_("\
2787 : : section [%2d] '%s': section group contains another group [%2d] '%s'\n"),
2788 : : idx, section_name (ebl, idx),
2789 : : val, section_name (ebl, val));
2790 : :
2791 [ - + ]: 88016 : if ((refshdr->sh_flags & SHF_GROUP) == 0)
2792 : 0 : ERROR (_("\
2793 : : section [%2d] '%s': element %zu references section [%2d] '%s' without SHF_GROUP flag set\n"),
2794 : : idx, section_name (ebl, idx), cnt / elsize,
2795 : : val, section_name (ebl, val));
2796 : : }
2797 : :
2798 [ + - - + ]: 88016 : if (val < shnum && ++scnref[val] == 2)
2799 : 88016 : ERROR (_("\
2800 : : section [%2d] '%s' is contained in more than one section group\n"),
2801 : : val, section_name (ebl, val));
2802 : : }
2803 : : }
2804 : : }
2805 : : }
2806 : :
2807 : :
2808 : : static const char *
2809 : 0 : section_flags_string (GElf_Word flags, char *buf, size_t len)
2810 : : {
2811 [ # # ]: 0 : if (flags == 0)
2812 : : return "none";
2813 : :
2814 : : static const struct
2815 : : {
2816 : : GElf_Word flag;
2817 : : const char *name;
2818 : : } known_flags[] =
2819 : : {
2820 : : #define NEWFLAG(name) { SHF_##name, #name }
2821 : : NEWFLAG (WRITE),
2822 : : NEWFLAG (ALLOC),
2823 : : NEWFLAG (EXECINSTR),
2824 : : NEWFLAG (MERGE),
2825 : : NEWFLAG (STRINGS),
2826 : : NEWFLAG (INFO_LINK),
2827 : : NEWFLAG (LINK_ORDER),
2828 : : NEWFLAG (OS_NONCONFORMING),
2829 : : NEWFLAG (GROUP),
2830 : : NEWFLAG (TLS),
2831 : : NEWFLAG (COMPRESSED),
2832 : : NEWFLAG (GNU_RETAIN),
2833 : : NEWFLAG (ORDERED),
2834 : : NEWFLAG (EXCLUDE)
2835 : : };
2836 : : #undef NEWFLAG
2837 : : const size_t nknown_flags = sizeof (known_flags) / sizeof (known_flags[0]);
2838 : :
2839 : : char *cp = buf;
2840 : :
2841 [ # # ]: 0 : for (size_t cnt = 0; cnt < nknown_flags; ++cnt)
2842 [ # # ]: 0 : if (flags & known_flags[cnt].flag)
2843 : : {
2844 [ # # ]: 0 : if (cp != buf && len > 1)
2845 : : {
2846 : 0 : *cp++ = '|';
2847 : 0 : --len;
2848 : : }
2849 : :
2850 : 0 : size_t ncopy = MIN (len - 1, strlen (known_flags[cnt].name));
2851 : 0 : cp = mempcpy (cp, known_flags[cnt].name, ncopy);
2852 : 0 : len -= ncopy;
2853 : :
2854 : 0 : flags ^= known_flags[cnt].flag;
2855 : : }
2856 : :
2857 [ # # ]: 0 : if (flags != 0 || cp == buf)
2858 : : {
2859 [ # # # # ]: 0 : int r = snprintf (cp, len - 1, "%s%" PRIx64,
2860 : : (cp == buf) ? "" : "|", (uint64_t) flags);
2861 [ # # ]: 0 : if (r > 0)
2862 : 0 : cp += r;
2863 : : }
2864 : 0 : *cp = '\0';
2865 : :
2866 : 0 : return buf;
2867 : : }
2868 : :
2869 : :
2870 : : static int
2871 : 132 : has_copy_reloc (Ebl *ebl, unsigned int symscnndx, unsigned int symndx)
2872 : : {
2873 : : /* First find the relocation section for the symbol table. */
2874 : 132 : Elf_Scn *scn = NULL;
2875 : 132 : GElf_Shdr shdr_mem;
2876 : 132 : GElf_Shdr *shdr = NULL;
2877 [ + - ]: 1276 : while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
2878 : : {
2879 : 1276 : shdr = gelf_getshdr (scn, &shdr_mem);
2880 [ + - ]: 1276 : if (shdr != NULL
2881 [ + + ]: 1276 : && (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
2882 [ - + ]: 132 : && shdr->sh_link == symscnndx)
2883 : : /* Found the section. */
2884 : : break;
2885 : : }
2886 : :
2887 [ - + ]: 132 : if (scn == NULL)
2888 : : return 0;
2889 : :
2890 : 132 : Elf_Data *data = elf_getdata (scn, NULL);
2891 [ - + - + ]: 132 : if (data == NULL || shdr->sh_entsize == 0)
2892 : : return 0;
2893 : :
2894 [ + + ]: 132 : if (shdr->sh_type == SHT_REL)
2895 [ - + ]: 72 : for (int i = 0; (size_t) i < shdr->sh_size / shdr->sh_entsize; ++i)
2896 : : {
2897 : 72 : GElf_Rel rel_mem;
2898 : 72 : GElf_Rel *rel = gelf_getrel (data, i, &rel_mem);
2899 [ - + ]: 72 : if (rel == NULL)
2900 : 0 : continue;
2901 : :
2902 [ + + ]: 72 : if (GELF_R_SYM (rel->r_info) == symndx
2903 [ + - ]: 16 : && ebl_copy_reloc_p (ebl, GELF_R_TYPE (rel->r_info)))
2904 : 16 : return 1;
2905 : : }
2906 : : else
2907 [ - + ]: 611180 : for (int i = 0; (size_t) i < shdr->sh_size / shdr->sh_entsize; ++i)
2908 : : {
2909 : 611180 : GElf_Rela rela_mem;
2910 : 611180 : GElf_Rela *rela = gelf_getrela (data, i, &rela_mem);
2911 [ - + ]: 611180 : if (rela == NULL)
2912 : 0 : continue;
2913 : :
2914 [ + + ]: 611180 : if (GELF_R_SYM (rela->r_info) == symndx
2915 [ + + ]: 148 : && ebl_copy_reloc_p (ebl, GELF_R_TYPE (rela->r_info)))
2916 : 116 : return 1;
2917 : : }
2918 : :
2919 : : return 0;
2920 : : }
2921 : :
2922 : :
2923 : : static int
2924 : 0 : in_nobits_scn (Ebl *ebl, unsigned int shndx)
2925 : : {
2926 : 0 : GElf_Shdr shdr_mem;
2927 : 0 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, shndx), &shdr_mem);
2928 [ # # # # ]: 0 : return shdr != NULL && shdr->sh_type == SHT_NOBITS;
2929 : : }
2930 : :
2931 : :
2932 : : static struct version_namelist
2933 : : {
2934 : : const char *objname;
2935 : : const char *name;
2936 : : GElf_Versym ndx;
2937 : : enum { ver_def, ver_need } type;
2938 : : struct version_namelist *next;
2939 : : } *version_namelist;
2940 : :
2941 : :
2942 : : static int
2943 : 904 : add_version (const char *objname, const char *name, GElf_Versym ndx, int type)
2944 : : {
2945 : : /* Check that there are no duplications. */
2946 : 904 : struct version_namelist *nlp = version_namelist;
2947 [ + + ]: 5196 : while (nlp != NULL)
2948 : : {
2949 [ + + + + ]: 4292 : if (((nlp->objname == NULL && objname == NULL)
2950 [ + + + - ]: 3922 : || (nlp->objname != NULL && objname != NULL
2951 [ + + ]: 3246 : && strcmp (nlp->objname, objname) == 0))
2952 [ - + ]: 2084 : && strcmp (nlp->name, name) == 0)
2953 [ # # ]: 0 : return nlp->type == ver_def ? 1 : -1;
2954 : 4292 : nlp = nlp->next;
2955 : : }
2956 : :
2957 : 904 : nlp = xmalloc (sizeof (*nlp));
2958 : 904 : nlp->objname = objname;
2959 : 904 : nlp->name = name;
2960 : 904 : nlp->ndx = ndx;
2961 : 904 : nlp->type = type;
2962 : 904 : nlp->next = version_namelist;
2963 : 904 : version_namelist = nlp;
2964 : :
2965 : 904 : return 0;
2966 : : }
2967 : :
2968 : :
2969 : : static void
2970 : 186 : check_versym (Ebl *ebl, int idx)
2971 : : {
2972 : 186 : Elf_Scn *scn = elf_getscn (ebl->elf, idx);
2973 : 186 : GElf_Shdr shdr_mem;
2974 : 186 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
2975 [ + - ]: 186 : if (shdr == NULL)
2976 : : /* The error has already been reported. */
2977 : 0 : return;
2978 : :
2979 : 186 : Elf_Data *data = elf_getdata (scn, NULL);
2980 [ - + ]: 186 : if (data == NULL)
2981 : : {
2982 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
2983 : : idx, section_name (ebl, idx));
2984 : 0 : return;
2985 : : }
2986 : :
2987 : 186 : Elf_Scn *symscn = elf_getscn (ebl->elf, shdr->sh_link);
2988 : 186 : GElf_Shdr symshdr_mem;
2989 : 186 : GElf_Shdr *symshdr = gelf_getshdr (symscn, &symshdr_mem);
2990 [ + - ]: 186 : if (symshdr == NULL)
2991 : : /* The error has already been reported. */
2992 : : return;
2993 : :
2994 [ - + ]: 186 : if (symshdr->sh_type != SHT_DYNSYM)
2995 : : {
2996 : 0 : ERROR (_("\
2997 : : section [%2d] '%s' refers in sh_link to section [%2d] '%s' which is no dynamic symbol table\n"),
2998 : : idx, section_name (ebl, idx),
2999 : : shdr->sh_link, section_name (ebl, shdr->sh_link));
3000 : 0 : return;
3001 : : }
3002 : :
3003 : : /* The number of elements in the version symbol table must be the
3004 : : same as the number of symbols. */
3005 [ + - + - ]: 186 : if (shdr->sh_entsize != 0 && symshdr->sh_entsize != 0
3006 : 186 : && (shdr->sh_size / shdr->sh_entsize
3007 [ - + ]: 186 : != symshdr->sh_size / symshdr->sh_entsize))
3008 : 0 : ERROR (_("\
3009 : : section [%2d] '%s' has different number of entries than symbol table [%2d] '%s'\n"),
3010 : : idx, section_name (ebl, idx),
3011 : : shdr->sh_link, section_name (ebl, shdr->sh_link));
3012 : :
3013 : 186 : Elf_Data *symdata = elf_getdata (symscn, NULL);
3014 [ + - + - ]: 186 : if (symdata == NULL || shdr->sh_entsize == 0)
3015 : : /* The error has already been reported. */
3016 : : return;
3017 : :
3018 [ + + ]: 10658 : for (int cnt = 1; (size_t) cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
3019 : : {
3020 : 10472 : GElf_Versym versym_mem;
3021 : 10472 : GElf_Versym *versym = gelf_getversym (data, cnt, &versym_mem);
3022 [ - + ]: 10472 : if (versym == NULL)
3023 : : {
3024 : 0 : ERROR (_("\
3025 : : section [%2d] '%s': symbol %d: cannot read version data\n"),
3026 : : idx, section_name (ebl, idx), cnt);
3027 : 0 : break;
3028 : : }
3029 : :
3030 : 10472 : GElf_Sym sym_mem;
3031 : 10472 : GElf_Sym *sym = gelf_getsym (symdata, cnt, &sym_mem);
3032 [ - + ]: 10472 : if (sym == NULL)
3033 : : /* Already reported elsewhere. */
3034 : 0 : continue;
3035 : :
3036 [ + + ]: 10472 : if (*versym == VER_NDX_GLOBAL)
3037 : : {
3038 : : /* Global symbol. Make sure it is not defined as local. */
3039 [ - + ]: 2372 : if (GELF_ST_BIND (sym->st_info) == STB_LOCAL)
3040 : 0 : ERROR (_("\
3041 : : section [%2d] '%s': symbol %d: local symbol with global scope\n"),
3042 : : idx, section_name (ebl, idx), cnt);
3043 : : }
3044 [ + + ]: 8100 : else if (*versym != VER_NDX_LOCAL)
3045 : : {
3046 : : /* Versioned symbol. Make sure it is not defined as local. */
3047 [ + + - + ]: 7228 : if (!gnuld && GELF_ST_BIND (sym->st_info) == STB_LOCAL)
3048 : 0 : ERROR (_("\
3049 : : section [%2d] '%s': symbol %d: local symbol with version\n"),
3050 : : idx, section_name (ebl, idx), cnt);
3051 : :
3052 : : /* Look through the list of defined versions and locate the
3053 : : index we need for this symbol. */
3054 : 7228 : struct version_namelist *runp = version_namelist;
3055 [ + - ]: 31192 : while (runp != NULL)
3056 [ + + ]: 31192 : if (runp->ndx == (*versym & (GElf_Versym) 0x7fff))
3057 : : break;
3058 : : else
3059 : 23964 : runp = runp->next;
3060 : :
3061 [ - + ]: 7228 : if (runp == NULL)
3062 : 0 : ERROR (_("\
3063 : : section [%2d] '%s': symbol %d: invalid version index %d\n"),
3064 : : idx, section_name (ebl, idx), cnt, (int) *versym);
3065 [ + + ]: 7228 : else if (sym->st_shndx == SHN_UNDEF
3066 [ - + ]: 5860 : && runp->type == ver_def)
3067 : 0 : ERROR (_("\
3068 : : section [%2d] '%s': symbol %d: version index %d is for defined version\n"),
3069 : : idx, section_name (ebl, idx), cnt, (int) *versym);
3070 [ + + ]: 7228 : else if (sym->st_shndx != SHN_UNDEF
3071 [ + + ]: 1368 : && runp->type == ver_need)
3072 : : {
3073 : : /* Unless this symbol has a copy relocation associated
3074 : : this must not happen. */
3075 [ - + ]: 132 : if (!has_copy_reloc (ebl, shdr->sh_link, cnt)
3076 [ # # ]: 0 : && !in_nobits_scn (ebl, sym->st_shndx))
3077 : 10472 : ERROR (_("\
3078 : : section [%2d] '%s': symbol %d: version index %d is for requested version\n"),
3079 : : idx, section_name (ebl, idx), cnt, (int) *versym);
3080 : : }
3081 : : }
3082 : : }
3083 : : }
3084 : :
3085 : :
3086 : : static int
3087 : 356 : unknown_dependency_p (Elf *elf, const char *fname)
3088 : : {
3089 : 356 : GElf_Phdr phdr_mem;
3090 : 356 : GElf_Phdr *phdr = NULL;
3091 : :
3092 : 356 : unsigned int i;
3093 [ + - ]: 2044 : for (i = 0; i < phnum; ++i)
3094 [ + - ]: 2044 : if ((phdr = gelf_getphdr (elf, i, &phdr_mem)) != NULL
3095 [ + + ]: 2044 : && phdr->p_type == PT_DYNAMIC)
3096 : : break;
3097 : :
3098 [ - + ]: 356 : if (i == phnum)
3099 : : return 1;
3100 [ - + ]: 356 : assert (phdr != NULL);
3101 : 356 : Elf_Scn *scn = gelf_offscn (elf, phdr->p_offset);
3102 : 356 : GElf_Shdr shdr_mem;
3103 : 356 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
3104 : 356 : Elf_Data *data = elf_getdata (scn, NULL);
3105 [ - + - + ]: 356 : if (shdr != NULL && shdr->sh_type == SHT_DYNAMIC
3106 [ - + - + ]: 356 : && data != NULL && shdr->sh_entsize != 0)
3107 [ - + ]: 1020 : for (size_t j = 0; j < shdr->sh_size / shdr->sh_entsize; ++j)
3108 : : {
3109 : 1020 : GElf_Dyn dyn_mem;
3110 : 1020 : GElf_Dyn *dyn = gelf_getdyn (data, j, &dyn_mem);
3111 [ + - + + ]: 1020 : if (dyn != NULL && dyn->d_tag == DT_NEEDED)
3112 : : {
3113 : 968 : const char *str = elf_strptr (elf, shdr->sh_link, dyn->d_un.d_val);
3114 [ + - + + ]: 968 : if (str != NULL && strcmp (str, fname) == 0)
3115 : : /* Found it. */
3116 : 356 : return 0;
3117 : : }
3118 : : }
3119 : :
3120 : : return 1;
3121 : : }
3122 : :
3123 : :
3124 : : static unsigned int nverneed;
3125 : :
3126 : : static void
3127 : 184 : check_verneed (Ebl *ebl, GElf_Shdr *shdr, int idx)
3128 : : {
3129 [ - + ]: 184 : if (++nverneed == 2)
3130 : 0 : ERROR (_("more than one version reference section present\n"));
3131 : :
3132 : 184 : GElf_Shdr strshdr_mem;
3133 : 184 : GElf_Shdr *strshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
3134 : : &strshdr_mem);
3135 [ + - ]: 184 : if (strshdr == NULL)
3136 : 0 : return;
3137 [ - + ]: 184 : if (strshdr->sh_type != SHT_STRTAB)
3138 : 0 : ERROR (_("\
3139 : : section [%2d] '%s': sh_link does not link to string table\n"),
3140 : : idx, section_name (ebl, idx));
3141 : :
3142 : 184 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
3143 [ - + ]: 184 : if (data == NULL)
3144 : : {
3145 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
3146 : : idx, section_name (ebl, idx));
3147 : 0 : return;
3148 : : }
3149 : 184 : unsigned int offset = 0;
3150 [ + + ]: 540 : for (Elf64_Word cnt = shdr->sh_info; cnt > 0; )
3151 : : {
3152 : 356 : cnt--;
3153 : :
3154 : : /* Get the data at the next offset. */
3155 : 356 : GElf_Verneed needmem;
3156 : 356 : GElf_Verneed *need = gelf_getverneed (data, offset, &needmem);
3157 [ + - ]: 356 : if (need == NULL)
3158 : : break;
3159 : :
3160 : 356 : unsigned int auxoffset = offset + need->vn_aux;
3161 : :
3162 [ - + ]: 356 : if (need->vn_version != EV_CURRENT)
3163 : 0 : ERROR (_("\
3164 : : section [%2d] '%s': entry %d has wrong version %d\n"),
3165 : : idx, section_name (ebl, idx), cnt, (int) need->vn_version);
3166 : :
3167 [ + - - + ]: 356 : if (need->vn_cnt > 0 && need->vn_aux < gelf_fsize (ebl->elf, ELF_T_VNEED,
3168 : : 1, EV_CURRENT))
3169 : : {
3170 : 0 : ERROR (_("\
3171 : : section [%2d] '%s': entry %d has wrong offset of auxiliary data\n"),
3172 : : idx, section_name (ebl, idx), cnt);
3173 : 0 : break;
3174 : : }
3175 : :
3176 : 712 : const char *libname = elf_strptr (ebl->elf, shdr->sh_link,
3177 : 356 : need->vn_file);
3178 [ - + ]: 356 : if (libname == NULL)
3179 : : {
3180 : 0 : ERROR (_("\
3181 : : section [%2d] '%s': entry %d has invalid file reference\n"),
3182 : : idx, section_name (ebl, idx), cnt);
3183 : 0 : goto next_need;
3184 : : }
3185 : :
3186 : : /* Check that there is a DT_NEEDED entry for the referenced library. */
3187 [ - + ]: 356 : if (unknown_dependency_p (ebl->elf, libname))
3188 : 0 : ERROR (_("\
3189 : : section [%2d] '%s': entry %d references unknown dependency\n"),
3190 : : idx, section_name (ebl, idx), cnt);
3191 : :
3192 [ + + ]: 1158 : for (int cnt2 = need->vn_cnt; --cnt2 >= 0; )
3193 : : {
3194 : 802 : GElf_Vernaux auxmem;
3195 : 802 : GElf_Vernaux *aux = gelf_getvernaux (data, auxoffset, &auxmem);
3196 [ + - ]: 802 : if (aux == NULL)
3197 : : break;
3198 : :
3199 [ - + ]: 802 : if ((aux->vna_flags & ~VER_FLG_WEAK) != 0)
3200 : 0 : ERROR (_("\
3201 : : section [%2d] '%s': auxiliary entry %d of entry %d has unknown flag\n"),
3202 : : idx, section_name (ebl, idx), need->vn_cnt - cnt2, cnt);
3203 : :
3204 : 1604 : const char *verstr = elf_strptr (ebl->elf, shdr->sh_link,
3205 : 802 : aux->vna_name);
3206 [ - + ]: 802 : if (verstr == NULL)
3207 : : {
3208 : 0 : ERROR (_("\
3209 : : section [%2d] '%s': auxiliary entry %d of entry %d has invalid name reference\n"),
3210 : : idx, section_name (ebl, idx), need->vn_cnt - cnt2, cnt);
3211 : 0 : break;
3212 : : }
3213 : : else
3214 : : {
3215 : 802 : GElf_Word hashval = elf_hash (verstr);
3216 [ - + ]: 802 : if (hashval != aux->vna_hash)
3217 : 0 : ERROR (_("\
3218 : : section [%2d] '%s': auxiliary entry %d of entry %d has wrong hash value: %#x, expected %#x\n"),
3219 : : idx, section_name (ebl, idx), need->vn_cnt - cnt2,
3220 : : cnt, (int) hashval, (int) aux->vna_hash);
3221 : :
3222 : 802 : int res = add_version (libname, verstr, aux->vna_other,
3223 : : ver_need);
3224 [ - + ]: 802 : if (unlikely (res !=0))
3225 : : {
3226 : 0 : ERROR (_("\
3227 : : section [%2d] '%s': auxiliary entry %d of entry %d has duplicate version name '%s'\n"),
3228 : : idx, section_name (ebl, idx), need->vn_cnt - cnt2,
3229 : : cnt, verstr);
3230 : : }
3231 : : }
3232 : :
3233 [ + + - + ]: 802 : if ((aux->vna_next != 0 || cnt2 > 0)
3234 [ - + ]: 446 : && aux->vna_next < gelf_fsize (ebl->elf, ELF_T_VNAUX, 1,
3235 : : EV_CURRENT))
3236 : : {
3237 : 0 : ERROR (_("\
3238 : : section [%2d] '%s': auxiliary entry %d of entry %d has wrong next field\n"),
3239 : : idx, section_name (ebl, idx), need->vn_cnt - cnt2, cnt);
3240 : 0 : break;
3241 : : }
3242 : :
3243 [ - + ]: 802 : auxoffset += MAX (aux->vna_next,
3244 : : gelf_fsize (ebl->elf, ELF_T_VNAUX, 1, EV_CURRENT));
3245 : : }
3246 : :
3247 : : /* Find the next offset. */
3248 : 356 : next_need:
3249 : 356 : offset += need->vn_next;
3250 : :
3251 [ + + ]: 356 : if ((need->vn_next != 0 || cnt > 0)
3252 [ - + ]: 172 : && offset < auxoffset)
3253 : : {
3254 : 0 : ERROR (_("\
3255 : : section [%2d] '%s': entry %d has invalid offset to next entry\n"),
3256 : : idx, section_name (ebl, idx), cnt);
3257 : 0 : break;
3258 : : }
3259 : :
3260 [ + + - + ]: 356 : if (need->vn_next == 0 && cnt > 0)
3261 : : {
3262 : 0 : ERROR (_("\
3263 : : section [%2d] '%s': entry %d has zero offset to next entry, but sh_info says there are more entries\n"),
3264 : : idx, section_name (ebl, idx), cnt);
3265 : 0 : break;
3266 : : }
3267 : : }
3268 : : }
3269 : :
3270 : :
3271 : : static unsigned int nverdef;
3272 : :
3273 : : static void
3274 : 20 : check_verdef (Ebl *ebl, GElf_Shdr *shdr, int idx)
3275 : : {
3276 [ - + ]: 20 : if (++nverdef == 2)
3277 : 0 : ERROR (_("more than one version definition section present\n"));
3278 : :
3279 : 20 : GElf_Shdr strshdr_mem;
3280 : 20 : GElf_Shdr *strshdr = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
3281 : : &strshdr_mem);
3282 [ + - ]: 20 : if (strshdr == NULL)
3283 : 0 : return;
3284 [ - + ]: 20 : if (strshdr->sh_type != SHT_STRTAB)
3285 : 0 : ERROR (_("\
3286 : : section [%2d] '%s': sh_link does not link to string table\n"),
3287 : : idx, section_name (ebl, idx));
3288 : :
3289 : 20 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
3290 [ - + ]: 20 : if (data == NULL)
3291 : : {
3292 : 0 : no_data:
3293 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
3294 : : idx, section_name (ebl, idx));
3295 : 0 : return;
3296 : : }
3297 : :
3298 : : /* Iterate over all version definition entries. We check that there
3299 : : is a BASE entry and that each index is unique. To do the later
3300 : : we collection the information in a list which is later
3301 : : examined. */
3302 : 20 : struct namelist
3303 : : {
3304 : : const char *name;
3305 : : struct namelist *next;
3306 : 20 : } *namelist = NULL;
3307 : 20 : struct namelist *refnamelist = NULL;
3308 : :
3309 : 20 : bool has_base = false;
3310 : 20 : unsigned int offset = 0;
3311 [ + + ]: 122 : for (Elf64_Word cnt = shdr->sh_info; cnt > 0; )
3312 : : {
3313 : 102 : cnt--;
3314 : :
3315 : : /* Get the data at the next offset. */
3316 : 102 : GElf_Verdef defmem;
3317 : 102 : GElf_Verdef *def = gelf_getverdef (data, offset, &defmem);
3318 [ - + ]: 102 : if (def == NULL)
3319 : 0 : goto no_data;
3320 : :
3321 [ + + ]: 102 : if ((def->vd_flags & VER_FLG_BASE) != 0)
3322 : : {
3323 [ - + ]: 20 : if (has_base)
3324 : 0 : ERROR (_("\
3325 : : section [%2d] '%s': more than one BASE definition\n"),
3326 : : idx, section_name (ebl, idx));
3327 [ - + ]: 20 : if (def->vd_ndx != VER_NDX_GLOBAL)
3328 : 0 : ERROR (_("\
3329 : : section [%2d] '%s': BASE definition must have index VER_NDX_GLOBAL\n"),
3330 : : idx, section_name (ebl, idx));
3331 : : has_base = true;
3332 : : }
3333 [ - + ]: 102 : if ((def->vd_flags & ~(VER_FLG_BASE|VER_FLG_WEAK)) != 0)
3334 : 0 : ERROR (_("\
3335 : : section [%2d] '%s': entry %d has unknown flag\n"),
3336 : : idx, section_name (ebl, idx), cnt);
3337 : :
3338 [ - + ]: 102 : if (def->vd_version != EV_CURRENT)
3339 : 0 : ERROR (_("\
3340 : : section [%2d] '%s': entry %d has wrong version %d\n"),
3341 : : idx, section_name (ebl, idx), cnt, (int) def->vd_version);
3342 : :
3343 [ + - - + ]: 102 : if (def->vd_cnt > 0 && def->vd_aux < gelf_fsize (ebl->elf, ELF_T_VDEF,
3344 : : 1, EV_CURRENT))
3345 : : {
3346 : 0 : ERROR (_("\
3347 : : section [%2d] '%s': entry %d has wrong offset of auxiliary data\n"),
3348 : : idx, section_name (ebl, idx), cnt);
3349 : 0 : break;
3350 : : }
3351 : :
3352 : 102 : unsigned int auxoffset = offset + def->vd_aux;
3353 : 102 : GElf_Verdaux auxmem;
3354 : 102 : GElf_Verdaux *aux = gelf_getverdaux (data, auxoffset, &auxmem);
3355 [ - + ]: 102 : if (aux == NULL)
3356 : 0 : goto no_data;
3357 : :
3358 : 102 : const char *name = elf_strptr (ebl->elf, shdr->sh_link, aux->vda_name);
3359 [ - + ]: 102 : if (name == NULL)
3360 : : {
3361 : 0 : ERROR (_("\
3362 : : section [%2d] '%s': entry %d has invalid name reference\n"),
3363 : : idx, section_name (ebl, idx), cnt);
3364 : 0 : goto next_def;
3365 : : }
3366 : 102 : GElf_Word hashval = elf_hash (name);
3367 [ - + ]: 102 : if (def->vd_hash != hashval)
3368 : 0 : ERROR (_("\
3369 : : section [%2d] '%s': entry %d has wrong hash value: %#x, expected %#x\n"),
3370 : : idx, section_name (ebl, idx), cnt, (int) hashval,
3371 : : (int) def->vd_hash);
3372 : :
3373 : 102 : int res = add_version (NULL, name, def->vd_ndx, ver_def);
3374 [ - + ]: 102 : if (unlikely (res !=0))
3375 : : {
3376 : 0 : ERROR (_("\
3377 : : section [%2d] '%s': entry %d has duplicate version name '%s'\n"),
3378 : : idx, section_name (ebl, idx), cnt, name);
3379 : : }
3380 : :
3381 : 102 : struct namelist *newname = alloca (sizeof (*newname));
3382 : 102 : newname->name = name;
3383 : 102 : newname->next = namelist;
3384 : 102 : namelist = newname;
3385 : :
3386 : 102 : auxoffset += aux->vda_next;
3387 [ + + ]: 166 : for (int cnt2 = 1; cnt2 < def->vd_cnt; ++cnt2)
3388 : : {
3389 : 64 : aux = gelf_getverdaux (data, auxoffset, &auxmem);
3390 [ - + ]: 64 : if (aux == NULL)
3391 : 0 : goto no_data;
3392 : :
3393 : 64 : name = elf_strptr (ebl->elf, shdr->sh_link, aux->vda_name);
3394 [ - + ]: 64 : if (name == NULL)
3395 : : {
3396 : 0 : ERROR (_("\
3397 : : section [%2d] '%s': entry %d has invalid name reference in auxiliary data\n"),
3398 : : idx, section_name (ebl, idx), cnt);
3399 : 0 : break;
3400 : : }
3401 : : else
3402 : : {
3403 : 64 : newname = alloca (sizeof (*newname));
3404 : 64 : newname->name = name;
3405 : 64 : newname->next = refnamelist;
3406 : 64 : refnamelist = newname;
3407 : : }
3408 : :
3409 [ + - - + ]: 64 : if ((aux->vda_next != 0 || cnt2 + 1 < def->vd_cnt)
3410 [ # # ]: 0 : && aux->vda_next < gelf_fsize (ebl->elf, ELF_T_VDAUX, 1,
3411 : : EV_CURRENT))
3412 : : {
3413 : 0 : ERROR (_("\
3414 : : section [%2d] '%s': entry %d has wrong next field in auxiliary data\n"),
3415 : : idx, section_name (ebl, idx), cnt);
3416 : 0 : break;
3417 : : }
3418 : :
3419 [ - + ]: 64 : auxoffset += MAX (aux->vda_next,
3420 : : gelf_fsize (ebl->elf, ELF_T_VDAUX, 1, EV_CURRENT));
3421 : : }
3422 : :
3423 : : /* Find the next offset. */
3424 : 102 : next_def:
3425 : 102 : offset += def->vd_next;
3426 : :
3427 [ + + ]: 102 : if ((def->vd_next != 0 || cnt > 0)
3428 [ - + ]: 82 : && offset < auxoffset)
3429 : : {
3430 : 0 : ERROR (_("\
3431 : : section [%2d] '%s': entry %d has invalid offset to next entry\n"),
3432 : : idx, section_name (ebl, idx), cnt);
3433 : 0 : break;
3434 : : }
3435 : :
3436 [ + + - + ]: 102 : if (def->vd_next == 0 && cnt > 0)
3437 : : {
3438 : 0 : ERROR (_("\
3439 : : section [%2d] '%s': entry %d has zero offset to next entry, but sh_info says there are more entries\n"),
3440 : : idx, section_name (ebl, idx), cnt);
3441 : 0 : break;
3442 : : }
3443 : : }
3444 : :
3445 [ - + ]: 20 : if (!has_base)
3446 : 0 : ERROR (_("section [%2d] '%s': no BASE definition\n"),
3447 : : idx, section_name (ebl, idx));
3448 : :
3449 : : /* Check whether the referenced names are available. */
3450 [ + + ]: 122 : while (namelist != NULL)
3451 : : {
3452 : 102 : struct version_namelist *runp = version_namelist;
3453 [ + - ]: 472 : while (runp != NULL)
3454 : : {
3455 [ + - ]: 472 : if (runp->type == ver_def
3456 [ + + ]: 472 : && strcmp (runp->name, namelist->name) == 0)
3457 : : break;
3458 : 370 : runp = runp->next;
3459 : : }
3460 : :
3461 [ - + ]: 102 : if (runp == NULL)
3462 : 0 : ERROR (_("\
3463 : : section [%2d] '%s': unknown parent version '%s'\n"),
3464 : : idx, section_name (ebl, idx), namelist->name);
3465 : :
3466 : 102 : namelist = namelist->next;
3467 : : }
3468 : : }
3469 : :
3470 : : static inline size_t
3471 : 0 : buffer_pos (Elf_Data *data, const unsigned char *p)
3472 : : {
3473 : 0 : return p - (const unsigned char *) data->d_buf;
3474 : : }
3475 : :
3476 : : static inline size_t
3477 : 8 : buffer_left (Elf_Data *data, const unsigned char *p)
3478 : : {
3479 : 8 : return (const unsigned char *) data->d_buf + data->d_size - p;
3480 : : }
3481 : :
3482 : : static void
3483 : 2 : check_attributes (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
3484 : : {
3485 [ - + ]: 2 : if (shdr->sh_size == 0)
3486 : : {
3487 : 0 : ERROR (_("section [%2d] '%s': empty object attributes section\n"),
3488 : : idx, section_name (ebl, idx));
3489 : 0 : return;
3490 : : }
3491 : :
3492 : 2 : Elf_Data *data = elf_rawdata (elf_getscn (ebl->elf, idx), NULL);
3493 [ + - + - : 2 : if (data == NULL || data->d_size == 0 || data->d_buf == NULL)
- + ]
3494 : : {
3495 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
3496 : : idx, section_name (ebl, idx));
3497 : 0 : return;
3498 : : }
3499 : :
3500 : 2 : const unsigned char *p = data->d_buf;
3501 [ - + ]: 2 : if (*p++ != 'A')
3502 : : {
3503 : 0 : ERROR (_("section [%2d] '%s': unrecognized attribute format\n"),
3504 : : idx, section_name (ebl, idx));
3505 : 0 : return;
3506 : : }
3507 : :
3508 [ + + ]: 4 : while (buffer_left (data, p) >= 4)
3509 : : {
3510 : 2 : uint32_t len;
3511 [ - + ]: 2 : memcpy (&len, p, sizeof len);
3512 : :
3513 [ - + ]: 2 : if (len == 0)
3514 : 0 : ERROR (_("\
3515 : : section [%2d] '%s': offset %zu: zero length field in attribute section\n"),
3516 : : idx, section_name (ebl, idx), buffer_pos (data, p));
3517 : :
3518 [ + - ]: 2 : if (MY_ELFDATA != ehdr->e_ident[EI_DATA])
3519 : 2 : CONVERT (len);
3520 : :
3521 [ - + ]: 2 : if (len > buffer_left (data, p))
3522 : : {
3523 : 0 : ERROR (_("\
3524 : : section [%2d] '%s': offset %zu: invalid length in attribute section\n"),
3525 : : idx, section_name (ebl, idx), buffer_pos (data, p));
3526 : 0 : break;
3527 : : }
3528 : :
3529 : 2 : const unsigned char *name = p + sizeof len;
3530 : 2 : p += len;
3531 : :
3532 : 2 : unsigned const char *q = memchr (name, '\0', len);
3533 [ - + ]: 2 : if (q == NULL)
3534 : : {
3535 : 0 : ERROR (_("\
3536 : : section [%2d] '%s': offset %zu: unterminated vendor name string\n"),
3537 : : idx, section_name (ebl, idx), buffer_pos (data, p));
3538 : 0 : break;
3539 : : }
3540 : 2 : ++q;
3541 : :
3542 [ + - + - ]: 2 : if (q - name == sizeof "gnu" && !memcmp (name, "gnu", sizeof "gnu"))
3543 [ + + ]: 4 : while (q < p)
3544 : : {
3545 : 2 : unsigned const char *chunk = q;
3546 : :
3547 : 2 : unsigned int subsection_tag;
3548 : 2 : get_uleb128 (subsection_tag, q, p);
3549 : :
3550 [ - + ]: 2 : if (q >= p)
3551 : : {
3552 : 0 : ERROR (_("\
3553 : : section [%2d] '%s': offset %zu: endless ULEB128 in attribute subsection tag\n"),
3554 : : idx, section_name (ebl, idx), buffer_pos (data, chunk));
3555 : 0 : break;
3556 : : }
3557 : :
3558 : 2 : uint32_t subsection_len;
3559 [ - + ]: 2 : if (p - q < (ptrdiff_t) sizeof subsection_len)
3560 : : {
3561 : 0 : ERROR (_("\
3562 : : section [%2d] '%s': offset %zu: truncated attribute section\n"),
3563 : : idx, section_name (ebl, idx), buffer_pos (data, q));
3564 : 0 : break;
3565 : : }
3566 : :
3567 [ - + ]: 2 : memcpy (&subsection_len, q, sizeof subsection_len);
3568 [ - + ]: 2 : if (subsection_len == 0)
3569 : : {
3570 : 0 : ERROR (_("\
3571 : : section [%2d] '%s': offset %zu: zero length field in attribute subsection\n"),
3572 : : idx, section_name (ebl, idx), buffer_pos (data, q));
3573 : :
3574 : 0 : q += sizeof subsection_len;
3575 : 0 : continue;
3576 : : }
3577 : :
3578 [ + - ]: 2 : if (MY_ELFDATA != ehdr->e_ident[EI_DATA])
3579 : 2 : CONVERT (subsection_len);
3580 : :
3581 : : /* Don't overflow, ptrdiff_t might be 32bits, but signed. */
3582 [ + - ]: 2 : if (p - chunk < (ptrdiff_t) subsection_len
3583 [ - + ]: 2 : || subsection_len >= (uint32_t) PTRDIFF_MAX)
3584 : : {
3585 : 0 : ERROR (_("\
3586 : : section [%2d] '%s': offset %zu: invalid length in attribute subsection\n"),
3587 : : idx, section_name (ebl, idx), buffer_pos (data, q));
3588 : 0 : break;
3589 : : }
3590 : :
3591 : 2 : const unsigned char *subsection_end = chunk + subsection_len;
3592 : 2 : chunk = q;
3593 : 2 : q = subsection_end;
3594 : :
3595 [ - + ]: 2 : if (subsection_tag != 1) /* Tag_File */
3596 : 0 : ERROR (_("\
3597 : : section [%2d] '%s': offset %zu: attribute subsection has unexpected tag %u\n"),
3598 : : idx, section_name (ebl, idx), buffer_pos (data, chunk), subsection_tag);
3599 : : else
3600 : : {
3601 : 2 : chunk += sizeof subsection_len;
3602 [ + + ]: 6 : while (chunk < q)
3603 : : {
3604 : 4 : unsigned int tag;
3605 : 4 : get_uleb128 (tag, chunk, q);
3606 : :
3607 : 4 : uint64_t value = 0;
3608 : 4 : const unsigned char *r = chunk;
3609 [ + - + - ]: 4 : if (tag == 32 || (tag & 1) == 0)
3610 : : {
3611 [ - + ]: 4 : if (r >= q)
3612 : 0 : goto invalid_uleb;
3613 : 4 : get_uleb128 (value, r, q);
3614 [ - + ]: 4 : if (r > q)
3615 : : {
3616 : 0 : invalid_uleb:
3617 : 0 : ERROR (_("\
3618 : : section [%2d] '%s': offset %zu: endless ULEB128 in attribute tag\n"),
3619 : : idx, section_name (ebl, idx), buffer_pos (data, chunk));
3620 : 0 : break;
3621 : : }
3622 : : }
3623 [ + - - + ]: 4 : if (tag == 32 || (tag & 1) != 0)
3624 : : {
3625 : 0 : r = memchr (r, '\0', q - r);
3626 [ # # ]: 0 : if (r == NULL)
3627 : : {
3628 : 0 : ERROR (_("\
3629 : : section [%2d] '%s': offset %zu: unterminated string in attribute\n"),
3630 : : idx, section_name (ebl, idx), buffer_pos (data, chunk));
3631 : 0 : break;
3632 : : }
3633 : 0 : ++r;
3634 : : }
3635 : :
3636 : 4 : const char *tag_name = NULL;
3637 : 4 : const char *value_name = NULL;
3638 [ - + ]: 4 : if (!ebl_check_object_attribute (ebl, (const char *) name,
3639 : : tag, value,
3640 : : &tag_name, &value_name))
3641 : 0 : ERROR (_("\
3642 : : section [%2d] '%s': offset %zu: unrecognized attribute tag %u\n"),
3643 : : idx, section_name (ebl, idx), buffer_pos (data, chunk), tag);
3644 [ + - - + ]: 4 : else if ((tag & 1) == 0 && value_name == NULL)
3645 : 0 : ERROR (_("\
3646 : : section [%2d] '%s': offset %zu: unrecognized %s attribute value %" PRIu64 "\n"),
3647 : : idx, section_name (ebl, idx), buffer_pos (data, chunk),
3648 : : tag_name, value);
3649 : :
3650 : 4 : chunk = r;
3651 : : }
3652 : : }
3653 : : }
3654 : : else
3655 : 2 : ERROR (_("\
3656 : : section [%2d] '%s': offset %zu: vendor '%s' unknown\n"),
3657 : : idx, section_name (ebl, idx), buffer_pos (data, p), name);
3658 : : }
3659 : :
3660 [ - + ]: 2 : if (buffer_left (data, p) != 0)
3661 : 0 : ERROR (_("\
3662 : : section [%2d] '%s': offset %zu: extra bytes after last attribute section\n"),
3663 : : idx, section_name (ebl, idx), buffer_pos (data, p));
3664 : : }
3665 : :
3666 : : static bool has_loadable_segment;
3667 : : static bool has_interp_segment;
3668 : :
3669 : : static const struct
3670 : : {
3671 : : const char *name;
3672 : : size_t namelen;
3673 : : GElf_Word type;
3674 : : enum { unused, exact, atleast, exact_or_gnuld } attrflag;
3675 : : GElf_Word attr;
3676 : : GElf_Word attr2;
3677 : : } special_sections[] =
3678 : : {
3679 : : /* See figure 4-14 in the gABI. */
3680 : : { ".bss", 5, SHT_NOBITS, exact, SHF_ALLOC | SHF_WRITE, 0 },
3681 : : { ".comment", 8, SHT_PROGBITS, atleast, 0, SHF_MERGE | SHF_STRINGS },
3682 : : { ".data", 6, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE, 0 },
3683 : : { ".data1", 7, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE, 0 },
3684 : : { ".debug_str", 11, SHT_PROGBITS, exact_or_gnuld, SHF_MERGE | SHF_STRINGS, 0 },
3685 : : { ".debug_line_str", 16, SHT_PROGBITS, exact_or_gnuld, SHF_MERGE | SHF_STRINGS, 0 },
3686 : : { ".debug", 6, SHT_PROGBITS, exact, 0, 0 },
3687 : : { ".dynamic", 9, SHT_DYNAMIC, atleast, SHF_ALLOC, SHF_WRITE },
3688 : : { ".dynstr", 8, SHT_STRTAB, exact, SHF_ALLOC, 0 },
3689 : : { ".dynsym", 8, SHT_DYNSYM, exact, SHF_ALLOC, 0 },
3690 : : { ".fini", 6, SHT_PROGBITS, exact, SHF_ALLOC | SHF_EXECINSTR, 0 },
3691 : : { ".fini_array", 12, SHT_FINI_ARRAY, exact, SHF_ALLOC | SHF_WRITE, 0 },
3692 : : { ".got", 5, SHT_PROGBITS, unused, 0, 0 }, // XXX more info?
3693 : : { ".hash", 6, SHT_HASH, exact, SHF_ALLOC, 0 },
3694 : : { ".init", 6, SHT_PROGBITS, exact, SHF_ALLOC | SHF_EXECINSTR, 0 },
3695 : : { ".init_array", 12, SHT_INIT_ARRAY, exact, SHF_ALLOC | SHF_WRITE, 0 },
3696 : : { ".interp", 8, SHT_PROGBITS, atleast, 0, SHF_ALLOC }, // XXX more tests?
3697 : : { ".line", 6, SHT_PROGBITS, exact, 0, 0 },
3698 : : { ".note", 6, SHT_NOTE, atleast, 0, SHF_ALLOC },
3699 : : { ".plt", 5, SHT_PROGBITS, unused, 0, 0 }, // XXX more tests
3700 : : { ".preinit_array", 15, SHT_PREINIT_ARRAY, exact, SHF_ALLOC | SHF_WRITE, 0 },
3701 : : { ".rela", 5, SHT_RELA, atleast, 0, SHF_ALLOC | SHF_INFO_LINK }, // XXX more tests
3702 : : { ".relr", 5, SHT_RELR, atleast, 0, SHF_ALLOC }, // XXX more tests
3703 : : { ".rel", 4, SHT_REL, atleast, 0, SHF_ALLOC | SHF_INFO_LINK }, // XXX more tests
3704 : : { ".rodata", 8, SHT_PROGBITS, atleast, SHF_ALLOC, SHF_MERGE | SHF_STRINGS },
3705 : : { ".rodata1", 9, SHT_PROGBITS, atleast, SHF_ALLOC, SHF_MERGE | SHF_STRINGS },
3706 : : { ".shstrtab", 10, SHT_STRTAB, exact, 0, 0 },
3707 : : { ".strtab", 8, SHT_STRTAB, atleast, 0, SHF_ALLOC }, // XXX more tests
3708 : : { ".symtab", 8, SHT_SYMTAB, atleast, 0, SHF_ALLOC }, // XXX more tests
3709 : : { ".symtab_shndx", 14, SHT_SYMTAB_SHNDX, atleast, 0, SHF_ALLOC }, // XXX more tests
3710 : : { ".tbss", 6, SHT_NOBITS, exact, SHF_ALLOC | SHF_WRITE | SHF_TLS, 0 },
3711 : : { ".tdata", 7, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE | SHF_TLS, 0 },
3712 : : { ".tdata1", 8, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE | SHF_TLS, 0 },
3713 : : { ".text", 6, SHT_PROGBITS, exact, SHF_ALLOC | SHF_EXECINSTR, 0 },
3714 : :
3715 : : /* The following are GNU extensions. */
3716 : : { ".gnu.version", 13, SHT_GNU_versym, exact, SHF_ALLOC, 0 },
3717 : : { ".gnu.version_d", 15, SHT_GNU_verdef, exact, SHF_ALLOC, 0 },
3718 : : { ".gnu.version_r", 15, SHT_GNU_verneed, exact, SHF_ALLOC, 0 },
3719 : : { ".gnu.attributes", 16, SHT_GNU_ATTRIBUTES, exact, 0, 0 },
3720 : : };
3721 : : #define nspecial_sections \
3722 : : (sizeof (special_sections) / sizeof (special_sections[0]))
3723 : :
3724 : : #define IS_KNOWN_SPECIAL(idx, string, prefix) \
3725 : : (special_sections[idx].namelen == sizeof string - (prefix ? 1 : 0) \
3726 : : && !memcmp (special_sections[idx].name, string, \
3727 : : sizeof string - (prefix ? 1 : 0)))
3728 : :
3729 : : /* Extra section flags that might or might not be added to the section
3730 : : and have to be ignored. */
3731 : : #define EXTRA_SHFLAGS (SHF_LINK_ORDER \
3732 : : | SHF_GNU_RETAIN \
3733 : : | SHF_GROUP \
3734 : : | SHF_COMPRESSED)
3735 : :
3736 : :
3737 : : /* Indices of some sections we need later. */
3738 : : static size_t eh_frame_hdr_scnndx;
3739 : : static size_t eh_frame_scnndx;
3740 : : static size_t gcc_except_table_scnndx;
3741 : :
3742 : :
3743 : : static void
3744 : 386 : check_sections (Ebl *ebl, GElf_Ehdr *ehdr)
3745 : : {
3746 [ - + ]: 386 : if (ehdr->e_shoff == 0)
3747 : : /* No section header. */
3748 : 0 : return;
3749 : :
3750 : : /* Allocate array to count references in section groups. */
3751 : 386 : scnref = xcalloc (shnum, sizeof (int));
3752 : :
3753 : : /* Check the zeroth section first. It must not have any contents
3754 : : and the section header must contain nonzero value at most in the
3755 : : sh_size and sh_link fields. */
3756 : 386 : GElf_Shdr shdr_mem;
3757 : 386 : GElf_Shdr *shdr = gelf_getshdr (elf_getscn (ebl->elf, 0), &shdr_mem);
3758 [ - + ]: 386 : if (shdr == NULL)
3759 : 0 : ERROR (_("cannot get section header of zeroth section\n"));
3760 : : else
3761 : : {
3762 [ - + ]: 386 : if (shdr->sh_name != 0)
3763 : 0 : ERROR (_("zeroth section has nonzero name\n"));
3764 [ - + ]: 386 : if (shdr->sh_type != 0)
3765 : 0 : ERROR (_("zeroth section has nonzero type\n"));
3766 [ - + ]: 386 : if (shdr->sh_flags != 0)
3767 : 0 : ERROR (_("zeroth section has nonzero flags\n"));
3768 [ - + ]: 386 : if (shdr->sh_addr != 0)
3769 : 0 : ERROR (_("zeroth section has nonzero address\n"));
3770 [ - + ]: 386 : if (shdr->sh_offset != 0)
3771 : 0 : ERROR (_("zeroth section has nonzero offset\n"));
3772 [ - + ]: 386 : if (shdr->sh_addralign != 0)
3773 : 0 : ERROR (_("zeroth section has nonzero align value\n"));
3774 [ - + ]: 386 : if (shdr->sh_entsize != 0)
3775 : 0 : ERROR (_("zeroth section has nonzero entry size value\n"));
3776 : :
3777 [ + + - + ]: 386 : if (shdr->sh_size != 0 && ehdr->e_shnum != 0)
3778 : 0 : ERROR (_("\
3779 : : zeroth section has nonzero size value while ELF header has nonzero shnum value\n"));
3780 : :
3781 [ + + - + ]: 386 : if (shdr->sh_link != 0 && ehdr->e_shstrndx != SHN_XINDEX)
3782 : 0 : ERROR (_("\
3783 : : zeroth section has nonzero link value while ELF header does not signal overflow in shstrndx\n"));
3784 : :
3785 [ - + - - ]: 386 : if (shdr->sh_info != 0 && ehdr->e_phnum != PN_XNUM)
3786 : 0 : ERROR (_("\
3787 : : zeroth section has nonzero link value while ELF header does not signal overflow in phnum\n"));
3788 : : }
3789 : :
3790 : 386 : int *segment_flags = xcalloc (phnum, sizeof segment_flags[0]);
3791 : :
3792 : 386 : bool dot_interp_section = false;
3793 : :
3794 : 386 : size_t hash_idx = 0;
3795 : 386 : size_t gnu_hash_idx = 0;
3796 : :
3797 : 386 : size_t versym_scnndx = 0;
3798 [ + + ]: 799156 : for (size_t cnt = 1; cnt < shnum; ++cnt)
3799 : : {
3800 : 798770 : Elf_Scn *scn = elf_getscn (ebl->elf, cnt);
3801 : 798770 : shdr = gelf_getshdr (scn, &shdr_mem);
3802 [ - + ]: 798770 : if (shdr == NULL)
3803 : : {
3804 : 0 : ERROR (_("\
3805 : : cannot get section header for section [%2zu] '%s': %s\n"),
3806 : : cnt, section_name (ebl, cnt), elf_errmsg (-1));
3807 : 0 : continue;
3808 : : }
3809 : :
3810 : 798770 : const char *scnname = elf_strptr (ebl->elf, shstrndx, shdr->sh_name);
3811 : :
3812 [ - + ]: 798770 : if (scnname == NULL)
3813 : 0 : ERROR (_("section [%2zu]: invalid name\n"), cnt);
3814 : : else
3815 : : {
3816 : : /* Check whether it is one of the special sections defined in
3817 : : the gABI. */
3818 : : size_t s;
3819 [ + + ]: 29406912 : for (s = 0; s < nspecial_sections; ++s)
3820 : 28659414 : if (strncmp (scnname, special_sections[s].name,
3821 [ + + ]: 28659414 : special_sections[s].namelen) == 0)
3822 : : {
3823 : 51272 : char stbuf1[100];
3824 : 51272 : char stbuf2[100];
3825 : 51272 : char stbuf3[100];
3826 : :
3827 : 51272 : GElf_Word good_type = special_sections[s].type;
3828 [ + + + + ]: 51272 : if (IS_KNOWN_SPECIAL (s, ".plt", false)
3829 [ + + ]: 210 : && ebl_bss_plt_p (ebl))
3830 : 51272 : good_type = SHT_NOBITS;
3831 : :
3832 : : /* In a debuginfo file, any normal section can be SHT_NOBITS.
3833 : : This is only invalid for DWARF sections and .shstrtab. */
3834 [ + + ]: 51272 : if (shdr->sh_type != good_type
3835 [ + - ]: 528 : && (shdr->sh_type != SHT_NOBITS
3836 [ + - ]: 528 : || !is_debuginfo
3837 [ - + - - ]: 528 : || IS_KNOWN_SPECIAL (s, ".debug_str", false)
3838 [ + + + - ]: 528 : || IS_KNOWN_SPECIAL (s, ".debug", true)
3839 [ - + - - ]: 528 : || IS_KNOWN_SPECIAL (s, ".shstrtab", false)))
3840 : 0 : ERROR (_("\
3841 : : section [%2d] '%s' has wrong type: expected %s, is %s\n"),
3842 : : (int) cnt, scnname,
3843 : : ebl_section_type_name (ebl, special_sections[s].type,
3844 : : stbuf1, sizeof (stbuf1)),
3845 : : ebl_section_type_name (ebl, shdr->sh_type,
3846 : : stbuf2, sizeof (stbuf2)));
3847 : :
3848 : 51272 : if (special_sections[s].attrflag == exact
3849 [ + + ]: 51272 : || special_sections[s].attrflag == exact_or_gnuld)
3850 : : {
3851 : : /* Except for the link order, retain, group bit and
3852 : : compression flag all the other bits should
3853 : : match exactly. */
3854 : 48354 : if ((shdr->sh_flags & ~EXTRA_SHFLAGS)
3855 [ - + ]: 48354 : != special_sections[s].attr
3856 [ # # # # ]: 0 : && (special_sections[s].attrflag == exact || !gnuld))
3857 : 0 : ERROR (_("\
3858 : : section [%2zu] '%s' has wrong flags: expected %s, is %s\n"),
3859 : : cnt, scnname,
3860 : : section_flags_string (special_sections[s].attr,
3861 : : stbuf1, sizeof (stbuf1)),
3862 : : section_flags_string (shdr->sh_flags
3863 : : & ~EXTRA_SHFLAGS,
3864 : : stbuf2, sizeof (stbuf2)));
3865 : : }
3866 [ + + ]: 2918 : else if (special_sections[s].attrflag == atleast)
3867 : : {
3868 [ + - ]: 2492 : if ((shdr->sh_flags & special_sections[s].attr)
3869 : : != special_sections[s].attr
3870 : 2492 : || ((shdr->sh_flags
3871 : 2492 : & ~(EXTRA_SHFLAGS
3872 : : | special_sections[s].attr
3873 [ - + ]: 2492 : | special_sections[s].attr2))
3874 : : != 0))
3875 : 0 : ERROR (_("\
3876 : : section [%2zu] '%s' has wrong flags: expected %s and possibly %s, is %s\n"),
3877 : : cnt, scnname,
3878 : : section_flags_string (special_sections[s].attr,
3879 : : stbuf1, sizeof (stbuf1)),
3880 : : section_flags_string (special_sections[s].attr2,
3881 : : stbuf2, sizeof (stbuf2)),
3882 : : section_flags_string (shdr->sh_flags
3883 : : & ~EXTRA_SHFLAGS,
3884 : : stbuf3, sizeof (stbuf3)));
3885 : : }
3886 : :
3887 [ + + ]: 51272 : if (strcmp (scnname, ".interp") == 0)
3888 : : {
3889 : 154 : dot_interp_section = true;
3890 : :
3891 [ - + ]: 154 : if (ehdr->e_type == ET_REL)
3892 : 0 : ERROR (_("\
3893 : : section [%2zu] '%s' present in object file\n"),
3894 : : cnt, scnname);
3895 : :
3896 [ + - ]: 154 : if ((shdr->sh_flags & SHF_ALLOC) != 0
3897 [ - + ]: 154 : && !has_loadable_segment)
3898 : 0 : ERROR (_("\
3899 : : section [%2zu] '%s' has SHF_ALLOC flag set but there is no loadable segment\n"),
3900 : : cnt, scnname);
3901 [ - + ]: 154 : else if ((shdr->sh_flags & SHF_ALLOC) == 0
3902 [ # # ]: 0 : && has_loadable_segment)
3903 : 0 : ERROR (_("\
3904 : : section [%2zu] '%s' has SHF_ALLOC flag not set but there are loadable segments\n"),
3905 : : cnt, scnname);
3906 : : }
3907 : : else
3908 : : {
3909 [ + + ]: 51118 : if (strcmp (scnname, ".symtab_shndx") == 0
3910 [ + - ]: 4 : && ehdr->e_type != ET_REL)
3911 : 0 : ERROR (_("\
3912 : : section [%2zu] '%s' is extension section index table in non-object file\n"),
3913 : : cnt, scnname);
3914 : :
3915 : : /* These sections must have the SHF_ALLOC flag set iff
3916 : : a loadable segment is available.
3917 : :
3918 : : .relxxx
3919 : : .strtab
3920 : : .symtab
3921 : : .symtab_shndx
3922 : :
3923 : : Check that if there is a reference from the
3924 : : loaded section these sections also have the
3925 : : ALLOC flag set. */
3926 : : #if 0
3927 : : // XXX TODO
3928 : : if ((shdr->sh_flags & SHF_ALLOC) != 0
3929 : : && !has_loadable_segment)
3930 : : ERROR (_("\
3931 : : section [%2zu] '%s' has SHF_ALLOC flag set but there is no loadable segment\n"),
3932 : : cnt, scnname);
3933 : : else if ((shdr->sh_flags & SHF_ALLOC) == 0
3934 : : && has_loadable_segment)
3935 : : ERROR (_("\
3936 : : section [%2zu] '%s' has SHF_ALLOC flag not set but there are loadable segments\n"),
3937 : : cnt, scnname);
3938 : : #endif
3939 : : }
3940 : :
3941 : 51272 : break;
3942 : : }
3943 : :
3944 : : /* Remember a few special sections for later. */
3945 [ + + ]: 798770 : if (strcmp (scnname, ".eh_frame_hdr") == 0)
3946 : 170 : eh_frame_hdr_scnndx = cnt;
3947 [ + + ]: 798600 : else if (strcmp (scnname, ".eh_frame") == 0)
3948 : 298 : eh_frame_scnndx = cnt;
3949 [ + + ]: 798302 : else if (strcmp (scnname, ".gcc_except_table") == 0)
3950 : 20 : gcc_except_table_scnndx = cnt;
3951 : : }
3952 : :
3953 [ + + - + ]: 798770 : if (shdr->sh_entsize != 0 && shdr->sh_size % shdr->sh_entsize)
3954 : 0 : ERROR (_("\
3955 : : section [%2zu] '%s': size not multiple of entry size\n"),
3956 : : cnt, section_name (ebl, cnt));
3957 : :
3958 [ - + ]: 798770 : if (elf_strptr (ebl->elf, shstrndx, shdr->sh_name) == NULL)
3959 : 0 : ERROR (_("cannot get section header\n"));
3960 : :
3961 : 798770 : if (shdr->sh_type >= SHT_NUM
3962 [ + + ]: 798770 : && shdr->sh_type != SHT_GNU_ATTRIBUTES
3963 : : && shdr->sh_type != SHT_GNU_LIBLIST
3964 : : && shdr->sh_type != SHT_CHECKSUM
3965 : : && shdr->sh_type != SHT_GNU_verdef
3966 : : && shdr->sh_type != SHT_GNU_verneed
3967 : : && shdr->sh_type != SHT_GNU_versym
3968 [ - + ]: 118 : && ebl_section_type_name (ebl, shdr->sh_type, NULL, 0) == NULL)
3969 : 0 : ERROR (_("section [%2zu] '%s' has unsupported type %d\n"),
3970 : : cnt, section_name (ebl, cnt),
3971 : : (int) shdr->sh_type);
3972 : :
3973 : : #define ALL_SH_FLAGS (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR | SHF_MERGE \
3974 : : | SHF_STRINGS | SHF_INFO_LINK | SHF_LINK_ORDER \
3975 : : | SHF_OS_NONCONFORMING | SHF_GROUP | SHF_TLS \
3976 : : | SHF_COMPRESSED | SHF_GNU_RETAIN)
3977 [ + + ]: 798770 : if (shdr->sh_flags & ~(GElf_Xword) ALL_SH_FLAGS)
3978 : : {
3979 : 8 : GElf_Xword sh_flags = shdr->sh_flags & ~(GElf_Xword) ALL_SH_FLAGS;
3980 [ + - ]: 8 : if (sh_flags & SHF_MASKPROC)
3981 : : {
3982 : : /* Strictly speaking SHF_EXCLUDE is a processor specific
3983 : : section flag, but it is used generically in the GNU
3984 : : toolchain. */
3985 [ - + ]: 8 : if (gnuld)
3986 : 0 : sh_flags &= ~(GElf_Xword) SHF_EXCLUDE;
3987 [ - + ]: 8 : if (!ebl_machine_section_flag_check (ebl,
3988 : : sh_flags & SHF_MASKPROC))
3989 : 0 : ERROR (_("section [%2zu] '%s'"
3990 : : " contains invalid processor-specific flag(s)"
3991 : : " %#" PRIx64 "\n"),
3992 : : cnt, section_name (ebl, cnt), sh_flags & SHF_MASKPROC);
3993 : 8 : sh_flags &= ~(GElf_Xword) SHF_MASKPROC;
3994 : : }
3995 : 8 : if (sh_flags & SHF_MASKOS)
3996 : : if (gnuld)
3997 : : sh_flags &= ~(GElf_Xword) SHF_GNU_RETAIN;
3998 [ - + ]: 8 : if (sh_flags != 0)
3999 : 0 : ERROR (_("section [%2zu] '%s' contains unknown flag(s)"
4000 : : " %#" PRIx64 "\n"),
4001 : : cnt, section_name (ebl, cnt), sh_flags);
4002 : : }
4003 [ + + ]: 798770 : if (shdr->sh_flags & SHF_TLS)
4004 : : {
4005 : : // XXX Correct?
4006 [ + - - + ]: 84 : if (shdr->sh_addr != 0 && !gnuld)
4007 : 0 : ERROR (_("\
4008 : : section [%2zu] '%s': thread-local data sections address not zero\n"),
4009 : : cnt, section_name (ebl, cnt));
4010 : :
4011 : : // XXX TODO more tests!?
4012 : : }
4013 : :
4014 [ - + ]: 798770 : if (shdr->sh_flags & SHF_COMPRESSED)
4015 : : {
4016 [ # # ]: 0 : if (shdr->sh_flags & SHF_ALLOC)
4017 : 0 : ERROR (_("\
4018 : : section [%2zu] '%s': allocated section cannot be compressed\n"),
4019 : : cnt, section_name (ebl, cnt));
4020 : :
4021 [ # # ]: 0 : if (shdr->sh_type == SHT_NOBITS)
4022 : 0 : ERROR (_("\
4023 : : section [%2zu] '%s': nobits section cannot be compressed\n"),
4024 : : cnt, section_name (ebl, cnt));
4025 : :
4026 : 0 : GElf_Chdr chdr;
4027 [ # # ]: 0 : if (gelf_getchdr (scn, &chdr) == NULL)
4028 : 0 : ERROR (_("\
4029 : : section [%2zu] '%s': compressed section with no compression header: %s\n"),
4030 : : cnt, section_name (ebl, cnt), elf_errmsg (-1));
4031 : : }
4032 : :
4033 [ - + ]: 798770 : if (shdr->sh_link >= shnum)
4034 : 0 : ERROR (_("\
4035 : : section [%2zu] '%s': invalid section reference in link value\n"),
4036 : : cnt, section_name (ebl, cnt));
4037 : :
4038 [ + + + + : 798770 : if (SH_INFO_LINK_P (shdr) && shdr->sh_info >= shnum)
- + ]
4039 : 0 : ERROR (_("\
4040 : : section [%2zu] '%s': invalid section reference in info value\n"),
4041 : : cnt, section_name (ebl, cnt));
4042 : :
4043 : 798770 : if ((shdr->sh_flags & SHF_MERGE) == 0
4044 [ - + ]: 798770 : && (shdr->sh_flags & SHF_STRINGS) != 0
4045 [ # # ]: 0 : && be_strict)
4046 : 0 : ERROR (_("\
4047 : : section [%2zu] '%s': strings flag set without merge flag\n"),
4048 : : cnt, section_name (ebl, cnt));
4049 : :
4050 [ + + - + ]: 798770 : if ((shdr->sh_flags & SHF_MERGE) != 0 && shdr->sh_entsize == 0)
4051 : 0 : ERROR (_("\
4052 : : section [%2zu] '%s': merge flag set but entry size is zero\n"),
4053 : : cnt, section_name (ebl, cnt));
4054 : :
4055 [ + + ]: 798770 : if (shdr->sh_flags & SHF_GROUP)
4056 : 88016 : check_scn_group (ebl, cnt);
4057 : :
4058 [ + + ]: 798770 : if (shdr->sh_flags & SHF_EXECINSTR)
4059 : : {
4060 [ + - + ]: 1120 : switch (shdr->sh_type)
4061 : : {
4062 : : case SHT_PROGBITS:
4063 : : break;
4064 : :
4065 : 134 : case SHT_NOBITS:
4066 [ - + ]: 134 : if (is_debuginfo)
4067 : : break;
4068 : 0 : FALLTHROUGH;
4069 : : default:
4070 : 0 : ERROR (_("\
4071 : : section [%2zu] '%s' has unexpected type %d for an executable section\n"),
4072 : : cnt, section_name (ebl, cnt), shdr->sh_type);
4073 : 0 : break;
4074 : : }
4075 : :
4076 [ + + ]: 1120 : if (shdr->sh_flags & SHF_WRITE)
4077 : : {
4078 [ - + - - ]: 4 : if (is_debuginfo && shdr->sh_type != SHT_NOBITS)
4079 : 0 : ERROR (_("\
4080 : : section [%2zu] '%s' must be of type NOBITS in debuginfo files\n"),
4081 : : cnt, section_name (ebl, cnt));
4082 : :
4083 [ + - ]: 4 : if (!is_debuginfo
4084 [ - + ]: 4 : && !ebl_check_special_section (ebl, cnt, shdr,
4085 : : section_name (ebl, cnt)))
4086 : 0 : ERROR (_("\
4087 : : section [%2zu] '%s' is both executable and writable\n"),
4088 : : cnt, section_name (ebl, cnt));
4089 : : }
4090 : : }
4091 : :
4092 [ + + + + ]: 798770 : if (ehdr->e_type != ET_REL && (shdr->sh_flags & SHF_ALLOC) != 0
4093 [ + + ]: 5350 : && !is_debuginfo)
4094 : : {
4095 : : /* Make sure the section is contained in a loaded segment
4096 : : and that the initialization part matches NOBITS sections. */
4097 : : unsigned int pcnt;
4098 : : GElf_Phdr phdr_mem;
4099 : : GElf_Phdr *phdr;
4100 : :
4101 [ + - ]: 15222 : for (pcnt = 0; pcnt < phnum; ++pcnt)
4102 [ + - ]: 15222 : if ((phdr = gelf_getphdr (ebl->elf, pcnt, &phdr_mem)) != NULL
4103 [ + + ]: 15222 : && ((phdr->p_type == PT_LOAD
4104 [ + + ]: 8020 : && (shdr->sh_flags & SHF_TLS) == 0)
4105 [ + + ]: 7526 : || (phdr->p_type == PT_TLS
4106 [ + - ]: 82 : && (shdr->sh_flags & SHF_TLS) != 0))
4107 [ + - ]: 7778 : && phdr->p_offset <= shdr->sh_offset
4108 [ + + ]: 7778 : && ((shdr->sh_offset - phdr->p_offset <= phdr->p_filesz
4109 [ + + ]: 4734 : && (shdr->sh_offset - phdr->p_offset < phdr->p_filesz
4110 [ + + ]: 344 : || shdr->sh_size == 0))
4111 [ + + ]: 3340 : || (shdr->sh_offset - phdr->p_offset < phdr->p_memsz
4112 [ + - ]: 258 : && shdr->sh_type == SHT_NOBITS)))
4113 : : {
4114 : : /* Found the segment. */
4115 : 4696 : if (phdr->p_offset + phdr->p_memsz
4116 [ - + ]: 4696 : < shdr->sh_offset + shdr->sh_size)
4117 : 0 : ERROR (_("\
4118 : : section [%2zu] '%s' not fully contained in segment of program header entry %d\n"),
4119 : : cnt, section_name (ebl, cnt), pcnt);
4120 : :
4121 [ + + ]: 4696 : if (shdr->sh_type == SHT_NOBITS)
4122 : : {
4123 [ - + ]: 258 : if (shdr->sh_offset < phdr->p_offset + phdr->p_filesz
4124 [ # # ]: 0 : && !is_debuginfo)
4125 : : {
4126 [ # # ]: 0 : if (!gnuld)
4127 : 0 : ERROR (_("\
4128 : : section [%2zu] '%s' has type NOBITS but is read from the file in segment of program header entry %d\n"),
4129 : : cnt, section_name (ebl, cnt), pcnt);
4130 : : else
4131 : : {
4132 : : /* This is truly horrible. GNU ld might put a
4133 : : NOBITS section in the middle of a PT_LOAD
4134 : : segment, assuming the next gap in the file
4135 : : actually consists of zero bits...
4136 : : So it really is like a PROGBITS section
4137 : : where the data is all zeros. Check those
4138 : : zero bytes are really there. */
4139 : 0 : bool bad;
4140 : 0 : Elf_Data *databits;
4141 : 0 : databits = elf_getdata_rawchunk (ebl->elf,
4142 : : shdr->sh_offset,
4143 : : shdr->sh_size,
4144 : : ELF_T_BYTE);
4145 : 0 : bad = (databits == NULL
4146 [ # # # # ]: 0 : || databits->d_size != shdr->sh_size);
4147 : 0 : for (size_t idx = 0;
4148 [ # # # # ]: 0 : ! bad && idx < databits->d_size;
4149 : 0 : idx++)
4150 : 0 : bad = ((char *) databits->d_buf)[idx] != 0;
4151 : :
4152 [ # # ]: 0 : if (bad)
4153 : 0 : ERROR (_("\
4154 : : section [%2zu] '%s' has type NOBITS but is read from the file in segment of program header entry %d and file contents is non-zero\n"),
4155 : : cnt, section_name (ebl, cnt), pcnt);
4156 : : }
4157 : : }
4158 : : }
4159 : : else
4160 : : {
4161 : 4438 : const GElf_Off end = phdr->p_offset + phdr->p_filesz;
4162 [ + - + + ]: 4438 : if (shdr->sh_offset > end ||
4163 [ - + ]: 48 : (shdr->sh_offset == end && shdr->sh_size != 0))
4164 : 0 : ERROR (_("\
4165 : : section [%2zu] '%s' has not type NOBITS but is not read from the file in segment of program header entry %d\n"),
4166 : : cnt, section_name (ebl, cnt), pcnt);
4167 : : }
4168 : :
4169 [ + + ]: 4696 : if (shdr->sh_type != SHT_NOBITS)
4170 : : {
4171 [ + + ]: 4438 : if ((shdr->sh_flags & SHF_EXECINSTR) != 0)
4172 : : {
4173 : 864 : segment_flags[pcnt] |= PF_X;
4174 [ - + ]: 864 : if ((phdr->p_flags & PF_X) == 0)
4175 : 0 : ERROR (_("\
4176 : : section [%2zu] '%s' is executable in nonexecutable segment %d\n"),
4177 : : cnt, section_name (ebl, cnt), pcnt);
4178 : : }
4179 : :
4180 [ + + ]: 4438 : if ((shdr->sh_flags & SHF_WRITE) != 0)
4181 : : {
4182 : 1302 : segment_flags[pcnt] |= PF_W;
4183 : 1302 : if (0 /* XXX vdso images have this */
4184 : : && (phdr->p_flags & PF_W) == 0)
4185 : : ERROR (_("\
4186 : : section [%2zu] '%s' is writable in unwritable segment %d\n"),
4187 : : cnt, section_name (ebl, cnt), pcnt);
4188 : : }
4189 : : }
4190 : :
4191 : : break;
4192 : : }
4193 : :
4194 [ - + ]: 4696 : if (pcnt == phnum)
4195 : 4696 : ERROR (_("\
4196 : : section [%2zu] '%s': alloc flag set but section not in any loaded segment\n"),
4197 : : cnt, section_name (ebl, cnt));
4198 : : }
4199 : :
4200 [ + + - + ]: 798770 : if (cnt == shstrndx && shdr->sh_type != SHT_STRTAB)
4201 : 0 : ERROR (_("\
4202 : : section [%2zu] '%s': ELF header says this is the section header string table but type is not SHT_TYPE\n"),
4203 : : cnt, section_name (ebl, cnt));
4204 : :
4205 [ + + + + : 798770 : switch (shdr->sh_type)
- + + + +
- + + + +
+ + + ]
4206 : : {
4207 : 186 : case SHT_DYNSYM:
4208 [ - + ]: 186 : if (ehdr->e_type == ET_REL)
4209 : 0 : ERROR (_("\
4210 : : section [%2zu] '%s': relocatable files cannot have dynamic symbol tables\n"),
4211 : : cnt, section_name (ebl, cnt));
4212 : 508 : FALLTHROUGH;
4213 : : case SHT_SYMTAB:
4214 : 508 : check_symtab (ebl, ehdr, shdr, cnt);
4215 : 508 : break;
4216 : :
4217 : 724 : case SHT_RELA:
4218 : 724 : check_rela (ebl, ehdr, shdr, cnt);
4219 : 724 : break;
4220 : :
4221 : 110 : case SHT_REL:
4222 : 110 : check_rel (ebl, ehdr, shdr, cnt);
4223 : 110 : break;
4224 : :
4225 : 0 : case SHT_RELR:
4226 : 0 : check_relr (ebl, ehdr, shdr, cnt);
4227 : 0 : break;
4228 : :
4229 : 186 : case SHT_DYNAMIC:
4230 : 186 : check_dynamic (ebl, ehdr, shdr, cnt);
4231 : 186 : break;
4232 : :
4233 : 4 : case SHT_SYMTAB_SHNDX:
4234 : 4 : check_symtab_shndx (ebl, ehdr, shdr, cnt);
4235 : 4 : break;
4236 : :
4237 : 78 : case SHT_HASH:
4238 : 78 : check_hash (shdr->sh_type, ebl, ehdr, shdr, cnt);
4239 : 78 : hash_idx = cnt;
4240 : 78 : break;
4241 : :
4242 : 116 : case SHT_GNU_HASH:
4243 : 116 : check_hash (shdr->sh_type, ebl, ehdr, shdr, cnt);
4244 : 116 : gnu_hash_idx = cnt;
4245 : 116 : break;
4246 : :
4247 : 0 : case SHT_NULL:
4248 : 0 : check_null (ebl, shdr, cnt);
4249 : 0 : break;
4250 : :
4251 : 44016 : case SHT_GROUP:
4252 : 44016 : check_group (ebl, ehdr, shdr, cnt);
4253 : 44016 : break;
4254 : :
4255 : 390 : case SHT_NOTE:
4256 : 390 : check_note_section (ebl, ehdr, shdr, cnt);
4257 : 390 : break;
4258 : :
4259 : 186 : case SHT_GNU_versym:
4260 : : /* We cannot process this section now since we have no guarantee
4261 : : that the verneed and verdef sections have already been read.
4262 : : Just remember the section index. */
4263 [ - + ]: 186 : if (versym_scnndx != 0)
4264 : 0 : ERROR (_("more than one version symbol table present\n"));
4265 : : versym_scnndx = cnt;
4266 : : break;
4267 : :
4268 : 184 : case SHT_GNU_verneed:
4269 : 184 : check_verneed (ebl, shdr, cnt);
4270 : 184 : break;
4271 : :
4272 : 20 : case SHT_GNU_verdef:
4273 : 20 : check_verdef (ebl, shdr, cnt);
4274 : 20 : break;
4275 : :
4276 : 2 : case SHT_GNU_ATTRIBUTES:
4277 : 2 : check_attributes (ebl, ehdr, shdr, cnt);
4278 : 2 : break;
4279 : :
4280 : : default:
4281 : : /* Nothing. */
4282 : : break;
4283 : : }
4284 : : }
4285 : :
4286 [ + + - + ]: 386 : if (has_interp_segment && !dot_interp_section)
4287 : 0 : ERROR (_("INTERP program header entry but no .interp section\n"));
4288 : :
4289 [ + + ]: 386 : if (!is_debuginfo)
4290 [ + + ]: 2098 : for (unsigned int pcnt = 0; pcnt < phnum; ++pcnt)
4291 : : {
4292 : 1752 : GElf_Phdr phdr_mem;
4293 : 1752 : GElf_Phdr *phdr = gelf_getphdr (ebl->elf, pcnt, &phdr_mem);
4294 [ + - + + ]: 1752 : if (phdr != NULL && (phdr->p_type == PT_LOAD || phdr->p_type == PT_TLS))
4295 : : {
4296 [ + + ]: 646 : if ((phdr->p_flags & PF_X) != 0
4297 [ - + ]: 286 : && (segment_flags[pcnt] & PF_X) == 0)
4298 : 0 : ERROR (_("\
4299 : : loadable segment [%u] is executable but contains no executable sections\n"),
4300 : : pcnt);
4301 : :
4302 [ + + ]: 646 : if ((phdr->p_flags & PF_W) != 0
4303 [ - + ]: 184 : && (segment_flags[pcnt] & PF_W) == 0)
4304 : 1752 : ERROR (_("\
4305 : : loadable segment [%u] is writable but contains no writable sections\n"),
4306 : : pcnt);
4307 : : }
4308 : : }
4309 : :
4310 : 386 : free (segment_flags);
4311 : :
4312 [ + + ]: 386 : if (version_namelist != NULL)
4313 : : {
4314 [ - + ]: 186 : if (versym_scnndx == 0)
4315 : 0 : ERROR (_("\
4316 : : no .gnu.versym section present but .gnu.versym_d or .gnu.versym_r section exist\n"));
4317 : : else
4318 : 186 : check_versym (ebl, versym_scnndx);
4319 : :
4320 : : /* Check for duplicate index numbers. */
4321 : 904 : do
4322 : : {
4323 : 904 : struct version_namelist *runp = version_namelist->next;
4324 [ + + ]: 5196 : while (runp != NULL)
4325 : : {
4326 [ - + ]: 4292 : if (version_namelist->ndx == runp->ndx)
4327 : : {
4328 : 0 : ERROR (_("duplicate version index %d\n"),
4329 : : (int) version_namelist->ndx);
4330 : 0 : break;
4331 : : }
4332 : 4292 : runp = runp->next;
4333 : : }
4334 : :
4335 : 904 : struct version_namelist *old = version_namelist;
4336 : 904 : version_namelist = version_namelist->next;
4337 : 904 : free (old);
4338 : : }
4339 [ + + ]: 904 : while (version_namelist != NULL);
4340 : : }
4341 [ - + ]: 200 : else if (versym_scnndx != 0)
4342 : 0 : ERROR (_("\
4343 : : .gnu.versym section present without .gnu.versym_d or .gnu.versym_r\n"));
4344 : :
4345 [ + + ]: 386 : if (hash_idx != 0 && gnu_hash_idx != 0)
4346 : 8 : compare_hash_gnu_hash (ebl, ehdr, hash_idx, gnu_hash_idx);
4347 : :
4348 : 386 : free (scnref);
4349 : : }
4350 : :
4351 : :
4352 : : static GElf_Off
4353 : 598 : check_note_data (Ebl *ebl, const GElf_Ehdr *ehdr,
4354 : : Elf_Data *data, int shndx, int phndx, GElf_Off start)
4355 : : {
4356 : 598 : size_t offset = 0;
4357 : 598 : size_t last_offset = 0;
4358 : 598 : GElf_Nhdr nhdr;
4359 : 598 : size_t name_offset;
4360 : 598 : size_t desc_offset;
4361 : 598 : while (offset < data->d_size
4362 [ + - ]: 1072 : && (offset = gelf_getnote (data, offset,
4363 : : &nhdr, &name_offset, &desc_offset)) > 0)
4364 : : {
4365 : 1072 : last_offset = offset;
4366 : :
4367 : : /* Make sure it is one of the note types we know about. */
4368 [ - + ]: 1072 : if (ehdr->e_type == ET_CORE)
4369 [ # # ]: 0 : switch (nhdr.n_type)
4370 : : {
4371 : : case NT_PRSTATUS:
4372 : : case NT_FPREGSET:
4373 : : case NT_PRPSINFO:
4374 : : case NT_TASKSTRUCT: /* NT_PRXREG on Solaris. */
4375 : : case NT_PLATFORM:
4376 : : case NT_AUXV:
4377 : : case NT_GWINDOWS:
4378 : : case NT_ASRS:
4379 : : case NT_PSTATUS:
4380 : : case NT_PSINFO:
4381 : : case NT_PRCRED:
4382 : : case NT_UTSNAME:
4383 : : case NT_LWPSTATUS:
4384 : : case NT_LWPSINFO:
4385 : : case NT_PRFPXREG:
4386 : : /* Known type. */
4387 : : break;
4388 : :
4389 : 0 : default:
4390 [ # # ]: 0 : if (shndx == 0)
4391 : 0 : ERROR (_("\
4392 : : phdr[%d]: unknown core file note type %" PRIu32 " at offset %" PRIu64 "\n"),
4393 : : phndx, (uint32_t) nhdr.n_type, start + offset);
4394 : : else
4395 : 0 : ERROR (_("\
4396 : : section [%2d] '%s': unknown core file note type %" PRIu32
4397 : : " at offset %zu\n"),
4398 : : shndx, section_name (ebl, shndx),
4399 : : (uint32_t) nhdr.n_type, offset);
4400 : : }
4401 : : else
4402 [ + - - + : 1072 : switch (nhdr.n_type)
- ]
4403 : : {
4404 : 1066 : case NT_GNU_ABI_TAG:
4405 : : case NT_GNU_HWCAP:
4406 : : case NT_GNU_BUILD_ID:
4407 : : case NT_GNU_GOLD_VERSION:
4408 : : case NT_GNU_PROPERTY_TYPE_0:
4409 [ + + ]: 1066 : if (nhdr.n_namesz == sizeof ELF_NOTE_GNU
4410 [ - + ]: 632 : && strcmp (data->d_buf + name_offset, ELF_NOTE_GNU) == 0)
4411 : : break;
4412 : : else
4413 : : {
4414 : : /* NT_VERSION is 1, same as NT_GNU_ABI_TAG. It has no
4415 : : descriptor and (ab)uses the name as version string. */
4416 [ + - - + ]: 434 : if (nhdr.n_descsz == 0 && nhdr.n_type == NT_VERSION)
4417 : : break;
4418 : : }
4419 : 0 : goto unknown_note;
4420 : :
4421 : 0 : case NT_GNU_BUILD_ATTRIBUTE_OPEN:
4422 : : case NT_GNU_BUILD_ATTRIBUTE_FUNC:
4423 : : /* GNU Build Attributes store most data in the owner
4424 : : name, which must start with the
4425 : : ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX "GA". */
4426 [ # # ]: 0 : if (nhdr.n_namesz >= sizeof ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX
4427 [ # # ]: 0 : && strncmp (data->d_buf + name_offset,
4428 : : ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX,
4429 : : strlen (ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX)) == 0)
4430 : : break;
4431 : : else
4432 : 0 : goto unknown_note;
4433 : :
4434 : : case NT_FDO_PACKAGING_METADATA:
4435 [ # # ]: 0 : if (nhdr.n_namesz == sizeof ELF_NOTE_FDO
4436 [ # # ]: 0 : && strcmp (data->d_buf + name_offset, ELF_NOTE_FDO) == 0)
4437 : : break;
4438 : : else
4439 : 0 : goto unknown_note;
4440 : :
4441 : : case 0:
4442 : : /* Linux vDSOs use a type 0 note for the kernel version word. */
4443 [ - + ]: 6 : if (nhdr.n_namesz == sizeof "Linux"
4444 [ - + ]: 6 : && !memcmp (data->d_buf + name_offset, "Linux", sizeof "Linux"))
4445 : : break;
4446 : 0 : FALLTHROUGH;
4447 : : default:
4448 : : {
4449 : 0 : unknown_note:
4450 [ # # ]: 0 : if (shndx == 0)
4451 : 0 : ERROR (_("\
4452 : : phdr[%d]: unknown object file note type %" PRIu32 " with owner name '%s' at offset %zu\n"),
4453 : : phndx, (uint32_t) nhdr.n_type,
4454 : : (char *) data->d_buf + name_offset, offset);
4455 : : else
4456 [ + + ]: 1670 : ERROR (_("\
4457 : : section [%2d] '%s': unknown object file note type %" PRIu32
4458 : : " with owner name '%s' at offset %zu\n"),
4459 : : shndx, section_name (ebl, shndx),
4460 : : (uint32_t) nhdr.n_type,
4461 : : (char *) data->d_buf + name_offset, offset);
4462 : : }
4463 : : }
4464 : : }
4465 : :
4466 : 598 : return last_offset;
4467 : : }
4468 : :
4469 : :
4470 : : static void
4471 : 240 : check_note (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Phdr *phdr, int cnt)
4472 : : {
4473 [ + - ]: 240 : if (ehdr->e_type != ET_CORE && ehdr->e_type != ET_REL
4474 [ + + - + ]: 240 : && ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
4475 : 0 : ERROR (_("\
4476 : : phdr[%d]: no note entries defined for the type of file\n"),
4477 : : cnt);
4478 : :
4479 [ + + ]: 240 : if (is_debuginfo)
4480 : : /* The p_offset values in a separate debug file are bogus. */
4481 : : return;
4482 : :
4483 [ + - ]: 208 : if (phdr->p_filesz == 0)
4484 : : return;
4485 : :
4486 : 208 : GElf_Off notes_size = 0;
4487 : 624 : Elf_Data *data = elf_getdata_rawchunk (ebl->elf,
4488 : 208 : phdr->p_offset, phdr->p_filesz,
4489 [ + + ]: 208 : (phdr->p_align == 8
4490 : : ? ELF_T_NHDR8 : ELF_T_NHDR));
4491 [ + - + - ]: 208 : if (data != NULL && data->d_buf != NULL)
4492 : 208 : notes_size = check_note_data (ebl, ehdr, data, 0, cnt, phdr->p_offset);
4493 : :
4494 [ - + ]: 208 : if (notes_size == 0)
4495 : 0 : ERROR (_("phdr[%d]: cannot get content of note section: %s\n"),
4496 : : cnt, elf_errmsg (-1));
4497 [ - + ]: 208 : else if (notes_size != phdr->p_filesz)
4498 : 0 : ERROR (_("phdr[%d]: extra %" PRIu64 " bytes after last note\n"),
4499 : : cnt, phdr->p_filesz - notes_size);
4500 : : }
4501 : :
4502 : :
4503 : : static void
4504 : 390 : check_note_section (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
4505 : : {
4506 [ + - ]: 390 : if (shdr->sh_size == 0)
4507 : : return;
4508 : :
4509 : 390 : Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
4510 [ + - - + ]: 390 : if (data == NULL || data->d_buf == NULL)
4511 : : {
4512 : 0 : ERROR (_("section [%2d] '%s': cannot get section data\n"),
4513 : : idx, section_name (ebl, idx));
4514 : 0 : return;
4515 : : }
4516 : :
4517 [ + + ]: 390 : if (ehdr->e_type != ET_CORE && ehdr->e_type != ET_REL
4518 [ + + - + ]: 388 : && ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN)
4519 : 0 : ERROR (_("\
4520 : : section [%2d] '%s': no note entries defined for the type of file\n"),
4521 : : idx, section_name (ebl, idx));
4522 : :
4523 : 390 : GElf_Off notes_size = check_note_data (ebl, ehdr, data, idx, 0, 0);
4524 : :
4525 [ - + ]: 390 : if (notes_size == 0)
4526 : 0 : ERROR (_("section [%2d] '%s': cannot get content of note section\n"),
4527 : : idx, section_name (ebl, idx));
4528 [ - + ]: 390 : else if (notes_size != shdr->sh_size)
4529 : 0 : ERROR (_("section [%2d] '%s': extra %" PRIu64
4530 : : " bytes after last note\n"),
4531 : : idx, section_name (ebl, idx), shdr->sh_size - notes_size);
4532 : : }
4533 : :
4534 : :
4535 : : /* Index of the PT_GNU_EH_FRAME program eader entry. */
4536 : : static int pt_gnu_eh_frame_pndx;
4537 : :
4538 : :
4539 : : static void
4540 : 386 : check_program_header (Ebl *ebl, GElf_Ehdr *ehdr)
4541 : : {
4542 [ + + ]: 386 : if (ehdr->e_phoff == 0)
4543 : : return;
4544 : :
4545 : 316 : if (ehdr->e_type != ET_EXEC && ehdr->e_type != ET_DYN
4546 [ - + ]: 316 : && ehdr->e_type != ET_CORE)
4547 : 0 : ERROR (_("\
4548 : : only executables, shared objects, and core files can have program headers\n"));
4549 : :
4550 : : int num_pt_interp = 0;
4551 : : int num_pt_tls = 0;
4552 : : int num_pt_relro = 0;
4553 : :
4554 [ + + ]: 2268 : for (unsigned int cnt = 0; cnt < phnum; ++cnt)
4555 : : {
4556 : 1952 : GElf_Phdr phdr_mem;
4557 : 1952 : GElf_Phdr *phdr;
4558 : :
4559 : 1952 : phdr = gelf_getphdr (ebl->elf, cnt, &phdr_mem);
4560 [ - + ]: 1952 : if (phdr == NULL)
4561 : : {
4562 : 0 : ERROR (_("cannot get program header entry %d: %s\n"),
4563 : : cnt, elf_errmsg (-1));
4564 : 0 : continue;
4565 : : }
4566 : :
4567 [ + + ]: 1952 : if (phdr->p_type >= PT_NUM && phdr->p_type != PT_GNU_EH_FRAME
4568 : : && phdr->p_type != PT_GNU_STACK && phdr->p_type != PT_GNU_RELRO
4569 : : && phdr->p_type != PT_GNU_PROPERTY
4570 : : /* Check for a known machine-specific type. */
4571 [ - + ]: 2 : && ebl_segment_type_name (ebl, phdr->p_type, NULL, 0) == NULL)
4572 : 0 : ERROR (_("\
4573 : : program header entry %d: unknown program header entry type %#" PRIx64 "\n"),
4574 : : cnt, (uint64_t) phdr->p_type);
4575 : :
4576 [ + + ]: 1952 : if (phdr->p_type == PT_LOAD)
4577 : 652 : has_loadable_segment = true;
4578 [ + + + + : 1300 : else if (phdr->p_type == PT_INTERP)
+ + + + ]
4579 : : {
4580 [ - + ]: 154 : if (++num_pt_interp != 1)
4581 : : {
4582 [ # # ]: 0 : if (num_pt_interp == 2)
4583 : 0 : ERROR (_("\
4584 : : more than one INTERP entry in program header\n"));
4585 : : }
4586 : 154 : has_interp_segment = true;
4587 : : }
4588 : : else if (phdr->p_type == PT_TLS)
4589 : : {
4590 [ - + ]: 60 : if (++num_pt_tls == 2)
4591 : 0 : ERROR (_("more than one TLS entry in program header\n"));
4592 : : }
4593 : : else if (phdr->p_type == PT_NOTE)
4594 : 240 : check_note (ebl, ehdr, phdr, cnt);
4595 : : else if (phdr->p_type == PT_DYNAMIC)
4596 : : {
4597 [ + + + - ]: 216 : if (ehdr->e_type == ET_EXEC && ! has_interp_segment)
4598 : 0 : ERROR (_("\
4599 : : static executable cannot have dynamic sections\n"));
4600 : : else
4601 : : {
4602 : : /* Check that the .dynamic section, if it exists, has
4603 : : the same address. */
4604 : : Elf_Scn *scn = NULL;
4605 [ + + ]: 266986 : while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
4606 : : {
4607 : 266956 : GElf_Shdr shdr_mem;
4608 : 266956 : GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
4609 [ + - + + ]: 266956 : if (shdr != NULL && shdr->sh_type == SHT_DYNAMIC)
4610 : : {
4611 [ - + ]: 186 : if (phdr->p_offset != shdr->sh_offset)
4612 : 0 : ERROR (_("\
4613 : : dynamic section reference in program header has wrong offset\n"));
4614 [ - + ]: 186 : if (phdr->p_memsz != shdr->sh_size)
4615 : 0 : ERROR (_("\
4616 : : dynamic section size mismatch in program and section header\n"));
4617 : 186 : break;
4618 : : }
4619 : : }
4620 : : }
4621 : : }
4622 : : else if (phdr->p_type == PT_GNU_RELRO)
4623 : : {
4624 [ - + ]: 94 : if (++num_pt_relro == 2)
4625 : 0 : ERROR (_("\
4626 : : more than one GNU_RELRO entry in program header\n"));
4627 : : else
4628 : : {
4629 : : /* Check that the region is in a writable segment. */
4630 : : unsigned int inner;
4631 [ + - ]: 468 : for (inner = 0; inner < phnum; ++inner)
4632 : : {
4633 : 468 : GElf_Phdr phdr2_mem;
4634 : 468 : GElf_Phdr *phdr2;
4635 : :
4636 : 468 : phdr2 = gelf_getphdr (ebl->elf, inner, &phdr2_mem);
4637 [ - + ]: 468 : if (phdr2 == NULL)
4638 : 0 : continue;
4639 : :
4640 [ + + ]: 468 : if (phdr2->p_type == PT_LOAD
4641 [ + - ]: 312 : && phdr->p_vaddr >= phdr2->p_vaddr
4642 : 312 : && (phdr->p_vaddr + phdr->p_memsz
4643 [ + + ]: 312 : <= phdr2->p_vaddr + phdr2->p_memsz))
4644 : : {
4645 [ - + ]: 94 : if ((phdr2->p_flags & PF_W) == 0)
4646 : 0 : ERROR (_("\
4647 : : loadable segment GNU_RELRO applies to is not writable\n"));
4648 : : /* Unless fully covered, relro flags could be a
4649 : : subset of the phdrs2 flags. For example the load
4650 : : segment could also have PF_X set. */
4651 [ + - ]: 94 : if (phdr->p_vaddr == phdr2->p_vaddr
4652 : 94 : && (phdr->p_vaddr + phdr->p_memsz
4653 [ - + ]: 94 : == phdr2->p_vaddr + phdr2->p_memsz))
4654 : : {
4655 : 0 : if ((phdr2->p_flags & ~PF_W)
4656 [ # # ]: 0 : != (phdr->p_flags & ~PF_W))
4657 : 0 : ERROR (_("\
4658 : : loadable segment [%u] flags do not match GNU_RELRO [%u] flags\n"),
4659 : : cnt, inner);
4660 : : }
4661 : : else
4662 : : {
4663 [ - + ]: 94 : if ((phdr->p_flags & ~phdr2->p_flags) != 0)
4664 : 0 : ERROR (_("\
4665 : : GNU_RELRO [%u] flags are not a subset of the loadable segment [%u] flags\n"),
4666 : : inner, cnt);
4667 : : }
4668 : 94 : break;
4669 : : }
4670 : : }
4671 : :
4672 [ - + ]: 94 : if (inner >= phnum)
4673 : 0 : ERROR (_("\
4674 : : %s segment not contained in a loaded segment\n"), "GNU_RELRO");
4675 : : }
4676 : : }
4677 : : else if (phdr->p_type == PT_PHDR)
4678 : : {
4679 : : /* Check that the region is in a writable segment. */
4680 : : unsigned int inner;
4681 [ + - ]: 466 : for (inner = 0; inner < phnum; ++inner)
4682 : : {
4683 : 466 : GElf_Phdr phdr2_mem;
4684 : 466 : GElf_Phdr *phdr2;
4685 : :
4686 : 466 : phdr2 = gelf_getphdr (ebl->elf, inner, &phdr2_mem);
4687 [ + - ]: 466 : if (phdr2 != NULL
4688 [ + + ]: 466 : && phdr2->p_type == PT_LOAD
4689 [ + - ]: 156 : && phdr->p_vaddr >= phdr2->p_vaddr
4690 : 156 : && (phdr->p_vaddr + phdr->p_memsz
4691 [ - + ]: 156 : <= phdr2->p_vaddr + phdr2->p_memsz))
4692 : : break;
4693 : : }
4694 : :
4695 [ - + ]: 156 : if (inner >= phnum)
4696 : 0 : ERROR (_("\
4697 : : %s segment not contained in a loaded segment\n"), "PHDR");
4698 : :
4699 : : /* Check that offset in segment corresponds to offset in ELF
4700 : : header. */
4701 [ - + ]: 156 : if (phdr->p_offset != ehdr->e_phoff)
4702 : 0 : ERROR (_("\
4703 : : program header offset in ELF header and PHDR entry do not match"));
4704 : : }
4705 : : else if (phdr->p_type == PT_GNU_EH_FRAME)
4706 : : {
4707 : : /* If there is an .eh_frame_hdr section it must be
4708 : : referenced by this program header entry. */
4709 : : Elf_Scn *scn = NULL;
4710 : : GElf_Shdr shdr_mem;
4711 : : GElf_Shdr *shdr = NULL;
4712 : : bool any = false;
4713 [ + - ]: 2608 : while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
4714 : : {
4715 : 2608 : any = true;
4716 : 2608 : shdr = gelf_getshdr (scn, &shdr_mem);
4717 [ + - ]: 2608 : if (shdr != NULL
4718 [ + + + + ]: 2608 : && ((is_debuginfo && shdr->sh_type == SHT_NOBITS)
4719 [ + + ]: 2382 : || (! is_debuginfo
4720 : 2360 : && (shdr->sh_type == SHT_PROGBITS
4721 [ + + ]: 2360 : || shdr->sh_type == SHT_X86_64_UNWIND)))
4722 [ + - ]: 1254 : && elf_strptr (ebl->elf, shstrndx, shdr->sh_name) != NULL
4723 [ + + ]: 1254 : && ! strcmp (".eh_frame_hdr",
4724 : 1254 : elf_strptr (ebl->elf, shstrndx, shdr->sh_name)))
4725 : : {
4726 [ + + ]: 170 : if (! is_debuginfo)
4727 : : {
4728 [ - + ]: 152 : if (phdr->p_offset != shdr->sh_offset)
4729 : 0 : ERROR (_("\
4730 : : call frame search table reference in program header has wrong offset\n"));
4731 [ + - ]: 152 : if (phdr->p_memsz != shdr->sh_size)
4732 : 0 : ERROR (_("\
4733 : : call frame search table size mismatch in program and section header\n"));
4734 : : }
4735 : : break;
4736 : : }
4737 : : }
4738 : :
4739 [ - + ]: 170 : if (scn == NULL)
4740 : : {
4741 : : /* If there is no section header table we don't
4742 : : complain. But if there is one there should be an
4743 : : entry for .eh_frame_hdr. */
4744 [ # # ]: 0 : if (any)
4745 : 0 : ERROR (_("\
4746 : : PT_GNU_EH_FRAME present but no .eh_frame_hdr section\n"));
4747 : : }
4748 : : else
4749 : : {
4750 : : /* The section must be allocated and not be writable and
4751 : : executable. */
4752 [ - + ]: 170 : if ((phdr->p_flags & PF_R) == 0)
4753 : 0 : ERROR (_("\
4754 : : call frame search table must be allocated\n"));
4755 [ + - - + ]: 170 : else if (shdr != NULL && (shdr->sh_flags & SHF_ALLOC) == 0)
4756 : 0 : ERROR (_("\
4757 : : section [%2zu] '%s' must be allocated\n"), elf_ndxscn (scn), ".eh_frame_hdr");
4758 : :
4759 [ - + ]: 170 : if ((phdr->p_flags & PF_W) != 0)
4760 : 0 : ERROR (_("\
4761 : : call frame search table must not be writable\n"));
4762 [ + - - + ]: 170 : else if (shdr != NULL && (shdr->sh_flags & SHF_WRITE) != 0)
4763 : 0 : ERROR (_("\
4764 : : section [%2zu] '%s' must not be writable\n"),
4765 : : elf_ndxscn (scn), ".eh_frame_hdr");
4766 : :
4767 [ - + ]: 170 : if ((phdr->p_flags & PF_X) != 0)
4768 : 0 : ERROR (_("\
4769 : : call frame search table must not be executable\n"));
4770 [ + - - + ]: 170 : else if (shdr != NULL && (shdr->sh_flags & SHF_EXECINSTR) != 0)
4771 : 0 : ERROR (_("\
4772 : : section [%2zu] '%s' must not be executable\n"),
4773 : : elf_ndxscn (scn), ".eh_frame_hdr");
4774 : : }
4775 : :
4776 : : /* Remember which entry this is. */
4777 : 170 : pt_gnu_eh_frame_pndx = cnt;
4778 : : }
4779 : :
4780 [ - + ]: 1952 : if (phdr->p_filesz > phdr->p_memsz
4781 [ # # ]: 0 : && (phdr->p_memsz != 0
4782 [ # # ]: 0 : || (phdr->p_type != PT_NOTE
4783 [ # # # # ]: 0 : && !(ehdr->e_machine == EM_RISCV
4784 : : && phdr->p_type == PT_RISCV_ATTRIBUTES))))
4785 : 0 : ERROR (_("\
4786 : : program header entry %d: file size greater than memory size\n"),
4787 : : cnt);
4788 : :
4789 [ + + ]: 1952 : if (phdr->p_align > 1)
4790 : : {
4791 [ - + ]: 1702 : if (!powerof2 (phdr->p_align))
4792 : 0 : ERROR (_("\
4793 : : program header entry %d: alignment not a power of 2\n"), cnt);
4794 [ - + ]: 1702 : else if ((phdr->p_vaddr - phdr->p_offset) % phdr->p_align != 0)
4795 : 1952 : ERROR (_("\
4796 : : program header entry %d: file offset and virtual address not module of alignment\n"), cnt);
4797 : : }
4798 : : }
4799 : : }
4800 : :
4801 : :
4802 : : static void
4803 : 298 : check_exception_data (Ebl *ebl __attribute__ ((unused)),
4804 : : GElf_Ehdr *ehdr __attribute__ ((unused)))
4805 : : {
4806 [ + + ]: 298 : if ((ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
4807 [ + + - + ]: 262 : && pt_gnu_eh_frame_pndx == 0 && eh_frame_hdr_scnndx != 0)
4808 : 0 : ERROR (_("executable/DSO with .eh_frame_hdr section does not have "
4809 : : "a PT_GNU_EH_FRAME program header entry"));
4810 : 298 : }
4811 : :
4812 : :
4813 : : /* Process one file. */
4814 : : static void
4815 : 386 : process_elf_file (Elf *elf, const char *prefix, const char *suffix,
4816 : : const char *fname, size_t size, bool only_one)
4817 : : {
4818 : : /* Reset variables. */
4819 : 386 : ndynamic = 0;
4820 : 386 : nverneed = 0;
4821 : 386 : nverdef = 0;
4822 : 386 : textrel = false;
4823 : 386 : needed_textrel = false;
4824 : 386 : has_loadable_segment = false;
4825 : 386 : has_interp_segment = false;
4826 : :
4827 : 386 : GElf_Ehdr ehdr_mem;
4828 : 386 : GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
4829 : 386 : Ebl *ebl;
4830 : :
4831 : : /* Print the file name. */
4832 [ - + ]: 386 : if (!only_one)
4833 : : {
4834 [ # # ]: 0 : if (prefix != NULL)
4835 : 0 : printf ("\n%s(%s)%s:\n", prefix, fname, suffix);
4836 : : else
4837 : 0 : printf ("\n%s:\n", fname);
4838 : : }
4839 : :
4840 [ - + ]: 386 : if (ehdr == NULL)
4841 : : {
4842 : 0 : ERROR (_("cannot read ELF header: %s\n"), elf_errmsg (-1));
4843 : 0 : return;
4844 : : }
4845 : :
4846 : 386 : ebl = ebl_openbackend (elf);
4847 : : /* If there is no appropriate backend library we cannot test
4848 : : architecture and OS specific features. Any encountered extension
4849 : : is an error. Often we'll get a "dummy" ebl, except if something
4850 : : really bad happen, like a totally corrupted ELF file or out of
4851 : : memory situation. */
4852 [ - + ]: 386 : if (ebl == NULL)
4853 : : {
4854 : 0 : ERROR (_("cannot create backend for ELF file\n"));
4855 : 0 : return;
4856 : : }
4857 : :
4858 : : /* Go straight by the gABI, check all the parts in turn. */
4859 : 386 : check_elf_header (ebl, ehdr, size);
4860 : :
4861 : : /* Check the program header. */
4862 : 386 : check_program_header (ebl, ehdr);
4863 : :
4864 : : /* Next the section headers. It is OK if there are no section
4865 : : headers at all. */
4866 : 386 : check_sections (ebl, ehdr);
4867 : :
4868 : : /* Check the exception handling data, if it exists. */
4869 [ + + + - ]: 386 : if (pt_gnu_eh_frame_pndx != 0 || eh_frame_hdr_scnndx != 0
4870 [ + + - + ]: 216 : || eh_frame_scnndx != 0 || gcc_except_table_scnndx != 0)
4871 : 298 : check_exception_data (ebl, ehdr);
4872 : :
4873 : : /* Report if no relocation section needed the text relocation flag. */
4874 [ - + - - ]: 386 : if (textrel && !needed_textrel)
4875 : 0 : ERROR (_("text relocation flag set but not needed\n"));
4876 : :
4877 : : /* Free the resources. */
4878 : 386 : ebl_closebackend (ebl);
4879 : : }
4880 : :
4881 : :
4882 : : #include "debugpred.h"
|
