Grzonu Blog

Ostatnio zajmowałem się w dalszym ciągu metodom wykrywania debuggera i odłączenia go.
Przykładowo stosowalem metode o ktorej pisałem 2 posty temu. Kozystala ona z NtQuerySystemInformation z parametrem SystemHandleInformation. Lecz jesli ktos uzywal Ollyego z pluginem OllyAdvanced metoda ta nie sprawdzała się. Sprobowałem wywolac ta funkcje poprzed syscall. Lecz nadal OllyOdvanced modyfikował wyniki.
Podobnie rzecz się miała w przypadku funkcji NtOpenProcess tak ze nie moglem otworzyc procesu debuggera aby pobrac uchwyty, ani znalesc PID procesu rodzica gdyz OllyAdvanced tak zmienial wyniki ze PID procesu rodzica == PID mojego procesu. Jako ze kozystalem z własnej procedury wywolujacej syscall OllyAdvanced musiał albo zakładać hooki w kernelu ale tą metode narazie odrzuciłem wiec jedyna opcja mogl byc sysexit.
Ale jak wiadomo w systemie Windows mamy 2 mechanizmy wywolywania syscalla(sysenter i INT 2E)
sysenter po powrocie do user mode wraca pod KiFastSystemCallRet a INT 2E wraca za instrukcje.
Wystarczy wywolywac te funkcje nie poprzez sysenter a wlasnie przez INT 2E aby OllyAdvanced nie modyfikował wynikow i co za tym idzie aby dało się łatwo wykryć debugger.

Bardzo lubie sciagnac zasłyszana piosenke do siebie jako mp3 (oczywiscie na 24h )
Czesto uzywam do tego z wrzuty i serwisow ktore umozliwiaja pobranie utworu z tego serwisu.
Niestety ostatnio wrzuta zmienila sposob pobierania plikow upodobnila go do sposobu megavideo ktory dosc mocno utrudnia pobieranie(do pobrania trzeba otworzyc plik XML a w nim jest link ale skozystac z niego mozna tylko z tego IP z ktorego zostal pobrany XML)

Czesc serwisow ktore umozliwiaja pobierania przestała dzialac a czesc wprowadzila skrypt Java ktory pobierze nam utwor. Jako ze Javy nie mam zainstalowanej i nie zamierzam instalowac tak wiec napisalem sobie programik w C++ ktory pobierze utwor z wrzuty.
Programik pisalem dla siebie no ale postanowilem udostepnic go szerszemu gronu. Wiec jakby komuś się przydał to zapraszam do sciagania

DOWNLOAD

Ostatnimi czasy wrocilem do badania metod wykrywania debuggerow i wymyslilem metode oparta o funkcje NtQuerySystemInformation mozliwe ze ktos wpadł juz na to wczesniej lecz nie moglem nic znalesc na ten temat.

Metoda jest bardzo prosta za pomoca funkcji NtQuerySystemInformation z parametrem SystemHandleInformation
pobieramy uchwyty otwarte przez wszystkie aplikacje. Poszukujemy uchwytow do procesow ktore sa uchwytami do naszego procesu i sprawdzamy czy wsrod uchwytow tego procesu nie znajduje sie uchwyt o typie 0xb czyli DebugObject jesli znajduje sie to moze byc znak ze jestesmy debuggowani(choc nie ma 100% pewnosci)

Czas na troche kodu

potrzebne nam zmienne i funkcja:

1
2
3
4
5
6
7
8
9

NTSTATUS                        ntStatus;
DWORD                           dwParentPID =   0xffffffff;
HANDLE							h_proc,h;
ULONG                           need;	
BOOL							isDebug=0;
 
 
HMODULE ntdll = GetModuleHandle("ntdll");
NTQSI NtQuerySystemInformation = (NTQSI)GetProcAddress(ntdll, "NtQuerySystemInformation");

Wywolajmy teraz funkcje NtQuerySystemInformation

1
2
3
4
5
6
7
8
9
10
11

ULONG size = 0x1000;
SYSTEM_HANDLE_INFORMATION *handles = (SYSTEM_HANDLE_INFORMATION*)malloc(size);
 
ntStatus = NtQuerySystemInformation(SystemHandleInformation, handles, size, &need);
if(ntStatus!=0)//jesli za maly bufor alokujemy wiekszy
					   {
                        free(handles);
                        size =need;
                        handles = (SYSTEM_HANDLE_INFORMATION*)malloc(size);
		NtQuerySystemInformation(SystemHandleInformation, handles, size, &need);
						}

w tym momecie w w strukturze handles mamy wszystkie uchwyty dostepne w systemie.
Musimy przeszukac czy wsrod nich nie ma uchwytow o typie 0×7 czyli proces.
Jesli taki znajdziemy to musimy otworzyc ten proces z prawami PROCESS_DUP_HANDLE
i zduplikowac ten uchwyt ale w naszym procesie. Nastepnie sprawdzic czy jest to uchwyt do naszego procesu a jesli tak to sprawdzic czy wsrod uchwytow tego procesu nie ma uchwytow typu DebugObject

A teraz praktyka:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int i=0;
int j=0;
for (i=0; i<handles->HandleCount; i++)
{
	if(handles->Handles[i].ObjectType==7)//Process
	{
		h=OpenProcess(PROCESS_DUP_HANDLE, FALSE,handles->Handles[i].OwnerPid);
		if(h!=0)
		{
			if (DuplicateHandle(h, (HANDLE)handles->Handles[i].HandleValue, GetCurrentProcess(),&h_proc, 0, FALSE, DUPLICATE_SAME_ACCESS))
			{
				if(GetProcessId(h_proc)==GetCurrentProcessId())
				{
					j=0;
					while(j<handles->HandleCount)
					{
						if(handles->Handles[i].OwnerPid==handles->Handles[j].OwnerPid && handles->Handles[j].ObjectType==0xb)
						{
						isDebug=1;
						}
					j++;
					}
				}
			}
		}
	}
}

Na koniec printfujemy wyniki przeszukiwania i zwalniamy bufor

1
2
3
4
5
6
7
8
9

if(isDebug==1)
{
printf("Debugger wykryty\n");
}
else
{
printf("Nie wykryto debuggera\n");
}
	if (handles) free(handles);

Caly kod programu mozna sciagnac TU

PS.
Czysty olly jest ta metoda bez problemu wykrywany ale np. Olly z pluginem StrongOD juz nie.
Plugin ten m.in powoduje ze lista uchwytow dla tego procesu jest pusta. Jest to tez dosc charakterystyczne bo kazdy program ma jakies uchwyty. Dodatkowo mozemy sprawdzac nasz proces rodzica jakie uchwyty posiada(albo nie posiada wcale)

Jak obiecalem tak zrobilem. Dzis chciałbym omowic IAT hooking i sposoby ich wykrywania.
Za jakis czas postaram sie napisac cos o hookach EAT i modyfikacjach kodu.

No wiec zaczynamy.
Najpierw kilka słow czym jest sam IAT hooking – jest to technika hookowania funkcji poprzez zamiane adresu funkcji umieszczonego w IAT na adres
funkcji umieszczonej w innej bibliotece dll albo poprostu gdzies w pamieci. O samym zakładaniu hookow pisal nie bede sa do tego dziesiatki gotowych
bibliotek, setki przykładowych kodów wiec mysle ze ci ktorzy jeszcze tego nie opanowali powinni jak najszybciej uzupełnic braki kozystajac z google.

Teraz cos na temat wykrywania tych hookow – Opisze w punktach co musimy zrobic:
1. Znajdujemy plik exe procesu w ktorym chcemy hookow poszukac.
2. Znajdujemy w tym pliku tablice IAT i sprawdzamy wszystkie funkcje znajdujace sie w IAT
3. Sprawdzamy w jakim module wg. IAT powinna znajdowac sie dana funkcja.
4. Sprawdzamy ImageBase i Size tego modułu i sprawdzamy czy adres w IAT miesci sie w przedziale
Jesli tak to wszystko OK jesli nie to sprawdzamy na jaki moduł wskazuje dany adres

To tyle teori.
Czas na praktyke.

Potrzebne naglowki:

1
2
3
4
5
6
7
8
9

#include <windows.h>
#include <stdio.h>
#include <string>
#include <Tlhelp32.h>
#include <vector>
#include <Psapi.h>
#include <fstream>
#include "PE_class.h" //moja klasa do obslugi plikow PE(udostepnie razem z reszta kodu)
#pragma comment (lib,"psapi.lib");

Zmienne globalne:

1
2
3

HANDLE hProc;//uchwyt procesu
DWORD pid;//ProcessID
DWORD MainImageBase;//ImageBase procesu

Main:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

int main(int argc, CHAR* argv[])
{
printf("\n\nIAT Hook detector v. 1.0 by Grzonu\n\n");
 
if(argc!=2)//sprawdzamy czy podano parametr jesli nie to wychodzimy
{
	printf("usage: %s <pid>\n\n",argv[0]);
	return 0;
}
pid=atoi(argv[1]);//pobieramy PID
DWORD IB=0;
DWORD ImgSize=0;
FindImageBase(pid,&IB,&ImgSize);//Znajdujemy ImageBase i Size procesu
printf("ImageBase: 0x%.8x\nImageSize: 0x%.8x\n\n",IB,ImgSize);
 
hProc=OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION,FALSE,pid);//otwieramy go
if(hProc==0)//jesli sie nie udalo to wychodzimy
{
printf("can`t open process\n");
return 0;
}
char* buf=LoadMod(IB);//ladujemy plik
MainImageBase=IB;
PE_file PE((HMODULE)buf);
IAT(&PE);//szukamy hookow
free(buf);//zwalniamy bufor zaalokowany w funkcji LoadMod
 
 
	return 0;
}

Teraz postaram sie omowic kazda z funkcji na poczatek FindImageBase() czyli funkcja szukajaca ImageBase i Size procesu

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

DWORD FindImageBase(DWORD pid,DWORD* IB,DWORD* ImgSize)//funkcja przyjmuje processID, wskazniki na bufory na dane
{
PROCESSENTRY32 lppe32;
char buf[260];
	memset(buf,0,260);
    HANDLE hSnapshot;
   hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//robimy snapshot listy procesow
    lppe32.dwSize = sizeof(PROCESSENTRY32);
 
    Process32First(hSnapshot, &lppe32);
	    do
        {
		if(lppe32.th32ProcessID==pid)//szukamy naszego procesu
		{
		strcpy(buf,lppe32.szExeFile);
		break;
		}
 
		}
        while(Process32Next(hSnapshot, &lppe32));
        CloseHandle(hSnapshot);
if(buf[0]==0)//jesli nie udalo sie znalesc zwracamy 0;
{
return 0;
}
 
MODULEENTRY32 mod32;
std::string x;
 
   hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);//robimy snapshot listy modolow znalezionego procesu
   mod32.dwSize = sizeof(MODULEENTRY32);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		x=mod32.szExePath;
		if(x.find(buf)!=0xFFFFFFFF)//sprawdzamy czy to główna czesc programu
		{//jesli tak to wypelniamy odpowiednie zmienne
			*IB=(DWORD)mod32.modBaseAddr;
			*ImgSize=mod32.modBaseSize;
		}
 
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
return 1;
}

Mamy wiec juz potrzebne ImageBase i ImageSize procesu. Teraz zajmiemy sie funkcja ladujaca kod modulu z pliku na ktory wskazuje ImageBase.
Dotyczyc to bedzie nie tylko glownego kodu programu ale i wszystkich bibliotek. Musimy pobrac ImageSize z pliku poniewaz ImageSize modulu
w pamieci bardzo latwo zmienic tak aby wygladalo ze kod jednej biblioteki pokrywa sie z druga poprzez zmiane ImageSize modulu w pamieci.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

char* LoadMod(DWORD IB)
{
char ProcName[260];
GetModuleFileNameEx(hProc,(HMODULE)IB,ProcName,260);//pobieramy pelna sciezke do binarki modulu
std::ifstream f(ProcName,std::ios::binary);//otwieramy plik
char* buf;
f.seekg(0,std::ios::end);
int size=f.tellg();
f.seekg(0,std::ios::beg);
buf=(char*)malloc(size);//alokujemy bufor(pamietajmy go pozniej zwolnic)
memset(buf,0,size);
int i=0;
char ch;
while(i<size)
{
f.get(ch);//wczytujemy
buf[i]=ch;
i++;
}
f.close();
return buf;//zwracamy bufor
}

Teraz czas na glowna funkcje IAT() ktora ma za zadanie znalesc wszystkie funkcje importowane przez aplikacje i sprawdzic czy nie sa hookowane.
Funkcja ta kozysta z kilku innych funkcji ktore tez po drodze omowie.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

void IAT(PE_file* PE)
{
HINSTANCE hInstance =(HINSTANCE)PE->buf;
PIMAGE_DOS_HEADER pdosheader = (PIMAGE_DOS_HEADER)hInstance;//pobieramy naglowki
PIMAGE_NT_HEADERS pntheaders = (PIMAGE_NT_HEADERS)((DWORD)hInstance + pdosheader->e_lfanew);//i dalej...
PIMAGE_SECTION_HEADER psectionheader = (PIMAGE_SECTION_HEADER)(pntheaders + 1);
PIMAGE_IMPORT_DESCRIPTOR pimportdescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hInstance + PE->RVA_to_RAW(pntheaders->OptionalHeader.DataDirectory[1].VirtualAddress));//znajdujemy adres IAT w naglowku PE ale jako ze szukamy w pliku a nie w procesie pamietamy o zamianie adresu z RVA na RAW
PIMAGE_THUNK_DATA pthunkdatain, pthunkdataout;
PIMAGE_IMPORT_BY_NAME pimportbyname;
DWORD dw;
PCHAR ptr;
DWORD IB;
char* buf;
DWORD ImgSize;
PIMAGE_OPTIONAL_HEADER32 opt;
DWORD address;
DWORD IAT_adr;
DWORD read;
 
int i=0;
while ( pimportdescriptor->TimeDateStamp != 0 ||pimportdescriptor->Name != 0)//pobieramy tak dlugo importy az sie skoncza :)
{
	ptr = (PCHAR)((DWORD)hInstance+ PE->RVA_to_RAW((DWORD)pimportdescriptor->Name));//Nazwa biblioteki Dll
	i=0;
	IB=FindModule(ptr);//Funkcja szukajaca ImageBase na podstawie nazwy biblioteki(omowie dalej)
	buf=LoadMod(IB);//opisana wczesniej funkcja ladujaca kod 
	PE_file PE2((HMODULE)buf);//ladujemy kod do klasy
	opt=PE2.GetOptionalHeader();//Pobieramy odpowiedni header
	ImgSize=opt->SizeOfImage;//pobieramy potrzebne nam pole z tego headera czyli ImageSize
	free(buf);//zwalniamy bufor
 
		pthunkdataout = (PIMAGE_THUNK_DATA)((DWORD)hInstance + PE->RVA_to_RAW((DWORD)pimportdescriptor->FirstThunk));//pobieramy adres gdzie zaczynaja sie adresy w IAT
		if (pimportdescriptor->Characteristics == 0)
		{
			pthunkdatain = pthunkdataout;//pobieramy adres struktury z ktorej pobierzemy nazwy funkcji
		}
		else 
		{
			pthunkdatain = (PIMAGE_THUNK_DATA)((DWORD)hInstance +PE->RVA_to_RAW((DWORD)pimportdescriptor->Characteristics));//to samo ;)
		}
 
		while ( pthunkdatain->u1.AddressOfData != NULL)//dopuki sa jeszcze jakies funkcje
		{
			if ((DWORD)pthunkdatain->u1.Ordinal & IMAGE_ORDINAL_FLAG)//jesli Ordinal
			{
				LPSTR x=MAKEINTRESOURCE(LOWORD(pthunkdatain->u1.Ordinal));//Ordinal
				address=MainImageBase+(pimportdescriptor->FirstThunk+(i*4));//adres bufora na adres funkcji
				ReadProcessMemory(hProc,(LPCVOID)address,&IAT_adr,4,&read);//Odczytujemy adres funkcji znajdujacej sie pod adresem pobranym wyzej
 
				if(IAT_adr<IB || IAT_adr>(IB+ImgSize))//sprawdzamy czy adres miesci sie w granicach swojego modułu
				{//jesli nie to sprawdzamy w jakim module znajduje sie funkcja
				DWORD HookBase=FindHookModule(IAT_adr);//pobieramy ImageBase modułu w ktorym znajduje sie ta funkcja.(Ta funkcje omowie pozniej)
				char modname[260];
				if(HookBase==0)//jesli nie ma takiego modulu oznacza ze jest to poprostu zaalokowana pamiec np. przez VirtualAllocEx
				{
				strcpy(modname,"Virtual Memory");
				}
				else//jesli jest to pobieramy sciezke do tego modułu
				{
				GetModuleFileNameEx(hProc,(HMODULE)HookBase,modname,260);
				}
printf("Ord: %x(%s) --- Hooked by %s(0x%.8x)\n",x,ptr,modname,IAT_adr);//printfujemy wynik :)
				}
 
 
			} else {
				pimportbyname = (PIMAGE_IMPORT_BY_NAME)(PE->RVA_to_RAW((DWORD)pthunkdatain->u1.AddressOfData) + (DWORD)hInstance);
					address=MainImageBase+(pimportdescriptor->FirstThunk+(i*4));//tutaj to samo co wyzej 
				ReadProcessMemory(hProc,(LPCVOID)address,&IAT_adr,4,&read);
 
				if(IAT_adr<IB || IAT_adr>(IB+ImgSize))
				{
				DWORD HookBase=FindHookModule(IAT_adr);
				char modname[260];
				if(HookBase==0)
				{
				strcpy(modname,"Virtual Memory");
				}
				else
				{
				GetModuleFileNameEx(hProc,(HMODULE)HookBase,modname,260);
				}
				printf("%s(%s) --- Hooked by %s(0x%.8x)\n",(char*)pimportbyname->Name,ptr,modname,IAT_adr);
				}
 
			}
 
        i++;//nastepna funkcja
			pthunkdatain++;
			pthunkdataout++;
		}
 
	pimportdescriptor++;//nastepna DLL`ka
 
}
}

To teraz 2 funkcje ktore mialem omowic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

void str_tolower(char* str)//funkcja zamieniajaca string na male litery
{
int i=0;
int size=strlen(str);
 
while(i<size)
{
str[i]=tolower(str[i]);
i++;
}
}
 
DWORD FindModule(char* mod_name)
{
MODULEENTRY32 mod32;
std::string x;
   HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);//o tym juz mowilem
   mod32.dwSize = sizeof(MODULEENTRY32);
   str_tolower(mod_name);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		str_tolower(mod32.szExePath);
		x=mod32.szExePath;
 
		if(x.find(mod_name)!=0xFFFFFFFF)//jesli to szukany modul to zwracamy jego ImageBase
		{
			return (DWORD)mod32.modBaseAddr;
		}
 
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
		return 0;
}
 
DWORD FindHookModule(DWORD Address)//funkcja szukajaca ImageBase modulu w ktorym znajduje sie funkcja
{
MODULEENTRY32 mod32;
   HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
   mod32.dwSize = sizeof(MODULEENTRY32);
 
    Module32First(hSnapshot, &mod32);
	     do
        {
		if(Address>=(DWORD)mod32.modBaseAddr && Address<=(DWORD)(mod32.modBaseAddr+mod32.modBaseSize))//jesli adres znajduje sie w przedziale <ImageBase ; ImageBase+ImageSize> to zwracamy jego ImageBase
		{
return (DWORD)mod32.modBaseAddr;
		}
 
		}
        while(Module32Next(hSnapshot, &mod32));
        CloseHandle(hSnapshot);
		return 0;
}

To chyba tyle na dzis.
Przedstawiona metoda jest prosta a jednak skuteczna(choc oczywiscie ja tez mozna ominac)
Jesli bym o czyms zapomnial to dopisze wkrotce

Załączam kod pod VC++ i binarke
Link

No to taki post oderwany od ogolnego tematu bloga ale mysle ze warto napisac
Po pierwsze chcialbym zdementowac plotki jakobym zapadł w śpiączke (wtf?) i uciac dyskusje na ten temat ktore podobno toczyly sie na IRCu xD
Wiec zyje i mam sie dobrze oczekuje niespokojnie na wyniki matur.

W najblizszym czasie mam w planie napisać kilka artów bo ten blog coś ostatnio świeci pustkami a coraz wiecej osób pyta kiedy coś nowego napisze.

No i kozystajac z okazji to miłych wakacji

No jak wiadomo dzisiejszy dzien to dzień różnych żartów
Pierwszy jaki znalazlem w sieci to rzekomo shackowana strona Gynvaela Coldwind (LINK) Strona wyglada bardzo realistycznie

No to czekamy na dalsze żarty

//Update
No to się doczekalismy
tak jak sie spodziewałem niebezpiecznik.pl też cos przygotował a mianowicie posta o tym że niebezpiecznik.pl został kupiony przez indykpol Gratulacje za pomysłowość

Uruchomiłem dziś wyszukiwarkę filmów online.
Szukajka przeszukuje sieć w poszukiwaniu filmów o interesującym nas tytule i wyswietla wynik.
Zapraszam do kozystania.

WYSZUKIWARKA

Poszukiwanie informacji o osobie

Czesto zdaza się, że chcemy zdobyć o pewnej osobie jak najwiecej informacji. No dobra nie zastanawiajmy się po co wam te dane zastanówmy czego możemy się dowiedzieć.
Cała metoda polega na dojsciu po nitce do kłębka, czyli mając np. jedna czy dwie informacje znaleśćich dużo więcej. Bardzo przydatne są do tego wszelkie wyszukiwarki, porównywarki i inne tego typu narzędzia.
Przydatna jest w zasadzie każda najmniejsza informacja. IP,mail, zdjecia, konta w serwisach społecznościowych ,znajomi ,numer gg, avatar na forum poprostu wszystko czym dysponujemy. Co mozemy zrobić np. z adresem IP …hmmm chyba jedynie sprawdzić host i jakies info o tym IP np. kozystając np. z ip.boo.pl
W zdecydowanej wiekszosci nie uzyskamy nic wiecej poza miejscem gdzie miesci sie serwer dostawcy internetu poszukiwanej osoby. No ale to juz coś. Na podstawie tego mozemy stwierdzić czy osoba przebywa w Polsce, w jakim zakątku kraju się znajduje.
Jesli dysponujemy adresem e-mail mozemy googlowac w poszukiwaniu tego adresu, możemy dzieki temu dotrzeć do stron na ktorych jest zarejestrowana poszukiwana przez nas osoba, czym się interesuje. Na tych stronach mozemy poszukac kolejnych rzeczy np. numeru gg, avatara z forum i innych miejsc. Mozemy trafić na konta z profili społecznościowych takich jak nasza-klasa czy fotka. No to juz nie lada gratka dla ludzi ktorzy próbują się czegoś dowiedzieć bardzo często ludzi piszą w swoich profilach bardzo wiele danych takich jak Imie i nazwisko , adres , telefon , gg. Mozemy dowiedzieć się kogo zna, a nuż mamy wspólnych znajomych. Widzimy często zdjęcia z wakacji, z domu, z imprez i wielu innych miejsc. Czasem jest nawet możliwość dowiedzieć się gdzie dane zdjecie było zrobione, jeśli aparat wyposarzony był w GPS jak to jest np. w przypadku aparatu z iPhone`a, który pozwala zapisać dane na temat miejsca zrobienia zdjecia o czym mozemy przeczytac np. na niebezpieczniku
Zdjecia , avatary i inne graficzne pliki mogą posłużyć do tego aby dowiedzieć się czegoś o poszukiwanej osobie np. dzieki stronie tineye.com która pokaże nam czy gdzieś w innym miejscu nie znajduje się już ono albo jego zmodyfikowana wersja. Dzieki temu znowu możemy trafić na strony z których kozysta poszukiwana osoba.
W wiekszosci przypadków jesteśmy w stanie znaleść wiele informacji o osobie. Lecz jeśli komuś będzie mocno zależało na tym aby google milczało na jego temat to uda mu się bo w 90% przypadków ludzie sami podają informacje na swoj temat które pozwalają ich znaleść.

Dzisiaj zacząłem przenosić stronę na nowy,lepszy,szybszy hosting. Dawny limit tranferu i miejsca przestawał wystarczać i balansował prawie na granicy. Przeniosłem więc stronę na większy serwer o 100x wiekszej powierzchni i ponad 100x wiekszym limicie transferu Mam nadzieje, że poprawi się komfort oglądania strony Wszystko to dzięki firmie az.pl która nie dość że podarowała mi domene za darmo to jeszcze dała mi ten hosting w bardzo przystępnej cenie

W ciagu kilku dni niektóre linki mogą nie działac ale postaram się to jak najszybciej poprawić.

Z dnim dzisiejszym strona zmienia adres na grzonu.com.pl
stary adres bedzie funkcjonował jeszcze około miesiąc rownolegle z nowym.