; example for exception handlig
format ELF executable
entry start

SYSCALL_EXIT  equ 1 ; syscall to function exit()
SYSCALL_WRITE equ 4 ; syscall to function write()
STDERR        equ 2 ; standard error

EXCEPTION_ID_DIVISION_BY_ZERO equ 2 ; exception id for 'division by zero'

section readable writeable
div_by_zero_exception_msg db 'Exception: Division by zero', 0xa
div_by_zero_exception_msg_size = $-div_by_zero_exception_msg
unknown_exception_msg db 'Exception: Unknown', 0xa
unknown_exception_msg_size = $-unknown_exception_msg

section readable executable
start:
; try
        mov     eax, 20
        mov     ebx, 0 ; <----- this will cause an exception!
; attempt to calculate eax/ebx
        call    do_complicated_calculations_1
        mov     eax, 30
        mov     ebx, 3
; attempt to calculate eax/ebx
        call    do_complicated_calculations_1
; success, set exit code to 0
        xor     ebx, ebx
        jmp     .finish
.catch_exception:
; check for exception id
        cmp     eax, EXCEPTION_ID_DIVISION_BY_ZERO
        jne     .prepare_unknown_exception_message
; prepare printing of 'division by zero' message
        mov     ecx, div_by_zero_exception_msg
        mov     edx, div_by_zero_exception_msg_size
        jmp     .print_exception_message
.prepare_unknown_exception_message:
; prepare printing of 'unknown' message
        mov     ecx, unknown_exception_msg
        mov     edx, unknown_exception_msg_size
.print_exception_message:
; print exception message
        mov     eax, SYSCALL_WRITE
        mov     ebx, STDERR
        int     0x80
; exception cought, set exit code to 1
        mov     ebx, 1
.finish:
        mov     eax, SYSCALL_EXIT
        int     0x80

;***************************************************************************
;  Some functions which the exception will jump over
;***************************************************************************
do_complicated_calculations_1:
        call    do_complicated_calculations_2
; more very long computations may be here
        ret

do_complicated_calculations_2:
        call    do_complicated_calculations_3
; more very long computations may be here
        ret

do_complicated_calculations_3:
        call    do_complicated_calculations_4
; more very long computations may be here
        ret

do_complicated_calculations_4:
        call    do_division
; more very long computations may be here
        ret

;***************************************************************************
;   Function
;      do_division
;   Description
;      tries to calculate result of eax / ebx
;      if ebx is zero then a division by zero exception is raised.
;   Parameters
;      eax - dividend
;      ebx - divisor
;   Return value
;      eax - result
;   Destroyed registers
;      eax, edx
;
;***************************************************************************
do_division:
        test    ebx, ebx
        jnz     .compute
; raise exception
        mov     eax, EXCEPTION_ID_DIVISION_BY_ZERO ; exception id is the parameter
; skip stack frames before that of start
        add     esp, 20
        jmp     start.catch_exception
.compute:
        xor     edx, edx
        div     ebx
        ret    

if ./exception; then echo ok; else echo not ok; fi    

#include <stdio.h>
#include <signal.h>
#include <setjmp.h>

void my_signal_handler(int status);
static jmp_buf env;

int main(void)
{
   signal(SIGSEGV, my_signal_handler);

   if(setjmp(env) == 0) {
      asm ("pushl 0");
   }

   printf("but I'm still alive\n");
   return 0;
}

void my_signal_handler(int status)
{
   printf("received SIGSEGV signal, status = %d\n", status);
   longjmp(env, 1);
}    

; example for exception handlig
format ELF executable
entry start

SYSCALL_EXIT   equ 1  ; syscall to function exit()
SYSCALL_WRITE  equ 4  ; syscall to function write()
SYSCALL_SIGNAL equ 48 ; syscall to function signal()
SIGSEGV        equ 11 ; signal id SIGSEGV
STDERR         equ 2  ; standard error

section readable writeable
signal_handler_msg db 'Hmmm, SIGSEGV signal received', 0xa
signal_handler_msg_size = $-signal_handler_msg
reborn_msg db "but I'm still alive", 0xa
reborn_msg_size = $-reborn_msg

section readable executable
start:
; install signal handler
        mov     eax, SYSCALL_SIGNAL
        mov     ebx, SIGSEGV
        mov     ecx, my_signal_handler
        int     0x80
; do something dirty
        push    dword [fs:0]
; print reborn message
.print_reborn_msg:
        mov     eax, SYSCALL_WRITE
        mov     ebx, STDERR
        mov     ecx, reborn_msg
        mov     edx, reborn_msg_size
        int     0x80
.finish:
        xor     ebx, ebx
        mov     eax, SYSCALL_EXIT
        int     0x80

my_signal_handler:
; print exception message
        mov     eax, SYSCALL_WRITE
        mov     ebx, STDERR
        mov     ecx, signal_handler_msg
        mov     edx, signal_handler_msg_size
        int     0x80
; remove return adress from the stack
        add     esp, 4
; jump after the erroneous code
        jmp     start.print_reborn_msg    

but only ptrace with pokeusr or peekusr (request 3 or 6)
could acces them
but ptrace is finally a system call it seems
so one could be able to embed it in the handler
doesnt it work that way ??

i saw in the above snippet one can write a reborn message ??
so instead of reborn message if i wish to modify the instruction pointer
to two bytes(i take two bytes as an arbitrary length actually the length of the offending codes mnemonic) below the offending code and just continue as if
nothing really happened how would i go about it
in assembly

; example for exception handlig
format ELF executable
entry start

SYSCALL_EXIT      equ 1  ; syscall to function exit()
SYSCALL_WRITE     equ 4  ; syscall to function write()
SYSCALL_SIGACTION equ 67 ; syscall to function sigaction()
SA_NOCLDSTOP      equ 0x00000001
SA_NOCLDWAIT      equ 0x00000002 ; not supported yet
SA_SIGINFO        equ 0x00000004 ; use sa_sigaction instead of sa_handler
SA_ONSTACK        equ 0x08000000
SA_RESTART        equ 0x10000000
SA_NODEFER        equ 0x40000000
SA_RESETHAND      equ 0x80000000
SIGSEGV           equ 11 ; signal id SIGSEGV
STDERR            equ 2  ; standard error

; sigaction structure for installing signal handler
struc sigaction sa, m, f {
        .sa_sigaction dd sa ; void (*sa_sigaction)(int, siginfo_t *, void *);
        .sa_mask      dd m  ; sigset_t sa_mask;
        .sa_flags     dd f  ; int sa_flags;
        .sa_restorer  dd 0  ; void (*sa_restorer)(void); -- obsoleted, don't use it
}

; sigcontext structure used in ucontext below
; it contains eip we're going to overwrite when catching signal
struc sigcontext {
        .gs            rw 1
        .__gsh         rw 1
        .fs            rw 1
        .__fsh         rw 1
        .es            rw 1
        .__esh         rw 1
        .ds            rw 1
        .__dsh         rw 1
        .edi           rd 1
        .esi           rd 1
        .ebp           rd 1
        .esp           rd 1
        .ebx           rd 1
        .edx           rd 1
        .ecx           rd 1
        .eax           rd 1
        .trapno        rd 1
        .err           rd 1
        .eip           rd 1
        .cs            rw 1
        .__csh         rw 1
        .eflags        rd 1
        .esp_at_signal rd 1
        .ss            rw 1
        .__ssh         rw 1
        .fpstate       rd 1
        .oldmask       rd 1
        .cr2           rd 1
}

virtual at 0
        sigcontext sigcontext
end virtual

; sigset structure used in ucontext below
_NSIG             equ 64
_NSIG_BPW         equ 32
_NSIG_WORDS       equ (_NSIG / _NSIG_BPW)

struc sigset_t {
        .sig rd _NSIG_WORDS
}

; signalstack structure used in ucontext below
struc signaltstack {
        ss_sp    rd 1
        ss_flags rd 1
        ss_size  rd 1
}

; structure type for 3rd parameter of signal handler
struc ucontext {
        .uc_flags    rd 1
        .uc_link     rd 1
        .uc_stack    signaltstack
        .uc_mcontext sigcontext
        .uc_sigmask  sigset_t
}

virtual at 0
        ucontext ucontext
end virtual

; some dangereous statements
macro do_dirty {
        push    dword [ds:0]
        mov     dword [ds:0], eax
        push    dword [fs:0]
}

; determine size of those statements at compilation time
virtual at 0
        do_dirty
        sizeof.do_dirty=$
end virtual


; define section for code and constants
section readable executable

; new_act is constant that's why it is here
new_act sigaction my_signal_handler, 0,  SA_SIGINFO

start:
; install signal handler
        mov     eax, SYSCALL_SIGACTION
        mov     ebx, SIGSEGV
        mov     ecx, new_act
        xor     edx, edx
        int     0x80
; check result of installing signal handler
        test    eax, eax
        mov     ebx, eax ; set exit value
        jnz     .finish
; do something dirty
        do_dirty
; print reborn message
        mov     eax, SYSCALL_WRITE
        mov     ebx, STDERR
        mov     ecx, reborn_msg
        mov     edx, reborn_msg_size
        int     0x80
        xor     ebx, ebx
.finish:
        mov     eax, SYSCALL_EXIT
        int     0x80

my_signal_handler:
; print exception message
        mov     eax, SYSCALL_WRITE
        mov     ebx, STDERR
        mov     ecx, signal_handler_msg
        mov     edx, signal_handler_msg_size
        int     0x80
; get parameter ucontext
        mov     eax, [esp+12]
; modify eip
        add     dword [eax+ucontext.uc_mcontext+sigcontext.eip], sizeof.do_dirty
        ret

; define section for data
section readable writeable
signal_handler_msg db 'Hmmm, SIGSEGV signal received', 0xa
signal_handler_msg_size = $-signal_handler_msg
reborn_msg db "but I'm still alive", 0xa
reborn_msg_size = $-reborn_msg    

now atleast i can understand how to alter eip to point to some other place

macro mov arg1,arg2
{
   if arg1 eq eip
      jmp arg2
   else
     mov arg1,arg2
}