find_kernel32:                                            ; 
  push esi                                                ; preserve the esi register.
        push ecx                                                ; preverse the ecx register.
        xor ecx, ecx                                    ; zero ecx so that it can be used as the
                                                                    ;   offset to obtain the first entry in the SEH list.
       mov esi, fs:[ecx]                           ; grab the first entry in the SEH list and store it in esi.
 not ecx                                                 ; flip all the bits in ecx so that it can be used in the
                                                                    ;   comparison later to determine if the last exception
                                                                     ;   handler has been hit.
find_kernel32_seh_loop:                                ; 
  lodsd                                                   ; load the next entry in the SEH list and store it in eax.
  mov esi, eax                                    ; initialize esi to the next entry in the list so that it’s
                                                                       ;   ready should the code need to loop again.
       cmp [eax], ecx                                  ; compare the value at eax to see if its set to 0xFFFFFFFF.
                                                                 ;   if it is, the last entry in the list has been reached and
                                                                       ;   it’s function pointer should be inside kernel32.dll.
  jne find_kernel32_seh_loop              ; if the values are not equal then the base address has not
                                                                 ;   been found. Loop again.
find_kernel32_seh_loop_done:         ; 
  mov eax, [eax + 0x04]                   ; if the next entry in the list was equal to 0xFFFFFFFF, one
                                                                        ;   knows the end has been hit. As such one can extract the
                                                                 ;   function pointer for this entry and store it in eax.
find_kernel32_base_loop:                        ; 
  dec eax                                                 ; decrement eax. If the previous value was aligned to a 64Kb
                                                                        ;   boundary, this will set us the low 16 bits of eax to
                                                                    ;   0xFFFF. if this is not the case it will simply decrement
                                                                        ;   eax to an undetermined value.
   xor ax, ax                                              ; zero the low 16 bits of eax to align the address on a
                                                                     ;   64Kb boundary.
  cmp word ptr [eax], 0x5A4D              ; check to see if the 2 byte value at eax is ’MZ’.
      jne find_kernel32_base_loop             ; if the values do not match, loop again and go to the next
                                                                 ;   lower 64Kb boundary. if they do match, drop down as the
                                                                 ;   base address of kernel32.dll has been successfully found.
find_kernel32_base_finished:               ; 
  pop ecx                                                 ; restore ecx to its original value.
        pop esi                                                 ; restore esi to its original value.
        ret                                                             ; return address to the caller.
    

GetKernelBase:
        find_kernel32:
            push esi
            push ecx

            xor ecx, ecx

            mov esi, [fs:ecx] ;How exactly does this work

            not ecx        

        find_kernel32_seh_loop:
            lodsd                                                
            mov esi, eax                            

            cmp [eax], ecx ;Why does it crash here, the debugger views this as cmp dword ptr ds:[eax], ecx, why? What is ds and why is it there?
            jne find_kernel32_seh_loop

        find_kernel32_seh_loop_done:
            mov eax, [eax + 4h] ;Crashes, same thing happens here, debugger: mov eax, dword ptr ds:[eax + 4h] 

        find_kernel32_base_loop:
            dec eax     
            xor ax, ax
            cmp word [eax], 0x5A4D ;Crashes, same thing also happens here

            jne find_kernel32_base_loop

        find_kernel32_base_finished:
            pop ecx   
            pop esi
            ret
    

Im attempting to have dynamically import every API by finding

the kernel32.dll base

;----  Get
;----  Kernel Base  M Z

         mov  eax, [fs:30h]
         mov  edx, 0B8h
         mov  ecx, [eax+30h]
         test eax,  eax
     jns KI_1
         mov  ebx, [eax+34h]
         test ecx,  ecx
     jnz KI_2

 KI_1:
         mov  eax, [eax+0Ch]
         sub  edx, 0B0h
         mov  eax, [eax+1Ch]
         mov  ebx, [eax]
 KI_2:
         mov  eax, [ebx+edx]
         mov [BUFFER_0], eax

     xor  eax, eax
     mov  eax, [fs:00h]    

find_kernel32:
        push esi
        push ecx
        xor ecx, ecx
        mov eax, [fs:ecx]            ;exchanged for mov esi, [fs:ecx]
        not ecx

find_kernel32_seh_loop:
        mov  esi,eax                 ;instead of destroying pointer esi with mov esi, eax
        lodsd
        cmp eax, ecx                 ;not [eax]
        jne find_kernel32_seh_loop

find_kernel32_seh_loop_done:
        mov eax, [esi]               ;esi has already been incremented by lodsd

find_kernel32_base_loop:
        dec eax
        xor ax, ax
        cmp word [eax], 0x5A4D
        jne find_kernel32_base_loop

find_kernel32_base_finished:
        pop ecx
        pop esi
        ret    

invoke GetModuleHandle,'Kernel32'