Hola muchachos, soy nuevo en el foro, en realidad siempre leo los temas que publican pero no soy de comentar.
En fin, como estoy un poco familiarizado con Delphi, se me ocurrió hacer, o por lo menos comenzar a estudiar sobre el tema de los crypter.
Me baje el código de fuente del OPCypter y a la hora de analizarlo hay lineas que la verdad no entiendo o no les encuentro el sentido...
Creo que es una gran idea analizarlo en conjunto ya que no solo me ayudaría a mi, si no también a otros principiantes.

Por empezar voy a dejar el código entero y más abajo las dudas en cuestión:

Código: Seleccionar todo

unit Builder;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, XPMan, StdCtrls, uEOF;

type
  TForm1 = class(TForm)
    GroupBox1: TGroupBox;
    edtFile: TEdit;
    btnFile: TButton;
    btnBuild: TButton;
    btnAbout: TButton;
    Open: TOpenDialog;
    XPManifest1: TXPManifest;
    Save: TSaveDialog;
    procedure btnFileClick(Sender: TObject);
    procedure btnAboutClick(Sender: TObject);
    procedure btnBuildClick(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function MakeXor(Buffer :String; Key :Integer) :String;
var
  i,c,x  :Integer;
begin
  for i := 1 to Length(Buffer) do
  begin
    c := Integer(Buffer[i]);
    x := c xor Key;
    Result := Result + Char(x);
  end;
end;

procedure TForm1.btnFileClick(Sender: TObject);
begin
  if Open.Execute then
    edtFile.Text := Open.FileName;
end;

procedure TForm1.btnAboutClick(Sender: TObject);
begin
  MessageBoxA(0,'Open Source Cryter'+#10+#13+
                ''+#10+#13+
                'Author: Xash'+#10+#13+
                'Description: Simple a crypter for beginner'+#10+#13+
                'Thanks: steve10120'+#10+#13+
                ''+#10+#13+
                '[FR] www.hacksecu.com'+#10+#13+
                '[EN] www.hackhound.org', 'About', 64);
end;

procedure TForm1.btnBuildClick(Sender: TObject);
var
  Buffer :String;
begin
  if not Save.Execute then
    Exit;

  Buffer := ReadFile(edtFile.Text);
  Buffer := MakeXor(Buffer, 1337);




  MessageBoxA(0, 'Crypted!', 'Information', 64);
end;

end.
Preguntas

Código: Seleccionar todo

function MakeXor(Buffer :String; Key :Integer) :String;
var
  i,c,x  :Integer;
begin
  for i := 1 to Length(Buffer) do
  begin
    c := Integer(Buffer[i]);
    x := c xor Key;
    Result := Result + Char(x);
  end;
end;
Entiendo bastante esta parte del código, pero no se para que sirve el valor buffer, de donde sale, para que se utiliza... etc...
Otra pregunta es si el Key es lo que determina la encriptación del archivo.

Código: Seleccionar todo

CopyFile(PChar(ExtractFilePath(ParamStr(0))+'Stub/Stub.exe'), PChar(Save.FileName), False);
  WriteEof(Save.FileName, Buffer, '[1]', '[2]');
¿La linea CopyFile, es la que une el stub, con el servidor ?
EOF, buscando en internet encontré que es el final del archivo, vi que en varios crypters lo nombran, ¿Cuál es la finalidad? ¿Qué significan esos [1] y [2]?

Y finalmente, se que es una duda bruta pero tampoco entiendo la finalidad del Stub y su trabajo en conjunto con el crypter, si alguien me lo pudiera explicar se lo agradecería.

Desde ya muchas gracias. Saludos.
Buffer es el archivo encryptado/a encriptar/desencriptar (se almacena en la variable Buffer y ya se trabaja desde ahí).

CopyFile se usa en este caso para:
1º) copiar el stub y despues..
2º) pegar el EOF (en este crypter el EOF será 'Buffer', es decir, el archivo encriptado), para ello se usa el Unit uEOF que sirve para leer esa parte separando entre delimitadores de inicio y fin de lo que es 'Buffer' quedando por tanto:

Stub + Buffer = Stub + [delimitador inicio ([1])] + Buffer + [delimitador fin ([2])]

No confundir el uso de EOF de este caso con el EOF de Bifrost, ya que no es lo mismo, habría que hacerlo de otra manera (sin delimitadores).

Espero que lo hayas entendido..

Es para mí un gran crypter para los que empezamos con Delphi ya que se entiende el code que da gusto y además funciona perfecto!

Saludos!
UDTools.net
GitHub: https://github.com/MetalUDT
Muchas gracias por tu respuesta, me aclaró bastante las dudas.

Básicamente, ¿El stub es como el archivo base sobre el que se inserta el buffer encriptado verdad?

No me quedo muy claro lo de los delimitadores...
El 1 es el inicio y el 2 es el final osea que la estructura del archivo seria:
1)Stub
2)Buffer
3)Comienzo EOF
4)Finaliación EOF

¿No debería el Buffer estar entre los delimitadores EOF?
¿Hay que seguir algún patrón con los ordenes ó se puede cambiar a gusto?

EDIT: También quería saber lo de "Key" si es lo que determina la encriptación en este crypter
julian2112 escribió:Muchas gracias por tu respuesta, me aclaró bastante las dudas.

Básicamente, ¿El stub es como el archivo base sobre el que se inserta el buffer encriptado verdad?

No me quedo muy claro lo de los delimitadores...
El 1 es el inicio y el 2 es el final osea que la estructura del archivo seria:
1)Stub
2)Buffer
3)Comienzo EOF
4)Finaliación EOF


¿No debería el Buffer estar entre los delimitadores EOF?
¿Hay que seguir algún patrón con los ordenes ó se puede cambiar a gusto?

EDIT: También quería saber lo de "Key" si es lo que determina la encriptación en este crypter
La parte que remarco en rojo lo tienes mal, por eso dije que va así xD:
Stub + Buffer = Stub + [delimitador inicio ([1])] + Buffer + [delimitador fin ([2])]
1)Stub
2)Primer delimitador EOF (Comienzo EOF)
3)Buffer
4)Segundo delimitador EOF (Finalización EOF)

Debe seguir un órden concreto si quieres que funcione, no puedes poner el buffer al inicio por ejemplo..

El stub es el programa encargado de desencryptar el archivo que hay incrustado en sí mismo (buffer) y de injectarlo en memoria (o para que haga las acciones para las que fue programado).
Y otra pregunta, finalmente ¿Lo que hace indetectable al archivo es el Key o la estructura del stub?
El archivo en sí queda indetectado, lo que es detectado es el stub.

Espero que ya se hayan resuelto todas las dudas;
UDTools.net
GitHub: https://github.com/MetalUDT
Hola que tal, estoy haciendo una guia de la función RunPe de steve 10120 que viene en el OP crypter, el cual se estan planteando en este post dudas, y para no abrir otro post repetido pregunto aquí.

mi duda es la siguiente una vez que hemos comprobado la cabecera (MZ) y el el PE tengo este codigo que no entiendo muy bien.

Código: Seleccionar todo

  CONT.ContextFlags := CONTEXT_FULL; // CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
          if GetThreadContext(PI.hThread, CONT) then 
          begin
            ReadProcessMemory(PI.hProcess, Ptr(CONT.Ebx + 8), @Addr, 4, Ret);
      
no se que estamos haciendo aqui exactamente. Alguien me puede explica.
angelp4491 escribió:Hola que tal, estoy haciendo una guia de la función RunPe de steve 10120 que viene en el OP crypter, el cual se estan planteando en este post dudas, y para no abrir otro post repetido pregunto aquí.

mi duda es la siguiente una vez que hemos comprobado la cabecera (MZ) y el el PE tengo este codigo que no entiendo muy bien.

Código: Seleccionar todo

  CONT.ContextFlags := CONTEXT_FULL; // CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
          if GetThreadContext(PI.hThread, CONT) then 
          begin
            ReadProcessMemory(PI.hProcess, Ptr(CONT.Ebx + 8), @Addr, 4, Ret);
      
Sirve para extraer el contexto de un hilo del proceso el GetThreadContext, y re quiere como parámetro la estructura CONTEXT con los parámetros de la estructura previamente seteados o modificados dependiendo a que quieres leer, como ahí estas modificando las Flags(banderitas/bits) de la estructura CONTEXT, y una vez que modificas o seteas la estructura a tu gusto la pasas a GetThreadContext para que te devuelva en la misma estructura el contexto del hilo del proceso, para después con ReadProcessMemory leer unos bytes en memoria, ahí por ejemplo estas leyendo el registro EBX + 8 Bytes, y necesitabas la estructura CONTEXT para obtener ese registro EBX :P

Si no entendiste te lo dejo en pocas palabras

En los runpe el contexto se utiliza para obtener/modificar los registros ensamblador ebx/eax/edx normalmente al final del runpe se usa para indicar donde esta el entrypoint me parece x)
//mHmm..
linkgl escribió:
angelp4491 escribió:Hola que tal, estoy haciendo una guia de la función RunPe de steve 10120 que viene en el OP crypter, el cual se estan planteando en este post dudas, y para no abrir otro post repetido pregunto aquí.

mi duda es la siguiente una vez que hemos comprobado la cabecera (MZ) y el el PE tengo este codigo que no entiendo muy bien.

Código: Seleccionar todo

  CONT.ContextFlags := CONTEXT_FULL; // CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
          if GetThreadContext(PI.hThread, CONT) then 
          begin
            ReadProcessMemory(PI.hProcess, Ptr(CONT.Ebx + 8), @Addr, 4, Ret);
      
Sirve para extraer el contexto de un hilo del proceso el GetThreadContext, y re quiere como parámetro la estructura CONTEXT con los parámetros de la estructura previamente seteados o modificados dependiendo a que quieres leer, como ahí estas modificando las Flags(banderitas/bits) de la estructura CONTEXT, y una vez que modificas o seteas la estructura a tu gusto la pasas a GetThreadContext para que te devuelva en la misma estructura el contexto del hilo del proceso, para después con ReadProcessMemory leer unos bytes en memoria, ahí por ejemplo estas leyendo el registro EBX + 8 Bytes, y necesitabas la estructura CONTEXT para obtener ese registro EBX :P

Si no entendiste te lo dejo en pocas palabras

En los runpe el contexto se utiliza para obtener/modificar los registros ensamblador ebx/eax/edx normalmente al final del runpe se usa para indicar donde esta el entrypoint me parece x)
Ok gracias, voy a buscar un poco más de información.
angelp4491 escribió:
linkgl escribió:
angelp4491 escribió:Hola que tal, estoy haciendo una guia de la función RunPe de steve 10120 que viene en el OP crypter, el cual se estan planteando en este post dudas, y para no abrir otro post repetido pregunto aquí.

mi duda es la siguiente una vez que hemos comprobado la cabecera (MZ) y el el PE tengo este codigo que no entiendo muy bien.

Código: Seleccionar todo

  CONT.ContextFlags := CONTEXT_FULL; // CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
          if GetThreadContext(PI.hThread, CONT) then 
          begin
            ReadProcessMemory(PI.hProcess, Ptr(CONT.Ebx + 8), @Addr, 4, Ret);
      
Sirve para extraer el contexto de un hilo del proceso el GetThreadContext, y re quiere como parámetro la estructura CONTEXT con los parámetros de la estructura previamente seteados o modificados dependiendo a que quieres leer, como ahí estas modificando las Flags(banderitas/bits) de la estructura CONTEXT, y una vez que modificas o seteas la estructura a tu gusto la pasas a GetThreadContext para que te devuelva en la misma estructura el contexto del hilo del proceso, para después con ReadProcessMemory leer unos bytes en memoria, ahí por ejemplo estas leyendo el registro EBX + 8 Bytes, y necesitabas la estructura CONTEXT para obtener ese registro EBX :P

Si no entendiste te lo dejo en pocas palabras

En los runpe el contexto se utiliza para obtener/modificar los registros ensamblador ebx/eax/edx normalmente al final del runpe se usa para indicar donde esta el entrypoint me parece x)
Ok gracias, voy a buscar un poco más de información.

Rectifico, buscando un poco más de información, lo que estamos haciendo aquí es buscar el Imagebase, que segun el IMAGE_OPTIONAL_HEADER se encuentra 8 bytes por debajo del entrypoint y la cual ocupa 4 bytes.

Código: Seleccionar todo

Estructura IMAGE_OPTIONAL_HEADER:
typedef struct _IMAGE_OPTIONAL_HEADER {
    WORD Magic;
    BYTE MajorLinkerVersion;
    BYTE MinorLinkerVersion;
    DWORD SizeOfCode;
    DWORD SizeOfInitializedData;
    DWORD SizeOfUninitializedData;
    DWORD AddressOfEntryPoint;
    DWORD BaseOfCode;
    DWORD BaseOfData;
    /*************Adicionales NT****************/
    DWORD ImageBase;
    DWORD SectionAlignment;
    DWORD FileAlignment;
    WORD MajorOperatingSystemVersion;
    WORD MinorOperatingSystemVersion;
    WORD MajorImageVersion;
    WORD MinorImageVersion;
    WORD MajorSubsystemVersion;
    WORD MinorSubsystemVersion;
    DWORD Reserved1;
    DWORD SizeOfImage;
    DWORD SizeOfHeaders;
    DWORD CheckSum;
    WORD Subsystem;
    WORD DllCharacteristics;
    DWORD SizeOfStackReserve;
    DWORD SizeOfStackCommit;
    DWORD SizeOfHeapReserve;
    DWORD SizeOfHeapCommit;
    DWORD LoaderFlags;
    DWORD NumberOfRvaAndSizes;
    IMAGE_DATA_DIRECTORY DataDirectory[16];
    /*************Adicionales NT****************/
} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
Responder

Volver a “Delphi”