CreateRemoteThread pour Linux

WinAPI a une fonction CreateRemoteThread qui vous permet de démarrer un nouveau thread dans l'espace d'adressage d'un autre processus. Il peut être utilisé pour une variété d'injections de DLL, à la fois à des fins malveillantes (astuces dans les jeux, vol de mot de passe, etc.), et pour corriger un bug dans un programme en cours d'exécution à la volée, ou ajouter des plugins à des endroits où ils n'étaient pas fournis.

En général, cette fonction a un utilitaire d'application douteux, il n'est donc pas surprenant que Linux ne dispose pas d'un analogue prêt à l'emploi de CreateRemoteThread. Cependant, je me demandais comment le mettre en œuvre. L'étude du sujet s'est transformée en une bonne aventure.

Je vais expliquer en détail comment, à l'aide de la spécification ELF, une certaine connaissance de l'architecture x86_64 et des appels système Linux, écrire votre propre petit débogueur qui peut charger et exécuter du code arbitraire dans un processus déjà en cours d'exécution et de travail.

La compréhension du texte nécessitera des connaissances de base sur la programmation système pour Linux: le langage C, les programmes d'écriture et de débogage dessus, une compréhension du rôle du code machine et de la mémoire dans l'ordinateur, le concept des appels système, la familiarité avec les principales bibliothèques et la lecture de la documentation.

• Idées principales
• Esquisse de solution
• Étape 1. Connexion au processus
• Étape 2. Rechercher des bibliothèques en mémoire
• Étape 3. Analyse des images de la bibliothèque ELF
• Étape 4. Implémentation du shellcode
• Étape 5. Démarrage d'un nouveau thread
• Conclusion

En conséquence, j'ai pu «ajouter» la possibilité de prévisualiser les mots de passe dans le centre de contrôle Gnome:

Idées principales

S'il n'y avait aucune clause dans les exigences relatives au chargement de code dans un processus déjà en cours d'exécution, la solution serait extrêmement simple: LD_PRELOAD. Cette variable d'environnement permet de charger une bibliothèque arbitraire avec l'application. Dans les bibliothèques partagées, vous pouvez définir des fonctions constructeur qui s'exécutent lors du chargement de la bibliothèque.

Ensemble, LD_PRELOAD et les constructeurs permettent l'exécution de code arbitraire dans n'importe quel processus utilisant un chargeur dynamique. Il s'agit d'une fonctionnalité relativement bien connue souvent utilisée pour le débogage. Par exemple, avec l'application, vous pouvez charger votre propre bibliothèque, qui définit les fonctions malloc () et free (), ce qui pourrait aider à détecter les fuites de mémoire.

Malheureusement, LD_PRELOAD ne fonctionne qu'au démarrage du processus. Il ne peut pas être utilisé pour charger une bibliothèque dans un processus déjà en cours d'exécution. Il existe une fonction dlopen () pour charger les bibliothèques pendant le processus, mais, évidemment, le processus lui-même doit l'appeler pour charger les plugins.

À propos des exécutables statiques

LD_PRELOAD ne fonctionne qu'avec les programmes qui utilisent le chargeur dynamique. Si le programme a été construit avec le commutateur -static , il inclut toutes les bibliothèques nécessaires. Dans ce cas, la résolution des dépendances dans les bibliothèques est effectuée au moment de la génération et le programme n'est généralement pas prêt et n'est pas en mesure de charger dynamiquement les bibliothèques après l'assemblage, au moment de l'exécution.

Dans les programmes assemblés statiquement, vous pouvez incorporer du code au moment de l'exécution, mais cela doit être fait d'une manière légèrement différente. Et ce n'est pas entièrement sûr, car le programme n'est peut-être pas prêt pour un tel virage.

En général, il n'y a pas de solution pratique prête à l'emploi, vous devez écrire votre vélo. Sinon, vous ne liriez pas ce texte :)

Conceptuellement, pour forcer le processus de quelqu'un d'autre à exécuter une sorte de code, vous devez effectuer les actions suivantes:

1. Prenez le contrôle du processus cible.
2. Chargez le code dans la mémoire du processus cible.
3. Préparez le code téléchargé pour l'exécution dans le processus cible.
4. Organisez l'exécution du code téléchargé par le processus cible.

Allons-y ...

Prendre le contrôle du processus

Tout d'abord, nous devons subordonner le processus cible à notre volonté. Après tout, les processus exécutent généralement uniquement leur propre code, ou le code des bibliothèques chargées, ou les résultats de la compilation JIT. Mais certainement pas notre code.

Une option consiste à utiliser une sorte de vulnérabilité dans le processus qui vous permet de prendre le contrôle. Un exemple classique des tutoriels: buffer overflow, permettant de réécrire l'adresse de retour sur la pile. C'est amusant, ça marche parfois même, mais pas adapté au cas général.

Nous utiliserons une autre façon honnête de prendre le contrôle: le débogage des appels système . Les débogueurs interactifs peuvent parfaitement arrêter les processus tiers, évaluer les expressions et bien d'autres choses. Ils peuvent - nous pouvons.

Sous Linux, l'appel système de débogage principal est ptrace () . Il vous permet de vous connecter aux processus, d'examiner leur statut et de contrôler la progression de leur exécution. ptrace () est assez bien documenté seul, mais les détails de son utilisation ne sont clairs qu'en pratique.

Chargement de code dans la mémoire de processus

Dans le cas de débordements de tampon, la charge utile ( code shell ) est généralement incluse dans le contenu qui déborde du même tampon. Lorsque vous utilisez le débogueur, le code nécessaire peut être écrit directement dans la mémoire de processus. Dans WinAPI, il existe une fonction spéciale WriteProcessMemory pour cela. Linux à cet effet est conforme à la méthode UNIX: pour chaque processus du système, il existe un fichier / proc / $ pid / mem , qui affiche la mémoire de ce processus. Il est possible d'écrire quelque chose dans la mémoire de processus en utilisant l'entrée-sortie habituelle.

Préparation du code pour l'exécution

Il ne suffit pas d'écrire du code en mémoire. Il doit encore être écrit dans la mémoire exécutable . Dans le cas de l'enregistrement via une vulnérabilité, cela présente des difficultés non triviales, mais comme nous pouvons contrôler complètement le processus cible, il ne nous sera pas difficile de trouver ou d'allouer la mémoire «correcte» pour nous-mêmes.

Un autre point important de préparation est le code shell lui-même. Dans ce document, nous voudrons probablement utiliser certaines fonctions des bibliothèques, telles que les entrées-sorties, les primitives graphiques, etc. Cependant, nous devons écrire du code machine nu, qui en soi n'a aucune idée des adresses de toutes ces fonctions intéressantes dans les bibliothèques. D'où les obtenez-vous?

Pour simplifier la vie du système d'exploitation et compliquer la vie du code malveillant, les bibliothèques n'utilisent généralement pas d'adresses fixes (et contiennent un code dit indépendant de la position ). Les adresses ne peuvent donc pas être devinées.

Lorsque le processus démarre normalement, le chargeur qui effectue les relocalisations est chargé de déterminer les adresses exactes des bibliothèques. Cependant, il ne remplit qu'une seule fois au départ. Si le processus autorise le chargement dynamique des bibliothèques, il contient un chargeur dynamique qui peut faire de même pendant l'exécution du processus. Cependant, l'adresse du chargeur dynamique n'est pas non plus fixe.

En général, avec les bibliothèques, il y a quatre options:

• n'utilisez pas du tout les bibliothèques, faites tout sur les appels système propres
• mettre des copies de toutes les bibliothèques nécessaires dans le code shell
• faites vous-même le travail du chargeur dynamique
• trouver un chargeur de démarrage dynamique et le faire charger nos bibliothèques

Nous choisirons ce dernier, car nous voulons les bibliothèques, et écrire notre chargeur de démarrage complet depuis longtemps. Ce n'est pas la méthode la plus secrète, et non la plus intéressante, mais la plus simple, puissante et fiable.

Transfert de contrôle au code

ptrace () vous permet de changer les registres du processeur, donc il ne devrait y avoir aucun problème avec le transfert du contrôle vers le code chargé et préparé: écrivez simplement l'adresse de notre code dans le registre% rip - et le tour est joué! Cependant, en réalité, tout n'est pas si simple. Les difficultés sont liées au fait que le processus débogué n'a en fait pas disparu et qu'il a également une sorte de code qui a été exécuté et continuera à être exécuté.

Esquisse de solution

Total, nous mettrons en œuvre notre flux dans un processus tiers comme suit:

1. Nous sommes connectés au processus cible de débogage.
2. On retrouve les bibliothèques nécessaires en mémoire:
   
   • libdl - pour charger une nouvelle bibliothèque
   • libpthread - pour démarrer un nouveau thread
3. On trouve les fonctions nécessaires dans les bibliothèques:
   
   • libdl: dlopen (), dlsym ()
   • libpthread: pthread_create (), pthread_detach ()

4. Nous introduisons le code shell dans la mémoire du processus cible:

   
   

    void shellcode(void) { void *payload = dlopen("/path/to/payload.so", RTLD_LAZY); void *entry = dlsym(payload, "entry_point"); pthread_t thread; pthread_create(&thread, NULL, entry, NULL); pthread_detach(thread); } 

   
   
5. Nous donnons le code shell à remplir.

En conséquence, les bibliothèques feront la bonne chose pour nous: elles chargeront notre bibliothèque avec le code dont nous avons besoin en mémoire et démarreront un nouveau thread exécutant ce code.

Limitations

L'approche décrite ci-dessus impose certaines limites:

• Le chargeur de démarrage doit disposer de privilèges suffisants pour déboguer le processus cible.
• Le processus doit utiliser libdl (prêt pour le chargement dynamique des modules).
• Le processus doit utiliser libpthread (prêt pour le multithreading).
• Les applications statiques ne sont pas prises en charge.

De plus, personnellement, je suis trop paresseux pour me soucier du support des architectures tout-en-un, nous nous limiterons donc à x86_64. (Même un x86 32 bits serait plus compliqué.)

Comme vous pouvez le voir, tout cela met fin à une utilisation secrète avec des cibles malveillantes. Cependant, la tâche conserve toujours un intérêt pour la recherche et laisse même une faible opportunité pour une utilisation industrielle.

Digression: à propos de l'utilisation de libdl et libpthread

Un lecteur-lecteur expérimenté peut se demander: pourquoi avoir besoin de libdl si les fonctions internes __libc_dlopen_mode () et __libc_dlsym () sont déjà intégrées dans glibc, et libdl n'est qu'un wrapper sur elles? De même, pourquoi exiger libpthread si un nouveau thread peut être facilement créé en utilisant l'appel système clone ()?

En effet, sur Internet, il y a loin d'un exemple de leur utilisation:

• https://github.com/gaffe23/linux-inject
• https://github.com/TsarFox/hypodermic
• http://hick.org/code/skape/papers/needle.txt
• https://github.com/ice799/injectso64
• http://www.ouah.org/subversiveld.pdf

Ils sont même mentionnés dans la littérature populaire des hackers:

• Apprendre l'analyse binaire Linux
• L'art de la médecine légale

Alors pourquoi pas? Eh bien, au moins parce que nous n'écrivons pas de code malveillant où une solution appropriée qui omet 90% des vérifications, prend 20 fois moins d'espace, mais fonctionne également dans 80% des cas. De plus, je voulais tout essayer de mes propres mains.

En effet, libdl n'est pas nécessaire pour charger la bibliothèque dans le cas de glibc. Son utilisation par le processus indique qu'il est clairement prêt pour le chargement de code dynamique. Malgré cela, en principe, vous pouvez refuser d'utiliser libdl (étant donné que nous devrons également rechercher la glibc plus tard également).

Pourquoi dlopen () à l'intérieur de la glibc?

C'est une question intéressante à sa manière. Réponse courte: détails de mise en œuvre.

Le point est le commutateur de service de noms (NSS) - l'une des parties de la glibc qui fournit la traduction de divers noms: noms de machines, protocoles, utilisateurs, serveurs de messagerie, etc. C'est elle qui est responsable de fonctions telles que getaddrinfo () pour obtenir des adresses IP en nom de domaine et getpwuid () pour obtenir des informations sur l'utilisateur par son identifiant numérique.

NSS a une architecture modulaire et les modules se chargent dynamiquement. En fait, pour cela, la glibc avait également besoin de mécanismes de chargement dynamique des bibliothèques. C'est pourquoi lorsque vous essayez d'utiliser getaddrinfo () dans une application assemblée statiquement, l'éditeur de liens affiche un avertissement «incompréhensible»:

 /tmp/build/socket.o: Dans la fonction `Socket :: bind ':
 socket.o :(. text + 0x374): avertissement: utilisation de 'getaddrinfo' dans un lien statique
 les applications nécessitent au moment de l'exécution les bibliothèques partagées de la version glibc
 utilisé pour la liaison

En ce qui concerne les threads, un thread n'est généralement pas seulement une pile et un code exécutable, mais également des données globales stockées dans un stockage local de threads (TLS). L'initialisation correcte d'un nouveau thread nécessite le fonctionnement coordonné du noyau du système d'exploitation, un chargeur de code binaire et un runtime de langage de programmation. Par conséquent, un simple appel à clone () suffit pour créer un flux qui peut écrire dans le fichier "Hello world!", Mais cela peut ne pas fonctionner pour un code plus complexe qui a besoin d'accéder à TLS et à d'autres choses intéressantes cachées aux yeux du programmeur d'application.

Un autre point lié au multithreading concerne les processus à un seul thread. Que se passe-t-il si nous créons un nouveau thread dans un processus qui n'a pas été conçu comme multithread? Bon comportement vague. En effet, dans le processus, il n'y a pas de synchronisation du travail entre les threads, ce qui entraînera tôt ou tard une corruption des données. Si nous exigeons que l'application utilise libpthread, alors nous pouvons être sûrs qu'elle est prête à fonctionner dans un environnement multithread (au moins elle devrait être prête).

Étape 1. Connexion au processus

Tout d'abord, nous devons nous connecter au processus cible pour le débogage, puis le déconnecter à nouveau. C'est là que l'appel système ptrace () entre en jeu.

Premier contact avec ptrace ()

Dans la documentation de ptrace (), vous pouvez trouver presque toutes les informations nécessaires:

   Fixation et détachement
        Un fil peut être attaché au traceur à l'aide de l'appel

            ptrace (PTRACE_ATTACH, pid, 0, 0);

        ou

            ptrace (PTRACE_SEIZE, pid, 0, PTRACE_O_flags);

        PTRACE_ATTACH envoie SIGSTOP à ce fil.  Si le traceur le veut
        SIGSTOP n'a aucun effet, il doit le supprimer.  Notez que si
        d'autres signaux sont envoyés simultanément à ce fil pendant l'attachement, le
        le traceur peut voir le tracé entrer dans le signal-livraison-stop avec d'autres signaux
        nal (s) en premier!  La pratique habituelle consiste à réinjecter ces signaux jusqu'à
        SIGSTOP s'affiche, puis supprimer l'injection de SIGSTOP.  Le bug de conception
        voici qu'un attach ptrace et un SIGSTOP livré simultanément peuvent
        course et le SIGSTOP simultané peuvent être perdus.

La première étape consiste donc à utiliser PTRACE_ATTACH:

 int ptrace_attach(pid_t pid) { /*     */ if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) return -1; /*    */ if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; return 0; } 

Après ptrace (), le processus cible n'est pas tout à fait prêt pour le débogage. Nous y sommes connectés, mais pour une étude interactive de l'état du processus, il faut l'arrêter. ptrace () envoie un signal SIGSTOP au processus, mais nous devons encore attendre que le processus s'arrête réellement.

Pour attendre, utilisez l'appel système waitpid (). Dans le même temps, plusieurs cas limites intéressants méritent d'être notés. Premièrement, le processus peut simplement se terminer ou mourir sans avoir reçu SIGSTOP. Dans ce cas, nous ne pouvons rien faire. Deuxièmement, un autre signal peut être préalablement envoyé au processus. Dans ce cas, nous devons laisser le processus le traiter (en utilisant PTRACE_CONT), et nous-mêmes, continuer d'attendre plus longtemps notre SIGSTOP:

 static int wait_for_process_stop(pid_t pid, int expected_signal) { for (;;) { int status = 0; /* ,    -  */ if (waitpid(pid, &status, 0) < 0) return -1; /*      —   */ if (WIFSIGNALED(status) || WIFEXITED(status)) return -1; /*   ,     */ if (WIFSTOPPED(status)) { /* *  WSTOPSIG()   , *   ptrace()   *     . */ int stop_signal = status >> 8; /*    ,    */ if (stop_signal == expected_signal) break; /*        */ if (ptrace(PTRACE_CONT, pid, 0, stop_signal) < 0) return -1; continue; } /*   —   */ return -1; } return 0; } 

Déconnexion du processus

Arrêter le processus de débogage est beaucoup plus simple: utilisez simplement PTRACE_DETACH:

 int ptrace_detach(pid_t pid) { if (ptrace(PTRACE_DETACH, pid, 0, 0) < 0) return -1; return 0; } 

À proprement parler, la désactivation explicite du débogueur n'est pas toujours nécessaire. Lorsque le processus de débogage se termine, il se déconnecte automatiquement de tous les processus débogués et les processus reprennent s'ils ont été arrêtés par ptrace (). Cependant, si le processus débogué a été explicitement arrêté par le débogueur à l'aide du signal SIGSTOP sans utiliser ptrace (), il ne se réveillera pas sans le signal SIGCONT ou PTRACE_DETACH correspondant. Par conséquent, il est préférable de se déconnecter culturellement des processus.

Paramètre Ptrace_scope

Le débogueur a un contrôle total sur le processus en cours de débogage. Si quelqu'un pouvait déboguer quoi que ce soit, quelle serait l'étendue du code malveillant! Il est évident que le débogage interactif est une activité assez spécifique, généralement nécessaire uniquement aux développeurs. Pendant le fonctionnement normal du système, le plus souvent, il n'est pas nécessaire de déboguer les processus.

Pour ces raisons, pour des raisons de sécurité, les systèmes désactivent généralement la possibilité de déboguer les processus par défaut. Le module de sécurité Yama en est responsable, géré via le fichier / proc / sys / kernel / yama / ptrace_scope. Il propose quatre comportements:

• 0 - l'utilisateur peut déboguer tous les processus qu'il a démarrés
• 1 - mode par défaut, seuls les processus démarrés par le débogueur peuvent être débogués
• 2 - seul un administrateur système racine peut déboguer les processus
• 3 - le débogage est interdit à tout le monde, le mode ne s'éteint qu'au redémarrage du système

De toute évidence, pour nos besoins, il sera nécessaire de pouvoir déboguer les processus lancés avant notre débogueur, donc pour les expériences, vous devrez soit basculer le système en mode développement en écrivant 0 dans un fichier ptrace_scope spécial (qui nécessite des droits d'administrateur):

 $ sudo sh -c 'echo 0 > /proc/sys/kernel/yama/ptrace_scope' 

ou exécutez le débogueur en tant qu'administrateur:

 $ sudo ./inject-thread ... 

Résultats de la première étape

Par conséquent, dans la première étape, nous sommes en mesure de nous connecter au processus cible en tant que débogueur et de nous en déconnecter plus tard.

Le processus cible sera arrêté et nous pouvons nous assurer que le système d'exploitation nous voit vraiment comme un débogueur:

 $ sudo ./inject-thread --target $(pgrep docker) $ cat /proc/$(pgrep docker)/status | head Name: docker State: t (tracing stop) <---    Tgid: 31330 Ngid: 0 Pid: 31330 PPid: 1 TracerPid: 2789 <--- PID   Uid: 0 0 0 0 Gid: 0 0 0 0 FDSize: 64 $ ps a | grep [2]789 2789 pts/5 S+ 0:00 ./inject-thread --target 31330 

Étape 2. Rechercher des bibliothèques en mémoire

L'étape suivante est plus simple: vous devez trouver dans la mémoire du processus cible la bibliothèque avec les fonctions dont nous avons besoin. Mais il y a beaucoup de mémoire, par où commencer et quoi exactement?

Fichier / proc / $ pid / maps

Un fichier spécial nous aidera avec cela, à travers lequel le noyau indique quoi et où se trouve le processus en mémoire. Comme vous le savez , dans le répertoire / proc de chaque processus, il y a un sous-répertoire. Et il y a un fichier qui décrit la carte mémoire du processus:

 $ cat / proc / self / maps
 00400000-0040c000 r-xp 00000000 fe: 01 1044592 / bin / cat
 0060b000-0060c000 r - p 0000b000 fe: 01 1044592 / bin / cat
 0060c000-0060d000 rw-p 0000c000 fe: 01 1044592 / bin / cat
 013d5000-013f6000 rw-p 00000000 00:00 0 [tas]
 7f9920bd1000-7f9920d72000 r-xp 00000000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920d72000-7f9920f72000 --- p 001a1000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920f72000-7f9920f76000 r - p 001a1000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920f76000-7f9920f78000 rw-p 001a5000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7fc3f8381000-7fc3f8385000 rw-p 00000000 00:00 0
 7fc3f8385000-7fc3f83a6000 r-xp 00000000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f83ec000-7fc3f840e000 rw-p 00000000 00:00 0
 7fc3f840e000-7fc3f8597000 r - p 00000000 fe: 01 657286 / usr / lib / locale / locale-archive
 7fc3f8597000-7fc3f859a000 rw-p 00000000 00:00 0
 7fc3f85a3000-7fc3f85a5000 rw-p 00000000 00:00 0
 7fc3f85a5000-7fc3f85a6000 r - p 00020000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f85a6000-7fc3f85a7000 rw-p 00021000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f85a7000-7fc3f85a8000 rw-p 00000000 00:00 0
 7ffdb6f0e000-7ffdb6f2f000 rw-p 00000000 00:00 0 [pile]
 7ffdb6f7f000-7ffdb6f81000 r-xp 00000000 00:00 0 [vdso]
 7ffdb6f81000-7ffdb6f83000 r - p 00000000 00:00 0 [vvar]
 ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]

Le contenu de ce fichier est généré à la volée par le noyau du système d'exploitation à partir de structures internes qui décrivent les régions mémoire du processus qui nous intéresse et contient les informations suivantes:

• plage d'adresses attribuée à la région
• droits d'accès à la région
  
  • r/- : lire
  • w/- : écrire
  • x/- : exécution
  • p/s : partage de mémoire avec d'autres processus
• décalage de fichier (le cas échéant)
• code de l'appareil où se trouve le fichier affiché
• numéro d'inode du fichier (le cas échéant)
• chemin d'accès au fichier affiché (le cas échéant)

Certaines régions de la mémoire sont mappées sur des fichiers: lorsqu'un processus lit une telle mémoire, il lit en fait les données des fichiers correspondants à un décalage spécifique. Si vous pouvez écrire dans une région, les modifications de la mémoire peuvent être visibles uniquement pour le processus lui - même (mécanisme de copie sur écriture , le mode p est privé) ou synchronisées avec le disque ( s mode s est partagé).

Les autres régions sont anonymes - cette mémoire ne correspond à aucun fichier. Le système d'exploitation donne simplement au processus un morceau de mémoire physique qu'il utilise. De telles régions sont utilisées, par exemple, pour la mémoire de processus "normale": pile et tas. Les régions anonymes peuvent être personnelles à un processus ou partagées entre plusieurs processus (mécanisme de mémoire partagée ).

De plus, il y a plusieurs régions spéciales dans la mémoire marquées des pseudo-noms [vdso] et [vsyscall]. Ils sont utilisés pour optimiser certains appels système.

Nous sommes intéressés par les régions où le contenu des fichiers de bibliothèque est affiché. Si nous lisons la carte mémoire et filtrons les entrées qu'elle contient par le nom du fichier affiché, nous trouverons toutes les adresses occupées par les bibliothèques dont nous avons besoin. Le format de la carte mémoire est spécialement adapté au traitement des programmes et se comprend facilement à l'aide des fonctions de la famille scanf ():

 static bool read_proc_line(const char *line, const char *library, struct memory_region *region) { unsigned long vaddr_low = 0; unsigned long vaddr_high = 0; char read = 0; char write = 0; char execute = 0; int path_offset = 0; /*    /proc/$pid/maps */ sscanf(line, "%lx-%lx %c%c%c%*c %*lx %*x:%*x %*d %n", &vaddr_low, &vaddr_high, &read, &write, &execute, &path_offset); /* ,       */ if (!strstr(line + path_offset, library)) return false; /*           */ if (region) { region->vaddr_low = vaddr_low; region->vaddr_high = vaddr_high; region->readable = (read == 'r'); region->writeable = (write == 'w'); region->executable = (execute == 'x'); region->content = NULL; } return true; } 

, libc-2.19.so, :

2 - ? 51? ? ?

, , .

, , . , , , (, , ).

, ( 4 ). , .

, . — — . 2 — , ( x86_64 4 , 2 , 1 ). .

, :

• libdl: dlopen() dlsym()
• libpthread: pthread_create() pthread_detach()

, , . Linux ( address space layout randomization , ASLR). (- , ), — - .

, , , /proc/$pid/maps. , .

3. ELF-

, , , .

:

 $ nm -D /lib/x86_64-linux-gnu/libdl-2.19.so | grep dlopen 0000000000001090 T dlopen 

nm . .

- , nm , . , dlsym().

— ELF-, . procfs. UNIX way, /proc/$pid/mem , — ( /proc/$pid/maps).

Linux mmap(), ( , ). :

 static int map_region(pid_t pid, struct memory_region *region) { size_t length = region->vaddr_high - region->vaddr_low; off_t offset = region->vaddr_low; char path[32] = {0}; snprintf(path, sizeof(path), "/proc/%d/mem", pid); /*     */ int fd = open(path, O_RDONLY); if (fd < 0) goto error; /*      */ void *buffer = malloc(length); if (!buffer) goto error_close_file; /*   */ if (read_region(fd, offset, buffer, length) < 0) goto error_free_buffer; region->content = buffer; close(fd); return 0; error_free_buffer: free(buffer); error_close_file: close(fd); error: return -1; } static int read_region(int fd, off_t offset, void *buffer, size_t length) { /*      */ if (lseek(fd, offset, SEEK_SET) < 0) return -1; size_t remaining = length; char *ptr = buffer; /* *     .   , *      ,  . */ while (remaining > 0) { ssize_t count = read(fd, ptr, remaining); if (count < 0) return -1; remaining -= count; ptr += count; } return 0; } 

ELF- . , -, , -, .

ELF

ELF — Linux. , , .

ELF . ELF . — , . , — . ELF-.

, libdl-2.19.so :

( readelf --headers .)

, , (29 9). — , , . ELF — , . Linux, , LOAD, ( ).

ELF- , . , .

, . «» . .bss, , ( ).

, ELF — , . ...

?

() . , dlsym(), . - .

ELF (. 2-10). , .dynamic , DYNAMIC . .dynamic , :

• .dynsym — ;
• .dynstr — ;
• .hash — -, .

, , ELF:

ELF, (1), (2), (3), (4) , .

ELF →

() ELF <elf.h>, , , . , ELF — . 32- 64- , , , . x86_64, ELF .

ELF- ( Elf64_Ehdr ). ( program headers ), e_phoff e_phnum :

— , , ELF- — , , , , .

e_phoff, , . e_phnum e_phentsize .

( ), ELF — 64 .

→ DYNAMIC

. — Elf64_Phdr ( 64- ELF-), . PT_DYNAMIC p_type :

:

• p_vaddr — , ;
• p_memsz — .

.dynamic 0x2D88 ( ). DYNAMIC — 0x202D88. 0x210 (8448) . .

DYNAMIC → .dynsym, .dynstr, .hash

.dynamic, DYNAMIC, . Elf64_Dyn , :

8 d_val d_ptr , 8- d_tag , , . :

• DT_HASH (4) — .hash ( d_ptr)
• DT_STRTAB (5) — .dynstr ( d_ptr)
• DT_SYMTAB (6) — .dynsym ( d_ptr)
• DT_STRSZ (10) — .dynstr ( d_val)
• DT_NULL (0) —

. .dynamic : , , , .

, DYNAMIC , . , , - , .

.dynamic , . -, .dynstr , ? .

. , .dynsym , . ( «» .symtab, , , . .)

Elf64_Sym , ELF — , , , . dlopen :

:

• st_name — ,
• st_info — ( )
• st_value —

( , nm , dlopen() .text, 0x1090 .)

, .

— - , . ( ). .dynstr , libdl-2.19.so :

, ( «dlopen», 0xA5) , . .

-

.hash - , . - — — ELF-, . , .dynsym, , . ( ) - .

- <elf.h>, (. 2-19). - , :

où

• nbuckets — buckets
• nchains — chains ( )
• buckets —
• chains —

- :

1. h .
2. i buckets[h % nbuckets] , .
3. ( ) , .
4. — chains[i % nchains] .
5. 3—4 , .

-, ELF:

 static uint32_t elf_hash(const char *name) { uint32_t h = 0; uint32_t g; while (*name) { h = (h << 4) + *name++; g = h & 0xF0000000; if (g) h ^= g >> 24; h &= ~g; } return h; } 

, "dlopen" - 112420542 :

libdl — , 39 , . - .

, :

• dlopen() dlsym() libdl
• pthread_create() pthread_detach() libpthread

, .

. . , .

ELF- . , ( ). , . , , . .

4. -

, , - , : , . - .

-

, -:

 void shellcode(void) { void *payload = dlopen("/path/to/payload.so", RTLD_LAZY); void (*entry)(void) = dlsym(payload, "entry_point"); pthread_t thread; pthread_create(&thread, NULL, entry, NULL); pthread_detach(thread); } 

?

, — . , , , - — - ! .

— - . , , : .

 /* *      .rodata:   * .         , *        . */ .section .rodata /* *   .       . *      -:    ,  *  ,       . */ .global shellcode_start .global shellcode_address_dlopen .global shellcode_address_dlsym .global shellcode_address_pthread_create .global shellcode_address_pthread_detach .global shellcode_address_payload .global shellcode_address_entry .global shellcode_end /* *   dlopen().     #include <dlfcn.h>, *       . */ .set RTLD_LAZY, 1 .align 8 shellcode_start: /* * void *payload = dlopen(shellcode_address_payload, RTLD_LAZY); * *        x86_64: * * -     %rdi, %rsi, %rdx, %rcx * -     %rax * -      * *         . * *       %rax,    *     . */ lea shellcode_address_payload(%rip),%rdi mov $RTLD_LAZY,%rsi mov shellcode_address_dlopen(%rip),%rax callq *%rax /* * void (*entry)(void) = dlsym(payload, shellcode_address_entry); */ mov %rax,%rdi lea shellcode_address_entry(%rip),%rsi mov shellcode_address_dlsym(%rip),%rax callq *%rax /* * pthread_t thread; * pthread_create(&thread, NULL, entry, NULL); * *            * ,     pthread_create(). */ sub $8,%rsp mov %rsp,%rdi xor %rsi,%rsi mov %rax,%rdx xor %rcx,%rcx mov shellcode_address_pthread_create(%rip),%rax callq *%rax /* * pthread_detach(thread); * *    ,   ,  *     . */ mov (%rsp),%rdi add $8,%rsp mov shellcode_address_pthread_detach(%rip),%rax callq *%rax /* *   - —    ,     *      ret.    *     ,  *      . */ int $3 /* *       ,   *   ,    - *     .   “  *  ” (global offset table, GOT),   *           . */ .align 8 shellcode_address_dlopen: .space 8 shellcode_address_dlsym: .space 8 shellcode_address_pthread_create: .space 8 shellcode_address_pthread_detach: .space 8 shellcode_address_payload: .space 256 shellcode_address_entry: .space 256 /* *  - . */ shellcode_end: .end 

, . :

 $ as -o shellcode.o shellcode.S 

, , , . : (procedure linkage table, PLT), .

- , (, ) . - .

-

- . , , , . ?

-

, . , . , . , .

(- ), : , , . , , JIT- , . ?

:

• - ,
• - ,

, . -, - , . -, . -, , - -, .

, . . x86_64 int $3 — 0xCC — . ptrace() PTRACE_POKETEXT — , 8 , . , , .

, , , : . - , .

?

, ! malloc()!

. , -, . . , mmap():

 void inject_shellcode(const void *shellcode_src, size_t shellcode_size) { void *shellcode_dst = mmap(NULL, shellcode_size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); copy_shellcode(shellcode_dst, shellcode_src, shellcode_size); } 

, ptrace() , .

, ? , . Linux x86_64 :

• %rax
• — — %rsi, %rdi, %rdx, %r10, %r8, %r9
• SYSCALL,
• %rax

ptrace() PTRACE_GETREGS PTRACE_SETREGS. , . - SYSCALL.

: , %rip. , , SYSCALL.

SYSCALL

SYSCALL? , . - , - . — libc. , , , :

 unsigned long find_syscall_instruction(struct library *library) { for (size_t i = 0; i < library->region_count; i++) { struct memory_region *region = &library->regions[i]; if (!(region->readable && region->executable)) continue; const uint8_t *region_data = region->content; size_t region_size = region->vaddr_high - region->vaddr_low; if (region_size < 2) continue; /* * 0F 05 syscall */ for (size_t offset = 0; offset < region_size - 1; offset++) { if (region_data[offset + 0] == 0x0F && region_data[offset + 1] == 0x05) { return region->vaddr_low + offset; } } } return 0; } 

, /proc/$pid/maps . x86_64 , - . , 0x0F 0x05. , , ARM, 0xDF 0x00 ( SVC #0), .

PTRACE_{GET,SET}REGS

:

 int get_registers(pid_t pid, struct user_regs_struct *registers) { int err = 0; if (ptrace(PTRACE_GETREGS, pid, registers, registers) < 0) err = -errno; return err; } 

struct user_regs_struct , <sys/user.h>. . . , varargs :

 static int set_regs_for_syscall(struct user_regs_struct *registers, unsigned long syscall_insn_vaddr, long syscall_number, int args_count, va_list args) { registers->rip = syscall_insn_vaddr; registers->rax = syscall_number; for (int i = 0; i < args_count; i++) { switch (i) { case 0: registers->rdi = va_arg(args, long); break; case 1: registers->rsi = va_arg(args, long); break; case 2: registers->rdx = va_arg(args, long); break; case 3: registers->r10 = va_arg(args, long); break; case 4: registers->r8 = va_arg(args, long); break; case 5: registers->r9 = va_arg(args, long); break; default: return -E2BIG; } } return 0; } static long perform_syscall(pid_t pid, unsigned long syscall_insn_vaddr, long syscall_number, int args_count, ...) { struct user_regs_struct old_registers; struct user_regs_struct new_registers; /* *    ,   *      . */ get_registers(pid, &old_registers); /* *      ,   * ,     . */ new_registers = old_registers; va_list args; va_start(args, args_count); set_regs_for_syscall(&new_registers, syscall_insn_vaddr, syscall_number, args_count, args); va_end(args); set_registers(pid, &new_registers); /* *    ,    *   ,    * (  ),    . *     . */ wait_for_syscall_completion(pid); /* *       *    . *        . */ get_registers(pid, &new_registers); long result = new_registers.rax; set_registers(pid, &old_registers); return result; } 

PTRACE_SYSCALL

: , ?

PTRACE_SYSCALL. PTRACE_CONT, . , - : , .

PTRACE_SYSCALL SIGTRAP : ( ) ( ). , ptrace() , , .

, SIGTRAP:

 static int wait_for_syscall_enter_exit_stop(pid_t pid) { if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) return -1; if (wait_for_process_stop(pid, SIGTRAP) < 0) return -1; return 0; } void wait_for_syscall_completion(pid_t pid) { wait_for_syscall_enter_exit_stop(pid); wait_for_syscall_enter_exit_stop(pid); } 

— , — (wait_for_process_stop() ). . , .

PTRACE_O_TRACESYSGOOD

, PTRACE_SYSCALL : , , - . , SIGTRAP ( ).

SIGTRAP . PTRACE_O_TRACESYSGOOD, :

• SIGTRAP — -
• SIGTRAP | 0x80 —

  int ptrace_attach(pid_t pid) { if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) return -1; if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; + /*     */ + unsigned long options = PTRACE_O_TRACESYSGOOD; + if (ptrace(PTRACE_SETOPTIONS, pid, 0, options) < 0) + return -1; return 0; } static int wait_for_syscall_enter_exit_stop(pid_t pid) { if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) return -1; - if (wait_for_process_stop(pid, SIGTRAP) < 0) + if (wait_for_process_stop(pid, SIGTRAP | 0x80) < 0) return -1; return 0; } 

-

- :

 void write_shellcode(void) { char shellcode_text[SHELLCODE_TEXT_SIZE]; size_t shellcode_size = shellcode_end - shellcode_start; /*   ,  ,  . . */ prepare_shellcode(shellcode_text, shellcode_size); /*   -   */ write_remote_memory(target, shellcode_text_vaddr, shellcode_text, shellcode_size); } 

- : dlopen(), .

 static inline void copy_shellcode(char *shellcode_text, const char *shellcode_addr, const void *data, size_t length) { ptrdiff_t offset = shellcode_addr - shellcode_start; memcpy(shellcode_text + offset, data, length); } static void prepare_shellcode(char *shellcode_text, size_t shellcode_size) { copy_shellcode(shellcode_text, shellcode_start, shellcode_start, shellcode_size); copy_shellcode(shellcode_text, shellcode_address_dlopen, &dlopen_vaddr, sizeof(dlopen_vaddr)); copy_shellcode(shellcode_text, shellcode_address_dlsym, &dlsym_vaddr, sizeof(dlsym_vaddr)); copy_shellcode(shellcode_text, shellcode_address_pthread_create, &pthread_create_vaddr, sizeof(pthread_create_vaddr)); copy_shellcode(shellcode_text, shellcode_address_pthread_detach, &pthread_detach_vaddr, sizeof(pthread_detach_vaddr)); copy_shellcode(shellcode_text, shellcode_address_payload, payload, sizeof(payload)); copy_shellcode(shellcode_text, shellcode_address_entry, entry, sizeof(entry)); } 

, , -:

 extern const char shellcode_start[]; extern const char shellcode_address_dlopen[]; extern const char shellcode_address_dlsym[]; extern const char shellcode_address_pthread_create[]; extern const char shellcode_address_pthread_detach[]; extern const char shellcode_address_payload[]; extern const char shellcode_address_entry[]; extern const char shellcode_end[]; 

, .

- . /proc/$pid/mem, :

 int write_remote_memory(pid_t pid, unsigned long vaddr, const void *data, size_t size) { char path[32] = {0}; snprintf(path, sizeof(path), "/proc/%d/mem", pid); /*       */ int fd = open(path, O_WRONLY); if (fd < 0) return -1; /*     */ if (lseek(fd, vaddr, SEEK_SET) < 0) { close(fd); return -1; } /*    */ int err = do_write_remote_memory(fd, data, size); close(fd); return err; } static int do_write_remote_memory(int fd, const void *data, size_t size) { size_t left = size; /* *    ,  ,     *   ,       *      . */ while (left > 0) { ssize_t wrote = write(fd, data, left); if (wrote < 0) return -1; data += wrote; left -= wrote; } return 0; } 

, - — « » . . - , .

5.

- . , : %rip -, PTRACE_SETREGS, PTRACE_CONT . .

, , . -? ?

, . , « » . , . :

• (async-signal-safe)

— . dlopen() pthread_create() . - dlopen(), dlopen() ?

-, , , . , pthread_create() . , ( ). clone().

pthread_create()?

, - , ?

: clone().

, (libc) (pthread). clone() (thread control block, TCB) (thread-local storage, TLS), , . . pthread_create() , .

«», clone() libc pthread. , .

clone() :

• ?
• ?
• -?

: -?

, - : , , , .

. , , . Comment? : exit(). , .

. exit() -:

 +.set __NR_exit, 60 .set RTLD_LAZY, 1 @@ - /* - *  . - */ - int $3 + /* + * exit(0); + */ + xor %rdi,%rdi + mov $__NR_exit,%rax + syscall 

: exit() — exit() . exit() , exit() — . Linux exit_group().

. . , , PROT_EXEC:

 shellcode_stack_vaddr = remote_mmap(target, syscall_vaddr, 0, SHELLCODE_STACK_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_STACK | MAP_GROWSDOWN, -1, 0); 

, Linux x86_64 — «» , . mmap() , clone() . , mmap() MAP_GROWSDOWN, , .

PTRACE_O_TRACECLONE

. , - . waitpid(), : , .

— PTRACE_O_TRACECLONE. . , . , , , . , PTRACE_ATTACH , .

-, :

 - unsigned long options = PTRACE_O_TRACESYSGOOD; + unsigned long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACECLONE; if (ptrace(PTRACE_SETOPTIONS, pid, 0, options) < 0) return -1; 

-, clone(), PTRACE_EVENT_CLONE, , PTRACE_SYSCALL. :

 -void wait_for_syscall_completion(pid_t pid) +void wait_for_syscall_completion(pid_t pid, long syscall) { wait_for_syscall_enter_exit_stop(pid); + + /*  clone()   PTRACE_EVENT_CLONE */ + if (syscall == __NR_clone) + wait_for_clone_event(pid); wait_for_syscall_enter_exit_stop(pid); } 

:

 static int wait_for_clone_event(pid_t pid) { if (ptrace(PTRACE_CONT, pid, 0, 0) < 0) return -1; int event = SIGTRAP | (PTRACE_EVENT_CLONE << 8); if (wait_for_process_stop(pid, event) < 0) return -1; return 0; } 

clone() PID , . :

 void clear_ptrace_options(pid_t pid) { ptrace(PTRACE_SETOPTIONS, pid, 0, 0); } 

, clone() ptrace(), PTRACE_O_TRACECLONE. , , - .

, - . clone() :

 static int spawn_shell_thread() { shell_tid = remote_clone(target, syscall_ret_vaddr, CLONE_FILES | CLONE_FS | CLONE_IO | CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_THREAD | CLONE_VM, /*   **  */ shellcode_stack_vaddr + SHELLCODE_STACK_SIZE); if (!shell_tid) return -1; return 0; } 

clone() : , , , . , .

CLONE_FILES, CLONE_FS, CLONE_IO, CLONE_SIGHAND, CLONE_SYSVSEM, CLONE_VM — . , CLONE_FILES , ( fork()). — — , . . , CLONE_VM , , .

CLONE_THREAD : Linux — « », . , , getpid() , kill() — - , execve() — , .

, clone() fork(): , . clone() : , — . . ( , , .)

, pthread_create() , , . ?

fork() :

 pid_t child = fork(); if (child < 0) { /* fork() ,    */ } if (child == 0) { /*     execve() */ } /*     */ 

, . clone() . .

. , clone() , . syscall ret, , . .

SYSCALL + RET

, . , syscall ret:

 -if (region_size < 2) +if (region_size < 3) continue; /* * 0F 05 syscall + * C3 retq */ -for (size_t offset = 0; offset < region_size - 1; offset++) { +for (size_t offset = 0; offset < region_size - 2; offset++) { if (region_data[offset + 0] == 0x0F && - region_data[offset + 1] == 0x05) + region_data[offset + 1] == 0x05 && + region_data[offset + 2] == 0xC3) { return region->vaddr_low + offset; } } 

, .

. prepare_shellcode() , , :

  void write_shellcode(void) { char shellcode_text[SHELLCODE_TEXT_SIZE]; size_t shellcode_size = shellcode_end - shellcode_start; /*   ,  ,  . . */ prepare_shellcode(shellcode_text, shellcode_size); /*   -   */ write_remote_memory(target, shellcode_text_vaddr, shellcode_text, shellcode_size); + /*    «»   */ + unsigned long retaddr_vaddr = + shellcode_stack_vaddr + SHELLCODE_STACK_SIZE - 8; + write_remote_memory(target, retaddr_vaddr, + &shellcode_text_vaddr, sizeof(shellcode_text_vaddr)); } 

, , .

, , . System V ABI , ( %rsp) 16 . shellcode_stack_vaddr + SHELLCODE_STACK_SIZE : ( 4096 ), 1 . 8 , , retq, - . - :

 - sub $8,%rsp + sub $16,%rsp /*   */ mov %rsp,%rdi xor %rsi,%rsi mov %rax,%rdx xor %rcx,%rcx mov shellcode_address_pthread_create(%rip),%rax callq *%rax 

, %rsp 16 pthread_create(). SIGSEGV, — pthread_create() , .

, - , clone():

  static int spawn_shell_thread() { shell_tid = remote_clone(target, syscall_ret_vaddr, CLONE_FILES | CLONE_FS | CLONE_IO | CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_THREAD | CLONE_VM, /*   **  */ - shellcode_stack_vaddr + SHELLCODE_STACK_SIZE); + shellcode_stack_vaddr + SHELLCODE_STACK_SIZE - 8); if (!shell_tid) return -1; return 0; } 

ptrace() SIGSTOP, :

 int ignore_thread_stop(pid_t pid) { return wait_for_process_stop(pid, SIGSTOP); } 

C’est tout. ptrace():

 void resume_thread(pid_t pid) { ptrace(PTRACE_CONT, pid, 0, 0); } 

, , , exit(). waitpid(). — CLONE_THREAD wait() ,— PTRACE_O_TRACECLONE, :

 int wait_for_process_exit(pid_t pid) { int status = 0; if (waitpid(pid, &status, 0) < 0) return -1; if (!WIFEXITED(status)) return -1; return WEXITSTATUS(status); } 

pthread , , pthread_join() pthread , . , — . , , .

Mémoire libre

, - . , - , munmap():

 void remote_munmap(pid_t pid, unsigned long syscall_insn_vaddr, unsigned long addr, size_t len) { perform_syscall(pid, syscall_insn_vaddr, __NR_munmap, 2, (long) addr, (long) len); } static void unmap_shellcode() { remote_munmap(target, syscall_ret_vaddr, shellcode_text_vaddr, SHELLCODE_TEXT_SIZE); remote_munmap(target, syscall_ret_vaddr, shellcode_stack_vaddr, SHELLCODE_STACK_SIZE); } 

, , , — ptrace() . (, SIGSTOP), , ( ):

 int stop_thread(pid_t pid) { if (kill(pid, SIGSTOP) < 0) return -1; if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; return 0; } 

, , . PTRACE_DETACH:

 int ptrace_detach(pid_t pid) { if (ptrace(PTRACE_DETACH, pid, 0, 0) < 0) return -1; return 0; } 

, . , . , .

Conclusion

? . , , .

Linux . GTK+ . , make:

 libpayload.so: payload.c $(CC) $(CFLAGS) $(shell pkg-config --cflags --libs gtk+-3.0) -shared -o $@ $< 

entry() GTK- — GTK UI , :

 #include <glib.h> #include <gtk/gtk.h> static gboolean actual_entry(gpointer _arg) { /*       : */ hook_gtk_entry_constructor(); /*   FALSE,       */ return FALSE; } void entry(void) { /*    -,   */ g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, actual_entry, NULL, NULL); } 

, GTK , GtkEntry . "input-purpose" . «», , .

GTK glib — — GtkEntry . constructed(), . :

 static void (*old_gtk_entry_constructed)(GObject *object); static void new_gtk_entry_constructed(GObject *object) { GtkEntry *entry = GTK_ENTRY(object); /*    */ old_gtk_entry_constructed(object); /*    ,  ,   entry */ } static void hook_gtk_entry_constructor(void) { /*     GtkEntry */ GTypeClass *entry_type_class = g_type_class_peek(GTK_TYPE_ENTRY); GObjectClass *entry_object_class = G_OBJECT_CLASS(entry_type_class); /* *     "constructed"     . */ old_gtk_entry_constructed = entry_object_class->constructed; entry_object_class->constructed = new_gtk_entry_constructed; } 

GtkEntry :

• , ,

, GtkEntry , , . , :

 static void new_gtk_entry_constructed(GObject *object) { GtkEntry *entry = GTK_ENTRY(object); old_gtk_entry_constructed(object); /*       */ g_signal_connect(entry, "notify::input-purpose", G_CALLBACK(input_purpose_changed), NULL); /*      */ g_signal_connect(entry, "icon-press", G_CALLBACK(icon_pressed), NULL); /*      */ g_signal_connect(entry, "icon-release", G_CALLBACK(icon_released), NULL); } 

. , . .

 static void input_purpose_changed(GtkEntry *entry) { GtkInputPurpose purpose = gtk_entry_get_input_purpose(entry); if (purpose == GTK_INPUT_PURPOSE_PASSWORD) { gtk_entry_set_icon_activatable(entry, GTK_ENTRY_ICON_PRIMARY, TRUE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-remove"); } else { gtk_entry_set_icon_activatable(entry, GTK_ENTRY_ICON_PRIMARY, FALSE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, NULL); } } 

: , , , - , :

 static void icon_pressed(GtkEntry *entry, GtkEntryIconPosition position) { if (position != GTK_ENTRY_ICON_PRIMARY) return; gtk_entry_set_visibility(entry, TRUE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-add"); } static void icon_released(GtkEntry *entry, GtkEntryIconPosition position) { if (position != GTK_ENTRY_ICON_PRIMARY) return; gtk_entry_set_visibility(entry, FALSE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-remove"); } 

C’est tout.

GitHub (GPLv2).

, . gdb :

 $ gdb --pid $(pgrep target) \ --batch \ -ex 'compile file -raw shell-code.c'