универсальный патчер памяти процесса для линукса

[HPDX2300]

создал отдельную тему, чтобы написанное в теме "как ломануть 1C 8.3 for Linux" не захламлялось пустяковыми постами. все значимые посты будут скопированы здесь, их обсуждение можно продолжать в теме "как ломануть 1C 8.3 for Linux" Тема "патчера памяти процесса" оч.перспективна для изготовления таблеток от жадности, и те, кто умеет пользоваться линуксовыми дебагерами, знают, что системные библиотеки делают такой патчинг при каждом запуске процесса, желающие узнать "о чём это я намекаю?" ищите в поисковике "Relocation Processing". Все исходники линукса есть, есть хороший дебагер IDA (не без недостатков). Хотел я проделать финт с 32-битным унипатчем (1С_UP.ехе) для линуксовой либы бэкбейс.so 32-бита разрядности, но пока ещё не нашел участок кода куда его впихнуть - там сильно мешают релоки, попадающие в тело унипатча, скрипт должен убирать несколько релоков, но его код становится от этого "чудесатее". Пока изучал в дебагере "Relocation Processing", дошел до идеи допилить либу /lib/ld-linux.so.2 (это ссылка на /lib/ld-2.17.so) до "патчера памяти процесса". Начните с экспериментов "в песочнице" - в вирт.машине установите любимый линукс, пересоберите из исходников glibc с отладочной информацией, установите дебагер IDA-free-7.6 (более новый не советую, но это на ваше усмотрение). В меню "Debugger" -> "Debugger options" включите 2-е галки "Suspend on debugging start" (или "Suspend on process entry point") и "Suspend on library load/unload" Откройте модуль толстого клиента 1cv8, начните отладку, нажав F9, и выведите окно загруженных модулей процесса - меню "Debugger" -> "Debugger windows" -> "Module list". В окне "Module list" на первой строке вверху написано имя файла запускаемого приложения (1cv8). Жмём F9 для продолжения выполнения процесса. Когда дебагер остановится при наступлении события "LIB_LOADED", то в окне "Module list" во второй строке сверху будет написано имя файла только что загруженной либы, но ещё не очончательно загруженной - смотрите в окно исполняемого кода - IDA остановился внутри функции dl_open_worker в либе ld_2.17.so, ещё не исправлены релоки (т.е. впереди будет патчинг памяти процесса в качестве примера) и не выполнен код инициализации библиотеки (секции .init и .init_array), вот удобный момент патчить память процесса - для этого вам придется дописать код glibc (а именно код загрузчика в некоторых файлах dl-*.с в папке elf). После сборки можно не выполнять make install, а проверить в дебагере работу нового загрузчика. Проверять в отладчике, отлаживая процесс загрузчика с параметром: 32-битный загрузчик ld-2.17.so /opt/1cv8/i386/8.3.25.1445/1cv8 или 64-битный загрузчик ld-2.17.so /opt/1cv8/х86_64/8.3.25.1445/1cv8 после make install создаются ссылки на файлы загрузчиков /lib/ld-linux.so.2 -> /lib/ld-2.17.so /lib64/ld-linux-x86-64.so.2 -> /lib64/ld-2.17.so либы ld-2.17.so хоть и названы одинаково, но это разной разрядности загрузчики. Чтобы не часто заниматься сборкой/отладкой надо продумать вопрос - как сообщать загрузчику инфу "в какой либе чё искать и чем заменять", полагаю это может быть текстовый файл где-нибудь в файловой системе.

[HPDX2300]

В линуксе есть возможность доустановить для любого пакета его отладочную информацию. Я проделал это с glibc, чтобы появились файлы с debug-инфой для загрузчика /usr/lib64/ld-2.17.so

на снимке МС в правой панели рядом с /usr/lib64/ld-2.17.so появилась ссылка на ld-2.17.so.debug,
а левая панель МС открыта в папке реального расположения файлов .debug

документация и сам загрузчик сообщают, что его можно запускать, указав в качестве параметра имя файла приложения.
вот я запускаю загрузчик в терминале:

[user@hostname lib64]$ ./ld-2.17.so 
Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]
You have invoked `ld.so', the helper program for shared library executables.
This program usually lives in the file `/lib/ld.so', and special directives
in executable files using ELF shared libraries tell the system's program
loader to load the helper program from this file.  This helper program loads
the shared libraries needed by the program executable, prepares the program
to run, and runs it.  You may invoke this helper program directly from the
command line to load and run an ELF executable file; this is like executing
that file itself, but always uses this helper program from the file you
specified, instead of the helper program file specified in the executable
file you run.  This is mostly of use for maintainers to test new versions
of this helper program; chances are you did not intend to run this program.

  --list                list all dependencies and how they are resolved
  --verify              verify that given object really is a dynamically linked
			object we can handle
  --inhibit-cache       Do not use /etc/ld.so.cache
  --library-path PATH   use given PATH instead of content of the environment
			variable LD_LIBRARY_PATH
  --inhibit-rpath LIST  ignore RUNPATH and RPATH information in object names
			in LIST
  --audit LIST          use objects named in LIST as auditors

хочу отлаживать в дебагере процесс загрузки толстого клиента для примера:

/usr/lib64/ld-2.17.so  /opt/1cv8/x86_64/8.3.25.1374/1cv8

потренируюсь на оригинальном ld-2.17.so, в дальнейшем я буду отлаживать пересобранный загрузчик.

IDA-free-8.4 не захотела начать отладку ld-2.17.so, выругалась:
Input file is a dynamic library, it cannot be run by itself.
Please specify the host application (Debugger, Process options)

в файле ida64 сделал исправление (patch) {0F 85 -> 90 E9}:
offset:19D90B: 0F 85 5D FC FF FF jnz -0x3A3 ; HACK: jnz -> jmp {0F 85 -> 90 E9} to debug ld.so

либа /usr/lib64/ld-2.17.so скопирована с именем /usr/lib64/_my_ld т.к. почти наверняка я захочу её патчить в процессе изучения, ida64 пропатчена, согласилась выполнять отладку /usr/lib64/_my_ld
в меню "Debugger" -> "Process options..." указан параметр процесса Parameters: /opt/1cv8/x86_64/8.3.25.1374/1cv8

установленная отладочная информация для библиотек glibc, в отладчике проявляет себя именами функций, типами параметров и локальных переменных, структурами с именами полей:



наиболее интересные для изучения функции:
ld.so:_dl_open
libc.so:__mprotect

[HPDX2300]

в самом начале базы данных, созданной IDA для загрузчика ld.so, написано из каких исходных файлов он скомпилирован:

.....
LOAD:0000000000000000                                                 ; Compiler     : GNU C++
LOAD:0000000000000000                                                 ; File Name   : /usr/lib64/unipatch_ld
LOAD:0000000000000000                                                 ; Format      : ELF64 for x86-64 (Shared object)
LOAD:0000000000000000                                                 ; Shared Name 'ld-linux-x86-64.so.2'
LOAD:0000000000000000                                                 ;
LOAD:0000000000000000                                                 ; Source File : 'rtld.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-load.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-lookup.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-object.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-reloc.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-deps.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-hwcaps.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-runtime.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-error.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-init.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-fini.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-debug.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-misc.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-version.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-profile.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-conflict.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-tls.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-origin.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-scope.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-execstack.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-caller.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-open.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-close.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-cache.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-tunables.c'
LOAD:0000000000000000                                                 ; Source File : 'tlsdesc.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-get-cpu-features.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-sysdep.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-environ.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-minimal.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-brk.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-sbrk.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-getcwd.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-openat64.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-opendir.c'
LOAD:0000000000000000                                                 ; Source File : 'dl-fxstatat64.c'
LOAD:0000000000000000                                                 ; Source File : 'check_fds.c'
LOAD:0000000000000000                                                 ; Source File : 'errno.c'
LOAD:0000000000000000                                                 ; Source File : 'closedir.c'
LOAD:0000000000000000                                                 ; Source File : 'readdir.c'
LOAD:0000000000000000                                                 ; Source File : 'rewinddir.c'
LOAD:0000000000000000                                                 ; Source File : 'getdents.c'
LOAD:0000000000000000                                                 ; Source File : 'fdopendir.c'
LOAD:0000000000000000                                                 ; Source File : 'profil.c'
LOAD:0000000000000000                                                 ; Source File : 'prof-freq.c'
LOAD:0000000000000000                                                 ; Source File : 'xstat.c'
LOAD:0000000000000000                                                 ; Source File : 'fxstat.c'
LOAD:0000000000000000                                                 ; Source File : 'lxstat.c'
LOAD:0000000000000000                                                 ; Source File : 'fcntl.c'
LOAD:0000000000000000                                                 ; Source File : 'mmap.c'
LOAD:0000000000000000                                                 ; Source File : '_exit.c'
LOAD:0000000000000000                                                 ; Source File : 'getpid.c'
LOAD:0000000000000000                                                 ; Source File : 'environ.c'
LOAD:0000000000000000                                                 ; Source File : 'sigaction.c'
LOAD:0000000000000000                                                 ; Source File : 'strdup.c'
LOAD:0000000000000000                                                 ; Source File : 'rtld-strncmp.c'
LOAD:0000000000000000                                                 ; Source File : 'rtld-memcmp.c'
LOAD:0000000000000000                                                 ; Source File : 'memmove.c'
LOAD:0000000000000000                                                 ; Source File : 'wordcopy.c'
LOAD:0000000000000000                                                 ; Source File : 'strstr-c.c'

[HPDX2300]

offsets in file IDA-7.6/ida64:

000E7062: 74 3C              jz  +3Ch  ; HACK: {3C->00} F2 toggle breakpoin for .exe and .dll

001CD5D7: 0F 85 42 F5 FF FF  jnz -ABEh ; HACK: {0F 85->90 E9} IDA не будет возражать отлаживать процесс ld.so

00283618: B8 01 00 00 00     mov eax,1 ; HACK: {1->0}   IDA не будет возражать при изучении её модулей

при отладке изделия секты надо изменить обработку exceptions: меню "Debugger" -> "Debugger options..." -> кнопка "Edit exceptions"

Code      Name     Suspend  Passed to    Report

0000000D  SIGPIPE  No       Application  Silent

00000011  SIGCHLD  No       Application  Silent

[HPDX2300]

only for IDA Free 7.6.210526 Linux-64
offsets in file ida64:

# E7062: 74 3C  jz +3Ch ; HACK: {3C->00} F2 будет ВКЛ/ВЫКЛ breakpoint и для windows-модулей (.exe и .dll)
printf '\x00' | dd of=ida64 bs=1 seek=$((0xE7063)) count=1 conv=notrunc

# 1CD5D7: 0F 85 42 F5 FF FF  jnz -ABEh ; HACK: {0F 85->90 E9} IDA не будет возражать отлаживать процесс ld.so
printf '\x90\xE9' | dd of=ida64 bs=1 seek=$((0x1CD5D7)) count=2 conv=notrunc

# 283618: B8 01 00 00 00  mov eax,1 ; HACK: {1->0} IDA не будет возражать при изучении её модулей
printf '\x00' | dd of=ida64 bs=1 seek=$((0x283619)) count=1 conv=notrunc

при отладке изделия секты надо изменить обработку exceptions:
меню "Debugger" -> "Debugger options..." -> кнопка "Edit exceptions"

Name=SIGPIPE  Suspend=No  Passed to=Application  Report=Silent
Name=SIGCHLD  Suspend=No  Passed to=Application  Report=Silent

[HPDX2300]

only for IDA Free 8.4.240527 Linux-64
offsets in file ida64:

# 221AA0: B8 01 00 00 00   mov eax,1 ; HACK: {1->0}   IDA не будет возражать при изучении её модулей
printf '\x00' | dd of=ida64 bs=1 seek=$((0x00221AA1)) count=1 conv=notrunc

# 19D90B: 0F 85 5D FC FF FF  jnz -0x3A3 ; HACK: jnz->jmp {0F 85->90 E9} IDA не будет возражать отлаживать процесс ld.so
printf '\x90\xE9' | dd of=ida64 bs=1 seek=$((0x19D90B)) count=2 conv=notrunc

# EAD5D: 74 06: jz short loc_EAD65 ; HACK: {6->0}  F2 будет ВКЛ/ВЫКЛ breakpoint и для windows-модулей (.exe,.dll, and so on)
printf '\x00' | dd of=ida64 bs=1 seek=$((0xEAD5E)) count=1 conv=notrunc

при отладке изделия секты надо изменить обработку exceptions:
меню "Debugger" -> "Debugger options..." -> кнопка "Edit exceptions"

Name=SIGPIPE  Suspend=No  Passed to=Application  Report=Silent
Name=SIGCHLD  Suspend=No  Passed to=Application  Report=Silent

[HPDX2300]

Показываю в каком виде будет доступно имя загружаемой библиотеки.
В выхлопе загрузчика увидите, в частности, строки:
relocation processing: /opt/1cv8/x86_64/8.3.18.1128/xml2.so
calling init: /opt/1cv8/x86_64/8.3.18.1128/xml2.so

буду запускать толстого клиента в окне терминала, но сперва небольшое введение:

$ export LD_DEBUG=help
$ ls

в выхлопе увидите варианты значений LD_DEBUG

посмотрим на выхлоп relocation processing

$ cd /opt/1cv8/x86_64/8.3.18.1128
$ export LD_DEBUG=reloc
$ ./1cv8
      3505:	relocation processing: /lib64/libc.so.6
...
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/libstdc++.so.6 (lazy)
...
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/core83.so (lazy)
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/coreui83.so (lazy)
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/wbase.so (lazy)
...
      3505:	relocation processing: ./1cv8 (lazy)
      3505:	relocation processing: /lib64/ld-linux-x86-64.so.2

//  выполнение секций .init загруженных модулей
...
      3505:	calling init: /lib64/libc.so.6
...
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/libstdc++.so.6
...
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/core83.so
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/coreui83.so
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/wbase.so
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/libtcmalloc_minimal.so.4
      3505:	initialize program: ./1cv8
!!!=> 3505:	transferring control: ./1cv8  // переход к выполнению кода приложения
...
// отсюда начинается динамическая загрузка модулей, её выполняет процесс 1cv8
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/xml2.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/xml2.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/json.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/json.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/techsys.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/techsys.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/xdto.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/xdto.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/pack.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/pack.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/image.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/image.so
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/libMagickCore-6.Q8.so.2 (lazy)
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/libMagickWand-6.Q8.so.2 (lazy)
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/libMagick++-6.Q8.so.6 (lazy)
      3505:	relocation processing: /opt/1cv8/x86_64/8.3.18.1128/grphcs.so (lazy)
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/libMagickCore-6.Q8.so.2
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/libMagickWand-6.Q8.so.2
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/libMagick++-6.Q8.so.6
      3505:	calling init: /opt/1cv8/x86_64/8.3.18.1128/grphcs.so
      3522:	relocation processing: /lib64/libc.so.6
      3522:	relocation processing: /lib64/libdl.so.2 (lazy)
      3522:	relocation processing: /lib64/libtinfo.so.5 (lazy)
      3522:	relocation processing: sh (lazy)
      3522:	relocation processing: /lib64/ld-linux-x86-64.so.2
      3522:	calling init: /lib64/libc.so.6
      3522:	calling init: /lib64/libdl.so.2
      3522:	calling init: /lib64/libtinfo.so.5
      3522:	initialize program: sh <=== это чё такое? это скрытый запуск скрипта, например получение инфы о железке
      3522:	transferring control: sh
...
// много строк выброшено для краткости
...
// появилось окно выбора баз, нажимаю кнопку "Выйти", начинается выполнение секций .fini загруженных модулей
...
      3505:	calling fini: ./1cv8 [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/xml2.so [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/json.so [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/xdto.so [0]
...
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/core83.so [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/libicui18n.so.46 [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/libicuuc.so.46 [0]
      3505:	calling fini: /lib64/libdl.so.2 [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/nuke83.so [0]
      3505:	calling fini: /opt/1cv8/x86_64/8.3.18.1128/libstdc++.so.6 [0]

[HPDX2300]

в файле glibc-src/elf/dl-reloc.c находим строку "relocation processing: %s":
в процедуре
_dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[], int reloc_mode, int consider_profiling)
написано:

  if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_RELOC, 0))
    _dl_debug_printf ("\nrelocation processing: %s%s\n",
                  l->l_name[0] ? l->l_name : rtld_progname,
                  lazy ? " (lazy)" : "");

  /* DT_TEXTREL is now in level 2 and might phase out at some time.
     But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make
     testing easier and therefore it will be available at all time.  */
  if (__builtin_expect (l->l_info[DT_TEXTREL] != NULL, 0))
    {
      /* Bletch.  We must make read-only segments writable
       long enough to relocate them.  */
      const ElfW(Phdr) *ph;
      for (ph = l->l_phdr; ph < &l->l_phdr[l->l_phnum]; ++ph)
      if (ph->p_type == PT_LOAD && (ph->p_flags & PF_W) == 0)
        { /* read-only секция выполняемого кода (p_type==PT_LOAD) будет сделана writable перед патчингом, он же relocation; сделает это функция __mprotect */
          struct textrels *newp;

          newp = (struct textrels *) alloca (sizeof (*newp));
          newp->len = (((ph->p_vaddr + ph->p_memsz + GLRO(dl_pagesize) - 1)
                    & ~(GLRO(dl_pagesize) - 1))
                   - (ph->p_vaddr & ~(GLRO(dl_pagesize) - 1)));
          newp->start = ((ph->p_vaddr & ~(GLRO(dl_pagesize) - 1))
                     + (caddr_t) l->l_addr);

          if (__mprotect (newp->start, newp->len, PROT_READ|PROT_WRITE) < 0) // секция выполняемого кода  writable если функция __mprotect вернёт код возврата >=0
            {
            errstring = N_("cannot make segment writable for relocation");
            call_error:
            _dl_signal_error (errno, l->l_name, NULL, errstring);
            }

#if (PF_R | PF_W | PF_X) == 7 && (PROT_READ | PROT_WRITE | PROT_EXEC) == 7
          newp->prot = (PF_TO_PROT
                    >> ((ph->p_flags & (PF_R | PF_W | PF_X)) * 4)) & 0xf;
#else
          newp->prot = 0;
          if (ph->p_flags & PF_R)
            newp->prot |= PROT_READ;
          if (ph->p_flags & PF_W)
            newp->prot |= PROT_WRITE;
          if (ph->p_flags & PF_X)
            newp->prot |= PROT_EXEC;
#endif
          newp->next = textrels;
          textrels = newp;
        }
    }

[HPDX2300]

в файле glibc-src/elf/dl-init.c находим строку "calling init: %s":
в процедуре
call_init (struct link_map *l, int argc, char **argv, char **env)
написано:

  /* Print a debug message if wanted.  */
  if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
    _dl_debug_printf ("\ncalling init: %s\n\n",
                  l->l_name[0] ? l->l_name : rtld_progname);

  /*
     Now run the local constructors.  There are two forms of them:
     - the one named by DT_INIT
     - the others in the DT_INIT_ARRAY.
  */
  if (l->l_info[DT_INIT] != NULL)
    {
      init_t init = (init_t) DL_DT_INIT_ADDRESS
      (l, l->l_addr + l->l_info[DT_INIT]->d_un.d_ptr);

      /* Call the function.  */
      init (argc, argv, env);
    }

  /* 
     Next see whether there is an array with initialization functions.
  */
  ElfW(Dyn) *init_array = l->l_info[DT_INIT_ARRAY];
  if (init_array != NULL)
    {
      unsigned int j;
      unsigned int jm;
      ElfW(Addr) *addrs;

      jm = l->l_info[DT_INIT_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr));

      addrs = (ElfW(Addr) *) (init_array->d_un.d_ptr + l->l_addr);
      for (j = 0; j < jm; ++j)
      ((init_t) addrs[j]) (argc, argv, env);
    }

[HPDX2300]

находим вызовы call_init - они все в файле glibc-src/elf/dl-init.c в процедуре _dl_init

void
internal_function
_dl_init (struct link_map *main_map, int argc, char **argv, char **env)
{
  ElfW(Dyn) *preinit_array = main_map->l_info[DT_PREINIT_ARRAY];
  ElfW(Dyn) *preinit_array_size = main_map->l_info[DT_PREINIT_ARRAYSZ];
  unsigned int i;

  if (__builtin_expect (GL(dl_initfirst) != NULL, 0))
    {
      call_init (GL(dl_initfirst), argc, argv, env);  <====== здесь вызов call_init
      GL(dl_initfirst) = NULL;
    }

  /* Don't do anything if there is no preinit array.  */
  if (__builtin_expect (preinit_array != NULL, 0)
      && preinit_array_size != NULL
      && (i = preinit_array_size->d_un.d_val / sizeof (ElfW(Addr))) > 0)
    {
      ElfW(Addr) *addrs;
      unsigned int cnt;

      if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
      _dl_debug_printf ("\ncalling preinit: %s\n\n",
                    main_map->l_name[0]
                    ? main_map->l_name : rtld_progname);

      addrs = (ElfW(Addr) *) (preinit_array->d_un.d_ptr + main_map->l_addr);
      for (cnt = 0; cnt < i; ++cnt)
      ((init_t) addrs[cnt]) (argc, argv, env);
    }

  /* Stupid users forced the ELF specification to be changed.  It now
     says that the dynamic loader is responsible for determining the
     order in which the constructors have to run.  The constructors
     for all dependencies of an object must run before the constructor
     for the object itself.  Circular dependencies are left unspecified.

     This is highly questionable since it puts the burden on the dynamic
     loader which has to find the dependencies at runtime instead of
     letting the user do it right.  Stupidity rules!  */              <======== "Шобла тупых побеждает упрямством"

  i = main_map->l_searchlist.r_nlist;
  while (i-- > 0)
    call_init (main_map->l_initfini[i], argc, argv, env);  <====== здесь вызов call_init

#ifndef HAVE_INLINED_SYSCALLS
  /* Finished starting up.  */
  INTUSE(_dl_starting_up) = 0;
#endif
}