script - ¿Cómo mostrar todas las bibliotecas compartidas utilizadas por los ejecutables en Linux?

scripts bash ejemplos

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. Use ldd para listar las bibliotecas compartidas para cada ejecutable.
2. Limpiar la salida
3. Ordenar, calcular recuentos, clasificar por recuento

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

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

La salida (solo para el directorio / bin) tendrá el siguiente aspecto:

 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 - Eliminado "grep -P"

Answer 2

Con ldd puede obtener las bibliotecas que usan las 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 elimina todas las líneas que no comienzan con una pestaña y filtra solo las bibliotecas reales. Con sort | uniq -c obtiene cada biblioteca con un recuento que indica el número de veces que ocurrió).

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 que no sean 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 3

En Linux utilizo:

lsof -P -T -p Application_PID

Esto funciona mejor que ldd cuando el ejecutable usa un cargador no predeterminado

Answer 4

En OS X por defecto no hay ldd , objdump o lsof . Como alternativa, prueba 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 completa la ruta completa del ejecutable y el entorno de usuario actual.

Answer 5

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

ldd test

Answer 6

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

Puse un guión bash de recursión de Q & D basado en la sugerencia ''readelf -d'' en una distribución RHEL 6.

Es muy básico y probará todas las dependencias cada vez, 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 ''found'' o ''failed''

Utilice y modifique, bajo su propio riesgo, por supuesto, como lo desee.

Answer 7

No tenía un disco duro 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 8

Verificar las dependencias de bibliotecas compartidas de un programa ejecutable

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

> $ ldd / ruta / a / programa

Tenga en cuenta que NO se recomienda ejecutar ldd con ningún ejecutable de terceros que no sea de confianza, ya que algunas versiones de ldd pueden invocar directamente el ejecutable para identificar sus dependencias de biblioteca, lo que puede suponer un riesgo de seguridad.

En cambio, una forma más segura de mostrar las dependencias de la biblioteca de un binario de aplicación desconocida es usar el siguiente comando.

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

para más información

Answer 9

en paquetes de impresión ubuntu relacionados con un ejecutable

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

Answer 10

para aprender qué bibliotecas usa un binario, use ldd

ldd path/to/the/tool

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

Answer 11

readelf -d recursión

redelf -d produce un resultado similar a objdump -p que se mencionó en: https://.com/a/15520982/895245

Pero tenga en cuenta que las bibliotecas dinámicas pueden depender de otras bibliotecas dinámicas, para que tenga que recurse.

Ejemplo:

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

Muestra ouptut:

 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

Elige uno y repite:

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

Muestra de salida:

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í.

/proc/<pid>/maps para ejecutar procesos

Esto es útil para encontrar todas las bibliotecas que se utilizan actualmente ejecutando ejecutables. P.ej:

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

muestra todas las dependencias dinámicas cargadas actualmente 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