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