it-swarm.com.de

Wie liste ich Bibliotheksabhängigkeiten einer nicht-nativen Binärdatei auf?

Bei der Entwicklung für native Plattformen kann ich mit ldd alle gemeinsam genutzten Bibliotheken (.so-Dateien) auflisten, die eine von mir erstellte ausführbare Binärdatei beim Start zu laden versucht. Beim Cross-Compilieren weiß ich jedoch nicht, wie ich dieselben Informationen erhalten kann. Das ldd ist kein normales Binutils-Dienstprogramm wie strip oder ar, das für das Cross-Compilieren zusammen mit gcc erstellt werden kann, sondern es ist ein Kryptisches Shell-Skript, das anscheinend nur auf einer nativen Plattform ausgeführt werden kann.

Gibt es also eine Möglichkeit, mithilfe der Tools für zielübergreifende Binutils eine Liste der dynamisch verknüpften Abhängigkeiten für eine fremde Binärdatei abzurufen?

56
lvella

gibt es eine Möglichkeit, eine Liste der dynamisch verknüpften Abhängigkeiten für eine fremde Binärdatei abzurufen?

Sie können direkt Abhängigkeiten einer Binärdatei leicht genug auflisten:

readelf -d a.out | grep NEEDED

 0x0000000000000001 (NEEDED)             Shared library: [librt.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]

Ich kenne keine Möglichkeit, dies rekursiv fortzusetzen, um die vollständige Liste zu erhalten (wie es ldd tut). Sie müssen den Vorgang für jede NEEDED Bibliothek von Hand wiederholen.

77

Sie können bash -x ldd /bin/ls Tun, um zu verstehen, was ldd tut. Das Skript ldd ist nicht so "kryptisch". Es läuft im Grunde

LD_TRACE_LOADED_OBJECTS=1 /lib64/ld-linux-x86-64.so.2 /bin/ls

daher wird der dynamische Loader des Systems verwendet (da das Ergebnis von ldd von Ihrer tatsächlichen Umgebung und Ihrem System abhängt!). Sie können jedoch mit objdump -x /bin/ls Den dynamischen Abschnitt einer ausführbaren Datei untersuchen, z.

% objdump -x /bin/ls
  /bin/ls:     file format elf64-x86-64
  /bin/ls
  architecture: i386:x86-64, flags 0x00000112:
  EXEC_P, HAS_SYMS, D_PAGED
  start address 0x00000000004046d4

  Program Header:
      PHDR off    0x0000000000000040 vaddr 0x0000000000400040 paddr 0x0000000000400040 align 2**3
           filesz 0x00000000000001c0 memsz 0x00000000000001c0 flags r-x
    INTERP off    0x0000000000000200 vaddr 0x0000000000400200 paddr 0x0000000000400200 align 2**0
           filesz 0x000000000000001c memsz 0x000000000000001c flags r--
      LOAD off    0x0000000000000000 vaddr 0x0000000000400000 paddr 0x0000000000400000 align 2**21
           filesz 0x0000000000019ef4 memsz 0x0000000000019ef4 flags r-x
      LOAD off    0x000000000001a000 vaddr 0x000000000061a000 paddr 0x000000000061a000 align 2**21
           filesz 0x000000000000077c memsz 0x0000000000001500 flags rw-
   DYNAMIC off    0x000000000001a028 vaddr 0x000000000061a028 paddr 0x000000000061a028 align 2**3
           filesz 0x00000000000001d0 memsz 0x00000000000001d0 flags rw-
      NOTE off    0x000000000000021c vaddr 0x000000000040021c paddr 0x000000000040021c align 2**2
           filesz 0x0000000000000044 memsz 0x0000000000000044 flags r--
  EH_FRAME off    0x0000000000017768 vaddr 0x0000000000417768 paddr 0x0000000000417768 align 2**2
           filesz 0x00000000000006fc memsz 0x00000000000006fc flags r--
     STACK off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**3
           filesz 0x0000000000000000 memsz 0x0000000000000000 flags rw-

  Dynamic Section:
    NEEDED               libselinux.so.1
    NEEDED               librt.so.1
    NEEDED               libacl.so.1
    NEEDED               libc.so.6
    INIT                 0x0000000000402148
    FINI                 0x00000000004125f8
    HASH                 0x0000000000400260
    GNU_HASH             0x00000000004005c0
    STRTAB               0x0000000000401100
    SYMTAB               0x0000000000400620
    STRSZ                0x00000000000004d7
    SYMENT               0x0000000000000018
    DEBUG                0x0000000000000000
    PLTGOT               0x000000000061a208
    PLTRELSZ             0x0000000000000990
    PLTREL               0x0000000000000007
    JMPREL               0x00000000004017b8
    RELA                 0x0000000000401740
    RELASZ               0x0000000000000078
    RELAENT              0x0000000000000018
    VERNEED              0x00000000004016c0
    VERNEEDNUM           0x0000000000000003
    VERSYM               0x00000000004015d8

  Version References:
    required from librt.so.1:
      0x09691a75 0x00 05 GLIBC_2.2.5
    required from libacl.so.1:
      0x05822452 0x00 06 ACL_1.2
      0x05822450 0x00 04 ACL_1.0
    required from libc.so.6:
      0x09691a75 0x00 03 GLIBC_2.2.5
      0x0d696913 0x00 02 GLIBC_2.3

Auch hier hängt die tatsächliche Abhängigkeit von dem System ab, auf dem Ihre Binärdatei ausgeführt wird (z. B. weil ich irgendwo einen LD_LIBRARY_PATH Mit meinem eigenen libc.so.6 Haben könnte, was eine schlechte Idee wäre).

Sie benötigen also eine Kreuzvariante von objdump

13

in gdb ist info shared ähnlich wie ldd. Es gibt vollständige, von Menschen lesbare Laufzeitinformationen der ausführbaren Datei.
readelf würde Pfad- und andere Bibliotheksinformationen verpassen.
readelf ist ein sehr gutes Werkzeug für die Host-Studie. Entwickler können wählen, dass funktioniert.

5

das hat mir geholfen

objdump -p /path/to/program | grep NEEDED 
2
captainchhala

Ein bisschen zu spät für diesen Zusatz, aber jemand könnte davon profitieren/klarstellen. Gibt das Flag -A nicht dasselbe Ergebnis wie ldd aus?

    $ readelf -AW /bin/vi

Library list section '.gnu.liblist' contains 8 entries:
     Library              Time Stamp          Checksum   Version Flags
  0: libselinux.so.1      2011-07-25T08:02:58 0x17a7d5f7 0       0
  1: libtermcap.so.2      2011-07-25T08:02:59 0x29ae9ff7 0       0
  2: libacl.so.1          2011-07-25T08:02:58 0x60748842 0       0
  3: libc.so.6            2011-07-25T08:02:58 0x0c2c7eeb 0       0
  4: libdl.so.2           2011-07-25T08:02:58 0xdfbfc467 0       0
  5: libsepol.so.1        2011-07-25T08:02:58 0x857499cb 0       0
  6: /lib64/ld-linux-x86-64.so.2 2011-07-25T08:02:58 0x9e6549b7 0       0
  7: libattr.so.1         2011-07-25T08:02:58 0x862f1546 0       0

Die einzige Information, die hier fehlt, scheint der vollständige Pfad zu sein, in dem sich diese Bibliotheken befinden.

Auf der anderen Seite sind die bisher erwähnten Tools nur dann nützlich, wenn Sie eine Installation haben, von der bekannt ist, dass sie funktioniert. Meine häufigsten Probleme sind:

  1. Installation eines Programms (meist über rpm), das dann nicht startet oder beim Start abstürzt. Irgendwie denke ich, dass dies mit Inkompatibilitäten in der Bibliothek zusammenhängt, aber ich habe keine einfache Möglichkeit gefunden, diese Dinge vor der Installation eines Programms (und auch nicht danach) zu überprüfen.
  2. In einem Versuch, (1) zu überwinden, habe ich manchmal darauf zurückgegriffen, die Quellen herunterzuladen und lokal zu kompilieren. Das typische Konfigurationsskript ist teilweise hilfreich, da es Ihnen sagt, welche Bibliotheken Sie vermissen. Es wird jedoch nicht angegeben, welche der niedrigsten Versionen solcher Bibliotheken erforderlich sind

Kann jemand Licht in diese Fragen bringen? Übrigens, ich habe versucht, Installationsanweisungen und Versionshinweise zu lesen, aber sie sind fast immer bei weitem nicht ausreichend.

Ein bulliges Beispiel kann alles in einen Zusammenhang bringen, also versuchen Sie bitte, Cinelerra zu kompilieren.

1
juan-pensante

Standardmäßig kann ldd nur auf dem Ziel ausgeführt werden. Es ist jedoch möglich, das Verhalten von ldd mit readelf nachzuahmen. Ein Skript mit dem Namen "xldd" wurde im Crosstool-ng-Projekt entwickelt. Eine unabhängige Version dieses Skripts finden Sie hier:

https://Gist.github.com/jerome-pouiller/c403786c1394f53f44a3b61214489e6f

1
Jezz

Es tut mir leid, einen Zombie-Thread zu erstellen, aber ich arbeite an einigen Dingen für meinen OpenWRT-Router und wollte, dass dies einige Abhängigkeiten überprüft, um festzustellen, ob auf meiner jffs2-Partition genügend Speicherplatz vorhanden ist, um nur e2fsck Zu kopieren. Kurze Antwort: nope.avi .

Wie auch immer, ich habe ein kleines Skript erstellt, das die akzeptierte Antwort plus einige (wahrscheinlich zu ausführliche) grep Aufrufe verwendet und mit ein wenig Handbewegung und einigen Einhorn-Tränen (keine Sorge, sie waren glücklich Tränen!) Ich habe es geschafft, das folgende Skript zusammenzustellen, das Ihnen alle Abhängigkeiten gibt. Ich bin mir sicher, dass es viel Raum für Verbesserungen gibt, insbesondere in Bezug auf RE: die Schleifen und Rekursionen sowie die Tatsache, dass es immer nur Bashismen sind (d. H. Indizierte Arrays), aber dies funktioniert zumindest nominal für mich:

#!/bin/bash

declare -a search_path
declare -a found_deps

find_dependencies() {
    local file="$1"
    local -a deps
    local -a deps_to_process

    deps=( $( readelf -d "$file" | grep "NEEDED" | \
        grep -o -E "\[[^]]*\]" | grep -o -E "[^][]*" ) )

    local add_this_dep=true

    # always assume we've found $file and add it to the $found_deps list
    # if it's not there
    for found_dep in "${found_deps[@]}"
    do
        if [ "$found_dep" = "$(basename $file)" ]
        then
            add_this_dep=false
            break
        fi
    done

    # if $add_this_dep is true, go ahead and add to the found_deps list
    if $add_this_dep
    then
        found_deps+=("$(basename $file)")
    fi

    # for every dependency found by readelf (no path)
    for dep in "${deps[@]}"
    do
        local process_dep=true

        # if the basename of the file passed into the function is
        # this dep, skip processing altogether
        if [ "$dep" = "$(basename $file)" ]
        then
            break
        else
            # otherwise, if it's one of the 'found deps' don't process it
            for found_dep in "${found_deps[@]}"
            do
                if [ "$dep" = "$found_dep" ]
                then
                    process_dep=false
                    break
                fi
            done

            # it wasn't one of the 'found deps' so add 
            # it to the found_deps list
            if $process_dep
            then
                found_deps+=($dep)
            fi
        fi

        # if we are supposed to process this dep
        if $process_dep
        then
            local file_path=

            # check each search path for a file named $dep underneath it
            for dir in $search_path
            do
                file_path=$( find "$dir" -name "$dep" | head -n 1 )

                # if the $file_path is not empty, then we found
                # a copy of it, so break out of the loop
                if [ -n "$file_path" ]; then break; fi;
            done

            # if the $file_path is not empty, then we found a copy
            # of the file, place it the list of deps to be processed
            if [ -n "$file_path" ]
            then
                deps_to_process+=($file_path)
            fi
        fi
    done

    # now, go through all of our $deps_to_process (with path)
    # and run "find_dependencies" on them
    for dep_to_process in "${deps_to_process[@]}"
    do
        find_dependencies "$dep_to_process"
    done
}

argc=$#

if [ $argc -eq 0 ]
then
    printf '%s: prints dependencies of a (potentially) non-native elf executable, recursively\n'
    printf '\n'
    printf 'usage:\n'
    printf '\t%s <non-native elf executable> [ --supress-header ] [ <path> ... ]\n' "$(basename $0)"
    printf '\twhere\n'
    printf '\t\t<non-native elf executable> is the name of a file to find the dependencies of.\n'
    printf '\t\t[ <path> ... ] is an optional list of directories under which to search for libraries.\n'
    printf '\t\t[ --supress-header ] is an optional flag that prints nothing other than the list of files to stdout.\n'
    printf '\t\t\t(without the parameter a banner is sent to stderr)'
    printf '\n'
else
    file="$1"
    shift 1

    show_header=true

    if [ "$1" = "--supress-header" ]; then show_header=false; shift 1; fi;

    if $show_header
    then
        printf ' -------------------------------------------------------------------------------------------------------------\n' 1>&2
        printf '  ldd-nonnative: find all dependencies of a (potentially) non-native binary %s\n' "$file" 1>&2
        printf ' -------------------------------------------------------------------------------------------------------------\n' 1>&2
    fi

    search_path="[email protected]"
    find_dependencies $file

    printf '\t%s\n' "${found_deps[@]}"
fi

# ❤ copyheart, shelleybutterfly, 2014
# love is never subject to the low; please copy and share with love :)

# contact information:
# [email protected]

# I hereby dedicate this software to the public domain in all jurisdictions
# where possible. In other jurisdictions, I license it to you under your
# choice of permissive license, as defined by the Open Source Institute (OSI),
# found at URL http://opensource.org. Should such a license be unavailable in
# your jurisdiection, you may use any copyleft open source license, again as
# defined by OSI; and if that too is unavailable, then you are licensed this
# software under the least restrictive possible terms allowed in your
# jurisdiction.

# I request but do not require that you give credit to me, shelleybutterfly,
# which I will accept in cases of licensing other than the public domain as
# valuable consideration for your use of my software. (I love to know that 
# my name is plastered all over some obscure piece of code that's at least
# appreciated by those who do see it, and I consider that more than enough
# consideration. :D) This software is provided completely as-is, and I take
# absolutely no responsibility for any damages that it may cause. It has
# not been fully tested and should be considered pre-alpha release quality,
# (that is to say, it is likely unstable and unsafe to use without your own
# validation to ensure that it meets some or any your needs without: among
# other things: melting your computer, calling your grandma at midnight,
# telling your girlfriend she's fat, and throwing your computer in the
# dishwasher to make sure it's clean, and you take full responsibility for
# doing your own testing to ensure that it suits your needs, and operates 
# properly int the conditions under which you intend to use it.

# Should you not be willing to take this risk, it is highly recommended
# that you do not use this software at all, ever, and that you instead find
# a real commercial piece of software, or other warranted piece of software,
# as I can not and do not and shall not provide any warranty of fitness for
# any purpose whatsoever, even to scrub your toilet, and it's provided with
# the understanding that it will be used primarily as an educational tool
# rather than any sort of production code. I disclaim any responsibility for
# anything that may happen to you due to your use of software, even if it
# causes huge zits, a rash under your boobs that wont go away, or a burning
# sensation when you pee. Sorry, **especially** for a burning sensation when
# you pee.

# Your use of this software implies acceptance of these terms as well as 
# any painful urination or other issues it may cause in your life.

# [deep breath] 

# my love to you all; I hope this software was useful to you in some way; if
# you end up using it despite the dire warnings against doing so, feel free
# to drop me a note at [email protected], as I imagine it
# will be rare enough to make my day, every time. ♥

Also los gehts. Hoffe es hilft jemandem. Egads, es hat lange gedauert, bis ich mit Shell-Skripten überhaupt so weit gekommen bin, dass ich so etwas durchgezogen habe, obwohl ich viel länger gebraucht habe, als es wahrscheinlich hätte sein sollen. Verzeihen Sie also, was wahrscheinlich einige von Ihnen erschüttert hat Skript-Gurus da draußen bis in den Kern deines Seins. :)

1

Verwenden Sie das folgende Tool, um die Abhängigkeit der gemeinsam genutzten Bibliotheken von einer nicht nativen Binärdatei aufzulisten: http://www.mathembedded.com/component/k2/item/1-cross-ldd.html

Ich benutze es auf SH4 und MIPS. Wie in einer anderen Antwort berichtet, können Sie dasselbe mit readelf-Ausgabe und einer rekursiven Schleife erreichen, aber ich habe es nie selbst versucht, da cross-ldd vorhanden ist.

0