]> git.pld-linux.org Git - packages/elfutils.git/commitdiff
- updated from FC
authorJakub Bogusz <qboosh@pld-linux.org>
Tue, 1 May 2007 14:02:44 +0000 (14:02 +0000)
committercvs2git <feedback@pld-linux.org>
Sun, 24 Jun 2012 12:13:13 +0000 (12:13 +0000)
Changed files:
    elfutils-robustify.patch -> 1.7

elfutils-robustify.patch

index 9f87c48da3b83e51ba63c6b97d74105c528c3c7c..761434e92c01c2c88a564af312c256b34525a0dd 100644 (file)
@@ -65,756 +65,503 @@ src/
        (check_symtab, is_rel_dyn, check_rela, check_rel, check_dynamic,
        check_symtab_shndx, check_hash, check_versym): Robustify.
 
---- elfutils-0.122/libelf/elf32_getphdr.c
-+++ elfutils-0.122/libelf/elf32_getphdr.c
-@@ -115,6 +115,16 @@ elfw2(LIBELFBITS,getphdr) (elf)
+--- elfutils-0.127/src/readelf.c.robustify
++++ elfutils-0.127/src/readelf.c
+@@ -958,6 +958,8 @@ handle_scngrp (Ebl *ebl, Elf_Scn *scn, G
+   Elf32_Word *grpref = (Elf32_Word *) data->d_buf;
  
-       if (elf->map_address != NULL)
-       {
-+        /* First see whether the information in the ELF header is
-+           valid and it does not ask for too much.  */
-+        if (unlikely (ehdr->e_phoff >= elf->maximum_size)
-+            || unlikely (ehdr->e_phoff + size > elf->maximum_size))
-+          {
-+            /* Something is wrong.  */
-+            __libelf_seterrno (ELF_E_INVALID_PHDR);
-+            goto out;
-+          }
+   GElf_Sym sym_mem;
++  GElf_Sym *sym = gelf_getsym (symdata, shdr->sh_info, &sym_mem);
 +
-         /* All the data is already mapped.  Use it.  */
-         if (ehdr->e_ident[EI_DATA] == MY_ELFDATA
-             && (ALLOW_UNALIGNED
---- elfutils-0.126/libelf/elf32_getshdr.c
-+++ elfutils-0.126/libelf/elf32_getshdr.c
-@@ -101,7 +101,8 @@ elfw2(LIBELFBITS,getshdr) (scn)
-       goto out;
-       size_t shnum;
--      if (INTUSE (elf_getshnum) (elf, &shnum) != 0)
-+      if (INTUSE (elf_getshnum) (elf, &shnum) != 0
-+        || shnum > SIZE_MAX / sizeof (ElfW2(LIBELFBITS,Shdr)))
-       goto out;
-       size_t size = shnum * sizeof (ElfW2(LIBELFBITS,Shdr));
+   printf ((grpref[0] & GRP_COMDAT)
+         ? ngettext ("\
+ \nCOMDAT section group [%2zu] '%s' with signature '%s' contains %zu entry:\n",
+@@ -970,8 +972,8 @@ handle_scngrp (Ebl *ebl, Elf_Scn *scn, G
+                     data->d_size / sizeof (Elf32_Word) - 1),
+         elf_ndxscn (scn),
+         elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
+-        elf_strptr (ebl->elf, symshdr->sh_link,
+-                    gelf_getsym (symdata, shdr->sh_info, &sym_mem)->st_name)
++        (sym == NULL ? NULL
++         : elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name))
+         ?: gettext ("<INVALID SYMBOL>"),
+         data->d_size / sizeof (Elf32_Word) - 1);
  
-@@ -118,6 +119,16 @@ elfw2(LIBELFBITS,getshdr) (scn)
+@@ -1122,7 +1124,8 @@ static void
+ handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
+ {
+   int class = gelf_getclass (ebl->elf);
+-  GElf_Shdr glink;
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink;
+   Elf_Data *data;
+   size_t cnt;
+   size_t shstrndx;
+@@ -1137,6 +1140,11 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, 
+     error (EXIT_FAILURE, 0,
+          gettext ("cannot get section header string table index"));
  
-       if (elf->map_address != NULL)
-       {
-+        /* First see whether the information in the ELF header is
-+           valid and it does not ask for too much.  */
-+        if (unlikely (ehdr->e_shoff >= elf->maximum_size)
-+            || unlikely (ehdr->e_shoff + size > elf->maximum_size))
-+          {
-+            /* Something is wrong.  */
-+            __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
-+            goto free_and_out;
-+          }
++  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
++  if (glink == NULL)
++    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
++         elf_ndxscn (scn));
 +
-         ElfW2(LIBELFBITS,Shdr) *notcvt;
+   printf (ngettext ("\
+ \nDynamic segment contains %lu entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
+                   "\
+@@ -1146,9 +1154,7 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, 
+         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
+         shdr->sh_offset,
+         (int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
+   fputs_unlocked (gettext ("  Type              Value\n"), stdout);
  
-         /* All the data is already mapped.  If we could use it
-
---- elfutils-0.122/libelf/elf32_newphdr.c
-+++ elfutils-0.122/libelf/elf32_newphdr.c
-@@ -124,6 +124,12 @@ elfw2(LIBELFBITS,newphdr) (elf, count)
-   else if (elf->state.ELFW(elf,LIBELFBITS).ehdr->e_phnum != count
-          || elf->state.ELFW(elf,LIBELFBITS).phdr == NULL)
-     {
-+      if (unlikely (count > SIZE_MAX / sizeof (ElfW2(LIBELFBITS,Phdr))))
-+      {
-+        result = NULL;
-+        goto out;
-+      }
-+
-       /* Allocate a new program header with the appropriate number of
-        elements.  */
-       result = (ElfW2(LIBELFBITS,Phdr) *)
---- elfutils-0.122/libelf/elf32_updatefile.c
-+++ elfutils-0.122/libelf/elf32_updatefile.c
-@@ -201,6 +201,9 @@ __elfw2(LIBELFBITS,updatemmap) (Elf *elf
-   /* Write all the sections.  Well, only those which are modified.  */
-   if (shnum > 0)
-     {
-+      if (unlikely (shnum > SIZE_MAX / sizeof (Elf_Scn *)))
-+      return 1;
+   for (cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
+@@ -1666,6 +1672,13 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, G
+     error (EXIT_FAILURE, 0,
+          gettext ("cannot get section header string table index"));
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
++                                 &glink_mem);
++  if (glink == NULL)
++    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
++         elf_ndxscn (scn));
 +
-       Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
-       Elf_Scn **scns = (Elf_Scn **) alloca (shnum * sizeof (Elf_Scn *));
-       char *const shdr_start = ((char *) elf->map_address + elf->start_offset
-@@ -571,6 +574,10 @@ __elfw2(LIBELFBITS,updatefile) (Elf *elf
-   /* Write all the sections.  Well, only those which are modified.  */
-   if (shnum > 0)
-     {
-+      if (unlikely (shnum > SIZE_MAX / (sizeof (Elf_Scn *)
-+                                      + sizeof (ElfW2(LIBELFBITS,Shdr)))))
-+      return 1;
+   /* Now we can compute the number of entries in the section.  */
+   unsigned int nsyms = data->d_size / (class == ELFCLASS32
+                                      ? sizeof (Elf32_Sym)
+@@ -1676,15 +1689,12 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, G
+                   nsyms),
+         (unsigned int) elf_ndxscn (scn),
+         elf_strptr (ebl->elf, shstrndx, shdr->sh_name), nsyms);
+-  GElf_Shdr glink;
+   printf (ngettext (" %lu local symbol  String table: [%2u] '%s'\n",
+                   " %lu local symbols  String table: [%2u] '%s'\n",
+                   shdr->sh_info),
+         (unsigned long int) shdr->sh_info,
+         (unsigned int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
+   fputs_unlocked (class == ELFCLASS32
+                 ? gettext ("\
+@@ -1920,7 +1930,13 @@ handle_verneed (Ebl *ebl, Elf_Scn *scn, 
+     error (EXIT_FAILURE, 0,
+          gettext ("cannot get section header string table index"));
+-  GElf_Shdr glink;
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
++                                 &glink_mem);
++  if (glink == NULL)
++    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
++         elf_ndxscn (scn));
 +
-       off_t shdr_offset = elf->start_offset + ehdr->e_shoff;
- #if EV_NUM != 2
-       xfct_t shdr_fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR];
---- elfutils-0.122/libelf/elf_begin.c
-+++ elfutils-0.122/libelf/elf_begin.c
-@@ -155,7 +155,8 @@ get_shnum (void *map_address, unsigned c
+   printf (ngettext ("\
+ \nVersion needs section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
+                   "\
+@@ -1931,9 +1947,7 @@ handle_verneed (Ebl *ebl, Elf_Scn *scn, 
+         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
+         shdr->sh_offset,
+         (unsigned int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
  
-       if (unlikely (result == 0) && ehdr.e32->e_shoff != 0)
-       {
--        if (offset + ehdr.e32->e_shoff + sizeof (Elf32_Shdr) > maxsize)
-+        if (unlikely (ehdr.e32->e_shoff >= maxsize)
-+            || unlikely (ehdr.e32->e_shoff + sizeof (Elf32_Shdr) > maxsize))
-           /* Cannot read the first section header.  */
-           return (size_t) -1l;
+   unsigned int offset = 0;
+   for (int cnt = shdr->sh_info; --cnt >= 0; )
+@@ -1986,8 +2000,14 @@ handle_verdef (Ebl *ebl, Elf_Scn *scn, G
+     error (EXIT_FAILURE, 0,
+          gettext ("cannot get section header string table index"));
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
++                                 &glink_mem);
++  if (glink == NULL)
++    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
++         elf_ndxscn (scn));
++
+   int class = gelf_getclass (ebl->elf);
+-  GElf_Shdr glink;
+   printf (ngettext ("\
+ \nVersion definition section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
+                   "\
+@@ -1999,9 +2019,7 @@ handle_verdef (Ebl *ebl, Elf_Scn *scn, G
+         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
+         shdr->sh_offset,
+         (unsigned int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
  
-@@ -198,7 +199,8 @@ get_shnum (void *map_address, unsigned c
+   unsigned int offset = 0;
+   for (int cnt = shdr->sh_info; --cnt >= 0; )
+@@ -2263,8 +2281,14 @@ handle_versym (Ebl *ebl, Elf_Scn *scn, G
+       filename = NULL;
+     }
  
-       if (unlikely (result == 0) && ehdr.e64->e_shoff != 0)
-       {
--        if (offset + ehdr.e64->e_shoff + sizeof (Elf64_Shdr) > maxsize)
-+        if (unlikely (ehdr.e64->e_shoff >= maxsize)
-+            || unlikely (ehdr.e64->e_shoff + sizeof (Elf64_Shdr) > maxsize))
-           /* Cannot read the first section header.  */
-           return (size_t) -1l;
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
++                                 &glink_mem);
++  if (glink == NULL)
++    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
++         elf_ndxscn (scn));
++
+   /* Print the header.  */
+-  GElf_Shdr glink;
+   printf (ngettext ("\
+ \nVersion symbols section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'",
+                   "\
+@@ -2276,9 +2300,7 @@ handle_versym (Ebl *ebl, Elf_Scn *scn, G
+         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
+         shdr->sh_offset,
+         (unsigned int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
  
-@@ -265,6 +267,15 @@ file_read_elf (int fildes, void *map_add
-     /* Could not determine the number of sections.  */
-     return NULL;
+   /* Now we can finally look at the actual contents of this section.  */
+   for (unsigned int cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
+@@ -2330,7 +2352,17 @@ print_hash_info (Ebl *ebl, Elf_Scn *scn,
+   for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
+     ++counts[lengths[cnt]];
  
-+  /* Check for too many sections.  */
-+  if (e_ident[EI_CLASS] == ELFCLASS32)
+-  GElf_Shdr glink;
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf,
++                                             shdr->sh_link),
++                                 &glink_mem);
++  if (glink == NULL)
 +    {
-+      if (scncnt > SIZE_MAX / (sizeof (Elf_Scn) + sizeof (Elf32_Shdr)))
-+      return NULL;
++      error (0, 0, gettext ("invalid sh_link value in section %Zu"),
++           elf_ndxscn (scn));
++      return;
 +    }
-+  else if (scncnt > SIZE_MAX / (sizeof (Elf_Scn) + sizeof (Elf64_Shdr)))
-+    return NULL;
 +
-   /* We can now allocate the memory.  */
-   Elf *elf = allocate_elf (fildes, map_address, offset, maxsize, cmd, parent,
-                          ELF_K_ELF, scncnt * sizeof (Elf_Scn));
-@@ -298,13 +309,31 @@ file_read_elf (int fildes, void *map_add
-       {
-         /* We can use the mmapped memory.  */
-         elf->state.elf32.ehdr = ehdr;
-+
-+        if (unlikely (ehdr->e_shoff >= maxsize)
-+            || unlikely (ehdr->e_shoff
-+                         + scncnt * sizeof (Elf32_Shdr) > maxsize))
-+          {
-+          free_and_out:
-+            free (elf);
-+            __libelf_seterrno (ELF_E_INVALID_FILE);
-+            return NULL;
-+          }
-         elf->state.elf32.shdr
-           = (Elf32_Shdr *) ((char *) ehdr + ehdr->e_shoff);
-+
-         if (ehdr->e_phnum > 0)
-+          {
-           /* Assign a value only if there really is a program
-              header.  Otherwise the value remains NULL.  */
-+            if (unlikely (ehdr->e_phoff >= maxsize)
-+                || unlikely (ehdr->e_phoff
-+                             + ehdr->e_phnum
-+                             * sizeof (Elf32_Phdr) > maxsize))
-+              goto free_and_out;
-           elf->state.elf32.phdr
-             = (Elf32_Phdr *) ((char *) ehdr + ehdr->e_phoff);
-+          }
+   printf (ngettext ("\
+ \nHistogram for bucket list length in section [%2u] '%s' (total of %d bucket):\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
+                   "\
+@@ -2343,9 +2375,7 @@ print_hash_info (Ebl *ebl, Elf_Scn *scn,
+         shdr->sh_addr,
+         shdr->sh_offset,
+         (unsigned int) shdr->sh_link,
+-        elf_strptr (ebl->elf, shstrndx,
+-                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
+-                                  &glink)->sh_name));
++        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
  
-         for (size_t cnt = 0; cnt < scncnt; ++cnt)
-           {
-@@ -373,13 +402,26 @@ file_read_elf (int fildes, void *map_add
-       {
-         /* We can use the mmapped memory.  */
-         elf->state.elf64.ehdr = ehdr;
-+
-+        if (unlikely (ehdr->e_shoff >= maxsize)
-+            || unlikely (ehdr->e_shoff
-+                         + scncnt * sizeof (Elf32_Shdr) > maxsize))
-+          goto free_and_out;
-         elf->state.elf64.shdr
-           = (Elf64_Shdr *) ((char *) ehdr + ehdr->e_shoff);
+   if (extrastr != NULL)
+     fputs (extrastr, stdout);
+@@ -3655,6 +3685,16 @@ print_debug_aranges_section (Ebl *ebl __
+       return;
+     }
++  GElf_Shdr glink_mem;
++  GElf_Shdr *glink;
++  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
++  if (glink == NULL)
++    {
++      error (0, 0, gettext ("invalid sh_link value in section %Zu"),
++           elf_ndxscn (scn));
++      return;
++    }
 +
-         if (ehdr->e_phnum > 0)
-+          {
-           /* Assign a value only if there really is a program
-              header.  Otherwise the value remains NULL.  */
-+            if (unlikely (ehdr->e_phoff >= maxsize)
-+                || unlikely (ehdr->e_phoff
-+                             + ehdr->e_phnum
-+                             * sizeof (Elf32_Phdr) > maxsize))
-+              goto free_and_out;
-           elf->state.elf64.phdr
-             = (Elf64_Phdr *) ((char *) ehdr + ehdr->e_phoff);
-+          }
+   printf (ngettext ("\
+ \nDWARF section '%s' at offset %#" PRIx64 " contains %zu entry:\n",
+                   "\
+--- elfutils-0.127/src/strip.c.robustify
++++ elfutils-0.127/src/strip.c
+@@ -412,6 +412,7 @@ handle_elf (int fd, Elf *elf, const char
+   Elf_Data debuglink_crc_data;
+   bool any_symtab_changes = false;
+   Elf_Data *shstrtab_data = NULL;
++  size_t shdridx = 0;
  
-         for (size_t cnt = 0; cnt < scncnt; ++cnt)
-           {
---- elfutils-0.122/libelf/elf_getarsym.c
-+++ elfutils-0.122/libelf/elf_getarsym.c
-@@ -179,6 +179,9 @@ elf_getarsym (elf, ptr)
-       size_t index_size = atol (tmpbuf);
+   /* Create the full name of the file.  */
+   if (prefix != NULL)
+@@ -542,6 +543,11 @@ handle_elf (int fd, Elf *elf, const char
+       goto fail_close;
+     }
  
-       if (SARMAG + sizeof (struct ar_hdr) + index_size > elf->maximum_size
-+#if SIZE_MAX <= 4294967295U
-+        || n >= SIZE_MAX / sizeof (Elf_Arsym)
-+#endif
-         || n * sizeof (uint32_t) > index_size)
-       {
-         /* This index table cannot be right since it does not fit into
---- elfutils-0.122/libelf/elf_getshstrndx.c
-+++ elfutils-0.122/libelf/elf_getshstrndx.c
-@@ -125,10 +125,25 @@ elf_getshstrndx (elf, dst)
-             if (elf->map_address != NULL
-                 && elf->state.elf32.ehdr->e_ident[EI_DATA] == MY_ELFDATA
-                 && (ALLOW_UNALIGNED
--                    || (((size_t) ((char *) elf->map_address + offset))
-+                    || (((size_t) ((char *) elf->map_address
-+                         + elf->start_offset + offset))
-                         & (__alignof__ (Elf32_Shdr) - 1)) == 0))
-+              {
-+                /* First see whether the information in the ELF header is
-+                   valid and it does not ask for too much.  */
-+                if (unlikely (offset + sizeof (Elf32_Shdr)
-+                              > elf->maximum_size))
-+                  {
-+                    /* Something is wrong.  */
-+                    __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
-+                    result = -1;
-+                    goto out;
-+                  }
++  if (shstrndx >= shnum)
++    goto illformed;
 +
-               /* We can directly access the memory.  */
--              num = ((Elf32_Shdr *) (elf->map_address + offset))->sh_link;
-+                num = ((Elf32_Shdr *) (elf->map_address + elf->start_offset
-+                                       + offset))->sh_link;
-+              }
-             else
-               {
-                 /* We avoid reading in all the section headers.  Just read
-@@ -163,10 +178,25 @@ elf_getshstrndx (elf, dst)
-             if (elf->map_address != NULL
-                 && elf->state.elf64.ehdr->e_ident[EI_DATA] == MY_ELFDATA
-                 && (ALLOW_UNALIGNED
--                    || (((size_t) ((char *) elf->map_address + offset))
-+                    || (((size_t) ((char *) elf->map_address
-+                         + elf->start_offset + offset))
-                         & (__alignof__ (Elf64_Shdr) - 1)) == 0))
-+              {
-+                /* First see whether the information in the ELF header is
-+                   valid and it does not ask for too much.  */
-+                if (unlikely (offset + sizeof (Elf64_Shdr)
-+                              > elf->maximum_size))
-+                  {
-+                    /* Something is wrong.  */
-+                    __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
-+                    result = -1;
-+                    goto out;
-+                  }
++#define elf_assert(test) do { if (!(test)) goto illformed; } while (0)
 +
-               /* We can directly access the memory.  */
--              num = ((Elf64_Shdr *) (elf->map_address + offset))->sh_link;
-+                num = ((Elf64_Shdr *) (elf->map_address
-+                       + elf->start_offset + offset))->sh_link;
-+              }
-             else
-               {
-                 /* We avoid reading in all the section headers.  Just read
---- elfutils-0.122/libelf/elf_newscn.c
-+++ elfutils-0.122/libelf/elf_newscn.c
-@@ -104,10 +104,18 @@ elf_newscn (elf)
-   else
+   /* Storage for section information.  We leave room for two more
+      entries since we unconditionally create a section header string
+      table.  Maybe some weird tool created an ELF file without one.
+@@ -563,7 +569,7 @@ handle_elf (int fd, Elf *elf, const char
      {
-       /* We must allocate a new element.  */
--      Elf_ScnList *newp;
-+      Elf_ScnList *newp = NULL;
-       assert (elf->state.elf.scnincr > 0);
+       /* This should always be true (i.e., there should not be any
+        holes in the numbering).  */
+-      assert (elf_ndxscn (scn) == cnt);
++      elf_assert (elf_ndxscn (scn) == cnt);
  
-+      if (
-+#if SIZE_MAX <= 4294967295U
-+        likely (elf->state.elf.scnincr
-+                < SIZE_MAX / 2 / sizeof (Elf_Scn) - sizeof (Elf_ScnList))
-+#else
-+        1
-+#endif
-+        )
-       newp = (Elf_ScnList *) calloc (sizeof (Elf_ScnList)
-                                    + ((elf->state.elf.scnincr *= 2)
-                                       * sizeof (Elf_Scn)), 1);
---- elfutils-0.122/libelf/gelf_getdyn.c
-+++ elfutils-0.122/libelf/gelf_getdyn.c
-@@ -93,7 +93,8 @@ gelf_getdyn (data, ndx, dst)
-        table entries has to be adopted.  The user better has provided
-        a buffer where we can store the information.  While copying the
-        data we are converting the format.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Dyn)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -114,7 +115,8 @@ gelf_getdyn (data, ndx, dst)
+       shdr_info[cnt].scn = scn;
  
-       /* The data is already in the correct form.  Just make sure the
-        index is OK.  */
--      if (unlikely ((ndx + 1) * sizeof (GElf_Dyn) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, GElf_Dyn)
-+        || unlikely ((ndx + 1) * sizeof (GElf_Dyn) > data_scn->d.d_size))
+@@ -576,6 +582,7 @@ handle_elf (int fd, Elf *elf, const char
+                                       shdr_info[cnt].shdr.sh_name);
+       if (shdr_info[cnt].name == NULL)
        {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_getlib.c
-+++ elfutils-0.122/libelf/gelf_getlib.c
-@@ -86,7 +86,8 @@ gelf_getlib (data, ndx, dst)
-   /* The data is already in the correct form.  Just make sure the
-      index is OK.  */
-   GElf_Lib *result = NULL;
--  if (unlikely ((ndx + 1) * sizeof (GElf_Lib) > data->d_size))
-+  if (INVALID_NDX (ndx, GElf_Lib)
-+      || unlikely ((ndx + 1) * sizeof (GElf_Lib) > data->d_size))
-     __libelf_seterrno (ELF_E_INVALID_INDEX);
-   else
-     {
---- elfutils-0.122/libelf/gelf_getmove.c
-+++ elfutils-0.122/libelf/gelf_getmove.c
-@@ -83,7 +83,8 @@ gelf_getmove (data, ndx, dst)
++      illformed:
+         error (0, 0, gettext ("illformed file '%s'"), fname);
+         goto fail_close;
+       }
+@@ -585,6 +592,8 @@ handle_elf (int fd, Elf *elf, const char
  
-   /* The data is already in the correct form.  Just make sure the
-      index is OK.  */
--  if (unlikely ((ndx + 1) * sizeof (GElf_Move) > data->d_size))
-+  if (INVALID_NDX (ndx, GElf_Move)
-+      || unlikely ((ndx + 1) * sizeof (GElf_Move) > data->d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
-       goto out;
---- elfutils-0.122/libelf/gelf_getrela.c
-+++ elfutils-0.122/libelf/gelf_getrela.c
-@@ -71,12 +71,6 @@ gelf_getrela (data, ndx, dst)
-   if (data_scn == NULL)
-     return NULL;
+       /* Remember the shdr.sh_link value.  */
+       shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link;
++      if (shdr_info[cnt].old_sh_link >= shnum)
++      goto illformed;
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return NULL;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_RELA))
-     {
-       __libelf_seterrno (ELF_E_INVALID_HANDLE);
-@@ -93,7 +87,8 @@ gelf_getrela (data, ndx, dst)
-   if (scn->elf->class == ELFCLASS32)
-     {
-       /* We have to convert the data.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Rela)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
+       /* Sections in files other than relocatable object files which
+        are not loaded can be freely moved by us.  In relocatable
+@@ -597,7 +606,7 @@ handle_elf (int fd, Elf *elf, const char
+        appropriate reference.  */
+       if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX))
        {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         result = NULL;
-@@ -114,7 +109,8 @@ gelf_getrela (data, ndx, dst)
-     {
-       /* Simply copy the data after we made sure we are actually getting
-        correct data.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Rela)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         result = NULL;
---- elfutils-0.122/libelf/gelf_getrel.c
-+++ elfutils-0.122/libelf/gelf_getrel.c
-@@ -71,12 +71,6 @@ gelf_getrel (data, ndx, dst)
-   if (data_scn == NULL)
-     return NULL;
+-        assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
++        elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
+         shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt;
+       }
+       else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP))
+@@ -614,7 +623,12 @@ handle_elf (int fd, Elf *elf, const char
+         for (inner = 1;
+              inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
+              ++inner)
++          {
++            if (grpref[inner] < shnum)
+           shdr_info[grpref[inner]].group_idx = cnt;
++            else
++              goto illformed;
++          }
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return NULL;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_REL))
-     {
-       __libelf_seterrno (ELF_E_INVALID_HANDLE);
-@@ -93,7 +87,8 @@ gelf_getrel (data, ndx, dst)
-   if (scn->elf->class == ELFCLASS32)
-     {
-       /* We have to convert the data.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Rel)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         result = NULL;
-@@ -113,7 +108,8 @@ gelf_getrel (data, ndx, dst)
-     {
-       /* Simply copy the data after we made sure we are actually getting
-        correct data.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Rel)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         result = NULL;
---- elfutils-0.122/libelf/gelf_getsym.c
-+++ elfutils-0.122/libelf/gelf_getsym.c
-@@ -90,7 +90,8 @@ gelf_getsym (data, ndx, dst)
-        table entries has to be adopted.  The user better has provided
-        a buffer where we can store the information.  While copying the
-        data we are converting the format.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data->d_size))
-+      if (INVALID_NDX (ndx, Elf32_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data->d_size))
+         if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0))
+           /* If the section group contains only one element and this
+@@ -625,7 +639,7 @@ handle_elf (int fd, Elf *elf, const char
+       }
+       else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym))
        {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -119,7 +120,8 @@ gelf_getsym (data, ndx, dst)
+-        assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
++        elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
+         shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt;
+       }
  
-       /* The data is already in the correct form.  Just make sure the
-        index is OK.  */
--      if (unlikely ((ndx + 1) * sizeof (GElf_Sym) > data->d_size))
-+      if (INVALID_NDX (ndx, GElf_Sym)
-+        || unlikely ((ndx + 1) * sizeof (GElf_Sym) > data->d_size))
+@@ -633,7 +647,7 @@ handle_elf (int fd, Elf *elf, const char
+        discarded right away.  */
+       if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0)
        {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_getsyminfo.c
-+++ elfutils-0.122/libelf/gelf_getsyminfo.c
-@@ -84,7 +84,8 @@ gelf_getsyminfo (data, ndx, dst)
+-        assert (shdr_info[cnt].group_idx != 0);
++        elf_assert (shdr_info[cnt].group_idx != 0);
  
-   /* The data is already in the correct form.  Just make sure the
-      index is OK.  */
--  if (unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data->d_size))
-+  if (INVALID_NDX (ndx, GElf_Syminfo)
-+      || unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data->d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
-       goto out;
---- elfutils-0.122/libelf/gelf_getsymshndx.c
-+++ elfutils-0.122/libelf/gelf_getsymshndx.c
-@@ -90,7 +90,9 @@ gelf_getsymshndx (symdata, shndxdata, nd
-      section index table.  */
-   if (likely (shndxdata_scn != NULL))
-     {
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Word) > shndxdata_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Word)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Word)
-+                     > shndxdata_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -110,7 +112,8 @@ gelf_getsymshndx (symdata, shndxdata, nd
-        table entries has to be adopted.  The user better has provided
-        a buffer where we can store the information.  While copying the
-        data we are converting the format.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata->d_size))
-+      if (INVALID_NDX (ndx, Elf32_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata->d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -139,7 +142,8 @@ gelf_getsymshndx (symdata, shndxdata, nd
+         if (shdr_info[shdr_info[cnt].group_idx].idx == 0)
+           {
+@@ -708,11 +722,15 @@ handle_elf (int fd, Elf *elf, const char
+           {
+             /* If a relocation section is marked as being removed make
+                sure the section it is relocating is removed, too.  */
+-            if ((shdr_info[cnt].shdr.sh_type == SHT_REL
++            if (shdr_info[cnt].shdr.sh_type == SHT_REL
+                  || shdr_info[cnt].shdr.sh_type == SHT_RELA)
+-                && shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
++              {
++                if (shdr_info[cnt].shdr.sh_info >= shnum)
++                  goto illformed;
++                else if (shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
+               shdr_info[cnt].idx = 1;
+           }
++          }
  
-       /* The data is already in the correct form.  Just make sure the
-        index is OK.  */
--      if (unlikely ((ndx + 1) * sizeof (GElf_Sym) > symdata->d_size))
-+      if (INVALID_NDX (ndx, GElf_Sym)
-+        || unlikely ((ndx + 1) * sizeof (GElf_Sym) > symdata->d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_getversym.c
-+++ elfutils-0.122/libelf/gelf_getversym.c
-@@ -92,7 +92,8 @@ gelf_getversym (data, ndx, dst)
+         if (shdr_info[cnt].idx == 1)
+           {
+@@ -737,7 +755,7 @@ handle_elf (int fd, Elf *elf, const char
+                 if (shdr_info[cnt].symtab_idx != 0
+                     && shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
+                   {
+-                    assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
++                    elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
  
-   /* The data is already in the correct form.  Just make sure the
-      index is OK.  */
--  if (unlikely ((ndx + 1) * sizeof (GElf_Versym) > data->d_size))
-+  if (INVALID_NDX (ndx, GElf_Versym)
-+      || unlikely ((ndx + 1) * sizeof (GElf_Versym) > data->d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
-       result = NULL;
---- elfutils-0.122/libelf/gelf_update_dyn.c
-+++ elfutils-0.122/libelf/gelf_update_dyn.c
-@@ -71,12 +71,6 @@ gelf_update_dyn (data, ndx, src)
-   if (data == NULL)
-     return 0;
+                     shdr_info[shdr_info[cnt].symtab_idx].data
+                       = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
+@@ -777,6 +795,9 @@ handle_elf (int fd, Elf *elf, const char
+                     else if (scnidx == SHN_XINDEX)
+                       scnidx = xndx;
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_DYN))
-     {
-       /* The type of the data better should match.  */
-@@ -102,7 +96,8 @@ gelf_update_dyn (data, ndx, src)
-       }
++                    if (scnidx >= shnum)
++                      goto illformed;
++
+                     if (shdr_info[scnidx].idx == 0)
+                       {
+                         /* Mark this section as used.  */
+@@ -808,12 +829,16 @@ handle_elf (int fd, Elf *elf, const char
+               }
  
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Dyn)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -116,7 +111,8 @@ gelf_update_dyn (data, ndx, src)
-   else
-     {
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Dyn) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Dyn)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Dyn) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_update_lib.c
-+++ elfutils-0.122/libelf/gelf_update_lib.c
-@@ -68,12 +68,6 @@ gelf_update_lib (data, ndx, src)
-   if (data == NULL)
-     return 0;
+             /* Handle references through sh_info.  */
+-            if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)
+-                && shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
++            if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
++              {
++                if (shdr_info[cnt].shdr.sh_info >= shnum)
++                  goto illformed;
++                else if ( shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
+               {
+                 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
+                 changes |= shdr_info[cnt].shdr.sh_info < cnt;
+               }
++              }
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   Elf_Data_Scn *data_scn = (Elf_Data_Scn *) data;
-   if (unlikely (data_scn->d.d_type != ELF_T_LIB))
-     {
-@@ -87,7 +81,8 @@ gelf_update_lib (data, ndx, src)
+             /* Mark the section as investigated.  */
+             shdr_info[cnt].idx = 2;
+@@ -912,7 +937,7 @@ handle_elf (int fd, Elf *elf, const char
+         error (EXIT_FAILURE, 0, gettext ("while generating output file: %s"),
+                elf_errmsg (-1));
  
-   /* Check whether we have to resize the data buffer.  */
-   int result = 0;
--  if (unlikely ((ndx + 1) * sizeof (Elf64_Lib) > data_scn->d.d_size))
-+  if (INVALID_NDX (ndx, Elf64_Lib)
-+      || unlikely ((ndx + 1) * sizeof (Elf64_Lib) > data_scn->d.d_size))
-     __libelf_seterrno (ELF_E_INVALID_INDEX);
-   else
-     {
---- elfutils-0.122/libelf/gelf_update_move.c
-+++ elfutils-0.122/libelf/gelf_update_move.c
-@@ -75,7 +75,7 @@ gelf_update_move (data, ndx, src)
-   assert (sizeof (GElf_Move) == sizeof (Elf64_Move));
+-      assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
++      elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
  
-   /* Check whether we have to resize the data buffer.  */
--  if (unlikely (ndx < 0)
-+  if (INVALID_NDX (ndx, GElf_Move)
-       || unlikely ((ndx + 1) * sizeof (GElf_Move) > data_scn->d.d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
---- elfutils-0.122/libelf/gelf_update_rela.c
-+++ elfutils-0.122/libelf/gelf_update_rela.c
-@@ -68,12 +68,6 @@ gelf_update_rela (Elf_Data *dst, int ndx
-   if (dst == NULL)
-     return 0;
+       /* Add this name to the section header string table.  */
+       shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0);
+@@ -949,7 +974,7 @@ handle_elf (int fd, Elf *elf, const char
+       error (EXIT_FAILURE, 0,
+              gettext ("while create section header section: %s"),
+              elf_errmsg (-1));
+-      assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
++      elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_RELA))
-     {
-       /* The type of the data better should match.  */
-@@ -101,7 +95,8 @@ gelf_update_rela (Elf_Data *dst, int ndx
-       }
+       shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn);
+       if (shdr_info[cnt].data == NULL)
+@@ -980,7 +1005,7 @@ handle_elf (int fd, Elf *elf, const char
+     }
  
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Rela)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -117,7 +112,8 @@ gelf_update_rela (Elf_Data *dst, int ndx
-   else
-     {
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Rela)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_update_rel.c
-+++ elfutils-0.122/libelf/gelf_update_rel.c
-@@ -68,12 +68,6 @@ gelf_update_rel (Elf_Data *dst, int ndx,
-   if (dst == NULL)
-     return 0;
+   /* Index of the section header table in the shdr_info array.  */
+-  size_t shdridx = cnt;
++  shdridx = cnt;
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_REL))
-     {
-       /* The type of the data better should match.  */
-@@ -99,7 +93,8 @@ gelf_update_rel (Elf_Data *dst, int ndx,
-       }
+   /* Add the section header string table section name.  */
+   shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10);
+@@ -1005,7 +1030,7 @@ handle_elf (int fd, Elf *elf, const char
+     error (EXIT_FAILURE, 0,
+          gettext ("while create section header section: %s"),
+          elf_errmsg (-1));
+-  assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
++  elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
  
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Rel)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -114,7 +109,8 @@ gelf_update_rel (Elf_Data *dst, int ndx,
-   else
-     {
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Rel)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_update_sym.c
-+++ elfutils-0.122/libelf/gelf_update_sym.c
-@@ -72,12 +72,6 @@ gelf_update_sym (data, ndx, src)
-   if (data == NULL)
-     return 0;
+   /* Finalize the string table and fill in the correct indices in the
+      section headers.  */
+@@ -1095,20 +1120,20 @@ handle_elf (int fd, Elf *elf, const char
+                   shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
+                                            NULL);
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_SYM))
-     {
-       /* The type of the data better should match.  */
-@@ -102,7 +96,8 @@ gelf_update_sym (data, ndx, src)
-       }
+-                  assert ((versiondata->d_size / sizeof (Elf32_Word))
++                  elf_assert ((versiondata->d_size / sizeof (Elf32_Word))
+                           >= shdr_info[cnt].data->d_size / elsize);
+                 }
  
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -125,7 +120,8 @@ gelf_update_sym (data, ndx, src)
-   else
-     {
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Sym) > data_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Sym) > data_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_update_syminfo.c
-+++ elfutils-0.122/libelf/gelf_update_syminfo.c
-@@ -72,12 +72,6 @@ gelf_update_syminfo (data, ndx, src)
-   if (data == NULL)
-     return 0;
+               if (shdr_info[cnt].version_idx != 0)
+                 {
+-                  assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
++                  elf_assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
+                   /* This section has associated version
+                      information.  We have to modify that
+                      information, too.  */
+                   versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn,
+                                              NULL);
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (data_scn->d.d_type != ELF_T_SYMINFO))
-     {
-       /* The type of the data better should match.  */
-@@ -93,7 +87,8 @@ gelf_update_syminfo (data, ndx, src)
-   rwlock_wrlock (scn->elf->lock);
+-                  assert ((versiondata->d_size / sizeof (GElf_Versym))
++                  elf_assert ((versiondata->d_size / sizeof (GElf_Versym))
+                           >= shdr_info[cnt].data->d_size / elsize);
+                 }
  
-   /* Check whether we have to resize the data buffer.  */
--  if (unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data_scn->d.d_size))
-+  if (INVALID_NDX (ndx, GElf_Syminfo)
-+      || unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data_scn->d.d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
-       goto out;
---- elfutils-0.122/libelf/gelf_update_symshndx.c
-+++ elfutils-0.122/libelf/gelf_update_symshndx.c
-@@ -77,12 +77,6 @@ gelf_update_symshndx (symdata, shndxdata
-   if (symdata == NULL)
-     return 0;
+@@ -1163,7 +1188,7 @@ handle_elf (int fd, Elf *elf, const char
+                     sec = shdr_info[sym->st_shndx].idx;
+                   else
+                     {
+-                      assert (shndxdata != NULL);
++                      elf_assert (shndxdata != NULL);
  
--  if (unlikely (ndx < 0))
--    {
--      __libelf_seterrno (ELF_E_INVALID_INDEX);
--      return 0;
--    }
--
-   if (unlikely (symdata_scn->d.d_type != ELF_T_SYM))
-     {
-       /* The type of the data better should match.  */
-@@ -128,7 +122,8 @@ gelf_update_symshndx (symdata, shndxdata
-       }
+                       sec = shdr_info[xshndx].idx;
+                     }
+@@ -1184,7 +1209,7 @@ handle_elf (int fd, Elf *elf, const char
+                           nxshndx = sec;
+                         }
  
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf32_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
-@@ -151,7 +146,8 @@ gelf_update_symshndx (symdata, shndxdata
-   else
-     {
-       /* Check whether we have to resize the data buffer.  */
--      if (unlikely ((ndx + 1) * sizeof (Elf64_Sym) > symdata_scn->d.d_size))
-+      if (INVALID_NDX (ndx, Elf64_Sym)
-+        || unlikely ((ndx + 1) * sizeof (Elf64_Sym) > symdata_scn->d.d_size))
-       {
-         __libelf_seterrno (ELF_E_INVALID_INDEX);
-         goto out;
---- elfutils-0.122/libelf/gelf_update_versym.c
-+++ elfutils-0.122/libelf/gelf_update_versym.c
-@@ -75,7 +75,7 @@ gelf_update_versym (data, ndx, src)
-   assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
+-                      assert (sec < SHN_LORESERVE || shndxdata != NULL);
++                      elf_assert (sec < SHN_LORESERVE || shndxdata != NULL);
  
-   /* Check whether we have to resize the data buffer.  */
--  if (unlikely (ndx < 0)
-+  if (INVALID_NDX (ndx, GElf_Versym)
-       || unlikely ((ndx + 1) * sizeof (GElf_Versym) > data_scn->d.d_size))
-     {
-       __libelf_seterrno (ELF_E_INVALID_INDEX);
---- elfutils-0.122/libelf/libelfP.h
-+++ elfutils-0.122/libelf/libelfP.h
-@@ -558,4 +558,13 @@ extern uint32_t __libelf_crc32 (uint32_t
-       }                                                                             \
-   } while (0)
+                       if ((inner != destidx || nshndx != sym->st_shndx
+                            || (shndxdata != NULL && nxshndx != xshndx))
+@@ -1207,7 +1232,7 @@ handle_elf (int fd, Elf *elf, const char
+                   else
+                     /* This is a section symbol for a section which has
+                        been removed.  */
+-                    assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION);
++                    elf_assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION);
+                 }
  
-+/* Convenience macro.  Assumes int NDX and TYPE with size at least
-+   2 bytes.  */
-+#if SIZE_MAX > 4294967295U
-+# define INVALID_NDX(ndx, type) unlikely (ndx < 0)
-+#else
-+# define INVALID_NDX(ndx, type) \
-+  unlikely ((unsigned int) (ndx) >= SIZE_MAX / sizeof (type))
-+#endif
-+
- #endif  /* libelfP.h */
---- elfutils-0.122/src/elflint.c
-+++ elfutils-0.122/src/elflint.c
-@@ -123,6 +123,9 @@ static uint32_t shstrndx;
- /* Array to count references in section groups.  */
- static int *scnref;
+               if (destidx != inner)
+@@ -1371,11 +1396,11 @@ handle_elf (int fd, Elf *elf, const char
+                   {
+                     GElf_Sym sym_mem;
+                     GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
+-                    assert (sym != NULL);
++                    elf_assert (sym != NULL);
  
-+/* Number of sections.  */
-+static unsigned int shnum;
-+
+                     const char *name = elf_strptr (elf, strshndx,
+                                                    sym->st_name);
+-                    assert (name != NULL);
++                    elf_assert (name != NULL);
+                     size_t hidx = elf_hash (name) % nbucket;
  
- int
- main (int argc, char *argv[])
-@@ -312,10 +315,19 @@ section_name (Ebl *ebl, int idx)
- {
-   GElf_Shdr shdr_mem;
-   GElf_Shdr *shdr;
+                     if (bucket[hidx] == 0)
+@@ -1394,7 +1419,7 @@ handle_elf (int fd, Elf *elf, const char
+             else
+               {
+                 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries.  */
+-                assert (shdr_info[cnt].shdr.sh_entsize
++                elf_assert (shdr_info[cnt].shdr.sh_entsize
+                         == sizeof (Elf64_Xword));
+                 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf;
+@@ -1428,11 +1453,11 @@ handle_elf (int fd, Elf *elf, const char
+                   {
+                     GElf_Sym sym_mem;
+                     GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
+-                    assert (sym != NULL);
++                    elf_assert (sym != NULL);
+                     const char *name = elf_strptr (elf, strshndx,
+                                                    sym->st_name);
+-                    assert (name != NULL);
++                    elf_assert (name != NULL);
+                     size_t hidx = elf_hash (name) % nbucket;
+                     if (bucket[hidx] == 0)
+--- elfutils-0.127/src/elflint.c.robustify
++++ elfutils-0.127/src/elflint.c
+@@ -123,6 +123,9 @@ static uint32_t shstrndx;
+ /* Array to count references in section groups.  */
+ static int *scnref;
++/* Number of sections.  */
++static unsigned int shnum;
++
+ int
+ main (int argc, char *argv[])
+@@ -312,10 +315,19 @@ section_name (Ebl *ebl, int idx)
+ {
+   GElf_Shdr shdr_mem;
+   GElf_Shdr *shdr;
 +  const char *ret;
 +
 +  if ((unsigned int) idx > shnum)
@@ -872,7 +619,7 @@ src/
        }
  
        if (sym->st_shndx == SHN_XINDEX)
-@@ -968,9 +978,11 @@ is_rel_dyn (Ebl *ebl, const GElf_Ehdr *e
+@@ -981,9 +991,11 @@ is_rel_dyn (Ebl *ebl, const GElf_Ehdr *e
      {
        GElf_Shdr rcshdr_mem;
        const GElf_Shdr *rcshdr = gelf_getshdr (scn, &rcshdr_mem);
@@ -886,7 +633,7 @@ src/
        {
          /* Found the dynamic section.  Look through it.  */
          Elf_Data *d = elf_getdata (scn, NULL);
-@@ -980,7 +992,9 @@ is_rel_dyn (Ebl *ebl, const GElf_Ehdr *e
+@@ -993,7 +1005,9 @@ is_rel_dyn (Ebl *ebl, const GElf_Ehdr *e
            {
              GElf_Dyn dyn_mem;
              GElf_Dyn *dyn = gelf_getdyn (d, cnt, &dyn_mem);
@@ -897,7 +644,7 @@ src/
  
              if (dyn->d_tag == DT_RELCOUNT)
                {
-@@ -994,7 +1008,9 @@ section [%2d] '%s': DT_RELCOUNT used for
+@@ -1007,7 +1021,9 @@ section [%2d] '%s': DT_RELCOUNT used for
                      /* Does the number specified number of relative
                         relocations exceed the total number of
                         relocations?  */
@@ -908,7 +655,7 @@ src/
                        ERROR (gettext ("\
  section [%2d] '%s': DT_RELCOUNT value %d too high for this section\n"),
                               idx, section_name (ebl, idx),
-@@ -1154,7 +1170,8 @@ section [%2d] '%s': no relocations for m
+@@ -1167,7 +1183,8 @@ section [%2d] '%s': no relocations for m
        }
      }
  
@@ -918,7 +665,7 @@ src/
      ERROR (gettext (reltype == ELF_T_RELA ? "\
  section [%2d] '%s': section entry size does not match ElfXX_Rela\n" : "\
  section [%2d] '%s': section entry size does not match ElfXX_Rel\n"),
-@@ -1376,7 +1393,8 @@ check_rela (Ebl *ebl, GElf_Ehdr *ehdr, G
+@@ -1389,7 +1406,8 @@ check_rela (Ebl *ebl, GElf_Ehdr *ehdr, G
    Elf_Data *symdata = elf_getdata (symscn, NULL);
    enum load_state state = state_undecided;
  
@@ -928,7 +675,7 @@ src/
      {
        GElf_Rela rela_mem;
        GElf_Rela *rela = gelf_getrela (data, cnt, &rela_mem);
-@@ -1426,7 +1444,8 @@ check_rel (Ebl *ebl, GElf_Ehdr *ehdr, GE
+@@ -1439,7 +1457,8 @@ check_rel (Ebl *ebl, GElf_Ehdr *ehdr, GE
    Elf_Data *symdata = elf_getdata (symscn, NULL);
    enum load_state state = state_undecided;
  
@@ -938,7 +685,7 @@ src/
      {
        GElf_Rel rel_mem;
        GElf_Rel *rel = gelf_getrel (data, cnt, &rel_mem);
-@@ -1528,7 +1547,8 @@ section [%2d] '%s': referenced as string
+@@ -1543,7 +1562,8 @@ section [%2d] '%s': referenced as string
           shdr->sh_link, section_name (ebl, shdr->sh_link),
           idx, section_name (ebl, idx));
  
@@ -948,7 +695,7 @@ src/
      ERROR (gettext ("\
  section [%2d] '%s': section entry size does not match ElfXX_Dyn\n"),
           idx, section_name (ebl, idx));
-@@ -1538,7 +1558,7 @@ section [%2d] '%s': section entry size d
+@@ -1553,7 +1573,7 @@ section [%2d] '%s': section entry size d
           idx, section_name (ebl, idx));
  
    bool non_null_warned = false;
@@ -957,7 +704,7 @@ src/
      {
        GElf_Dyn dyn_mem;
        GElf_Dyn *dyn = gelf_getdyn (data, cnt, &dyn_mem);
-@@ -1756,6 +1776,8 @@ section [%2d] '%s': entry size does not 
+@@ -1834,6 +1854,8 @@ section [%2d] '%s': entry size does not 
           idx, section_name (ebl, idx));
  
    if (symshdr != NULL
@@ -966,7 +713,7 @@ src/
        && (shdr->sh_size / shdr->sh_entsize
          < symshdr->sh_size / symshdr->sh_entsize))
      ERROR (gettext ("\
-@@ -1782,6 +1804,12 @@ section [%2d] '%s': extended section ind
+@@ -1860,6 +1882,12 @@ section [%2d] '%s': extended section ind
      }
  
    Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
@@ -979,7 +726,7 @@ src/
  
    if (*((Elf32_Word *) data->d_buf) != 0)
      ERROR (gettext ("symbol 0 should have zero extended section index\n"));
-@@ -1824,7 +1852,7 @@ section [%2d] '%s': hash table section i
+@@ -1902,7 +1930,7 @@ section [%2d] '%s': hash table section i
  
    size_t maxidx = nchain;
  
@@ -988,7 +735,7 @@ src/
      {
        size_t symsize = symshdr->sh_size / symshdr->sh_entsize;
  
-@@ -1835,18 +1863,28 @@ section [%2d] '%s': hash table section i
+@@ -1913,18 +1941,28 @@ section [%2d] '%s': hash table section i
        maxidx = symsize;
      }
  
@@ -997,33 +744,29 @@ src/
    size_t cnt;
    for (cnt = 2; cnt < 2 + nbucket; ++cnt)
 -    if (((Elf32_Word *) data->d_buf)[cnt] >= maxidx)
--      ERROR (gettext ("\
 +    {
 +      if (buf + cnt >= end)
 +      break;
 +      else if (buf[cnt] >= maxidx)
-+      ERROR (gettext ("\
+       ERROR (gettext ("\
  section [%2d] '%s': hash bucket reference %zu out of bounds\n"),
--           idx, section_name (ebl, idx), cnt - 2);
-+             idx, section_name (ebl, idx), cnt - 2);
+            idx, section_name (ebl, idx), cnt - 2);
 +    }
  
    for (; cnt < 2 + nbucket + nchain; ++cnt)
 -    if (((Elf32_Word *) data->d_buf)[cnt] >= maxidx)
--      ERROR (gettext ("\
 +    {
 +      if (buf + cnt >= end)
 +      break;
 +      else if (buf[cnt] >= maxidx)
-+      ERROR (gettext ("\
+       ERROR (gettext ("\
  section [%2d] '%s': hash chain reference %zu out of bounds\n"),
--           idx, section_name (ebl, idx), cnt - 2 - nbucket);
-+             idx, section_name (ebl, idx), cnt - 2 - nbucket);
+            idx, section_name (ebl, idx), cnt - 2 - nbucket);
 +    }
  }
  
  
-@@ -1876,18 +1914,28 @@ section [%2d] '%s': hash table section i
+@@ -1954,18 +1992,28 @@ section [%2d] '%s': hash table section i
        maxidx = symsize;
      }
  
@@ -1032,25 +775,22 @@ src/
    size_t cnt;
    for (cnt = 2; cnt < 2 + nbucket; ++cnt)
 -    if (((Elf64_Xword *) data->d_buf)[cnt] >= maxidx)
--      ERROR (gettext ("\
 +    {
 +      if (buf + cnt >= end)
 +      break;
 +      else if (buf[cnt] >= maxidx)
-+      ERROR (gettext ("\
+       ERROR (gettext ("\
  section [%2d] '%s': hash bucket reference %zu out of bounds\n"),
--           idx, section_name (ebl, idx), cnt - 2);
-+             idx, section_name (ebl, idx), cnt - 2);
+            idx, section_name (ebl, idx), cnt - 2);
 +    }
  
    for (; cnt < 2 + nbucket + nchain; ++cnt)
 -    if (((Elf64_Xword *) data->d_buf)[cnt] >= maxidx)
--      ERROR (gettext ("\
 +    {
 +      if (buf + cnt >= end)
 +      break;
 +      else if (buf[cnt] >= maxidx)
-+      ERROR (gettext ("\
+       ERROR (gettext ("\
  section [%2d] '%s': hash chain reference %" PRIu64 " out of bounds\n"),
 -           idx, section_name (ebl, idx), (uint64_t) (cnt - 2 - nbucket));
 +             idx, section_name (ebl, idx), (uint64_t) cnt - 2 - nbucket);
@@ -1058,7 +798,7 @@ src/
  }
  
  
-@@ -1912,7 +1960,7 @@ section [%2d] '%s': bitmask size not pow
+@@ -1990,7 +2038,7 @@ section [%2d] '%s': bitmask size not pow
    if (shdr->sh_size < (4 + bitmask_words + nbuckets) * sizeof (Elf32_Word))
      {
        ERROR (gettext ("\
@@ -1067,7 +807,7 @@ src/
             idx, section_name (ebl, idx), (long int) shdr->sh_size,
             (long int) ((4 + bitmask_words + nbuckets) * sizeof (Elf32_Word)));
        return;
-@@ -2430,8 +2478,9 @@ section [%2d] '%s' refers in sh_link to 
+@@ -2644,8 +2692,9 @@ section [%2d] '%s' refers in sh_link to 
  
    /* The number of elements in the version symbol table must be the
       same as the number of symbols.  */
@@ -1079,7 +819,7 @@ src/
      ERROR (gettext ("\
  section [%2d] '%s' has different number of entries than symbol table [%2d] '%s'\n"),
           idx, section_name (ebl, idx),
-@@ -3336,6 +3385,8 @@ phdr[%d]: no note entries defined for th
+@@ -3574,6 +3623,8 @@ phdr[%d]: no note entries defined for th
      return;
  
    char *notemem = gelf_rawchunk (ebl->elf, phdr->p_offset, phdr->p_filesz);
@@ -1088,484 +828,736 @@ src/
  
    /* ELF64 files often use note section entries in the 32-bit format.
       The p_align field is set to 8 in case the 64-bit format is used.
---- elfutils-0.122/src/readelf.c
-+++ elfutils-0.122/src/readelf.c
-@@ -958,6 +958,8 @@ handle_scngrp (Ebl *ebl, Elf_Scn *scn, G
-   Elf32_Word *grpref = (Elf32_Word *) data->d_buf;
+--- elfutils-0.127/libelf/elf_begin.c.robustify
++++ elfutils-0.127/libelf/elf_begin.c
+@@ -155,7 +155,8 @@ get_shnum (void *map_address, unsigned c
  
-   GElf_Sym sym_mem;
-+  GElf_Sym *sym = gelf_getsym (symdata, shdr->sh_info, &sym_mem);
-+
-   printf ((grpref[0] & GRP_COMDAT)
-         ? ngettext ("\
- \nCOMDAT section group [%2zu] '%s' with signature '%s' contains %zu entry:\n",
-@@ -970,8 +972,8 @@ handle_scngrp (Ebl *ebl, Elf_Scn *scn, G
-                     data->d_size / sizeof (Elf32_Word) - 1),
-         elf_ndxscn (scn),
-         elf_strptr (ebl->elf, shstrndx, shdr->sh_name),
--        elf_strptr (ebl->elf, symshdr->sh_link,
--                    gelf_getsym (symdata, shdr->sh_info, &sym_mem)->st_name)
-+        (sym == NULL ? NULL
-+         : elf_strptr (ebl->elf, symshdr->sh_link, sym->st_name))
-         ?: gettext ("<INVALID SYMBOL>"),
-         data->d_size / sizeof (Elf32_Word) - 1);
+       if (unlikely (result == 0) && ehdr.e32->e_shoff != 0)
+       {
+-        if (ehdr.e32->e_shoff + sizeof (Elf32_Shdr) > maxsize)
++        if (unlikely (ehdr.e32->e_shoff >= maxsize)
++            || unlikely (ehdr.e32->e_shoff + sizeof (Elf32_Shdr) > maxsize))
+           /* Cannot read the first section header.  */
+           return 0;
  
-@@ -1122,7 +1124,8 @@ static void
- handle_dynamic (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr)
- {
-   int class = gelf_getclass (ebl->elf);
--  GElf_Shdr glink;
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink;
-   Elf_Data *data;
-   size_t cnt;
-   size_t shstrndx;
-@@ -1137,6 +1140,11 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, 
-     error (EXIT_FAILURE, 0,
-          gettext ("cannot get section header string table index"));
+@@ -203,7 +204,8 @@ get_shnum (void *map_address, unsigned c
  
-+  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
-+  if (glink == NULL)
-+    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
-+         elf_ndxscn (scn));
-+
-   printf (ngettext ("\
- \nDynamic segment contains %lu entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
-                   "\
-@@ -1146,9 +1154,7 @@ handle_dynamic (Ebl *ebl, Elf_Scn *scn, 
-         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
-         shdr->sh_offset,
-         (int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
-   fputs_unlocked (gettext ("  Type              Value\n"), stdout);
+       if (unlikely (result == 0) && ehdr.e64->e_shoff != 0)
+       {
+-        if (ehdr.e64->e_shoff + sizeof (Elf64_Shdr) > maxsize)
++        if (unlikely (ehdr.e64->e_shoff >= maxsize)
++            || unlikely (ehdr.e64->e_shoff + sizeof (Elf64_Shdr) > maxsize))
+           /* Cannot read the first section header.  */
+           return 0;
  
-   for (cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
-@@ -1666,6 +1672,13 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, G
-     error (EXIT_FAILURE, 0,
-          gettext ("cannot get section header string table index"));
+@@ -275,6 +277,15 @@ file_read_elf (int fildes, void *map_add
+     /* Could not determine the number of sections.  */
+     return NULL;
  
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
-+                                 &glink_mem);
-+  if (glink == NULL)
-+    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
-+         elf_ndxscn (scn));
++  /* Check for too many sections.  */
++  if (e_ident[EI_CLASS] == ELFCLASS32)
++    {
++      if (scncnt > SIZE_MAX / (sizeof (Elf_Scn) + sizeof (Elf32_Shdr)))
++      return NULL;
++    }
++  else if (scncnt > SIZE_MAX / (sizeof (Elf_Scn) + sizeof (Elf64_Shdr)))
++    return NULL;
 +
-   /* Now we can compute the number of entries in the section.  */
-   unsigned int nsyms = data->d_size / (class == ELFCLASS32
-                                      ? sizeof (Elf32_Sym)
-@@ -1676,15 +1689,12 @@ handle_symtab (Ebl *ebl, Elf_Scn *scn, G
-                   nsyms),
-         (unsigned int) elf_ndxscn (scn),
-         elf_strptr (ebl->elf, shstrndx, shdr->sh_name), nsyms);
--  GElf_Shdr glink;
-   printf (ngettext (" %lu local symbol  String table: [%2u] '%s'\n",
-                   " %lu local symbols  String table: [%2u] '%s'\n",
-                   shdr->sh_info),
-         (unsigned long int) shdr->sh_info,
-         (unsigned int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
-   fputs_unlocked (class == ELFCLASS32
-                 ? gettext ("\
-@@ -1920,7 +1930,13 @@ handle_verneed (Ebl *ebl, Elf_Scn *scn, 
-     error (EXIT_FAILURE, 0,
-          gettext ("cannot get section header string table index"));
+   /* We can now allocate the memory.  */
+   Elf *elf = allocate_elf (fildes, map_address, offset, maxsize, cmd, parent,
+                          ELF_K_ELF, scncnt * sizeof (Elf_Scn));
+@@ -308,13 +319,31 @@ file_read_elf (int fildes, void *map_add
+       {
+         /* We can use the mmapped memory.  */
+         elf->state.elf32.ehdr = ehdr;
++
++        if (unlikely (ehdr->e_shoff >= maxsize)
++            || unlikely (ehdr->e_shoff
++                         + scncnt * sizeof (Elf32_Shdr) > maxsize))
++          {
++          free_and_out:
++            free (elf);
++            __libelf_seterrno (ELF_E_INVALID_FILE);
++            return NULL;
++          }
+         elf->state.elf32.shdr
+           = (Elf32_Shdr *) ((char *) ehdr + ehdr->e_shoff);
++
+         if (ehdr->e_phnum > 0)
++          {
+           /* Assign a value only if there really is a program
+              header.  Otherwise the value remains NULL.  */
++            if (unlikely (ehdr->e_phoff >= maxsize)
++                || unlikely (ehdr->e_phoff
++                             + ehdr->e_phnum
++                             * sizeof (Elf32_Phdr) > maxsize))
++              goto free_and_out;
+           elf->state.elf32.phdr
+             = (Elf32_Phdr *) ((char *) ehdr + ehdr->e_phoff);
++          }
  
--  GElf_Shdr glink;
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
-+                                 &glink_mem);
-+  if (glink == NULL)
-+    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
-+         elf_ndxscn (scn));
+         for (size_t cnt = 0; cnt < scncnt; ++cnt)
+           {
+@@ -383,13 +412,26 @@ file_read_elf (int fildes, void *map_add
+       {
+         /* We can use the mmapped memory.  */
+         elf->state.elf64.ehdr = ehdr;
 +
-   printf (ngettext ("\
- \nVersion needs section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
-                   "\
-@@ -1931,9 +1947,7 @@ handle_verneed (Ebl *ebl, Elf_Scn *scn, 
-         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
-         shdr->sh_offset,
-         (unsigned int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
++        if (unlikely (ehdr->e_shoff >= maxsize)
++            || unlikely (ehdr->e_shoff
++                         + scncnt * sizeof (Elf32_Shdr) > maxsize))
++          goto free_and_out;
+         elf->state.elf64.shdr
+           = (Elf64_Shdr *) ((char *) ehdr + ehdr->e_shoff);
++
+         if (ehdr->e_phnum > 0)
++          {
+           /* Assign a value only if there really is a program
+              header.  Otherwise the value remains NULL.  */
++            if (unlikely (ehdr->e_phoff >= maxsize)
++                || unlikely (ehdr->e_phoff
++                             + ehdr->e_phnum
++                             * sizeof (Elf32_Phdr) > maxsize))
++              goto free_and_out;
+           elf->state.elf64.phdr
+             = (Elf64_Phdr *) ((char *) ehdr + ehdr->e_phoff);
++          }
  
-   unsigned int offset = 0;
-   for (int cnt = shdr->sh_info; --cnt >= 0; )
-@@ -1986,8 +2000,14 @@ handle_verdef (Ebl *ebl, Elf_Scn *scn, G
-     error (EXIT_FAILURE, 0,
-          gettext ("cannot get section header string table index"));
+         for (size_t cnt = 0; cnt < scncnt; ++cnt)
+           {
+--- elfutils-0.127/libelf/libelfP.h.robustify
++++ elfutils-0.127/libelf/libelfP.h
+@@ -574,4 +574,13 @@ extern uint32_t __libelf_crc32 (uint32_t
+       }                                                                             \
+   } while (0)
  
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
-+                                 &glink_mem);
-+  if (glink == NULL)
-+    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
-+         elf_ndxscn (scn));
++/* Convenience macro.  Assumes int NDX and TYPE with size at least
++   2 bytes.  */
++#if SIZE_MAX > 4294967295U
++# define INVALID_NDX(ndx, type) unlikely (ndx < 0)
++#else
++# define INVALID_NDX(ndx, type) \
++  unlikely ((unsigned int) (ndx) >= SIZE_MAX / sizeof (type))
++#endif
 +
-   int class = gelf_getclass (ebl->elf);
--  GElf_Shdr glink;
-   printf (ngettext ("\
- \nVersion definition section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
-                   "\
-@@ -1999,9 +2019,7 @@ handle_verdef (Ebl *ebl, Elf_Scn *scn, G
-         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
-         shdr->sh_offset,
-         (unsigned int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
+ #endif  /* libelfP.h */
+--- elfutils-0.127/libelf/gelf_update_move.c.robustify
++++ elfutils-0.127/libelf/gelf_update_move.c
+@@ -75,7 +75,7 @@ gelf_update_move (data, ndx, src)
+   assert (sizeof (GElf_Move) == sizeof (Elf64_Move));
  
-   unsigned int offset = 0;
-   for (int cnt = shdr->sh_info; --cnt >= 0; )
-@@ -2263,8 +2281,14 @@ handle_versym (Ebl *ebl, Elf_Scn *scn, G
-       filename = NULL;
-     }
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
-+                                 &glink_mem);
-+  if (glink == NULL)
-+    error (EXIT_FAILURE, 0, gettext ("invalid sh_link value in section %Zu"),
-+         elf_ndxscn (scn));
-+
-   /* Print the header.  */
--  GElf_Shdr glink;
-   printf (ngettext ("\
- \nVersion symbols section [%2u] '%s' contains %d entry:\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'",
-                   "\
-@@ -2276,9 +2300,7 @@ handle_versym (Ebl *ebl, Elf_Scn *scn, G
-         class == ELFCLASS32 ? 10 : 18, shdr->sh_addr,
-         shdr->sh_offset,
-         (unsigned int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
-   /* Now we can finally look at the actual contents of this section.  */
-   for (unsigned int cnt = 0; cnt < shdr->sh_size / shdr->sh_entsize; ++cnt)
-@@ -2330,7 +2352,17 @@ print_hash_info (Ebl *ebl, Elf_Scn *scn,
-   for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
-     ++counts[lengths[cnt]];
--  GElf_Shdr glink;
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink = gelf_getshdr (elf_getscn (ebl->elf,
-+                                             shdr->sh_link),
-+                                 &glink_mem);
-+  if (glink == NULL)
-+    {
-+      error (0, 0, gettext ("invalid sh_link value in section %Zu"),
-+           elf_ndxscn (scn));
-+      return;
-+    }
-+
-   printf (ngettext ("\
- \nHistogram for bucket list length in section [%2u] '%s' (total of %d bucket):\n Addr: %#0*" PRIx64 "  Offset: %#08" PRIx64 "  Link to section: [%2u] '%s'\n",
-                   "\
-@@ -2343,9 +2375,7 @@ print_hash_info (Ebl *ebl, Elf_Scn *scn,
-         shdr->sh_addr,
-         shdr->sh_offset,
-         (unsigned int) shdr->sh_link,
--        elf_strptr (ebl->elf, shstrndx,
--                    gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link),
--                                  &glink)->sh_name));
-+        elf_strptr (ebl->elf, shstrndx, glink->sh_name));
-   if (extrastr != NULL)
-     fputs (extrastr, stdout);
-@@ -3654,6 +3684,16 @@ print_debug_aranges_section (Ebl *ebl __
-       return;
-     }
-+  GElf_Shdr glink_mem;
-+  GElf_Shdr *glink;
-+  glink = gelf_getshdr (elf_getscn (ebl->elf, shdr->sh_link), &glink_mem);
-+  if (glink == NULL)
-+    {
-+      error (0, 0, gettext ("invalid sh_link value in section %Zu"),
-+           elf_ndxscn (scn));
-+      return;
-+    }
-+
-   printf (ngettext ("\
- \nDWARF section '%s' at offset %#" PRIx64 " contains %zu entry:\n",
-                   "\
---- elfutils-0.122/src/strip.c
-+++ elfutils-0.122/src/strip.c
-@@ -412,6 +412,7 @@ handle_elf (int fd, Elf *elf, const char
-   Elf_Data debuglink_crc_data;
-   bool any_symtab_changes = false;
-   Elf_Data *shstrtab_data = NULL;
-+  size_t shdridx = 0;
-   /* Create the full name of the file.  */
-   if (prefix != NULL)
-@@ -542,6 +543,11 @@ handle_elf (int fd, Elf *elf, const char
-       goto fail_close;
-     }
-+  if (shstrndx >= shnum)
-+    goto illformed;
-+
-+#define elf_assert(test) do { if (!(test)) goto illformed; } while (0)
-+
-   /* Storage for section information.  We leave room for two more
-      entries since we unconditionally create a section header string
-      table.  Maybe some weird tool created an ELF file without one.
-@@ -563,7 +569,7 @@ handle_elf (int fd, Elf *elf, const char
+   /* Check whether we have to resize the data buffer.  */
+-  if (unlikely (ndx < 0)
++  if (INVALID_NDX (ndx, GElf_Move)
+       || unlikely ((ndx + 1) * sizeof (GElf_Move) > data_scn->d.d_size))
      {
-       /* This should always be true (i.e., there should not be any
-        holes in the numbering).  */
--      assert (elf_ndxscn (scn) == cnt);
-+      elf_assert (elf_ndxscn (scn) == cnt);
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+--- elfutils-0.127/libelf/gelf_getsym.c.robustify
++++ elfutils-0.127/libelf/gelf_getsym.c
+@@ -90,7 +90,8 @@ gelf_getsym (data, ndx, dst)
+        table entries has to be adopted.  The user better has provided
+        a buffer where we can store the information.  While copying the
+        data we are converting the format.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data->d_size))
++      if (INVALID_NDX (ndx, Elf32_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data->d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -119,7 +120,8 @@ gelf_getsym (data, ndx, dst)
  
-       shdr_info[cnt].scn = scn;
+       /* The data is already in the correct form.  Just make sure the
+        index is OK.  */
+-      if (unlikely ((ndx + 1) * sizeof (GElf_Sym) > data->d_size))
++      if (INVALID_NDX (ndx, GElf_Sym)
++        || unlikely ((ndx + 1) * sizeof (GElf_Sym) > data->d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_getrela.c.robustify
++++ elfutils-0.127/libelf/gelf_getrela.c
+@@ -71,12 +71,6 @@ gelf_getrela (data, ndx, dst)
+   if (data_scn == NULL)
+     return NULL;
  
-@@ -576,6 +582,7 @@ handle_elf (int fd, Elf *elf, const char
-                                       shdr_info[cnt].shdr.sh_name);
-       if (shdr_info[cnt].name == NULL)
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return NULL;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_RELA))
+     {
+       __libelf_seterrno (ELF_E_INVALID_HANDLE);
+@@ -93,7 +87,8 @@ gelf_getrela (data, ndx, dst)
+   if (scn->elf->class == ELFCLASS32)
+     {
+       /* We have to convert the data.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Rela)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
        {
-+      illformed:
-         error (0, 0, gettext ("illformed file '%s'"), fname);
-         goto fail_close;
-       }
-@@ -585,6 +592,8 @@ handle_elf (int fd, Elf *elf, const char
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         result = NULL;
+@@ -114,7 +109,8 @@ gelf_getrela (data, ndx, dst)
+     {
+       /* Simply copy the data after we made sure we are actually getting
+        correct data.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Rela)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         result = NULL;
+--- elfutils-0.127/libelf/gelf_getmove.c.robustify
++++ elfutils-0.127/libelf/gelf_getmove.c
+@@ -83,7 +83,8 @@ gelf_getmove (data, ndx, dst)
  
-       /* Remember the shdr.sh_link value.  */
-       shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link;
-+      if (shdr_info[cnt].old_sh_link >= shnum)
-+      goto illformed;
+   /* The data is already in the correct form.  Just make sure the
+      index is OK.  */
+-  if (unlikely ((ndx + 1) * sizeof (GElf_Move) > data->d_size))
++  if (INVALID_NDX (ndx, GElf_Move)
++      || unlikely ((ndx + 1) * sizeof (GElf_Move) > data->d_size))
+     {
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+       goto out;
+--- elfutils-0.127/libelf/gelf_update_symshndx.c.robustify
++++ elfutils-0.127/libelf/gelf_update_symshndx.c
+@@ -77,12 +77,6 @@ gelf_update_symshndx (symdata, shndxdata
+   if (symdata == NULL)
+     return 0;
  
-       /* Sections in files other than relocatable object files which
-        are not loaded can be freely moved by us.  In relocatable
-@@ -597,7 +606,7 @@ handle_elf (int fd, Elf *elf, const char
-        appropriate reference.  */
-       if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX))
-       {
--        assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
-+        elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
-         shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt;
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (symdata_scn->d.d_type != ELF_T_SYM))
+     {
+       /* The type of the data better should match.  */
+@@ -128,7 +122,8 @@ gelf_update_symshndx (symdata, shndxdata
        }
-       else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP))
-@@ -614,7 +623,12 @@ handle_elf (int fd, Elf *elf, const char
-         for (inner = 1;
-              inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
-              ++inner)
-+          {
-+            if (grpref[inner] < shnum)
-           shdr_info[grpref[inner]].group_idx = cnt;
-+            else
-+              goto illformed;
-+          }
  
-         if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0))
-           /* If the section group contains only one element and this
-@@ -625,7 +639,7 @@ handle_elf (int fd, Elf *elf, const char
-       }
-       else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym))
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata_scn->d.d_size))
        {
--        assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
-+        elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
-         shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt;
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -151,7 +146,8 @@ gelf_update_symshndx (symdata, shndxdata
+   else
+     {
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Sym) > symdata_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Sym) > symdata_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_update_dyn.c.robustify
++++ elfutils-0.127/libelf/gelf_update_dyn.c
+@@ -71,12 +71,6 @@ gelf_update_dyn (data, ndx, src)
+   if (data == NULL)
+     return 0;
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_DYN))
+     {
+       /* The type of the data better should match.  */
+@@ -102,7 +96,8 @@ gelf_update_dyn (data, ndx, src)
        }
  
-@@ -633,7 +647,7 @@ handle_elf (int fd, Elf *elf, const char
-        discarded right away.  */
-       if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0)
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Dyn)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
        {
--        assert (shdr_info[cnt].group_idx != 0);
-+        elf_assert (shdr_info[cnt].group_idx != 0);
-         if (shdr_info[shdr_info[cnt].group_idx].idx == 0)
-           {
-@@ -708,11 +722,15 @@ handle_elf (int fd, Elf *elf, const char
-           {
-             /* If a relocation section is marked as being removed make
-                sure the section it is relocating is removed, too.  */
--            if ((shdr_info[cnt].shdr.sh_type == SHT_REL
-+            if (shdr_info[cnt].shdr.sh_type == SHT_REL
-                  || shdr_info[cnt].shdr.sh_type == SHT_RELA)
--                && shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
-+              {
-+                if (shdr_info[cnt].shdr.sh_info >= shnum)
-+                  goto illformed;
-+                else if (shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
-               shdr_info[cnt].idx = 1;
-           }
-+          }
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -116,7 +111,8 @@ gelf_update_dyn (data, ndx, src)
+   else
+     {
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Dyn) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Dyn)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Dyn) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_update_rela.c.robustify
++++ elfutils-0.127/libelf/gelf_update_rela.c
+@@ -68,12 +68,6 @@ gelf_update_rela (Elf_Data *dst, int ndx
+   if (dst == NULL)
+     return 0;
  
-         if (shdr_info[cnt].idx == 1)
-           {
-@@ -737,7 +755,7 @@ handle_elf (int fd, Elf *elf, const char
-                 if (shdr_info[cnt].symtab_idx != 0
-                     && shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
-                   {
--                    assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
-+                    elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_RELA))
+     {
+       /* The type of the data better should match.  */
+@@ -101,7 +95,8 @@ gelf_update_rela (Elf_Data *dst, int ndx
+       }
  
-                     shdr_info[shdr_info[cnt].symtab_idx].data
-                       = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
-@@ -777,6 +795,9 @@ handle_elf (int fd, Elf *elf, const char
-                     else if (scnidx == SHN_XINDEX)
-                       scnidx = xndx;
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Rela)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Rela) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -117,7 +112,8 @@ gelf_update_rela (Elf_Data *dst, int ndx
+   else
+     {
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Rela)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Rela) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_getsymshndx.c.robustify
++++ elfutils-0.127/libelf/gelf_getsymshndx.c
+@@ -90,7 +90,9 @@ gelf_getsymshndx (symdata, shndxdata, nd
+      section index table.  */
+   if (likely (shndxdata_scn != NULL))
+     {
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Word) > shndxdata_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Word)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Word)
++                     > shndxdata_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -110,7 +112,8 @@ gelf_getsymshndx (symdata, shndxdata, nd
+        table entries has to be adopted.  The user better has provided
+        a buffer where we can store the information.  While copying the
+        data we are converting the format.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata->d_size))
++      if (INVALID_NDX (ndx, Elf32_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > symdata->d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -139,7 +142,8 @@ gelf_getsymshndx (symdata, shndxdata, nd
  
-+                    if (scnidx >= shnum)
-+                      goto illformed;
+       /* The data is already in the correct form.  Just make sure the
+        index is OK.  */
+-      if (unlikely ((ndx + 1) * sizeof (GElf_Sym) > symdata->d_size))
++      if (INVALID_NDX (ndx, GElf_Sym)
++        || unlikely ((ndx + 1) * sizeof (GElf_Sym) > symdata->d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/elf32_newphdr.c.robustify
++++ elfutils-0.127/libelf/elf32_newphdr.c
+@@ -124,6 +124,12 @@ elfw2(LIBELFBITS,newphdr) (elf, count)
+   else if (elf->state.ELFW(elf,LIBELFBITS).ehdr->e_phnum != count
+          || elf->state.ELFW(elf,LIBELFBITS).phdr == NULL)
+     {
++      if (unlikely (count > SIZE_MAX / sizeof (ElfW2(LIBELFBITS,Phdr))))
++      {
++        result = NULL;
++        goto out;
++      }
 +
-                     if (shdr_info[scnidx].idx == 0)
-                       {
-                         /* Mark this section as used.  */
-@@ -808,12 +829,16 @@ handle_elf (int fd, Elf *elf, const char
-               }
-             /* Handle references through sh_info.  */
--            if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)
--                && shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
-+            if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
-+              {
-+                if (shdr_info[cnt].shdr.sh_info >= shnum)
-+                  goto illformed;
-+                else if ( shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
-               {
-                 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
-                 changes |= shdr_info[cnt].shdr.sh_info < cnt;
-               }
-+              }
-             /* Mark the section as investigated.  */
-             shdr_info[cnt].idx = 2;
-@@ -912,7 +937,7 @@ handle_elf (int fd, Elf *elf, const char
-         error (EXIT_FAILURE, 0, gettext ("while generating output file: %s"),
-                elf_errmsg (-1));
--      assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
-+      elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
+       /* Allocate a new program header with the appropriate number of
+        elements.  */
+       result = (ElfW2(LIBELFBITS,Phdr) *)
+--- elfutils-0.127/libelf/gelf_update_sym.c.robustify
++++ elfutils-0.127/libelf/gelf_update_sym.c
+@@ -72,12 +72,6 @@ gelf_update_sym (data, ndx, src)
+   if (data == NULL)
+     return 0;
  
-       /* Add this name to the section header string table.  */
-       shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0);
-@@ -949,7 +974,7 @@ handle_elf (int fd, Elf *elf, const char
-       error (EXIT_FAILURE, 0,
-              gettext ("while create section header section: %s"),
-              elf_errmsg (-1));
--      assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
-+      elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_SYM))
+     {
+       /* The type of the data better should match.  */
+@@ -102,7 +96,8 @@ gelf_update_sym (data, ndx, src)
+       }
  
-       shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn);
-       if (shdr_info[cnt].data == NULL)
-@@ -980,7 +1005,7 @@ handle_elf (int fd, Elf *elf, const char
-     }
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Sym) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -125,7 +120,8 @@ gelf_update_sym (data, ndx, src)
+   else
+     {
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Sym) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Sym)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Sym) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_getsyminfo.c.robustify
++++ elfutils-0.127/libelf/gelf_getsyminfo.c
+@@ -84,7 +84,8 @@ gelf_getsyminfo (data, ndx, dst)
  
-   /* Index of the section header table in the shdr_info array.  */
--  size_t shdridx = cnt;
-+  shdridx = cnt;
+   /* The data is already in the correct form.  Just make sure the
+      index is OK.  */
+-  if (unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data->d_size))
++  if (INVALID_NDX (ndx, GElf_Syminfo)
++      || unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data->d_size))
+     {
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+       goto out;
+--- elfutils-0.127/libelf/gelf_getlib.c.robustify
++++ elfutils-0.127/libelf/gelf_getlib.c
+@@ -86,7 +86,8 @@ gelf_getlib (data, ndx, dst)
+   /* The data is already in the correct form.  Just make sure the
+      index is OK.  */
+   GElf_Lib *result = NULL;
+-  if (unlikely ((ndx + 1) * sizeof (GElf_Lib) > data->d_size))
++  if (INVALID_NDX (ndx, GElf_Lib)
++      || unlikely ((ndx + 1) * sizeof (GElf_Lib) > data->d_size))
+     __libelf_seterrno (ELF_E_INVALID_INDEX);
+   else
+     {
+--- elfutils-0.127/libelf/elf32_updatefile.c.robustify
++++ elfutils-0.127/libelf/elf32_updatefile.c
+@@ -201,6 +201,9 @@ __elfw2(LIBELFBITS,updatemmap) (Elf *elf
+   /* Write all the sections.  Well, only those which are modified.  */
+   if (shnum > 0)
+     {
++      if (unlikely (shnum > SIZE_MAX / sizeof (Elf_Scn *)))
++      return 1;
++
+       Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
+       Elf_Scn **scns = (Elf_Scn **) alloca (shnum * sizeof (Elf_Scn *));
+       char *const shdr_start = ((char *) elf->map_address + elf->start_offset
+@@ -571,6 +574,10 @@ __elfw2(LIBELFBITS,updatefile) (Elf *elf
+   /* Write all the sections.  Well, only those which are modified.  */
+   if (shnum > 0)
+     {
++      if (unlikely (shnum > SIZE_MAX / (sizeof (Elf_Scn *)
++                                      + sizeof (ElfW2(LIBELFBITS,Shdr)))))
++      return 1;
++
+       off_t shdr_offset = elf->start_offset + ehdr->e_shoff;
+ #if EV_NUM != 2
+       xfct_t shdr_fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR];
+--- elfutils-0.127/libelf/gelf_getversym.c.robustify
++++ elfutils-0.127/libelf/gelf_getversym.c
+@@ -92,7 +92,8 @@ gelf_getversym (data, ndx, dst)
  
-   /* Add the section header string table section name.  */
-   shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10);
-@@ -1005,7 +1030,7 @@ handle_elf (int fd, Elf *elf, const char
-     error (EXIT_FAILURE, 0,
-          gettext ("while create section header section: %s"),
-          elf_errmsg (-1));
--  assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
-+  elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
+   /* The data is already in the correct form.  Just make sure the
+      index is OK.  */
+-  if (unlikely ((ndx + 1) * sizeof (GElf_Versym) > data->d_size))
++  if (INVALID_NDX (ndx, GElf_Versym)
++      || unlikely ((ndx + 1) * sizeof (GElf_Versym) > data->d_size))
+     {
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+       result = NULL;
+--- elfutils-0.127/libelf/elf_getarsym.c.robustify
++++ elfutils-0.127/libelf/elf_getarsym.c
+@@ -179,6 +179,9 @@ elf_getarsym (elf, ptr)
+       size_t index_size = atol (tmpbuf);
  
-   /* Finalize the string table and fill in the correct indices in the
-      section headers.  */
-@@ -1095,20 +1120,20 @@ handle_elf (int fd, Elf *elf, const char
-                   shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
-                                            NULL);
+       if (SARMAG + sizeof (struct ar_hdr) + index_size > elf->maximum_size
++#if SIZE_MAX <= 4294967295U
++        || n >= SIZE_MAX / sizeof (Elf_Arsym)
++#endif
+         || n * sizeof (uint32_t) > index_size)
+       {
+         /* This index table cannot be right since it does not fit into
+--- elfutils-0.127/libelf/gelf_getrel.c.robustify
++++ elfutils-0.127/libelf/gelf_getrel.c
+@@ -71,12 +71,6 @@ gelf_getrel (data, ndx, dst)
+   if (data_scn == NULL)
+     return NULL;
  
--                  assert ((versiondata->d_size / sizeof (Elf32_Word))
-+                  elf_assert ((versiondata->d_size / sizeof (Elf32_Word))
-                           >= shdr_info[cnt].data->d_size / elsize);
-                 }
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return NULL;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_REL))
+     {
+       __libelf_seterrno (ELF_E_INVALID_HANDLE);
+@@ -93,7 +87,8 @@ gelf_getrel (data, ndx, dst)
+   if (scn->elf->class == ELFCLASS32)
+     {
+       /* We have to convert the data.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Rel)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         result = NULL;
+@@ -113,7 +108,8 @@ gelf_getrel (data, ndx, dst)
+     {
+       /* Simply copy the data after we made sure we are actually getting
+        correct data.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Rel)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         result = NULL;
+--- elfutils-0.127/libelf/gelf_update_versym.c.robustify
++++ elfutils-0.127/libelf/gelf_update_versym.c
+@@ -75,7 +75,7 @@ gelf_update_versym (data, ndx, src)
+   assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
  
-               if (shdr_info[cnt].version_idx != 0)
-                 {
--                  assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
-+                  elf_assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
-                   /* This section has associated version
-                      information.  We have to modify that
-                      information, too.  */
-                   versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn,
-                                              NULL);
+   /* Check whether we have to resize the data buffer.  */
+-  if (unlikely (ndx < 0)
++  if (INVALID_NDX (ndx, GElf_Versym)
+       || unlikely ((ndx + 1) * sizeof (GElf_Versym) > data_scn->d.d_size))
+     {
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+--- elfutils-0.127/libelf/gelf_getdyn.c.robustify
++++ elfutils-0.127/libelf/gelf_getdyn.c
+@@ -93,7 +93,8 @@ gelf_getdyn (data, ndx, dst)
+        table entries has to be adopted.  The user better has provided
+        a buffer where we can store the information.  While copying the
+        data we are converting the format.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Dyn)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Dyn) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -114,7 +115,8 @@ gelf_getdyn (data, ndx, dst)
  
--                  assert ((versiondata->d_size / sizeof (GElf_Versym))
-+                  elf_assert ((versiondata->d_size / sizeof (GElf_Versym))
-                           >= shdr_info[cnt].data->d_size / elsize);
-                 }
+       /* The data is already in the correct form.  Just make sure the
+        index is OK.  */
+-      if (unlikely ((ndx + 1) * sizeof (GElf_Dyn) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, GElf_Dyn)
++        || unlikely ((ndx + 1) * sizeof (GElf_Dyn) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/gelf_update_syminfo.c.robustify
++++ elfutils-0.127/libelf/gelf_update_syminfo.c
+@@ -72,12 +72,6 @@ gelf_update_syminfo (data, ndx, src)
+   if (data == NULL)
+     return 0;
  
-@@ -1163,7 +1188,7 @@ handle_elf (int fd, Elf *elf, const char
-                     sec = shdr_info[sym->st_shndx].idx;
-                   else
-                     {
--                      assert (shndxdata != NULL);
-+                      elf_assert (shndxdata != NULL);
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_SYMINFO))
+     {
+       /* The type of the data better should match.  */
+@@ -93,7 +87,8 @@ gelf_update_syminfo (data, ndx, src)
+   rwlock_wrlock (scn->elf->lock);
  
-                       sec = shdr_info[xshndx].idx;
-                     }
-@@ -1184,7 +1209,7 @@ handle_elf (int fd, Elf *elf, const char
-                           nxshndx = sec;
-                         }
+   /* Check whether we have to resize the data buffer.  */
+-  if (unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data_scn->d.d_size))
++  if (INVALID_NDX (ndx, GElf_Syminfo)
++      || unlikely ((ndx + 1) * sizeof (GElf_Syminfo) > data_scn->d.d_size))
+     {
+       __libelf_seterrno (ELF_E_INVALID_INDEX);
+       goto out;
+--- elfutils-0.127/libelf/gelf_update_rel.c.robustify
++++ elfutils-0.127/libelf/gelf_update_rel.c
+@@ -68,12 +68,6 @@ gelf_update_rel (Elf_Data *dst, int ndx,
+   if (dst == NULL)
+     return 0;
  
--                      assert (sec < SHN_LORESERVE || shndxdata != NULL);
-+                      elf_assert (sec < SHN_LORESERVE || shndxdata != NULL);
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   if (unlikely (data_scn->d.d_type != ELF_T_REL))
+     {
+       /* The type of the data better should match.  */
+@@ -99,7 +93,8 @@ gelf_update_rel (Elf_Data *dst, int ndx,
+       }
  
-                       if ((inner != destidx || nshndx != sym->st_shndx
-                            || (shndxdata != NULL && nxshndx != xshndx))
-@@ -1207,7 +1232,7 @@ handle_elf (int fd, Elf *elf, const char
-                   else
-                     /* This is a section symbol for a section which has
-                        been removed.  */
--                    assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION);
-+                    elf_assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION);
-                 }
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf32_Rel)
++        || unlikely ((ndx + 1) * sizeof (Elf32_Rel) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+@@ -114,7 +109,8 @@ gelf_update_rel (Elf_Data *dst, int ndx,
+   else
+     {
+       /* Check whether we have to resize the data buffer.  */
+-      if (unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
++      if (INVALID_NDX (ndx, Elf64_Rel)
++        || unlikely ((ndx + 1) * sizeof (Elf64_Rel) > data_scn->d.d_size))
+       {
+         __libelf_seterrno (ELF_E_INVALID_INDEX);
+         goto out;
+--- elfutils-0.127/libelf/elf_newscn.c.robustify
++++ elfutils-0.127/libelf/elf_newscn.c
+@@ -104,10 +104,18 @@ elf_newscn (elf)
+   else
+     {
+       /* We must allocate a new element.  */
+-      Elf_ScnList *newp;
++      Elf_ScnList *newp = NULL;
  
-               if (destidx != inner)
-@@ -1371,11 +1396,11 @@ handle_elf (int fd, Elf *elf, const char
-                   {
-                     GElf_Sym sym_mem;
-                     GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
--                    assert (sym != NULL);
-+                    elf_assert (sym != NULL);
+       assert (elf->state.elf.scnincr > 0);
  
-                     const char *name = elf_strptr (elf, strshndx,
-                                                    sym->st_name);
--                    assert (name != NULL);
-+                    elf_assert (name != NULL);
-                     size_t hidx = elf_hash (name) % nbucket;
++      if (
++#if SIZE_MAX <= 4294967295U
++        likely (elf->state.elf.scnincr
++                < SIZE_MAX / 2 / sizeof (Elf_Scn) - sizeof (Elf_ScnList))
++#else
++        1
++#endif
++        )
+       newp = (Elf_ScnList *) calloc (sizeof (Elf_ScnList)
+                                    + ((elf->state.elf.scnincr *= 2)
+                                       * sizeof (Elf_Scn)), 1);
+--- elfutils-0.127/libelf/gelf_update_lib.c.robustify
++++ elfutils-0.127/libelf/gelf_update_lib.c
+@@ -68,12 +68,6 @@ gelf_update_lib (data, ndx, src)
+   if (data == NULL)
+     return 0;
  
-                     if (bucket[hidx] == 0)
-@@ -1394,7 +1419,7 @@ handle_elf (int fd, Elf *elf, const char
+-  if (unlikely (ndx < 0))
+-    {
+-      __libelf_seterrno (ELF_E_INVALID_INDEX);
+-      return 0;
+-    }
+-
+   Elf_Data_Scn *data_scn = (Elf_Data_Scn *) data;
+   if (unlikely (data_scn->d.d_type != ELF_T_LIB))
+     {
+@@ -87,7 +81,8 @@ gelf_update_lib (data, ndx, src)
+   /* Check whether we have to resize the data buffer.  */
+   int result = 0;
+-  if (unlikely ((ndx + 1) * sizeof (Elf64_Lib) > data_scn->d.d_size))
++  if (INVALID_NDX (ndx, Elf64_Lib)
++      || unlikely ((ndx + 1) * sizeof (Elf64_Lib) > data_scn->d.d_size))
+     __libelf_seterrno (ELF_E_INVALID_INDEX);
+   else
+     {
+--- elfutils-0.127/libelf/elf_getshstrndx.c.robustify
++++ elfutils-0.127/libelf/elf_getshstrndx.c
+@@ -125,10 +125,25 @@ elf_getshstrndx (elf, dst)
+             if (elf->map_address != NULL
+                 && elf->state.elf32.ehdr->e_ident[EI_DATA] == MY_ELFDATA
+                 && (ALLOW_UNALIGNED
+-                    || (((size_t) ((char *) elf->map_address + offset))
++                    || (((size_t) ((char *) elf->map_address
++                         + elf->start_offset + offset))
+                         & (__alignof__ (Elf32_Shdr) - 1)) == 0))
++              {
++                /* First see whether the information in the ELF header is
++                   valid and it does not ask for too much.  */
++                if (unlikely (offset + sizeof (Elf32_Shdr)
++                              > elf->maximum_size))
++                  {
++                    /* Something is wrong.  */
++                    __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
++                    result = -1;
++                    goto out;
++                  }
++
+               /* We can directly access the memory.  */
+-              num = ((Elf32_Shdr *) (elf->map_address + offset))->sh_link;
++                num = ((Elf32_Shdr *) (elf->map_address + elf->start_offset
++                                       + offset))->sh_link;
++              }
              else
                {
-                 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries.  */
--                assert (shdr_info[cnt].shdr.sh_entsize
-+                elf_assert (shdr_info[cnt].shdr.sh_entsize
-                         == sizeof (Elf64_Xword));
+                 /* We avoid reading in all the section headers.  Just read
+@@ -163,10 +178,25 @@ elf_getshstrndx (elf, dst)
+             if (elf->map_address != NULL
+                 && elf->state.elf64.ehdr->e_ident[EI_DATA] == MY_ELFDATA
+                 && (ALLOW_UNALIGNED
+-                    || (((size_t) ((char *) elf->map_address + offset))
++                    || (((size_t) ((char *) elf->map_address
++                         + elf->start_offset + offset))
+                         & (__alignof__ (Elf64_Shdr) - 1)) == 0))
++              {
++                /* First see whether the information in the ELF header is
++                   valid and it does not ask for too much.  */
++                if (unlikely (offset + sizeof (Elf64_Shdr)
++                              > elf->maximum_size))
++                  {
++                    /* Something is wrong.  */
++                    __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
++                    result = -1;
++                    goto out;
++                  }
++
+               /* We can directly access the memory.  */
+-              num = ((Elf64_Shdr *) (elf->map_address + offset))->sh_link;
++                num = ((Elf64_Shdr *) (elf->map_address
++                       + elf->start_offset + offset))->sh_link;
++              }
+             else
+               {
+                 /* We avoid reading in all the section headers.  Just read
+--- elfutils-0.127/libelf/elf32_getshdr.c.robustify
++++ elfutils-0.127/libelf/elf32_getshdr.c
+@@ -101,7 +101,8 @@ elfw2(LIBELFBITS,getshdr) (scn)
+       goto out;
  
-                 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf;
-@@ -1428,11 +1453,11 @@ handle_elf (int fd, Elf *elf, const char
-                   {
-                     GElf_Sym sym_mem;
-                     GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
--                    assert (sym != NULL);
-+                    elf_assert (sym != NULL);
+       size_t shnum;
+-      if (INTUSE (elf_getshnum) (elf, &shnum) != 0)
++      if (INTUSE (elf_getshnum) (elf, &shnum) != 0
++        || shnum > SIZE_MAX / sizeof (ElfW2(LIBELFBITS,Shdr)))
+       goto out;
+       size_t size = shnum * sizeof (ElfW2(LIBELFBITS,Shdr));
  
-                     const char *name = elf_strptr (elf, strshndx,
-                                                    sym->st_name);
--                    assert (name != NULL);
-+                    elf_assert (name != NULL);
-                     size_t hidx = elf_hash (name) % nbucket;
+@@ -118,6 +119,16 @@ elfw2(LIBELFBITS,getshdr) (scn)
  
-                     if (bucket[hidx] == 0)
+       if (elf->map_address != NULL)
+       {
++        /* First see whether the information in the ELF header is
++           valid and it does not ask for too much.  */
++        if (unlikely (ehdr->e_shoff >= elf->maximum_size)
++            || unlikely (ehdr->e_shoff + size > elf->maximum_size))
++          {
++            /* Something is wrong.  */
++            __libelf_seterrno (ELF_E_INVALID_SECTION_HEADER);
++            goto free_and_out;
++          }
++
+         ElfW2(LIBELFBITS,Shdr) *notcvt;
+         /* All the data is already mapped.  If we could use it
+--- elfutils-0.127/libelf/elf32_getphdr.c.robustify
++++ elfutils-0.127/libelf/elf32_getphdr.c
+@@ -116,6 +116,16 @@ elfw2(LIBELFBITS,getphdr) (elf)
+       if (elf->map_address != NULL)
+       {
++        /* First see whether the information in the ELF header is
++           valid and it does not ask for too much.  */
++        if (unlikely (ehdr->e_phoff >= elf->maximum_size)
++            || unlikely (ehdr->e_phoff + size > elf->maximum_size))
++          {
++            /* Something is wrong.  */
++            __libelf_seterrno (ELF_E_INVALID_PHDR);
++            goto out;
++          }
++
+         /* All the data is already mapped.  Use it.  */
+         void *file_phdr = ((char *) elf->map_address
+                            + elf->start_offset + ehdr->e_phoff);
This page took 0.405093 seconds and 4 git commands to generate.