diff --git a/src/kernel/memory/alloc.c b/src/kernel/memory/alloc.c
index 97d0a84..b968b61 100644
--- a/src/kernel/memory/alloc.c
+++ b/src/kernel/memory/alloc.c
@@ -1,37 +1,37 @@
+#include <_stdio.h>
 #include <alloc.h>
 #include <stdint.h>
-#include <_stdio.h>
 
-MemoryBlock* firstBlock;
+MemoryBlock *firstBlock;
 
 void initMemoryAllocation(uint32_t kernelEnd) {
-    firstBlock = (MemoryBlock*) kernelEnd;
+    firstBlock = (MemoryBlock *)kernelEnd;
     firstBlock->next = 0x00;
     firstBlock->last = 0x00;
     firstBlock->state = FREE;
     firstBlock->size = -1;
 }
 
-void* mallocTask(uint32_t size, Task* task) {
-    MemoryBlock* current = firstBlock;
-    while (! (current->next == 0x00 || current->state == FREE && current->size >= size)) {
+void *mallocTask(uint32_t size, Task *task) {
+    MemoryBlock *current = firstBlock;
+    while (!(current->next == 0x00 ||
+             current->state == FREE && current->size >= size)) {
         current = current->next;
     }
-    MemoryBlock* next;
+    MemoryBlock *next;
     if (current->next == 0x00) {
-        // this is currently the last block -> initialize the new last block
-        next = (MemoryBlock*) ((void*) (current + 1) + size);
+        next = ((void *)(&current[1]) + size);
         next->last = current;
         next->state = FREE;
         next->next = 0x00;
         next->size = -1;
     } else {
-        // there is a next block
         next = current->next;
     }
-    if (current->size > size + sizeof(MemoryBlock) * 2 && current->next != 0x00) {
+    if (current->size > size + sizeof(MemoryBlock) * 2 &&
+        current->next != 0x00) {
         // segment the current block if it is big enough
-        current->next = (MemoryBlock*) (((void*) (current + 1)) + size);
+        current->next = (MemoryBlock *)(((void *)(current + 1)) + size);
         current->next->size = current->size - sizeof(MemoryBlock) - size;
         current->size = size;
         current->next->state = FREE;
@@ -39,56 +39,49 @@
         next->last = current->next;
     } else {
         current->next = next;
-        if (current->next->next == 0x00) {
-            current->size = size;
-        }
     }
+    current->size = ((void *)next) - (void *)(current + 1);
     current->state = IN_USE;
     current->task = task;
-    return (void*) (current + 1);
+    return (void *)(current + 1);
 }
 
-void* malloc(uint32_t size) {
-    return mallocTask(size, (Task*) getCurrentTask());
+void *malloc(uint32_t size) {
+    return mallocTask(size, (Task *)getCurrentTask());
 }
 
-void mergeNextIfPossible(MemoryBlock* current) {
+void mergeNextIfPossible(MemoryBlock *current) {
     if (current->next != 0x00 && current->next->state == FREE) {
-        current->size = current->size + sizeof(MemoryBlock) + current->next->size;
+        current->size += sizeof(MemoryBlock) + current->next->size;
         current->next = current->next->next;
-        current->next->next->last = current;
+        current->next->last = current;
     }
 }
 
-void free(void* location) {
-    MemoryBlock* current = ((MemoryBlock*) location) - 1;
+void free(void *location) {
+    MemoryBlock *current = ((MemoryBlock *)location) - 1;
     current->state = FREE;
+    for (uint32_t i = 0; i < current->size; i++) {
+        ((uint8_t *)&current[1])[i] = 0;
+    }
     mergeNextIfPossible(current);
     if (current->last != 0x00 && current->last->state == FREE) {
         current = current->last;
     }
-    mergeNextIfPossible(current); // call this function twice in case a used block between 2 free blocks is freed
+    mergeNextIfPossible(current); // call this function twice in case a used
+                                  // block between 2 free blocks is freed
     mergeNextIfPossible(current);
 }
 
-void printMemoryStack() {
-    MemoryBlock* current = firstBlock;
-    while (current->next != 0x00) {
-        printf("AT: %x size: %x next: %x last: %x, state: %x\n", current, current->size, current->next, current->last, current->state);
-        current = current->next;
-    }
-    printf("AT: %x size: %x next: %x last: %x, state: %x\n", current, current->size, current->next, current->last, current->state);
-}
-
-void freeTaskAllocations(Task* task) {
-    MemoryBlock* current = firstBlock;
+void freeTaskAllocations(Task *task) {
+    MemoryBlock *current = firstBlock;
     while (current->next != 0x00) {
         if (current->task == task) {
-            free(current);
+            free(current + 1);
         }
         current = current->next;
     }
     if (current->task == task) {
-        free(current);
+        free(current + 1);
     }
-}
\ No newline at end of file
+}