Creacion de un Server Builder con recursos

Creacion de un Server Builder con recursos

8:25 0 Comments A+ a-



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

0x01 : Introduccion
0x02 : Creacion del builder
0x03 : Creacion del stub
0x04 : Probando el programa
0x05 : Builder Tools

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

0x01 : Introduccion

En este manual les voy a enseñar como hacer un Server Builder en Delphi usando recursos , en el manual anteior les enseñe como hacerlo mediante EOF , algo que no era muy seguro porque los datos estaban en texto plano y se podian leer facilmente , mediante recursos es diferente y para asegurarlo vamos a usar XOR para eso.

Empecemos ...

0x02 : Creacion del builder

Primero vamos hacer el builder , para eso vamos a "File->New->VCL Forms Application" como lo hice en la imagen :



Ahora creamos dos edit y boton con el texto de "Make Server" como en la siguiente imagen :



Despues deben cambiar el titulo del formulario a "Builder" y cambiarle el nombre por defecto que tienen los edits de la siguiente forma :

Edit1 -> ip
Edit2 -> port

Una vez hecho , hacemos doble click en el boton y agregamos el siguiente codigo :

Código: Delphi
  1. procedure TForm1.Button1Click(Sender: TObject);
  2. var
  3.   archivo: string; // Declaramos la variable "archivo" como string
  4.   datos: string; // Declaramos la variable "datos" como string
  5.   clave: integer; // Declaramos la variable "clave" como integer
  6. begin
  7.   archivo := 'stubnow.exe';
  8.   // Establecemos la variable "archivo" como el nombre del ejecutable
  9.   // que vamos abrir
  10.   datos := '[ip]' + ip.Text + '[ip]' + '[port]' + port.Text + '[port]';
  11.   // Establecemos los datos que contiene la IP y el puerto separados por etiquetas
  12.   // y los guardamos en la variable "datos"
  13.   clave := 123; // Establecemos la variable "clave" como "123"
  14.   escribir_recurso(archivo, datos, clave);
  15.   // Escribimos el recurso usando la funcion
  16.   // "escribir_recurso" usando como argumentos las variables que acabamos de establecer
  17.   ShowMessage('Done'); // Mostramos un mensaje en pantalla
  18. end;

Fuera del codigo de la funcion "click" del boton agregamos el codigo de estas dos funciones :

Código: Delphi
  1. function xor_now(texto: string; clave: integer): string;
  2. // Funcion xor_now con el argumento
  3. // del texto a crifrar y la clave a usar
  5. var
  6.   numero: integer; // Declaramos la variable "numero" como entero
  7.   contenido: string; // Declaramos la variable "contenido" como string
  8. begin
  9.   contenido := ''; // Vaciamos la variable contenido
  10.   for numero := 1 to Length(texto) do // Realizamos un for del "1"
  11.   // a la longitud de la variable texto
  12.   begin
  13.     contenido := contenido + Char(integer(texto[numero]) xor clave);
  14.     // Realizamos el cifrado xor
  15.   end;
  16.   Result := contenido; // Devolvemos como resultado la variable "contenido"
  17. end;
  19. function escribir_recurso(ruta: string; datos: string; clave: integer): bool;
  20. var
  21.   escribiendo: THandle; // Declaramos la variable "escribiendo" como THandle
  22. begin
  23.   datos := xor_now('-0x646F646479206861636B6D616E-' + datos +
  24.     '-0x646F646479206861636B6D616E-', clave);
  25.   // Ciframos los datos usando la funcion xor_now
  26.   // Los parametros que usamos en la funcion xor_now son la variable "datos" como el texto
  27.   // a cifrar , los "datos" estan entre dos delimitadores para facilitar su busqueda y
  28.   // tambien usamos la variable "clave" como key en el cifrado xor
  29.   escribiendo := BeginUpdateResource(pchar(ruta), False);
  30.   // Empezamos el inicio de de la creacion
  31.   // del recurso usando la variable "ruta"
  32.   UpdateResource(escribiendo, MakeIntResource(10), 'CONFIGURATION', 0,
  33.     pchar(datos), (Length(datos) + 1) * SizeOf(datos[1]));
  34.   // Escribimos el recurso usando
  35.   // la variable "datos" como el contenido del recurso y como nombre del recurso usamos
  36.   // "CONFIGURATION"
  37.   EndUpdateResource(escribiendo, False); // Terminamos de crear el recurso
  38.   Result := True; // Devolvemos True como resultado de la funcion
  39. end;

Les deberia quedar algo asi :



Con eso ya estaria el builder entonces guardamos el proyecto como "builder_now" o como quieran para terminar el builder.

0x03 : Creacion del stub

Ahora vamos a codear el Stub para eso vamos a "File->New->VCL Forms Application" como lo hice en la imagen :



La idea es buscar el recurso en el ejecutable mismo , entonces para eso vamos a crear dos edits y un boton con el texto de "Get Values".

Despues deben poner como titulo del formulario "Stub" y cambiar los names de los edits de la siguiente forma :

Edit1 -> ip
Edit2 -> port

El formulario les deberia quedar algo asi :



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

Código: Delphi
  1. procedure TForm1.Button1Click(Sender: TObject);
  2. var
  3.   clave: integer; // Declaramos la variable "clave" como integer
  4.   datos: string; // Declaramos la variable "datos" como string
  5.   ip_found: string; // Declaramos la variable "ip_found" como string
  6.   port_found: string; // Declaramos la variable "port_found" como string
  7. begin
  8.   clave := 123; // Establecemos la variable "clave" como 123
  9.   datos := leer_recurso(clave); // Leemos el recurso usando el key que esta
  10.   // en la variable clave y guardamos los datos en la variable "datos"
  11.   ip_found := regex(datos, '[ip]', '[ip]');
  12.   // Usamos la funcion regex() para buscar
  13.   // la ip y la guardamos en la variable "ip_found"
  14.   port_found := regex(datos, '[port]', '[port]');
  15.   // Usamos la funcion regex() para
  16.   // buscar el puerto y lo guardamos en la variable "port_found"
  17.   ip.text := ip_found; // Mostramos en el edit "ip" la IP
  18.   port.text := port_found; // Mostramos en el edit "port" el puerto
  19.   ShowMessage('Loaded'); // Mostramos en pantalla un mensaje
  20. end;

Despues ponemos las siguientes funciones fuera del codigo del boton :

Código: Delphi
  1. function regex(text: string; deaca: string; hastaaca: string): string;
  2. begin
  3.   Delete(text, 1, AnsiPos(deaca, text) + Length(deaca) - 1);
  4.   SetLength(text, AnsiPos(hastaaca, text) - 1);
  5.   Result := text;
  6. end;
  8. function xor_now(texto: string; clave: integer): string;
  9. // Funcion xor_now con el argumento
  10. // del texto a crifrar y la clave a usar
  12. var
  13.   numero: integer; // Declaramos la variable "numero" como entero
  14.   contenido: string; // Declaramos la variable "contenido" como string
  15. begin
  16.   contenido := ''; // Vaciamos la variable contenido
  17.   for numero := 1 to Length(texto) do // Realizamos un for del "1"
  18.   // a la longitud de la variable texto
  19.   begin
  20.     contenido := contenido + Char(integer(texto[numero]) xor clave);
  21.     // Realizamos el cifrado xor
  22.   end;
  23.   Result := contenido; // Devolvemos como resultado la variable contenido
  24. end;
  26. function leyendo_recurso: string;
  27. var
  28.   leyendo1: HRSRC; // Establecemos la variable "leyendo1" como HRSRC
  29.   leyendo2: DWORD; // Establecemos la variable "leyendo2" como DWORD
  30.   leyendo3: THandle; // Establecemos la variable "leyendo3" como THandle
  31.   leyendo4: pointer; // Establecemos la variable "leyendo4" como Pointer
  32. begin
  33.   leyendo1 := FindResource(hInstance, 'CONFIGURATION', RT_RCDATA);
  34.   // Buscamos el recurso
  35.   // "CONFIGURATION"
  36.   leyendo2 := SizeofResource(hInstance, leyendo1);
  37.   // Calculamos la tamaño del recurso
  38.   leyendo3 := LoadResource(hInstance, leyendo1); // Cargamos el recurso
  39.   leyendo4 := LockResource(leyendo3);
  40.   // Bloqueamos el recurso para poder leerlo despues
  41.   if leyendo4 <> nil then // Si "leyendo4" no esta null ...
  42.   begin
  43.     SetLength(Result, leyendo2 - 1); // Cambiamos la longitud de Result
  44.     CopyMemory(@Result[1], leyendo4, leyendo2);
  45.     // Copiamos los datos al resultado de la funcion
  46.     FreeResource(leyendo3); // Liberamos el recurso
  47.   end;
  48. end;
  50. function leer_recurso(clave: integer): string;
  51. var
  52.   datos: string; // Declaramos la variable "datos" como string
  53. begin
  54.   datos := xor_now(leyendo_recurso, clave);
  55.   // Realizamos el cifrado xor con los datos que usamos
  56.   // como argumentos de la funcion leer_recurso()
  57.   datos := regex(datos, '-0x646F646479206861636B6D616E-',
  58.     '-0x646F646479206861636B6D616E-');
  59.   // Usamos la funcion regex() para cortar los delimitadores
  60.   // y encontrar asi los datos del recurso para despues guardar el
  61.   // resultado en la variable "datos"
  62.   Result := datos;
  63.   // Devolvemos como resultado lo que contiene la variable "datos"
  64. end;

El codigo les deberia quedar asi :



Guardan el proyecto con el nombre que quieran y con eso ya estaria listo el stub.

0x04 : Probando el programa

Para probarlo cargamos el builder y llenamos los campos de IP y Puerto como quieran , un ejemplo de como los complete yo seria  :



Despues presionan el boton "Make Server" y listo.

Ahora cargamos el stub y le damos al boton "Get Values" , deberian ver como resultado algo como esto :



Si no ven algo como en la imagen es porque hicieron algo mal en el codigo.

0x05 : Builder Tools

Como regalo les dejo esta Unit que hice en Delphi sobre como hacer un Builder , contiene funciones para EOF y Recursos , en los dos casos uso XOR para encriptar los datos , tambien viene con ejemplos de uso.

Solo deben agregar "builder_tools" en el parte de "uses" del codigo y listo , podran usar las funciones.

El codigo :

Código: Delphi
  1. // Unit : Builder Tools
  2. // Version : 0.2
  3. // (C) Doddy Hackman 2015
  4. // Credits : Resources based in http://www.hackforums.net/showthread.php?tid=1422700
  5. // Examples :
  6. // escribir_eof('stub.exe','-delimitador-','-delimitador-','test',123);
  7. // leer_eof('stub.exe','-delimitador-','-delimitador-',123);
  8. // escribir_recurso('stub.exe','test',123);
  9. // leer_recurso(123);
  11. unit builder_tools;
  13. interface
  15. uses SysUtils, Windows;
  17. function leer_eof(ruta, delimitador1, delimitador2: string;
  18.   clave: integer): string;
  19. function escribir_eof(ruta, delimitador1, delimitador2, texto: string;
  20.   clave: integer): bool;
  21. function escribir_recurso(ruta: string; datos: string; clave: integer): bool;
  22. function leyendo_recurso: string;
  23. function leer_recurso(clave: integer): string;
  24. function xor_now(texto: string; clave: integer): string;
  25. function regex(text: string; deaca: string; hastaaca: string): string;
  27. implementation
  29. function xor_now(texto: string; clave: integer): string;
  30. var
  31.   numero: integer;
  32.   contenido: string;
  33. begin
  34.   contenido := '';
  35.   for numero := 1 to Length(texto) do
  36.   begin
  37.     contenido := contenido + Char(integer(texto[numero]) xor clave);
  38.   end;
  39.   Result := contenido;
  40. end;
  42. function regex(text: string; deaca: string; hastaaca: string): string;
  43. begin
  44.   Delete(text, 1, AnsiPos(deaca, text) + Length(deaca) - 1);
  45.   SetLength(text, AnsiPos(hastaaca, text) - 1);
  46.   Result := text;
  47. end;
  49. function leer_eof(ruta, delimitador1, delimitador2: string;
  50.   clave: integer): string;
  51. var
  52.   ob: THandle;
  53.   code: Array [0 .. 9999 + 1] of Char;
  54.   nose: DWORD;
  55.   resultado: string;
  57. begin
  59.   ob := INVALID_HANDLE_VALUE;
  60.   code := '';
  62.   ob := CreateFile(pchar(ruta), GENERIC_READ, FILE_SHARE_READ, nil,
  63.     OPEN_EXISTING, 0, 0);
  64.   if (ob <> INVALID_HANDLE_VALUE) then
  65.   begin
  66.     SetFilePointer(ob, -9999, nil, FILE_END);
  67.     ReadFile(ob, code, 9999, nose, nil);
  68.     CloseHandle(ob);
  69.   end;
  71.   resultado := regex(code, delimitador1, delimitador2);
  72.   resultado := xor_now(resultado, clave);
  73.   Result := resultado;
  75. end;
  77. function escribir_eof(ruta, delimitador1, delimitador2, texto: string;
  78.   clave: integer): bool;
  79. var
  80.   linea: string;
  81.   aca: THandle;
  82.   code: Array [0 .. 9999 + 1] of Char;
  83.   nose: DWORD;
  84.   marca_uno: string;
  85.   marca_dos: string;
  87. begin
  89.   aca := INVALID_HANDLE_VALUE;
  90.   nose := 0;
  92.   begin
  93.     linea := delimitador1 + xor_now(texto, clave) + delimitador2;
  94.     StrCopy(code, pchar(linea));
  95.     aca := CreateFile(pchar(ruta), GENERIC_WRITE, FILE_SHARE_READ, nil,
  96.       OPEN_EXISTING, 0, 0);
  97.     if (aca <> INVALID_HANDLE_VALUE) then
  98.     begin
  99.       SetFilePointer(aca, 0, nil, FILE_END);
  100.       WriteFile(aca, code, 9999, nose, nil);
  101.       CloseHandle(aca);
  102.       Result := True;
  103.     end
  104.     else
  105.     begin
  106.       Result := False;
  107.     end;
  108.   end;
  109. end;
  111. function escribir_recurso(ruta: string; datos: string; clave: integer): bool;
  112. var
  113.   escribiendo: THandle;
  114. begin
  115.   datos := xor_now('-0x646F646479206861636B6D616E-' + datos +
  116.     '-0x646F646479206861636B6D616E-', clave);
  117.   escribiendo := BeginUpdateResource(pchar(ruta), False);
  118.   UpdateResource(escribiendo, MakeIntResource(10), 'CONFIGURATION', 0,
  119.     pchar(datos), (Length(datos) + 1) * SizeOf(datos[1]));
  120.   EndUpdateResource(escribiendo, False);
  121.   Result := True;
  122. end;
  124. function leyendo_recurso: string;
  125. var
  126.   leyendo1: HRSRC;
  127.   leyendo2: DWORD;
  128.   leyendo3: THandle;
  129.   leyendo4: pointer;
  130. begin
  131.   leyendo1 := FindResource(hInstance, 'CONFIGURATION', RT_RCDATA);
  132.   leyendo2 := SizeofResource(hInstance, leyendo1);
  133.   leyendo3 := LoadResource(hInstance, leyendo1);
  134.   leyendo4 := LockResource(leyendo3);
  135.   if leyendo4 <> nil then
  136.   begin
  137.     SetLength(Result, leyendo2 - 1);
  138.     CopyMemory(@Result[1], leyendo4, leyendo2);
  139.     FreeResource(leyendo3);
  140.   end;
  141. end;
  143. function leer_recurso(clave: integer): string;
  144. var
  145.   datos: string;
  146. begin
  147.   datos := xor_now(leyendo_recurso, clave);
  148.   datos := regex(datos, '-0x646F646479206861636B6D616E-',
  149.     '-0x646F646479206861636B6D616E-');
  150.   Result := datos;
  151. end;
  153. end.
  155. // The End ?

Eso seria todo.

Version PDF.


Autor: Doddy


Suscribirse a: Enviar comentarios (Atom)