[v4] elf: Also try DT_RUNPATH for LD_AUDIT dlopen [BZ #28455] (original) (raw)

   $(objpfx)tst-audit16-cmp.out
   fd = -1;
 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 bool did_main_map;
  /* When the object has the RUNPATH information we don't use any
 RPATHs.  */
  if (loader == NULL || loader->l_info[DT_RUNPATH] == NULL)
{
  /* This is the executable's map (if there is one).  Make sure that
     we do not look at it twice.  */
 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 bool did_main_map = false;
 did_main_map = false;

  /* First try the DT_RPATH of the dependent object that caused NAME
     to be loaded.  Then that object's dependent, and on up.  */
 /* Make sure that we do not look at RUNPATH in the executable
twice.  */
 did_main_map = false;
  /* Look at the RUNPATH information for this binary.  */
  if (fd == -1 && loader != NULL
  && cache_rpath (loader, &loader->l_runpath_dirs,
          DT_RUNPATH, "RUNPATH"))
     &loader->l_runpath_dirs, &realname, &fb, loader,
     LA_SER_RUNPATH, &found_other_class);
 did_main_map = loader == main_map;
 fd = open_path (name, namelen, mode,
       &loader->l_runpath_dirs, &realname, &fb, loader,
       LA_SER_RUNPATH, &found_other_class);
 /* When processing the lookup we may need to additionally try
DT_RUNPATH in the executable for a glibc internal dlopen call
when looking for audit modules.  */
 if (__glibc_unlikely (mode & __RTLD_AUDIT)
 && fd == -1
 && !did_main_map
 && main_map != NULL
 && main_map->l_type != lt_loaded)
 struct r_search_path_struct l_rpath_dirs;
 l_rpath_dirs.dirs = NULL;
 if (cache_rpath (main_map, &l_rpath_dirs,
        DT_RUNPATH, "RUNPATH"))
   fd = open_path (name, namelen, mode, &l_rpath_dirs,
         &realname, &fb, loader ?: main_map,
         LA_SER_RUNPATH, &found_other_class);
  if (fd == -1)
    {
         $(objpfx)tst-audit16-cmp.out
cmp <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mrow></mrow><mo>&gt;</mo></msup></mrow><annotation encoding="application/x-tex">^ &gt; </annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7404em;"></span><span class="mord"><span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7404em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mrel mtight">&gt;</span></span></span></span></span></span></span></span></span></span></span>@; \
$(evaluate-test)
   fd = -1;
 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 bool did_main_map;
  /* When the object has the RUNPATH information we don't use any
  RPATHs.  */
  if (loader == NULL || loader->l_info[DT_RUNPATH] == NULL)
 {
   /* This is the executable's map (if there is one).  Make sure that
      we do not look at it twice.  */
  struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
  bool did_main_map = false;
  did_main_map = false;

  /* First try the DT_RPATH of the dependent object that caused NAME
     to be loaded.  Then that object's dependent, and on up.  */
 /* Make sure that we do not look at RUNPATH in the executable
 twice.  */
 did_main_map = false;
  /* Look at the RUNPATH information for this binary.  */
  if (fd == -1 && loader != NULL
   && cache_rpath (loader, &loader->l_runpath_dirs,
                   DT_RUNPATH, "RUNPATH"))
fd = open_path (name, namelen, mode,
                &loader->l_runpath_dirs, &realname, &fb, loader,
                LA_SER_RUNPATH, &found_other_class);
{
  did_main_map = loader == main_map;
  fd = open_path (name, namelen, mode,
                  &loader->l_runpath_dirs, &realname, &fb, loader,
                  LA_SER_RUNPATH, &found_other_class);
}
 /* When processing the lookup we may need to additionally try
 DT_RUNPATH in the executable for a glibc internal dlopen call
 when looking for audit modules.  */
 if (__glibc_unlikely (mode & __RTLD_AUDIT)
  && fd == -1
  && !did_main_map
  && main_map != NULL
  && main_map->l_type != lt_loaded)
{
  struct r_search_path_struct l_rpath_dirs;
  l_rpath_dirs.dirs = NULL;
  if (cache_rpath (main_map, &l_rpath_dirs,
                   DT_RUNPATH, "RUNPATH"))
    fd = open_path (name, namelen, mode, &l_rpath_dirs,
                    &realname, &fb, loader ?: main_map,
                    LA_SER_RUNPATH, &found_other_class);
}

 if (fd == -1)
   {
   $(objpfx)tst-audit16-cmp.out
   fd = -1;
 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 bool did_main_map;
  /* When the object has the RUNPATH information we don't use any
 RPATHs.  */
  if (loader == NULL || loader->l_info[DT_RUNPATH] == NULL)
{
  /* This is the executable's map (if there is one).  Make sure that
     we do not look at it twice.  */
 struct link_map *main_map = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
 bool did_main_map = false;
 did_main_map = false;

  /* First try the DT_RPATH of the dependent object that caused NAME
     to be loaded.  Then that object's dependent, and on up.  */
 /* Make sure that we do not look at RUNPATH in the executable
twice.  */
 did_main_map = false;
  /* Look at the RUNPATH information for this binary.  */
  if (fd == -1 && loader != NULL
  && cache_rpath (loader, &loader->l_runpath_dirs,
          DT_RUNPATH, "RUNPATH"))
     &loader->l_runpath_dirs, &realname, &fb, loader,
     LA_SER_RUNPATH, &found_other_class);
 did_main_map = loader == main_map;
 fd = open_path (name, namelen, mode,
       &loader->l_runpath_dirs, &realname, &fb, loader,
       LA_SER_RUNPATH, &found_other_class);
 /* When processing the lookup we may need to additionally try
DT_RUNPATH in the executable for a glibc internal dlopen call
when looking for audit modules.  */
 if (__glibc_unlikely (mode & __RTLD_AUDIT)
 && fd == -1
 && !did_main_map
 && main_map != NULL
 && main_map->l_type != lt_loaded)
 struct r_search_path_struct l_rpath_dirs;
 l_rpath_dirs.dirs = NULL;
 if (cache_rpath (main_map, &l_rpath_dirs,
        DT_RUNPATH, "RUNPATH"))
   fd = open_path (name, namelen, mode, &l_rpath_dirs,
         &realname, &fb, loader ?: main_map,
         LA_SER_RUNPATH, &found_other_class);
  if (fd == -1)
    {

Message ID	20211216020605.792222-1-hjl.tools@gmail.com (mailing list archive)
State	Superseded
Delegated to:	Adhemerval Zanella Netto
Headers	DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org A1BF63858D3C To: libc-alpha@sourceware.org Subject: [PATCH v4] elf: Also try DT_RUNPATH for LD_AUDIT dlopen [BZ #28455] Date: Wed, 15 Dec 2021 18:06:05 -0800 Message-Id: 20211216020605.792222-1-hjl.tools@gmail.com MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: list From: "H.J. Lu via Libc-alpha" libc-alpha@sourceware.org Reply-To: "H.J. Lu" hjl.tools@gmail.com Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" libc-alpha-bounces+patchwork=sourceware.org@sourceware.org
Series	[v4] elf: Also try DT_RUNPATH for LD_AUDIT dlopen [BZ #28455] \| [v4] elf: Also try DT_RUNPATH for LD_AUDIT dlopen [BZ #28455]

Context	Check	Description
dj/TryBot-apply_patch	success	Patch applied to master at the time it was sent
dj/TryBot-32bit	success	Build for i686

[v4] elf: Also try DT_RUNPATH for LD_AUDIT dlopen [BZ #28455] (original) (raw)

Checks

Commit Message

DT_RUNPATH is only used to find the immediate dependencies of the executable or shared object containing the DT_RUNPATH entry. Update LD_AUDIT dlopen call to try the DT_RUNPATH entry of the executable. This partially fixes BZ #28455.

Comments

Patch