Как испортить стек в программе на C

Вот решение, не совсем стабильное в разных средах, но у меня работает на процессоре x86_64 в Windows/MinGW64. Это может не работать для вас из коробки, но все же вы можете использовать аналогичный подход.

void function_b(void) {
    char buffer[4];
    buffer[0] = 0xa1; // part 1
    buffer[1] = 0xb2;
    buffer[2] = 0xc3;
    buffer[3] = 0x04;
    register int * rsp asm ("rsp"); // part 2
    register size_t r10 asm ("r10");
    r10 = 0;
    while (*rsp != 0x04c3b2a1) {rsp++; r10++;} // part 3
    while (*rsp != 0x00b1c2d3) rsp++; // part 4
    rsp -= r10; // part 5
    rsp = (int *) ((size_t) rsp & ~0xF); // part 6
    fprintf(stdout, "Executing function_b\n");
}

Хитрость в том, что у каждого из function_a и function_b есть только одна локальная переменная, и мы можем найти адрес этой переменной, просто поискав в памяти.

1. Сначала ставим в буфер сигнатуру, пусть это будет 4-х байтное целое число 0x04c3b2a1 (помните, что x86_64 имеет прямой порядок байтов).

2. После этого мы объявляем две переменные для представления регистров: rsp — это указатель стека, а r10 — просто какой-то неиспользуемый регистр. Это позволяет не использовать операторы asm позже в коде, но при этом иметь возможность напрямую использовать регистры. Важно, что переменные на самом деле не занимают память стека, они сами являются ссылками на регистры процессора.

3. После этого мы перемещаем указатель стека с шагом в 4 байта (поскольку размер int равен 4 байтам), пока не дойдем до buffer. Мы должны помнить смещение от указателя стека до первой переменной здесь, и мы используем r10 для его сохранения.

4. Далее мы хотим узнать, как далеко в стеке находятся экземпляры function_b и function_a. Хорошее приближение — это расстояние между buffer и beacon, поэтому теперь мы ищем beacon.

5. После этого мы должны вернуться от beacon, первой переменной function_a, к началу экземпляра всего function_a в стеке. Это мы делаем, вычитая значение, хранящееся в r10.

6. Наконец, вот еще немного. По крайней мере, в моей конфигурации стек оказывается выровненным по 16 байтам, и в то время как массив buffer выравнивается по левому краю 16-байтового блока, переменная beacon выравнивается по правому краю такого блока. Или это что-то с похожим эффектом и другим объяснением?.. Так или иначе, поэтому мы просто очищаем последние четыре бита указателя стека, чтобы он снова выровнялся по 16 байтам. 32-битный GCC для меня ничего не выравнивает, поэтому вы можете пропустить или изменить эту строку.

При работе над решением мне пригодился следующий макрос:

#ifdef DEBUG
#define show_sp() \
    do { \
        register void * rsp asm ("rsp"); \
        fprintf(stdout, "stack pointer is %016X\n", rsp); \
    } while (0);
#else
#define show_sp() do{}while(0);
#endif

После этого, когда вы вставляете show_sp(); в свой код и компилируете с -DDEBUG, он печатает значение указателя стека в соответствующий момент. При компиляции без -DDEBUG макрос просто компилируется в пустой оператор. Конечно, другие переменные и регистры можно вывести аналогичным образом.

хорошо, предположим, что эпилог (то есть код в } строке) для function_a и для function_b одинаков

несмотря на то, что функции A и B не симметричны, мы можем предположить это, потому что они имеют одинаковую сигнатуру (без параметров, без возвращаемого значения), одинаковые соглашения о вызовах и одинаковый размер локальных переменных (4 байта - int beacon = 0x0b1c2d3 против char buffer[4];) и с оптимизацией - обе должны быть удалены, потому что неиспользованный. но мы не должны использовать дополнительные локальные переменные в function_b, чтобы не нарушить это предположение. самый проблемный момент здесь - то, что function_A или function_B будет использовать энергонезависимые регистры (и в результате сохранить его в прологе и восстановить в эпилоге) - но однако похоже здесь не место для этого.

поэтому мой следующий код основан на этом предположении - epilogueA == epilogueB (на самом деле решение @Gassa также основано на нем.

также нужно очень четко указать, что function_a и function_b не должны быть встроенными. это очень важно - без этого никакое решение невозможно. поэтому я позволил себе добавить атрибут noinline к function_a и function_b. примечание - не изменение кода, а добавление атрибута, что автор этой задачи неявно подразумевает, но не указывает явно. не знаю, как в GCC пометить функцию как noinline, но в CL для этого используется __declspec(noinline).

следующий код, который я пишу для компилятора CL, где существует следующая встроенная функция

void * _AddressOfReturnAddress();

но я думаю, что GCC также должен иметь аналог этой функции. также я использую

void* _ReturnAddress();

но на самом деле _ReturnAddress() == *(void**)_AddressOfReturnAddress() и мы можем использовать только _AddressOfReturnAddress(). простое использование _ReturnAddress() делает исходный (но не двоичный) код меньше и читабельнее.

и следующий код работает как для x86, так и для x64. и этот код работает (проверено) с любой оптимизацией.

несмотря на то, что я использую 2 глобальные переменные - код является потокобезопасным - действительно мы можем вызывать main из нескольких потоков одновременно, вызывать его несколько раз - но все будет работать правильно (только, конечно, как я говорю в начале, если epilogueA == epilogueB)

надеюсь, комментарии в коде достаточно сами объяснили

__declspec(noinline) void function_b(void){
    char buffer[4];

    buffer[0] = 0;

    static void *IPa, *IPb;

    // save the IPa address
    _InterlockedCompareExchangePointer(&IPa, _ReturnAddress(), 0);

    if (_ReturnAddress() == IPa)
    {
        // we called from function_a
        function_b();
        // <-- IPb
        if (_ReturnAddress() == IPa)
        {
            // we called from function_a, change return address for return to IPb instead IPa
            *(void**)_AddressOfReturnAddress() = IPb;
            return;
        }
        // we at stack of function_a here.
        // we must be really at point IPa
        // and execute fprintf(stdout, "Executed function_b\n"); + '}' (epilogueA)
        // but we will execute fprintf(stdout, "Executing function_b\n"); + '}' (epilogueB)
        // assume that epilogueA == epilogueB
    }
    else
    {
        // we called from function_b
        IPb = _ReturnAddress();
        return;
    }

    fprintf(stdout, "Executing function_b\n");
    // epilogueB
}

__declspec(noinline) void function_a(void) {
    int beacon = 0x0b1c2d3;
    fprintf(stdout, "Executing function_a\n");
    function_b();
    // <-- IPa
    fprintf(stdout, "Executed function_b\n");
    // epilogueA
}

int main(void) {
    function_a();
    fprintf(stdout, "Finished!\n");
    return 0;
}