Removed ossec solutions

school/os-sec/uebung/02/02_1.md

@@ -1,54 +0,0 @@
-# Aufgabe 1
-
-1)
-    * Fragment 1: fastcall, da die parameter durch die register eax, edx und ecx übergeben werden, return value in eax
-	* Fragment 2: cdecl, da die parameter in right-to-left order auf dem stack liegen, return value in eax, kein stack
-        cleanup
-	* Fragment 3: stdcall, parameter in right-to-left order auf dem stack, return value in eax, callee cleanup
-
-2)
-    * Fragment 1: EAX = a, edx = b, ecx = c
-
-Annahme: Angabe der Parameterreihenfolge _nach_ dem call, also im neuen stackframe
-    * Fragment 2: ebp+0x8 = a, ebp+0x0c = b, ebp+0x10 = c
-    * Fragment 3: ebp+0x8 = a, ebp+0x0c = b, ebp+0x10 = c
-
-Annahme: Angabe der Parameterreihenfolge _vor_ dem call, also im alten stackframe
-    * Fragment 2: esp = a, esp+0x4 = b, esp+0x8 = c
-    * Fragment 3: esp = a, esp+0x4 = b, esp+0x8 = c
-
-
-3)
-    * Fragment 1: Caller cleanup bzw da nur 3 Parameter verwendet werden, kein stack cleanup nötig, da alle parameter
-        über register übergeben werden
-    * Fragment 2: Caller cleanup
-    * Fragment 3: Callee cleanup
-
-4)
-    Fragment 1:
-
-    ```
-    MOV eax, 3
-    MOV edx, 2
-    MOV ecx, 1
-    CALL f
-    ```
-
-    Fragement 2:
-
-    ```
-    PUSH 1
-    PUSH 2
-    PUSH 3
-    CALL f
-    ADD ESP, 12
-    ```
-
-    Fragment 3:
-
-    ```
-    PUSH 1
-    PUSH 2
-    PUSH 3
-    CALL f
-    ```

school/os-sec/uebung/02/02_2.c

@@ -1,63 +0,0 @@
-#include<inttypes.h>
-
-/*
-PUSH    EBP
-MOV EBP,   ESP
-SUB ESP ,   4						; reserve 4 bytes in the stack frame -> local variable int32_t -> i
-MOV DWORD PTR  [ EBP − 4 ] ,   1	; initialize local variable with 1
-
-; EBP+8 : first parameter -> a
-; EBP+12 : second parameter -> b
-
-loop:
-CMP DWORD PTR  [ EPB+ 8 ] ,   99	; while (a >= 99)
-JL SHORT  exit
-LEA EAX,   [ EBP+12 ]				; eax = *b;
-DEC DWORD PTR  [EAX]				; *b--;
-CMP DWORD PTR  [ EBP+ 12 ] ,   99	; if (b >= 99)
-JL SHORT  continue
-JMP SHORT  exit						; break
-
-continue:
-MOV EDX,   [ EBP+8]					; edx = a
-LEA EAX,   [ EBP − 4]				; eax = *i
-ADD DWORD PTR  [EAX] ,  EDX			; *eax += edx -> i += a
-INC DWORD PTR  [ EBP+8]				; a++;
-JMP SHORT  loop						; loop
-
-exit:
-MOV EAX,  DWORD PTR  [ EBP − 4]		; return i
-MOV ESP ,  EBP						; cleanup
-POP EBP								; cleanup
-RETN
-
- */
-
-int32_t f(int32_t a, int32_t b) {
-	int32_t i = 1;
-	b--;
-	while (a >= 99 && b < 99) {
-		i += a;
-		a++;
-		b--;
-	}
-	return i;
-}
-
-/* int32_t f(int32_t a, int32_t b) { */
-/* 	int32_t i = 1; */
-/* 	while (a >= 99) { */
-/* 		b--; */
-/* 		if (b < 99) { */
-/* 			i += a; */
-/* 			a++; */
-/* 		} else { */
-/* 			break; */
-/* 		} */
-/* 	} */
-/* 	return i; */
-/* } */
-
-int main(void) {
-	f(1,2);
-}

school/os-sec/uebung/02/02_3.md

@@ -1,39 +0,0 @@
-# Übung 2 Aufgabe 3
-
-1.
-
-| Instruction      | Kommentar                                       |
-| ---              | ---                                             |
-| `push eax`       | speichere wert aus eax auf dem stack            |
-| `push ecx`       | 2. Parameter wird auf Stack gepusht             |
-| `push edx`       | 1. Parameter wird auf Stack gepusht             |
-| `call CAFEBABEh` | Subrotine an Adresse 0xCAFEBABE wird aufgerufen |
-| `add esp, 12`    | Zuvor gepushte parameter werden aufgeräumt      |
-
-| Instruction            | Kommentar                                                            |
-| ---                    | ---                                                                  |
-| `push ebp`             | Wert von ebp wird auf Stack gespeichert                              |
-| `mov ebp, esp`         | ebp Zeigt auf aktuellen stack pointer                                |
-| `sub esp, 4`           | lokalen stackframe von 4 bytes reservieren                           |
-| `mov ecx, [ebp+8]`     | schreibe parameter 1 nach ecx                                        |
-| `add ecx, [ebp+12]`    | addiere parameter 2 auf ecx (param1+param2)                          |
-| `mov [ebp-4], ecx`     | schreibe wert aus eax in lokalen stackframe; int x = (param1+param2) |
-| `dec dword ptr[ebp-4]` | subtrahiere 1 von wert in lokalem stackframe; x--                    |
-| `dec dword ptr[ebp-4]` | subtrahiere 1 von wert in lokalem stackframe; x--                    |
-| `mov eax, [ebp-4]`     | schreibe wert aus lokalem stackframe nach eax; return x              |
-| `mov esp, ebp`         | stelle alten stackpointer wieder her                                 |
-| `pop ebp`              | stelle alten basepointer wieder her                                  |
-| `ret 8`                | springe zurück zum aufrufenden punkt und räume den stack auf         |
-
-2.
-
-```
-int32_t f(int32_t a, int32_t b) {
-	return (a+b)-2;
-}
-```
-
-3.
-
-4.
-Sowohl Caller, also auch Callee räumen den Stack auf. Darüber hinaus