elf/readelflib.c

   1 /* Copyright (C) 1999-2023 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)                                          \
  29 do                                                              \
  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.  */
  41 int
  42 process_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 dynamic_addr;
  48   size_t dynamic_size;
  49   char *program_interpreter;
  50
  51   ElfW(Ehdr) *elf_header;
  52   ElfW(Phdr) *elf_pheader, *segment;
  53   ElfW(Dyn) *dynamic_segment, *dyn_entry;
  54   char *dynamic_strings;
  55
  56   elf_header = (ElfW(Ehdr) *) file_contents;
  57
  58   if (elf_header->e_ident [EI_CLASS] != ElfW (CLASS))
  59     {
  60       if (opt_verbose)
  61         {
  62           if (elf_header->e_ident [EI_CLASS] == ELFCLASS32)
  63             error (0, 0, _("%s is a 32 bit ELF file.\n"), file_name);
  64           else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64)
  65             error (0, 0, _("%s is a 64 bit ELF file.\n"), file_name);
  66           else
  67             error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name);
  68         }
  69       return 1;
  70     }
  71
  72   if (elf_header->e_type != ET_DYN)
  73     {
  74       error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
  75              elf_header->e_type);
  76       return 1;
  77     }
  78
  79   /* Get information from elf program header.  */
  80   elf_pheader = (ElfW(Phdr) *) (elf_header->e_phoff + file_contents);
  81   check_ptr (elf_pheader);
  82
  83   /* The library is an elf library.  */
  84   *flag = FLAG_ELF_LIBC6;
  85
  86   /* The default ISA level is 0.  */
  87   *isa_level = 0;
  88
  89   dynamic_addr = 0;
  90   dynamic_size = 0;
  91   program_interpreter = NULL;
  92   for (i = 0, segment = elf_pheader;
  93        i < elf_header->e_phnum; i++, segment++)
  94     {
  95       check_ptr (segment);
  96
  97       switch (segment->p_type)
  98         {
  99         case PT_DYNAMIC:
 100           if (dynamic_addr)
 101             error (0, 0, _("more than one dynamic segment\n"));
 102
 103           dynamic_addr = segment->p_offset;
 104           dynamic_size = segment->p_filesz;
 105           break;
 106
 107         case PT_INTERP:
 108           program_interpreter = (char *) (file_contents + segment->p_offset);
 109           check_ptr (program_interpreter);
 110
 111         case PT_GNU_PROPERTY:
 112           /* The NT_GNU_PROPERTY_TYPE_0 note must be aligned to 4 bytes
 113              in 32-bit objects and to 8 bytes in 64-bit objects.  Skip
 114              notes with incorrect alignment.  */
 115           if (segment->p_align == (__ELF_NATIVE_CLASS / 8))
 116             {
 117               const ElfW(Nhdr) *note = (const void *) (file_contents
 118                                                        + segment->p_offset);
 119               const ElfW(Addr) size = segment->p_filesz;
 120               const ElfW(Addr) align = segment->p_align;
 121
 122               const ElfW(Addr) start = (ElfW(Addr)) (uintptr_t) note;
 123               unsigned int last_type = 0;
 124
 125               while ((ElfW(Addr)) (uintptr_t) (note + 1) - start < size)
 126                 {
 127                   /* Find the NT_GNU_PROPERTY_TYPE_0 note.  */
 128                   if (note->n_namesz == 4
 129                       && note->n_type == NT_GNU_PROPERTY_TYPE_0
 130                       && memcmp (note + 1, "GNU", 4) == 0)
 131                     {
 132                       /* Check for invalid property.  */
 133                       if (note->n_descsz < 8
 134                           || (note->n_descsz % sizeof (ElfW(Addr))) != 0)
 135                         goto done;
 136
 137                       /* Start and end of property array.  */
 138                       unsigned char *ptr = (unsigned char *) (note + 1) + 4;
 139                       unsigned char *ptr_end = ptr + note->n_descsz;
 140
 141                       do
 142                         {
 143                           unsigned int type = *(unsigned int *) ptr;
 144                           unsigned int datasz = *(unsigned int *) (ptr + 4);
 145
 146                           /* Property type must be in ascending order.  */
 147                           if (type < last_type)
 148                             goto done;
 149
 150                           ptr += 8;
 151                           if ((ptr + datasz) > ptr_end)
 152                             goto done;
 153
 154                           last_type = type;
 155
 156                           /* Target specific property processing.
 157                              Return value:
 158                                false: Continue processing the properties.
 159                                true : Stop processing the properties.
 160                            */
 161                           if (read_gnu_property (isa_level, type,
 162                                                  datasz, ptr))
 163                             goto done;
 164
 165                           /* Check the next property item.  */
 166                           ptr += ALIGN_UP (datasz, sizeof (ElfW(Addr)));
 167                         }
 168                       while ((ptr_end - ptr) >= 8);
 169
 170                       /* Only handle one NT_GNU_PROPERTY_TYPE_0.  */
 171                       goto done;
 172                     }
 173
 174                   note = ((const void *) note
 175                           + ELF_NOTE_NEXT_OFFSET (note->n_namesz,
 176                                                   note->n_descsz,
 177                                                   align));
 178                 }
 179             }
 180 done:
 181           break;
 182
 183         default:
 184           break;
 185         }
 186
 187     }
 188
 189   /* Now we can read the dynamic sections.  */
 190   if (dynamic_size == 0)
 191     return 1;
 192
 193   dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr);
 194   check_ptr (dynamic_segment);
 195
 196   /* Find the string table.  */
 197   dynamic_strings = NULL;
 198   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 199        ++dyn_entry)
 200     {
 201       check_ptr (dyn_entry);
 202       if (dyn_entry->d_tag == DT_STRTAB)
 203         {
 204           /* Find the file offset of the segment containing the dynamic
 205              string table.  */
 206           ElfW(Off) loadoff = -1;
 207           for (i = 0, segment = elf_pheader;
 208                i < elf_header->e_phnum; i++, segment++)
 209             {
 210               if (segment->p_type == PT_LOAD
 211                   && dyn_entry->d_un.d_val >= segment->p_vaddr
 212                   && (dyn_entry->d_un.d_val - segment->p_vaddr
 213                       < segment->p_filesz))
 214                 {
 215                   loadoff = segment->p_vaddr - segment->p_offset;
 216                   break;
 217                 }
 218             }
 219           if (loadoff == (ElfW(Off)) -1)
 220             {
 221               /* Very strange. */
 222               loadoff = 0;
 223             }
 224
 225           dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val
 226                                       - loadoff);
 227           check_ptr (dynamic_strings);
 228           break;
 229         }
 230     }
 231
 232   if (dynamic_strings == NULL)
 233     return 1;
 234
 235   /* Now read the DT_SONAME entries.  */
 236   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 237        ++dyn_entry)
 238     {
 239       if (dyn_entry->d_tag == DT_SONAME)
 240         {
 241           char *name = dynamic_strings + dyn_entry->d_un.d_val;
 242           check_ptr (name);
 243           *soname = xstrdup (name);
 244           return 0;
 245         }
 246     }
 247
 248   return 0;
 249 }