;******
; CODED BY LINKGL
; SUBCLASIFICANDO CALCULADORA EN FASM
; FELIZ NAVIDAD ¡!                          -
;                ---      --  --    -  -  / /   ------   ---
;               |   |    |  ||  \  | || |/ /   |  ____| |   |
;               |   |  _ |  ||   \ | ||    \   |  |___  |   |  -
;               |   |_| ||  ||    \  ||  |\ \  |  |   | |   |_| |
;               |_______||__|| _|\___||__| \_\ |______| |_______|
;*****
format PE GUI 4.0
entry start
include 'win32ax.inc'

  linkpi PROCESS_INFORMATION <>
  linksi STARTUPINFO <>
  temp dd ?,0
  tempu dd ?,0
  tam dd ?,0
  handle dd ?,0



  start:

        ;Creamos el proceso y si no existe saltamos a nohayarchivo
        invoke CreateProcessA,0,"c:\windows\system32\calc.exe",0,0,0,0,0,0,linksi,linkpi
        cmp eax,0
        je      .nohayarchivo
        ;Cargamos kernel32.dll
        invoke LoadLibrary,"kernel32.dll"
        mov [temp],eax
        ;Obtenemos la direccion virtual de todas estas API's
        ;Y las almacenamos en distintas variables
        invoke GetProcAddress,[temp],"GetProcAddress"

        mov [gpa],eax

        invoke GetProcAddress,[temp],"LoadLibraryA"
        mov [gmh],eax
        invoke LoadLibrary,"user32.dll"
        mov [tempu],eax
        invoke GetProcAddress,[tempu],"MessageBoxA"
        mov [msgbox],eax
        mov [msggbox],eax
        invoke GetProcAddress,[tempu],"FindWindowA"
        mov [fwa],eax
        invoke GetProcAddress,[tempu],"SetWindowLongA"
        mov [swl],eax
        invoke GetProcAddress,[tempu],"CallWindowProcA"
        mov [cwp],eax

        mov [dir_wproc],WndProc
        ;mov ruta,message

        ;sacamos el tamaño de las dos funciones (inyectame y el procedimiento de ventana)
        ;haciendo una resta de la direccion de donde comienza inyectame hasta la direccion de
        ;la etiqueta final
        mov ebx,final
        sub ebx,inyectame
        mov [tam],ebx
        ;Reservamos ese tamaño en la memoria del proceso a inyectarnos
        ;Escribimos nuestras funciones
        ;Y creamos el hilo donde correran las funciones
        invoke VirtualAllocEx,[linkpi.hProcess],0,[tam],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
        mov [handle],eax
        invoke WriteProcessMemory,[linkpi.hProcess],[handle],addr inyectame,[tam],0
        invoke CreateRemoteThread,[linkpi.hProcess],0,0,[handle],0,0,0
        ; invoke Sleep,3000
      ;  invoke  MessageBox,0,'Extrayendo todo lo posible','Me he inyectado!',0
       ; invoke ResumeThread,[linkpi.hThread]
        ret
  .nohayarchivo:
        invoke MessageBox,HWND_DESKTOP,'No se pudo abrir el proceso especificado','&Error',0
        ret

 proc inyectame
 ;Tecnica del offset delta
   call offset
   offset:
   pop edx
   sub edx,offset
   mov edi,edx
   mov esi,edx
   mov esi,edx
   mov edi,edx
   push edx

   pop edx
;un msgbox para ver si todo ha ido bien con el titulo de la ventana
   add edx,ventana
      push 0
   push edx
   push edx
   push 0
   call [edi+msgbox]
   ;restauramos el offset delta
   mov edx,edi
   ;calculamos y cargamos en edx la direccion
   ;de la variable ventana
   add edx,ventana
   ;llamamos a findwindowa
   push edx
   push 0
   call [esi+fwa]
   mov ebx,eax
   ;movemos el handle a ebx
   mov esi,edi
   mov edx,edi
   ;igual calculamos la direccion de la winproc
   add edx,WndProc
   ;llamamos a setwindowlong reemplazando la winproc por la nuestra
   ;con esto ya la subclasificamos e instalamos nuestra wproc
   push edx
   push -4
   push ebx
   call [esi+swl]
   mov [esi+prev_proc],eax
   cmp eax,0
   ;si todo ha ido bien ya instalamos nuestra winproc
   ;si no saldra un msgbox
   je salto
   ;c:\windows\system32\calc.exe
   ret
      salto:
  ; mov edx,edi
  ; add edi,ventana
   mov edx,edi
   add edx,ventana
   push 0
   push edx
   push edx
   push 0
   call [edi+msgbox]
   ret
 

  ;VARIABLES
  ;NOTA: Unas son inecesarias solo las use para debuggear errores
  msgbox dd ?  ;Dirección MessageBox
  tit db "Inyectado",0
  msg db "Ya me inyecte",0
  ventana db "Calculadora",0

  gpa dd ? ;Dir getprocaddress
  gmh dd ? ;Dir loadlibrary/getmodulehandle en su defecto
  fwa dd ? ;FindWindowA
  swl dd ? ;SetWindowLongA
;  cwp dd ? ;callwindowproca
  dir_wproc dd ? ;v_address de la winproc
  hndle dd ?
  chl dd ?


  endp
  ;procedimiento de ventana
proc WndProc, Hwnd, Umsg, wParam, lParam
;tecnica offset delta
   call delta
   delta:
   pop edx
   sub edx,delta
   mov edi,edx
   mov esi,edx
   mov esi,edx
   mov edi,edx
   push edx

   pop edx

   mov esi,edx
   mov edi,edx
   ;comparamos el mnsj de entrada aver si es WM_WINDOWPOSCHANGED (0X0047) VER MSDN
   cmp [Umsg],0x0047
   ;Si es el mensaje saltamos a box
   je box
   mov esi,edx
   ;Llamamos a Callwinproc para mandar los mensajes al procedimiento original y no se cuelge el programa
   push [lParam]
   push [wParam]
   push [Umsg]
   push [Hwnd]
   push [esi+prev_proc]
  call [esi+cwp]
  ;fin
   ret
   box:
   ;llamamos al msgbox
   add esi,msgg
   push 0
   push esi
   push esi
   push 0
   call [edi+msggbox]
   ret
   cwp dd ?
   msgg db "Cambio de posicion la ventana",0
   msggbox dd ?
endp
;DIRECCION de la proc anterior a la que instalamos
  prev_proc dd ?
  final:



data import

  library kernel,'KERNEL32.DLL',\
          user,'USER32.DLL'

  import kernel,\
         GetModuleHandle,'GetModuleHandleA',\
         ExitProcess,'ExitProcess',\
         CreateProcessA,'CreateProcessA',\
         GetProcAddress,'GetProcAddress',\
  VirtualAllocEx,'VirtualAllocEx',\
  WriteProcessMemory,'WriteProcessMemory',\
  CreateRemoteThread,'CreateRemoteThread',\
  LoadLibrary,'LoadLibraryA',\
  ResumeThread,'ResumeThread',\
  Sleep,'Sleep'

  import user,\
         DialogBoxParam,'DialogBoxParamA',\
         CheckRadioButton,'CheckRadioButton',\
         GetDlgItemText,'GetDlgItemTextA',\
         IsDlgButtonChecked,'IsDlgButtonChecked',\
         MessageBox,'MessageBoxA',\
         EndDialog,'EndDialog'
         end data

void imprimir(char *s)
{
  printf("texto->%s",s);
}
int main()
{
  imprimir("cadena");
  return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/***********************************
* Coder: Linkgl                    *
* Fecha:17/12/10                   *
***********************************/
char *substr(char * szCadena,int dwInicio,int dwLongitud)
{
  int i;
  char *szNueva=(char *)malloc(strlen(szCadena));
  memset(szNueva,0,strlen(szCadena));
  for(i=dwInicio;i<dwInicio+dwLongitud;i++)
    szNueva[strlen(szNueva)]=szCadena[i];
  return szNueva;
}
//->implementacion
int main ()
{
  printf("La cadena es : %s",substr("funciona con underc0de",13,9));
  getchar();
  return 0;
} 

#include <stdio.h>
#include <string.h>

int main()
{
    while(1)
    {
      char recv[5];
      printf("Di algo:\n");
      scanf("%s",recv);
      if(strcmp(recv,"hola")==0)
        printf("hola\n");
      if(strcmp(recv,"adios")==0)
      {
        printf("bae\n");
        return 0;
      }
      printf("di hola o adios\n");
      getchar();
    }
    return 0;
}

/***********************************
* Coder: Linkgl                    *
* Thanks: The swash                *
* Exaple for hooks WH_KEYBOARD_LL  *
***********************************/
#include <windows.h>
#include <stdio.h>
//declaramos el hook publico
HHOOK hHook;

LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{
   //llamamos a la estructura y la hacemos puntero para lParam
   KBDLLHOOKSTRUCT kbHookStruct = *(KBDLLHOOKSTRUCT*)lParam; 
   //PKDLLHOOKSTRUCT *kbHookStruct = (PKBDLLHOOKSTRUCT *)lParam;
   if(nCode < 0) //si es menor a 0 pasamos al siguiente hook
     return CallNextHookEx(0, nCode, wParam, lParam);
   if(wParam == WM_KEYDOWN) //Si se detecto pulsacion de tecla 
       printf("%s", (char *)&kbHookStruct.vkCode); //imprimimos convirtiendo a char *

   return CallNextHookEx(0, nCode, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
   MSG msg;
   //definimos/activamos el hook
   hHook=SetWindowsHookEx(WH_KEYBOARD_LL,(HOOKPROC)LowLevelKeyboardProc,GetModuleHandle(NULL),0);
   //Bucle de mensajes
   while(TRUE==GetMessage(&msg, NULL, 0, 0))
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   //eliminamos el hook
   UnhookWindowsHookEx(hHook);
}

#include <stdio.h>
#include <stdlib.h>



struct curso_asistido{
   char ncurso;
   char prof_curso;
   int codcurso;
};
struct asistente{
   int ced;
   int carne;
   char insti;
   char nombre;
   struct curso_asistido link; //Aca anidamos la primera estructura para llamarla como link
};

int main()
{
struct asistente lenk;
lenk.link.codcurso=41; 
printf("%d",lenk.link.codcurso);
getchar();
return 0;
}

<?php
set_time_limit(0);
error_reporting(0);
/*
@Coder: Linkgl
  @Fecha: 14/08/2011
*/
function simpleono($cadena)
{
  $p1=strpos($cadena,"\"");
  $p2=strpos($cadena,"'");
  if($p1!==false && $p2!==false)
  {
    if($p1<$p2)
      return $p1;
    else
      return $p2;
  }
  else
    return 0;
}
 
function searchanddestroy($cadena,$buscar,$separador)
{
  $arr=explode($cadena,$separador);
  for($i=0;$i<count($arr);$i++)
  {
    if($arr[$i]==$buscar)
      return true;
  }
  return false;
}
function generador($direccion)
{  
$p_inicio=$direccion;
$enlaces=file_get_contents("enlaces.txt");
$c_inicio=file_get_contents($p_inicio);
$c1=strpos($c_inicio,"<a href=");
//BUSCAMOS UN ENLACE
while($c1!==false)
{
  $curret_pos=$c1;
  //INTENTAMOS EXTRAER EL ENLACE
  $url=substr($c_inicio,$c1+9);
  $c2=simpleono($url);
  $enlaces=file_get_contents("enlaces.txt");
  if($c2!==false)
  {
    //echo $url."before";
    $url=substr($url,0,$c2);
    if(strpos($url,"http://")===0 || strpos($url,"www.")===0 || strpos($url,"https://")===0)
    {
      if($url!=$p_inicio)
      {
        if(strpos($enlaces,$url)===false)
        {
          $fp=fopen("enlaces.txt","a");
          fwrite($fp,$url."\n");
          fclose($fp);
          flush();sleep(1);flush();
          echo $url."<br>"; 
          generador($url);
        }
      }
    }
    else
    {
      $newurl=$p_inicio.$url; //lolz.com/#
      if($url!="")
      {   
        if(searchanddestroy($enlaces,$newurl,"\n")===false && $url!="#")
        {
          $fp=fopen("enlaces.txt","a");
          fwrite($fp,$newurl."\n");
          fclose($fp); 
          flush();sleep(1);flush();
          echo $newurl."<br>";
          generador($newurl);
        } 
      }
    }
  }
  else
  {
    echo "Cierre de etiqueta no encontrado<br>";
  }
  $c1=strpos($c_inicio,"<a href=",$c1+1);
}
}
if(!isset($_POST['sitioweb']) || empty($_POST['sitioweb']))
{
?>
<form action="#" method="post">
<input type="text" name="sitioweb">
<input type="submit" value="indexar!">
</form>
<?php
}
else
{
echo "Iniciando<br>";
generador($_POST['sitioweb']);
echo "No hay más enlaces<br>";
}
?>

/*
  @Coder: Linkgl
    @Funcion: Instr o StrPos */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//prototipo
int instr(char *cadena,char *necesitada);

//->uso
int main()
{
  int x=instr("linkholalink","hola");
  printf("%d",x);
  getchar();
  return 0;
}

//funcion
int instr(char *cadena,char *necesitada)
{
  int iCadena=strlen(cadena);
  int iNecesitada=strlen(necesitada);
  int i;
  char *temp=(char *)malloc(iNecesitada);
  memset(temp,0,iNecesitada);
  for(i=0;i<iCadena*iNecesitada;i++)
  {
    memcpy(temp,cadena+i,iNecesitada);
    if(strcmp((char *)necesitada,(char *)temp)==0)
    {
      free(temp);
      return i+1;     
    }
  }
  free(temp);
  return -1;
}

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
DWORD FindXBytes(DWORD inicio,LPVOID bytes,LPSTR proceso,DWORD tam)
{
  STARTUPINFO si
  PROCESS_INFORMATION pi;
  ZeroMemory( &si, sizeof(si) );
  ZeroMemory( &pi, sizeof(pi) );
  si.cb = sizeof(si);
  DWORD leidos;
  char *value;
  value=(char *)malloc(tam);
  memset(value,0,tam);
  if(CreateProcess(proceso,"",NULL,NULL,FALSE,NULL,NULL,NULL,&si,&pi))
  {
    ResumeThread(pi.hThread);
    while(ReadProcessMemory(pi.hProcess, (LPVOID)inicio, &value, tam, &leidos))
    {
      if(memcmp(bytes,&value,tam)==0)
      {
        TerminateProcess(pi.hProcess,0);
        return inicio;
      }
      inicio++;
    }
    TerminateProcess(pi.hProcess,0);
    return 0;
  }
  else
  {
    return 0;
  }
}
int main()
{
  //->Ejemplo de uso  
  char buscar[7]={0xFF,0x35,0x50,0x20,0x40,0x00};
  int posicion=FindXBytes(0x401000,buscar,"c:\\crackme2.exe",6);
  if(posicion!=0)
    printf("%s esta en la direccion en memoria-> %X",buscar,posicion);
  else printf("no se encontro %s en la memoria virtual del programa");
  getchar();
  return 0;
}