Es por que antes estaba en VB6 y lo he movido aquí

Oks, ahora mismo lo pruebo entonces ^^

Gracias

dark_hat, muy interesante el código, por la estructura de linux (que usa elfs ) no tiene mucho sentido crear un virus, pero la verdad es que es muy interesante el código. Estoy intentándolo probarlo ahora mismo, que ensamblador has usado??

Salu2

Cualquier programa accede constantemente a posiciones de memoria, y el tuyo no es una excepción, además por el propio funcionamiento de CreateThread tienes que acceder a la posición de memoria de hThreadID, de ahí que tenga que ser un puntero, pero claro en Vb...

Prueba esto, dale a hThreadID el valor 5 antes de llamar al api (hThreadID = 5) y luego ejecútalo, a ver que valor hexadecimal te sale en el mensaje de error... (si subieras un poco de code no tendríamos que andar con estas..)


Una función o un sub? como lo tienes declarado??

De todas formas los hilos en VB6 siempre te van a dar problemas...
Salu2

Lo he leído bien...


De todas formas da igual, solo era un a aclaración. Las apis son propias de cada SO, por eso no puedes usar el api de windows en ubuntu

Para hacer programas que te sirvan en los dos SO's (y en más) y sin tener que recompilar o cambiar una sola línea de código puedes usar java, C# y demás lenguajes de la plataforma .net (gracias a mono) y no se si alguno más, esos son los que yo conozco 

Salu2

Dios mio!! pero no digas burradas!!! Como va a haber apis como las de windows???? el api de windows es propio de windows como su nombre indica, no puedes usarlo en linux  Linux ya cuenta con su propias apis, informatete sobre los syscall's

Salu2

Pues por ejemplo vale para meterle código (generalmente para un virus) cambiar el EP para que apunte a la nueva sección y que sea lo primero que se ejecute. También se puede ampliar el tamaño de la última sección
Otro uso es meterle código de nuevo, encriptar el resto de secciones y usarlo a modo de crypter

Salu2 E0N

Pues como dice el título con esta función se puede añadir una sección nueva a un ejecutable para meter en ella lo que queramos (para un virus o un crypter os será útil )

Se pueden reducir unos pocos bytes simplificando un poco el código, pero lo he dejado así para que se entiendan mejor los pasos que hay que seguir, bueno, ahí va:

; Codigo para añadir una sección a un ejecutable by E0N
include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
start:
 
        stdcall AddSection, rutaAdd, nombreSec, 0x1000, 0xE0000020 ;CODE+MEM_EXECUTE+MEM_READ+MEM_WRITE
        invoke ExitProcess, 0
 
        rutaAdd   db 'H:\archivo.exe',0
        nombreSec db '.new',0
 
 
; Procedimiento que añade una sección a un archivo. Parametros:
; ruta        -> Ruta del archivo al que le añadiremos la sección
; nombre      -> El nombre de la nueva sección
; tam         -> Tamaño de la nueva sección (RawSize)
; propiedades -> Las caracteristicas de la sección
proc AddSection ruta, nombre, tam, propiedades
locals
   hFile      dd ?  ; Handle del archivo
   TamAr      dd ?  ; Tamaño del archivo+Tamaño sección nueva
   hMap       dd ?  ; Handle del archivo mapeado
   IB         dd ?  ; Desde donde se carga en memoria
 
   PE         dd ?  ; Puntero a PE\0\0
   UltSec     dd ?  ; Inicio de la sección a añadir (final de la última sección)
   VOffset    dd ?  ; El VirtualOfffset de la nueva sección
endl
 
     ; Guardamos los registros
     pusha
 
     ; Mapeamos el archivo en memoria con [tam] bytes de más
     invoke CreateFile, [ruta], GENERIC_READ+GENERIC_WRITE, FILE_SHARE_WRITE+FILE_SHARE_READ, 0, OPEN_EXISTING, 0,0
     mov [hFile], eax
     invoke GetFileSize, [hFile], 0
     add eax, [tam]
     mov [TamAr], eax
     invoke CreateFileMapping, [hFile], 0, PAGE_READWRITE, 0, [TamAr], 0
     mov [hMap], eax
     invoke MapViewOfFile, eax, FILE_MAP_ALL_ACCESS, 0, 0, 0
     mov [IB], eax
 
     ; Le restamos 0x28 al offset 0x3C y guardamos la posición actual del signature
     mov eax, [IB]
     sub dword[eax+0x3C], 0x28
     add eax, dword[eax+0x3C]
     mov [PE], eax
 
     ; Desplazamos las cabeceras 0x28 bytes
     mov esi, [PE]
     add esi, 0x28
     mov edi, [PE]
 
     xor ebx, ebx
     mov bx, word[esi+0x6]
     mov eax, 0x28
     mul ebx
     mov ecx, eax
     add ecx, 248
     push ecx
 
     rep movsb
 
     pop ebx
     add ebx, [PE]
     mov [UltSec], ebx
     invoke RtlZeroMemory, ebx, 0x28
 
     ; Calculamos el VirtualOffset de la nueva sección
     mov edi, [UltSec]
     sub edi, 0x28
     mov ebx, [PE]
 
     mov eax, dword[edi+8]  ; eax = VirtualSize+VirtualOffset+SectionAligement (redondeado)
     add eax, dword[edi+12]
     add eax, dword[ebx+0x38]
     and eax, 0xFFFFF000
     mov [VOffset], eax
 
 
     ; Añadimos la sección al section header
     mov eax, [PE]
     add eax, 0x6
     inc word[eax]
 
     invoke lstrlen, [nombre]
     invoke RtlMoveMemory, [UltSec], [nombre], eax ; Name
     mov edi, [UltSec]
     mov dword[edi+8],  0x00000000    ; VirtualSize
     mov eax, [VOffset]
     mov dword[edi+12], eax           ; VirtualOffset
     mov eax, [tam]
     mov dword[edi+16], eax           ; RawSize
     mov eax, [TamAr]
     sub eax, [tam]
     mov dword[edi+20], eax           ; RawOfset
     mov eax, [propiedades]
     mov dword[edi+36], eax           ; Propiedades
 
     ; Cambiamos el SizeOfImage
     mov eax, [PE]
     mov ebx, [tam]
     add dword[eax+0x50], ebx
 
     ; Liberamos memoria, restauramos los registros y volvemos
     invoke CloseHandle, [hFile]
     invoke CloseHandle, [hMap]
     invoke UnmapViewOfFile, [IB]
     popa
     ret
endp
 
.end start

Salu2 E0N

NOTA: Por el método que se emplea si se intentan añadir muchas secciones así el ejecutable quedará corrupto, es útil para añadir una o dos (más que suficientes por otra parte). Si se quieren añadir más habría que adoptar otro método. A lo mejor me animo y subo el código para hacerlo de la otra forma

Pues adivinos no somos, pega un trozo del código donde te da el error (usa el debugger). Aunque el fallo tiene toda la pinta de ser por que creas mal el hilo, fíjate que intentas acceder a la posición 0x000.. y ahí no hay nunca nada

Debuggea para ver si el hilo se crea o no. Yo creo que va a ser eso, pero sin ver código imposible saberlo...

Salu2

Prueba así:

struct hostent *host;
host=gethostbyname("localhost");
servidor.sin_addr = *((struct in_addr *)host->h_addr);
 

Salu2

No te recomiendo que pierdas mucho el tiempo con eso, pero bueno.. Aquí puedes ver todas las funciones de esa unidad:
http://docs.mis-algoritmos.com/pascal.ref.Graph.html

Mira, aquí tienes la documentación de ese debugger en español:
http://www.drk.com.ar/docs/development/conociendo_gdb.php

No hace falta instalar nada, pon en la consola "gdb" y listo


Salu2

http://msdn.microsoft.com/en-us/library/ms682437.aspx

La primera entrada en google poniendo solamente su nombre y zas!, llegas a la documentación oficial de MS

Y si ya buscas un poco más pues encuentras un código en este mism foro que hace lo que tu quieres:
http://foro.elhacker.net/programacion_vb/inyeccion_para_crashear_procesos-t200065.0.html;msg951183#msg951183

Salu2

Hola

Yo para la universidad tuve que hacer un "pinball" en pascal, que realmente es una pelota (bueno una 'O') que choca y cae xD Te lo dejo para que veas como hize para imprimir el tablero y tal.

Lo del busca-minas es muy simple. Pintas el tablero y pides por teclado una casilla (no hace falta que uses grafics ni nada de eso) y usas GoToXY para pintar donde quieras y listo. Te dejo mi "pinball" por si le quieres hechar un ojo a algunas funciones que te pueden ser útiles

PROGRAM P3A;
 
USES 
 
  CRT;
 
CONST
 
  (* Colores para el formato del texto *)
 
  BLANCO   = 15;
 
  AMARILLO = 14;
 
  ROJO     = 4;
 
 
 
  (* Bordes del tablero *)
 
  ESQ_SUPI = chr(201);
 
  ESQ_SUPD = chr(187);
 
  ESQ_INFI = chr(200);
 
  ESQ_INFD = chr(188);
 
  BOR_HORI = chr(205);
 
  BOR_VERT = chr(186);
 
 
 
  (* Elementos del tablero *)
 
  PELOTA   = 'O';
 
  OBSTAC   = chr(219);
 
 
 
TYPE
 
  (* El tipo de array del tablero *)
 
  ATablero = ARRAY [0..9, 0..6] OF char;
 
  (* Estructura para la posici¢n de la pelota *)
 
  StructPos = RECORD
 
    F : Integer;         (* Fila donde se encuentra la pelota *)
 
    C : Integer;         (* Columna donde se encuentra la pelota *)
 
    Direccion : Integer; (* Direcci¢n hacia la que va la pelota *)
 
  END;
 
 
 
(************************************)
 
(*           SUBPROGRAMAS           *)
 
(************************************)
 
 
 
 
 
(* Procedure que va llamando a distintos procedures
 
para crear la animaci¢n completa as¡ como pedir datos
 
y de m s. *)
 
PROCEDURE CrearAnimacion; 
 
VAR
 
  Obstaculos : Integer;   (* El n£mero de obstaculos *)
 
  Tablero    : ATablero;  (* El tablero *)
 
  PosPelota  : StructPos; (* La posici¢n de la pelota *)
 
  Ganar      : Boolean;   (* Si hemos ganado o no *)
 
  Continuar  : Integer;   (* Para saber si el jugador quiere jugar m s *)
 
 
 
 
 
  (* Funci¢n que lee por teclado el n£mero
 
  de obstaculos que tendr  el tablero *)
 
  FUNCTION LeerObstaculos : Integer;
 
  VAR
 
    Obstaculos : Integer; (* El n£mero de obstaculos *)
 
 
 
  BEGIN (* LeerObstaculos *)
 
    REPEAT
 
      Clrscr; WriteLn;
 
      Write  ('šCu ntos obstaculos quiere poner en el tablero? ');
 
      ReadLn (Obstaculos);
 
      IF (Obstaculos  < 0) OR (Obstaculos > 39) THEN 
 
      BEGIN
 
        TextColor(ROJO);
 
        WriteLn; WriteLn ('N£mero de obstaculos incorrecto, introduzca un valor entre 0 y 39');
 
        TextColor(BLANCO);
 
        delay(2000);
 
      END;
 
    UNTIL (Obstaculos  >= 0) AND (Obstaculos <= 39);
 
    LeerObstaculos := Obstaculos;
 
  END; (* LeerObstaculos *)
 
 
 
 
 
  (* Procedure que inicializa el tablero coloc ndole
 
    los bordes, la pelota y los obstaculos.
 
    ENTRADA:
 
     - VAR Tablero : El tablero a inicializar
 
     - Obstaculos  : EL n£mero de obstaculos
 
     - StructPos   : La posici¢n de la pelota *)
 
  PROCEDURE IniTablero(var Tablero : ATablero; Obstaculos : Integer;
 
                       var PosPelota : StructPos);
 
 
 
        (* Procedure que pone los bordes al tablero *)
 
        PROCEDURE PonerBordes (var Tablero : ATablero); 
 
        VAR
 
          F, C : Integer; (* Contadores para recorres filas y columnas *)
 
        BEGIN (* PonerBordes *)
 
          FOR F :=0 TO 9 DO
 
          BEGIN
 
              FOR C :=0 TO 6 DO
 
              BEGIN
 
               IF F=0 THEN (* Primera fila *)
 
                 CASE C OF
 
                   0 :  Tablero[F,C] := ESQ_SUPI;
 
                   6 :  Tablero[F,C] := ESQ_SUPD;
 
                   ELSE Tablero[F,C] := BOR_HORI;
 
                 END
 
               ELSE IF F=9 THEN (* Ultima fila *)
 
                 CASE C OF
 
                   0 :  Tablero[F,C] := ESQ_INFI;
 
                   3 :  Tablero[F,C] := ' ';
 
                   6 :  Tablero[F,C] := ESQ_INFD;
 
                   ELSE Tablero[F,C] := BOR_HORI;
 
                 END
 
               ELSE  (* El resto de las filas *)
 
                 CASE C OF
 
                   0,6 : Tablero[F,C] := BOR_VERT;
 
                   ELSE Tablero[F,C] := ' ';
 
                 END;
 
              END; (* Segundo FOR *)
 
          END; (* Primer FOR *)
 
        END; (* PonerBordes *)
 
 
 
        (* Procedure que pone la pelota en alguna de las
 
        casillas superiores del tablero *)
 
        PROCEDURE PonerPelota (var Tablero : ATablero; var PosPelota : StructPos);
 
        VAR
 
          Posicion : Integer; (* La posici¢n aleatoria de la pelota *)
 
        BEGIN
 
          Posicion := Random(5)+1;
 
          Tablero[1,Posicion] := PELOTA;
 
          PosPelota.F := 1;
 
          PosPelota.C := Posicion;
 
          PosPelota.Direccion := Random(8);
 
        END;
 
 
 
        (* Procedure que pone los obstaculos en el tablero
 
        aleatoriamente *)
 
        PROCEDURE PonerObstaculos(var Tablero : ATablero; Obstaculos : Integer);
 
        VAR
 
          F, C, N : Integer; (* Filas y columnas *)
 
        BEGIN
 
          FOR N:= 1 TO Obstaculos DO
 
	  BEGIN
 
	    F := Random(8)+1;
 
	    C := Random(5)+1;
 
	    IF (Tablero[F,C] = ' ') THEN
 
	      Tablero[F,C] := chr(219)
 
	    ELSE
 
	      N:= N-1;
 
          END;
 
	END;  
 
 
 
  BEGIN (* IniTablero *)
 
    PonerBordes(Tablero);
 
    PonerPelota(Tablero, PosPelota);
 
    PonerObstaculos(Tablero, Obstaculos);
 
  END;  (* IniTablero *)
 
 
 
 
 
  (* Procedure que muestra por pantalla el tablero
 
  que anteriormente debe haber sido inicializado.
 
  ENTRADA:
 
   - Tablero        : El tablero a pintar *)
 
  PROCEDURE PintarTablero(Tablero : ATablero);
 
  VAR
 
    F, C : Integer; (* Contadores para recorrer filas y columnas *)
 
  BEGIN (* PintarTablero *)
 
    Clrscr; WriteLn; WriteLn;
 
    WriteLn(' Si desea salir pulse enter. Si no el juego finalizar  cuando la pelota');
 
    WriteLn(' salga por la casilla vacia de la parte inferior del tablero.');
 
    WriteLn; WriteLn; WriteLn; Write('                              ');
 
    FOR F := 0 TO 9 DO
 
    BEGIN
 
      FOR C := 0 TO 6 DO
 
        Write (Tablero[F, C]);
 
        WriteLn;
 
        Write('                              ');
 
    END;
 
  END;  (* PintarTablero *)
 
 
 
  (* Procedure que  mueve la pelota por el tablero
 
  seg£n corresponda.
 
  Devuelve TRUE si la partida ha terminado y FALSE en caso contrario. *)
 
  FUNCTION PosicionarPelota(var Tablero : ATablero; var PosPelota : StructPos) : Boolean;
 
 
 
         (* Procedure que comprueba el posible choque de la pelota 
 
	 y si no choca la posiciona donde corresponde.
 
         ENTRADA:
 
          - SumFil, SumCol: El n£mero que hay que sumar en el array para
 
                            mover la pelota en la direcci¢n correcta.
 
          - Tablero: El array que representa el tablero.
 
          - PosPelota: La estructura con los datos de la pelota. *)
 
         Procedure MoverPelota(SumFil, SumCol : Integer; var Tablero : ATablero; var PosPelota : StructPos);
 
         BEGIN
 
           (* Si la pelota se puede mover *)
 
           IF Tablero[PosPelota.F + SumFil, PosPelota.C + SumCol] = ' ' THEN
 
           BEGIN
 
             Tablero[PosPelota.F, PosPelota.C ] := ' ';
 
             PosPelota.F := PosPelota.F + SumFil;
 
             PosPelota.C := PosPelota.C + SumCol;
 
             Tablero[PosPelota.F, PosPelota.C] := PELOTA;
 
           END
 
           (* Si la pelota se choca *)
 
           ELSE
 
             PosPelota.Direccion := Random(8);
 
         END;
 
 
 
 
 
    BEGIN (* PosicionarPelota *)
 
 
 
    (* Comprobamos si hemos ganado *)
 
    IF (PosPelota.F = 9) AND (PosPelota.C = 3) THEN
 
    BEGIN
 
       PosicionarPelota := TRUE;
 
       WriteLn; WriteLn; WriteLn;
 
       TextColor(AMARILLO);
 
       WriteLn('                ­Felicidades! Ha ganado usted el juego.');
 
       TextColor(BLANCO);
 
    END
 
    ELSE
 
       PosicionarPelota := FALSE;
 
 
 
    CASE PosPelota.Direccion OF
 
      0: (* Arriba *)
 
         MoverPelota(-1, 0, Tablero, PosPelota);
 
      1: (* Arriba-Derecha *)
 
         MoverPelota(-1, 1, Tablero, PosPelota);
 
      2: (* Arriba-Izquierda *)
 
         MoverPelota(-1, -1, Tablero, PosPelota);
 
      3: (* Izquierda *)
 
         MoverPelota(0, -1, Tablero, PosPelota);
 
      4: (* Derecha *)
 
         MoverPelota(0, 1, Tablero, PosPelota);
 
      5: (* Abajo *)
 
         MoverPelota(1, 0, Tablero, PosPelota);
 
      6: (* Abajo-Derecha *)
 
         MoverPelota(1, 1, Tablero, PosPelota);
 
      7: (* Abajo-Izquierda *)
 
         MoverPelota(1, -1, Tablero, PosPelota);
 
    END; (* END CASE *)
 
 
 
  END;  (* PosicionarPelota *)
 
 
 
BEGIN (* CrearAnimacion*)
 
  REPEAT
 
    Obstaculos := LeerObstaculos;
 
    IniTablero (Tablero, Obstaculos, PosPelota);
 
    REPEAT
 
      PintarTablero(Tablero);
 
      Ganar := PosicionarPelota(Tablero, PosPelota);
 
      Delay(20);
 
    UNTIL KeyPressed OR Ganar;
 
  REPEAT
 
    WriteLn; WriteLn; WriteLn;
 
    Write(' šDesea jugar otra partida? (1 Si/2 No)');
 
    ReadLn (Continuar);
 
    IF (Continuar <> 1) AND (Continuar <> 2) THEN
 
    BEGIN
 
       TextColor(ROJO);
 
       WriteLn; WriteLn('Opcion incorrecta. 1 Si/2 No');
 
       TextColor(BLANCO);
 
    END;
 
  UNTIL  (Continuar = 1) OR (Continuar = 2);
 
  UNTIL  Continuar = 2;
 
END; (* CrearAnimacion*)
 
 
 
 
 
(************************************)
 
(*       PROGRAMA PRINCIPAL         *)
 
(************************************)
 
 
 
BEGIN (* Programa principal *)
 
  Randomize;
 
  TextColor(BLANCO);
 
  CrearAnimacion;
 
END.

Salu2 E0N

Ciertamente siempre acaban pillando el patrón xD Un buen enlace para coger ideas básicas sobre polimorfismo en virus:

http://www.wikilearning.com/curso_gratis/curso_de_programacion_de_virus-tecnicas_avanzadas/4312-17

No es muy avanzado, pero te servirá Sobre lo de consultar una web para ver si es detectado o no a mi me parece más práctico que si es detectado se cambie por un exe nuevo e indetectable en vez de cambiar la encriptación...

Salu2