def.asm

FSG加密工具2.0＋源代码经典加壳程序

;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
; DEF - prostacki encryptor plikow PE EXE
; kompatybilny z 95,NT
;
;
; bart/xtreeme
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

.586						; dostepne rozkazy dla procesora pentium
.mmx						; +mmx
.model flat,stdcall

includelib	e:\dev\masm\lib\kernel32.lib	; tylko tyle potrzebne jest dzisiaj do szczescia
includelib	e:\dev\masm\lib\user32.lib
includelib	e:\dev\masm\lib\comdlg32.lib

include		e:\dev\masm\include\kernel32.inc
include		e:\dev\masm\include\user32.inc
include		e:\dev\masm\include\comdlg32.inc

include		e:\dev\masm\include\windows.inc
include		pe.inc				; stale dla PE

.data?
	lpFilename	db 256 dup(?)		; bufor na nazwe pliku
	lpFile		MEMF <>			; struktura dla uchwytow etc.
	lpPeheader	dd ?			; wskaznik do naglowka PE
	lpSectionTable	dd ?

.data
	lpOfn		dd lOfn			; rozmiar struktury
			dd 0			; hWnd
			dd 0			; hInst
			dd offset szFilter	; filtr
			dd 0			; lpstrCustomFilter; 
			dd 0			; nMaxCustFilter; 
			dd 0			; nFilterIndex; 
			dd offset lpFilename	; lpstrFile; 
			dd 256			; nMaxFile; 
			dd 0			; lpstrFileTitle; 
			dd 0			; nMaxFileTitle; 
			dd 0			; lpstrInitialDir; 
			dd offset szCaption	; lpstrTitle; 
			dd OFN_HIDEREADONLY	; Flags; 

			dw 0			; nFileOffset; 
			dw 0			; nFileExtension; 
			dd 0			; lpstrDefExt; 
			dd 0			; lCustData; 
			dd 0			; lpfnHook; 
			dd 0			; lpTemplateName; 
	lOfn		equ $-lpOfn


	szCaption	db 'DEF v1.0 by bart/xt - wybierz plik do zaszyfrowania',0
	szFilter	db 'Pliki EXE (*.exe)',0,'*.exe',0
			db 'Wszystkie pliki (*.*)',0,'*.*',0,0

	szError		db 'Nieprawidlowy format pliku!',0
	szDef		db 'DEF v1.0 by bart/xt',0

.code
_start:

; wybor pliku do zaszyfrowania

	push	offset lpOfn			; wskaznik do struktury OFN
	call	GetOpenFileNameA		; pobierz nazwe pliku
	test	eax,eax				; jesli user nic nie wybral wyjdz
	je	_exit

; otwieranie pliku

	push	offset lpFilename		; nazwa pliku
	call	_open_file
	inc	eax				; uchwyt pliku, zwrocony po CreateFileA
	je	_exit				;

	test	ecx,ecx
	je	_exit				; rozmiar pliku, wyjdz jesli plik ma 0 bajtow

	dec	eax				; przywroc oryginalny uchwyt pliku

	mov	ebx,offset lpFile		; ustaw ebx na strukture, w ktorej beda zapisane
	assume	ebx:ptr MEMF			; uchwyt pliku, rozmiar, mapa, uchwyt mapy

	mov	[ebx].file_handle,eax		; zapisz uchwyt pliku
	mov	[ebx].file_size,ecx		; zapisz rozmiar pliku

; mapowanie
	push	eax				; uchwyt pliku
	push	ecx				; rozmiar pliku
	call	_map_file			; mapuj plik
	test	eax,eax				; jesli wskaznik do mapy = 0 (np. dysk jest pelny)
	je	_exit_close			; zamknij plik i wyjdz

	test	ecx,ecx
	je	_exit_close			; jesli uchwyt mapy = 0 wyjdz

	mov	[ebx].mem_ptr,eax		; zapisz wskaznik mapy pliku
	mov	[ebx].mem_handle,ecx		; uchwyt mapy

; sprawdzanie formatu pliku
	cmp	word ptr[eax],'ZM'		; sprawdz naglowek MS-DOS
	jne	_bad_format

	add	eax,dword ptr[eax+3Ch]		; do mapy pliku dodaj DWORDa okreslajacego odleglosc
						; naglowka PE od poczatku pliku, w eax otrzymamy
						; adres naglowka PE w mapowanym obszarze pamieci

	mov	lpPeheader,eax			; zapamietaj adres naglowka PE do zmiennej

	xchg	eax,edi				; adres naglowka PE do rejestru edi

; sprawdzy czy format pliku jest zgodny z PE

	cmp	dword ptr[edi],00004550h	; sprawdz sygnature naglowka PE, czyli bajty
	jne	_bad_format			; 'PE',0,0
						; jesli brak naglowka PE wyjdz

	cmp	dword ptr[edi+entrypointRVA],0	; brak entrypoint RVA(brak adresu kodu od ktorego rozpoczyna
	je	_bad_format			; sie wykonywanie kodu)

	test	word ptr[edi+DllFlags],2000h	; sprawdz czy plik jest plikiem wykonywalnym EXE czy
	jne	_bad_format			; biblioteka dynamiczna DLL
						; jesli to biblioteka wyjdz


; tabela sekcji
	movzx	edx,word ptr[edi+NtHeaderSize]	; rozmiar naglowka PE
	lea	edx,[edi+edx+18h]		; oblicz offset do tablicy sekcji

	cmp	dword ptr[edx],'fed.'		; sprawdz czy plik czasem nie jest juz zaszyfrowany
	je	_bad_format			; def-em (po nazwie 1 sekcji)


	mov	lpSectionTable,edx		; zapisz offset tabeli sekcji w zmiennej globalnej




	movzx	ecx,word ptr[edi+numObj]	; liczba sekcji

; szyfrowanie sekcji
; edx <-- tabela sekcji
; edi <-- naglowek PE
; ecx <-- liczba sekcji

_encrypt_sections:
						; edx --> wskaznik do naglowka sekcji
	call	_is_encryptable			; sprawdz czy sekcja nadaje sie do szyfrowania
	test	eax,eax				; jesli funkcja zwroci 0 sprawdz nastepna sekcje
	je	_encrypt_skip			;

	mov	esi,dword ptr[edx+objpoff]	; fizyczny offset sekcji wzgledem poczatku plikow
	add	esi,[ebx].mem_ptr		; dodaj do niego offset mapowanego pliku
						; = offset sekcji w mapowanym pliku

	mov	eax,dword ptr[edx+objpsize]	; rozmiar fizyczny sekcji

_encrypt:					; szyfruj sekcje
	xor	byte ptr[esi],al
	inc	esi
	dec	eax
	jne	_encrypt


	inc	eax				; ustaw al na 1, wstaw znacznik 1 co oznacza, ze
_encrypt_skip:					; sekcja zostala zaszyfrowana
	mov	dword ptr[edx],'fed.'		; nowa nazwa sekcji
	bswap	eax
	mov	dword ptr[edx+4],eax		; wstaw znacznik 0 lub 1
						; 1 <-- sekcja zaszyfrowana
						; 0 <-- nie

						; ustaw jednakowe flagi dla wszystkich sekcji
	mov	dword ptr[edx+objflags],0C00000E0h


	add	edx,objlen			; ustaw edx na offset nastepnego naglowka sekcji
	loop	_encrypt_sections		;


; korygowanie offsetow loadera
	mov	edx,dword ptr[edi+imagebase]	; imagebase
	mov	dword ptr[_ldr_imagebase],edx

	mov	eax,dword ptr[edi+entrypointRVA]; oryginalny entrypoint RVA
	add	eax,edx				; VA
	mov	dword ptr[_ldr_host],eax	; zapisz adres powrotu z kodu loadera

	mov	eax,lpSectionTable		; tablica naglowkow sekcji w pliku - offset mapy = offset w pliku
	sub	eax,[ebx].mem_ptr
	add	eax,edx				; VA
	mov	dword ptr[_ldr_sections],eax	; tablica naglowkow sekcji

	movzx	ecx,word ptr[edi+numObj]	; liczba sekcji
	mov	byte ptr[_ldr_count],cl

	imul	ecx,ecx,objlen			; ecx liczba naglowkow

	mov	eax,lpSectionTable		; tablica naglowkow sekcji w pliku - offset mapy = offset w pliku
	sub	eax,[ebx].mem_ptr

	add	eax,ecx				; koniec tabeli sekcji RVA

	mov	dword ptr[edi+entrypointRVA],eax; ustaw nowy adres entrypoint-a

	add	eax,[ebx].mem_ptr
	xchg	eax,edi				;
	mov	esi,offset _loader		; offset zrodlowy loadera
	mov	ecx,_loader_size		; rozmiar kodu loadera
	rep	movsb				; kopiuj kod loadera


	push	-1				; beepnij na sukces
	call	MessageBeep
	jmp	_exit_unmap

_bad_format:					; bledny format pliku, wyjdz i zamknij
	push	10h				; plik
	push	offset szDef
	push	offset szError
	push	0
	call	MessageBoxA

_exit_unmap:					; unmapuj plik
	push	[ebx].mem_ptr
	push	[ebx].mem_handle
	call	_unmap


_exit_close:
	push	[ebx].file_handle		; zamknij plik
	call	CloseHandle


_exit:
	push	-1
	call	ExitProcess			; bye bye


;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
; kod loadera, kod jest na tyle maly, ze miesci sie bez problemu miedzy
; ostatnim naglowkiem sekcji a 1 sekcja (ala CIH)
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
_loader:
	mov	esi,987654321			; wskaznik na tabele sekcji
_ldr_sections	equ dword ptr $-4		; adres VA


	push	0				; ilosc sekcji (max 127)
_ldr_count	equ byte ptr $-1
	pop	ecx


_ldr_next:
	cmp	byte ptr[esi+7],0		; jesli ostatni bajt w nzwie sekcji = 0
	je	_ldr_not_encrypted		; sekcja nie zostala zaszyfrowana, sprawdz
						; nastepna

	mov	eax,dword ptr[esi+objrva]	; do RVA dodaj imagebase, w ten sposob
	add	eax,987654321			; otrzymamy offset VA sekcji w zaladowanym
_ldr_imagebase	equ dword ptr $-4		; pliku


	mov	edx,dword ptr[esi+objpsize]	; rozmiar fizyczny sekcji

_ldr_decrypt:					; deszyfruj sekcje
	xor	byte ptr[eax],dl
	inc	eax
	dec	edx
	jne	_ldr_decrypt

_ldr_not_encrypted:

	add	esi,objlen			; ustaw esi na kolejna sekcje
	loop	_ldr_next			; kolejna sekcja


	push	987654321			; skok do entrypointa
_ldr_host	equ dword ptr $-4
	ret

_loader_end:
_loader_size equ $-_loader







;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
;
;	mov	edx,offset section_header
;	call	_is_rsrc
;
;	sprawdza, czy sekcja zawiera zasoby
;
;	na wyjsciu:
;	eax	- 1 sekcja zasobow
;		  0 brak zasobow
;
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

_is_rsrc proc near

	cmp	dword ptr[edx],'rsr.'		; rsrc
	je	_rsrc_section

	cmp	dword ptr[edx],'oser'		; resource
	je	_rsrc_section

	mov	eax,dword ptr[edx+objrva]
	cmp	eax,dword ptr[ebx+resource]	; czy RVA sekcji wskazuje na zasoby?
	je	_rsrc_section			; jesli tak pomin sekcje

	sub	eax,eax
	ret

_rsrc_section:
	sub	eax,eax
	inc	eax
	ret

_is_rsrc endp



;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
;
;	mov	edx,offset section_header
;	call	_is_encryptable
;
;	sprawdza, czy sekcja nadaje sie do kompresji/szyfrowania
;
;	na wyjsciu:
;	eax	- 0 sekcja nie nadaje sie do kompresji
;		  1 sekcja nadaje sie do kompresji
;
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

_is_encryptable proc near
	push	ebx
	mov	ebx,dword ptr[lpPeheader]

	call	_is_rsrc			; jesli to zasoby, nie kompresuj
	dec	eax
	je	_bad_section


	cmp	dword ptr[edx],'ler.'		; reloc
	je	_bad_section

	cmp	dword ptr[edx],'ade.'		; edata
	je	_bad_section

	cmp	dword ptr[edx],'ete.'		; etext
	je	_bad_section

	cmp	dword ptr[edx],'adr.'		; rdata
	je	_bad_section

	cmp	dword ptr[edx],'slt.'		; tls
	je	_bad_section

	cmp	dword ptr[edx],'adi.'		; idata
	je	_bad_section


	sub	eax,eax

	cmp	dword ptr[edx+objpoff],eax	; offset do sekcji = 0, pomin
	je	_bad_section			; szyfrowanie sekcji

	cmp	dword ptr[edx+objpsize],eax	; rozmiar fizyczny sekcji = 0
	je	_bad_section			; omin sekcje


	mov	eax,dword ptr[edx+objrva]	; RVA sekcji

	cmp	eax,dword ptr[ebx+resource]	; czy RVA sekcji wskazuje na zasoby?
	je	_bad_section			; jesli tak pomin sekcje

	cmp	eax,dword ptr[ebx+edatadir]	; pomin sekcje edata(sekcja exportow)
	je	_bad_section			;


	cmp	eax,dword ptr[ebx+import]
	je	_bad_section

	cmp	eax,dword ptr[ebx+reloc]	; relokacje(chociaz i tak powinny byc juz usuniete)
	je	_bad_section			; pomin sekcje

	cmp	eax,dword ptr[ebx+tls]		; ThreadLocalStorage?
	je	_bad_section			; pomin sekcje, Windows wymaga aby sekcja
						; TLS nie byla modyfikowana

	sub	eax,eax
	jmp	_check_exit


_bad_section:
	or	eax,-1

_check_exit:
	inc	eax
	pop	ebx

	ret

_is_encryptable endp


;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
;
;	push	offset lpFilename
;	call	_open_file
;
;	Otwiera plik do zapisu i odczytu z podanej lokalizacji
;
;	na wejsciu:
;	lpFilename  - nazwa pliku do otworzenia
;
;	na wyjsciu:
;	eax	- uchwyt pliku lub -1 jesli blad
;	ecx	- rozmiar pliku
;
;	modyfikowane rejestry:
;	eax,ecx,edx
;
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

_open_file proc near
	pop	eax
	pop	edx
	push	eax

	push	edx

	push	FILE_ATTRIBUTE_ARCHIVE		; atrybuty
	push	edx				; nazwa pliku
	call	SetFileAttributesA		; usun atrybuty blokujace dostep do zapisu
	
	pop	edx				; pop nazwa pliku

	sub	eax,eax
	push	eax
	push	FILE_ATTRIBUTE_NORMAL
	push	OPEN_EXISTING			; akcja, otworz plik
	push	eax
	push	eax
	push	GENERIC_READ + GENERIC_WRITE	; tryb dostepu
	push	edx				; nazwa pliku
	call	CreateFileA
	
	cmp	eax,-1				; sprawdz wartosc zwrocona przez CreateFileA
	je	_open_err			; jesli to -1 to znaczy, ze wystapil blad
						; wyjdz z takim wynikiem z funkcji

	push	eax				; zapamietaj na stosie uchwyt pliku

	push	0				; 0 dla plikow mniejszych niz 4gb
	push	eax				; uchwyt pliku
	call	GetFileSize			; pobierz rozmiar pliku

	pop	ecx				; pop, uchwyt pliku do ecx
	xchg	eax,ecx				; zamien wartosci w rejestrach, tak, ze
						; w eax znajdzie sie uchyt pliku a w ecx
						; rozmiar pliku
_open_err:
	ret					; wyjscie z funkcji

_open_file endp


;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
;
;	push	hFile
;	push	cbSize
;	call	_map_file
;
;	Mapuje plik do pamieci, wszystkie operacje dokonywane na pamieci maja fizyczne
;	odzwierciedlenie na dysku
;
;	na wejsciu:
;	hFile	- uchwyt pliku otwartego w trybie do odczytu i zapisu
;	cbSize	- rozmiar pliku
;
;	na wyjsciu:
;	eax	- wskaznik do mapowanego pliku lub 0 jesli blad
;	ecx	- uchwyt mapowanego pliku
;
;	modyfikowane rejestry:
;	eax,ecx,edx
;
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

_map_file proc near

	pop	eax				; adres powrotu
	pop	ecx				; rozmiar pliku
	pop	edx				; uchwyt pliku

	push	eax

	sub	eax,eax
	push	eax
	push	ecx				; rozmiar pliku(+opcjonalnie rozmiar
						; dodtkowego obszaru pamieci)

	push	eax				;
	push	PAGE_READWRITE			; tryb dostepu do mapy pliku
	push	eax
	push	edx				; uchwyt pliku
	call	CreateFileMappingA

	push	eax				; zapamietaj uchwyt mapy pliku

	sub	edx,edx				; zeruj edx

	push	edx				; ilosc bajtow do mapowania, gdy 0
						; mapowany jest caly plik
	push	edx				;
	push	edx				;
	push	FILE_MAP_WRITE			; flagi dostepu
	push	eax				;
	call	MapViewOfFile			; w eax wskaznik do mapy pliku

	pop	ecx				; uchwyt mapy pliku do ecx
	ret
_map_file endp


;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
;
;	push	lpMap
;	push	hMap
;	call	_unmap
;
;	zamyka mapowany plik + zapisuje zmiany jakie dokonano na mapie pliku
;
;	na wejsciu:
;	lpMap		- wskaznik do mapy pliku
;	hMap		- uchwyt mapy pliku
;
;	na wyjsciu:
;	brak
;
;	modyfikowane rejestry:
;	eax,ecx,edx
;
;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪

_unmap	proc near
	pop	eax

	pop	ecx				; hMap
	pop	edx				; lpMap

	push	eax

	push	ecx				; zapamietaj parametr dla CloseHandle

	push	edx				; lpMap
	call	UnmapViewOfFile			; usuwa obraz mapy pliku z przestrzeni adresowej
						; naszego procesu

	call	CloseHandle			; zamknij mape pliku

	ret
_unmap	endp

end _start