Comment détecter si le processus en cours est exécuté par GDB ?

Question

La méthode standard serait la suivante :

if (ptrace(PTRACE_TRACEME, 0, NULL, 0) == -1)
  printf("traced!\n");

Dans ce cas, ptrace renvoie une erreur si le processus actuel est tracé (c'est-à-dire en l'exécutant avec gdb ou en s'y attachant).

Mais il y a un sérieux problème avec ceci : si l'appel retourne avec succès, gdb peut ne pas s'y attacher plus tard. Ce qui est un problème puisque je n'essaie pas d'implémenter un système anti-débogage. Mon but est d'émettre un 'int 3' lorsqu'une condition est remplie (c'est-à-dire qu'une assert échoue) et que gdb est en cours d'exécution (sinon j'obtiens un SIGTRAP qui arrête l'application).

Désactiver SIGTRAP et émettre un 'int 3' à chaque fois n'est pas une bonne solution car l'application que je teste pourrait utiliser SIGTRAP dans un autre but (auquel cas je suis toujours dans la merde, donc ça n'aurait pas d'importance mais c'est le principe de la chose :)).

Gracias

Answer 1

Sous Windows, il existe une API IsDebuggerPresent pour vérifier si le processus est en cours de débogage. Sous linux, nous pouvons vérifier cela d'une autre manière (pas si efficace).

Vérifier " /proc/self/status "pour " TracerPid Attribut ".

Exemple de code :

#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <ctype.h>

bool debuggerIsAttached()
{
    char buf[4096];

    const int status_fd = ::open("/proc/self/status", O_RDONLY);
    if (status_fd == -1)
        return false;

    const ssize_t num_read = ::read(status_fd, buf, sizeof(buf) - 1);
    ::close(status_fd);

    if (num_read <= 0)
        return false;

    buf[num_read] = '\0';
    constexpr char tracerPidString[] = "TracerPid:";
    const auto tracer_pid_ptr = ::strstr(buf, tracerPidString);
    if (!tracer_pid_ptr)
        return false;

    for (const char* characterPtr = tracer_pid_ptr + sizeof(tracerPidString) - 1; characterPtr <= buf + num_read; ++characterPtr)
    {
        if (::isspace(*characterPtr))
            continue;
        else
            return ::isdigit(*characterPtr) != 0 && *characterPtr != '0';
    }

    return false;
}

Answer 2

Le code que j'ai fini par utiliser est le suivant :

int
gdb_check()
{
  int pid = fork();
  int status;
  int res;

  if (pid == -1)
    {
      perror("fork");
      return -1;
    }

  if (pid == 0)
    {
      int ppid = getppid();

      /* Child */
      if (ptrace(PTRACE_ATTACH, ppid, NULL, NULL) == 0)
        {
          /* Wait for the parent to stop and continue it */
          waitpid(ppid, NULL, 0);
          ptrace(PTRACE_CONT, NULL, NULL);

          /* Detach */
          ptrace(PTRACE_DETACH, getppid(), NULL, NULL);

          /* We were the tracers, so gdb is not present */
          res = 0;
        }
      else
        {
          /* Trace failed so gdb is present */
          res = 1;
        }
      exit(res);
    }
  else
    {
      waitpid(pid, &status, 0);
      res = WEXITSTATUS(status);
    }
  return res;
}

Quelques trucs :

• Lorsque ptrace(PTRACE_ATTACH, ...) réussit, le processus tracé s'arrête et doit être poursuivi.
• Cela fonctionne également lorsque gdb s'attache ultérieurement.
• L'inconvénient est que, lorsqu'il est utilisé fréquemment, il provoque un sérieux ralentissement.
• De plus, il a été confirmé que cette solution ne fonctionne que sur Linux. Comme le mentionnent les commentaires, elle ne fonctionnera pas sur BSD.

Quoi qu'il en soit, merci pour les réponses.

Answer 3

Auparavant, en guise de commentaire : vous pourriez bifurquer vers un enfant qui essaierait de PTRACE_ATTACH son parent (puis le détacher si nécessaire) et communique le résultat en retour. Cela semble cependant un peu inélégant.

Comme vous le mentionnez, cela est assez coûteux. Je suppose que ce n'est pas trop grave si les assertions échouent de façon irrégulière. Peut-être que cela vaudrait la peine de garder un seul enfant qui tourne longtemps pour faire cela - partager deux tuyaux entre le parent et l'enfant, l'enfant fait sa vérification quand il lit un octet et renvoie ensuite un octet avec le statut.

Answer 4

J'ai eu un besoin similaire, et j'ai trouvé les alternatives suivantes

static int _debugger_present = -1;
static void _sigtrap_handler(int signum)
{
    _debugger_present = 0;
    signal(SIGTRAP, SIG_DFL);
}

void debug_break(void)
{
    if (-1 == _debugger_present) {
        _debugger_present = 1;
        signal(SIGTRAP, _sigtrap_handler);
        raise(SIGTRAP);
    }
}

Si elle est appelée, la fonction debug_break ne s'interrompra que si un débogueur est attaché.

Si vous exécutez sur x86 et que vous voulez un point d'arrêt qui s'interrompt dans l'appelant (et non pas dans soulever ), il suffit d'inclure l'en-tête suivant et d'utiliser la macro debug_break :

#ifndef BREAK_H
#define BREAK_H

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

int _debugger_present = -1;
static void _sigtrap_handler(int signum)
{
    _debugger_present = 0;
    signal(SIGTRAP, SIG_DFL);
}

#define debug_break()                       \
do {                                        \
    if (-1 == _debugger_present) {          \
        _debugger_present = 1;              \
        signal(SIGTRAP, _sigtrap_handler);  \
        __asm__("int3");                    \
    }                                       \
} while(0)

#endif

Answer 5

J'ai découvert qu'une version modifiée du "hack" du descripteur de fichier décrit par Silviocesare y blogué par xorl a bien fonctionné pour moi.

Voici le code modifié que j'utilise :

#include <stdio.h>
#include <unistd.h>

// gdb apparently opens FD(s) 3,4,5 (whereas a typical prog uses only stdin=0, stdout=1,stderr=2)
int detect_gdb(void)
{
    int rc = 0;
    FILE *fd = fopen("/tmp", "r");

    if (fileno(fd) > 5)
    {
        rc = 1;
    }

    fclose(fd);
    return rc;
}