Скопируйте функцию в память и выполните ее

Вы, кажется, поняли часть о флагах защиты. Если вы знаете размер функции, теперь вы можете просто выполнить memcpy() и передать адрес f1 в качестве исходного адреса.

Одно большое предостережение заключается в том, что на многих платформах вы не сможете вызывать какие-либо другие функции из той, которую вы копируете (f1), потому что относительные адреса жестко закодированы в двоичном коде функции и перемещают ее в другой код. расположение в памяти может привести к тому, что эти относительные адреса станут плохими.

Это работает, потому что функция1 и функция2 имеют одинаковый размер в памяти. Нам нужна длина function2 для нашей memcopy, поэтому нужно сделать следующее: int diff = (&main - &function2);

Вы заметите, что можете редактировать функцию 2 по своему вкусу, и она продолжает работать нормально!

Кстати ловкий трюк. К сожалению, компилятор g++ выдает неверное преобразование из void* в int... Но на самом деле с gcc он отлично компилируется;)

Модифицированные источники:

//Hacky solution and simple proof of concept that works for me (and compiles without warning on Mac OS X/GCC 4.2.1):
//fixed the diff address to also work when function2 is variable size    
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include <sys/mman.h>

int function1(int x){ 
   return x-5;
}   

int function2(int x){ 
  //printf("hello world");
  int k=32;
  int l=40;
  return x+5+k+l;
}   


int main(){
  int diff = (&main - &function2);
  printf("pagesize: %d, diff: %d\n",getpagesize(),diff);

  int (*fptr)(int);

  void *memfun = malloc(4096);

  if (mprotect(memfun, 4096, PROT_READ|PROT_EXEC|PROT_WRITE) == -1) {
      perror ("mprotect");
  }   

  memcpy(memfun, (const void*)&function2, diff);

  fptr = &function1;
  printf("native: %d\n",(*fptr)(6));
  fptr = memfun;
  printf("memory: %d\n",(*fptr)(6) );
  fptr = &function1;
  printf("native: %d\n",(*fptr)(6));

  free(memfun);
  return 0;
}   

Выход:

Walter-Schrepperss-MacBook-Pro:cppWork wschrep$ gcc memoryFun.c 
Walter-Schrepperss-MacBook-Pro:cppWork wschrep$ ./a.out 
pagesize: 4096, diff: 35
native: 1
memory: 83
native: 1

Еще одно замечание: вызов printf приведет к segfault, потому что printf, скорее всего, не будет найден из-за неправильного относительного адреса...

Хакерское решение и простое доказательство концепции, которое работает для меня (и компилируется без предупреждения в Mac OS X/GCC 4.2.1):

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include <sys/mman.h>

int function1(int x){
   return x-5;
}

int function2(int x){
  return x+5;
}


int main(){
  int diff = (&function2 - &function1);
  printf("pagesize: %d, diff: %d\n",getpagesize(),diff);

  int (*fptr)(int);

  void *memfun = malloc(4096);

  if (mprotect(memfun, 4096, PROT_READ|PROT_EXEC|PROT_WRITE) == -1) {
      perror ("mprotect");
  }

  memcpy(memfun, (const void*)&function2, diff);

  fptr = &function1;
  printf("native: %d\n",(*fptr)(6));
  fptr = memfun;
  printf("memory: %d\n",(*fptr)(6) );
  fptr = &function1;
  printf("native: %d\n",(*fptr)(6));

  free(memfun);
  return 0;
}

Я пробовал эту проблему много раз в C и пришел к выводу, что это невозможно решить, используя только язык C. Моя главная проблема заключалась в том, чтобы найти длину функции для копирования.

Стандартный язык C не предоставляет никаких методов для получения длины функции. Однако можно использовать язык ассемблера и «разделы», чтобы найти длину. Как только длина найдена, копирование и выполнение становятся простыми.

Самое простое решение — создать или определить сегмент компоновщика, содержащий функцию. Напишите модуль на языке ассемблера для вычисления и публичного объявления длины этого сегмента. Используйте эту константу для размера функции.

Существуют и другие методы, включающие настройку компоновщика, такие как предопределенные области или фиксированные местоположения и копирование этих местоположений.

Во встраиваемых системах большая часть кода, который копирует исполняемые файлы в оперативную память, написана на ассемблере.

Это может быть решение взлома здесь. Не могли бы вы создать фиктивную переменную или функцию непосредственно после функции (для копирования), получить адрес этой фиктивной переменной/функции, а затем взять адрес функции, чтобы выполнить арифметику суммирования, используя адреса для получения размера функции? Это возможно, поскольку память распределяется линейно и упорядоченно (а не случайным образом). Это также позволит сохранить копирование функций в рамках переносимого характера ANSI C, а не вникать в системный ассемблерный код. Я нахожу C довольно гибким, нужно просто все обдумать.