A school assignment. Caesar cipher in x86 32bit assembly.

Caesar.asm

INCLUDE Irvine32.inc
ExitProcess proto,dwExitCode:dword

; Adat
.data
Str_Mode		DB "Kodolas vagy dekodolas? K/D ", 0
Str_Shift		DB "Eltolas? ", 0
Str_Code		DB "Szoveg? ", 0
Str_Result		DB "Kimenet: ", 34, 0 ; 34 = "
Str_Quote		DB 34, 0 ; Egy idézőjel
Str_Invalid		DB "Hibas adat!", 10, 0
Str_NewLine		DB 10, 0 ; Új sor
Str_ExitTxt		DB 10, "Nyomj meg egy gombot a kilepeshez...", 0

_Mode			DB 0 ; Mód változó (0 - Kódolás, 1 - Dekódolás)
_Offset			DD 0 ; Kódolás eltolása

InputMax = 256
_Input			DB InputMax+1 dup (?) ; Kód buffer, max 256 karakter + 0 végére
_InputLength	DD 0

; Kód
.code
main proc

	; Infók bekérése
Label_GetMode:
	; Kódolási mód bekérése
	mov edx, offset Str_Mode
	call WriteString
	
	call ReadChar ; Bekérem a karaktert

	call WriteChar ; Kiírom a bemenetet (visszajelzés)

	mov edx, offset Str_NewLine
	call WriteString

	cmp AL, 'K' ; Kódolás mód?
	je Label_ModeCode
	cmp AL, 'k' ; Kódolás mód? Kisbetűvel
	je Label_ModeCode

	cmp AL, 'D' ; Dekódolás?
	je Label_ModeDecode
	cmp AL, 'd' ; Dekódolás? Kisbetűvel
	je Label_ModeDecode

	; Hibás bemeneti adat
	mov edx, offset Str_Invalid
	call WriteString

	jmp Label_GetMode

Label_ModeCode:
	mov _Mode, 0
	jmp Label_GetOffset

Label_ModeDecode:
	mov _Mode, 1


Label_GetOffset:
	; Eltolás bekérése
	mov edx, offset Str_Shift
	call WriteString

	call ReadInt

	cmp eax, 0
	jl Label_OffsetInvalid
	jmp Label_OffsetOK

Label_OffsetInvalid:
	; Hibás bemeneti adat (kisebb mint 0)
	mov edx, offset Str_Invalid
	call WriteString

	jmp Label_GetOffset

Label_OffsetOK:
	cmp _Mode, 1 ; Megnézem hogy mi a mód
	je Label_OffsetNeg ; Dekódolás?
	jmp Label_OffsetStore

Label_OffsetNeg:
	neg eax ; Dekódolásnál annyi a különbség, hogy visszafele kell tolni a betűket -> megfordítom a beírt eltolást

Label_OffsetStore:
	mov _Offset, eax


Label_GetInput:
	; Bemeneti kód bekérése
	mov edx, offset Str_Code
	call WriteString

	mov edx, offset _Input
	mov ecx, InputMax
	call ReadString

	mov _InputLength, eax ; EAX tartalmazza a beírt szöveg hosszát


Label_DoCode:
	; Caesar kódolás
	mov eax, 0 ; EAX tárolja az éppen kódolandó karaktert (pontosabban AL, de az egészet kiürítem)
	mov ecx, 0 ; ECX számolja hogy hol járok a bemeneti szövegben

Label_CodeLoop:

	; Átrakom a szöveg karakterét AL-be
	mov edx, offset _Input
	add edx, ecx
	mov al, [edx]

	; Megnézem, hogy a karakter kis vagy nagybetű
	cmp al, 'a'
	jge Label_AboveLowerA ; Ha a betű kis 'a' vagy nagyobb ascii kód

	cmp al, 'A'
	jge Label_AboveUpperA ; Ha a betű nagy 'A' vagy nagyobb ascii kód

	; Ha egyik se, akkor nem csinálok vele semmit
	jmp Label_CodeLoopEnd

Label_AboveLowerA:
	cmp al, 'z'
	jle Label_BelowLowerZ ; Ha a betű kis 'z' vagy kisebb ascii kód
	jmp Label_CodeLoopEnd ; Nem kisbetű

Label_BelowLowerZ:
	; Itt már biztos vagyok benne, hogy a betű kis betű
	mov ebx, 0
	jmp Label_ShiftCharacter


Label_AboveUpperA:
	cmp al, 'Z'
	jle Label_BelowUpperZ ; Ha a betű nagy 'Z' vagy kisebb ascii kód
	jmp Label_CodeLoopEnd ; Nem nagybetű

Label_BelowUpperZ:
	; Itt már biztos vagyok benne, hogy a betű nagybetű
	mov ebx, 1

	; Kisbetűt csinálok AL-ből
	add al, 32

	jmp Label_ShiftCharacter


Label_ShiftCharacter: ; Itt történik az eltolás, bemenetek: AL = karakter ascii kódja (kisbetű), EBX = karakter eredeti mérete (0 = kisbetű, 1 = nagybetű)
	push ebx ; Eltárolom EBX értékét

	sub al, 97 ; Az ascii karakter kódból ABC relatív kódot csinálok
	movsx eax, al ; Kiterjesztem az kódot egy 32 bites számra

	add eax, _Offset ; Eltolom a kódot

	; Előkészülök maradékos osztásra: 32 bites osztás EDX:EAX / OP = EAX, maradék: EDX
	cdq ; EAX -> EDX:EAX
	
	mov ebx, 26
	idiv ebx ; 26 karakter van az angol ábécében

	; EDX-ben van a maradék, ez mondja meg, hogy az ábécében relatív, melyik betű a kódolás eredménye

	pop ebx
	cmp ebx, 1 ; Nagybetű volt az eredeti betű?
	je Label_NewUpper

Label_NewLower:
	mov al, 'a'
	jmp Label_CreateNewChar

Label_NewUpper:
	mov al, 'A'

Label_CreateNewChar:
	movsx eax, al ; Kiterjesztem az alap karatert 32 bitre, hogy tudjak vele számolni

	cmp edx, 0
	jl Label_NegativeOffset

	; Pozitív eltolás
	add eax, edx ; Ascii A + eltolás -> visszakapom az ascii kódot
	jmp Label_StoreNewChar

Label_NegativeOffset:
	mov ebx, 26 ; EBX már nem kell mert megvan az alap karater (kis vagy nagybetű)
	add ebx, edx ; 26-hoz hozzáadom a negatív eltolást, így az ábécé végétől visszafele számolok

	add eax, ebx ; Eltolom az ascii kódot az új pozitív eltolással

Label_StoreNewChar:
	; Visszarakom az új karaktert a szövegbe
	mov edx, offset _Input
	add edx, ecx
	mov [edx], al

Label_CodeLoopEnd:
	; A szöveg hosszáig megyek
	inc ecx ; Növelem a szöveg indexet
	cmp ecx, _InputLength ; Megnézem, hogy a végére értem-e
	jl Label_CodeLoop ; Ha nem, folytatom


Label_WriteOutput: ; Kiírja az eredményt
	; Kész a kódolás
	mov edx, offset Str_Result
	call WriteString

	mov edx, offset _Input
	call WriteString

	mov edx, offset Str_Quote
	call WriteString

	; Újsor + kilépés szöveg
	mov edx, offset Str_ExitTxt
	call WriteString

	; Várok egy karakter nyomást
	call ReadChar

	invoke ExitProcess,0
main endp
end main