$inlos95/98 XOR  (leichte Freigabeverschlsselung)           1-10-99 /10:33:41




                          ______/\____  _____   ___          2600BYTE
       Ŀ   \  ___\___  \/  \  \_/  /   
         Ŀ    / / __  _/  /     \    /     
           Ŀ    / /_/ /  ___/  /__\  \  \      
                      \____/\____/__/    \___\__\    
                  
                    
                      




 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 Sinlosen Freigabenamen
 ein zB. (" FICKDICH ") das erleichtert die suche im
 Regstrierungs Editor, weiter unten steht: "Zugriffstyp"

           ( ) Schreibgeschtzt
           ( ) Lese -/Schreibzugriff
           (o) Zugriff abhngig vom Kennwort ......  > dieses bitte anklicken

 Jetzt noch ein Passwort eingeben ich wrde 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 besttigung und fertig. Es kann
 sein das bei euch jetzt zwei Passwrter verlangt
 werden: "Eines fr Schreib - geschtzt und eines fr Lese-/Schreibzugriff"
 Ihr knnt 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 groen umwandelt...jedensfalls war mir mal so

 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 drckt jetzt mal die [Strg] + [F] jetzt sollte
 ein Fenster erscheinen in diesem steht: "Suchen nach:"  [ FICKDICH ] ihr
 errinnert euch ?

           (o) Schlssel ......    > 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
 "Path"="E:\\"                           < Der Path wo die freigabe ist
 "Parm2enc"=hex:                         < Passwort fr (nur Lesezugriff)
 "Parm1enc"=hex:74,db,0c,e7,12,e8,95,2b  < Passwort fr (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 groes A genommen habt schaut ihr in
 einer tabelle nach welcher hexwert fr ein A steht...
   A=41
   B=42     !! ACHTUNG HEXWERT NICHT DECIMAL !!
   C=43....usw

 dann alle hexdeccodes " 74 DB 0C E7 12 E8 95 2B "
 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 fr ein PW eingegeben hat und ob 95/98

 so nehmen wir mal an euer PW ist nicht 8x mal ein A sondern "TEST1234"
 so bleibt trotzdem die selbe Maske
                                    T  E  S  T  1  2  3  4
                                    35 9A 4D A6 53 A9 D4 6A


 ahh klingelst jetzt.....?!?! ich brauche jetzt nur den anderen Weg
 rechnen |>-umkehr-<| das wrde heien 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 verschlsselung die es giebt
 naja fast..... die einfachste wre wohl jedem buchstaben einen anderen
 zu zuordnen ;-) wenn ihr wissen wollte wie man das umsetzt in ein prog.
 dann unter cray@2600byte.de


******************************************************************************


Was ist XOR ???
-------------------
 XOR ist eine Methode die Bits zu verstauschen


Was ist 0 und 1 ???   /+DEC2HEX function / umrechnung in pascal
-------------------

  Der Computer kennt im wessentlichen nur zwei Zustnde:
    + 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 vol lstndige 4-Bit Kodetabelle sieht so aus:

   dez.  binr
    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 krzere Variante benutzen, die
  einem diese Masse von 101010111001 ersparte.
  Da jedoch die Umwandlung von Binr in Dezimal nicht ganz schnell im Kopf
  zu rechnen ist, und andersrum es auch nicht gerade den Spass macht, hat
  man ein neues Zahlenformat eingefhrt: Hexadezimal

  Aber nun erstmal die Umrechnung von Dezimal in Binr:
  Man nehme eine Dezimale Zahl z.Bsp.: 97d
    97d = ????????b
  Man fngt fr gewhnlich bei der ganz linken (binre Zahl) Stelle an, die
  im dezimalen System einen Wert hat, der grer als 97d ist. In diesem Fall
  ist das 128d (10000000b). Da die Zahl 97d grer 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 nchste Stelle vor, das ist 64d (01000000b)
  Da 97d grer als 64d ist, bedeutet das, das die nchste Stelle eine 1
  ist, also
    97d == 01??????.
    Jetzt ziehen wir von 97d die 64d ab: 97d - 64d == 33d
  Wir kommen zu nchsten Stelle (00100000b) == 32d. 33d ist grer als 32d
  also wieder eine 1 fr die stelle (00100000d)
    97d == 011????? ... Und dann noch 33d - 32d == 1d ( also eins )
  Die nchste Stelle: (00010000b) == 16d
    1d ist nicht grer/gleich als 16d also ist diese Stelle 0
    97d == 0110????b
  Nchste Stelle: (00001000b) = 8d
    1d ist nicht grer/gleich als 8d also ist diese Stelle auch 0
    97d == 01100???b
  Nchste Stelle: (00000100b) = 4d
    1d ist nicht grer/gleich als 4d also ist diese Stelle auch 0
    97d == 011000??b
  Nchste Stelle: (00000010b) = 2d
    1d ist nicht grer/gleich als 2d also ist diese Stelle auch 0
    97d == 0110000?b
  Nchste Stelle: (00001000b) = 8d
    1d ist jetzt grer/gleich wie 1d also ist diese Stelle eine 1
    97d == 01100001b

  Tada! 97d ist also binr 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 Binr
  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:
    Binr    : 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
    Binr    :   0001 0100 0011 1100 1010  also 00010100001111001010b

  Also, wie das hier alles es so schn zeigt, lsst es sich wunderbar von
  Binr nach Hexa und von Hexa nach Binr 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 Binr und
  alles andere interessiert ihn nicht.
  Er rechnet nicht nur, sondern er speicher 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 groes in der Funktion gemacht habe... ich hab
  einfach das dezimal Format bergangen, weil ja der Prozessor so nett war,
  und fr mich die Binrdigits schn suberlich in 8ter Packs aufn Stck
  gelegt hat und ich nur noch aus den insgesammt vier Bytes alle 4er Bitblcke
  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 Bitblcke; 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 beleiben erhalten,
  .                 die oberen 4 Bits werden gelscht (auf null gesetzt)
  .
  b:=c and $F0;   ; $F0 = 11110000b ... die unteren 4 Bits werden gelscht,
  .                 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 gelscht
  .
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 dafr 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 durchfhren wir natrlich fr 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;  { Rckgabe-String }
        a,
        b,
        i      : Byte;    { Zhlvariabel }
  BEGIN
    Back:='';                        { Den Rckgabe-String erstmal initialisieren }
    i:=0;                            { Stellenzhler 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;                   { Rckgabewert}
  END;


BEGIN
  ASM mov ax,03h
      int 10h End;
  WriteLn('Ich zeig die Hexazahlen an:');
  WriteLn(Dec2Hex($11112368,8));
END.

//////////////////////////////////////////////////////////////////////////////

GrEEtInG$ tO

              cleaner /PsiMAX       |THANX for more information
              interference
              kryptocrew            |hmmmm




CRAY sagt: "das ich fr nichts hafte war doch schon klar oder ?"

cray@2600byte.de