как итеративно или рекурсивно различать структуру, такую ​​как структура C / C ++, при ее изменении

Question

это может показаться слишком сложным или слишком простым вопросом,

, но как поступить с разложением структуры C или C ++ или аналогичной, ища значения, которые либо меняются, либо не меняются, принимая во вниманиесуществование подструктур и указателей на подструктуры, такие как struct b substruct[5];

, в основном имитирующие классические «адреса памяти поиска от x до y, и регистрируют каждый адрес в соответствии с условием, а затем повторяют» подход поиска надежного / ненадежногоадреса для значений, кроме примененных к структуре вместо

структура может быть получена (обычно) с помощью любого хорошего отладчика, такого как опция gdb p или API Python в gdb

или radare2, но я понятия не имею, как это сделать со структурой двоичного файла

, самое близкое, что у меня есть

[0x000051c0]> "td struct foo {char* a; int b;}"
[0x000051c0]> tp foo

, но это не печатает внутреннюю структуру файловсам как gdb p, только тот, который объявлен в radare2

или через сам исходный код

примечание, которое я могу получитьструктура через gdb (с некоторыми ошибками, такими как прямые и непрямые циклы рекурсии из-за чего-то вроде этого):

ПРИМЕЧАНИЕ: все следующие структуры генерируются через api gdb python, если не указано иное

очевидный пример:

struct a {
    struct a b;
} a; // not generated
a.b = a; // a.b now loops back to self resulting in a direct recursion loop, a.b == a thus a.b.a.b.a.b.a.b == a

и более сложный пример:

struct a{
    int val1;
    int val2;
    struct a * next;
    char * string
}; // not generated
struct a * linked_list;
linked_list = malloc(1*sizeof(struct a));
*linked_list = (struct a) {20,20,NULL,"HI"};
(*linked_list).next = malloc(1*sizeof(struct a));
*(*linked_list).next = (struct a) {5,5,NULL,"HI"};
(*(*linked_list).next).next = malloc(1*sizeof(struct a));
*(*(*linked_list).next).next = (struct a) {5,5,NULL,"HI"};

, который выдаст

struct a {
    int val1 = 20;
    int val2 = 20;
    struct a {
        int val1 = 5;
        int val2 = 5;
        struct a {
            int val1 = 5;
            int val2 = 5;
            struct a * next = NULL;
            char * string = 0x555555554b94 "HI";
        }  next;
        char * string = 0x555555554b94 "HI";
    } * next;
    char * string = 0x555555554b94 "HI";
} * linked_list;

однако, если мы изменим

*(*(*linked_list).next).next = (struct a) {5,5,NULL,"HI"};

до

*(*(*linked_list).next).next = (struct a) {5,5,linked_list,"HI"};

тогда мы получим

struct a {
    int val1 = 20;
    int val2 = 20;
    struct a {
        int val1 = 5;
        int val2 = 5;
        struct a {
            int val1 = 5;
            int val2 = 5;
            struct a {
                /* loops back to struct a { ... } * linked_list; thus entering indirect infinite recursion */
            } * next // not generated as script does not handle recursion yet
            char * string = 0x555555554b94 "HI";
        }  next;
        char * string = 0x555555554b94 "HI";
    } * next;
    char * string = 0x555555554b94 "HI";
} * linked_list;

, но на самом деле речь не идет о предотвращении рекурсии, хотя это помогает узнать, где и как это может происходить в структуре или подобном, такdiff не входит в бесконечную рекурсию сам, в зависимости от того, как она будет работать, будь то трассировка, анализ или другие средства

в теории структура diff должна выглядеть примерно так

, учитывая следующееструктурные изменения struct a объявлены в сложном примере:

struct a {
  int val1 = 5;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} A;
struct a {
  int val1 = 20;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * A_PTR_ONE_STAR;
struct a {
  int val1 = 21;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} ** A_PTR_TWO_STAR;
struct a {
  int val1 = 22;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} *** A_PTR_THREE_STAR;
struct a {
  int val1 = 20;
  struct a {
    int val1 = 5;
    struct a * next = NULL;
    int val2 = 0;
    char * string = 0x555555554b44 "HI";
  } * next;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * linked_list;

разница должна давать следующие

мы не будем навязывать строгие условия, такие как значение musне может происходить более одного раза, так как это было бы несправедливо, поскольку его можно использовать для проверки значений, которые уникальны тем, что никогда не встречаются более одного раза

. Мы будем использовать следующую исходную структуру для обоих условий, чтобы избежать дублирования воба примера

original:
struct a {
  int val1 = 5;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} A;

diff:
struct a {
  int val1 = 5;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} A;

если условие - это значения, которые изменились:

original:
struct a {
  int val1 = 20;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * A_PTR_ONE_STAR;

diff:
struct a {
  int val1 = 20;
  NULL
  NULL
  NULL
} * A_PTR_ONE_STAR; // not generated

original:
struct a {
  int val1 = 21;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} ** A_PTR_TWO_STAR;

diff:
struct a {
  int val1 = 21;
  NULL
  NULL
  NULL
} ** A_PTR_TWO_STAR; // not generated

original:
struct a {
  int val1 = 22;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} *** A_PTR_THREE_STAR;

diff:
struct a {
  int val1 = 22;
  NULL
  NULL
  NULL
} *** A_PTR_THREE_STAR; // not generated

original:
struct a {
  int val1 = 20;
  struct a {
    int val1 = 5;
    struct a * next = NULL;
    int val2 = 0;
    char * string = 0x555555554b44 "HI";
  } * next;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * linked_list;

diff:
struct a {
  int val1 = 20;
  NULL
  NULL
  NULL
} * linked_list; // not generated

и для условия, что значения не должны изменяться:

original:
struct a {
  int val1 = 20;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * A_PTR_ONE_STAR;

diff:
struct a {
  NULL
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * A_PTR_ONE_STAR; // not generated

original:
struct a {
  int val1 = 21;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} ** A_PTR_TWO_STAR;

diff:
struct a {
  NULL
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} ** A_PTR_TWO_STAR; // not generated

original:
struct a {
  int val1 = 22;
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} *** A_PTR_THREE_STAR;

diff:
struct a {
  NULL
  struct a * next = NULL;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} *** A_PTR_THREE_STAR; // not generated

original:
struct a {
  int val1 = 20;
  struct a {
    int val1 = 5;
    struct a * next = NULL;
    int val2 = 0;
    char * string = 0x555555554b44 "HI";
  } * next;
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * linked_list;

diff:
struct a {
  NULL
  NULL
  int val2 = 0;
  char * string = 0x555555554b44 "HI";
} * linked_list; // not generated