Creando un socket con FASM para Linux

[Yuki]

Bueno, como estoy creando un malware para Linux tengo que escribir y probar código, tuve (y tengo) bastantes problemas con los sockets, no por su complejidad de uso (que es nula), sino por el simple hecho de que no obtengo los resultados deseados.

Escribí este código para encontrar el error de manera más sencilla, pero no pude hacerlo debido a que milagrosamente el código decidió funcionar sin problemas (o eso creo).


Para FASM:

Código (asm) [Seleccionar] Expandir

format ELF executable 3
entry start

segment readable executable

SYS_SOCKET = 1
SYS_SOCKETCALL = 102
SYS_WRITE = 4

start:
        mov DWORD[sockparams+4*0],2 ; PF_INET - AF_INET (2)
        mov DWORD[sockparams+4*1],1 ; SOCK_STREAM (1)
        mov DWORD[sockparams+4*2],0 ; 0, También probé con IPPROTO_TCP (6)

        lea ecx,DWORD[sockparams]
        mov ebx,SYS_SOCKET
        mov eax,SYS_SOCKETCALL
        int 0x80
        cmp eax,0
        je .MOSTRAR_MENSAJE_CERO
        js .MOSTRAR_MENSAJE_MENOR_CERO
        jb .MOSTRAR_MENSAJE_MENOR_CERO
        ja .MOSTRAR_MENSAJE_NO_CERO
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_CERO:
        mov edx,7
        mov ecx,cero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_NO_CERO:
        mov edx,19
        mov ecx,nocero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
        jmp .CONTINUAR
.MOSTRAR_MENSAJE_MENOR_CERO:
        mov edx,15
        mov ecx,menorcero_mensaje
        mov ebx,1
        mov eax,SYS_WRITE
        int 0x80
.CONTINUAR:
        mov eax,1
        xor ebx,ebx
        int 0x80

segment readable writeable

        sockparams rd 10

        menorcero_mensaje db 'Menor a cero...',0
        cero_mensaje db 'Cero...',0
        nocero_mensaje db 'Es mayor a cero! :0',0

Considero que está muy claro, pero si no se entiende no duden en decirme. Espero que les sirva a aquellas personas interesadas en la programación de bajo nivel para Linux.

Testeado en TinyCore Linux emulado mediante QEMU.

[cpu2]

Hola

Porque en las líneas 11,12 y 13 pasas los parámetros con un mov?

No es mejor dejarlos ya preparados como los mensajes de abajo, y luego pasar el puntero de una sola instrucción?

Lo mismo con los saltos, y las etiquetas para los write, sobran instrucciones.

Si pretendes programar malware de calidad, optimiza tus códigos.

Saludos.

[Yuki]

Es un código de ejemplo, lo escribí de esta manera para el foro

Y si te molesta mi código, te recomiendo que veas el de SpyNET, uno de los rats más respetados... su código es un total desastre  te va a agarrar una embolia cuando lo leas

[cpu2]

No me molestas tu código, simplemente es para que lo veas. Puedes escribir código entendible, sin tantas instrucciones, como lo tienes escrito para tí? Sin el ejemplo?

No conozco ese código de SpyNET, si me facilitas la búsqueda te lo agradecería.

Por último, si tienes más problemas te invito ha que los postees, este subforo está inactivo.

Saludos.

[Yuki]

Es un código de ejemplo, lo escribí de esta manera para el foro

Y si te molesta mi código, te recomiendo que veas el de SpyNET, uno de los rats más respetados... su código es un total desastre  te va a agarrar una embolia cuando lo leas

Lo decía jugando, no es de mala manera

Dejo el código que yo considero optimizado a continuación:

Código (asm) [Seleccionar] Expandir

format ELF executable 3
entry start

segment readable executable

SYS_SOCKET = 1
SYS_SOCKETCALL = 102
SYS_WRITE = 4

start:
        mov ecx,sockparams
        mov ebx,SYS_SOCKET
        mov eax,SYS_SOCKETCALL
        int 0x80

        test eax,eax
        jz .ZERO
        js .BELOW_ZERO
        jnz .ABOVE_ZERO
.ZERO:
        mov edx,7
        mov ecx,cero_mensaje
        jmp .WRITE
.ABOVE_ZERO:
        mov edx,19
        mov ecx,nocero_mensaje
        jmp .WRITE
.BELOW_ZERO:
        mov edx,15
        mov ecx,menorcero_mensaje
.WRITE:
        xor ebx,ebx ; Dos opcode menos
        inc ebx     ;
        mov eax,SYS_WRITE
        int 0x80

        xor eax,eax ; Dos opcode menos
        inc eax     ;
        xor ebx,ebx
        int 0x80

segment readable writeable

        sockparams        dd 2,1,0
        menorcero_mensaje db 'Menor a cero...',0
        cero_mensaje      db 'Cero...',0
        nocero_mensaje    db 'Es mayor a cero! :0',0

Si se puede optimizar más avisenme, por ahí necesito mejorar mis códigos. Aunque en realidad ya no uso el sistema SYS_CALL, sino que uso la librería de C para los sockets.

[cpu2]

Con la optimización te refieres al tamaño del código? O a su rapidez?

En el:

Código (asm) [Seleccionar] Expandir

xor ebx, ebx
Inc ebx

// Mejor

mov ebx, 1

En el del eax igual. Y arriba en los saltos lógicos podrías ahorrar el jz. Ya que si ningún salto condicional como jnz y js es válido ejecutaría la etiqueta ZERO automáticamente.

Si entiendo que no quieras usar algunas syscalls, se quedan cortas... Ejemplo el write mismo, es mucho más práctico printf, pero bueno write está enfocado a más cosas no solo a imprimir texto en pantalla atraves de su descriptor.
Saludos

[Yuki]

Está bueno el planteo, yo siempre creí que

Código (asm) [Seleccionar] Expandir

xor ebx,ebx
inc ebx

sería más rápido que:

Código (asm) [Seleccionar] Expandir

mov ebx,1

Lo ideal siempre es optimizar la velocidad y el tamaño juntos, pero si el primero es más lento que el segundo no creo que tenga mucho sentido ahorrar 2 bytes.

Es verdad que siguen sobrando líneas, no se porqué no me dí cuenta