1/* Copyright (C) 1999-2022 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18#include <elf-read-prop.h>
19
20/* This code is a heavily simplified version of the readelf program
21 that's part of the current binutils development version. For architectures
22 which need to handle both 32bit and 64bit ELF libraries, this file is
23 included twice for each arch size. */
24
25/* check_ptr checks that a pointer is in the mmaped file and doesn't
26 point outside it. */
27#undef check_ptr
28#define check_ptr(ptr) \
29do \
30 { \
31 if ((void *)(ptr) < file_contents \
32 || (void *)(ptr) > (file_contents+file_length)) \
33 { \
34 error (0, 0, _("file %s is truncated\n"), file_name); \
35 return 1; \
36 } \
37 } \
38 while (0);
39
40/* Returns 0 if everything is ok, != 0 in case of error. */
41int
42process_elf_file (const char *file_name, const char *lib, int *flag,
43 unsigned int *isa_level, char **soname, void *file_contents,
44 size_t file_length)
45{
46 int i;
47 unsigned int j;
48 unsigned int dynamic_addr;
49 size_t dynamic_size;
50 char *program_interpreter;
51
52 ElfW(Ehdr) *elf_header;
53 ElfW(Phdr) *elf_pheader, *segment;
54 ElfW(Dyn) *dynamic_segment, *dyn_entry;
55 char *dynamic_strings;
56
57 elf_header = (ElfW(Ehdr) *) file_contents;
58
59 if (elf_header->e_ident [EI_CLASS] != ElfW (CLASS))
60 {
61 if (opt_verbose)
62 {
63 if (elf_header->e_ident [EI_CLASS] == ELFCLASS32)
64 error (0, 0, _("%s is a 32 bit ELF file.\n"), file_name);
65 else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64)
66 error (0, 0, _("%s is a 64 bit ELF file.\n"), file_name);
67 else
68 error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name);
69 }
70 return 1;
71 }
72
73 if (elf_header->e_type != ET_DYN)
74 {
75 error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
76 elf_header->e_type);
77 return 1;
78 }
79
80 /* Get information from elf program header. */
81 elf_pheader = (ElfW(Phdr) *) (elf_header->e_phoff + file_contents);
82 check_ptr (elf_pheader);
83
84 /* The library is an elf library, now search for soname and
85 libc5/libc6. */
86 *flag = FLAG_ELF;
87
88 /* The default ISA level is 0. */
89 *isa_level = 0;
90
91 dynamic_addr = 0;
92 dynamic_size = 0;
93 program_interpreter = NULL;
94 for (i = 0, segment = elf_pheader;
95 i < elf_header->e_phnum; i++, segment++)
96 {
97 check_ptr (segment);
98
99 switch (segment->p_type)
100 {
101 case PT_DYNAMIC:
102 if (dynamic_addr)
103 error (0, 0, _("more than one dynamic segment\n"));
104
105 dynamic_addr = segment->p_offset;
106 dynamic_size = segment->p_filesz;
107 break;
108
109 case PT_INTERP:
110 program_interpreter = (char *) (file_contents + segment->p_offset);
111 check_ptr (program_interpreter);
112
113 /* Check if this is enough to classify the binary. */
114 for (j = 0; j < sizeof (interpreters) / sizeof (interpreters [0]);
115 ++j)
116 if (strcmp (program_interpreter, interpreters[j].soname) == 0)
117 {
118 *flag = interpreters[j].flag;
119 break;
120 }
121 break;
122
123 case PT_GNU_PROPERTY:
124 /* The NT_GNU_PROPERTY_TYPE_0 note must be aligned to 4 bytes
125 in 32-bit objects and to 8 bytes in 64-bit objects. Skip
126 notes with incorrect alignment. */
127 if (segment->p_align == (__ELF_NATIVE_CLASS / 8))
128 {
129 const ElfW(Nhdr) *note = (const void *) (file_contents
130 + segment->p_offset);
131 const ElfW(Addr) size = segment->p_filesz;
132 const ElfW(Addr) align = segment->p_align;
133
134 const ElfW(Addr) start = (ElfW(Addr)) (uintptr_t) note;
135 unsigned int last_type = 0;
136
137 while ((ElfW(Addr)) (uintptr_t) (note + 1) - start < size)
138 {
139 /* Find the NT_GNU_PROPERTY_TYPE_0 note. */
140 if (note->n_namesz == 4
141 && note->n_type == NT_GNU_PROPERTY_TYPE_0
142 && memcmp (note + 1, "GNU", 4) == 0)
143 {
144 /* Check for invalid property. */
145 if (note->n_descsz < 8
146 || (note->n_descsz % sizeof (ElfW(Addr))) != 0)
147 goto done;
148
149 /* Start and end of property array. */
150 unsigned char *ptr = (unsigned char *) (note + 1) + 4;
151 unsigned char *ptr_end = ptr + note->n_descsz;
152
153 do
154 {
155 unsigned int type = *(unsigned int *) ptr;
156 unsigned int datasz = *(unsigned int *) (ptr + 4);
157
158 /* Property type must be in ascending order. */
159 if (type < last_type)
160 goto done;
161
162 ptr += 8;
163 if ((ptr + datasz) > ptr_end)
164 goto done;
165
166 last_type = type;
167
168 /* Target specific property processing.
169 Return value:
170 false: Continue processing the properties.
171 true : Stop processing the properties.
172 */
173 if (read_gnu_property (isa_level, type,
174 datasz, ptr))
175 goto done;
176
177 /* Check the next property item. */
178 ptr += ALIGN_UP (datasz, sizeof (ElfW(Addr)));
179 }
180 while ((ptr_end - ptr) >= 8);
181
182 /* Only handle one NT_GNU_PROPERTY_TYPE_0. */
183 goto done;
184 }
185
186 note = ((const void *) note
187 + ELF_NOTE_NEXT_OFFSET (note->n_namesz,
188 note->n_descsz,
189 align));
190 }
191 }
192done:
193 break;
194
195 default:
196 break;
197 }
198
199 }
200
201 /* Now we can read the dynamic sections. */
202 if (dynamic_size == 0)
203 return 1;
204
205 dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr);
206 check_ptr (dynamic_segment);
207
208 /* Find the string table. */
209 dynamic_strings = NULL;
210 for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
211 ++dyn_entry)
212 {
213 check_ptr (dyn_entry);
214 if (dyn_entry->d_tag == DT_STRTAB)
215 {
216 /* Find the file offset of the segment containing the dynamic
217 string table. */
218 ElfW(Off) loadoff = -1;
219 for (i = 0, segment = elf_pheader;
220 i < elf_header->e_phnum; i++, segment++)
221 {
222 if (segment->p_type == PT_LOAD
223 && dyn_entry->d_un.d_val >= segment->p_vaddr
224 && (dyn_entry->d_un.d_val - segment->p_vaddr
225 < segment->p_filesz))
226 {
227 loadoff = segment->p_vaddr - segment->p_offset;
228 break;
229 }
230 }
231 if (loadoff == (ElfW(Off)) -1)
232 {
233 /* Very strange. */
234 loadoff = 0;
235 }
236
237 dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val
238 - loadoff);
239 check_ptr (dynamic_strings);
240 break;
241 }
242 }
243
244 if (dynamic_strings == NULL)
245 return 1;
246
247 /* Now read the DT_NEEDED and DT_SONAME entries. */
248 for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
249 ++dyn_entry)
250 {
251 if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
252 {
253 char *name = dynamic_strings + dyn_entry->d_un.d_val;
254 check_ptr (name);
255
256 if (dyn_entry->d_tag == DT_NEEDED)
257 {
258
259 if (*flag == FLAG_ELF)
260 {
261 /* Check if this is enough to classify the binary. */
262 for (j = 0;
263 j < sizeof (known_libs) / sizeof (known_libs [0]);
264 ++j)
265 if (strcmp (name, known_libs [j].soname) == 0)
266 {
267 *flag = known_libs [j].flag;
268 break;
269 }
270 }
271 }
272
273 else if (dyn_entry->d_tag == DT_SONAME)
274 *soname = xstrdup (name);
275
276 /* Do we have everything we need? */
277 if (*soname && *flag != FLAG_ELF)
278 return 0;
279 }
280 }
281
282 return 0;
283}
284