Niecałe trzy lata temu opublikowałem post pod tytułem "Wolność dla wszystkiego, czyli kompletne anihilowanie pamięci procesu", który był opisem próby uwolnienia wszystkich regionów pamięci należących do danej Windowsowej aplikacji, z poziomu tejże aplikacji. Wczoraj dostałem maila od raphael<AT>gfreedom<DOT>org z opisem (udanej) próby wykonania podobnego eksperymentu pod systemem opartym o jądro Linux. Dostałem również zgodę na opublikowanie jego maila w formie postu gościnnego, co niniejszym czynie.

Zanim przejdę do rzeczy, krótka uwaga skierowana do co bardziej początkujących czytelników mojego bloga: zwróćcie uwagę jak autor maila poradził sobie z napotkanymi problemami - często nie trzeba znać najbardziej optymalnej metody na osiągnięcie czegoś, wystarczy trochę pomyśleć i pokombinować :)

OK, without further ado:

-- Post gościnny by raphael<AT>gfreedom<DOT>org --

Gdy czytałem posta na Twoim blogu "Wolność dla wszystkiego, czyli kompletne anihilowanie pamięci procesu" (http://gynvael.coldwind.pl/?id=91) zapamiętałem tylko kilka rzeczy: zostaje mały fragment pamięci i działa to na Windowsie. Oczywiście pomyślałem o Linuksie. Ale nie wiedziałem jak to zorganizować. Potrzebne mi były funkcje jak VirtualFree().
Potem przeczytałem "Simplified Assembly Loader" (http://gynvael.coldwind.pl/?id=387), i w kodzie źródłowym było wywołanie mmap().
Myśląc dalej, jeżeli jest mmap(), to musi być munmap(). Jest. Pojawiła się wtedy koncepcja. Brakowało mi tylko informacji co konkretnie mam zwolnić. (przypominam, że zapomniałem co wcześniej przeczytałem; zrobiłeś VirtualProtect() a następnie VirtualFree() na całej pamięci. Swoją drogą nie wiem czy to będzie działać na Linuksie przez mprotect() oraz munmap() ).

I przypomniałem sobie o katalogu /proc. W pliku /proc/<PID>/maps są wszystkie mapy pamięci z adresami. Nie zastanawiając się więcej zacząłem pisać.
Zasada działania programu:
* Alokujemy 4KB pod adresem 0x08000000.
* Zapisujemy fragment kodu pod adres 0x08000800 (przypadkowo wybrałem taki sam adres)
* Czytamy plik maps, początek oraz koniec mapy (pomijając nasz obszar)
* Zapisujemy informacje, początek i długość, pod adresy 0x08000000 oraz 0x08000100
* Zapisujemy liczbę wpisów pod adres 0x080007fc
* jmp lub call pod 0x08000800
* Kod wykonuje munmap() dla każdego zestawu.
* Potem pause()
* I exit() dla pewności.

Wygląda to tak:
Kod asm:
bits 32
org 0x08000800                   ;pod ten adres zostanie załadowany kod
begin:
mov esi, [0x080007fc]            ;ładujemy ilość wpisów
loop:
and esi, esi                     ;sprawdzamy czy jakieś zostały
jz inf                           ;jeżeli nie opuszczamy pętle
dec esi
mov eax, 91                      ;munmap()
mov ebx, [0x08000000+esi*4]
mov ecx, [0x08000100+esi*4]
int 0x80
jmp loop
inf: mov eax, 29                 ;pause()
int 0x80
mov eax, 1                       ;exit()
int 0x80
Kompilujemy: nasm -f bin -o code.bin code.asm

I wstawiamy jako string do poniższego kodu.
Miałem tutaj zonka, hexdump odwraca bajty. np 0x12, 0x34, 0x56, 0x78 wyświetla jak 0x34, 0x12, 0x78, 0x56. Napisałem małe narzędzie które utworzy cały string, 15 min pracy.
Nie znalazłem disasemblera dla czystych plików binarnych, napisałem własny z wykorzystaniem libdisasm, 30 min pracy.
Kod w C:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/mman.h>

unsigned char* code=
{
"\x8b\x35\xfc\x07\x00\x08\x21\xf6\x74\x18\x4e\xb8\x5b\x00\x00\x00\x8b\x1c\xb5\x00\x00"
"\x00\x08\x8b\x0c\xb5\x00\x01\x00\x08\xcd\x80\xeb\xe4\xb8\x1d\x00\x00\x00\xcd\x80\xb8"
"\x01\x00\x00\x00\xcd\x80"
};

unsigned int code_length=48;

int main()
{
  int pid;
  void* pointer;
  FILE* file;
  char name[24];
  char buf[128];
  int i=0;
  unsigned int begin,end,length;
  unsigned long* start_table=(unsigned long*)0x08000000;
  unsigned long* length_table=(unsigned long*)0x08000100;
  unsigned int total=0;
  int* num;
  pid=getpid();
  printf("PID: %d\n",pid);
  pointer=(void*)0x08000000;
  printf("Alokacja jednej ramki pod adresem %p\n",pointer);
  pointer=mmap(pointer,0x1000,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE,0,0);
  if(pointer!=(void*)0x08000000)
  {
      perror("mmap() : ");
      exit(2);
  }
  printf("Alokacja udana: %p\n",pointer);
  //tutaj kopiujemy kod do ramki
  printf("Zapisywanie kodu pod adresem 0x08000800\n");
  memcpy((void*)0x08000800,code,code_length);


  printf("Wyznaczanie pliku nazwy pliku... ");
  sprintf(name,"/proc/%d/maps",pid);
  printf("%s\n",name);
  printf("Otwieranie pliku... ");
  file=fopen(name,"r");
  if(file==NULL)
  {
      printf("Nie można otworzyć pliku %s\n",name);
      exit(2);
  }
  printf("OK\n");

  printf("Odczyt map pamięci...\n");
  while(!feof(file))
  {
      if(fgets(buf,128,file)==NULL) break;
      sscanf(buf,"%x-%x",&begin,&end);
      length=end-begin;
      total+=length;
      printf("Segment begin=0x%08x, end=0x%08x, length=0x%08x  %u\n",begin,end,length,length);
      if(begin!=0x08000000)
      {
          start_table[i]=begin;
          length_table[i]=length;
          i++;
      }
  }
  fclose(file);
  printf("Wszystkich segmentów:            %d\n",i+1);
  printf("Całkowity rozmiar:               0x%08x , %dB\n",total,total);
  printf("Rozmiar segmentów do usunięcia:  0x%08x , %dB\n",total-4096,total-4096);
  printf("Naciśnij enter aby kontynuować...");
  munlockall();
  num=(int*) 0x080007fc;
  *num=i;
  getchar();
  __asm__ __volatile__ ("jmp 0x08000800\n");
  return 0;
}

I w pamięci pozostaje tylko 4KB pamięci.

raphael:/proc/17369 $ cat maps
08000000-08001000 rwxp 00000000 00:00 0
bfee2000-bfee2000 rw-p 00000000 00:00 0
raphael:/proc/17369 $
Ten drugi wpis ma rozmiar 0, i powstaje podczas jednego z munmap(), chyba tego dla stosu.
Ogólnie to bezpośrednio nic pożytecznego nie zrobiłem, ale nauczyłem się masę rzeczy.
Bawiąc się dalej z mmap(), dowiedziałem się, że nie możemy zaalokować pamięci pod adresem 0x00000000. (Dokładniej to tylko root może). A jest to spowodowane tym, że odwołanie do NULL, powinno powodować błąd.
Testowałem malloc() (Tak, proces może mieć tylko 3GB pamięci), ale po zaalokowaniu tej pamięci, nie jest ona zabierana z puli systemu. Tzn przed uruchomieniem programu jest powiedzmy 10% używanej pamięci RAM, tyle samo jest po zaalokowaniu pamięci. Dopiero jakaś operacja na pamięci (read write) zabiera, chyba stronę, z puli systemu. Nie wiem, dlaczego Linuks tak działa, ale jestem w trakcie szukania.

-- The end --

I tyle ;)