¿Cómo se muestran todas las bibliotecas compartidas utilizadas por los ejecutables en Linux?

Question

Me gustaría saber qué bibliotecas utilizan los ejecutables en mi sistema. Más específicamente, me gustaría clasificar qué bibliotecas se usan más, junto con los binarios que las usan. ¿Cómo puedo hacer esto?

Answer 1

1. Utilice ldd para listar las bibliotecas compartidas para cada ejecutable.
2. de limpieza de la salida
3. Ordena, los recuentos de cómputo, ordenar por conteo

Para encontrar la respuesta para todos los ejecutables en el directorio "/ bin":

find /bin -type f -perm /a+x -exec ldd {} \; \ 
| grep so \ 
| sed -e '/^[^\t]/ d' \ 
| sed -e 's/\t//' \ 
| sed -e 's/.*=..//' \ 
| sed -e 's/ (0.*)//' \ 
| sort \ 
| uniq -c \ 
| sort -n 

cambio "/ bin" arriba a "/" para buscar en todos los directorios.

de salida (sólo para el directorio/bin) se verá algo como esto:

1 /lib64/libexpat.so.0 
    1 /lib64/libgcc_s.so.1 
    1 /lib64/libnsl.so.1 
    1 /lib64/libpcre.so.0 
    1 /lib64/libproc-3.2.7.so 
    1 /usr/lib64/libbeecrypt.so.6 
    1 /usr/lib64/libbz2.so.1 
    1 /usr/lib64/libelf.so.1 
    1 /usr/lib64/libpopt.so.0 
    1 /usr/lib64/librpm-4.4.so 
    1 /usr/lib64/librpmdb-4.4.so 
    1 /usr/lib64/librpmio-4.4.so 
    1 /usr/lib64/libsqlite3.so.0 
    1 /usr/lib64/libstdc++.so.6 
    1 /usr/lib64/libz.so.1 
    2 /lib64/libasound.so.2 
    2 /lib64/libblkid.so.1 
    2 /lib64/libdevmapper.so.1.02 
    2 /lib64/libpam_misc.so.0 
    2 /lib64/libpam.so.0 
    2 /lib64/libuuid.so.1 
    3 /lib64/libaudit.so.0 
    3 /lib64/libcrypt.so.1 
    3 /lib64/libdbus-1.so.3 
    4 /lib64/libresolv.so.2 
    4 /lib64/libtermcap.so.2 
    5 /lib64/libacl.so.1 
    5 /lib64/libattr.so.1 
    5 /lib64/libcap.so.1 
    6 /lib64/librt.so.1 
    7 /lib64/libm.so.6 
    9 /lib64/libpthread.so.0 
13 /lib64/libselinux.so.1 
13 /lib64/libsepol.so.1 
22 /lib64/libdl.so.2 
83 /lib64/ld-linux-x86-64.so.2 
83 /lib64/libc.so.6 

Editar - Se ha eliminado "grep -P"

Answer 2

para aprender lo que las bibliotecas a usos binarios, utilice LDD

ldd path/to/the/tool 

Habría que escribir un pequeño script de shell para llegar a su colapso de todo el sistema.

Answer 3

Con ldd usted puede conseguir las bibliotecas que utilizan herramientas. Para clasificar el uso de bibliotecas para un conjunto de herramientas, puede usar algo como el siguiente comando.

ldd /bin/* /usr/bin/* ... | sed -e '/^[^\t]/ d; s/^\t\(.* => \)\?\([^ ]*\) (.*/\2/g' | sort | uniq -c 

(Aquí sed tiras todas las líneas que no empiezan con una ficha y los filtros fuera sólo las bibliotecas reales. Con sort | uniq -c que recibe cada biblioteca con un recuento que indica el número de veces que se ha producido.)

Es posible que desee agregar sort -g al final para obtener las bibliotecas en orden de uso.

Tenga en cuenta que probablemente obtenga líneas dos líneas no de biblioteca con el comando anterior. Uno de los ejecutables estáticos ("no es un ejecutable dinámico") y uno sin ninguna biblioteca. Este último es el resultado de linux-gate.so.1 que no es una biblioteca en su sistema de archivos sino una "suministrada" por el kernel.

Answer 4

En el sistema UNIX, supongamos que el nombre binario (ejecutable) es prueba.Luego usamos el siguiente comando para listar las bibliotecas utilizadas en la prueba es

ldd test 

Answer 5

En Linux utilizo:

lsof -P -T -p Application_PID 

Esto funciona mejor que ldd cuando el ejecutable utiliza un non default loader

Answer 6

I no tenía ldd en mi cadena de herramientas ARM así que usé objdump:

$ (CROSS_COMPILE) objdump -p

Por ejemplo:

objdump -p /usr/bin/python: 

Dynamic Section: 
    NEEDED    libpthread.so.0 
    NEEDED    libdl.so.2 
    NEEDED    libutil.so.1 
    NEEDED    libssl.so.1.0.0 
    NEEDED    libcrypto.so.1.0.0 
    NEEDED    libz.so.1 
    NEEDED    libm.so.6 
    NEEDED    libc.so.6 
    INIT     0x0000000000416a98 
    FINI     0x000000000053c058 
    GNU_HASH    0x0000000000400298 
    STRTAB    0x000000000040c858 
    SYMTAB    0x0000000000402aa8 
    STRSZ    0x0000000000006cdb 
    SYMENT    0x0000000000000018 
    DEBUG    0x0000000000000000 
    PLTGOT    0x0000000000832fe8 
    PLTRELSZ    0x0000000000002688 
    PLTREL    0x0000000000000007 
    JMPREL    0x0000000000414410 
    RELA     0x0000000000414398 
    RELASZ    0x0000000000000078 
    RELAENT    0x0000000000000018 
    VERNEED    0x0000000000414258 
    VERNEEDNUM   0x0000000000000008 
    VERSYM    0x0000000000413534 

Answer 7

En OS X de forma predeterminada no hay ldd, objdump o lsof. Como alternativa, intente otool -L:

$ otool -L `which openssl` 
/usr/bin/openssl: 
    /usr/lib/libcrypto.0.9.8.dylib (compatibility version 0.9.8, current version 0.9.8) 
    /usr/lib/libssl.0.9.8.dylib (compatibility version 0.9.8, current version 0.9.8) 
    /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0) 

En este ejemplo, el uso de which openssl se llena en el trayecto completamente cualificado para el entorno de usuario ejecutable y corriente dada.

Answer 8

Verificar dependencias de bibliotecas compartidas de un programa ejecutable

para averiguar qué bibliotecas ejecutable en particular depende, comando ldd puede utilizar. Este comando invoca al enlazador dinámico para descubrir las dependencias de la biblioteca de un ejecutable.

> $ ldd/ruta/a/programa

en cuenta que no es recomendable hacer funcionar LDD con cualquier ejecutable que no se confía de terceros debido a que algunas versiones de LDD pueden invocar directamente el ejecutable para identificar sus dependencias de bibliotecas , que puede ser un riesgo de seguridad

En su lugar, una forma más segura de mostrar las dependencias de la biblioteca de un binario de aplicación desconocido es utilizar el siguiente comando.

$ objdump -p/ruta/a/programa | grep NECESITA

for more info

Answer 9

readelf -d recursividad

redelf -d produce una salida similar a objdump -p que se mencionan en: https://stackoverflow.com/a/15520982/895245

Pero cuidado que las bibliotecas dinámicas pueden depender de otras bibliotecas dinámicas, a usted tiene que recurse.

Ejemplo:

readelf -d /bin/ls | grep 'NEEDED' 

ouptut muestra:

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

Entonces:

$ locate libselinux.so.1 
/lib/i386-linux-gnu/libselinux.so.1 
/lib/x86_64-linux-gnu/libselinux.so.1 
/mnt/debootstrap/lib/x86_64-linux-gnu/libselinux.so.1 

elegir uno, y repetir:

readelf -d /lib/x86_64-linux-gnu/libselinux.so.1 | grep 'NEEDED' 

salida

muestra:

0x0000000000000001 (NEEDED)    Shared library: [libpcre.so.3] 
0x0000000000000001 (NEEDED)    Shared library: [libdl.so.2] 
0x0000000000000001 (NEEDED)    Shared library: [libc.so.6] 
0x0000000000000001 (NEEDED)    Shared library: [ld-linux-x86-64.so.2] 

Y así sucesivamente.

/proc/<pid>/maps de los procesos en ejecución

Esto es útil para encontrar todas las bibliotecas que se utilizan actualmente mediante la ejecución de archivos ejecutables. Por ejemplo:

sudo awk '/\.so/{print $6}' /proc/1/maps | sort -u 

muestra dependencias toda cargados actualmente dinámicas de init (PID 1):

/lib/x86_64-linux-gnu/ld-2.23.so 
/lib/x86_64-linux-gnu/libapparmor.so.1.4.0 
/lib/x86_64-linux-gnu/libaudit.so.1.0.0 
/lib/x86_64-linux-gnu/libblkid.so.1.1.0 
/lib/x86_64-linux-gnu/libc-2.23.so 
/lib/x86_64-linux-gnu/libcap.so.2.24 
/lib/x86_64-linux-gnu/libdl-2.23.so 
/lib/x86_64-linux-gnu/libkmod.so.2.3.0 
/lib/x86_64-linux-gnu/libmount.so.1.1.0 
/lib/x86_64-linux-gnu/libpam.so.0.83.1 
/lib/x86_64-linux-gnu/libpcre.so.3.13.2 
/lib/x86_64-linux-gnu/libpthread-2.23.so 
/lib/x86_64-linux-gnu/librt-2.23.so 
/lib/x86_64-linux-gnu/libseccomp.so.2.2.3 
/lib/x86_64-linux-gnu/libselinux.so.1 
/lib/x86_64-linux-gnu/libuuid.so.1.3.0 

Ver también: https://superuser.com/questions/310199/see-currently-loaded-shared-objects-in-linux/1243089

Answer 10

en ubuntu paquetes de impresión relacionados con un ejecutable

ldd executable_name | awk '{print $ 3}' | xargs dpkg -S | awk -F ":" '{print $ 1} '

Answer 11

Encontré esta publicación muy útil, ya que necesitaba investigar las dependencias de una biblioteca suministrada por un tercero (rutas de ejecución de 32 contra 64 bits).

Puse en común una secuencia de comandos recursiva de Q & D basada en la sugerencia 'readelf -d' en una distribución RHEL 6.

Es muy básico y probará todas las dependencias todas las veces, incluso si hubiera sido probado antes (es decir, muy detallado). La salida es muy básica también.

#! /bin/bash 

recurse() 
# Param 1 is the nuumber of spaces that the output will be prepended with 
# Param 2 full path to library 
{ 
#Use 'readelf -d' to find dependencies 
dependencies=$(readelf -d ${2} | grep NEEDED | awk '{ print $5 }' | tr -d '[]') 
for d in $dependencies; do 
    echo "${1}${d}" 
    nm=${d##*/} 
    #libstdc++ hack for the '+'-s 
    nm1=${nm//"+"/"\+"} 
    # /lib /lib64 /usr/lib and /usr/lib are searched 
    children=$(locate ${d} | grep -E "(^/(lib|lib64|usr/lib|usr/lib64)/${nm1})") 
    rc=$? 
    #at least locate... didn't fail 
    if [ ${rc} == "0" ] ; then 
     #we have at least one dependency 
     if [ ${#children[@]} -gt 0 ]; then 
     #check the dependeny's dependencies 
     for c in $children; do 
      recurse " ${1}" ${c} 
     done 
     else 
     echo "${1}no children found" 
     fi 
    else 
     echo "${1}locate failed for ${d}" 
    fi 
done 
} 
# Q&D -- recurse needs 2 params could/should be supplied from cmdline 
recurse "" !!full path to library you want to investigate!! 

redirigir la salida a un archivo y grep para 'encontrado' o 'fallido'

usar y modificar, a su propio riesgo, por supuesto, como desee.